WebSVN – svn1 – Diff – /Mara/branches/QtMain/report.cpp

 *       pri_final               - Print final results
 *       pri_interim             - Print interim results
 *       print_class_header      - Print a class header
 *       print_class_stats       - Generate the class stats
 *       print_legend            - Print the legend
-*       pi_place                - Return place data
-*       pr_place                - Return place data
+*       px_place                - Return place data with NE and V indication
 *       ck_data                 - Check data for bad times
 *       srt_place               - Update placing information
 *       do_big_sort             - Main sort routine for final data
 *       sort                    - Sort in memory buffer
 *       sort_comp               - qsort comparison function
 };
 int         sort_leg;
 int         sort_mode;
 bool        sort_withEquestrian;
+bool        sort_afterEquestrianLeg;
 report_type report_html = text;
 bool        report_all = FALSE;
 /* Parameters used by the sort routine to govern its actions */
     /*
      * Sort the data in finishing order
      */
-    if( ck_data( leg, C_END ) )
-        return;                                  /* Check data for this leg */
+    ck_data( leg, C_END );                      /* Check data for this leg */
     sort_team_data( leg, S_FIN, true );         /* Sort the data */
     /*
      * Now print the data on the printer
 void p_place( ty_s_data * ptr, int leg, unsigned k )
+{
     if( k < sort_num )
+    {
         print( "%4.4s %4d %8s  ",
-               pr_place( ptr->place, ptr->flags.bad_times ),
+               px_place(-1, ptr->place, false, false, ptr->flags ),
                ptr->team, time_fa( ptr->leg[leg], ptr->flags.disqualified ) );
+    }
     else
+    {
         print( "%20s", "" );
+    }
     if( found )
+    {
         print( "%4d %4.4s %8s  ",
                ptra->team,
-               pr_place( ptra->place, ptra->flags.bad_times ),
+               px_place( -1, ptra->place, false, false, ptra->flags ),
                time_fa( ptra->leg[leg], ptra->flags.disqualified ) );
+    }
     else
+    {
         print( "%20s", "" );
     /*
      * Sort the data in finishing order
      */
-    if( ck_data( leg, C_ELAPSED ) )
-        return;                                  /* Check data for this leg */
+    ck_data( leg, C_ELAPSED );                      /* Check data for this leg */
-    sort_team_data( leg, S_IFIN, true );               /* Sort the data on elapsed time */
+    sort_team_data( leg, S_IFIN, true );            /* Sort the data on elapsed time */
     /*
      * Now print the data on the printer
      */
 // *
 // *  Print place information
 // *
 // *  Purpose:
 // *      This helper function is called to Print place and elapsed information
-// *      in a 20-character field
+// *      in a 20-character field: Place:Team:ElapsedTime
 // *
 // *  Parameters:
 // *      ptr         Address of the place data
 // *      leg         Leg to print
 // *      k           Current index into sorted array. Simply
 void pe_place( ty_s_data * ptr, int leg, unsigned k )
+{
     if( k < sort_num )
+    {
         print( "%4.4s %4d %8s  ",
-               pr_place( ptr->place, ptr->flags.bad_times ),
+               px_place( -1, ptr->place, false, false, ptr->flags ),
                ptr->team,
                time_fa( ptr->lege[leg], ptr->flags.disqualified ) );
+    }
     else
+    {
+    }
     if( found )
+    {
         print( "%4d %4.4s %8s  ",
                ptra->team,
-               pr_place( ptra->place, ptra->flags.bad_times ),
+               px_place( -1, ptra->place, false, false, ptra->flags ),
                time_fa( ptra->lege[leg], ptra->flags.disqualified ) );
+    }
     else
+    {
         print( "%20s", "" );
     /*
     **  Generate ALL results with HTML tags
     */
     report_html = html;
     pri_final();
+    pri_final_teamOrder();
     report_html = printed;
     pri_final();
+    pri_final_teamOrder();
     report_html = text;
+}
 /*========================================================================
     int         lcount;
     bool        isNeClass = false;
     int         place;
-    if( ck_data( -1, C_ELAPSED ) )
+    ck_data( -1, C_ELAPSED );
-        return;
     /*
     **  Sort on every thing
     **  Then generate all the stats too
     */
     do_big_sort();
         return;
     /*
      * Print out the data
      */
-    print_class_header( -1, TRUE );                      /* Print the header */
+    print_class_header( -1, TRUE );                     /* Print the header */
-    ptr = sort_data;
     sort_team_data( 0, S_L, true );                     /* Re-sort on elapsed time */
     lcount = 0;
     for( ptr = sort_data, i = 0; i < sort_num; i++, ptr++ )
+    {
         if ( ptr->teamclass == config.nonequestrian_class )
         **  Print the basics (Finishing order)
         **      - Place within complete field
         **      - Team number - with HTML reference to team file
         **      - Class
         */
-        if ( report_html == printed && lcount %5 == 4 ) print_underline( TRUE );
+        if ( report_html == printed && lcount % 5 == 4 ) print_underline( TRUE );
-        print( "%4.4s ", pn_place( team_buf.leg[0].l_place, ptr->flags.bad_times, ptr->flags.non_equestrian ) );
+        print( "%4.4s ", px_place( 0, team_buf.leg[0].l_place, false, true, ptr->flags ) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "name" ,"html")), team_buf.numb );
         print( "%4d",  team_buf.numb );
         if ( report_html == html ) print( "</A>" );
         print( " %-*s", 3, team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         **      - End place
         */
         for( j = 1; j <= config.num_legs; j++ )
+        {
             bool isEquestrianLeg = (j == config.equestrian_leg && team_buf.flags.non_equestrian);
-            bool afterEquestrianLeg = (team_buf.flags.non_equestrian && j > config.equestrian_leg);
             /*
             **  Ensure that non-equestrian leg data is not displayed
             */
             if ( isEquestrianLeg )
+            {
                 print( "  %-8s %4.4s %4.4s", "-- NE --", "NE","NE");
+            }
             else
+            {
-                print( "  %-8s %4.4s %4.4s",
-                    time_a( team_buf.leg[j].elapsed ),
+                print( "  %-8s", time_a( team_buf.leg[j].elapsed ));
-                    pr_place( team_buf.leg[j].l_place, ptr->flags.bad_times ),
+                if ( config.num_legs != 1 ) print( " %4.4s",      px_place( j, team_buf.leg[j].l_place, false, false, ptr->flags ));
-                    pn_place( team_buf.leg[j].le_place,ptr->flags.bad_times, afterEquestrianLeg )
+                if ( config.num_legs != 1 ) print( " %4.4s",   px_place( j, team_buf.leg[j].le_place,true , true, ptr->flags ));
-                  );
+                if ( config.num_legs == 1 ) print( " %-*s ",  MAX_TM_NAME, team_buf.name );
+            }
+        }
        /*
         **  Print the trailer (Finishing order)
         **      - Total time
         **      - Category place - with reference to category file
         */
-//        print( "  %-8s ",  time_a( team_buf.leg[0].elapsed ) );
-        print( "  %-8s ", time_a( ptr->lege[0] ) );
+        if ( config.num_legs != 1 ) print( "  %-8s ", time_a( ptr->lege[0] ) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">",url_encode(p_filename(filebase, config.team_class[team_buf.teamclass - 1].abr ,"html")), team_buf.numb );
-        print( "%-4.4s", pn_place( team_buf.leg[0].lc_place, ptr->flags.bad_times, ptr->flags.non_equestrian && 0 ) );
+        print( "%4.4s", px_place( 0, team_buf.leg[0].lc_place, false, false, ptr->flags) );
         if ( report_html == html ) print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
+    }
         **      - Team number - with HTML reference to team file
         **      - Class
         */
         if ( report_html == printed && lcount %5 == 4 ) print_underline( TRUE );
