def __init__(self,main,app):
tk.Frame.__init__(self,main)
self.app = app
self.char = app.char
self.ewt00 = ImageTk.PhotoImage(file="img/ewt_00.png")
self.ewt05 = ImageTk.PhotoImage(file="img/ewt_05.png")
self.ewt10 = ImageTk.PhotoImage(file="img/ewt_10.png")
self.ewt20 = ImageTk.PhotoImage(file="img/ewt_20.png")
# this var holds the entry field ...
self.roll_var = tk.StringVar()
# setting up the frames
self.left_frame = tk.Frame(self)
self.ewt_frame = tk.Frame(self.left_frame)
self.showEWT(self.ewt_frame)
self.ewt_frame.pack()
self.roll_frame = tk.Frame(self.left_frame)
self.showRollFrame(self.roll_frame)
self.roll_frame.pack(fill=tk.X)
self.left_frame.pack(side=tk.LEFT)
self.result_frame = tk.Frame(self)
self.result_frame.pack(side=tk.LEFT, anchor=tk.N)
def __init__(self, main, col, row):
super().__init__()
self.minsize(250, 1)
self.main = main
main.open_windows["mod_ed"] = self
self.col = col
self.row = row
self.size = ""
# store widgets for access
self.widgets = {}
self.vars = {}
self.var_names = {}
self.page = main.template.find("page[@num='"+str(main.active_page)+"']")
self.module = None
self.space = self._checkLocation()
self.frame = tk.Frame(self)
if self.module is None:
self._newModule(self.frame)
else:
self._editModule(self.frame)
self.frame.pack(fill=tk.BOTH)
self.protocol("WM_DELETE_WINDOW", self.close)
def showContent(self, frame):
content_ids = self.item.get("content", "")
content_ids = content_ids.split(" ")
content_frame = tk.LabelFrame(frame, text=msg.IE_CONTENT)
for content_id in content_ids:
sub_item = self.char.getItemById(content_id)
if sub_item is not None:
sub_item_id = sub_item.get("id")
line = tk.Frame(content_frame)
label_text = sub_item.get("quantity") + "x - " + sub_item.get("name")
label = tk.Label(line, text=label_text)
label.bind(
"<Button-1>",
lambda event, load_item=sub_item:
self.close(load=load_item)
)
label.pack(side=tk.LEFT)
unpack_icon = ImageTk.PhotoImage(file="img/unpack.png")
unpack_button = tk.Button(line, image=unpack_icon)
unpack_button.image = unpack_icon
ToolTip(unpack_button, msg.IE_TT_UNPACK)
unpack_button.bind(
"<Button-1>",
lambda event, sub=sub_item, line_widget=line:
self.unpackItem(event, sub, line_widget)
)
unpack_button.pack(side=tk.RIGHT, anchor=tk.E)
line.pack(fill=tk.X, expand=1)
content_frame.pack(fill=tk.X, expand=1)
def getClipInfo(self, frame):
self.showContent(frame)
search = "option[@name='" + it.OPTION_CALIBER + "']"
caliber = self.item.find(search).get("value")
size = self.item.find("container").get("size")
items = self.getMatchingAmmo(caliber)
for item in items:
line = tk.Frame(frame)
item_id = item.get("id")
name_label = tk.Label(line, text=item.get("name"))
name_label.pack(side=tk.LEFT)
button_fill = tk.Button(line, text=msg.IE_FILL_CLIP)
button_fill.bind(
"<Button-1>",
lambda event, item=item:
self.loadRoundInClip(event, item, fill=True)
)
button_fill.pack(side=tk.RIGHT)
button_plus1 = tk.Button(line, text=msg.IE_ADD_ONE)
button_plus1.bind(
"<Button-1>",
lambda event, item=item:
self.loadRoundInClip(event, item, fill=False)
)
button_plus1.pack(side=tk.RIGHT)
line.pack()
def initialAccount(self, parent):
frame = tk.Frame(parent)
frame.columnconfigure(1, weight=100)
minus = ImageTk.PhotoImage(file="img/minus.png")
reduce_account = tk.Button(
frame, image=minus, command=lambda: self.updateInitialAccount(-1))
reduce_account.image = minus
img = ImageTk.PhotoImage(file="img/money.png")
account_label = tk.Label(
frame,
textvariable=self.account_info,
compound=tk.LEFT,
image=img,
)
account_label.image = img
account_label.grid(row=0, column=1)
plus = ImageTk.PhotoImage(file="img/plus.png")
increase_account = tk.Button(
frame, image=plus, command=lambda: self.updateInitialAccount(+1))
increase_account.image = plus
mode = self.char.getEditMode()
if mode == "generation":
reduce_account.grid(row=0, column=0)
increase_account.grid(row=0, column=2)
return frame
def __init__(self, main, app):
tk.Frame.__init__(self, main)
self.app = app
self.char = app.char
self.open_windows = app.open_windows
self.widgets = {}
self.template = None
self.grid = []
self.active_page = 1
self.pages = 0
self._getTemplate()
if self.template is None:
self.template = self._newTemplate()
self.pages = len(self.template.findall("page"))
# for display ..
self.cur_page = tk.StringVar()
page_label = "{page} / {pages}".format(page=str(self.active_page),
pages=str(self.pages))
self.cur_page.set(page_label)
self.page_frame = tk.Frame(self)
self.page_canvas = tk.Canvas(self.page_frame,
width=1,
height=1,
borderwidth=0,
highlightthickness=0,
relief=tk.FLAT,
bg="#ffffff")
self.page_canvas.pack(fill=tk.BOTH, expand=1)
self.page_canvas.bind("<Button-1>", self._editModule)
self.page_canvas.bind("<Configure>",
lambda event: self.showPage(self.page_canvas))
self.page_frame.pack(fill=tk.BOTH, expand=1)
self.control_frame = tk.Frame(self)
self.showControl(self.control_frame)
self._switchPage(0)
self.control_frame.pack(fill=tk.X)
def showEquippedItems(self):
canvas = self.equipped_canvas
# clear contents
canvas.delete(tk.ALL)
y = 0
# display weight ...
weight = tk.Label(canvas, text=self.updateWeight())
canvas.create_window(0, y, anchor=tk.NW, window=weight)
y += 25
# armor and clothing
armor_frame = tk.LabelFrame(canvas,
text=msg.ES_CLOTHING_ARMOR,
width=self.canvas_width)
lines = self.showEquippedClothing(armor_frame)
if lines > 1:
armor = canvas.create_window(
0,
y, # x, y
window=armor_frame,
anchor=tk.NW,
width=self.canvas_width)
self.update_idletasks()
y += armor_frame.winfo_height()
cyber_frame = tk.LabelFrame(canvas, text=msg.ES_BIOTECH, width=250)
lines = self.showEquippedBiotech(cyber_frame)
if lines > 1:
armor = canvas.create_window(
0,
y, # x, y
window=cyber_frame,
anchor=tk.NW,
width=self.canvas_width)
self.update_idletasks()
y += cyber_frame.winfo_height()
# carried bags
bags = self.char.getContainers()
for bag in bags:
bag_frame = tk.Frame(canvas)
self.showBagContents(bag, bag_frame)
canvas.create_window(
0,
y, # x, y
window=bag_frame,
anchor=tk.NW,
width=self.canvas_width)
self.update_idletasks()
y += bag_frame.winfo_height()
def __init__(self, app, contact):
tk.Toplevel.__init__(self, app)
self.app = app
self.app.open_windows["contact"] = self
self.char = app.char
self.contact = contact
self.vars = {}
self.xp_cost = tk.IntVar()
self.changes = []
self.main_screen = tk.Frame(self)
self.bottom_menu = tk.Frame(self)
self.showContact(self.main_screen)
self.showMenu(self.bottom_menu)
self.updateMenu(self.bottom_menu)
self.main_screen.pack(fill=tk.BOTH, anchor=tk.NW)
self.bottom_menu.pack(side=tk.BOTTOM, anchor=tk.S, fill=tk.X)
self.protocol("WM_DELETE_WINDOW", self.close)
def showBagContents(self, bag, frame):
bag_id = int(bag.get("id"))
# if no bag is the active bag - this bag becomes the active bag ...
if self.active_bag_id == -1:
self.active_bag_id = bag_id
bag_tag = bag.find("container")
bag_frame = tk.LabelFrame(frame, text=bag_tag.get("name"))
if self.active_bag_id == bag_id:
bag_frame.config(font=config.Style.BAG_LF_FONT, )
ToolTip(bag_frame, msg.ES_TT_ACTIVE_BAG)
else:
ToolTip(bag_frame, msg.ES_TT_INACTIVE_BAG)
# retrieve bag content and display ...
item_ids = bag.get("content")
if item_ids is not None:
entries = item_ids.split()
for item_id in entries:
item = self.char.getItemById(item_id)
if item is not None:
item_line = tk.Frame(bag_frame)
quantity_label = tk.Label(item_line,
text=item.get("quantity") +
msg.MULTIPLY)
quantity_label.pack(side=tk.LEFT)
item_label = tk.Label(item_line, text=item.get("name"))
item_label.bind("<Button-1>",
lambda event, id=item_id: self.
displayItemEditor(event, id))
item_label.pack(side=tk.LEFT, fill=tk.X, expand=1)
unpack_icon = ImageTk.PhotoImage(file="img/unpack.png")
item_unpack = tk.Button(item_line, image=unpack_icon)
ToolTip(item_unpack, msg.ES_TT_UNPACK)
item_unpack.image = unpack_icon
item_unpack.bind(
"<Button-1>",
lambda event, id=item_id: self.unpackItem(event, id))
item_unpack.pack(side=tk.RIGHT, anchor=tk.E)
item_line.pack(fill=tk.X, expand=1)
children = bag_frame.winfo_children()
# for empty bag ...
if not children:
tk.Label(bag_frame, text=" ").pack()
bag_frame.pack(fill=tk.BOTH, expand=1)
bag_frame.bind(
"<Button-1>",
lambda event, bag_id=bag_id: self.setActiveBag(event, bag_id))
def _newModule(self, frame):
tk.Label(frame, text=msg.ME_NEW).pack(fill=tk.X, expand=1)
mod_types = (
msg.PDF_ATTRIBUTES,
msg.PDF_TRAITS,
msg.PDF_SKILLS,
msg.PDF_EQUIPMENT,
msg.PDF_WEAPONS,
msg.PDF_CONTACTS,
msg.PDF_EWT,
msg.PDF_IMAGE,
msg.PDF_NOTES)
# this will be the frame for the option selection ...
selected_type = tk.StringVar()
selected_type.trace("w", self._modTypeChanged)
self.vars[str(selected_type)] = selected_type
self.var_names["module"] = str(selected_type)
select_button = tk.OptionMenu(
frame,
selected_type,
*mod_types)
selected_type.set(mod_types[0])
select_button.pack(fill=tk.X, expand=1)
row = str(self.row)
col = str(self.col)
id = str(self.main.getHighestModuleId()+1)
sub_frame = tk.Frame(frame)
self.widgets["options"] = option_frame = tk.Frame(sub_frame)
option_frame.pack(fill=tk.X)
selected_type.set(mod_types[0])
sub_frame.pack(fill=tk.BOTH, expand=1)
add_button = tk.Button(frame, text=msg.ME_ADD, command=self._addModule)
add_button.pack(fill=tk.X)
def __init__(self, app, item):
tk.Toplevel.__init__(self)
self.app = app
self.char = app.char
self.item = item
self.widgets = {}
self.item_name = item.get("name")
self.item_quantity = int(item.get("quantity", "1"))
self.item_price = float(item.get("price", "0"))
self.item_quality = int(item.get("quality","6"))
self.description_content = ""
self.protocol("WM_DELETE_WINDOW", self.close)
self.item_screen = tk.Frame(self)
self.item_title = tk.Frame(self.item_screen)
self.item_body = tk.Frame(self.item_screen)
self.item_title.pack(fill=tk.X, expand=1, anchor=tk.N)
self.item_body.pack(fill=tk.BOTH, expand=1, anchor=tk.N)
self.item_menu = tk.Frame(self)
self.item_screen.pack(
fill=tk.BOTH,
expand=1,
anchor=tk.NW
)
self.item_menu.pack(side=tk.BOTTOM, anchor=tk.SW, fill=tk.X)
self.setMinHeight()
# important variables:
self.split_number = tk.IntVar()
self.destroy_check = 0
self.some_item_id = -1
self._showItemInfo()
self.addMenuIcons()
self.update_idletasks()
self.minsize(self.winfo_reqwidth(), self.winfo_reqheight())
def showEquippedMelee(self, canvas):
""" show the equipped melee weapons
canvas: tk.Canvas - where to display the stuff ...
"""
# clear the frame
canvas.delete(tk.ALL)
# get the items
items = self.char.getItems()
y = 0
for item in items:
if item.get("equipped", "0") == "1":
item_type = item.get("type")
weapons = [
it.CLUB, it.BLADE, it.STAFF, it.OTHER_MELEE, it.TOOLS,
it.NATURAL
]
if item_type in weapons:
item_name = item.get("name")
item_id = item.get("id")
damage = item.find("damage")
if damage is not None:
damage_value = damage.get("value")
item_frame = tk.Frame(canvas,
borderwidth=2,
relief=tk.RIDGE)
name_label = tk.Label(item_frame, text=item_name)
name_label.bind("<Button-1>",
lambda event, item_id=item_id: self.
displayItemEditor(event, item_id))
name_label.pack(side=tk.LEFT)
damage_label = tk.Label(item_frame, text=damage_value)
damage_label.pack(side=tk.RIGHT, anchor=tk.E)
canvas.create_window(
0,
y, # x, y
window=item_frame,
anchor=tk.NW,
width=self.canvas_width)
self.update_idletasks()
y += item_frame.winfo_height()
def getBiotechInfo(self, frame, item_type):
implanted = int(self.item.get("equipped", "0"))
inside = self.item.get("inside", "-1")
if inside != -1:
parent = self.char.getItemById(inside)
if parent is not None:
name = parent.get("name")
parent_type = parent.get("type")
if parent_type in [it.IMPLANT, it.PROSTHESIS]:
if item_type == it.PROSTHESIS:
status = msg.IE_ATTACHED_TO
else:
status = msg.IE_BUILT_INTO
label = tk.Label(
frame,
text=status+name
)
label.bind(
"<Button-1>",
lambda item=parent:
self.close(load=parent)
)
label.pack()
content = self.item.get("content", "")
if content != "":
content_list = content.split()
else:
content_list = []
content_frame = tk.LabelFrame(frame, text=msg.IE_IMPLANT_ADDONS)
for item_id in content_list:
sub_item = self.char.getItemById(item_id)
if sub_item is not None:
item_frame = tk.Frame(content_frame)
sub_name = sub_item.get("name")
sub_type = sub_item.get("type")
label = tk.Label(
item_frame,
text=sub_name
)
label.bind(
"<Button-1>",
lambda event, sub_item=sub_item:
self.close(load=sub_item)
)
label.pack(side=tk.LEFT, anchor=tk.W)
button = tk.Button(
item_frame,
text=msg.IE_UNEQUIP,
command=lambda sub_item=sub_item:
self.unpackProsthesis(sub_item)
)
if sub_type == it.PROSTHESIS:
button.pack(side=tk.RIGHT, anchor=tk.E)
item_frame.pack(fill=tk.X)
if content_list:
content_frame.pack(fill=tk.X)
if item_type != it.IMPLANT_PART:
add_ons = (self.char.getItems(item_type=it.IMPLANT_PART)
+ self.char.getItems(item_type=it.PROSTHESIS))
for sub_item in add_ons:
inside = sub_item.get("inside", "-1")
sub_id = sub_item.get("id")
if (inside != "-1"
or self.item.get("id") in sub_item.get("content", "").split()
or sub_id == self.item.get("id")
):
continue
sub_name = sub_item.get("name")
if sub_id not in content_list:
sub_frame = tk.Frame(frame)
label = tk.Label(
sub_frame,
text=sub_name
)
label.pack(side=tk.LEFT, anchor=tk.W)
button = tk.Button(
sub_frame,
text="einbauen",
command=lambda sub_item=sub_item:
self.packItem(sub_item)
)
button.pack(side=tk.RIGHT, anchor=tk.E)
sub_frame.pack(fill=tk.X)
if item_type == it.IMPLANT and not implanted:
tk.Button(
frame,
text=msg.IE_IMPLANT,
command=self.equipItem
).pack(fill=tk.X)
items = self.char.getItems(item_type=it.IMPLANT_PART)
for item in items:
pass
def updateSkillList(self):
""" Render the contents of the skill lists """
width = self.active_skill_canvas.winfo_width()
if width < 2:
return
# retrieve edit mode once ...
edit_mode = self.char.getEditMode()
# clear the canvas ...
self.active_skill_canvas.delete(tk.ALL)
self.passive_skill_canvas.delete(tk.ALL)
# sort the skills
self.char.sortSkills()
# add entries to the lists ...
active_count = 0
passive_count = 0
skills = self.char.getSkills()
for skill in skills:
# decide which side this skill goes to ...
skill_type = skill.get("type")
if skill_type == "active":
canvas = self.active_skill_canvas
active_count += 1
y_pos = (active_count - 1)
else:
canvas = self.passive_skill_canvas
passive_count += 1
y_pos = (passive_count - 1)
skill_frame = tk.Frame(canvas)
# get skill name and specialization - set font accordingly
skill_text = skill.get("name")
skill_font = ""
skill_spec = int(skill.get("spec", "2"))
if skill_spec == 1:
skill_font = "Arial 10 bold"
elif skill_spec == 2:
skill_font = "Arial 10"
elif skill_spec == 3:
skill_font = "Arial 10 italic"
# creating a IntVar() and linking tcl variable name to skill_name
value_var = self.char.skill_values[skill_text] = tk.IntVar()
self.char.skill_trace[str(value_var)] = skill_text
# retrieve the current value
skill_value = int(skill.get("value"))
value_var.set(skill_value)
# how to display the value (spinbox / value+button / only value)
if edit_mode == cd.GENERATION:
# adding a trace to the variable
value_var.trace("w", self.char.skillChange)
# use a spinbox to move skill up and down
value_spinner = tk.Spinbox(skill_frame,
from_=0,
to=3,
textvariable=value_var,
width=2,
font="Arial 10 bold")
# or a button just to increase skill
plus = ImageTk.PhotoImage(file="img/plus_s.png")
value_button = self.widgets[skill_text + "_inc"] = tk.Label(
skill_frame,
image=plus,
)
value_button.image = plus
value_button.bind(
"<Button-1>",
lambda event, canvas=canvas, skill_text=skill_text: self.
increaseSkill(skill_text, canvas))
value_text = self.char.skill_values[skill_text].get()
self.widgets[skill_text] = value_label = tk.Label(
skill_frame,
font=config.Style.SKILL_FONT,
textvariable=value_var)
# render the line to the canvas
height = 24
# background
background = None
if y_pos % 2 == 0:
background = "#ddddff"
name_label = tk.Label(skill_frame,
text=skill_text,
font=skill_font,
anchor=tk.W)
if background:
name_label.config(background=background)
value_label.config(background=background)
value_button.config(background=background)
name_label.bind(
"<Button-1>",
lambda event, name=skill_text: self.showSkillInfo(name))
skill_frame.columnconfigure(0, weight=100)
if edit_mode == cd.GENERATION:
skill_frame.columnconfigure(0, weight=100)
name_label.grid(row=0, column=0, sticky=tk.NSEW)
value_spinner.grid(row=0, column=1, sticky=tk.NSEW)
elif edit_mode == cd.EDIT:
name_label.grid(row=0, column=0, sticky=tk.NSEW)
value_label.grid(row=0, column=1, sticky=tk.NSEW)
value_button.grid(row=0, column=2, sticky=tk.NSEW)
else:
name_label.grid(row=0, column=0, sticky=tk.NSEW)
value_label.grid(row=0, column=1, sticky=tk.NSEW)
canvas.create_window(0,
y_pos * height,
width=width,
height=height,
anchor=tk.NW,
window=skill_frame)
self.update_idletasks()
# set scroll regions based on content
self.active_skill_canvas.config(
scrollregion=self.active_skill_canvas.bbox("all"))
self.passive_skill_canvas.config(
scrollregion=self.passive_skill_canvas.bbox("all"))
def getPistolInfo(self, frame):
chambered_id = self.item.find("ammo").get("loaded", "-1")
chambered_item = self.char.getItemById(str(chambered_id))
first_round = None
chamber_frame = tk.LabelFrame(frame, text=msg.IE_LOADED)
chamber_frame.pack(fill=tk.X, expand=1)
if chambered_item is not None:
chamber_info = tk.Label(
chamber_frame,
text=chambered_item.get("name")
)
chamber_info.pack(fill=tk.X, expand=1)
else:
chamber_frame.config(text=msg.IE_NOT_LOADED)
loaded_clip = None
content = self.item.get("content", "-1").split()
for item_id in content:
item = self.char.getItemById(item_id)
if item is not None:
if item.get("type") == it.CLIP:
loaded_clip = item
break
if loaded_clip is None:
label = tk.Label(
frame,
text=msg.IE_NO_CLIP_LOADED,
borderwidth=2,
relief=tk.RIDGE
)
label.pack(fill=tk.X)
else:
loaded_clip_frame = tk.LabelFrame(
frame, text=msg.IE_CLIP_LOADED
)
loaded_rounds = 0
loaded_clip_content = loaded_clip.get("content", "-1").split()
try:
first_round = self.char.getItemById(loaded_clip_content[0])
except IndexError:
pass
if first_round is not None:
loaded_rounds = len(loaded_clip_content)
capacity = loaded_clip.find("container").get("size")
info = msg.IE_CLIP_STATUS + str(loaded_rounds)+" / "+str(capacity)
content_label = tk.Label(loaded_clip_frame, text=info)
content_label.pack(fill=tk.X, expand=1)
eject_button = tk.Button(loaded_clip_frame, text=msg.IE_EJECT)
eject_button.bind(
"<Button-1>",
lambda event, clip=loaded_clip:
self.ejectClip(event, clip)
)
eject_button.pack(fill=tk.X, expand=1)
loaded_clip_frame.pack(fill=tk.X, expand=1)
fire_button = tk.Button(
chamber_frame,
text=msg.IE_FIRE_WEAPON,
command=self.fireWeapon
)
if chambered_item is None or self.char.getEditMode() == "generation":
fire_button.config(state=tk.DISABLED)
fire_button.pack(fill=tk.X)
reload_button = tk.Button(chamber_frame, text=msg.IE_CYCLE_WEAPON)
reload_button.bind(
"<Button-1>",
lambda event, item=first_round:
self.reloadChamber(event, item))
reload_button.pack(fill=tk.X)
search = "option[@name='"+it.OPTION_CALIBER+"']"
caliber = self.item.find(search).get("value")
clips = self.getMatchingAmmo(caliber, it.CLIP)
if clips:
clips_label = tk.Label(frame, text=msg.IE_COMPATIBLE_CLIPS)
clips_label.pack()
for clip in clips:
clip_frame = tk.Frame(frame, borderwidth="1", relief=tk.RIDGE)
name_frame = tk.Label(clip_frame)
name_frame.pack(fill=tk.X, expand=1)
clip_capacity = clip.find("container").get("size")
clip_contents = "0"
content = clip.get("content", "-1").split()
try:
first_round = self.char.getItemById(content[0])
except IndexError:
first_round = None
if first_round is not None:
clip_contents = str(len(content))
info = first_round.get("name") + " [" + first_round.find("damage").get("value") + "]"
first_round_label = tk.Label(clip_frame, text=info)
first_round_label.pack(fill=tk.X, expand=1)
if loaded_clip is None:
load_button = tk.Button(clip_frame, text=msg.IE_LOAD_WEAPON)
load_button.bind(
"<Button-1>",
lambda event, item=clip:
self.loadClip(event, item)
)
load_button.pack(fill=tk.X, expand=1)
name = clip.get("name") + " ("+clip_contents+"/"+clip_capacity+")"
name_frame.config(text=name)
clip_frame.pack(fill=tk.X, expand=1)
def getRevolverInfo(self, frame):
number_chambers = int(self.item.find("ammo").get("chambers"))
active_chamber = int(self.item.find("ammo").get("active", "1"))
loaded_ammo = self.item.find("ammo").get("loaded", "-1")
ammo_list = loaded_ammo.split()
while len(ammo_list) < number_chambers:
ammo_list.append("-1")
chamber_frame = tk.LabelFrame(frame, text=msg.IE_CHAMBERS)
i = 0
self.widgets["chambers"] = chamber_frame
while i < number_chambers:
loaded_item = None
if len(ammo_list) > i:
loaded_item = self.char.getItemById(str(ammo_list[i]))
text = msg.IE_EMPTY
if loaded_item is not None:
text = loaded_item.get("name")
chamber_button = tk.Button(chamber_frame, text=text)
self.widgets["chamber"+str(i+1)] = chamber_button
chamber_button.bind(
"<Button-1>",
lambda event, chamber=i+1:
self.selectChamber(event, chamber)
)
chamber_button.pack(fill=tk.X, expand=1)
if i == active_chamber - 1:
chamber_button.state(["pressed"])
i += 1
chamber_frame.pack(fill=tk.X, expand=1)
chambered_item = self.char.getItemById(ammo_list[active_chamber-1])
if chambered_item is not None:
if chambered_item.get("name") == msg.IE_SHELL_CASING:
chambered_item = None
fire_button = tk.Button(
chamber_frame,
text=msg.IE_FIRE_WEAPON,
command=self.fireWeapon
)
if chambered_item is None or self.char.getEditMode() == "generation":
fire_button.config(state=tk.DISABLED)
fire_button.pack(fill=tk.X)
eject_button = tk.Button(
chamber_frame, text=msg.IE_CLEAR,
command=self.ejectBullets
)
eject_button.pack(fill=tk.X)
select_label = tk.Label(frame, text=msg.IE_AVAILABLE_AMMO)
search = "option[@name='"+it.OPTION_CALIBER+"']"
caliber = self.item.find(search).get("value")
items = self.getMatchingAmmo(caliber)
if items:
select_label.pack()
for item in items:
line = tk.Frame(frame)
item_id = item.get("id")
ammo_button = tk.Button(line, text=item.get("name"))
ammo_button.bind(
"<Button-1>",
lambda event, item=item, line=line:
self.loadRoundInChamber(event, item))
ammo_button.pack(side=tk.RIGHT)
line.pack()
def __init__(self, main, app):
tk.Frame.__init__(self, main)
self.app = app
self.char = app.char
self.width = 0
self.height = 0
self.image = None
self.images = []
self.variants = {}
self.selected_size = ""
self.selected_ratio = 0
self.x = None
self.y = None
# this checks if there are still operations going on ...
self.finished = 0
self.update = 0
# create canvas ...
self.edit_frame = tk.Frame(self)
self.edit_frame.pack(side=tk.LEFT, fill=tk.X, anchor=tk.N)
self.image_canvas = tk.Canvas(self, width=1, height=1)
self.image_canvas.bind("<B1-Motion>", self._moveFrame)
self.image_canvas.bind("<ButtonRelease-1>", self._stopMotion)
self.image_canvas.bind_all("+", self._scaleFrame)
self.image_canvas.bind_all("-", self._scaleFrame)
self.image_canvas.bind_all("<Left>", self._moveFrame)
self.image_canvas.bind_all("<Right>", self._moveFrame)
self.image_canvas.bind_all("<Up>", self._moveFrame)
self.image_canvas.bind_all("<Down>", self._moveFrame)
self.image_canvas.bind("<Configure>", self.resize)
self.image_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
self.load_button = tk.Button(self.edit_frame)
self.load_button.pack()
self._checkForImage()
# TEST
tk.Button(
self.edit_frame,
text="TESTEXPORT",
command=self._test,
).pack(fill=tk.X)
self.variant_frame = tk.LabelFrame(self.edit_frame,
text=msg.IS_SET_SELECTION)
self.img_on_canvas = None
self.rect = None
# try loading an existing image ...
image_tag = self.char.getImage()
if image_tag is not None:
self.update_idletasks()
filename = image_tag.get("file")
self.image = Image.open(filename)
self._displayImage()
def showResults(self, frame, results):
""" display the results of an EWT roll using graphics
Args:
frame: a tk.Frame() to display the results in
(will be cleared on each call)
results: expects the results of rollEWT(..,transparent=True)!
"""
# clear frame
widgets = frame.winfo_children()
for widget in widgets: widget.destroy()
# load images from disk
d = {}
ewt = {}
try:
d[1] = ImageTk.PhotoImage(file="img/d1.png")
d[2] = ImageTk.PhotoImage(file="img/d2.png")
d[3] = ImageTk.PhotoImage(file="img/d3.png")
d[4] = ImageTk.PhotoImage(file="img/d4.png")
d[5] = ImageTk.PhotoImage(file="img/d5.png")
d[6] = ImageTk.PhotoImage(file="img/d6.png")
d[7] = ImageTk.PhotoImage(file="img/d7.png")
d[8] = ImageTk.PhotoImage(file="img/d8.png")
d[9] = ImageTk.PhotoImage(file="img/d9.png")
d[10] = ImageTk.PhotoImage(file="img/d0.png")
ewt["0"] = ImageTk.PhotoImage(file="img/ewt_00.png")
ewt["/"] = ImageTk.PhotoImage(file="img/ewt_05.png")
ewt["x"] = ImageTk.PhotoImage(file="img/ewt_10.png")
ewt["x+"] = ImageTk.PhotoImage(file="img/ewt_20.png")
except IOError:
d = {1: "1"}
ewt = {"0": "O", "/": "/", "x": "x", "X+": "X+"}
# last roll header ...
last_roll = self.roll_var.get()
parts = last_roll.split("/")
if int(parts[1]) > 0:
parts[1] = "+"+str(parts[1])
if parts[1] == "0":
parts[1] = "±0"
tk.Label(
frame,
text="Letzter Wurf: "+parts[0]+"/"+parts[1],
justify=tk.LEFT,
font="sans 10 bold"
).pack(anchor=tk.W)
roll = 1
sum = 0
for result in results:
roll_frame = tk.Frame(frame)
if result[1] == 0.0:
effect = ewt["0"]
if result[1] == 0.5:
effect = ewt["/"]
if result[1] == 1.0:
effect = ewt["x"]
if result[2]:
text = effect = ewt["x+"]
else:
roll += 1
# if graphics exist ...
if d[1] != "1" and ewt["0"] != "O":
dice = d[result[0]]
dice_img = tk.Label(roll_frame, image=dice)
dice_img.image = dice
dice_img.pack(side=tk.LEFT)
colon = tk.Label(roll_frame, text=" : ", font="sans 16 bold")
colon.pack(side=tk.LEFT)
effect_img = tk.Label(roll_frame, image=effect)
effect_img.image = effect
effect_img.pack(side=tk.LEFT)
else:
text = "Wurf: "+str(result[0]) + " - Effekt: "+effect
roll_frame.pack()
sum += result[1]
tk.Label(
frame,
text="Gesamteffekt: "+str(sum),
justify=tk.LEFT,
font="sans 10 bold"
).pack(anchor=tk.W)
def showEquippedGuns(self, canvas):
""" This method fills a frame with data about equipped guns
canvas: tk.Canvas() where to display the data
"""
# clear the frame
canvas.delete(tk.ALL)
# go for the items
items = self.char.getItems()
y = 0
for item in items:
if item.get("equipped", "0") == "1":
item_type = item.get("type")
weapons = [
it.PISTOL,
it.REVOLVER,
it.RIFLE,
it.SHOT_GUN,
it.RIFLE_SA,
it.SHOT_GUN_SA,
it.AUTOMATIC_WEAPON,
]
if item_type in weapons:
item_name = item.get("name")
damage = item.find("damage").get("value")
# retrieve the loaded round
chambered_item = None
chambers = 1
loaded_chambers = 0
ammo_tag = item.find("ammo")
if ammo_tag is not None:
active_chamber = int(ammo_tag.get("active", "1"))
chambers = int(ammo_tag.get("chambers", "1"))
loaded_ammo = ammo_tag.get("loaded", "-1")
ammo_list = loaded_ammo.split()
chambered_id = ammo_list[active_chamber - 1]
chambered_item = self.char.getItemById(chambered_id)
for chamber in ammo_list:
if chamber != "-1":
loaded_chambers += 1
# get other content
loaded_clip = None
content = item.get("content", "x")
if content != "x":
content_list = content.split()
for content_id in content_list:
content_item = self.char.getItemById(content_id)
if content_item is not None:
content_type = content_item.get("type")
if content_type == it.CLIP:
loaded_clip = content_item
# building the display ...
item_id = item.get("id")
weapon_frame = tk.Frame(canvas,
borderwidth=2,
relief=tk.RIDGE)
name_line = tk.Frame(weapon_frame)
name_label = tk.Label(name_line,
text=item_name,
justify=tk.LEFT)
name_label.bind("<Button-1>",
lambda event, item_id=item_id: self.
displayItemEditor(event, item_id))
name_label.pack(side=tk.LEFT, fill=tk.X, expand=1)
chambered_line = tk.Frame(weapon_frame)
if chambered_item is None:
damage_label = tk.Label(name_line, text=damage)
damage_label.pack(side=tk.RIGHT, anchor=tk.E)
chamber_label = tk.Label(chambered_line,
text=msg.ES_NOT_LOADED)
chamber_label.pack()
else:
chambered_name = chambered_item.get("name")
damage = chambered_item.find("damage").get("value")
chamber_label = tk.Label(chambered_line,
text=chambered_name)
chamber_label.pack(side=tk.LEFT,
fill=tk.X,
anchor=tk.W)
damage_label = tk.Label(chambered_line, text=damage)
damage_label.pack(side=tk.RIGHT, anchor=tk.E)
ammo_line = tk.Frame(weapon_frame)
if loaded_clip is None:
ammo_text = msg.ES_CHAMBERED_AMMO.format(
chambers=chambers, loaded=loaded_chambers)
ammo_label = tk.Label(ammo_line, text=ammo_text)
ammo_label.pack(fill=tk.X, expand=1)
else:
clip_name = loaded_clip.get("name")
clip_size = loaded_clip.find("container").get("size")
clip_content = loaded_clip.get("content", "x").split()
ammo_in_clip = 0
if len(clip_content) == 1 and clip_content[0] == "x":
pass
else:
ammo_in_clip = len(clip_content)
ammo_text = msg.ES_CLIP.format(name=clip_name,
number=ammo_in_clip,
capacity=clip_size)
ammo_label = tk.Label(ammo_line, text=ammo_text)
ammo_label.pack(fill=tk.X, expand=1)
name_line.pack(fill=tk.X, expand=1)
chambered_line.pack(fill=tk.X, expand=1)
ammo_line.pack(fill=tk.X, expand=1)
canvas.create_window(
0,
y, # x, y
window=weapon_frame,
anchor=tk.NW,
width=self.canvas_width)
self.update_idletasks()
y += weapon_frame.winfo_height()
def noteFrame(self, note):
id = note.get("id", "")
name = note.get("name", "")
update = lambda event, id=id: self._update(event, id)
text = note.text
if not text:
text = ""
frame = tk.Frame(self.notes_canvas)
title = tk.Entry(frame, width=15, font="Arial 14 bold")
title.insert("0", name)
title.bind("<KeyRelease>", update)
title.place(
x=0,
y=0,
relheight=.1,
relwidth=.9,
anchor=tk.NW
)
del_icon = ImageTk.PhotoImage(file="img/cross_small.png")
delete_button = tk.Button(
frame,
image=del_icon,
)
delete_button.bind(
"<Button-1>",
lambda event, id=id: self._delNote(event, id))
ToolTip(delete_button, msg.NS_TT_DELETE)
delete_button.image = del_icon
delete_button.place(
relx=1,
y=0,
relheight=.1,
relwidth=.1,
anchor=tk.NE
)
text_widget = tk.Text(
frame,
width=1,
height=1,
wrap=tk.WORD,
borderwidth=0,
highlightthickness=1,
highlightbackground="#666666",
font="Arial 10"
)
text_widget.insert("0.0", text)
text_widget.bind("<KeyRelease>", update)
text_widget.place(
relx=0,
rely=.1,
relheight=.9,
relwidth=1,
anchor=tk.NW
)
if self.char.getEditMode() == "view":
title.config(state=tk.DISABLED)
delete_button.config(state=tk.DISABLED)
text_widget.config(
state=tk.DISABLED,
background="#eeeeee",
borderwidth=0,
highlightthickness=1,
highlightbackground="#cccccc",
)
return frame
def _modTypeChanged(self, name, e, m):
selected = self.vars[name].get()
try:
frame = self.widgets["options"]
except KeyError:
frame = None
if frame:
# cleanup ...
widgets = frame.winfo_children()
for widget in widgets:
widget.destroy()
row = str(self.row)
col = str(self.col)
sizes = self._potentialSizes()
if selected == msg.PDF_ATTRIBUTES:
if msg.PDF_DOUBLE in sizes:
sizes = [msg.PDF_DOUBLE]
else:
sizes = [""]
if selected == msg.PDF_EWT:
if msg.PDF_SINGLE in sizes:
sizes = [msg.PDF_SINGLE]
else:
sizes = [""]
size = tk.StringVar()
self.vars[str(size)] = size
self.var_names["size"] = str(size)
size_button = tk.OptionMenu(
frame,
size,
*sizes
)
size.set(sizes[0])
size_button.pack(fill=tk.X)
if selected == msg.PDF_TRAITS:
"""
trait_type = "all",
info_lines = 1,
start_index = 0
"""
trait_types = [
msg.PDF_ALL_TRAITS,
msg.PDF_POSITIVE_TRAITS,
msg.PDF_NEGATIVE_TRAITS
]
trait_type = tk.StringVar()
self.vars[str(trait_type)] = trait_type
self.var_names["trait_type"] = str(trait_type)
trait_type_button = tk.OptionMenu(
frame,
trait_type,
*trait_types
)
trait_type.set(trait_types[0])
trait_type_button.pack(fill=tk.X)
info_lines = tk.StringVar()
self.vars[str(info_lines)] = info_lines
self.var_names["info_lines"] = str(info_lines)
info_lines.set("0")
info_lines_frame = tk.Frame(frame)
info_lines_label = tk.Label(
info_lines_frame,
text=msg.ME_TEXTLINES
)
info_lines_label.pack(side=tk.LEFT)
info_lines_spinner = tk.Spinbox(
frame,
from_=0,
to=5,
textvariable=info_lines,
width=2)
info_lines_spinner.pack(side=tk.LEFT)
info_lines_frame.pack(fill=tk.X, expand=1)
pass
if selected == msg.PDF_SKILLS:
skill_types = [
msg.PDF_SKILLS_ALL,
msg.PDF_SKILLS_ACTIVE,
msg.PDF_SKILLS_PASSIVE,
msg.PDF_SKILLS_KNOWLEDGE,
msg.PDF_SKILLS_LANGUAGE
]
skill_type = tk.StringVar()
self.vars[str(skill_type)] = skill_type
self.var_names["skill_type"] = str(skill_type)
skill_type_button = tk.OptionMenu(
frame,
skill_type,
*skill_types
)
skill_type.set(skill_types[0])
skill_type_button.pack(fill=tk.X)
if selected == msg.PDF_WEAPONS:
variants = [
msg.PDF_ALL_WEAPONS,
msg.PDF_MELEE,
msg.PDF_GUNS,
msg.PDF_AMMO
]
variant = tk.StringVar()
self.vars[str(variant)] = variant
self.var_names["variant"] = str(variant)
variant_button = tk.OptionMenu(
frame,
variant,
*variants)
variant.set(variants[0])
variant_button.pack(fill=tk.X)
equipped = tk.IntVar()
self.vars[str(equipped)] = equipped
self.var_names["equipped"] = str(equipped)
equipped.set(0)
tk.Checkbutton(
frame,
text=msg.ME_EQUIPPED_WEAPONS,
variable=equipped,
offvalue=0,
onvalue=1
).pack(fill=tk.X)
amount = tk.IntVar()
self.vars[str(amount)] = amount
self.var_names["amount"] = str(amount)
amount.set(0)
tk.Checkbutton(
frame,
text=msg.ME_SHOW_QUANTITY,
variable=amount,
offvalue=0,
onvalue=1
).pack(fill=tk.X)
info_lines = tk.StringVar()
self.vars[str(info_lines)] = info_lines
self.var_names["info_lines"] = str(info_lines)
info_lines.set("0")
info_lines_frame = tk.Frame(frame)
info_lines_label = tk.Label(
info_lines_frame,
text=msg.ME_TEXTLINES
)
info_lines_label.pack(side=tk.LEFT)
info_lines_spinner = tk.Spinbox(
frame,
from_=0,
to=5,
textvariable=info_lines,
width=2
)
info_lines_spinner.pack(side=tk.LEFT)
info_lines_frame.pack(fill=tk.X, expand=1)
if selected == msg.PDF_EQUIPMENT:
item_group = tk.StringVar()
groups = [
msg.PDF_EQUIPMENT_ALL,
msg.PDF_EQUIPMENT_CLOTHING,
msg.PDF_EQUIPMENT_TOOLS,
msg.PDF_EQUIPMENT_BIOTECH,
msg.PDF_EQUIPMENT_MONEY
]
self.vars[str(item_group)] = item_group
self.var_names["item_group"] = str(item_group)
item_group.set(groups[0])
labelframe = tk.LabelFrame(frame, text="Gruppe wählen")
tk.OptionMenu(
labelframe,
item_group,
*groups
).pack(fill=tk.X)
labelframe.pack(fill=tk.X)
# condense items selection ...
condensed = tk.IntVar()
self.vars[str(condensed)] = condensed
self.var_names["condensed"] = str(condensed)
condensed.set(0)
tk.Checkbutton(
frame,
text=msg.ME_CONDENSE,
variable=condensed,
offvalue=0,
onvalue=1,
).pack(fill=tk.X, expand=1)
# show only equipped stuff selection
equipped = tk.IntVar()
self.vars[str(equipped)] = equipped
self.var_names["equipped"] = str(equipped)
equipped.set(0)
tk.Checkbutton(
frame,
text=msg.ME_EQUIPPED_STUFF,
variable=equipped,
offvalue=0,
onvalue=1,
).pack(fill=tk.X, expand=1)
# display content selection
content = tk.IntVar()
self.vars[str(content)] = content
self.var_names["content"] = str(content)
content.set(0)
tk.Checkbutton(
frame,
text=msg.ME_BAG_CONTENTS,
variable=content,
offvalue=0,
onvalue=1,
).pack(fill=tk.X, expand=1)
# display weapons selection
display_weapons = tk.IntVar()
self.vars[str(display_weapons)] = display_weapons
self.var_names["display_weapons"] = str(display_weapons)
display_weapons.set(0)
tk.Checkbutton(
frame,
text=msg.ME_SHOW_WEAPONS,
variable=display_weapons,
offvalue=0,
onvalue=1,
).pack(fill=tk.X, expand=1)
# use item_id selector
use_item_id = tk.IntVar()
self.vars[str(use_item_id)] = use_item_id
self.var_names["use_item_id"] = str(use_item_id)
use_item_id.set(0)
use_item_id_button = tk.Checkbutton(
frame,
text=msg.ME_ONLY_BAG,
variable=use_item_id,
offvalue=0,
onvalue=1,
)
use_item_id_button.pack(fill=tk.X, expand=1)
# select items that are bags/containers ...
items = self.main.char.getItems()
containers = [
it.CLOTHING,
it.BAG,
it.CONTAINER,
it.BOX,
it.TOOLS,
it.HARNESS]
self.vars["bags"] = []
for item in items:
if item.get("type") in containers:
container = item.find("container")
if container is not None:
item_id = item.get("id")
item_name = item.get("name")
self.vars["bags"].append(item_id+": "+item_name)
if len(self.vars["bags"]) == 0:
use_item_id_button.config(state=tk.DISABLED)
else:
bag_lists = self.vars["bags"]
bag_list = tk.StringVar()
self.vars[str(bag_list)] = bag_list
self.var_names["bag_list"] = str(bag_list)
bag_list_button = tk.OptionMenu(
frame,
bag_list,
*bag_lists
)
bag_list.set(bag_lists[0])
bag_list_button.pack()
# how many info_lines
info_lines = tk.StringVar()
self.vars[str(info_lines)] = info_lines
self.var_names["info_lines"] = str(info_lines)
info_lines.set("0")
info_lines_frame = tk.Frame(frame)
info_lines_label = tk.Label(
info_lines_frame,
text=msg.ME_TEXTLINES
)
info_lines_label.pack(side=tk.LEFT)
info_lines_spinner = tk.Spinbox(
frame,
from_=0,
to=5,
textvariable=info_lines,
width=2
)
info_lines_spinner.pack(side=tk.LEFT)
# show weight
show_weight = tk.IntVar()
self.vars[str(show_weight)] = show_weight
self.var_names["show_weight"] = str(show_weight)
show_weight.set(0)
tk.Checkbutton(
info_lines_frame,
text=msg.ME_SHOW_WEIGHT,
variable=show_weight,
offvalue=0,
onvalue=1
).pack(side=tk.LEFT)
# show value
show_value = tk.IntVar()
self.vars[str(show_value)] = show_value
self.var_names["show_value"] = str(show_value)
show_value.set(0)
tk.Checkbutton(
info_lines_frame,
text=msg.ME_SHOW_VALUE,
variable=show_value,
offvalue=0,
onvalue=1
).pack(side=tk.LEFT)
info_lines_frame.pack(fill=tk.X, expand=1)
# add traces (when everything exists) ...
condensed.trace("w", self._equipmentOptions)
equipped.trace("w", self._equipmentOptions)
content.trace("w", self._equipmentOptions)
use_item_id.trace("w", self._equipmentOptions)
if selected == msg.PDF_CONTACTS:
contact_types = [
msg.PDF_ALL_CONTACTS,
msg.PDF_FRIENDS,
msg.PDF_ENEMIES
]
contact_type = tk.StringVar()
self.vars[str(contact_type)] = contact_type
self.var_names["contact_type"] = str(contact_type)
contact_type_button = tk.OptionMenu(
frame,
contact_type,
*contact_types
)
contact_type.set(contact_types[0])
contact_type_button.pack(fill=tk.X)
info_lines = tk.StringVar()
self.vars[str(info_lines)] = info_lines
self.var_names["info_lines"] = str(info_lines)
info_lines.set("0")
info_lines_frame = tk.Frame(frame)
info_lines_label = tk.Label(
info_lines_frame,
text=msg.ME_TEXTLINES
)
info_lines_label.pack(side=tk.LEFT)
info_lines_spinner = tk.Spinbox(
frame,
from_=0,
to=5,
textvariable=info_lines,
width=2
)
info_lines_spinner.pack(side=tk.LEFT)
info_lines_frame.pack(fill=tk.X, expand=1)
if selected == msg.PDF_NOTES:
notes = self.main.char.getNotes()
entries = []
for note in notes:
id = note.get("id", "")
name = note.get("name", "")
entries.append(id+": "+name)
if entries:
var = tk.StringVar()
var.set(msg.ME_NOT_SELECTED)
var.trace("w", self._notesEdited)
self.vars["id"] = var
sub_frame = tk.LabelFrame(frame, text=msg.ME_NOTES)
button = tk.OptionMenu(
sub_frame,
var,
*entries
)
button.pack(fill=tk.X)
sub_frame.pack(fill=tk.X)
title = tk.StringVar()
self.vars["title"] = title
title_frame = tk.LabelFrame(frame, text=msg.ME_NOTES_TITLE)
entry = tk.Entry(title_frame, textvariable=title)
entry.pack(fill=tk.X)
title_frame.pack(fill=tk.X)
title.trace("w", self._notesEdited)
if selected == msg.PDF_IMAGE:
pass
def showUnassignedItems(self):
# clear the list ...
canvas = self.unassigned_canvas
canvas.delete(tk.ALL)
# get all items
items = self.char.getItems()
equippable_types = self.itemlist.EQUIPPABLE
y = 0
canvas.update()
for item in items:
# is the item currently packed or assigned as carried item?
unassigned = True
inside = int(item.get("inside", "-1"))
if inside > 0:
unassigned = False
equipped = int(item.get("equipped", "0"))
if equipped == 1:
unassigned = False
# display unassigned items
if unassigned:
quantity = int(item.get("quantity"))
item_id = item.get("id")
item_frame = tk.Frame(canvas)
item_frame.columnconfigure(1, weight=100)
amount_label = tk.Label(item_frame,
text=str(quantity) + msg.MULTIPLY,
justify=tk.LEFT,
width=4)
amount_label.grid(row=0, column=0, sticky=tk.EW)
name_label = tk.Label(item_frame,
text=item.get("name"),
justify=tk.LEFT)
name_label.bind("<Button-1>",
lambda event, item_id=item_id: self.
displayItemEditor(event, item_id))
name_label.grid(row=0, column=1, sticky=tk.EW)
item_type = item.get("type")
if item_type in equippable_types:
show = True
if item_type == it.TOOLS:
container = item.find("container")
damage = item.find("damage")
if damage is None and container is None:
show = False
equip_icon = ImageTk.PhotoImage(file="img/equip.png")
equip_button = tk.Button(item_frame, image=equip_icon)
ToolTip(equip_button, msg.ES_TT_EQUIP)
equip_button.image = equip_icon
equip_button.bind("<Button-1>",
lambda event, item_id=item_id: self.
equipItem(event, item_id))
if show:
equip_button.grid(row=0, column=2, sticky=tk.EW)
else:
empty = tk.Label(item_frame, text=" ", width=2)
empty.grid(row=0, column=2)
else:
empty = tk.Label(item_frame, text=" ", width=2)
empty.grid(row=0, column=2, sticky=tk.EW)
if self.active_bag_id >= 0:
pack_icon = ImageTk.PhotoImage(file="img/pack.png")
pack_button = tk.Button(item_frame, image=pack_icon)
ToolTip(pack_button, msg.ES_TT_PACK)
pack_button.image = pack_icon
pack_button.bind("<Button-1>",
lambda event, item_id=item_id: self.
packItem(event, item_id))
pack_button.grid(row=0, column=3, sticky=tk.EW)
else:
empty = tk.Label(item_frame, text=" ", width=2)
empty.grid(row=0, column=3, sticky=tk.EW)
canvas.create_window(
0,
y, # x, y
width=self.canvas_width,
window=item_frame,
anchor=tk.NW,
)
y += name_label.winfo_reqheight() + 5
def __init__(self, main, app):
tk.Frame.__init__(self, main)
self.app = app
self.char = app.char
self.itemlist = app.itemlist
self.canvas_width = 0
self.account_info = tk.StringVar()
self.active_bag_id = -1
self.open_windows = app.open_windows
# define the three columns
self.left_frame = tk.Frame(self)
self.left_frame.place(relx=0,
rely=0,
relwidth=1 / 3,
relheight=1,
anchor=tk.NW)
# displaying the characters initial account
self.initial_account_frame = self.initialAccount(self.left_frame)
self.initial_account_frame.pack(fill=tk.X)
self.updateInitialAccount()
# a button to buy new stuff (opens the InventoryEditor)
self.buy_button = tk.Button(self.left_frame,
text=msg.ES_BUY_BUTTON,
command=self.displayInventoryEditor)
self.buy_button.pack(fill=tk.X)
# show equipped items
self.equipped_frame = tk.LabelFrame(self.left_frame,
text=msg.ES_EQUIPPED,
font=config.Style.TITLE_LF_FONT)
self.equipped_canvas = tk.Canvas(self.equipped_frame,
width=1,
height=1)
self.equipped_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
self.equipped_scroll = tk.Scrollbar(self.equipped_frame,
orient=tk.VERTICAL)
self.equipped_scroll.pack(side=tk.LEFT, fill=tk.Y)
self.equipped_scroll.config(command=self.equipped_canvas.yview)
self.equipped_canvas.config(yscrollcommand=self.equipped_scroll.set)
self.equipped_frame.pack(fill=tk.BOTH, expand=1)
self.showEquippedItems()
# center frame
# used for the weapons
self.center_frame = tk.Frame(self)
self.melee_frame = tk.LabelFrame(self.center_frame,
text=msg.ES_MELEE,
font=config.Style.TITLE_LF_FONT)
self.melee_canvas = tk.Canvas(self.melee_frame, width=1, height=1)
self.melee_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
self.melee_scroll = tk.Scrollbar(self.melee_frame, orient=tk.VERTICAL)
self.melee_scroll.pack(side=tk.LEFT, fill=tk.Y)
self.melee_scroll.config(command=self.melee_canvas.yview)
self.melee_canvas.config(yscrollcommand=self.melee_scroll.set)
self.melee_frame.place(relx=0,
rely=0,
relwidth=1,
relheight=.5,
anchor=tk.NW)
self.guns_frame = tk.LabelFrame(self.center_frame,
text=msg.ES_GUNS,
font=config.Style.TITLE_LF_FONT)
self.guns_canvas = tk.Canvas(self.guns_frame, width=1, height=1)
self.guns_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
self.guns_scroll = tk.Scrollbar(self.guns_frame, orient=tk.VERTICAL)
self.guns_scroll.pack(side=tk.LEFT, fill=tk.Y)
self.guns_scroll.config(command=self.guns_canvas.yview)
self.guns_canvas.config(yscrollcommand=self.guns_scroll.set)
self.guns_frame.place(relx=0,
rely=0.5,
relwidth=1,
relheight=.5,
anchor=tk.NW)
self.center_frame.place(relx=1 / 3,
rely=0,
relwidth=1 / 3,
relheight=1,
anchor=tk.NW)
self.showEquippedGuns(self.guns_canvas)
self.showEquippedMelee(self.melee_canvas)
# the right frame is used for unassigned items
self.right_frame = tk.Frame(self)
self.unassigned_frame = tk.LabelFrame(self.right_frame,
text=msg.ES_UNASSIGNED,
font=config.Style.TITLE_LF_FONT)
self.unassigned_canvas = tk.Canvas(self.unassigned_frame,
height=1,
width=1)
self.unassigned_canvas.bind("<Configure>", self.updateItemList)
self.unassigned_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
self.unassigned_scroll = tk.Scrollbar(self.unassigned_frame,
orient=tk.VERTICAL)
self.unassigned_scroll.pack(side=tk.LEFT, fill=tk.Y)
self.unassigned_scroll.config(command=self.unassigned_canvas.yview)
self.unassigned_canvas.config(
yscrollcommand=self.unassigned_scroll.set)
self.unassigned_frame.place(relx=0,
rely=0,
relwidth=1,
relheight=1,
anchor=tk.NW)
self.right_frame.place(relx=2 / 3,
rely=0,
relwidth=1 / 3,
relheight=1,
anchor=tk.NW)
self.showUnassignedItems()
def __init__(self, main):
tk.Frame.__init__(self, main)
self.main = main
self.module = None
# setting up data
self.settings = Settings()
self.char = Character()
self.skills = SkillTree(self.settings)
self.traits = TraitTree(self.settings)
self.itemlist = ItemTree(self.settings)
self._setHotkeys()
# creating the menu
self.menubar = tk.Menu(main)
# building the file menu
self.filemenu = tk.Menu(self.menubar, tearoff="0")
self.filemenu.add_command(label=msg.MENU_NEW, command=self.newChar)
self.filemenu.add_command(label=msg.MENU_LOAD,
command=self.openCharWindow)
self.filemenu.add_command(label=msg.MENU_SAVE,
command=self.saveCharWindow)
self.filemenu.add_command(label=msg.MENU_QUIT,
command=self.main.destroy)
self.menubar.add_cascade(label=msg.MENU_FILE, menu=self.filemenu)
# building the tools menu
self.toolmenu = tk.Menu(self.menubar, tearoff="0")
self.toolmenu.add_command(label=msg.MENU_EDITMODE,
command=self._editModeWindow)
self.toolmenu.add_command(
label=msg.MENU_EWT,
command=lambda: self.switchWindow(msg.MENU_EWT))
self.toolmenu.add_command(
label=msg.MENU_MOVEMENT,
command=lambda: self.switchWindow(msg.MENU_MOVEMENT))
self.toolmenu.add_command(label=msg.MENU_IMPROVE,
command=self._displayImprove)
self.toolmenu.add_command(
label=msg.MENU_SETTINGS,
command=lambda: self.switchWindow(msg.MENU_SETTINGS))
self.toolmenu.add_command(label=msg.MENU_RELOAD_DATA,
command=self._reloadData)
self.toolmenu.add_command(
label=msg.MENU_CHAR_LOG,
command=lambda: self.switchWindow(msg.MENU_CHAR_LOG))
self.toolmenu.add_command(
label=msg.MENU_EDIT_EXPANSION,
command=lambda: self.switchWindow(msg.MENU_EDIT_EXPANSION))
self.menubar.add_cascade(label=msg.MENU_TOOLS, menu=self.toolmenu)
# building the help menu
self.helpmenu = tk.Menu(self.menubar, tearoff="0")
self.helpmenu.add_command(label=msg.MENU_ABOUT, command=self.about)
self.menubar.add_cascade(label=msg.MENU_HELP, menu=self.helpmenu)
# assigning the menu ...
main.config(menu=self.menubar)
# stuff that needs to be available across some functions
self.global_vars = {}
# defining a dict for subwindows to track them
self.open_windows = {
"trait": 0,
"skill": 0,
"inv": 0,
"contact": 0,
"itemedit": 0,
"mod_ed": 0,
"improve": 0,
"editmode": 0
}
self.widgets = {}
# initializing the basic screen layout ...
self.toolbar = tk.Frame(self)
self.toolbar.place(x=0, y=0, relheight=.1, relwidth=1, anchor=tk.NW)
self.main_frame = tk.Frame(self)
self.main_frame.place(x=0,
rely=.10,
relheight=.85,
relwidth=1,
anchor=tk.NW)
self.status_bar = StatusBar(self)
self.status_bar.place(x=0,
rely=1,
relheight=.05,
relwidth=1,
anchor=tk.SW)
# self.startScreenImage()
self.newChar()
self.showToolbar()
self.updateTitle()
self.size = (self.winfo_toplevel().winfo_reqwidth(),
self.winfo_toplevel().winfo_reqheight())
def __init__(self, main, app):
tk.Frame.__init__(self, main)
# localize data ...
# create the character instance # #
self.app = app
self.char = app.char
self.skills = app.skills
self.traits = app.traits
self.itemlist = app.itemlist
# stuff that needs to be available across some functions
self.global_vars = dict()
# defining subwindows to track them!
self.open_windows = app.open_windows
self.widgets = {}
# from here on we are building the screen layout ...
# column 1 ...
self.frame_1 = frame_1 = tk.Frame(self)
frame_1.place(relheight=1,
relwidth=1 / 12,
relx=0,
rely=0,
anchor=tk.NW)
# starting with the attribute frame ...
attr_frame = tk.Frame(frame_1)
attr_list = self.char.ATTRIB_LIST
attr_names = [
msg.PHY, msg.MEN, msg.SOZ, msg.NK, msg.FK, msg.LP, msg.EP, msg.MP
]
edit_mode = self.char.getEditMode()
for attr, name in zip(attr_list, attr_names):
frame = tk.LabelFrame(
attr_frame,
font=config.Style.ATTR_LF_FONT,
text=name,
)
# initiate the IntVars and bind their tcl names to the attributes
attrib_values = self.char.attrib_values
attrib_values[attr] = tk.IntVar()
attrib_values[attr].set(self.char.getAttributeValue(attr))
# in generation mode we have spinboxes ...
if edit_mode == cd.GENERATION:
self.char.attrib_trace[str(attrib_values[attr])] = attr
self.widgets[attr] = tk.Spinbox(
frame,
from_=core.MIN_ATTRIBUTE,
to=core.MAX_ATTRIBUTE,
font=config.Style.ATTR_FONT,
justify=tk.CENTER,
textvariable=attrib_values[attr],
width=3)
self.widgets[attr].pack(fill=tk.X)
self.char.widgets = self.widgets
self.char.attrib_values[attr].trace("w",
self.char.attributeChange)
# in edit mode there are buttons and labels
if edit_mode == cd.EDIT:
frame.columnconfigure(0, weight=100)
value_field = tk.Label(frame,
textvariable=attrib_values[attr],
font=config.Style.ATTR_FONT,
width=3)
value_field.grid(row=0, column=0, sticky=tk.EW)
plus = ImageTk.PhotoImage(file="img/plus_s.png")
self.widgets[attr + "_inc"] = tk.Label(
frame,
image=plus,
)
self.widgets[attr + "_inc"].image = plus
self.widgets[attr + "_inc"].bind(
"<Button-1>",
lambda event, attr=attr: self.increaseAttribute(attr))
self.widgets[attr + "_inc"].grid(row=0, column=1, sticky=tk.EW)
# in view and sim mode there is only a label ...
if edit_mode in [cd.VIEW, cd.SIMULATION]:
value_field = tk.Label(frame,
textvariable=attrib_values[attr],
font=config.Style.ATTR_FONT,
width=3)
value_field.pack(fill=tk.X, expand=1)
frame.pack(fill=tk.X)
attr_frame.pack(fill=tk.X, anchor=tk.N)
# this displays the characters XP
xp_frame = tk.LabelFrame(frame_1, text=msg.XP)
xp_avail = tk.Label(xp_frame, textvariable=self.char.xp_avail)
self.char.xp_avail.set(self.char.getAvailableXP())
xp_avail.pack(side=tk.LEFT)
xp_total_text = " / " + str(self.char.getTotalXP())
self.xp_total = tk.Label(xp_frame, text=xp_total_text)
self.xp_total.pack(side=tk.LEFT)
xp_frame.pack(fill=tk.X)
# this makes the second block
frame_2 = tk.Frame(self)
# beginning with the data frame
data_frame = tk.LabelFrame(
frame_2,
font=config.Style.TITLE_LF_FONT,
text=msg.CS_BASE_DATA,
)
data_list = [[cd.NAME, msg.NAME, 0, 0, 4],
[cd.SPECIES, msg.SPECIES, 1, 0, 4],
[cd.ORIGIN, msg.ORIGIN, 2, 0, 4],
[cd.CONCEPT, msg.CONCEPT, 3, 0, 4],
[cd.PLAYER, msg.PLAYER, 4, 0, 4],
[cd.HEIGHT, msg.HEIGHT, 5, 0, 1],
[cd.WEIGHT, msg.WEIGHT, 5, 1, 1],
[cd.AGE, msg.AGE, 5, 2, 1],
[cd.GENDER, msg.GENDER, 5, 3, 1],
[cd.HAIR, msg.HAIR, 6, 0, 1],
[cd.EYES, msg.EYES, 6, 1, 1],
[cd.SKIN, msg.SKIN_COLOR, 6, 2, 1],
[cd.SKIN_TYPE, msg.SKIN_TYPE, 6, 3, 1]]
for data in data_list:
frame = tk.LabelFrame(data_frame, text=data[1])
# creating a StringVar() and linking the tcl name
value_var = tk.StringVar()
self.char.data_values[data[0]] = value_var
self.char.data_trace[str(value_var)] = data[0]
# retrieve already stored data from character
stored_value = self.char.getData(data[0])
if stored_value:
value_var.set(stored_value)
width = 10 * data[4]
entry = tk.Entry(frame,
textvariable=value_var,
width=width,
**config.Style.DATA_STYLE)
if edit_mode in [cd.VIEW, cd.SIMULATION]:
entry.config(state=tk.DISABLED)
else:
entry.bind("<FocusOut>", self.dataUpdated)
entry.pack(fill=tk.BOTH, expand=1)
frame.grid(row=data[2],
column=data[3],
columnspan=data[4],
sticky="NSWE")
for row in range(7):
data_frame.rowconfigure(row, weight=1)
for col in range(4):
data_frame.columnconfigure(col, weight=1)
data_frame.pack(fill=tk.BOTH, anchor=tk.N, expand=1)
# within this frame will be the character traits
traits_frame = tk.LabelFrame(
frame_2,
font=config.Style.TITLE_LF_FONT,
text=msg.CS_TRAITS,
)
self.traits_text = tk.Text(traits_frame,
bg="#eeeeee",
font="Arial 10",
wrap=tk.WORD,
height=5,
width=10)
self.updateTraitList()
# finally pack the field and disable it for editing
self.traits_text.pack(fill=tk.BOTH, expand=1)
traits_frame.pack(fill=tk.BOTH, expand=1)
new_traits_button = tk.Button(frame_2,
text=msg.CS_ADD_TRAIT,
command=self.showTraitWindow)
if edit_mode in [cd.VIEW, cd.SIMULATION]:
new_traits_button.config(state=tk.DISABLED)
new_traits_button.pack(fill=tk.X)
traits_frame.pack(fill=tk.BOTH, expand=1)
frame_2.place(relheight=1,
relwidth=.4 - 1 / 12,
relx=1 / 12,
rely=0,
anchor=tk.NW)
# this frame holds the character skills ...
frame_3 = tk.Frame(self)
skill_frame = tk.Frame(frame_3)
# active skills ...
self.active_skill_frame = tk.LabelFrame(
skill_frame,
font=config.Style.TITLE_LF_FONT,
text=msg.CS_ACTIVE_SKILLS,
)
self.active_skill_canvas = tk.Canvas(self.active_skill_frame,
width=1,
height=1)
self.active_skill_canvas.bind("<Configure>",
lambda event: self.updateSkillList())
self.active_skill_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
self.active_skill_scroll = tk.Scrollbar(self.active_skill_frame,
orient=tk.VERTICAL)
self.active_skill_scroll.pack(side=tk.LEFT, fill=tk.Y)
self.active_skill_scroll.config(command=self.active_skill_canvas.yview)
self.active_skill_canvas.config(
yscrollcommand=self.active_skill_scroll.set)
# passive skills
self.passive_skill_frame = tk.LabelFrame(
skill_frame,
font=config.Style.TITLE_LF_FONT,
text=msg.CS_PASSIVE_SKILLS,
)
self.passive_skill_canvas = tk.Canvas(self.passive_skill_frame,
width=1,
height=1)
self.passive_skill_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
self.passive_skill_scroll = tk.Scrollbar(self.passive_skill_frame,
orient=tk.VERTICAL)
self.passive_skill_scroll.pack(side=tk.LEFT, fill=tk.Y)
self.passive_skill_scroll.config(
command=self.passive_skill_canvas.yview)
self.passive_skill_canvas.config(
yscrollcommand=self.passive_skill_scroll.set)
# initialize the list and place it on screen ...
self.updateSkillList()
self.active_skill_frame.place(relx=0,
rely=0,
relwidth=.5,
relheight=1,
anchor=tk.NW)
self.passive_skill_frame.place(relx=0.5,
rely=0,
relwidth=.5,
relheight=1,
anchor=tk.NW)
skill_frame.pack(fill=tk.BOTH, expand=1)
# and a button to add skills
new_skill_button = tk.Button(frame_3,
text=msg.CS_ADD_SKILLS,
command=self.showSkillWindow)
if edit_mode in ["view", "simulation"]:
new_skill_button.config(state=tk.DISABLED)
new_skill_button.pack(fill=tk.X)
frame_3.place(relheight=1, relwidth=.6, relx=.4, rely=0, anchor=tk.NW)
def _showItemInfo(self):
""" Display the item info in the main screen section
"""
item_title = self.item_title
item_body = self.item_body
# clear the frames (if necessary)
widgets = item_title.winfo_children()
for widget in widgets:
widget.destroy()
widgets = item_body.winfo_children()
for widget in widgets:
widget.destroy()
quant_label = tk.Label(
item_title,
text=str(self.item_quantity) + "x - ",
font="Helvetica 12 bold")
quant_label.pack(side=tk.LEFT)
name_label = tk.Entry(
item_title,
font="Helvetica 12 bold",
)
name_label.insert(0, self.item_name)
name_label.config(**config.Style.HIDDEN_ENTRY)
name_label.pack(side=tk.LEFT, expand=1)
name_label.bind("<Double-Button-1>", self._activateEntryField)
name_label.bind(
"<Return>",
lambda event:
self._updateAttribute(event, attribute="name")
)
weight = self.getWeight()
if weight > 500:
weight_str = str(round(weight/1000.0, 2))
weight_str = weight_str.replace(".", ",") + msg.IE_KG
else:
weight_str = str(weight) + msg.IE_G
weight_str = msg.IE_WEIGHT + weight_str
# check for limit:
limit = 0
container = self.item.find("container")
if container is not None:
limit = int(container.get("limit", "0"))
weight_label = tk.Label(item_body, text=weight_str, anchor=tk.W)
if weight > limit > 0:
weight_label.config(**config.Style.RED)
weight_label.pack(fill=tk.X)
price = round(self.item_price * self.item_quantity, 2)
price = str(price)
if "." in price:
price = price.split(".")
price[1] = price[1] + "0000"
price[1] = price[1][0:2]
price = msg.MONEYSPLIT.join(price)
price_str = msg.IE_PRICE_VALUE + price
price_label = tk.Label(item_body, text=price_str, anchor=tk.W)
price_label.pack(fill=tk.X)
qualtities = {
1: msg.IE_QUALITY_1,
2: msg.IE_QUALITY_2,
3: msg.IE_QUALITY_3,
4: msg.IE_QUALITY_4,
5: msg.IE_QUALITY_5,
6: msg.IE_QUALITY_6,
7: msg.IE_QUALITY_7,
8: msg.IE_QUALITY_8,
9: msg.IE_QUALITY_9,
}
quality_str = msg.IE_QUALITY + ": " + qualtities[self.item_quality]
quality_frame = tk.Frame(item_body)
quality_label = tk.Label(
quality_frame,
text=quality_str,
)
quality_label.pack(side=tk.LEFT)
rep_icon = ImageTk.PhotoImage(file="img/repair.png")
rep_label = tk.Label(quality_frame, image=rep_icon)
rep_label.bind("<Button-1>", self.repair)
rep_label.image = rep_icon
ToolTip(rep_label, msg.IE_TT_REPAIR)
if self.item_quality >= 9:
rep_label.config(state=tk.DISABLED)
rep_label.pack(side=tk.RIGHT, anchor=tk.W)
dmg_icon = ImageTk.PhotoImage(file="img/damage.png")
dmg_label = tk.Label(quality_frame, image=dmg_icon)
dmg_label.bind("<Button-1>", self.damage)
dmg_label.image = dmg_icon
dmg_label.pack(side=tk.RIGHT, anchor=tk.W)
ToolTip(dmg_label, msg.IE_TT_DAMAGE_ITEM)
if self.item_quality <= 1:
dmg_label.config(state=tk.DISABLED)
quality_frame.pack(fill=tk.X)
options = self.item.findall("option")
for option in options:
name = option.get("name", "")
value = option.get("value", "")
frame = tk.Frame(self.item_body)
display_name = ""
if name == it.OPTION_CALIBER:
display_name = msg.IE_CALIBER
elif name == it.OPTION_COLOR:
display_name = msg.IE_CE_FABRIC_COLOR
else:
display_name = name
tk.Label(
frame,
text=display_name
).pack(side=tk.LEFT, anchor=tk.W)
entry = tk.Entry(
frame,
width=len(value)+2,
)
entry.delete(0, tk.END)
entry.insert(0, value)
entry.config(**config.Style.HIDDEN_ENTRY)
entry.bind("<Double-Button-1>", self._activateEntryField)
entry.bind(
"<Return>",
lambda event, name=name:
self._updateTag(event, tagname="option", name=name)
)
entry.pack(side=tk.RIGHT, anchor=tk.E, fill=tk.X, expand=1)
frame.pack(fill=tk.X, expand=1, anchor=tk.W)
# display stuff according to item type ...
self.showMore(item_body)
# display the description Window ...
description_text = tk.Text(
item_body,
width=30,
height=8,
wrap=tk.WORD,
font="Helvetica 9"
)
description_text.bind("<KeyRelease>", self.descriptionEdited)
description_text.pack(fill=tk.X)
description = self.item.find("description")
if description is not None:
description_text.insert(tk.END, description.text)
def __init__(self, app):
tk.Toplevel.__init__(self, app)
# point to character and skilltree
self.char = app.char
self.all_skills = app.skills
self.app = app
self.app.open_windows["skill"] = self
self.minspec = 1
self.maxspec = 3
self.origin = ""
self.complete_list = [skill[0] for skill in self.all_skills.getList()]
# icons:
self.unsel_icon = ImageTk.PhotoImage(file="img/unsel.png")
self.sel_icon = ImageTk.PhotoImage(file="img/sel.png")
# build the window
if self.char.getEditMode == "generation":
self.title(msg.SS_ADD_REMOVE_SKILLS)
else:
self.title(msg.SS_ADD_SKILLS)
self.protocol("WM_DELETE_WINDOW", self.close)
self.search_frame = tk.Frame(self)
self.search = tk.StringVar()
self.search_gf = tk.Button(self.search_frame,
width=3,
text=msg.SS_BASE,
command=self.toggleMinSpec)
self.search_gf.config(relief=tk.SUNKEN)
ToolTip(self.search_gf, msg.SS_TT_SHOW_BASE)
self.search_gf.pack(side=tk.LEFT)
self.search_sp = tk.Button(self.search_frame,
width=3,
text=msg.SS_SPEC,
command=self.toggleMaxSpec)
self.search_sp.config(relief=tk.SUNKEN)
ToolTip(self.search_sp, msg.SS_TT_SHOW_SPEC)
self.search_sp.pack(side=tk.LEFT)
self.search_box = tk.Entry(self.search_frame, textvariable=self.search)
ToolTip(self.search_box, msg.SS_TT_SEARCH)
self.search_box.pack(side=tk.LEFT, fill=tk.X, expand=1)
self.search_button = tk.Button(
self.search_frame,
text=msg.SS_SEARCH,
command=lambda: self._showSkills(search=True))
self.search_button.pack(side=tk.RIGHT)
self.search_frame.pack(fill=tk.X, expand=1)
self.frame = tk.Frame(self)
self.scrollbar = tk.Scrollbar(self.frame, orient=tk.VERTICAL)
self.list_box = tk.Treeview(self.frame)
self.list_box.bind("<<TreeviewSelect>>", self._selectionChanged)
self.list_box.config(
selectmode=tk.EXTENDED,
yscrollcommand=self.scrollbar.set,
height=20,
show="tree",
)
self.scrollbar.config(command=self.list_box.yview)
self.list_box.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
self.scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
self.frame.pack(fill=tk.BOTH)
self.new_skill_name = tk.StringVar()
self.new_skill_name.set(msg.SS_NEW_SKILL)
self.new_skill_name.trace(
"w", lambda name, empty, mode: self._newSkillName())
self.new_skill_check = False
self.new_skill_entry = tk.Entry(self,
textvariable=self.new_skill_name,
state=tk.DISABLED)
self.new_skill_entry.bind("<FocusIn>", self._skillEntryFocus)
self.new_skill_entry_focus = False
self.new_skill_entry.pack(fill=tk.X)
self.add_button_text = tk.StringVar()
self.add_button = tk.Button(self,
textvariable=self.add_button_text,
command=self.addSkills,
state=tk.DISABLED)
if self.char.getEditMode() == "generation":
self.add_button_text.set(msg.SS_ADD_REMOVE_SKILLS)
else:
self.add_button_text.set(msg.SS_ADD_SKILLS)
self.add_button.pack(fill=tk.X)
self._showSkills()
self.focus()
def _editModule(self, frame):
tk.Label(frame, text=msg.ME_EDIT).pack()
mod_type = self.module.get("type")
# change size ...
self.space = self._getSpace()
sizes = self._potentialSizes()
if mod_type == page.MOD_ATTRIBUTES:
if msg.PDF_DOUBLE in sizes:
sizes = [msg.PDF_DOUBLE]
else:
sizes = [""]
if mod_type == page.MOD_EWT:
if msg.PDF_SINGLE in sizes:
sizes = [msg.PDF_SINGLE]
else:
sizes = [""]
tk.Label(frame, text=msg.ME_CHANGE_SIZE).pack()
size = tk.StringVar()
self.vars[str(size)] = size
self.var_names["size"] = str(size)
cur_size = self.module.get("size")
size_names = {
page.SINGLE: msg.PDF_SINGLE,
page.WIDE: msg.PDF_WIDE,
page.DOUBLE: msg.PDF_DOUBLE,
page.QUART: msg.PDF_QUART,
page.TRIPLE: msg.PDF_TRIPLE,
page.BIG: msg.PDF_BIG,
page.FULL: msg.PDF_FULL,
page.HALF: msg.PDF_HALF
}
cur_size = size_names[cur_size]
size_button = tk.OptionMenu(
frame,
size,
*sizes
)
size.set(cur_size)
size_button.pack(fill=tk.X)
if mod_type in [
page.MOD_TRAITS,
page.MOD_WEAPONS,
page.MOD_EQUIPMENT,
page.MOD_CONTACTS
]:
info_lines = tk.StringVar()
self.vars[str(info_lines)] = info_lines
self.var_names["info_lines"] = str(info_lines)
info_lines_tag = self.module.find("param[@name='info_lines']")
if info_lines_tag is not None:
info_lines.set(info_lines_tag.get("value", "0"))
else:
info_lines.set("0")
sub_frame = tk.Frame(frame)
tk.Label(sub_frame, text=msg.ME_TEXTLINES).pack(side=tk.LEFT)
tk.Spinbox(
sub_frame,
textvariable=info_lines,
from_=0,
to=5,
width=2
).pack(side=tk.LEFT)
sub_frame.pack()
tk.Button(frame, text=msg.ME_SAVE, command=self._updateModule).pack()
tk.Button(frame, text=msg.ME_DELETE, command=self._removeModule).pack()
