69 lines
3.2 KiB
Python
69 lines
3.2 KiB
Python
# FlightMonitor/__main__.py
|
|
import tkinter as tk
|
|
|
|
# MODIFIED: Import the logging configuration dictionary
|
|
# WHY: Need to pass configuration to the logger setup function.
|
|
# HOW: Added import.
|
|
from .data.logging_config import LOGGING_CONFIG # Import the config dictionary
|
|
|
|
# MODIFIED: Import the new setup_basic_logging function AND get_logger function
|
|
# WHY: Need to call the centralized basic setup function early and get logger instances.
|
|
# HOW: Changed setup_logging to setup_basic_logging.
|
|
from .utils.logger import setup_basic_logging, get_logger
|
|
|
|
from .gui.main_window import MainWindow
|
|
from .controller.app_controller import AppController
|
|
|
|
|
|
def main():
|
|
"""
|
|
Main function to launch the Flight Monitor application.
|
|
Initializes the Tkinter root, sets up basic logging, creates the controller
|
|
and the main window, and starts the event loop.
|
|
"""
|
|
# Initialize the Tkinter root window FIRST
|
|
root = tk.Tk()
|
|
|
|
# MODIFIED: Setup basic logging AFTER Tkinter root is created
|
|
# WHY: The Tkinter-based log processor needs a root instance to schedule itself.
|
|
# The TkinterTextHandler itself will be added later by MainWindow.
|
|
# HOW: Called setup_basic_logging here, passing the necessary arguments.
|
|
setup_basic_logging(
|
|
root_tk_instance_for_processor=root,
|
|
logging_config_dict=LOGGING_CONFIG,
|
|
)
|
|
|
|
# Now that basic logging is set up (console, file, queue), we can use module_logger
|
|
module_logger_main = get_logger(__name__)
|
|
module_logger_main.info("Application starting...")
|
|
|
|
# Create the application controller
|
|
app_controller = AppController()
|
|
|
|
# MODIFIED: Set the main window instance in the controller *before* creating MainWindow
|
|
# WHY: MainWindow's initialization (specifically MapCanvasManager) might call back
|
|
# to the controller requesting MainWindow methods (like show_error_message).
|
|
# If the controller doesn't have a reference to MainWindow yet, these calls fail.
|
|
# By setting it here, the controller has a reference to the *soon-to-be-created*
|
|
# MainWindow (self-referencing via `app_controller.set_main_window`),
|
|
# which allows it to correctly pass itself (with its window reference) to sub-components like MapCanvasManager.
|
|
# HOW: Moved this line before MainWindow creation. It's a forward reference,
|
|
# but Tkinter's `root` and `app_controller` are already defined.
|
|
# MainWindow will then internally set its own reference during its init.
|
|
# NOTE: This is a common pattern for mutually dependent objects.
|
|
main_app_window_placeholder = MainWindow(root, app_controller) # Create the main application window instance
|
|
app_controller.set_main_window(main_app_window_placeholder) # Pass the instance to the controller
|
|
# main_app_window = main_app_window_placeholder # Keep the name consistent
|
|
|
|
# Start the Tkinter event loop
|
|
module_logger_main.info("Starting Tkinter main loop.")
|
|
root.mainloop()
|
|
module_logger_main.info("Tkinter main loop finished.")
|
|
|
|
# Cleanup is handled by MainWindow's _on_closing method, which in turn
|
|
# calls controller.on_application_exit and logger.shutdown_logging_system.
|
|
module_logger_main.info("Application finished.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() |