afonso/core-extra
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

pygui: changes to support saving and loading canvas backgrounds to xml, canvas dimensions will apply globally

Browse source
This commit is contained in:
Blake Harnden 2020-12-17 12:25:11 -08:00
parent 5d436dd94d
commit 4a8f8557a6
7 changed files with 123 additions and 108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

140
daemon/core/gui/coreclient.py
View file

@ -40,17 +40,13 @@ from core.api.grpc.wrappers import (
SessionState, SessionState,
ThroughputsEvent, ThroughputsEvent,
) )
from core.gui import appconfig
from core.gui.appconfig import BACKGROUNDS_PATH, XMLS_PATH, CoreServer, Observer from core.gui.appconfig import BACKGROUNDS_PATH, XMLS_PATH, CoreServer, Observer
from core.gui.dialogs.emaneinstall import EmaneInstallDialog from core.gui.dialogs.emaneinstall import EmaneInstallDialog
from core.gui.dialogs.error import ErrorDialog from core.gui.dialogs.error import ErrorDialog
from core.gui.dialogs.mobilityplayer import MobilityPlayer from core.gui.dialogs.mobilityplayer import MobilityPlayer
from core.gui.dialogs.sessions import SessionsDialog from core.gui.dialogs.sessions import SessionsDialog
from core.gui.graph.edges import CanvasEdge from core.gui.graph.edges import CanvasEdge
from core.gui.graph.graph import CanvasGraph
from core.gui.graph.node import CanvasNode from core.gui.graph.node import CanvasNode
from core.gui.graph.shape import AnnotationData, Shape
from core.gui.graph.shapeutils import ShapeType
from core.gui.interface import InterfaceManager from core.gui.interface import InterfaceManager
from core.gui.nodeutils import NodeDraw, NodeUtils from core.gui.nodeutils import NodeDraw, NodeUtils
@ -326,59 +322,65 @@ class CoreClient:
def is_runtime(self) -> bool: def is_runtime(self) -> bool:
return self.session and self.session.state == SessionState.RUNTIME return self.session and self.session.state == SessionState.RUNTIME
def parse_metadata(self, canvas: CanvasGraph) -> None: def parse_metadata(self) -> None:
# canvas setting # canvas setting
config = self.session.metadata config = self.session.metadata
canvas_config = config.get("canvas") canvas_config = config.get("canvas")
logging.debug("canvas metadata: %s", canvas_config) logging.debug("canvas metadata: %s", canvas_config)
if canvas_config: if canvas_config:
canvas_config = json.loads(canvas_config) canvas_config = json.loads(canvas_config)
# get configured dimensions and gridlines option
dimensions = self.app.manager.default_dimensions
dimensions = canvas_config.get("dimensions", dimensions)
gridlines = canvas_config.get("gridlines", True) gridlines = canvas_config.get("gridlines", True)
self.app.canvas.show_grid.set(gridlines) self.app.manager.show_grid.set(gridlines)
fit_image = canvas_config.get("fit_image", False) self.app.manager.redraw_canvases(dimensions)
self.app.canvas.adjust_to_dim.set(fit_image)
wallpaper_style = canvas_config.get("wallpaper-style", 1) # get background configurations
self.app.canvas.scale_option.set(wallpaper_style) for background_config in canvas_config.get("canvases", []):
width = self.app.guiconfig.preferences.width canvas_id = background_config.get("id")
height = self.app.guiconfig.preferences.height if canvas_id is None:
dimensions = canvas_config.get("dimensions", [width, height]) logging.error("canvas config id not provided")
self.app.canvas.redraw_canvas(dimensions) continue
wallpaper = canvas_config.get("wallpaper") canvas = self.app.manager.get(canvas_id)
if wallpaper: fit_image = background_config.get("fit_image", False)
wallpaper = str(appconfig.BACKGROUNDS_PATH.joinpath(wallpaper)) wallpaper_style = background_config.get("wallpaper-style", 1)
canvas.set_wallpaper(wallpaper) wallpaper = background_config.get("wallpaper")
else: canvas.adjust_to_dim.set(fit_image)
canvas.redraw_canvas() canvas.scale_option.set(wallpaper_style)
canvas.set_wallpaper(None) logging.info("canvas config: %s", background_config)
if wallpaper:
wallpaper = str(BACKGROUNDS_PATH.joinpath(wallpaper))
canvas.set_wallpaper(wallpaper)
# load saved shapes # load saved shapes
shapes_config = config.get("shapes") # shapes_config = config.get("shapes")
if shapes_config: # if shapes_config:
shapes_config = json.loads(shapes_config) # shapes_config = json.loads(shapes_config)
for shape_config in shapes_config: # for shape_config in shapes_config:
logging.debug("loading shape: %s", shape_config) # logging.debug("loading shape: %s", shape_config)
shape_type = shape_config["type"] # shape_type = shape_config["type"]
try: # try:
shape_type = ShapeType(shape_type) # shape_type = ShapeType(shape_type)
coords = shape_config["iconcoords"] # coords = shape_config["iconcoords"]
data = AnnotationData( # data = AnnotationData(
shape_config["label"], # shape_config["label"],
shape_config["fontfamily"], # shape_config["fontfamily"],
shape_config["fontsize"], # shape_config["fontsize"],
shape_config["labelcolor"], # shape_config["labelcolor"],
shape_config["color"], # shape_config["color"],
shape_config["border"], # shape_config["border"],
shape_config["width"], # shape_config["width"],
shape_config["bold"], # shape_config["bold"],
shape_config["italic"], # shape_config["italic"],
shape_config["underline"], # shape_config["underline"],
) # )
shape = Shape( # shape = Shape(
self.app, self.app.canvas, shape_type, *coords, data=data # self.app, self.app.canvas, shape_type, *coords, data=data
) # )
canvas.shapes[shape.id] = shape # canvas.shapes[shape.id] = shape
except ValueError: # except ValueError:
logging.exception("unknown shape: %s", shape_type) # logging.exception("unknown shape: %s", shape_type)
# load edges config # load edges config
edges_config = config.get("edges") edges_config = config.get("edges")
@ -555,29 +557,35 @@ class CoreClient:
mobility_player.show() mobility_player.show()
def set_metadata(self) -> None: def set_metadata(self) -> None:
# TODO: handle metadata for multiple canvases
return
# create canvas data # create canvas data
wallpaper_path = None canvases = []
if self.app.canvas.wallpaper_file: for canvas in self.app.manager.canvases.values():
wallpaper = Path(self.app.canvas.wallpaper_file) wallpaper_path = None
if BACKGROUNDS_PATH == wallpaper.parent: if canvas.wallpaper_file:
wallpaper_path = wallpaper.name wallpaper = Path(canvas.wallpaper_file)
else: if BACKGROUNDS_PATH == wallpaper.parent:
wallpaper_path = str(wallpaper) wallpaper_path = wallpaper.name
canvas_config = { else:
"wallpaper": wallpaper_path, wallpaper_path = str(wallpaper)
"wallpaper-style": self.app.canvas.scale_option.get(), config = {
"gridlines": self.app.canvas.show_grid.get(), "id": canvas.id,
"fit_image": self.app.canvas.adjust_to_dim.get(), "wallpaper": wallpaper_path,
"dimensions": self.app.canvas.current_dimensions, "wallpaper-style": canvas.scale_option.get(),
} "fit_image": canvas.adjust_to_dim.get(),
}
canvases.append(config)
canvas_config = dict(
gridlines=self.app.manager.show_grid.get(),
dimensions=self.app.manager.current_dimensions,
canvases=canvases,
)
canvas_config = json.dumps(canvas_config) canvas_config = json.dumps(canvas_config)
# create shapes data # create shapes data
shapes = [] shapes = []
for shape in self.app.canvas.shapes.values(): # TODO: handle shapes being on multiple canvases
shapes.append(shape.metadata()) # for shape in self.app.canvas.shapes.values():
# shapes.append(shape.metadata())
shapes = json.dumps(shapes) shapes = json.dumps(shapes)
# create edges config # create edges config

