def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine:
try:
uci = is_uci(new_engine)
if not uci:
if not is_cecp(new_engine):
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(
engine["command"])
print("Maybe not a chess engine")
return
path, binname = os.path.split(new_engine)
for e in discoverer.getEngines():
if e["name"] == binname:
binname = e["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(
new_engine)
self.widgets["engine_protocol_combo"].set_active(
0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
active = self.widgets[
"engine_protocol_combo"].get_active()
protocol = "uci" if active == 0 else "xboard"
discoverer.addEngine(binname, new_engine, protocol)
self.cur_engine = binname
glock_connect_after(discoverer, "engine_discovered",
update_store)
self.add = False
discoverer.discover()
except:
print("There is something wrong with this executable")
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == gtk.RESPONSE_OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine:
try:
uci = is_uci(new_engine)
if not uci:
if not is_cecp(new_engine):
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
print "Maybe not a chess engine"
return
path, binname = os.path.split(new_engine)
for e in discoverer.getEngines():
if e["name"] == binname:
binname = e["name"] + "(1)"
break
self.widgets["engine_name_entry"].set_text(binname)
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
name = self.widgets["engine_name_entry"].get_text().strip()
active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if active==0 else "xboard"
discoverer.addEngine(name, new_engine, protocol)
self.cur_engine = name
glock_connect_after(discoverer, "engine_discovered", update_store)
self.add = False
discoverer.start()
except:
print "There is something wrong with this executable"
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
vm_name = None
vm_args = None
vmpath = ""
if new_engine.lower().endswith(
".exe") and sys.platform != "win32":
vm_name = "wine"
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("wine not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
for vm in VM_LIST:
ext = os.path.splitext(new_engine)[1]
if ext == vm.ext:
vm_name = vm.name
vm_args = vm.args
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
vm_name + _(" is not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
break
if new_engine:
vm_ext_list = [vm.ext for vm in VM_LIST]
if ext not in vm_ext_list and not os.access(
new_engine, os.X_OK):
msg_dia = Gtk.MessageDialog(type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>%s is not marked executable in the filesystem</b></big>"
% new_engine))
msg_dia.format_secondary_text(
_("Try chmod a+x %s" % new_engine))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
try:
engine_command = []
if vmpath:
engine_command.append(vmpath)
if vm_args is not None:
engine_command.append(vm_args)
engine_command.append(new_engine)
# Some engines support CECP and UCI, but main variant engines are CECP,
# so we better to start with CECP this case
variant_engines = ("fmax", "sjaakii", "sjeng")
if any((True for eng in variant_engines
if eng in new_engine.lower())):
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(engine_command)
if check_ok:
uci = checker is is_uci
break
else:
continue
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(
engine["command"])
msg_dia = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"
))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
self.add = False
engine_chooser_dialog.hide()
return
binname = os.path.split(new_engine)[1]
for eng in discoverer.getEngines():
if eng["name"] == binname:
binname = eng["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(
new_engine)
self.widgets["engine_protocol_combo"].set_active(
0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
# active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
if vm_args is not None:
vm_args = vm_args.split(",")
# print(binname, new_engine, protocol, vm_name, vm_args)
discoverer.addEngine(binname, new_engine, protocol,
vm_name, vm_args)
self.cur_engine = binname
self.add = False
discoverer.discover()
except:
msg_dia = Gtk.MessageDialog(type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine.lower().endswith(".exe") and sys.platform != "win32":
vm_name = "wine"
vmpath = searchPath(vm_name, access=os.R_OK|os.X_OK)
if vmpath is None:
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("wine not installed"))
d.run()
d.hide()
new_engine = ""
else:
vmpath += " "
else:
vm_name = None
vmpath = ""
if new_engine:
try:
# Some engines support CECP and UCI, but variant engines are CECP,
# so we better to start with CECP this case
variant_engines = ("fmax", "sjaakii", "sjeng")
if any((True for e in variant_engines if e in new_engine.lower())):
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
ok = checker(vmpath + new_engine)
if ok:
uci = checker is is_uci
break
else:
continue
if not ok:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("There is something wrong with this executable"))
d.run()
d.hide()
engine_chooser_dialog.hide()
return
path, binname = os.path.split(new_engine)
for e in discoverer.getEngines():
if e["name"] == binname:
binname = e["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
discoverer.addEngine(binname, new_engine, protocol, vm_name)
self.cur_engine = binname
self.add = False
discoverer.discover()
except:
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("There is something wrong with this executable"))
d.run()
d.hide()
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine.lower().endswith(
".exe") and sys.platform != "win32":
vm_name = "wine"
vmpath = searchPath(vm_name, access=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(type=Gtk.MessageType.ERROR, \
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" % \
new_engine))
msg_dia.format_secondary_text(_("wine not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
else:
vmpath += " "
else:
vm_name = None
vmpath = ""
if new_engine:
try:
# Some engines support CECP and UCI, but variant engines are CECP,
# so we better to start with CECP this case
variant_engines = ("fmax", "sjaakii", "sjeng")
if any((True for eng in variant_engines
if eng in new_engine.lower())):
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(vmpath + new_engine)
if check_ok:
uci = checker is is_uci
break
else:
continue
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(
engine["command"])
msg_dia = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"
))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
return
binname = os.path.split(new_engine)[1]
for eng in discoverer.getEngines():
if eng["name"] == binname:
binname = eng["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(
new_engine)
self.widgets["engine_protocol_combo"].set_active(
0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
active = self.widgets[
"engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
discoverer.addEngine(binname, new_engine, protocol,
vm_name)
self.cur_engine = binname
self.add = False
discoverer.discover()
except:
msg_dia = Gtk.MessageDialog(type=Gtk.MessageType.ERROR, \
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" % \
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine.lower().endswith(".exe"):
vm_name = "wine"
vmpath = searchPath(vm_name, access=os.R_OK|os.X_OK)
if vmpath is None:
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("wine not installed"))
d.run()
d.hide()
new_engine = ""
else:
vmpath += " "
else:
vm_name = None
vmpath = ""
if new_engine:
try:
uci = is_uci(vmpath + new_engine)
if not uci:
if not is_cecp(vmpath + new_engine):
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("There is something wrong with this executable"))
d.run()
d.hide()
engine_chooser_dialog.hide()
return
path, binname = os.path.split(new_engine)
for e in discoverer.getEngines():
if e["name"] == binname:
binname = e["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if active==0 else "xboard"
discoverer.addEngine(binname, new_engine, protocol, vm_name)
self.cur_engine = binname
glock_connect_after(discoverer, "engine_discovered", update_store)
self.add = False
discoverer.discover()
except:
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("There is something wrong with this executable"))
d.run()
d.hide()
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
binname = os.path.split(new_engine)[1]
ext = os.path.splitext(new_engine)[1]
# Verify if the engine already exists under the same name
if new_engine != "":
for eng in discoverer.getEngines():
if eng["command"] == new_engine:
msg_dia = Gtk.MessageDialog(
mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("The engine is already installed under the same name"
))
msg_dia.run()
msg_dia.hide()
new_engine = ""
break
# Detect the host application
if new_engine != "":
vm_name = None
vm_args = None
vmpath = ""
# Scripting
for vm in VM_LIST:
if ext == vm.ext:
vm_name = vm.name
vm_args = vm.args
break
# Wine for Windows application under Linux
if vm_name is None and new_engine.lower().endswith(
".exe") and sys.platform != "win32":
vm_name = "wine"
# Check that the interpreter is available
if vm_name is not None:
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(
mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
vm_name + _(" is not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
# Next checks
if new_engine:
vm_ext_list = [vm.ext for vm in VM_LIST]
if ext not in vm_ext_list and not os.access(
new_engine, os.X_OK):
msg_dia = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>%s is not marked executable in the filesystem</b></big>"
% new_engine))
msg_dia.format_secondary_text(
_("Try chmod a+x %s" % new_engine))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
try:
engine_command = []
if vmpath:
engine_command.append(vmpath)
if vm_args is not None:
engine_command += vm_args
engine_command.append(new_engine)
# Search the engines based on the most expectable protocol
refeng = discoverer.getReferencedEngine(binname)
if refeng is not None and refeng[
"protocol"] == "xboard":
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(engine_command)
if check_ok:
uci = checker is is_uci
break
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(
engine["command"])
msg_dia = Gtk.MessageDialog(
mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"
))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
self.add = False
engine_chooser_dialog.hide()
return
self.widgets["engine_command_entry"].set_text(
new_engine)
self.widgets["engine_protocol_combo"].set_active(
0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
# active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
# print(binname, new_engine, protocol, vm_name, vm_args)
discoverer.addEngine(binname, new_engine, protocol,
vm_name, vm_args)
self.cur_engine = binname
self.add = False
discoverer.discover()
except Exception:
msg_dia = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(
_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
vm_name = None
vm_args = None
vmpath = ""
if new_engine.lower().endswith(".exe") and sys.platform != "win32":
vm_name = "wine"
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("wine not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
for vm in VM_LIST:
ext = os.path.splitext(new_engine)[1]
if ext == vm.ext:
vm_name = vm.name
vm_args = vm.args
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(vm_name + _(" is not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
break
if new_engine:
vm_ext_list = [vm.ext for vm in VM_LIST]
if ext not in vm_ext_list and not os.access(new_engine, os.X_OK):
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>%s is not marked executable in the filesystem</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("Try chmod a+x %s" % new_engine))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
try:
engine_command = []
if vmpath:
engine_command.append(vmpath)
if vm_args is not None:
engine_command.append(vm_args)
engine_command.append(new_engine)
# Some engines support CECP and UCI, but main variant engines are CECP,
# so we better to start with CECP this case
variant_engines = ("fmax", "sjaakii", "sjeng")
if any((True
for eng in variant_engines
if eng in new_engine.lower())):
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(engine_command)
if check_ok:
uci = checker is is_uci
break
else:
continue
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(
self.cur_engine)
engine_chooser_dialog.set_filename(engine[
"command"])
msg_dia = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_(
"There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
self.add = False
engine_chooser_dialog.hide()
return
binname = os.path.split(new_engine)[1]
for eng in discoverer.getEngines():
if eng["name"] == binname:
binname = eng["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
# active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
if vm_args is not None:
vm_args = vm_args.split(",")
# print(binname, new_engine, protocol, vm_name, vm_args)
discoverer.addEngine(binname, new_engine, protocol, vm_name, vm_args, "unknown")
self.cur_engine = binname
self.add = False
discoverer.discover()
except Exception:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_(
"There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
if new_engine.lower().endswith(".exe") and sys.platform != "win32":
vm_name = "wine"
vmpath = searchPath(vm_name, access=os.R_OK|os.X_OK)
if vmpath is None:
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("wine not installed"))
d.run()
d.hide()
new_engine = ""
else:
vmpath += " "
else:
vm_name = None
vmpath = ""
if new_engine:
try:
uci = is_uci(vmpath + new_engine)
if not uci:
if not is_cecp(vmpath + new_engine):
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("There is something wrong with this executable"))
d.run()
d.hide()
engine_chooser_dialog.hide()
return
path, binname = os.path.split(new_engine)
for e in discoverer.getEngines():
if e["name"] == binname:
binname = e["name"] + "(1)"
break
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if active==0 else "xboard"
discoverer.addEngine(binname, new_engine, protocol, vm_name)
self.cur_engine = binname
discoverer.connect_after("engine_discovered", update_store)
self.add = False
discoverer.discover()
except:
d = Gtk.MessageDialog(
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
d.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
d.format_secondary_text(_("There is something wrong with this executable"))
d.run()
d.hide()
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
def add(button):
self.add = True
response = engine_chooser_dialog.run()
if response == Gtk.ResponseType.OK:
new_engine = engine_chooser_dialog.get_filename()
binname = os.path.split(new_engine)[1]
ext = os.path.splitext(new_engine)[1]
# Verify if the engine already exists under the same name
if new_engine != "":
for eng in discoverer.getEngines():
if eng["command"] == new_engine:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
msg_dia.format_secondary_text(_("The engine is already installed under the same name"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
break
# Detect the host application
if new_engine != "":
vm_name = None
vm_args = None
vmpath = ""
# Scripting
for vm in VM_LIST:
if ext == vm.ext:
vm_name = vm.name
vm_args = vm.args
break
# Wine for Windows application under Linux
if vm_name is None and new_engine.lower().endswith(".exe") and sys.platform != "win32":
vm_name = "wine"
# Check that the interpreter is available
if vm_name is not None:
vmpath = shutil.which(vm_name, mode=os.R_OK | os.X_OK)
if vmpath is None:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
msg_dia.format_secondary_text(vm_name + _(" is not installed"))
msg_dia.run()
msg_dia.hide()
new_engine = ""
# Next checks
if new_engine:
vm_ext_list = [vm.ext for vm in VM_LIST]
if ext not in vm_ext_list and not os.access(new_engine, os.X_OK):
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>%s is not marked executable in the filesystem</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("Try chmod a+x %s" % new_engine))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
try:
engine_command = []
if vmpath:
engine_command.append(vmpath)
if vm_args is not None:
engine_command.append(vm_args)
engine_command.append(new_engine)
# Search the engines based on the most expectable protocol
refeng = discoverer.getReferencedEngine(binname)
if refeng is not None and refeng["protocol"] == "xboard":
checkers = [is_cecp, is_uci]
else:
checkers = [is_uci, is_cecp]
uci = False
for checker in checkers:
check_ok = checker(engine_command)
if check_ok:
uci = checker is is_uci
break
else:
continue
if not check_ok:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
msg_dia = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(
_("<big><b>Unable to add %s</b></big>" %
new_engine))
msg_dia.format_secondary_text(_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
engine_chooser_dialog.hide()
self.add = False
engine_chooser_dialog.hide()
return
self.widgets["engine_command_entry"].set_text(new_engine)
self.widgets["engine_protocol_combo"].set_active(0 if uci else 1)
self.widgets["engine_args_entry"].set_text("")
# active = self.widgets["engine_protocol_combo"].get_active()
protocol = "uci" if uci else "xboard"
if vm_args is not None:
vm_args = vm_args.split(",")
# print(binname, new_engine, protocol, vm_name, vm_args)
discoverer.addEngine(binname, new_engine, protocol, vm_name, vm_args)
self.cur_engine = binname
self.add = False
discoverer.discover()
except Exception:
msg_dia = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
msg_dia.set_markup(_("<big><b>Unable to add %s</b></big>" % new_engine))
msg_dia.format_secondary_text(_("There is something wrong with this executable"))
msg_dia.run()
msg_dia.hide()
self.add = False
engine_chooser_dialog.hide()
return
else:
# restore the original
engine = discoverer.getEngineByName(self.cur_engine)
engine_chooser_dialog.set_filename(engine["command"])
engine_chooser_dialog.hide()
