def __init__(self, editor, pos, name):
self.name = name
self.buttons = {}
self.buttons[name + '_label'] = button.DefaultButton(self,
None,
pos=(0, 0),
size=(100, 20),
text=name)
self.buttons[name + '_increment'] = button.DefaultButton(
self,
change_object_value(editor, name, 1),
pos=(0, 0),
size=(30, 30),
text="+")
self.buttons[name + '_decrement'] = button.DefaultButton(
self,
change_object_value(editor, name, -1),
pos=(0, 0),
size=(30, 30),
text="-")
self.buttons[name + '_value'] = button.DefaultButton(self,
None,
pos=(0, 0),
size=(30, 30),
text="0")
self.pos = pos
def __init__(self,
game,
text,
on_complete_fun=None,
on_yes_fun=None,
on_no_fun=None):
super(QuestionBox, self).__init__(game, text, None)
self.yes_button = button.DefaultButton(owner=self,
function=self.yes,
pos=(350, 220),
text="Yes",
size=(100, 60))
self.no_button = button.DefaultButton(owner=self,
function=self.no,
pos=(550, 220),
text="No",
size=(100, 60))
self.buttons.append(self.yes_button)
self.buttons.append(self.no_button)
if on_complete_fun is not None:
self.on_complete = on_complete_fun
if on_yes_fun is not None:
self.on_yes = on_yes_fun
if on_no_fun is not None:
self.on_no = on_no_fun
def __init__(self, game, text, on_hide_fun=None):
super(InfoBox, self).__init__(game, text, on_hide_fun)
self.ok_button = button.DefaultButton(owner=self,
function=self.hide,
pos=(500, 220),
text="OK",
size=(100, 60))
self.buttons.append(self.ok_button)
def __init__(self,
owner=None,
items=None,
function=None,
color=(120, 0, 0),
border_color=(120, 50, 80),
border_width=2,
text=None,
font_size=10,
labels='dictkey',
order=(0, 0),
window=window,
**kwargs):
super(DropDownList, self).__init__(window=window, **kwargs)
self.color = color
self.border_color = border_color
self.border_width = border_width
self.text = text
self.font_size = font_size
self.labels = labels
self._open = False
self._drop_group = pyglet.graphics.OrderedGroup(99, self._group)
self.function = function
self.order = order
self.owner = owner # container that created the button, allows for the button function to interact with its creator
self.items = items
self.selected_name = "<None>"
self.selected = None
self.main_button = button.DefaultButton(
owner=self,
function=self.main_button_click,
pos=self.pos,
size=self.size,
font_size=font_size,
visible=self.visible,
text=u"<None>",
border_color=self.border_color,
border_width=self.border_width,
color=self.color,
batch=self._batch,
group=self._group)
self.drop_buttons = []
self.first_time = True
self.refresh()
self.high_color = (0, 120, 0)
self.high_border_color = (0, 200, 0)
self.update_buttons()
def __init__(self, game, text, on_hide_fun=None):
self.game = game
if on_hide_fun is not None:
self.on_hide = on_hide_fun
self.background = button.DefaultButton(owner=self,
function=None,
pos=(300, 200),
text=text,
size=(500, 400))
self.buttons = []
self.visible = False
def __init__(self,
game,
toggle_button_text,
pos=(0, 0),
toggle_pos=(0, 0),
toggle_order=None):
"""
Set .pre = unique identifying sting to prevent name conflicts when combined into update list in .game
Toggle button for the editor appears at toggle_pos.
If toggle_order != None, then overrides toggle_pos. Then toggle button for this editor is aligned to the grid of owning editor.
Append editors that stem from this editor in self.sub_editors.
- sub_editors_pos is top-left of where it will appear when enabled
Positions of buttons/lists are done on a grid basis, set with order=(y, x) in declaration.
- top left of grid is self.pos
- button size and spacing set with .size, .vert_spacing, .horizontal_spacing
"""
self.game = game
self.pre = '' # button/list name prefix - prevents name conflicts when combined into update list in .game
self.toggle_button_text = toggle_button_text
self.toggle_button_name = self.toggle_button_text.lower()
self.toggle_button_name = self.toggle_button_name.replace(' ', '_')
self.toggle_button_name = 'toggle_' + self.toggle_button_name
self.buttons = {}
self.drop_lists = {}
self.layouts = {} # name: (layout, position/order, order=True/False)
self.sub_editors = []
self.sub_editors_pos = (0, 0)
self.enabled = False
self.size = (120, 20)
self.vert_spacing = 5
self.horizontal_spacing = 5
self._pos = (0, 0)
self.toggle_pos = toggle_pos
self.toggle_order = toggle_order
self.toggle_button = button.DefaultButton(self,
self.toggle_self,
text=toggle_button_text,
pos=toggle_pos)
self.buttons[self.toggle_button_name] = self.toggle_button
self.pos = pos
def create_elements(self): # placeholder for auto-complete
def main_label_up():
x, y = self.buttons['main_label'].pos
self.pos = (x, y - self.vert_spacing)
def main_label_drag(dx, dy):
x, y = self.buttons['main_label'].pos
self.buttons['main_label'].pos = x + dx, y + dy
self.buttons['main_label'] = button.DefaultButton(
self, None, text=self.toggle_button_text, order=(-1, 0))
self.buttons['main_label'].on_click_up = main_label_up
self.buttons['main_label'].on_drag = main_label_drag
self.buttons['main_label'].enabled = True
def create_elements(self):
self.buttons = {}
self.drop_lists = {}
self.buttons['toggle_trigger_editor'] = button.DefaultButton(self, self.toggle_self, text="Trigger Editor", pos=(0, window.height - 40))
db = button.DefaultButton
dl = drop_down_list.DropDownList
dls = drop_down_list.DropDownListSlider
self.buttons['create_new_trigger'] = db(self, self.create_new_trigger, text="New Trigger", order=(0, 0))
self.drop_lists['triggers'] = dls(self, self.game.map.triggers, self.select_trigger, max_display=4, order=(0, 1))
self.buttons['delete_trigger'] = db(self, self.delete_selected_trigger, text="Delete Trigger", order=(0, 2))
self.buttons['interaction_type_label'] = db(self, None, text="Interaction Type:", order=(1, 0))
self.drop_lists['interaction_type'] = dl(self, object_interaction_types, self.set_interaction_type, order=(1, 1))
self.buttons['pick_interactee'] = db(self, self.pick_interactee, text="Pick Interactee", order=(2, 0))
self.drop_lists['interactees'] = dl(self, {}, self.select_interactee, order=(2, 1))
self.buttons['delete_interactee'] = db(self, self.delete_interactee, text="Delete Interactee", order=(2, 2))
self.buttons['new_zone'] = db(self, self.create_new_zone, text="New Zone", order=(3, 0))
self.drop_lists['zones'] = dl(self, {}, self.select_zone, order=(3, 1))
self.buttons['delete_zone'] = db(self, self.delete_selected_zone, text="Delete Zone", order=(4, 0))
self.buttons['zone_bottomleft'] = db(self, self.zone_bottomleft, text="Select Bottom Left", order=(4, 1))
self.buttons['zone_topright'] = db(self, self.zone_topright, text="Select Top Right", order=(4, 2))
self.buttons['pick_target'] = db(self, self.pick_target, text="Pick Target", order=(5, 0))
self.drop_lists['targets'] = dl(self, {}, self.select_target, order=(5, 1))
self.buttons['delete_target'] = db(self, self.delete_target, text="Delete Target", order=(5, 2))
self.buttons['pick_conditional'] = db(self, self.pick_conditional, text="Pick Conditional", order=(6, 0))
self.drop_lists['conditionals'] = dl(self, {}, self.select_conditional, order=(6, 1))
self.buttons['delete_conditional'] = db(self, self.delete_conditional, text="Delete Conditional", order=(6, 2))
self.buttons['action_label'] = db(self, None, text="Action Edit:", order=(7, 0))
self.drop_lists['new_action'] = dl(self, trigger_functions_dict, self.add_action, order=(7, 1))
self.drop_lists['actions'] = dl(self, {}, self.select_action, order=(7, 2), labels='func_name')
self.buttons['delete_action'] = db(self, self.delete_action, text="Delete Action", order=(7, 3))
self.drop_lists['action_options'] = dl(self, {}, self.set_action_option, order=(7, 4), visible=False)
self.update_element_positions()
self.toggle_self(False)
def select_cutscene_action(self):
# remove old s***e
if len(self.dyn_lists) > 0 or len(self.dyn_buttons) > 0:
self.dyn_lists = []
self.dyn_buttons = []
# changed? upkeep...
if self.selected_cutscene_action != self.cutscene_actions_list.selected:
self.highlighted = []
self.selected_cutscene_action = self.cutscene_actions_list.selected
def add_control(x):
# ALL the boilerplate!
if isinstance(x, drop_down_list.DropDownList):
self.dyn_lists.append(x)
elif isinstance(x, button.Button):
self.dyn_buttons.append(x)
add_control.control_i += 1
return x
add_control.control_i = 0
def int_dec_fun(ev, attr):
dec = 1
if self.game.key_controller.keys[
Pkey.LSHIFT] or self.game.key_controller.keys[Pkey.RSHIFT]:
dec = 10
if self.game.key_controller.keys[
Pkey.LCTRL] or self.game.key_controller.keys[Pkey.RCTRL]:
dec = 50
setattr(ev, attr, getattr(ev, attr) - dec)
def int_inc_fun(ev, attr):
inc = 1
if self.game.key_controller.keys[
Pkey.LSHIFT] or self.game.key_controller.keys[Pkey.RSHIFT]:
inc = 10
if self.game.key_controller.keys[
Pkey.LCTRL] or self.game.key_controller.keys[Pkey.RCTRL]:
inc = 50
setattr(ev, attr, getattr(ev, attr) + inc)
def bool_toggle_fun(ev, attr):
setattr(ev, attr, not getattr(ev, attr))
def obj_ref_sel_fun(ev, attr):
def finish_obj_click(o_name):
self.highlighted.remove(str(ev) + '-' + attr)
setattr(ev, attr, o_name)
self.select_cutscene_action()
self.refresh_cutscene_actions()
# are they actually unclicking the button?
if (str(ev) + '-' + attr) in self.highlighted:
self.highlighted.remove(str(ev) + '-' + attr)
else:
self.highlighted.append(str(ev) + '-' + attr)
self.game.mouse_controller.pick_object(finish_obj_click)
def pick_coords_fun(ev, attr):
def finish_coords_click(pos):
self.highlighted.remove(str(ev) + '-' + attr)
dest = pos
dest = (dest[0] - 12, dest[1])
setattr(ev, attr, dest)
self.select_cutscene_action()
self.refresh_cutscene_actions()
# unclicking?
if (str(ev) + '-' + attr) in self.highlighted:
self.highlighted.remove(str(ev) + '-' + attr)
else:
self.highlighted.append(str(ev) + '-' + attr)
self.game.mouse_controller.pick_position(finish_coords_click)
def drop_down_fun(ev, attr):
# wow such hack
s = getattr(self, self.hint).selected
setattr(ev, attr, s)
def drop_down_fun2(ev, attr):
s = getattr(ev, 'drop_friend_' + attr).selected
setattr(ev, attr, s)
def incredifun(thing, attr, fun, hint=None):
def clicky():
self.hint = hint
fun(thing, attr)
self.select_cutscene_action() # re-render controls
self.refresh_cutscene_actions(
) # re-render action descriptions
return clicky
# new s***e?
if self.selected_cutscene_action:
ev = self.selected_cutscene_action
def get_pos(add_x=20):
get_pos.x_pos += add_x
return 930 + get_pos.x_pos - add_x, 240 - get_pos.row * 20
get_pos.row = 0
get_pos.x_pos = 0
for k, v in ev.get_editor().iteritems():
add_control(
button.DefaultButton(self,
None,
get_pos(add_x=80),
text=k,
size=(80, 20)))
if v == 'int':
add_control(
button.DefaultButton(self,
incredifun(ev, k, int_dec_fun),
get_pos(),
text="-",
size=(20, 20)))
add_control(
button.DefaultButton(self,
None,
get_pos(add_x=50),
text=str(getattr(ev, k)),
size=(50, 20)))
add_control(
button.DefaultButton(self,
incredifun(ev, k, int_inc_fun),
get_pos(),
text="+",
size=(20, 20)))
elif v == 'string':
print('TODO string')
elif v == 'obj_ref':
add_control(
button.DefaultButton(self,
None,
get_pos(add_x=100),
text=getattr(ev, k),
size=(100, 20)))
if not (str(ev) + '-' + k) in self.highlighted:
add_control(
button.DefaultButton(self,
incredifun(
ev, k, obj_ref_sel_fun),
get_pos(50),
text="Pick",
size=(50, 20)))
else:
add_control(
button.Button(self,
incredifun(ev, k, obj_ref_sel_fun),
get_pos(50),
text="Pick",
size=(50, 20),
color=(0, 120, 0),
border_color=(0, 200, 0),
border_width=3))
elif v == 'coords':
add_control(
button.DefaultButton(self,
None,
get_pos(add_x=100),
text=str(getattr(ev, k)),
size=(100, 20)))
if not (str(ev) + '-' + k) in self.highlighted:
add_control(
button.DefaultButton(self,
incredifun(
ev, k, pick_coords_fun),
get_pos(50),
text="Pick",
size=(50, 20)))
else:
add_control(
button.Button(self,
incredifun(ev, k, pick_coords_fun),
get_pos(50),
text="Pick",
size=(50, 20),
color=(0, 120, 0),
border_color=(0, 200, 0),
border_width=3))
elif v == 'bool':
if getattr(ev, k):
add_control(
button.Button(self,
incredifun(ev, k, bool_toggle_fun),
get_pos(50),
text=u"\u2713",
color=(0, 120, 0),
border_color=(0, 200, 0),
size=(50, 20),
border_width=3))
else:
add_control(
button.DefaultButton(self,
incredifun(
ev, k, bool_toggle_fun),
get_pos(50),
text="x",
size=(50, 20)))
elif v == 'dialogue_file':
files = os.listdir(constants.DIALOGUE_DIR)
fd = {}
for f in files:
fd[f] = f
# hack!
self.dfc = add_control(
drop_down_list.DropDownList(self,
fd,
None,
get_pos(250),
size=(250, 20)))
if getattr(ev, k) is not None:
try:
self.dfc.list_func(getattr(ev, k))()
except:
self.dfc.list_func(None)()
setattr(ev, k, None)
self.dfc.function = incredifun(ev, k, drop_down_fun, 'dfc')
elif v == 'dialogue_heading':
# woo assumptions
dd = collections.OrderedDict()
try:
d = dialogue.load_dialogue(getattr(
ev, 'dialogue_file'))
for dk in d.keys():
dd[dk] = dk
except:
pass
# hack!
self.dhc = add_control(
drop_down_list.DropDownList(self,
dd,
None,
get_pos(250),
size=(250, 20)))
if getattr(ev, k) is not None:
try:
self.dhc.list_func(getattr(ev, k))()
except:
self.dhc.list_func(None)()
setattr(ev, k, None)
self.dhc.function = incredifun(ev, k, drop_down_fun, 'dhc')
elif v == 'string_drop_down':
dd = collections.OrderedDict()
try:
l = ev.get_autocomplete(k)
for dkey in l:
dd[dkey] = dkey
except:
pass
ddl = add_control(
drop_down_list.DropDownList(self,
dd,
None,
get_pos(250),
size=(250, 20)))
setattr(ev, 'drop_friend_' + k, ddl)
if getattr(ev, k) is not None:
try:
ddl.set_to_value(getattr(ev, k))
except:
ddl.set_to_default()
setattr(ev, k, None)
ddl.function = incredifun(ev, k, drop_down_fun2)
else:
print("!!! Cutscene action editor doesn't know what a '" +
v + "' is")
get_pos.x_pos = 0
get_pos.row += 1
def __init__(self, game, main_editor):
self.game = game
self.main_editor = main_editor
self.cutscenes = self.game.map.cutscenes.copy()
self.cutscenes['New... (TODO)'] = None
self.possible_cutscene_actions = cutscene.possible_actions
self.static_buttons = []
self.static_lists = []
def pu(tine):
if isinstance(tine, button.Button):
self.static_buttons.append(tine)
else:
self.static_lists.append(tine)
return tine
# Misc
self.toggle_button = pu(
button.DefaultButton(self,
self.toggle_visible,
pos=(0, window.height - 20),
size=(100, 20),
text="Cutscenes"))
self.toggle_button.enabled = True
self.cutscene_list = pu(
drop_down_list.DropDownList(self,
self.cutscenes,
self.select_cutscene,
pos=(980, window.height - 55),
size=(300, 20)))
self.cutscene_status_button = pu(
button.DefaultButton(self,
None,
pos=(1060, window.height - 75),
size=(1280 - 1060, 20),
text="No cutscene selected."))
# Cutscene playback controls
self.play_button = pu(
button.DefaultButton(self,
self.play_cutscene,
pos=(980, window.height - 75),
size=(20, 20),
text=u"\u25B6"))
self.play_and_run_button = pu(
button.DefaultButton(self,
self.play_cutscene_and_run,
pos=(1000, window.height - 75),
size=(40, 20),
text=u"\u25B6 R"))
self.stop_button = pu(
button.DefaultButton(self,
self.stop_cutscene,
pos=(1040, window.height - 75),
size=(20, 20),
text=u"\u25A0"))
# Controls to add new action
self.cutscene_new_action_list = pu(
drop_down_list.DropDownList(self,
cutscene.possible_actions,
None,
pos=(980, window.height - 95),
size=(280, 20)))
pu(
button.DefaultButton(self,
self.add_cutscene_action,
pos=(980 + 280, window.height - 95),
size=(20, 20),
text="+"))
# Manipulate action order
pu(
button.DefaultButton(self,
self.push_cutscene_action_up,
pos=(880, window.height - 115),
size=(50, 20),
text="push ^"))
pu(
button.DefaultButton(self,
self.push_cutscene_action_down,
pos=(880, window.height - 135),
size=(50, 20),
text="push v"))
pu(
button.DefaultButton(self,
self.delete_cutscene_action,
pos=(880, window.height - 155),
size=(50, 20),
text="-"))
pu(
button.DefaultButton(self,
self.scroll_cutscene_actions_up,
pos=(880, window.height - 175),
size=(50, 20),
text="more ^"))
pu(
button.DefaultButton(self,
self.scroll_cutscene_actions_down,
pos=(880, window.height - 195),
size=(50, 20),
text="more v"))
self.selected_cutscene = None
self.selected_cutscene_action = None
self.cutscene_actions_desc = collections.OrderedDict()
self.cutscene_actions_list = pu(
drop_down_list.DropDownList(self,
self.cutscene_actions_desc,
self.select_cutscene_action,
pos=(930, window.height - 95),
size=(350, 20)))
self.dyn_buttons = []
self.dyn_lists = []
self.playing = False
self.highlighted = []
self.hint = None
self.visible = False
self._update_visible()
def __init__(self, game):
self.game = game
self.save_state = None # to go back to when you re-open editor after testing your changes
self.undo_states = []
self.undo_index = 0
self.text_sprites = {}
self.font_size = 20
self.buttons = {}
self.drop_lists = {}
###################################################################
# Place new object
###################################################################
# self.possible_characters = character_objects.possible_characters
# self.possible_characters = dict(self.possible_characters.items() + prop_objects.possible_props.items())
self.possible_characters = {}
self.buttons['place_object_label'] = button.DefaultButton(
self, None, pos=(100, window.height - 20), text="Place Object")
self.drop_lists['place_object'] = drop_down_list.DropDownList(
self,
self.possible_characters,
self.update_object_prototype,
pos=(200, window.height - 20),
size=(100, 20))
self.object_prototype = None
self.get_possible_characters()
###################################################################
# Trigger Editor
###################################################################
self.trigger_editor = trigger_edit.TriggerEditor(self.game)
self.buttons['toggle_trigger_editor'] = self.trigger_editor.buttons[
'toggle_trigger_editor']
self.buttons = dict(self.buttons.items() +
self.trigger_editor.buttons.items())
self.drop_lists = dict(self.drop_lists.items() +
self.trigger_editor.drop_lists.items())
###################################################################
# Character Template Editor
###################################################################
self.character_template_editor = character_edit.CharacterTemplateEditor(
self.game, self)
self.buttons[
'toggle_char_edit'] = self.character_template_editor.toggle_button
# # add prefix to keys, then combine with main editor buttons
# char_edit_buttons_prefixed = {}
# for k, v in self.character_template_editor.buttons.iteritems():
# char_edit_buttons_prefixed[self.character_template_editor.pre + k] = v
#
#
# char_edit_lists_prefixed = {}
# for k, v in self.character_template_editor.drop_lists.iteritems():
# char_edit_lists_prefixed[self.character_template_editor.pre + k] = v
#
# self.buttons = dict(self.buttons.items() + char_edit_buttons_prefixed.items())
# self.drop_lists = dict(self.drop_lists.items() + char_edit_lists_prefixed.items())
###################################################################
# Edit object
###################################################################
# self.object_edit_buttons = []
# self.object_edit_lists = []
self.object_to_edit = None
self.object_to_edit_name = None
# self.show_fears_checklist = False
# self.show_scared_of_checklist = False
self.color = (120, 0, 0)
self.border_color = (120, 50, 80)
self.high_color = (0, 120, 0)
self.high_border_color = (0, 200, 0)
# self.possible_fears = get_fears_from_file()
# self.possible_fears.append(u'player')
# self.int_edits = {}
h_off = 10
v_off = 400
# self.create_checklist_buttons()
# #fears/scared_by checklist show/hide
# self.buttons['fears_checklist_toggle'] = button.DefaultButton(self, self.toggle_fears_checklist,
# pos=(window.width - 100 - h_off, window.height - v_off - 70),
# size=(100, 20), text="Fears")
# self.buttons['scared_of_checklist_toggle'] = button.DefaultButton(self, self.toggle_scared_of_checklist,
# pos=(window.width - 210 - h_off, window.height - v_off - 70),
# size=(100, 20), text="Scared Of")
#
# # speed and weight edit button sets.
# self.int_edits['normal_speed'] = IntEdit(self, (window.width - 210 - h_off, window.height - v_off - 35), 'normal_speed')
# self.int_edits['feared_speed'] = IntEdit(self, (window.width - 100 - h_off, window.height - v_off - 35), 'feared_speed')
# self.int_edits['collision_weight'] = IntEdit(self, (window.width - 320 - h_off, window.height - v_off - 35), 'collision_weight')
#
# for ie in self.int_edits.itervalues():
# self.buttons = dict(self.buttons.items() + ie.buttons.items())
# name edit
# age edit
# v_ind = 0
# # function edit
# self.show_function_edit = False
# self.function_edit_buttons = []
# self.function_edit_lists = []
# self.buttons['function_edit_toggle'] = button.DefaultButton(self, self.toggle_function_edit,
# pos=(window.width - 320 - h_off, window.height - v_off - 70),
# size=(100, 20), text="Function Edit", visible=False, enabled=False)
# self.object_edit_buttons.append('function_edit_toggle')
# for module, func_dict in character_functions.all_functions_dict.iteritems():
# #display button
# self.buttons[module] = button.DefaultButton(self, None,
# pos=(100, window.height - 200 - v_ind * 40),
# size=(200, 20), text=module, visible=False, enabled=False)
# self.function_edit_buttons.append(module)
# # drop list to choose funciton for each object event type
# self.drop_lists[module] = drop_down_list.DropDownList(self, func_dict,
# set_function(self, module), pos=(300, window.height - 200 - v_ind * 40),
# size=(200, 20), visible=False, enabled=False)
# self.function_edit_lists.append(module)
# v_ind += 1
self.buttons['delete_selection'] = button.DefaultButton(
self,
self.delete_selected_object,
pos=(window.width - 210 - h_off, window.height - v_off - 200),
size=(100, 20),
text="Delete Object",
visible=True)
#
#
# self.object_edit_buttons += ['fears_checklist_toggle', 'scared_of_checklist_toggle',
# 'normal_speed_label', 'normal_speed_increment', 'normal_speed_decrement', 'normal_speed_value',
# 'feared_speed_label', 'feared_speed_increment', 'feared_speed_decrement', 'feared_speed_value',
# 'collision_weight_label', 'collision_weight_increment', 'collision_weight_decrement', 'collision_weight_value',
# 'delete_selection']
# for v in self.object_edit_buttons:
# self.buttons[v].visible = False
# self.buttons[v].enabled = False
# for v in self.object_edit_lists:
# self.drop_lists[v].visible = False
# self.drop_lists[v].enabled = False
###################################################################
# Cutscene editor
###################################################################
self.cutscene_editor = cutscene.CutsceneEditor(self.game, self)
###################################################################
# Other buttons
###################################################################
self.buttons['save_map'] = button.DefaultButton(
self,
self.save_map,
pos=(window.width - 100 - h_off, window.height - v_off - 200),
size=(100, 20),
text="Save Map",
visible=True)
self.buttons['undo'] = button.DefaultButton(
self,
self.undo,
pos=(window.width - 210 - h_off, window.height - v_off - 170),
size=(100, 20),
text="Undo",
visible=True)
self.buttons['redo'] = button.DefaultButton(
self,
self.redo,
pos=(window.width - 100 - h_off, window.height - v_off - 170),
size=(100, 20),
text="Redo",
visible=True)
self.stored_button_enabled_state = {
'place_object_label': True,
'toggle_trigger_editor': True,
'delete_selection': True,
'toggle_char_edit': True,
'save_map': True,
'undo': True,
'redo': True
}
self.stored_list_enabled_state = {'place_object': True}
def refresh(self, new_items=None): # call if the list changes
if not new_items is None:
self.items = new_items
for b in self.drop_buttons:
b.delete()
self.drop_buttons = [
button.DefaultButton(self,
self.list_func(None),
size=self.size,
font_size=self.font_size,
visible=False,
text=u"<None>",
border_color=self.border_color,
border_width=self.border_width,
color=self.color,
batch=self._batch,
group=self._drop_group)
]
if isinstance(self.items, list):
for i in self.items:
if self.labels == 'func_name':
t = i.func_name
elif self.labels == 'classname':
t = i.__class__.__name__
else:
t = str(i)
self.drop_buttons.append(
button.DefaultButton(self,
self.list_func(i, t),
size=self.size,
font_size=self.font_size,
visible=False,
text=t,
border_color=self.border_color,
border_width=self.border_width,
color=self.color,
batch=self._batch,
group=self._drop_group))
else:
for k, v in self.items.iteritems():
if self.labels == 'classname':
t = v.__class__.__name__
t += ': '
t += unicode(k)
else:
t = unicode(k)
self.drop_buttons.append(
button.DefaultButton(self,
self.list_func(k, t),
size=self.size,
font_size=self.font_size,
visible=False,
text=t,
border_color=self.border_color,
border_width=self.border_width,
color=self.color,
batch=self._batch,
group=self._drop_group))
if not self.first_time: # prevent self.function() being run before the owner of this list is fully initialised
self.set_to_default()
else:
self.first_time = False
if self.open:
self.update_buttons()
