533 lines
16 KiB
Python
533 lines
16 KiB
Python
#!/usr/bin/python
|
|
# gfceu - Graphical launcher for FCE Ultra.
|
|
# Designed on Ubuntu, with platfrom independence in mind.
|
|
version = "0.7svn"
|
|
title = "gfceu"
|
|
# Copyright (C) 2006 Lukas Sabota <punkrockguy318@comcast.net>
|
|
##
|
|
"""
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
"""
|
|
|
|
# # # # # # # #
|
|
# Python imports
|
|
|
|
import sys
|
|
import os
|
|
import pickle
|
|
import shutil
|
|
from optparse import OptionParser
|
|
#from subprocess import Popen
|
|
|
|
try:
|
|
import pygtk
|
|
pygtk.require("2.0")
|
|
import gtk
|
|
except ImportError:
|
|
print "The PyGTK libraries cannot be found.\n\
|
|
Ensure that PyGTK (>=2.12) is installed on this system.\n\
|
|
On Debian based systems (like Ubuntu), try this command:\n\
|
|
sudo apt-get install python-gtk2 libgtk2.0-0"
|
|
|
|
|
|
|
|
|
|
class game_options:
|
|
# sound
|
|
sound_check = True
|
|
soundq_check = True
|
|
soundrate_entry = "11000"
|
|
soundbufsize_entry = "48"
|
|
|
|
# video
|
|
fullscreen_check = False
|
|
xscale_spin = 2
|
|
yscale_spin = 2
|
|
bpp_combo = 32
|
|
extra_entry = ''
|
|
romfile = ''
|
|
opengl_check = False
|
|
|
|
# network
|
|
join_radio = False
|
|
join_add = ''
|
|
join_port = 4046
|
|
join_pass = ''
|
|
host_radio = False
|
|
host_port = 4046
|
|
host_pass = ''
|
|
no_network_radio = True
|
|
|
|
|
|
def load_options():
|
|
global options, optionsfile
|
|
try:
|
|
ifile = file(optionsfile, 'r')
|
|
options = pickle.load(ifile)
|
|
pickle.load(ifile)
|
|
except:
|
|
return
|
|
ifile.close()
|
|
|
|
def save_options():
|
|
global options, optionsfile, appconfigdir
|
|
ofile = file(optionsfile, 'w')
|
|
pickle.dump(options, ofile)
|
|
ofile.close()
|
|
|
|
def give_widgets():
|
|
"""
|
|
give_widgets()
|
|
|
|
This function takes data from the options struct and relays it to
|
|
the GTK window
|
|
"""
|
|
global options, widgets
|
|
try:
|
|
widgets.get_object("rom_entry").set_text(options.romfile)
|
|
|
|
# sound
|
|
widgets.get_object("sound_check").set_active(options.sound_check)
|
|
widgets.get_object("soundq_check").set_active(options.soundq_check)
|
|
widgets.get_object("soundrate_entry").set_text(options.soundrate_entry)
|
|
widgets.get_object("soundbufsize_entry").set_text(options.soundbufsize_entry)
|
|
|
|
# video
|
|
widgets.get_object("fullscreen_check").set_active(options.fullscreen_check)
|
|
widgets.get_object("opengl_check").set_active(options.opengl_check)
|
|
widgets.get_object("xscale_spin").set_value(options.xscale_spin)
|
|
widgets.get_object("yscale_spin").set_value(options.yscale_spin)
|
|
|
|
widgets.get_object("extra_entry").set_text(options.extra_entry)
|
|
|
|
# Usability point:
|
|
# Users will probably not want to remember their previous network setting.
|
|
# Users may accidently be connecting to a remote server/hosting a game when
|
|
# they were unaware.
|
|
# No network is being set by default
|
|
widgets.get_object("no_network_radio").set_active(True)
|
|
widgets.get_object("join_add").set_text(options.join_add)
|
|
widgets.get_object("join_port").set_value(float(options.join_port))
|
|
widgets.get_object("join_pass").set_text(options.join_pass)
|
|
widgets.get_object("host_port").set_value(float(options.host_port))
|
|
widgets.get_object("host_pass").set_text(options.host_pass)
|
|
|
|
except AttributeError:
|
|
# When new widgets are added, old pickle files might break.
|
|
options = game_options()
|
|
give_widgets()
|
|
except RuntimeError:
|
|
print "shit"
|
|
|
|
def set_options():
|
|
"""
|
|
set_options()
|
|
|
|
This function grabs all of the data from the GTK widgets
|
|
and stores it in the options object.
|
|
"""
|
|
options.romfile = widgets.get_object("rom_entry").get_text()
|
|
|
|
# sound
|
|
options.sound_check = widgets.get_object("sound_check").get_active()
|
|
options.soundq_check = widgets.get_object("soundq_check").get_active()
|
|
options.soundrate_entry = widgets.get_object("soundrate_entry").get_text()
|
|
options.soundbufsize_entry = widgets.get_object("soundbufsize_entry").get_text()
|
|
|
|
# video
|
|
options.fullscreen_check = widgets.get_object("fullscreen_check").get_active()
|
|
options.opengl_check = widgets.get_object("opengl_check").get_active()
|
|
options.xscale_spin = widgets.get_object("xscale_spin").get_value()
|
|
options.yscale_spin = widgets.get_object("yscale_spin").get_value()
|
|
|
|
options.extra_entry = widgets.get_object("extra_entry").get_text()
|
|
|
|
options.join_radio = widgets.get_object("join_radio").get_active()
|
|
options.host_radio = widgets.get_object("host_radio").get_active()
|
|
options.no_network_radio = widgets.get_object("no_network_radio").get_active()
|
|
options.join_add = widgets.get_object("join_add").get_text()
|
|
options.join_port = int(widgets.get_object("join_port").get_value())
|
|
options.join_pass = widgets.get_object("join_pass").get_text()
|
|
options.host_port = widgets.get_object("host_port").get_value()
|
|
options.host_pass = widgets.get_object("host_pass").get_text()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def find_binary(file):
|
|
|
|
path = os.getenv('PATH')
|
|
directories= []
|
|
directory = ''
|
|
# check for '$' so last entry is processed
|
|
for x in path + '$':
|
|
if x != ':' and x != '$':
|
|
directory = directory + x
|
|
else:
|
|
directories.append(directory)
|
|
directory = ''
|
|
|
|
for x in directories:
|
|
if os.path.isfile(os.path.join(x, file)):
|
|
return os.path.join(x,file)
|
|
|
|
if os.path.isfile(os.path.join(os.curdir,file)):
|
|
return os.path.join(os.curdir, file)
|
|
|
|
return None
|
|
|
|
|
|
# # # # # # # # # # # # # # # # #
|
|
# Globals
|
|
options = None
|
|
appconfigdir = os.getenv('HOME') + '/.'+ title
|
|
optionsfile = appconfigdir + 'gfceu_options.dat'
|
|
widgets = None
|
|
|
|
class GfceuApp:
|
|
def __init__(self):
|
|
self.fceux_binary = self.find_fceu()
|
|
self.load_ui()
|
|
self.setup_environment()
|
|
|
|
options = game_options()
|
|
load_options()
|
|
give_widgets()
|
|
try:
|
|
gtk.main()
|
|
except KeyboardInterrupt:
|
|
sys.exit(0)
|
|
|
|
def msg(self, text, use_gtk=False):
|
|
"""
|
|
GfceuApp.msg()
|
|
|
|
This function prints messages to the user. This is generally used for status
|
|
messages. If a GTK message_box is requried, the use_gtk flag can be enabled.
|
|
"""
|
|
print text
|
|
if use_gtk:
|
|
msgbox = gtk.MessageDialog(parent=None, flags=0, type=gtk.MESSAGE_INFO,
|
|
buttons=gtk.BUTTONS_CLOSE)
|
|
msgbox.set_markup(text)
|
|
msgbox.run()
|
|
msgbox.destroy()
|
|
|
|
def print_error(self, message, code, use_gtk=True, fatal=True):
|
|
"""
|
|
GfceuApp.error()
|
|
|
|
Presents the user with an error message and optionally quits the program.
|
|
"""
|
|
print title + ' error code '+str(code)+': ' + message
|
|
if use_gtk:
|
|
msgbox = gtk.MessageDialog(parent=None, flags=0, type=gtk.MESSAGE_ERROR,
|
|
buttons=gtk.BUTTONS_CLOSE)
|
|
msgbox.set_markup(title + ' ERROR Code '+str(code)+':\n'+message)
|
|
msgbox.run()
|
|
msgbox.destroy()
|
|
if fatal:
|
|
sys.exit(code)
|
|
|
|
def setup_environment (self):
|
|
"""
|
|
Configures the environment if this is the first time the application
|
|
has been run. For instance, it checks for the options file and creates
|
|
it if it doesn't exist. It also converts between the old version and
|
|
the new version of this application, which stores the options file in
|
|
a separate directory.
|
|
"""
|
|
|
|
global appconfigdir, optionsfile
|
|
|
|
if not os.path.exists(appconfigdir):
|
|
# this is the first time the application is run.
|
|
# create the directory
|
|
self.msg("Creating application settings directory")
|
|
os.mkdir(appconfigdir)
|
|
|
|
def find_fceu(self):
|
|
bin = find_binary('fceux')
|
|
if bin == None:
|
|
gfceu_error('Could not find the fceu binary.\n\
|
|
Ensure that FCE Ultra is installed and in the $PATH.\n\
|
|
On Debian based systems (like Ubuntu), try the following command:\n\
|
|
sudo apt-get install fceu', 4, True)
|
|
else:
|
|
self.msg('Using: ' + bin)
|
|
|
|
return bin
|
|
|
|
def load_ui(self):
|
|
global widgets
|
|
""" Search for the glade XML file and load it """
|
|
# Check first in the directory of this script.
|
|
if os.path.isfile('gfceu.xml'):
|
|
glade_file = 'gfceu.xml'
|
|
# Then check to see if its installed on a *nix system
|
|
elif os.path.isfile(os.path.join(os.path.dirname(sys.argv[0]), '../share/gfceu/gfceu.xml')):
|
|
glade_file = os.path.join(os.path.dirname(sys.argv[0]), '../share/gfceu/gfceu.xml')
|
|
else:
|
|
print 'ERROR.'
|
|
print 'Could not find the glade.xml file.'
|
|
print 'Try reinstalling the application.'
|
|
sys.exit(1)
|
|
|
|
try:
|
|
print "Using: " + glade_file
|
|
widgets = gtk.Builder()
|
|
widgets.add_from_file(glade_file)
|
|
widgets.connect_signals(self)
|
|
except:
|
|
self.print_error("Couldn't load the UI data.", 24)
|
|
|
|
widgets.get_object("main_window").show_all()
|
|
|
|
def launch(self, rom_name, local=False):
|
|
global options
|
|
set_options()
|
|
|
|
sound_options = ''
|
|
|
|
if options.sound_check:
|
|
sound_options += '--sound 1 '
|
|
else:
|
|
sound_options += '--sound 0 '
|
|
|
|
if options.soundq_check:
|
|
sound_options += '--soundq 1 '
|
|
else:
|
|
sound_options += '--soundq 0 '
|
|
|
|
if options.soundrate_entry:
|
|
sound_options += '--soundrate ' + options.soundrate_entry + ' '
|
|
|
|
if options.soundbufsize_entry:
|
|
sound_options += '--soundbufsize ' + options.soundbufsize_entry + ' '
|
|
|
|
# video
|
|
video_options = ''
|
|
if options.fullscreen_check:
|
|
video_options += '--fullscreen 1 '
|
|
else:
|
|
video_options += '--fullscreen 0 '
|
|
|
|
if options.opengl_check:
|
|
video_options += '--opengl 1 '
|
|
else:
|
|
video_options += '--opengl 0 '
|
|
|
|
video_options += ' --xscale ' + str(options.xscale_spin)
|
|
video_options += ' --yscale ' + str(options.yscale_spin)
|
|
video_options += ' '
|
|
|
|
|
|
# Netplay is fucked right now
|
|
|
|
if options.join_radio:
|
|
if options.join_pass == '':
|
|
netpass = ''
|
|
else:
|
|
netpass = '--pass ' + options.join_pass
|
|
network = '--net ' + options.join_add +\
|
|
' --port '+ str(options.join_port) + ' ' + netpass
|
|
else:
|
|
network = ''
|
|
|
|
if options.host_radio:
|
|
"""
|
|
if options.host_pass == '':
|
|
netpass = ' '
|
|
else:
|
|
# netpass = ' --pass ' + '"' + options.host_pass + '" '
|
|
netpass = ' --pass ' + options.host_pass
|
|
network = '--net localhost --port '+\
|
|
str(options.host_port) + netpass + ' '
|
|
"""
|
|
network = ''
|
|
|
|
if local:
|
|
network = ''
|
|
|
|
|
|
command = self.fceux_binary + ' ' + sound_options + video_options +\
|
|
network + options.extra_entry + ' '+ rom_name
|
|
self.msg('Command: ' + command)
|
|
|
|
# more code to disable because netplay is fucked
|
|
"""
|
|
if options.host_radio:
|
|
xterm_binary = find_binary("xterm")
|
|
if xterm_binary == None:
|
|
gfceu_error("Cannot find xterm on this system. You will not \n\
|
|
be informed of server output.", 102, True, False)
|
|
args = [self.server_binary]
|
|
else:
|
|
args = [xterm_binary, "-e", self.server_binary]
|
|
args.append('--port')
|
|
args.append(str(options.host_port))
|
|
if options.host_pass:
|
|
args.append("--password")
|
|
args.append(options.host_pass)
|
|
pid = Popen(args).pid
|
|
"""
|
|
widgets.get_object("main_window").hide()
|
|
|
|
# os.system() is a blocker, so we must force
|
|
# gtk to process our events.
|
|
while gtk.events_pending():
|
|
gtk.main_iteration_do()
|
|
|
|
os.system(command)
|
|
widgets.get_object("main_window").show()
|
|
|
|
# another part of netplay code
|
|
"""
|
|
if options.host_radio:
|
|
os.kill(pid, 9)
|
|
"""
|
|
|
|
### Callbacks
|
|
def launch_button_clicked(self, arg1):
|
|
|
|
global options
|
|
options.romfile = widgets.get_object("rom_entry").get_text()
|
|
if widgets.get_object("rom_entry").get_text() == '':
|
|
self.msg('Please specify a ROM to open in the main tab.', True)
|
|
return
|
|
|
|
self.launch('"'+ options.romfile +'"')
|
|
|
|
def about_button_clicked(self, menuitem, data=None):
|
|
widgets.get_object("about_dialog").set_name('GNOME FCE Ultra '+version)
|
|
widgets.get_object("about_dialog").run()
|
|
widgets.get_object("about_dialog").hide()
|
|
|
|
def browse_button_clicked(self, menuitem, data=None):
|
|
global options
|
|
set_options()
|
|
chooser = gtk.FileChooserDialog("Open...", None,
|
|
gtk.FILE_CHOOSER_ACTION_OPEN,
|
|
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
|
|
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
|
|
chooser.set_property("local-only", False)
|
|
chooser.set_default_response(gtk.RESPONSE_OK)
|
|
|
|
filter=gtk.FileFilter()
|
|
filter.set_name("NES Roms")
|
|
filter.add_mime_type("application/x-nes-rom")
|
|
filter.add_mime_type("application/zip")
|
|
filter.add_pattern("*.nes")
|
|
filter.add_pattern("*.zip")
|
|
chooser.add_filter(filter)
|
|
|
|
filter = gtk.FileFilter()
|
|
filter.set_name("All files")
|
|
filter.add_pattern("*")
|
|
chooser.add_filter(filter)
|
|
|
|
|
|
|
|
if options.romfile == '':
|
|
folder = os.getenv('HOME')
|
|
else:
|
|
folder = os.path.split(options.romfile)[0]
|
|
|
|
chooser.set_current_folder (folder)
|
|
|
|
response = chooser.run()
|
|
chooser.hide()
|
|
|
|
if response == gtk.RESPONSE_OK:
|
|
if chooser.get_filename():
|
|
x = chooser.get_filename()
|
|
widgets.get_object("rom_entry").set_text(x)
|
|
options.romfile = x
|
|
|
|
def gamepad_clicked(self, widget, data=None):
|
|
|
|
d = {'gp1_button' : '1',
|
|
'gp2_button' : '2',
|
|
'gp3_button' : '3',
|
|
'gp4_button' : '4'}
|
|
command = '-inputcfg gamepad' + d[widget.name] + ' /dev/null'
|
|
self.launch(command, True)
|
|
|
|
def config_help_button_clicked(self, menuitem, data=None):
|
|
msgbox = gtk.MessageDialog(parent=None, flags=0,
|
|
type=gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_CLOSE)
|
|
msgbox.set_markup("Once a gamepad is seleceted, a titlebar will be displayed\
|
|
indicating a NES button. Press the button or key you would like to have\
|
|
associated with the button indicated on the titlebar. This process\
|
|
will repeat until all buttons on the gamepad are configured.")
|
|
msgbox.run()
|
|
msgbox.hide()
|
|
|
|
|
|
def join_radio_clicked(self, menuitem, data=None):
|
|
global options
|
|
widgets.get_object("join_frame").set_sensitive(True)
|
|
widgets.get_object("host_frame").set_sensitive(False)
|
|
options.join_radio = True
|
|
options.host_radio = False
|
|
options.no_network_radio = False
|
|
|
|
def host_radio_clicked(self, menuitem, data=None):
|
|
if widgets.get_object("host_radio").get_active():
|
|
self.server_binary = find_binary('fceu-server')
|
|
|
|
if self.server_binary == None:
|
|
if os.name == 'nt':
|
|
gfceu_error("The fceu server software cannot be found. \n\
|
|
Ensure that it is installed in the same directory as \n\
|
|
GFCE Ultra.", 102, True, False)
|
|
else:
|
|
gfceu_error("The fceu server software cannot be found on \n\
|
|
this system. Ensure that it is installed and in your path.",
|
|
101, True, False)
|
|
widgets.get_object("no_network_radio").set_active(True)
|
|
options.no_network_radio = True
|
|
return False
|
|
|
|
widgets.get_object("join_frame").set_sensitive(False)
|
|
widgets.get_object("host_frame").set_sensitive(True)
|
|
options.join_radio = False
|
|
options.host_radio = True
|
|
options.no_network_radio = False
|
|
|
|
def no_network_radio_clicked(self, menuitem, data=None):
|
|
widgets.get_object("join_frame").set_sensitive(False)
|
|
widgets.get_object("host_frame").set_sensitive(False)
|
|
options.join_radio = False
|
|
options.host_radio = False
|
|
options.no_network_radio = True
|
|
|
|
def end(self, menuitem, data=None):
|
|
global options, optionsfile
|
|
set_options()
|
|
save_options()
|
|
gtk.main_quit()
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser = OptionParser(version='%prog '+ version)
|
|
parser.parse_args()
|
|
|
|
app = GfceuApp()
|
|
|