mirror of
https://github.com/DSheirer/sdrtrunk.git
synced 2026-11-17 02:57:35 -05:00
Compare commits
8 Commits
2660-now-p
...
2673-spect
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
99d61ac24d | ||
|
|
feeedb7c29 | ||
|
|
6dd06288ac | ||
|
|
5fd469c402 | ||
|
|
0bc5d6db64 | ||
|
|
80754558d6 | ||
|
|
2f9d52a56a | ||
|
|
5474a5a448 |
37
README.md
37
README.md
@@ -1,7 +1,30 @@
|
||||

|
||||

|
||||
[](https://github.com/DSheirer/sdrtrunk/releases/latest)
|
||||
[](https://github.com/DSheirer/sdrtrunk/releases)
|
||||
[](LICENSE)
|
||||
[](https://discord.gg/HJQaKYE)
|
||||
|
||||
# MacOS Tahoe 26.1 Users - Attention:
|
||||
# sdrtrunk
|
||||
A cross-platform java application for decoding, monitoring, recording and streaming trunked mobile and related radio protocols using Software Defined Radios (SDR).
|
||||
|
||||
> ## 📖 [Read the sdrtrunk User Manual](https://github.com/DSheirer/sdrtrunk/wiki/User-Manual)
|
||||
> New to sdrtrunk? Start with the **[Getting Started](https://github.com/DSheirer/sdrtrunk/wiki/Getting-Started)** guide,
|
||||
> then use the **[User Manual](https://github.com/DSheirer/sdrtrunk/wiki/User-Manual)** and
|
||||
> **[How-To Guides](https://github.com/DSheirer/sdrtrunk/wiki/How-To-Guides)** to set up tuners, playlists, aliases and streaming.
|
||||
|
||||
* [Help/Wiki Home Page](https://github.com/DSheirer/sdrtrunk/wiki)
|
||||
* [Getting Started](https://github.com/DSheirer/sdrtrunk/wiki/Getting-Started)
|
||||
* [User Manual](https://github.com/DSheirer/sdrtrunk/wiki/User-Manual)
|
||||
* [How-To Guides](https://github.com/DSheirer/sdrtrunk/wiki/How-To-Guides)
|
||||
* [FAQ](https://github.com/DSheirer/sdrtrunk/wiki/FAQ)
|
||||
* [Download](https://github.com/DSheirer/sdrtrunk/releases)
|
||||
* [Support](https://github.com/DSheirer/sdrtrunk/wiki/Support)
|
||||
|
||||

|
||||
**Figure 1:** sdrtrunk decoding a P25 Phase 1 simulcast trunked radio system
|
||||
|
||||
## MacOS Tahoe 26.1 Users - Attention
|
||||
Changes to USB support in Tahoe version 26.x cause sdrtrunk to fail to launch. Do the following to install the latest libusb and create a symbolic link and then use the nightly build which includes an updated usb4java native library for Tahoe with ARM processor. There may still be issue(s) with MacOS accessing your USB SDR tuners.
|
||||
|
||||
```
|
||||
@@ -19,18 +42,6 @@ Finally, create a symbolic link from the installed library to the place where us
|
||||
sudo ln -s /opt/homebrew/Cellar/libusb/HEAD-9ceaa52/lib/libusb-1.0.0.dylib /opt/local/lib/libusb-1.0.0.dylib
|
||||
```
|
||||
|
||||
# sdrtrunk
|
||||
A cross-platform java application for decoding, monitoring, recording and streaming trunked mobile and related radio protocols using Software Defined Radios (SDR).
|
||||
|
||||
* [Help/Wiki Home Page](https://github.com/DSheirer/sdrtrunk/wiki)
|
||||
* [Getting Started](https://github.com/DSheirer/sdrtrunk/wiki/Getting-Started)
|
||||
* [User's Manual](https://github.com/DSheirer/sdrtrunk/wiki/User-Manual)
|
||||
* [Download](https://github.com/DSheirer/sdrtrunk/releases)
|
||||
* [Support](https://github.com/DSheirer/sdrtrunk/wiki/Support)
|
||||
|
||||

|
||||
**Figure 1:** sdrtrunk Application Screenshot
|
||||
|
||||
## Download the Latest Release
|
||||
All release versions of sdrtrunk are available from the [releases](https://github.com/DSheirer/sdrtrunk/releases) tab.
|
||||
|
||||
|
||||
@@ -840,11 +840,16 @@ public class SDRTrunk implements Listener<TunerEvent>
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the title bar with the tuner name
|
||||
* Updates the title bar with the tuner name. No-op when running headless (no main window).
|
||||
* @param tunerName optional
|
||||
*/
|
||||
private void updateTitle(String tunerName)
|
||||
{
|
||||
if(mMainGui == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if(tunerName != null)
|
||||
{
|
||||
mMainGui.setTitle(mTitle + " - " + tunerName);
|
||||
|
||||
@@ -40,6 +40,7 @@ import io.github.dsheirer.preference.UserPreferences;
|
||||
import io.github.dsheirer.preference.identifier.TalkgroupFormatPreference;
|
||||
import io.github.dsheirer.sample.Broadcaster;
|
||||
import io.github.dsheirer.sample.Listener;
|
||||
import io.github.dsheirer.source.tuner.channel.TunerChannelSource;
|
||||
import java.text.DecimalFormat;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
@@ -356,6 +357,21 @@ public class ChannelMetadataView extends VBox implements ChannelMetadataModel.Li
|
||||
frequency.setCellFactory(NowPlayingCells.formatted(value -> frequencyFormat.format(value / 1e6d)));
|
||||
columns.add(frequency);
|
||||
|
||||
//Tuner that sources the channel
|
||||
columns.add(NowPlayingCells.column("tuner", "Tuner", null, Pos.CENTER,
|
||||
row -> getTunerName(row.getChannelMetadata()), Row::revisionProperty));
|
||||
|
||||
//System and site labels from the channel configuration, hidden by default
|
||||
TableColumn<Row,String> system = NowPlayingCells.column("system", "System", null, Pos.CENTER,
|
||||
row -> toText(row.getChannelMetadata().getSystemConfigurationIdentifier()), Row::revisionProperty);
|
||||
system.setVisible(false);
|
||||
columns.add(system);
|
||||
|
||||
TableColumn<Row,String> site = NowPlayingCells.column("site", "Site", null, Pos.CENTER,
|
||||
row -> toText(row.getChannelMetadata().getSiteConfigurationIdentifier()), Row::revisionProperty);
|
||||
site.setVisible(false);
|
||||
columns.add(site);
|
||||
|
||||
columns.add(NowPlayingCells.column("channel.name", "Channel Name", null, Pos.CENTER,
|
||||
row -> toText(row.getChannelMetadata().getChannelNameConfigurationIdentifier()), Row::revisionProperty));
|
||||
|
||||
@@ -365,7 +381,8 @@ public class ChannelMetadataView extends VBox implements ChannelMetadataModel.Li
|
||||
column.setSortable(false);
|
||||
}
|
||||
|
||||
//Column numbers in the Swing version of the table, for its stored column widths. Talker is a new column.
|
||||
//Column numbers in the Swing version of the table, for its stored column widths. Talker, Tuner, System and Site are new
|
||||
//columns.
|
||||
String[] swingColumns = {"status", "decoder", "from", "from.alias", "to", "to.alias", "channel", "frequency",
|
||||
"channel.name"};
|
||||
|
||||
@@ -382,6 +399,22 @@ public class ChannelMetadataView extends VBox implements ChannelMetadataModel.Li
|
||||
return columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Name of the tuner that sources the channel, or null if the channel isn't sourced by a tuner.
|
||||
*/
|
||||
private String getTunerName(ChannelMetadata channelMetadata)
|
||||
{
|
||||
Channel channel = mChannelMetadataModel.getChannelFromMetadata(channelMetadata);
|
||||
ProcessingChain processingChain = channel != null ? mChannelProcessingManager.getProcessingChain(channel) : null;
|
||||
|
||||
if(processingChain != null && processingChain.getSource() instanceof TunerChannelSource tunerChannelSource)
|
||||
{
|
||||
return tunerChannelSource.getTunerName();
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decoder logical channel name with the timeslot, if any
|
||||
*/
|
||||
|
||||
@@ -27,6 +27,7 @@ import io.github.dsheirer.gui.playlist.channel.ChannelEditor;
|
||||
import io.github.dsheirer.gui.playlist.channel.ChannelTabRequest;
|
||||
import io.github.dsheirer.gui.playlist.manager.PlaylistManagerEditor;
|
||||
import io.github.dsheirer.gui.playlist.radioreference.RadioReferenceEditor;
|
||||
import io.github.dsheirer.gui.playlist.radioreference.ViewRadioReferenceRequest;
|
||||
import io.github.dsheirer.gui.playlist.streaming.StreamingEditor;
|
||||
import io.github.dsheirer.gui.preference.PreferenceEditorType;
|
||||
import io.github.dsheirer.gui.preference.ViewUserPreferenceEditorRequest;
|
||||
@@ -77,6 +78,7 @@ public class PlaylistEditor extends BorderPane
|
||||
private Tab mStreamingTab;
|
||||
private AliasEditor mAliasEditor;
|
||||
private ChannelEditor mChannelEditor;
|
||||
private RadioReferenceEditor mRadioReferenceEditor;
|
||||
|
||||
/**
|
||||
* Constructs an instance
|
||||
@@ -122,6 +124,13 @@ public class PlaylistEditor extends BorderPane
|
||||
getChannelEditor().process((ChannelTabRequest)request);
|
||||
}
|
||||
break;
|
||||
case RADIOREFERENCE:
|
||||
if(request instanceof ViewRadioReferenceRequest viewRequest)
|
||||
{
|
||||
getTabPane().getSelectionModel().select(getRadioReferenceTab());
|
||||
getRadioReferenceEditor().view(viewRequest);
|
||||
}
|
||||
break;
|
||||
case PLAYLIST:
|
||||
//Ignore - this is a request to simply show te playlist editor
|
||||
break;
|
||||
@@ -266,12 +275,22 @@ public class PlaylistEditor extends BorderPane
|
||||
if(mRadioReferenceTab == null)
|
||||
{
|
||||
mRadioReferenceTab = new Tab("Radio Reference");
|
||||
mRadioReferenceTab.setContent(new RadioReferenceEditor(mUserPreferences, mPlaylistManager));
|
||||
mRadioReferenceTab.setContent(getRadioReferenceEditor());
|
||||
}
|
||||
|
||||
return mRadioReferenceTab;
|
||||
}
|
||||
|
||||
private RadioReferenceEditor getRadioReferenceEditor()
|
||||
{
|
||||
if(mRadioReferenceEditor == null)
|
||||
{
|
||||
mRadioReferenceEditor = new RadioReferenceEditor(mUserPreferences, mPlaylistManager);
|
||||
}
|
||||
|
||||
return mRadioReferenceEditor;
|
||||
}
|
||||
|
||||
private Tab getStreamingTab()
|
||||
{
|
||||
if(mStreamingTab == null)
|
||||
|
||||
@@ -55,6 +55,8 @@ public class AgencyEditor extends VBox
|
||||
private ListView<Agency> mAgencyListView;
|
||||
private AgencyFrequencyEditor mAgencyFrequencyEditor;
|
||||
private IntegerProperty mAgencyCountProperty = new SimpleIntegerProperty();
|
||||
private Integer mPendingAgencyId;
|
||||
private AgencyFrequencyEditor.FrequencyTarget mPendingFrequency;
|
||||
|
||||
/**
|
||||
* Constructs an instance
|
||||
@@ -109,6 +111,56 @@ public class AgencyEditor extends VBox
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepares to show the agency with the frequency selected when the agencies are next set
|
||||
* @param agencyId of the agency, or the negative county id for a county's own frequencies
|
||||
* @param frequency to select, or null
|
||||
*/
|
||||
public void prepareView(int agencyId, AgencyFrequencyEditor.FrequencyTarget frequency)
|
||||
{
|
||||
mUserPreferences.getRadioReferencePreference().setPreferredAgencyId(agencyId, mLevel);
|
||||
mPendingAgencyId = agencyId;
|
||||
mPendingFrequency = frequency;
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows the agency with the frequency selected
|
||||
* @param agencyId of the agency, or the negative county id for a county's own frequencies
|
||||
* @param frequency to select, or null
|
||||
* @return false when the editor doesn't list the agency
|
||||
*/
|
||||
public boolean view(int agencyId, AgencyFrequencyEditor.FrequencyTarget frequency)
|
||||
{
|
||||
prepareView(agencyId, frequency);
|
||||
|
||||
for(Agency agency: getAgencyListView().getItems())
|
||||
{
|
||||
if(agency.getAgencyId() == agencyId)
|
||||
{
|
||||
if(getAgencyListView().getSelectionModel().getSelectedItem() == agency)
|
||||
{
|
||||
//Already shown - select the frequency in the shown categories
|
||||
mPendingAgencyId = null;
|
||||
mPendingFrequency = null;
|
||||
|
||||
if(frequency != null)
|
||||
{
|
||||
getAgencyFrequencyEditor().viewFrequency(frequency);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
getAgencyListView().getSelectionModel().select(agency);
|
||||
}
|
||||
|
||||
getAgencyListView().scrollTo(agency);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return getAgencyListView().getItems().isEmpty();
|
||||
}
|
||||
|
||||
public void clear()
|
||||
{
|
||||
getAgencyListView().getItems().clear();
|
||||
@@ -155,6 +207,17 @@ public class AgencyEditor extends VBox
|
||||
{
|
||||
getAgencyFrequencyEditor().clearAndSetLoading();
|
||||
|
||||
if(mPendingAgencyId != null && mPendingAgencyId == agency.getAgencyId())
|
||||
{
|
||||
if(mPendingFrequency != null)
|
||||
{
|
||||
getAgencyFrequencyEditor().viewFrequency(mPendingFrequency);
|
||||
}
|
||||
|
||||
mPendingAgencyId = null;
|
||||
mPendingFrequency = null;
|
||||
}
|
||||
|
||||
mUserPreferences.getRadioReferencePreference().setPreferredAgencyId(agency.getAgencyId(), mLevel);
|
||||
|
||||
ThreadPool.CACHED.submit(() -> {
|
||||
|
||||
@@ -68,6 +68,21 @@ public class AgencyFrequencyEditor extends GridPane
|
||||
private Level mLevel;
|
||||
private ComboBox<Category> mCategoryComboBox;
|
||||
private ComboBox<SubCategory> mSubCategoryComboBox;
|
||||
private FrequencyTarget mPendingFrequency;
|
||||
private boolean mLoadingFrequencies;
|
||||
|
||||
/**
|
||||
* Frequency to select in the editor
|
||||
* @param category name, or null
|
||||
* @param subCategory name, or null
|
||||
* @param frequencyHz downlink frequency
|
||||
* @param description of the frequency, or null
|
||||
* @param alphaTag of the frequency, or null
|
||||
*/
|
||||
public record FrequencyTarget(String category, String subCategory, long frequencyHz, String description,
|
||||
String alphaTag)
|
||||
{
|
||||
}
|
||||
private TableView<Frequency> mFrequencyTableView;
|
||||
private Label mPlaceholderLabel;
|
||||
private ProgressIndicator mProgressIndicator;
|
||||
@@ -165,7 +180,11 @@ public class AgencyFrequencyEditor extends GridPane
|
||||
sorted.add(0, ALL_CATEGORIES);
|
||||
}
|
||||
getCategoryComboBox().getItems().addAll(sorted);
|
||||
getCategoryComboBox().getSelectionModel().select(sorted.get(0));
|
||||
|
||||
if(mPendingFrequency == null || !selectPendingFrequency())
|
||||
{
|
||||
getCategoryComboBox().getSelectionModel().select(sorted.get(0));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -173,6 +192,115 @@ public class AgencyFrequencyEditor extends GridPane
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects the frequency in its category and subcategory, now or once the categories are set
|
||||
*/
|
||||
public void viewFrequency(FrequencyTarget target)
|
||||
{
|
||||
mPendingFrequency = target;
|
||||
|
||||
if(!getCategoryComboBox().getItems().isEmpty())
|
||||
{
|
||||
selectPendingFrequency();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects the pending frequency's category and subcategory, which loads the frequencies, or selects the frequency
|
||||
* when they're already shown.
|
||||
* @return false when the categories don't include the frequency's category
|
||||
*/
|
||||
private boolean selectPendingFrequency()
|
||||
{
|
||||
FrequencyTarget target = mPendingFrequency;
|
||||
Category category = null;
|
||||
|
||||
for(Category candidate: getCategoryComboBox().getItems())
|
||||
{
|
||||
if(candidate != ALL_CATEGORIES && candidate.getName() != null &&
|
||||
candidate.getName().equals(target.category()))
|
||||
{
|
||||
category = candidate;
|
||||
}
|
||||
}
|
||||
|
||||
if(category == null)
|
||||
{
|
||||
mPendingFrequency = null;
|
||||
return false;
|
||||
}
|
||||
|
||||
if(getCategoryComboBox().getValue() != category)
|
||||
{
|
||||
getCategoryComboBox().getSelectionModel().select(category);
|
||||
}
|
||||
|
||||
SubCategory subCategory = null;
|
||||
|
||||
for(SubCategory candidate: getSubCategoryComboBox().getItems())
|
||||
{
|
||||
if(candidate != ALL_SUB_CATEGORIES && candidate.getName() != null &&
|
||||
candidate.getName().equals(target.subCategory()))
|
||||
{
|
||||
subCategory = candidate;
|
||||
}
|
||||
}
|
||||
|
||||
if(subCategory != null && getSubCategoryComboBox().getValue() != subCategory)
|
||||
{
|
||||
//Loading the subcategory frequencies selects the frequency
|
||||
getSubCategoryComboBox().getSelectionModel().select(subCategory);
|
||||
}
|
||||
else if(!mLoadingFrequencies)
|
||||
{
|
||||
selectFrequency();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects the pending frequency in the frequencies table: the one with the same description or alpha tag, or else
|
||||
* the first one with the same frequency
|
||||
*/
|
||||
private void selectFrequency()
|
||||
{
|
||||
FrequencyTarget target = mPendingFrequency;
|
||||
mPendingFrequency = null;
|
||||
|
||||
if(target == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Frequency match = null;
|
||||
|
||||
for(Frequency frequency: getFrequencyTableView().getItems())
|
||||
{
|
||||
if(frequency.getDownlinkHz() == target.frequencyHz())
|
||||
{
|
||||
boolean same = (target.description() != null && target.description().equals(frequency.getDescription())) ||
|
||||
(target.alphaTag() != null && target.alphaTag().equals(frequency.getAlphaTag()));
|
||||
|
||||
if(same)
|
||||
{
|
||||
match = frequency;
|
||||
break;
|
||||
}
|
||||
else if(match == null)
|
||||
{
|
||||
match = frequency;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(match != null)
|
||||
{
|
||||
getFrequencyTableView().getSelectionModel().select(match);
|
||||
getFrequencyTableView().scrollTo(match);
|
||||
}
|
||||
}
|
||||
|
||||
private FrequencyEditor getFrequencyEditor()
|
||||
{
|
||||
if(mFrequencyEditor == null)
|
||||
@@ -400,6 +528,7 @@ public class AgencyFrequencyEditor extends GridPane
|
||||
getFrequencyTableView().getItems().clear();
|
||||
|
||||
SubCategory subCategory = mSubCategoryComboBox.getValue();
|
||||
mLoadingFrequencies = subCategory != null;
|
||||
|
||||
if(subCategory != null)
|
||||
{
|
||||
@@ -453,14 +582,23 @@ public class AgencyFrequencyEditor extends GridPane
|
||||
}
|
||||
|
||||
Platform.runLater(() -> {
|
||||
//Another subcategory was selected while loading - its frequencies are shown instead
|
||||
if(getSubCategoryComboBox().getValue() != subCategory)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
mLoadingFrequencies = false;
|
||||
getFrequencyTableView().getItems().addAll(frequencies);
|
||||
setLoading(false);
|
||||
selectFrequency();
|
||||
});
|
||||
}
|
||||
catch(Throwable t)
|
||||
{
|
||||
mLog.error("Error retrieving frequencies for subcategory [" + subCategory.getName() + "]", t);
|
||||
Platform.runLater(() -> {
|
||||
mLoadingFrequencies = false;
|
||||
setLoading(false);
|
||||
new RadioReferenceUnavailableAlert(getSubCategoryComboBox()).showAndWait();
|
||||
});
|
||||
|
||||
@@ -26,12 +26,17 @@ import io.github.dsheirer.preference.PreferenceType;
|
||||
import io.github.dsheirer.preference.UserPreferences;
|
||||
import io.github.dsheirer.preference.radioreference.RadioReferencePreference;
|
||||
import io.github.dsheirer.rrapi.RadioReferenceException;
|
||||
import io.github.dsheirer.rrapi.RadioReferenceService;
|
||||
import io.github.dsheirer.rrapi.type.AgencyInfo;
|
||||
import io.github.dsheirer.rrapi.type.Agency;
|
||||
import io.github.dsheirer.rrapi.type.AuthorizationInformation;
|
||||
import io.github.dsheirer.rrapi.type.Country;
|
||||
import io.github.dsheirer.rrapi.type.CountryInfo;
|
||||
import io.github.dsheirer.rrapi.type.County;
|
||||
import io.github.dsheirer.rrapi.type.CountyInfo;
|
||||
import io.github.dsheirer.rrapi.type.Site;
|
||||
import io.github.dsheirer.rrapi.type.SystemInformation;
|
||||
import io.github.dsheirer.service.radioreference.FrequencyCandidate;
|
||||
import io.github.dsheirer.rrapi.type.State;
|
||||
import io.github.dsheirer.rrapi.type.StateInfo;
|
||||
import io.github.dsheirer.service.radioreference.RadioReference;
|
||||
@@ -41,7 +46,9 @@ import javafx.application.Platform;
|
||||
import javafx.beans.binding.Bindings;
|
||||
import javafx.geometry.Insets;
|
||||
import javafx.geometry.Pos;
|
||||
import javafx.scene.control.Alert;
|
||||
import javafx.scene.control.Button;
|
||||
import javafx.scene.control.ButtonType;
|
||||
import javafx.scene.control.ComboBox;
|
||||
import javafx.scene.control.Label;
|
||||
import javafx.scene.control.Tab;
|
||||
@@ -62,7 +69,9 @@ import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
@@ -168,8 +177,6 @@ public class RadioReferenceEditor extends BorderPane implements Consumer<Authori
|
||||
{
|
||||
getCountryComboBox().getItems().clear();
|
||||
|
||||
final int preferredCountryId = mUserPreferences.getRadioReferencePreference().getPreferredCountryId();
|
||||
|
||||
ThreadPool.CACHED.execute(() -> {
|
||||
try
|
||||
{
|
||||
@@ -177,6 +184,8 @@ public class RadioReferenceEditor extends BorderPane implements Consumer<Authori
|
||||
|
||||
Platform.runLater(() -> {
|
||||
getCountryComboBox().getItems().addAll(countries);
|
||||
//Read when the list arrives, so a view request made while loading is honored
|
||||
int preferredCountryId = mUserPreferences.getRadioReferencePreference().getPreferredCountryId();
|
||||
|
||||
if(preferredCountryId >= 0)
|
||||
{
|
||||
@@ -199,6 +208,342 @@ public class RadioReferenceEditor extends BorderPane implements Consumer<Authori
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Where a view request's system or frequency is listed in the editor
|
||||
* @param countryId of the country
|
||||
* @param stateId of the state
|
||||
* @param countyId of the county, or 0 for a state level listing
|
||||
* @param level of the listing: COUNTY or STATE
|
||||
* @param systemId of the trunked system, or null for an agency
|
||||
* @param siteId of the site to select, or -1
|
||||
* @param agencyId of the agency, or the negative county id for a county's own frequencies, or null for a system
|
||||
* @param frequency to select in the agency, or null
|
||||
*/
|
||||
private record ViewTarget(int countryId, int stateId, int countyId, Level level, Integer systemId, int siteId,
|
||||
Integer agencyId, AgencyFrequencyEditor.FrequencyTarget frequency)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows the request's trunked system site or conventional frequency: selects its country, state and county, the
|
||||
* tab that lists it, and the system and site or the agency and frequency. Finds where it's listed in the
|
||||
* background.
|
||||
*/
|
||||
public void view(ViewRadioReferenceRequest request)
|
||||
{
|
||||
ThreadPool.CACHED.execute(() -> {
|
||||
try
|
||||
{
|
||||
ViewTarget target = resolve(request);
|
||||
|
||||
Platform.runLater(() -> {
|
||||
if(target == null)
|
||||
{
|
||||
showViewError("Radio Reference doesn't list where this " +
|
||||
(request.getSystemId() != null ? "system" : "frequency") + " is listed.");
|
||||
}
|
||||
else
|
||||
{
|
||||
navigate(target);
|
||||
}
|
||||
});
|
||||
}
|
||||
catch(RadioReferenceException rre)
|
||||
{
|
||||
mLog.error("Error finding radio reference listing to view - " + rre.getMessage());
|
||||
Platform.runLater(() -> new RadioReferenceUnavailableAlert(getTabPane()).showAndWait());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds where the request's system or frequency is listed. Call from a background thread.
|
||||
* @return target, or null when it can't be found
|
||||
*/
|
||||
private ViewTarget resolve(ViewRadioReferenceRequest request) throws RadioReferenceException
|
||||
{
|
||||
RadioReferenceService service = mRadioReference.getService();
|
||||
|
||||
if(request.getSystemId() != null)
|
||||
{
|
||||
int systemId = request.getSystemId();
|
||||
int siteId = request.getSiteId() != null ? request.getSiteId() : -1;
|
||||
//The site's county first, then the system's counties, then its states
|
||||
Set<Integer> countyIds = new LinkedHashSet<>();
|
||||
|
||||
for(Site site: nonNull(service.getSites(systemId)))
|
||||
{
|
||||
if(site.getSiteId() == siteId && isCounty(site.getCountyId()))
|
||||
{
|
||||
countyIds.add(site.getCountyId());
|
||||
}
|
||||
}
|
||||
|
||||
SystemInformation systemInformation = service.getSystemInformation(systemId);
|
||||
|
||||
if(systemInformation != null)
|
||||
{
|
||||
for(County county: nonNull(systemInformation.getCounties()))
|
||||
{
|
||||
if(isCounty(county.getCountyId()))
|
||||
{
|
||||
countyIds.add(county.getCountyId());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Limit the requests for systems that span many counties
|
||||
int checked = 0;
|
||||
|
||||
for(Integer countyId: countyIds)
|
||||
{
|
||||
if(checked++ >= 10)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
CountyInfo countyInfo = service.getCountyInfo(countyId);
|
||||
|
||||
if(countyInfo != null && nonNull(countyInfo.getSystems()).stream()
|
||||
.anyMatch(system -> system.getSystemId() == systemId))
|
||||
{
|
||||
return new ViewTarget(getCountryId(service, countyInfo.getStateId()), countyInfo.getStateId(),
|
||||
countyId, Level.COUNTY, systemId, siteId, null, null);
|
||||
}
|
||||
}
|
||||
|
||||
if(systemInformation != null)
|
||||
{
|
||||
for(State state: nonNull(systemInformation.getStates()))
|
||||
{
|
||||
StateInfo stateInfo = service.getStateInfo(state.getStateId());
|
||||
|
||||
if(stateInfo != null && nonNull(stateInfo.getSystems()).stream()
|
||||
.anyMatch(system -> system.getSystemId() == systemId))
|
||||
{
|
||||
return new ViewTarget(getCountryId(service, state.getStateId()), state.getStateId(), 0,
|
||||
Level.STATE, systemId, siteId, null, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
String key = request.getSourceKey();
|
||||
AgencyFrequencyEditor.FrequencyTarget frequency = getFrequencyTarget(request.getCandidate());
|
||||
|
||||
if(key != null && key.startsWith("county:"))
|
||||
{
|
||||
int countyId = Integer.parseInt(key.substring("county:".length()));
|
||||
CountyInfo countyInfo = service.getCountyInfo(countyId);
|
||||
|
||||
if(countyInfo != null)
|
||||
{
|
||||
return new ViewTarget(getCountryId(service, countyInfo.getStateId()), countyInfo.getStateId(),
|
||||
countyId, Level.COUNTY, null, -1, -countyId, frequency);
|
||||
}
|
||||
}
|
||||
else if(key != null && key.startsWith("agency:"))
|
||||
{
|
||||
int agencyId = Integer.parseInt(key.substring("agency:".length()));
|
||||
AgencyInfo agencyInfo = service.getAgencyInfo(agencyId);
|
||||
|
||||
if(agencyInfo != null && isCounty(agencyInfo.getCountyId()))
|
||||
{
|
||||
CountyInfo countyInfo = service.getCountyInfo(agencyInfo.getCountyId());
|
||||
|
||||
if(countyInfo != null && nonNull(countyInfo.getAgencies()).stream()
|
||||
.anyMatch(agency -> agency.getAgencyId() == agencyId))
|
||||
{
|
||||
return new ViewTarget(getCountryId(service, countyInfo.getStateId()), countyInfo.getStateId(),
|
||||
countyInfo.getCountyId(), Level.COUNTY, null, -1, agencyId, frequency);
|
||||
}
|
||||
}
|
||||
|
||||
if(agencyInfo != null && agencyInfo.getStateId() > 0)
|
||||
{
|
||||
StateInfo stateInfo = service.getStateInfo(agencyInfo.getStateId());
|
||||
|
||||
if(stateInfo != null && nonNull(stateInfo.getAgencies()).stream()
|
||||
.anyMatch(agency -> agency.getAgencyId() == agencyId))
|
||||
{
|
||||
return new ViewTarget(getCountryId(service, stateInfo.getStateId()), stateInfo.getStateId(), 0,
|
||||
Level.STATE, null, -1, agencyId, frequency);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Frequency to select for the candidate: its source is the owner, category and subcategory
|
||||
*/
|
||||
private static AgencyFrequencyEditor.FrequencyTarget getFrequencyTarget(FrequencyCandidate candidate)
|
||||
{
|
||||
if(candidate == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
String[] source = candidate.source() != null ? candidate.source().split(" › ") : new String[0];
|
||||
String category = source.length >= 3 ? source[source.length - 2] : null;
|
||||
String subCategory = source.length >= 3 ? source[source.length - 1] : null;
|
||||
return new AgencyFrequencyEditor.FrequencyTarget(category, subCategory, candidate.frequencyHz(),
|
||||
candidate.title(), candidate.alphaTag());
|
||||
}
|
||||
|
||||
/**
|
||||
* Country of the state: the preferred country when it has the state, or else the first country that has it
|
||||
*/
|
||||
private int getCountryId(RadioReferenceService service, int stateId) throws RadioReferenceException
|
||||
{
|
||||
int preferredCountryId = mUserPreferences.getRadioReferencePreference().getPreferredCountryId();
|
||||
List<Integer> countryIds = new ArrayList<>();
|
||||
|
||||
if(preferredCountryId > 0)
|
||||
{
|
||||
countryIds.add(preferredCountryId);
|
||||
}
|
||||
|
||||
for(Country country: nonNull(service.getCountries()))
|
||||
{
|
||||
if(country.getCountryId() != preferredCountryId)
|
||||
{
|
||||
countryIds.add(country.getCountryId());
|
||||
}
|
||||
}
|
||||
|
||||
for(Integer countryId: countryIds)
|
||||
{
|
||||
CountryInfo countryInfo = service.getCountryInfo(countryId);
|
||||
|
||||
if(countryInfo != null && nonNull(countryInfo.getStates()).stream()
|
||||
.anyMatch(state -> state.getStateId() == stateId))
|
||||
{
|
||||
return countryId;
|
||||
}
|
||||
}
|
||||
|
||||
return preferredCountryId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicates if the county id is a real county. Temporary sites in an unknown county have county id 99999.
|
||||
*/
|
||||
private static boolean isCounty(int countyId)
|
||||
{
|
||||
return countyId > 0 && countyId != 99999;
|
||||
}
|
||||
|
||||
private static <T> List<T> nonNull(List<T> list)
|
||||
{
|
||||
return list != null ? list : List.of();
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects the target's country, state and county, its tab, and its system or agency. Selecting a country, state
|
||||
* or county loads the lists below it, which select the preferred ids set here, so only the first selection that
|
||||
* changes is made here.
|
||||
*/
|
||||
private void navigate(ViewTarget target)
|
||||
{
|
||||
RadioReferencePreference preference = mUserPreferences.getRadioReferencePreference();
|
||||
preference.setPreferredCountryId(target.countryId());
|
||||
preference.setPreferredStateId(target.stateId());
|
||||
|
||||
if(target.countyId() > 0)
|
||||
{
|
||||
preference.setPreferredCountyId(target.countyId());
|
||||
}
|
||||
|
||||
SystemEditor systemEditor = target.level() == Level.COUNTY ? getCountySystemEditor() : getStateSystemEditor();
|
||||
AgencyEditor agencyEditor = target.level() == Level.COUNTY ? getCountyAgencyEditor() : getStateAgencyEditor();
|
||||
|
||||
if(target.systemId() != null)
|
||||
{
|
||||
systemEditor.prepareView(target.systemId(), target.siteId());
|
||||
getTabPane().getSelectionModel().select(target.level() == Level.COUNTY ? getCountySystemTab() :
|
||||
getStateSystemTab());
|
||||
}
|
||||
else
|
||||
{
|
||||
agencyEditor.prepareView(target.agencyId(), target.frequency());
|
||||
getTabPane().getSelectionModel().select(target.level() == Level.COUNTY ? getCountyAgencyTab() :
|
||||
getStateAgencyTab());
|
||||
}
|
||||
|
||||
//Lists that are still loading select the preferred ids when they arrive
|
||||
Country country = getCountryComboBox().getItems().stream()
|
||||
.filter(item -> item.getCountryId() == target.countryId()).findFirst().orElse(null);
|
||||
|
||||
if(country == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if(getCountryComboBox().getValue() != country)
|
||||
{
|
||||
getCountryComboBox().getSelectionModel().select(country);
|
||||
return;
|
||||
}
|
||||
|
||||
State state = getStateComboBox().getItems().stream()
|
||||
.filter(item -> item.getStateId() == target.stateId()).findFirst().orElse(null);
|
||||
|
||||
if(state == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if(getStateComboBox().getValue() != state)
|
||||
{
|
||||
getStateComboBox().getSelectionModel().select(state);
|
||||
return;
|
||||
}
|
||||
|
||||
if(target.level() == Level.COUNTY)
|
||||
{
|
||||
County county = getCountyComboBox().getItems().stream()
|
||||
.filter(item -> item.getCountyId() == target.countyId()).findFirst().orElse(null);
|
||||
|
||||
if(county == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if(getCountyComboBox().getValue() != county)
|
||||
{
|
||||
getCountyComboBox().getSelectionModel().select(county);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
boolean listed = target.systemId() != null ? systemEditor.view(target.systemId(), target.siteId()) :
|
||||
agencyEditor.view(target.agencyId(), target.frequency());
|
||||
|
||||
if(!listed)
|
||||
{
|
||||
showViewError("The Radio Reference tab doesn't list this " + (target.systemId() != null ? "system" :
|
||||
"agency") + ".");
|
||||
}
|
||||
}
|
||||
|
||||
private void showViewError(String message)
|
||||
{
|
||||
Alert alert = new Alert(Alert.AlertType.INFORMATION, message, ButtonType.OK);
|
||||
alert.setTitle("Radio Reference");
|
||||
alert.setHeaderText("Can't show the Radio Reference listing");
|
||||
|
||||
if(getScene() != null)
|
||||
{
|
||||
alert.initOwner(getScene().getWindow());
|
||||
}
|
||||
|
||||
alert.show();
|
||||
}
|
||||
|
||||
private TabPane getTabPane()
|
||||
{
|
||||
if(mTabPane == null)
|
||||
@@ -596,8 +941,6 @@ public class RadioReferenceEditor extends BorderPane implements Consumer<Authori
|
||||
|
||||
if(country != null)
|
||||
{
|
||||
int preferredStateId = mUserPreferences.getRadioReferencePreference().getPreferredStateId();
|
||||
|
||||
ThreadPool.CACHED.execute(() -> {
|
||||
try
|
||||
{
|
||||
@@ -606,6 +949,7 @@ public class RadioReferenceEditor extends BorderPane implements Consumer<Authori
|
||||
Platform.runLater(() -> {
|
||||
getNationalAgencyEditor().setAgencies(countryInfo.getAgencies());
|
||||
getStateComboBox().getItems().addAll(countryInfo.getStates());
|
||||
int preferredStateId = mUserPreferences.getRadioReferencePreference().getPreferredStateId();
|
||||
|
||||
for(State state: mStateComboBox.getItems())
|
||||
{
|
||||
@@ -652,8 +996,6 @@ public class RadioReferenceEditor extends BorderPane implements Consumer<Authori
|
||||
clearEditors(Level.STATE);
|
||||
getCountyComboBox().getItems().clear();
|
||||
|
||||
int preferredCountyId = mUserPreferences.getRadioReferencePreference().getPreferredCountyId();
|
||||
|
||||
if(state != null)
|
||||
{
|
||||
ThreadPool.CACHED.execute(() -> {
|
||||
@@ -665,6 +1007,7 @@ public class RadioReferenceEditor extends BorderPane implements Consumer<Authori
|
||||
getStateAgencyEditor().setAgencies(stateInfo.getAgencies());
|
||||
getStateSystemEditor().setSystems(stateInfo.getSystems());
|
||||
getCountyComboBox().getItems().addAll(stateInfo.getCounties());
|
||||
int preferredCountyId = mUserPreferences.getRadioReferencePreference().getPreferredCountyId();
|
||||
|
||||
for(County county: mCountyComboBox.getItems())
|
||||
{
|
||||
|
||||
@@ -47,7 +47,7 @@ import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Playlist actions for radio reference frequencies and trunked system sites: find the playlist channel that already
|
||||
* decodes a frequency or site, enable or disable it, or add a channel and start it. A frequency or site that already
|
||||
* decodes a frequency or site, enable or disable it, or add a channel and optionally start it. A frequency or site that already
|
||||
* has a playlist channel with the same protocol isn't added again.
|
||||
*
|
||||
* The add, enable and disable actions run in the background and report errors to the caller's error handler, on the
|
||||
@@ -452,6 +452,17 @@ public class RadioReferencePlaylistActions
|
||||
* @param firstFrequency to start the new control channel on, e.g. the frequency the user picked, or null
|
||||
*/
|
||||
public void addSite(SiteRecord siteRecord, Long firstFrequency, Consumer<String> onError)
|
||||
{
|
||||
addSite(siteRecord, firstFrequency, true, onError);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds playlist channels for the trunked system site, like {@link #addSite(SiteRecord, Long, Consumer)}, and
|
||||
* optionally starts them.
|
||||
* @param firstFrequency to start the new control channel on, e.g. the frequency the user picked, or null
|
||||
* @param start true to start the new channels, or the site's existing channels
|
||||
*/
|
||||
public void addSite(SiteRecord siteRecord, Long firstFrequency, boolean start, Consumer<String> onError)
|
||||
{
|
||||
ThreadPool.CACHED.execute(() -> {
|
||||
SiteDetails details = getSiteDetails(siteRecord, onError);
|
||||
@@ -475,14 +486,21 @@ public class RadioReferencePlaylistActions
|
||||
return;
|
||||
}
|
||||
|
||||
enableAll(existing, onError);
|
||||
if(start)
|
||||
{
|
||||
enableAll(existing, onError);
|
||||
}
|
||||
|
||||
//The channel model's list backs the playlist editor, so it's changed on the JavaFX thread
|
||||
Platform.runLater(() -> {
|
||||
for(Channel channel: channels)
|
||||
{
|
||||
mPlaylistManager.getChannelModel().addChannel(channel);
|
||||
enable(channel, onError);
|
||||
|
||||
if(start)
|
||||
{
|
||||
enable(channel, onError);
|
||||
}
|
||||
}
|
||||
});
|
||||
return;
|
||||
@@ -499,7 +517,7 @@ public class RadioReferencePlaylistActions
|
||||
return;
|
||||
}
|
||||
|
||||
addAndStart(channel, onError);
|
||||
add(channel, start, onError);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -507,6 +525,16 @@ public class RadioReferencePlaylistActions
|
||||
* Adds a playlist channel for one repeater of a repeater site (LTR) and starts it, or starts its existing channel
|
||||
*/
|
||||
public void addRepeater(SiteRecord siteRecord, long frequency, Consumer<String> onError)
|
||||
{
|
||||
addRepeater(siteRecord, frequency, true, onError);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a playlist channel for one repeater of a repeater site (LTR) unless the playlist has one, and optionally
|
||||
* starts the channel
|
||||
* @param start true to start the new or existing channel
|
||||
*/
|
||||
public void addRepeater(SiteRecord siteRecord, long frequency, boolean start, Consumer<String> onError)
|
||||
{
|
||||
ThreadPool.CACHED.execute(() -> {
|
||||
SiteDetails details = getSiteDetails(siteRecord, onError);
|
||||
@@ -526,7 +554,7 @@ public class RadioReferencePlaylistActions
|
||||
return;
|
||||
}
|
||||
|
||||
addAndStart(channels.get(0), onError);
|
||||
add(channels.get(0), start, onError);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -534,6 +562,16 @@ public class RadioReferencePlaylistActions
|
||||
* Adds a playlist channel for the conventional frequency and starts it, or starts the existing channel
|
||||
*/
|
||||
public void addConventional(FrequencyCandidate candidate, Consumer<String> onError)
|
||||
{
|
||||
addConventional(candidate, true, onError);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a playlist channel for the conventional frequency unless the playlist has one, and optionally starts the
|
||||
* channel
|
||||
* @param start true to start the new or existing channel
|
||||
*/
|
||||
public void addConventional(FrequencyCandidate candidate, boolean start, Consumer<String> onError)
|
||||
{
|
||||
ModeDecoderType mode = ModeDecoderType.fromName(candidate.mode());
|
||||
String[] source = candidate.source() != null ? candidate.source().split(" › ") : new String[0];
|
||||
@@ -550,28 +588,36 @@ public class RadioReferencePlaylistActions
|
||||
return;
|
||||
}
|
||||
|
||||
addAndStart(channel, onError);
|
||||
add(channel, start, onError);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the channel to the playlist and starts it, unless the playlist already has a channel for its frequencies
|
||||
* and protocol, which is started instead
|
||||
* Adds the channel to the playlist and optionally starts it, unless the playlist already has a channel for its
|
||||
* frequencies and protocol, which is started instead when starting
|
||||
*/
|
||||
private void addAndStart(Channel channel, Consumer<String> onError)
|
||||
private void add(Channel channel, boolean start, Consumer<String> onError)
|
||||
{
|
||||
Channel existing = findChannel(getFrequencies(channel.getSourceConfiguration()),
|
||||
getProtocolFamily(channel.getDecodeConfiguration().getDecoderType()));
|
||||
|
||||
if(existing != null)
|
||||
{
|
||||
enable(existing, onError);
|
||||
if(start)
|
||||
{
|
||||
enable(existing, onError);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
//The channel model's list backs the playlist editor, so it's changed on the JavaFX thread
|
||||
Platform.runLater(() -> {
|
||||
mPlaylistManager.getChannelModel().addChannel(channel);
|
||||
enable(channel, onError);
|
||||
|
||||
if(start)
|
||||
{
|
||||
enable(channel, onError);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -156,6 +156,41 @@ public class SystemEditor extends VBox
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepares to show the system with the site selected when the systems are next set.
|
||||
* @param systemId of the system
|
||||
* @param siteId to select, or -1 for none
|
||||
*/
|
||||
public void prepareView(int systemId, int siteId)
|
||||
{
|
||||
mUserPreferences.getRadioReferencePreference().setPreferredSystemId(systemId, mLevel);
|
||||
getTabPane().getSelectionModel().select(getSystemTab());
|
||||
getSystemSiteSelectionEditor().viewSite(systemId, siteId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows the system with the site selected
|
||||
* @param systemId of the system
|
||||
* @param siteId to select, or -1 for none
|
||||
* @return false when the editor doesn't list the system
|
||||
*/
|
||||
public boolean view(int systemId, int siteId)
|
||||
{
|
||||
prepareView(systemId, siteId);
|
||||
|
||||
for(System system: getSystemComboBox().getItems())
|
||||
{
|
||||
if(system.getSystemId() == systemId)
|
||||
{
|
||||
//Selecting the shown system again doesn't reload it - the site is selected in the shown system
|
||||
getSystemComboBox().getSelectionModel().select(system);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return getSystemComboBox().getItems().isEmpty();
|
||||
}
|
||||
|
||||
private TabPane getTabPane()
|
||||
{
|
||||
if(mTabPane == null)
|
||||
|
||||
@@ -58,6 +58,8 @@ public class SystemSiteSelectionEditor extends GridPane
|
||||
private UserPreferences mUserPreferences;
|
||||
private PlaylistManager mPlaylistManager;
|
||||
private ProgressIndicator mProgressIndicator;
|
||||
private int mPendingSystemId = -1;
|
||||
private int mPendingSiteId = -1;
|
||||
private Label mPlaceholderLabel;
|
||||
private Label mProtocolLabel;
|
||||
private Label mFlavorLabel;
|
||||
@@ -132,6 +134,46 @@ public class SystemSiteSelectionEditor extends GridPane
|
||||
Collections.sort(sites, Ordering.natural());
|
||||
getSiteTableView().getItems().addAll(sites);
|
||||
setLoading(false);
|
||||
|
||||
if(system != null && system.getSystemId() == mPendingSystemId)
|
||||
{
|
||||
selectSite(mPendingSiteId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects the site once the system is shown, or now when it's already shown.
|
||||
* @param systemId of the system
|
||||
* @param siteId to select, or -1 for none
|
||||
*/
|
||||
public void viewSite(int systemId, int siteId)
|
||||
{
|
||||
if(mCurrentSystem != null && mCurrentSystem.getSystemId() == systemId &&
|
||||
!getSiteTableView().getItems().isEmpty())
|
||||
{
|
||||
selectSite(siteId);
|
||||
}
|
||||
else
|
||||
{
|
||||
mPendingSystemId = systemId;
|
||||
mPendingSiteId = siteId;
|
||||
}
|
||||
}
|
||||
|
||||
private void selectSite(int siteId)
|
||||
{
|
||||
mPendingSystemId = -1;
|
||||
mPendingSiteId = -1;
|
||||
|
||||
for(EnrichedSite site: getSiteTableView().getItems())
|
||||
{
|
||||
if(site.getSite() != null && site.getSite().getSiteId() == siteId)
|
||||
{
|
||||
getSiteTableView().getSelectionModel().select(site);
|
||||
getSiteTableView().scrollTo(site);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void clear()
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
/*
|
||||
* *****************************************************************************
|
||||
* Copyright (C) 2014-2026 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 io.github.dsheirer.gui.playlist.radioreference;
|
||||
|
||||
import io.github.dsheirer.gui.playlist.PlaylistEditorRequest;
|
||||
import io.github.dsheirer.service.radioreference.FrequencyCandidate;
|
||||
|
||||
/**
|
||||
* Request to show a trunked system site, or a conventional frequency, in the playlist editor's Radio Reference tab
|
||||
*/
|
||||
public class ViewRadioReferenceRequest extends PlaylistEditorRequest
|
||||
{
|
||||
private final Integer mSystemId;
|
||||
private final Integer mSiteId;
|
||||
private final String mSourceKey;
|
||||
private final FrequencyCandidate mCandidate;
|
||||
|
||||
private ViewRadioReferenceRequest(Integer systemId, Integer siteId, String sourceKey, FrequencyCandidate candidate)
|
||||
{
|
||||
mSystemId = systemId;
|
||||
mSiteId = siteId;
|
||||
mSourceKey = sourceKey;
|
||||
mCandidate = candidate;
|
||||
}
|
||||
|
||||
/**
|
||||
* Request to show a trunked system with the site selected
|
||||
* @param systemId radio reference system id
|
||||
* @param siteId radio reference site id, or null to show the system only
|
||||
*/
|
||||
public static ViewRadioReferenceRequest site(int systemId, Integer siteId)
|
||||
{
|
||||
return new ViewRadioReferenceRequest(systemId, siteId, null, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Request to show a conventional frequency in the county or agency that lists it
|
||||
* @param sourceKey of the county or agency that lists the frequency: county:123 or agency:789
|
||||
* @param candidate frequency to select
|
||||
*/
|
||||
public static ViewRadioReferenceRequest frequency(String sourceKey, FrequencyCandidate candidate)
|
||||
{
|
||||
return new ViewRadioReferenceRequest(null, null, sourceKey, candidate);
|
||||
}
|
||||
|
||||
/**
|
||||
* Radio reference system id, or null for a conventional frequency
|
||||
*/
|
||||
public Integer getSystemId()
|
||||
{
|
||||
return mSystemId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Radio reference site id, or null
|
||||
*/
|
||||
public Integer getSiteId()
|
||||
{
|
||||
return mSiteId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Key of the county or agency that lists the conventional frequency, or null for a trunked system
|
||||
*/
|
||||
public String getSourceKey()
|
||||
{
|
||||
return mSourceKey;
|
||||
}
|
||||
|
||||
/**
|
||||
* Conventional frequency to select, or null for a trunked system
|
||||
*/
|
||||
public FrequencyCandidate getCandidate()
|
||||
{
|
||||
return mCandidate;
|
||||
}
|
||||
|
||||
@Override
|
||||
public TabName getTabName()
|
||||
{
|
||||
return TabName.RADIOREFERENCE;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
/*
|
||||
* *****************************************************************************
|
||||
* Copyright (C) 2014-2026 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 io.github.dsheirer.gui.spectrum;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Channel shown in the display's Channels hover card
|
||||
* @param title of the channel, drawn in the color of its state
|
||||
* @param details lines
|
||||
* @param state of the channel: an enabled or disabled playlist channel, or a radio reference candidate
|
||||
* @param key identifying the channel, e.g. the playlist channel, so the card lists it once, or null
|
||||
* @param prompts true when the entry is reason to show the card, e.g. the channel's labels don't fit in its box, or
|
||||
* false when it's only listed while the card is shown for other entries
|
||||
*/
|
||||
public record ChannelCardEntry(String title, List<String> details, ChannelMenus.State state, Object key,
|
||||
boolean prompts)
|
||||
{
|
||||
}
|
||||
399
src/main/java/io/github/dsheirer/gui/spectrum/ChannelMenus.java
Normal file
399
src/main/java/io/github/dsheirer/gui/spectrum/ChannelMenus.java
Normal file
@@ -0,0 +1,399 @@
|
||||
/*
|
||||
* *****************************************************************************
|
||||
* Copyright (C) 2014-2026 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 io.github.dsheirer.gui.spectrum;
|
||||
|
||||
import io.github.dsheirer.controller.channel.Channel;
|
||||
import io.github.dsheirer.eventbus.MyEventBus;
|
||||
import io.github.dsheirer.gui.playlist.channel.ViewChannelRequest;
|
||||
import io.github.dsheirer.source.tuner.channel.TunerChannel;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.text.DecimalFormat;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Base64;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import javafx.event.Event;
|
||||
import javafx.event.EventHandler;
|
||||
import javafx.scene.Node;
|
||||
import javafx.scene.Scene;
|
||||
import javafx.scene.control.ContextMenu;
|
||||
import javafx.scene.control.Label;
|
||||
import javafx.scene.control.Menu;
|
||||
import javafx.scene.control.MenuItem;
|
||||
import javafx.scene.control.SeparatorMenuItem;
|
||||
import javafx.scene.layout.VBox;
|
||||
import javafx.scene.paint.Color;
|
||||
import javafx.stage.WindowEvent;
|
||||
|
||||
/**
|
||||
* Context menu entries of the Channels section, shared by the playlist channel and radio reference layers. Each
|
||||
* channel is a submenu showing its title and details, like the display's hover cards, with the actions for its state.
|
||||
* The entries have the display theme's colors: the card background, with the title colored by state - the theme's
|
||||
* active color (a green) for an enabled playlist channel, its inactive color (a blue) for a disabled one, and its
|
||||
* plain text color for a radio reference candidate that isn't in the playlist.
|
||||
*/
|
||||
public final class ChannelMenus
|
||||
{
|
||||
/**
|
||||
* Context menu section of the channel entries
|
||||
*/
|
||||
public static final String SECTION = "Channels";
|
||||
|
||||
private static final DecimalFormat FREQUENCY_FORMAT = new DecimalFormat("0.00000");
|
||||
private static final String STYLE_ITEM = "channel-menu-item";
|
||||
private static final String STYLE_TITLE = "channel-menu-title";
|
||||
private static final String STYLE_DETAIL = "channel-menu-detail";
|
||||
private static final String STYLE_NOTE = "channel-menu-note";
|
||||
//Minimum contrast ratio of the colored text against the menu background
|
||||
private static final double MIN_CONTRAST = 3.0;
|
||||
|
||||
/**
|
||||
* State of a channel entry, which sets its color
|
||||
*/
|
||||
public enum State
|
||||
{
|
||||
ENABLED("channel-menu-enabled"),
|
||||
DISABLED("channel-menu-disabled"),
|
||||
CANDIDATE("channel-menu-candidate");
|
||||
|
||||
private final String mStyleClass;
|
||||
|
||||
State(String styleClass)
|
||||
{
|
||||
mStyleClass = styleClass;
|
||||
}
|
||||
|
||||
public String getStyleClass()
|
||||
{
|
||||
return mStyleClass;
|
||||
}
|
||||
}
|
||||
|
||||
private ChannelMenus()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Channel entry submenu showing the title and details
|
||||
* @param title of the channel
|
||||
* @param details line, or null
|
||||
* @param state of the channel
|
||||
* @param key identifying the channel, e.g. the playlist channel, so the display lists it once, or null
|
||||
*/
|
||||
public static Menu createEntry(String title, String details, State state, Object key)
|
||||
{
|
||||
Label titleLabel = new Label(title);
|
||||
titleLabel.getStyleClass().add(STYLE_TITLE);
|
||||
VBox box = new VBox(titleLabel);
|
||||
|
||||
if(details != null)
|
||||
{
|
||||
Label detailLabel = new Label(details);
|
||||
detailLabel.getStyleClass().add(STYLE_DETAIL);
|
||||
box.getChildren().add(detailLabel);
|
||||
}
|
||||
|
||||
Menu menu = new Menu(null, box);
|
||||
menu.getStyleClass().addAll(STYLE_ITEM, state.getStyleClass());
|
||||
menu.setUserData(key);
|
||||
return menu;
|
||||
}
|
||||
|
||||
/**
|
||||
* Entry for a playlist channel: enable or disable it, and view or edit it in the playlist editor
|
||||
* @param channel in the playlist
|
||||
* @param tunerChannel of the channel to describe, or null for the channel's first
|
||||
* @param toggle that enables the channel when it's disabled or disables it when it's enabled, or null when the
|
||||
* channel can't be started or stopped from the menu, e.g. a traffic channel
|
||||
*/
|
||||
public static Menu createChannelEntry(Channel channel, TunerChannel tunerChannel, Runnable toggle)
|
||||
{
|
||||
boolean processing = channel.isProcessing();
|
||||
State state = getState(channel);
|
||||
Menu menu = createEntry(getTitle(channel), String.join(" \u00B7 ", getDetails(channel, tunerChannel)), state,
|
||||
channel);
|
||||
|
||||
if(toggle != null)
|
||||
{
|
||||
menu.getItems().add(createItem(processing ? "Disable" : "Enable", state, toggle));
|
||||
}
|
||||
|
||||
menu.getItems().add(createItem("View/Edit in Playlist", state,
|
||||
() -> MyEventBus.getGlobalEventBus().post(new ViewChannelRequest(channel))));
|
||||
return menu;
|
||||
}
|
||||
|
||||
/**
|
||||
* Hover card entry for a playlist channel
|
||||
* @param channel in the playlist
|
||||
* @param tunerChannel of the channel to describe, or null for the channel's first
|
||||
* @param prompts true when the entry is reason to show the card
|
||||
*/
|
||||
public static ChannelCardEntry createCardEntry(Channel channel, TunerChannel tunerChannel, boolean prompts)
|
||||
{
|
||||
//One details line, as in the menu entry, so the card has room for more channels
|
||||
return new ChannelCardEntry(getTitle(channel), List.of(String.join(" \u00B7 ", getDetails(channel,
|
||||
tunerChannel))), getState(channel), channel, prompts);
|
||||
}
|
||||
|
||||
/**
|
||||
* State of a playlist channel
|
||||
*/
|
||||
public static State getState(Channel channel)
|
||||
{
|
||||
return channel.isProcessing() ? State.ENABLED : State.DISABLED;
|
||||
}
|
||||
|
||||
private static String getTitle(Channel channel)
|
||||
{
|
||||
return channel.getName() != null && !channel.getName().isEmpty() ? channel.getName() : "(unnamed)";
|
||||
}
|
||||
|
||||
/**
|
||||
* Detail lines of a playlist channel: the system and site, then the decoder, frequency and state
|
||||
* @param tunerChannel of the channel to describe, or null for the channel's first
|
||||
*/
|
||||
public static List<String> getDetails(Channel channel, TunerChannel tunerChannel)
|
||||
{
|
||||
if(tunerChannel == null)
|
||||
{
|
||||
List<TunerChannel> tunerChannels = channel.getTunerChannels();
|
||||
tunerChannel = tunerChannels.isEmpty() ? null : tunerChannels.get(0);
|
||||
}
|
||||
|
||||
List<String> details = new ArrayList<>();
|
||||
String systemSite = join(channel.hasSystem() ? channel.getSystem() : null,
|
||||
channel.hasSite() ? channel.getSite() : null);
|
||||
|
||||
if(systemSite != null)
|
||||
{
|
||||
details.add(systemSite);
|
||||
}
|
||||
|
||||
details.add(join(channel.getDecodeConfiguration().getDecoderType().getShortDisplayString(),
|
||||
tunerChannel != null ? FREQUENCY_FORMAT.format(tunerChannel.getFrequency() / 1E6) + " MHz" : null,
|
||||
channel.isProcessing() ? "Enabled" : "Disabled"));
|
||||
return details;
|
||||
}
|
||||
|
||||
/**
|
||||
* Action item of an entry's submenu
|
||||
*/
|
||||
public static MenuItem createItem(String text, State state, Runnable action)
|
||||
{
|
||||
MenuItem item = new MenuItem(text);
|
||||
item.getStyleClass().addAll(STYLE_ITEM, state.getStyleClass());
|
||||
item.setOnAction(event -> action.run());
|
||||
return item;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inactive item of an entry's submenu that explains something, e.g. why a candidate can't be added
|
||||
*/
|
||||
public static MenuItem createNote(String text)
|
||||
{
|
||||
MenuItem item = new MenuItem(text);
|
||||
item.getStyleClass().addAll(STYLE_ITEM, STYLE_NOTE);
|
||||
item.setDisable(true);
|
||||
return item;
|
||||
}
|
||||
|
||||
/**
|
||||
* Separator of an entry's submenu
|
||||
*/
|
||||
public static SeparatorMenuItem createSeparator()
|
||||
{
|
||||
SeparatorMenuItem separator = new SeparatorMenuItem();
|
||||
separator.getStyleClass().add(STYLE_ITEM);
|
||||
return separator;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gives the context menu's channel entries the theme's colors. The stylesheet goes into the scenes of the menu
|
||||
* and the entry submenus, since a popup takes its owner's stylesheets when it's shown and the application theme's
|
||||
* stylesheets are added to each popup's scene: the more specific rules win in the same scene.
|
||||
*/
|
||||
public static void style(ContextMenu menu, SpectralDisplayTheme theme)
|
||||
{
|
||||
String stylesheet = createStylesheet(theme);
|
||||
menu.addEventHandler(WindowEvent.WINDOW_SHOWN, event -> addStylesheet(menu.getScene(), stylesheet));
|
||||
|
||||
for(MenuItem item: menu.getItems())
|
||||
{
|
||||
if(item instanceof Menu entry && entry.getStyleClass().contains(STYLE_ITEM))
|
||||
{
|
||||
//The submenu's popup isn't exposed, but its items' nodes are in its scene once it's showing
|
||||
EventHandler<Event> handler = event -> {
|
||||
for(MenuItem child: entry.getItems())
|
||||
{
|
||||
Node node = child.getStyleableNode();
|
||||
|
||||
if(node != null && node.getScene() != null)
|
||||
{
|
||||
addStylesheet(node.getScene(), stylesheet);
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
entry.setOnShowing(handler);
|
||||
entry.setOnShown(handler);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void addStylesheet(Scene scene, String stylesheet)
|
||||
{
|
||||
if(scene != null && !scene.getStylesheets().contains(stylesheet))
|
||||
{
|
||||
scene.getStylesheets().add(stylesheet);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stylesheet with the theme's colors
|
||||
* @return data URL of the stylesheet
|
||||
*/
|
||||
static String createStylesheet(SpectralDisplayTheme theme)
|
||||
{
|
||||
Color background = opaque(theme.getBackground());
|
||||
String detail = css(readable(opaque(theme.getLine()), background));
|
||||
String item = ".menu-item." + STYLE_ITEM;
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append(item).append(" { -fx-background-color: ").append(css(background)).append("; }\n");
|
||||
sb.append(item).append(":focused, ").append(item).append(":hover { -fx-background-color: ")
|
||||
.append(css(background)).append(", ").append(css(theme.getLine(0.35))).append("; }\n");
|
||||
sb.append(item).append(":disabled, ").append(item).append(":disabled .label { -fx-opacity: 1; }\n");
|
||||
|
||||
for(State state: State.values())
|
||||
{
|
||||
String color = css(readable(getColor(theme, state), background));
|
||||
String stateItem = item + "." + state.getStyleClass();
|
||||
//The item labels, and the title of an entry
|
||||
sb.append(textRules(color, stateItem + " .label", stateItem + ":focused .label",
|
||||
stateItem + ":hover .label"));
|
||||
}
|
||||
|
||||
//More specific than the state rules, so the details keep their color on hover
|
||||
sb.append(textRules(detail, item + " .label." + STYLE_DETAIL, item + ":focused .label." + STYLE_DETAIL,
|
||||
item + ":hover .label." + STYLE_DETAIL, item + "." + STYLE_NOTE + " .label"));
|
||||
sb.append(item).append(" .label.").append(STYLE_TITLE).append(" { -fx-font-weight: bold; }\n");
|
||||
sb.append(".menu.").append(STYLE_ITEM).append(" > .right-container > .arrow { -fx-background-color: ")
|
||||
.append(detail).append("; }\n");
|
||||
sb.append(".separator-menu-item.").append(STYLE_ITEM).append(" { -fx-padding: 0.25em 0; }\n");
|
||||
sb.append(".separator-menu-item.").append(STYLE_ITEM).append(" > .line { -fx-border-color: ")
|
||||
.append(css(theme.getLine(0.5)))
|
||||
.append(" transparent transparent transparent; -fx-border-insets: 0; -fx-padding: 0; }\n");
|
||||
return "data:text/css;base64," +
|
||||
Base64.getEncoder().encodeToString(sb.toString().getBytes(StandardCharsets.UTF_8));
|
||||
}
|
||||
|
||||
/**
|
||||
* Title color of the state: the theme's active color (a green) for an enabled playlist channel, its inactive
|
||||
* color (a blue) for a disabled one, and its plain text color for a radio reference candidate
|
||||
*/
|
||||
public static Color getColor(SpectralDisplayTheme theme, State state)
|
||||
{
|
||||
return switch(state)
|
||||
{
|
||||
case ENABLED -> theme.getChannelActive();
|
||||
case DISABLED -> theme.getChannelInactive();
|
||||
case CANDIDATE -> theme.getText();
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Color moved toward white on a dark background, or black on a light one, until it's readable on the background
|
||||
*/
|
||||
public static Color readable(Color color, Color background)
|
||||
{
|
||||
Color target = luminance(background) < 0.5 ? Color.WHITE : Color.BLACK;
|
||||
Color adjusted = color;
|
||||
|
||||
for(int step = 1; step <= 10 && contrast(adjusted, background) < MIN_CONTRAST; step++)
|
||||
{
|
||||
adjusted = color.interpolate(target, step / 10.0);
|
||||
}
|
||||
|
||||
return adjusted;
|
||||
}
|
||||
|
||||
static double contrast(Color a, Color b)
|
||||
{
|
||||
double la = luminance(a);
|
||||
double lb = luminance(b);
|
||||
return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
|
||||
}
|
||||
|
||||
private static double luminance(Color color)
|
||||
{
|
||||
return (0.2126 * linear(color.getRed())) + (0.7152 * linear(color.getGreen())) +
|
||||
(0.0722 * linear(color.getBlue()));
|
||||
}
|
||||
|
||||
private static double linear(double channel)
|
||||
{
|
||||
return channel <= 0.03928 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);
|
||||
}
|
||||
|
||||
/**
|
||||
* Rules that set the text color of the labels and of their text nodes. The dark application theme fills each
|
||||
* label's text node, so both are set.
|
||||
*/
|
||||
private static String textRules(String color, String... labelSelectors)
|
||||
{
|
||||
String labels = String.join(", ", labelSelectors);
|
||||
String texts = String.join(" .text, ", labelSelectors) + " .text";
|
||||
return labels + " { -fx-text-fill: " + color + "; }\n" + texts + " { -fx-fill: " + color + "; }\n";
|
||||
}
|
||||
|
||||
private static Color opaque(Color color)
|
||||
{
|
||||
return Color.color(color.getRed(), color.getGreen(), color.getBlue());
|
||||
}
|
||||
|
||||
private static String css(Color color)
|
||||
{
|
||||
return String.format(Locale.ROOT, "rgba(%d,%d,%d,%.3f)", Math.round(color.getRed() * 255),
|
||||
Math.round(color.getGreen() * 255), Math.round(color.getBlue() * 255), color.getOpacity());
|
||||
}
|
||||
|
||||
/**
|
||||
* Values joined with a middle dot, skipping null and empty values
|
||||
*/
|
||||
public static String join(String... values)
|
||||
{
|
||||
StringBuilder sb = new StringBuilder();
|
||||
|
||||
for(String value: values)
|
||||
{
|
||||
if(value != null && !value.isEmpty())
|
||||
{
|
||||
if(!sb.isEmpty())
|
||||
{
|
||||
sb.append(" · ");
|
||||
}
|
||||
|
||||
sb.append(value);
|
||||
}
|
||||
}
|
||||
|
||||
return sb.isEmpty() ? null : sb.toString();
|
||||
}
|
||||
}
|
||||
@@ -20,6 +20,12 @@
|
||||
package io.github.dsheirer.gui.spectrum;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.IdentityHashMap;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.ConcurrentLinkedQueue;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
@@ -1120,15 +1126,53 @@ public class SpectralDisplay extends StackPane
|
||||
double xFraction = width > 0 ? event.getX() / width : 0.5;
|
||||
ContextMenu menu = new ContextMenu();
|
||||
|
||||
//Items of the layers grouped by section, in layer order. A layer without a section is a group of its own.
|
||||
Map<Object,List<MenuItem>> groups = new LinkedHashMap<>();
|
||||
Map<Object,Map<Object,MenuItem>> listed = new HashMap<>();
|
||||
|
||||
for(SpectralDisplayLayer layer: mLayers)
|
||||
{
|
||||
List<MenuItem> items = layer.getContextMenuItems(pane.getSection(), frequency);
|
||||
|
||||
if(items != null && !items.isEmpty())
|
||||
if(items == null || items.isEmpty())
|
||||
{
|
||||
menu.getItems().addAll(items);
|
||||
menu.getItems().add(new SeparatorMenuItem());
|
||||
continue;
|
||||
}
|
||||
|
||||
Object key = layer.getContextMenuSection() != null ? layer.getContextMenuSection() : layer;
|
||||
List<MenuItem> group = groups.computeIfAbsent(key, k -> new ArrayList<>());
|
||||
Map<Object,MenuItem> keys = listed.computeIfAbsent(key, k -> new IdentityHashMap<>());
|
||||
|
||||
for(MenuItem item: items)
|
||||
{
|
||||
MenuItem earlier = item.getUserData() != null ? keys.get(item.getUserData()) : null;
|
||||
|
||||
if(earlier != null)
|
||||
{
|
||||
//The same channel from another layer is listed once, with the other layer's options added
|
||||
mergeOptions(earlier, item);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(item.getUserData() != null)
|
||||
{
|
||||
keys.put(item.getUserData(), item);
|
||||
}
|
||||
|
||||
group.add(item);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(Map.Entry<Object,List<MenuItem>> group: groups.entrySet())
|
||||
{
|
||||
if(group.getKey() instanceof String section)
|
||||
{
|
||||
menu.getItems().add(SpectralDisplayLayer.createSectionHeader(section));
|
||||
}
|
||||
|
||||
menu.getItems().addAll(group.getValue());
|
||||
menu.getItems().add(new SeparatorMenuItem());
|
||||
}
|
||||
|
||||
Menu zoomMenu = new Menu("Zoom");
|
||||
@@ -1154,11 +1198,97 @@ public class SpectralDisplay extends StackPane
|
||||
menu.getItems().add(pause);
|
||||
}
|
||||
|
||||
alignLabels(menu.getItems());
|
||||
ChannelMenus.style(menu, getTheme());
|
||||
mContextMenu = menu;
|
||||
menu.show(pane, event.getScreenX(), event.getScreenY());
|
||||
event.consume();
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the submenu options of a later entry for the same channel that the earlier entry doesn't have, e.g. the
|
||||
* radio reference layer's option to view a playlist channel's listing. When the later entry has all of the
|
||||
* earlier entry's options, the earlier entry takes the later entry's options in their order, otherwise the
|
||||
* missing options are added after a separator.
|
||||
*/
|
||||
private static void mergeOptions(MenuItem earlier, MenuItem later)
|
||||
{
|
||||
if(!(earlier instanceof Menu earlierMenu) || !(later instanceof Menu laterMenu))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Set<String> earlierTexts = getOptionTexts(earlierMenu);
|
||||
Set<String> laterTexts = getOptionTexts(laterMenu);
|
||||
|
||||
if(laterTexts.containsAll(earlierTexts))
|
||||
{
|
||||
if(laterTexts.size() > earlierTexts.size())
|
||||
{
|
||||
//Items belong to one menu, so they're moved
|
||||
List<MenuItem> options = new ArrayList<>(laterMenu.getItems());
|
||||
laterMenu.getItems().clear();
|
||||
earlierMenu.getItems().setAll(options);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
List<MenuItem> added = new ArrayList<>();
|
||||
|
||||
for(MenuItem option: laterMenu.getItems())
|
||||
{
|
||||
if(!(option instanceof SeparatorMenuItem) && option.getText() != null &&
|
||||
!earlierTexts.contains(option.getText()))
|
||||
{
|
||||
added.add(option);
|
||||
}
|
||||
}
|
||||
|
||||
if(!added.isEmpty())
|
||||
{
|
||||
laterMenu.getItems().removeAll(added);
|
||||
earlierMenu.getItems().add(ChannelMenus.createSeparator());
|
||||
earlierMenu.getItems().addAll(added);
|
||||
}
|
||||
}
|
||||
|
||||
private static Set<String> getOptionTexts(Menu menu)
|
||||
{
|
||||
Set<String> texts = new HashSet<>();
|
||||
|
||||
for(MenuItem option: menu.getItems())
|
||||
{
|
||||
if(!(option instanceof SeparatorMenuItem) && option.getText() != null)
|
||||
{
|
||||
texts.add(option.getText());
|
||||
}
|
||||
}
|
||||
|
||||
return texts;
|
||||
}
|
||||
|
||||
/**
|
||||
* A context menu places item text in a column after the widest graphic, so when a layer's items show their
|
||||
* content as a graphic, the text of the other items is moved into a graphic too, to line up on the left.
|
||||
*/
|
||||
private static void alignLabels(List<MenuItem> items)
|
||||
{
|
||||
if(items.stream().noneMatch(item -> item.getGraphic() != null && !(item instanceof SeparatorMenuItem)))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for(MenuItem item: items)
|
||||
{
|
||||
if(item.getGraphic() == null && item.getText() != null && !(item instanceof SeparatorMenuItem))
|
||||
{
|
||||
item.setGraphic(new Label(item.getText()));
|
||||
item.setText(null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resizable pane that holds a canvas for one display section.
|
||||
*/
|
||||
|
||||
@@ -147,6 +147,44 @@ public abstract class SpectralDisplayLayer
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
/**
|
||||
* Channels at the mouse position for the display's Channels hover card (see
|
||||
* {@link io.github.dsheirer.gui.spectrum.layer.ChannelCardLayer}). Called on the JavaFX application thread while
|
||||
* the mouse rests over the display, so it should be quick.
|
||||
* @param cursor mouse position
|
||||
* @param area of the section under the mouse
|
||||
* @return entries, or an empty list
|
||||
*/
|
||||
public List<ChannelCardEntry> getCardEntries(DisplayCursor cursor, RenderArea area)
|
||||
{
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
/**
|
||||
* Context menu section of this layer's items. The items of layers with the same section are listed together
|
||||
* under a header with the section name, each item once: an item whose user data is the same object as an earlier
|
||||
* item's in the section is left out.
|
||||
* @return section name, or null for items of their own without a header
|
||||
*/
|
||||
public String getContextMenuSection()
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Section header for context menu items: an inactive item with smaller bold text in the theme's text color,
|
||||
* slightly faded. Inline styles, since the application theme's stylesheets are added to each popup's scene.
|
||||
* @param title of the section
|
||||
*/
|
||||
public static MenuItem createSectionHeader(String title)
|
||||
{
|
||||
MenuItem header = new MenuItem(title);
|
||||
header.setDisable(true);
|
||||
header.getStyleClass().add("spectral-menu-section-header");
|
||||
header.setStyle("-fx-opacity: 0.6; -fx-font-size: 0.85em; -fx-font-weight: bold;");
|
||||
return header;
|
||||
}
|
||||
|
||||
/**
|
||||
* Title of this layer's section in the configuration panel, or null to place the layer's rows in the panel's
|
||||
* Display section instead of a section of their own.
|
||||
|
||||
@@ -239,6 +239,74 @@ public enum SpectralDisplayTheme
|
||||
return mCorrection;
|
||||
}
|
||||
|
||||
/**
|
||||
* Text color for an active (enabled) playlist channel in the Channels menu and card: a green that reads as
|
||||
* active on the theme's background, or the theme's own highlight in the monochrome themes. Red/green color
|
||||
* blind themes use a yellowish green and blue/yellow color blind themes a green that stays distinct from
|
||||
* {@link #getChannelInactive()}.
|
||||
*/
|
||||
public Color getChannelActive()
|
||||
{
|
||||
return Color.web(switch(this)
|
||||
{
|
||||
case CLASSIC -> "#33E633";
|
||||
case DARK -> "#66BB6A";
|
||||
case MEDIUM -> "#81C784";
|
||||
case LIGHT -> "#2E7D32";
|
||||
case GREEN_PHOSPHOR -> "#66FF8C";
|
||||
case AMBER -> "#FFC233";
|
||||
case GRAYSCALE -> "#FFFFFF";
|
||||
case HIGH_CONTRAST_DARK -> "#00FF00";
|
||||
case HIGH_CONTRAST_LIGHT -> "#006400";
|
||||
case VIRIDIS -> "#6DCD59";
|
||||
case CIVIDIS -> "#B4DE2C";
|
||||
case INFERNO -> "#4CC764";
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Text color for an inactive (disabled) playlist channel in the Channels menu and card: a blue that reads as
|
||||
* inactive on the theme's background, or a dimmed shade in the monochrome themes. The blue/yellow color blind
|
||||
* theme uses a pink, since blue and green look alike there.
|
||||
*/
|
||||
public Color getChannelInactive()
|
||||
{
|
||||
return Color.web(switch(this)
|
||||
{
|
||||
case CLASSIC -> "#4D9FFF";
|
||||
case DARK -> "#64B5F6";
|
||||
case MEDIUM -> "#90CAF9";
|
||||
case LIGHT -> "#1565C0";
|
||||
case GREEN_PHOSPHOR -> "#3FAF5C";
|
||||
case AMBER -> "#B07A10";
|
||||
case GRAYSCALE -> "#8C8C8C";
|
||||
case HIGH_CONTRAST_DARK -> "#00BFFF";
|
||||
case HIGH_CONTRAST_LIGHT -> "#0000C0";
|
||||
case VIRIDIS -> "#5B9BF0";
|
||||
case CIVIDIS -> "#56B4E9";
|
||||
case INFERNO -> "#E879C6";
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Plain text color on the theme's background, e.g. for menu entries that aren't highlighted
|
||||
*/
|
||||
public Color getText()
|
||||
{
|
||||
return Color.web(switch(this)
|
||||
{
|
||||
case CLASSIC, HIGH_CONTRAST_DARK -> "#FFFFFF";
|
||||
case DARK -> "#E6E8EB";
|
||||
case MEDIUM -> "#F0F4F8";
|
||||
case LIGHT -> "#212529";
|
||||
case GREEN_PHOSPHOR -> "#CCFFCC";
|
||||
case AMBER -> "#FFF0C2";
|
||||
case GRAYSCALE -> "#D0D0D0";
|
||||
case HIGH_CONTRAST_LIGHT -> "#000000";
|
||||
case VIRIDIS, CIVIDIS, INFERNO -> "#E8E8EE";
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* ARGB color for the waterfall intensity index (0 - 255).
|
||||
*/
|
||||
|
||||
@@ -22,6 +22,7 @@ package io.github.dsheirer.gui.spectrum;
|
||||
import io.github.dsheirer.controller.channel.ChannelModel;
|
||||
import io.github.dsheirer.controller.channel.ChannelProcessingManager;
|
||||
import io.github.dsheirer.gui.playlist.radioreference.RadioReferencePlaylistActions;
|
||||
import io.github.dsheirer.gui.spectrum.layer.ChannelCardLayer;
|
||||
import io.github.dsheirer.gui.spectrum.layer.ChannelLayer;
|
||||
import io.github.dsheirer.gui.spectrum.layer.RadioReferenceLayer;
|
||||
import io.github.dsheirer.playlist.PlaylistManager;
|
||||
@@ -104,8 +105,8 @@ public class TunerSpectralDisplay extends DftSpectralDisplay implements ISourceE
|
||||
private TunerSpectralDisplay(ChannelLayer channelLayer, RadioReferenceLayer radioReferenceLayer,
|
||||
DiscoveredTunerModel discoveredTunerModel, boolean saveSettings)
|
||||
{
|
||||
//The radio reference layer draws after the channel layer, so its card is on top
|
||||
super(SETTINGS_PREFIX, saveSettings, channelLayer, radioReferenceLayer);
|
||||
//The channels card draws after the other layers, so it's on top
|
||||
super(SETTINGS_PREFIX, saveSettings, channelLayer, radioReferenceLayer, new ChannelCardLayer());
|
||||
mChannelLayer = channelLayer;
|
||||
mRadioReferenceLayer = radioReferenceLayer;
|
||||
mDiscoveredTunerModel = discoveredTunerModel;
|
||||
|
||||
@@ -0,0 +1,430 @@
|
||||
/*
|
||||
* *****************************************************************************
|
||||
* Copyright (C) 2014-2026 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 io.github.dsheirer.gui.spectrum.layer;
|
||||
|
||||
import io.github.dsheirer.gui.spectrum.ChannelCardEntry;
|
||||
import io.github.dsheirer.gui.spectrum.ChannelMenus;
|
||||
import io.github.dsheirer.gui.spectrum.CursorReadout;
|
||||
import io.github.dsheirer.gui.spectrum.DisplayCursor;
|
||||
import io.github.dsheirer.gui.spectrum.DisplaySection;
|
||||
import io.github.dsheirer.gui.spectrum.RenderArea;
|
||||
import io.github.dsheirer.gui.spectrum.SpectralDisplayLayer;
|
||||
import io.github.dsheirer.gui.spectrum.SpectralDisplayModel;
|
||||
import io.github.dsheirer.gui.spectrum.SpectralDisplayTheme;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.IdentityHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
import javafx.animation.PauseTransition;
|
||||
import javafx.geometry.VPos;
|
||||
import javafx.scene.canvas.GraphicsContext;
|
||||
import javafx.scene.paint.Color;
|
||||
import javafx.scene.text.Font;
|
||||
import javafx.scene.text.FontWeight;
|
||||
import javafx.scene.text.Text;
|
||||
import javafx.scene.text.TextAlignment;
|
||||
import javafx.util.Duration;
|
||||
|
||||
/**
|
||||
* Channels hover card. When the mouse rests over the spectrum or the waterfall, shows a card next to the mouse with
|
||||
* the channels at the mouse position that the other layers provide (see
|
||||
* {@link SpectralDisplayLayer#getCardEntries}): playlist channels first, then radio reference candidates. The titles
|
||||
* have the colors of the Channels context menu entries: one for an enabled playlist channel, one for a disabled one
|
||||
* and one for a candidate. The card replaces the cursor readout and ends with the readout lines.
|
||||
*
|
||||
* The card is shown when an entry prompts it, e.g. a playlist channel whose labels don't fit in its box or a
|
||||
* candidate; the other channels at the mouse position are then listed too.
|
||||
*/
|
||||
public class ChannelCardLayer extends SpectralDisplayLayer
|
||||
{
|
||||
private static final Duration HOVER_DELAY = Duration.millis(400);
|
||||
private static final Font FONT = Font.font(11);
|
||||
private static final Font TITLE_FONT = Font.font(Font.getDefault().getFamily(), FontWeight.BOLD, 11);
|
||||
private static final int MAX_ENTRIES = 6;
|
||||
private static final double MAX_TEXT_WIDTH = 380;
|
||||
private static final double PADDING = 6;
|
||||
private static final double GAP = 5;
|
||||
//Space beside the text and below the readout lines, as in the cursor readout, so the readout lines stay in place
|
||||
private static final double PADDING_X = 4;
|
||||
//Space kept between the card and the edges of the section
|
||||
private static final double EDGE_MARGIN = 2;
|
||||
private static final double READOUT_PADDING = 2;
|
||||
private static final String HEADER = ChannelMenus.SECTION;
|
||||
|
||||
private final Text mMeasure = new Text();
|
||||
private final double mTextHeight;
|
||||
private PauseTransition mHoverTimer;
|
||||
private DisplaySection mHoverSection;
|
||||
private double mHoverX = Double.NaN;
|
||||
private double mHoverY = Double.NaN;
|
||||
private boolean mHoverReady;
|
||||
private List<ChannelCardEntry> mEntries = Collections.emptyList();
|
||||
private Card mCard;
|
||||
|
||||
/**
|
||||
* Card text, measured when the entries or the room change
|
||||
* @param entries lines of each shown entry: the title, then the details
|
||||
* @param states of the shown entries
|
||||
* @param more line, or null
|
||||
* @param textWidth of the widest line
|
||||
* @param lineCount of the header, entry and more lines
|
||||
* @param source entries the card was made from
|
||||
* @param maxTextWidth that the lines were shortened to
|
||||
* @param maxHeight that the card was limited to
|
||||
* @param readoutLines that the card was sized for
|
||||
*/
|
||||
private record Card(List<List<String>> entries, List<ChannelMenus.State> states, String more, double textWidth,
|
||||
int lineCount, List<ChannelCardEntry> source, double maxTextWidth, double maxHeight,
|
||||
int readoutLines)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs an instance
|
||||
*/
|
||||
public ChannelCardLayer()
|
||||
{
|
||||
mMeasure.setFont(FONT);
|
||||
mMeasure.setText("Ag");
|
||||
mTextHeight = Math.ceil(mMeasure.getLayoutBounds().getHeight());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void dispose()
|
||||
{
|
||||
if(mHoverTimer != null)
|
||||
{
|
||||
mHoverTimer.stop();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderSpectrumForeground(GraphicsContext gc, RenderArea area)
|
||||
{
|
||||
render(gc, area, DisplaySection.SPECTRUM);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderWaterfall(GraphicsContext gc, RenderArea area)
|
||||
{
|
||||
render(gc, area, DisplaySection.WATERFALL);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draws the card in the section under the mouse once the mouse has rested for the hover delay
|
||||
*/
|
||||
private void render(GraphicsContext gc, RenderArea area, DisplaySection section)
|
||||
{
|
||||
DisplayCursor cursor = getSpectralDisplay() != null ? getSpectralDisplay().getDisplayCursor() : null;
|
||||
trackHover(cursor);
|
||||
|
||||
if(cursor != null && cursor.section() == section && replacesCursorReadout(cursor, area))
|
||||
{
|
||||
drawCard(gc, area, cursor, mEntries);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The card replaces the cursor readout while it's shown: it ends with the readout lines, in the readout's place.
|
||||
*/
|
||||
@Override
|
||||
public boolean replacesCursorReadout(DisplayCursor cursor, RenderArea area)
|
||||
{
|
||||
SpectralDisplayModel model = getModel();
|
||||
|
||||
//Only for the position the mouse rested at - the readout comes back as soon as the mouse moves
|
||||
if(!mHoverReady || model == null || !model.hasSource() || cursor == null || cursor.section() != mHoverSection ||
|
||||
cursor.x() != mHoverX || cursor.y() != mHoverY || area.width() <= 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
mEntries = getEntries(cursor, area);
|
||||
return mEntries.stream().anyMatch(ChannelCardEntry::prompts);
|
||||
}
|
||||
|
||||
/**
|
||||
* Entries of the other layers, each channel once, playlist channels first
|
||||
*/
|
||||
private List<ChannelCardEntry> getEntries(DisplayCursor cursor, RenderArea area)
|
||||
{
|
||||
List<ChannelCardEntry> entries = new ArrayList<>();
|
||||
Set<Object> keys = Collections.newSetFromMap(new IdentityHashMap<>());
|
||||
|
||||
for(SpectralDisplayLayer layer: getSpectralDisplay().getLayers())
|
||||
{
|
||||
if(layer == this)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
for(ChannelCardEntry entry: layer.getCardEntries(cursor, area))
|
||||
{
|
||||
if(entry.key() == null || keys.add(entry.key()))
|
||||
{
|
||||
entries.add(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
entries.sort(Comparator.comparing(entry -> entry.state() == ChannelMenus.State.CANDIDATE));
|
||||
return entries;
|
||||
}
|
||||
|
||||
/**
|
||||
* Restarts the hover delay each time the mouse moves, and hides the card until it passes
|
||||
*/
|
||||
private void trackHover(DisplayCursor cursor)
|
||||
{
|
||||
if(cursor == null)
|
||||
{
|
||||
if(mHoverSection != null)
|
||||
{
|
||||
mHoverSection = null;
|
||||
mHoverReady = false;
|
||||
getHoverTimer().stop();
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if(cursor.section() != mHoverSection || cursor.x() != mHoverX || cursor.y() != mHoverY)
|
||||
{
|
||||
mHoverSection = cursor.section();
|
||||
mHoverX = cursor.x();
|
||||
mHoverY = cursor.y();
|
||||
mHoverReady = false;
|
||||
getHoverTimer().playFromStart();
|
||||
}
|
||||
}
|
||||
|
||||
private PauseTransition getHoverTimer()
|
||||
{
|
||||
if(mHoverTimer == null)
|
||||
{
|
||||
mHoverTimer = new PauseTransition(HOVER_DELAY);
|
||||
mHoverTimer.setOnFinished(event -> {
|
||||
mHoverReady = true;
|
||||
requestRender();
|
||||
});
|
||||
}
|
||||
|
||||
return mHoverTimer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Draws the card in place of the cursor readout: beside the mouse and above it, placed like the readout, with the
|
||||
* channels above the readout lines so the frequency and level stay where the readout showed them. The card fits
|
||||
* the larger side of the mouse and the height of the section, showing as many channels as fit.
|
||||
*/
|
||||
private void drawCard(GraphicsContext gc, RenderArea area, DisplayCursor cursor, List<ChannelCardEntry> entries)
|
||||
{
|
||||
//The level line changes with the mouse height while the channels don't
|
||||
List<String> readout = CursorReadout.lines(cursor, area, getModel());
|
||||
double readoutWidth = 0;
|
||||
|
||||
for(String line: readout)
|
||||
{
|
||||
readoutWidth = Math.max(readoutWidth, measure(line, FONT));
|
||||
}
|
||||
|
||||
double room = Math.max(area.width() - cursor.x(), cursor.x()) - CursorReadout.GAP_X - EDGE_MARGIN;
|
||||
double maxTextWidth = Math.max(readoutWidth, Math.min(MAX_TEXT_WIDTH, room - (PADDING_X * 2)));
|
||||
//Above the mouse, so the readout lines stay where the readout showed them, when an entry fits there
|
||||
double above = cursor.y() - CursorReadout.GAP_Y;
|
||||
double maxHeight = above >= cardHeight(5, 1, true, readout.size()) ? above : area.plotHeight() - EDGE_MARGIN;
|
||||
|
||||
if(mCard == null || !mCard.source().equals(entries) || mCard.maxTextWidth() != maxTextWidth ||
|
||||
mCard.maxHeight() != maxHeight || mCard.readoutLines() != readout.size())
|
||||
{
|
||||
mCard = createCard(entries, maxTextWidth, maxHeight, readout.size());
|
||||
}
|
||||
|
||||
Card card = mCard;
|
||||
SpectralDisplayTheme theme = getSpectralDisplay().getTheme();
|
||||
Color background = opaque(theme.getBackground());
|
||||
Color detail = opaque(theme.getLine());
|
||||
double width = Math.max(card.textWidth(), readoutWidth) + (PADDING_X * 2);
|
||||
double height = cardHeight(card.lineCount(), card.entries().size(), card.more() != null, readout.size());
|
||||
double x = Math.max(0, CursorReadout.x(cursor, width, area));
|
||||
double y = CursorReadout.y(cursor, height, area);
|
||||
|
||||
gc.setFill(theme.getBackground(0.92));
|
||||
gc.fillRoundRect(x, y, width, height, 8, 8);
|
||||
gc.setStroke(detail);
|
||||
gc.setLineWidth(1.0);
|
||||
gc.strokeRoundRect(Math.floor(x) + 0.5, Math.floor(y) + 0.5, width, height, 8, 8);
|
||||
gc.setTextAlign(TextAlignment.LEFT);
|
||||
gc.setTextBaseline(VPos.TOP);
|
||||
|
||||
double textX = x + PADDING_X;
|
||||
double lineY = y + PADDING;
|
||||
gc.setFill(detail);
|
||||
gc.setFont(TITLE_FONT);
|
||||
gc.fillText(HEADER, textX, lineY);
|
||||
lineY += mTextHeight + GAP;
|
||||
|
||||
for(int index = 0; index < card.entries().size(); index++)
|
||||
{
|
||||
List<String> lines = card.entries().get(index);
|
||||
gc.setFill(ChannelMenus.readable(ChannelMenus.getColor(theme, card.states().get(index)), background));
|
||||
gc.setFont(TITLE_FONT);
|
||||
gc.fillText(lines.get(0), textX, lineY);
|
||||
lineY += mTextHeight;
|
||||
gc.setFill(detail);
|
||||
gc.setFont(FONT);
|
||||
|
||||
for(int line = 1; line < lines.size(); line++)
|
||||
{
|
||||
gc.fillText(lines.get(line), textX, lineY);
|
||||
lineY += mTextHeight;
|
||||
}
|
||||
|
||||
lineY += GAP;
|
||||
}
|
||||
|
||||
if(card.more() != null)
|
||||
{
|
||||
gc.setFill(detail);
|
||||
gc.setFont(FONT);
|
||||
gc.fillText(card.more(), textX, lineY);
|
||||
lineY += mTextHeight + GAP;
|
||||
}
|
||||
|
||||
//The readout lines, separated from the channels, in the readout's style
|
||||
double separator = Math.floor(lineY - (GAP / 2.0)) + 0.5;
|
||||
gc.setStroke(theme.getLine(0.5));
|
||||
gc.strokeLine(textX, separator, x + width - PADDING_X, separator);
|
||||
gc.setFill(theme.getCursor());
|
||||
gc.setFont(FONT);
|
||||
|
||||
for(String line: readout)
|
||||
{
|
||||
gc.fillText(line, textX, lineY);
|
||||
lineY += mTextHeight;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Height of a card with the lines
|
||||
* @param lineCount of the header, entry and more lines
|
||||
* @param entries number of entries
|
||||
* @param more true when the card has a more line
|
||||
* @param readoutLines number of readout lines
|
||||
*/
|
||||
private double cardHeight(int lineCount, int entries, boolean more, int readoutLines)
|
||||
{
|
||||
int gaps = 1 + entries + (more ? 1 : 0);
|
||||
return ((lineCount + readoutLines) * mTextHeight) + (gaps * GAP) + PADDING + READOUT_PADDING;
|
||||
}
|
||||
|
||||
/**
|
||||
* Card text for as many entries as fit the height, shortened to the width
|
||||
*/
|
||||
private Card createCard(List<ChannelCardEntry> source, double maxTextWidth, double maxHeight, int readoutLines)
|
||||
{
|
||||
int limit = Math.min(source.size(), MAX_ENTRIES);
|
||||
List<List<String>> entries = new ArrayList<>();
|
||||
List<ChannelMenus.State> states = new ArrayList<>();
|
||||
double textWidth = measure(HEADER, TITLE_FONT);
|
||||
int lineCount = 1;
|
||||
|
||||
for(int index = 0; index < limit; index++)
|
||||
{
|
||||
ChannelCardEntry entry = source.get(index);
|
||||
List<String> lines = new ArrayList<>();
|
||||
lines.add(fit(entry.title(), TITLE_FONT, maxTextWidth));
|
||||
|
||||
for(String detail: entry.details())
|
||||
{
|
||||
if(detail != null)
|
||||
{
|
||||
lines.add(fit(detail, FONT, maxTextWidth));
|
||||
}
|
||||
}
|
||||
|
||||
//Keep room for the more line when entries are left out
|
||||
boolean more = index + 1 < source.size();
|
||||
|
||||
if(!entries.isEmpty() && cardHeight(lineCount + lines.size() + (more ? 1 : 0), entries.size() + 1, more,
|
||||
readoutLines) > maxHeight)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
textWidth = Math.max(textWidth, measure(lines.get(0), TITLE_FONT));
|
||||
|
||||
for(int line = 1; line < lines.size(); line++)
|
||||
{
|
||||
textWidth = Math.max(textWidth, measure(lines.get(line), FONT));
|
||||
}
|
||||
|
||||
lineCount += lines.size();
|
||||
entries.add(lines);
|
||||
states.add(entry.state());
|
||||
}
|
||||
|
||||
String more = source.size() > entries.size() ? "+ " + (source.size() - entries.size()) + " more" : null;
|
||||
|
||||
if(more != null)
|
||||
{
|
||||
textWidth = Math.max(textWidth, measure(more, FONT));
|
||||
lineCount++;
|
||||
}
|
||||
|
||||
return new Card(entries, states, more, textWidth, lineCount, source, maxTextWidth, maxHeight, readoutLines);
|
||||
}
|
||||
|
||||
/**
|
||||
* Text shortened with an ellipsis to fit the width
|
||||
*/
|
||||
private String fit(String text, Font font, double maxWidth)
|
||||
{
|
||||
if(measure(text, font) <= maxWidth)
|
||||
{
|
||||
return text;
|
||||
}
|
||||
|
||||
int length = text.length();
|
||||
|
||||
while(length > 1 && measure(text.substring(0, length) + "…", font) > maxWidth)
|
||||
{
|
||||
length--;
|
||||
}
|
||||
|
||||
return text.substring(0, length) + "…";
|
||||
}
|
||||
|
||||
private double measure(String text, Font font)
|
||||
{
|
||||
mMeasure.setFont(font);
|
||||
mMeasure.setText(text);
|
||||
double width = mMeasure.getLayoutBounds().getWidth();
|
||||
mMeasure.setFont(FONT);
|
||||
return width;
|
||||
}
|
||||
|
||||
private static Color opaque(Color color)
|
||||
{
|
||||
return Color.color(color.getRed(), color.getGreen(), color.getBlue());
|
||||
}
|
||||
}
|
||||
@@ -24,8 +24,8 @@ import io.github.dsheirer.controller.channel.ChannelEvent;
|
||||
import io.github.dsheirer.controller.channel.ChannelException;
|
||||
import io.github.dsheirer.controller.channel.ChannelModel;
|
||||
import io.github.dsheirer.controller.channel.ChannelProcessingManager;
|
||||
import io.github.dsheirer.eventbus.MyEventBus;
|
||||
import io.github.dsheirer.gui.playlist.channel.ViewChannelRequest;
|
||||
import io.github.dsheirer.gui.spectrum.ChannelCardEntry;
|
||||
import io.github.dsheirer.gui.spectrum.ChannelMenus;
|
||||
import io.github.dsheirer.gui.spectrum.ConfigurationRow;
|
||||
import io.github.dsheirer.gui.spectrum.DisplayCursor;
|
||||
import io.github.dsheirer.gui.spectrum.DisplaySection;
|
||||
@@ -56,7 +56,6 @@ import javafx.scene.control.MenuItem;
|
||||
import javafx.scene.control.Tooltip;
|
||||
import javafx.scene.paint.Color;
|
||||
import javafx.scene.text.Font;
|
||||
import javafx.scene.text.FontWeight;
|
||||
import javafx.scene.text.Text;
|
||||
import javafx.scene.text.TextAlignment;
|
||||
|
||||
@@ -66,24 +65,20 @@ import javafx.scene.text.TextAlignment;
|
||||
* decoder. Processing and selected channels use their own colors. When the decoder applies a frequency correction,
|
||||
* a bracket at the bottom of the box shows the corrected channel position and the PPM error.
|
||||
*
|
||||
* When the zoom level is too low for a channel's labels to fit in its box, moving the mouse over the channel shows a
|
||||
* popout card near the bottom of the spectrum (or the waterfall) with the channel name, system, site, decoder,
|
||||
* frequency and state. The popout can be turned off with the hover details setting.
|
||||
* When the zoom level is too low for a channel's labels to fit in its box, resting the mouse over the channel lists
|
||||
* it in the Channels hover card (drawn by {@link ChannelCardLayer}) with its system, site, decoder, frequency and
|
||||
* state. This can be turned off with the hover details setting.
|
||||
*
|
||||
* Right-clicking a channel adds a menu item to view or edit the channel in the playlist editor.
|
||||
* Right-clicking a channel lists it in the Channels context menu, to enable or disable it or view or edit it in the
|
||||
* playlist editor.
|
||||
*/
|
||||
public class ChannelLayer extends SpectralDisplayLayer
|
||||
{
|
||||
private static final Font FONT = Font.font(11);
|
||||
private static final DecimalFormat PPM_FORMAT = new DecimalFormat("0.0");
|
||||
private static final DecimalFormat FREQUENCY_FORMAT = new DecimalFormat("0.00000");
|
||||
private static final Font POPOUT_TITLE_FONT = Font.font(Font.getDefault().getFamily(), FontWeight.BOLD, 11);
|
||||
private static final double MIN_LABEL_BOX_WIDTH = 12;
|
||||
private static final double POPOUT_MIN_HIT_WIDTH = 10;
|
||||
private static final double POPOUT_PADDING = 6;
|
||||
private static final double POPOUT_GAP = 5;
|
||||
private static final double POPOUT_SWATCH = 8;
|
||||
private static final int POPOUT_MAX_CHANNELS = 4;
|
||||
private static final double MIN_HIT_WIDTH = 10;
|
||||
|
||||
/**
|
||||
* Which channels the layer shows.
|
||||
@@ -382,131 +377,23 @@ public class ChannelLayer extends SpectralDisplayLayer
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
renderPopout(gc, area, DisplaySection.SPECTRUM);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderWaterfall(GraphicsContext gc, RenderArea area)
|
||||
{
|
||||
renderPopout(gc, area, DisplaySection.WATERFALL);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draws a card near the bottom of the section under the mouse with the details of each channel under the mouse
|
||||
* whose labels don't fit in its box at the current zoom. The card moves to the top of the section when the mouse
|
||||
* is over the bottom of the section.
|
||||
* Card entries for the channels under the mouse. A channel whose labels don't fit in its box at the current
|
||||
* zoom prompts the card. The hit area of a narrow channel is widened so it can be found with the mouse.
|
||||
*/
|
||||
private void renderPopout(GraphicsContext gc, RenderArea area, DisplaySection section)
|
||||
@Override
|
||||
public List<ChannelCardEntry> getCardEntries(DisplayCursor cursor, RenderArea area)
|
||||
{
|
||||
SpectralDisplayModel model = getModel();
|
||||
DisplayCursor cursor = getSpectralDisplay().getDisplayCursor();
|
||||
List<ChannelCardEntry> entries = new ArrayList<>();
|
||||
|
||||
if(!mHoverDetails.get() || model == null || !model.hasSource() || cursor == null ||
|
||||
cursor.section() != section || mChannelDisplay.get() == ChannelDisplay.NONE)
|
||||
if(!mHoverDetails.get() || model == null || mChannelDisplay.get() == ChannelDisplay.NONE)
|
||||
{
|
||||
return;
|
||||
return entries;
|
||||
}
|
||||
|
||||
List<PopoutEntry> entries = getPopoutEntries(model, area, cursor.x());
|
||||
|
||||
if(entries.isEmpty())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
SpectralDisplayTheme theme = getSpectralDisplay().getTheme();
|
||||
int shown = Math.min(entries.size(), POPOUT_MAX_CHANNELS);
|
||||
String more = entries.size() > shown ? "+ " + (entries.size() - shown) + " more" : null;
|
||||
|
||||
//Measure the card
|
||||
double textWidth = 0;
|
||||
int lineCount = 0;
|
||||
|
||||
for(int x = 0; x < shown; x++)
|
||||
{
|
||||
PopoutEntry entry = entries.get(x);
|
||||
textWidth = Math.max(textWidth, measure(entry.title(), POPOUT_TITLE_FONT) + POPOUT_SWATCH + 5);
|
||||
|
||||
for(String line: entry.details())
|
||||
{
|
||||
textWidth = Math.max(textWidth, measure(line, FONT));
|
||||
}
|
||||
|
||||
lineCount += 1 + entry.details().size();
|
||||
}
|
||||
|
||||
if(more != null)
|
||||
{
|
||||
textWidth = Math.max(textWidth, measure(more, FONT));
|
||||
lineCount++;
|
||||
}
|
||||
|
||||
double width = textWidth + (POPOUT_PADDING * 2);
|
||||
double height = (lineCount * mTextHeight) + ((shown - 1) * POPOUT_GAP) + (POPOUT_PADDING * 2);
|
||||
double bottom = section == DisplaySection.SPECTRUM ? area.plotHeight() : area.height();
|
||||
double x = Math.max(4, Math.min(area.width() - width - 4, cursor.x() - (width / 2.0)));
|
||||
double y = bottom - height - 6;
|
||||
|
||||
//Keep the card out from under the mouse
|
||||
if(cursor.y() >= y - 4)
|
||||
{
|
||||
y = 6;
|
||||
}
|
||||
|
||||
if(y < 0 || width > area.width())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
gc.setFill(theme.getBackground(0.88));
|
||||
gc.fillRoundRect(x, y, width, height, 8, 8);
|
||||
gc.setStroke(opaque(theme.getLine()));
|
||||
gc.setLineWidth(1.0);
|
||||
gc.strokeRoundRect(Math.floor(x) + 0.5, Math.floor(y) + 0.5, width, height, 8, 8);
|
||||
gc.setTextAlign(TextAlignment.LEFT);
|
||||
gc.setTextBaseline(VPos.TOP);
|
||||
|
||||
double lineY = y + POPOUT_PADDING;
|
||||
double textX = x + POPOUT_PADDING;
|
||||
|
||||
for(int index = 0; index < shown; index++)
|
||||
{
|
||||
PopoutEntry entry = entries.get(index);
|
||||
double swatchY = lineY + ((mTextHeight - POPOUT_SWATCH) / 2.0);
|
||||
gc.setFill(opaque(entry.color()));
|
||||
gc.fillRect(textX, swatchY, POPOUT_SWATCH, POPOUT_SWATCH);
|
||||
gc.setFill(theme.getCursor());
|
||||
gc.setFont(POPOUT_TITLE_FONT);
|
||||
gc.fillText(entry.title(), textX + POPOUT_SWATCH + 5, lineY);
|
||||
lineY += mTextHeight;
|
||||
gc.setFill(opaque(theme.getLine()));
|
||||
gc.setFont(FONT);
|
||||
|
||||
for(String line: entry.details())
|
||||
{
|
||||
gc.fillText(line, textX, lineY);
|
||||
lineY += mTextHeight;
|
||||
}
|
||||
|
||||
lineY += POPOUT_GAP;
|
||||
}
|
||||
|
||||
if(more != null)
|
||||
{
|
||||
gc.fillText(more, textX, lineY - POPOUT_GAP);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Channels under the screen x position whose labels don't fit in the channel box. The hit area of a narrow
|
||||
* channel is widened so it can be found with the mouse.
|
||||
*/
|
||||
private List<PopoutEntry> getPopoutEntries(SpectralDisplayModel model, RenderArea area, double cursorX)
|
||||
{
|
||||
List<PopoutEntry> entries = new ArrayList<>();
|
||||
SpectralDisplayTheme theme = getSpectralDisplay().getTheme();
|
||||
|
||||
for(Channel channel: getChannels(model))
|
||||
{
|
||||
if(!isShown(channel))
|
||||
@@ -523,38 +410,14 @@ public class ChannelLayer extends SpectralDisplayLayer
|
||||
continue;
|
||||
}
|
||||
|
||||
double hitWidth = Math.max(POPOUT_MIN_HIT_WIDTH, box.width());
|
||||
double hitWidth = Math.max(MIN_HIT_WIDTH, box.width());
|
||||
double hitStart = box.center() - (hitWidth / 2.0);
|
||||
|
||||
if(cursorX < hitStart || cursorX > hitStart + hitWidth || labelsFit(channel, box))
|
||||
if(cursor.x() >= hitStart && cursor.x() <= hitStart + hitWidth)
|
||||
{
|
||||
continue;
|
||||
entries.add(ChannelMenus.createCardEntry(channel, tunerChannel, !labelsFit(channel, box)));
|
||||
break;
|
||||
}
|
||||
|
||||
List<String> details = new ArrayList<>();
|
||||
String systemSite = join(channel.hasSystem() ? channel.getSystem() : null,
|
||||
channel.hasSite() ? channel.getSite() : null);
|
||||
|
||||
if(systemSite != null)
|
||||
{
|
||||
details.add(systemSite);
|
||||
}
|
||||
|
||||
String state = channel.isProcessing() ? "Enabled" : "Disabled";
|
||||
|
||||
if(channel.isSelected())
|
||||
{
|
||||
state += ", Selected";
|
||||
}
|
||||
|
||||
details.add(join(channel.getDecodeConfiguration().getDecoderType().getShortDisplayString(),
|
||||
FREQUENCY_FORMAT.format(tunerChannel.getFrequency() / 1E6) + " MHz", state));
|
||||
|
||||
Color color = channel.isSelected() ? theme.getChannelSelected() :
|
||||
channel.isProcessing() ? theme.getChannelProcessing() : theme.getChannel();
|
||||
entries.add(new PopoutEntry(channel.getName() != null ? channel.getName() : "(unnamed)", details,
|
||||
color));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -723,14 +586,9 @@ public class ChannelLayer extends SpectralDisplayLayer
|
||||
frequency <= tunerChannel.getMaxFrequency())
|
||||
{
|
||||
//Traffic channels are started and stopped by their decoder, not from the playlist
|
||||
if(!channel.isTrafficChannel() && mChannelProcessingManager != null)
|
||||
{
|
||||
items.add(createEnableItem(channel));
|
||||
}
|
||||
|
||||
MenuItem item = new MenuItem("View/Edit: " + channel.getShortTitle());
|
||||
item.setOnAction(e -> MyEventBus.getGlobalEventBus().post(new ViewChannelRequest(channel)));
|
||||
items.add(item);
|
||||
Runnable toggle = !channel.isTrafficChannel() && mChannelProcessingManager != null ?
|
||||
() -> toggle(channel) : null;
|
||||
items.add(ChannelMenus.createChannelEntry(channel, tunerChannel, toggle));
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -739,14 +597,20 @@ public class ChannelLayer extends SpectralDisplayLayer
|
||||
return items;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getContextMenuSection()
|
||||
{
|
||||
return ChannelMenus.SECTION;
|
||||
}
|
||||
|
||||
/**
|
||||
* Menu item that starts the channel when it's disabled, or stops it when it's enabled, in the background
|
||||
* Stops the channel when it's processing, otherwise starts it
|
||||
*/
|
||||
private MenuItem createEnableItem(Channel channel)
|
||||
private void toggle(Channel channel)
|
||||
{
|
||||
boolean processing = channel.isProcessing();
|
||||
MenuItem item = new MenuItem((processing ? "Disable: " : "Enable: ") + channel.getShortTitle());
|
||||
item.setOnAction(e -> ThreadPool.CACHED.execute(() -> {
|
||||
|
||||
ThreadPool.CACHED.execute(() -> {
|
||||
try
|
||||
{
|
||||
if(processing)
|
||||
@@ -762,8 +626,7 @@ public class ChannelLayer extends SpectralDisplayLayer
|
||||
{
|
||||
showError((processing ? "Can't stop " : "Can't start ") + channel.getShortTitle(), ce.getMessage());
|
||||
}
|
||||
}));
|
||||
return item;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -792,10 +655,4 @@ public class ChannelLayer extends SpectralDisplayLayer
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Channel details for the popout card.
|
||||
*/
|
||||
private record PopoutEntry(String title, List<String> details, Color color)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,24 +20,27 @@
|
||||
package io.github.dsheirer.gui.spectrum.layer;
|
||||
|
||||
import io.github.dsheirer.controller.channel.Channel;
|
||||
import io.github.dsheirer.eventbus.MyEventBus;
|
||||
import io.github.dsheirer.gui.playlist.radioreference.ViewRadioReferenceRequest;
|
||||
import io.github.dsheirer.gui.playlist.radioreference.RadioReferencePlaylistActions;
|
||||
import io.github.dsheirer.module.decode.DecoderType;
|
||||
import io.github.dsheirer.service.radioreference.SiteRecord;
|
||||
import io.github.dsheirer.source.tuner.channel.TunerChannel;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import javafx.application.Platform;
|
||||
import javafx.scene.control.Alert;
|
||||
import javafx.scene.control.ButtonType;
|
||||
import javafx.scene.control.Menu;
|
||||
import javafx.scene.control.MenuItem;
|
||||
import io.github.dsheirer.gui.spectrum.ChannelCardEntry;
|
||||
import io.github.dsheirer.gui.spectrum.ChannelMenus;
|
||||
import io.github.dsheirer.gui.spectrum.ChannelMenus.State;
|
||||
import io.github.dsheirer.gui.spectrum.ConfigurationRow;
|
||||
import io.github.dsheirer.gui.spectrum.CursorReadout;
|
||||
import io.github.dsheirer.gui.spectrum.DisplayCursor;
|
||||
import io.github.dsheirer.gui.spectrum.DisplaySection;
|
||||
import io.github.dsheirer.gui.spectrum.RenderArea;
|
||||
import io.github.dsheirer.gui.spectrum.SpectralDisplayLayer;
|
||||
import io.github.dsheirer.gui.spectrum.SpectralDisplayModel;
|
||||
import io.github.dsheirer.gui.spectrum.SpectralDisplayTheme;
|
||||
import io.github.dsheirer.service.radioreference.DistanceFormat;
|
||||
import io.github.dsheirer.service.radioreference.FrequencyCandidate;
|
||||
import io.github.dsheirer.service.radioreference.RadioReferenceFrequencyIndex;
|
||||
@@ -45,76 +48,37 @@ import io.github.dsheirer.service.radioreference.RadioReferenceFrequencyIndex.Ra
|
||||
import java.text.DecimalFormat;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import javafx.animation.PauseTransition;
|
||||
import javafx.beans.property.BooleanProperty;
|
||||
import javafx.beans.property.SimpleBooleanProperty;
|
||||
import javafx.geometry.VPos;
|
||||
import javafx.scene.canvas.GraphicsContext;
|
||||
import javafx.scene.control.Label;
|
||||
import javafx.scene.control.Tooltip;
|
||||
import javafx.scene.paint.Color;
|
||||
import javafx.scene.text.Font;
|
||||
import javafx.scene.text.FontWeight;
|
||||
import javafx.scene.text.Text;
|
||||
import javafx.scene.text.TextAlignment;
|
||||
import javafx.util.Duration;
|
||||
|
||||
/**
|
||||
* Radio reference candidates layer. When the mouse rests over the spectrum or the waterfall, shows a card next to the
|
||||
* mouse with the radio reference frequencies near the frequency under the mouse, nearest to the user's location first.
|
||||
* Radio reference candidates layer. Lists the radio reference frequencies near the frequency under the mouse,
|
||||
* nearest to the user's location first, in the Channels hover card (drawn by {@link ChannelCardLayer}) and the
|
||||
* Channels context menu. A candidate that a playlist channel already decodes is listed as that channel.
|
||||
*
|
||||
* The candidates come from the radio reference frequency index, which needs a premium account and the user's location.
|
||||
* Looking up a frequency doesn't call the web service.
|
||||
*/
|
||||
public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
{
|
||||
private static final Duration HOVER_DELAY = Duration.millis(400);
|
||||
private static final Font FONT = Font.font(11);
|
||||
private static final Font TITLE_FONT = Font.font(Font.getDefault().getFamily(), FontWeight.BOLD, 11);
|
||||
private static final DecimalFormat FREQUENCY_FORMAT = new DecimalFormat("0.00000");
|
||||
private static final long MIN_TOLERANCE_HZ = 3_000;
|
||||
private static final double TOLERANCE_PIXELS = 3.0;
|
||||
private static final int MAX_CANDIDATES = 6;
|
||||
private static final double MAX_TEXT_WIDTH = 380;
|
||||
private static final double PADDING = 6;
|
||||
private static final double GAP = 5;
|
||||
//Space beside the text and below the readout lines, as in the cursor readout, so the readout lines stay in place
|
||||
private static final double PADDING_X = 4;
|
||||
//Space kept between the card and the edges of the section
|
||||
private static final double EDGE_MARGIN = 2;
|
||||
private static final double READOUT_PADDING = 2;
|
||||
private static final String HEADER = "Radio Reference";
|
||||
|
||||
private final RadioReferenceFrequencyIndex mIndex;
|
||||
private final RadioReferencePlaylistActions mActions;
|
||||
private final BooleanProperty mHoverCandidates = new SimpleBooleanProperty(true);
|
||||
private final Text mMeasure = new Text();
|
||||
private final double mTextHeight;
|
||||
private PauseTransition mHoverTimer;
|
||||
private DisplaySection mHoverSection;
|
||||
private double mHoverX = Double.NaN;
|
||||
private double mHoverY = Double.NaN;
|
||||
private boolean mHoverReady;
|
||||
private long mResultsFrequency = Long.MIN_VALUE;
|
||||
private long mResultsTolerance;
|
||||
private List<RankedCandidate> mResults = Collections.emptyList();
|
||||
private Card mCard;
|
||||
|
||||
/**
|
||||
* Candidate text of the card, measured once per lookup
|
||||
* @param entries lines of each candidate: the title, then the details
|
||||
* @param more line, or null
|
||||
* @param textWidth of the widest line
|
||||
* @param lineCount of the header, candidate and more lines
|
||||
* @param maxTextWidth that the lines were shortened to
|
||||
* @param maxHeight that the card was limited to
|
||||
* @param readoutLines that the card was sized for
|
||||
*/
|
||||
private record Card(List<List<String>> entries, String more, double textWidth, int lineCount,
|
||||
double maxTextWidth, double maxHeight, int readoutLines)
|
||||
{
|
||||
}
|
||||
private List<RankedCandidate> mCardCandidates;
|
||||
private List<ChannelCardEntry> mCardEntries = Collections.emptyList();
|
||||
private long mCardEntriesTime;
|
||||
|
||||
/**
|
||||
* Constructs an instance.
|
||||
@@ -125,9 +89,6 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
{
|
||||
mIndex = index;
|
||||
mActions = actions;
|
||||
mMeasure.setFont(FONT);
|
||||
mMeasure.setText("Ag");
|
||||
mTextHeight = Math.ceil(mMeasure.getLayoutBounds().getHeight());
|
||||
mHoverCandidates.addListener((ob, ov, nv) -> requestRender());
|
||||
}
|
||||
|
||||
@@ -148,15 +109,6 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void dispose()
|
||||
{
|
||||
if(mHoverTimer != null)
|
||||
{
|
||||
mHoverTimer.stop();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getConfigurationTitle()
|
||||
{
|
||||
@@ -181,10 +133,17 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
return List.of(hover, new ConfigurationRow("Nearby", status));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getContextMenuSection()
|
||||
{
|
||||
return ChannelMenus.SECTION;
|
||||
}
|
||||
|
||||
/**
|
||||
* Context menu items for the candidates at the frequency, in the card's order: add a candidate to the playlist and
|
||||
* start it, or enable or disable the playlist channel that already decodes it. One item per site, and per
|
||||
* frequency and protocol, so an item never adds a duplicate channel.
|
||||
* Channel entries for the candidates at the frequency, in the card's order. A candidate that a playlist channel
|
||||
* already decodes is listed as that playlist channel, otherwise as a candidate to add to the playlist (and
|
||||
* start). Both can be viewed in the playlist editor's Radio Reference tab (View in Radio Reference). One entry per site, since the site's
|
||||
* frequencies share its channel. Adding never duplicates a playlist channel.
|
||||
*/
|
||||
@Override
|
||||
public List<MenuItem> getContextMenuItems(DisplaySection section, long frequency)
|
||||
@@ -219,139 +178,121 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
|
||||
if(site != null && offered.add(key))
|
||||
{
|
||||
addSiteItem(items, site, candidate, frequency);
|
||||
items.add(createSiteEntry(site, ranked));
|
||||
}
|
||||
}
|
||||
else
|
||||
else if(offered.add("frequency:" + candidate.frequencyHz() + ":" + candidate.title() + ":" +
|
||||
candidate.source()))
|
||||
{
|
||||
DecoderType decoderType = RadioReferencePlaylistActions.getDecoderType(candidate);
|
||||
Set<DecoderType> family = RadioReferencePlaylistActions.getProtocolFamily(decoderType);
|
||||
String protocol = family.isEmpty() ? String.valueOf(candidate.mode()) : family.iterator().next().name();
|
||||
|
||||
if(offered.add("frequency:" + candidate.frequencyHz() + ":" + protocol))
|
||||
{
|
||||
addConventionalItem(items, candidate, decoderType, frequency);
|
||||
}
|
||||
items.add(createConventionalEntry(ranked, RadioReferencePlaylistActions.getDecoderType(candidate)));
|
||||
}
|
||||
}
|
||||
|
||||
if(!items.isEmpty())
|
||||
{
|
||||
MenuItem header = new MenuItem("Radio Reference");
|
||||
header.setDisable(true);
|
||||
items.add(0, header);
|
||||
}
|
||||
|
||||
//Playlist channels first, then the candidates, each in the card's order
|
||||
items.sort(Comparator.comparing(item -> item.getUserData() == null));
|
||||
return items;
|
||||
}
|
||||
|
||||
private void addSiteItem(List<MenuItem> items, SiteRecord site, FrequencyCandidate candidate, long frequency)
|
||||
/**
|
||||
* Entry for a trunked system site, or for the candidate's repeater of a repeater site (LTR)
|
||||
*/
|
||||
private Menu createSiteEntry(SiteRecord site, RankedCandidate ranked)
|
||||
{
|
||||
String label = site.systemName() + " \u00B7 Site " + site.siteNumber() +
|
||||
(site.description() != null ? " " + site.description() : "");
|
||||
FrequencyCandidate candidate = ranked.candidate();
|
||||
boolean repeater = RadioReferencePlaylistActions.isRepeaterSite(site);
|
||||
ViewRadioReferenceRequest view = ViewRadioReferenceRequest.site(site.systemId(), site.siteId());
|
||||
String unsupported = RadioReferencePlaylistActions.getUnsupportedReason(site);
|
||||
Channel existing = unsupported != null ? null : repeater ? mActions.findChannel(List.of(candidate.frequencyHz()),
|
||||
RadioReferencePlaylistActions.getSiteDecoderTypes(site)) : mActions.findSiteChannel(site);
|
||||
|
||||
if(existing != null)
|
||||
{
|
||||
return createPlaylistEntry(existing, view);
|
||||
}
|
||||
|
||||
String title = site.systemName() + " \u00B7 Site " + site.siteNumber() +
|
||||
(site.description() != null ? " " + site.description() : "");
|
||||
|
||||
if(repeater)
|
||||
{
|
||||
title += site.channels().stream().filter(channel -> channel.frequencyHz() == candidate.frequencyHz() &&
|
||||
channel.logicalChannelNumber() > 0).map(channel -> " LCN " + channel.logicalChannelNumber())
|
||||
.findFirst().orElse("");
|
||||
}
|
||||
|
||||
Menu menu = ChannelMenus.createEntry(title, describe(ranked), State.CANDIDATE, null);
|
||||
|
||||
if(unsupported != null)
|
||||
{
|
||||
MenuItem item = new MenuItem(label + " \u2013 " + unsupported);
|
||||
item.setDisable(true);
|
||||
items.add(item);
|
||||
return;
|
||||
menu.getItems().add(ChannelMenus.createNote(unsupported));
|
||||
}
|
||||
|
||||
if(RadioReferencePlaylistActions.isRepeaterSite(site))
|
||||
else if(repeater)
|
||||
{
|
||||
addRepeaterItem(items, site, candidate.frequencyHz(), label, frequency);
|
||||
return;
|
||||
}
|
||||
|
||||
Channel existing = mActions.findSiteChannel(site);
|
||||
|
||||
if(existing != null)
|
||||
{
|
||||
//The channel layer offers the channels at the clicked frequency
|
||||
if(!covers(existing, frequency))
|
||||
{
|
||||
items.add(createEnableItem(existing));
|
||||
}
|
||||
menu.getItems().addAll(
|
||||
ChannelMenus.createItem("Add to Playlist and Start", State.CANDIDATE,
|
||||
() -> mActions.addRepeater(site, candidate.frequencyHz(), true, this::showError)),
|
||||
ChannelMenus.createItem("Add to Playlist", State.CANDIDATE,
|
||||
() -> mActions.addRepeater(site, candidate.frequencyHz(), false, this::showError)));
|
||||
}
|
||||
else
|
||||
{
|
||||
MenuItem item = new MenuItem("Add and Start: " + label);
|
||||
//Start on the right-clicked frequency when it's a control or alternate control channel
|
||||
item.setOnAction(event -> mActions.addSite(site, candidate.frequencyHz(), this::showError));
|
||||
items.add(item);
|
||||
//Start on the candidate frequency when it's a control or alternate control channel
|
||||
menu.getItems().addAll(
|
||||
ChannelMenus.createItem("Add to Playlist and Start", State.CANDIDATE,
|
||||
() -> mActions.addSite(site, candidate.frequencyHz(), true, this::showError)),
|
||||
ChannelMenus.createItem("Add to Playlist", State.CANDIDATE,
|
||||
() -> mActions.addSite(site, candidate.frequencyHz(), false, this::showError)));
|
||||
}
|
||||
|
||||
addViewItem(menu, State.CANDIDATE, view);
|
||||
return menu;
|
||||
}
|
||||
|
||||
/**
|
||||
* Menu item for one repeater of a repeater site (LTR): add and start it, or enable or disable its channel
|
||||
* Entry for a conventional frequency
|
||||
*/
|
||||
private void addRepeaterItem(List<MenuItem> items, SiteRecord site, long repeaterFrequency, String label,
|
||||
long frequency)
|
||||
private Menu createConventionalEntry(RankedCandidate ranked, DecoderType decoderType)
|
||||
{
|
||||
Channel existing = mActions.findChannel(List.of(repeaterFrequency),
|
||||
RadioReferencePlaylistActions.getSiteDecoderTypes(site));
|
||||
FrequencyCandidate candidate = ranked.candidate();
|
||||
String sourceKey = mIndex.getSourceKey(candidate);
|
||||
ViewRadioReferenceRequest view = sourceKey != null ?
|
||||
ViewRadioReferenceRequest.frequency(sourceKey, candidate) : null;
|
||||
Channel existing = decoderType != null ? mActions.findConventionalChannel(candidate) : null;
|
||||
|
||||
if(existing != null)
|
||||
{
|
||||
if(!covers(existing, frequency))
|
||||
{
|
||||
items.add(createEnableItem(existing));
|
||||
}
|
||||
|
||||
return;
|
||||
return createPlaylistEntry(existing, view);
|
||||
}
|
||||
|
||||
String lcn = site.channels().stream().filter(channel -> channel.frequencyHz() == repeaterFrequency &&
|
||||
channel.logicalChannelNumber() > 0).map(channel -> " LCN " + channel.logicalChannelNumber())
|
||||
.findFirst().orElse("");
|
||||
MenuItem item = new MenuItem("Add and Start: " + label + lcn + " (" +
|
||||
FREQUENCY_FORMAT.format(repeaterFrequency / 1E6) + " MHz)");
|
||||
item.setOnAction(event -> mActions.addRepeater(site, repeaterFrequency, this::showError));
|
||||
items.add(item);
|
||||
}
|
||||
|
||||
private void addConventionalItem(List<MenuItem> items, FrequencyCandidate candidate, DecoderType decoderType,
|
||||
long frequency)
|
||||
{
|
||||
String label = candidate.title() + " (" + FREQUENCY_FORMAT.format(candidate.frequencyHz() / 1E6) + " MHz" +
|
||||
(candidate.mode() != null ? " " + candidate.mode() : "") + ")";
|
||||
Menu menu = ChannelMenus.createEntry(candidate.title() != null ? candidate.title() : "(untitled)",
|
||||
describe(ranked), State.CANDIDATE, null);
|
||||
|
||||
if(decoderType == null)
|
||||
{
|
||||
MenuItem item = new MenuItem(label + " \u2013 mode isn't supported");
|
||||
item.setDisable(true);
|
||||
items.add(item);
|
||||
return;
|
||||
}
|
||||
|
||||
Channel existing = mActions.findConventionalChannel(candidate);
|
||||
|
||||
if(existing != null)
|
||||
{
|
||||
if(!covers(existing, frequency))
|
||||
{
|
||||
items.add(createEnableItem(existing));
|
||||
}
|
||||
menu.getItems().add(ChannelMenus.createNote("Mode isn't supported"));
|
||||
}
|
||||
else
|
||||
{
|
||||
MenuItem item = new MenuItem("Add and Start: " + label);
|
||||
item.setOnAction(event -> mActions.addConventional(candidate, this::showError));
|
||||
items.add(item);
|
||||
menu.getItems().addAll(
|
||||
ChannelMenus.createItem("Add to Playlist and Start", State.CANDIDATE,
|
||||
() -> mActions.addConventional(candidate, true, this::showError)),
|
||||
ChannelMenus.createItem("Add to Playlist", State.CANDIDATE,
|
||||
() -> mActions.addConventional(candidate, false, this::showError)));
|
||||
}
|
||||
|
||||
addViewItem(menu, State.CANDIDATE, view);
|
||||
return menu;
|
||||
}
|
||||
|
||||
/**
|
||||
* Menu item that enables the playlist channel when it's disabled, or disables it when it's enabled
|
||||
* Entry for the playlist channel that decodes a candidate: enable or disable it, view or edit it, and view the
|
||||
* candidate in the Radio Reference tab
|
||||
* @param view request for the candidate, or null when its listing isn't known
|
||||
*/
|
||||
private MenuItem createEnableItem(Channel channel)
|
||||
private Menu createPlaylistEntry(Channel channel, ViewRadioReferenceRequest view)
|
||||
{
|
||||
boolean processing = channel.isProcessing();
|
||||
MenuItem item = new MenuItem((processing ? "Disable: " : "Enable: ") + channel.getShortTitle());
|
||||
item.setOnAction(event -> {
|
||||
if(processing)
|
||||
Runnable toggle = channel.isTrafficChannel() ? null : () -> {
|
||||
if(channel.isProcessing())
|
||||
{
|
||||
mActions.disable(channel, this::showError);
|
||||
}
|
||||
@@ -359,25 +300,22 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
{
|
||||
mActions.enable(channel, this::showError);
|
||||
}
|
||||
});
|
||||
return item;
|
||||
};
|
||||
Menu menu = ChannelMenus.createChannelEntry(channel, null, toggle);
|
||||
addViewItem(menu, channel.isProcessing() ? State.ENABLED : State.DISABLED, view);
|
||||
return menu;
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicates if one of the channel's tuner channels includes the frequency
|
||||
* Adds the item that shows the candidate in the playlist editor's Radio Reference tab
|
||||
* @param request to show the candidate, or null when the candidate's listing isn't known
|
||||
*/
|
||||
private static boolean covers(Channel channel, long frequency)
|
||||
private static void addViewItem(Menu menu, State state, ViewRadioReferenceRequest request)
|
||||
{
|
||||
for(TunerChannel tunerChannel: channel.getTunerChannels())
|
||||
{
|
||||
if(tunerChannel != null && tunerChannel.getMinFrequency() <= frequency &&
|
||||
frequency <= tunerChannel.getMaxFrequency())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
MenuItem view = ChannelMenus.createItem("View in Radio Reference", state,
|
||||
() -> MyEventBus.getGlobalEventBus().post(request));
|
||||
view.setDisable(request == null);
|
||||
menu.getItems().addAll(ChannelMenus.createSeparator(), view);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -399,49 +337,88 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderSpectrumForeground(GraphicsContext gc, RenderArea area)
|
||||
{
|
||||
render(gc, area, DisplaySection.SPECTRUM);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderWaterfall(GraphicsContext gc, RenderArea area)
|
||||
{
|
||||
render(gc, area, DisplaySection.WATERFALL);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draws the card in the section under the mouse once the mouse has rested for the hover delay
|
||||
*/
|
||||
private void render(GraphicsContext gc, RenderArea area, DisplaySection section)
|
||||
{
|
||||
DisplayCursor cursor = getSpectralDisplay() != null ? getSpectralDisplay().getDisplayCursor() : null;
|
||||
trackHover(cursor);
|
||||
|
||||
if(cursor != null && cursor.section() == section && replacesCursorReadout(cursor, area))
|
||||
{
|
||||
drawCard(gc, area, cursor, getCandidates(cursor.frequency(), getTolerance(getModel(), area)));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The card replaces the cursor readout while it's shown: it ends with the readout lines, in the readout's place.
|
||||
* Card entries for the candidates at the mouse position, in the card's order. A candidate that a playlist
|
||||
* channel already decodes is listed as that playlist channel.
|
||||
*/
|
||||
@Override
|
||||
public boolean replacesCursorReadout(DisplayCursor cursor, RenderArea area)
|
||||
public List<ChannelCardEntry> getCardEntries(DisplayCursor cursor, RenderArea area)
|
||||
{
|
||||
SpectralDisplayModel model = getModel();
|
||||
|
||||
//Only for the position the mouse rested at - the readout comes back as soon as the mouse moves
|
||||
if(mIndex == null || !mHoverCandidates.get() || !mHoverReady || model == null || !model.hasSource() ||
|
||||
cursor == null || cursor.section() != mHoverSection || cursor.x() != mHoverX || cursor.y() != mHoverY ||
|
||||
area.width() <= 0)
|
||||
if(mIndex == null || !mHoverCandidates.get() || model == null || area.width() <= 0)
|
||||
{
|
||||
return false;
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
return !getCandidates(cursor.frequency(), getTolerance(model, area)).isEmpty();
|
||||
List<RankedCandidate> candidates = getCandidates(cursor.frequency(), getTolerance(model, area));
|
||||
|
||||
//The playlist channels of the candidates, looked up once per lookup or second, since that copies the playlist
|
||||
if(candidates != mCardCandidates || System.currentTimeMillis() - mCardEntriesTime > 1000)
|
||||
{
|
||||
mCardCandidates = candidates;
|
||||
mCardEntriesTime = System.currentTimeMillis();
|
||||
mCardEntries = createCardEntries(candidates);
|
||||
}
|
||||
|
||||
return mCardEntries;
|
||||
}
|
||||
|
||||
private List<ChannelCardEntry> createCardEntries(List<RankedCandidate> candidates)
|
||||
{
|
||||
List<ChannelCardEntry> entries = new ArrayList<>();
|
||||
Set<String> listed = new HashSet<>();
|
||||
|
||||
for(RankedCandidate ranked: candidates)
|
||||
{
|
||||
FrequencyCandidate candidate = ranked.candidate();
|
||||
Channel existing = mActions != null ? findChannel(candidate) : null;
|
||||
|
||||
if(existing != null)
|
||||
{
|
||||
entries.add(ChannelMenus.createCardEntry(existing, null, true));
|
||||
}
|
||||
//The same listing in several places (e.g. a county and its agency) is shown once
|
||||
else if(listed.add(candidate.frequencyHz() + "|" + candidate.title() + "|" + candidate.source()))
|
||||
{
|
||||
List<String> details = new ArrayList<>();
|
||||
details.add(describe(ranked));
|
||||
String source = source(candidate);
|
||||
|
||||
if(source != null)
|
||||
{
|
||||
details.add(source);
|
||||
}
|
||||
|
||||
String title = candidate.title() != null ? candidate.title() : "(untitled)";
|
||||
entries.add(new ChannelCardEntry(title, details, State.CANDIDATE, null, true));
|
||||
}
|
||||
}
|
||||
|
||||
return entries;
|
||||
}
|
||||
|
||||
/**
|
||||
* Playlist channel that decodes the candidate, or null
|
||||
*/
|
||||
private Channel findChannel(FrequencyCandidate candidate)
|
||||
{
|
||||
if(candidate.isSiteFrequency())
|
||||
{
|
||||
SiteRecord site = mIndex.getSite(candidate.systemId(), candidate.siteId());
|
||||
|
||||
if(site == null || RadioReferencePlaylistActions.getUnsupportedReason(site) != null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
return RadioReferencePlaylistActions.isRepeaterSite(site) ?
|
||||
mActions.findChannel(List.of(candidate.frequencyHz()),
|
||||
RadioReferencePlaylistActions.getSiteDecoderTypes(site)) : mActions.findSiteChannel(site);
|
||||
}
|
||||
|
||||
return RadioReferencePlaylistActions.getDecoderType(candidate) != null ?
|
||||
mActions.findConventionalChannel(candidate) : null;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -453,47 +430,6 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
return Math.max(MIN_TOLERANCE_HZ, Math.round(Math.max(TOLERANCE_PIXELS * hertzPerPixel, model.getBinWidth())));
|
||||
}
|
||||
|
||||
/**
|
||||
* Restarts the hover delay each time the mouse moves, and hides the card until it passes
|
||||
*/
|
||||
private void trackHover(DisplayCursor cursor)
|
||||
{
|
||||
if(cursor == null)
|
||||
{
|
||||
if(mHoverSection != null)
|
||||
{
|
||||
mHoverSection = null;
|
||||
mHoverReady = false;
|
||||
getHoverTimer().stop();
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if(cursor.section() != mHoverSection || cursor.x() != mHoverX || cursor.y() != mHoverY)
|
||||
{
|
||||
mHoverSection = cursor.section();
|
||||
mHoverX = cursor.x();
|
||||
mHoverY = cursor.y();
|
||||
mHoverReady = false;
|
||||
getHoverTimer().playFromStart();
|
||||
}
|
||||
}
|
||||
|
||||
private PauseTransition getHoverTimer()
|
||||
{
|
||||
if(mHoverTimer == null)
|
||||
{
|
||||
mHoverTimer = new PauseTransition(HOVER_DELAY);
|
||||
mHoverTimer.setOnFinished(event -> {
|
||||
mHoverReady = true;
|
||||
requestRender();
|
||||
});
|
||||
}
|
||||
|
||||
return mHoverTimer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Candidates for the frequency, looked up again only when the frequency or the tolerance changes
|
||||
*/
|
||||
@@ -504,172 +440,11 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
mResults = mIndex.lookup(frequency, tolerance);
|
||||
mResultsFrequency = frequency;
|
||||
mResultsTolerance = tolerance;
|
||||
mCard = null;
|
||||
}
|
||||
|
||||
return mResults;
|
||||
}
|
||||
|
||||
/**
|
||||
* Draws the card in place of the cursor readout: beside the mouse and above it, placed like the readout, with the
|
||||
* candidates above the readout lines so the frequency and level stay where the readout showed them. The card
|
||||
* fits the larger side of the mouse and the height of the section, showing as many candidates as fit.
|
||||
*/
|
||||
private void drawCard(GraphicsContext gc, RenderArea area, DisplayCursor cursor, List<RankedCandidate> candidates)
|
||||
{
|
||||
//The level line changes with the mouse height while the candidates don't
|
||||
List<String> readout = CursorReadout.lines(cursor, area, getModel());
|
||||
double readoutWidth = 0;
|
||||
|
||||
for(String line: readout)
|
||||
{
|
||||
readoutWidth = Math.max(readoutWidth, measure(line, FONT));
|
||||
}
|
||||
|
||||
double room = Math.max(area.width() - cursor.x(), cursor.x()) - CursorReadout.GAP_X - EDGE_MARGIN;
|
||||
double maxTextWidth = Math.max(readoutWidth, Math.min(MAX_TEXT_WIDTH, room - (PADDING_X * 2)));
|
||||
//Above the mouse, so the readout lines stay where the readout showed them, when a candidate fits there
|
||||
double above = cursor.y() - CursorReadout.GAP_Y;
|
||||
double maxHeight = above >= cardHeight(5, 1, true, readout.size()) ? above : area.plotHeight() - EDGE_MARGIN;
|
||||
|
||||
if(mCard == null || mCard.maxTextWidth() != maxTextWidth || mCard.maxHeight() != maxHeight ||
|
||||
mCard.readoutLines() != readout.size())
|
||||
{
|
||||
mCard = createCard(candidates, maxTextWidth, maxHeight, readout.size());
|
||||
}
|
||||
|
||||
Card card = mCard;
|
||||
SpectralDisplayTheme theme = getSpectralDisplay().getTheme();
|
||||
double width = Math.max(card.textWidth(), readoutWidth) + (PADDING_X * 2);
|
||||
double height = cardHeight(card.lineCount(), card.entries().size(), card.more() != null, readout.size());
|
||||
double x = Math.max(0, CursorReadout.x(cursor, width, area));
|
||||
double y = CursorReadout.y(cursor, height, area);
|
||||
|
||||
gc.setFill(theme.getBackground(0.92));
|
||||
gc.fillRoundRect(x, y, width, height, 8, 8);
|
||||
gc.setStroke(opaque(theme.getLine()));
|
||||
gc.setLineWidth(1.0);
|
||||
gc.strokeRoundRect(Math.floor(x) + 0.5, Math.floor(y) + 0.5, width, height, 8, 8);
|
||||
gc.setTextAlign(TextAlignment.LEFT);
|
||||
gc.setTextBaseline(VPos.TOP);
|
||||
|
||||
double textX = x + PADDING_X;
|
||||
double lineY = y + PADDING;
|
||||
gc.setFill(theme.getCursor());
|
||||
gc.setFont(TITLE_FONT);
|
||||
gc.fillText(HEADER, textX, lineY);
|
||||
lineY += mTextHeight + GAP;
|
||||
|
||||
for(List<String> lines: card.entries())
|
||||
{
|
||||
gc.setFill(theme.getCursor());
|
||||
gc.setFont(TITLE_FONT);
|
||||
gc.fillText(lines.get(0), textX, lineY);
|
||||
lineY += mTextHeight;
|
||||
gc.setFill(opaque(theme.getLine()));
|
||||
gc.setFont(FONT);
|
||||
|
||||
for(int line = 1; line < lines.size(); line++)
|
||||
{
|
||||
gc.fillText(lines.get(line), textX, lineY);
|
||||
lineY += mTextHeight;
|
||||
}
|
||||
|
||||
lineY += GAP;
|
||||
}
|
||||
|
||||
if(card.more() != null)
|
||||
{
|
||||
gc.setFill(opaque(theme.getLine()));
|
||||
gc.setFont(FONT);
|
||||
gc.fillText(card.more(), textX, lineY);
|
||||
lineY += mTextHeight + GAP;
|
||||
}
|
||||
|
||||
//The readout lines, separated from the candidates, in the readout's style
|
||||
double separator = Math.floor(lineY - (GAP / 2.0)) + 0.5;
|
||||
gc.setStroke(theme.getLine(0.5));
|
||||
gc.strokeLine(textX, separator, x + width - PADDING_X, separator);
|
||||
gc.setFill(theme.getCursor());
|
||||
gc.setFont(FONT);
|
||||
|
||||
for(String line: readout)
|
||||
{
|
||||
gc.fillText(line, textX, lineY);
|
||||
lineY += mTextHeight;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Height of a card with the lines
|
||||
* @param lineCount of the header, candidate and more lines
|
||||
* @param entries number of candidates
|
||||
* @param more true when the card has a more line
|
||||
* @param readoutLines number of readout lines
|
||||
*/
|
||||
private double cardHeight(int lineCount, int entries, boolean more, int readoutLines)
|
||||
{
|
||||
int gaps = 1 + entries + (more ? 1 : 0);
|
||||
return ((lineCount + readoutLines) * mTextHeight) + (gaps * GAP) + PADDING + READOUT_PADDING;
|
||||
}
|
||||
|
||||
/**
|
||||
* Card text for as many candidates as fit the height: each candidate's title, details and source, shortened to
|
||||
* the width
|
||||
*/
|
||||
private Card createCard(List<RankedCandidate> candidates, double maxTextWidth, double maxHeight,
|
||||
int readoutLines)
|
||||
{
|
||||
int limit = Math.min(candidates.size(), MAX_CANDIDATES);
|
||||
List<List<String>> entries = new ArrayList<>();
|
||||
double textWidth = measure(HEADER, TITLE_FONT);
|
||||
int lineCount = 1;
|
||||
|
||||
for(int index = 0; index < limit; index++)
|
||||
{
|
||||
RankedCandidate candidate = candidates.get(index);
|
||||
List<String> lines = new ArrayList<>();
|
||||
String title = candidate.candidate().title() != null ? candidate.candidate().title() : "(untitled)";
|
||||
lines.add(fit(title, TITLE_FONT, maxTextWidth));
|
||||
lines.add(fit(describe(candidate), FONT, maxTextWidth));
|
||||
String source = source(candidate.candidate());
|
||||
|
||||
if(source != null)
|
||||
{
|
||||
lines.add(fit(source, FONT, maxTextWidth));
|
||||
}
|
||||
|
||||
//Keep room for the more line when candidates are left out
|
||||
boolean more = index + 1 < candidates.size();
|
||||
|
||||
if(!entries.isEmpty() && cardHeight(lineCount + lines.size() + (more ? 1 : 0), entries.size() + 1, more,
|
||||
readoutLines) > maxHeight)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
textWidth = Math.max(textWidth, measure(lines.get(0), TITLE_FONT));
|
||||
|
||||
for(int line = 1; line < lines.size(); line++)
|
||||
{
|
||||
textWidth = Math.max(textWidth, measure(lines.get(line), FONT));
|
||||
}
|
||||
|
||||
lineCount += lines.size();
|
||||
entries.add(lines);
|
||||
}
|
||||
|
||||
String more = candidates.size() > entries.size() ? "+ " + (candidates.size() - entries.size()) + " more" : null;
|
||||
|
||||
if(more != null)
|
||||
{
|
||||
textWidth = Math.max(textWidth, measure(more, FONT));
|
||||
lineCount++;
|
||||
}
|
||||
|
||||
return new Card(entries, more, textWidth, lineCount, maxTextWidth, maxHeight, readoutLines);
|
||||
}
|
||||
|
||||
/**
|
||||
* Frequency, mode or use, tone, encryption and distance of the candidate
|
||||
*/
|
||||
@@ -691,35 +466,6 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
return join(alphaTag, candidate.source());
|
||||
}
|
||||
|
||||
/**
|
||||
* Text shortened with an ellipsis to fit the width
|
||||
*/
|
||||
private String fit(String text, Font font, double maxWidth)
|
||||
{
|
||||
if(measure(text, font) <= maxWidth)
|
||||
{
|
||||
return text;
|
||||
}
|
||||
|
||||
int length = text.length();
|
||||
|
||||
while(length > 1 && measure(text.substring(0, length) + "…", font) > maxWidth)
|
||||
{
|
||||
length--;
|
||||
}
|
||||
|
||||
return text.substring(0, length) + "…";
|
||||
}
|
||||
|
||||
private double measure(String text, Font font)
|
||||
{
|
||||
mMeasure.setFont(font);
|
||||
mMeasure.setText(text);
|
||||
double width = mMeasure.getLayoutBounds().getWidth();
|
||||
mMeasure.setFont(FONT);
|
||||
return width;
|
||||
}
|
||||
|
||||
private static String join(String... values)
|
||||
{
|
||||
StringBuilder sb = new StringBuilder();
|
||||
@@ -739,9 +485,4 @@ public class RadioReferenceLayer extends SpectralDisplayLayer
|
||||
|
||||
return sb.isEmpty() ? null : sb.toString();
|
||||
}
|
||||
|
||||
private static Color opaque(Color color)
|
||||
{
|
||||
return Color.color(color.getRed(), color.getGreen(), color.getBlue());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -57,6 +57,7 @@ public class TableColumnMonitor<S>
|
||||
public static final String LEGACY_INDEX = "column.legacy.index";
|
||||
private static final String ORDER = ".column.order";
|
||||
private static final String HIDDEN = ".column.hidden";
|
||||
private static final String KNOWN = ".column.known";
|
||||
private static final String WIDTH = ".column.width.";
|
||||
private static final String SEPARATOR = ",";
|
||||
|
||||
@@ -230,6 +231,7 @@ public class TableColumnMonitor<S>
|
||||
|
||||
mPreferences.remove(mKey + ORDER);
|
||||
mPreferences.remove(mKey + HIDDEN);
|
||||
mPreferences.remove(mKey + KNOWN);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -328,10 +330,13 @@ public class TableColumnMonitor<S>
|
||||
if(hidden != null)
|
||||
{
|
||||
Set<String> hiddenIds = Set.of(hidden.isEmpty() ? new String[0] : hidden.split(SEPARATOR));
|
||||
Set<String> knownIds = getKnownIds();
|
||||
|
||||
for(TableColumn<S,?> column: mDefaultOrder)
|
||||
{
|
||||
column.setVisible(!hiddenIds.contains(column.getId()));
|
||||
//Columns that weren't in the table when the visibility was stored are new, so use the default
|
||||
column.setVisible(knownIds.contains(column.getId()) ? !hiddenIds.contains(column.getId()) :
|
||||
mDefaultVisibility.get(column));
|
||||
}
|
||||
|
||||
if(getVisibleColumnCount() == 0)
|
||||
@@ -375,6 +380,32 @@ public class TableColumnMonitor<S>
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* IDs of the columns that were in the table when the visibility was stored. Settings stored before the known
|
||||
* columns were stored only had columns that are shown by default.
|
||||
*/
|
||||
private Set<String> getKnownIds()
|
||||
{
|
||||
String known = mPreferences.get(mKey + KNOWN, null);
|
||||
|
||||
if(known != null)
|
||||
{
|
||||
return Set.of(known.isEmpty() ? new String[0] : known.split(SEPARATOR));
|
||||
}
|
||||
|
||||
Set<String> ids = new HashSet<>();
|
||||
|
||||
for(TableColumn<S,?> column: mDefaultOrder)
|
||||
{
|
||||
if(mDefaultVisibility.get(column))
|
||||
{
|
||||
ids.add(column.getId());
|
||||
}
|
||||
}
|
||||
|
||||
return ids;
|
||||
}
|
||||
|
||||
private int getVisibleColumnCount()
|
||||
{
|
||||
int count = 0;
|
||||
@@ -405,9 +436,12 @@ public class TableColumnMonitor<S>
|
||||
private void storeVisibility()
|
||||
{
|
||||
List<String> ids = new ArrayList<>();
|
||||
List<String> known = new ArrayList<>();
|
||||
|
||||
for(TableColumn<S,?> column: mDefaultOrder)
|
||||
{
|
||||
known.add(column.getId());
|
||||
|
||||
if(!column.isVisible())
|
||||
{
|
||||
ids.add(column.getId());
|
||||
@@ -415,6 +449,7 @@ public class TableColumnMonitor<S>
|
||||
}
|
||||
|
||||
mPreferences.put(mKey + HIDDEN, String.join(SEPARATOR, ids));
|
||||
mPreferences.put(mKey + KNOWN, String.join(SEPARATOR, known));
|
||||
}
|
||||
|
||||
private String getWidthKey(TableColumn<S,?> column)
|
||||
|
||||
@@ -502,10 +502,10 @@ public class ThemeManager
|
||||
.append("-fx-background-color: ").append(accent).append(";")
|
||||
.append("}");
|
||||
|
||||
//URL-encode the body; java.net.URLEncoder is fine for our restricted charset.
|
||||
String encoded = java.net.URLEncoder.encode(css.toString(),
|
||||
java.nio.charset.StandardCharsets.UTF_8);
|
||||
return "data:text/css," + encoded;
|
||||
//Base64-encode the body. Don't use URLEncoder: it is form encoding and turns spaces
|
||||
//into '+', which a data URL doesn't decode, so JavaFX silently drops the whole sheet.
|
||||
return "data:text/css;base64," + java.util.Base64.getEncoder().encodeToString(
|
||||
css.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8));
|
||||
}
|
||||
catch(Throwable t)
|
||||
{
|
||||
|
||||
@@ -123,6 +123,8 @@ public class RadioReferenceFrequencyIndex
|
||||
});
|
||||
private volatile NavigableMap<Long,List<FrequencyCandidate>> mFrequencies = Collections.emptyNavigableMap();
|
||||
private volatile List<SiteRecord> mSites = Collections.emptyList();
|
||||
//Key of the source (county:123 or agency:789) that lists each conventional frequency
|
||||
private volatile Map<FrequencyCandidate,String> mSourceKeys = Collections.emptyMap();
|
||||
private final List<Runnable> mUpdateListeners = new java.util.concurrent.CopyOnWriteArrayList<>();
|
||||
private volatile BuildParameters mParameters;
|
||||
private volatile long mRefreshed;
|
||||
@@ -308,6 +310,7 @@ public class RadioReferenceFrequencyIndex
|
||||
stopBuild();
|
||||
mFrequencies = Collections.emptyNavigableMap();
|
||||
mSites = Collections.emptyList();
|
||||
mSourceKeys = Collections.emptyMap();
|
||||
mParameters = null;
|
||||
notifyUpdated();
|
||||
setStatus("Set your location in the playlist editor's Radio Reference tab");
|
||||
@@ -1105,6 +1108,16 @@ public class RadioReferenceFrequencyIndex
|
||||
nonNull(source.candidates()).stream().anyMatch(candidate -> !candidate.isSiteFrequency()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Key of the radio reference source that lists the conventional frequency: county:123 for a county's frequencies
|
||||
* or agency:789 for an agency's frequencies. Can be called from any thread.
|
||||
* @return key, or null when the index doesn't have the candidate or it's a trunked site frequency
|
||||
*/
|
||||
public String getSourceKey(FrequencyCandidate candidate)
|
||||
{
|
||||
return candidate != null ? mSourceKeys.get(candidate) : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Site record by system and site id
|
||||
* @return site, or null when the index doesn't have it
|
||||
@@ -1280,13 +1293,23 @@ public class RadioReferenceFrequencyIndex
|
||||
{
|
||||
mFrequencies = toFrequencies(sources);
|
||||
List<SiteRecord> sites = new ArrayList<>();
|
||||
Map<FrequencyCandidate,String> sourceKeys = new HashMap<>();
|
||||
|
||||
for(Source source: sources)
|
||||
{
|
||||
sites.addAll(nonNull(source.sites()));
|
||||
|
||||
if(!source.isSystem())
|
||||
{
|
||||
for(FrequencyCandidate candidate: nonNull(source.candidates()))
|
||||
{
|
||||
sourceKeys.putIfAbsent(candidate, source.key());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mSites = Collections.unmodifiableList(sites);
|
||||
mSourceKeys = Collections.unmodifiableMap(sourceKeys);
|
||||
notifyUpdated();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,206 @@
|
||||
/*
|
||||
* *****************************************************************************
|
||||
* Copyright (C) 2014-2026 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 io.github.dsheirer.source.tuner;
|
||||
|
||||
import java.text.DecimalFormat;
|
||||
import java.util.function.DoubleSupplier;
|
||||
import java.util.function.Supplier;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* Lightweight sample drop detector for tuners that don't provide sample counters or hardware timestamps. Counts the
|
||||
* samples delivered by the tuner and compares the count against the number of samples expected from the sample rate
|
||||
* and the elapsed (host) time. Logs a warning when the tuner consistently delivers fewer samples than expected, which
|
||||
* indicates that samples are being dropped (ie by the USB bus or because the host isn't keeping up).
|
||||
*
|
||||
* Detection: each evaluation window (5 seconds) produces a sample deficit (expected minus received). The deficit is
|
||||
* accumulated with a cumulative sum that subtracts an allowance for the clock difference between the tuner and the
|
||||
* host, and that never goes below zero. Buffer delivery jitter (ie a delayed buffer) adds a deficit to one window
|
||||
* that the following window gives back, while dropped samples are never given back. So drops are only declared
|
||||
* when the accumulated deficit exceeds the threshold at two consecutive evaluations.
|
||||
*
|
||||
* The stream is assumed to be stopped (ie no buffer listeners) or restarted when buffers stop arriving for longer than
|
||||
* the restart gap, and detection restarts with the next buffer. Detection also restarts when the sample rate changes.
|
||||
*
|
||||
* Note: process() is invoked on the tuner's sample stream thread and is not thread safe.
|
||||
*/
|
||||
public class SampleDropMonitor
|
||||
{
|
||||
private static final Logger LOG = LoggerFactory.getLogger(SampleDropMonitor.class);
|
||||
private static final DecimalFormat PERCENT_FORMAT = new DecimalFormat("0.00");
|
||||
private static final long NANOS_PER_SECOND = 1_000_000_000L;
|
||||
//Evaluation window
|
||||
static final long WINDOW_NANOS = 5 * NANOS_PER_SECOND;
|
||||
//Buffer arrival gap that indicates the stream was stopped and restarted
|
||||
static final long RESTART_GAP_NANOS = 2 * NANOS_PER_SECOND;
|
||||
//Minimum interval between warnings, so that drops are summarized instead of logged every window
|
||||
static final long LOG_INTERVAL_NANOS = 60 * NANOS_PER_SECOND;
|
||||
//Allowance for the tuner versus host clock difference and sample rate rounding (parts per million). Drop rates
|
||||
//below this aren't detected.
|
||||
static final double CLOCK_ALLOWANCE = 500.0 / 1_000_000.0;
|
||||
//Accumulated deficit that indicates dropped samples, in milliseconds of samples
|
||||
static final double THRESHOLD_MILLISECONDS = 20.0;
|
||||
|
||||
private final DoubleSupplier mSampleRateSupplier;
|
||||
private final Supplier<String> mTunerNameSupplier;
|
||||
private boolean mStarted = false;
|
||||
private long mWindowStart;
|
||||
private long mLastBuffer;
|
||||
private long mLastLog;
|
||||
private long mWindowSampleCount;
|
||||
private double mSampleRate;
|
||||
private double mAccumulatedDeficit;
|
||||
private boolean mThresholdExceeded;
|
||||
//Start of the period summarized by the next warning: the detection (re)start or the previous warning.
|
||||
private long mReportStart;
|
||||
private double mUnreportedDroppedSamples;
|
||||
private long mTotalDroppedSamples;
|
||||
|
||||
/**
|
||||
* Constructs an instance
|
||||
* @param tunerNameSupplier provides the tuner name for log messages.
|
||||
* @param sampleRateSupplier provides the tuner's current sample rate.
|
||||
*/
|
||||
public SampleDropMonitor(Supplier<String> tunerNameSupplier, DoubleSupplier sampleRateSupplier)
|
||||
{
|
||||
mTunerNameSupplier = tunerNameSupplier;
|
||||
mSampleRateSupplier = sampleRateSupplier;
|
||||
}
|
||||
|
||||
/**
|
||||
* Total number of samples detected as dropped since this monitor was created.
|
||||
*/
|
||||
public long getTotalDroppedSamples()
|
||||
{
|
||||
return mTotalDroppedSamples;
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes a buffer of samples received from the tuner.
|
||||
* @param sampleCount number of (complex) samples in the buffer.
|
||||
*/
|
||||
public void process(int sampleCount)
|
||||
{
|
||||
process(sampleCount, System.nanoTime());
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes a buffer of samples received from the tuner.
|
||||
* @param sampleCount number of (complex) samples in the buffer.
|
||||
* @param now arrival time in nanoseconds (System.nanoTime()).
|
||||
*/
|
||||
void process(int sampleCount, long now)
|
||||
{
|
||||
if(!mStarted || now - mLastBuffer > RESTART_GAP_NANOS)
|
||||
{
|
||||
restart(now);
|
||||
return;
|
||||
}
|
||||
|
||||
mLastBuffer = now;
|
||||
//The samples of each buffer arriving within the window (after the window's starting buffer) were produced during
|
||||
//the window.
|
||||
mWindowSampleCount += sampleCount;
|
||||
|
||||
long elapsed = now - mWindowStart;
|
||||
|
||||
if(elapsed >= WINDOW_NANOS)
|
||||
{
|
||||
evaluate(now, elapsed);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Restarts detection. The buffer at the restart time starts the window and isn't counted, since its samples were
|
||||
* produced before the window start.
|
||||
*/
|
||||
private void restart(long now)
|
||||
{
|
||||
mStarted = true;
|
||||
mWindowStart = now;
|
||||
mLastBuffer = now;
|
||||
mLastLog = now - LOG_INTERVAL_NANOS;
|
||||
mReportStart = now;
|
||||
mUnreportedDroppedSamples = 0.0;
|
||||
mWindowSampleCount = 0;
|
||||
mSampleRate = mSampleRateSupplier.getAsDouble();
|
||||
mAccumulatedDeficit = 0.0;
|
||||
mThresholdExceeded = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Evaluates the completed window and starts the next window.
|
||||
*/
|
||||
private void evaluate(long now, long elapsed)
|
||||
{
|
||||
double sampleRate = mSampleRateSupplier.getAsDouble();
|
||||
|
||||
if(sampleRate != mSampleRate || sampleRate <= 0)
|
||||
{
|
||||
restart(now);
|
||||
return;
|
||||
}
|
||||
|
||||
double expected = sampleRate * elapsed / NANOS_PER_SECOND;
|
||||
double deficit = expected - mWindowSampleCount;
|
||||
mAccumulatedDeficit = Math.max(0.0, mAccumulatedDeficit + deficit - (expected * CLOCK_ALLOWANCE));
|
||||
|
||||
if(mAccumulatedDeficit > sampleRate * THRESHOLD_MILLISECONDS / 1000.0)
|
||||
{
|
||||
//Require the deficit to persist across a second window to rule out buffer delivery jitter.
|
||||
if(mThresholdExceeded)
|
||||
{
|
||||
mUnreportedDroppedSamples += mAccumulatedDeficit;
|
||||
mTotalDroppedSamples += (long)mAccumulatedDeficit;
|
||||
mAccumulatedDeficit = 0.0;
|
||||
mThresholdExceeded = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
mThresholdExceeded = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mThresholdExceeded = false;
|
||||
}
|
||||
|
||||
if(mUnreportedDroppedSamples > 0 && now - mLastLog >= LOG_INTERVAL_NANOS)
|
||||
{
|
||||
double period = (double)(now - mReportStart) / NANOS_PER_SECOND;
|
||||
double milliseconds = mUnreportedDroppedSamples / sampleRate * 1000.0;
|
||||
double percent = mUnreportedDroppedSamples / (sampleRate * period) * 100.0;
|
||||
LOG.warn("Tuner [" + mTunerNameSupplier.get() + "] is dropping samples - approximately [" +
|
||||
(long)mUnreportedDroppedSamples + "] samples (" + Math.round(milliseconds) + " ms, " +
|
||||
PERCENT_FORMAT.format(percent) + "% of the sample stream) were lost over the last " +
|
||||
Math.round(period) + " seconds. The USB bus or the computer isn't keeping up with the tuner's " +
|
||||
"sample rate. Dropped samples cause decoders to lose sync and cause choppy audio. Try a " +
|
||||
"different USB port or USB controller, avoid USB hubs and extension cables, don't share the USB " +
|
||||
"controller with other tuners, or lower the tuner sample rate.");
|
||||
mLastLog = now;
|
||||
mReportStart = now;
|
||||
mUnreportedDroppedSamples = 0.0;
|
||||
}
|
||||
|
||||
mWindowStart = now;
|
||||
mWindowSampleCount = 0;
|
||||
}
|
||||
}
|
||||
@@ -89,6 +89,7 @@ public abstract class Tuner implements ISourceEventProcessor, ITunerErrorListene
|
||||
try
|
||||
{
|
||||
getTunerController().start();
|
||||
getTunerController().setSampleDropMonitorTunerName(getPreferredName());
|
||||
}
|
||||
catch(SourceException se)
|
||||
{
|
||||
|
||||
@@ -63,6 +63,8 @@ public abstract class TunerController implements Tunable, ISourceEventProcessor,
|
||||
private ITunerErrorListener mTunerErrorListener;
|
||||
private static final DecimalFormat DF = new DecimalFormat("0.000");
|
||||
protected TunerFrequencyErrorManager mTunerFrequencyErrorManager;
|
||||
private final SampleDropMonitor mSampleDropMonitor;
|
||||
private volatile String mSampleDropMonitorTunerName;
|
||||
|
||||
/**
|
||||
* Abstract tuner controller class. The tuner controller manages frequency bandwidth and currently tuned channels
|
||||
@@ -75,6 +77,39 @@ public abstract class TunerController implements Tunable, ISourceEventProcessor,
|
||||
mFrequencyController = new FrequencyController(this);
|
||||
mSourceEventListener = new SourceEventListenerToProcessorAdapter(this);
|
||||
mTunerFrequencyErrorManager = new TunerFrequencyErrorManager(this);
|
||||
mSampleDropMonitor = isSampleDropMonitorSupported() ? new SampleDropMonitor(this::getSampleDropMonitorTunerName,
|
||||
this::getSampleRate) : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicates if the tuner's sample stream should be monitored for dropped samples by counting the samples delivered
|
||||
* against the sample rate. Override to disable for sources that aren't real-time (ie recordings) or for tuners
|
||||
* that detect dropped samples from hardware sample counters or timestamps.
|
||||
*
|
||||
* Note: invoked from this class's constructor, so overrides must not depend on subclass state.
|
||||
* @return true to monitor (default).
|
||||
*/
|
||||
protected boolean isSampleDropMonitorSupported()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the tuner name used when logging dropped sample warnings.
|
||||
* @param tunerName to log
|
||||
*/
|
||||
public void setSampleDropMonitorTunerName(String tunerName)
|
||||
{
|
||||
mSampleDropMonitorTunerName = tunerName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tuner name for dropped sample warnings: the name set by the tuner, or the tuner type.
|
||||
*/
|
||||
private String getSampleDropMonitorTunerName()
|
||||
{
|
||||
String name = mSampleDropMonitorTunerName;
|
||||
return name != null ? name : String.valueOf(getTunerType());
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -684,6 +719,11 @@ public abstract class TunerController implements Tunable, ISourceEventProcessor,
|
||||
*/
|
||||
protected void broadcast(INativeBuffer complexSamples)
|
||||
{
|
||||
if(mSampleDropMonitor != null)
|
||||
{
|
||||
mSampleDropMonitor.process(complexSamples.sampleCount());
|
||||
}
|
||||
|
||||
//Note: unprotected access to the broadcaster ... the broadcaster uses thread-save internal list
|
||||
mNativeBufferBroadcaster.broadcast(complexSamples);
|
||||
}
|
||||
|
||||
@@ -47,7 +47,7 @@ public class MultiFrequencyTunerChannelSource extends TunerChannelSource
|
||||
private final static Logger mLog = LoggerFactory.getLogger(MultiFrequencyTunerChannelSource.class);
|
||||
|
||||
private TunerManager mTunerManager;
|
||||
private TunerChannelSource mTunerChannelSource;
|
||||
private volatile TunerChannelSource mTunerChannelSource;
|
||||
private List<Long> mFrequencies;
|
||||
private List<Long> mLockedFrequencies = new ArrayList<>();
|
||||
private int mFrequencyListPointer = 0;
|
||||
@@ -73,6 +73,17 @@ public class MultiFrequencyTunerChannelSource extends TunerChannelSource
|
||||
mPreferredTuner = preferredTuner;
|
||||
}
|
||||
|
||||
/**
|
||||
* Name of the tuner that provides the current frequency's tuner channel source, which can change as the
|
||||
* frequencies rotate.
|
||||
*/
|
||||
@Override
|
||||
public String getTunerName()
|
||||
{
|
||||
TunerChannelSource source = mTunerChannelSource;
|
||||
return source != null ? source.getTunerName() : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies the channel decoder requested frequency correction.
|
||||
* @param correction requested by the downstream processors.
|
||||
|
||||
@@ -41,6 +41,7 @@ public abstract class TunerChannelSource extends ComplexSource implements ISourc
|
||||
protected String mThreadName;
|
||||
private final ChannelFrequencyErrorManager mChannelFrequencyErrorManager;
|
||||
private volatile long mStartTimestamp;
|
||||
private volatile String mTunerName;
|
||||
|
||||
/**
|
||||
* Tuner Channel Source is a Digital Drop Channel (DDC) abstract class that defines the minimum functionality
|
||||
@@ -112,6 +113,24 @@ public abstract class TunerChannelSource extends ComplexSource implements ISourc
|
||||
return mTunerChannel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Name of the tuner that provides this channel source.
|
||||
* @return preferred name of the tuner or null if not set
|
||||
*/
|
||||
public String getTunerName()
|
||||
{
|
||||
return mTunerName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the name of the tuner that provides this channel source.
|
||||
* @param tunerName preferred name of the tuner
|
||||
*/
|
||||
public void setTunerName(String tunerName)
|
||||
{
|
||||
mTunerName = tunerName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the timestamp for the oldest samples to provide to this channel when it starts. This only applies to
|
||||
* sources where the producer incorporates a sample delay buffer.
|
||||
|
||||
@@ -99,7 +99,7 @@ public abstract class FCDTunerController extends TunerController
|
||||
mComplexMixer = new ComplexMixer(mixerTDL, tunerType.getAudioFormat(), tunerType.getDisplayString(),
|
||||
new ComplexShortAdapter());
|
||||
mComplexMixer.setBufferSampleCount(getBufferSampleCount());
|
||||
mComplexMixer.setBufferListener(mNativeBufferBroadcaster);
|
||||
mComplexMixer.setBufferListener(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -151,6 +151,16 @@ public class LimeSdrTunerController extends TunerController
|
||||
setUsableBandwidthPercentage(USABLE_BANDWIDTH_PERCENT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Disables the generic sample drop monitor since dropped samples are counted exactly from the hardware sample
|
||||
* timestamps (see countDroppedSamples()).
|
||||
*/
|
||||
@Override
|
||||
protected boolean isSampleDropMonitorSupported()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public TunerType getTunerType()
|
||||
{
|
||||
|
||||
@@ -655,6 +655,7 @@ public class TunerManager implements IDiscoveredTunerStatusListener
|
||||
|
||||
if(source != null)
|
||||
{
|
||||
source.setTunerName(discoveredTuner.getTuner().getPreferredName());
|
||||
return source;
|
||||
}
|
||||
}
|
||||
@@ -680,6 +681,11 @@ public class TunerManager implements IDiscoveredTunerStatusListener
|
||||
{
|
||||
source = discoveredTuner.getTuner().getChannelSourceManager().getSource(tunerChannel,
|
||||
channelSpecification, threadName);
|
||||
|
||||
if(source != null)
|
||||
{
|
||||
source.setTunerName(discoveredTuner.getTuner().getPreferredName());
|
||||
}
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
|
||||
@@ -129,6 +129,15 @@ public class RecordingTunerController extends TunerController
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Disables the generic sample drop monitor since recordings are replayed and not limited to a real-time sample rate.
|
||||
*/
|
||||
@Override
|
||||
protected boolean isSampleDropMonitorSupported()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public TunerType getTunerType()
|
||||
{
|
||||
|
||||
@@ -130,7 +130,7 @@ public abstract class RspTunerController<I extends IControlRsp> extends TunerCon
|
||||
|
||||
for(RspNativeBuffer buffer: buffers)
|
||||
{
|
||||
mNativeBufferBroadcaster.broadcast(buffer);
|
||||
broadcast(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -90,6 +90,15 @@ public class TestTunerController extends TunerController
|
||||
//No-op
|
||||
}
|
||||
|
||||
/**
|
||||
* Disables the generic sample drop monitor since the generated test sample stream is not a hardware sample stream.
|
||||
*/
|
||||
@Override
|
||||
protected boolean isSampleDropMonitorSupported()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public TunerType getTunerType()
|
||||
{
|
||||
|
||||
@@ -69,4 +69,23 @@ public class SpectralDisplayThemeTest
|
||||
SpectralDisplayTheme theme = SpectralDisplayTheme.CLASSIC;
|
||||
assertEquals(theme.getWaterfallColor(255), theme.getWaterfallColor((byte)255));
|
||||
}
|
||||
|
||||
@Test
|
||||
void channelMenuColorsAreReadableAndDistinct()
|
||||
{
|
||||
for(SpectralDisplayTheme theme: SpectralDisplayTheme.values())
|
||||
{
|
||||
javafx.scene.paint.Color background = theme.getBackground();
|
||||
javafx.scene.paint.Color active = theme.getChannelActive();
|
||||
javafx.scene.paint.Color inactive = theme.getChannelInactive();
|
||||
javafx.scene.paint.Color text = theme.getText();
|
||||
|
||||
//Readable without the menu having to adjust them
|
||||
assertTrue(ChannelMenus.contrast(active, background) >= 3.0, theme + " active contrast");
|
||||
assertTrue(ChannelMenus.contrast(inactive, background) >= 3.0, theme + " inactive contrast");
|
||||
assertTrue(ChannelMenus.contrast(text, background) >= 4.5, theme + " text contrast");
|
||||
assertTrue(!active.equals(inactive) && !active.equals(text) && !inactive.equals(text),
|
||||
theme + " colors differ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -212,6 +212,27 @@ public class TableColumnMonitorTest
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newHiddenByDefaultColumnStaysHidden() throws Exception
|
||||
{
|
||||
onFx(() -> {
|
||||
//Stored by a version without the hidden by default 'site' column and without the known columns
|
||||
mPreferences.put(KEY + ".column.hidden", "a");
|
||||
TableView<String> table = createTable("a", "b", "site");
|
||||
table.getColumns().get(2).setVisible(false);
|
||||
monitor(table);
|
||||
assertEquals(List.of("b"), visibleIds(table));
|
||||
|
||||
//The user shows the column, which is kept in the next session
|
||||
table.getColumns().get(2).setVisible(true);
|
||||
TableView<String> restored = createTable("a", "b", "site", "system");
|
||||
restored.getColumns().get(2).setVisible(false);
|
||||
restored.getColumns().get(3).setVisible(false);
|
||||
monitor(restored);
|
||||
assertEquals(List.of("b", "site"), visibleIds(restored));
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void lastVisibleColumnCantBeHidden() throws Exception
|
||||
{
|
||||
|
||||
@@ -0,0 +1,146 @@
|
||||
/*
|
||||
* *****************************************************************************
|
||||
* Copyright (C) 2014-2026 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 io.github.dsheirer.source.tuner;
|
||||
|
||||
import java.util.Random;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* Drives the sample drop monitor with simulated buffer arrival times.
|
||||
*/
|
||||
public class SampleDropMonitorTest
|
||||
{
|
||||
private static final double SAMPLE_RATE = 10_000_000.0;
|
||||
private static final int BUFFER = 65_536;
|
||||
private static final double BUFFER_NANOS = BUFFER / SAMPLE_RATE * 1e9;
|
||||
|
||||
/**
|
||||
* Simulated tuner stream: buffers are produced at the sample rate (scaled by the tuner clock error) and arrive
|
||||
* with optional delivery jitter.
|
||||
*/
|
||||
private static class Stream
|
||||
{
|
||||
private final SampleDropMonitor mMonitor = new SampleDropMonitor(() -> "test", () -> SAMPLE_RATE);
|
||||
private final Random mRandom = new Random(42);
|
||||
private final double mClockScale;
|
||||
private final double mJitterNanos;
|
||||
private double mProduced = 1_000_000_000.0;
|
||||
|
||||
Stream(double clockPpm, double jitterNanos)
|
||||
{
|
||||
mClockScale = 1.0 + clockPpm / 1e6;
|
||||
mJitterNanos = jitterNanos;
|
||||
}
|
||||
|
||||
/**
|
||||
* Produces buffers for the duration, delivering all of them.
|
||||
*/
|
||||
void run(double seconds)
|
||||
{
|
||||
run(seconds, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Produces buffers for the duration, dropping one of every dropInterval buffers (0 = none).
|
||||
*/
|
||||
void run(double seconds, int dropInterval)
|
||||
{
|
||||
long count = (long)(seconds * 1e9 / BUFFER_NANOS);
|
||||
|
||||
for(long x = 1; x <= count; x++)
|
||||
{
|
||||
mProduced += BUFFER_NANOS / mClockScale;
|
||||
|
||||
if(dropInterval > 0 && x % dropInterval == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
double jitter = mJitterNanos > 0 ? mRandom.nextDouble() * mJitterNanos : 0;
|
||||
mMonitor.process(BUFFER, (long)(mProduced + jitter));
|
||||
}
|
||||
}
|
||||
|
||||
void pause(double seconds)
|
||||
{
|
||||
mProduced += seconds * 1e9;
|
||||
}
|
||||
|
||||
long dropped()
|
||||
{
|
||||
return mMonitor.getTotalDroppedSamples();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void cleanStreamWithClockErrorAndJitterHasNoDrops()
|
||||
{
|
||||
Stream stream = new Stream(-100, 30_000_000);
|
||||
stream.run(600);
|
||||
assertEquals(0, stream.dropped());
|
||||
|
||||
stream = new Stream(100, 30_000_000);
|
||||
stream.run(600);
|
||||
assertEquals(0, stream.dropped());
|
||||
}
|
||||
|
||||
@Test
|
||||
void singleDeliveryStallIsNotADrop()
|
||||
{
|
||||
Stream stream = new Stream(0, 0);
|
||||
stream.run(30);
|
||||
//A 500 ms delivery stall: the buffers produced during the stall are all delivered when it ends
|
||||
double stallEnd = stream.mProduced + 0.5e9;
|
||||
|
||||
while(stream.mProduced + BUFFER_NANOS < stallEnd)
|
||||
{
|
||||
stream.mProduced += BUFFER_NANOS;
|
||||
stream.mMonitor.process(BUFFER, (long)stallEnd);
|
||||
}
|
||||
|
||||
stream.run(30);
|
||||
assertEquals(0, stream.dropped());
|
||||
}
|
||||
|
||||
@Test
|
||||
void droppedBuffersAreDetected()
|
||||
{
|
||||
Stream stream = new Stream(50, 10_000_000);
|
||||
stream.run(60);
|
||||
//Drop 1 of every 100 buffers (1%) for 60 seconds = ~0.6 seconds of samples
|
||||
stream.run(60, 100);
|
||||
stream.run(30);
|
||||
double expected = 60.0 * SAMPLE_RATE / 100.0;
|
||||
double dropped = stream.dropped();
|
||||
assertTrue(Math.abs(dropped - expected) < expected * 0.1, "Dropped " + dropped + " expected " + expected);
|
||||
}
|
||||
|
||||
@Test
|
||||
void streamRestartIsNotADrop()
|
||||
{
|
||||
Stream stream = new Stream(0, 0);
|
||||
stream.run(20);
|
||||
stream.pause(10);
|
||||
stream.run(20);
|
||||
assertEquals(0, stream.dropped());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user