cs2tracker 2.1.14__py3-none-any.whl → 2.1.16__py3-none-any.whl

cs2tracker/app/editor_frame.py

@@ -8,6 +8,7 @@ from tkinter import messagebox, ttk
 from nodejs import node
 from ttk_text import ThemedText
 
+from cs2tracker.config import get_config
 from cs2tracker.constants import (
     CONFIG_FILE,
     CONFIG_FILE_BACKUP,
@@ -15,13 +16,13 @@ from cs2tracker.constants import (
     INVENTORY_IMPORT_FILE,
     INVENTORY_IMPORT_SCRIPT,
 )
-from cs2tracker.util import get_config
+from cs2tracker.util.tkinter import centered, size_info
 
 ADD_CUSTOM_ITEM_TITLE = "Add Custom Item"
-ADD_CUSTOM_ITEM_SIZE = "500x220"
+ADD_CUSTOM_ITEM_SIZE = "500x230"
 
 IMPORT_INVENTORY_TITLE = "Import Steam Inventory"
-IMPORT_INVENTORY_SIZE = "600x550"
+IMPORT_INVENTORY_SIZE = "700x350"
 
 IMPORT_INVENTORY_PROCESS_TITLE = "Importing Steam Inventory..."
 IMPORT_INVENTORY_PROCESS_SIZE = "700x500"
@@ -30,13 +31,13 @@ config = get_config()
 
 
 class ConfigEditorFrame(ttk.Frame):
-    def __init__(self, parent):
+    def __init__(self, window):
         """Initialize the configuration editor frame that allows users to view and edit
         the configuration options.
         """
-        super().__init__(parent, padding=15)
+        super().__init__(window, padding=15)
 
-        self.parent = parent
+        self.window = window
         self.edit_entry = None
         self._add_widgets()
 
@@ -71,9 +72,11 @@ class ConfigEditorFrame(ttk.Frame):
             config.load_from_file()
             self.reload_config_into_tree()
             messagebox.showerror(
-                "Config Error", f"The configuration is invalid. ({config.last_error})", parent=self
+                "Config Error",
+                f"The configuration is invalid. ({config.last_error})",
+                parent=self.window,
             )
-        self.parent.focus_set()
+        self.window.focus_set()
         self.tree.focus_set()
 
     def _save_edit(self, event, row, column):
@@ -126,13 +129,18 @@ class ConfigEditorFrame(ttk.Frame):
         """
         selected = self.tree.selection()
         if selected:
-            row = selected[0]
-            section_name = self.tree.parent(row)
-            if section_name == "Custom Items":
-                self.tree.delete(row)
+            item = selected[0]
+            section_name = self.tree.parent(item)
+            if section_name in ("Stickers", "Skins"):
+                next_option = self.tree.next(item)
+                self.tree.delete(item)
                 self.save_config()
-                self.tree.focus("Custom Items")
-                self.tree.selection_set("Custom Items")
+                if next_option:
+                    self.tree.focus(next_option)
+                    self.tree.selection_set(next_option)
+                else:
+                    self.tree.focus(section_name)
+                    self.tree.selection_set(section_name)
 
     def _destroy_entry(self, _):
         """Destroy any entry widgets in the treeview on an event, such as a mouse wheel
@@ -150,34 +158,68 @@ class ConfigEditorFrame(ttk.Frame):
         self.tree.bind("<Double-1>", self._set_cell_value)
         self.tree.bind("<Return>", self._set_selection_value)
         self.tree.bind("<BackSpace>", self._delete_selection_value)
-        self.parent.bind("<MouseWheel>", self._destroy_entry)
-        self.parent.bind("<Escape>", self._destroy_entry)
+        self.window.bind("<MouseWheel>", self._destroy_entry)
+        self.window.bind("<Escape>", self._destroy_entry)
 
     def _load_config_into_tree(self):
         """Load the configuration options into the treeview for display and editing."""
         for section in config.sections():
+            # App Settings are internal and shouldn't be displayed to the user
             if section == "App Settings":
                 continue
+
             section_level = self.tree.insert("", "end", iid=section, text=section)
-            for config_option, value in config.items(section):
+
+            # Items in the Stickers, Cases, and Skins sections should be displayed alphabetically sorted
+            section_items = config.items(section)
+            if section in ("Stickers", "Cases", "Skins"):
+                section_items = sorted(section_items)
+
+            for config_option, value in section_items:
                 if section not in ("User Settings", "App Settings"):
                     option_name = config.option_to_name(config_option, href=True)
-                    self.tree.insert(section_level, "end", text=option_name, values=[value])
+                    self.tree.insert(
+                        section_level,
+                        "end",
+                        iid=f"{section}-{option_name}",
+                        text=option_name,
+                        values=[value],
+                    )
                 else:
                     option_name = config.option_to_name(config_option)
-                    self.tree.insert(section_level, "end", text=option_name, values=[value])
+                    self.tree.insert(
+                        section_level,
+                        "end",
+                        iid=f"{section}-{option_name}",
+                        text=option_name,
+                        values=[value],
+                    )
 
         self.tree.focus("User Settings")
         self.tree.selection_set("User Settings")
 
     def reload_config_into_tree(self):
-        """Reload the configuration options into the treeview for display and
-        editing.
+        """Reload the configuration options into the treeview for display and editing
+        and maintain the users current selection.
         """
+        selected = self.tree.selection()
+        selected_text, selected_section = None, None
+        if selected:
+            selected_text = self.tree.item(selected[0], "text")
+            selected_section = self.tree.parent(selected[0])
+
         for item in self.tree.get_children():
             self.tree.delete(item)
         self._load_config_into_tree()
 
+        if selected_section:
+            self.tree.item(selected_section, open=True)
+            self.tree.focus(f"{selected_section}-{selected_text}")
+            self.tree.selection_set(f"{selected_section}-{selected_text}")
+        elif selected:
+            self.tree.focus(selected_text)
+            self.tree.selection_set(selected_text)  # type: ignore
+
     def _configure_treeview(self):
         """Configure a treeview to display and edit configuration options."""
         scrollbar = ttk.Scrollbar(self)
@@ -220,7 +262,7 @@ class ConfigEditorButtonFrame(ttk.Frame):
         reset_button = ttk.Button(self, text="Reset", command=self._reset_config)
         reset_button.pack(side="left", expand=True, padx=5)
 
-        custom_item_button = ttk.Button(self, text="Add Custom Item", command=self._add_custom_item)
+        custom_item_button = ttk.Button(self, text="Add Item", command=self._add_custom_item)
         custom_item_button.pack(side="left", expand=True, padx=5)
 
         import_inventory_button = ttk.Button(
@@ -231,7 +273,9 @@ class ConfigEditorButtonFrame(ttk.Frame):
     def _reset_config(self):
         """Reset the configuration file to its default state."""
         confirm = messagebox.askokcancel(
-            "Reset Config", "Are you sure you want to reset the configuration?", parent=self
+            "Reset Config",
+            "Are you sure you want to reset the configuration?",
+            parent=self.editor_frame,
         )
         if confirm:
             copy(CONFIG_FILE_BACKUP, CONFIG_FILE)
@@ -244,36 +288,48 @@ class ConfigEditorButtonFrame(ttk.Frame):
         """Open a window to add a new custom item."""
         custom_item_window = tk.Toplevel(self.editor_frame)
         custom_item_window.title(ADD_CUSTOM_ITEM_TITLE)
-        custom_item_window.geometry(ADD_CUSTOM_ITEM_SIZE)
+        custom_item_window.geometry(centered(custom_item_window, ADD_CUSTOM_ITEM_SIZE))
+        custom_item_window.minsize(*size_info(ADD_CUSTOM_ITEM_SIZE))
         custom_item_window.focus_set()
 
+        def on_close():
+            custom_item_window.destroy()
+            self.editor_frame.tree.focus_set()
+
+        custom_item_window.protocol("WM_DELETE_WINDOW", on_close)
+
         custom_item_frame = CustomItemFrame(custom_item_window, self.editor_frame)
         custom_item_frame.pack(expand=True, fill="both", padx=15, pady=15)
-        self.editor_frame.tree.focus_set()
 
     def _import_steam_inventory(self):
         """Open a window to import the user's Steam inventory."""
         steam_inventory_window = tk.Toplevel(self.editor_frame)
         steam_inventory_window.title(IMPORT_INVENTORY_TITLE)
-        steam_inventory_window.geometry(IMPORT_INVENTORY_SIZE)
+        steam_inventory_window.geometry(centered(steam_inventory_window, IMPORT_INVENTORY_SIZE))
+        steam_inventory_window.minsize(*size_info(IMPORT_INVENTORY_SIZE))
         steam_inventory_window.focus_set()
 
+        def on_close():
+            steam_inventory_window.destroy()
+            self.editor_frame.tree.focus_set()
+
+        steam_inventory_window.protocol("WM_DELETE_WINDOW", on_close)
+
         steam_inventory_frame = InventoryImportFrame(steam_inventory_window, self.editor_frame)
         steam_inventory_frame.pack(expand=True, fill="both", padx=15, pady=15)
-        self.editor_frame.tree.focus_set()
 
 
 class CustomItemFrame(ttk.Frame):
-    def __init__(self, parent, editor_frame):
+    def __init__(self, window, editor_frame):
         """Initialize the custom item frame that allows users to add custom items."""
-        super().__init__(parent, style="Card.TFrame", padding=15)
-        self.parent = parent
+        super().__init__(window, style="Card.TFrame", padding=15)
+        self.window = window
         self.editor_frame = editor_frame
         self._add_widgets()
 
     def _add_widgets(self):
         """Add widgets to the custom item frame for entering item details."""
-        ttk.Label(self, text="Item URL:").pack(pady=5)
+        ttk.Label(self, text="Steam Market Listing URL:").pack(pady=5)
         item_url_entry = ttk.Entry(self)
         item_url_entry.pack(fill="x", padx=10)
 
@@ -287,95 +343,115 @@ class CustomItemFrame(ttk.Frame):
             command=lambda: self._add_custom_item(item_url_entry.get(), item_owned_entry.get()),
         )
         add_button.pack(pady=10)