-        print( "%4.4s ", pn_place( team_buf.leg[0].lc_place, flags , eflags ) );
+        print( "%4.4s ", px_place( 0, team_buf.leg[0].lc_place, false, false, ptr->flags) );
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "name" ,"html")), team_buf.numb );
         print( "%4d",  team_buf.numb );
         if ( report_html == html ) print( "</A>" );
         print( " %-*s", 3, team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         for( j = 1; j <= config.num_legs; j++ )
+        {
             bool isEquestrianLeg = (j == config.equestrian_leg && (ptr->teamclass == config.nonequestrian_class || ptr->flags.non_equestrian));
-            bool afterEquestrianLeg = ((ptr->teamclass == config.nonequestrian_class || ptr->flags.non_equestrian) && j > config.equestrian_leg);
             /*
             **  Ensure that non-equestrian leg data is not displayed
             */
             if ( isEquestrianLeg )
+            {
                 print( "  %-8s %4.4s %4.4s", "-- NE --", "NE","NE");
+            }
             else
+            {
-                print( "  %-8s %4.4s %4.4s", time_a( team_buf.leg[j].elapsed ),
+                print( "  %-8s", time_a( team_buf.leg[j].elapsed ));
-                       pr_place( team_buf.leg[j].lc_place,  flags ),
+                if ( config.num_legs != 1 ) print( " %4.4s", px_place( j, team_buf.leg[j].lc_place,  false, false, ptr->flags ));
-                       pn_place( team_buf.leg[j].lec_place, flags, afterEquestrianLeg ) );
+                if ( config.num_legs != 1 ) print( " %4.4s", px_place( j, team_buf.leg[j].lec_place, true , true, ptr->flags ) );
+                if ( config.num_legs == 1 ) print( " %-*s ", MAX_TM_NAME, team_buf.name );
+            }
+        }
         /*
         **  Print the trailer
         **      - Total time
         **      - Overall place - with reference to overall place file
         */
-        /* print( "  %-8s ", time_a( team_buf.leg[0].elapsed ) ); */
-        print( "  %-8s ", time_a( ptr->lege[0] ) );
+        if ( config.num_legs != 1 ) print( "  %-8s ", time_a( ptr->lege[0] ) );
-        if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "finish" ,"html")), team_buf.numb );
+        if ( report_html == html )  print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "finish" ,"html")), team_buf.numb );
-        print( "%4.4s", pn_place( team_buf.leg[0].l_place, flags , ptr->flags.non_equestrian));
+        print( "%4.4s", px_place( 0, team_buf.leg[0].l_place, false, true, ptr->flags));
-        if ( report_html == html ) print( "</A>" );
+        if ( report_html == html )  print( "</A>" );
         if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
         lcount++;
         print( "\n" );
+    }
     pri_name_index_body();
