player/player.py

   1 #!/usr/bin/env python
   2
   3 import sys
   4 import os.path
   5 from gi.repository import GObject, GLib, Gdk, Gio, Gtk, Chimara
   6 import config
   7
   8 # FIXME: Dummy translation function, for now
   9 _ = lambda x: x
  10
  11
  12 class Player(GObject.GObject):
  13         __gtype_name__ = 'ChimaraPlayer'
  14
  15         def __init__(self):
  16                 super(Player, self).__init__()
  17
  18                 # FIXME: should use the Keyfile backend, but that's not available from
  19                 # Python
  20                 self.prefs_settings = Gio.Settings('org.chimara-if.player.preferences')
  21                 self.state_settings = Gio.Settings('org.chimara-if.player.state')
  22
  23                 builder = Gtk.Builder()
  24                 builder.add_from_file('chimara.ui')
  25                 self.window = builder.get_object('chimara')
  26                 self.aboutwindow = builder.get_object('aboutwindow')
  27                 self.prefswindow = builder.get_object('prefswindow')
  28                 actiongroup = builder.get_object('actiongroup')
  29
  30                 # Set the default value of the "View/Toolbar" menu item upon creation
  31                 # of a new window to the "show-toolbar-default" setting, but bind the
  32                 # setting one-way only - we don't want toolbars to disappear suddenly
  33                 toolbar_action = builder.get_object('toolbar')
  34                 toolbar_action.active = \
  35                         self.state_settings.get_boolean('show-toolbar-default')
  36                 self.state_settings.bind('show-toolbar-default', toolbar_action,
  37                         'active', Gio.SettingsBindFlags.SET)
  38
  39                 filt = Gtk.RecentFilter()
  40                 for pattern in ['*.z[1-8]', '*.[zg]lb', '*.[zg]blorb', '*.ulx', '*.blb',
  41                         '*.blorb']:
  42                         filt.add_pattern(pattern)
  43                 recent = builder.get_object('recent')
  44                 recent.add_filter(filt)
  45
  46                 uimanager = Gtk.UIManager()
  47                 uimanager.add_ui_from_file('chimara.menus')
  48                 uimanager.insert_action_group(actiongroup, 0)
  49                 menubar = uimanager.get_widget('/menubar')
  50                 toolbar = uimanager.get_widget('/toolbar')
  51                 toolbar.no_show_all = True
  52                 if toolbar_action.active:
  53                         toolbar.show()
  54                 else:
  55                         toolbar.hide()
  56
  57                 # Connect the accelerators
  58                 accels = uimanager.get_accel_group()
  59                 self.window.add_accel_group(accels)
  60
  61                 self.glk = Chimara.IF()
  62                 self.glk.props.ignore_errors = True
  63                 self.glk.set_css_from_file('style.css')
  64
  65                 vbox = builder.get_object('vbox')
  66                 vbox.pack_end(self.glk, True, True, 0)
  67                 vbox.pack_start(menubar, False, False, 0)
  68                 vbox.pack_start(toolbar, False, False, 0)
  69
  70                 #builder.connect_signals(self)  # FIXME Segfaults?!
  71                 builder.get_object('open').connect('activate', self.on_open_activate)
  72                 builder.get_object('restore').connect('activate',
  73                         self.on_restore_activate)
  74                 builder.get_object('save').connect('activate', self.on_save_activate)
  75                 builder.get_object('stop').connect('activate', self.on_stop_activate)
  76                 builder.get_object('recent').connect('item-activated',
  77                         self.on_recent_item_activated)
  78                 builder.get_object('undo').connect('activate', self.on_undo_activate)
  79                 builder.get_object('quit').connect('activate', self.on_quit_activate)
  80                 builder.get_object('copy').connect('activate', self.on_copy_activate)
  81                 builder.get_object('paste').connect('activate', self.on_paste_activate)
  82                 builder.get_object('preferences').connect('activate',
  83                         self.on_preferences_activate)
  84                 builder.get_object('about').connect('activate', self.on_about_activate)
  85                 toolbar_action.connect('toggled', self.on_toolbar_toggled)
  86                 self.aboutwindow.connect('response', lambda x, *args: x.hide())
  87                 self.aboutwindow.connect('delete-event',
  88                         lambda x, *args: x.hide_on_delete())
  89                 self.window.connect('delete-event', self.on_window_delete_event)
  90                 self.prefswindow.connect('response', lambda x, *args: x.hide())
  91                 self.prefswindow.connect('delete-event',
  92                         lambda x, *args: x.hide_on_delete())
  93                 # FIXME Delete to here when above bug is fixed
  94
  95                 self.glk.connect('notify::program-name', self.change_window_title)
  96                 self.glk.connect('notify::story-name', self.change_window_title)
  97
  98                 # Create preferences window
  99                 # TODO
 100
 101         def change_window_title(self, glk, pspec, data=None):
 102                 if glk.props.program_name is None:
 103                         title = "Chimara"
 104                 elif glk.props.story_name is None:
 105                         title = "{interp} - Chimara".format(interp=glk.props.program_name)
 106                 else:
 107                         title = "{interp} - {story} - Chimara".format(
 108                                 interp=glk.props.program_name,
 109                                 story=glk.props.story_name)
 110                 self.window.props.title = title
 111
 112         def on_open_activate(self, action, data=None):
 113                 if not self.confirm_open_new_game():
 114                         return
 115
 116                 dialog = Gtk.FileChooserDialog(_('Open Game'), self.window,
 117                         Gtk.FileChooserAction.OPEN,
 118                         (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
 119                         Gtk.STOCK_OPEN, Gtk.ResponseType.ACCEPT))
 120
 121                 # Get last opened path
 122                 path = _maybe(self.state_settings.get_value('last-open-path'))
 123                 if path is not None:
 124                         dialog.set_current_folder(path)
 125
 126                 response = dialog.run()
 127                 dialog.hide()
 128                 if response != Gtk.ResponseType.ACCEPT:
 129                         return
 130
 131                 gamefile = dialog.get_file()
 132                 self.search_for_graphics_file(gamefile.get_path())
 133                 try:
 134                         self.glk.run_game_file(gamefile)
 135                 except GLib.Error as e:
 136                         error_dialog(self.window, _('Could not open game file {filename}: {errmsg}').format(filename=gamefile.get_path(), errmsg=e.message))
 137                         return
 138
 139                 path = dialog.get_current_folder()
 140                 if path is not None:
 141                         self.state_settings.last_open_path = path
 142
 143                 # Add file to recent files list
 144                 manager = Gtk.RecentManager.get_default()
 145                 uri = gamefile.get_uri()
 146                 manager.add_item(uri)
 147
 148                 dialog.destroy()
 149
 150         def on_recent_item_activated(self, chooser, data=None):
 151                 if not self.confirm_open_new_game():
 152                         return
 153
 154                 uri = chooser.get_current_uri()
 155                 gamefile = Gio.file_new_for_uri(uri)
 156
 157                 self.search_for_graphics_file(gamefile.get_path())
 158                 try:
 159                         self.glk.run_game_file(gamefile)
 160                 except GLib.Error as e:
 161                         error_dialog(self.window,
 162                                 _('Could not open game file {filename}: {errmsg}').format(
 163                                         filename=gamefile.get_basename(),
 164                                         errmsg=e.message))
 165                         return
 166
 167                 # Add file to recent files list again, this updates it to most recently
 168                 # used
 169                 manager = Gtk.RecentManager.get_default()
 170                 manager.add_item(uri)
 171
 172         def on_stop_activate(self, action, data=None):
 173                 self.glk.stop()
 174
 175         def on_quit_chimara_activate(self, action, data=None):
 176                 Gtk.main_quit()
 177
 178         def on_copy_activate(self, action, data=None):
 179                 focus = self.window.get_focus()
 180                 # Call "copy clipboard" on any widget that defines it
 181                 if (isinstance(focus, Gtk.Label)
 182                         or isinstance(focus, Gtk.Entry)
 183                         or isinstance(focus, Gtk.TextView)):
 184                         focus.emit('copy-clipboard')
 185
 186         def on_paste_activate(self, action, data=None):
 187                 focus = self.window.get_focus()
 188                 # Call "paste clipboard" on any widget that defines it
 189                 if isinstance(focus, Gtk.Entry) or isinstance(focus, Gtk.TextView):
 190                         focus.emit('paste-clipboard')
 191
 192         def on_preferences_activate(self, action, data=None):
 193                 self.prefswindow.present()
 194
 195         def on_toolbar_toggled(self, action, data=None):
 196                 if action.get_active():
 197                         self.toolbar.show()
 198                 else:
 199                         self.toolbar.hide()
 200
 201         def on_undo_activate(self, action, data=None):
 202                 self.glk.feed_line_input('undo')
 203
 204         def on_save_activate(self, action, data=None):
 205                 self.glk.feed_line_input('save')
 206
 207         def on_restore_activate(self, action, data=None):
 208                 self.glk.feed_line_input('restore')
 209
 210         def on_restart_activate(self, action, data=None):
 211                 self.glk.feed_line_input('restart')
 212
 213         def on_quit_activate(self, action, data=None):
 214                 self.glk.feed_line_input('quit')
 215
 216         def on_about_activate(self, action, data=None):
 217                 self.aboutwindow.set_version(config.PACKAGE_VERSION)
 218                 self.aboutwindow.present()
 219
 220         def on_window_delete_event(self, widget, event, data=None):
 221                 Gtk.main_quit()
 222                 return True
 223
 224         def confirm_open_new_game(self):
 225                 """
 226                 If a game is running in the Glk widget, warn the user that they will
 227                 quit the currently running game if they open a new one. Returns True if
 228                 no game was running. Returns False if the user cancelled. Returns True
 229                 and shuts down the running game if the user wishes to continue.
 230                 """
 231                 if not self.glk.props.running:
 232                         return True
 233
 234                 dialog = Gtk.MessageDialog(self.window,
 235                         Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
 236                         Gtk.MessageType.WARNING, Gtk.ButtonsType.CANCEL,
 237                         _("Are you sure you want to open a new game?"))
 238                 dialog.format_secondary_text(
 239                         _("If you open a new game, you will quit the one you are "
 240                         "currently playing."))
 241                 dialog.add_button(Gtk.STOCK_OPEN, Gtk.ResponseType.OK)
 242                 response = dialog.run()
 243                 dialog.hide()
 244
 245                 if response != Gtk.ResponseType.OK:
 246                         return False
 247
 248                 self.glk.stop()
 249                 self.glk.wait()
 250                 return True
 251
 252         def search_for_graphics_file(self, filename):
 253                 """Internal function: See if there is a corresponding graphics file"""
 254
 255                 # First get the name of the story file
 256                 base = os.path.basename(filename)
 257                 base_noext = os.path.splitext(base)[0]
 258
 259                 # Check in the stored resource path, if set
 260                 resource_path = _maybe(self.prefs_settings.get_value('resource-path'))
 261
 262                 # Otherwise check in the current directory
 263                 if resource_path is None:
 264                         resource_path = os.path.dirname(filename)
 265
 266                 blorbfile = os.path.join(resource_path, base_noext + '.blb')
 267                 if os.path.exists(blorbfile):
 268                         self.glk.graphics_file = blorbfile
 269
 270
 271 def _maybe(variant):
 272         """Gets a maybe value from a GVariant - not handled in PyGI"""
 273         v = variant.get_maybe()
 274         if v is None:
 275                 return None
 276         return v.unpack()
 277
 278
 279 def error_dialog(parent, message):
 280         dialog = Gtk.MessageDialog(parent, Gtk.DialogFlags.DESTROY_WITH_PARENT,
 281                 Gtk.MessageType.ERROR, Gtk.ButtonsType.OK, message)
 282         dialog.run()
 283         dialog.destroy()
 284
 285 if __name__ == '__main__':
 286         Gdk.threads_init()
 287
 288         player = Player()
 289         player.window.show_all()
 290
 291         if len(sys.argv) == 3:
 292                 player.glk.props.graphics_file = sys.argv[2]
 293         if len(sys.argv) >= 2:
 294                 try:
 295                         player.glk.run_game(sys.argv[1])
 296                 except GLib.Error as e:
 297                         error_dialog(player.window,
 298                                 _("Error starting Glk library: {errmsg}").format(
 299                                         errmsg=e.message))
 300                         sys.exit(1)
 301
 302         Gdk.threads_enter()
 303         Gtk.main()
 304         Gdk.threads_leave()
 305
 306         player.glk.stop()
 307         player.glk.wait()
 308
 309         sys.exit(0)