From 6b67a74055fd371774babb4dc501c54b08c09393 Mon Sep 17 00:00:00 2001
From: Denny <denny@denny-desktop>
Date: Sat, 21 Jan 2017 08:13:18 -0500
Subject: [PATCH] #90 [WIP] Adds ability to show streaming status on main
 application window using menu (View > Show Streaming Status).  Resolves a
 number of issues with the SystemProperties class.

---
 src/audio/AudioManager.java                   |   27 +-
 src/audio/broadcast/BroadcastModel.java       |    2 +-
 src/audio/broadcast/BroadcastPanel.java       |   89 +-
 src/audio/broadcast/BroadcastStatusPanel.java |  125 ++
 src/controller/ControllerPanel.java           |    8 +-
 src/controller/channel/ChannelModel.java      |  622 +++----
 src/gui/SDRTrunk.java                         |  110 +-
 src/properties/SystemProperties.java          |  167 +-
 src/spectrum/DFTProcessor.java                |  865 +++++-----
 src/spectrum/SpectralDisplayPanel.java        | 1506 ++++++++---------
 10 files changed, 1820 insertions(+), 1701 deletions(-)
 create mode 100644 src/audio/broadcast/BroadcastStatusPanel.java

diff --git a/src/audio/AudioManager.java b/src/audio/AudioManager.java
index 6be25898..02578da0 100644
--- a/src/audio/AudioManager.java
+++ b/src/audio/AudioManager.java
@@ -118,12 +118,11 @@ public class AudioManager implements Listener<AudioPacket>, IAudioController
 
         try
         {
-            setMixerChannelConfiguration(configuration);
+            setMixerChannelConfiguration(configuration, false);
         }
         catch(Exception e)
         {
-            mLog.error("Couldn't set stored audio mixer/channel configuration"
-                + " - using default", e);
+            mLog.error("Couldn't set stored audio mixer/channel configuration - using default", e);
 
             try
             {
@@ -131,8 +130,7 @@ public class AudioManager implements Listener<AudioPacket>, IAudioController
             }
             catch(Exception e2)
             {
-                mLog.error("Couldn't set default audio mixer/channel "
-                    + "configuration - no audio will be available", e2);
+                mLog.error("Couldn't set default audio mixer/channel configuration - no audio will be available", e2);
             }
         }
     }
@@ -217,8 +215,12 @@ public class AudioManager implements Listener<AudioPacket>, IAudioController
     @Override
     public void setMixerChannelConfiguration(MixerChannelConfiguration entry) throws AudioException
     {
-        if(entry != null &&
-            (entry.getMixerChannel() == MixerChannel.MONO || entry.getMixerChannel() == MixerChannel.STEREO))
+        setMixerChannelConfiguration(entry, true);
+    }
+
+    public void setMixerChannelConfiguration(MixerChannelConfiguration entry, boolean saveSettings) throws AudioException
+    {
+        if(entry != null && (entry.getMixerChannel() == MixerChannel.MONO || entry.getMixerChannel() == MixerChannel.STEREO))
         {
             mControllerBroadcaster.broadcast(CONFIGURATION_CHANGE_STARTED);
 
@@ -260,11 +262,12 @@ public class AudioManager implements Listener<AudioPacket>, IAudioController
 
             mControllerBroadcaster.broadcast(CONFIGURATION_CHANGE_COMPLETE);
 
-            SystemProperties properties = SystemProperties.getInstance();
-
-            properties.set(AUDIO_MIXER_PROPERTY, entry.getMixer().getMixerInfo().getName());
-            properties.set(AUDIO_CHANNELS_PROPERTY, entry.getMixerChannel().name());
-            properties.save();
+            if(saveSettings)
+            {
+                SystemProperties properties = SystemProperties.getInstance();
+                properties.set(AUDIO_MIXER_PROPERTY, entry.getMixer().getMixerInfo().getName());
+                properties.set(AUDIO_CHANNELS_PROPERTY, entry.getMixerChannel().name());
+            }
         }
     }
 
diff --git a/src/audio/broadcast/BroadcastModel.java b/src/audio/broadcast/BroadcastModel.java
index f6e9b587..ad79cf9a 100644
--- a/src/audio/broadcast/BroadcastModel.java
+++ b/src/audio/broadcast/BroadcastModel.java
@@ -585,7 +585,7 @@ public class BroadcastModel extends AbstractTableModel implements Listener<Audio
         switch(column)
         {
             case COLUMN_SERVER_ICON:
-                return null;
+                return "Streaming";
             case COLUMN_STREAM_NAME:
                 return "Name";
             case COLUMN_BROADCASTER_STATUS:
diff --git a/src/audio/broadcast/BroadcastPanel.java b/src/audio/broadcast/BroadcastPanel.java
index 557b5d80..d299dac9 100644
--- a/src/audio/broadcast/BroadcastPanel.java
+++ b/src/audio/broadcast/BroadcastPanel.java
@@ -50,7 +50,7 @@ public class BroadcastPanel extends JPanel implements ActionListener, ListSelect
     private AliasModel mAliasModel;
     private IconManager mIconManager;
 
-    private JTable mBroadcastConfigurationTable;
+    private BroadcastStatusPanel mBroadcastStatusPanel;
     private JideSplitPane mSplitPane;
     private Editor<BroadcastConfiguration> mEmptyEditor = new EmptyEditor<>("Configuration:");
     private Editor<BroadcastConfiguration> mEditor;
@@ -72,17 +72,11 @@ public class BroadcastPanel extends JPanel implements ActionListener, ListSelect
     {
         setLayout(new MigLayout("insets 0 0 0 0 ", "[grow,fill]", "[grow,fill]"));
 
-        mBroadcastConfigurationTable = new JTable(mBroadcastModel);
-        mBroadcastConfigurationTable.setAutoCreateRowSorter(true);
-        mBroadcastConfigurationTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
-        mBroadcastConfigurationTable.getSelectionModel().addListSelectionListener(BroadcastPanel.this);
+        mBroadcastStatusPanel = new BroadcastStatusPanel(mBroadcastModel);
 
-        mBroadcastConfigurationTable.getColumnModel().getColumn(BroadcastModel.COLUMN_SERVER_ICON).setPreferredWidth(1);
-        mBroadcastConfigurationTable.getColumnModel().getColumn(BroadcastModel.COLUMN_STREAM_NAME).setPreferredWidth(25);
-        mBroadcastConfigurationTable.getColumnModel().getColumn(BroadcastModel.COLUMN_BROADCASTER_STATUS)
-            .setCellRenderer(new StatusCellRenderer());
-
-        JScrollPane scroller = new JScrollPane(mBroadcastConfigurationTable);
+        mBroadcastStatusPanel.getTable().setAutoCreateRowSorter(true);
+        mBroadcastStatusPanel.getTable().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        mBroadcastStatusPanel.getTable().getSelectionModel().addListSelectionListener(BroadcastPanel.this);
 
         JPanel buttonsPanel = new JPanel();
         buttonsPanel.setLayout(new MigLayout("insets 0 0 0 0", "[grow,fill][grow,fill][grow,fill]", "[]"));
@@ -122,7 +116,7 @@ public class BroadcastPanel extends JPanel implements ActionListener, ListSelect
 
         listAndButtonsPanel.setLayout(new MigLayout("insets 0 0 0 0", "[grow,fill]", "[grow,fill][]"));
 
-        listAndButtonsPanel.add(scroller, "wrap");
+        listAndButtonsPanel.add(mBroadcastStatusPanel, "wrap");
         listAndButtonsPanel.add(buttonsPanel);
 
         mSplitPane = new JideSplitPane(JideSplitPane.HORIZONTAL_SPLIT);
@@ -168,11 +162,11 @@ public class BroadcastPanel extends JPanel implements ActionListener, ListSelect
      */
     private BroadcastConfiguration getSelectedBroadcastConfiguration()
     {
-        int viewRow = mBroadcastConfigurationTable.getSelectedRow();
+        int viewRow = mBroadcastStatusPanel.getTable().getSelectedRow();
 
         if(viewRow >= 0)
         {
-            int modelRow = mBroadcastConfigurationTable.convertRowIndexToModel(viewRow);
+            int modelRow = mBroadcastStatusPanel.getTable().convertRowIndexToModel(viewRow);
 
             if(modelRow >= 0)
             {
@@ -255,75 +249,12 @@ public class BroadcastPanel extends JPanel implements ActionListener, ListSelect
                         mBroadcastModel.addBroadcastConfiguration(configuration);
 
                         int modelRow = mBroadcastModel.getRowForConfiguration(configuration);
-                        int tableRow = mBroadcastConfigurationTable.convertRowIndexToView(modelRow);
-                        mBroadcastConfigurationTable.changeSelection(tableRow, 0, false, false);
+                        int tableRow = mBroadcastStatusPanel.getTable().convertRowIndexToView(modelRow);
+                        mBroadcastStatusPanel.getTable().changeSelection(tableRow, 0, false, false);
                     }
                 }
             });
         }
     }
 
-    /**
-     * Custom cell renderer for the broadcast state column.
-     */
-    public class StatusCellRenderer extends DefaultTableCellRenderer
-    {
-        public StatusCellRenderer()
-        {
-            setOpaque(true);
-        }
-
-        @Override
-        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
-                                                       boolean hasFocus, int row, int column)
-        {
-            JLabel component = (JLabel)super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
-
-            if(isSelected)
-            {
-                setBackground(table.getSelectionBackground());
-                setForeground(table.getSelectionForeground());
-            }
-            else
-            {
-                if(value instanceof BroadcastState)
-                {
-                    BroadcastState state = (BroadcastState)value;
-
-                    if(state == BroadcastState.CONNECTED)
-                    {
-                        setBackground(Color.GREEN);
-                        setForeground(table.getForeground());
-                    }
-                    else if(state == BroadcastState.DISABLED)
-                    {
-                        setBackground(table.getBackground());
-                        setForeground(Color.LIGHT_GRAY);
-                    }
-                    else if(state == BroadcastState.INVALID_SETTINGS)
-                    {
-                        setBackground(Color.YELLOW);
-                        setForeground(table.getForeground());
-                    }
-                    else if(state.isErrorState())
-                    {
-                        setBackground(Color.RED);
-                        setForeground(table.getForeground());
-                    }
-                    else
-                    {
-                        setBackground(table.getBackground());
-                        setForeground(table.getForeground());
-                    }
-                }
-                else
-                {
-                    setForeground(table.getForeground());
-                    setBackground(table.getBackground());
-                }
-            }
-
-            return this;
-        }
-    }
 }
diff --git a/src/audio/broadcast/BroadcastStatusPanel.java b/src/audio/broadcast/BroadcastStatusPanel.java
new file mode 100644
index 00000000..34d91baf
--- /dev/null
+++ b/src/audio/broadcast/BroadcastStatusPanel.java
@@ -0,0 +1,125 @@
+/*******************************************************************************
+ * sdrtrunk
+ * Copyright (C) 2014-2017 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
+ ******************************************************************************/
+package audio.broadcast;
+
+import net.miginfocom.swing.MigLayout;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableCellRenderer;
+import java.awt.*;
+
+public class BroadcastStatusPanel extends JPanel
+{
+    private JTable mTable;
+    private JScrollPane mScrollPane;
+    private BroadcastModel mBroadcastModel;
+
+    public BroadcastStatusPanel(BroadcastModel broadcastModel)
+    {
+        mBroadcastModel = broadcastModel;
+
+        init();
+    }
+
+    public JTable getTable()
+    {
+        return mTable;
+    }
+
+    private void init()
+    {
+        setLayout(new MigLayout("insets 0 0 0 0 ", "[grow,fill]", "[grow,fill]"));
+
+        mTable = new JTable(mBroadcastModel);
+
+        DefaultTableCellRenderer renderer = (DefaultTableCellRenderer)mTable.getDefaultRenderer(String.class);
+        renderer.setHorizontalAlignment(SwingConstants.CENTER);
+
+        mTable.getColumnModel().getColumn(BroadcastModel.COLUMN_BROADCASTER_STATUS).setCellRenderer(new StatusCellRenderer());
+
+        mScrollPane = new JScrollPane(mTable);
+
+        add(mScrollPane);
+    }
+
+    /**
+     * Custom cell renderer for the broadcast state column.
+     */
+    public class StatusCellRenderer extends DefaultTableCellRenderer
+    {
+        public StatusCellRenderer()
+        {
+            setOpaque(true);
+            setHorizontalAlignment(SwingConstants.CENTER);
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+                                                       boolean hasFocus, int row, int column)
+        {
+            JLabel component = (JLabel)super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+
+            if(isSelected)
+            {
+                setBackground(table.getSelectionBackground());
+                setForeground(table.getSelectionForeground());
+            }
+            else
+            {
+                if(value instanceof BroadcastState)
+                {
+                    BroadcastState state = (BroadcastState)value;
+
+                    if(state == BroadcastState.CONNECTED)
+                    {
+                        setBackground(Color.GREEN);
+                        setForeground(table.getForeground());
+                    }
+                    else if(state == BroadcastState.DISABLED)
+                    {
+                        setBackground(table.getBackground());
+                        setForeground(Color.LIGHT_GRAY);
+                    }
+                    else if(state == BroadcastState.INVALID_SETTINGS)
+                    {
+                        setBackground(Color.YELLOW);
+                        setForeground(table.getForeground());
+                    }
+                    else if(state.isErrorState())
+                    {
+                        setBackground(Color.RED);
+                        setForeground(table.getForeground());
+                    }
+                    else
+                    {
+                        setBackground(table.getBackground());
+                        setForeground(table.getForeground());
+                    }
+                }
+                else
+                {
+                    setForeground(table.getForeground());
+                    setBackground(table.getBackground());
+                }
+            }
+
+            return this;
+        }
+    }
+}
diff --git a/src/controller/ControllerPanel.java b/src/controller/ControllerPanel.java
index 354025b7..9b3f6cd3 100644
--- a/src/controller/ControllerPanel.java
+++ b/src/controller/ControllerPanel.java
@@ -24,6 +24,7 @@ import audio.AudioManager;
 import audio.AudioPanel;
 import audio.broadcast.BroadcastModel;
 import audio.broadcast.BroadcastPanel;
+import audio.broadcast.BroadcastStatusPanel;
 import channel.metadata.ChannelMetadataViewer;
 import com.jidesoft.swing.JideTabbedPane;
 import controller.channel.ChannelController;
@@ -34,6 +35,7 @@ import icon.IconManager;
 import map.MapPanel;
 import map.MapService;
 import net.miginfocom.swing.MigLayout;
+import properties.SystemProperties;
 import settings.SettingsManager;
 import source.SourceManager;
 import source.tuner.TunerModel;
@@ -54,6 +56,7 @@ public class ControllerPanel extends JPanel
     private ChannelModel mChannelModel;
     private MapPanel mMapPanel;
     private TunerViewPanel mTunerManagerPanel;
+    private BroadcastModel mBroadcastModel;
 
     private JideTabbedPane mTabbedPane;
     protected JTable mChannelActivityTable = new JTable();
@@ -70,6 +73,7 @@ public class ControllerPanel extends JPanel
                            SourceManager sourceManager,
                            TunerModel tunerModel)
     {
+        mBroadcastModel = broadcastModel;
         mChannelModel = channelModel;
 
         mAudioPanel = new AudioPanel(iconManager, settingsManager, sourceManager, audioManager);
@@ -91,7 +95,7 @@ public class ControllerPanel extends JPanel
 
     private void init()
     {
-        setLayout(new MigLayout("insets 0 0 0 0 ", "[grow,fill]", "[]0[grow,fill]"));
+        setLayout(new MigLayout("insets 0 0 0 0 ", "[grow,fill]", "[]0[grow,fill]0[]"));
 
         add(mAudioPanel, "wrap");
 
@@ -109,6 +113,6 @@ public class ControllerPanel extends JPanel
         //Set preferred size to influence the split between these panels
         mTabbedPane.setPreferredSize(new Dimension(880, 500));
 
-        add(mTabbedPane);
+        add(mTabbedPane,"wrap");
     }
 }
