def do_init(self, license=None):
# We ignore the license, not needed in the player
import MMurl, windowinterface
opts, files = self.tmpopts, self.tmpfiles
del self.tmpopts
del self.tmpfiles
self._tracing = 0
self.nocontrol = 0 # For player compatability
self._closing = 0
self._mm_callbacks = {}
self.tops = []
self.last_location = ''
try:
import mm, posix, fcntl
except ImportError:
pass
else:
pipe_r, pipe_w = posix.pipe()
mm.setsyncfd(pipe_w)
self._mmfd = pipe_r
windowinterface.select_setcallback(
pipe_r, self._mmcallback, (posix.read, fcntl.fcntl, fcntl))
self.commandlist = [
OPEN(callback=(self.open_callback, ())),
OPENFILE(callback=(self.openfile_callback, ())),
OPEN_RECENT(callback=self.open_recent_callback), # Dynamic cascade
# RELOAD(callback = (self.reload_callback, ())),
PREFERENCES(callback=(self.preferences_callback, ())),
CHECKVERSION(callback=(self.checkversion_callback, ())),
EXIT(callback=(self.close_callback, ())),
CHOOSESKIN(callback=(self.skin_callback, ())),
## CHOOSECOMPONENTS(callback = (self.components_callback, ())),
]
import settings
if hasattr(windowinterface,
'is_embedded') and windowinterface.is_embedded():
settings.factory_defaults()
if settings.get('debug'):
self.commandlist = self.commandlist + [
TRACE(callback=(self.trace_callback, ())),
DEBUG(callback=(self.debug_callback, ())),
CRASH(callback=(self.crash_callback, ())),
]
MainDialog.__init__(self, 'GRiNS')
# first open all files
for file in files:
self.openURL_callback(MMurl.guessurl(file), 0)
if not files and settings.get('skin'):
self.openURL_callback('data:application/smil,<smil/>', 0, 0, 0)
self._update_recent(None)
# then play them
if not hasattr(windowinterface,
'is_embedded') or not windowinterface.is_embedded():
for top in self.tops:
top.player.playsubtree(top.root)
def __init__(self, opts, files):
import windowinterface, features
if hasattr(features, 'expiry_date') and features.expiry_date:
import time
import version
tm = time.localtime(time.time())
yymmdd = tm[:3]
if yymmdd > features.expiry_date:
rv = windowinterface.GetOKCancel(
"This beta copy of GRiNS has expired.\n\n"
"Do you want to check www.oratrix.com for a newer version?"
)
if rv == 0:
url = 'http://www.oratrix.com/indir/%s/update.html' % version.shortversion
windowinterface.htmlwindow(url)
sys.exit(0)
self.tmpopts = opts
self.tmpfiles = files
flag = hasattr(windowinterface,
'is_embedded') and windowinterface.is_embedded()
if hasattr(features, 'license_features_needed'
) and features.license_features_needed and not flag:
import license
license_features_needed = list(features.license_features_needed)
if 'smil2player' not in license_features_needed:
license_features_needed.append('smil2player')
self.tmplicensedialog = license.WaitLicense(
self.do_init, license_features_needed)
else:
self.do_init()
self.recent_file_list = []
def save():
import windowinterface
if hasattr(windowinterface,
'is_embedded') and windowinterface.is_embedded():
# don't save when embedded
return 1
try:
fp = open(PREFSFILENAME, 'w')
except IOError:
return 0
for name, value in user_settings.items():
if not default_settings.has_key(
name) or value != default_settings[name]:
fp.write('%s = %s\n' % (name, ` value `))
fp.close()
return 1
def openURL_callback(self, url, startplay=1, update_recent=1, askskin=1):
import windowinterface
windowinterface.setwaiting()
from MMExc import MSyntaxError
import TopLevel
self.last_location = url
try:
top = TopLevel.TopLevel(self, url, askskin)
except IOError:
import windowinterface
windowinterface.showmessage('Cannot open: %s' % url)
except MSyntaxError:
import windowinterface
windowinterface.showmessage('Parse error in document: %s' % url)
else:
self.tops.append(top)
top.show()
top.player.show()
if update_recent:
self._update_recent(url)
if startplay and (not hasattr(windowinterface, 'is_embedded')
or not windowinterface.is_embedded()):
top.player.playsubtree(top.root)
def read_it(self):
## import time
self.changed = 0
## print 'parsing', self.filename, '...'
## t0 = time.time()
import urlcache
mtype = urlcache.mimetype(self.filename)
if mtype not in ('application/x-grins-project', 'application/smil',
'application/smil+xml',
'application/x-grins-binary-project') and (
not hasattr(windowinterface, 'is_embedded')
or not windowinterface.is_embedded()):
ans = windowinterface.GetYesNoCancel(
'MIME type not application/smil or application/x-grins-project.\nOpen as SMIL document anyway?'
)
if ans == 0: # yes
mtype = 'application/smil'
elif ans == 2: # cancel
raise IOError('user request')
if mtype in ('application/x-grins-project', 'application/smil',
'application/smil+xml'):
# init progress dialog
if mtype in ('application/smil', 'application/smil+xml'):
self.progress = windowinterface.ProgressDialog("Loading")
self.progressMessage = "Loading SMIL document..."
else:
self.progress = windowinterface.ProgressDialog("Loading")
self.progressMessage = "Loading GRiNS document..."
try:
import SMILTreeRead
self.root = SMILTreeRead.ReadFile(self.filename, self.printfunc, \
progressCallback=(self.progressCallback, 0))
except (UserCancel, IOError):
# the progress dialog will desapear
self.progress = None
# re-raise
raise sys.exc_type
# just update that the loading is finished
self.progressCallback(1.0)
# the progress dialog will disappear
if sys.platform == 'wince':
self.progress.close()
self.progress = None
elif mtype == 'application/x-grins-binary-project':
self.progress = windowinterface.ProgressDialog("Loading")
self.progressMessage = "Loading GRiNS document..."
import QuickRead
self.root = QuickRead.ReadFile(
self.filename, progressCallback=(self.progressCallback, 0.5))
self.progressCallback(1.0)
if sys.platform == 'wince':
self.progress.close()
self.progress = None
## elif mtype == 'application/x-grins-cmif':
## import MMRead
## self.root = MMRead.ReadFile(self.filename)
else:
from MediaRead import MediaRead
self.root = MediaRead(self.filename, mtype, self.printfunc)
## t1 = time.time()
## print 'done in', round(t1-t0, 3), 'sec.'
self.context = self.root.GetContext()
if sys.platform == 'wince':
errors = self.context.getParseErrors()
if errors is not None:
if errors.getType() == 'fatal':
msg = 'Fatal error'
else:
msg = 'Error'
logfile = r'\My Documents\GRiNS Error Log.txt'
f = open(logfile, 'w')
f.write(errors.getFormatedErrorsMessage())
f.close()
windowinterface.showmessage('%s logged in %s' % (msg, logfile))