-        self.parent.bind("<Return>", lambda _: add_button.invoke())
+        self.window.bind("<Return>", lambda _: add_button.invoke())
+
+    def _update_existing(self, section, item_name, item_owned):
+        """
+        Try to update an item in the treeview with the new item details.
+
+        :return: True if the item was updated, False if it was not found.
+        """
+        for existing_item in self.editor_frame.tree.get_children(section):
+            existing_item_name = self.editor_frame.tree.item(existing_item, "text")
+            if item_name == existing_item_name:
+                self.editor_frame.tree.set(existing_item, column="#1", value=item_owned)
+                self.editor_frame.focus_set()
+                self.editor_frame.save_config()
+                self.window.destroy()
+                return True
+        return False
+
+    def _get_insert_index(self, item_name, section):
+        """Get the index to insert the new item in alphabetical order."""
+        insert_index = "end"
+        for existing_item_index, existing_item in enumerate(
+            self.editor_frame.tree.get_children(section)
+        ):
+            existing_item_name = self.editor_frame.tree.item(existing_item, "text")
+            if item_name < existing_item_name:
+                insert_index = existing_item_index
+                break
+        return insert_index
 
     def _add_custom_item(self, item_href, item_owned):
         """Add a custom item to the configuration."""
         if not item_href or not item_owned:
