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

adjust open xml

Browse source
This commit is contained in:
Huy Pham 2019-10-29 09:04:16 -07:00
parent 5829e3ae42
commit 2a32a5b1a2
13 changed files with 277 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
coretk/coretk/app.py
View file

@ -1,6 +1,7 @@
import logging
import tkinter as tk
import coretk.appcache as appcache
import coretk.images as images
from coretk.coregrpc import CoreGrpc
from coretk.coremenubar import CoreMenubar
@ -13,6 +14,8 @@ from coretk.menuaction import MenuAction
class Application(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
appcache.cache_variable(self)
print(self.is_open_xml)
self.load_images()
self.setup_app()
self.menubar = None
@ -51,7 +54,7 @@ class Application(tk.Frame):
def create_widgets(self):
edit_frame = tk.Frame(self)
edit_frame.pack(side=tk.LEFT, fill=tk.Y, ipadx=2, ipady=2)
self.core_editbar = CoreToolbar(self.master, edit_frame, self.menubar)
self.core_editbar = CoreToolbar(self, edit_frame, self.menubar)
self.core_editbar.create_toolbar()
def draw_canvas(self):
@ -63,7 +66,7 @@ class Application(tk.Frame):
)
self.canvas.pack(fill=tk.BOTH, expand=True)
self.core_editbar.update_canvas(self.canvas)
self.core_editbar.canvas = self.canvas
scroll_x = tk.Scrollbar(
self.canvas, orient=tk.HORIZONTAL, command=self.canvas.xview

33
coretk/coretk/appcache.py Normal file
View file

@ -0,0 +1,33 @@
"""
stores some information helpful for setting starting values for some tables
like size and scale, set wallpaper, etc
"""
import tkinter as tk
def cache_variable(application):
# for menubar
application.is_open_xml = False
application.size_and_scale = None
application.set_wallpaper = None
# set wallpaper variables
# canvas id of the wallpaper
application.wallpaper_id = None
# current image for wallpaper
application.current_wallpaper = None
# wallpaper option
application.radiovar = tk.IntVar()
application.radiovar.set(1)
# show grid option
application.show_grid_var = tk.IntVar()
application.show_grid_var.set(1)
# adjust canvas to image dimension variable
application.adjust_to_dim_var = tk.IntVar()
application.adjust_to_dim_var.set(0)

13
coretk/coretk/coregrpc.py
View file

@ -190,7 +190,7 @@ class CoreGrpc:
logging.info("delete nodes %s", response)
def delete_links(self, delete_session=None):
sid = None
# sid = None
if delete_session is None:
sid = self.session_id
else:
@ -228,7 +228,6 @@ class CoreGrpc:
ip4=interface.ipv4,
ip4mask=interface.ip4prefix,
)
# if1 = core_pb2.Interface(id=id1, name=edge.interface_1.name, ip4=edge.interface_1.ipv4, ip4mask=edge.interface_1.ip4prefix)
logging.debug("create interface 1 %s", if1)
# interface1 = self.interface_helper.create_interface(id1, 0)
@ -241,15 +240,12 @@ class CoreGrpc:
ip4=interface.ipv4,
ip4mask=interface.ip4prefix,
)
# if2 = core_pb2.Interface(id=id2, name=edge.interface_2.name, ip4=edge.interface_2.ipv4, ip4mask=edge.interface_2.ip4prefix)
logging.debug("create interface 2: %s", if2)
# interface2 = self.interface_helper.create_interface(id2, 0)
# response = self.core.add_link(self.session_id, id1, id2, interface1, interface2)
response = self.core.add_link(self.session_id, id1, id2, if1, if2)
logging.info("created link: %s", response)
self.core.get_node_links(self.session_id, id1)
# self.core.get_node_links(self.session_id, id1)
# def get_session(self):
# response = self.core.get_session(self.session_id)
@ -283,10 +279,7 @@ class CoreGrpc:
"""
response = self.core.open_xml(file_path)
self.session_id = response.session_id
# print("Sessionz")
# self.core.events(self.session_id, self.log_event)
# return response.session_id
# logging.info("coregrpc.py open_xml()", type(response))
logging.debug("coreprgc.py open_xml(): %s", response.result)
def close(self):
"""

10
coretk/coretk/coremenubar.py
View file

