From 807790ff380ff27d1816789811be1a180233a1b2 Mon Sep 17 00:00:00 2001 From: markjfine Date: Thu, 8 Apr 2021 08:56:30 -0400 Subject: [PATCH] more image references forgot to add reference to radar key in map display. --- res/nrsc5-dui.py | 1897 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1897 insertions(+) create mode 100644 res/nrsc5-dui.py diff --git a/res/nrsc5-dui.py b/res/nrsc5-dui.py new file mode 100644 index 0000000..7bfe15e --- /dev/null +++ b/res/nrsc5-dui.py @@ -0,0 +1,1897 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# NRSC5 DUI - A graphical interface for nrsc5 +# Copyright (C) 2017-2019 Cody Nybo & Clayton Smith, 2019 zefie, 2021 Mark J. Fine +# +# 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 . + +# Updated by zefie for modern nrsc5 ~ 2019 +# Updated and enhanced by markjfine ~ 2021 + +#import os, sys, shutil, re, gtk, gobject, json, datetime, numpy, glob, time, platform +import os, pty, select, sys, shutil, re, json, datetime, numpy, glob, time, platform +from subprocess import Popen, PIPE +from threading import Timer, Thread +from dateutil import tz +from PIL import Image, ImageFont, ImageDraw + +import gi +gi.require_version("Gtk", "3.0") +from gi.repository import Gtk, GObject, Gdk, GdkPixbuf, GLib + +import urllib3 +from OpenSSL import SSL + +# print debug messages to stdout (if debugger is attached) +debugMessages = (sys.gettrace() != None) +debugAutoStart = True + +if hasattr(sys, 'frozen'): + runtimeDir = os.path.dirname(sys.executable) # for py2exe +else: + runtimeDir = sys.path[0] + +aasDir = os.path.join(runtimeDir, "aas") # aas (data from nrsc5) file directory +mapDir = os.path.join(runtimeDir, "map") # map (data we process) file directory +resDir = os.path.join(runtimeDir, "res") # resource (application dependencies) file directory +cfgDir = os.path.join(runtimeDir, "cfg") # config file directory + +class NRSC5_DUI(object): + def __init__(self): + global runtimeDir, resDir + #gobject.threads_init() + #Gdk.threads_init() + self.windowsOS = False # save our determination as a var in case we change how we determine. + + self.getControls() # get controls and windows + self.initStreamInfo() # initilize stream info and clear status widgets + self.http = urllib3.PoolManager() + + self.debugLog("Local path determined as " + runtimeDir) + + if (platform.system() == 'Windows'): + # Windows release layout + self.windowsOS = True + self.binDir = os.path.join(runtimeDir, "bin") # windows binaries directory + self.nrsc5Path = os.path.join(self.binDir,'nrsc5.exe') + else: + # Linux/Mac/proper posix + # if nrsc5 and transcoder are not in the system path, set the full path here + arg1 = "" + if (len(sys.argv[1:]) > 0): + arg1 = sys.argv[1].strip() + self.nrsc5Path = arg1+"nrsc5" + + self.debugLog("OS Determination: Windows = {}".format(self.windowsOS)) + + self.mapFile = os.path.join(resDir, "map.png") + self.defaultSize = [490,250] # default width,height of main app + self.nrsc5 = None # nrsc5 process + self.nrsc5master = None + self.nrsc5slave = None + self.playerThread = None # player thread + self.playing = False # currently playing + self.statusTimer = None # status update timer + self.imageChanged = False # has the album art changed + self.xhdrChanged = False # has the HDDR data changed + self.nrsc5Args = [] # arguments for nrsc5 + self.logFile = None # nrsc5 log file + self.lastImage = "" # last image file displayed + self.coverImage = "" + self.id3Changed = False + #self.lastXHDR = ["", -1] # the last XHDR data received + self.lastXHDR = "" # the last XHDR data received + self.stationStr = "" # current station frequency (string) + self.streamNum = 0 # current station stream number + self.nrsc5msg = "" # send key command to nrsc5 (streamNum) + self.update_btns = True + self.set_program_btns() + self.bookmarks = [] # station bookmarks + self.booknames = ["","","",""] # station bookmark names + self.stationLogos = {} # station logos + self.bookmarked = False # is current station bookmarked + self.mapViewer = None # map viewer window + self.weatherMaps = [] # list of current weathermaps sorted by time + self.waittime = 10 # time in seconds to wait for file to exist + self.waitdivider = 4 # check this many times per second for file + self.pixbuf = None # store image buffer for rescaling on resize + self.mimeTypes = { # as defined by iHeartRadio anyway, defined here for possible future use + "4F328CA0":["image/png","png"], + "1E653E9C":["image/jpg","jpg"], + "BB492AAC":["text/plain","txt"] + } + self.mapData = { + "mapMode" : 1, + "mapTiles" : [[0,0,0],[0,0,0],[0,0,0]], + "mapComplete" : False, + "weatherTime" : 0, + "weatherPos" : [0,0,0,0], + "weatherNow" : "", + "weatherID" : "", + "viewerConfig" : { + "mode" : 1, + "animate" : False, + "scale" : True, + "windowPos" : (0,0), + "windowSize" : (764,632), + "animationSpeed" : 0.5 + } + } + + self.ServiceDataType = { + 0 : "Non_Specific", + 1 : "News", + 3 : "Sports", + 29 : "Weather", + 31 : "Emergency", + 65 : "Traffic", + 66 : "Image Maps", + 80 : "Text", + 256 : "Advertising", + 257 : "Financial", + 258 : "Stock Ticker", + 259 : "Navigation", + 260 : "Electronic Program Guide", + 261 : "Audio", + 262 : "Private Data Network", + 263 : "Service Maintenance", + 264 : "HD Radio System Services", + 265 : "Audio-Related Objects", + 511 : "Test_Str_E" + } + + self.ProgramType = { + 0 : "None", + 1 : "News", + 2 : "Information", + 3 : "Sports", + 4 : "Talk", + 5 : "Rock", + 6 : "Classic Rock", + 7 : "Adult Hits", + 8 : "Soft Rock", + 9 : "Top 40", + 10 : "Country", + 11 : "Oldies", + 12 : "Soft", + 13 : "Nostalgia", + 14 : "Jazz", + 15 : "Classical", + 16 : "Rhythm and Blues", + 17 : "Soft Rhythm and Blues", + 18 : "Foreign Language", + 19 : "Religious Music", + 20 : "Religious Talk", + 21 : "Personality", + 22 : "Public", + 23 : "College", + 24 : "Spanish Talk", + 25 : "Spanish Music", + 26 : "Hip-Hop", + 29 : "Weather", + 30 : "Emergency Test", + 31 : "Emergency", + 65 : "Traffic", + 76 : "Special Reading Services" + } + + self.pointer_cursor = Gdk.Cursor(Gdk.CursorType.LEFT_PTR) + self.hand_cursor = Gdk.Cursor(Gdk.CursorType.HAND2) + #self.missing_image = Gtk.Image.new_from_icon_name("MISSING_IMAGE",Gtk.IconSize.LARGE_TOOLBAR) + + # set events on info labels + self.set_tuning_actions(self.btnAudioPrgs0, "btn_prg0", False, False) + self.set_tuning_actions(self.btnAudioPrgs1, "btn_prg1", False, False) + self.set_tuning_actions(self.btnAudioPrgs2, "btn_prg2", False, False) + self.set_tuning_actions(self.btnAudioPrgs3, "btn_prg3", False, False) + + self.set_tuning_actions(self.lblAudioPrgs0, "prg0", True, True) + self.set_tuning_actions(self.lblAudioPrgs1, "prg1", True, True) + self.set_tuning_actions(self.lblAudioPrgs2, "prg2", True, True) + self.set_tuning_actions(self.lblAudioPrgs3, "prg3", True, True) + + self.set_tuning_actions(self.lblAudioSvcs0, "svc0", True, True) + self.set_tuning_actions(self.lblAudioSvcs1, "svc1", True, True) + self.set_tuning_actions(self.lblAudioSvcs2, "svc2", True, True) + self.set_tuning_actions(self.lblAudioSvcs3, "svc3", True, True) + + # setup bookmarks listview + nameRenderer = Gtk.CellRendererText() + nameRenderer.set_property("editable", True) + nameRenderer.connect("edited", self.on_bookmarkNameEdited) + + colStation = Gtk.TreeViewColumn("Station", Gtk.CellRendererText(), text=0) + colName = Gtk.TreeViewColumn("Name", nameRenderer, text=1) + + colStation.set_resizable(True) + colStation.set_sort_column_id(2) + colName.set_resizable(True) + colName.set_sort_column_id(1) + + self.lvBookmarks.append_column(colStation) + self.lvBookmarks.append_column(colName) + + # regex for getting nrsc5 output + self.regex = [ + #re.compile("^.*main\.c:[\d]+: Station name: (.*)$"), # 0 match station name + #re.compile("^.*main\.c:[\d]+: Station location: (-?[\d]+\.[\d]+) (-?[\d]+\.[\d]+), ([\d]+)m$"), # 1 match station location + #re.compile("^.*main\.c:[\d]+: Slogan: (.*)$"), # 2 match station slogan + #re.compile("^.*main\.c:[\d]+: Audio bit rate: (.*) kbps$"), # 3 match audio bit rate + #re.compile("^.*main\.c:[\d]+: Title: (.*)$"), # 4 match title + #re.compile("^.*main\.c:[\d]+: Artist: (.*)$"), # 5 match artist + #re.compile("^.*main\.c:[\d]+: Album: (.*)$"), # 6 match album + #re.compile("^.*main\.c:[\d]+: LOT file: port=([\d]+) lot=([\d]+) name=(.*\.(?:jpg|png|txt)) size=([\d]+) mime=([\w]+)$"), # 7 match file (album art, maps, weather info) + #re.compile("^.*main\.c:[\d]+: MER: (-?[\d]+\.[\d]+) dB \(lower\), (-?[\d]+\.[\d]+) dB \(upper\)$"), # 8 match MER + #re.compile("^.*main\.c:[\d]+: BER: (0\.[\d]+), avg: (0\.[\d]+), min: (0\.[\d]+), max: (0\.[\d]+)$"), # 9 match BER + #re.compile("^.*nrsc5\.c:[\d]+: Best gain: (.*) dB,.*$"), # 10 match gain + #re.compile("^.*main\.c:[\d]+: SIG Service: type=(.*) number=(.*) name=(.*)$"), # 11 match stream + #re.compile("^.*main\.c:[\d]+: .*Data component:.* port=([\d]+).* type=([\d]+) .*$"), # 12 match port + #re.compile("^.*main\.c:[\d]+: XHDR: .* ([0-9A-Fa-f]{8}) (.*)$"), # 13 match xhdr tag + #re.compile("^.*main\.c:[\d]+: Unique file identifier: PPC;07; ([\S]+).*$") # 14 match unique file id + re.compile("^[0-9\:]{8,8} Station name: (.*)$"), # 0 match station name + re.compile("^[0-9\:]{8,8} Station location: (-?[\d]+\.[\d]+) (-?[\d]+\.[\d]+), ([\d]+)m$"), # 1 match station location + re.compile("^[0-9\:]{8,8} Slogan: (.*)$"), # 2 match station slogan + re.compile("^[0-9\:]{8,8} Audio bit rate: (.*) kbps$"), # 3 match audio bit rate + re.compile("^[0-9\:]{8,8} Title: (.*)$"), # 4 match title + re.compile("^[0-9\:]{8,8} Artist: (.*)$"), # 5 match artist + re.compile("^[0-9\:]{8,8} Album: (.*)$"), # 6 match album + re.compile("^[0-9\:]{8,8} LOT file: port=([\d]+) lot=([\d]+) name=(.*\.(?:jpg|png|txt)) size=([\d]+) mime=([\w]+)$"), # 7 match file (album art, maps, weather info) + re.compile("^[0-9\:]{8,8} MER: (-?[\d]+\.[\d]+) dB \(lower\), (-?[\d]+\.[\d]+) dB \(upper\)$"), # 8 match MER + re.compile("^[0-9\:]{8,8} BER: (0\.[\d]+), avg: (0\.[\d]+), min: (0\.[\d]+), max: (0\.[\d]+)$"), # 9 match BER + re.compile("^[0-9\:]{8,8} Best gain: (.*) dB,.*$"), # 10 match gain + re.compile("^[0-9\:]{8,8} SIG Service: type=(.*) number=(.*) name=(.*)$"), # 11 match stream + re.compile("^[0-9\:]{8,8} .*Data component:.* id=([\d]+).* port=([\d]+).* service_data_type=([\d]+) .*$"), # 12 match port (and data_service_type) + re.compile("^[0-9\:]{8,8} XHDR: (.*) ([0-9A-Fa-f]{8}) (.*)$"), # 13 match xhdr tag + re.compile("^[0-9\:]{8,8} Unique file identifier: PPC;07; ([\S]+).*$"), # 14 match unique file id + re.compile("^[0-9\:]{8,8} Genre: (.*)$"), # 15 match genre + re.compile("^[0-9\:]{8,8} Message: (.*)$"), # 16 match message + re.compile("^[0-9\:]{8,8} Alert: (.*)$"), # 17 match alert + re.compile("^[0-9\:]{8,8} .*Audio component:.* id=([\d]+).* port=([\d]+).* type=([\d]+) .*$"), # 18 match port (and type) + re.compile("^[0-9\:]{8,8} Synchronized$"), # 19 synchronized + re.compile("^[0-9\:]{8,8} Lost synchronization$"), # 20 lost synch + re.compile("^[0-9\:]{8,8} Lost device$"), # 21 lost device + re.compile("^[0-9\:]{8,8} Open device failed.$") # 22 No device + ] + + self.loadSettings() + self.proccessWeatherMaps() + #self..connect('check-resize',self.on_window_resized) # TODO: fix on resize infinite loop + + # set up pty + self.nrsc5master,self.nrsc5slave = pty.openpty() + + def set_tuning_actions(self, widget, name, has_win, set_curs): + widget.set_property("name",name) + widget.set_sensitive(False) + if has_win: + widget.set_has_window(True) + widget.set_events(Gdk.EventMask.BUTTON_PRESS_MASK) + widget.connect("button-press-event", self.on_program_select) + if set_curs: + widget.add_events(Gdk.EventMask.ENTER_NOTIFY_MASK) + widget.connect("enter-notify-event", self.on_enter_set_cursor) + + def on_enter_set_cursor(self, widget, event): + if (widget.get_label() != ""): + widget.get_window().set_cursor(self.hand_cursor) + + def img_to_pixbuf(self,img): + """convert PIL.Image to GdkPixbuf.Pixbuf""" + data = GLib.Bytes.new(img.tobytes()) + return GdkPixbuf.Pixbuf.new_from_bytes(data, GdkPixbuf.Colorspace.RGB, 'A' in img.getbands(),8, img.width, img.height, len(img.getbands())*img.width) + + def on_cover_resize(self, container): + global mapDir + if self.coverImage != "": + #img_size = min(self.alignmentCover.get_allocated_height(), self.alignmentCover.get_allocated_width()) - 12 + #pixbuf = GdkPixbuf.Pixbuf.new_from_file(self.coverImage) + #pixbuf = pixbuf.scale_simple(img_size, img_size, GdkPixbuf.InterpType.BILINEAR) + #self.imgCover.set_from_pixbuf(pixbuf) + self.showArtwork(self.coverImage) + + img_size = min(self.alignmentMap.get_allocated_height(), self.alignmentMap.get_allocated_width()) - 12 + if (self.mapData["mapMode"] == 0): + map_file = os.path.join(mapDir, "TrafficMap.png") + if os.path.isfile(map_file): + map_img = Image.open(map_file).resize((img_size, img_size), Image.LANCZOS) + self.imgMap.set_from_pixbuf(self.img_to_pixbuf(map_img)) + else: + #self.imgMap.set_from_stock(Gtk.STOCK_MISSING_IMAGE, Gtk.IconSize.LARGE_TOOLBAR) + self.imgMap.set_from_icon_name("MISSING_IMAGE", Gtk.IconSize.DIALOG) + elif (self.mapData["mapMode"] == 1): + if os.path.isfile(self.mapData["weatherNow"]): + map_img = Image.open(self.mapData["weatherNow"]).resize((img_size, img_size), Image.LANCZOS) + self.imgMap.set_from_pixbuf(self.img_to_pixbuf(map_img)) + else: + #self.imgMap.set_from_stock(Gtk.STOCK_MISSING_IMAGE, Gtk.IconSize.LARGE_TOOLBAR) + self.imgMap.set_from_icon_name("MISSING_IMAGE", Gtk.IconSize.DIALOG) + + def id3_did_change(self): + oldTitle = self.txtTitle.get_label() + oldArtist = self.txtArtist.get_label() + newTitle = self.streamInfo["Title"] + newArtist = self.streamInfo["Artist"] + return ((newArtist != oldArtist) and (newTitle != oldTitle)) + + def get_cover_data(self, response): + check = -1 + resultUrl = "" + resultArtist = "" + m = re.search(r"card card_large float_fix",response) + if (m.start() > -1): + response = response[m.start():] + m = re.search(r" -1): + response = response[m.start()+15:] + m = re.search(r"\"",response) + if (m.start() > -1): + resultUrl = response[:m.start()] + response = response[m.start()+1:] + m = re.search(r" -1): + response = response[m.start()+13:] + m = re.search(r"\"",response) + if (m.start() > -1): + resultArtist = response[:m.start()] + response = response[m.start()+1:] + check = 0 + return check, response, resultUrl, resultArtist + + def fix_artist(self): + newArtist = self.streamInfo["Artist"] + if ("/" in newArtist): + m = re.search(r"/",newArtist) + if (m.start() > -1): + newArtist = newArtist[:m.start()].strip() + return newArtist + + def get_cover_image_online(self): + global aasDir + got_cover = False + + # only change when there's a new ID3 + if (self.id3Changed): + # only care about the first artist listed if separated by slashes + newArtist = self.fix_artist() + baseStr = str(newArtist +" - "+self.streamInfo["Title"]).replace("/","_").replace(":","_") + #saveStr = "aas/"+ baseStr.replace(" ","_")+".jpg" + saveStr = os.path.join(aasDir, baseStr.replace(" ","_")+".jpg") + searchStr = baseStr.replace(" ","+") + + # does it already exist? + if (os.path.isfile(saveStr)): + self.coverImage = saveStr + + # if not, get it from Discogs + else: + try: + searchStr = "https://www.discogs.com/search/?q="+searchStr+"&type=all" + r = self.http.request('GET',searchStr) + if (r.status == 200): + response = r.data.decode('utf-8') + + # loop through the page until you either get an artist match or you run out of page (check) + while (not got_cover): + resultUrl = "" + resultArtist = "" + check, response, resultUrl, resultArtist = self.get_cover_data(response) + got_cover = (newArtist.lower() in resultArtist.lower()) and (check == 0) + + # if you got a match, save it + if (resultUrl != ""): + with self.http.request('GET', resultUrl, preload_content=False) as r, open(saveStr, 'wb') as out_file: + if (r.status == 200): + shutil.copyfileobj(r, out_file) + self.coverImage = saveStr + + # If no match use the station logo if there is one + else: + self.coverImage = os.path.join(aasDir, self.stationLogos[self.stationStr][self.streamNum]) + except: + pass + + # now display it by simulating a window resize + self.on_cover_resize(self.mainWindow) + + def showArtwork(self, art): + img_size = min(self.alignmentCover.get_allocated_height(), self.alignmentCover.get_allocated_width()) - 12 + self.pixbuf = GdkPixbuf.Pixbuf.new_from_file(art) + self.pixbuf = self.pixbuf.scale_simple(img_size, img_size, GdkPixbuf.InterpType.BILINEAR) + self.imgCover.set_from_pixbuf(self.pixbuf) + + def displayLogo(self): + global aasDir + #if (self.stationLogos.has_key(self.stationStr)): + if (self.stationStr in self.stationLogos): + # show station logo if it's cached + logo = os.path.join(aasDir, self.stationLogos[self.stationStr][self.streamNum]) + if (os.path.isfile(logo)): + self.streamInfo["Logo"] = self.stationLogos[self.stationStr][self.streamNum] + #img_size = min(self.alignmentCover.get_allocated_height(), self.alignmentCover.get_allocated_width()) - 12 + #self.pixbuf = Gtk.gdk.pixbuf_new_from_file(logo) + #self.pixbuf = GdkPixbuf.Pixbuf.new_from_file(logo) + self.coverImage = logo + #self.handle_window_resize() + #self.pixbuf = self.pixbuf.scale_simple(img_size, img_size, GdkPixbuf.InterpType.BILINEAR) + #self.imgCover.set_from_pixbuf(self.pixbuf) + self.showArtwork(logo) + else: + # add entry in database for the station if it doesn't exist + self.stationLogos[self.stationStr] = ["", "", "", ""] + + def service_data_type_name(self, type): + for key, value in self.ServiceDataType.items(): + if (key == type): + return value + + def program_type_name(self, type): + for key, value in self.ProgramType.items(): + if (key == type): + return value + + def handle_window_resize(self): + if (self.pixbuf != None): + #allocation = self.imgCover.get_allocation() + #desired_width = int(allocation.width / 2.5) + #desired_height = desired_width + desired_size = min(self.alignmentCover.get_allocated_height(), self.alignmentCover.get_allocated_width()) - 12 + #self.pixbuf = self.pixbuf.scale_simple(desired_width, desired_height, Gtk.gdk.INTERP_HYPER) + self.pixbuf = self.pixbuf.scale_simple(desired_size, desired_size, GdkPixbuf.InterpType.BILINEAR) + self.imgCover.set_from_pixbuf(self.pixbuf) + + def on_window_resized(self,window): + self.handle_window_resize() + + def on_btnPlay_clicked(self, btn): + global aasDir + # start playback + if (not self.playing): + + self.nrsc5Args = [self.nrsc5Path] + + # update all of the spin buttons to prevent the text from sticking + self.spinFreq.update() + #self.spinStream.update() + self.spinGain.update() + self.spinPPM.update() + self.spinRTL.update() + + # enable aas output if temp dir was created + if (aasDir is not None): + self.nrsc5Args.append("--dump-aas-files") + self.nrsc5Args.append(aasDir) + + # set gain if auto gain is not selected + if (not self.cbAutoGain.get_active()): + self.streamInfo["Gain"] = self.spinGain.get_value() + self.nrsc5Args.append("-g") + #self.nrsc5Args.append(str(int(self.streamInfo["Gain"]*10))) + self.nrsc5Args.append(str(int(self.streamInfo["Gain"]))) + + # set ppm error if not zero + if (self.spinPPM.get_value() != 0): + self.nrsc5Args.append("-p") + self.nrsc5Args.append(str(int(self.spinPPM.get_value()))) + + # set rtl device number if not zero + if (self.spinRTL.get_value() != 0): + self.nrsc5Args.append("-d") + self.nrsc5Args.append(str(int(self.spinRTL.get_value()))) + + # set frequency and stream + self.nrsc5Args.append(str(self.spinFreq.get_value())) + #self.nrsc5Args.append(str(int(self.spinStream.get_value()-1))) + self.nrsc5Args.append(str(int(self.streamNum))) + + #print(self.nrsc5Args) + + # start the timer + self.statusTimer = Timer(1, self.checkStatus) + self.statusTimer.start() + + # disable the controls + self.spinFreq.set_sensitive(False) + #self.spinStream.set_sensitive(False) + self.spinGain.set_sensitive(False) + self.spinPPM.set_sensitive(False) + self.spinRTL.set_sensitive(False) + self.btnPlay.set_sensitive(False) + self.btnStop.set_sensitive(True) + self.cbAutoGain.set_sensitive(False) + self.playing = True + #self.lastXHDR = ["", -1] + self.lastXHDR = "" + + # start the player thread + self.playerThread = Thread(target=self.play) + self.playerThread.start() + + self.stationStr = str(self.spinFreq.get_value()) + #self.stationNum = int(self.spinStream.get_value())-1 + #self.set_program_btns() + + self.displayLogo() + + # check if station is bookmarked + self.bookmarked = False + #freq = int((self.spinFreq.get_value()+0.005)*100) + int(self.spinStream.get_value()) + freq = int((self.spinFreq.get_value()+0.005)*100) + int(self.streamNum + 1) + for b in self.bookmarks: + if (b[2] == freq): + self.bookmarked = True + break + + self.get_bookmark_names() + + self.btnBookmark.set_sensitive(not self.bookmarked) + if (self.notebookMain.get_current_page() != 3): + self.btnDelete.set_sensitive(self.bookmarked) + + def get_bookmark_names(self): + self.booknames = ["","","",""] + freq = str(int((self.spinFreq.get_value()+0.005)*10)) + for b in self.bookmarks: + test = str(b[2]) + if (test[:-1] == freq): + self.booknames[int(test[-1])-1] = b[1] + + def on_btnStop_clicked(self, btn): + # stop playback + if (self.playing): + self.playing = False + + # shutdown nrsc5 + if (self.nrsc5 is not None and not self.nrsc5.poll()): + self.nrsc5.terminate() + + if (self.playerThread is not None) and (btn is not None): + self.playerThread.join(1) + + # stop timer + self.statusTimer.cancel() + self.statusTimer = None + + # enable controls + if (not self.cbAutoGain.get_active()): + self.spinGain.set_sensitive(True) + self.spinFreq.set_sensitive(True) + #self.spinStream.set_sensitive(True) + self.spinPPM.set_sensitive(True) + self.spinRTL.set_sensitive(True) + self.btnPlay.set_sensitive(True) + self.btnStop.set_sensitive(False) + self.btnBookmark.set_sensitive(False) + self.cbAutoGain.set_sensitive(True) + + # clear stream info + self.initStreamInfo() + + self.btnBookmark.set_sensitive(False) + if (self.notebookMain.get_current_page() != 3): + self.btnDelete.set_sensitive(False) + + def on_btnBookmark_clicked(self, btn): + # pack frequency and channel number into one int + #freq = int((self.spinFreq.get_value()+0.005)*100) + int(self.spinStream.get_value()) + freq = int((self.spinFreq.get_value()+0.005)*100) + int(self.streamNum + 1) + + # create bookmark + bookmark = [ + #"{:4.1f}-{:1.0f}".format(self.spinFreq.get_value(), self.spinStream.get_value()), + "{:4.1f}-{:1.0f}".format(self.spinFreq.get_value(), self.streamNum + 1), + self.streamInfo["Callsign"], + freq + ] + self.bookmarked = True # mark as bookmarked + self.bookmarks.append(bookmark) # store bookmark in array + self.lsBookmarks.append(bookmark) # add bookmark to listview + self.btnBookmark.set_sensitive(False) # disable bookmark button + + if (self.notebookMain.get_current_page() != 3): + self.btnDelete.set_sensitive(True) # enable delete button + + self.get_bookmark_names() + + def on_btnDelete_clicked(self, btn): + # select current station if not on bookmarks page + if (self.notebookMain.get_current_page() != 3): + station = int((self.spinFreq.get_value()+0.005)*100) + int(self.streamNum + 1) + for i in range(0, len(self.lsBookmarks)): + if (self.lsBookmarks[i][2] == station): + self.lvBookmarks.set_cursor(i) + break + + # get station of selected row + (model, iter) = self.lvBookmarks.get_selection().get_selected() + station = model.get_value(iter, 2) + + # remove row + model.remove(iter) + + # remove bookmark + for i in range(0, len(self.bookmarks)): + if (self.bookmarks[i][2] == station): + self.bookmarks.pop(i) + break + + if (self.notebookMain.get_current_page() != 3 and self.playing): + self.btnBookmark.set_sensitive(True) + self.bookmarked = False + + self.get_bookmark_names() + + def on_btnAbout_activate(self, btn): + global resDir + # sets up and displays about dialog + if self.about_dialog: + self.about_dialog.present() + return + + authors = [ + "Cody Nybo ", + "Clayton Smith ", + "nefie ", + "Mark J. Fine " + ] + + license = """ + NRSC5 DUI - A second-generation graphical interface for nrsc5 + Copyright (C) 2017-2019 Cody Nybo & Clayton Smith, 2019 zefie, 2021 Mark J. Fine + 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 .""" + + about_dialog = Gtk.AboutDialog() + about_dialog.set_transient_for(self.mainWindow) + about_dialog.set_destroy_with_parent(True) + about_dialog.set_name("NRSC5 DUI") + about_dialog.set_program_name("NRSC5 DUI") + about_dialog.set_version("2.1.0") + about_dialog.set_copyright("Copyright © 2017-2019 Cody Nybo & Clayton Smith, 2019 zefie, 2021 Mark J. Fine") + about_dialog.set_website("https://github.com/markjfine/nrsc5-dui") + about_dialog.set_comments("A second-generation graphical interface for nrsc5.") + about_dialog.set_authors(authors) + about_dialog.set_license(license) + #about_dialog.set_logo(Gtk.gdk.pixbuf_new_from_file("logo.png")) + about_dialog.set_logo(GdkPixbuf.Pixbuf.new_from_file(os.path.join(resDir,"logo.png"))) + + # callbacks for destroying the dialog + def close(dialog, response, editor): + editor.about_dialog = None + dialog.destroy() + + def delete_event(dialog, event, editor): + editor.about_dialog = None + return True + + about_dialog.connect("response", close, self) + about_dialog.connect("delete-event", delete_event, self) + + self.about_dialog = about_dialog + about_dialog.show() + + def on_stream_changed(self): + self.lastXHDR = "" + self.streamInfo["Title"] = "" + self.streamInfo["Album"] = "" + self.streamInfo["Artist"] = "" + self.streamInfo["Genre"] = "" + self.streamInfo["Cover"] = "" + self.streamInfo["Logo"] = "" + self.streamInfo["Bitrate"] = 0 + self.set_program_btns() + if self.playing: + self.nrsc5msg = str(self.streamNum) + self.displayLogo() + #TODO: fix so stream change is smoother - should be able to pipe new stream number to running application and update display_logo() + # For now, just restart + #if (self.playing): + # self.on_btnStop_clicked(None) + # self.on_btnPlay_clicked(None) + + def set_program_btns(self): + self.btnAudioPrgs0.set_active(self.update_btns and self.streamNum == 0) + self.btnAudioPrgs1.set_active(self.update_btns and self.streamNum == 1) + self.btnAudioPrgs2.set_active(self.update_btns and self.streamNum == 2) + self.btnAudioPrgs3.set_active(self.update_btns and self.streamNum == 3) + self.update_btns = True + + def on_program_select(self, _label, evt): + stream_num = int(_label.get_property("name")[-1]) + is_lbl = _label.get_property("name")[0] != "b" + self.update_btns = is_lbl + self.streamNum = stream_num + self.on_stream_changed() + + def on_cbAutoGain_toggled(self, btn): + self.spinGain.set_sensitive(not btn.get_active()) + self.lblGain.set_visible(btn.get_active()) + + def on_listviewBookmarks_row_activated(self, treeview, path, view_column): + if (len(path) != 0): + # get station from bookmark row + tree_iter = treeview.get_model().get_iter(path[0]) + station = treeview.get_model().get_value(tree_iter, 2) + + # set frequency and stream + self.spinFreq.set_value(float(int(station/10)/10.0)) + #self.spinStream.set_value(station%10) + self.streamNum = (station%10)-1 + self.on_stream_changed() + + # stop playback if playing + if (self.playing): + self.on_btnStop_clicked(None) + + # play bookmarked station + self.on_btnPlay_clicked(None) + + def on_lvBookmarks_selection_changed(self, tree_selection): + # enable delete button if bookmark is selected + (model, pathlist) = self.lvBookmarks.get_selection().get_selected_rows() + self.btnDelete.set_sensitive(len(pathlist) != 0) + + def on_bookmarkNameEdited(self, cell, path, text, data=None): + # update name in listview + iter = self.lsBookmarks.get_iter(path) + self.lsBookmarks.set(iter, 1, text) + + # update name in bookmarks array + for b in self.bookmarks: + if (b[2] == self.lsBookmarks[path][2]): + b[1] = text + break + + def on_notebookMain_switch_page(self, notebook, page, page_num): + # disable delete button if not on bookmarks page and station is not bookmarked + if (page_num != 3 and (not self.bookmarked or not self.playing)): + self.btnDelete.set_sensitive(False) + # enable delete button if not on bookmarks page and station is bookmarked + elif (page_num != 3 and self.bookmarked): + self.btnDelete.set_sensitive(True) + # enable delete button if on bookmarks page and a bookmark is selected + else: + (model, iter) = self.lvBookmarks.get_selection().get_selected() + self.btnDelete.set_sensitive(iter is not None) + + def on_radMap_toggled(self, btn): + global mapDir + if (btn.get_active()): + if (btn == self.radMapTraffic): + self.mapData["mapMode"] = 0 + mapFile = os.path.join(mapDir, "TrafficMap.png") + if (os.path.isfile(mapFile)): # check if map exists + mapImg = Image.open(mapFile).resize((200,200), Image.LANCZOS) # scale map to fit window + self.imgMap.set_from_pixbuf(imgToPixbuf(mapImg)) # convert image to pixbuf and display + else: + #self.imgMap.set_from_stock(Gtk.STOCK_MISSING_IMAGE, Gtk.ICON_SIZE_LARGE_TOOLBAR) # display missing image if file is not found + #self.imgMap.set_from_stock(Gtk.STOCK_MISSING_IMAGE, Gtk.IconSize.LARGE_TOOLBAR) # display missing image if file is not found + self.imgMap.set_from_icon_name("MISSING_IMAGE", Gtk.IconSize.DIALOG) + + elif (btn == self.radMapWeather): + self.mapData["mapMode"] = 1 + if (os.path.isfile(self.mapData["weatherNow"])): + mapImg = Image.open(self.mapData["weatherNow"]).resize((200,200), Image.LANCZOS) # scale map to fit window + self.imgMap.set_from_pixbuf(imgToPixbuf(mapImg)) # convert image to pixbuf and display + else: + #self.imgMap.set_from_stock(Gtk.STOCK_MISSING_IMAGE, Gtk.ICON_SIZE_LARGE_TOOLBAR) # display missing image if file is not found + #self.imgMap.set_from_stock(Gtk.STOCK_MISSING_IMAGE, Gtk.IconSize.LARGE_TOOLBAR) # display missing image if file is not found + self.imgMap.set_from_icon_name("MISSING_IMAGE", Gtk.IconSize.DIALOG) + + def on_btnMap_clicked(self, btn): + # open map viewer window + if (self.mapViewer is None): + self.mapViewer = NRSC5_Map(self, self.mapViewerCallback, self.mapData) + self.mapViewer.mapWindow.show() + + def mapViewerCallback(self): + # delete the map viewer + self.mapViewer = None + + def play(self): + FNULL = open(os.devnull, 'w') + FTMP = open('tmp.log','w') + + # run nrsc5 and output stdout & stderr to pipes + #self.nrsc5 = Popen(self.nrsc5Args, stdout=PIPE, stderr=PIPE, universal_newlines=True) + self.nrsc5 = Popen(self.nrsc5Args, shell=False, stdin=self.nrsc5slave, stdout=PIPE, stderr=PIPE, universal_newlines=True) + + while True: + # send input to nrsc5 if needed + if (self.nrsc5msg != ""): + select.select([],[self.nrsc5master],[]) + os.write(self.nrsc5master,str.encode(self.nrsc5msg)) + #print(self.nrsc5msg) + self.nrsc5msg = "" + # read output from nrsc5 + output = self.nrsc5.stderr.readline() + # parse the output + self.parseFeedback(output) + + # write output to log file if enabled + if (self.cbLog.get_active() and self.logFile is not None): + self.logFile.write(output) + self.logFile.flush() + + # check if nrsc5 has exited + if (self.nrsc5.poll() and not self.playing): + # cleanup if shutdown + self.debugLog("Process Terminated") + self.nrsc5 = None + break + elif (self.nrsc5.poll() and self.playing): + # restart nrsc5 if it crashes + self.debugLog("Restarting NRSC5") + time.sleep(1) + self.nrsc5 = Popen(self.nrsc5Args, shell=False, stdin=self.nrsc5slave, stdout=PIPE, stderr=PIPE, universal_newlines=True) + + def set_synchronization(self, state): + self.imgNoSynch.set_visible(state == 0) + self.imgSynch.set_visible(state == 1) + self.imgLostDevice.set_visible(state == -1) + + def set_button_name(self, btnWidget, lblWidget, stream): + temp = self.streamInfo["Streams"][stream] + if ((temp == "") or (temp == "MPS") or (temp[0:3] == "SPS") or (temp[0:2] == "HD") ): + if (self.booknames[stream] != ""): + temp = self.booknames[stream] + lblWidget.set_label(temp) + btnWidget.set_sensitive(temp != "") + + def set_label_name(self, lblWidget, inString, doSens): + lblWidget.set_label(inString) + lblWidget.set_tooltip_text(inString) + if (doSens): + lblWidget.set_sensitive(inString != "") + + def checkStatus(self): + # update status information + def update(): + global aasDir + #Gdk.threads_enter() + try: + imagePath = "" + image = "" + #ber = [self.streamInfo["BER"][0]*100,self.streamInfo["BER"][1]*100,self.streamInfo["BER"][2]*100,self.streamInfo["BER"][3]*100] + ber = [self.streamInfo["BER"][i]*100 for i in range(4)] + self.id3Changed = self.id3_did_change() + self.txtTitle.set_text(self.streamInfo["Title"]) + self.txtTitle.set_tooltip_text(self.streamInfo["Title"]) + self.txtArtist.set_text(self.streamInfo["Artist"]) + self.txtArtist.set_tooltip_text(self.streamInfo["Artist"]) + self.txtAlbum.set_text(self.streamInfo["Album"]) + self.txtAlbum.set_tooltip_text(self.streamInfo["Album"]) + self.txtGenre.set_text(self.streamInfo["Genre"]) + self.txtGenre.set_tooltip_text(self.streamInfo["Genre"]) + self.lblBitRate.set_label("{:3.1f} kbps".format(self.streamInfo["Bitrate"])) + self.lblBitRate2.set_label("{:3.1f} kbps".format(self.streamInfo["Bitrate"])) + #self.lblError.set_label("{:2.2f}% BER ".format(self.streamInfo["BER"][1]*100)) + self.lblError.set_label("{:2.2f}% BER ".format(self.streamInfo["BER"][0]*100)) + self.lblCall.set_label(" " + self.streamInfo["Callsign"]) + self.lblName.set_label(self.streamInfo["Callsign"]) + self.lblSlogan.set_label(self.streamInfo["Slogan"]) + self.lblSlogan.set_tooltip_text(self.streamInfo["Slogan"]) + self.lblMessage.set_label(self.streamInfo["Message"]) + self.lblMessage.set_tooltip_text(self.streamInfo["Message"]) + self.lblAlert.set_label(self.streamInfo["Alert"]) + self.lblAlert.set_tooltip_text(self.streamInfo["Alert"]) + self.set_button_name(self.btnAudioPrgs0,self.btnAudioLbl0,0) + self.set_button_name(self.btnAudioPrgs1,self.btnAudioLbl1,1) + self.set_button_name(self.btnAudioPrgs2,self.btnAudioLbl2,2) + self.set_button_name(self.btnAudioPrgs3,self.btnAudioLbl3,3) + self.set_label_name(self.lblAudioPrgs0, self.streamInfo["Streams"][0], True) + self.set_label_name(self.lblAudioPrgs1, self.streamInfo["Streams"][1], True) + self.set_label_name(self.lblAudioPrgs2, self.streamInfo["Streams"][2], True) + self.set_label_name(self.lblAudioPrgs3, self.streamInfo["Streams"][3], True) + self.set_label_name(self.lblAudioSvcs0, self.streamInfo["Programs"][0], True) + self.set_label_name(self.lblAudioSvcs1, self.streamInfo["Programs"][1], True) + self.set_label_name(self.lblAudioSvcs2, self.streamInfo["Programs"][2], True) + self.set_label_name(self.lblAudioSvcs3, self.streamInfo["Programs"][3], True) + self.set_label_name(self.lblDataSvcs0, self.streamInfo["Services"][0], False) + self.set_label_name(self.lblDataSvcs1, self.streamInfo["Services"][1], False) + self.set_label_name(self.lblDataSvcs2, self.streamInfo["Services"][2], False) + self.set_label_name(self.lblDataSvcs3, self.streamInfo["Services"][3], False) + self.set_label_name(self.lblDataType0, self.streamInfo["SvcTypes"][0], False) + self.set_label_name(self.lblDataType1, self.streamInfo["SvcTypes"][1], False) + self.set_label_name(self.lblDataType2, self.streamInfo["SvcTypes"][2], False) + self.set_label_name(self.lblDataType3, self.streamInfo["SvcTypes"][3], False) + self.lblMerLower.set_label("{:1.2f} dB".format(self.streamInfo["MER"][0])) + self.lblMerUpper.set_label("{:1.2f} dB".format(self.streamInfo["MER"][1])) + self.lblBerNow.set_label("{:1.3f}% (Now)".format(ber[0])) + self.lblBerAvg.set_label("{:1.3f}% (Avg)".format(ber[1])) + self.lblBerMin.set_label("{:1.3f}% (Min)".format(ber[2])) + self.lblBerMax.set_label("{:1.3f}% (Max)".format(ber[3])) + + if (self.cbAutoGain.get_active()): + self.spinGain.set_value(self.streamInfo["Gain"]) + self.lblGain.set_label("{:2.1f}dB".format(self.streamInfo["Gain"])) + + # second param is lot id, if -1, show cover, otherwise show cover + # technically we should show the file with the matching lot id + + #if (int(self.lastXHDR[1]) > 0 and self.streamInfo["Cover"] != None): + if self.lastXHDR == "0": + imagePath = os.path.join(aasDir, self.streamInfo["Cover"]) + image = self.streamInfo["Cover"] + #elif (int(self.lastXHDR[1]) < 0 or self.streamInfo["Cover"] == None): + elif self.lastXHDR == "1": + imagePath = os.path.join(aasDir, self.streamInfo["Logo"]) + image = self.streamInfo["Logo"] + if (not os.path.isfile(imagePath)): + self.imgCover.clear() + self.coverImage = "" + + # resize and display image if it changed and exists + #if (self.xhdrChanged and self.lastImage != image and os.path.isfile(imagePath)): + if (self.lastImage != image) and os.path.isfile(imagePath): + self.xhdrChanged = False + self.lastImage = image + #img_size = min(self.alignmentCover.get_allocated_height(), self.alignmentCover.get_allocated_width()) - 12 + #self.pixbuf = Gtk.gdk.pixbuf_new_from_file(imagePath) + #self.pixbuf = GdkPixbuf.Pixbuf.new_from_file(imagePath) + self.coverImage = imagePath + #self.pixbuf = self.pixbuf.scale_simple(img_size, img_size, GdkPixbuf.InterpType.BILINEAR) + #self.imgCover.set_from_pixbuf(self.pixbuf) + self.showArtwork(imagePath) + #self.handle_window_resize() + self.debugLog("Image Changed") + + if (self.cbCovers.get_active() and self.id3Changed): + self.get_cover_image_online() + + finally: + #Gdk.threads_leave() + pass + + if (self.playing): + #gobject.idle_add(update) + GLib.idle_add(update) + self.statusTimer = Timer(1, self.checkStatus) + self.statusTimer.start() + + def processTrafficMap(self, fileName): + global aasDir, mapDir + r = re.compile("^[\d]+_TMT_.*_([1-3])_([1-3])_([\d]{4})([\d]{2})([\d]{2})_([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})_([0-9A-Fa-f]{4})\..*$") # match file name + m = r.match(fileName) + + if (m): + x = int(m.group(1))-1 # X position + y = int(m.group(2))-1 # Y position + + # get time from map tile and convert to local time + dt = datetime.datetime(int(m.group(3)), int(m.group(4)), int(m.group(5)), int(m.group(6)), int(m.group(7)), tzinfo=tz.tzutc()) + t = dt.astimezone(tz.tzlocal()) # local time + ts = dtToTs(dt) # unix timestamp (utc) + + # check if the tile has already been loaded + if (self.mapData["mapTiles"][x][y] == ts): + try: + os.remove(os.path.join(aasDir, fileName)) # delete this tile, it's not needed + except: + pass + return # no need to recreate the map if it hasn't changed + + self.debugLog("Got Traffic Map Tile: {:g},{:g}".format(x,y)) + + self.mapData["mapComplete"] = False # new tiles are coming in, the map is nolonger complete + self.mapData["mapTiles"][x][y] = ts # store time for current tile + + try: + currentPath = os.path.join(aasDir,fileName) + newPath = os.path.join(mapDir, "TrafficMap_{:g}_{:g}.png".format(x,y)) # create path to new tile location + if(os.path.exists(newPath)): os.remove(newPath) # delete old image if it exists (only necessary on windows) + shutil.move(currentPath, newPath) # move and rename map tile + except: + self.debugLog("Error moving map tile (src: "+currentPath+", dest: "+newPath+")", True) + self.mapData["mapTiles"][x][y] = 0 + + # check if all of the tiles are loaded + if (self.checkTiles(ts)): + self.debugLog("Got complete traffic map") + self.mapData["mapComplete"] = True # map is complete + + # stitch the map tiles into one image + imgMap = Image.new("RGB", (600, 600), "white") # create blank image for traffic map + for i in range(0,3): + for j in range(0,3): + tileFile = os.path.join(mapDir, "TrafficMap_{:g}_{:g}.png".format(i,j)) # get path to tile + imgMap.paste(Image.open(tileFile), (j*200, i*200)) # paste tile into map + os.remove(tileFile) # delete tile image + + # now put a timestamp on it. + imgMap = imgMap.convert("RGBA") + imgBig = (981,981) # size of a weather map + #posTS = (imgMap.size[0]-235, imgMap.size[1]-29) # calculate position to put timestamp (bottom right) + posTS = (imgBig[0]-235, imgBig[1]-29) # calculate position to put timestamp (bottom right) + #imgTS = self.mkTimestamp(t, imgMap.size, posTS) # create timestamp + imgTS = self.mkTimestamp(t, imgBig, posTS) # create timestamp for a weather map + imgTS = imgTS.resize((imgMap.size[0], imgMap.size[1]), Image.LANCZOS) # resize it so it's proportional to the size of a traffic map (981 -> 600) + imgMap = Image.alpha_composite(imgMap, imgTS) # overlay timestamp on traffic map + + imgMap.save(os.path.join(mapDir, "TrafficMap.png")) # save traffic map + + # display on map page + if (self.radMapTraffic.get_active()): + img_size = min(self.alignmentMap.get_allocated_height(), self.alignmentMap.get_allocated_width()) - 12 + #imgMap = imgMap.resize((200,200), Image.LANCZOS) # scale map to fit window + imgMap = imgMap.resize((img_size, img_size), Image.LANCZOS) + self.imgMap.set_from_pixbuf(imgToPixbuf(imgMap)) # convert image to pixbuf and display + + if (self.mapViewer is not None): self.mapViewer.updated(0) # notify map viwerer if it's open + + def processWeatherOverlay(self, fileName): + global aasDir, mapDir + r = re.compile("^[\d]+_DWRO_(.*)_.*_([\d]{4})([\d]{2})([\d]{2})_([\d]{2})([\d]{2})_([0-9A-Fa-f]+)\..*$") # match file name + m = r.match(fileName) + + if (m): + # get time from map tile and convert to local time + dt = datetime.datetime(int(m.group(2)), int(m.group(3)), int(m.group(4)), int(m.group(5)), int(m.group(6)), tzinfo=tz.tzutc()) + t = dt.astimezone(tz.tzlocal()) # local time + ts = dtToTs(dt) # unix timestamp (utc) + id = self.mapData["weatherID"] + + if (m.group(1) != id): + if (id == ""): + self.debugLog("Received weather overlay before metadata, ignoring..."); + else: + self.debugLog("Received weather overlay with the wrong ID: " + m.group(1) + " (wanted " + id +")") + return + + if (self.mapData["weatherTime"] == ts): + try: + os.remove(os.path.join(aasDir, fileName)) # delete this tile, it's not needed + except: + pass + return # no need to recreate the map if it hasn't changed + + self.debugLog("Got Weather Overlay") + + self.mapData["weatherTime"] = ts # store time for current overlay + wxOlPath = os.path.join(mapDir,"WeatherOverlay_{:s}_{:}.png".format(id, ts)) + wxMapPath = os.path.join(mapDir,"WeatherMap_{:s}_{:}.png".format(id, ts)) + + # move new overlay to map directory + try: + if(os.path.exists(wxOlPath)): os.remove(wxOlPath) # delete old image if it exists (only necessary on windows) + shutil.move(os.path.join(aasDir, fileName), wxOlPath) # move and rename map tile + except: + self.debugLog("Error moving weather overlay", True) + self.mapData["weatherTime"] = 0 + + # create weather map + try: + mapPath = os.path.join(mapDir, "BaseMap_" + id + ".png") # get path to base map + if (os.path.isfile(mapPath) == False): # make sure base map exists + self.makeBaseMap(self.mapData["weatherID"], self.mapData["weatherPos"]) # create base map if it doesn't exist + + imgMap = Image.open(mapPath).convert("RGBA") # open map image + posTS = (imgMap.size[0]-235, imgMap.size[1]-29) # calculate position to put timestamp (bottom right) + imgTS = self.mkTimestamp(t, imgMap.size, posTS) # create timestamp + imgRadar = Image.open(wxOlPath).convert("RGBA") # open radar overlay + imgRadar = imgRadar.resize(imgMap.size, Image.LANCZOS) # resize radar overlay to fit the map + imgMap = Image.alpha_composite(imgMap, imgRadar) # overlay radar image on map + imgMap = Image.alpha_composite(imgMap, imgTS) # overlay timestamp + imgMap.save(wxMapPath) # save weather map + os.remove(wxOlPath) # remove overlay image + self.mapData["weatherNow"] = wxMapPath + + # display on map page + if (self.radMapWeather.get_active()): + img_size = min(self.alignmentMap.get_allocated_height(), self.alignmentMap.get_allocated_width()) - 12 + #imgMap = imgMap.resize((200,200), Image.LANCZOS) # scale map to fit window + imgMap = imgMap.resize((img_size, img_size), Image.LANCZOS) # scale map to fit window + self.imgMap.set_from_pixbuf(imgToPixbuf(imgMap)) # convert image to pixbuf and display + + self.proccessWeatherMaps() # get rid of old maps and add new ones to the list + if (self.mapViewer is not None): self.mapViewer.updated(1) # notify map viwerer if it's open + + except: + self.debugLog("Error creating weather map", True) + self.mapData["weatherTime"] = 0 + + def proccessWeatherInfo(self, fileName): + global aasDir + weatherID = None + weatherPos = None + + try: + with open(os.path.join(aasDir, fileName)) as weatherInfo: # open weather info file + for line in weatherInfo: # read line by line + if ("DWR_Area_ID=" in line): # look for line with "DWR_Area_ID=" in it + # get ID from line + r = re.compile("^DWR_Area_ID=\"(.+)\"$") + m = r.match(line) + weatherID = m.group(1) + + elif ("Coordinates=" in line): # look for line with "Coordinates=" in it + # get coordinates from line + r = re.compile("^Coordinates=.*\((-?[\d]+\.[\d]+),(-?[\d]+\.[\d]+)\).*\((-?[\d]+\.[\d]+),(-?[\d]+\.[\d]+)\).*$") + m = r.match(line) + weatherPos = [float(m.group(1)),float(m.group(2)), float(m.group(3)), float(m.group(4))] + except: + self.debugLog("Error opening weather info", True) + + if (weatherID is not None and weatherPos is not None): # check if ID and position were found + if (self.mapData["weatherID"] != weatherID or self.mapData["weatherPos"] != weatherPos): # check if ID or position has changed + self.debugLog("Got position: ({:n}, {:n}) ({:n}, {:n})".format(*weatherPos)) + self.mapData["weatherID"] = weatherID # set weather ID + self.mapData["weatherPos"] = weatherPos # set weather map position + + self.makeBaseMap(weatherID, weatherPos) + self.weatherMaps = [] + self.proccessWeatherMaps() + + def proccessWeatherMaps(self): + global mapDir + numberOfMaps = 0 + #r = re.compile("^map.WeatherMap_([a-zA-Z0-9]+)_([0-9]+).png") + r = re.compile("^.*map.WeatherMap_([a-zA-Z0-9]+)_([0-9]+).png") + now = dtToTs(datetime.datetime.now(tz.tzutc())) # get current time + files = glob.glob(os.path.join(mapDir, "WeatherMap_") + "*.png") # look for weather map files + files.sort() # sort files + #print(files) + for f in files: + m = r.match(f) # match regex + if (m): + id = m.group(1) # location ID + ts = int(m.group(2)) # timestamp (UTC) + + # remove weather maps older than 12 hours + if (now - ts > 60*60*12): + try: + if (f in self.weatherMaps): + self.weatherMaps.pop(self.weatherMaps.index(f)) # remove from list + os.remove(f) # remove file + self.debugLog("Deleted old weather map: " + f) + except: + self.debugLog("Error Failed to Delete: " + f) + + # skip if not the correct location + elif (id == self.mapData["weatherID"]): + if (f not in self.weatherMaps): + self.weatherMaps.append(f) # add to list + numberOfMaps += 1 + + + self.debugLog("Found {} weather maps".format(numberOfMaps)) + + def getMapArea(self, lat1, lon1, lat2, lon2): + from math import asinh, tan, radians + + # get pixel coordinates from latitude and longitude + # calculations taken from https://github.com/KYDronePilot/hdfm + top = asinh(tan(radians(52.482780))) + lat1 = top - asinh(tan(radians(lat1))) + lat2 = top - asinh(tan(radians(lat2))) + x1 = (lon1 + 130.781250) * 7162 / 39.34135 + x2 = (lon2 + 130.781250) * 7162 / 39.34135 + y1 = lat1 * 3565 / (top - asinh(tan(radians(38.898)))) + y2 = lat2 * 3565 / (top - asinh(tan(radians(38.898)))) + + return (int(round(x1)), int(round(y1)), int(round(x2)), int(round(y2))) + + def makeBaseMap(self, id, pos): + global mapDir + mapPath = os.path.join(mapDir, "BaseMap_" + id + ".png") # get map path + if (os.path.isfile(self.mapFile)): + if (os.path.isfile(mapPath) == False): # check if the map has already been created for this location + self.debugLog("Creating new map: " + mapPath) + px = self.getMapArea(*pos) # convert map locations to pixel coordinates + mapImg = Image.open(self.mapFile).crop(px) # open the full map and crop it to the coordinates + mapImg.save(mapPath) # save the cropped map to disk for later use + self.debugLog("Finished creating map") + else: + self.debugLog("Error map file not found: " + self.mapFile, True) + mapImg = Image.new("RGBA", (pos[2]-pos[1], pos[3]-pos[1]), "white") # if the full map is not available, use a blank image + mapImg.save(mapPath) + + def checkTiles(self, t): + # check if all the tiles have been received + for i in range(0,3): + for j in range(0,3): + if (self.mapData["mapTiles"][i][j] != t): + return False + return True + + def mkTimestamp(self, t, size, pos): + global resDir + # create a timestamp image to overlay on the weathermap + x,y = pos + text = "{:04g}-{:02g}-{:02g} {:02g}:{:02g}".format(t.year, t.month, t.day, t.hour, t.minute) # format timestamp + imgTS = Image.new("RGBA", size, (0,0,0,0)) # create a blank image + draw = ImageDraw.Draw(imgTS) # the drawing object + font = ImageFont.truetype(os.path.join(resDir,"DejaVuSansMono.ttf"), 24) # DejaVu Sans Mono 24pt font + draw.rectangle((x,y, x+231,y+25), outline="black", fill=(128,128,128,96)) # draw a box around the text + draw.text((x+3,y), text, fill="black", font=font) # draw the text + return imgTS # return the image + + def parseFeedback(self, line): + global aasDir, mapDir + line = line.strip() + #print(line) + if (self.regex[4].match(line)): + # match title + m = self.regex[4].match(line) + self.streamInfo["Title"] = m.group(1) + elif (self.regex[5].match(line)): + # match artist + m = self.regex[5].match(line) + self.streamInfo["Artist"] = m.group(1) + elif (self.regex[6].match(line)): + # match album + m = self.regex[6].match(line) + self.streamInfo["Album"] = m.group(1) + elif (self.regex[15].match(line)): + # match genre + m = self.regex[15].match(line) + self.streamInfo["Genre"] = m.group(1) + elif (self.regex[3].match(line)): + # match audio bit rate + m = self.regex[3].match(line) + self.streamInfo["Bitrate"] = float(m.group(1)) + elif (self.regex[8].match(line)): + # match MER + m = self.regex[8].match(line) + self.streamInfo["MER"] = [float(m.group(1)), float(m.group(2))] + elif (self.regex[9].match(line)): + # match BER + m = self.regex[9].match(line) + self.streamInfo["BER"] = [float(m.group(1)), float(m.group(2)), float(m.group(3)), float(m.group(4))] + elif (self.regex[13].match(line)): + # match xhdr + m = self.regex[13].match(line) + #xhdr = [m.group(1),m.group(2)] + xhdr = m.group(1) + mime = m.group(2) + lot = m.group(3) + if (xhdr != self.lastXHDR): + self.lastXHDR = xhdr + self.xhdrChanged = True + #self.debugLog("XHDR Changed: {:s} (lot {:s})".format(xhdr[0],xhdr[1])) + self.debugLog("XHDR Changed: {:s} (lot {:s})".format(xhdr,lot)) + elif (self.regex[7].match(line)): + # match album art + m = self.regex[7].match(line) + if (m): + fileName = "{}_{}".format(m.group(2),m.group(3)) + fileSize = int(m.group(4)) + headerOffset = int(len(m.group(2))) + 1 + + p = int(m.group(1),16) + + # check file existance and size .. right now we just debug log + if (not os.path.isfile(os.path.join(aasDir,fileName))): + self.debugLog("Missing file: " + fileName) + else: + actualFileSize = os.path.getsize(os.path.join(aasDir,fileName)) + if (fileSize != actualFileSize): + self.debugLog("Corrupt file: " + fileName + " (expected: "+fileSize+" bytes, got "+actualFileSize+" bytes)") + + #tmp = self.streams[int(self.spinStream.get_value()-1)][0] + tmp = self.streams[int(self.streamNum)][0] + + #if (p == self.streams[int(self.spinStream.get_value()-1)][0]): + if (p == self.streams[int(self.streamNum)][0]): + self.streamInfo["Cover"] = fileName + self.debugLog("Got Album Cover: " + fileName) + #elif (p == self.streams[int(self.spinStream.get_value()-1)][1]): + elif (p == self.streams[int(self.streamNum)][1]): + self.streamInfo["Logo"] = fileName + self.stationLogos[self.stationStr][self.streamNum] = fileName # add station logo to database + self.debugLog("Got Station Logo: " + fileName) + + elif(fileName[headerOffset:(5+headerOffset)] == "DWRO_" and mapDir is not None): + self.processWeatherOverlay(fileName) + elif(fileName[headerOffset:(4+headerOffset)] == "TMT_" and mapDir is not None): + self.processTrafficMap(fileName) # proccess traffic map tile + elif(fileName[headerOffset:(5+headerOffset)] == "DWRI_" and mapDir is not None): + self.proccessWeatherInfo(fileName) + + elif (self.regex[0].match(line)): + # match station name + m = self.regex[0].match(line) + self.streamInfo["Callsign"] = m.group(1) + elif (self.regex[2].match(line)): + # match station slogan + m = self.regex[2].match(line) + self.streamInfo["Slogan"] = m.group(1) + elif (self.regex[16].match(line)): + # match message + m = self.regex[16].match(line) + self.streamInfo["Message"] = m.group(1) + elif (self.regex[17].match(line)): + # match alert + m = self.regex[17].match(line) + self.streamInfo["Alert"] = m.group(1) + elif (self.regex[10].match(line)): + # match gain + m = self.regex[10].match(line) + self.streamInfo["Gain"] = float(m.group(1))/10 + elif (self.regex[11].match(line)): + # match stream + m = self.regex[11].match(line) + t = m.group(1) # stream type + s = int(m.group(2), 10) # stream number + n = m.group(3) + + self.debugLog("Found Stream: Type {:s}, Number {:02X}". format(t, s)) + self.lastType = t + if (t == "audio" and s >= 1 and s <= 4): + self.numStreams = s + self.streamInfo["Streams"][s-1] = n + if (t == "data"): + self.streamInfo["Services"][self.numServices] = n + self.numServices += 1 + elif (self.regex[12].match(line)): + # match port and data_service_type + m = self.regex[12].match(line) + id = int(m.group(1), 10) + p = int(m.group(2), 16) + t = int(m.group(3), 10) + self.debugLog("\tFound Port: {:03X}". format(p)) + + if (self.lastType == "audio" and self.numStreams > 0): + self.streams[self.numStreams-1].append(p) + if ((self.lastType == "data") and (id == 0) and (self.numServices > 0)): + self.streamInfo["SvcTypes"][self.numServices-1] = self.service_data_type_name(t) + elif (self.regex[18].match(line)): + # match program type + m = self.regex[18].match(line) + id = int(m.group(1), 10) + p = int(m.group(2), 16) + t = int(m.group(3), 10) + + if ((self.lastType == "audio") and (id == 0) and (self.numStreams > 0)): + self.streamInfo["Programs"][self.numStreams-1] = self.program_type_name(t) + elif (self.regex[19].match(line)): + # match synchronized + self.set_synchronization(1) + elif (self.regex[20].match(line)): + # match lost synch + self.set_synchronization(0) + elif (self.regex[21].match(line)): + # match lost device + self.set_synchronization(-1) + elif (self.regex[22].match(line)): + # match Open device failed + self.on_btnStop_clicked(None) + self.set_synchronization(-1) + + def getControls(self): + global resDir + # setup gui + builder = Gtk.Builder() + builder.add_from_file(os.path.join(resDir,"mainForm.glade")) + builder.connect_signals(self) + + # Windows + self.mainWindow = builder.get_object("mainWindow") + self.mainWindow.set_icon_from_file(os.path.join(resDir,"logo.png")) + self.mainWindow.connect("delete-event", self.shutdown) + self.mainWindow.connect("destroy", Gtk.main_quit) + self.about_dialog = None + + # get controls + self.image1 = builder.get_object("image1") + self.notebookMain = builder.get_object("notebookMain") + self.alignmentCover = builder.get_object("alignmentCover") + self.imgCover = builder.get_object("imgCover") + self.alignmentMap = builder.get_object("alignment_map") + self.imgMap = builder.get_object("imgMap") + self.spinFreq = builder.get_object("spinFreq") + #self.spinStream = builder.get_object("spinStream") + self.spinGain = builder.get_object("spinGain") + self.spinPPM = builder.get_object("spinPPM") + self.spinRTL = builder.get_object("spinRTL") + self.cbAutoGain = builder.get_object("cbAutoGain") + self.cbLog = builder.get_object("cbLog") + self.cbCovers = builder.get_object("cbCovers") + self.btnPlay = builder.get_object("btnPlay") + self.btnStop = builder.get_object("btnStop") + self.btnBookmark = builder.get_object("btnBookmark") + self.btnDelete = builder.get_object("btnDelete") + self.btnMap = builder.get_object("btnMap") + self.radMapTraffic = builder.get_object("radMapTraffic") + self.radMapWeather = builder.get_object("radMapWeather") + self.txtTitle = builder.get_object("txtTitle") + self.txtArtist = builder.get_object("txtArtist") + self.txtAlbum = builder.get_object("txtAlbum") + self.txtGenre = builder.get_object("txtGenre") + self.lblName = builder.get_object("lblName") + self.lblSlogan = builder.get_object("lblSlogan") + self.lblMessage = builder.get_object("lblMessage") + self.lblAlert = builder.get_object("lblAlert") + self.btnAudioPrgs0 = builder.get_object("btn_audio_prgs0") + self.btnAudioPrgs1 = builder.get_object("btn_audio_prgs1") + self.btnAudioPrgs2 = builder.get_object("btn_audio_prgs2") + self.btnAudioPrgs3 = builder.get_object("btn_audio_prgs3") + self.btnAudioLbl0 = builder.get_object("btn_audio_lbl0") + self.btnAudioLbl1 = builder.get_object("btn_audio_lbl1") + self.btnAudioLbl2 = builder.get_object("btn_audio_lbl2") + self.btnAudioLbl3 = builder.get_object("btn_audio_lbl3") + self.lblAudioPrgs0 = builder.get_object("lbl_audio_prgs0") + self.lblAudioPrgs1 = builder.get_object("lbl_audio_prgs1") + self.lblAudioPrgs2 = builder.get_object("lbl_audio_prgs2") + self.lblAudioPrgs3 = builder.get_object("lbl_audio_prgs3") + self.lblAudioSvcs0 = builder.get_object("lbl_audio_svcs0") + self.lblAudioSvcs1 = builder.get_object("lbl_audio_svcs1") + self.lblAudioSvcs2 = builder.get_object("lbl_audio_svcs2") + self.lblAudioSvcs3 = builder.get_object("lbl_audio_svcs3") + self.lblDataSvcs0 = builder.get_object("lbl_data_svcs0") + self.lblDataSvcs1 = builder.get_object("lbl_data_svcs1") + self.lblDataSvcs2 = builder.get_object("lbl_data_svcs2") + self.lblDataSvcs3 = builder.get_object("lbl_data_svcs3") + self.lblDataType0 = builder.get_object("lbl_data_svcs10") + self.lblDataType1 = builder.get_object("lbl_data_svcs11") + self.lblDataType2 = builder.get_object("lbl_data_svcs12") + self.lblDataType3 = builder.get_object("lbl_data_svcs13") + self.lblCall = builder.get_object("lblCall") + self.lblGain = builder.get_object("lblGain") + self.lblBitRate = builder.get_object("lblBitRate") + self.lblBitRate2 = builder.get_object("lblBitRate2") + self.lblError = builder.get_object("lblError") + self.lblMerLower = builder.get_object("lblMerLower") + self.lblMerUpper = builder.get_object("lblMerUpper") + self.lblBerNow = builder.get_object("lblBerNow") + self.lblBerAvg = builder.get_object("lblBerAvg") + self.lblBerMin = builder.get_object("lblBerMin") + self.lblBerMax = builder.get_object("lblBerMax") + self.imgNoSynch = builder.get_object("img_nosynch") + self.imgSynch = builder.get_object("img_synchpilot") + self.imgLostDevice = builder.get_object("img_lostdevice") + self.lvBookmarks = builder.get_object("listviewBookmarks") + self.lsBookmarks = Gtk.ListStore(str, str, int) + + self.lvBookmarks.set_model(self.lsBookmarks) + self.lvBookmarks.get_selection().connect("changed", self.on_lvBookmarks_selection_changed) + + self.image1.set_from_pixbuf(GdkPixbuf.Pixbuf.new_from_file(os.path.join(resDir,"weather.png"))) + self.imgNoSynch.set_from_pixbuf(GdkPixbuf.Pixbuf.new_from_file(os.path.join(resDir,"nosynch.png"))) + self.imgSynch.set_from_pixbuf(GdkPixbuf.Pixbuf.new_from_file(os.path.join(resDir,"synchpilot.png"))) + self.imgLostDevice.set_from_pixbuf(GdkPixbuf.Pixbuf.new_from_file(os.path.join(resDir,"lostdevice.png"))) + self.btnMap.set_icon_widget(self.image1) + + self.mainWindow.connect("check-resize", self.on_cover_resize) + + def initStreamInfo(self): + # stream information + self.streamInfo = { + "Callsign": "", # station callsign + "Slogan": "", # station slogan + "Message": "", # station message + "Alert": "", # station alert + "Title": "", # track title + "Album": "", # track album + "Genre": "", # track genre + "Artist": "", # track artist + "Cover": "", # filename of track cover + "Logo": "", # station logo + "Streams": ["","","",""], # audio stream names + "Programs": ["","","",""], # audio stream types + "Services": ["","","",""], # data service names + "SvcTypes": ["","","",""], # data service types + "Bitrate": 0, # current stream bit rate + "MER": [0,0], # modulation error ratio: lower, upper + "BER": [0,0,0,0], # bit error rate: current, average, min, max + "Gain": 0 # automatic gain + } + + self.streams = [[],[],[],[]] + self.numStreams = 0 + self.numServices = 0 + self.lastType = 0 + + # clear status info + self.lblCall.set_label("") + self.btnAudioLbl0.set_label("") + self.btnAudioLbl1.set_label("") + self.btnAudioLbl2.set_label("") + self.btnAudioLbl3.set_label("") + self.lblBitRate.set_label("") + self.lblBitRate2.set_label("") + self.lblError.set_label("") + self.lblGain.set_label("") + self.txtTitle.set_text("") + self.txtArtist.set_text("") + self.txtAlbum.set_text("") + self.txtGenre.set_text("") + self.imgCover.clear() + self.coverImage = "" + self.lblName.set_label("") + self.lblSlogan.set_label("") + self.lblSlogan.set_tooltip_text("") + self.lblMessage.set_label("") + self.lblMessage.set_tooltip_text("") + self.btnAudioPrgs0.set_sensitive(False) + self.btnAudioPrgs1.set_sensitive(False) + self.btnAudioPrgs2.set_sensitive(False) + self.btnAudioPrgs3.set_sensitive(False) + self.lblAudioPrgs0.set_label("") + self.lblAudioPrgs0.set_sensitive(False) + self.lblAudioPrgs1.set_label("") + self.lblAudioPrgs1.set_sensitive(False) + self.lblAudioPrgs2.set_label("") + self.lblAudioPrgs2.set_sensitive(False) + self.lblAudioPrgs3.set_label("") + self.lblAudioPrgs3.set_sensitive(False) + self.lblAudioSvcs0.set_label("") + self.lblAudioSvcs0.set_sensitive(False) + self.lblAudioSvcs1.set_label("") + self.lblAudioSvcs1.set_sensitive(False) + self.lblAudioSvcs2.set_label("") + self.lblAudioSvcs2.set_sensitive(False) + self.lblAudioSvcs3.set_label("") + self.lblAudioSvcs3.set_sensitive(False) + self.lblDataSvcs0.set_label("") + self.lblDataSvcs1.set_label("") + self.lblDataSvcs2.set_label("") + self.lblDataSvcs3.set_label("") + self.lblDataType0.set_label("") + self.lblDataType1.set_label("") + self.lblDataType2.set_label("") + self.lblDataType3.set_label("") + self.lblMerLower.set_label("") + self.lblMerUpper.set_label("") + self.lblBerNow.set_label("") + self.lblBerAvg.set_label("") + self.lblBerMin.set_label("") + self.lblBerMax.set_label("") + self.set_synchronization(0) + + def loadSettings(self): + global aasDir, cfgDir, mapDir + + # load station logos + try: + with open(os.path.join(cfgDir,"stationLogos.json"), mode='r') as f: + self.stationLogos = json.load(f) + except: + self.debugLog("Error: Unable to load station logo database", True) + + self.mainWindow.resize(self.defaultSize[0],self.defaultSize[1]) + + # load settings + try: + with open(os.path.join(cfgDir,"config.json"), mode='r') as f: + config = json.load(f) + + if "MapData" in config: + self.mapData = config["MapData"] + if (self.mapData["mapMode"] == 0): + self.radMapTraffic.set_active(True) + self.radMapTraffic.toggled() + elif (self.mapData["mapMode"] == 1): + self.radMapWeather.set_active(True) + self.radMapWeather.toggled() + + if "Width" and "Height" in config: + self.mainWindow.resize(config["Width"],config["Height"]) + else: + self.mainWindow.resize(self.defaultSize) + + self.mainWindow.move(config["WindowX"], config["WindowY"]) + self.spinFreq.set_value(config["Frequency"]) + #self.spinStream.set_value(config["Stream"]) + self.streamNum = config["Stream"]-1 + if (self.streamNum < 0): + self.streamNum = 0 + self.set_program_btns() + self.spinGain.set_value(config["Gain"]) + self.cbAutoGain.set_active(config["AutoGain"]) + self.spinPPM.set_value(config["PPMError"]) + self.spinRTL.set_value(config["RTL"]) + self.cbLog.set_active(config["LogToFile"]) + if ("DLoadArt" in config): + self.cbCovers.set_active(config["DLoadArt"]) + self.bookmarks = config["Bookmarks"] + for bookmark in self.bookmarks: + self.lsBookmarks.append(bookmark) + except: + self.debugLog("Error: Unable to load config", True) + + # create aas directory + if (not os.path.isdir(aasDir)): + try: + os.mkdir(aasDir) + except: + self.debugLog("Error: Unable to create AAS directory", True) + aasDir = None + + # create map directory + if (not os.path.isdir(mapDir)): + try: + os.mkdir(mapDir) + except: + self.debugLog("Error: Unable to create Map directory", True) + mapDir = None + + # open log file + try: + self.logFile = open("nrsc5.log", mode='a') + except: + self.debugLog("Error: Unable to create log file", True) + + def shutdown(self, *args): + global cfgDir + # stop map viewer animation if it's running + if (self.mapViewer is not None and self.mapViewer.animateTimer is not None): + self.mapViewer.animateTimer.cancel() + self.mapViewer.animateStop = True + + while (self.mapViewer.animateBusy): + self.debugLog("Animation Busy - Stopping") + if (self.mapViewer.animateTimer is not None): + self.mapViewer.animateTimer.cancel() + time.sleep(0.25) + + self.playing = False + + # kill nrsc5 if it's running + if (self.nrsc5 is not None and not self.nrsc5.poll()): + self.nrsc5.kill() + + # shut down status timer if it's running + if (self.statusTimer is not None): + self.statusTimer.cancel() + + # wait for player thread to exit + #if (self.playerThread is not None and self.playerThread.isAlive()): + if (self.playerThread is not None and self.playerThread.is_alive()): + self.playerThread.join(1) + + # close log file if it's enabled + if (self.logFile is not None): + self.logFile.close() + + # save settings + try: + with open(os.path.join(cfgDir,"config.json"), mode='w') as f: + winX, winY = self.mainWindow.get_position() + width, height = self.mainWindow.get_size() + config = { + "CfgVersion": "1.1.0", + "WindowX" : winX, + "WindowY" : winY, + "Width" : width, + "Height" : height, + "Frequency" : self.spinFreq.get_value(), + #"Stream" : int(self.spinStream.get_value()), + "Stream" : int(self.streamNum)+1, + "Gain" : self.spinGain.get_value(), + "AutoGain" : self.cbAutoGain.get_active(), + "PPMError" : int(self.spinPPM.get_value()), + "RTL" : int(self.spinRTL.get_value()), + "LogToFile" : self.cbLog.get_active(), + "DLoadArt" : self.cbCovers.get_active(), + "Bookmarks" : self.bookmarks, + "MapData" : self.mapData, + } + # sort bookmarks + config["Bookmarks"].sort(key=lambda t: t[2]) + + json.dump(config, f, indent=2) + + with open(os.path.join(cfgDir,"stationLogos.json"), mode='w') as f: + json.dump(self.stationLogos, f, indent=2) + except: + self.debugLog("Error: Unable to save config", True) + + def debugLog(self, message, force=False): + if (debugMessages or force): + now = datetime.datetime.now() + print (now.strftime("%b %d %H:%M:%S : ") + message) + +class NRSC5_Map(object): + def __init__(self, parent, callback, data): + global resDir + # setup gui + builder = Gtk.Builder() + builder.add_from_file(os.path.join(resDir,"mapForm.glade")) + builder.connect_signals(self) + + self.parent = parent # parent class + self.callback = callback # callback function + self.data = data # map data + self.animateTimer = None # timer used to animate weather maps + self.animateBusy = False + self.animateStop = False + self.weatherMaps = parent.weatherMaps # list of weather maps sorted by time + self.mapIndex = 0 # the index of the next weather map to display + + # get the controls + self.mapWindow = builder.get_object("mapWindow") + self.imgMap = builder.get_object("imgMap") + self.radMapWeather = builder.get_object("radMapWeather") + self.radMapTraffic = builder.get_object("radMapTraffic") + self.chkAnimate = builder.get_object("chkAnimate") + self.chkScale = builder.get_object("chkScale") + self.spnSpeed = builder.get_object("spnSpeed") + self.adjSpeed = builder.get_object("adjSpeed") + self.imgKey = builder.get_object("imgKey") + + self.imgKey.set_from_pixbuf(GdkPixbuf.Pixbuf.new_from_file(os.path.join(resDir,"radar_key.png"))) + self.mapWindow.connect("delete-event", self.on_mapWindow_delete) + + self.config = data["viewerConfig"] # get the map viewer config + self.mapWindow.resize(*self.config["windowSize"]) # set the window size + self.mapWindow.move(*self.config["windowPos"]) # set the window position + if (self.config["mode"] == 0): + self.radMapTraffic.set_active(True) # set the map radio buttons + elif (self.config["mode"] == 1): + self.radMapWeather.set_active(True) + self.setMap(self.config["mode"]) # display the current map + + self.chkAnimate.set_active(self.config["animate"]) # set the animation mode + self.chkScale.set_active(self.config["scale"]) # set the scale mode + self.spnSpeed.set_value(self.config["animationSpeed"]) # set the animation speed + + def on_radMap_toggled(self, btn): + if (btn.get_active()): + if (btn == self.radMapTraffic): + self.config["mode"] = 0 + self.imgKey.set_visible(False) # hide the key for the weather radar + + # stop animation if it's enabled + if (self.animateTimer is not None): + self.animateTimer.cancel() + self.animateTimer = None + + self.setMap(0) # show the traffic map + + elif (btn == self.radMapWeather): + self.config["mode"] = 1 + self.imgKey.set_visible(True) # show the key for the weather radar + + # check if animate is enabled and start animation + if (self.config["animate"] and self.animateTimer is None): + self.animateTimer = Timer(0.05, self.animate) + self.animateTimer.start() + + # no animation, just show the current map + elif(not self.config["animate"]): + self.setMap(1) + + def on_chkAnimate_toggled(self, btn): + self.config["animate"] = self.chkAnimate.get_active() + + if (self.config["animate"] and self.config["mode"] == 1): + # start animation + self.animateTimer = Timer(self.config["animationSpeed"], self.animate) # create the animation timer + self.animateTimer.start() # start the animation timer + else: + # stop animation + if (self.animateTimer is not None): + self.animateTimer.cancel() # cancel the animation timer + self.animateTimer = None + self.mapIndex = len(self.weatherMaps)-1 # reset the animation index + self.setMap(self.config["mode"]) # show the most recent map + + def on_chkScale_toggled(self, btn): + self.config["scale"] = btn.get_active() + if (self.config["mode"] == 1): + if (self.config["animate"]): + i = len(self.weatherMaps)-1 if (self.mapIndex-1 < 0) else self.mapIndex-1 # get the index for the current map in the animation + self.showImage(self.weatherMaps[i], self.config["scale"]) # show the current map in the animation + else: + self.showImage(self.data["weatherNow"], self.config["scale"]) # show the most recent map + + def on_spnSpeed_value_changed(self, spn): + self.config["animationSpeed"] = self.adjSpeed.get_value() # get the animation speed + + def on_mapWindow_delete(self, *args): + # cancel the timer if it's running + if (self.animateTimer is not None): + self.animateTimer.cancel() + self.animateStop = True + + # wait for animation to finish + while (self.animateBusy): + self.parent.debugLog("Waiting for animation to finish") + if (self.animateTimer is not None): + self.animateTimer.cancel() + time.sleep(0.25) + + self.config["windowPos"] = self.mapWindow.get_position() # store current window position + self.config["windowSize"] = self.mapWindow.get_size() # store current window size + self.callback() # run the callback + + def animate(self): + fileName = self.weatherMaps[self.mapIndex] if len(self.weatherMaps) else "" + if (os.path.isfile(fileName)): + self.animateBusy = True # set busy to true + + if (self.config["scale"]): + mapImg = imgToPixbuf(Image.open(fileName).resize((600,600), Image.LANCZOS)) # open weather map, resize to 600x600, and convert to pixbuf + else: + mapImg = imgToPixbuf(Image.open(fileName)) # open weather map and convert to pixbuf + + if (self.config["animate"] and self.config["mode"] == 1 and not self.animateStop): # check if the viwer is set to animated weather map + self.imgMap.set_from_pixbuf(mapImg) # display image + self.mapIndex += 1 # incriment image index + if (self.mapIndex >= len(self.weatherMaps)): # check if this is the last image + self.mapIndex = 0 # reset the map index + self.animateTimer = Timer(2, self.animate) # show the last image for a longer time + else: + self.animateTimer = Timer(self.config["animationSpeed"], self.animate) # set the timer to the normal speed + + self.animateTimer.start() # start the timer + else: + self.animateTimer = None # clear the timer + + self.animateBusy = False # set busy to false + else: + self.chkAnimate.set_active(False) # stop animation if image was not found + self.mapIndex = 0 + + def showImage(self, fileName, scale): + if (os.path.isfile(fileName)): + if (scale): + mapImg = Image.open(fileName).resize((600,600), Image.LANCZOS) # open and scale map to fit window + else: + mapImg = Image.open(fileName) # open map + + self.imgMap.set_from_pixbuf(imgToPixbuf(mapImg)) # convert image to pixbuf and display + else: + #self.imgMap.set_from_stock(Gtk.STOCK_MISSING_IMAGE, Gtk.ICON_SIZE_LARGE_TOOLBAR) # display missing image if file is not found + #self.imgMap.set_from_stock(Gtk.STOCK_MISSING_IMAGE, Gtk.IconSize.LARGE_TOOLBAR) # display missing image if file is not found + self.imgMap.set_from_icon_name("MISSING_IMAGE", Gtk.IconSize.DIALOG) + + def setMap(self, map): + global mapDir + if (map == 0): + self.showImage(os.path.join(mapDir, "TrafficMap.png"), False) # show traffic map + elif (map == 1): + self.showImage(self.data["weatherNow"], self.config["scale"]) # show weather map + + def updated(self, imageType): + if (self.config["mode"] == 0): + self.setMap(0) + elif (self.config["mode"] == 1): + self.setMap(1) + self.mapIndex = len(self.weatherMaps)-1 + +def dtToTs(dt): + # convert datetime to timestamp + return int((dt - datetime.datetime(1970, 1, 1, tzinfo=tz.tzutc())).total_seconds()) + +def tsToDt(ts): + # convert timestamp to datetime + return datetime.datetime.utcfromtimestamp(ts) + +def imgToPixbuf(img): + # convert PIL.Image to gdk.pixbuf + #imgArr = numpy.array(img.convert("RGB")) + #return gtk.gdk.pixbuf_new_from_array(imgArr, gtk.gdk.COLORSPACE_RGB, 8) + data = GLib.Bytes.new(img.tobytes()) + return GdkPixbuf.Pixbuf.new_from_bytes(data, GdkPixbuf.Colorspace.RGB, 'A' in img.getbands(), + 8, img.width, img.height, len(img.getbands())*img.width) + + +if __name__ == "__main__": + # show main window and start main thread + nrsc5_dui = NRSC5_DUI() + nrsc5_dui.mainWindow.show() + if (debugMessages and debugAutoStart): + nrsc5_dui.on_btnPlay_clicked(nrsc5_dui) + + Gtk.main()