diff --git a/src/controller/channel/ChannelModel.java b/src/controller/channel/ChannelModel.java
index 9efe8cc2..638c9a59 100644
--- a/src/controller/channel/ChannelModel.java
+++ b/src/controller/channel/ChannelModel.java
@@ -1,343 +1,343 @@
 /*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014-2016 Dennis Sheirer
- * 
- *     This program is free software: you can redistribute it and/or modify
- *     it under the terms of the GNU General Public License as published by
- *     the Free Software Foundation, either version 3 of the License, or
- *     (at your option) any later version.
- * 
- *     This program is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- * 
- *     You should have received a copy of the GNU General Public License
- *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * sdrtrunk
+ * Copyright (C) 2014-2017 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
  ******************************************************************************/
 package controller.channel;
 
+import controller.channel.Channel.ChannelType;
+import controller.channel.ChannelEvent.Event;
+import module.decode.DecoderType;
+
+import javax.swing.table.AbstractTableModel;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
-import javax.swing.table.AbstractTableModel;
-
-import module.decode.DecoderType;
-import controller.channel.Channel.ChannelType;
-import controller.channel.ChannelEvent.Event;
-
 /**
  * Channel Model
  */
 public class ChannelModel extends AbstractTableModel implements IChannelEventBroadcaster
 {
-	private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;
 
-	private List<Channel> mChannels = new CopyOnWriteArrayList<>();
-	private List<Channel> mTrafficChannels = new CopyOnWriteArrayList<>();
-	private List<ChannelEventListener> mListeners = new CopyOnWriteArrayList<>();
+    public static final int COLUMN_ENABLED = 0;
+    public static final int COLUMN_SYSTEM = 1;
+    public static final int COLUMN_SITE = 2;
+    public static final int COLUMN_NAME = 3;
+    public static final int COLUMN_ALIAS_LIST = 4;
+    public static final int COLUMN_SOURCE = 5;
+    public static final int COLUMN_DECODER = 6;
 
-	public ChannelModel()
-	{
-	}
+    private static final String[] COLUMN_NAMES = new String[] {"Enabled", "System", "Site", "Name", "Alias List",
+        "Source", "Decoder"};
 
-	/**
-	 * Unmodifiable list of non-traffic channels currently in the model
-	 */
-	public List<Channel> getChannels()
-	{
-		return Collections.unmodifiableList( mChannels );
-	}
-	
-	public Channel getChannelAtIndex( int row )
-	{
-		if( mChannels.size() >= row )
-		{
-			return mChannels.get( row );
-		}
-		
-		return null;
-	}
-	
-	/**
-	 * Returns a list of unique system values from across the channel set
-	 */
-	public List<String> getSystems()
-	{
-		List<String> systems = new ArrayList<>();
-		
-		for( Channel channel: mChannels )
-		{
-			if( channel.hasSystem() && !systems.contains( channel.getSystem() ) )
-			{
-				systems.add( channel.getSystem() );
-			}
-		}
-		
-		Collections.sort( systems );
-		
-		return systems;
-	}
-	
-	/**
-	 * Returns a list of unique site values for all channels that have a matching
-	 * system value
-	 */
-	public List<String> getSites( String system )
-	{
-		List<String> sites = new ArrayList<>();
+    private List<Channel> mChannels = new CopyOnWriteArrayList<>();
+    private List<Channel> mTrafficChannels = new CopyOnWriteArrayList<>();
+    private List<ChannelEventListener> mListeners = new CopyOnWriteArrayList<>();
 
-		if( system != null )
-		{
-			for( Channel channel: mChannels )
-			{
-				if( channel.hasSystem() && 
-					system.equals( channel.getSystem() ) &&
-					channel.hasSite() &&
-					!sites.contains( channel.getSite() ) )
-				{
-					sites.add( channel.getSite() );
-				}
-			}
-		}
+    public ChannelModel()
+    {
+    }
 
-		Collections.sort( sites );
-		
-		return sites;
-	}
+    /**
+     * Unmodifiable list of non-traffic channels currently in the model
+     */
+    public List<Channel> getChannels()
+    {
+        return Collections.unmodifiableList(mChannels);
+    }
 
-	/**
-	 * Broadcasts the channel event to all registered listeners
-	 */
-	@Override
-	public void broadcast( ChannelEvent event )
-	{
-		for( ChannelEventListener listener: mListeners )
-		{
-			listener.channelChanged( event );
-		}
-		
-		if( event.getChannel().getChannelType() == ChannelType.STANDARD )
-		{
-			switch( event.getEvent() )
-			{
-				case NOTIFICATION_CONFIGURATION_CHANGE:
-				case NOTIFICATION_PROCESSING_START:
-				case NOTIFICATION_PROCESSING_STOP:
-				case NOTIFICATION_SELECTION_CHANGE:
-					int index = mChannels.indexOf( event.getChannel() );
-					fireTableRowsUpdated( index, index );
-					break;
-				default:
-					break;
-			}
-		}
-		
-		if( event.getEvent() == Event.REQUEST_DELETE )
-		{
-			removeChannel( event.getChannel() );
-		}
-	}
+    public Channel getChannelAtIndex(int row)
+    {
+        if(row < mChannels.size())
+        {
+            return mChannels.get(row);
+        }
 
-	/**
-	 * Bulk loading of channel list.  Each channel is added and a channel add
-	 * event is broadcast.
-	 */
-	public void addChannels( List<Channel> channels )
-	{
-		for( Channel channel: channels )
-		{
-			addChannel( channel );
-		}
-	}
+        return null;
+    }
 
-	/**
-	 * Adds the channel to the model and broadcasts a channel add event
-	 */
-	public int addChannel( Channel channel )
-	{
-		int index = -1;
-		
-		switch( channel.getChannelType() )
-		{
-			case STANDARD:
-				mChannels.add( channel );
-				
-				index = mChannels.size() - 1;
-				
-				fireTableRowsInserted( index, index );
-				break;
-			case TRAFFIC:
-				mTrafficChannels.add( channel );
-				index = mChannels.size() - 1;
-				break;
-			default:
-				break;
-		}
-		
-		broadcast( new ChannelEvent( channel, Event.NOTIFICATION_ADD ) );
-		
-		if( channel.getEnabled() )
-		{
-			broadcast( new ChannelEvent( channel, Event.REQUEST_ENABLE ) );
-		}
-		
-		return index;
-	}
-	
-	/**
-	 * Removes the channel from the model and broadcasts a channel remove event
-	 */
-	public void removeChannel( Channel channel )
-	{
-		if( channel != null )
-		{
-			switch( channel.getChannelType() )
-			{
-				case STANDARD:
-					int index = mChannels.indexOf( channel );
-					
-					mChannels.remove( channel );
+    /**
+     * Returns a list of unique system values from across the channel set
+     */
+    public List<String> getSystems()
+    {
+        List<String> systems = new ArrayList<>();
 
-					if( index >= 0 )
-					{
-						fireTableRowsDeleted( index, index );
-					}
-					break;
-				case TRAFFIC:
-					mTrafficChannels.remove( channel );
-					break;
-				default:
-					break;
-			}
-			
-			broadcast( new ChannelEvent( channel, Event.NOTIFICATION_DELETE ) );
-		}
-	}
+        for(Channel channel : mChannels)
+        {
+            if(channel.hasSystem() && !systems.contains(channel.getSystem()))
+            {
+                systems.add(channel.getSystem());
+            }
+        }
 
-	/**
-	 * Returns a list of channels that fall within the frequency range
-	 * 
-	 * @param start frequency of the range
-	 * @param stop frequency of the range
-	 * 
-	 * @return list of channels or an empty list if none fall within the range
-	 */
-	public List<Channel> getChannelsInFrequencyRange( long start, long stop )
-	{
-		List<Channel> channels = new ArrayList<>();
-		
-		for( Channel channel: mChannels )
-		{
-			if( channel.isWithin( start, stop ) )
-			{
-				channels.add( channel );
-			}
-		}
-		
-		for( Channel channel: mTrafficChannels )
-		{
-			if( channel.isWithin( start, stop ) )
-			{
-				channels.add( channel );
-			}
-		}
-		
-		return channels;
-	}
-	
-	public void addListener( ChannelEventListener listener )
-	{
-		mListeners.add( listener );
-	}
-	
-	public void removeListener( ChannelEventListener listener )
-	{
-		mListeners.remove( listener );
-	}
+        Collections.sort(systems);
 
-	//Table Model Interface Methods - standard channels only
-	@Override
-	public int getRowCount()
-	{
-		return mChannels.size();
-	}
+        return systems;
+    }
 
-	@Override
-	public int getColumnCount()
-	{
-		return 6;
-	}
+    /**
+     * Returns a list of unique site values for all channels that have a matching
+     * system value
+     */
+    public List<String> getSites(String system)
+    {
+        List<String> sites = new ArrayList<>();
 
-	@Override
-	public String getColumnName( int columnIndex )
-	{
-		switch( columnIndex )
-		{
-			case 0:
-				return "System";
-			case 1:
-				return "Site";
-			case 2:
-				return "Name";
-			case 3:
-				return "Alias List";
-			case 4:
-				return "Source";
-			case 5:
-				return "Decoder";
-		}
-		
-		return null;
-	}
+        if(system != null)
+        {
+            for(Channel channel : mChannels)
+            {
+                if(channel.hasSystem() &&
+                    system.equals(channel.getSystem()) &&
+                    channel.hasSite() &&
+                    !sites.contains(channel.getSite()))
+                {
+                    sites.add(channel.getSite());
+                }
+            }
+        }
 
-	@Override
-	public Class<?> getColumnClass( int columnIndex )
-	{
-		return String.class;
-	}
+        Collections.sort(sites);
 
-	@Override
-	public boolean isCellEditable( int rowIndex, int columnIndex )
-	{
-		return false;
-	}
+        return sites;
+    }
 
-	@Override
-	public Object getValueAt( int rowIndex, int columnIndex )
-	{
-		Channel channel = mChannels.get( rowIndex );
-		
-		switch( columnIndex )
-		{
-			case 0:
-				return channel.getSystem();
-			case 1:
-				return channel.getSite();
-			case 2:
-				return channel.getName();
-			case 3:
-				return channel.getAliasListName();
-			case 4:
-				return channel.getSourceConfiguration().getDescription();
-			case 5:
-				return channel.getDecodeConfiguration()
-							.getDecoderType().getShortDisplayString();
-		}
-		
-		return null;
-	}
+    /**
+     * Broadcasts the channel event to all registered listeners
+     */
+    @Override
+    public void broadcast(ChannelEvent event)
+    {
+        for(ChannelEventListener listener : mListeners)
+        {
+            listener.channelChanged(event);
+        }
 
-	@Override
-	public void setValueAt( Object aValue, int rowIndex, int columnIndex )
-	{
-		throw new IllegalArgumentException( "Not yet implemented" );
-	}
-	
-	public void createChannel( DecoderType decoderType, long frequency )
-	{
-		throw new UnsupportedOperationException( "Not yet implemented" );
-	}
+        if(event.getChannel().getChannelType() == ChannelType.STANDARD)
+        {
+            switch(event.getEvent())
+            {
+                case NOTIFICATION_CONFIGURATION_CHANGE:
+                case NOTIFICATION_PROCESSING_START:
+                case NOTIFICATION_PROCESSING_STOP:
+                case NOTIFICATION_SELECTION_CHANGE:
+                    int index = mChannels.indexOf(event.getChannel());
+                    fireTableRowsUpdated(index, index);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        if(event.getEvent() == Event.REQUEST_DELETE)
+        {
+            removeChannel(event.getChannel());
+        }
+    }
+
+    /**
+     * Bulk loading of channel list.  Each channel is added and a channel add
+     * event is broadcast.
+     */
+    public void addChannels(List<Channel> channels)
+    {
+        for(Channel channel : channels)
+        {
+            addChannel(channel);
+        }
+    }
+
+    /**
+     * Adds the channel to the model and broadcasts a channel add event
+     */
+    public int addChannel(Channel channel)
+    {
+        int index = -1;
+
+        switch(channel.getChannelType())
+        {
+            case STANDARD:
+                mChannels.add(channel);
+
+                index = mChannels.size() - 1;
+
+                fireTableRowsInserted(index, index);
+                break;
+            case TRAFFIC:
+                mTrafficChannels.add(channel);
+                index = mChannels.size() - 1;
+                break;
+            default:
+                break;
+        }
+
+        broadcast(new ChannelEvent(channel, Event.NOTIFICATION_ADD));
+
+        if(channel.getEnabled())
+        {
+            broadcast(new ChannelEvent(channel, Event.REQUEST_ENABLE));
+        }
+
+        return index;
+    }
+
+    /**
+     * Removes the channel from the model and broadcasts a channel remove event
+     */
+    public void removeChannel(Channel channel)
+    {
+        if(channel != null)
+        {
+            switch(channel.getChannelType())
+            {
+                case STANDARD:
+                    int index = mChannels.indexOf(channel);
+
+                    mChannels.remove(channel);
+
+                    if(index >= 0)
+                    {
+                        fireTableRowsDeleted(index, index);
+                    }
+                    break;
+                case TRAFFIC:
+                    mTrafficChannels.remove(channel);
+                    break;
+                default:
+                    break;
+            }
+
+            broadcast(new ChannelEvent(channel, Event.NOTIFICATION_DELETE));
+        }
+    }
+
+    /**
+     * Returns a list of channels that fall within the frequency range
+     *
+     * @param start frequency of the range
+     * @param stop frequency of the range
+     * @return list of channels or an empty list if none fall within the range
+     */
+    public List<Channel> getChannelsInFrequencyRange(long start, long stop)
+    {
+        List<Channel> channels = new ArrayList<>();
+
+        for(Channel channel : mChannels)
+        {
+            if(channel.isWithin(start, stop))
+            {
+                channels.add(channel);
+            }
+        }
+
+        for(Channel channel : mTrafficChannels)
+        {
+            if(channel.isWithin(start, stop))
+            {
+                channels.add(channel);
+            }
+        }
+
+        return channels;
+    }
+
+    public void addListener(ChannelEventListener listener)
+    {
+        mListeners.add(listener);
+    }
+
+    public void removeListener(ChannelEventListener listener)
+    {
+        mListeners.remove(listener);
+    }
+
+    //Table Model Interface Methods - standard channels only
+    @Override
+    public int getRowCount()
+    {
+        return mChannels.size();
+    }
+
+    @Override
+    public int getColumnCount()
+    {
+        return COLUMN_NAMES.length;
+    }
+
+    @Override
+    public String getColumnName(int columnIndex)
+    {
+        if(columnIndex < COLUMN_NAMES.length)
+        {
+            return COLUMN_NAMES[columnIndex];
+        }
+
+        return null;
+    }
+
+    @Override
+    public Class<?> getColumnClass(int columnIndex)
+    {
+        return String.class;
+    }
+
+    @Override
+    public boolean isCellEditable(int rowIndex, int columnIndex)
+    {
+        return false;
+    }
+
+    @Override
+    public Object getValueAt(int rowIndex, int columnIndex)
+    {
+        Channel channel = mChannels.get(rowIndex);
+
+        switch(columnIndex)
+        {
+            case COLUMN_ENABLED:
+                return channel.getEnabled() ? "Enabled" : null;
+            case COLUMN_SYSTEM:
+                return channel.getSystem();
+            case COLUMN_SITE:
+                return channel.getSite();
+            case COLUMN_NAME:
+                return channel.getName();
+            case COLUMN_ALIAS_LIST:
+                return channel.getAliasListName();
+            case COLUMN_SOURCE:
+                return channel.getSourceConfiguration().getDescription();
+            case COLUMN_DECODER:
+                return channel.getDecodeConfiguration().getDecoderType().getShortDisplayString();
+        }
+
+        return null;
+    }
+
+    @Override
+    public void setValueAt(Object aValue, int rowIndex, int columnIndex)
+    {
+        throw new IllegalArgumentException("Not yet implemented");
+    }
+
+    public void createChannel(DecoderType decoderType, long frequency)
+    {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
 }
diff --git a/src/gui/SDRTrunk.java b/src/gui/SDRTrunk.java
index 6844986e..cb056047 100644
--- a/src/gui/SDRTrunk.java
+++ b/src/gui/SDRTrunk.java
@@ -21,6 +21,7 @@ import alias.AliasModel;
 import alias.action.AliasActionManager;
 import audio.AudioManager;
 import audio.broadcast.BroadcastModel;
+import audio.broadcast.BroadcastStatusPanel;
 import com.jidesoft.swing.JideSplitPane;
 import controller.ControllerPanel;
 import controller.ThreadPoolManager;
@@ -65,12 +66,17 @@ import java.util.concurrent.TimeUnit;
 public class SDRTrunk implements Listener<TunerEvent>
 {
     private final static Logger mLog = LoggerFactory.getLogger(SDRTrunk.class);
+    private static final String PROPERTY_BROADCAST_STATUS_VISIBLE = "main.broadcast.status.visible";
+    private boolean mBroadcastStatusVisible;
 
     private IconManager mIconManager;
+    private BroadcastStatusPanel mBroadcastStatusPanel;
+    private BroadcastModel mBroadcastModel;
     private ControllerPanel mControllerPanel;
     private SettingsManager mSettingsManager;
     private SpectralDisplayPanel mSpectralPanel;
     private JFrame mMainGui = new JFrame();
+    private JideSplitPane mSplitPane;
 
     private String mTitle;
 
@@ -139,14 +145,14 @@ public class SDRTrunk implements Listener<TunerEvent>
         AudioManager audioManager = new AudioManager(threadPoolManager, sourceManager.getMixerManager());
         channelProcessingManager.addAudioPacketListener(audioManager);
 
-        BroadcastModel broadcastModel = new BroadcastModel(threadPoolManager, mIconManager);
+        mBroadcastModel = new BroadcastModel(threadPoolManager, mIconManager);
 
-        channelProcessingManager.addAudioPacketListener(broadcastModel);
+        channelProcessingManager.addAudioPacketListener(mBroadcastModel);
 
         MapService mapService = new MapService(mIconManager);
         channelProcessingManager.addMessageListener(mapService);
 
-        mControllerPanel = new ControllerPanel(audioManager, aliasModel, broadcastModel,
+        mControllerPanel = new ControllerPanel(audioManager, aliasModel, mBroadcastModel,
                 channelModel, channelMapModel, channelProcessingManager, mIconManager,
                 mapService, mSettingsManager, sourceManager, tunerModel);
 
@@ -160,7 +166,7 @@ public class SDRTrunk implements Listener<TunerEvent>
         tunerModel.addListener(this);
 
         PlaylistManager playlistManager = new PlaylistManager(threadPoolManager,
-                aliasModel, broadcastModel, channelModel, channelMapModel);
+                aliasModel, mBroadcastModel, channelModel, channelMapModel);
 
         playlistManager.init();
 
@@ -209,9 +215,7 @@ public class SDRTrunk implements Listener<TunerEvent>
      */
     private void initGUI()
     {
-        mMainGui.setLayout(new MigLayout("insets 0 0 0 0 ",
-                "[grow,fill]",
-                "[grow,fill]"));
+        mMainGui.setLayout(new MigLayout("insets 0 0 0 0 ", "[grow,fill]", "[grow,fill]"));
 
         /**
          * Setup main JFrame window
@@ -225,12 +229,20 @@ public class SDRTrunk implements Listener<TunerEvent>
         mSpectralPanel.setPreferredSize(new Dimension(1280, 300));
         mControllerPanel.setPreferredSize(new Dimension(1280, 500));
 
-        JideSplitPane splitPane = new JideSplitPane(JideSplitPane.VERTICAL_SPLIT);
-        splitPane.setDividerSize(5);
-        splitPane.add(mSpectralPanel);
-        splitPane.add(mControllerPanel);
+        mSplitPane = new JideSplitPane(JideSplitPane.VERTICAL_SPLIT);
+        mSplitPane.setDividerSize(5);
+        mSplitPane.add(mSpectralPanel);
+        mSplitPane.add(mControllerPanel);
 
-        mMainGui.add(splitPane, "cell 0 0,span,grow");
+        mBroadcastStatusVisible = SystemProperties.getInstance().get(PROPERTY_BROADCAST_STATUS_VISIBLE, false);
+
+        //Show broadcast status panel when user requests - disabled by default
+        if(mBroadcastStatusVisible)
+        {
+            mSplitPane.add(getBroadcastStatusPanel());
+        }
+
+        mMainGui.add(mSplitPane, "cell 0 0,span,grow");
 
         /**
          * Menu items
@@ -291,6 +303,12 @@ public class SDRTrunk implements Listener<TunerEvent>
 
         fileMenu.add(exitMenu);
 
+        JMenu viewMenu = new JMenu("View");
+
+        viewMenu.add(new BroadcastStatusVisibleMenuItem(mControllerPanel));
+
+        menuBar.add(viewMenu);
+
         JMenuItem screenCaptureItem = new JMenuItem("Screen Capture");
 
         screenCaptureItem.setMnemonic(KeyEvent.VK_C);
@@ -360,6 +378,50 @@ public class SDRTrunk implements Listener<TunerEvent>
         menuBar.add(screenCaptureItem);
     }
 
+    /**
+     * Lazy constructor for broadcast status panel
+     */
+    private BroadcastStatusPanel getBroadcastStatusPanel()
+    {
+        if(mBroadcastStatusPanel == null)
+        {
+            mBroadcastStatusPanel = new BroadcastStatusPanel(mBroadcastModel);
+            mBroadcastStatusPanel.setPreferredSize(new Dimension(880, 100));
+            mBroadcastStatusPanel.getTable().setEnabled(false);
+        }
+
+        return mBroadcastStatusPanel;
+    }
+
+    /**
+     * Toggles visibility of the broadcast channels status panel at the bottom of the controller panel
+     */
+    private void toggleBroadcastStatusPanelVisibility()
+    {
+        mBroadcastStatusVisible = !mBroadcastStatusVisible;
+
+        EventQueue.invokeLater(new Runnable()
+        {
+            @Override
+            public void run()
+            {
+                if(mBroadcastStatusVisible)
+                {
+                    mSplitPane.add(getBroadcastStatusPanel());
+                }
+                else
+                {
+                    mSplitPane.remove(getBroadcastStatusPanel());
+                }
+
+                mMainGui.revalidate();
+            }
+        });
+
+        SystemProperties.getInstance().set(PROPERTY_BROADCAST_STATUS_VISIBLE, mBroadcastStatusVisible);
+    }
+
+
     /**
      * Loads the application properties file from the user's home directory,
      * creating the properties file for the first-time, if necessary
@@ -435,4 +497,28 @@ public class SDRTrunk implements Listener<TunerEvent>
             mMainGui.setTitle(mTitle + " - " + event.getTuner().getName());
         }
     }
+
+    public class BroadcastStatusVisibleMenuItem extends JCheckBoxMenuItem
+    {
+        private ControllerPanel mControllerPanel;
+
+        public BroadcastStatusVisibleMenuItem(ControllerPanel controllerPanel)
+        {
+            super("Show Streaming Status");
+
+            mControllerPanel = controllerPanel;
+
+            setSelected(mBroadcastStatusPanel != null);
+
+            addActionListener(new ActionListener()
+            {
+                @Override
+                public void actionPerformed(ActionEvent e)
+                {
+                    toggleBroadcastStatusPanelVisibility();
+                    setSelected(mBroadcastStatusVisible);
+                }
+            });
+        }
+    }
 }
diff --git a/src/properties/SystemProperties.java b/src/properties/SystemProperties.java
index e717aa61..aea40331 100644
--- a/src/properties/SystemProperties.java
+++ b/src/properties/SystemProperties.java
@@ -1,19 +1,20 @@
 /*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014 Dennis Sheirer
+ * sdrtrunk
+ * Copyright (C) 2014-2017 Dennis Sheirer
  *
- *     This program is free software: you can redistribute it and/or modify
- *     it under the terms of the GNU General Public License as published by
- *     the Free Software Foundation, either version 3 of the License, or
- *     (at your option) any later version.
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *     This program is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
  *
- *     You should have received a copy of the GNU General Public License
- *     along with this program.  If not, see <http://www.gnu.org/licenses/>
  ******************************************************************************/
 package properties;
 
@@ -33,24 +34,27 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Properties;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
- * SystemProperties - provides an isolated instance of properties for the
- * application
+ * SystemProperties - provides an isolated instance of properties for the application
  */
-
 public class SystemProperties
 {
-    private final static Logger mLog =
-        LoggerFactory.getLogger(SystemProperties.class);
+    private final static Logger mLog = LoggerFactory.getLogger(SystemProperties.class);
 
-    private static String sDEFAULT_APP_ROOT = "SDRTrunk";
-    private static String sPROPERTIES_FILENAME = "SDRTrunk.properties";
+    private static String DEFAULT_APP_ROOT = "SDRTrunk";
+    private static String PROPERTIES_FILENAME = "SDRTrunk.properties";
 
-    private static SystemProperties mInstance;
+    private static SystemProperties INSTANCE;
     private static Properties mProperties;
     private Path mPropertiesPath;
     private String mApplicationName;
+    private AtomicBoolean mSavePending = new AtomicBoolean();
+    private ScheduledExecutorService mScheduledExecutorService;
 
     private SystemProperties()
     {
@@ -64,50 +68,27 @@ public class SystemProperties
      */
     public static SystemProperties getInstance()
     {
-        if(mInstance == null)
+        if(INSTANCE == null)
         {
-            mInstance = new SystemProperties();
+            INSTANCE = new SystemProperties();
         }
 
-        return mInstance;
+        return INSTANCE;
     }
 
     /**
      * Saves any currently changed settings to the application properties file
      */
-    public void save()
+    private void save()
     {
-        Path propsPath =
-            getApplicationRootPath().resolve(sPROPERTIES_FILENAME);
-
-        OutputStream out = null;
-
-        try
+        if(mSavePending.compareAndSet(false, true))
         {
-            out = new FileOutputStream(propsPath.toString());
-
-            String comments =
-                "SDRTrunk - SDR Trunking Decoder Application Settings";
-
-            mProperties.store(out, comments);
-        }
-        catch(Exception e)
-        {
-            mLog.error("SystemProperties - exception while saving " +
-                "application properties", e);
-        }
-        finally
-        {
-            if(out != null)
+            if(mScheduledExecutorService == null)
             {
-                try
-                {
-                    out.close();
-                }
-                catch(IOException e)
-                {
-                }
+                mScheduledExecutorService = Executors.newScheduledThreadPool(1);
             }
+
+            mScheduledExecutorService.schedule(new SavePropertiesTask(), 2, TimeUnit.SECONDS);
         }
     }
 
@@ -120,12 +101,12 @@ public class SystemProperties
     {
         Path retVal = null;
 
-        String root = get("root.directory", sDEFAULT_APP_ROOT);
+        String root = get("root.directory", DEFAULT_APP_ROOT);
 
-        if(root.equalsIgnoreCase(sDEFAULT_APP_ROOT))
+        if(root.equalsIgnoreCase(DEFAULT_APP_ROOT))
         {
             retVal = Paths.get(
-                System.getProperty("user.home"), sDEFAULT_APP_ROOT);
+                System.getProperty("user.home"), DEFAULT_APP_ROOT);
         }
         else
         {
@@ -147,8 +128,7 @@ public class SystemProperties
             }
             catch(IOException e)
             {
-                mLog.error("SystemProperties - exception while creating " +
-                    "app folder [" + folder + "]", e);
+                mLog.error("SystemProperties - exception while creating app folder [" + folder + "]", e);
             }
         }
 
@@ -169,8 +149,6 @@ public class SystemProperties
 
     /**
      * Loads the properties file into this properties set
-     *
-     * @param file
      */
     public void load(Path propertiesPath)
     {
@@ -178,44 +156,20 @@ public class SystemProperties
         {
             mPropertiesPath = propertiesPath;
 
-            InputStream in = null;
-
-            try
+            if(Files.exists(mPropertiesPath))
             {
-                in = new FileInputStream(propertiesPath.toString());
-            }
-            catch(FileNotFoundException e)
-            {
-                mLog.error("SDRTrunk - exception while opening inputstream on " +
-                    "application properties file", e);
-            }
-
-            if(in != null)
-            {
-                try
+                try(InputStream in = new FileInputStream(propertiesPath.toString()))
                 {
                     mProperties.load(in);
                 }
-                catch(IOException e)
+                catch(IOException ioe)
                 {
-                    mLog.error("SDRTrunk - exception while loading properties " +
-                        "inputstream into SystemProperties", e);
-                }
-                finally
-                {
-                    try
-                    {
-                        in.close();
-                    }
-                    catch(IOException e)
-                    {
-                    }
+                    mLog.error("Error loading system properties file", ioe.getMessage());
                 }
             }
         }
 
-        mLog.info("SystemProperties - loaded [" +
-            propertiesPath.toString() + "]");
+        mLog.info("SystemProperties - loaded [" + propertiesPath.toString() + "]");
     }
 
     public String getApplicationName()
@@ -339,6 +293,22 @@ public class SystemProperties
         save();
     }
 
+    /**
+     * Sets (overrides) the property key with the new boolean value
+     */
+    public void set(String key, boolean value)
+    {
+        set(key, String.valueOf(value));
+    }
+
+    /**
+     * Sets (overrides) the property key with the new integer value
+     */
+    public void set(String key, int value)
+    {
+        set(key, String.valueOf(value));
+    }
+
     /**
      * Gets the named color property, storing the default value in properties file if it doesn't exist.
      *
@@ -362,4 +332,25 @@ public class SystemProperties
         return new Color(color.getRed(), color.getGreen(), color.getBlue(), alpha);
     }
 
+    public class SavePropertiesTask implements Runnable
+    {
+        @Override
+        public void run()
+        {
+            if(mSavePending.compareAndSet(true, false))
+            {
+                Path propsPath = getApplicationRootPath().resolve(PROPERTIES_FILENAME);
+
+                try(OutputStream out = new FileOutputStream(propsPath.toString()))
+                {
+                    String comments = "SDRTrunk - SDR Trunking Decoder Application Settings";
+                    mProperties.store(out, comments);
+                }
+                catch(IOException ioe)
+                {
+                    mLog.error("Error saving system properties file [" + propsPath.toString() + "]", ioe);
+                }
+            }
+        }
+    }
 }
diff --git a/src/spectrum/DFTProcessor.java b/src/spectrum/DFTProcessor.java
index a90c432d..68611fdd 100644
--- a/src/spectrum/DFTProcessor.java
+++ b/src/spectrum/DFTProcessor.java
@@ -1,22 +1,38 @@
 /*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014,2015 Dennis Sheirer
- * 
- *     This program is free software: you can redistribute it and/or modify
- *     it under the terms of the GNU General Public License as published by
- *     the Free Software Foundation, either version 3 of the License, or
- *     (at your option) any later version.
- * 
- *     This program is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- * 
- *     You should have received a copy of the GNU General Public License
- *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * sdrtrunk
+ * Copyright (C) 2014-2017 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
  ******************************************************************************/
 package spectrum;
 
+import controller.NamingThreadFactory;
+import dsp.filter.Window;
+import dsp.filter.Window.WindowType;
+import org.jtransforms.fft.FloatFFT_1D;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import properties.SystemProperties;
+import sample.Buffer;
+import sample.Listener;
+import sample.SampleType;
+import sample.complex.ComplexBuffer;
+import source.tuner.frequency.FrequencyChangeEvent;
+import source.tuner.frequency.IFrequencyChangeProcessor;
+import spectrum.converter.DFTResultsConverter;
+
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.concurrent.ArrayBlockingQueue;
@@ -27,491 +43,460 @@ import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import org.jtransforms.fft.FloatFFT_1D;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import properties.SystemProperties;
-import sample.Buffer;
-import sample.Listener;
-import sample.SampleType;
-import sample.complex.ComplexBuffer;
-import source.tuner.frequency.FrequencyChangeEvent;
-import source.tuner.frequency.IFrequencyChangeProcessor;
-import spectrum.converter.DFTResultsConverter;
-import controller.NamingThreadFactory;
-import dsp.filter.Window;
-import dsp.filter.Window.WindowType;
-
 /**
  * Processes both complex samples or float samples and dispatches a float array
- * of DFT results, using configurable fft size and output dispatch timelines.  
+ * of DFT results, using configurable fft size and output dispatch timelines.
  */
-public class DFTProcessor implements Listener<ComplexBuffer>, 
-									 IFrequencyChangeProcessor,
-									 IDFTWidthChangeProcessor
+public class DFTProcessor implements Listener<ComplexBuffer>, IFrequencyChangeProcessor, IDFTWidthChangeProcessor
 {
-	private final static Logger mLog = 
-			LoggerFactory.getLogger( DFTProcessor.class );
+    private final static Logger mLog = LoggerFactory.getLogger(DFTProcessor.class);
 
-	private CopyOnWriteArrayList<DFTResultsConverter> mListeners =
-			new CopyOnWriteArrayList<DFTResultsConverter>();
+    private CopyOnWriteArrayList<DFTResultsConverter> mListeners = new CopyOnWriteArrayList<DFTResultsConverter>();
 
-	//Fixed size sample queue.  We set the size at 12 based on the highest
-	//sample rate tuner (10 MHz) producing 153 frames per second and the lowest
-	//DFT processing frame rate of 12 frames per second.  This means that the 
-	//maximum size needed is 153 / 12 = 11 frames per DFT processing iteration
-	//so we set it at 12.	
-	private BlockingQueue<ComplexBuffer> mQueue = new ArrayBlockingQueue<>( 12 );
+    //Fixed size sample queue.  We set the size at 12 based on the highest
+    //sample rate tuner (10 MHz) producing 153 frames per second and the lowest
+    //DFT processing frame rate of 12 frames per second.  This means that the
+    //maximum size needed is 153 / 12 = 11 frames per DFT processing iteration
+    //so we set it at 12.
+    private BlockingQueue<ComplexBuffer> mQueue = new ArrayBlockingQueue<>(12);
 
-	private ScheduledExecutorService mScheduler = Executors
-			.newScheduledThreadPool( 1, new NamingThreadFactory( "spectrum dft" ) );	
-	
-	public static final String FRAME_RATE_PROPERTY = "spectral.display.frame.rate";
-	
-	private DFTSize mDFTSize = DFTSize.FFT04096;
-	private DFTSize mNewDFTSize = DFTSize.FFT04096;
-	
-	private double[] mWindow;
-	
-	/* The Cosine and Hanning windows seem to offer the best spectral display
-	 * with minimal bin leakage/smearing */
-	private WindowType mWindowType = Window.WindowType.HANNING;
+    private ScheduledExecutorService mScheduler = Executors
+        .newScheduledThreadPool(1, new NamingThreadFactory("spectrum dft processor"));
 
-	private FloatFFT_1D mFFT = new FloatFFT_1D( mDFTSize.getSize() );
-	
-	private int mFrameRate;
-	private int mSampleRate;
-	private int mFFTFloatsPerFrame;
-	private float mNewFloatsPerFrame;
-	private float mNewFloatResidual;
-	private float[] mPreviousFrame = new float[ 8192 ];
-	
-	private float[] mCurrentBuffer;
-	private int mCurrentBufferPointer = 0;
-	
-	private SampleType mSampleType;
+    public static final String FRAME_RATE_PROPERTY = "spectral.display.frame.rate";
 
-	private AtomicBoolean mRunning = new AtomicBoolean();
-	
-	public DFTProcessor( SampleType sampleType )
-	{
-		setSampleType( sampleType );
-		setFrameRate( 20 );
-		
-		loadSettings();
-	}
-	
-	private void loadSettings()
-	{
-		int frameRate = SystemProperties.getInstance().get( FRAME_RATE_PROPERTY, 20 );
-		
-		setFrameRate( frameRate );
-	}
-	
-	public void dispose()
-	{
-		stop();
-		
-		mListeners.clear();
-		mQueue.clear();
-		mWindow = null;
-		mCurrentBuffer = null;
-	}
-	
-	public WindowType getWindowType()
-	{
-		return mWindowType;
-	}
-	
-	public void setWindowType( WindowType windowType )
-	{
-		mWindowType = windowType;
-		
-		if( mSampleType == SampleType.COMPLEX )
-		{
-			mWindow = Window.getWindow( mWindowType, 
-										mDFTSize.getSize() * 2 );		
-		}
-		else
-		{
-			mWindow = Window.getWindow( mWindowType,
-										mDFTSize.getSize() );		
-		}
-	}
-	
-	/**
-	 * Sets the processor mode to Float or Complex, depending on the sample
-	 * types that will be delivered for processing
-	 */
-	public void setSampleType( SampleType type )
-	{
-		mSampleType = type;
-		setWindowType( mWindowType );
-	}
-	
-	public SampleType getSampleType()
-	{
-		return mSampleType;
-	}
+    private DFTSize mDFTSize = DFTSize.FFT04096;
+    private DFTSize mNewDFTSize = DFTSize.FFT04096;
 
-	/**
-	 * Queues an FFT size change request.  The scheduled executor will apply 
-	 * the change when it runs.
-	 */
-	public void setDFTSize( DFTSize size )
-	{
-		mNewDFTSize = size;
-	}
-	
-	public DFTSize getDFTSize()
-	{
-		return mDFTSize;
-	}
-	
-	public int getFrameRate()
-	{
-		return mFrameRate;
-	}
-	
-	public void setFrameRate( int framesPerSecond )
-	{
-		//TODO: make sure frame rate & sample rate sample requirement doesn't
-		//expect overlap greater than the previous frame length
-		
-		if( framesPerSecond < 1 || framesPerSecond > 1000 )
-		{
-			throw new IllegalArgumentException( "DFTProcessor cannot run "
-			+ "more than 1000 times per second -- requested setting:" 
-					+ framesPerSecond );
-		}
+    private double[] mWindow;
 
-		mFrameRate = framesPerSecond;
-		
-		SystemProperties properties = SystemProperties.getInstance();
-		
-		properties.set( FRAME_RATE_PROPERTY, String.valueOf( mFrameRate ) );
+    /* The Cosine and Hanning windows seem to offer the best spectral display
+     * with minimal bin leakage/smearing */
+    private WindowType mWindowType = Window.WindowType.HANNING;
 
-		calculateConsumptionRate();
+    private FloatFFT_1D mFFT = new FloatFFT_1D(mDFTSize.getSize());
 
-		restart();
-	}
-	
-	public void start()
-	{
-		/**
+    private int mFrameRate;
+    private int mSampleRate;
+    private int mFFTFloatsPerFrame;
+    private float mNewFloatsPerFrame;
+    private float mNewFloatResidual;
+    private float[] mPreviousFrame = new float[8192];
+
+    private float[] mCurrentBuffer;
+    private int mCurrentBufferPointer = 0;
+
+    private SampleType mSampleType;
+
+    private AtomicBoolean mRunning = new AtomicBoolean();
+
+    public DFTProcessor(SampleType sampleType)
+    {
+        setSampleType(sampleType);
+        mFrameRate = SystemProperties.getInstance().get(FRAME_RATE_PROPERTY, 20);
+        calculateConsumptionRate();
+        start();
+    }
+
+    public void dispose()
+    {
+        stop();
+
+        mListeners.clear();
+        mQueue.clear();
+        mWindow = null;
+        mCurrentBuffer = null;
+    }
+
+    public WindowType getWindowType()
+    {
+        return mWindowType;
+    }
+
+    public void setWindowType(WindowType windowType)
+    {
+        mWindowType = windowType;
+
+        if(mSampleType == SampleType.COMPLEX)
+        {
+            mWindow = Window.getWindow(mWindowType, mDFTSize.getSize() * 2);
+        }
+        else
+        {
+            mWindow = Window.getWindow(mWindowType, mDFTSize.getSize());
+        }
+    }
+
+    /**
+     * Sets the processor mode to Float or Complex, depending on the sample
+     * types that will be delivered for processing
+     */
+    public void setSampleType(SampleType type)
+    {
+        mSampleType = type;
+        setWindowType(mWindowType);
+    }
+
+    public SampleType getSampleType()
+    {
+        return mSampleType;
+    }
+
+    /**
+     * Queues an FFT size change request.  The scheduled executor will apply
+     * the change when it runs.
+     */
+    public void setDFTSize(DFTSize size)
+    {
+        mNewDFTSize = size;
+    }
+
+    public DFTSize getDFTSize()
+    {
+        return mDFTSize;
+    }
+
+    public int getFrameRate()
+    {
+        return mFrameRate;
+    }
+
+    public void setFrameRate(int framesPerSecond)
+    {
+        //TODO: make sure frame rate & sample rate sample requirement doesn't
+        //expect overlap greater than the previous frame length
+
+        if(framesPerSecond < 1 || framesPerSecond > 1000)
+        {
+            throw new IllegalArgumentException("DFTProcessor cannot run "
+                + "more than 1000 times per second -- requested setting:"
+                + framesPerSecond);
+        }
+
+        mFrameRate = framesPerSecond;
+
+        SystemProperties.getInstance().set(FRAME_RATE_PROPERTY, mFrameRate);
+
+        calculateConsumptionRate();
+
+        restart();
+    }
+
+    public void start()
+    {
+        /**
          * Reset the scheduler
          */
-		mScheduler = Executors.newScheduledThreadPool( 1, new NamingThreadFactory( "spectrum dft" ) );
+        mScheduler = Executors.newScheduledThreadPool(1, new NamingThreadFactory("spectrum dft"));
 
-		/**
-		 * Schedule the DFT to run calculations at a fixed rate
-		 */
-		int initialDelay = 0;
-		int period = (int)( 1000 / mFrameRate );
-		TimeUnit unit = TimeUnit.MILLISECONDS;
+        /**
+         * Schedule the DFT to run calculations at a fixed rate
+         */
+        int initialDelay = 0;
+        int period = (int) (1000 / mFrameRate);
+        TimeUnit unit = TimeUnit.MILLISECONDS;
 
-		mScheduler.scheduleAtFixedRate( new DFTCalculationTask(), 
-											initialDelay, period, unit );
-	}
-	
-	public void stop()
-	{
-		/**
-		 * Shutdown the scheduler and clear out any remaining tasks
-		 */
+        mScheduler.scheduleAtFixedRate(new DFTCalculationTask(),
+            initialDelay, period, unit);
+    }
+
+    public void stop()
+    {
+        /**
+         * Shutdown the scheduler and clear out any remaining tasks
+         */
         try
         {
-    		mScheduler.shutdown();
+            mScheduler.shutdown();
 
-            mScheduler.awaitTermination( 100, TimeUnit.MILLISECONDS );
+            mScheduler.awaitTermination(100, TimeUnit.MILLISECONDS);
         }
-        catch ( InterruptedException e )
+        catch(InterruptedException e)
         {
-        	/* Do nothing ... we're shutting down */
+            /* Do nothing ... we're shutting down */
 //	        mLog.error( "DFTProcessor - exception while awaiting shutdown of "
 //	        		+ "calculation scheduler for reset", e );
         }
-	}
-	
-	public void restart()
-	{
-		stop();
-		start();
-	}
-	
-	public int getCalculationsPerSecond()
-	{
-		return mFrameRate;
-	}
-	
-	/**
-	 * Places the sample into a transfer queue for future processing. 
-	 */
-	@Override
-    public void receive( ComplexBuffer sampleBuffer )
-    {
-		mQueue.offer( sampleBuffer );
     }
-	
-	private void getNextBuffer()
-	{
-		mCurrentBuffer = null;
 
-		try
+    public void restart()
+    {
+        stop();
+        start();
+    }
+
+    public int getCalculationsPerSecond()
+    {
+        return mFrameRate;
+    }
+
+    /**
+     * Places the sample into a transfer queue for future processing.
+     */
+    @Override
+    public void receive(ComplexBuffer sampleBuffer)
+    {
+        mQueue.offer(sampleBuffer);
+    }
+
+    private void getNextBuffer()
+    {
+        mCurrentBuffer = null;
+
+        try
         {
-			Buffer buffer = mQueue.take();
+            Buffer buffer = mQueue.take();
             mCurrentBuffer = buffer.getSamples();
         }
-        catch ( InterruptedException e )
+        catch(InterruptedException e)
         {
-        	mCurrentBuffer = null;
+            mCurrentBuffer = null;
         }
 
-		mCurrentBufferPointer = 0;
-	}
+        mCurrentBufferPointer = 0;
+    }
 
-	private float[] getSamples()
-	{
-		int remaining = (int)mFFTFloatsPerFrame;
+    private float[] getSamples()
+    {
+        int remaining = (int) mFFTFloatsPerFrame;
 
-		float[] currentFrame = new float[ remaining ];
+        float[] currentFrame = new float[remaining];
 
-		int currentFramePointer = 0;
+        int currentFramePointer = 0;
 
-		float integralFloatsToConsume = mNewFloatsPerFrame + mNewFloatResidual;
-		
-		int newFloatsToConsumeThisFrame = (int)integralFloatsToConsume;
-		
-		mNewFloatResidual = integralFloatsToConsume - newFloatsToConsumeThisFrame;
+        float integralFloatsToConsume = mNewFloatsPerFrame + mNewFloatResidual;
+
+        int newFloatsToConsumeThisFrame = (int) integralFloatsToConsume;
+
+        mNewFloatResidual = integralFloatsToConsume - newFloatsToConsumeThisFrame;
 		
 		/* If the number of required floats for the fft is greater than the
 		 * consumption rate per frame, we have to reach into the previous
 		 * frame to makeup the difference. */
-		if( newFloatsToConsumeThisFrame < remaining )
-		{
-			int previousFloatsRequired = remaining - newFloatsToConsumeThisFrame;
-			
-			System.arraycopy( mPreviousFrame, 
-							  mPreviousFrame.length - previousFloatsRequired, 
-							  currentFrame, 
-							  currentFramePointer, 
-							  previousFloatsRequired );
-			
-			remaining -= previousFloatsRequired;
-			currentFramePointer += previousFloatsRequired;
-		}
+        if(newFloatsToConsumeThisFrame < remaining)
+        {
+            int previousFloatsRequired = remaining - newFloatsToConsumeThisFrame;
+
+            System.arraycopy(mPreviousFrame,
+                mPreviousFrame.length - previousFloatsRequired,
+                currentFrame,
+                currentFramePointer,
+                previousFloatsRequired);
+
+            remaining -= previousFloatsRequired;
+            currentFramePointer += previousFloatsRequired;
+        }
 
 		/* Fill the rest of the buffer with new samples */
-		while( mRunning.get() && remaining > 0 )
-		{
-			if( mCurrentBuffer == null || 
-					mCurrentBufferPointer >= mCurrentBuffer.length )
-			{
-				getNextBuffer();
-			}
+        while(mRunning.get() && remaining > 0)
+        {
+            if(mCurrentBuffer == null ||
+                mCurrentBufferPointer >= mCurrentBuffer.length)
+            {
+                getNextBuffer();
+            }
 
 			/* If we don't have new samples to use, send the current frame with
 			 * the remaining values as zero */
-			if( mCurrentBuffer == null )
-			{
-				remaining = 0;
-			}
-			else
-			{
-				int samplesAvailable = mCurrentBuffer.length - mCurrentBufferPointer;
+            if(mCurrentBuffer == null)
+            {
+                remaining = 0;
+            }
+            else
+            {
+                int samplesAvailable = mCurrentBuffer.length - mCurrentBufferPointer;
 
-				while( remaining > 0 && samplesAvailable > 0 )
-				{
-					currentFrame[ currentFramePointer++ ] = 
-							(float)mCurrentBuffer[ mCurrentBufferPointer++ ];
-					
-					samplesAvailable--;
-					remaining--;
-					newFloatsToConsumeThisFrame--;
-				}
-			}
-		}
+                while(remaining > 0 && samplesAvailable > 0)
+                {
+                    currentFrame[currentFramePointer++] =
+                        (float) mCurrentBuffer[mCurrentBufferPointer++];
+
+                    samplesAvailable--;
+                    remaining--;
+                    newFloatsToConsumeThisFrame--;
+                }
+            }
+        }
 		
 		/* If the incoming float rate is greater than the fft consumption rate,
 		 * then we have to purge some floats, otherwise, store the previous
 		 * frame, because we have overlapping frames */
-		if( newFloatsToConsumeThisFrame > 0 )
-		{
-			purge( newFloatsToConsumeThisFrame );
-		}
-		else
-		{
-			mPreviousFrame = Arrays.copyOf( currentFrame, currentFrame.length );
-		}
+        if(newFloatsToConsumeThisFrame > 0)
+        {
+            purge(newFloatsToConsumeThisFrame);
+        }
+        else
+        {
+            mPreviousFrame = Arrays.copyOf(currentFrame, currentFrame.length);
+        }
 
-		return currentFrame;
-	}
-	
-	private void calculate()
-	{
-		float[] samples = getSamples();
-		
-		Window.apply( mWindow, samples );
-
-		if( mSampleType == SampleType.REAL )
-		{
-			mFFT.realForward( samples );
-		}
-		else
-		{
-			mFFT.complexForward( samples );
-		}
-		
-		dispatch( samples );
-	}
-
-	
-	private void purge( int samplesToPurge )
-	{
-		if( samplesToPurge <= 0 )
-		{
-			throw new IllegalArgumentException( "DFTProcessor - cannot purge "
-					+ "negative sample amount" );
-		}
-
-		while( mRunning.get() && samplesToPurge > 0 )
-		{
-			if( mCurrentBuffer == null || 
-					mCurrentBufferPointer >= mCurrentBuffer.length )
-			{
-				getNextBuffer();
-			}
-
-			if( mCurrentBuffer != null )
-			{
-				int samplesAvailable = mCurrentBuffer.length - mCurrentBufferPointer;
-				
-				if( samplesAvailable >= samplesToPurge )
-				{
-					mCurrentBufferPointer += samplesToPurge;
-					samplesToPurge = 0;
-				}
-				else
-				{
-					samplesToPurge -= samplesAvailable;
-					mCurrentBufferPointer = mCurrentBuffer.length;
-				}
-			}
-			else
-			{
-				samplesToPurge = 0;
-			}
-		}
-	}
-	
-	/**
-	 * Takes a calculated DFT results set, reformats the data, and sends it 
-	 * out to all registered listeners.
-	 */
-	private void dispatch( float[] results )
-	{
-		Iterator<DFTResultsConverter> it = mListeners.iterator();
-
-		while( it.hasNext() )
-		{
-			it.next().receive( results );
-		}
-	}
-
-    public void addConverter( DFTResultsConverter listener )
-    {
-		mListeners.add( listener );
+        return currentFrame;
     }
 
-    public void removeConverter( DFTResultsConverter listener )
+    private void calculate()
     {
-		mListeners.remove( listener );
+        float[] samples = getSamples();
+
+        Window.apply(mWindow, samples);
+
+        if(mSampleType == SampleType.REAL)
+        {
+            mFFT.realForward(samples);
+        }
+        else
+        {
+            mFFT.complexForward(samples);
+        }
+
+        dispatch(samples);
     }
-	
-	private class DFTCalculationTask implements Runnable
-	{
-		@Override
+
+
+    private void purge(int samplesToPurge)
+    {
+        if(samplesToPurge <= 0)
+        {
+            throw new IllegalArgumentException("DFTProcessor - cannot purge "
+                + "negative sample amount");
+        }
+
+        while(mRunning.get() && samplesToPurge > 0)
+        {
+            if(mCurrentBuffer == null ||
+                mCurrentBufferPointer >= mCurrentBuffer.length)
+            {
+                getNextBuffer();
+            }
+
+            if(mCurrentBuffer != null)
+            {
+                int samplesAvailable = mCurrentBuffer.length - mCurrentBufferPointer;
+
+                if(samplesAvailable >= samplesToPurge)
+                {
+                    mCurrentBufferPointer += samplesToPurge;
+                    samplesToPurge = 0;
+                }
+                else
+                {
+                    samplesToPurge -= samplesAvailable;
+                    mCurrentBufferPointer = mCurrentBuffer.length;
+                }
+            }
+            else
+            {
+                samplesToPurge = 0;
+            }
+        }
+    }
+
+    /**
+     * Takes a calculated DFT results set, reformats the data, and sends it
+     * out to all registered listeners.
+     */
+    private void dispatch(float[] results)
+    {
+        Iterator<DFTResultsConverter> it = mListeners.iterator();
+
+        while(it.hasNext())
+        {
+            it.next().receive(results);
+        }
+    }
+
+    public void addConverter(DFTResultsConverter listener)
+    {
+        mListeners.add(listener);
+    }
+
+    public void removeConverter(DFTResultsConverter listener)
+    {
+        mListeners.remove(listener);
+    }
+
+    private class DFTCalculationTask implements Runnable
+    {
+        @Override
         public void run()
         {
-			try
-			{
+            try
+            {
 				/* Only run if we're not currently running */
-				if( mRunning.compareAndSet( false, true ) )
-				{
-					checkFFTSize();
+                if(mRunning.compareAndSet(false, true))
+                {
+                    checkFFTSize();
 
-					calculate();
-					
-					mRunning.set( false );
-				}
-			}
-			catch( Exception e )
-			{
-				mLog.error( "error during dft processor calculation task", e );
-			}
+                    calculate();
+
+                    mRunning.set(false);
+                }
+            }
+            catch(Exception e)
+            {
+                mLog.error("error during dft processor calculation task", e);
+            }
         }
-	}
-	
-	/**
-	 * Checks for a queued FFT width change request and applies it.  This 
-	 * method will only be accessed by the scheduled executor that gains 
-	 * access to run a calculate method, thus providing thread safety.
-	 */
-	private void checkFFTSize()
-	{
-		if( mNewDFTSize.getSize() != mDFTSize.getSize() )
-		{
-			mDFTSize = mNewDFTSize;
-			
-			calculateConsumptionRate();
-
-			setWindowType( mWindowType );
-
-			if( mSampleType == SampleType.COMPLEX )
-			{
-				mPreviousFrame = new float[ mDFTSize.getSize() * 2 ];
-			}
-			else
-			{
-				mPreviousFrame = new float[ mDFTSize.getSize() ];
-			}
-
-			mFFT = new FloatFFT_1D( mDFTSize.getSize() );
-		}
-	}
-	
-	public void clearBuffer()
-	{
-		mQueue.clear();
-	}
-	
-	@Override
-    public void frequencyChanged( FrequencyChangeEvent event )
-    {
-		switch( event.getEvent() )
-		{
-			case NOTIFICATION_SAMPLE_RATE_CHANGE:
-				mSampleRate = event.getValue().intValue();
-				calculateConsumptionRate();
-				break;
-			default:
-				break;
-		}
     }
-	
-	/**
-	 * 
-	 */
-	private void calculateConsumptionRate()
-	{
-		mNewFloatResidual = 0.0f;
-		
-		mNewFloatsPerFrame = ( (float)mSampleRate / (float)mFrameRate ) *
-				( mSampleType == SampleType.COMPLEX ? 2.0f : 1.0f );
-		
-		mFFTFloatsPerFrame = ( mSampleType == SampleType.COMPLEX ? 
-					mDFTSize.getSize() * 2 : 
-					mDFTSize.getSize() );
-	}
+
+    /**
+     * Checks for a queued FFT width change request and applies it.  This
+     * method will only be accessed by the scheduled executor that gains
+     * access to run a calculate method, thus providing thread safety.
+     */
+    private void checkFFTSize()
+    {
+        if(mNewDFTSize.getSize() != mDFTSize.getSize())
+        {
+            mDFTSize = mNewDFTSize;
+
+            calculateConsumptionRate();
+
+            setWindowType(mWindowType);
+
+            if(mSampleType == SampleType.COMPLEX)
+            {
+                mPreviousFrame = new float[mDFTSize.getSize() * 2];
+            }
+            else
+            {
+                mPreviousFrame = new float[mDFTSize.getSize()];
+            }
+
+            mFFT = new FloatFFT_1D(mDFTSize.getSize());
+        }
+    }
+
+    public void clearBuffer()
+    {
+        mQueue.clear();
+    }
+
+    @Override
+    public void frequencyChanged(FrequencyChangeEvent event)
+    {
+        switch(event.getEvent())
+        {
+            case NOTIFICATION_SAMPLE_RATE_CHANGE:
+                mSampleRate = event.getValue().intValue();
+                calculateConsumptionRate();
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     *
+     */
+    private void calculateConsumptionRate()
+    {
+        mNewFloatResidual = 0.0f;
+
+        mNewFloatsPerFrame = ((float) mSampleRate / (float) mFrameRate) *
+            (mSampleType == SampleType.COMPLEX ? 2.0f : 1.0f);
+
+        mFFTFloatsPerFrame = (mSampleType == SampleType.COMPLEX ?
+            mDFTSize.getSize() * 2 :
+            mDFTSize.getSize());
+    }
 }
diff --git a/src/spectrum/SpectralDisplayPanel.java b/src/spectrum/SpectralDisplayPanel.java
index 878a8e79..93779777 100644
--- a/src/spectrum/SpectralDisplayPanel.java
+++ b/src/spectrum/SpectralDisplayPanel.java
@@ -1,58 +1,34 @@
 /*******************************************************************************
- *     SDR Trunk 
- *     Copyright (C) 2014-2016 Dennis Sheirer
- * 
- *     This program is free software: you can redistribute it and/or modify
- *     it under the terms of the GNU General Public License as published by
- *     the Free Software Foundation, either version 3 of the License, or
- *     (at your option) any later version.
- * 
- *     This program is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- * 
- *     You should have received a copy of the GNU General Public License
- *     along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * sdrtrunk
+ * Copyright (C) 2014-2017 Dennis Sheirer
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ *
  ******************************************************************************/
 package spectrum;
 
-import java.awt.Component;
-import java.awt.Dimension;
-import java.awt.EventQueue;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.event.ComponentEvent;
-import java.awt.event.ComponentListener;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseWheelEvent;
-import java.text.DecimalFormat;
-import java.util.ArrayList;
-import java.util.Hashtable;
-
-import javax.swing.JCheckBoxMenuItem;
-import javax.swing.JComponent;
-import javax.swing.JLabel;
-import javax.swing.JLayeredPane;
-import javax.swing.JMenu;
-import javax.swing.JMenuItem;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.JScrollPane;
-import javax.swing.JSeparator;
-import javax.swing.JSlider;
-import javax.swing.JSplitPane;
-import javax.swing.SwingUtilities;
-import javax.swing.event.ChangeEvent;
-import javax.swing.event.ChangeListener;
-import javax.swing.event.MouseInputAdapter;
-
+import com.jidesoft.swing.JideSplitPane;
+import controller.channel.Channel;
+import controller.channel.ChannelModel;
+import controller.channel.ChannelProcessingManager;
+import controller.channel.ChannelUtils;
+import dsp.filter.Window.WindowType;
+import dsp.filter.smoothing.SmoothingFilter.SmoothingType;
 import module.decode.DecoderType;
 import net.miginfocom.swing.MigLayout;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
 import properties.SystemProperties;
 import sample.Listener;
 import sample.SampleType;
@@ -74,36 +50,38 @@ import spectrum.menu.FrameRateItem;
 import spectrum.menu.SmoothingItem;
 import spectrum.menu.SmoothingTypeItem;
 
-import com.jidesoft.swing.JideSplitPane;
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.event.MouseInputAdapter;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseWheelEvent;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Hashtable;
 
-import controller.channel.Channel;
-import controller.channel.ChannelModel;
-import controller.channel.ChannelProcessingManager;
-import controller.channel.ChannelUtils;
-import dsp.filter.Window.WindowType;
-import dsp.filter.smoothing.SmoothingFilter.SmoothingType;
-
-public class SpectralDisplayPanel extends JPanel 
-								  implements Listener<ComplexBuffer>,
-								  			 IFrequencyChangeProcessor,
-								  			 IDFTWidthChangeProcessor
- {
+public class SpectralDisplayPanel extends JPanel implements Listener<ComplexBuffer>, IFrequencyChangeProcessor, IDFTWidthChangeProcessor
+{
     private static final long serialVersionUID = 1L;
-    
-	private final static Logger mLog = 
-			LoggerFactory.getLogger( SpectralDisplayPanel.class );
 
-	private static DecimalFormat sCURSOR_FORMAT = new DecimalFormat( "000.00000" );
+    private final static Logger mLog = LoggerFactory.getLogger(SpectralDisplayPanel.class);
 
-	public static final String FFT_SIZE_PROPERTY = "spectral.display.dft.size";
-	public static final int NO_ZOOM = 0;
-	public static final int MAX_ZOOM = 6;
+    private static DecimalFormat sCURSOR_FORMAT = new DecimalFormat("000.00000");
 
-	private DFTSize mDFTSize = DFTSize.FFT04096;
-	private int mZoom = 0;
-	private int mDFTZoomWindowOffset = 0;
+    public static final String FFT_SIZE_PROPERTY = "spectral.display.dft.size";
+    public static final int NO_ZOOM = 0;
+    public static final int MAX_ZOOM = 6;
 
-	private JScrollPane mScrollPane;
+    private DFTSize mDFTSize = DFTSize.FFT04096;
+    private int mZoom = 0;
+    private int mDFTZoomWindowOffset = 0;
+
+    private JScrollPane mScrollPane;
     private JLayeredPane mLayeredPanel;
     private SpectrumPanel mSpectrumPanel;
     private WaterfallPanel mWaterfallPanel;
@@ -113,122 +91,128 @@ public class SpectralDisplayPanel extends JPanel
     private ChannelModel mChannelModel;
     private ChannelProcessingManager mChannelProcessingManager;
     private SettingsManager mSettingsManager;
-	private Tuner mTuner;
-    
-	/**
-	 * Spectral Display Panel provides a frequency component display with a
-	 * historical waterfall display and a transparent overlay to show frequency,
-	 * cursor and channel information.
-	 * 
-	 * Mouse scrolling and zooming are supported and the waterfall display can
-	 * be paused.
-	 * 
-	 * Complex sample buffers are processed by a DFTProcessor and the output of
-	 * the DFT is translated to decibels for display in the spectrum and
-	 * waterfall components.
-	 */
-    public SpectralDisplayPanel( ChannelModel channelModel,
-    							 ChannelProcessingManager channelProcessingManager,
-    							 SettingsManager settingsManager )
-    {
-    	mChannelModel = channelModel;
-    	mChannelProcessingManager = channelProcessingManager;
-    	mSettingsManager = settingsManager;
+    private Tuner mTuner;
 
-    	mSpectrumPanel = new SpectrumPanel( mSettingsManager );
-    	mOverlayPanel = new OverlayPanel( mSettingsManager, mChannelModel );
-    	mWaterfallPanel = new WaterfallPanel( mSettingsManager );
-    	
-		init();
-		
-		loadSettings();
+    /**
+     * Spectral Display Panel provides a frequency component display with a
+     * historical waterfall display and a transparent overlay to show frequency,
+     * cursor and channel information.
+     *
+     * Mouse scrolling and zooming are supported and the waterfall display can
+     * be paused.
+     *
+     * Complex sample buffers are processed by a DFTProcessor and the output of
+     * the DFT is translated to decibels for display in the spectrum and
+     * waterfall components.
+     */
+    public SpectralDisplayPanel(ChannelModel channelModel,
+                                ChannelProcessingManager channelProcessingManager,
+                                SettingsManager settingsManager)
+    {
+        mChannelModel = channelModel;
+        mChannelProcessingManager = channelProcessingManager;
+        mSettingsManager = settingsManager;
+
+        mSpectrumPanel = new SpectrumPanel(mSettingsManager);
+        mOverlayPanel = new OverlayPanel(mSettingsManager, mChannelModel);
+        mWaterfallPanel = new WaterfallPanel(mSettingsManager);
+
+        init();
+
+        loadSettings();
     }
-    
+
     private void loadSettings()
     {
-    	SystemProperties properties = SystemProperties.getInstance();
-    	
-    	String rawSize = properties.get( FFT_SIZE_PROPERTY, DFTSize.FFT04096.name() );
-    	
-    	DFTSize size = null;
-    	
-    	if( rawSize != null )
-    	{
-    		try
-    		{
-    			size = DFTSize.valueOf( rawSize );
-    		}
-    		catch( Exception e )
-    		{
-    			//Do nothing
-    		}
-    	}
-    	
-    	if( size == null )
-    	{
-    		size = DFTSize.FFT04096;
-    	}
-    	
-    	setDFTSize( size );
+        SystemProperties properties = SystemProperties.getInstance();
+
+        String rawSize = properties.get(FFT_SIZE_PROPERTY, DFTSize.FFT04096.name());
+
+        DFTSize size = null;
+
+        if(rawSize != null)
+        {
+            try
+            {
+                size = DFTSize.valueOf(rawSize);
+            }
+            catch(Exception e)
+            {
+                //Do nothing
+            }
+        }
+
+        if(size == null)
+        {
+            size = DFTSize.FFT04096;
+        }
+
+        setDFTSize(size, false);
     }
-    
+
     public void dispose()
     {
-		/* De-register from receiving samples when the window closes */
-    	clearTuner();
+        /* De-register from receiving samples when the window closes */
+        clearTuner();
 
-    	mSettingsManager = null;
-    	
-    	mDFTProcessor.dispose();
-    	mDFTProcessor = null;
-    	
-    	mDFTConverter.dispose();
-    	mDFTConverter = null;
-    	
-    	mSpectrumPanel.dispose();
-    	mSpectrumPanel = null;
-    	
-    	mWaterfallPanel.dispose();
-    	mWaterfallPanel = null;
-    	
-    	mOverlayPanel.dispose();
-    	mOverlayPanel = null;
-    	
-    	
-    	mTuner = null;
+        mSettingsManager = null;
+
+        mDFTProcessor.dispose();
+        mDFTProcessor = null;
+
+        mDFTConverter.dispose();
+        mDFTConverter = null;
+
+        mSpectrumPanel.dispose();
+        mSpectrumPanel = null;
+
+        mWaterfallPanel.dispose();
+        mWaterfallPanel = null;
+
+        mOverlayPanel.dispose();
+        mOverlayPanel = null;
+
+
+        mTuner = null;
     }
-    
-	/**
-	 * Queues an FFT size change request.  The scheduled executor will apply 
-	 * the change when it runs.
-	 */
-	public void setDFTSize( DFTSize size )
-	{
-		mDFTProcessor.setDFTSize( size );
-		mOverlayPanel.setDFTSize( size );
-		mDFTSize = size;
-		
-		SystemProperties properties = SystemProperties.getInstance();
-		
-		properties.set( FFT_SIZE_PROPERTY, size.name() );
 
-		setZoom( 0, 0, 0 );
-	}
-	
-    @Override
-	public DFTSize getDFTSize()
-	{
-		return mDFTSize;
-	}
-
-	public int getZoom()
+    /**
+     * Queues an FFT size change request.  The scheduled executor will apply
+     * the change when it runs.
+     */
+    public void setDFTSize(DFTSize size, boolean save)
     {
-    	return mZoom;
+        mDFTProcessor.setDFTSize(size);
+        mOverlayPanel.setDFTSize(size);
+        mDFTSize = size;
+
+        if(save)
+        {
+            SystemProperties.getInstance().set(FFT_SIZE_PROPERTY, size.name());
+        }
+
+        setZoom(0, 0, 0);
     }
-    
+
+    public void setDFTSize(DFTSize size)
+    {
+        setDFTSize(size, true);
+    }
+
+    @Override
+    public DFTSize getDFTSize()
+    {
+        return mDFTSize;
+    }
+
+    public int getZoom()
+    {
+        return mZoom;
+    }
+
     /**
      * Sets the current zoom level which will be 2 to the power of zoom (2^zoom)
-     * 
+     *
      * 0 	No Zoom
      * 1	2x Zoom
      * 2	4x Zoom
@@ -236,101 +220,102 @@ public class SpectralDisplayPanel extends JPanel
      * 4	16x Zoom
      * 5	32x Zoom
      * 6    64x Zoom
-     * 
+     *
      * @param zoom level, 0 - 6.
      * @param frequency under the mouse to maintain while zooming
      * @param xAxisOffset where to maintain the frequency under the mouse
      */
-    public void setZoom( int zoom, long frequency, double windowOffset )
+    public void setZoom(int zoom, long frequency, double windowOffset)
     {
-		if( zoom < NO_ZOOM )
-		{
-			zoom = NO_ZOOM;
-		}
-		else if( zoom > MAX_ZOOM )
-		{
-			zoom = MAX_ZOOM;
-		}
+        if(zoom < NO_ZOOM)
+        {
+            zoom = NO_ZOOM;
+        }
+        else if(zoom > MAX_ZOOM)
+        {
+            zoom = MAX_ZOOM;
+        }
 
-    	if( zoom != mZoom )
-    	{
-        	mZoom = zoom;
-        	
-        	//Calculate the bin offset that would place the reference frequency
-        	//at the left edge of the zoom window.
-        	double binOffsetToFrequency = getBinOffset( frequency );
+        if(zoom != mZoom)
+        {
+            mZoom = zoom;
 
-        	//Calculate the bin offset into the newly sized zoom window that 
-        	//would place the frequency in the same proportional window location 
-        	//that it was in the previous zoom size
-        	double windowBinOffset = (double)getZoomWindowSizeInBins() * windowOffset;
+            //Calculate the bin offset that would place the reference frequency
+            //at the left edge of the zoom window.
+            double binOffsetToFrequency = getBinOffset(frequency);
 
-        	//Set the overall offset to place the reference frequency in the 
-        	//same location in the newly zoomed window
-        	double offset = binOffsetToFrequency - windowBinOffset;
-        	
-        	mSpectrumPanel.setZoom( mZoom );
-        	mOverlayPanel.setZoom( mZoom );
-        	mWaterfallPanel.setZoom( mZoom );
+            //Calculate the bin offset into the newly sized zoom window that
+            //would place the frequency in the same proportional window location
+            //that it was in the previous zoom size
+            double windowBinOffset = (double) getZoomWindowSizeInBins() * windowOffset;
 
-        	setZoomWindowOffset( offset );
-    	}
+            //Set the overall offset to place the reference frequency in the
+            //same location in the newly zoomed window
+            double offset = binOffsetToFrequency - windowBinOffset;
+
+            mSpectrumPanel.setZoom(mZoom);
+            mOverlayPanel.setZoom(mZoom);
+            mWaterfallPanel.setZoom(mZoom);
+
+            setZoomWindowOffset(offset);
+        }
     }
-    
+
     /**
      * Sets the offset (in DFT bins) to the first bin that the zoom window displays
      */
-    public void setZoomWindowOffset( double offset )
+    public void setZoomWindowOffset(double offset)
     {
-    	if( offset < 0 )
-    	{
-    		offset = 0;
-    	}
-    	
-    	if( offset > ( mDFTSize.getSize() - getZoomWindowSizeInBins() ) )
-		{
-    		offset = mDFTSize.getSize() - getZoomWindowSizeInBins();
-		}
-    	
-    	mDFTZoomWindowOffset = (int)offset;
-    	
-    	mSpectrumPanel.setZoomWindowOffset( mDFTZoomWindowOffset );
-    	mOverlayPanel.setZoomWindowOffset( mDFTZoomWindowOffset );
-    	mWaterfallPanel.setZoomWindowOffset( mDFTZoomWindowOffset );
+        if(offset < 0)
+        {
+            offset = 0;
+        }
+
+        if(offset > (mDFTSize.getSize() - getZoomWindowSizeInBins()))
+        {
+            offset = mDFTSize.getSize() - getZoomWindowSizeInBins();
+        }
+
+        mDFTZoomWindowOffset = (int) offset;
+
+        mSpectrumPanel.setZoomWindowOffset(mDFTZoomWindowOffset);
+        mOverlayPanel.setZoomWindowOffset(mDFTZoomWindowOffset);
+        mWaterfallPanel.setZoomWindowOffset(mDFTZoomWindowOffset);
     }
-    
+
     /**
      * Calculates the size of the current zoom window in DFT bins
      */
     private int getZoomWindowSizeInBins()
     {
-    	return mDFTSize.getSize() / getZoomMultiplier();
+        return mDFTSize.getSize() / getZoomMultiplier();
     }
-    
-    
+
+
     public int getZoomMultiplier()
     {
-    	return (int)Math.pow( 2.0, mZoom );
+        return (int) Math.pow(2.0, mZoom);
     }
-    
+
     /**
      * Calculates the overall offset of the frequency from the current minimum
      * frequency in terms of total FFT width
+     *
      * @param frequency
      * @return
      */
-    private double getBinOffset( long frequency )
+    private double getBinOffset(long frequency)
     {
-    	double offset = 0.0;
-    	
-    	if( mOverlayPanel.containsFrequency( frequency ) )
-    	{
-    		offset = (double)mDFTSize.getSize() * 
-				( (double)( frequency - mOverlayPanel.getMinFrequency() ) / 
-					(double)mOverlayPanel.getBandwidth() );
-    	}
-    	
-    	return offset;
+        double offset = 0.0;
+
+        if(mOverlayPanel.containsFrequency(frequency))
+        {
+            offset = (double) mDFTSize.getSize() *
+                ((double) (frequency - mOverlayPanel.getMinFrequency()) /
+                    (double) mOverlayPanel.getBandwidth());
+        }
+
+        return offset;
     }
 
     /**
@@ -339,614 +324,623 @@ public class SpectralDisplayPanel extends JPanel
      */
     public boolean isOptimizedDrawingEnabled()
     {
-    	return false;
+        return false;
     }
-   
+
     private void init()
     {
-    	setLayout( new MigLayout( "insets 0 0 0 0", "[grow]", "[grow]") );
+        setLayout(new MigLayout("insets 0 0 0 0", "[grow]", "[grow]"));
 
-    	/**
-    	 * The layered pane holds the overlapping spectrum and channel panels
-    	 * and manages the sizing of each panel with the resize listener
-    	 */
-    	mLayeredPanel = new JLayeredPane();
-    	mLayeredPanel.addComponentListener( new ResizeListener() );
+        /**
+         * The layered pane holds the overlapping spectrum and channel panels
+         * and manages the sizing of each panel with the resize listener
+         */
+        mLayeredPanel = new JLayeredPane();
+        mLayeredPanel.addComponentListener(new ResizeListener());
 
-    	/**
-    	 * Create a mouse adapter to handle mouse events over the spectrum
-    	 * and waterfall panels
-    	 */
-    	MouseEventProcessor mouser = new MouseEventProcessor();
-    	
-    	mOverlayPanel.addMouseListener( mouser );
-    	mOverlayPanel.addMouseMotionListener( mouser );
-    	mOverlayPanel.addMouseWheelListener( mouser );
+        /**
+         * Create a mouse adapter to handle mouse events over the spectrum
+         * and waterfall panels
+         */
+        MouseEventProcessor mouser = new MouseEventProcessor();
 
-    	//Add the spectrum and channel panels to the layered panel
-    	mLayeredPanel.add( mSpectrumPanel, new Integer( 0 ), 0 );
-    	mLayeredPanel.add( mOverlayPanel, new Integer( 1 ), 0 );
+        mOverlayPanel.addMouseListener(mouser);
+        mOverlayPanel.addMouseMotionListener(mouser);
+        mOverlayPanel.addMouseWheelListener(mouser);
 
-    	//Create the waterfall
-    	mWaterfallPanel.addMouseListener( mouser );
-    	mWaterfallPanel.addMouseMotionListener( mouser );
-    	mWaterfallPanel.addMouseWheelListener( mouser );
+        //Add the spectrum and channel panels to the layered panel
+        mLayeredPanel.add(mSpectrumPanel, new Integer(0), 0);
+        mLayeredPanel.add(mOverlayPanel, new Integer(1), 0);
+
+        //Create the waterfall
+        mWaterfallPanel.addMouseListener(mouser);
+        mWaterfallPanel.addMouseMotionListener(mouser);
+        mWaterfallPanel.addMouseWheelListener(mouser);
 
     	/* Attempt to set a 50/50 split preferred size for the split pane */
-    	double totalHeight = mLayeredPanel.getPreferredSize().getHeight() +
-    					  mWaterfallPanel.getPreferredSize().getHeight();
-    	
-    	mLayeredPanel.setPreferredSize( new Dimension( (int)mLayeredPanel
-    			.getPreferredSize().getWidth(), (int)( totalHeight / 2.0d ) ) );
-    	
-    	mWaterfallPanel.setPreferredSize( new Dimension( (int)mWaterfallPanel
-    			.getPreferredSize().getWidth(), (int)( totalHeight / 2.0d ) ) );
-    	
-    	//Create the split pane to hold the layered pane and the waterfall
-    	JideSplitPane splitPane = new JideSplitPane( JSplitPane.VERTICAL_SPLIT );
-    	splitPane.setDividerSize( 5 );
-    	splitPane.add( mLayeredPanel );
-    	splitPane.add( mWaterfallPanel );
-    	
-    	mScrollPane = new JScrollPane( splitPane );
-    	
-        add( mScrollPane, "grow" );
-        
-    	/**
-    	 * Setup DFTProcessor to process samples and register the waterfall and
-    	 * spectrum panel to receive the processed dft results
-    	 */
-		mDFTProcessor = new DFTProcessor( SampleType.COMPLEX );
-		mDFTConverter = new ComplexDecibelConverter();
-		mDFTProcessor.addConverter( mDFTConverter );
-		
-    	mDFTConverter.addListener( (DFTResultsListener)mSpectrumPanel );
-    	mDFTConverter.addListener( (DFTResultsListener)mWaterfallPanel );
+        double totalHeight = mLayeredPanel.getPreferredSize().getHeight() +
+            mWaterfallPanel.getPreferredSize().getHeight();
+
+        mLayeredPanel.setPreferredSize(new Dimension((int) mLayeredPanel
+            .getPreferredSize().getWidth(), (int) (totalHeight / 2.0d)));
+
+        mWaterfallPanel.setPreferredSize(new Dimension((int) mWaterfallPanel
+            .getPreferredSize().getWidth(), (int) (totalHeight / 2.0d)));
+
+        //Create the split pane to hold the layered pane and the waterfall
+        JideSplitPane splitPane = new JideSplitPane(JSplitPane.VERTICAL_SPLIT);
+        splitPane.setDividerSize(5);
+        splitPane.add(mLayeredPanel);
+        splitPane.add(mWaterfallPanel);
+
+        mScrollPane = new JScrollPane(splitPane);
+
+        add(mScrollPane, "grow");
+
+        /**
+         * Setup DFTProcessor to process samples and register the waterfall and
+         * spectrum panel to receive the processed dft results
+         */
+        mDFTProcessor = new DFTProcessor(SampleType.COMPLEX);
+        mDFTConverter = new ComplexDecibelConverter();
+        mDFTProcessor.addConverter(mDFTConverter);
+
+        mDFTConverter.addListener((DFTResultsListener) mSpectrumPanel);
+        mDFTConverter.addListener((DFTResultsListener) mWaterfallPanel);
     }
 
-	/**
-	 * Receives frequency change events -- primarily from tuner components.
-	 */
-    public void frequencyChanged( FrequencyChangeEvent event )
+    /**
+     * Receives frequency change events -- primarily from tuner components.
+     */
+    public void frequencyChanged(FrequencyChangeEvent event)
     {
-		mOverlayPanel.frequencyChanged( event );
-		mDFTProcessor.frequencyChanged( event );
+        mOverlayPanel.frequencyChanged(event);
+        mDFTProcessor.frequencyChanged(event);
     }
 
-	/**
-	 * Complex sample buffer receive method
-	 */
-	@Override
-    public void receive( ComplexBuffer sampleBuffer )
+    /**
+     * Complex sample buffer receive method
+     */
+    @Override
+    public void receive(ComplexBuffer sampleBuffer)
     {
-		mDFTProcessor.receive( sampleBuffer );
+        mDFTProcessor.receive(sampleBuffer);
     }
 
-	/**
-	 * Responds to tuner event by deregistering from the current
-	 * complex sample buffer source and registering with the tuner argument.
-	 */
-	public void showTuner( Tuner tuner )
-	{
-		clearTuner();
-		
-		mDFTProcessor.clearBuffer();
+    /**
+     * Responds to tuner event by deregistering from the current
+     * complex sample buffer source and registering with the tuner argument.
+     */
+    public void showTuner(Tuner tuner)
+    {
+        clearTuner();
 
-		mTuner = tuner;
+        mDFTProcessor.clearBuffer();
 
-		if( mTuner != null )
-		{
-			//Register to receive frequency change events
-			mTuner.getTunerController().addListener( this );
+        mTuner = tuner;
 
-			//Register the dft processor to receive samples from the tuner
-			mTuner.addListener( (Listener<ComplexBuffer>)mDFTProcessor );
-			
-			mSpectrumPanel.setSampleSize( mTuner.getSampleSize() );
-			
-			//Fire frequency and sample rate change events so that the spectrum
-			//and overlay panels can synchronize
-			frequencyChanged( new FrequencyChangeEvent( 
-					Event.NOTIFICATION_FREQUENCY_CHANGE, 
-					mTuner.getTunerController().getFrequency() ) );
-			
-			frequencyChanged( new FrequencyChangeEvent( 
-					Event.NOTIFICATION_SAMPLE_RATE_CHANGE, 
-					mTuner.getTunerController().getSampleRate() ) );
-		}
-	}
-
-	/**
-	 * Tuner de-selection cleanup method
-	 */
-	public void clearTuner()
-	{
-		if( mTuner != null )
-		{
-			//Deregister for frequency change events from the tuner
-			mTuner.getTunerController().removeListener( this );
-			
-			//Deregister the dft processor from receiving samples
-			mTuner.removeListener( (Listener<ComplexBuffer>)mDFTProcessor );
-			mTuner = null;
-		}
-	}
-
-	/**
-	 * Monitors the sizing of the layered pane and resizes the spectrum and
-	 * channel panels whenever the layered pane is resized
-	 */
-	public class ResizeListener implements ComponentListener
-	{
-		@Override
-        public void componentResized( ComponentEvent e )
+        if(mTuner != null)
         {
-			Component c = e.getComponent();
-			
-			mSpectrumPanel.setBounds( 0, 0, c.getWidth(), c.getHeight() );
-			mOverlayPanel.setBounds( 0, 0, c.getWidth(), c.getHeight() );
+            //Register to receive frequency change events
+            mTuner.getTunerController().addListener(this);
+
+            //Register the dft processor to receive samples from the tuner
+            mTuner.addListener((Listener<ComplexBuffer>) mDFTProcessor);
+
+            mSpectrumPanel.setSampleSize(mTuner.getSampleSize());
+
+            //Fire frequency and sample rate change events so that the spectrum
+            //and overlay panels can synchronize
+            frequencyChanged(new FrequencyChangeEvent(
+                Event.NOTIFICATION_FREQUENCY_CHANGE,
+                mTuner.getTunerController().getFrequency()));
+
+            frequencyChanged(new FrequencyChangeEvent(
+                Event.NOTIFICATION_SAMPLE_RATE_CHANGE,
+                mTuner.getTunerController().getSampleRate()));
+        }
+    }
+
+    /**
+     * Tuner de-selection cleanup method
+     */
+    public void clearTuner()
+    {
+        if(mTuner != null)
+        {
+            //Deregister for frequency change events from the tuner
+            mTuner.getTunerController().removeListener(this);
+
+            //Deregister the dft processor from receiving samples
+            mTuner.removeListener((Listener<ComplexBuffer>) mDFTProcessor);
+            mTuner = null;
+        }
+    }
+
+    /**
+     * Monitors the sizing of the layered pane and resizes the spectrum and
+     * channel panels whenever the layered pane is resized
+     */
+    public class ResizeListener implements ComponentListener
+    {
+        @Override
+        public void componentResized(ComponentEvent e)
+        {
+            Component c = e.getComponent();
+
+            mSpectrumPanel.setBounds(0, 0, c.getWidth(), c.getHeight());
+            mOverlayPanel.setBounds(0, 0, c.getWidth(), c.getHeight());
         }
 
-		@Override
-        public void componentHidden( ComponentEvent arg0 ) {}
-		@Override
-        public void componentMoved( ComponentEvent arg0 ) {}
-		@Override
-        public void componentShown( ComponentEvent arg0 ) {}
-	}
-	
-	/**
-	 * Mouse event handler for the spectral display panel.
-	 */
-	public class MouseEventProcessor extends MouseInputAdapter
-	{
-		private int mDFTZoomWindowOffsetAtDragStart = 0;
-		private int mDragStartX = 0;
-		private double mPixelsPerBin;
-		
-		public MouseEventProcessor()
-		{
-		}
-
-		@Override
-		public void mouseWheelMoved( MouseWheelEvent e )
-		{
-			int zoom = mZoom - e.getWheelRotation();
-
-			long frequency = mOverlayPanel.getFrequencyFromAxis( e.getX() );
-
-			double windowOffset = (double)e.getX() / (double)getWidth();
-
-			setZoom( zoom, frequency, windowOffset );
-		}
-		
-		@Override
-        public void mouseMoved( MouseEvent event )
+        @Override
+        public void componentHidden(ComponentEvent arg0)
         {
-			update( event );
         }
-		
-		@Override
-        public void mouseDragged( MouseEvent event ) 
-		{			
-			update( event );
 
-			int dragDistance = mDragStartX - event.getX();
-			
-			double binDistance = (double)dragDistance / mPixelsPerBin;
-
-			int offset = (int)( mDFTZoomWindowOffsetAtDragStart + binDistance );
-			
-			if( offset < 0 )
-			{
-				offset = 0;
-			}
-			
-			int maxOffset = mDFTSize.getSize() - ( mDFTSize.getSize() / getZoomMultiplier() );
-			
-			if( offset > maxOffset )
-			{
-				offset = maxOffset;
-			}
-
-			setZoomWindowOffset( offset );
-		}
-		@Override
-        public void mousePressed( MouseEvent e ) 
-		{
-			mDragStartX = e.getX();
-			
-			mDFTZoomWindowOffsetAtDragStart = mDFTZoomWindowOffset;
-			
-			mPixelsPerBin = (double)getWidth() / 
-							( (double)( mDFTSize.getSize() ) / 
-							  (double)getZoomMultiplier() );
-		}
-		
-		/**
-		 * Updates the cursor display while the mouse is performing actions
-		 */
-		private void update( MouseEvent event )
-		{
-			if( event.getComponent() == mOverlayPanel )
-			{
-				mOverlayPanel.setCursorLocation( event.getPoint() );
-			}
-			else
-			{
-				mWaterfallPanel.setCursorLocation( event.getPoint() );
-				mWaterfallPanel.setCursorFrequency( 
-				mOverlayPanel.getFrequencyFromAxis( event.getPoint().x ) );
-			}
-		}
-
-		@Override
-        public void mouseEntered( MouseEvent e ) 
-		{
-			if( e.getComponent() == mOverlayPanel )
-			{
-				mOverlayPanel.setCursorVisible( true );
-			}
-			else
-			{
-				mWaterfallPanel.setCursorVisible( true );
-			}
-		}
-		
-		@Override
-        public void mouseExited( MouseEvent e )
-		{
-			mOverlayPanel.setCursorVisible( false );
-			mWaterfallPanel.setCursorVisible( false );
-		}
-
-		/**
-		 * Displays the context menu.
-		 */
-		@Override
-        public void mouseClicked( MouseEvent event )
+        @Override
+        public void componentMoved(ComponentEvent arg0)
         {
-			if( SwingUtilities.isRightMouseButton( event ) )
-			{
-				JPopupMenu contextMenu = new JPopupMenu();
-				
-				if( event.getComponent() == mWaterfallPanel )
-				{
-					contextMenu.add( new PauseItem( mWaterfallPanel, "Pause" ) );
-				}
+        }
 
-				long frequency = 
-						mOverlayPanel.getFrequencyFromAxis( event.getX() );
-				
-				if( event.getComponent() == mOverlayPanel )
-				{
-					ArrayList<Channel> channels = 
-							mOverlayPanel.getChannelsAtFrequency( frequency );
+        @Override
+        public void componentShown(ComponentEvent arg0)
+        {
+        }
+    }
 
-					for( Channel channel: channels )
-					{
-						JMenu channelMenu = ChannelUtils.getContextMenu( mChannelModel, 
-							mChannelProcessingManager, channel, 
-							SpectralDisplayPanel.this );
+    /**
+     * Mouse event handler for the spectral display panel.
+     */
+    public class MouseEventProcessor extends MouseInputAdapter
+    {
+        private int mDFTZoomWindowOffsetAtDragStart = 0;
+        private int mDragStartX = 0;
+        private double mPixelsPerBin;
 
-						if( channelMenu != null )
-						{
-							contextMenu.add( channelMenu );
-						}
-					}
+        public MouseEventProcessor()
+        {
+        }
 
-					if( !channels.isEmpty() )
-					{
-						contextMenu.add( new JSeparator() );
-					}
-					
-				}
+        @Override
+        public void mouseWheelMoved(MouseWheelEvent e)
+        {
+            int zoom = mZoom - e.getWheelRotation();
 
-				JMenu frequencyMenu = new JMenu( 
-						sCURSOR_FORMAT.format( (float)frequency / 1000000.0f ) );
+            long frequency = mOverlayPanel.getFrequencyFromAxis(e.getX());
 
-				JMenu decoderMenu = new JMenu( "Add Decoder" );
+            double windowOffset = (double) e.getX() / (double) getWidth();
 
-				for( DecoderType type: DecoderType.getPrimaryDecoders() )
-				{
-					decoderMenu.add( new DecoderItem( type, frequency ) );
-				}
-				
-				frequencyMenu.add( decoderMenu );
-				
-				contextMenu.add( frequencyMenu );
+            setZoom(zoom, frequency, windowOffset);
+        }
 
-				contextMenu.add( new JSeparator() );
+        @Override
+        public void mouseMoved(MouseEvent event)
+        {
+            update(event);
+        }
 
-				/**
-				 * Color Menus
-				 */
-				JMenu colorMenu = new JMenu( "Color" );
+        @Override
+        public void mouseDragged(MouseEvent event)
+        {
+            update(event);
 
-				colorMenu.add( new ColorSettingMenuItem( mSettingsManager, 
-						ColorSettingName.CHANNEL_CONFIG ) );
+            int dragDistance = mDragStartX - event.getX();
 
-				colorMenu.add( new ColorSettingMenuItem( mSettingsManager, 
-						ColorSettingName.CHANNEL_CONFIG_PROCESSING ) );
+            double binDistance = (double) dragDistance / mPixelsPerBin;
 
-				colorMenu.add( new ColorSettingMenuItem( mSettingsManager, 
-						ColorSettingName.CHANNEL_CONFIG_SELECTED ) );
+            int offset = (int) (mDFTZoomWindowOffsetAtDragStart + binDistance);
 
-				colorMenu.add( new ColorSettingMenuItem( mSettingsManager, 
-						ColorSettingName.SPECTRUM_CURSOR ) );
+            if(offset < 0)
+            {
+                offset = 0;
+            }
 
-				colorMenu.add( new ColorSettingMenuItem( mSettingsManager, 
-						ColorSettingName.SPECTRUM_LINE ) );
+            int maxOffset = mDFTSize.getSize() - (mDFTSize.getSize() / getZoomMultiplier());
 
-				colorMenu.add( new ColorSettingMenuItem( mSettingsManager, 
-						ColorSettingName.SPECTRUM_BACKGROUND ) );
+            if(offset > maxOffset)
+            {
+                offset = maxOffset;
+            }
 
-				colorMenu.add( new ColorSettingMenuItem( mSettingsManager, 
-						ColorSettingName.SPECTRUM_GRADIENT_BOTTOM ) );
+            setZoomWindowOffset(offset);
+        }
 
-				colorMenu.add( new ColorSettingMenuItem( mSettingsManager, 
-						ColorSettingName.SPECTRUM_GRADIENT_TOP ) );
+        @Override
+        public void mousePressed(MouseEvent e)
+        {
+            mDragStartX = e.getX();
 
-				contextMenu.add( colorMenu );
-				
-				/**
-				 * Display items: fft and frame rate
-				 */
-				JMenu displayMenu = new JMenu( "Display" );
-				contextMenu.add(  displayMenu );
+            mDFTZoomWindowOffsetAtDragStart = mDFTZoomWindowOffset;
 
-				if( event.getComponent() != mWaterfallPanel )
-				{
-					/**
-					 * Averaging menu
-					 */
-					JMenu averagingMenu = new JMenu( "Averaging" );
-					averagingMenu.add( 
-							new AveragingItem( mSpectrumPanel, 4 ) );
-					displayMenu.add( averagingMenu );
-					
-					/**
-					 * Channel Display setting menu
-					 */
-					JMenu channelDisplayMenu = new JMenu( "Channel" );
+            mPixelsPerBin = (double) getWidth() /
+                ((double) (mDFTSize.getSize()) /
+                    (double) getZoomMultiplier());
+        }
 
-					channelDisplayMenu.add( new ChannelDisplayItem( 
-							mOverlayPanel, ChannelDisplay.ALL ) );
-					channelDisplayMenu.add( new ChannelDisplayItem( 
-							mOverlayPanel, ChannelDisplay.ENABLED ) );
-					channelDisplayMenu.add( new ChannelDisplayItem( 
-							mOverlayPanel, ChannelDisplay.NONE ) );
+        /**
+         * Updates the cursor display while the mouse is performing actions
+         */
+        private void update(MouseEvent event)
+        {
+            if(event.getComponent() == mOverlayPanel)
+            {
+                mOverlayPanel.setCursorLocation(event.getPoint());
+            }
+            else
+            {
+                mWaterfallPanel.setCursorLocation(event.getPoint());
+                mWaterfallPanel.setCursorFrequency(
+                    mOverlayPanel.getFrequencyFromAxis(event.getPoint().x));
+            }
+        }
 
-					displayMenu.add( channelDisplayMenu );
-				}
+        @Override
+        public void mouseEntered(MouseEvent e)
+        {
+            if(e.getComponent() == mOverlayPanel)
+            {
+                mOverlayPanel.setCursorVisible(true);
+            }
+            else
+            {
+                mWaterfallPanel.setCursorVisible(true);
+            }
+        }
 
-				
-				/**
-				 * FFT width
-				 */
-				JMenu fftWidthMenu = new JMenu( "FFT Width" );
-				displayMenu.add( fftWidthMenu );
-				
-				for( DFTSize width: DFTSize.values() )
-				{
-					fftWidthMenu.add( new DFTSizeItem( SpectralDisplayPanel.this, width ) );
-				}
+        @Override
+        public void mouseExited(MouseEvent e)
+        {
+            mOverlayPanel.setCursorVisible(false);
+            mWaterfallPanel.setCursorVisible(false);
+        }
 
-				/**
-				 * DFT Processor Frame Rate
-				 */
-				JMenu frameRateMenu = new JMenu( "Frame Rate" );
-				displayMenu.add(  frameRateMenu );
-				
-				frameRateMenu.add( new FrameRateItem( mDFTProcessor, 14 ) );
-				frameRateMenu.add( new FrameRateItem( mDFTProcessor, 16 ) );
-				frameRateMenu.add( new FrameRateItem( mDFTProcessor, 18 ) );
-				frameRateMenu.add( new FrameRateItem( mDFTProcessor, 20 ) );
-				frameRateMenu.add( new FrameRateItem( mDFTProcessor, 25 ) );
-				frameRateMenu.add( new FrameRateItem( mDFTProcessor, 30 ) );
-				frameRateMenu.add( new FrameRateItem( mDFTProcessor, 40 ) );
-				frameRateMenu.add( new FrameRateItem( mDFTProcessor, 50 ) );
+        /**
+         * Displays the context menu.
+         */
+        @Override
+        public void mouseClicked(MouseEvent event)
+        {
+            if(SwingUtilities.isRightMouseButton(event))
+            {
+                JPopupMenu contextMenu = new JPopupMenu();
 
-				/**
-				 * FFT Window Type
-				 */
-				JMenu fftWindowType = new JMenu( "Window Type" );
-				displayMenu.add( fftWindowType );
-				
-				for( WindowType type: WindowType.values() )
-				{
-					fftWindowType.add( 
-							new FFTWindowTypeItem( mDFTProcessor, type ) );
-				}
-				
-				if( event.getComponent() != mWaterfallPanel )
-				{
-					/**
-					 * Smoothing menu
-					 */
-					JMenu smoothingMenu = new JMenu( "Smoothing" );
+                if(event.getComponent() == mWaterfallPanel)
+                {
+                    contextMenu.add(new PauseItem(mWaterfallPanel, "Pause"));
+                }
 
-					if( mSpectrumPanel.getSmoothingType() != SmoothingType.NONE )
-					{
-						smoothingMenu.add( new SmoothingItem( mSpectrumPanel, 5 ) );
-						smoothingMenu.add( new JSeparator() );
-					}
-					smoothingMenu.add( new SmoothingTypeItem( mSpectrumPanel, SmoothingType.GAUSSIAN ) );
-					smoothingMenu.add( new SmoothingTypeItem( mSpectrumPanel, SmoothingType.TRIANGLE ) );
-					smoothingMenu.add( new SmoothingTypeItem( mSpectrumPanel, SmoothingType.RECTANGLE ) );
-					smoothingMenu.add( new SmoothingTypeItem( mSpectrumPanel, SmoothingType.NONE ) );
-					
-					displayMenu.add( smoothingMenu );
-				}
+                long frequency =
+                    mOverlayPanel.getFrequencyFromAxis(event.getX());
+
+                if(event.getComponent() == mOverlayPanel)
+                {
+                    ArrayList<Channel> channels =
+                        mOverlayPanel.getChannelsAtFrequency(frequency);
+
+                    for(Channel channel : channels)
+                    {
+                        JMenu channelMenu = ChannelUtils.getContextMenu(mChannelModel,
+                            mChannelProcessingManager, channel,
+                            SpectralDisplayPanel.this);
+
+                        if(channelMenu != null)
+                        {
+                            contextMenu.add(channelMenu);
+                        }
+                    }
+
+                    if(!channels.isEmpty())
+                    {
+                        contextMenu.add(new JSeparator());
+                    }
+
+                }
+
+                JMenu frequencyMenu = new JMenu(
+                    sCURSOR_FORMAT.format((float) frequency / 1000000.0f));
+
+                JMenu decoderMenu = new JMenu("Add Decoder");
+
+                for(DecoderType type : DecoderType.getPrimaryDecoders())
+                {
+                    decoderMenu.add(new DecoderItem(type, frequency));
+                }
+
+                frequencyMenu.add(decoderMenu);
+
+                contextMenu.add(frequencyMenu);
+
+                contextMenu.add(new JSeparator());
+
+                /**
+                 * Color Menus
+                 */
+                JMenu colorMenu = new JMenu("Color");
+
+                colorMenu.add(new ColorSettingMenuItem(mSettingsManager,
+                    ColorSettingName.CHANNEL_CONFIG));
+
+                colorMenu.add(new ColorSettingMenuItem(mSettingsManager,
+                    ColorSettingName.CHANNEL_CONFIG_PROCESSING));
+
+                colorMenu.add(new ColorSettingMenuItem(mSettingsManager,
+                    ColorSettingName.CHANNEL_CONFIG_SELECTED));
+
+                colorMenu.add(new ColorSettingMenuItem(mSettingsManager,
+                    ColorSettingName.SPECTRUM_CURSOR));
+
+                colorMenu.add(new ColorSettingMenuItem(mSettingsManager,
+                    ColorSettingName.SPECTRUM_LINE));
+
+                colorMenu.add(new ColorSettingMenuItem(mSettingsManager,
+                    ColorSettingName.SPECTRUM_BACKGROUND));
+
+                colorMenu.add(new ColorSettingMenuItem(mSettingsManager,
+                    ColorSettingName.SPECTRUM_GRADIENT_BOTTOM));
+
+                colorMenu.add(new ColorSettingMenuItem(mSettingsManager,
+                    ColorSettingName.SPECTRUM_GRADIENT_TOP));
+
+                contextMenu.add(colorMenu);
+
+                /**
+                 * Display items: fft and frame rate
+                 */
+                JMenu displayMenu = new JMenu("Display");
+                contextMenu.add(displayMenu);
+
+                if(event.getComponent() != mWaterfallPanel)
+                {
+                    /**
+                     * Averaging menu
+                     */
+                    JMenu averagingMenu = new JMenu("Averaging");
+                    averagingMenu.add(
+                        new AveragingItem(mSpectrumPanel, 4));
+                    displayMenu.add(averagingMenu);
+
+                    /**
+                     * Channel Display setting menu
+                     */
+                    JMenu channelDisplayMenu = new JMenu("Channel");
+
+                    channelDisplayMenu.add(new ChannelDisplayItem(
+                        mOverlayPanel, ChannelDisplay.ALL));
+                    channelDisplayMenu.add(new ChannelDisplayItem(
+                        mOverlayPanel, ChannelDisplay.ENABLED));
+                    channelDisplayMenu.add(new ChannelDisplayItem(
+                        mOverlayPanel, ChannelDisplay.NONE));
+
+                    displayMenu.add(channelDisplayMenu);
+                }
+
+
+                /**
+                 * FFT width
+                 */
+                JMenu fftWidthMenu = new JMenu("FFT Width");
+                displayMenu.add(fftWidthMenu);
+
+                for(DFTSize width : DFTSize.values())
+                {
+                    fftWidthMenu.add(new DFTSizeItem(SpectralDisplayPanel.this, width));
+                }
+
+                /**
+                 * DFT Processor Frame Rate
+                 */
+                JMenu frameRateMenu = new JMenu("Frame Rate");
+                displayMenu.add(frameRateMenu);
+
+                frameRateMenu.add(new FrameRateItem(mDFTProcessor, 14));
+                frameRateMenu.add(new FrameRateItem(mDFTProcessor, 16));
+                frameRateMenu.add(new FrameRateItem(mDFTProcessor, 18));
+                frameRateMenu.add(new FrameRateItem(mDFTProcessor, 20));
+                frameRateMenu.add(new FrameRateItem(mDFTProcessor, 25));
+                frameRateMenu.add(new FrameRateItem(mDFTProcessor, 30));
+                frameRateMenu.add(new FrameRateItem(mDFTProcessor, 40));
+                frameRateMenu.add(new FrameRateItem(mDFTProcessor, 50));
+
+                /**
+                 * FFT Window Type
+                 */
+                JMenu fftWindowType = new JMenu("Window Type");
+                displayMenu.add(fftWindowType);
+
+                for(WindowType type : WindowType.values())
+                {
+                    fftWindowType.add(
+                        new FFTWindowTypeItem(mDFTProcessor, type));
+                }
+
+                if(event.getComponent() != mWaterfallPanel)
+                {
+                    /**
+                     * Smoothing menu
+                     */
+                    JMenu smoothingMenu = new JMenu("Smoothing");
+
+                    if(mSpectrumPanel.getSmoothingType() != SmoothingType.NONE)
+                    {
+                        smoothingMenu.add(new SmoothingItem(mSpectrumPanel, 5));
+                        smoothingMenu.add(new JSeparator());
+                    }
+                    smoothingMenu.add(new SmoothingTypeItem(mSpectrumPanel, SmoothingType.GAUSSIAN));
+                    smoothingMenu.add(new SmoothingTypeItem(mSpectrumPanel, SmoothingType.TRIANGLE));
+                    smoothingMenu.add(new SmoothingTypeItem(mSpectrumPanel, SmoothingType.RECTANGLE));
+                    smoothingMenu.add(new SmoothingTypeItem(mSpectrumPanel, SmoothingType.NONE));
+
+                    displayMenu.add(smoothingMenu);
+                }
 
 				/*
 				 * Zoom menu 
 				 */
-				JMenuItem zoomMenu = new JMenu( "Zoom" );
+                JMenuItem zoomMenu = new JMenu("Zoom");
 
-				double windowOffset = (double)event.getX() / (double)getWidth();
-				
-				zoomMenu.add( new ZoomItem( frequency, windowOffset ) );
-				
-				contextMenu.add( zoomMenu );
-				
+                double windowOffset = (double) event.getX() / (double) getWidth();
 
-				if( contextMenu != null )
-				{
-					if( event.getComponent() == mOverlayPanel )
-					{
-						contextMenu.show( mOverlayPanel, 
-										  event.getX(), 
-										  event.getY() );
-					}
-					else
-					{
-						contextMenu.show( mWaterfallPanel, 
-										  event.getX(), 
-										  event.getY() );
-					}
-				}				
-			}
+                zoomMenu.add(new ZoomItem(frequency, windowOffset));
+
+                contextMenu.add(zoomMenu);
+
+
+                if(contextMenu != null)
+                {
+                    if(event.getComponent() == mOverlayPanel)
+                    {
+                        contextMenu.show(mOverlayPanel,
+                            event.getX(),
+                            event.getY());
+                    }
+                    else
+                    {
+                        contextMenu.show(mWaterfallPanel,
+                            event.getX(),
+                            event.getY());
+                    }
+                }
+            }
         }
-	}
-	
-	public class PauseItem extends JCheckBoxMenuItem
-	{
+    }
+
+    public class PauseItem extends JCheckBoxMenuItem
+    {
         private static final long serialVersionUID = 1L;
 
         private Pausable mPausable;
-        
-        public PauseItem( Pausable pausable, String label )
+
+        public PauseItem(Pausable pausable, String label)
         {
-        	super( label );
-        	
-        	final boolean paused = pausable.isPaused();
-        	
-        	setSelected( paused );
-        	
-        	mPausable = pausable;
-        	
-        	addActionListener( new ActionListener() 
-        	{
-				@Override
-                public void actionPerformed( ActionEvent e )
+            super(label);
+
+            final boolean paused = pausable.isPaused();
+
+            setSelected(paused);
+
+            mPausable = pausable;
+
+            addActionListener(new ActionListener()
+            {
+                @Override
+                public void actionPerformed(ActionEvent e)
                 {
-					EventQueue.invokeLater( new Runnable() 
-					{
-						@Override
+                    EventQueue.invokeLater(new Runnable()
+                    {
+                        @Override
                         public void run()
                         {
-							mPausable.setPaused( !paused );
+                            mPausable.setPaused(!paused);
                         }
-					} );
+                    });
                 }
-        	} );
+            });
         }
-	}
-	
-	public class ZoomItem extends JSlider
-	{
-		private static final long serialVersionUID = 1L;
+    }
 
-		private long mFrequency;
-		private double mWindowOffset;
-		
-		public ZoomItem( long frequency, double windowOffset )
-		{
-			super( NO_ZOOM, MAX_ZOOM, mZoom );
-			
-			mFrequency = frequency;
-			mWindowOffset = windowOffset;
-
-			Hashtable<Integer,JComponent> labels = new Hashtable<>();
-			labels.put( new Integer( 0 ), new JLabel( "1x" ) );
-			labels.put( new Integer( 1 ), new JLabel( "2x" ) );
-			labels.put( new Integer( 2 ), new JLabel( "4x" ) );
-			labels.put( new Integer( 3 ), new JLabel( "8x" ) );
-			labels.put( new Integer( 4 ), new JLabel( "16x" ) );
-			labels.put( new Integer( 5 ), new JLabel( "32x" ) );
-			labels.put( new Integer( 6 ), new JLabel( "64x" ) );
-			
-			setLabelTable( labels );
-			
-			setMajorTickSpacing( 1 );
-			setMinorTickSpacing( 1 );
-			setPaintTicks( true );
-			setPaintLabels( true );
-			
-			this.addChangeListener( new ChangeListener() 
-			{
-				@Override
-				public void stateChanged( ChangeEvent e )
-				{
-					setZoom( getValue(), mFrequency, mWindowOffset );
-				}
-			} );
-		}
-	}
-	
-	public class ChannelDisplayItem extends JCheckBoxMenuItem
-	{
+    public class ZoomItem extends JSlider
+    {
         private static final long serialVersionUID = 1L;
-        
+
+        private long mFrequency;
+        private double mWindowOffset;
+
+        public ZoomItem(long frequency, double windowOffset)
+        {
+            super(NO_ZOOM, MAX_ZOOM, mZoom);
+
+            mFrequency = frequency;
+            mWindowOffset = windowOffset;
+
+            Hashtable<Integer,JComponent> labels = new Hashtable<>();
+            labels.put(new Integer(0), new JLabel("1x"));
+            labels.put(new Integer(1), new JLabel("2x"));
+            labels.put(new Integer(2), new JLabel("4x"));
+            labels.put(new Integer(3), new JLabel("8x"));
+            labels.put(new Integer(4), new JLabel("16x"));
+            labels.put(new Integer(5), new JLabel("32x"));
+            labels.put(new Integer(6), new JLabel("64x"));
+
+            setLabelTable(labels);
+
+            setMajorTickSpacing(1);
+            setMinorTickSpacing(1);
+            setPaintTicks(true);
+            setPaintLabels(true);
+
+            this.addChangeListener(new ChangeListener()
+            {
+                @Override
+                public void stateChanged(ChangeEvent e)
+                {
+                    setZoom(getValue(), mFrequency, mWindowOffset);
+                }
+            });
+        }
+    }
+
+    public class ChannelDisplayItem extends JCheckBoxMenuItem
+    {
+        private static final long serialVersionUID = 1L;
+
         private OverlayPanel mOverlayPanel;
         private ChannelDisplay mChannelDisplay;
 
-        public ChannelDisplayItem( OverlayPanel panel, ChannelDisplay display )
+        public ChannelDisplayItem(OverlayPanel panel, ChannelDisplay display)
         {
-        	super( display.name() );
+            super(display.name());
 
-        	mOverlayPanel = panel;
-        	
-        	mChannelDisplay = display;
-        	
-        	setSelected( mOverlayPanel.getChannelDisplay() == mChannelDisplay );
-        	
-        	addActionListener( new ActionListener() 
-        	{
-				@Override
-                public void actionPerformed( ActionEvent e )
+            mOverlayPanel = panel;
+
+            mChannelDisplay = display;
+
+            setSelected(mOverlayPanel.getChannelDisplay() == mChannelDisplay);
+
+            addActionListener(new ActionListener()
+            {
+                @Override
+                public void actionPerformed(ActionEvent e)
                 {
-					EventQueue.invokeLater( new Runnable() 
-					{
-						@Override
+                    EventQueue.invokeLater(new Runnable()
+                    {
+                        @Override
                         public void run()
                         {
-							mOverlayPanel.setChannelDisplay( mChannelDisplay );
+                            mOverlayPanel.setChannelDisplay(mChannelDisplay);
                         }
-					} );
+                    });
                 }
-        	} );
+            });
         }
-	}
-	
-	/**
-	 * Context menu item to provide one-click access to starting a channel
-	 * processing with the selected decoder
-	 */
-	public class DecoderItem extends JMenuItem
-	{
+    }
+
+    /**
+     * Context menu item to provide one-click access to starting a channel
+     * processing with the selected decoder
+     */
+    public class DecoderItem extends JMenuItem
+    {
         private static final long serialVersionUID = 1L;
 
         private ChannelModel mChannelModel;
         private long mFrequency;
         private DecoderType mDecoder;
-        
-        public DecoderItem( DecoderType type, long frequency )
+
+        public DecoderItem(DecoderType type, long frequency)
         {
-        	super( type.getDisplayString() );
-        	
-        	mFrequency = frequency;
-        	mDecoder = type;
-        	
-        	addActionListener( new ActionListener() 
-        	{
-				@Override
-                public void actionPerformed( ActionEvent e )
+            super(type.getDisplayString());
+
+            mFrequency = frequency;
+            mDecoder = type;
+
+            addActionListener(new ActionListener()
+            {
+                @Override
+                public void actionPerformed(ActionEvent e)
                 {
-					mChannelModel.createChannel( mDecoder, mFrequency );
+                    mChannelModel.createChannel(mDecoder, mFrequency);
                 }
-        	} );
+            });
         }
-	}
+    }
 }