+}
 /*========================================================================
+ *
+ *  Print final results in Team Order
+ *
+ *  Purpose:
+ *      This function is called to Print final results in Team Order
+ *
+ *  Parameters:
+ *      None
+ *
+ *  Returns:
+ *      Nothing
+ *
+ *========================================================================*/
+void pri_final_teamOrder(void)
+{
+    ty_s_data  *ptr;
+    team_type   team_buf;
+    unsigned    i;
+    int         j;
+    int         lcount;
+    ck_data( -1, C_ELAPSED );
+    /*
+    **  Sort on every thing
+    **  Then generate all the stats too
+    */
+    do_big_sort();
+    gen_stats();
+    /*
+     * Now print the data on the printer
+     */
+    if( !open_printer( "", "team_order", 132, report_html, "Team Order" ) )
+        return;
+    /*
+     * Print out the data
+     */
+    print_class_header( -1, TRUE );                      /* Print the header */
+    ptr = sort_data;
+    sort_team_data( 0, S_TEAM, true );                   /* Re-sort on team number */
+    lcount = 0;
+    for( ptr = sort_data, i = 0; i < sort_num; i++, ptr++ )
+    {
+        if ( ptr->teamclass == config.nonequestrian_class )
+            continue;
+        g_record( ptr->team, &team_buf );
+        /*
+        ** If this is a NE team then dummy up some of the data that hasn't been stored in team_buf
+        */
+        if (ptr->flags.non_equestrian)
+        {
+            team_buf.leg[0].l_place = sort_aux[ptr->team].leq_place[0];
+            team_buf.leg[0].lc_place = sort_aux[ptr->team].lq_place[0];;
+        }
+        /*
+        **  If printing an HTML report then we need to mark
+        **  the entry with a reference so that we can link to it
+        */
+        if ( report_html == html )
+        {
+            print( "<A NAME=\"Team_%04d\"></A>",team_buf.numb );
+        }
+        /*
+        **  Print the basics (Finishing order)
+        **      - Place within complete field
+        **      - Team number - with HTML reference to team file
+        **      - Class
+        */
+        if ( report_html == printed && lcount %5 == 4 ) print_underline( TRUE );
+        print( "%4.4s ", px_place( 0, team_buf.leg[0].l_place, false, true, ptr->flags ) );
+        if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "name" ,"html")), team_buf.numb );
+        print( "%4d",  team_buf.numb );
+        if ( report_html == html ) print( "</A>" );
+        print( " %-*s", 3, team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
+        /*
+        **  Print the per-leg data
+        **      - Time
+        **      - Leg place
+        **      - End place
+        */
+        for( j = 1; j <= config.num_legs; j++ )
+        {
+            bool isEquestrianLeg = (j == config.equestrian_leg && team_buf.flags.non_equestrian);
+            /*
+            **  Ensure that non-equestrian leg data is not displayed
+            */
+            if ( isEquestrianLeg )
+            {
+                print( "  %-8s %4.4s %4.4s", "-- NE --", "NE","NE");
+            }
+            else
+            {
+                print( "  %-8s",                     time_a( team_buf.leg[j].elapsed ));
+                if ( config.num_legs != 1 ) print( " %4.4s", px_place(j, team_buf.leg[j].l_place, false, false, ptr->flags ));
+                if ( config.num_legs != 1 ) print( " %4.4s", px_place(j, team_buf.leg[j].le_place,true,  true, ptr->flags ) );
+                if ( config.num_legs == 1 ) print( " %-*s ", MAX_TM_NAME, team_buf.name );
+            }
+        }
+       /*
+        **  Print the trailer (Finishing order)
+        **      - Total time
+        **      - Category place - with reference to category file
+        */
+       if ( config.num_legs != 1 ) print( "  %-8s ", time_a( ptr->lege[0] ) );
+        if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">",url_encode(p_filename(filebase, config.team_class[team_buf.teamclass - 1].abr ,"html")), team_buf.numb );
+        print( "%4.4s", px_place( 0, team_buf.leg[0].lc_place, false, false, ptr->flags ) );
+        if ( report_html == html ) print( "</A>" );
+        if ( report_html == printed && lcount %5 == 4 ) print_underline( FALSE );
+        lcount++;
+        print( "\n" );
+    }
+    print_class_stats( -1, TRUE );              /* Print statistics */
+    print_legend(-1, 1 );                       /* Print the legend */
+    close_printer();                            /* Close the printer */
+}
+/*========================================================================
+ *
  *  Place to text
+ *
  *  Purpose:
  *      This function is called to convert a place to text
+ *
     print( "    ");
     if ( report_html == html ) print( "<A HREF=\"#%s\">",url_encode("Hall Of Fame"));
     print( "%s",  "Hall Of Fame" );
     if ( report_html == html ) print( "</A>" );
+    if (config.awardsfilename[0])
+    {
+        print( "\n");
+        print( "    ");
+        if ( report_html == html ) print( "<A HREF=\"#%s\">",url_encode("Additional Awards"));
+        print( "%s",  "Additional Awards" );
+        if ( report_html == html ) print( "</A>" );
+    }
     print( "\n");
     print( "    ");
     if ( report_html == html ) print( "<A HREF=\"#%s\">",url_encode("FASTEST"));
     print( "%s",  "FASTEST" );
     if ( report_html == html ) print( "</A>" );
                 /*
                 **  Ensure we have a valid team
                 **  Can't award disqualified teams
                 **  Can't award NE teams unless its a NE award
                 */
-                if ( ptr->flags.bad_times )
+                if ( ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check || !ptr->flags.valid )
                     break;
                 if ( ptr->teamclass != config.nonequestrian_class  && ptr->flags.non_equestrian )
                     break;
                     /*
                     **  Ensure we have a valid team
                     **  Can't award disqualified teams
                     **  Can't award NE teams unless its a NE award
                     */
-                    if ( ptr->flags.bad_times )
+                    if ( ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check || !ptr->flags.valid )
                         break;
                     if ( ptr->teamclass != config.nonequestrian_class  && ptr->flags.non_equestrian )
                         break;
         qDebug( "There are no new stars for the Hall of Fame");
+    }
     if ( report_html == html ) print( "\n");
     if ( report_html == html ) print( "<A HREF=\"#%s\">Awards Index</A>",url_encode("INDEX"));
+    /*
+    **  Insert additional Awards information
+    */
+    if (config.awardsfilename[0])
+    {
+        print( "\n");
+        if ( report_html == html )
+        {
+            print( "<hr>" );
+            print( "<A name=\"%s\"></A>",url_encode("Additional Awards"));
+        }
+        else
+        {
+            print( "%s\n", solid_line);
+        }
+        print( "%s",  "Additional Awards" );
+        print ("\n");
+        /*
+        **  Read and process the named awards file
+        */
+        FILE       *adfile = NULL;
+        char        line[201];
+        QString name = QmConfig::getAddendemFile(config.awardsfilename);
+        if (! name.isEmpty())
+        {
+            adfile = fopen( qPrintable(name), "rt" );  /* Open the file for reading */
+        }
+        if( adfile )
+        {
+            while( fgets( line, sizeof(line)-1, adfile ) ) {
+                //  Process each line
+                //  Attempt to perform some smart text replacements
+                //  ie: <TeamNumber:63> <TeamName:63><TeamLegName:1:63>
+                print( "%s", line );
+            }
+            fclose(adfile);
+        }
+        else
+        {
+            if ( report_html == html )  print ("<br>");
+            print( "\nThe awards file could not be found: %s\n",  adfile);
+        }
+        if ( report_html == html ) print( "\n");
+        if ( report_html == html ) print( "<A HREF=\"#%s\">Awards Index</A>",url_encode("INDEX"));
+    }
     /*
     **  Generate the FASTEST information
     */
     print( "\n" );
     print( "\n");
     */
     print( "<TABLE border=0 align=center>" );
     pri_master_index_entry( "name", "Team list" );
     pri_master_index_entry( "competitor", "Competitor list" );
     pri_master_index_entry( "finish", "Finishing Order for all Teams" );
+    pri_master_index_entry( "team_order", "All Teams with results" );
     pri_master_index_entry( "awards", "Prizes and Awards" );
     print( "<tr><td>\n" );
     print( "\n" );
     for( j = 1; j <= config.num_class; j++ )
     print( "<TABLE border=0 align=center>" );
 #if 1
     pri_master_index_entry( "name", "Team list" );
     pri_master_index_entry( "competitor", "Competitor list" );
     pri_master_index_entry( "finish", "Finishing Order for all Teams" );