-            messagebox.showerror("Input Error", "All fields must be filled out.", parent=self)
-            self.editor_frame.focus_set()
-            self.parent.focus_set()
+            messagebox.showerror(
+                "Input Error", "All fields must be filled out.", parent=self.window
+            )
+            return
+        if config.option_exists(item_href, exclude_sections=("Stickers", "Skins")):
+            messagebox.showerror(
+                "Item Exists", "This item already exists in another section.", parent=self.window
+            )
             return
 
-        item_name = config.option_to_name(item_href, href=True)
+        try:
+            item_name = config.option_to_name(item_href, href=True)
+        except ValueError as error:
+            messagebox.showerror("Invalid URL", str(error), parent=self.window)
+            return
 
-        # Make sure not to reinsert custom items that have already been added
-        for option in self.editor_frame.tree.get_children("Custom Items"):
-            option_name = self.editor_frame.tree.item(option, "text")
-            if option_name == item_name:
-                self.editor_frame.tree.set(option, column="#1", value=item_owned)
-                self.editor_frame.focus_set()
-                self.editor_frame.save_config()
-                self.parent.destroy()
-                return
+        if self._update_existing("Stickers", item_name, item_owned):
+            return
+        if self._update_existing("Skins", item_name, item_owned):
+            return
 
+        section = "Stickers" if item_name.startswith("Sticker") else "Skins"
+        insert_index = self._get_insert_index(item_name, section)
         self.editor_frame.tree.insert(
-            "Custom Items",
-            "end",
+            section,
+            insert_index,
+            iid=f"{section}-{item_name}",
             text=item_name,
             values=[item_owned],
         )