10
daemon/core/gui/dialogs/canvassizeandscale.py
View file

@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
from core.gui import validation from core.gui import validation
from core.gui.dialogs.dialog import Dialog from core.gui.dialogs.dialog import Dialog
from core.gui.graph.graph import CanvasGraph from core.gui.graph.manager import CanvasManager
from core.gui.themes import FRAME_PAD, PADX, PADY from core.gui.themes import FRAME_PAD, PADX, PADY
if TYPE_CHECKING: if TYPE_CHECKING:
@ -22,9 +22,9 @@ class SizeAndScaleDialog(Dialog):
create an instance for size and scale object create an instance for size and scale object
""" """
super().__init__(app, "Canvas Size and Scale") super().__init__(app, "Canvas Size and Scale")
self.canvas: CanvasGraph = self.app.canvas self.manager: CanvasManager = self.app.manager
self.section_font: font.Font = font.Font(weight=font.BOLD) self.section_font: font.Font = font.Font(weight=font.BOLD)
width, height = self.canvas.current_dimensions width, height = self.manager.current_dimensions
self.pixel_width: tk.IntVar = tk.IntVar(value=width) self.pixel_width: tk.IntVar = tk.IntVar(value=width)
self.pixel_height: tk.IntVar = tk.IntVar(value=height) self.pixel_height: tk.IntVar = tk.IntVar(value=height)
location = self.app.core.session.location location = self.app.core.session.location
@ -189,9 +189,7 @@ class SizeAndScaleDialog(Dialog):
def click_apply(self) -> None: def click_apply(self) -> None:
width, height = self.pixel_width.get(), self.pixel_height.get() width, height = self.pixel_width.get(), self.pixel_height.get()
self.canvas.redraw_canvas((width, height)) self.manager.redraw_canvases((width, height))
if self.canvas.wallpaper:
self.canvas.redraw_wallpaper()
location = self.app.core.session.location location = self.app.core.session.location
location.x = self.x.get() location.x = self.x.get()
location.y = self.y.get() location.y = self.y.get()

