diff -ru linrad-04.05/palette.c linrad-04.05-jazzkutyaremix/palette.c
--- linrad-04.05/palette.c	2015-02-08 18:16:18.000000000 +0100
+++ linrad-04.05-jazzkutyaremix/palette.c	2015-05-31 02:43:45.231913675 +0200
@@ -25,7 +25,7 @@
 // any mistakes immediately
 #include "globdef.h"
 #include "screendef.h"
-#define MAX_SVGA_PALETTE 59
+#define MAX_SVGA_PALETTE 60
 
 /*
 // Black and white palette for (publishing)
@@ -71,8 +71,9 @@
 //    52      |      53      |     54       |     55
 0x0a,0x0a,0x3f,0x14,0x14,0x3f,0x1f,0x1f,0x3f,0x2b,0x2b,0x3f,
 //    56      |      57      |     58       |     59
-0x0e,0x29,0x22,0x12,0x12,   0,0x30,0x30,0x3f,         0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,
+0x0e,0x29,0x22,0x12,0x12,   0,0x30,0x30,0x3f,0x3f,0x30,0x30,
+//    60      |
+0x0,0x0,0x0,   0,0,0,0,0,0,0,0,0,0,0,
 // do not forget to update MAX_SVGA_PALETTE when adding more colours
 
 0,0,0,0,0,0,0,0,0,0,0,0,
diff -ru linrad-04.05/screen.c linrad-04.05-jazzkutyaremix/screen.c
--- linrad-04.05/screen.c	2015-02-08 18:16:18.000000000 +0100
+++ linrad-04.05-jazzkutyaremix/screen.c	2015-05-31 02:31:06.360902237 +0200
@@ -584,6 +584,88 @@
   }
 }
 
+// prefix bbs means basband spectrum
+void bbs_clearsegment(int x,int bottom, int top) {
+    int y,color;
+    for (y=bottom;y<=top;y++) {
+        color=bg_background[y];
+        if( (x == curv_xpixel && y >= bg_y4 && y < bg_y3) ||
+            (x == flat_xpixel && y >= bg_ymax && y < bg_y4) )
+          {
+          color=14;
+          }
+        else 
+          {
+          if( (x == bfo_xpixel && y >= bg_y3 && y < bg_y2) ||
+              (x == bfo10_xpixel && y >= bg_y2 && y < bg_y1) ||
+              (x == bfo100_xpixel && y >= bg_y1) )
+            {
+            color=12;
+            }
+          }
+        if( bg_carrfilter_y[x] == y)color=58;
+        if( bg_filterfunc_y[x] == y)color=14;
+        lir_setpixel(x,y,color);
+    }
+}
+void bbs_drawsegment(int x,int bottom, int top,int color) {
+    int y;
+    for (y=bottom;y<=top;y++) lir_setpixel(x,y,color);
+}
+
+struct {
+    // data for n-1
+    int x,y,y_old,color;
+    // data for n-2
+    int px,py,py_old;
+} bbs_draw_state;
+
+void bbs_draw_init(void) {
+    bbs_draw_state.x=bbs_draw_state.px=-1;
+}
+
+void bbs_do_segment(int xnext,int ynext,int oldynext) {
+    if (bbs_draw_state.x==-1) return;
+    int top=bbs_draw_state.y_old;
+    int bottom=top;
+    if (bbs_draw_state.px!=-1) {
+        int m=(bbs_draw_state.y_old+bbs_draw_state.py_old)/2;
+        if (m<bottom) bottom=m+1;
+        if (m>top) top=m-1;
+    }
+    if (xnext!=-1) {
+        int m=(bbs_draw_state.y_old+oldynext)/2;
+        if (m<bottom) bottom=m;
+        if (m>top) top=m;
+    }
+    // raise bottom to at least bgbutt[BG_SQUELCH_LEVEL].y2 only if we are below the squelch widget
+    if(bbs_draw_state.x >= bgbutt[BG_SQUELCH_LEVEL].x1 && bottom<bgbutt[BG_SQUELCH_LEVEL].y2) bottom=bgbutt[BG_SQUELCH_LEVEL].y2;
+    if (bottom<=top) bbs_clearsegment(bbs_draw_state.x,bottom,top);
+
+    top=bbs_draw_state.y;
+    bottom=top;
+    if (bbs_draw_state.px!=-1) {
+        int m=(bbs_draw_state.y+bbs_draw_state.py)/2;
+        if (m<bottom) bottom=m+1;
+        if (m>top) top=m-1;
+    }
+    if (xnext!=-1) {
+        int m=(bbs_draw_state.y+ynext)/2;
+        if (m<bottom) bottom=m;
+        if (m>top) top=m;
+    }
+    // raise bottom to at least bgbutt[BG_SQUELCH_LEVEL].y2 only if we are below the squelch widget
+    if(bbs_draw_state.x >= bgbutt[BG_SQUELCH_LEVEL].x1 && bottom<bgbutt[BG_SQUELCH_LEVEL].y2) bottom=bgbutt[BG_SQUELCH_LEVEL].y2;
+    if (bottom<=top) bbs_drawsegment(bbs_draw_state.x,bottom,top,bbs_draw_state.color);
+}
+void bbs_draw_finish(void) {
+    bbs_do_segment(-1,-1,-1);
+}
+void bbs_draw_state_shift(void) {
+    bbs_draw_state.px=bbs_draw_state.x;
+    bbs_draw_state.py=bbs_draw_state.y;
+    bbs_draw_state.py_old=bbs_draw_state.y_old;
+}
 void show_baseband_spectrum(void)
 {
 int i,j,k,kk,color,pp,bg_xpix1,bg_xpix2;
@@ -603,6 +685,7 @@
 if(sw_onechan)
   {  
   p2=bg.yfac_log*log10(fft3_slowsum[i]*pwrfac);
+  bbs_draw_init();
   for(k=bg_xpix1; k<bg_xpix2; k+=pp)
     {
     p1=p2;
@@ -618,46 +701,26 @@
       if(new_y1 < 0)new_y1=0;
       new_y1=bg_y0-new_y1;
       if(new_y1 < ymax)new_y1=ymax;
-      if( new_y1 != old_y1)
+      if( new_y1 != old_y1 || 1) // since size of a line segment depends on previous and next y value, we can not spare redrawing for no change
+                                 // in current y 
         {
-        color=bg_background[old_y1];
-        if( (kk == curv_xpixel && old_y1 >= bg_y4 && old_y1 < bg_y3) ||
-            (kk == flat_xpixel && old_y1 >= bg_ymax && old_y1 < bg_y4) )
-          {
-          color=14;
-          }
-        else 
-          {
-          if( (kk == bfo_xpixel && old_y1 >= bg_y3 && old_y1 < bg_y2) ||
-              (kk == bfo10_xpixel && old_y1 >= bg_y2 && old_y1 < bg_y1) ||
-              (kk == bfo100_xpixel && old_y1 >= bg_y1) )
-            {
-            color=12;
-            }
-          }
-        if( bg_carrfilter_y[kk] == old_y1)color=58;
-        if( bg_filterfunc_y[kk] == old_y1)color=14;
-        if(kk < bgbutt[BG_SQUELCH_LEVEL].x1)
-          {
-          lir_setpixel(kk,old_y1,color);
-          lir_setpixel(kk,new_y1,15);
-          }
-        else
-          {
-          if(old_y1 > bgbutt[BG_SQUELCH_LEVEL].y2)
-            {
-            lir_setpixel(kk,old_y1,color);
-            }
-          if(new_y1 > bgbutt[BG_SQUELCH_LEVEL].y2)
-            {
-            lir_setpixel(kk,new_y1,15);
-            }
-          }          
+        // we are going over _each_ x coord from bg_xpix1 to bg_xpix2 and in order, so no magic needed:
+        // do a segment, shift state, put in new data
+        bbs_do_segment(kk,new_y1,old_y1);    // handle a segment for kk-1 (data is in bbs_draw_state)
+        // shift bbs_draw_state
+        bbs_draw_state_shift();
+        // put in new data
+        bbs_draw_state.x=kk;
+        bbs_draw_state.y=new_y1;
+        bbs_draw_state.y_old=old_y1;
+        bbs_draw_state.color=59;
+
         fft3_spectrum[kk]=new_y1;
         }
       }
     i++;
     }
+  bbs_draw_finish();     // flush any remaining segment left in bbs_draw_state
   }
 else
   {
diff -ru linrad-04.05/screendef.h linrad-04.05-jazzkutyaremix/screendef.h
--- linrad-04.05/screendef.h	2015-02-08 18:16:18.000000000 +0100
+++ linrad-04.05-jazzkutyaremix/screendef.h	2015-05-31 02:20:44.969639977 +0200
@@ -83,7 +83,7 @@
 
 
 
-#define MAX_SVGA_PALETTE 59
+#define MAX_SVGA_PALETTE 60
 
 
 // Note that these definitions give the order by which data is 
diff -ru linrad-04.05/screensub.c linrad-04.05-jazzkutyaremix/screensub.c
--- linrad-04.05/screensub.c	2015-02-08 18:16:18.000000000 +0100
+++ linrad-04.05-jazzkutyaremix/screensub.c	2015-05-31 02:31:15.784888481 +0200
@@ -875,6 +875,79 @@
   }  
 }
 
+// update_wg state variables
+// only draw line segments for a given x when previous and next point are known
+// data for n-1
+int uwg_x;
+int uwg_y,uwg_oldy,uwg_color,uwg_bkgcolor;
+// data for n-2
+int uwg_px;
+int uwg_py,uwg_poldy;
+
+void update_wg_init(void) {
+    uwg_x=uwg_px=-1;
+}
+void update_wg_drawsegment(int xnext,int ynext,int oldynext) {
+    // 3 points:
+    // p0: u_wg_px,u_wg_py
+    // p1: u_wg_x,u_wg_y
+    // p2: xnext,ynext
+    if (uwg_x==-1) return;
+    // first reproduce everything with old y values, that is:
+    // calculate old line segment for column uwg_x
+    // p0 and p2 may be undef
+    if (uwg_px==-1 && xnext==-1) {
+        // only one single lonely pixel
+        int bkgcolor=uwg_bkgcolor==0 ? wg_background[uwg_oldy] : uwg_bkgcolor;
+        lir_setpixel(uwg_x,uwg_oldy,bkgcolor);
+    } else {
+        int stop=uwg_oldy;          // not stop but segment-top. nah.
+        int sbottom=uwg_oldy;       // segment bottom
+        if (uwg_px!=-1) {
+            int m=(uwg_oldy+uwg_poldy)/2;
+            if (m<sbottom) sbottom=m+1;         // -1 and +1 to avoid a horizontal double pixel where 2 line segments connect
+            if (m>stop) stop=m-1;               // there are still double vertical pixels when neightbouring y values are very similar or same
+                                                // but those are a good thing(tm)
+        }
+        if (xnext!=-1) {
+            int m=(uwg_oldy+oldynext)/2;
+            if (m<sbottom) sbottom=m;
+            if (m>stop) stop=m;
+        }
+        // so here we are: line from (uwg_x,sbottom) to (uwg_x,stop) should be cleared
+        //lir_line(uwg_x,sbottom,uwg_x,stop,uwg_bkgcolor)
+        int y;
+        for (y=sbottom;y<=stop;y++) {
+            int bkgcolor=uwg_bkgcolor==0 ? wg_background[y] : uwg_bkgcolor;
+            lir_setpixel(uwg_x,y,bkgcolor);
+        }
+    }
+
+    // calculating new line segment for column uwg_x
+    // p0 and p2 may be undef
+    if (uwg_px==-1 && xnext==-1) {
+        // TODO only one single lonely pixel
+        lir_setpixel(uwg_x,uwg_y,uwg_color);
+    } else {
+        int stop=uwg_y;
+        int sbottom=uwg_y;
+        if (uwg_px!=-1) {
+            int m=(uwg_y+uwg_py)/2;
+            if (m<sbottom) sbottom=m+1;
+            if (m>stop) stop=m-1;
+        }
+        if (xnext!=-1) {
+            int m=(uwg_y+ynext)/2;
+            if (m<sbottom) sbottom=m;
+            if (m>stop) stop=m;
+        }
+        // so here we are: line from (uwg_x,sbottom) to (uwg_x,stop) should be drawed
+        lir_line(uwg_x,sbottom,uwg_x,stop,uwg_color);
+    }
+}
+void update_wg_finish(void) {
+    update_wg_drawsegment(-1,-1,-1);
+}
 void update_wg(int xpix,int new_y, char spk_color )
 {
 int i, old_y, sw;
@@ -893,9 +966,10 @@
   old_y=-old_y;
   if(spk_color !=12)sw=1;
   }
-if(new_y!=old_y || sw!=0)
+if (spk_color==15) spk_color=59;
+if(new_y!=old_y || sw!=0 || 1)
   {
-  bkg_color=wg_background[old_y];
+  bkg_color=0;  // this will flag to the segment drawer to use the background array for clearing
   if( (ui.network_flag&NET_RX_OUTPUT) != 0)
     {  
     for(i=0; i<MAX_FREQLIST; i++)
@@ -920,8 +994,30 @@
         }
       }  
     }
-  lir_setpixel(xpix,old_y,bkg_color);
-  lir_setpixel(xpix,new_y,spk_color);
+  //lir_setpixel(xpix,old_y,bkg_color);
+  //lir_setpixel(xpix,new_y,spk_color);
+  if (uwg_x==(xpix-1)) {
+      // state information + current xpix,new_y gives 3 points from which we can draw line segment for xpix-1
+      // TODO do it
+      update_wg_drawsegment(xpix,new_y,old_y);
+      // step data thru our state
+      uwg_px=uwg_x;
+      uwg_py=uwg_y;
+      uwg_poldy=uwg_oldy;
+      
+  } else {
+      // line is not cintinous
+      // TODO first perform drawing left in state
+      update_wg_drawsegment(-1,-1,-1);
+      // then reinit state with new segment starting with this call
+      uwg_px=uwg_py=-1;
+  }
+  uwg_x=xpix;
+  uwg_y=new_y;
+  uwg_color=spk_color;
+  uwg_bkgcolor=bkg_color;
+  uwg_oldy=old_y;
+
   if(spk_color != 15)new_y=-new_y;
   fft1_spectrum[xpix]=new_y;
   }
@@ -1039,6 +1135,7 @@
 if(wg.xpoints_per_pixel == 1 || wg.pixels_per_xpoint == 1)
   {
   i=wg.first_xpoint+wg_first_xpixel-wg_first_xpixel;
+  update_wg_init();
   for(xpix=wg_first_xpixel; xpix<=wg_last_xpixel; xpix++)
     {
     if(liminfo[i]==0)
@@ -1055,12 +1152,14 @@
       }
     i++;
     }
+  update_wg_finish();
   }    
 else
   {
   if(wg.xpoints_per_pixel == 0)
     {
 // There are more pixels than data points so we must interpolate.
+    update_wg_init();
     i=wg.first_xpoint+(wg_first_xpixel-wg_first_xpixel)/wg.pixels_per_xpoint;
     if(fft1_slowsum[i] > 0.5)
       {
@@ -1120,12 +1219,14 @@
       i++;
       yval=t1;
       }      
+    update_wg_finish();
     }
   else
     {
 // There is more than one data point for each pixel.
 // Slide a triangular filter across the spectrum to make it
 // smoother before resampling.
+    update_wg_init();
     i=wg.first_xpoint+(wg_first_xpixel-wg_first_xpixel)*wg.xpoints_per_pixel;
     for(xpix=wg_first_xpixel; xpix<wg_last_xpixel; xpix++)
       {
@@ -1150,6 +1251,7 @@
         }
       i+=wg.xpoints_per_pixel;
       }
+    update_wg_finish();
     }  
   }
 if(fft1_correlation_flag)