-        self.editor_frame.focus_set()
         self.editor_frame.save_config()
-        self.parent.destroy()
+        self.window.destroy()
 
 
 class InventoryImportFrame(ttk.Frame):
     # pylint: disable=too-many-instance-attributes
-    def __init__(self, parent, editor_frame):
+    def __init__(self, window, editor_frame):
         """Initialize the inventory import frame that allows users to import their Steam
         inventory.
         """
-        super().__init__(parent, style="Card.TFrame", padding=10)
-        self.parent = parent
+        super().__init__(window, padding=10)
+        self.window = window
         self.editor_frame = editor_frame
         self._add_widgets()
 
     def _add_widgets(self):
         """Add widgets to the inventory import frame."""
-        self._configure_checkboxes()
-        self.storage_units_checkbox.pack(anchor="w", padx=20, pady=(15, 5))
-        self.regular_inventory_checkbox.pack(anchor="w", padx=20, pady=5)
-
-        self.import_cases_checkbox.pack(anchor="w", padx=20, pady=5)
-        self.import_sticker_capsules_checkbox.pack(anchor="w", padx=20, pady=5)
-        self.import_stickers_checkbox.pack(anchor="w", padx=20, pady=5)
-        self.import_others_checkbox.pack(anchor="w", padx=20, pady=5)
-
         self._configure_entries()
-        self.user_name_label.pack(pady=(20, 10))
-        self.user_name_entry.pack(fill="x", padx=50)
-        self.password_label.pack(pady=10)
-        self.password_entry.pack(fill="x", padx=50)
-        self.two_factor_label.pack(pady=10)
-        self.two_factor_entry.pack(fill="x", padx=50)
-
-        self.import_button = ttk.Button(
-            self, text="Import", command=self._import_inventory, state="disabled"
-        )
+        self.user_name_label.pack(pady=5)
+        self.user_name_entry.pack(fill="x", expand=True, padx=10)
+        self.password_label.pack(pady=5)
+        self.password_entry.pack(fill="x", expand=True, padx=10)
+        self.two_factor_label.pack(pady=5)
+        self.two_factor_entry.pack(fill="x", expand=True, padx=10)
         self.import_button.pack(pady=10)
-        self.parent.bind("<Return>", lambda _: self.import_button.invoke())
+        self.entry_frame.pack(side="left", padx=10, pady=(0, 20), fill="both", expand=True)
 
-        def form_complete(_):
-            if (
-                len(self.user_name_entry.get().strip()) > 0
-                and len(self.password_entry.get().strip()) > 0
-                and len(self.two_factor_entry.get().strip()) > 0
-            ):
-                self.import_button.configure(state="normal")
-            else:
-                self.import_button.configure(state="disabled")
-
-        self.parent.bind("<KeyRelease>", form_complete)
+        self._configure_checkboxes()
+        self.storage_units_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.regular_inventory_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.import_cases_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.import_sticker_capsules_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.import_stickers_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.import_others_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.checkbox_frame.pack(side="left", padx=10, pady=(0, 20), fill="both", expand=True)
 
     def _configure_checkboxes(self):
         # pylint: disable=attribute-defined-outside-init
         """Configure the checkboxes for selecting what to import from the Steam
         inventory.
         """