3
daemon/core/gui/dialogs/canvaswallpaper.py
View file

@ -23,7 +23,7 @@ class CanvasWallpaperDialog(Dialog):
create an instance of CanvasWallpaper object create an instance of CanvasWallpaper object
""" """
super().__init__(app, "Canvas Background") super().__init__(app, "Canvas Background")
self.canvas: CanvasGraph = self.app.canvas self.canvas: CanvasGraph = self.app.manager.current()
self.scale_option: tk.IntVar = tk.IntVar(value=self.canvas.scale_option.get()) self.scale_option: tk.IntVar = tk.IntVar(value=self.canvas.scale_option.get())
self.adjust_to_dim: tk.BooleanVar = tk.BooleanVar( self.adjust_to_dim: tk.BooleanVar = tk.BooleanVar(
value=self.canvas.adjust_to_dim.get() value=self.canvas.adjust_to_dim.get()
@ -161,7 +161,6 @@ class CanvasWallpaperDialog(Dialog):
def click_apply(self) -> None: def click_apply(self) -> None:
self.canvas.scale_option.set(self.scale_option.get()) self.canvas.scale_option.set(self.scale_option.get())
self.canvas.adjust_to_dim.set(self.adjust_to_dim.get()) self.canvas.adjust_to_dim.set(self.adjust_to_dim.get())
self.canvas.show_grid.click_handler()
filename = self.filename.get() filename = self.filename.get()
if not filename: if not filename:
filename = None filename = None

27
daemon/core/gui/graph/graph.py
View file

@ -37,11 +37,12 @@ if TYPE_CHECKING:
from core.gui.graph.manager import CanvasManager from core.gui.graph.manager import CanvasManager
from core.gui.coreclient import CoreClient from core.gui.coreclient import CoreClient
ZOOM_IN = 1.1 ZOOM_IN: float = 1.1
ZOOM_OUT = 0.9 ZOOM_OUT: float = 0.9
ICON_SIZE = 48 ICON_SIZE: int = 48
MOVE_NODE_MODES = {GraphMode.NODE, GraphMode.SELECT} MOVE_NODE_MODES: Set[GraphMode] = {GraphMode.NODE, GraphMode.SELECT}
MOVE_SHAPE_MODES = {GraphMode.ANNOTATION, GraphMode.SELECT} MOVE_SHAPE_MODES: Set[GraphMode] = {GraphMode.ANNOTATION, GraphMode.SELECT}
BACKGROUND_COLOR: str = "#cccccc"
class CanvasGraph(tk.Canvas): class CanvasGraph(tk.Canvas):
@ -49,14 +50,15 @@ class CanvasGraph(tk.Canvas):
self, self,
master: tk.BaseWidget, master: tk.BaseWidget,
app: "Application", app: "Application",
canvas_manager: "CanvasManager", manager: "CanvasManager",
core: "CoreClient", core: "CoreClient",
_id: int, _id: int,
dimensions: Tuple[int, int],
) -> None: ) -> None:
super().__init__(master, highlightthickness=0, background="#cccccc") super().__init__(master, highlightthickness=0, background=BACKGROUND_COLOR)
self.id: int = _id self.id: int = _id
self.app: "Application" = app self.app: "Application" = app
self.manager: "CanvasManager" = canvas_manager self.manager: "CanvasManager" = manager
self.core: "CoreClient" = core self.core: "CoreClient" = core
self.selection: Dict[int, int] = {} self.selection: Dict[int, int] = {}
self.select_box: Optional[Shape] = None self.select_box: Optional[Shape] = None
@ -72,10 +74,7 @@ class CanvasGraph(tk.Canvas):
self.drawing_edge: Optional[CanvasEdge] = None self.drawing_edge: Optional[CanvasEdge] = None
self.rect: Optional[int] = None self.rect: Optional[int] = None
self.shape_drawing: bool = False self.shape_drawing: bool = False
width = self.app.guiconfig.preferences.width self.current_dimensions: Tuple[int, int] = dimensions
height = self.app.guiconfig.preferences.height
self.default_dimensions: Tuple[int, int] = (width, height)
self.current_dimensions: Tuple[int, int] = self.default_dimensions
self.ratio: float = 1.0 self.ratio: float = 1.0
self.offset: Tuple[int, int] = (0, 0) self.offset: Tuple[int, int] = (0, 0)
self.cursor: Tuple[int, int] = (0, 0) self.cursor: Tuple[int, int] = (0, 0)
@ -105,7 +104,7 @@ class CanvasGraph(tk.Canvas):
if self.rect is not None: if self.rect is not None:
self.delete(self.rect) self.delete(self.rect)
if not dimensions: if not dimensions:
dimensions = self.default_dimensions dimensions = self.manager.default_dimensions
self.current_dimensions = dimensions self.current_dimensions = dimensions
self.rect = self.create_rectangle( self.rect = self.create_rectangle(
0, 0,
@ -845,7 +844,7 @@ class CanvasGraph(tk.Canvas):
self.tag_raise(tag) self.tag_raise(tag)
def set_wallpaper(self, filename: Optional[str]) -> None: def set_wallpaper(self, filename: Optional[str]) -> None:
logging.debug("setting wallpaper: %s", filename) logging.info("setting canvas(%s) background: %s", self.id, filename)
if filename: if filename:
img = Image.open(filename) img = Image.open(filename)
self.wallpaper = img self.wallpaper = img

40
daemon/core/gui/graph/manager.py
View file

@ -52,6 +52,7 @@ class CanvasManager:
self.app.guiconfig.preferences.width, self.app.guiconfig.preferences.width,
self.app.guiconfig.preferences.height, self.app.guiconfig.preferences.height,
) )
self.current_dimensions: Tuple[int, int] = self.default_dimensions
self.show_node_labels: ShowVar = ShowVar(self, tags.NODE_LABEL, value=True) self.show_node_labels: ShowVar = ShowVar(self, tags.NODE_LABEL, value=True)
self.show_link_labels: ShowVar = ShowVar(self, tags.LINK_LABEL, value=True) self.show_link_labels: ShowVar = ShowVar(self, tags.LINK_LABEL, value=True)
self.show_links: ShowVar = ShowVar(self, tags.EDGE, value=True) self.show_links: ShowVar = ShowVar(self, tags.EDGE, value=True)
@ -92,6 +93,12 @@ class CanvasManager:
def all(self) -> ValuesView[CanvasGraph]: def all(self) -> ValuesView[CanvasGraph]:
return self.canvases.values() return self.canvases.values()
def get(self, canvas_id: int) -> CanvasGraph:
canvas = self.canvases.get(canvas_id)
if not canvas:
canvas = self.add_canvas(canvas_id)
return canvas
def add_canvas(self, canvas_id: int = None) -> CanvasGraph: def add_canvas(self, canvas_id: int = None) -> CanvasGraph:
# create tab frame # create tab frame
tab = ttk.Frame(self.notebook, padding=0) tab = ttk.Frame(self.notebook, padding=0)
@ -102,11 +109,12 @@ class CanvasManager:
canvas_id = self._next_id() canvas_id = self._next_id()
self.notebook.add(tab, text=f"Canvas {canvas_id}") self.notebook.add(tab, text=f"Canvas {canvas_id}")
unique_id = self.notebook.tabs()[-1] unique_id = self.notebook.tabs()[-1]
logging.info("tab(%s) is %s", unique_id, canvas_id)
self.unique_ids[unique_id] = canvas_id self.unique_ids[unique_id] = canvas_id
# create canvas # create canvas
canvas = CanvasGraph(tab, self.app, self, self.core, canvas_id) canvas = CanvasGraph(
tab, self.app, self, self.core, canvas_id, self.default_dimensions
)
canvas.grid(sticky=tk.NSEW) canvas.grid(sticky=tk.NSEW)
self.canvases[canvas_id] = canvas self.canvases[canvas_id] = canvas
@ -148,22 +156,15 @@ class CanvasManager:
self.annotation_type = None self.annotation_type = None
self.node_draw = None self.node_draw = None
if session.nodes: # draw session
self.draw_session(session) self.draw_session(session)
else:
self.add_canvas()
def draw_session(self, session: Session) -> None: def draw_session(self, session: Session) -> None:
# create session nodes # create session nodes
for core_node in session.nodes.values(): for core_node in session.nodes.values():
# get tab id for node # get tab id for node
canvas_id = core_node.canvas if core_node.canvas > 0 else 1 canvas_id = core_node.canvas if core_node.canvas > 0 else 1
canvas = self.get(canvas_id)
# get or create canvas
canvas = self.canvases.get(canvas_id)
if not canvas:
canvas = self.add_canvas(canvas_id)
# add node, avoiding ignored nodes # add node, avoiding ignored nodes
if NodeUtils.is_ignore_node(core_node.type): if NodeUtils.is_ignore_node(core_node.type):
continue continue
@ -185,8 +186,17 @@ class CanvasManager:
else: else:
logging.error("cant handle nodes linked between canvases") logging.error("cant handle nodes linked between canvases")
# TODO: handle metadata # parse metadata and organize canvases
# self.core.parse_metadata(canvas) self.core.parse_metadata()
# organize all canvases
for canvas in self.canvases.values(): for canvas in self.canvases.values():
canvas.organize() canvas.organize()
# create a default canvas if none were created prior
if not self.canvases:
self.add_canvas()
def redraw_canvases(self, dimensions: Tuple[int, int]) -> None:
for canvas in self.canvases.values():
canvas.redraw_canvas(dimensions)
if canvas.wallpaper:
canvas.redraw_wallpaper()

