kopia lustrzana https://github.com/ctjacobs/pyqso
185 wiersze
7.5 KiB
Python
Executable File
185 wiersze
7.5 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
# Copyright (C) 2012 Christian T. Jacobs.
|
|
|
|
# This file is part of PyQSO.
|
|
|
|
# PyQSO 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.
|
|
#
|
|
# PyQSO 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 PyQSO. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from gi.repository import Gtk, GdkPixbuf
|
|
import argparse
|
|
import configparser
|
|
import os
|
|
import os.path
|
|
import sys
|
|
import signal
|
|
|
|
# This will help Python find the PyQSO modules that need to be imported below.
|
|
pyqso_path = os.path.join(os.path.realpath(os.path.dirname(__file__)), os.pardir)
|
|
sys.path.insert(0, pyqso_path)
|
|
|
|
import logging
|
|
logging.basicConfig(level=logging.INFO)
|
|
logging.info("PyQSO development version.")
|
|
|
|
# PyQSO modules
|
|
from pyqso.adif import *
|
|
from pyqso.logbook import *
|
|
from pyqso.menu import *
|
|
from pyqso.toolbar import *
|
|
from pyqso.toolbox import *
|
|
from pyqso.preferences_dialog import *
|
|
|
|
|
|
class PyQSO(Gtk.Window):
|
|
|
|
""" The PyQSO application class. """
|
|
|
|
def __init__(self, logbook_path=None):
|
|
""" Set up the main (root) window, start the event loop, and open a logbook (if the logbook's path is specified by the user in the command line).
|
|
|
|
:arg str logbook_path: An optional argument containing the path of the logbook file to open. If no value is provided, this defaults to None and no logbook is opened.
|
|
"""
|
|
|
|
# Call the constructor of the super class (Gtk.Window)
|
|
Gtk.Window.__init__(self, title="PyQSO")
|
|
|
|
# Check that the directory for holding PyQSO configuration files exists. If it doesn't, create it now.
|
|
try:
|
|
os.makedirs(os.path.expanduser('~/.config/pyqso'), exist_ok=True)
|
|
except Exception as e:
|
|
logging.error("An error occurred whilst creating a directory for PyQSO configuration files. Try creating the directory '~/.config/pyqso' manually.")
|
|
logging.exception(e)
|
|
|
|
# Get any application-specific preferences from the configuration file
|
|
config = configparser.ConfigParser()
|
|
|
|
# Check that the configuration file actually exists (and is readable)
|
|
# otherwise, we will resort to the defaults.
|
|
have_config = (config.read(os.path.expanduser("~/.config/pyqso/preferences.ini")) != [])
|
|
|
|
self.set_size_request(800, 600) # Default to an 800 x 600 resolution.
|
|
self.set_position(Gtk.WindowPosition.CENTER)
|
|
possible_icon_paths = [os.path.join(pyqso_path, "icons", "log_64x64.png")]
|
|
for icon_path in possible_icon_paths:
|
|
try:
|
|
self.set_icon_from_file(icon_path)
|
|
except Exception as error:
|
|
print(error.message)
|
|
|
|
# Kills the application if the close button is clicked on the main window itself.
|
|
self.connect("delete-event", Gtk.main_quit)
|
|
|
|
vbox_outer = Gtk.VBox()
|
|
self.add(vbox_outer)
|
|
|
|
self.statusbar = Gtk.Statusbar()
|
|
context_id = self.statusbar.get_context_id("Status")
|
|
self.statusbar.push(context_id, "No logbook is currently open.")
|
|
|
|
# Create a Logbook so we can add/remove/edit logs and records,
|
|
# once connected to the SQLite database.
|
|
self.logbook = Logbook(self)
|
|
self.logbook.set_scrollable(True)
|
|
|
|
self.toolbox = Toolbox(self)
|
|
|
|
# Set up menu and tool bars
|
|
# These classes depend on the Logbook and Toolbox class,
|
|
# so pack the logbook and toolbox after the menu and toolbar.
|
|
self.menu = Menu(self)
|
|
self.toolbar = Toolbar(self)
|
|
|
|
vbox_outer.pack_start(self.menu, False, False, 0)
|
|
vbox_outer.pack_start(self.toolbar, False, False, 0)
|
|
vbox_outer.pack_start(self.logbook, True, True, 0)
|
|
vbox_outer.pack_start(self.toolbox, True, True, 0)
|
|
vbox_outer.pack_start(self.statusbar, False, False, 0)
|
|
|
|
self.show_all()
|
|
|
|
if(have_config):
|
|
if(config.get("general", "show_toolbox") == "False"):
|
|
self.toolbox.toggle_visible_callback()
|
|
else:
|
|
# Hide the Toolbox by default
|
|
self.toolbox.toggle_visible_callback()
|
|
|
|
if(logbook_path is not None):
|
|
self.logbook.open(widget=None, path=logbook_path)
|
|
|
|
return
|
|
|
|
def show_about(self, widget):
|
|
""" Show the About dialog, which includes license information. """
|
|
about = Gtk.AboutDialog()
|
|
about.set_modal(True)
|
|
about.set_transient_for(parent=self)
|
|
about.set_program_name("PyQSO")
|
|
about.set_version("0.3")
|
|
about.set_authors(["Christian T. Jacobs (2E0ICL)"])
|
|
about.set_license("""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/>.""")
|
|
about.set_comments("PyQSO: A contact logging tool for amateur radio operators.")
|
|
possible_icon_paths = [os.path.join(pyqso_path, "icons", "log_64x64.png")]
|
|
for icon_path in possible_icon_paths:
|
|
try:
|
|
about.set_logo(GdkPixbuf.Pixbuf.new_from_file_at_scale(icon_path, 64, 64, False))
|
|
except Exception as error:
|
|
print(error.message)
|
|
about.run()
|
|
about.destroy()
|
|
return
|
|
|
|
def show_preferences(self, widget):
|
|
""" Show the Preferences dialog. Any changes made by the user after clicking the 'Ok' button are saved in the .cfg file. """
|
|
preferences = PreferencesDialog(self)
|
|
response = preferences.run()
|
|
if(response == Gtk.ResponseType.OK):
|
|
preferences.commit()
|
|
preferences.destroy()
|
|
return
|
|
|
|
if(__name__ == "__main__"):
|
|
# Get any command line arguments
|
|
parser = argparse.ArgumentParser(prog="pyqso")
|
|
parser.add_argument("-d", "--debug", action="store_true", default=False, help="Enable debugging. All debugging messages will be written to pyqso.debug.")
|
|
parser.add_argument("-l", "--logbook", action="store", type=str, metavar="/path/to/my_logbook_file.db", default=None, help="Path to a Logbook file. If this file does not already exist, then it will be created.")
|
|
args = parser.parse_args()
|
|
|
|
# Output debugging messages to a file
|
|
if(args.debug):
|
|
# Get the root logger
|
|
logger = logging.getLogger()
|
|
logger.setLevel(logging.DEBUG)
|
|
# Add a file handler
|
|
handler = logging.FileHandler("pyqso.debug", mode="w")
|
|
formatter = logging.Formatter(fmt="%(asctime)s %(levelname)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
|
|
handler.setFormatter(formatter)
|
|
logger.addHandler(handler)
|
|
|
|
signal.signal(signal.SIGINT, signal.SIG_DFL) # Exit PyQSO if a SIGINT signal is captured.
|
|
application = PyQSO(args.logbook) # Populate the main window and show it
|
|
Gtk.main() # Start up the event loop!
|