#!/usr/bin/env python
import gtk,gtk.glade
import gobject
import os
import data
class Space:
def __init__(self, factions=None, fleets=None, commodities=None):
self.space_glade = "space.glade"
self.planet_glade = "planets.glade"
self.systemsXML = "../../dat/ssys.xml"
self.planetsXML = "../../dat/planet.xml"
self.planet_gfx = "../../gfx/planet/"
self.loadSystems(self.systemsXML)
self.loadPlanets(self.planetsXML)
self.factions = {} if factions is None else factions
self.fleets = {} if fleets is None else fleets
self.commodities = {} if commodities is None else commodities
self.swtree = None
self.pwtree = None
def loadSystems(self, xmlfile):
self.systems = data.load(xmlfile, "ssys", True,
["jumps", "planets"], {"fleets":"chance"} )
def saveSystems(self, xmlfile):
data.save( "ssys.xml", self.systems, "Systems", "ssys", True,
{"jumps":"jump","planets":"planet"}, {"fleets":["fleet","chance"]})
def loadPlanets(self, xmlfile):
self.planets = data.load(xmlfile, "planet", True, ["commodities"])
def savePlanets(self, xmlfile):
data.save("planet.xml", self.planets, "Planets", "planet", True,
{ "commodities":"commodity" })
def __genPlanetTree(self):
self.planetTree = {}
# Set planets to none.
for planet in self.planets.keys():
self.planetTree[planet] = None
# Set allocated planets.
for name, system in self.systems.items():
for planet in system["planets"]:
self.planetTree[planet] = name
def window(self):
self.windowSystem()
self.windowPlanet()
def windowSystem(self):
"""
create the window
"""
# --------------- SYSTEMS --------------------
self.swtree = gtk.glade.XML(self.space_glade, "winSystems")
# Hook events and stuff.
hooks = {
"winSystems":["destroy",self.__done],
"treSystems":["button-release-event", self.__supdate],
"inpName":["changed", self.__supdate],
"butDone":["clicked", self.__done],
"butSave":["clicked",self.saveSystems],
"butZoomIn":["clicked", self.__space_zoomin],
"butZoomOut":["clicked", self.__space_zoomout],
"butReset":["clicked", self.__space_reset],
"butAddJump":["clicked", self.__jump_add],
"butRmJump":["clicked", self.__jump_rm],
"butNew":["clicked", self.__snew],
"butFleetAdd":["clicked", self.__fleet_add],
"butFleetRemove":["clicked", self.__fleet_rm]
}
for key, val in hooks.items():
self.__swidget(key).connect(val[0], val[1])
self.__create_treSystems()
# Custom widget drawing area thingy.
self.zoom = 1
self.space_sel = ""
area = self.__swidget("draSpace")
area.set_double_buffered(True)
area.set_events(gtk.gdk.EXPOSURE_MASK
| gtk.gdk.LEAVE_NOTIFY_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK)
area.connect("expose-event", self.__space_draw)
area.connect("button-press-event", self.__space_down)
area.connect("motion-notify-event", self.__space_drag)
# Factions.
wgt = self.__swidget("comFleets")
combo = gtk.ListStore(str)
combo.append(["None"])
for f in self.fleets.keys():
node = combo.append([f])
cell = gtk.CellRendererText()
wgt.pack_start(cell, True)
wgt.add_attribute(cell, 'text', 0)
wgt.set_model(combo)
wgt.set_active(0)
# Display the window and such.
self.__swidget("winSystems").show_all()
self.cur_system = ""
self.x = self.y = 0
self.lx = self.ly = 0
def windowSystemClose(self):
wgt = self.__swidget("winSystems")
if wgt != None:
wgt.hide_all()
def windowPlanet(self):
# ---------------- PLANETS --------------------
self.pwtree = gtk.glade.XML(self.planet_glade, "winPlanets")
self.__pwidget("winPlanets").show_all()
self.cur_planet = ""
# Hooks.
hooks = {
"butNew":["clicked", self.__pnew],
"trePlanets":["button-release-event", self.__pupdate],
"comSystem":["changed", self.__pnewSys],
"comFaction":["changed", self.__pnewFact],
"comClass":["changed", self.__class_sel],
"butSave":["clicked", self.savePlanets],
"butComAdd":["clicked", self.__commodity_add],
"butComRm":["clicked", self.__commodity_rm],
"comSpace":["changed", self.__space_sel],
"comExterior":["changed", self.__exterior_sel],
"butDescription":["clicked", self.__edit_description],
"butBar":["clicked", self.__edit_bar]
}
for key, val in hooks.items():
self.__pwidget(key).connect(val[0], val[1])
# Planet tree.
self.__create_trePlanets()
# Classes.
classes = [ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
"M", "O", "P", "Q", "R", "S", "T", "X", "Y", "Z",
"0", "1", "2", "3"]
wgt = self.__pwidget("comClass")
combo = gtk.ListStore(str)
for c in classes:
node = combo.append(c)
cell = gtk.CellRendererText()
wgt.pack_start(cell, True)
wgt.add_attribute(cell, 'text', 0)
wgt.set_model(combo)
wgt.set_active(0)
# Factions.
wgt = self.__pwidget("comFaction")
combo = gtk.ListStore(str)
combo.append(["None"])
for f in self.factions.keys():
node = combo.append([f])
cell = gtk.CellRendererText()
wgt.pack_start(cell, True)
wgt.add_attribute(cell, "text", 0)
wgt.set_model(combo)
wgt.set_active(0)
# Commodities.
wgt = self.__pwidget("comCommodities")
combo.append(["None"])
for c in self.commodities.keys():
node = combo.append([c])
cell = gtk.CellRendererText()
wgt.pack_start(cell, True)
wgt.add_attribute(cell, 'text', 0)
wgt.set_model(combo)
wgt.set_active(0)
# Graphics - space.
wgt = self.__pwidget("comSpace")
combo = gtk.ListStore(str)
combo.append(["None"])
for gfx in os.listdir(self.planet_gfx+"space"):
if gfx[-4:] == ".png":
node = combo.append([gfx])
cell = gtk.CellRendererText()
wgt.pack_start(cell, True)
wgt.add_attribute(cell, 'text', 0)
wgt.set_model(combo)
wgt.set_active(0)
# Graphics - exterior.
wgt = self.__pwidget("comExterior")
combo = gtk.ListStore(str)
combo.append(["None"])
for gfx in os.listdir(self.planet_gfx+"exterior"):
if gfx[-4:] == ".png":
node = combo.append([gfx])
cell = gtk.CellRendererText()
wgt.pack_start(cell, True)
wgt.add_attribute(cell, 'text', 0)
wgt.set_model(combo)
wgt.set_active(0)
def windowPlanetClose(self):
wgt = self.__pwidget("winPlanets")
if wgt != None:
wgt.hide_all()
def __create_treSystems(self):
# Populate the tree.
wgt = self.__swidget("treSystems")
self.tree_systems = gtk.TreeStore(str)
for system in self.systems: # Load the planets.
treenode = self.tree_systems.append(None, [system])
for planet in self.systems[system]['planets']:
self.tree_systems.append(treenode, [planet])
col = gtk.TreeViewColumn('Systems')
cell = gtk.CellRendererText()
if wgt.get_column(0):
wgt.remove_column(wgt.get_column(0))
wgt.append_column(col)
col.pack_start(cell, True)
col.add_attribute(cell, 'text', 0)
wgt.set_model(self.tree_systems)
def __create_trePlanets(self):
# Population.
wgt = self.__pwidget("trePlanets")
self.tree_planets = gtk.TreeStore(str)
for planet in self.planets:
treenode = self.tree_planets.append(None, [planet])
col = gtk.TreeViewColumn('Planets')
cell = gtk.CellRendererText()
if wgt.get_column(0):
wgt.remove_column(wgt.get_column(0))
wgt.append_column(col)
col.pack_start(cell, True)
col.add_attribute(cell, 'text', 0)
wgt.set_model(self.tree_planets)
def __create_treCommodities(self):
# Treeview.
wgt = self.__pwidget("treCommodities")
self.tree_commodities = gtk.TreeStore(str)
try:
for commodity in self.planets[self.cur_planet]["general"]["commodities"]:
treenode = self.tree_commodities.append(None, [commodity])
except:
commodity = None
col = gtk.TreeViewColumn('Commodities')
cell = gtk.CellRendererText()
if wgt.get_column(0):
wgt.remove_column(wgt.get_column(0))
wgt.append_column(col)
col.pack_start(cell, True)
col.add_attribute(cell, 'text', 0)
wgt.set_model(self.tree_commodities)
def __swidget(self,wgtname):
"""
get a widget from the winSystems
"""
return self.swtree.get_widget(wgtname)
def __pwidget(self, wgtname):
return self.pwtree.get_widget(wgtname)
def __supdate(self, wgt=None, index=None, iter=None):
"""
Update the window
"""
# Store the current values.
self.__sstore()
self.cur_system = self.__curSystem()
if self.cur_system == "":
return
system = self.systems[self.cur_system]
# Load it all.
dic = {
"inpName":self.cur_system,
"spiInterference":system["general"]["interference"],
"spiAsteroids":system["general"]["asteroids"],
"spiStars":system["general"]["stars"],
"labPos":"%s,%s" % (system["pos"]["x"],system["pos"]["y"])
}
for key, value in dic.items():
self.__swidget(key).set_text(str(value))
# Load jumps.
jumps = gtk.ListStore(str)
for jump in system["jumps"]: # Load the planets.
treenode = jumps.append([jump])
col = gtk.TreeViewColumn('Jumps')
cell = gtk.CellRendererText()
wgt = self.__swidget("treJumps")
if wgt.get_column(0):
wgt.remove_column( wgt.get_column(0) )
wgt.append_column(col)
col.pack_start(cell, True)
col.add_attribute(cell, 'text', 0)
wgt.set_model(jumps)
# Load fleets.
fleets = gtk.ListStore(str, int)
for item in system["fleets"]:
for fleet, chance in item.items():
treenode = fleets.append([fleet, int(chance)])
wgt = self.__swidget("treFleets")
if wgt.get_column(0):
wgt.remove_column(wgt.get_column(0))
wgt.remove_column(wgt.get_column(0))
columns = [None]*2
columns[0] = gtk.TreeViewColumn('Fleet')
columns[1] = gtk.TreeViewColumn('Chance')
for n in range(2):
wgt.append_column(columns[n])
columns[n].cell = gtk.CellRendererText()
columns[n].pack_start(columns[n].cell, True)
columns[n].set_attributes(columns[n].cell, text = n)
wgt.set_model(fleets)
self.__space_draw()
def __pupdate(self, wgt=None, event=None):
# Store the current values
if self.cur_planet != self.__curPlanet():
self.__pstore()
self.__genPlanetTree()
self.cur_planet = self.__curPlanet()
if self.cur_planet == "":
return
planet = self.planets[self.cur_planet]
dic = {
"inpName":self.cur_planet
}
for key, value in dic.items():
self.__pwidget(key).set_text(str(value))
# Class.
cls = planet["general"]["class"]
i = 0
wgt = self.__pwidget("comClass")
model = wgt.get_model()
for row in model:
if row[0] == cls:
wgt.set_active_iter(model.get_iter(i))
i = i + 1
# Faction.
wgt = self.__pwidget("comFaction")
try:
fact = planet["general"]["faction"]
i = 0
model = wgt.get_model()
for row in model:
if row[0] == fact:
wgt.set_active(i)
i = i + 1
except:
wgt.set_active(0) # None.
# gfx - space.
space = planet["GFX"]["space"]
i = 0
wgt = self.__pwidget("comSpace")
model = wgt.get_model()
for row in model:
if row[0] == space:
wgt.set_active_iter(model.get_iter(i))
i = i+1
# gfx - exterior.
wgt = self.__pwidget("comExterior")
model = wgt.get_model()
try:
exterior = planet["GFX"]["exterior"]
i = 0
for row in model:
if row[0] == exterior:
wgt.set_active_iter(model.get_iter(i))
i = i+1
except:
wgt.set_active_iter(model.get_iter(0))
# Tech.
try:
self.__pwidget("spiTech0").set_text(str(planet["general"]["tech"]["main"]))
except:
self.__pwidget("spiTech0").set_text(str(0))
# Services.
services = int(planet["general"]["services"])
serv = {
"cheLand":2**0,
"cheBasic":2**1,
"cheCommodity":2**2,
"cheOutfits":2**3,
"cheShipyard":2**4,
}
for s, m in serv.items():
if services & m > 0:
self.__pwidget(s).set_active(True)
else:
self.__pwidget(s).set_active(False)
self.__pwidget("imaPlanet").set_from_file(self.planet_gfx + "space/" +
planet["GFX"]["space"])
# System.
wgt = self.__pwidget("comSystem")
combo = gtk.ListStore(str)
for sysname in self.systems.keys():
node = combo.append([sysname])
cell = gtk.CellRendererText()
if wgt.get_model() == None:
wgt.pack_start(cell, True)
wgt.add_attribute(cell, 'text', 0)
wgt.set_model(combo)
self.__genPlanetTree()
i = 0
for row in combo:
if row[0] == self.planetTree[self.cur_planet]:
wgt.set_active_iter(combo.get_iter(i))
i = i + 1
# Commodities.
self.__create_treCommodities()
def __sstore(self):
sys_name = self.__swidget("inpName").get_text()
if sys_name == "":
return
# Renamed the current system.
if sys_name != self.cur_system:
self.systems[sys_name] = self.systems[self.cur_system] # Copy it over.
model = self.__swidget("treSystems").get_model()
# Must rename the node in the treeview.
for i in model:
if i[0] == self.cur_system:
i[0] = sys_name
break
# Update the jump paths.
for key, value in self.systems.items():
i = 0
for jump in value["jumps"]:
if jump == self.cur_system:
self.systems[key]["jumps"].pop(i)
self.systems[key]["Jumps"].append(sys_name)
i = i+1
# Delete the old system and change current to it.
del self.systems[self.cur_system] # Get rid of the old one.
self.cur_system = sys_name # Now use self.cur_system again.
try:
system = self.systems[self.cur_system]
except:
return # No system selected yet.
# Start to load all the input stuff.
# General crap.
self.__sinpStore(system, "spiStars", "general", "stars")
self.__sinpStore(system, "spiInterference", "general", "interference")
self.__sinpStore(system, "spiAsteroids", "general", "asteroids")
def __pstore(self):
planet_name = self.__pwidget("inpName").get_text()
if planet_name == "":
return
# Changed planet name.
if planet_name != self.cur_planet:
self.planets[planet_name] = self.planets[self.cur_planet]
model = self.__pwidget("trePlanets").get_model()
for i in model:
if i[0] == self.cur_planet:
i[0] = planet_name
break
del self.planets[self.cur_planet]
self.cur_planet = planet_name
try:
planet = self.planets[self.cur_planet]
except:
return
# Get the service.
services = 0
serv = {
"cheLand":2**0,
"cheBasic":2**1,
"cheCommodity":2**2,
"cheOutfits":2**3,
"cheShipyard":2**4
}
for s, m in serv.items():
if self.__pwidget(s).get_active():
services = services + m
planet["general"]["services"] = services
# Get the techs.
tech0 = self.__pwidget("spiTech0").get_text()
if tech0 > 0:
try:
planet["general"]["tech"]["main"] = tech0
except:
planet["general"]["tech"] = {}
planet["general"]["tech"]["main"] = tech0
else:
del planet["general"]["tech"]["main"]
def __sinpStore(self, system, wgt, tag, minortag=None):
text = self.__swidget(wgt).get_text()
if minortag==None:
system[tag] = text
else:
system[tag][minortag] = text
def __curSystem(self):
# Important thingies.
tree = self.__swidget("treSystems")
model = tree.get_model()
try:
iter = tree.get_selection().get_selected()[1]
p = model.iter_parent(iter)
except:
return ""
if p == None:
return model.get_value(iter, 0)
else:
return model.get_value(p, 0)
def __curPlanet(self):
tree = self.__pwidget("trePlanets")
model = tree.get_model()
try:
iter = tree.get_selection().get_selected()[1]
except:
return ""
return model.get_value(iter, 0)
def __done(self, widget=None, data=None):
"""
Window is done
"""
#gtk.main_quit()
return
def __space_reset(self, wgt=None, event=None):
self.x = self.y = 0
self.space_sel = ""
self.__space_draw()
def __space_down(self, wgt, event):
x = event.x
y = event.y
wx, wy, ww, wh = self.__swidget("draSpace").get_allocation()
mx = (x - (self.x*self.zoom + ww/2))/self.zoom
my = (y - (self.y*self.zoom + wh/2))/self.zoom
# Modify the current position.
if event.button == 1 and self.__swidget("butReposition").get_active() and self.cur_system != "":
system = self.systems[self.cur_system]
system["pos"]["x"] = str(int(mx))
system["pos"]["y"] = str(int(-my))
self.__space_draw()
self.__swidget("butReposition").set_active(False)
# See if a system is in "click" range.
r = 15
for name, sys in self.systems.items():
sx = int(sys["pos"]["x"])
sy = -int(sys["pos"]["y"])
if abs(sx-mx) < r and abs(sy-my) < r:
if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS:
tree = self.__swidget("treSystems")
self.__selSys(name)
elif event.button == 1:
self.space_sel = name
self.__space_draw()
break
self.lx = x
self.ly = y
return True
def __space_drag(self, wgt, event):
x = event.x
y = event.y
state = event.state
wx, wy, ww, wh = self.__swidget("draSpace").get_allocation()
mx = (x - (self.x*self.zoom + ww/2))/self.zoom
my = (y - (self.y*self.zoom + wh/2))/self.zoom
self.__swidget("labCurPos").set_text("%d%d" % (mx, my))
if state & gtk.gdk.BUTTON1_MASK:
xrel = x - self.lx
yrel = y - self.ly
self.x = self.x + xrel/self.zoom
self.y = self.y + yrel/self.zoom
self.lx = x
self.ly = y
self.__space_draw()
return True
def __space_zoomout(self, wgt=None, event=None):
self.zoom = self.zoom/2
if self.zoom < 0.1:
self.zoom = 0.1
self.__space_draw()
def __space_zoomin(self, wgt=None, event=None):
self.zoom = self.zoom*2
if self.zoom > 4:
self.zoom = 4
self.__space_draw()
def __space_draw(self, wgt=None, event=None):
area = self.__swidget("draSpace")
wx, wy, ww, wh = area.get_allocation()
cx = self.x*self.zoom + ww/2
cy = self.y*self.zoom + wh/2
r = 15
# Colour stuff.
sys_gc = area.window.new_gc()
col = area.get_colormap().alloc_color("yellow")
sys_gc.foreground = col
bg_gc = area.window.new_gc()
col = area.get_colormap().alloc_color("black")
bg_gc.foreground = col
jmp_gc = area.window.new_gc()
col = area.get_colormap().alloc_color("blue")
jmp_gc.foreground = col
sel_gc = area.window.new_gc()
col = area.get_colormap().alloc_color("red")
sel_gc.foreground = col
inert_gc = area.window.new_gc()
col = area.get_colormap().alloc_color("grey")
inert_gc.foreground = col
# Cleanup.
area.window.draw_rectangle(bg_gc, True, 0, 0, ww, wh)
area.window.draw_rectangle(sys_gc, False, 0, 0, ww-1, wh-1)
for sys_name, system in self.systems.items():
sx = int(system["pos"]["x"])
sy = -int(system["pos"]["y"])
dx = int(cx+sx*self.zoom)
dy = int(cy+sy*self.zoom)
# Draw jumps.
for jump in system["jumps"]:
jsx = int(self.systems[jump]["pos"]["x"])
jsy = -int(self.systems[jump]["pos"]["y"])
jdx = int(cx+jsx*self.zoom)
jdy = int(cy+jsy*self.zoom)
area.window.draw_line(jmp_gc, dx, dy, jdx, jdy)
# Draw circle.
if sys_name == self.space_sel:
gc = sel_gc
elif len(system["planets"]) == 0:
gc = inert_gc
else:
gc = sys_gc
if sys_name == self.__curSystem():
gc2 = jmp_gc
else:
gc2 = bg_gc
area.window.draw_arc(gc, True, dx-r/2, dy-r/2, r, r, 0, 360*64)
area.window.draw_arc(gc2, True, dx-r/2+2, dy-r/2+2, r-4, r-4, 0, 360*64)
# Draw name.
layout = area.create_pango_layout(sys_name)
area.window.draw_layout(gc, dx+r/2+2, dy-r/2, layout)
# Draw the frame at the end.
area.window.draw_rectangle(sys_gc, False, 0, 0, ww-1, wh-1)
"""
Add or remove jumps from a star system.
"""
def __jump_add(self, wgt=None, event=None):
if self.space_sel == self.cur_system: # Can't add to self.
return
if self.space_sel in self.systems.keys() and self.cur_system in self.systems.keys():
self.systems[self.cur_system]["jumps"].append(self.space_sel)
self.systems[self.space_sel]["jumps"].append(self.cur_system)
data.uniq(self.systems[self.cur_system]["jumps"])
data.uniq(self.systems[self.space_sel]["jumps"])
self.__supdate()
self.__space_draw()
def __jump_rm(self, wgt=None, event=None):
if self.space_sel in self.systems.keys() and self.cur_system in self.systems.keys():
self.systems[self.cur_system]["jumps"].remove(self.space_sel)
self.systems[self.space_sel]["jumps"].remove(self.cur_system)
self.__supdate()
self.__space_draw()
"""
Add or remove fleets from a star system.
"""
def __fleet_sel(self):
tree = self.__swidget("treFleets")
model = tree.get_model()
try:
iter = tree.get_selection().get_selected()[1]
except:
return ""
return model.get_value(iter, 0), mode.get_value(iter, 1)
def __fleet_add(self, wgt=None, event=None):
fleet = self.__swidget("comFleets").get_active_text()
value = self.__swidget("spiFleets").get_value_as_int()
if fleet != "None" and value > 0:
self.systems[self.cur_system]["fleets"].append({fleet:str(value)})
self.__supdate()
def __fleet_rm(self, wgt=None, event=None):
sel, chance = self.__fleet_sel()
if sel is "":
return
i = 0
for item in self.systems[self.cur_system]["fleets"]:
for key, value in item.items():
if key == sel and value == str(chance):
self.systems[self.cur_system]["fleets"].pop(i)
self.__supdate()
return
i = i+1
"""
Add or remove a commodity from a planet.
"""
def __commodity_sel(self):
tree = self.__pwidget("treCommodities")
model = tree.get_model()
try:
iter = tree.get_selection().get_selected()[1]
except:
return ""
return model.get_value(iter, 0)
def __commodity_add(self, wgt=None, event=None):
commodity = self.__pwidget("comCommodities").get_active_text()
if commodity != "None" and self.cur_planet != "":
planet = self.planets[self.cur_planet]
try:
planet["general"]["commodities"].append(commodity)
data.uniq(planet["general"]["commodities"])
except:
planet["general"]["commodities"] = [commodity]
self.__pupdate()
def __commodity_rm(self, wgt=None, event=None):
commodity = self.__commodity_sel()
if commodity != "":
self.planets[self.cur_planet]["general"]["commodities"].remove(commodity)
if len(self.planets[self.cur_planet]["general"]["commodities"]) == 0:
del self.planets[self.cur_planet]["general"]["commodities"]
self.__pupdate()
"""
Change the planet graphics.
"""
def __space_sel(self, wgt=None, event=None):
space = self.__pwidget("comSpace").get_active_text()
if self.cur_planet != "":
self.planets[self.cur_planet]["GFX"]["space"] = space
self.__pupdate()
def __exterior_sel(self, wgt=None, event=None):
space = self.__pwidget("comExterior").get_active_text()
if self.cur_planet != "" and space != "None":
self.planets[self.cur_planet]["GFX"]["exterior"] = space
self.__pupdate()
"""
Change the planet class.
"""
def __class_sel(self, wgt=None, event=None):
cls = self.__pwidget("comClass").get_active_text()
if self.cur_planet != "":
self.planets[self.cur_planet]["general"]["class"] = cls
self.__pupdate()
"""
Open the description editor.
"""
def __edit_description(self, wgt=None, event=None):
if self.cur_planet == "":
return
wtree = gtk.glade.XML(self.planet_glade, "winDescription")
wtree.get_widget("winDescription").show_all()
# Hooks.
wtree.get_widget("butDescDone").connect("clicked", self.__desc_done)
# Set text.
buf = gtk.TextBuffer()
try:
buf.set_text(self.planets[self.cur_planet]["general"]["description"])
except:
buf.set_text("")
wtree.get_widget("texDescription").set_buffer(buf)
self.dtree = wtree
def __desc_done(self, wgt=None, event=None):
buf = self.dtree.get_widget("texDescription").get_buffer()
desc = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
if desc != "":
self.planets[self.cur_planet]["general"]["description"] = desc
else:
if "description" in self.planets[self.cur_planet]["general"].keys():
del self.planets[self.cur_planet]["general"]["description"]
self.dtree.get_widget("winDescription").hide_all()
"""
Open the bar editor.
"""
def __edit_bar(self, wgt=None, event=None):
if self.cur_planet == "":
return
wtree = gtk.glade.XML(self.planet_glade, "winBar")
wtree.get_widget("winBar").show_all()
# Hooks.
wtree.get_widget("butBarDone").connect("clicked", self.__bar_done)
# Set text.
buf = gtk.TextBuffer()
try:
buf.set_text(self.planets[self.cur_planet]["general"]["bar"])
except:
buf.set_text("")
wtree.get_widget("texBar").set_buffer(buf)
self.btree = wtree
def __bar_done(self, wgt=None, event=None):
buf = self.btree.get_widget("texBar").get_buffer()
desc = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
if desc != "":
self.planets[self.cur_planet]["general"]["bar"] = desc
else:
if "bar" in self.planets[self.cur_planet]["general"].keys():
del self.planets[self.cur_planet]["general"]["bar"]
self.btree.get_widget("winBar").hide_all()
"""
Create a new star system.
"""
def __snew(self, wgt=None, event=None):
name = "new system"
gen = { "asteroids":0, "interference":0, "stars":100 }
pos = { "x":0, "y":0 }
new_ssys = { "general":gen, "pos":pos, "jumps":[], "fleets":[], "planets":[] }
self.systems[name] = new_ssys
self.__create_treSystems()
self.__selSys(name)
"""
Create a new planet.
"""
def __pnew(self, wgt=None, event=None):
name = "new planet"
gfx = { "space":"None" }
gen = { "class":"A", "services":0 }
pos = { "x":0, "y":0 }
new_planet = { "GFX":gfx, "general":gen, "pos":pos }
self.planets[name] = new_planet
self.__create_trePlanets()
self.__selPlanet(name)
def __selSys(self, system):
i = 0
tree = self.__swidget("treSystems")
for row in tree.get_model():
if row[0] == system:
tree.set_cursor(i)
self.__supdate()
break
i = i+1
def __selPlanet(self, planet):
i = 0
tree = self.__pwidget("trePlanets")
for row in tree.get_model():
if row[0] == planet:
tree.set_cursor(i)
self.__pupdate()
break
i = i + 1
def __pnewSys(self, wgt=None, event=None):
combo = self.__pwidget("comSystem")
sys = combo.get_active_text()
planet = self.cur_planet
if planet == "":
return
# Remove other existances of the planet..
for name, system in self.systems.items():
for pnt in system["planets"]:
if pnt == planet:
if name == sys: # No change.
return
system["planets"].remove(planet)
# Append to new location.
self.systems[sys]["planets"].append(planet)
# Recreate the tree.
self.__genPlanetTree()
self.__create_treSystems()
self.__supdate()
self.__pupdate()
def __pnewFact(self, wgt=None, event=None):
if self.cur_planet == "":
return
combo = self.__pwidget("comFaction")
fact = combo.get_active_text()
planet = self.planets[self.cur_planet]
if planet == "":
return
if fact == "None":
try:
del planet["general"]["faction"]
except:
return
else:
planet["general"]["faction"] = fact
def debug(self):
print "---SYSTEMS------------------"
print
for name, sys in self.systems.items():
print " ---SYSTEM: %s-----------" % name
print sys
print " ------------------------"
print
print "----------------------------"
print
print "---PLANETS------------------"
print self.planets
print "----------------------------"
print