def default_window():
return {
"width": core.get_main_window_size()[0] + 20,
"height": core.get_main_window_size()[1] - 40,
"on_close": close_popup,
"x_pos": 0,
"y_pos": 0,
}
def __reset(self):
for x in range(0, self.__width):
for y in range(self.__height - 1, 0, -1):
tag = f"brick-{x}.{y}"
core.delete_draw_command("canvas", tag)
size = core.get_main_window_size()
core.configure_item("canvas", width=size[0], height=size[1])
xstep = size[0] / self.__width
# 60% of the board in "height" so we have some room
ystep = (size[1] * .4) / self.__height
self.__paddle = [size[0] * .475, size[1] * .85]
scaleX = 0.01
scaleY = 0.02
yOffset = 50
xOffset = 0
self.__speed = 300
self.__pos = (size[0] * .5, size[1] * .8, 0, -self.__speed)
self.__board = {}
for x in range(0, self.__width):
for y in range(self.__height - 1, 0, -1):
h = int(y / self.__height * 255)
color = (h, h, h)
x1 = int(x * xstep + xstep * scaleX) + xOffset
x2 = int((x + 1) * xstep - xstep * scaleX) + xOffset
y2 = int((y + 1) * ystep - ystep * scaleY) + yOffset
y1 = int(y * ystep + ystep * scaleY) + yOffset
core.draw_rectangle("canvas", (x1, y1), (x2, y2),
color,
fill=color,
tag=f"brick-{x}.{y}")
self.__board[(x, y)] = (x1, y1, x2, y2)
def main():
parser = argparse.ArgumentParser(
description="Winsnap: Snap windows into a customizable grid")
parser.add_argument("--debug",
action="store_true",
help="Show the log window")
args = parser.parse_args()
main_window = MainWindow()
def mouse_click_cb(sender, data):
main_window.refresh_windows()
def startup_cb(sender, data):
main_window.load()
dpg_core.set_mouse_click_callback(mouse_click_cb)
dpg_core.set_start_callback(startup_cb)
dpg_core.set_resize_callback(main_window.resize_callback,
handler="Main Window")
scale = ctypes.windll.shcore.GetScaleFactorForDevice(0) / 100
dpg_core.set_global_font_scale(scale)
w, h = dpg_core.get_main_window_size()
dpg_core.set_main_window_size(int(w * scale), int(h * scale))
dpg_core.set_main_window_title("WinSnap")
if args.debug:
dpg_core.show_logger()
dpg_core.start_dearpygui(primary_window="Main Window")
def __cbFractalDraw(self, pointArray: list):
color = [255, 255, 255, 255]
thickness = math.log(
40 / self.__iteration) * (5 / self.__fractal.dAngle)
size = core.get_main_window_size()
center = (size[0] * 0.5, size[1] * 0.5)
points = [(int(x[0] + center[0]), int(x[1] + center[1]))
for x in pointArray]
core.draw_polyline("Canvas", points, color, thickness=thickness)
def auto_center(sender, data):
# adjust the height of the body window on resize
# so that the scrolling works correctly
header_window_height = 100
window_height = dpg.get_main_window_size()[1]
body_window_height = window_height - header_window_height - 40 # 100 ~ dpgs.get_item_height('header window')
dpgs.set_item_height('body window', body_window_height)
# make the width header and body windows equal to the width of the main window
window_width = dpg.get_main_window_size()[
0] # dpgs.get_item_width('main window')
dpgs.set_item_width('header window', window_width)
dpgs.set_item_width('body window', window_width)
# align header
item_name = dpg.get_item_children("item-to-center")
item_width = dpgs.get_item_width('dearpygui logo') # 200
left = int(window_width / 2 - item_width / 2 - 23)
minimum_left_padding = 50
if left < minimum_left_padding:
left = minimum_left_padding
dpgs.set_item_width('left-spacer', left)
# space between columns
minimum_space_between_columns = 100
space_between_columns = int(window_width * 0.1)
if space_between_columns < minimum_space_between_columns:
space_between_columns = minimum_space_between_columns
dpgs.set_item_width('space between columns', space_between_columns)
dpgs.set_item_width('space between columns 2', space_between_columns)
dpgs.set_item_width('space between columns 3', space_between_columns)
# align body containing tiles
item_width = dpgs.get_item_width('Demo 1')
left = int(
((window_width - 1200 -
((space_between_columns - minimum_space_between_columns) / 2)) /
2)) # TO CORRECT FOR SPACE BETWEEN COLUMNS
minimum_left_padding = 50
if left < minimum_left_padding:
left = minimum_left_padding
dpgs.set_item_width("left-spacer-tiles", left)
def _resize(self):
"""."""
size = core.get_main_window_size()
width = int(size[0] / self.__rows * .98)
height = int(size[1] / self.__rows * .98)
ratio = float(size[0]) / size[1]
if size[1] > size[0]:
ratio = float(size[1]) / size[0]
self.__height = int(height * ratio * .575)
self.__width = width
self.__redraw()
def create_login():
#get main window size
window_size = core.get_main_window_size()
#Setup server status window size
status_width = 250
status_height = 150
#Setup login status
login_width = 300
login_height = 100
#Setup Positions for login
login_x = int((window_size[0] / 2) - ((login_width / 2) +
(status_width / 2)))
login_y = int((window_size[1] / 2) - ((login_height / 2) +
(status_height / 4)))
#Setup positions for status
status_x = int((window_size[0] / 2) - ((login_width / 2) -
(status_width / 2)))
status_y = int((window_size[1] / 2) - ((login_height / 2) +
(status_height / 2)))
#Setup Status
create_status(status_x, status_y)
#Build window size
with simple.window("login_window",
no_title_bar=True,
no_close=True,
no_resize=True,
autosize=True,
x_pos=login_x,
y_pos=login_y):
core.add_text("LOGIN")
core.add_input_text("login_input",
hint="auth key",
on_enter=True,
password=True,
label="")
core.add_text("login_error_text",
default_value=" ",
before="login_button")
core.add_button("login_button",
label="Login Button",
callback=request_login)
def __init__(self):
core.set_main_window_size(720, 540)
self.__width = 17
self.__height = 7
self.__total = self.__width * self.__height
self.__board = {}
size = core.get_main_window_size()
self.__paddle = [size[0] * .475, size[1] * .85]
self.__paddleSize = (80, 8)
# x, y, angle (rads), speed
self.__radius = 6
self.__speed = 300
self.__paddleSpeed = 1000
self.__speedMax = self.__speed * 3
self.__pos = (size[0] * .5, size[1] * .8, 0, -self.__speed)
with simple.window("main"):
with simple.group("scoreboard"):
core.add_label_text("score")
core.add_same_line()
core.add_text("score-value")
# core.add_same_line()
core.add_label_text("time")
core.add_same_line()
core.add_text("time-value")
core.add_drawing("canvas", width=size[0], height=size[1])
core.draw_circle("canvas",
size,
self.__radius, (255, 255, 255, 255),
fill=(128, 128, 128, 255),
tag="ball")
core.draw_rectangle("canvas", [
self.__paddle[0] - self.__paddleSize[0],
self.__paddle[1] - self.__paddleSize[1]
], [
self.__paddle[0] + self.__paddleSize[0],
self.__paddle[1] + self.__paddleSize[1]
], (255, 255, 255, 255),
fill=(128, 128, 128, 255),
tag="paddle")
core.set_resize_callback(self.__resize)
core.set_render_callback(self.__render)
core.set_key_down_callback(self.__keydown)
core.set_mouse_wheel_callback(self.__mousewheel)
def __render(self):
w = core.get_value("Width")
h = core.get_value("Height")
if w != self.__width or h != self.__height:
for i in range(self.__width, self.__width * self.__height):
core.delete_draw_command("Canvas", f"quad-{i}")
self.__width = w
self.__height = h
for i in range(self.__width, self.__width * self.__height):
core.draw_quad("Canvas", (0, 0), (0, 0), (0, 0), (0, 0), (0, 0, 0, 0), thickness=0, tag=f"quad-{i}")
self.__fire = [0] * (self.__height * self.__width)
for x in range(self.__width):
self.__fire[x + self.__width] = random.random() * 255
for y in range(self.__height - 1, 1, -1):
for x in range(self.__width):
i = y * self.__width + x
w2 = (x + self.__width) % self.__width
self.__fire[i] = math.floor((
self.__fire[(y - 1) * self.__width + w2] +
self.__fire[(y - 1) * self.__width + (x - 1 + self.__width) % self.__width] +
self.__fire[(y - 2) * self.__width + w2] +
self.__fire[(y - 1) * self.__width + (x + 1 + self.__width) % self.__width]) /
4.34)
ws, hs = core.get_main_window_size()
xScale = ws / self.__width
yScale = hs / self.__height
for i in range(self.__width, self.__width * self.__height):
kwarg = {}
x1 = (i % self.__width) * xScale
y1 = (self.__height - math.floor(i / self.__width)) * yScale
kwarg['p1'] = (x1, y1)
kwarg['p2'] = (x1 + xScale, y1)
kwarg['p3'] = (x1 + xScale, y1 + yScale)
kwarg['p4'] = (x1, y1 + yScale)
r = self.__fire[i]
g = int(self.__fire[i] * .2)
kwarg['color'] = (r, g, 0, 255)
kwarg['fill'] = (r, g, 0, 255)
core.modify_draw_command("Canvas", f"quad-{i}", **kwarg)
def __render(self):
delta = core.get_delta_time()
# offset everyone the delta amount
x, y, h, v = self.__pos
size = core.get_main_window_size()
x += (h * delta)
y += (v * delta)
x1 = x - self.__radius
x2 = x + self.__radius
y1 = y - self.__radius
y2 = y + self.__radius
# hit walls
if x1 <= 10 or x2 >= size[0] - 10:
h += (math.copysign(1, h) * 0.1 * self.__speed)
h *= -1
if y1 <= 50 or y2 >= size[1] - 100:
v += (math.copysign(1, v) * 0.1 * self.__speed)
v *= -1
# hit paddle....
if x > self.__paddle[0] - self.__paddleSize[0] and \
x < self.__paddle[0] + self.__paddleSize[0] and \
y > self.__paddle[1] - 1.5 * self.__paddleSize[1]:
v *= -1
# check bricks ??? all of them? ouch...
for k, rect in self.__board.items():
if x2 >= rect[0] and x1 <= rect[2] and y2 >= rect[
1] and y1 <= rect[3]:
px, py = k
core.delete_draw_command("canvas", f"brick-{px}.{py}")
del self.__board[k]
v *= -1
h += (math.copysign(1, h) * 0.1 * self.__speed)
break
core.modify_draw_command("canvas", "ball", center=[x, y])
v = min(self.__speedMax, max(-self.__speedMax, v))
h = min(self.__speedMax, max(-self.__speedMax, h))
self.__pos = (x, y, h, v)
def __init__(self, new_scan_click_callback: callable):
self._window_name: str = 'Hello Screen'
self._new_scan_click_callback: callable = new_scan_click_callback
main_window_size = core.get_main_window_size()
self._window_x_pos: int = int(main_window_size[0] / 2) - 200
self._window_y_pos: int = int(main_window_size[1] / 2) - 100
self._logo_full_path = get_resource_full_path('resources/logo.png')
with simple.window(self._window_name):
core.configure_item(self._window_name,
width=300,
height=250,
x_pos=self._window_x_pos,
y_pos=self._window_y_pos,
label='Welcome!')
core.add_text('Welcome to Duplicate Image Finder!')
core.add_text('Version: ' + get_version())
core.add_drawing(name='hello_screen_logo', width=100, height=100)
core.draw_image(drawing='hello_screen_logo',
file=self._logo_full_path,
pmin=[0, 0],
pmax=[100, 100],
uv_min=[0, 0],
uv_max=[1, 1],
tag="image")
core.add_button(name='start_new_scan_button',
label='Start New Scan',
callback=self._internal_new_scan_click_callback)
core.add_button(name='visit_source_page_button',
label='Visit Github source page',
callback=self._visit_source_page_click_callback)
def __move(self, direction):
x, y = self.__paddle
delta = core.get_delta_time()
x += direction * delta * self.__paddleSpeed
# bounds
size = core.get_main_window_size()
if x < self.__paddleSize[0]:
x = self.__paddleSize[0]
if x > size[0] - self.__paddleSize[0]:
x = size[0] - self.__paddleSize[0]
pmin = [
self.__paddle[0] - self.__paddleSize[0],
self.__paddle[1] - self.__paddleSize[1]
]
pmax = [
self.__paddle[0] + self.__paddleSize[0],
self.__paddle[1] + self.__paddleSize[1]
]
core.modify_draw_command("canvas", "paddle", pmin=pmin, pmax=pmax)
self.__paddle = (x, y)
def create_app():
#Add window
with simple.window("main_window"):
#Create Menu
menu.create_menu()
#Generalized styling
core.set_style_window_rounding(0.0)
#Setup Styling by finding main_window dimensions
raw_app_dimensions = core.get_main_window_size("main_window")
app_dimensions = Dimensions(0, 20, raw_app_dimensions[0], raw_app_dimensions[1] - 60)
#Look for a cleaner way to set this up?
output_dimensions = Dimensions(
x = 0,
y = 20,
width = 0.8 * app_dimensions.width,
height = 0.8 * app_dimensions.height
)
input_dimensions = Dimensions(
x = 0,
y = output_dimensions.y + output_dimensions.height,
width = output_dimensions.width,
height = app_dimensions.height - output_dimensions.height
)
#Add server input
server_input.create_server_input(input_dimensions)
#Add server output
server_output.create_server_output(output_dimensions)
#Create server connection
server_status.create_status(int(0.8 * app_dimensions.width), 20)
#Set the main_window to be primary
core.set_primary_window("main_window", True)
core.set_main_window_title("Circus Referee Console")
def __init__(self):
self._window_name: str = 'Scan in progress'
main_window_size = core.get_main_window_size()
self._window_x_pos: int = int(main_window_size[0] / 2) - 200
self._window_y_pos: int = int(main_window_size[1] / 2) - 100
with simple.window(self._window_name):
core.configure_item(self._window_name,
width=300,
height=200,
x_pos=self._window_x_pos,
y_pos=self._window_y_pos,
label='Scan in progress')
core.add_text('Scan in progress')
core.add_text('Number of scanned images: ')
core.add_same_line()
core.add_text('##number_of_scanned_images',
source=NUMBER_OF_SCANNED_IMAGES)
def __init__(self):
core.set_vsync(False)
core.set_style_window_padding(0, 0)
self.__iteration = 3
# load the data blob
root = path.dirname(path.realpath(__file__))
with open(f'{root}/fractal.json', 'r') as data:
self.__fractalData = OrderedDict(json.load(data))
self.__fractalKeys = [k for k in self.__fractalData.keys()]
d = self.__fractalKeys[0]
self.__fractal = Fractal(**self.__fractalData[d])
size = core.get_main_window_size()
with simple.window("MainWindow"):
with simple.group("Controls"):
core.add_input_int("Iteration",
width=120,
min_value=2,
max_value=40,
min_clamped=True,
max_clamped=True,
default_value=self.__iteration,
callback=self.__cbIterationValue)
simple.tooltip(
"Iteration",
"How many times to re-run the pattern parser with the \
previous runs output. Increasing this directly increases computation time."
)
with simple.group("Controls-Angle"):
core.add_input_float("Angle",
width=120,
default_value=self.__fractal.dAngle,
callback=self.__cbAngleValue)
simple.tooltip(
"Angle",
"Degrees the turtle will turn either positive or negative, when issued such commands."
)
core.add_same_line()
core.add_checkbox("AngleAnimate",
default_value=False,
label="Animate")
core.add_input_float("AngleStep",
width=120,
default_value=.002,
step=0.001,
step_fast=0.01)
simple.tooltip(
"AngleStep",
"Amount the animator will step through the angle.")
core.add_input_float("Length",
width=120,
default_value=self.__fractal.delta,
callback=self.__cbDeltaValue)
simple.tooltip(
"Length",
"Relative distance, forward or backward, the turtle will take when commanded."
)
core.add_same_line()
core.add_listbox("power",
label='',
items=self.__fractalKeys,
callback=self.__cbFractalType)
core.add_drawing("Canvas", width=size[0] * 2, height=size[1] * 2)
core.set_resize_callback(self.__resize)
core.set_render_callback(self.__render)
self.__refresh()
def get_size() -> Tuple[int, int]:
return tuple(dpgcore.get_main_window_size())
def main():
center_items = []
core.add_data('item_center_list', center_items)
with simple.window(TITLE):
with simple.menu_bar('##menu_bar'):
with simple.menu('File'):
# core.add_menu_item('Import', callback=None)
# core.add_menu_item('Export', callback=None)
with simple.menu('Theme'):
themes = ['Dark', 'Light', 'Classic', 'Dark 2', 'Grey', 'Dark Grey', 'Cherry', 'Purple', 'Gold', 'Red']
for theme in themes:
core.add_menu_item(theme, callback=menu.update_theme)
# core.add_menu_item('Exit', callback=None)
with simple.menu('About'):
core.add_menu_item('Version', callback=menu.show_version)
with simple.group('##input_group'):
# Title input
core.add_text('Title:')
core.add_input_text(TITLE_ID, hint='Enter title', width=WIDGET_WIDTH)
core.add_spacing(count=2)
# Identifier input
core.add_text('Identifier:')
core.add_input_text(IDENTIFIER_ID, hint='Enter identifier', width=WIDGET_WIDTH)
core.add_spacing(count=2)
# Password input
core.add_text('Password:'******'Enter password', width=WIDGET_WIDTH)
core.add_spacing(count=2)
# Note input
core.add_text('Note:')
core.add_input_text(NOTE_ID, hint='Enter note info', width=WIDGET_WIDTH)
core.add_spacing(count=10)
# Save button
save_clear_spacing = 50
core.add_button('##save', label='Save', callback=input_field.save_password, width=WIDGET_HALF_WIDTH - (save_clear_spacing // 2))
core.set_item_color('##save', core.mvGuiCol_Button, color=GREEN)
core.add_same_line(spacing=save_clear_spacing)
# Clear input entry button
core.add_button('##clear_input', label='Clear input', callback=input_field.clear_input, width=WIDGET_HALF_WIDTH - (save_clear_spacing // 2))
core.add_spacing(count=20)
with simple.group('##log_group'):
# Logger
core.add_logger('##log_message', auto_scroll_button=False, copy_button=False, filter=False, clear_button=False, width=WIDGET_WIDTH, height=80)
core.set_log_level(core.mvTRACE, logger='##log_message')
core.add_spacing(count=10)
# Clear log button
core.add_button('##clear_log', label='Clear log', callback=logger.clear_log, width=WIDGET_WIDTH)
core.add_spacing(count=10)
with simple.group('##password_table_group'):
# Password table
header = ['No', 'Title', 'Identifier', 'Password', 'Note']
core.add_table('##password_table', header, callback=table.table_printer, height=int(WINDOW_HEIGHT * 0.45), width=WIDGET_WIDTH)
core.add_spacing(count=10)
table.update_password_table()
# Update password table button
update_delete_spacing = 20
core.add_button('##update_table', label='Update table', callback=table.update_password_table, width=WIDGET_HALF_WIDTH - (update_delete_spacing // 2))
core.set_item_color('##update_table', core.mvGuiCol_Button, color=BLUE)
core.add_same_line(spacing=update_delete_spacing)
# Delete password table button
core.add_button('##delete_table', label='Delete table', width=WIDGET_HALF_WIDTH - (update_delete_spacing // 2))
core.set_item_color('##delete_table', core.mvGuiCol_Button, color=RED)
with simple.popup('##delete_table', '##ask_delete', mousebutton=core.mvMouseButton_Left, modal=True):
with simple.group('##delete_table_button_group'):
delete_table_spacing = 10
delete_table_half_width = core.get_main_window_size()[1] // 5 - delete_table_spacing
core.add_text('##delete_table_button', default_value='Are you sure to delete all data?')
core.add_spacing(count=delete_table_spacing)
core.add_button('##delete_table_button_yes', label='Yes', callback=table.delete_password_table, callback_data=True, width=delete_table_half_width)
core.add_same_line(spacing=delete_table_spacing)
core.add_button('##delete_table_button_no', label='No', callback=table.delete_password_table, callback_data=False, width=delete_table_half_width)
# TODO WONT WORK NEED TO FIX center_item FUNCTION
# center_item('##delete_table_button')
# center_item('##delete_table_button_yes')
# center_item('##delete_table_button_no')
# center_item('##delete_table_button_group')
if DEBUG_MODE:
# core.show_logger()
simple.show_debug()
# simple.show_documentation()
# Common Configuration
core.set_theme(DEFAULT_THEME)
core.add_additional_font(FONT, FONT_SIZE)
core.set_main_window_title(TITLE)
core.set_main_window_size(WINDOW_WIDTH, WINDOW_HEIGHT)
core.set_main_window_resizable(RESIZABLE)
core.set_style_window_padding(WINDOW_PADDING, WINDOW_PADDING)
core.set_exit_callback(model.close_connection)
# core.set_render_callback(apply_centering)
core.start_dearpygui(primary_window=TITLE)
def __resize(self):
width, _ = core.get_main_window_size()
core.configure_item('thread', width=width)
for b in self.__bars:
core.configure_item(b, width=width)
