1000 lines
28 KiB
Python
1000 lines
28 KiB
Python
#!/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
|
|
|