Resolves #151 - mpt1327 decoder configuration was not setting editor to modified on changes to traffic channel pool size or traffic channel timeout

This commit is contained in:
Denny
2017-01-28 16:59:58 -05:00
parent f63b05c1e4
commit f7c144ca16

View File

@@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* SDR Trunk * sdrtrunk
* Copyright (C) 2014-2016 Dennis Sheirer * Copyright (C) 2014-2017 Dennis Sheirer
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
@@ -14,33 +14,27 @@
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/> * along with this program. If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/ ******************************************************************************/
package module.decode.mpt1327; package module.decode.mpt1327;
import gui.editor.Editor;
import gui.editor.EditorValidationException;
import gui.editor.ValidatingEditor;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import module.decode.config.DecodeConfiguration;
import net.miginfocom.swing.MigLayout;
import controller.channel.Channel; import controller.channel.Channel;
import controller.channel.map.ChannelMap; import controller.channel.map.ChannelMap;
import controller.channel.map.ChannelMapManagerFrame; import controller.channel.map.ChannelMapManagerFrame;
import controller.channel.map.ChannelMapModel; import controller.channel.map.ChannelMapModel;
import gui.editor.Editor;
import gui.editor.EditorValidationException;
import gui.editor.ValidatingEditor;
import module.decode.config.DecodeConfiguration;
import net.miginfocom.swing.MigLayout;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
public class MPT1327DecoderEditor extends ValidatingEditor<Channel> public class MPT1327DecoderEditor extends ValidatingEditor<Channel>
{ {
@@ -55,7 +49,7 @@ public class MPT1327DecoderEditor extends ValidatingEditor<Channel>
private JSlider mTrafficChannelPoolSize; private JSlider mTrafficChannelPoolSize;
private ChannelMapModel mChannelMapModel; private ChannelMapModel mChannelMapModel;
public MPT1327DecoderEditor( ChannelMapModel channelMapModel ) public MPT1327DecoderEditor(ChannelMapModel channelMapModel)
{ {
mChannelMapModel = channelMapModel; mChannelMapModel = channelMapModel;
@@ -64,222 +58,224 @@ public class MPT1327DecoderEditor extends ValidatingEditor<Channel>
private void init() private void init()
{ {
setLayout( new MigLayout( "insets 0 0 0 0,wrap 4", "[right][grow,fill][right][grow,fill]", "" ) ); setLayout(new MigLayout("insets 0 0 0 0,wrap 4", "[right][grow,fill][right][grow,fill]", ""));
mAFC = new JCheckBox( "AFC: 3000 Hz" ); mAFC = new JCheckBox("AFC: 3000 Hz");
mAFC.setEnabled( false ); mAFC.setEnabled(false);
mAFC.setToolTipText( "AFC automatically adjusts the center frequency of the channel to " mAFC.setToolTipText("AFC automatically adjusts the center frequency of the channel to "
+ "correct/compensate for inaccuracies and frequency drift in the tuner" ); + "correct/compensate for inaccuracies and frequency drift in the tuner");
mAFC.addActionListener( new ActionListener() mAFC.addActionListener(new ActionListener()
{ {
@Override @Override
public void actionPerformed( ActionEvent arg0 ) public void actionPerformed(ActionEvent arg0)
{ {
setModified( true ); setModified(true);
if( mAFC.isSelected() && !mAFCMaximumCorrection.isEnabled() ) if(mAFC.isSelected() && !mAFCMaximumCorrection.isEnabled())
{ {
mAFCMaximumCorrection.setEnabled( true ); mAFCMaximumCorrection.setEnabled(true);
} }
else if( !mAFC.isSelected() && mAFCMaximumCorrection.isEnabled() ) else if(!mAFC.isSelected() && mAFCMaximumCorrection.isEnabled())
{ {
mAFCMaximumCorrection.setEnabled( false ); mAFCMaximumCorrection.setEnabled(false);
} }
} }
} ); });
add( mAFC ); add(mAFC);
mAFCMaximumCorrection = new JSlider( 0, 7000, 3000 ); mAFCMaximumCorrection = new JSlider(0, 7000, 3000);
mAFCMaximumCorrection.setEnabled( false ); mAFCMaximumCorrection.setEnabled(false);
mAFCMaximumCorrection.setToolTipText( "Maximum AFC frequency correction (0 - 15kHz)" ); mAFCMaximumCorrection.setToolTipText("Maximum AFC frequency correction (0 - 15kHz)");
mAFCMaximumCorrection.setMajorTickSpacing( 2000 ); mAFCMaximumCorrection.setMajorTickSpacing(2000);
mAFCMaximumCorrection.setMinorTickSpacing( 1000 ); mAFCMaximumCorrection.setMinorTickSpacing(1000);
mAFCMaximumCorrection.setPaintTicks( true ); mAFCMaximumCorrection.setPaintTicks(true);
mAFCMaximumCorrection.addChangeListener( new ChangeListener() mAFCMaximumCorrection.addChangeListener(new ChangeListener()
{ {
@Override @Override
public void stateChanged( ChangeEvent e ) public void stateChanged(ChangeEvent e)
{ {
mAFC.setText( "AFC: " + mAFCMaximumCorrection.getValue() + " Hz" ); mAFC.setText("AFC: " + mAFCMaximumCorrection.getValue() + " Hz");
setModified( true ); setModified(true);
} }
} ); });
add( mAFCMaximumCorrection ); add(mAFCMaximumCorrection);
JButton channelMaps = new JButton( "Channel Maps" ); JButton channelMaps = new JButton("Channel Maps");
channelMaps.addActionListener( new ActionListener() channelMaps.addActionListener(new ActionListener()
{ {
@Override @Override
public void actionPerformed( ActionEvent e ) public void actionPerformed(ActionEvent e)
{ {
final ChannelMapManagerFrame manager = final ChannelMapManagerFrame manager =
new ChannelMapManagerFrame( mChannelMapModel ); new ChannelMapManagerFrame(mChannelMapModel);
EventQueue.invokeLater( new Runnable() EventQueue.invokeLater(new Runnable()
{ {
@Override @Override
public void run() public void run()
{ {
manager.setVisible( true ); manager.setVisible(true);
} }
} ); });
} }
} ); });
add( channelMaps, "span 2" ); add(channelMaps, "span 2");
List<ChannelMap> maps = mChannelMapModel.getChannelMaps(); List<ChannelMap> maps = mChannelMapModel.getChannelMaps();
ChannelMap[] mapArray = maps.toArray( new ChannelMap[ maps.size() ] ); ChannelMap[] mapArray = maps.toArray(new ChannelMap[maps.size()]);
mComboChannelMaps = new JComboBox<ChannelMap>(); mComboChannelMaps = new JComboBox<ChannelMap>();
mComboChannelMaps.setModel( new DefaultComboBoxModel<ChannelMap>( mapArray ) ); mComboChannelMaps.setModel(new DefaultComboBoxModel<ChannelMap>(mapArray));
mComboChannelMaps.setEnabled( false ); mComboChannelMaps.setEnabled(false);
add( new JLabel( "Channel Map:" ) ); add(new JLabel("Channel Map:"));
add( mComboChannelMaps, "span 3,grow" ); add(mComboChannelMaps, "span 3,grow");
mTrafficChannelPoolSize = new JSlider( JSlider.HORIZONTAL, DecodeConfiguration.TRAFFIC_CHANNEL_LIMIT_MINIMUM, mTrafficChannelPoolSize = new JSlider(JSlider.HORIZONTAL, DecodeConfiguration.TRAFFIC_CHANNEL_LIMIT_MINIMUM,
DecodeConfiguration.TRAFFIC_CHANNEL_LIMIT_MAXIMUM, DecodeConfiguration.TRAFFIC_CHANNEL_LIMIT_DEFAULT ); DecodeConfiguration.TRAFFIC_CHANNEL_LIMIT_MAXIMUM, DecodeConfiguration.TRAFFIC_CHANNEL_LIMIT_DEFAULT);
mTrafficChannelPoolSize.setEnabled( false ); mTrafficChannelPoolSize.setEnabled(false);
mTrafficChannelPoolSize.setMajorTickSpacing( 10 ); mTrafficChannelPoolSize.setMajorTickSpacing(10);
mTrafficChannelPoolSize.setMinorTickSpacing( 5 ); mTrafficChannelPoolSize.setMinorTickSpacing(5);
mTrafficChannelPoolSize.setPaintTicks( true ); mTrafficChannelPoolSize.setPaintTicks(true);
mTrafficChannelPoolSizeLabel = new JLabel( "Traffic Pool: " + mTrafficChannelPoolSizeLabel = new JLabel("Traffic Pool: " +
mTrafficChannelPoolSize.getValue() + " " ); mTrafficChannelPoolSize.getValue() + " ");
mTrafficChannelPoolSize.addChangeListener( new ChangeListener() mTrafficChannelPoolSize.addChangeListener(new ChangeListener()
{ {
@Override @Override
public void stateChanged( ChangeEvent e ) public void stateChanged(ChangeEvent e)
{ {
mTrafficChannelPoolSizeLabel.setText( "Traffic Pool: " + mTrafficChannelPoolSizeLabel.setText("Traffic Pool: " +
mTrafficChannelPoolSize.getValue() ); mTrafficChannelPoolSize.getValue());
setModified(true);
} }
} ); });
add( mTrafficChannelPoolSizeLabel ); add(mTrafficChannelPoolSizeLabel);
add( mTrafficChannelPoolSize ); add(mTrafficChannelPoolSize);
mCallTimeout = new JSlider( JSlider.HORIZONTAL, DecodeConfiguration.CALL_TIMEOUT_MINIMUM, mCallTimeout = new JSlider(JSlider.HORIZONTAL, DecodeConfiguration.CALL_TIMEOUT_MINIMUM,
DecodeConfiguration.CALL_TIMEOUT_MAXIMUM, DecodeConfiguration.DEFAULT_CALL_TIMEOUT_SECONDS ); DecodeConfiguration.CALL_TIMEOUT_MAXIMUM, DecodeConfiguration.DEFAULT_CALL_TIMEOUT_SECONDS);
mCallTimeout.setEnabled( false ); mCallTimeout.setEnabled(false);
mCallTimeout.setMajorTickSpacing( 100 ); mCallTimeout.setMajorTickSpacing(100);
mCallTimeout.setMinorTickSpacing( 50 ); mCallTimeout.setMinorTickSpacing(50);
mCallTimeout.setPaintTicks( true ); mCallTimeout.setPaintTicks(true);
mCallTimeoutLabel = new JLabel( "Timeout: " + mCallTimeout.getValue() + " " ); mCallTimeoutLabel = new JLabel("Timeout: " + mCallTimeout.getValue() + " ");
mCallTimeout.addChangeListener( new ChangeListener() mCallTimeout.addChangeListener(new ChangeListener()
{ {
@Override @Override
public void stateChanged( ChangeEvent e ) public void stateChanged(ChangeEvent e)
{ {
mCallTimeoutLabel.setText( "Timeout: " + mCallTimeout.getValue() ); mCallTimeoutLabel.setText("Timeout: " + mCallTimeout.getValue());
setModified(true);
} }
} ); });
add( mCallTimeoutLabel ); add(mCallTimeoutLabel);
add( mCallTimeout ); add(mCallTimeout);
} }
@Override @Override
public void save() public void save()
{ {
if( hasItem() && isModified() ) if(hasItem() && isModified())
{ {
DecodeConfigMPT1327 mpt = new DecodeConfigMPT1327(); DecodeConfigMPT1327 mpt = new DecodeConfigMPT1327();
mpt.setAFC( mAFC.isSelected() ); mpt.setAFC(mAFC.isSelected());
mpt.setAFCMaximumCorrection( mAFCMaximumCorrection.getValue() ); mpt.setAFCMaximumCorrection(mAFCMaximumCorrection.getValue());
mpt.setTrafficChannelPoolSize( mTrafficChannelPoolSize.getValue() ); mpt.setTrafficChannelPoolSize(mTrafficChannelPoolSize.getValue());
mpt.setCallTimeout( mCallTimeout.getValue() ); mpt.setCallTimeout(mCallTimeout.getValue());
if( mComboChannelMaps.getSelectedItem() != null ) if(mComboChannelMaps.getSelectedItem() != null)
{ {
ChannelMap map = (ChannelMap)mComboChannelMaps.getSelectedItem(); ChannelMap map = (ChannelMap)mComboChannelMaps.getSelectedItem();
mpt.setChannelMapName( map.getName() ); mpt.setChannelMapName(map.getName());
} }
getItem().setDecodeConfiguration( mpt ); getItem().setDecodeConfiguration(mpt);
} }
setModified( false ); setModified(false);
} }
@Override @Override
public void validate( Editor<Channel> editor ) throws EditorValidationException public void validate(Editor<Channel> editor) throws EditorValidationException
{ {
//No validation required //No validation required
} }
private void setControlsEnabled( boolean enabled ) private void setControlsEnabled(boolean enabled)
{ {
if( mAFC.isEnabled() != enabled ) if(mAFC.isEnabled() != enabled)
{ {
mAFC.setEnabled( enabled ); mAFC.setEnabled(enabled);
} }
if( mComboChannelMaps.isEnabled() != enabled ) if(mComboChannelMaps.isEnabled() != enabled)
{ {
mComboChannelMaps.setEnabled( enabled ); mComboChannelMaps.setEnabled(enabled);
} }
if( mTrafficChannelPoolSize.isEnabled() != enabled ) if(mTrafficChannelPoolSize.isEnabled() != enabled)
{ {
mTrafficChannelPoolSize.setEnabled( enabled ); mTrafficChannelPoolSize.setEnabled(enabled);
} }
if( mCallTimeout.isEnabled() != enabled ) if(mCallTimeout.isEnabled() != enabled)
{ {
mCallTimeout.setEnabled( enabled ); mCallTimeout.setEnabled(enabled);
} }
} }
@Override @Override
public void setItem( Channel item ) public void setItem(Channel item)
{ {
super.setItem( item ); super.setItem(item);
if( hasItem() ) if(hasItem())
{ {
setControlsEnabled( true ); setControlsEnabled(true);
DecodeConfiguration config = getItem().getDecodeConfiguration(); DecodeConfiguration config = getItem().getDecodeConfiguration();
if( config instanceof DecodeConfigMPT1327 ) if(config instanceof DecodeConfigMPT1327)
{ {
DecodeConfigMPT1327 mpt = (DecodeConfigMPT1327)config; DecodeConfigMPT1327 mpt = (DecodeConfigMPT1327)config;
mAFC.setSelected( mpt.isAFCEnabled() ); mAFC.setSelected(mpt.isAFCEnabled());
mAFCMaximumCorrection.setValue( mpt.getAFCMaximumCorrection() ); mAFCMaximumCorrection.setValue(mpt.getAFCMaximumCorrection());
mAFCMaximumCorrection.setEnabled( mpt.isAFCEnabled() ); mAFCMaximumCorrection.setEnabled(mpt.isAFCEnabled());
ChannelMap map = mChannelMapModel.getChannelMap( mpt.getChannelMapName() ); ChannelMap map = mChannelMapModel.getChannelMap(mpt.getChannelMapName());
if( map != null ) if(map != null)
{ {
mComboChannelMaps.setSelectedItem( map ); mComboChannelMaps.setSelectedItem(map);
} }
mTrafficChannelPoolSize.setValue( mpt.getTrafficChannelPoolSize() ); mTrafficChannelPoolSize.setValue(mpt.getTrafficChannelPoolSize());
mCallTimeout.setValue( mpt.getCallTimeout() ); mCallTimeout.setValue(mpt.getCallTimeout());
setModified( false ); setModified(false);
} }
else else
{ {
mAFC.setSelected( false ); mAFC.setSelected(false);
mAFCMaximumCorrection.setValue( DecodeConfiguration.DEFAULT_AFC_MAX_CORRECTION ); mAFCMaximumCorrection.setValue(DecodeConfiguration.DEFAULT_AFC_MAX_CORRECTION);
mAFCMaximumCorrection.setEnabled( false ); mAFCMaximumCorrection.setEnabled(false);
mTrafficChannelPoolSize.setValue( DecodeConfiguration.TRAFFIC_CHANNEL_LIMIT_DEFAULT ); mTrafficChannelPoolSize.setValue(DecodeConfiguration.TRAFFIC_CHANNEL_LIMIT_DEFAULT);
mCallTimeout.setValue( DecodeConfiguration.DEFAULT_CALL_TIMEOUT_SECONDS ); mCallTimeout.setValue(DecodeConfiguration.DEFAULT_CALL_TIMEOUT_SECONDS);
setModified( true ); setModified(true);
} }
} }
else else
{ {
setControlsEnabled( false ); setControlsEnabled(false);
setModified( false ); setModified(false);
} }
} }
} }