+    pri_master_index_entry( "team_order", "All Teams with results" );
     pri_master_index_entry( "awards", "Prizes and Awards" );
     print( "<tr><td>\n" );
     print( "\n" );
     pri_master_index_entry( "summary", "Category Summary" );
         g_record( ptr->team, &team_buf );
         print( "%4d %4.4s %-*s",
                team_buf.numb,
-               pi_place( team_buf.leg[config.num_legs].le_place,
+               px_place(-1, team_buf.leg[config.num_legs].le_place, false, false, ptr->flags ),
-                         ptr->flags.disqualified, team_buf.leg[0].elapsed ),
 ,
-               team_buf.teamclass ==
-? "" : config.team_class[team_buf.teamclass - 1].abr );
+               team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         for( j = 1; j <= config.num_legs; j++ )
+        {
-            print( "  %-8s %4.4s %4.4s",
-                   time_fa( team_buf.leg[j].elapsed,
-                            ptr->flags.disqualified ),
-                   pi_place( team_buf.leg[j].l_place, ptr->flags.disqualified,
+            print( "  %-8s", time_fa( team_buf.leg[j].elapsed, ptr->flags.disqualified ));
-                             team_buf.leg[j].elapsed ),
+            if ( config.num_legs != 1 ) print( " %4.4s", px_place(j, team_buf.leg[j].l_place, false, true, ptr->flags ));
-                   pi_place( team_buf.leg[j].le_place,
+            if ( config.num_legs != 1 ) print( " %4.4s", px_place(j, team_buf.leg[j].le_place, false, true, ptr->flags ));
-                             ptr->flags.disqualified,
-                             team_buf.leg[j].elapsed ) );
+            if ( config.num_legs == 1 ) print( " %-*s ",     MAX_TM_NAME, team_buf.name );
         }
-        print( "  %-8s %4.4s\n",
-               time_fa( team_buf.leg[0].elapsed, ptr->flags.disqualified ),
+        if ( config.num_legs != 1 ) print( "  %-8s", time_fa( team_buf.leg[0].elapsed, ptr->flags.disqualified ));
-               pi_place( team_buf.leg[config.num_legs].lec_place,
+        print( " %4.4s\n", px_place(0, team_buf.leg[config.num_legs].lec_place, false, false, ptr->flags ));
-                         ptr->flags.disqualified, team_buf.leg[0].elapsed ) );
+    }
     print_class_stats( -1, FALSE );             /* Print statistics */
     print_legend(-1, 1);                        /* Print the legend */
     close_printer();                            /* Close the printer */
         **  Now read in the team record
         */
         g_record( ptr->team, &team_buf );
         print( "%4d %4.4s %-*s",
                team_buf.numb,
-               pi_place( team_buf.leg[config.num_legs].lec_place,
+               px_place(-1, team_buf.leg[config.num_legs].lec_place, false, false, ptr->flags ),
-                         ptr->flags.disqualified, team_buf.leg[0].elapsed ),
 ,
-               team_buf.teamclass ==
-? "" : config.team_class[team_buf.teamclass - 1].abr );
+               team_buf.teamclass == 0 ? "" : config.team_class[team_buf.teamclass - 1].abr );
         for( j = 1; j <= config.num_legs; j++ )
+        {
-            print( "  %-8s %4.4s %4.4s",
-                   time_fa( team_buf.leg[j].elapsed,
+            print( "  %-8s", time_fa( team_buf.leg[j].elapsed, ptr->flags.disqualified ));
-                            ptr->flags.disqualified ),
-                   pi_place( team_buf.leg[j].lc_place,
+            if ( config.num_legs != 1 ) print( " %4.4s", px_place(j, team_buf.leg[j].lc_place,  false, true, ptr->flags ));
-                             ptr->flags.disqualified,
-                             team_buf.leg[j].elapsed ),
-                   pi_place( team_buf.leg[j].lec_place,
+            if ( config.num_legs != 1 ) print( " %4.4s", px_place(j, team_buf.leg[j].lec_place, false, true, ptr->flags ));
-                             ptr->flags.disqualified,
-                             team_buf.leg[j].elapsed ) );
+            if ( config.num_legs == 1 ) print( " %-*s ", MAX_TM_NAME, team_buf.name );
         }
-        print( "  %-8s %4.4s\n",
-               time_fa( team_buf.leg[0].elapsed, ptr->flags.disqualified ),
+        if ( config.num_legs != 1 ) print( "  %-8s", time_fa( team_buf.leg[0].elapsed, ptr->flags.disqualified ));
-               pi_place( team_buf.leg[config.num_legs].le_place,
+        print( " %4.4s\n", px_place(0, team_buf.leg[config.num_legs].le_place, false, false, ptr->flags ) );
-                         ptr->flags.disqualified, team_buf.leg[0].elapsed ) );
+    }
     print_class_stats( last_class, FALSE );
     print_legend(last_class, 1);
     close_printer();
     csv_print( "%s", "Flag:valid Team");
     csv_print( "%s", "Flag:bad_times" );
     csv_print( "%s", "Flag:disqualified" );
     csv_print( "%s", "Flag:non_equestrian" );
     csv_print( "%s", "Flag:vet_check" );
+    // Not available as the data is only in-memory
+    // csv_print( "%s", "Flag:notInFastest" );
+    // csv_print( "%s", "Flag:notInSort" );
     csv_print("\n");
     for( i = config.min_team; i <= config.max_team; i++ )
+    {
             csv_print( "%d", team_buf.flags.valid );
             csv_print( "%d", team_buf.flags.bad_times );
             csv_print( "%d", team_buf.flags.disqualified );
             csv_print( "%d", team_buf.flags.non_equestrian );
             csv_print( "%d", team_buf.flags.vet_check );
+            // Not available as the data is only in-memory
+            // csv_print( "%d", team_buf.flags.notInFastest );
+            // csv_print( "%d", team_buf.flags.notInSort );
 //How about class placings
             csv_print( "\n" );
         report_html = text;
+    }
     pri_final();
+    pri_final_teamOrder();
     pri_final_html();
     pri_csv_data();
     pri_summary_html();
     pri_summary();
     pri_awards_html();
     pri_awards();
     pri_master_index();
+    report_html = html;
+    pri_interim();
+    report_html = text;
     pri_interim();
     report_all = FALSE;
+}
     **  Now printout the column headings
     **  This is a two line display
     **
     **  Line-1  Leg names
     */