8
daemon/core/gui/graph/shape.py
View file

@ -85,7 +85,7 @@ class Shape:
fill=self.shape_data.fill_color, fill=self.shape_data.fill_color,
outline=self.shape_data.border_color, outline=self.shape_data.border_color,
width=self.shape_data.border_width, width=self.shape_data.border_width,
state=self.canvas.show_annotations.state(), state=self.app.manager.show_annotations.state(),
) )
self.draw_shape_text() self.draw_shape_text()
elif self.shape_type == ShapeType.RECTANGLE: elif self.shape_type == ShapeType.RECTANGLE:
@ -99,7 +99,7 @@ class Shape:
fill=self.shape_data.fill_color, fill=self.shape_data.fill_color,
outline=self.shape_data.border_color, outline=self.shape_data.border_color,
width=self.shape_data.border_width, width=self.shape_data.border_width,
state=self.canvas.show_annotations.state(), state=self.app.manager.show_annotations.state(),
) )
self.draw_shape_text() self.draw_shape_text()
elif self.shape_type == ShapeType.TEXT: elif self.shape_type == ShapeType.TEXT:
@ -111,7 +111,7 @@ class Shape:
text=self.shape_data.text, text=self.shape_data.text,
fill=self.shape_data.text_color, fill=self.shape_data.text_color,
font=font, font=font,
state=self.canvas.show_annotations.state(), state=self.app.manager.show_annotations.state(),
) )
else: else:
logging.error("unknown shape type: %s", self.shape_type) logging.error("unknown shape type: %s", self.shape_type)
@ -139,7 +139,7 @@ class Shape:
text=self.shape_data.text, text=self.shape_data.text,
fill=self.shape_data.text_color, fill=self.shape_data.text_color,
font=font, font=font,
state=self.canvas.show_annotations.state(), state=self.app.manager.show_annotations.state(),
) )
def shape_motion(self, x1: float, y1: float) -> None: def shape_motion(self, x1: float, y1: float) -> None:

3
daemon/core/gui/menubar.py
View file

@ -129,8 +129,9 @@ class Menubar(tk.Menu):
""" """
menu = tk.Menu(self) menu = tk.Menu(self)
menu.add_command(label="New", command=self.click_canvas_add) menu.add_command(label="New", command=self.click_canvas_add)
menu.add_command(label="Delete", command=self.click_canvas_delete)
menu.add_command(label="Size / Scale", command=self.click_canvas_size_and_scale) menu.add_command(label="Size / Scale", command=self.click_canvas_size_and_scale)
menu.add_separator()
menu.add_command(label="Delete", command=self.click_canvas_delete)
menu.add_command(label="Wallpaper", command=self.click_canvas_wallpaper) menu.add_command(label="Wallpaper", command=self.click_canvas_wallpaper)
self.add_cascade(label="Canvas", menu=menu) self.add_cascade(label="Canvas", menu=menu)