+        self.checkbox_frame = ttk.LabelFrame(self, text="Import Settings", padding=15)
+
         self.regular_inventory_value = tk.BooleanVar(value=False)
         self.regular_inventory_checkbox = ttk.Checkbutton(
-            self,
+            self.checkbox_frame,
             text="Regular Inventory",
             variable=self.regular_inventory_value,
             style="Switch.TCheckbutton",
@@ -383,7 +459,7 @@ class InventoryImportFrame(ttk.Frame):
 
         self.storage_units_value = tk.BooleanVar(value=True)
         self.storage_units_checkbox = ttk.Checkbutton(
-            self,
+            self.checkbox_frame,
             text="Storage Units",
             variable=self.storage_units_value,
             style="Switch.TCheckbutton",
@@ -391,12 +467,15 @@ class InventoryImportFrame(ttk.Frame):
 
         self.import_cases_value = tk.BooleanVar(value=True)
         self.import_cases_checkbox = ttk.Checkbutton(
-            self, text="Import Cases", variable=self.import_cases_value, style="Switch.TCheckbutton"
+            self.checkbox_frame,
+            text="Import Cases",
+            variable=self.import_cases_value,
+            style="Switch.TCheckbutton",
         )
 
         self.import_sticker_capsules_value = tk.BooleanVar(value=True)
         self.import_sticker_capsules_checkbox = ttk.Checkbutton(
-            self,
+            self.checkbox_frame,
             text="Import Sticker Capsules",
             variable=self.import_sticker_capsules_value,
             style="Switch.TCheckbutton",
@@ -404,7 +483,7 @@ class InventoryImportFrame(ttk.Frame):
 
         self.import_stickers_value = tk.BooleanVar(value=False)
         self.import_stickers_checkbox = ttk.Checkbutton(
-            self,
+            self.checkbox_frame,
             text="Import Stickers",
             variable=self.import_stickers_value,
             style="Switch.TCheckbutton",
@@ -412,7 +491,7 @@ class InventoryImportFrame(ttk.Frame):
 
         self.import_others_value = tk.BooleanVar(value=False)
         self.import_others_checkbox = ttk.Checkbutton(
-            self,
+            self.checkbox_frame,
             text="Import Other Items",
             variable=self.import_others_value,
             style="Switch.TCheckbutton",
@@ -423,14 +502,37 @@ class InventoryImportFrame(ttk.Frame):
         """Configure the entry fields for Steam username, password, and two-factor
         code.
         """
-        self.user_name_label = ttk.Label(self, text="Steam Username:")
-        self.user_name_entry = ttk.Entry(self, justify="center", font=("Helvetica", 11))
+        self.entry_frame = ttk.Frame(self, style="Card.TFrame", padding=15)
 
-        self.password_label = ttk.Label(self, text="Steam Password:")
-        self.password_entry = ttk.Entry(self, show="*", justify="center", font=("Helvetica", 11))
+        self.user_name_label = ttk.Label(self.entry_frame, text="Steam Username:")
+        self.user_name_entry = ttk.Entry(self.entry_frame, justify="center", font=("Helvetica", 11))
 
-        self.two_factor_label = ttk.Label(self, text="Steam Guard Code:")
-        self.two_factor_entry = ttk.Entry(self, justify="center", font=("Helvetica", 11))
+        self.password_label = ttk.Label(self.entry_frame, text="Steam Password:")
+        self.password_entry = ttk.Entry(
+            self.entry_frame, show="*", justify="center", font=("Helvetica", 11)
+        )
+
+        self.two_factor_label = ttk.Label(self.entry_frame, text="Steam Guard Code:")
+        self.two_factor_entry = ttk.Entry(
+            self.entry_frame, justify="center", font=("Helvetica", 11)
+        )
+
+        self.import_button = ttk.Button(
+            self.entry_frame, text="Import", command=self._import_inventory, state="disabled"
+        )
+
+        def check_form(_):
+            if (
+                len(self.user_name_entry.get().strip()) > 0
+                and len(self.password_entry.get().strip()) > 0
+                and len(self.two_factor_entry.get().strip()) > 0
+            ):
+                self.import_button.configure(state="normal")
+            else:
+                self.import_button.configure(state="disabled")
+
+        self.window.bind("<KeyRelease>", check_form)
+        self.window.bind("<Return>", lambda _: self.import_button.invoke())
 
     def _import_inventory(self):
         """
@@ -467,27 +569,36 @@ class InventoryImportFrame(ttk.Frame):
             ]
         )
 
-        self.parent.destroy()
+        self.window.destroy()
 
     def _display_node_subprocess(self, node_cmd):
-        text_window = tk.Toplevel(self.editor_frame)
-        text_window.title(IMPORT_INVENTORY_PROCESS_TITLE)
-        text_window.geometry(IMPORT_INVENTORY_PROCESS_SIZE)
-        text_window.focus_set()
+        console_window = tk.Toplevel(self.editor_frame)
+        console_window.title(IMPORT_INVENTORY_PROCESS_TITLE)
+        console_window.geometry(centered(console_window, IMPORT_INVENTORY_PROCESS_SIZE))
+        console_window.minsize(*size_info(IMPORT_INVENTORY_PROCESS_SIZE))
+        console_window.focus_force()
+
+        def on_close():
+            console_window.destroy()
+            config.read_from_inventory_file()
+            self.editor_frame.reload_config_into_tree()
+            self.editor_frame.tree.focus_set()
 
-        process_frame = InventoryImportProcessFrame(text_window, self.editor_frame)
+        console_window.protocol("WM_DELETE_WINDOW", on_close)
+
+        process_frame = InventoryImportProcessFrame(console_window, self.editor_frame)
         process_frame.pack(expand=True, fill="both", padx=15, pady=15)
-        process_frame.console.focus_set()
+        process_frame.console.focus_force()
         process_frame.start(node_cmd)
 
 
 class InventoryImportProcessFrame(ttk.Frame):
     # pylint: disable=attribute-defined-outside-init
     # Source: https://stackoverflow.com/questions/27327886/issues-intercepting-subprocess-output-in-real-time
-    def __init__(self, parent, editor_frame):
+    def __init__(self, window, editor_frame):
         """Initialize the frame that displays the output of the subprocess."""
-        super().__init__(parent)
-        self.parent = parent
+        super().__init__(window)
+        self.window = window
         self.editor_frame = editor_frame
         self._add_widgets()
 
@@ -498,6 +609,7 @@ class InventoryImportProcessFrame(ttk.Frame):
 
         self.console = ThemedText(self, wrap="word", yscrollcommand=self.scrollbar.set)
         self.console.config(state="disabled")
+        self.console.tag_configure("error", foreground="red")
         self.console.pack(expand=True, fill="both", padx=10, pady=10)
 
         self.scrollbar.config(command=self.console.yview)
@@ -531,14 +643,17 @@ class InventoryImportProcessFrame(ttk.Frame):
         try:
             line = self.queue.get(block=False)
             self.console.config(state="normal")
-            self.console.insert("end", line)
+            if "[ERROR]" in line:
+                self.console.insert("end", line, "error")
+            else:
+                self.console.insert("end", line)
             self.console.config(state="disabled")
             self.console.yview("end")
         except Empty:
             pass
 
         if self.process.poll() is None or not self.queue.empty():
-            self.after(50, self._update_lines)
+            self.after(35, self._update_lines)
         else:
             self._cleanup()
 
@@ -552,4 +667,4 @@ class InventoryImportProcessFrame(ttk.Frame):
         config.read_from_inventory_file()
         self.editor_frame.reload_config_into_tree()
         self.editor_frame.tree.focus_set()
-        self.parent.destroy()
+        self.window.destroy()

cs2tracker/app/history_frame.py

@@ -0,0 +1,61 @@
+from tkinter import ttk
+from typing import cast
+
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
+from matplotlib.dates import DateFormatter
+
+from cs2tracker.config import get_config
+from cs2tracker.logs import PriceLogs
+from cs2tracker.scraper.parser import Parser
+
+config = get_config()
+
+
+class PriceHistoryFrame(ttk.Frame):
+    # pylint: disable=attribute-defined-outside-init
+    def __init__(self, parent):
+        """Initialize the price history frame."""
+        super().__init__(parent)
+
+        self._add_widgets()
+
+    def _add_widgets(self):
+        """Add widgets to the frame."""
+        self._configure_canvas()
+        self.canvas.get_tk_widget().pack(fill="both", expand=True)
+
+        self.toolbar = NavigationToolbar2Tk(self.canvas, self)
+        self.toolbar.update()
+        self.toolbar.pack()
+
+    def _configure_canvas(self):
+        """Configure the canvas on which the price history chart is drawn."""
+        self._draw_plot()
+        plt.close(self.fig)
+
+        self.canvas = FigureCanvasTkAgg(self.fig, master=self)
+        self.canvas.draw()
+
+    def _draw_plot(self):
+        """Draw a chart of the price history."""
+
+        self.fig, ax_raw = plt.subplots(dpi=100)
+        self.fig.autofmt_xdate()
+        ax = cast(Axes, ax_raw)
+
+        dates, totals = PriceLogs.read()
+        for price_source in Parser.SOURCES:
+            usd_prices = totals[price_source]["USD"]
+            converted_prices = totals[price_source][config.conversion_currency]
+            ax.plot(dates, usd_prices, label=f"{price_source.name.title()}: USD")
+            ax.plot(
+                dates,
+                converted_prices,
+                label=f"{price_source.name.title()}: {config.conversion_currency}",
+            )
+
+        ax.legend(loc="upper left", fontsize="small")
+        date_formatter = DateFormatter("%Y-%m-%d")
+        ax.xaxis.set_major_formatter(date_formatter)