+    if (config.num_legs == 1 ) {
+        print( "%-*s", 4, "" );
+        print( "  %-*s", 18, config.leg_name[0] );
+        print( " %-*s", MAX_TM_NAME + 1, "" );
+        print( "%-4s\n", ( teamclass < 0 ) ? "Cat" : "Fin" );
+    } else {
-    print( "%-*s %-*s %-*s", 4, "", 4, "", 3, "" );
+        print( "%-*s %-*s %-*s", 4, "", 4, "", 3, "" );
-    for( j = 1; j <= config.num_legs; j++ )
+        for( j = 1; j <= config.num_legs; j++ )
-    {
+        {
-        print_bold( TRUE );
+            print_bold( TRUE );
-        print( "  %-*s", 18, config.leg_name[j - 1] );
+            print( "  %-*s", 18, config.leg_name[j - 1] );
-        print_bold( FALSE );
+            print_bold( FALSE );
+        }
+        print( "  %-8s %-4s\n", "Total", ( teamclass < 0 ) ? "Cat" : "Fin" );
+    }
-    print( "  %-8s %-4s\n", "Total", ( teamclass < 0 ) ? "Cat" : "Fin" );
     /*
     **  Line-2  Details
     */
     print_underline( TRUE );
     print( "%-*s %*s %-*s", 4, final ? "Plce" : "Team",
 , final ? "Team" : "Plce",
 , "Cat" );
-    for( j = 1; j <= config.num_legs; j++ )
-        print( "  %-8s %-4s %-4s", "Time", " LP", " EP" );
+    if (config.num_legs == 1 ) {
+        print( "  %-8s", "Time" );
+        print( " %-*s", MAX_TM_NAME + 1, "Team Name" );
+        print( "%-4s\n", "Plce" );
+    } else {
+        for( j = 1; j <= config.num_legs; j++ )
+            print( "  %-8s %-4s %-4s", "Time", " LP", " EP" );
-    print( "  %-8s %-4s\n", "Time", "Plce" );
+        print( "  %-8s %-4s\n", "Time", "Plce" );
+    }
     print_underline( FALSE );
+}
 /*========================================================================
+ *
+    {
         print_bold( TRUE );
         print( "%-13s  ", config.leg_name[i - 1] );
         print_bold( FALSE );
+    }
-    print( "%-13s  \n", final ? "Total" : "" );
+    if ( config.num_legs != 1 ) print( "%-13s  ", final ? "Total" : "" );
+    print( "\n" );
     /*
     **  Print the fastest teams for each leg and overall
     **  Add cross references to the team names for the fastest teams
     */
         if ( report_html == html ) print( "<A HREF=\"%s#Team_%04d\">", url_encode(p_filename(filebase, "name" ,"html")), stats.fast.team[j][c] );
         print( "%4d",  stats.fast.team[j][c] );
         if ( report_html == html ) print( "</A>" );
         print( " %s  ", time_a( stats.fast.time[j][c] ) );
+        if ( config.num_legs == 1 ) break;
+    }
     print( "\n" );
     /*
     **  Print the average time for each leg
                 j = 0;                           /* Leg-0 last */
             else
                 break;
+        }
         print( "     %s  ", time_a( stats.average[j][c] ) );
+        if ( config.num_legs == 1 ) break;
+    }
+}
 /*========================================================================
+ *
     for( i = 1, count = 0; i <= config.num_class; i++ )
+    {
         if (!config.team_class[i - 1].abr[0])
             continue;
-#if 0
-        /*
-        **  Skip any non-equestrian class in the legend
-        **  Don't want to tell the general user whats goes on, unless we actually
-        **  creating the non-equestrian report.
-        */
-        if ( class != config.nonequestrian_class  && i == config.nonequestrian_class )
-            continue;
-#endif
         if ( report_html == html ) print( "<A HREF=\"%s\">",url_encode(p_filename(filebase, config.team_class[i - 1].abr ,"html")) );
         print( "%-*s", 3, config.team_class[i - 1].abr );
         if ( report_html == html ) print( "</A>" );
         print( " : %-*s  ", LEN_CLASS_NAME, config.team_class[i - 1].full_name );
     /*
      * Other comments
      */
     if ( full )
+    {
+        if ( config.num_legs != 1 )  {
+            print( "\n" );
+            if ( report_html ) print_underline(TRUE);
-        print( "\nPlace numbers (LP and EP)\n" );
+            print( "Place numbers (LP and EP)" );
+            if ( report_html ) print_underline(FALSE);
+            print( "\n" );
-        print( "LP - Placing based on elapsed time within the leg.                Cat Plce - Placing within the category.\n" );
+            print( "LP - Placing based on elapsed time within the leg.                Cat Plce - Placing within the category.\n" );
-        print( "EP - Placing based on accumulated times to the end of that leg.   Fin Plce - Overall placing within the event.\n" );
+            print( "EP - Placing based on accumulated times to the end of that leg.   Fin Plce - Overall placing within the event.\n" );
-        print( "U  - Placing not available.\n" );
+            print( "U  - Placing not available.\n" );
+        } else {
+            print( "\n" );
+            if ( report_html ) print_underline(TRUE);
+            print( "Table Legend" );
+            if ( report_html ) print_underline(FALSE);
+            print( "\n" );
+            print( "Cat Plce - Placing within the category.\n");
+            print ("Fin Plce - Overall placing within the event.\n" );
+            print( "U        - Placing not available.\n" );
+        }
+    }
     /*
      *  Insert the contents of the config.addendum file
      *  or a defualt message
     if( adfile )
+    {
         while( fgets( line, sizeof(line)-1, adfile ) )
             print( "%s", line );
+        fclose (adfile);
+    }
     else
+    {
         print( "\nTiming and Results by\n" );
         print( "Embedded Solutions\n" );
+    }
+}
-/*========================================================================
- *
- *  Return place data
- *
- *  Purpose:
- *      This function is called to return place data
- *
- *      This routine is called to fill a print team_buffer - to allow for
- *      multiple calls to this function ( before the data is used ) a number
- *      of static team_buffers are maintained
- *
- *  Parameters:
- *      num         place - if not bad_times
- *      disq        Disqualified flag
- *      time        Time data is based on
- *
- *  Returns:
- *      This function returns a pointer to the character string for the
- *      number or a pointer to a bad_times string.
- *
- *========================================================================*/
-const char       *pi_place( int num, int disq, time_t time )
-{
-    static char store[2][5];                     /* 2 stores for 4 digit numbers */
-    static int  i = 0;                           /* Current index into store */
-    static const char *dis = "D";                      /* Disqualified */
-    static const char *non = "-";                      /* Invalid time */
-    if( disq )                                   /* Disqualified team */
-        return ( dis );
-    if( time <= 0 )                              /* Unknown time */
-        return ( non );
-    i++;
-    if( i >= 2 )
-        i = 0;                                   /* Select next entry */
-    sprintf( store[i], "%4d", num );
-    return ( store[i] );
-}
 /*========================================================================
+ *
- *  Return place data
+ *  Return place data or NE flag
+ *
  *  Purpose:
  *      This function is called to Return place data
+ *
  *      This routine is called to fill a print team_buffer - to allow for
  *      multiple calls to this function ( before the data is used ) a number
  *      of static team_buffers are maintained
+ *
  *  Parameters:
+ *      leg         Leg number being processed or
+ *                  -1: Unplaced on any bad flag
- *      num         place - if not bad_times
+ *      num         place - if valid time
+ *      epMode      true:  Event Time Mode - Show V and NE flags
+ *                  false: Leg Time Mode -
+ *      neMode      true: Display NE for NE Teams
+ *                  false: Display data for NE teams
- *      disq        Disqualified flag
+ *      flags       Team flags
+ *
  *  Returns:
  *      This function returns a pointer to the character string for the
- *      number or a pointer to a bad_times string.
+ *      number or a pointer to a status string.
+ *
  *========================================================================*/
