home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / code / bcpp / file9 / cdmusic.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  46.6 KB  |  1,333 lines
  1. extern "C" {
  2. #include "cdmaster.h"
  3.          }
  4. #include "cdmusic.h"
  5. #include "cdmcrt.h"
  6.  
  7. #define OKAY 0
  8. #define FAIL 1
  9.  
  10. char *nodrives= "No CDROM drives attached.\n";
  11. char *nomscdex= "MSCDEX is not installed.\n";
  12.  
  13. char far*fldNames[ MAXFIELDS ];
  14. char far*fldTypes[ MAXFIELDS ];
  15.  
  16. REQUIREDFIELDARRAY TR_TrackRecord[] =
  17.   {
  18.     { 3, "Disc ID",          "N",    1 },
  19.     { 3, "Track ID",         "N",    2 },
  20.     { 1, "Title",            "A80",  3 },
  21.     { 1, "Min",              "S",    4 },
  22.     { 1, "Sec",              "S",    5 },
  23.     { 1, "Sec100",           "S",    6 }
  24.   };
  25.  
  26. REQUIREDFIELDARRAY SR_SearchRecord[] =
  27.   {
  28.     { 3, "Disc ID",          "N",    1 },
  29.     { 1, "Artist",           "A80",  2 },
  30.     { 1, "Title",            "A80",  3 },
  31.     { 1, "Tracks",           "S",    4 },
  32.     { 1, "Min",              "S",    5 },
  33.     { 1, "Sec",              "S",    6 },
  34.     { 1, "Entry Date",           "D",    7 }
  35.   };
  36.  
  37. REQUIREDFIELDARRAY DR_DiscRecord[] =
  38.   {
  39.     { 3, "Disc ID",          "N",    1 },
  40.     { 1, "Artist",           "A80",  2 },
  41.     { 1, "Title",            "A80",  3 },
  42.     { 1, "Tracks",           "S",    4 },
  43.     { 1, "Min",              "S",    5 },
  44.     { 1, "Sec",              "S",    6 },
  45.     { 1, "Entry Date",           "D",    7 }
  46.   };
  47.  
  48. REQUIREDFIELDARRAY PD_DiscRecord[] =
  49.   {
  50.     { 3, "Artist",           "A80",  1 },
  51.     { 3, "Title",            "A80",  2 },
  52.     { 3, "Disc ID",          "N",    3 },
  53.     { 1, "Tracks",           "S",    4 },
  54.     { 1, "Min",              "S",    5 },
  55.     { 1, "Sec",              "S",    6 },
  56.     { 1, "Entry Date",           "D",    7 }
  57.   };
  58.  
  59. TRACKFIELDARRAY TR_TrackArray[ 99 ];
  60.  
  61. extern char MouseChar;
  62. extern ColorSet EsColors,
  63.                cdColors;
  64. RawWindow glWindow;
  65. char glString[ 80 ];
  66. TABLEHANDLE glDiscTable;
  67. RECORDHANDLE glSearchRecord;
  68.  
  69.  
  70. /*--------------------------------------------------------------------------*/
  71. int Error( int lcRC )
  72.   {
  73.     if ( lcRC != PXSUCCESS )
  74.       {
  75.       CharStr( ' ', 78, glString );
  76.         glWindow.wFastText( glString, 20, 2 );
  77.       sprintf( glString, "CDMUSIC: %s", PXErrMsg( lcRC ) );
  78.       glWindow.wFastText( glString, 20, 2 );
  79.       }
  80.  
  81.     return lcRC;
  82.   }
  83.  
  84. //--------------------------------------------------------------------------
  85. int GetData( REQUIREDFIELDARRAY *lcFieldArray, RECORDHANDLE lcRecordHandle, int lcField )
  86.   {
  87.     long theDate;
  88.     int month, day, year;
  89.     double theValue;
  90.     short theShort;
  91.     int isBlank;
  92.     FIELDHANDLE lcFieldHandle;
  93.  
  94.     lcFieldHandle = lcFieldArray[ lcField ].fldHandle;
  95.  
  96.     /* if this field is blank, we want to return a blank string */
  97.     if ( !Error( PXFldBlank( lcRecordHandle, lcFieldHandle, &isBlank ) ) )
  98.       {
  99.         if ( isBlank )
  100.         {
  101.             lcFieldArray[ lcField ].fldBuffer[0] = '\0';
  102.             return PXSUCCESS;
  103.         }
  104.       }
  105.     else
  106.         return FAIL;
  107.  
  108.     //printf( " Get %d", lcFieldArray[ lcField ].fldHandle );
  109.     switch( lcFieldArray[ lcField ].fldType[0] )
  110.       {
  111.         case 'a':
  112.         case 'A':
  113.             if ( Error( PXGetAlpha( lcRecordHandle, lcFieldHandle, BUFSIZ, lcFieldArray[ lcField ].fldBuffer ) ) )
  114.             return FAIL;
  115.             break;
  116.         case 'd':
  117.         case 'D':
  118.           if ( !Error( PXGetDate( lcRecordHandle, lcFieldHandle, &theDate ) ) )
  119.             {
  120.                 PXDateDecode( theDate, &month, &day, &year );
  121.                 sprintf( lcFieldArray[ lcField ].fldBuffer, "%d/%d/%d", month, day, year );
  122.             }
  123.             else
  124.                 return FAIL;
  125.           break;
  126.         case 'n':
  127.         case 'N':
  128.             if ( !Error( PXGetDoub( lcRecordHandle, lcFieldHandle, &theValue ) ) )
  129.                 sprintf( lcFieldArray[ lcField ].fldBuffer, "%5.0lf", theValue );
  130.             else
  131.                 return FAIL;
  132.             break;
  133.         case '$':
  134.             if ( !Error( PXGetDoub( lcRecordHandle, lcFieldHandle, &theValue ) ) )
  135.                 sprintf( lcFieldArray[ lcField ].fldBuffer, "%4.2lf", theValue );
  136.             else
  137.                 return FAIL;
  138.             break;
  139.         case 's':
  140.         case 'S':
  141.             if ( !Error( PXGetShort( lcRecordHandle, lcFieldHandle, &theShort ) ) )
  142.                 sprintf( lcFieldArray[ lcField ].fldBuffer, "%d", theShort );
  143.             else
  144.                 return FAIL;
  145.             break;
  146.       }
  147.     return( PXSUCCESS );
  148.   }
  149.  
  150. /*--------------------------------------------------------------------------*/
  151. int PutData( REQUIREDFIELDARRAY *lcFieldArray,
  152.              RECORDHANDLE lcRecordHandle,
  153.            int lcField )
  154.   {
  155.     long theDate;
  156.     int month, day, year;
  157.     double theValue;
  158.     short theShort;
  159.  
  160.     /* If the field is blank, put a blank into the record buffer. */
  161.     if ( strlen( lcFieldArray[ lcField ].fldBuffer ) == 0 )
  162.       {
  163.       if ( Error( PXPutBlank( lcRecordHandle, lcFieldArray[ lcField ].fldHandle ) ) != PXSUCCESS )
  164.           {
  165.           return FAIL;
  166.           }
  167.       else
  168.         {
  169.           return PXSUCCESS;
  170.          }
  171.       }
  172.  
  173.     //printf( " Put %d", lcFieldArray[ lcField ].fldHandle );
  174.     switch( lcFieldArray[ lcField ].fldType[0] )
  175.     {
  176.         case 'a':
  177.         case 'A':
  178.           if ( Error( PXPutAlpha( lcRecordHandle, lcFieldArray[ lcField ].fldHandle, lcFieldArray[ lcField ].fldBuffer ) ) )
  179.                 return FAIL;
  180.             break;
  181.  
  182.         case 'D':
  183.         case 'd':
  184.             sscanf( lcFieldArray[ lcField ].fldBuffer, "%d/%d/%d", &month, &day, &year );
  185.             if ( ( Error( PXDateEncode( month, day, year, &theDate ) ) ) ||
  186.                  ( Error( PXPutDate( lcRecordHandle, lcFieldArray[ lcField ].fldHandle, theDate ) ) ) )
  187.                 return FAIL;
  188.           break;
  189.  
  190.         case '$':
  191.         case 'N':
  192.         case 'n':
  193.             sscanf( lcFieldArray[ lcField ].fldBuffer, "%lf", &theValue );
  194.             if ( Error( PXPutDoub( lcRecordHandle, lcFieldArray[ lcField ].fldHandle, theValue ) ) )
  195.             return FAIL;
  196.             break;
  197.         case 'S':
  198.         case 's':
  199.             sscanf( lcFieldArray[ lcField ].fldBuffer, "%d", &theShort );
  200.             if ( Error( PXPutShort( lcRecordHandle, lcFieldArray[ lcField ].fldHandle, theShort ) ) )
  201.                 return FAIL;
  202.             break;
  203.     }
  204.  
  205.     return PXSUCCESS;
  206.   }
  207.  
  208. /*--------------------------------------------------------------------------*/
  209. word track_scrn( )
  210. {
  211.   word Status;
  212.   ScrollingEntryScreen ES;
  213.  
  214.   OPEntryInit();
  215.  
  216.   #if defined(UseMouse)
  217.   if (MouseInstalled) {
  218.       //activate mouse cursor
  219.       SoftMouseCursor(0x0000, (ColorMono(EsColors.MouseColor, EsColors.MouseMono) << 8)+
  220.                        MouseChar);
  221.       ShowMouse();
  222.       //enable mouse support
  223.       EntryCommands.cpOptionsOn(cpEnableMouse);
  224.     };
  225.   #endif
  226.  
  227.   //initialize entry screen
  228.   Status = cd_trackscrn( ES, EsColors );
  229.  
  230.   ES.Process();
  231.   ES.Erase();
  232.   #if defined(UseMouse)
  233.   HideMouse();
  234.   #endif
  235.   ES.Done();
  236.   return Status;
  237. };
  238.  
  239. /*--------------------------------------------------------------------------*/
  240. void PickTitle( word lcItem, pkMode lcMode,
  241.                 pkItemType &lcType, char *lcIString,
  242.                 PickListPtr PickPtr )
  243.   {
  244.     int lcRC,
  245.         lcDone = 0,
  246.         lcCount = 0;
  247.  
  248.     lcRC = Error( PXSrchFld( glDiscTable, glSearchRecord, SR_SearchRecord[ SR_Artist ].fldHandle, SEARCHFIRST ) );
  249.     do
  250.       {
  251.         lcCount++;
  252.         if ( ( lcItem == lcCount ) &&
  253.              ( lcRC == PXSUCCESS ) )
  254.           {
  255.             if ( lcRC == PXSUCCESS )
  256.               lcRC = Error( PXRecGet( glDiscTable, glSearchRecord ) );
  257.             if ( lcRC == PXSUCCESS )
  258.               lcRC = Error( PXGetAlpha( glSearchRecord, SR_SearchRecord[ SR_Title ].fldHandle, BUFSIZ, SR_SearchRecord[ SR_Title ].fldBuffer ) );
  259.             strcpy( lcIString, SR_SearchRecord[ SR_Title ].fldBuffer );
  260.             lcDone = 1;
  261.           }
  262.          if ( ( lcRC == PXSUCCESS ) &&
  263.               ( !lcDone ) )
  264.            lcRC = PXSrchFld( glDiscTable, glSearchRecord, SR_SearchRecord[ SR_Artist ].fldHandle, SEARCHNEXT );
  265.       }
  266.     while ( ( lcRC == PXSUCCESS ) &&
  267.             ( !lcDone ) );
  268.   }
  269.  
  270. /*--------------------------------------------------------------------------*/
  271. word disc_search( TABLEHANDLE lcDiscTable, RECORDHANDLE lcDiscRecord,
  272.                   RECORDHANDLE lcSearchRecord )
  273.   {
  274.     PickList lcPick;
  275.     int lcRC,
  276.         lcCount;
  277.     long lcLong;
  278.     word lcCmd = ccQuit;
  279.  
  280.  
  281.     strcpy( SR_SearchRecord[ SR_Artist ].fldBuffer, DR_DiscRecord[ DR_Artist ].fldBuffer );
  282.     lcRC = Error( PXPutAlpha( lcSearchRecord, SR_SearchRecord[ SR_Artist ].fldHandle, SR_SearchRecord[ SR_Artist ].fldBuffer ) );
  283.     if ( lcRC == PXSUCCESS )
  284.       lcRC = PXSrchFld( lcDiscTable, lcSearchRecord, SR_SearchRecord[ SR_Artist ].fldHandle, SEARCHFIRST );
  285.     if ( lcRC == PXSUCCESS )
  286.       {
  287.         lcCount = 0;
  288.         do
  289.           {
  290.             lcRC = PXSrchFld( lcDiscTable, lcSearchRecord, SR_SearchRecord[ SR_Artist ].fldHandle, SEARCHNEXT );
  291.             lcCount++;
  292.           }
  293.         while ( lcRC == PXSUCCESS );
  294.         glDiscTable = lcDiscTable;
  295.         glSearchRecord = lcSearchRecord;
  296.  
  297.         OPPickInit();
  298.         lcRC = lcPick.InitCustom ( 35, 10, 70, 20,
  299.                             EsColors,
  300.                             DefWindowOptions | wBordered,
  301.                             35,
  302.                             lcCount,
  303.                             PickTitle,
  304.                             PickVertical,
  305.                             SingleChoice );
  306.         lcPick.SetSearchMode(PickCharSearch);
  307.         lcPick.wFrame.AddShadow( shBR, shOverWrite);
  308.         lcPick.wFrame.AddHeader( SR_SearchRecord[ SR_Artist ].fldBuffer, heTL );
  309.         lcPick.Process();
  310.         lcPick.Erase();
  311.         //get selection
  312.         lcCmd = lcPick.GetLastCommand( );
  313.         if ( lcCmd == ccSelect )
  314.           {
  315.             lcCount = 0;
  316.             lcRC = PXSUCCESS;
  317.             while ( ( lcCount <= SR_LASTFIELD ) &&
  318.                     ( lcRC == PXSUCCESS ) )
  319.               {
  320.                 lcRC = GetData( SR_SearchRecord, lcSearchRecord, lcCount );
  321.                 lcCount++;
  322.               }
  323.           }
  324.         lcPick.Done();
  325.       }
  326.     else
  327.       {
  328.         glWindow.wFastText( "CDMUSIC: Artist Search Failed", 20, 2 );
  329.       }
  330.     return lcCmd;
  331.   }
  332.  
  333. /*--------------------------------------------------------------------------*/
  334. int cd_scrn( TABLEHANDLE lcDiscTable, RECORDHANDLE lcDiscRecord, int lcSearch )
  335. {
  336.   word lcField,
  337.        lcTrackEdit = 0,
  338.        lcRC,
  339.        Status;
  340.   EntryScreen ES;
  341.   PXCODE pxErr;
  342.   RECORDHANDLE lcSearchRecord;
  343.  
  344.   OPEntryInit();
  345.   lcSearch = 0;
  346.  
  347.   #if defined(UseMouse)
  348.   if (MouseInstalled) {
  349.       //activate mouse cursor
  350.       SoftMouseCursor(0x0000, (ColorMono(EsColors.MouseColor, EsColors.MouseMono) << 8)+
  351.                        MouseChar);
  352.       ShowMouse();
  353.       //enable mouse support
  354.       EntryCommands.cpOptionsOn(cpEnableMouse);
  355.     };
  356.   #endif
  357.  
  358.   //initialize entry screen
  359.   Status = cd_discscrn(ES, EsColors );
  360.   if (Status != 0) {
  361.     printf("Error initializing entry screen: %u\r\n", Status);
  362.     exit( 0 );
  363.     return Status;
  364.   };
  365.  
  366.   EntryCommands.AddCommand( ccUser1,  1, 0x3B00, 0 ); //F1   SEARCH
  367.   EntryCommands.AddCommand( ccUser2,  1, 0x3C00, 0 ); //F2   TRACK
  368.   EntryCommands.AddCommand( ccUser3,  1, 0x3D00, 0 ); //F3   EXIT
  369.   EntryCommands.AddCommand( ccUser10, 1, 0x4400, 0 ); //F10
  370.   EntryCommands.AddCommand( ccUser9,  1, 0x4300, 0 ); //F9   PRINT
  371.   EntryCommands.AddCommand( ccUser8,  1, 0x4200, 0 ); //F8   CLEANUP
  372.  
  373.   do
  374.     {
  375.       ES.Process();
  376.       Status = ES.GetLastCommand();
  377.       switch( Status )
  378.         {
  379.           case ccUser1 : {
  380.                            if ( strlen( DR_DiscRecord[ DR_Artist ].fldBuffer ) > 1 )
  381.                              {
  382.                                pxErr = Error( PXRecBufOpen( lcDiscTable, &lcSearchRecord ) );
  383.                                Status = disc_search( lcDiscTable, lcDiscRecord, lcSearchRecord );
  384.                                if ( Status == ccSelect )
  385.                                  {
  386.                                    lcSearch = 1;
  387.                                    Status = ccUser1;
  388.                                  }
  389.                                else
  390.                                  {
  391.                                    Status = ccUser2;
  392.                                  }
  393.  
  394.  
  395.                                pxErr = Error( PXRecBufClose( lcSearchRecord ) );
  396.                              }
  397.                            break;
  398.                          }
  399.           case ccUser2 : {
  400.                            lcRC = track_scrn( );
  401.                            break;
  402.                          }
  403.         }
  404.       }
  405.     while ( Status == ccUser2 );
  406.     ES.Erase();
  407.     #if defined(UseMouse)
  408.       HideMouse();
  409.     #endif
  410.     ES.Done();
  411.     return Status;
  412.   }
  413.  
  414. //----------------------------------------------------------------------------
  415. int addcdrecord( TABLEHANDLE lcDiscTable,   TABLEHANDLE lcTrackTable,
  416.                  RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord,
  417.                  long lcDiskID, int lcTracks, int lcdrive )
  418.   {
  419.     int    lcRC = PXSUCCESS,
  420.            lcField,
  421.            lctrack,
  422.            lcstatus,
  423.            lcmin,
  424.            lcsec,
  425.            lc10;
  426.     long   lctframes,
  427.            lcdframes;
  428.     struct date lcDate;
  429.  
  430.  
  431.     getdate( &lcDate );
  432.     sprintf( DR_DiscRecord[ DR_Tracks ].fldBuffer, "%d", lcTracks );
  433.     lctrack = 1;
  434.     lcdframes = 0;
  435.     do
  436.       {
  437.         sprintf( TR_TrackRecord[ TR_DiscID ].fldBuffer, "%ld", lcDiskID );
  438.         sprintf( TR_TrackRecord[ TR_TrackID ].fldBuffer, "%d", lctrack );
  439.         lctframes = gettrackframes( lcdrive, lctrack );
  440.         lcdframes += lctframes;
  441.         lcmin = ( ( lctframes / 75 ) / 60 );
  442.         lcsec = ( ( lctframes - ( ( lcmin * 60 ) * 75 ) ) / 75 );
  443.         lc10  = ( ( lctframes - ( ( ( lcmin * 60 ) * 75 ) +
  444.                   ( lcsec * 75 )      ) ) * ( 100 / 75 ) );
  445.         sprintf( TR_TrackRecord[ TR_Min ].fldBuffer, "%d", lcmin );
  446.         sprintf( TR_TrackRecord[ TR_Sec ].fldBuffer, "%d", lcsec );
  447.         sprintf( TR_TrackRecord[ TR_Sec100 ].fldBuffer, "%d", lc10 );
  448.         lcField = 0;
  449.  
  450.         while ( ( lcField <= TR_LASTFIELD ) &&
  451.                 ( lcRC == PXSUCCESS ) )
  452.           {
  453.             lcRC = PutData( TR_TrackRecord, lcTrackRecord, lcField );
  454.             lcField++;
  455.           }
  456.  
  457.         TR_TrackArray[ lctrack ].discid = lcDiskID;
  458.         TR_TrackArray[ lctrack ].trackid = lctrack;
  459.         TR_TrackArray[ lctrack ].min = lcmin;
  460.         TR_TrackArray[ lctrack ].sec = lcsec;
  461.         TR_TrackArray[ lctrack ].sec100 = lc10;
  462.         if ( lcRC == PXSUCCESS )
  463.           lcRC = Error( PXRecAppend( lcTrackTable, lcTrackRecord ) );
  464.         if ( lcRC == PXSUCCESS )
  465.           lcRC = Error( PXSave( ) );
  466.       }
  467.     while ( ( ++lctrack <= lcTracks ) &&
  468.             ( lcRC == PXSUCCESS ) );
  469.  
  470.     if ( lcRC == PXSUCCESS )
  471.       {
  472.         lcmin = ( ( lcdframes / 75 ) / 60 );
  473.         lctframes = long ( lcdframes  / 75 );
  474.         lctframes = lctframes - ( lcmin * 60 );
  475.         lcsec = lctframes;
  476.         lc10  = ( ( lcdframes - ( ( ( lcmin * 60 ) * 75 ) +
  477.                   ( lcsec * 75 )      ) ) * ( 100 / 75 ) );
  478.         sprintf( DR_DiscRecord[ DR_Tracks ].fldBuffer, "%d", lcTracks );
  479.         sprintf( DR_DiscRecord[ DR_Min ].fldBuffer, "%d", lcmin );
  480.         sprintf( DR_DiscRecord[ DR_Sec ].fldBuffer, "%d", lcsec );
  481.         sprintf( DR_DiscRecord[ DR_Entry ].fldBuffer, "%d/%d/%d", lcDate.da_mon, lcDate.da_day, lcDate.da_year );
  482.         lcField = 0;
  483.         while ( ( lcField <= DR_LASTFIELD ) &&
  484.                 ( lcRC == PXSUCCESS ) )
  485.           {
  486.             lcRC = PutData( DR_DiscRecord, lcDiscRecord, lcField );
  487.             lcField++;
  488.           }
  489.         if ( lcRC == PXSUCCESS )
  490.           lcRC = Error( PXRecAppend( lcDiscTable, lcDiscRecord ) );
  491.         if ( lcRC == PXSUCCESS )
  492.           lcRC = Error( PXSave( ) );
  493.       }
  494.     return PXSUCCESS;
  495.   }
  496.  
  497. /*--------------------------------------------------------------------------*/
  498. int HPLaserJetCursor( FILE *lcLaserJetHandle, int lcHoriz, int lcVert )
  499.   {
  500.     char LJVert[] = {27, 42, 112};
  501.  
  502.     fwrite( LJVert, 1, sizeof( LJVert ), lcLaserJetHandle );
  503.     fprintf( lcLaserJetHandle, "%dY", lcVert );
  504.     fwrite( LJVert, 1, sizeof( LJVert ), lcLaserJetHandle );
  505.     fprintf( lcLaserJetHandle, "%dX", lcHoriz );
  506.     return PXSUCCESS;
  507.   }
  508.  
  509. /*--------------------------------------------------------------------------*/
  510. int CrossTableCopy( REQUIREDFIELDARRAY *lcFromArray, TABLEHANDLE lcFromTable, RECORDHANDLE lcFromRecord, int lcFromStop,
  511.                 REQUIREDFIELDARRAY *lcToArray, TABLEHANDLE lcToTable, RECORDHANDLE lcToRecord, int lcToStop )
  512.   {
  513.     int iteration,
  514.         iteration2,
  515.       lcRC;
  516.     RECORDNUMBER lcRecordNumber;
  517.     FIELDHANDLE lcField;
  518.  
  519.     CharStr( ' ', 40, glString);
  520.     glWindow.wFastText( glString, 5, 20 );
  521.     glWindow.wFastText( "Cross Copy", 5, 20 );
  522.     glWindow.wFastText( glString, 6, 2 );
  523.     glWindow.wFastText( "Record #->", 6, 2 );
  524.     for ( iteration = 0; iteration < lcToStop; ++iteration )
  525.       {
  526.       if ( lcToArray[ iteration ].required > 0 )
  527.         {
  528.            iteration2 = 0;
  529.            while ( iteration2 < lcFromStop )
  530.              {
  531.              if ( ( stricmp( lcFromArray[ iteration2 ].fldName, lcToArray[ iteration ].fldName ) == 0 ) &&
  532.                   ( strncmpi( lcFromArray[ iteration2 ].fldType, lcToArray[ iteration ].fldType, 1 ) == 0 ) )
  533.                    {
  534.                  lcToArray[ iteration ].crossNdx = iteration2;
  535.                }
  536.              iteration2++;
  537.                }
  538.           }
  539.       }
  540.  
  541.     lcRC = Error( PXRecFirst( lcFromTable ) );
  542.     lcRecordNumber = 1;
  543.     while ( lcRC == PXSUCCESS )
  544.       {
  545.       if ( lcRC == PXSUCCESS )
  546.         lcRC = Error( PXRecGet( lcFromTable, lcFromRecord ) );
  547.       for ( iteration = 0; iteration < lcToStop; ++iteration )
  548.         {
  549.           if ( lcToArray[ iteration ].required > 0 )
  550.               {
  551.              lcRC = GetData( lcFromArray, lcFromRecord, lcToArray[ iteration ].crossNdx );
  552.              strcpy( lcToArray[ iteration ].fldBuffer, lcFromArray[ lcToArray[ iteration ].crossNdx ].fldBuffer );
  553.              lcRC = PutData( lcToArray, lcToRecord, iteration );
  554.             }
  555.           else
  556.             {
  557.               strcpy( lcToArray[ iteration ].fldBuffer, "" );
  558.               lcRC = PutData( lcToArray, lcToRecord, iteration );
  559.             }
  560.           }
  561.       if ( lcRC == PXSUCCESS )
  562.           lcRC = Error( PXRecAppend( lcToTable, lcToRecord ) );
  563.       if ( lcRC == PXSUCCESS )
  564.         lcRC = Error( PXRecNum( lcFromTable, &lcRecordNumber ) );
  565.       sprintf( glString, "%d", lcRecordNumber );
  566.         glWindow.wFastText( glString, 6, 20 );
  567.       if ( lcRC == PXSUCCESS )
  568.           lcRC = Error( PXRecNext( lcFromTable ) );
  569.       }
  570.  
  571.     if ( lcRC == PXERR_ENDOFTABLE )
  572.       lcRC = PXSUCCESS;
  573.     return lcRC;
  574.   }
  575.  
  576. /*--------------------------------------------------------------------------*/
  577. int CheckTableStructure( TABLEHANDLE lcTableHandle, REQUIREDFIELDARRAY *lcFieldArray, int lcFields )
  578.   {
  579.     int rc,
  580.         iteration,
  581.       lcFieldCount,
  582.         iteration2;
  583.  
  584.     rc = PXSUCCESS;
  585.     lcFieldCount = 0;
  586.     rc = Error( PXRecNFlds( lcTableHandle, &lcFieldCount ) );
  587.     for ( iteration = 1; iteration <= lcFields; ++iteration )
  588.       {
  589.       iteration2 = 0;
  590.       while ( stricmp( lcFieldArray[iteration-1].fldName, fldNames[iteration2] ) != 0 &&
  591.             iteration2 <= lcFieldCount-1 )
  592.         iteration2++;
  593.       if ( stricmp( lcFieldArray[iteration-1].fldName, fldNames[iteration2]) == 0 )
  594.         {
  595.           if ( strncmp( lcFieldArray[iteration-1].fldType, fldTypes[iteration2], strlen( lcFieldArray[iteration-1].fldType ) ) == 0 )
  596.             {
  597.             lcFieldArray[iteration-1].fldHandle = iteration2 + 1;
  598.             lcFieldArray[iteration-1].fldBuffer = (char *) malloc( BUFSIZ );
  599.             rc = PXSUCCESS;
  600.             }
  601.           else
  602.             {
  603.             sprintf( glString, "ERROR: Type mismatch (%s vs. %s) for Field #%d (%s)\n", fldTypes[iteration2],
  604.                                                             lcFieldArray[iteration - 1].fldType,
  605.                                                             iteration,
  606.                                                             lcFieldArray[iteration-1].fldName);
  607.             glWindow.wFastText( glString, 24, 2 );
  608.             iteration = lcFields;
  609.             rc = PXERR_OUTOFRANGE;
  610.             }
  611.         }
  612.       else
  613.         {
  614.           sprintf( glString, "ERROR: %d %s MISSING\n", iteration, lcFieldArray[iteration-1].fldName);
  615.           glWindow.wFastText( glString, 24, 2 );
  616.           iteration = lcFields;
  617.           rc = PXERR_OUTOFRANGE;
  618.         }
  619.       }
  620.  
  621.     return rc;
  622.   }
  623.  
  624. /*--------------------------------------------------------------------------*/
  625. int GetTableStructure( TABLEHANDLE lcTableHandle )
  626.   {
  627.     int rc;
  628.     FIELDHANDLE lcFieldHandle;
  629.     char fldName[ BUFSIZ ];
  630.     char fldType[ BUFSIZ ];
  631.     int lcFieldCount;
  632.  
  633.     lcFieldCount = 0;
  634.     rc = Error( PXRecNFlds(lcTableHandle, &lcFieldCount ) );
  635.     if ( rc == PXSUCCESS )
  636.       for ( lcFieldHandle = 1; lcFieldHandle <= lcFieldCount; ++lcFieldHandle )
  637.         {
  638.           rc = Error( PXFldName( lcTableHandle, lcFieldHandle, BUFSIZ, fldName ) );
  639.           if ( rc == PXSUCCESS )
  640.             rc = Error( PXFldType( lcTableHandle, lcFieldHandle, BUFSIZ, fldType ) );
  641.           if ( rc == PXSUCCESS )
  642.             {
  643.               /* printf( "%d\t", fldHandle ); */
  644.               fldNames[ lcFieldHandle-1 ] = strdup( fldName );
  645.               /* printf( "%s\t", fldNames[ fldHandle-1 ] ); */
  646.               fldTypes[ lcFieldHandle-1 ] = strdup( fldType );
  647.               /* printf( "%s\n", fldTypes[ fldHandle-1 ] ); */
  648.             }
  649.           else
  650.             lcFieldHandle = lcFieldCount + 1;
  651.       }
  652.  
  653.     return rc;
  654.   }
  655.  
  656. /*--------------------------------------------------------------------------*/
  657. int DeleteTableStructure( TABLEHANDLE lcTableHandle )
  658.   {
  659.     int rc;
  660.     FIELDHANDLE lcFieldHandle;
  661.     char fldName[ BUFSIZ ];
  662.     char fldType[ BUFSIZ ];
  663.     int lcFieldCount;
  664.  
  665.     lcFieldCount = 0;
  666.     rc = Error( PXRecNFlds(lcTableHandle, &lcFieldCount ) );
  667.     if ( rc == PXSUCCESS )
  668.       for ( lcFieldHandle = lcFieldCount; lcFieldHandle >= 1; --lcFieldHandle )
  669.         {
  670.         free( (void *)fldTypes[ lcFieldHandle - 1 ] );
  671.         free( (void *)fldNames[ lcFieldHandle - 1 ] );
  672.         }
  673.  
  674.     return rc;
  675.   }
  676.  
  677. /*--------------------------------------------------------------------------*/
  678. int MakeTable( TABLEHANDLE *lcTableHandle, REQUIREDFIELDARRAY *lcFieldArray,
  679.              char *lcTableName, RECORDHANDLE *lcRecordHandle, int lcFields )
  680.   {
  681.     FIELDHANDLE lcKeyHandles[ ] = { 1, 2, 3 };
  682.     int  iteration,
  683.        lcKeyFields,
  684.          lcRC;
  685.     char far*lcfldNames[ MAXFIELDS ];
  686.     char far*lcfldTypes[ MAXFIELDS ];
  687.  
  688.     CharStr( ' ', 40, glString);
  689.     glWindow.wFastText( glString, 5, 20 );
  690.     sprintf( glString, "Making %s", lcTableName );
  691.     glWindow.wFastText( glString, 5, 20 );
  692.     lcKeyFields = 0;
  693.     for ( iteration = 1; iteration <= lcFields; ++iteration )
  694.       {
  695.       if ( lcFieldArray[ iteration - 1 ].required == 3 )
  696.         {
  697.           lcKeyFields++;
  698.         }
  699.       lcfldNames[ iteration - 1 ] = strdup( lcFieldArray[ iteration - 1 ].fldName );
  700.       lcfldTypes[ iteration - 1 ] = strdup( lcFieldArray[ iteration - 1 ].fldType );
  701.       }
  702.  
  703.     lcRC = Error( PXTblCreate( lcTableName, lcFields, lcfldNames, lcfldTypes ) );
  704.     if ( lcRC == PXSUCCESS )
  705.       lcRC = Error( PXKeyAdd( lcTableName, lcKeyFields, lcKeyHandles, PRIMARY ) );
  706.     if ( lcRC == PXSUCCESS )
  707.       lcRC = Error( PXTblOpen( lcTableName, lcTableHandle, 0, 0 ) );
  708.     if ( lcRC == PXSUCCESS )
  709.       lcRC = Error( PXRecBufOpen( *lcTableHandle, lcRecordHandle ) );
  710.  
  711.     for ( iteration = 1; iteration <= lcFields; ++iteration )
  712.       {
  713.       free( (void *)lcfldNames[ iteration - 1 ] );
  714.       free( (void *)lcfldTypes[ iteration - 1 ] );
  715.       lcFieldArray[ iteration - 1 ].fldBuffer = (char *) malloc( BUFSIZ );
  716.       }
  717.  
  718.     return lcRC;
  719.   }
  720.  
  721. //----------------------------------------------------------------------------
  722. int cd_getdisc( TABLEHANDLE lcDiscTable,   TABLEHANDLE lcTrackTable,
  723.                 RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord )
  724.   {
  725.     int lcRC,
  726.         lcTrack,
  727.         lcField;
  728.  
  729.     lcRC = Error( PXRecGet( lcDiscTable, lcDiscRecord ) );
  730.     lcField = 0;
  731.     while ( ( lcField <= DR_LASTFIELD ) &&
  732.             ( lcRC == PXSUCCESS ) )
  733.       {
  734.         lcRC = GetData( DR_DiscRecord, lcDiscRecord, lcField );
  735.         lcField++;
  736.       }
  737.  
  738.     strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, DR_DiscRecord[ DR_DiscID ].fldBuffer );
  739.     lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  740.     lcRC = PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHFIRST );
  741.     lcTrack = 1;
  742.     while ( ( lcRC == PXSUCCESS ) &&
  743.             ( TR_TrackArray[ lcTrack ].title != NULL ) )
  744.       {
  745.         lcRC = Error( PXRecGet( lcTrackTable, lcTrackRecord ) );
  746.         lcField = 0;
  747.         while ( ( lcField <= TR_LASTFIELD ) &&
  748.                 ( lcRC == PXSUCCESS ) )
  749.           {
  750.             lcRC = GetData( TR_TrackRecord, lcTrackRecord, lcField );
  751.             lcField++;
  752.           }
  753.         sscanf( TR_TrackRecord[ TR_DiscID ].fldBuffer, "%ld", &TR_TrackArray[ lcTrack ].discid );
  754.         sscanf( TR_TrackRecord[ TR_TrackID ].fldBuffer, "%d", &TR_TrackArray[ lcTrack ].trackid );
  755.         sscanf( TR_TrackRecord[ TR_Min ].fldBuffer, "%d", &TR_TrackArray[ lcTrack ].min );
  756.         sscanf( TR_TrackRecord[ TR_Sec ].fldBuffer, "%d", &TR_TrackArray[ lcTrack ].sec );
  757.         sscanf( TR_TrackRecord[ TR_Sec100 ].fldBuffer, "%d", &TR_TrackArray[ lcTrack ].sec100 );
  758.         strcpy( TR_TrackArray[ lcTrack ].title, TR_TrackRecord[ TR_Title ].fldBuffer );
  759.         lcTrack++;
  760.         lcRC =  PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHNEXT );
  761.       }
  762.  
  763.     return lcRC;
  764.   }
  765.  
  766. //----------------------------------------------------------------------------
  767. int cd_update( TABLEHANDLE lcDiscTable,   TABLEHANDLE lcTrackTable,
  768.                RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord )
  769.   {
  770.     int lcRC,
  771.         lcTrack,
  772.         lcField;
  773.  
  774.     lcField = 0;
  775.     lcRC = Error( PXSrchKey( lcDiscTable, lcDiscRecord, 1, SEARCHFIRST ) );
  776.     if ( lcRC == PXSUCCESS )
  777.       lcRC = Error( PXRecGet( lcDiscTable, lcDiscRecord ) );
  778.     while ( ( lcField <= DR_LASTFIELD ) &&
  779.             ( lcRC == PXSUCCESS ) )
  780.       {
  781.         lcRC = PutData( DR_DiscRecord, lcDiscRecord, lcField );
  782.         lcField++;
  783.       }
  784.     if ( lcRC == PXSUCCESS )
  785.       {
  786.         lcRC = Error( PXRecUpdate( lcDiscTable, lcDiscRecord ) );
  787.       }
  788.     if ( lcRC == PXSUCCESS )
  789.       {
  790.         lcRC = Error( PXSave( ) );
  791.       }
  792.  
  793.     strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, DR_DiscRecord[ DR_DiscID ].fldBuffer );
  794.     lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  795.     lcRC = Error( PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHFIRST ) );
  796.     lcTrack = 1;
  797.     while ( ( lcRC == PXSUCCESS ) &&
  798.             ( TR_TrackArray[ lcTrack ].title != NULL ) )
  799.       {
  800.         if ( lcRC == PXSUCCESS )
  801.           lcRC = Error( PXRecGet( lcTrackTable, lcTrackRecord ) );
  802.         sprintf( TR_TrackRecord[ TR_Min ].fldBuffer, "%d", TR_TrackArray[ lcTrack ].min );
  803.         sprintf( TR_TrackRecord[ TR_Sec ].fldBuffer, "%d", TR_TrackArray[ lcTrack ].sec );
  804.         sprintf( TR_TrackRecord[ TR_Sec100 ].fldBuffer, "%d", TR_TrackArray[ lcTrack ].sec100 );
  805.         strcpy( TR_TrackRecord[ TR_Title ].fldBuffer, TR_TrackArray[ lcTrack ].title );
  806.         lcField = TR_Title;
  807.         while ( ( lcField <= TR_LASTFIELD ) &&
  808.                 ( lcRC == PXSUCCESS ) )
  809.           {
  810.             lcRC = PutData( TR_TrackRecord, lcTrackRecord, lcField );
  811.             lcField++;
  812.           }
  813.         lcTrack++;
  814.         lcRC = Error( PXRecUpdate( lcTrackTable, lcTrackRecord ) );
  815.         lcRC = Error( PXSave( ) );
  816.         lcRC = PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHNEXT );
  817.       }
  818.  
  819.     return lcRC;
  820.   }
  821.  
  822. //----------------------------------------------------------------------------
  823. int cd_print( TABLEHANDLE lcDiscTable,   TABLEHANDLE lcTrackTable,
  824.               RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord )
  825.   {
  826.     int lcRC,
  827.         lcFound,
  828.         lcField,
  829.         lcHoriz = 50,
  830.         lcVert = 50;
  831.     FILE *lcLaserJetHandle;
  832.     TABLEHANDLE lcPrintTable;
  833.     RECORDHANDLE lcPrintRecord;
  834.     char formfeed[] = {12};
  835.  
  836.     lcRC = Error( PXTblExist( "PRINT", &lcFound ) );
  837.     if ( lcRC == PXSUCCESS )
  838.       {
  839.         if ( lcFound )
  840.           {
  841.             lcRC = Error( PXTblOpen( "PRINT", &lcPrintTable, 0, 0 ) );
  842.             if ( lcRC == PXSUCCESS )
  843.               lcRC = Error( PXRecBufOpen( lcPrintTable, &lcPrintRecord ) );
  844.           }
  845.         else
  846.           {
  847.             lcRC = MakeTable( &lcPrintTable, PD_DiscRecord, "PRINT", &lcPrintRecord, PD_LASTFIELD + 1 );
  848.           }
  849.       }
  850.     if ( lcRC == PXSUCCESS )
  851.       {
  852.         if ( lcRC == PXSUCCESS )
  853.           lcRC = GetTableStructure( lcPrintTable );
  854.         if ( lcRC == PXSUCCESS )
  855.           lcRC = CheckTableStructure( lcPrintTable, PD_DiscRecord, PD_LASTFIELD + 1 );
  856.         if ( lcRC == PXSUCCESS )
  857.           lcRC = DeleteTableStructure( lcPrintTable );
  858.       }
  859.  
  860.     if ( lcRC == PXSUCCESS )
  861.       lcRC = CrossTableCopy( DR_DiscRecord, lcDiscTable,  lcDiscRecord,  DR_LASTFIELD + 1,
  862.                              PD_DiscRecord, lcPrintTable, lcPrintRecord, PD_LASTFIELD + 1 );
  863.  
  864.     lcLaserJetHandle = fopen( "PRN","wb" );
  865.     lcRC = Error( PXRecFirst( lcPrintTable ) );
  866.     do
  867.       {
  868.         lcRC = Error( PXRecGet( lcPrintTable, lcPrintRecord ) );
  869.         lcField = 0;
  870.         while ( ( lcField <= PD_LASTFIELD ) &&
  871.                 ( lcRC == PXSUCCESS ) )
  872.           {
  873.         lcRC = GetData( PD_DiscRecord, lcPrintRecord, lcField );
  874.         lcField++;
  875.           }
  876.         lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz, lcVert );
  877.         fprintf( lcLaserJetHandle, "%s", PD_DiscRecord[ PD_DiscID ].fldBuffer );
  878.         lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz + 300, lcVert );
  879.         fprintf( lcLaserJetHandle, "%s", PD_DiscRecord[ PD_Artist ].fldBuffer );
  880.         lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz + 900, lcVert );
  881.         fprintf( lcLaserJetHandle, "%s", PD_DiscRecord[ PD_Title ].fldBuffer );
  882.         if ( lcVert >= 3000 )
  883.           {
  884.             lcVert = 50;
  885.             fwrite( formfeed, 1, sizeof( formfeed ), lcLaserJetHandle );
  886.           }
  887.         else
  888.           {
  889.             lcVert += 25;
  890.           }
  891.  
  892.         strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, PD_DiscRecord[ PD_DiscID ].fldBuffer );
  893.         lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  894.         lcRC = Error( PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHFIRST ) );
  895.         if ( lcRC == PXSUCCESS )
  896.           do
  897.             {
  898.               lcRC = Error( PXRecGet( lcTrackTable, lcTrackRecord ) );
  899.               lcField = 0;
  900.               while ( ( lcField <= TR_LASTFIELD ) &&
  901.                       ( lcRC == PXSUCCESS ) )
  902.                 {
  903.                   lcRC = GetData( TR_TrackRecord, lcTrackRecord, lcField );
  904.                   lcField++;
  905.                 }
  906.               lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz + 25, lcVert );
  907.               fprintf( lcLaserJetHandle, "|" );
  908.               lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz + 75, lcVert );
  909.               fprintf( lcLaserJetHandle, "%s", TR_TrackRecord[ TR_TrackID ].fldBuffer );
  910.               lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz + 150, lcVert );
  911.               fprintf( lcLaserJetHandle, "%s", TR_TrackRecord[ TR_Title ].fldBuffer );
  912.               lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz + 900, lcVert );
  913.               fprintf( lcLaserJetHandle, "%s", TR_TrackRecord[ TR_Min ].fldBuffer );
  914.               lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz + 950, lcVert );
  915.               fprintf( lcLaserJetHandle, "%s", TR_TrackRecord[ TR_Sec ].fldBuffer );
  916.               lcRC = HPLaserJetCursor( lcLaserJetHandle, lcHoriz + 1000, lcVert );
  917.               fprintf( lcLaserJetHandle, "%s", TR_TrackRecord[ TR_Sec100 ].fldBuffer );
  918.               if ( lcVert >= 3000 )
  919.                 {
  920.                   lcVert = 50;
  921.                   fwrite( formfeed, 1, sizeof( formfeed ), lcLaserJetHandle );
  922.                 }
  923.               else
  924.                 {
  925.                   lcVert += 25;
  926.                 }
  927.  
  928.               lcRC = PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHNEXT );
  929.             }
  930.           while( lcRC != PXERR_RECNOTFOUND );
  931.         lcRC = PXRecNext( lcPrintTable );
  932.       }
  933.     while ( lcRC != PXERR_ENDOFTABLE );
  934.     fclose( lcLaserJetHandle );
  935.  
  936.     lcRC = Error( PXRecBufClose( lcPrintRecord ) );
  937.     if ( lcRC == PXSUCCESS )
  938.     lcRC = Error( PXTblClose( lcPrintTable ) );
  939.     if ( lcRC == PXSUCCESS )
  940.       lcRC = Error( PXTblDelete( "PRINT" ) );
  941.  
  942.     return PXSUCCESS;
  943.   }
  944.  
  945. //----------------------------------------------------------------------------
  946. int cd_newid( TABLEHANDLE lcDiscTable, TABLEHANDLE lcTrackTable,
  947.               RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord )
  948.   {
  949.     int lctrack,
  950.         lcendtrack,
  951.         lcRC;
  952.  
  953.     strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, SR_SearchRecord[ SR_DiscID ].fldBuffer );
  954.     lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  955.     lcRC = PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHFIRST );
  956.     if ( lcRC == PXSUCCESS )
  957.       {
  958.         lctrack = 1;
  959.         while ( TR_TrackArray[ lctrack ].title != NULL )
  960.           {
  961.             lcRC = Error( PXRecGet( lcTrackTable, lcTrackRecord ) );
  962.             lcRC = GetData( TR_TrackRecord, lcTrackRecord, TR_Title );
  963.             strcpy( TR_TrackArray[ lctrack ].title, TR_TrackRecord[ TR_Title ].fldBuffer );
  964.             strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, DR_DiscRecord[ DR_DiscID ].fldBuffer );
  965.             lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID);
  966.             lcRC = Error( PXRecUpdate( lcTrackTable, lcTrackRecord ) );
  967.             lcRC = Error( PXSave( ) );
  968.  
  969.             strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, SR_SearchRecord[ SR_DiscID ].fldBuffer );
  970.             lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  971.             lcRC = PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHFIRST );
  972.             lctrack++;
  973.           }
  974.       }
  975.  
  976.     strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, DR_DiscRecord[ DR_DiscID ].fldBuffer );
  977.     strcpy( DR_DiscRecord[ DR_DiscID ].fldBuffer, SR_SearchRecord[ SR_DiscID ].fldBuffer );
  978.     strcpy( DR_DiscRecord[ DR_Title ].fldBuffer, SR_SearchRecord[ SR_Title ].fldBuffer );
  979.     lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_DiscID );
  980.     lcRC = PXSrchKey( lcDiscTable, lcDiscRecord, 1, SEARCHFIRST );
  981.     if ( lcRC == PXSUCCESS )
  982.       {
  983.         lcRC = Error( PXRecGet( lcDiscTable, lcDiscRecord ) );
  984.  
  985.         strcpy( DR_DiscRecord[ DR_DiscID ].fldBuffer, TR_TrackRecord[ TR_DiscID ].fldBuffer );
  986.         lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_DiscID);
  987.         lcRC = Error( PXRecUpdate( lcDiscTable, lcDiscRecord ) );
  988.         lcRC = Error( PXSave( ) );
  989.       }
  990.     return PXSUCCESS;
  991.  
  992.   }
  993. //----------------------------------------------------------------------------
  994. int cd_deleteid( TABLEHANDLE lcDiscTable, TABLEHANDLE lcTrackTable,
  995.                  RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord )
  996.   {
  997.     int lcRC;
  998.  
  999.     strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, DR_DiscRecord[ DR_DiscID ].fldBuffer );
  1000.     lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  1001.     lcRC = PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHFIRST );
  1002.     while ( lcRC == PXSUCCESS )
  1003.       {
  1004.         lcRC = PXRecDelete( lcTrackTable );
  1005.         lcRC = PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHFIRST );
  1006.       }
  1007.  
  1008.     lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_DiscID );
  1009.     lcRC = PXSrchKey( lcDiscTable, lcDiscRecord, 1, SEARCHFIRST );
  1010.     if ( lcRC == PXSUCCESS )
  1011.       {
  1012.         lcRC = PXRecDelete( lcDiscTable );
  1013.       }
  1014.     return PXSUCCESS;
  1015.   }
  1016.  
  1017. //----------------------------------------------------------------------------
  1018. int cd_cleantable( TABLEHANDLE lcDiscTable, TABLEHANDLE lcTrackTable,
  1019.                    RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord )
  1020.   {
  1021.     int lcRC;
  1022.  
  1023.     lcRC = Error( PXRecFirst( lcDiscTable ) );
  1024.     do
  1025.       {
  1026.         lcRC = Error( PXRecGet( lcDiscTable, lcDiscRecord ) );
  1027.         lcRC = GetData( DR_DiscRecord, lcDiscRecord, DR_DiscID );
  1028.         strcpy( TR_TrackRecord[ TR_DiscID ].fldBuffer, DR_DiscRecord[ DR_DiscID ].fldBuffer );
  1029.         lcRC = PutData( TR_TrackRecord, lcTrackRecord, TR_DiscID );
  1030.         lcRC = PXSrchKey( lcTrackTable, lcTrackRecord, 1, SEARCHFIRST );
  1031.         if ( lcRC == PXERR_RECNOTFOUND )
  1032.           {
  1033.             lcRC = PXRecDelete( lcDiscTable);
  1034.           }
  1035.         else
  1036.           {
  1037.             lcRC = PXRecNext( lcDiscTable );
  1038.           }
  1039.       }
  1040.     while ( lcRC == PXSUCCESS );
  1041.  
  1042.     return lcRC;
  1043.   }
  1044.  
  1045. //----------------------------------------------------------------------------
  1046. int process_loop( TABLEHANDLE lcDiscTable, TABLEHANDLE lcTrackTable,
  1047.                   RECORDHANDLE lcDiscRecord, RECORDHANDLE lcTrackRecord )
  1048.   {
  1049.     int lcRC,
  1050.         lcFound,
  1051.         lcField,
  1052.         lcSearch,
  1053.         bgntrack,
  1054.         endtrack,
  1055.         numcdroms = 0,
  1056.         ourdrive = 0,
  1057.         firstdrive = 0,
  1058.         quitcd = 0,
  1059.         status = 0,
  1060.         lcAutoAdd = 1;
  1061.     long sframe,
  1062.          f,
  1063.          dframes,
  1064.          lc10,
  1065.          lcsec,
  1066.          lcmin,
  1067.          track;
  1068.     word lcCmd;
  1069.     char lcLine[ 80 ];
  1070.     struct trackinfo ti;
  1071.     struct cdtable *cdt;
  1072.     struct date lcDate;
  1073.  
  1074.     if ( ( !ismscdex( ) ) ||
  1075.          ( !( numcdroms = getnumcdroms( ) ) ) ||
  1076.          ( !( firstdrive = getfirstcdrom( ) ) ) )
  1077.       {
  1078.         if ( !ismscdex( ) )
  1079.           {
  1080.             sprintf( glString, "CDMUSIC: %s", nomscdex );
  1081.             glWindow.wFastText( glString, 20, 2 );
  1082.           }
  1083.         else
  1084.           {
  1085.             sprintf( glString, "CDMUSIC: %s", nodrives );
  1086.             glWindow.wFastText( glString, 20, 2 );
  1087.           }
  1088.       }
  1089.  
  1090.     do
  1091.       {
  1092.         lcRC = PXSUCCESS;
  1093.         ourdrive = firstdrive;
  1094.         do
  1095.           {
  1096.             status = cdstatus( ourdrive );
  1097.           }
  1098.         while ( !( status & CDISHERE) );
  1099.  
  1100.         cdt = buildaudiotoc( ourdrive );
  1101.             //initialize Disc Record
  1102.             lcField = 0;
  1103.             while ( lcField <= DR_LASTFIELD )
  1104.             {
  1105.               strcpy( DR_DiscRecord[ lcField ].fldBuffer, "" );
  1106.               lcField++;
  1107.             }
  1108.  
  1109.             //initialize Track Record
  1110.             lcField = 0;
  1111.             while ( lcField <= TR_LASTFIELD )
  1112.             {
  1113.               strcpy( TR_TrackRecord[ lcField ].fldBuffer, "" );
  1114.               lcField++;
  1115.             }
  1116.  
  1117.             //initialize Search Record
  1118.             lcField = 0;
  1119.             while ( lcField <= SR_LASTFIELD )
  1120.               {
  1121.                 strcpy( SR_SearchRecord[ lcField ].fldBuffer, "" );
  1122.                 lcField++;
  1123.               }
  1124.  
  1125.             for ( lcField = 1; lcField <= 99; lcField++ )
  1126.               {
  1127.                 if ( lcField <= cdt->di.ltrk )
  1128.                   {
  1129.                     TR_TrackArray[ lcField ].title = ( char * ) malloc( 80 );
  1130.                     if ( TR_TrackArray[ lcField ].title != NULL )
  1131.                       {
  1132.                         strcpy( TR_TrackArray[ lcField ].title, "" );
  1133.                       }
  1134.                   }
  1135.                 else
  1136.                   {
  1137.                     TR_TrackArray[ lcField ].title = NULL;
  1138.                   }
  1139.               }
  1140.             sprintf( DR_DiscRecord[ DR_DiscID ].fldBuffer, "%ld", cdt->di.eodisc );
  1141.             lcRC = PutData( DR_DiscRecord, lcDiscRecord, DR_DiscID );
  1142.             if ( lcRC == PXSUCCESS )
  1143.               lcRC = PXSrchKey( lcDiscTable, lcDiscRecord, 1, SEARCHFIRST );
  1144.             if ( lcRC == PXSUCCESS )
  1145.               {
  1146.                 lcFound = 1;
  1147.                 lcRC = cd_getdisc( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1148.               }
  1149.             else
  1150.               {
  1151.                 lcFound = 0;
  1152.                 if ( lcAutoAdd )
  1153.                   {
  1154.                     lcRC = addcdrecord( lcDiscTable, lcTrackTable,
  1155.                                         lcDiscRecord, lcTrackRecord,
  1156.                                         cdt->di.eodisc, cdt->di.ltrk, ourdrive );
  1157.                   }
  1158.               }
  1159.  
  1160.             lcCmd = cd_scrn( lcDiscTable, lcDiscRecord, lcSearch );
  1161.             switch ( lcCmd )
  1162.               {
  1163.                 case ccQuit  : {
  1164.                                  if ( ( !lcFound ) &&
  1165.                                       ( lcAutoAdd ) )
  1166.                                    {
  1167.                                      cd_update( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1168.                                    }
  1169.                                  else
  1170.                                    {
  1171.                                      cd_update( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1172.                                    }
  1173.                                  break;
  1174.                                }
  1175.                 case ccUser0 : {
  1176.                                  break;
  1177.                                }
  1178.                 case ccUser1 : {
  1179.                                  if ( lcSearch )
  1180.                                    {
  1181.                                      lcRC = cd_deleteid( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1182.                                      lcRC = cd_newid( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1183.                                      lcRC = cd_update( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1184.                                    }
  1185.                                  break;
  1186.                                }
  1187.                 case ccUser2 : {
  1188.                                  //handled in cd_scrn()
  1189.                                  break;
  1190.                                }
  1191.                 case ccUser3 : {
  1192.                                  quitcd = 1;
  1193.                                  break;
  1194.                                }
  1195.                 case ccUser8 : {
  1196.                                  lcRC = cd_cleantable( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1197.                                  break;
  1198.                                }
  1199.                 case ccUser9 : { //Print Report
  1200.                                  lcRC = cd_print( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1201.                                  break;
  1202.                                }
  1203.                 case ccUser10: {
  1204.                                  break;
  1205.                                }
  1206.               }
  1207.  
  1208.             for ( lcField = cdt->di.ltrk; lcField >= 1; lcField-- )
  1209.               {
  1210.                 free( ( void * ) TR_TrackArray[ lcField ].title );
  1211.               }
  1212.  
  1213.             lcRC = Error( PXRecBufEmpty( lcDiscRecord ) );
  1214.             lcRC = Error( PXRecBufEmpty( lcTrackRecord ) );
  1215.  
  1216.           destroyaudiotoc(ourdrive);
  1217.           cdeject( ourdrive );
  1218.       }
  1219.     while( !quitcd );
  1220.  
  1221.     return(OKAY);
  1222.   }
  1223.  
  1224. /*--------------------------------------------------------------------------*/
  1225.   int process_main( void )
  1226.     {
  1227.       int exist,
  1228.           lcRC;
  1229.       RECORDHANDLE lcDiscRecord,
  1230.                    lcTrackRecord;
  1231.       TABLEHANDLE  lcDiscTable,
  1232.                lcTrackTable;
  1233.  
  1234.       OPRawWindowInit();
  1235.  
  1236.       glWindow.InitCustom( 2, 2, 79, 23, cdColors, wBordered + wClear );
  1237.       glWindow.wFrame.AddHeader( "CDMUSIC Status Window", heTC );
  1238.       glWindow.Draw();
  1239.  
  1240.       lcRC = Error( PXTblExist( "DISC", &exist ) );
  1241.       if ( lcRC == PXSUCCESS )
  1242.       {
  1243.         if ( exist )
  1244.           {
  1245.             lcRC = Error( PXTblOpen( "DISC", &lcDiscTable, 0, 0 ) );
  1246.             if ( lcRC == PXSUCCESS )
  1247.             lcRC = Error( PXRecBufOpen( lcDiscTable, &lcDiscRecord ) );
  1248.           }
  1249.         else
  1250.           {
  1251.             lcRC = MakeTable( &lcDiscTable, DR_DiscRecord, "DISC", &lcDiscRecord, DR_LASTFIELD + 1 );
  1252.           }
  1253.       }
  1254.       if ( lcRC == PXSUCCESS )
  1255.       {
  1256.         if ( lcRC == PXSUCCESS )
  1257.           lcRC = GetTableStructure( lcDiscTable );
  1258.         if ( lcRC == PXSUCCESS )
  1259.           lcRC = CheckTableStructure( lcDiscTable, DR_DiscRecord, DR_LASTFIELD + 1 );
  1260.         if ( lcRC == PXSUCCESS )
  1261.           lcRC = CheckTableStructure( lcDiscTable, SR_SearchRecord, SR_LASTFIELD + 1 );
  1262.         if ( lcRC == PXSUCCESS )
  1263.           lcRC = DeleteTableStructure( lcDiscTable );
  1264.       }
  1265.  
  1266.       if ( lcRC == PXSUCCESS )
  1267.       lcRC = Error( PXTblExist( "TRACK", &exist ) );
  1268.       if ( lcRC == PXSUCCESS )
  1269.       {
  1270.         if ( exist )
  1271.           {
  1272.             lcRC = Error( PXTblOpen( "TRACK", &lcTrackTable, 0, 0 ) );
  1273.             if ( lcRC == PXSUCCESS )
  1274.             lcRC = Error( PXRecBufOpen( lcTrackTable, &lcTrackRecord ) );
  1275.           }
  1276.         else
  1277.           {
  1278.             lcRC = MakeTable( &lcTrackTable, TR_TrackRecord, "TRACK", &lcTrackRecord, TR_LASTFIELD + 1 );
  1279.           }
  1280.       }
  1281.       if ( lcRC == PXSUCCESS )
  1282.       {
  1283.         if ( lcRC == PXSUCCESS )
  1284.           lcRC = GetTableStructure( lcTrackTable );
  1285.         if ( lcRC == PXSUCCESS )
  1286.           lcRC = CheckTableStructure( lcTrackTable, TR_TrackRecord, TR_LASTFIELD + 1 );
  1287.         if ( lcRC == PXSUCCESS )
  1288.           lcRC = DeleteTableStructure( lcTrackTable );
  1289.       }
  1290.  
  1291.  
  1292.       if ( lcRC == PXSUCCESS )
  1293.         lcRC = process_loop( lcDiscTable, lcTrackTable, lcDiscRecord, lcTrackRecord );
  1294.  
  1295.       lcRC = PXSUCCESS;
  1296.       if ( lcRC == PXSUCCESS )
  1297.         lcRC = Error( PXRecBufClose( lcTrackRecord ) );
  1298.       if ( lcRC == PXSUCCESS )
  1299.         lcRC = Error( PXRecBufClose( lcDiscRecord ) );
  1300.       if ( lcRC == PXSUCCESS )
  1301.         lcRC = Error( PXTblClose( lcTrackTable ) );
  1302.       if ( lcRC == PXSUCCESS )
  1303.         lcRC = Error( PXTblClose( lcDiscTable ) );
  1304.  
  1305.       glWindow.wFrame.AddHeader( "Finished - Press any key", heBC );
  1306.       glWindow.wFrame.UpdateFrame();
  1307.       ReadKeyWord();
  1308.       glWindow.Erase();
  1309.       glWindow.Done();
  1310.  
  1311.       return lcRC;
  1312.     }
  1313.  
  1314. /*--------------------------------------------------------------------------*/
  1315. main( void )
  1316.   {
  1317.     int rc;
  1318.  
  1319.     printf( "CDMUSIC.EXE: CD music library database input/scanner v1.0\n" );
  1320.     printf( "Uses Paradox v4.0 database format with CD-ROM drive\n" );
  1321.  
  1322.     rc = ( Error ( PXInit( ) ) );
  1323.     if (rc == PXSUCCESS)
  1324.       {
  1325.         return( process_main() );
  1326.       }
  1327.     else
  1328.       {
  1329.         printf( "CDMUSIC: %s\n", PXErrMsg( rc ) );
  1330.       }
  1331.     return PXSUCCESS;
  1332.   }
  1333.