def pulse(sheet, stage=0):
try:
total_stages = 20
f = 1.0 * stage / total_stages
lightFontColour = shadeN([cs.background, cs.lightText], [0, 1],
cs.fontOpacity)
darkFontColour = shadeN([(1, 1, 1), cs.darkText], [0, 1],
cs.fontOpacity)
if stage <= total_stages:
sheetColour = shadeN([(1, 1, 1), cs.background], [0, 1], f)
textColour = shadeN([darkFontColour, lightFontColour], [0, 1], f)
sheet.configure(bg=toHex(sheetColour), fg=toHex(textColour))
if stage < total_stages:
t = threading.Timer(0.01, pulse, [sheet, stage + 1])
t.daemon = True
t.start()
except:
pass
def linkAdd(self, importance=1):
# see which link end is free to assign
if importance == 0:
#print "double click!"
self.parentSheet.resetLinkData()
#else:
# print "single click"
if self.parentSheet.linkA == -1:
self.parentSheet.linkA = self.index
self.parentSheet.linkImportance = importance #random.randint(1,2)
# hold circle colour
holdColour = shadeN([(1, 1, 1), self.cs.highlight2], [0, 3],
importance + 2)
if importance == 1:
self.canvas.itemconfig(self.smallCircleIndex,
fill=toHex(holdColour))
else:
self.canvas.itemconfig(self.smallCircleIndex,
fill=toHex(holdColour))
elif self.parentSheet.linkB == -1:
self.parentSheet.linkB = self.index
self.parentSheet.addLink()
def translateEthernet(self):
self.ethernet_header = self.packet[0:14]
self.eth = unpack('!6s6sH' , self.ethernet_header)
self.dst_mac = toHex(self.ethernet_header[0:6].decode("latin1"))
self.src_mac = toHex(self.ethernet_header[6:12].decode("latin1"))
#print stringToHex(self.src_mac)
#print self.dst_mac
string_print = 'Source MAC-Address : ' + str(self.src_mac)\
+ ' Destination MAC-Address : ' + str(self.dst_mac)
debug_print(string_print)
def init_pages():
global tk_sheets
# destroy any sheets in list so that we can update it (ex. after deletion)
for s in tk_sheets:
s.destroy()
font_colour = toHex(
shadeN([cs.background, cs.lightText], [0, 1], cs.fontOpacity))
tk_sheets = []
sheets_info = get_sheet_list()
for s in sheets_info:
s_box = tk.Label(tk_root,
text=s['name'],
font=settings.FONT,
bg=toHex(cs.background),
fg=font_colour,
cursor='hand1',
anchor=tk.CENTER)
s_box.bind(
'<Button-1>',
lambda event, filename=s['filename']: sheetClick(filename, event))
s_box.bind('<Button-3>',
lambda event, sheet=s: sheetRightClick(sheet, event))
s_box.bind('<Enter>',
lambda event, sheet=s_box: labelEnter(sheet, event))
s_box.bind('<Leave>',
lambda event, sheet=s_box: labelLeave(sheet, event))
tk_sheets.append(s_box)
s_box_plus = tk.Label(tk_root,
text='+',
font=settings.FONT,
bg=toHex(cs.background),
fg=font_colour,
cursor='hand1',
anchor=tk.CENTER)
s_box_plus.bind('<Button-1>', addFile)
s_box_plus.bind('<Enter>',
lambda event, sheet=s_box_plus: labelEnter(sheet, event))
s_box_plus.bind('<Leave>',
lambda event, sheet=s_box_plus: labelLeave(sheet, event))
tk_sheets.append(s_box_plus)
resize_layout()
def printMem(self, title: str, start: int, stop: int, step: int) -> None:
print(title)
for addr in range(start, stop, step):
print(f'\t{toHex(addr, length=4)}', end=' ')
for offset in range(step):
print(toHex(self.read(addr + offset)), end=' ')
print()
def addLink(self):
tA = self.linkA
tB = self.linkB
if tA == -1 or tB == -1:
print("ERROR: a link end not assigned")
if tA != tB and not self.hasLink(tA, tB):
self.links.append(
Link(self,
self.getThought(tA),
self.getThought(tB),
importance=self.linkImportance))
#print "Creating a link!"
# set circle colour back to white
TA = self.getThought(tA)
TA.canvas.itemconfig(TA.smallCircleIndex,
fill=toHex(self.cs.smallCircle))
# reset link assignments
self.resetLinkData()
self.lowerLinks()
def __init__(self, root, canvas, filename):
self.root = root
self.canvas = canvas
self.cs = cs.ColourScheme()
self.thoughts = []
self.links = []
self.canvas.bind("<Double-Button-1>", self.addAtCoord)
self.canvas.bind('<Button-1>', self.startDrag)
self.canvas.bind('<B1-Motion>', self.onDrag)
self.canvas.bind('<ButtonRelease-1>', self.endThoughtDrag)
self.root.bind('<Control-Key-s>', self.saveData)
self.canvas.bind('<4>', lambda event: self.zoom('in', event))
self.canvas.bind('<5>', lambda event: self.zoom('out', event))
self.canvas.configure(bg=toHex(self.cs.background))
self.curIndex = 0 #keep track of index most recently assigned (first thought=1)
self.filename = filename
self.imageList = []
self.initDrawing()
self.root.update()
self.resize()
self.loadFile()
def addFile(event=[]):
global sheets, addLabelGeom, tk_text
pixelX = tk_root.winfo_width()
pixelY = tk_root.winfo_height()
num = len(tk_sheets)
gridSide = int(math.ceil(math.sqrt(num)))
tk_text.focus()
fontSize = addLabelGeom[4]
tk_text.place(x=addLabelGeom[0],
y=addLabelGeom[1],
width=addLabelGeom[2],
height=addLabelGeom[3])
fontColour = toHex(shadeN([(1, 1, 1), cs.darkText], [0, 1],
cs.fontOpacity))
tk_text.configure(font=(settings.MAIN_FONT, fontSize, "normal"),
fg=fontColour,
bg="white")
tk_root.update()
def graphics_init(colour_scheme):
tk_root.title("MindMap Wrapper")
tk_root.geometry("{}x{}+{}+{}".format(settings.SCREEN_SIZE[0] // 2,
settings.SCREEN_SIZE[1] // 2,
settings.SCREEN_SIZE[0] // 4,
settings.SCREEN_SIZE[1] // 2))
tk_root.config(bg=toHex(colour_scheme.background))
def initDrawing(self):
# draw the save button
self.saveIcon, self.imageList = utils.loadImage(
filename=settings.SRC_DIR + "/icons/save.png",
size=(20, 20),
imageList=self.imageList,
root=self.root,
background=toHex(self.cs.background))
self.saveIcon.bind("<Button-1>", self.handleSavePress)
return
def initDrawing(self):
#self.canvasIndex = self.canvas.create_line(self.tA.pixLoc[0], self.tA.pixLoc[1],
# self.tB.pixLoc[0], self.tB.pixLoc[1],
# fill="white", width=5)
x0, y0, x1, y1 = self.getCoords()
#xb0,yb0,xb1,yb1 = self.getHeadCoords()
self.canvasIndex = self.add_to_layer(
self.importance,
self.canvas.create_line, (x0, y0, x1, y1),
fill=utils.toHex(self.colour),
activefill=utils.toHex(self.cs.highlight2),
width=int(self.z_width),
activewidth=5)
self.canvas.tag_bind(self.canvasIndex, '<Button-3>', self.remove)
#self.canvas.tag_bind(self.canvasIndex2, '<ButtonRelease-3>', self.endDrag)
self.grow()
def createTrainingsData():
inputs = []
targets = []
idx = 0
while idx < 10000:
redOfFirst = math.floor(random.random() * 255)
greenOfFirst = math.floor(random.random() * 255)
blueOfFirst = math.floor(random.random() * 255)
hex1 = ut.toHex(redOfFirst) + "" + ut.toHex(greenOfFirst) + "" + ut.toHex(blueOfFirst)
lum = 1
redOfSec = None
greenOfSec = None
blueOfSec = None
while lum < 4.5:
redOfSec = math.floor(random.random() * 255)
greenOfSec = math.floor(random.random() * 255)
blueOfSec = math.floor(random.random() * 255)
hex2 = ut.toHex(redOfSec) + "" + ut.toHex(greenOfSec) + "" + ut.toHex(blueOfSec)
lum = ut.calcLumin('#' + hex1, '#' + hex2)
inputs.append([redOfFirst / 255, greenOfFirst / 255, blueOfFirst / 255])
targets.append([redOfSec / 255, greenOfSec / 255, blueOfSec / 255])
idx += 1
return inputs, targets
def addLeave(event=[], stage=0):
#try:
total_stages = 20
f = 1.0 * stage / total_stages
if stage <= total_stages:
bgColour = shadeN([(1.0, 1.0, 1.0), cs.background], [0, 1], f)
textColour = shadeN([cs.darkText, cs.lightText], [0, 1], f)
fontColour = shadeN([bgColour, textColour], [0, 1], cs.fontOpacity)
tk_text.configure(fg=toHex(fontColour),
bg=toHex(bgColour)) #toHex(textColour))
if stage < total_stages:
t = threading.Timer(0.01, addLeave, [[], stage + 1])
t.daemon = True
t.start()
else:
tk_text.place(x=-1, y=-1, width=0, height=0)
tk_root.focus()
def pulse(self, stage=0):
#try:
total_stages = 20
f = 1.0 * stage / total_stages
if stage <= total_stages:
bkgColour = shadeN([
self.cs.background, self.cs.backgroundPulse, self.cs.background
], [0, 0.5, 1], f)
self.canvas.configure(bg=toHex(bkgColour))
if stage < total_stages:
t = threading.Timer(0.01, self.pulse, [stage + 1])
t.daemon = True
t.start()
#except:
# pass
def tcpSend(data): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((config.DTN_Address, config.DTN_TCPPort)) #s.setblocking(0) connectData = "dtn!" #magic part connectData += chr(03) #version connectData += chr(0) #flags connectData += chr(0)+chr(10) #keepalive connectData += sdnv.sdnv_encode(len(proxy_eid)) connectData += proxy_eid s.send(connectData) s.recv(1024) s.send(data) response = s.recv(1024) if len(response)>0: print "Response: "+toHex(response) s.close() pplpl()
def takeLog(self) -> None:
self.LOG['frames'] = self.frames
self.LOG['opcode'] = toHex(self.z80.opcode)
self.LOG['opname'] = self.z80.opname
self.LOG['arg0'] = toHex(self.z80.args[0])
self.LOG['arg1'] = toHex(self.z80.args[1])
self.LOG['PC'] = toHex(self.z80.PC, 4)
self.LOG['SP'] = toHex(self.z80.SP, 4)
self.LOG['A'] = toHex(self.z80.A)
self.LOG['B'] = toHex(self.z80.B)
self.LOG['C'] = toHex(self.z80.C)
self.LOG['D'] = toHex(self.z80.D)
self.LOG['E'] = toHex(self.z80.E)
self.LOG['F'] = toHex(self.z80.F)
self.LOG['H'] = toHex(self.z80.H)
self.LOG['L'] = toHex(self.z80.L)
if __name__ == "__main__":
cs = ColourScheme()
tk_root = tk.Tk()
graphics_init(cs)
tk_root.bind("<Configure>", resize_layout)
# create list of files on canvas
sheets = get_sheet_list()
tk_sheets = []
font_colour = toHex(
shadeN([cs.background, cs.lightText], [0, 1], cs.fontOpacity))
for s in sheets:
s_box = tk.Label(tk_root,
text=s['name'],
font=settings.FONT,
bg=toHex(cs.background),
fg=font_colour,
cursor='hand1',
anchor=tk.CENTER)
s_box.bind(
'<Button-1>',
lambda event, filename=s['filename']: sheetClick(filename, event))
s_box.bind('<Button-3>',
lambda event, sheet=s: sheetRightClick(sheet, event))
s_box.bind('<Enter>',
def labelEnter(sheet, event=[]):
sheet.configure(bg="white",
fg=toHex(
shadeN([(1, 1, 1), cs.darkText], [0, 1],
cs.fontOpacity)))
def pulse2(self, event=[], stage=0):
if self.pulsePause and stage == 0: return
if stage == 0:
if time.time() - self.prevPulseTime <= 1:
return
if self.colour == self.cs.def_thought: return
#if self.parentSheet.fastGraphics: return
canvasW = self.root.winfo_width()
canvasH = self.root.winfo_height()
if stage == 0:
self.canvas.tag_lower(self.pulseCircleIndex, "all")
#for i in range(self.numShadow):
# self.canvas.tag_raise(self.pulseCircleIndex, self.shadowCircleIndex[i])
total_stages = 10
f = 1.0 * stage / total_stages
r = self.z_r
# center of circle
x = 1.0 * canvasW * self.loc[0]
y = 1.0 * canvasH * self.loc[1]
#print "here"
if stage <= total_stages:
self.pulsePause = True
pRad = 40 * self.curZoom
curRad = r + f * pRad
x0p, y0p = x - curRad, y - curRad
x1p, y1p = x + curRad, y + curRad
fill = util.shadeN([self.colour, self.cs.def_thought], [0, 1], f)
self.canvas.coords(self.pulseCircleIndex, x0p, y0p, x1p, y1p)
self.canvas.itemconfig(self.pulseCircleIndex, fill=toHex(fill))
t = threading.Timer(0.04, self.pulse, [[], stage + 1])
t.daemon = True
t.start()
else:
offset = 0 #10*self.curZoom
rFrac = 0.5 #1.1
x0p, y0p = (x + offset) - r * rFrac, (
y + offset) - r * rFrac #x-r/2, y-r/2
x1p, y1p = (x + offset) + r * rFrac, (
y + offset) + r * rFrac #x+r/2, y+r/2
self.canvas.coords(self.pulseCircleIndex, x0p, y0p, x1p, y1p)
#self.canvas.itemconfig(self.pulseCircleIndex, fill = toHex(self.cs.lightGrey))
self.pulsePause = False
self.prevPulseTime = time.time()
def recolour(self, event=[]):
self.canvas.itemconfig(self.mainCircleIndex,
fill=toHex(self.colour),
outline=toHex(self.colour))
self.tk_text.configure(bg=toHex(self.colour))
def updateFont(self, fromZoom=False):
# dynamically optimize text colour
textColour = self.textColour
lum = utils.luminance(self.colour)
if lum >= 0.5:
#print "light background"
# 87% opacity for important black text on coloured background
textColour = shadeN([self.colour, self.cs.darkText], [0, 1],
self.cs.fontOpacity)
else:
#print "dark background"
#textColour=self.cs.lightText
textColour = shadeN([self.colour, self.cs.lightText], [0, 1],
self.cs.fontOpacity)
#if textColour != self.textColour:
self.textColour = textColour
insertbg = [
v * 0.5 + w * 0.5
for v, w in zip(self.textColour, self.cs.def_thought)
]
if not fromZoom:
self.tk_text.configure(fg=toHex(textColour),
insertbackground=toHex(insertbg))
if not fromZoom:
tags = list(self.tk_text.tag_names(index=None))
tags.remove("sel")
tags.remove("center")
for t in tags:
self.tk_text.tag_delete(t)
text = self.getText()
# check for bolding
fontThickness = "normal"
if '#B' in text:
fontThickness = "bold"
elif '#I' in text:
fontThickness = "italic"
self.tk_text.configure(font=(settings.MAIN_FONT,
int(self.z_fontSize // 1), fontThickness))
self.canvas.itemconfig(self.labelIndex,
font=(settings.MAIN_FONT,
max(1, int(self.z_labelFontSize // 1)),
"normal"))
if '#' not in text and '*' not in text:
return
pos = 1
LINES = text.splitlines()
for l in range(len(LINES)):
line = LINES[l]
#print "line: ", line
if line.strip() == "" or ('#' not in line and '*' not in line):
pos += 1
continue
fontSize = self.z_fontSize
if len(line) >= 2:
#if line[0:2] == '##':
if '##' in line:
fontSize = fontSize / 2
locLS = 0
locRS = len(line) - 1
# also colour each word by its importance
words = split2(line)
for W in words:
word = W[0]
wStart = W[1]
wEnd = W[2]
if W[0][0] == '#':
tagName = '%s.%s' % (pos, wStart) + 'WF'
self.tk_text.tag_add(tagName, '%s.%s' % (pos, wStart),
'%s.%s' % (pos, wStart + len(word)))
self.tk_text.tag_config(tagName,
font=(settings.MAIN_FONT,
int(self.z_fontSize // 2),
fontThickness))
elif W[0][0] == '*' and W[0][len(W[0]) - 1] == '*':
tagName = '%s.%s' % (pos, wStart) + 'BF'
self.tk_text.tag_add(tagName, '%s.%s' % (pos, wStart),
'%s.%s' % (pos, wStart + len(word)))
self.tk_text.tag_config(tagName,
font=(settings.MAIN_FONT,
int(fontSize // 1), "bold"))
else:
tagName = '%s.%s' % (pos, wStart) + 'norm'
self.tk_text.tag_add(tagName, '%s.%s' % (pos, wStart),
'%s.%s' % (pos, wStart + len(word)))
self.tk_text.tag_config(tagName,
font=(settings.MAIN_FONT,
int(fontSize // 1),
fontThickness))
pos += 1
def reDraw(self, init=False, r=-1, pixChange=False, fromZoom=False):
canvasW = self.root.winfo_width()
canvasH = self.root.winfo_height()
# r : radius of main circle
if init:
r = self.z_r
else:
if r == -1:
r = self.z_r
# prevent bubbles from moving when screen resized
if pixChange:
self.loc = (1.0 * self.pixLoc[0] / canvasW,
1.0 * self.pixLoc[1] / canvasH)
r = int(r)
# center of circle
x = 1.0 * canvasW * self.loc[0]
y = 1.0 * canvasH * self.loc[1]
self.pixLoc = (x, y)
'''
curTime = time.time()
draw = (curTime - self.prevDrawTime)>1./60
if draw or init:
self.prevDrawTime = curTime
else:
return
'''
'''
draw filled circle for pulse animation
'''
offset = 0 #10*self.curZoom
rFrac = 0.5 #1.1
x0p, y0p = (x + offset) - r * rFrac, (
y + offset) - r * rFrac #x-r/2, y-r/2
x1p, y1p = (x + offset) + r * rFrac, (
y + offset) + r * rFrac #x+r/2, y+r/2
if init:
fill = toHex(self.cs.lightGrey)
self.pulseCircleIndex = self.canvas.create_oval(x0p,
y0p,
x1p,
y1p,
fill=fill,
width=0,
activewidth=0,
tags="pulseCircle")
#self.canvas.tag_lower(self.pulseCircleIndex, "all")
else:
self.canvas.coords(self.pulseCircleIndex, x0p, y0p, x1p, y1p)
'''
draw main filled circle
'''
x0p, y0p = x - r, y - r
x1p, y1p = x + r, y + r
if init:
fill, outline = toHex(self.colour), toHex(self.cs.highlight2)
self.mainCircleIndex = self.canvas.create_oval(
x0p,
y0p,
x1p,
y1p,
fill=fill,
outline=fill,
activeoutline=outline,
width=2,
activewidth=2,
tags="mainCircle")
#self.canvas.itemconfigure("mainCircle", cursor="hand1")
else:
self.canvas.coords(self.mainCircleIndex, x0p, y0p, x1p, y1p)
'''
now create and draw text box
'''
if init:
self.tk_text = tk.Text(self.root,
bd=0,
highlightthickness=0,
wrap="word",
font=(settings.MAIN_FONT,
int(self.z_labelFontSize), "normal"),
bg=toHex(self.colour),
fg=toHex(self.cs.lightText))
self.tk_text.insert(tk.END, self.text) # set initial text
self.tk_text.tag_configure("center", justify='center')
self.tk_text.tag_add("center", 1.0, "end")
tr = (r * 0.7)
tx = x
ty = y
tx0p, ty0p = tx - tr, ty - tr
self.tk_text.place(x=tx0p, y=ty0p, width=2 * tr, height=2 * tr)
if fromZoom:
self.updateFont(fromZoom=True)
'''
draw ring around main filled circle
'''
ring1_r = r + int(self.z_ringSpacing[0])
x0p, y0p = x - ring1_r, y - ring1_r
x1p, y1p = x + ring1_r, y + ring1_r
if init:
outline = toHex(self.cs.ring1)
self.mainRingIndex = self.canvas.create_oval(
x0p,
y0p,
x1p,
y1p,
fill='',
outline=outline,
activeoutline=toHex(self.cs.highlight2),
width=self.z_ringWidths[0],
activewidth=self.z_ringWidths[0] * 2)
else:
self.canvas.coords(self.mainRingIndex, x0p, y0p, x1p, y1p)
if fromZoom:
self.canvas.itemconfig(self.mainRingIndex,
width=self.z_ringWidths[0],
activewidth=self.z_ringWidths[0] * 2)
''' draw text for times above ring '''
tx = x
ty = y - r - int(self.z_ringSpacing[0]) - 10 * self.curZoom
if init:
self.labelIndex = self.canvas.create_text(
tx,
ty,
text="",
font=(settings.MAIN_FONT, int(self.z_fontSize), "normal"),
fill=toHex(
shadeN([self.cs.background, self.cs.lightText], [0, 1],
0.54)))
self.canvas.coords(self.labelIndex, tx, ty)
#if fromZoom:
# self.updateFont(fromZoom=True)
'''
draw small circle on outer ring
'''
pRad = r + int(self.z_ringSpacing[0])
pa = pRad #*1.0/math.sqrt(2.0)
pb = math.sqrt(pRad * pRad - pa * pa)
s_x, s_y = x - pa, y + pb
s_r = int(self.z_smallRad)
x0p, y0p = s_x - s_r, s_y - s_r
x1p, y1p = s_x + s_r, s_y + s_r
if init:
outline, fill = toHex(self.cs.ring1), toHex(self.cs.smallCircle)
self.smallCircleIndex = self.canvas.create_oval(
x0p,
y0p,
x1p,
y1p,
fill=fill,
outline=outline,
width=0,
activefill=toHex(self.cs.highlight2))
else:
self.canvas.coords(self.smallCircleIndex, x0p, y0p, x1p, y1p)
''' draw circles under main circle for shadow '''
if init:
self.shadowCircleIndex = []
self.numShadow = 10
ns = 1.0 * self.numShadow
#reDraw = (time.time() - self.prevDrawTime)>0.1
for i in range(0, self.numShadow):
x_offset = 0
y_offset = self.z_height
rFrac = 1.0 + (1.0 + 0.01 * self.z_height) * (0.02 * i) * (
self.std_r / self.r)
x0p, y0p = (x + x_offset) - r * rFrac, (y + y_offset) - r * rFrac
x1p, y1p = (x + x_offset) + r * rFrac, (y + y_offset) + r * rFrac
if init:
fill = shadeN([self.cs.shadow, self.cs.background], [0, 1.0],
1.0 * math.sqrt(i / ns))
shadowIndex = self.canvas.create_oval(x0p,
y0p,
x1p,
y1p,
fill=toHex(fill),
width=0)
self.shadowCircleIndex.append(shadowIndex)
self.canvas.tag_lower(shadowIndex, "all")
else:
#if reDraw:
self.canvas.coords(self.shadowCircleIndex[i], x0p, y0p, x1p,
y1p)