@ -66,13 +66,11 @@ class CoreMenubar(object):
underline=0,
)
file_menu.add_command(label="Reload", command=action.file_reload, underline=0)
file_menu.add_command(
label="Save", command=action.file_save, accelerator="Ctrl+S", underline=0
)
# file_menu.add_command(
# label="Save", command=action.file_save, accelerator="Ctrl+S", underline=0
# )
# file_menu.add_command(label="Save As XML...", command=action.file_save_as_xml)
file_menu.add_command(
label="Save As XML...", command=self.menu_action.file_save_as_xml
)
file_menu.add_command(label="Save", command=self.menu_action.file_save_as_xml)
file_menu.add_separator()

45
coretk/coretk/coretoolbar.py
View file

@ -3,12 +3,11 @@ import tkinter as tk
from enum import Enum
from core.api.grpc import core_pb2
from coretk.coretoolbarhelp import CoreToolbarHelp
from coretk.graph import GraphMode
from coretk.images import ImageEnum, Images
from coretk.tooltip import CreateToolTip
# from coretk.graph_helper import WlanConnection
class SessionStateEnum(Enum):
NONE = "none"
@ -25,13 +24,14 @@ class CoreToolbar(object):
Core toolbar class
"""
def __init__(self, master, edit_frame, menubar):
def __init__(self, application, edit_frame, menubar):
"""
Create a CoreToolbar instance
:param tkinter.Frame edit_frame: edit frame
"""
self.master = master
self.application = application
self.master = application.master
self.edit_frame = edit_frame
self.menubar = menubar
self.radio_value = tk.IntVar()
@ -50,15 +50,6 @@ class CoreToolbar(object):
self.canvas = None
def update_canvas(self, canvas):
"""
Update canvas variable in CoreToolbar class
:param tkinter.Canvas canvas: core canvas
:return: nothing
"""
self.canvas = canvas
def destroy_previous_frame(self):
"""
Destroy any extra frame from previous before drawing a new one
@ -169,6 +160,7 @@ class CoreToolbar(object):
:return: nothing
"""
logging.debug("Click START STOP SESSION button")
helper = CoreToolbarHelp(self.application)
# self.destroy_children_widgets(self.edit_frame)
self.destroy_children_widgets()
self.canvas.mode = GraphMode.SELECT
@ -176,24 +168,29 @@ class CoreToolbar(object):
# set configuration state
state = self.canvas.core_grpc.get_session_state()
if state == core_pb2.SessionState.SHUTDOWN:
if state == core_pb2.SessionState.SHUTDOWN or self.application.is_open_xml:
self.canvas.core_grpc.set_session_state(SessionStateEnum.DEFINITION.value)
self.application.is_open_xml = False
self.canvas.core_grpc.set_session_state(SessionStateEnum.CONFIGURATION.value)
for node in self.canvas.grpc_manager.nodes.values():
self.canvas.core_grpc.add_node(
node.type, node.model, int(node.x), int(node.y), node.name, node.node_id
)
for edge in self.canvas.grpc_manager.edges.values():
self.canvas.core_grpc.add_link(
edge.id1, edge.id2, edge.type1, edge.type2, edge
)
helper.add_nodes()
helper.add_edges()
# for node in self.canvas.grpc_manager.nodes.values():
# print(node.type, node.model, int(node.x), int(node.y), node.name, node.node_id)
# self.canvas.core_grpc.add_node(
# node.type, node.model, int(node.x), int(node.y), node.name, node.node_id
# )
# print(len(self.canvas.grpc_manager.edges))
# for edge in self.canvas.grpc_manager.edges.values():
# print(edge.id1, edge.id2, edge.type1, edge.type2)
# self.canvas.core_grpc.add_link(
# edge.id1, edge.id2, edge.type1, edge.type2, edge
# )
self.canvas.core_grpc.set_session_state(SessionStateEnum.INSTANTIATION.value)
# self.canvas.core_grpc.get_session()
# self.application.is_open_xml = False
self.create_runtime_toolbar()
def click_link_tool(self):

31
coretk/coretk/coretoolbarhelp.py Normal file
View file

@ -0,0 +1,31 @@
"""
CoreToolbar help to draw on canvas, and make grpc client call
"""
class CoreToolbarHelp:
def __init__(self, application):
self.application = application
self.core_grpc = application.core_grpc
def add_nodes(self):
"""
add the nodes stored in grpc manager
:return: nothing
"""
grpc_manager = self.application.canvas.grpc_manager
for node in grpc_manager.nodes.values():
self.application.core_grpc.add_node(
node.type, node.model, int(node.x), int(node.y), node.name, node.node_id
)
def add_edges(self):
"""
add the edges stored in grpc manager
:return:
"""
grpc_manager = self.application.canvas.grpc_manager
for edge in grpc_manager.edges.values():
self.application.core_grpc.add_link(
edge.id1, edge.id2, edge.type1, edge.type2, edge
)

37
coretk/coretk/graph.py
View file

@ -43,7 +43,7 @@ class CanvasGraph(tk.Canvas):
self.core_grpc = grpc
self.grpc_manager = GrpcManager(grpc)
self.helper = GraphHelper(self)
self.helper = GraphHelper(self, grpc)
# self.core_id_to_canvas_id = {}
# self.core_map = CoreToCanvasMapping()
# self.draw_existing_component()
@ -61,7 +61,8 @@ class CanvasGraph(tk.Canvas):
:return:
"""
# delete any existing drawn items
self.delete_components()
# self.delete_components()
self.helper.delete_canvas_components()
# set the private variables to default value
self.mode = GraphMode.SELECT
@ -73,12 +74,14 @@ class CanvasGraph(tk.Canvas):
self.edges = {}
self.drawing_edge = None
print("graph.py create a new grpc manager")
self.grpc_manager = GrpcManager(new_grpc)
# new grpc
self.core_grpc = new_grpc
print("grpah.py draw existing component")
self.draw_existing_component()
print(self.grpc_manager.edges)
def setup_bindings(self):
"""
@ -130,6 +133,8 @@ class CanvasGraph(tk.Canvas):
for node in session.nodes:
# peer to peer node is not drawn on the GUI
if node.type != core_pb2.NodeType.PEER_TO_PEER:
# draw nodes on the canvas
image, name = Images.convert_type_and_model_to_image(
node.type, node.model
)
@ -138,7 +143,10 @@ class CanvasGraph(tk.Canvas):
)
self.nodes[n.id] = n
core_id_to_canvas_id[node.id] = n.id
# store the node in grpc manager
self.grpc_manager.add_preexisting_node(n, session_id, node, name)
self.grpc_manager.update_reusable_id()
# draw existing links
@ -165,6 +173,9 @@ class CanvasGraph(tk.Canvas):
self,
is_wired=False,
)
edge_token = tuple(sorted((n1.id, n2.id)))
e.token = edge_token
e.dst = n2.id
n1.edges.add(e)
n2.edges.add(e)
self.edges[e.token] = e
@ -195,8 +206,8 @@ class CanvasGraph(tk.Canvas):
)
# TODO will include throughput and ipv6 in the future
if1 = Interface(grpc_if1.name, grpc_if1.ip4)
if2 = Interface(grpc_if2.name, grpc_if2.ip4)
if1 = Interface(grpc_if1.name, grpc_if1.ip4, ifid=grpc_if1.id)
if2 = Interface(grpc_if2.name, grpc_if2.ip4, ifid=grpc_if2.id)
self.grpc_manager.edges[e.token].interface_1 = if1
self.grpc_manager.edges[e.token].interface_2 = if2
self.grpc_manager.nodes[
@ -207,14 +218,16 @@ class CanvasGraph(tk.Canvas):
].interfaces.append(if2)
# lift the nodes so they on top of the links
for i in core_id_to_canvas_id.values():
# for i in core_id_to_canvas_id.values():
# self.lift(i)
for i in self.find_withtag("node"):
self.lift(i)
def delete_components(self):
tags = ["node", "edge", "linkinfo", "nodename"]
for i in tags:
for id in self.find_withtag(i):
self.delete(id)
# def delete_components(self):
# tags = ["node", "edge", "linkinfo", "nodename"]
# for i in tags:
# for id in self.find_withtag(i):
# self.delete(id)
def canvas_xy(self, event):
"""
@ -237,7 +250,6 @@ class CanvasGraph(tk.Canvas):
:return: the item that the mouse point to
"""
overlapping = self.find_overlapping(event.x, event.y, event.x, event.y)
print(overlapping)
nodes = set(self.find_withtag("node"))
selected = None
for _id in overlapping:
@ -263,7 +275,6 @@ class CanvasGraph(tk.Canvas):
self.focus_set()
self.selected = self.get_selected(event)
logging.debug(f"click release selected: {self.selected}")
print(self.mode)
if self.mode == GraphMode.EDGE:
self.handle_edge_release(event)
elif self.mode == GraphMode.NODE:

15
coretk/coretk/graph_helper.py
View file

@ -7,13 +7,26 @@ import tkinter as tk
from core.api.grpc import core_pb2
from coretk.images import ImageEnum, Images
CANVAS_COMPONENT_TAGS = ["edge", "node", "nodename", "wallpaper", "linkinfo"]
class GraphHelper:
def __init__(self, canvas):
def __init__(self, canvas, grpc):
"""
create an instance of GraphHelper object
"""
self.canvas = canvas
self.core_grpc = grpc
def delete_canvas_components(self):
"""
delete the components of the graph leaving only the blank canvas
:return: nothing
"""
for tag in CANVAS_COMPONENT_TAGS:
for i in self.canvas.find_withtag(tag):
self.canvas.delete(i)
def draw_wireless_case(self, src_id, dst_id, edge):
src_node_name = self.canvas.nodes[src_id].node_type

19
coretk/coretk/grpcmanagement.py
View file

@ -160,13 +160,17 @@ class GrpcManager:
"""
Add preexisting nodes to grpc manager
:param str name: node_type
:param core_pb2.Node core_node: core node grpc message
:param coretk.graph.CanvasNode canvas_node: canvas node
:param int session_id: session id
:return: nothing
"""
# update the next available id
core_id = core_node.id
if core_id >= self.id:
print(core_id)
if self.id is None or core_id >= self.id:
self.id = core_id + 1
self.preexisting.append(core_id)
n = Node(
@ -198,12 +202,13 @@ class GrpcManager:
:return: nothing
"""
for i in range(1, self.id):
if i not in self.preexisting:
self.reusable.append(i)
if len(self.preexisting) > 0:
for i in range(1, self.id):
if i not in self.preexisting:
self.reusable.append(i)
self.preexisting.clear()
logging.debug("Next id: %s, Reusable: %s", self.id, self.reusable)
self.preexisting.clear()
logging.debug("Next id: %s, Reusable: %s", self.id, self.reusable)
def delete_node(self, canvas_id):
"""
@ -263,8 +268,6 @@ class GrpcManager:
edge.interface_1 = src_interface
edge.interface_2 = dst_interface
print(src_interface)
print(dst_interface)
return src_interface, dst_interface
def add_edge(self, session_id, token, canvas_id_1, canvas_id_2):

14
coretk/coretk/menuaction.py
View file

@ -37,8 +37,8 @@ def file_reload():
logging.debug("Click file Reload")
def file_save():
logging.debug("Click file save")
# def file_save():
# logging.debug("Click file save")
def file_save_shortcut(event):
@ -390,6 +390,7 @@ class MenuAction:
def file_open_xml(self):
logging.info("menuaction.py file_open_xml()")
self.application.is_open_xml = True
file_path = filedialog.askopenfilename(
initialdir=SAVEDIR,
title="Open",
@ -413,16 +414,19 @@ class MenuAction:
self.application.core_grpc = core_grpc
self.application.core_editbar.destroy_children_widgets()
self.application.core_editbar.create_runtime_toolbar()
self.application.core_editbar.create_toolbar()
# self.application.is_open_xml = False
# self.application.core_editbar.create_runtime_toolbar()
# self.application.canvas.draw_existing_component()
# t1 = time.clock()
# print(t1 - t0)
def canvas_size_and_scale(self):
SizeAndScale(self.application)
self.application.size_and_scale = SizeAndScale(self.application)
def canvas_set_wallpaper(self):
CanvasWallpaper(self.application)
self.application.set_wallpaper = CanvasWallpaper(self.application)
def help_core_github(self):
webbrowser.open_new("https://github.com/coreemu/core")

2
coretk/coretk/prev_saved_xml.txt
View file

@ -1,2 +0,0 @@
/home/ncs/Desktop/runningtest.xml
/home/ncs/Desktop/notrunning.xml

117
coretk/coretk/setwallpaper.py
View file

@ -14,6 +14,7 @@ WALLPAPER_DIR = os.path.join(PATH, "wallpaper")
class ScaleOption(enum.Enum):
NONE = 0
UPPER_LEFT = 1
CENTERED = 2
SCALED = 3
@ -22,15 +23,23 @@ class ScaleOption(enum.Enum):
class CanvasWallpaper:
def __init__(self, application):
"""
create an instance of CanvasWallpaper object
:param coretk.app.Application application: root application
"""
self.application = application
self.canvas = self.application.canvas
self.top = tk.Toplevel()
self.top.title("Set Canvas Wallpaper")
self.radiovar = tk.IntVar()
print(self.application.radiovar.get())
self.radiovar.set(self.application.radiovar.get())
self.show_grid_var = tk.IntVar()
self.show_grid_var.set(self.application.show_grid_var.get())
self.adjust_to_dim_var = tk.IntVar()
self.wallpaper = None
self.adjust_to_dim_var.set(self.application.adjust_to_dim_var.get())
self.create_image_label()
self.create_text_label()
@ -75,6 +84,11 @@ class CanvasWallpaper:
img_label.image = tk_img
def clear_link(self):
"""
delete like shown in image link entry if there is any
:return: nothing
"""
# delete entry
img_open_frame = self.top.grid_slaves(2, 0)[0]
filename_entry = img_open_frame.grid_slaves(0, 0)[0]
@ -115,10 +129,28 @@ class CanvasWallpaper:
b4 = tk.Radiobutton(f, text="titled", value=4, variable=self.radiovar)
b4.grid(row=0, column=3)
self.radiovar.set(1)
# self.radiovar.set(1)
f.grid()
def adjust_canvas_size(self):
# deselect all radio buttons and grey them out
if self.adjust_to_dim_var.get() == 1:
self.radiovar.set(0)
option_frame = self.top.grid_slaves(3, 0)[0]
for i in option_frame.grid_slaves():
i.config(state=tk.DISABLED)
# turn back the radio button to active state so that user can choose again
elif self.adjust_to_dim_var.get() == 0:
option_frame = self.top.grid_slaves(3, 0)[0]
for i in option_frame.grid_slaves():
i.config(state=tk.NORMAL)
self.radiovar.set(1)
else:
logging.error("setwallpaper.py adjust_canvas_size invalid value")
def additional_options(self):
b = tk.Checkbutton(self.top, text="Show grid", variable=self.show_grid_var)
b.grid(sticky=tk.W, padx=5)
@ -126,15 +158,21 @@ class CanvasWallpaper:
self.top,
text="Adjust canvas size to image dimensions",
variable=self.adjust_to_dim_var,
command=self.adjust_canvas_size,
)
b.grid(sticky=tk.W, padx=5)
self.show_grid_var.set(1)
self.adjust_to_dim_var.set(0)
def delete_previous_wallpaper(self):
prev_wallpaper = self.canvas.find_withtag("wallpaper")
if prev_wallpaper:
for i in prev_wallpaper:
def delete_canvas_components(self, tag_list):
"""
delete canvas items whose tag is in the tag list
:param list[string] tag_list: list of tags
:return: nothing
"""
for tag in tag_list:
for i in self.canvas.find_withtag(tag):
self.canvas.delete(i)
def get_canvas_width_and_height(self):
@ -159,6 +197,7 @@ class CanvasWallpaper:
return
def upper_left(self, img):
print("upperleft")
tk_img = ImageTk.PhotoImage(img)
# crop image if it is bigger than canvas
@ -178,7 +217,8 @@ class CanvasWallpaper:
# place left corner of image to the left corner of the canvas
self.application.croppedwallpaper = cropped_tk
self.delete_previous_wallpaper()
self.delete_canvas_components(["wallpaper"])
# self.delete_previous_wallpaper()
wid = self.canvas.create_image(
(cropx / 2, cropy / 2), image=cropped_tk, tags="wallpaper"
@ -213,7 +253,8 @@ class CanvasWallpaper:
# place the center of the image at the center of the canvas
self.application.croppedwallpaper = cropped_tk
self.delete_previous_wallpaper()
self.delete_canvas_components(["wallpaper"])
# self.delete_previous_wallpaper()
wid = self.canvas.create_image(
(canvas_w / 2, canvas_h / 2), image=cropped_tk, tags="wallpaper"
)
@ -231,7 +272,8 @@ class CanvasWallpaper:
image_tk = ImageTk.PhotoImage(resized_image)
self.application.croppedwallpaper = image_tk
self.delete_previous_wallpaper()
self.delete_canvas_components(["wallpaper"])
# self.delete_previous_wallpaper()
wid = self.canvas.create_image(
(canvas_w / 2, canvas_h / 2), image=image_tk, tags="wallpaper"
@ -241,11 +283,34 @@ class CanvasWallpaper:
def tiled(self, img):
return
def draw_new_canvas(self, canvas_width, canvas_height):
"""
delete the old canvas and draw a new one
:param int canvas_width: canvas width in pixel
:param int canvas_height: canvas height in pixel
:return:
"""
self.delete_canvas_components(["rectangle", "gridline"])
self.canvas.draw_grid(canvas_width, canvas_height)
def canvas_to_image_dimension(self, img):
image_tk = ImageTk.PhotoImage(img)
img_w = image_tk.width()
img_h = image_tk.height()
self.delete_canvas_components(["wallpaper"])
self.draw_new_canvas(img_w, img_h)
wid = self.canvas.create_image((img_w / 2, img_h / 2), image=image_tk)
self.application.croppedwallpaper = image_tk
self.application.wallpaper_id = wid
def show_grid(self):
"""
:return: nothing
"""
self.application.adjust_to_dim_var.set(self.adjust_to_dim_var.get())
if self.show_grid_var.get() == 0:
for i in self.canvas.find_withtag("gridline"):
self.canvas.itemconfig(i, state=tk.HIDDEN)
@ -256,28 +321,46 @@ class CanvasWallpaper:
else:
logging.error("setwallpaper.py show_grid invalid value")
def save_wallpaper_options(self):
self.application.radiovar.set(self.radiovar.get())
self.application.show_grid_var.set(self.show_grid_var.get())
self.application.adjust_to_dim_var.set(self.adjust_to_dim_var.get())
def click_apply(self):
img_link_frame = self.top.grid_slaves(2, 0)[0]
filename = img_link_frame.grid_slaves(0, 0)[0].get()
if not filename:
self.delete_canvas_components(["wallpaper"])
self.top.destroy()
self.application.current_wallpaper = None
self.save_wallpaper_options()
return
try:
img = Image.open(filename)
self.application.current_wallpaper = img
except FileNotFoundError:
print("invalid filename, draw original white plot")
if self.application.wallpaper_id:
self.canvas.delete(self.application.wallpaper_id)
self.top.destroy()
return
if self.radiovar.get() == ScaleOption.UPPER_LEFT.value:
self.upper_left(img)
elif self.radiovar.get() == ScaleOption.CENTERED.value:
self.center(img)
elif self.radiovar.get() == ScaleOption.SCALED.value:
self.scaled(img)
elif self.radiovar.get() == ScaleOption.TILED.value:
print("not implemented yet")
self.application.adjust_to_dim_var.set(self.adjust_to_dim_var.get())
if self.adjust_to_dim_var.get() == 0:
self.application.radiovar.set(self.radiovar.get())
if self.radiovar.get() == ScaleOption.UPPER_LEFT.value:
self.upper_left(img)
elif self.radiovar.get() == ScaleOption.CENTERED.value:
self.center(img)
elif self.radiovar.get() == ScaleOption.SCALED.value:
self.scaled(img)
elif self.radiovar.get() == ScaleOption.TILED.value:
print("not implemented yet")
elif self.adjust_to_dim_var.get() == 1:
self.canvas_to_image_dimension(img)
self.show_grid()
self.top.destroy()

22
coretk/coretk/sizeandscale.py
View file

@ -4,6 +4,8 @@ size and scale
import tkinter as tk
from functools import partial
from coretk.setwallpaper import ScaleOption
DRAW_OBJECT_TAGS = ["edge", "node", "nodename", "linkinfo", "antenna"]
@ -246,6 +248,26 @@ class SizeAndScale:
meter_per_pixel = float(scale_frame.grid_slaves(0, 1)[0].get()) / 100
self.application.canvas.meters_per_pixel = meter_per_pixel
self.redraw_grid(pixel_width, pixel_height)
print(self.application.current_wallpaper)
print(self.application.radiovar)
# if there is a current wallpaper showing, redraw it based on current wallpaper options
wallpaper_tool = self.application.set_wallpaper
current_wallpaper = self.application.current_wallpaper
if current_wallpaper:
if self.application.adjust_to_dim_var.get() == 0:
if self.application.radiovar.get() == ScaleOption.UPPER_LEFT.value:
wallpaper_tool.upper_left(current_wallpaper)
elif self.application.radiovar.get() == ScaleOption.CENTERED.value:
wallpaper_tool.center(current_wallpaper)
elif self.application.radiovar.get() == ScaleOption.SCALED.value:
wallpaper_tool.scaled(current_wallpaper)
elif self.application.radiovar.get() == ScaleOption.TILED.value:
print("not implemented")
elif self.application.adjust_to_dim_var.get() == 1:
wallpaper_tool.canvas_to_image_dimension(current_wallpaper)
wallpaper_tool.show_grid()
self.top.destroy()
def apply_cancel(self):