-const char *pr_place( int num, int disq )
+const char *px_place( int leg, int num, bool epMode, bool neMode, team_flags flags )
+{
     static char store[2][5];                     /* 2 stores for 4 digit numbers */
     static int  i = 0;                           /* Current index into store */
     static const char *dis = "U";
+    static const char *alt = "NE";
+    static const char *vet = "U";
-    if( disq )
+    if (flags.bad_times || flags.disqualified || !flags.valid)
-        return ( dis );
+        return dis;
-    i++;
-    if( i >= 2 )
-        i = 0;                                   /* Select next entry */
-    sprintf( store[i], "%4d", num );
+    if (leg == -1 && flags.vet_check )
-    return ( store[i] );
+        return vet;
+    if (neMode && flags.non_equestrian && (leg >= config.equestrian_leg || leg == 0))
-}
+        return alt;
-/*========================================================================
- *
- *  Return place data or NE flag
- *
- *  Purpose:
- *      This function is called to Return place data
- *
- *      This routine is called to fill a print team_buffer - to allow for
- *      multiple calls to this function ( before the data is used ) a number
+    if (epMode && flags.vet_check && leg >= config.equestrian_leg)
- *      of static team_buffers are maintained
- *
- *  Parameters:
- *      num         place - if not bad_times
- *      disq        Disqualified flag
- *      flag        Flag NE data
- *
- *  Returns:
+        return vet;
- *      This function returns a pointer to the character string for the
- *      number or a pointer to a bad_times string.
- *
- *========================================================================*/
-const char *pn_place( int num, int disq, bool flag )
-{
-    static char store[2][5];                     /* 2 stores for 4 digit numbers */
-    static int  i = 0;                           /* Current index into store */
+    if ( flags.vet_check && (leg == config.equestrian_leg || leg == 0))
-    static const char *dis = "U";
+        return vet;
-    static const char *alt = "NE";
-    if( disq )
+    if (num <= 0)
-        return ( dis );
+        return dis;
-    if (flag)
-        return ( alt );
     i++;
     if( i >= 2 )
         i = 0;                                   /* Select next entry */
     sprintf( store[i], "%4d", num );
  *      and the report process can be aborted
+ *
  *  Parameters:
  *      leg             Leg to test
  *      mode            Either end or elapsed times to be tested
+ *                          C_END     - Printing in Leg Finishing Time
+ *                          C_DISQUAL - Interim results
+ *                          C_ELAPSED - Elapsed times
+ *
- *  Returns:
- *      Returns FALSE if the report operation is to be aborted
+ *
  *========================================================================*/
-bool ck_data( int leg, int mode )
+void ck_data( int leg, int mode )
+{
     ty_s_data  *ptr;
     unsigned    i;
     int         bad = 0;
     int         k;
             t = ptr->lege;
         else
             t = ptr->leg;
-        ptr->flags.bad_times = ptr->flags.disqualified;
+        // If the team is duff, then don;t include in Event or Leg Calcs
-        if( ! ptr->flags.bad_times )
+        if( !ptr->flags.valid || ptr->flags.bad_times || ptr->flags.disqualified)
+        {
+            ptr->flags.notInLP = TRUE;
+        }
+        else
+        {
+            // If any of the leg times are duff, then don't include the leg Event Calcs
             if( leg <= 0 )
+            {
                 for( k = 0; k <= config.num_legs; k++ )
+                {
                     if ( !(config.equestrian_leg && ptr->flags.non_equestrian && config.equestrian_leg == k  ))
                 bad_leg = t[leg] <= 0;
+            }
             if( bad_leg )
+            {
-                ptr->flags.bad_times = TRUE;
                 if ( ! report_all )
+                {
                     qDebug( "Team with incorrect time information: %d", ptr->team  );
                     bad++;
+                }
     if( bad )
+    {
         qDebug( "%d teams with incorrect times. These have been flagged as unplaced", bad );
+    }
-    return ( FALSE );
+}
 /*========================================================================
+ *
  *  Update placing information
+ *
  *========================================================================*/
 void srt_place(void)
+{
-    if( ck_data( -1, C_ELAPSED ) )
+    ck_data( -1, C_ELAPSED );
-        return;
     do_big_sort();
     /*
      * Generate the stats
      */
         sort_team_data( i, S_L, sortWithEq );
         for( j = 1, k = 1, q = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        {
             sort_aux[ptr->team].team = ptr->team;
+            if (i == config.equestrian_leg || i == 0) {
+                if (ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check) {
+                    if (ptr->isNeData) {
+                        sort_aux[ptr->team].lq_place[i] = -1;
+                    } else {
+                        sort_aux[ptr->team].l_place[i] = -1;
+                    }
+                    continue;
+                }
+            }
+            // Flag as unplaced NE teams on the EQ leg
+            // DO NOT Flag as unplaced in overall (leg:0) NE teams as this is used in the full report
+            if ( (i == config.equestrian_leg /*|| i == 0*/ ) && ptr->flags.non_equestrian ) {
+                if (ptr->isNeData) {
+                    sort_aux[ptr->team].lq_place[i] = -1;
+                } else {
+                    sort_aux[ptr->team].l_place[i] = -1;
+                }
+                continue;
+            }
             if (ptr->isNeData) {
                 sort_aux[ptr->team].lq_place[i] = q++;
             } else {
                 sort_aux[ptr->team].l_place[i] = k++;
+            }
         **  Then save the teams place at the end of each leg
         */
         sort_team_data( i, S_LE, sortWithEq);
         for( j = 1, k = 1, q = 1, ptr = sort_data; j <= sort_num; ptr++, j++ )
+        {
+            if (i == 0 || i == config.equestrian_leg || sort_afterEquestrianLeg ) {
+                if (ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check) {
+                    if (ptr->isNeData) {
+                        sort_aux[ptr->team].leq_place[i] = -1;
+                    } else {
+                        sort_aux[ptr->team].le_place[i] = -1;
+                    }
+                    continue;
+                }
+            }
+            // Flag as unplaced NE teams on the EQ leg
+            // Flag as unplaced NE teams after the EQ leg
+            // Flag as unplaced in overall (leg:0) NE teams
+            if ( (i == config.equestrian_leg || sort_afterEquestrianLeg || i == 0 ) && ptr->flags.non_equestrian ) {
-            if (ptr->isNeData) {
+                if (ptr->isNeData) {
-                sort_aux[ptr->team].leq_place[i] = q++;
+                    sort_aux[ptr->team].leq_place[i] = -1;
+                } else {
+                    sort_aux[ptr->team].le_place[i] = -1;
+                }
+                continue;
+            }
-            else {
+            if (ptr->isNeData) {
+                sort_aux[ptr->team].leq_place[i] = q++;
+            } else {
                 sort_aux[ptr->team].le_place[i] = k++;
+            }
+        }
         /*
             else {
                 if (ptr->isNeData)
                     isNe = true;
+            }
+            // Flag as unplaced NE teams on the EQ leg
+            if (i == 0 || i == config.equestrian_leg) {
+                if (ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check) {
+                    if (isNe) {
+                        sort_aux[ptr->team].lq_place[i] = -1;
+                    } else {
+                        sort_aux[ptr->team].lc_place[i] = -1;
+                    }
+                    continue;
+                }
+            }
+            if ( i == config.equestrian_leg && ptr->flags.non_equestrian ) {
+                if (ptr->isNeData) {
+                    sort_aux[ptr->team].lq_place[i] = -1;
+                } else {
+                    sort_aux[ptr->team].lc_place[i] = -1;
+                }
+                continue;
+            }
             if (isNe) {
                 if( teamclassq != ptr->teamclass )
+                {
                     q = 1;
                     teamclassq = ptr->teamclass;
                     k = 1;
                     teamclass = ptr->teamclass;
+                }
                 sort_aux[ptr->team].lc_place[i] = k++;
+            }
+        }
         /*
         **  Sort on end time per class
         **  Then save the teams place at the end of each leg per class
             else {
                 if (ptr->isNeData)
                     isNe = true;
+            }
+            if (i == 0 || i == config.equestrian_leg || sort_afterEquestrianLeg) {
+                if (ptr->flags.bad_times || ptr->flags.disqualified || ptr->flags.vet_check) {
+                    if (isNe) {
+                        sort_aux[ptr->team].leq_place[i] = -1;
+                    } else {
+                        sort_aux[ptr->team].lec_place[i] = -1;
+                    }
+                    continue;
+                }
+            }
+            // Flag as unplaced NE teams on the EQ leg
+            // Flag as unplaced NE teams after the EQ leg
+            // Flag as unplaced in overall (leg:0) NE teams
+            if ( (i == config.equestrian_leg || sort_afterEquestrianLeg || i == 0 ) && ptr->flags.non_equestrian ) {
+                if (ptr->isNeData) {
+                    sort_aux[ptr->team].leq_place[i] = -1;
+                } else {
+                    sort_aux[ptr->team].lec_place[i] = -1;
+                }
+                continue;
+            }
             if (isNe) {
                 if( teamclassq != ptr->teamclass )
+                {
                     q = 1;
                     teamclassq = ptr->teamclass;
                     k = 1;
                     teamclass = ptr->teamclass;
+                }
                 sort_aux[ptr->team].lec_place[i] = k++;
+            }
+        }
+    }
     /*
     **  Write the place information back to disk for use in the displays
     ty_s_data  *ptr;
     sort_leg = leg;                              /* Leg is global for the comparison function */
     sort_mode = mode;                            /* Mode is global for compare function */
     sort_withEquestrian = withEq;                /* Mode is global for compare function */
+    sort_afterEquestrianLeg = ( config.equestrian_leg && leg > config.equestrian_leg);
     qsort( ( char * ) sort_data, sort_num, sizeof( ty_s_data ), sort_comp );
     /*
      * Insert "place data" into the sorted data
     for( j = 1; j <= sort_num; j++, ptr++ )
+    {
         ptr->place = j;
+    }
+    //qDebug() << "sort_team_data: Leg:" << leg << ",M:" << mode << ",E:" << withEq;
+}
 /*========================================================================
+ *
  *  qsort comparison function
     **
     **  If not sorting within a class (ie Overall), then Non_Equestrian
     **  is better than a bad time. Places NE before disqualified
     **
     */
+    bool aNoSort = false;
+    bool bNoSort = false;
+    if ( sort_leg != 0 && (sort_mode == S_LC || sort_mode == S_L ) ) {
+        aNoSort = a->flags.notInLP;
+        bNoSort = b->flags.notInLP;
+    }
+    if ( sort_withEquestrian && (sort_mode == S_LC || sort_mode == S_L ) ) {
+        if (a->flags.vet_check)
+            aNoSort = true;
+        if (b->flags.vet_check)
+            bNoSort = true;
+    }
+    if (a->flags.bad_times || a->flags.disqualified || !a->flags.valid)
+        aNoSort = true;
+    if (b->flags.bad_times || b->flags.disqualified || !b->flags.valid)
+        bNoSort = true;
+    if ( sort_mode == S_FIN || sort_mode == S_IFIN ) {
+        if (a->flags.vet_check)
+            aNoSort = true;
+        if (b->flags.vet_check)
+            bNoSort = true;
+    }
+    // On the Equestrian Leg, vetted out teams are treated as disqualified
-    if( a->flags.bad_times || b->flags.bad_times || ( sort_withEquestrian && a->flags.non_equestrian) || (sort_withEquestrian && b->flags.non_equestrian))  /* Valid data has precedence */
+    if (sort_leg == config.equestrian_leg || (sort_afterEquestrianLeg && ( sort_mode == S_LE || sort_mode == S_LEC))) {
+        if (a->flags.vet_check)
+            aNoSort = true;
+        if (b->flags.vet_check)
+            bNoSort = true;
+    }
+    if (aNoSort && bNoSort)
+        return ( a->team - b->team );
+    if (aNoSort || bNoSort)
+        return ( aNoSort ? 1 : -1 );
+    if( sort_withEquestrian && sort_mode != S_FIN && sort_mode != S_IFIN )
+    {
-        if( a->flags.bad_times && b->flags.bad_times )
+        if( a->flags.non_equestrian && b->flags.non_equestrian )
-        {
-            return ( a->team - b->team );
-        }
-        else if( a->flags.bad_times || b->flags.bad_times )
+        {
+            /*
+            **  Both are non equestrian
+            **  Let the time sort operate ...
+            */
-            return ( a->flags.bad_times ? 1 : -1 );
+            //return ( a->team - b->team );
+        }
-        if( sort_mode != S_FIN && sort_mode != S_IFIN )
+        else if( a->flags.non_equestrian || b->flags.non_equestrian )
+        {
-            if( a->flags.non_equestrian && b->flags.non_equestrian )
-            {
-                /*
-                **  Both are non equestrian
-                **  Let the time sort operate ...
-                */
-                //return ( a->team - b->team );
-            }
-            else
-            {
-                /* One is equestrian */
+            /* One is equestrian */
-                /* Good times better than NE */
+            /* Good times better than NE */
-                return ( a->flags.non_equestrian ? 1 : -1 );
+            return ( a->flags.non_equestrian ? 1 : -1 );
-            }
+        }
+    }
     /*
     **  Before we sort on times we must determine which time to
     /*
      ** If we are ignore Equestrian config then place the Equestrian data last
     */
-#if 0
-    if (a->isNeData != b->isNeData) {
-         return ( a->isNeData ? 1 : -1 );
-    }
-#endif
 #if 1
     if (sort_withEquestrian) {
         if (a->isNeData != b->isNeData)
             return ( a->isNeData ? 1 : -1 );
+    }
 bool load_report_data(void)
+{
     ty_s_data  *ptr;                             /* pointer to sort data type */
     ty_s_data  *last;
-    int         j;
+    unsigned    j;
     unsigned    num;
     team_type   team_buf;
     /*
      * Fetch memory for the data store
                 ptr->teamclass = team_buf.teamclass;
                 ptr->real_teamclass = team_buf.teamclass;
                 ptr->flags = team_buf.flags;
+                // Add a few flags to simplify processing
+                //  Vetted out teams to be included inthe fastest calcs - except for Equestian Leg
+                //  Bodgey teams are not sorted by place - only after all places and then by team number
-//                if (ptr->flags.non_equestrian)
+                ptr->flags.notInLP = 0;
-//                    ptr->flags.disqualified = true;
+                ptr->flags.notInFastest = 0;
+                if ( ptr->flags.bad_times || ptr->flags.disqualified || !ptr->flags.valid) {
-                if (ptr->flags.vet_check)
+                    ptr->flags.notInLP = 1;
-                    ptr->flags.disqualified = true;
+                    ptr->flags.notInFastest = 1;
+                }
                 ptr++;
                 sort_num++;
                     ptr->isNeData = true;
                     ptr->lege[0] = 0;
                     for( j = 0; j < MAX_LEGS + 1; j++ )
+                    {
-                        if ( j == config.equestrian_leg )
+                        if ( (short)j == config.equestrian_leg )
+                        {
                             last->lege[j] = ptr->lege[j] = 0;
                             if ( config.equestrian_leg > 1 )
                                 last->leg[j] = ptr->leg[j] = ptr->leg[j-1];
+                        }
                     last->start = ptr->start = team_buf.leg[0].start;
                     ptr->teamclass = config.nonequestrian_class;
                     ptr->real_teamclass = team_buf.teamclass;
                     ptr->flags = team_buf.flags;
-//                    ptr->flags.disqualified = false;
                     ptr++;
                     sort_num++;
+                }
 #endif
+            }
+        }
+    }
+    // Debug
+//    qDebug() << "--- Start ---";
+//    sort_team_data( 0, S_L, 1 );
+//    for( j = 1, ptr = sort_data; j <= sort_num; j++, ptr++ )
+//    {
+//        qDebug() << "T:" << ptr->team
+//                << "Class:" << ptr->teamclass
+//                << "NEData:" << (ptr->isNeData? 1:0)
+//                << "iLP:" << (ptr->flags.notInLP ? 1:0)
+//                << "iF:" << (ptr->flags.notInFastest ? 1:0)
+//                << "Valid:" << (ptr->flags.valid ? 1:0)
+//                << "NE:" << (ptr->flags.non_equestrian? 1:0)
+//                << "B:" << (ptr->flags.bad_times ? 1 : 0 )
+//                << "D:" << (ptr->flags.disqualified ? 1:0 )
+//                << "V:" << (ptr->flags.vet_check ? 1:0 )
+//                << "LE0:" << ptr->lege[0]
+//                << "L0:" << ptr->leg[0]
+//                << "LE1:" << ptr->lege[3]
+//                ;
+//    }
+//    qDebug() << "-----------------------------------End---";
     return ( TRUE );
+}
 /*========================================================================
+ *
         **  of the data can be trusted.
         **
         **  If the team has been disqualified, then don't use any
         **  of the data.
         */
-        if( ptr->flags.bad_times || ptr->flags.disqualified  )
+        if (ptr->flags.notInFastest) {
             continue;
+        }
+        //if( ptr->flags.bad_times || ptr->flags.disqualified  )
+        //    continue;
         /*
         **  Ignore non-Equestrian, unless we are processing the psuedo NE class
+        **  2021: Now allow NE to be considered in the fastest stats
         */
-        if ( ptr->teamclass != config.nonequestrian_class && ptr->flags.non_equestrian)
+        //if ( ptr->teamclass != config.nonequestrian_class && ptr->flags.non_equestrian)
-            continue;
+        //    continue;
         for( j = 0; j <= config.num_legs; j++ )
+        {
             if( ptr->lege[j] <= 0 )              /* Ignore bad data */
                 continue;
             /*
+            ** If this is the Equestrian Leg and the team has been vetted out, then this team cannot
+            ** be included into the stats for this leg
+            **
+            ** If team has been vetted out then don't consider in fastest overall
+            */
+            if ( ptr->flags.vet_check && (j == config.equestrian_leg || j== 0)) {
+                continue;
+            }
+            /* If this is the Equestrian Leg and the team is a Non-Equestrian Team, then don't include
+            ** it into the stats.
+            **
+            ** If this is a NE team then don't consider it to be fastest overall
+            */
+            if ( ptr->teamclass != config.nonequestrian_class && ptr->flags.non_equestrian &&  (j == config.equestrian_leg || j== 0)) {
+                continue;
+            }
+            /*
             **  Determine fastest team : overall
             **  Ignore the non-equestrian data as this is in the list twice
             */
             if( ( ptr->lege[j] < stats.fast.time[j][0] )
                 || ( stats.fast.time[j][0] < 0 ) )

Subversion Repositories svn1

(root)/Mara/branches/QtMain/report.cpp – Rev 357 → 359