def __add_commands_of_action(self, class_name):
# Ask for the InitAction prototype
dlg = newcmddlg.NewInitActionCmdDlg(self)
result_ok = dlg.ShowModal() == wx.ID_OK
if result_ok:
init_proto = dlg.get_command_prototype()
else:
init_proto = 'b_init_o'
dlg.Destroy()
# Add action commands
self.__add_command(class_name, 'action_init', init_proto)
self.__add_command(class_name, 'action_run', 'b_run_v')
self.__add_command(class_name, 'action_end', 'v_end_v')
# Open InitAction script so the user doesn't
# forget to set the parameters
if result_ok:
cmd_unpath = self.__get_cmd_path(class_name, init_proto, True)
win = scripteditordlg.create_window(
app.get_top_window(),
cmd_unpath
)
win.display()
app.get_top_window().emit_app_event(
events.ActionAdded(class_name)
)
def on_inspect_class_button(self, event):
class_name = str(self.model.get_object_class())
entity_server = servers.get_entity_class_server()
class_to_inspect = entity_server.getentityclass(class_name)
win = objdlg.create_window(app.get_top_window(),
class_to_inspect.getfullname())
win.display()
def __save_docs(self):
dlg = waitdlg.WaitDialog(app.get_top_window())
for i in range(len(self.savers)):
if self.checklist.IsChecked(i):
dlg.set_message("Saving %s ..." % self.savers[i].get_brief())
self.savers[i].save()
dlg.Destroy()
def layer_can_be_deleted(layer):
""" Check that the layer can be deleted.
Warn the user if it isn't and return false.
Otherwise just return true. """
# check the layer has not been locked
layer_name = layer.getlayername()
if layer.islocked():
cjr.show_error_message(
"You cannot delete the '%s' layer.\n\n" \
"It is not possible to delete a locked layer." % layer_name
)
return False
# check that there're at least two layers
manager = servers.get_layer_manager()
if manager.getnumlayers() <= 1:
msg = "You cannot delete the '%s' layer.\n\n" \
"A level must always have at least one layer." % layer_name
cjr.show_error_message(msg)
return False
# check if there's some entity not marked as deleted within the layer
try:
try:
wx.BeginBusyCursor()
e_server = servers.get_entity_object_server()
entity = e_server.getfirstentityobject()
report = []
while entity is not None:
if entity.hascomponent('ncEditor'):
if not entity.isdeleted():
entity_layer_id = entity.getlayerid()
if entity_layer_id >= 0:
entity_layer = manager.searchlayerbyid(
entity_layer_id)
if entity_layer.getlayername() == layer_name:
entity_class = entity.getentityclass().getname(
)
entity_name = ""
if entity.hascomponent('ncGameplay'):
entity_name = entity.getname()
report.append((entity.getid(), entity_class,
entity_name))
entity = e_server.getnextentityobject()
finally:
wx.EndBusyCursor()
except:
# make sure any errors are not hidden
raise
# show a report about all the entities found in the layer, if any
if len(report) > 0:
caption = "Error deleting the '%s' layer" % layer_name
msg = "Unable to delete the '%s' layer because it " \
"still contains the following entities" % layer_name
log = (['Id', 'Class', 'Name'], report)
usagelog.UsageLogDialog(app.get_top_window(), caption, msg, log)
return False
return True
def edit_brushes(self):
# cannot edit brushes for default material
if not self.is_for_default_material():
dlg = grassbrushes.MaterialBrushesDialog(app.get_top_window(),
self.material)
dlg.ShowModal()
dlg.Destroy()
def __edit_command_of_class(self, class_name, cmd_name):
cmd_unpath = self.__get_cmd_path( class_name, cmd_name, True )
win = scripteditordlg.create_window(
app.get_top_window(),
cmd_unpath
)
win.display()
def on_new_cmd(self, event):
# Ask for a command prototype
dlg = newcmddlg.NewCommandDialog(self)
result_ok = dlg.ShowModal() == wx.ID_OK
if result_ok:
cmd_proto = dlg.get_command_prototype()
dlg.Destroy()
# Create and add the new command to the selected class
if result_ok:
# Get the class name for the new command
class_name = self.tree_classes.get_selected_class_name()
if class_name is None:
cjr.show_error_message(
"Cannot add commands to the selected class"
)
return
# Create an empty command for the selected class from a template
self.__add_command( class_name, 'command', cmd_proto )
# Add the new command to the command list
self.list_cmds.Append( cmd_proto )
servers.get_script_server().refreshclass( str(class_name) )
# Open for editing the new command script
cmd_unpath = self.__get_cmd_path(class_name, cmd_proto, True)
win = scripteditordlg.create_window(
app.get_top_window(),
cmd_unpath
)
win.display()
def __can_delete_selector(self, class_name):
usage_log = usagelog.find_fsm_selector( class_name )
if len( usage_log[1] ) > 0:
dlg = usagelog.DeleteErrorDialog(
app.get_top_window(),
"FSM selector '" + class_name + "'",
usage_log
)
dlg.Show()
return False
# Save FSMs to avoid inconsistences between memory and persisted states
# (and make the previous check valid)
delete = self.__save_fsms('FSM selector')
# Delete the singleton selector instance so the class can be deleted
if delete:
selector_path = format.append_to_path(
fsm.get_fsm_selectors_lib(),
class_name
)
try:
pynebula.delete( str(selector_path) )
except:
pass
return delete
def on_new_cmd(self, event):
# Ask for a command prototype
dlg = newcmddlg.NewCommandDialog(self)
result_ok = dlg.ShowModal() == wx.ID_OK
if result_ok:
cmd_proto = dlg.get_command_prototype()
dlg.Destroy()
# Create and add the new command to the selected class
if result_ok:
# Get the class name for the new command
class_name = self.tree_classes.get_selected_class_name()
if class_name is None:
cjr.show_error_message(
"Cannot add commands to the selected class")
return
# Create an empty command for the selected class from a template
self.__add_command(class_name, 'command', cmd_proto)
# Add the new command to the command list
self.list_cmds.Append(cmd_proto)
servers.get_script_server().refreshclass(str(class_name))
# Open for editing the new command script
cmd_unpath = self.__get_cmd_path(class_name, cmd_proto, True)
win = scripteditordlg.create_window(app.get_top_window(),
cmd_unpath)
win.display()
def postlevel_process(is_new_level):
if not is_new_level:
return
# What follows should be done only for new and open level commands
# Load the level preset
apply_level_preset()
# Set the new outdoor to the terrain state
if servers.get_conjurer().getcurrentstate() == 'terrain':
trn.get_terrain_module().setoutdoor(
app.get_outdoor_obj()
)
# End the persist-restore process (continue from prelevel_process)
# Close guiDialog windows
frame = app.get_top_window()
for child in frame.get_child_dialogs():
child.Close()
# Refresh other GUI features
frame.refresh_all()
# Restore persisted guiDialog windows
for data in prelevel_process.child_data:
restore_window(data)
prelevel_process.child_data = []
def on_select_colour(self):
# cannot change colour of default material
if not self.is_for_default_material():
dlg = grasscolor.MaterialColorDialog(app.get_top_window(),
self.material)
if dlg.ShowModal() == wx.ID_OK:
self.set_button_colour_from_material()
dlg.Destroy()
def _save_fsms(self):
msg = "Deleting a %s will save any modified finite state machine.\n\n" % self.caption
msg = msg + "Continue anyway?"
result = cjr.confirm_yes_no(self, msg)
delete = (result == wx.ID_YES)
if delete:
# Save modified FSMs
fsm_paths = fsm.get_fsms()
for fsm_path in fsm_paths:
sm = pynebula.lookup( fsm_path )
if sm.isdirty():
servers.get_fsm_server().savefsm( sm )
sm.setdirty( False )
app.get_top_window(self).emit_app_event(
events.FSMSaved( fsm_path )
)
return delete
def __save_fsms(self, caption):
msg = "Deleting a %s will save any modified " \
"finite state machine.\n\n" \
"Continue anyway?" % caption
result = cjr.confirm_yes_no(self, msg)
delete = (result == wx.ID_YES)
if delete:
# Save modified FSMs
fsm_paths = fsm.get_fsms()
for fsm_path in fsm_paths:
state_machine = pynebula.lookup(fsm_path)
if state_machine.isdirty():
servers.get_fsm_server().savefsm(state_machine)
state_machine.setdirty(False)
app.get_top_window().emit_app_event(
events.FSMSaved(fsm_path))
return delete
def __on_emitters(self, event):
if self.has_item_selected():
particle_system_name = self.get_selected_class_name()
win = particleemitdlg.create_window(app.get_top_window(),
str(particle_system_name))
win.display()
else:
cjr.show_error_message("Please select a Particle System.")
def on_zoom_texture(self, event):
material = self.__get_material()
tex_path = servers.get_file_server().manglepath(
material.gettexturethumbnail(0) )
dlg = imagepreview.PreviewDialog( app.get_top_window(self), tex_path,
self.get_texture_filename() )
dlg.Show()
os.remove( tex_path )
def open_inspector (self):
"""Open a property editor for selected entities"""
entity_list = self.get_selected_entities()
select_count = len(entity_list)
if select_count > 1:
model = scripting.ScriptingModelMultiObject(entity_list)
propertyview.create_window(
app.get_top_window(),
model
)
elif select_count == 1:
entity = entity_list[0]
entity_id = entity.getid()
win = objdlg.create_window(
app.get_top_window(),
entity_id
)
win.display()
def __save_docs(self):
dlg = waitdlg.WaitDialog( app.get_top_window() )
for i in range( len(self.savers) ):
if self.checklist.IsChecked(i):
dlg.set_message(
"Saving %s ..." % self.savers[i].get_brief()
)
self.savers[i].save()
dlg.Destroy()
def edit_brushes(self):
# cannot edit brushes for default material
if not self.is_for_default_material():
dlg = grassbrushes.MaterialBrushesDialog(
app.get_top_window(),
self.material
)
dlg.ShowModal()
dlg.Destroy()
def on_select_objects(self, event):
"""Set the selection objects mode"""
enabled = event.Checked()
self.Check(ID_SelectObjects, enabled)
msg = "Do you want to save subentity changes?"
result = cjr.confirm_yes_no(app.get_top_window(), msg)
save = (result == wx.ID_YES)
succeed = app.get_object_state().setselectionmode(0, save)
if succeed:
self.__get_toolbar().select_selection_mode(0)
def on_select_colour(self):
# cannot change colour of default material
if not self.is_for_default_material():
dlg = grasscolor.MaterialColorDialog(
app.get_top_window(),
self.material
)
if dlg.ShowModal() == wx.ID_OK:
self.set_button_colour_from_material()
dlg.Destroy()
def __on_change_name(self, event):
# Change the FSM file and object names
fsm = pynebula.lookup( self.fsm_path )
old_name = str( format.get_name( self.fsm_path ) )
new_name = str( self.text_name.get_value() )
fsm.setname( new_name )
servers.get_fsm_server().savefsm( fsm )
fsm.setname( old_name )
servers.get_fsm_server().erasefsm( fsm )
fsm.setname( new_name )
# Update the controls
self.fsm_path = fsm.getfullname()
self.ctrl_states.set_fsm( self.fsm_path )
self.ctrl_statetype.set_state(None)
self.ctrl_transitions.set_state(None)
# self.ctrl_emotactions.set_state(None)
# Notify change to update the name in the FSM library
app.get_top_window(self).emit_app_event( events.FSMNameChanged(
new_name=new_name, old_name=old_name ) )
fsmevents.signal_fsm_change( self, fsmevents.ID_FSMNameChanged, self.fsm_path )
def on_inspect_class_button(self, event):
class_name = str( self.model.get_object_class() )
entity_server = servers.get_entity_class_server()
class_to_inspect = entity_server.getentityclass(
class_name
)
win = objdlg.create_window(
app.get_top_window(),
class_to_inspect.getfullname()
)
win.display()
def __on_change_name(self, event):
# Change the FSM file and object names
fsm = pynebula.lookup(self.fsm_path)
old_name = str(format.get_name(self.fsm_path))
new_name = str(self.text_name.get_value())
fsm.setname(new_name)
servers.get_fsm_server().savefsm(fsm)
fsm.setname(old_name)
servers.get_fsm_server().erasefsm(fsm)
fsm.setname(new_name)
# Update the controls
self.fsm_path = fsm.getfullname()
self.ctrl_states.set_fsm(self.fsm_path)
self.ctrl_statetype.set_state(None)
self.ctrl_transitions.set_state(None)
# self.ctrl_emotactions.set_state(None)
# Notify change to update the name in the FSM library
app.get_top_window(self).emit_app_event(
events.FSMNameChanged(new_name=new_name, old_name=old_name))
fsmevents.signal_fsm_change(self, fsmevents.ID_FSMNameChanged,
self.fsm_path)
def __on_emitters(self, event):
if self.has_item_selected():
particle_system_name = self.get_selected_class_name()
win = particleemitdlg.create_window(
app.get_top_window(),
str(particle_system_name)
)
win.display()
else:
cjr.show_error_message(
"Please select a Particle System."
)
def __can_delete_action(self, class_name):
usage_log = usagelog.find_behaviour_action(class_name)
if len(usage_log[1]) > 0:
dlg = usagelog.DeleteErrorDialog(
app.get_top_window(), "behaviour action '" + class_name + "'",
usage_log)
dlg.Show()
return False
# Save FSMs to avoid inconsistences between memory and persisted states
# (and make the previous check valid)
return self.__save_fsms('behaviour action')
def __on_edit(self, event):
if self.has_item_selected():
particle_system = self.get_selected_class()
try:
wx.BeginBusyCursor()
win = objdlg.create_window(app.get_top_window(),
particle_system.getfullname())
finally:
wx.EndBusyCursor()
win.display()
else:
cjr.show_error_message("Please select a Particle System to edit.")
def on_select_objects(self, event):
"""Set the selection objects mode"""
enabled = event.Checked()
self.Check( ID_SelectObjects, enabled )
msg = "Do you want to save subentity changes?"
result = cjr.confirm_yes_no(
app.get_top_window(),
msg
)
save = (result == wx.ID_YES)
succeed = app.get_object_state().setselectionmode( 0, save )
if succeed:
self.__get_toolbar().select_selection_mode( 0 )
def on_export_entities(self, event):
"""Open an export dialog"""
if self.layer_selected is None:
cjr.show_error_message("Please select a layer")
return
entity_list = self.get_all_exportable_entities_for_selected_layer()
if entity_list:
dialog = expentdlg.create_window(app.get_top_window(), entity_list)
dialog.ShowModal()
dialog.Destroy()
else:
cjr.show_error_message(
"There are no entities available for export in this layer")
def on_pg_right_click(self, event):
""" Open an inspector if the click property is an object """
pid = event.get_value()
prop_type = self.pg.get_property_type(pid)
if prop_type == propgrid.Type_Object:
prop_value = self.pg.get_property_value(pid)
if prop_value is not None:
obj_type = self.model.get_object_type()
if obj_type == "nroot" or obj_type == "entityclass":
prop_value = prop_value.getfullname()
win = objdlg.create_window(app.get_top_window(), prop_value)
win.display()
event.Skip()
def on_ok(self, event):
if self.button_texture.GetLabel() == "<default>":
entity_class = particle.CreateClass( str(self.text_name.GetValue()), self.target_library )
else:
texture = format.append_to_path( "wc:export/textures", self.button_texture.GetLabel() )
entity_class = particle.CreateClass( str(self.text_name.GetValue()), self.target_library, str(texture) )
if entity_class is None:
wx.MessageBox( "Couldn't create the particle system class named '" \
+ self.text_name.GetValue() + "'", "Conjurer",
style=wx.ICON_ERROR )
else:
objdlg.create_window( app.get_top_window(), entity_class.getfullname() )
self.EndModal(wx.ID_OK)
def __can_delete_action(self, class_name):
usage_log = usagelog.find_behaviour_action( class_name )
if len( usage_log[1] ) > 0:
dlg = usagelog.DeleteErrorDialog(
app.get_top_window(),
"behaviour action '" + class_name + "'",
usage_log
)
dlg.Show()
return False
# Save FSMs to avoid inconsistences between memory and persisted states
# (and make the previous check valid)
return self.__save_fsms('behaviour action')
def open_export_dialog(self):
"""Open an export dialog for the selected entities"""
entity_list = self.get_selected_entities_ok_for_export()
select_count = len(entity_list)
if select_count > 0:
dialog = expentdlg.createWindow(
app.get_top_window(),
entity_list
)
dialog.ShowModal()
dialog.Destroy()
else:
cjr.show_error_message(
"There are no entities currently selected"
)
def __add_commands_of_action(self, class_name):
# Ask for the InitAction prototype
dlg = newcmddlg.NewInitActionCmdDlg(self)
result_ok = dlg.ShowModal() == wx.ID_OK
if result_ok:
init_proto = dlg.get_command_prototype()
else:
init_proto = 'b_init_o'
dlg.Destroy()
# Add action commands
self.__add_command(class_name, 'action_init', init_proto)
self.__add_command(class_name, 'action_run', 'b_run_v')
self.__add_command(class_name, 'action_end', 'v_end_v')
# Open InitAction script so the user doesn't
# forget to set the parameters
if result_ok:
cmd_unpath = self.__get_cmd_path(class_name, init_proto, True)
win = scripteditordlg.create_window(app.get_top_window(),
cmd_unpath)
win.display()
app.get_top_window().emit_app_event(events.ActionAdded(class_name))
def __on_edit(self, event):
if self.has_item_selected():
particle_system = self.get_selected_class()
try:
wx.BeginBusyCursor()
win = objdlg.create_window(
app.get_top_window(),
particle_system.getfullname()
)
finally:
wx.EndBusyCursor()
win.display()
else:
cjr.show_error_message(
"Please select a Particle System to edit."
)
def on_pg_right_click (self, event):
""" Open an inspector if the click property is an object """
pid = event.get_value()
prop_type = self.pg.get_property_type(pid)
if prop_type == propgrid.Type_Object:
prop_value = self.pg.get_property_value(pid)
if prop_value is not None:
obj_type = self.model.get_object_type()
if obj_type == "nroot" or obj_type == "entityclass":
prop_value = prop_value.getfullname()
win = objdlg.create_window(
app.get_top_window(),
prop_value
)
win.display()
event.Skip()
def on_export_entities(self, event):
"""Open an export dialog"""
if self.layer_selected is None:
cjr.show_error_message("Please select a layer")
return
entity_list = self.get_all_exportable_entities_for_selected_layer()
if entity_list:
dialog = expentdlg.create_window(
app.get_top_window(),
entity_list
)
dialog.ShowModal()
dialog.Destroy()
else:
cjr.show_error_message(
"There are no entities available for export in this layer"
)
def __on_left_dlcick (self, event):
# get entity id
row_index = event.GetRow()
row_data = self.__get_data_for_row(row_index)
an_id = row_data[0]
if self.parent.modal:
entity_name = row_data[2]
string_to_show = "%s (id = %s)" % ( entity_name, str(an_id) )
grand_parent = self.parent.GetParent()
grand_parent.SetTitle(string_to_show)
grand_parent.Hide()
grand_parent.EndModal(wx.ID_OK)
else:
# show an inspector window for the entity
win = objdlg.create_window(
app.get_top_window(),
an_id
)
win.display()
def __on_selection_mode(self, event):
mode = self.choice_selection_mode.GetSelection()
menu = self.GetParent().get_menubar().get_menu('&View')
succeed = False
if mode == 0 and app.is_subentity_mode_active():
result = cjr.confirm_yes_no(
app.get_top_window(), "Do you want to save subentity changes?")
save = (result == wx.ID_YES)
succeed = app.get_object_state().setselectionmode(mode, save)
else:
succeed = app.get_object_state().setselectionmode(mode, False)
if succeed:
if mode == 0:
id_selection = viewcmds.ID_SelectObjects
elif mode == 1:
id_selection = viewcmds.ID_SelectWaypoints
else:
id_selection = viewcmds.ID_SelectTerrainCells
menu.Check(id_selection, True)
def prelevel_process(is_new_level):
# Forbid any level operation while in game mode
if app.is_in_gameplay_mode():
cjr.show_error_message(
"Operation not allowed while in game mode"
)
return False
# Exit from any test mode
app.get_ai_tester().disablegameplayupdating()
app.get_ai_tester().disablesoundsources()
# Clear undo buffer
servers.get_command_server().clean()
if not is_new_level:
return True
# Discard deleted entities
servers.get_entity_object_server().discarddeletedobjects()
servers.get_entity_class_server().discarddeletedclasses()
# What follows should be done only for new and open level commands
# Clear selection
app.get_object_state().resetselection()
# Make terrain state release some buffers
if servers.get_conjurer().getcurrentstate() == 'terrain':
trn.get_terrain_module().setoutdoor(None)
# Begin a persist-restore process to close those invalid windows for
# the new level and refresh the valid ones (continue in postlevel_process)
# Persist guiDialog windows
frame = app.get_top_window()
prelevel_process.child_data = []
for child in frame.get_child_dialogs():
data = persist_window(child)
if data is not None:
prelevel_process.child_data.insert(0, data)
return True
def __can_delete_selector(self, class_name):
usage_log = usagelog.find_fsm_selector(class_name)
if len(usage_log[1]) > 0:
dlg = usagelog.DeleteErrorDialog(
app.get_top_window(), "FSM selector '" + class_name + "'",
usage_log)
dlg.Show()
return False
# Save FSMs to avoid inconsistences between memory and persisted states
# (and make the previous check valid)
delete = self.__save_fsms('FSM selector')
# Delete the singleton selector instance so the class can be deleted
if delete:
selector_path = format.append_to_path(fsm.get_fsm_selectors_lib(),
class_name)
try:
pynebula.delete(str(selector_path))
except:
pass
return delete
def __on_selection_mode(self, event):
mode = self.choice_selection_mode.GetSelection()
menu = self.GetParent().get_menubar().get_menu('&View')
succeed = False
if mode == 0 and app.is_subentity_mode_active():
result = cjr.confirm_yes_no(
app.get_top_window(),
"Do you want to save subentity changes?"
)
save = (result == wx.ID_YES)
succeed = app.get_object_state().setselectionmode( mode, save )
else:
succeed = app.get_object_state().setselectionmode( mode, False )
if succeed:
if mode == 0:
id_selection = viewcmds.ID_SelectObjects
elif mode == 1:
id_selection = viewcmds.ID_SelectWaypoints
else:
id_selection = viewcmds.ID_SelectTerrainCells
menu.Check( id_selection, True )
def prelevel_process(is_new_level):
# Forbid any level operation while in game mode
if app.is_in_gameplay_mode():
cjr.show_error_message("Operation not allowed while in game mode")
return False
# Exit from any test mode
app.get_ai_tester().disablegameplayupdating()
app.get_ai_tester().disablesoundsources()
# Clear undo buffer
servers.get_command_server().clean()
if not is_new_level:
return True
# Discard deleted entities
servers.get_entity_object_server().discarddeletedobjects()
servers.get_entity_class_server().discarddeletedclasses()
# What follows should be done only for new and open level commands
# Clear selection
app.get_object_state().resetselection()
# Make terrain state release some buffers
if servers.get_conjurer().getcurrentstate() == 'terrain':
trn.get_terrain_module().setoutdoor(None)
# Begin a persist-restore process to close those invalid windows for
# the new level and refresh the valid ones (continue in postlevel_process)
# Persist guiDialog windows
frame = app.get_top_window()
prelevel_process.child_data = []
for child in frame.get_child_dialogs():
data = persist_window(child)
if data is not None:
prelevel_process.child_data.insert(0, data)
return True
def postlevel_process(is_new_level):
if not is_new_level:
return
# What follows should be done only for new and open level commands
# Load the level preset
apply_level_preset()
# Set the new outdoor to the terrain state
if servers.get_conjurer().getcurrentstate() == 'terrain':
trn.get_terrain_module().setoutdoor(app.get_outdoor_obj())
# End the persist-restore process (continue from prelevel_process)
# Close guiDialog windows
frame = app.get_top_window()
for child in frame.get_child_dialogs():
child.Close()
# Refresh other GUI features
frame.refresh_all()
# Restore persisted guiDialog windows
for data in prelevel_process.child_data:
restore_window(data)
prelevel_process.child_data = []
def select_current_tool(self):
self.terrain.selecttool( self.GetSelection() )
self.terrain.setpaintbrushsize(
self.GetParent().slider_size.get_value()
)
app.get_top_window(self).get_menubar().get_menu('T&ools').on_terrain_tool(None)
def open_log_group_editor(self, log_class_name):
win = loggrpdlg.create_window(app.get_top_window(), log_class_name)
win.display()
def on_help(self, event):
iehelpwindow.CreateWindow( app.get_top_window(self),
"http://thezombieengine.sourceforge.net/SWD+Nebula+Conjurer+FSM+editor" )
def __add_commands_of_condition(self, class_name):
self.__add_command(class_name, 'condition', 'b_evaluate_o')
app.get_top_window().emit_app_event(events.ConditionAdded(class_name))
def __add_commands_of_selector(self, class_name):
self.__add_command(class_name, 'fsmselector', 's_SelectFSM_o')
app.get_top_window().emit_app_event(
events.FSMSelectorAdded(class_name)
)
def __add_commands_of_trigger(self, class_name):
self.__add_command(class_name, 'trigger_output', 'v_ExecuteOutput_oo')
app.get_top_window().emit_app_event(
events.TriggerScriptAdded(class_name)
)
def layer_can_be_deleted(layer):
""" Check that the layer can be deleted.
Warn the user if it isn't and return false.
Otherwise just return true. """
# check the layer has not been locked
layer_name = layer.getlayername()
if layer.islocked():
cjr.show_error_message(
"You cannot delete the '%s' layer.\n\n" \
"It is not possible to delete a locked layer." % layer_name
)
return False
# check that there're at least two layers
manager = servers.get_layer_manager()
if manager.getnumlayers() <= 1:
msg = "You cannot delete the '%s' layer.\n\n" \
"A level must always have at least one layer." % layer_name
cjr.show_error_message(msg)
return False
# check if there's some entity not marked as deleted within the layer
try:
try:
wx.BeginBusyCursor()
e_server = servers.get_entity_object_server()
entity = e_server.getfirstentityobject()
report = []
while entity is not None:
if entity.hascomponent('ncEditor'):
if not entity.isdeleted():
entity_layer_id = entity.getlayerid()
if entity_layer_id >= 0:
entity_layer = manager.searchlayerbyid(
entity_layer_id
)
if entity_layer.getlayername() == layer_name:
entity_class = entity.getentityclass().getname()
entity_name = ""
if entity.hascomponent('ncGameplay'):
entity_name = entity.getname()
report.append(
(entity.getid(), entity_class, entity_name)
)
entity = e_server.getnextentityobject()
finally:
wx.EndBusyCursor()
except:
# make sure any errors are not hidden
raise
# show a report about all the entities found in the layer, if any
if len( report ) > 0:
caption = "Error deleting the '%s' layer" % layer_name
msg = "Unable to delete the '%s' layer because it " \
"still contains the following entities" % layer_name
log = ( ['Id', 'Class', 'Name'], report )
usagelog.UsageLogDialog(
app.get_top_window(),
caption,
msg,
log
)
return False
return True
def __add_commands_of_trigger(self, class_name):
self.__add_command(class_name, 'trigger_output', 'v_ExecuteOutput_oo')
app.get_top_window().emit_app_event(
events.TriggerScriptAdded(class_name))
def __add_commands_of_selector(self, class_name):
self.__add_command(class_name, 'fsmselector', 's_SelectFSM_o')
app.get_top_window().emit_app_event(
events.FSMSelectorAdded(class_name))
def select_current_tool(self):
self.terrain.selecttool(self.GetSelection())
self.terrain.setpaintbrushsize(
self.GetParent().slider_size.get_value())
app.get_top_window(self).get_menubar().get_menu(
'T&ools').on_terrain_tool(None)
def on_button_inspect_clicked(self, event):
win = objdlg.create_window(
app.get_top_window(),
self.entity.getid()
)
win.display()
def __edit_command_of_class(self, class_name, cmd_name):
cmd_unpath = self.__get_cmd_path(class_name, cmd_name, True)
win = scripteditordlg.create_window(app.get_top_window(), cmd_unpath)
win.display()
