[Tlf-devel] Date bug, worked-window

[Fabian Kurz]

Hello,

I used tlf-0.9.28 in the SP-DX contest last weekend, works great, no
major problems. I also noticed the spurious characters as reported by
N7XY, sometimes a bit confusing but not really a problem and I trust
it will be fixed.

I found one little bug: The date in the line where the actual QSO is
entered is not continuously updated, so when the clock switched from
23:59 to 00:00 last night, the date remained at 01-Apr-2006; however
when logging new QSOs, it was OK in the last displayed QSOs. In
the entry-line itself it remained wrong.
Looks like the date in this line is only updated by clear_display(),
which will be called sooner or later anyway, but in my case (only
using tlf for logging, not keying etc) it took until half an hour
after midnight or so until it changed. 
Adding a clear_display(); to the time_update()-function helped, but
maybe it would be more clever to let time_update itself update the
date aswell, in the same fashion it updates the time.

Another little thing that bothered me during the SP-DX contest was the
way the "Worked"-window works. It always shows the *last* QSO matching
the (partial) call which is entered at the moment on each band.
In SP-DX I worked both SQ9C and later SQ9CAQ on 80m. When I was on
40m and entered "SQ9C", on 80m the QSO for SQ9CAQ was displayed,
because it was the last matching QSO for "SQ9C". I was confused
because I was pretty sure I had SQ9C worked on 80m, and thought I
might have logged him on the wrong band (he was also in log on 160m
:) because he didn't show up in the Worked-window on 80. In my opinion
the "Worked"-window should - if available - display QSOs with exactly
the callsign entered with higher priority than any other matching
callsign.
Of course this is a rare case, only happens when several calls which
have at least the same prefix and a common first suffix letter, but it
bothered me, so I wrote a small patch for searchlog.c to avoid such
confusion:

31a32,41
> /* DJ1YFK "worked window"-patch */
> static char band_yfk[4]="";   
> static char testcall_yfk[13]="";
> static char hiscall_yfk[13]="            ";
> int xx=0;
> int bm[6];
> int bandnr;
> int yy=0;
> /* */
> 
153c164,168
<               for (r_index = 0; r_index < srch_index; r_index++){
---
> 
>               // initialize array best matching callsigns
>               for(xx=0; xx<6; xx++) { bm[xx] = 0; }
> 
>               for (r_index = 0; r_index < srch_index; r_index++){
164a180,240
>                       
>                       /* DJ1YFK worked-window patch */
>                       strncpy(band_yfk, searchresult[r_index],3);
>                       band_yfk[4]= '\0';
>                       bandnr = atoi(band_yfk);
>                       
>                       strncpy(testcall_yfk, searchresult[r_index]+29,12);
>                       testcall_yfk[13]= '\0';
>                       
>                       // Create string with his call + whitespaces
>                       strcpy(hiscall_yfk,"            ");
>                       for (xx=0; xx < strlen(hiscall); xx++) {
>                               hiscall_yfk[xx] = hiscall[xx];
>                       }
>                       // find out how many characters match
>                       yy=0;
>                       for (xx=0; xx < 13; xx++) {     
>                               if(hiscall_yfk[xx] == testcall_yfk[xx]) {yy++;}
>                       }
> 
>                       // delete QSOs that match worse than anything before
>                       // of course still less-good magtching QSOs can be in 
> the array,
>                       // but *before* the better matching one, so they will be
>                       // overwritten later.
>                       switch (bandnr) {
>                                       case 160: { if (yy < bm[0]) {
>                                               result[r_index][0] = '\0'; 
>                                               }
>                                               else { bm[0] = yy; }
>                                               break;
>                                       }
>                                       case 80: { if (yy < bm[1]) {
>                                               result[r_index][0] = '\0'; 
>                                               }
>                                               else { bm[1] = yy; }
>                                               break;
>                                       }
>                                       case 40: { if (yy < bm[2]) {
>                                               result[r_index][0] = '\0'; 
>                                               }
>                                               else { bm[2] = yy; }
>                                               break;
>                                       }
>                                       case 20: { if (yy < bm[3]) {
>                                               result[r_index][0] = '\0'; 
>                                               }
>                                               else { bm[3] = yy; }
>                                               break;
>                                       }
>                                       case 15: { if (yy < bm[4]) {
>                                               result[r_index][0] = '\0'; 
>                                               }
>                                               else { bm[4] = yy; }
>                                               break;
>                                       }
>                                       case 10: { if (yy < bm[5]) {
>                                               result[r_index][0] = '\0'; 
>                                               }
>                                               else { bm[5] = yy; }
>                                       }
>                       } /* end of patch */

Not sure if you like it; requires some extra CPU time; look pretty long
winded, but I am not really fluent in C. At least it appears to work.
Would have been so easy in Perl :-)

Hw?

73,
-- 
Fabian Kurz, DJ1YFK * Dresden, Germany * http://fkurz.net/
Online log: http://dl0tud.tu-dresden.de/~dj1yfk/log.html