def dismiss(self, *args, **kwargs):
"""Used to change the language and the font proportion"""
lang = config.settings.langCode.get() == old_lang or config.settings.langCode.get() == self.saveOldConfig[config.settings.langCode]
font = config.settings.fontProportion.get() == old_fprop or config.settings.fontProportion.get() == self.saveOldConfig[config.settings.fontProportion]
#-# The following lines will be used for the language and font dynamic changes
#-# The restart boxes will be suppressed.
# lang = config.settings.langCode.get() == self.saveOldConfig[config.settings.langCode]
# font = config.settings.fontProportion.get() == self.saveOldConfig[config.settings.fontProportion]
# self.changeLanguage()
# if not font or not lang:
# editor = self.mcedit.editor
# if editor and editor.unsavedEdits:
# result = albow.ask("You must restart MCEdit to see language changes", ["Save and Restart", "Restart", "Later"])
# else:
# result = albow.ask("You must restart MCEdit to see language changes", ["Restart", "Later"])
# if result == "Save and Restart":
# editor.saveFile()
# self.mcedit.restart()
# elif result == "Restart":
# self.mcedit.restart()
# elif result == "Later":
# pass
self.reshowNumberFields()
for key in self.saveOldConfig.keys():
self.saveOldConfig[key] = key.get()
config.save()
Dialog.dismiss(self, *args, **kwargs)
def cancel(self, *args, **kwargs):
Changes = False
for key in self.saveOldConfig.keys():
if key.get() != self.saveOldConfig[key]:
Changes = True
oldLanguage = self.saveOldConfig[config.settings.langCode]
if config.settings.langCode.get() != oldLanguage:
Changes = True
newPortable = _(self.portableVar.get())
if newPortable != _(self.saveOldPortable):
Changes = True
if not Changes:
Dialog.dismiss(self, *args, **kwargs)
return
result = albow.ask("Do you want to save your changes?", ["Save", "Don't Save", "Cancel"])
if result == "Cancel":
return
if result == "Save":
self.dismiss(*args, **kwargs)
return
if config.settings.langCode.get() != oldLanguage:
self.languageButton.selectedChoice = self.sgnal[oldLanguage]
self.changeLanguage()
if _(newPortable) != _(self.saveOldPortable):
self.portableVar.set(newPortable)
self.togglePortable()
for key in self.saveOldConfig.keys():
key.set(self.saveOldConfig[key])
config.save()
Dialog.dismiss(self, *args, **kwargs)
def dismiss(self, *args, **kwargs):
for key in self.saveOldConfig.keys():
self.saveOldConfig[key] = key.get()
self.saveOldResourcePack = self.resourcePackButton.selectedChoice
config.save()
Dialog.dismiss(self, *args, **kwargs)
def dismiss(self, *args, **kwargs):
"""Used to change the language."""
lng = config.settings.langCode.get()
try:
o, n, sc = albow.translate.setLang(lng)
except:
o, n, sc = albow.translate.setLang(self.langs[lng])
if not sc and n != "en_US":
albow.alert(_("{} is not a valid language").format("%s [%s]" % (self.sgnal[n], n)))
if o == n:
o = "en_US"
config.settings.langCode.set(o)
albow.translate.setLang(o)
elif o != n:
editor = self.mcedit.editor
if editor and editor.unsavedEdits:
result = albow.ask("You must restart MCEdit to see language changes", ["Save and Restart", "Restart", "Later"])
else:
result = albow.ask("You must restart MCEdit to see language changes", ["Restart", "Later"])
if result == "Save and Restart":
editor.saveFile()
self.mcedit.restart()
elif result == "Restart":
self.mcedit.restart()
elif result == "Later":
pass
for key in self.saveOldConfig.keys():
self.saveOldConfig[key] = key.get()
config.save()
Dialog.dismiss(self, *args, **kwargs)
def process_data_files():
# TODO: fix bug
# new_config = get_new_new_config()
# config.load()
# config.config["modules"]["gae_proxy"]["current_version"] = new_config["modules"]["gae_proxy"]["current_version"]
# config.config["modules"]["launcher"]["current_version"] = new_config["modules"]["launcher"]["current_version"]
config.save()
def qApp_aboutToQuit(self):
if self.isMaximized():
config.GUI_MAXIMIZED = True
else:
config.GUI_MAXIMIZED = False
config.GUI_GEOMETRY = self.geometry()
config.save()
def key_down(self, evt):
keyname = self.root.getKey(evt)
if keyname == 'Escape':
if self.changesNum:
result = albow.ask("Do you want to save your changes?", ["Save", "Don't Save", "Cancel"])
if result == "Save":
self.done()
elif result == "Don't Save":
for k in self.changes.keys():
config.keys[config.convert(k)].set(self.changes[k])
self.changesNum = False
self.changes = {}
self.choiceButton.selectedChoice = self.oldChoice
config.save()
self.dismiss()
else:
self.dismiss()
elif keyname == 'Up' and self.selectedKeyIndex > 0:
self.selectedKeyIndex -= 1
elif keyname == 'Down' and self.selectedKeyIndex < len(self.keyConfigKeys) - 1:
self.selectedKeyIndex += 1
elif keyname == 'Return':
self.enter += 1
self.askAssignSelectedKey()
self.root.handling_ctrl(evt)
def dismiss(self, *args, **kwargs):
"""Used to change the language and the font proportion"""
lang = config.settings.langCode.get() == old_lang or config.settings.langCode.get() == self.saveOldConfig[config.settings.langCode]
font = config.settings.fontProportion.get() == old_fprop or config.settings.fontProportion.get() == self.saveOldConfig[config.settings.fontProportion]
#-# The following lines will be used for the language and font dynamic changes
#-# The restart boxes will be suppressed.
# lang = config.settings.langCode.get() == self.saveOldConfig[config.settings.langCode]
# font = config.settings.fontProportion.get() == self.saveOldConfig[config.settings.fontProportion]
# self.changeLanguage()
# if not font or not lang:
# editor = self.mcedit.editor
# if editor and editor.unsavedEdits:
# result = albow.ask("You must restart MCEdit to see language changes", ["Save and Restart", "Restart", "Later"])
# else:
# result = albow.ask("You must restart MCEdit to see language changes", ["Restart", "Later"])
# if result == "Save and Restart":
# editor.saveFile()
# self.mcedit.restart()
# elif result == "Restart":
# self.mcedit.restart()
# elif result == "Later":
# pass
self.reshowNumberFields()
for key in self.saveOldConfig.keys():
self.saveOldConfig[key] = key.get()
config.save()
Dialog.dismiss(self, *args, **kwargs)
def cancel(self, *args, **kwargs):
Changes = False
self.reshowNumberFields()
for key in self.saveOldConfig.keys():
if key.get() != self.saveOldConfig[key]:
Changes = True
if self.saveOldResourcePack != self.resourcePackButton.selectedChoice:
Changes = True
if not Changes:
Dialog.dismiss(self, *args, **kwargs)
return
result = albow.ask("Do you want to save your changes?", ["Save", "Don't Save", "Cancel"])
if result == "Cancel":
return
if result == "Save":
self.dismiss(*args, **kwargs)
return
for key in self.saveOldConfig.keys():
key.set(self.saveOldConfig[key])
if self.resourcePackButton.selectedChoice != self.saveOldResourcePack:
self.resourcePackButton.selectedChoice = self.saveOldResourcePack
self.change_texture()
config.save()
Dialog.dismiss(self, *args, **kwargs)
def OnClose(self, event):
"""Program exit event handler"""
# If changes have taken place save of old grid
if self.main_window.changed_since_save:
save_choice = self.interfaces.get_save_request_from_user()
if save_choice is None:
# Cancelled close operation
return
elif save_choice:
# User wants to save content
post_command_event(self.main_window, SaveMsg)
# Uninit the AUI stuff
self.main_window._mgr.UnInit()
# Save config
config.save()
# Close main_window
self.main_window.Destroy()
def key_down(self, evt):
keyname = self.root.getKey(evt)
if keyname == 'Escape':
if self.changesNum:
result = albow.ask("Do you want to save your changes?",
["Save", "Don't Save", "Cancel"])
if result == "Save":
self.done()
elif result == "Don't Save":
for k in self.changes.keys():
config.keys[config.convert(k)].set(self.changes[k])
self.changesNum = False
self.changes = {}
self.choiceButton.selectedChoice = self.oldChoice
config.save()
self.dismiss()
else:
self.dismiss()
elif keyname == 'Up' and self.selectedKeyIndex > 0:
self.selectedKeyIndex -= 1
elif keyname == 'Down' and self.selectedKeyIndex < len(
self.keyConfigKeys) - 1:
self.selectedKeyIndex += 1
elif keyname == 'Return':
self.enter += 1
self.askAssignSelectedKey()
self.root.handling_ctrl(evt)
def cancel(self, *args, **kwargs):
Changes = False
self.reshowNumberFields()
for key in self.saveOldConfig.keys():
if key.get() != self.saveOldConfig[key]:
Changes = True
if self.saveOldResourcePack != self.resourcePackButton.selectedChoice:
Changes = True
if not Changes:
Dialog.dismiss(self, *args, **kwargs)
return
result = albow.ask("Do you want to save your changes?",
["Save", "Don't Save", "Cancel"])
if result == "Cancel":
return
if result == "Save":
self.dismiss(*args, **kwargs)
return
for key in self.saveOldConfig.keys():
key.set(self.saveOldConfig[key])
if self.resourcePackButton.selectedChoice != self.saveOldResourcePack:
self.resourcePackButton.selectedChoice = self.saveOldResourcePack
self.change_texture()
config.save()
Dialog.dismiss(self, *args, **kwargs)
def authorize(self, payload):
# Handle OAuth authorization code callback. Returns access token if successful, otherwise raises CredentialsError
if not '?' in payload:
print 'Auth\tMalformed response "%s"' % payload.encode('utf-8')
raise CredentialsError() # Not well formed
data = urlparse.parse_qs(payload[payload.index('?')+1:])
if not self.state or not data.get('state') or data['state'][0] != self.state:
print 'Auth\tUnexpected response "%s"' % payload.encode('utf-8')
raise CredentialsError() # Unexpected reply
if not data.get('code'):
print 'Auth\tNegative response "%s"' % payload.encode('utf-8')
if data.get('error_description'):
raise CredentialsError('Error: %s' % data['error_description'][0])
elif data.get('error'):
raise CredentialsError('Error: %s' % data['error'][0])
elif data.get('message'):
raise CredentialsError('Error: %s' % data['message'][0])
else:
raise CredentialsError()
try:
r = None
data = {
'grant_type': 'authorization_code',
'client_id': CLIENT_ID,
'code_verifier': self.verifier,
'code': data['code'][0],
'redirect_uri': protocolhandler.redirect,
}
r = self.session.post(SERVER_AUTH + URL_TOKEN, data=data, timeout=auth_timeout)
data = r.json()
if r.status_code == requests.codes.ok:
print 'Auth\tNew token for %s' % self.cmdr.encode('utf-8')
cmdrs = config.get('cmdrs')
idx = cmdrs.index(self.cmdr)
tokens = config.get('fdev_apikeys') or []
tokens = tokens + [''] * (len(cmdrs) - len(tokens))
tokens[idx] = data.get('refresh_token', '')
config.set('fdev_apikeys', tokens)
config.save() # Save settings now for use by command-line app
return data.get('access_token')
except:
print 'Auth\tCan\'t get token for %s' % self.cmdr.encode('utf-8')
print_exc()
if r: self.dump(r)
raise CredentialsError()
print 'Auth\tCan\'t get token for %s' % self.cmdr.encode('utf-8')
self.dump(r)
if data.get('error_description'):
raise CredentialsError('Error: %s' % data['error_description'])
elif data.get('error'):
raise CredentialsError('Error: %s' % data['error'])
elif data.get('message'):
raise CredentialsError('Error: %s' % data['message'])
else:
raise CredentialsError()
def dismiss(self, *args, **kwargs):
self.checkMaxView()
for key in self.saveOldConfig.keys():
self.saveOldConfig[key] = key.get()
self.saveOldResourcePack = self.resourcePackButton.selectedChoice
config.save()
Dialog.dismiss(self, *args, **kwargs)
def save_sounds(self):
sounds_dict = defaultdict(dict)
for category, sounds in self.sounds.items():
for sound in sounds:
sounds_dict[category][sound] = None
settings['sounds'] = json.dumps(sounds_dict)
config.save()
def resetDefault(self):
for key in self.saveOldConfig.keys():
key.set(key.default)
if self.resourcePackButton.selectedChoice != "Default Resource Pack":
self.resourcePackButton.selectedChoice = "Default Resource Pack"
self.change_texture()
config.save()
def invalidate(cmdr):
print 'Auth\tInvalidated token for %s' % cmdr.encode('utf-8')
cmdrs = config.get('cmdrs')
idx = cmdrs.index(cmdr)
tokens = config.get('fdev_apikeys') or []
tokens = tokens + [''] * (len(cmdrs) - len(tokens))
tokens[idx] = ''
config.set('fdev_apikeys', tokens)
config.save() # Save settings now for use by command-line app
def dismiss(self, *args, **kwargs):
self.reshowNumberFields()
self.checkMaxView()
for key in self.saveOldConfig.keys():
self.saveOldConfig[key] = key.get()
self.saveOldResourcePack = self.resourcePackButton.selectedChoice
config.save()
Dialog.dismiss(self, *args, **kwargs)
def resetDefault(self):
for key in self.saveOldConfig.keys():
key.set(key.default)
self.reshowNumberFields()
if self.resourcePackButton.selectedChoice != "Default Resource Pack":
self.resourcePackButton.selectedChoice = "Default Resource Pack"
self.change_texture()
config.save()
def invalidate(cmdr):
print 'Auth\tInvalidated token for %s' % cmdr.encode('utf-8')
cmdrs = config.get('cmdrs')
idx = cmdrs.index(cmdr)
tokens = config.get('fdev_apikeys') or []
tokens = tokens + [''] * (len(cmdrs) - len(tokens))
tokens[idx] = ''
config.set('fdev_apikeys', tokens)
config.save() # Save settings now for use by command-line app
def open_explorer(self):
self.folder = QtWidgets.QFileDialog.getExistingDirectory(
dir=self.gui.line_folder.text())
if self.folder:
self.gui.line_folder.setText(self.folder)
settings['folder'] = self.folder
config.save()
self.sounds.clear()
self._load_tree_items()
def restart(self):
self.saveWindowPosition()
config.save()
self.editor.renderer.discardAllChunks()
self.editor.deleteAllCopiedSchematics()
python = sys.executable
if sys.argv[0].endswith('.exe') or hasattr(sys, 'frozen'):
os.execl(python, python, *sys.argv[1:])
else:
os.execl(python, python, *sys.argv)
def disable(self, name):
""" prevent plugins <name> to be loaded. """
try:
config['loadlist'].remove(name)
config.save()
self.plugdeny.data.append(name)
self.plugdeny.save()
except:
pass
def verify(self, callback, code):
try:
self.session.verify(code)
config.save() # Save settings now for use by command-line app
except Exception as e:
if __debug__: print_exc()
self.button['state'] = self.theme_button['state'] = tk.NORMAL
self.status['text'] = unicode(e)
else:
return callback() # try again
def restart(self):
self.saveWindowPosition()
config.save()
self.editor.renderer.discardAllChunks()
self.editor.deleteAllCopiedSchematics()
python = sys.executable
if sys.argv[0].endswith('.exe') or hasattr(sys, 'frozen'):
os.execl(python, python, * sys.argv[1:])
else:
os.execl(python, python, * sys.argv)
def verify(self, code):
try:
self.session.verify(code)
config.save() # Save settings now for use by command-line app
except Exception as e:
if __debug__: print_exc()
self.button['state'] = tk.NORMAL
self.status['text'] = unicode(e)
else:
return self.getandsend() # try again
def invalidate(cmdr: str) -> None:
"""Invalidate Refresh Token for specified Commander."""
logger.info(f'Frontier CAPI Auth: Invalidated token for "{cmdr}"')
cmdrs = config.get('cmdrs')
idx = cmdrs.index(cmdr)
tokens = config.get('fdev_apikeys') or []
tokens = tokens + [''] * (len(cmdrs) - len(tokens))
tokens[idx] = ''
config.set('fdev_apikeys', tokens)
config.save() # Save settings now for use by command-line app
def req_config_handler(self):
req = urlparse.urlparse(self.path).query
reqs = urlparse.parse_qs(req, keep_blank_values=True)
data = ''
appid_updated = False
try:
if reqs['cmd'] == ['get_config']:
ret_config = {
"appid": "|".join(config.GAE_APPIDS),
"auto_adjust_scan_ip_thread_num":
config.auto_adjust_scan_ip_thread_num,
"scan_ip_thread_num": config.max_scan_ip_thread_num,
"use_ipv6": config.use_ipv6
}
data = json.dumps(ret_config, default=lambda o: o.__dict__)
elif reqs['cmd'] == ['set_config']:
appids = self.postvars['appid'][0]
if appids != "|".join(config.GAE_APPIDS):
if appids and (front.ip_manager.good_ipv4_num +
front.ip_manager.good_ipv6_num):
fail_appid_list = test_appids(appids)
if len(fail_appid_list):
fail_appid = "|".join(fail_appid_list)
return self.send_response_nc(
'text/html',
'{"res":"fail", "reason":"appid fail:%s"}' %
fail_appid)
appid_updated = True
if appids:
xlog.info("set appids:%s", appids)
config.GAE_APPIDS = appids.split("|")
else:
config.GAE_APPIDS = []
config.save()
config.load()
front.appid_manager.reset_appid()
if appid_updated:
front.http_dispatcher.close_all_worker()
front.ip_manager.reset()
data = '{"res":"success"}'
self.send_response_nc('text/html', data)
#http_request("http://127.0.0.1:8085/init_module?module=gae_proxy&cmd=restart")
return
except Exception as e:
xlog.exception("req_config_handler except:%s", e)
data = '{"res":"fail", "except":"%s"}' % e
self.send_response_nc('text/html', data)
def enable(self, name):
""" enable plugin <name>. """
try:
if name not in config['loadlist']:
config['loadlist'].append(name)
config.save()
self.plugdeny.data.remove(name)
self.plugdeny.save()
except:
pass
def done(self):
self.changesNum = False
self.changes = {}
config.save()
self.editor.movements = [
config.keys.left.get(),
config.keys.right.get(),
config.keys.forward.get(),
config.keys.back.get(),
config.keys.up.get(),
config.keys.down.get()
]
self.editor.toolbarKeys = [
config.keys.select.get(),
config.keys.brush.get(),
config.keys.clone.get(),
config.keys.fillAndReplace.get(),
config.keys.filter.get(),
config.keys.importKey.get(),
config.keys.players.get(),
config.keys.worldSpawnpoint.get(),
config.keys.chunkControl.get(),
config.keys.nbtExplorer.get()
]
self.editor.cameraPan = [
config.keys.panLeft.get(),
config.keys.panRight.get(),
config.keys.panUp.get(),
config.keys.panDown.get()
]
self.editor.sprintKey = config.keys.sprint.get()
self.root.movementLabel.text = _(
"{0}/{1}/{2}/{3}/{4}/{5} to move").format(
_(config.keys.forward.get()),
_(config.keys.left.get()),
_(config.keys.back.get()),
_(config.keys.right.get()),
_(config.keys.up.get()),
_(config.keys.down.get()),
)
self.root.slowDownLabel.text = _("{0} to slow down").format(
_(config.keys.brake.get()))
self.root.detailsLabel.text = _("Hold {0} for details").format(
_(config.keys.showBlockInfo.get()))
self.root.commandRow.labels[0].text = config.keys.newWorld.get()
self.root.commandRow.labels[1].text = config.keys.quickLoad.get()
self.root.commandRow.labels[2].text = config.keys.open.get()
self.dismiss()
def disable(self, name):
""" prevent plugins <name> to be loaded. """
try:
config['loadlist'].remove(name)
config.save()
self.plugdeny.data.append(name)
self.plugdeny.save()
except:
pass
def check_new_machine():
current_path = os.path.dirname(os.path.abspath(__file__))
if current_path != config.last_path:
config.last_path = current_path
config.save()
if sys.platform == "win32" and platform.release() == "XP":
notify_install_tcpz_for_winXp()
if os.getenv("XXNET_NO_MESS_SYSTEM", "0") == "0":
xlog.info("generate desktop shortcut")
create_desktop_shortcut()
def authorize(self, payload):
# Handle OAuth authorization code callback. Returns access token if successful, otherwise raises CredentialsError
if not '?' in payload:
print 'Auth\tMalformed response "%s"' % payload.encode('utf-8')
raise CredentialsError() # Not well formed
data = urlparse.parse_qs(payload[payload.index('?') + 1:])
if not self.state or not data.get(
'state') or data['state'][0] != self.state:
print 'Auth\tUnexpected response "%s"' % payload.encode('utf-8')
raise CredentialsError() # Unexpected reply
if not data.get('code'):
print 'Auth\tNegative response "%s"' % payload.encode('utf-8')
if data.get('error_description'):
raise CredentialsError('Error: %s' %
data['error_description'][0])
elif data.get('error'):
raise CredentialsError('Error: %s' % data['error'][0])
else:
raise CredentialsError()
try:
data = {
'grant_type': 'authorization_code',
'client_id': CLIENT_ID,
'code_verifier': self.verifier,
'code': data['code'][0],
'redirect_uri': protocolhandler.redirect,
}
r = self.session.post(SERVER_AUTH + URL_TOKEN,
data=data,
timeout=timeout)
if r.status_code == requests.codes.ok:
print 'Auth\tNew token for %s' % self.cmdr.encode('utf-8')
data = r.json()
cmdrs = config.get('cmdrs')
idx = cmdrs.index(self.cmdr)
tokens = config.get('fdev_apikeys') or []
tokens = tokens + [''] * (len(cmdrs) - len(tokens))
tokens[idx] = data.get('refresh_token', '')
config.set('fdev_apikeys', tokens)
config.save() # Save settings now for use by command-line app
return data.get('access_token')
else:
print 'Auth\tCan\'t get token for %s' % self.cmdr.encode(
'utf-8')
self.dump(r)
except:
print 'Auth\tCan\'t get token for %s' % self.cmdr.encode('utf-8')
print_exc()
raise CredentialsError()
def enable(self, name):
""" enable plugin <name>. """
try:
if name not in config['loadlist']:
config['loadlist'].append(name)
config.save()
self.plugdeny.data.remove(name)
self.plugdeny.save()
except:
pass
async def language(self, ctx: Context, *args):
settings = get_language_config_by_id(ctx.guild.id)
supported_languages = [
i.replace(".yml", "") for i in os.listdir("./translations")
]
if args:
if args[0] not in supported_languages:
await ctx.send(
embed=Embed(description=settings.not_supported_language,
color=0xff0000))
return
langs = config.language
translation = config.translation
langs[str(ctx.guild.id)] = args[0]
config.save("language", langs)
translation[str(ctx.guild.id)] = get_default_bible_translation(
str(ctx.guild.id))
config.save("translation", translation)
settings = get_language_config_by_id(ctx.guild.id)
await ctx.send(embed=Embed(
description=settings.f_language_successfully_changed(
get_language(ctx.guild.id)),
color=0x34bdeb))
return
embed = Embed(
title=settings.f_language_settings_embed_title(ctx.guild.name),
description=settings.f_language_settings_embed_description(
get_language(ctx.guild.id), await get_prefix(ctx.message)),
color=0x34bdeb)
langs = dict()
for filename in os.listdir("./translations"):
if filename.endswith(".yml"):
yaml_file = yaml.safe_load(open(f"translations/{filename}"))
langs[filename[:-4]] = yaml_file["language-name"]
description = ""
for l in langs.keys():
description += f"`{l}` | " + langs[l] + "\n"
embed.add_field(name=settings.supported_languages,
value=description,
inline=False)
await ctx.send(embed=embed)
def req_scan_ip_handler(self):
req = urlparse.urlparse(self.path).query
reqs = urlparse.parse_qs(req, keep_blank_values=True)
data = ""
if reqs['cmd'] == ['get_range']:
data = front.ipv4_source.load_range_content()
elif reqs['cmd'] == ['update']:
#update ip_range if needed
content = self.postvars['ip_range'][0]
#check ip_range checksums, update if needed
default_digest = hashlib.md5(
front.ipv4_source.load_range_content(
default=True)).hexdigest()
old_digest = hashlib.md5(
front.ipv4_source.load_range_content()).hexdigest()
new_digest = hashlib.md5(content).hexdigest()
if new_digest == default_digest:
front.ipv4_source.remove_user_range()
else:
if old_digest != new_digest:
front.ipv4_source.update_range_content(content)
if old_digest != new_digest:
front.ipv4_source.load_ip_range()
#update auto_adjust_scan_ip and scan_ip_thread_num
should_auto_adjust_scan_ip = int(
self.postvars['auto_adjust_scan_ip_thread_num'][0])
thread_num_for_scan_ip = int(
self.postvars['scan_ip_thread_num'][0])
use_ipv6 = self.postvars['use_ipv6'][0]
if config.use_ipv6 != use_ipv6:
xlog.debug("use_ipv6 change to %s", use_ipv6)
config.use_ipv6 = use_ipv6
#update user config settings
config.auto_adjust_scan_ip_thread_num = should_auto_adjust_scan_ip
config.max_scan_ip_thread_num = thread_num_for_scan_ip
config.save()
config.load()
front.ip_manager.adjust_scan_thread_num()
#reponse
data = '{"res":"success"}'
mimetype = 'text/plain'
self.send_response_nc(mimetype, data)
def set_proxy_applist(self):
xlog.debug("set_proxy_applist %r", self.postvars)
config.proxy_by_app = int(
self.postvars.get(b'proxy_by_app') == [b"true"])
config.enabled_app_list = utils.to_str(
self.postvars.get(b"enabled_app_list[]", []))
xlog.debug("set_proxy_applist proxy_by_app:%s", config.proxy_by_app)
xlog.debug("set_proxy_applist enabled_app_list:%s",
config.enabled_app_list)
config.save()
data = {"res": "success"}
self.send_response("text/html", json.dumps(data))
def restart(self):
self.saveWindowPosition()
config.save()
self.editor.renderer.discardAllChunks()
self.editor.deleteAllCopiedSchematics()
if self.editor.level:
self.editor.level.close()
self.editor.root.RemoveEditFiles()
python = sys.executable
if sys.argv[0].endswith(".exe") or hasattr(sys, "frozen"):
os.execl(python, python, *sys.argv[1:])
else:
os.execl(python, python, *sys.argv)
def done(self):
self.changesNum = False
self.changes = {}
config.save()
self.editor.movements = [
config.keys.left.get(),
config.keys.right.get(),
config.keys.forward.get(),
config.keys.back.get(),
config.keys.up.get(),
config.keys.down.get()
]
self.editor.toolbarKeys = [
config.keys.select.get(),
config.keys.brush.get(),
config.keys.clone.get(),
config.keys.fillAndReplace.get(),
config.keys.filter.get(),
config.keys.importKey.get(),
config.keys.players.get(),
config.keys.worldSpawnpoint.get(),
config.keys.chunkControl.get(),
config.keys.nbtExplorer.get()
]
self.editor.cameraPan = [
config.keys.panLeft.get(),
config.keys.panRight.get(),
config.keys.panUp.get(),
config.keys.panDown.get()
]
self.editor.sprintKey = config.keys.sprint.get()
self.root.movementLabel.text = _("{0}/{1}/{2}/{3}/{4}/{5} to move").format(
_(config.keys.forward.get()),
_(config.keys.left.get()),
_(config.keys.back.get()),
_(config.keys.right.get()),
_(config.keys.up.get()),
_(config.keys.down.get()),
)
self.root.slowDownLabel.text = _("{0} to slow down").format(_(config.keys.brake.get()))
self.root.detailsLabel.text = _("Hold {0} for details").format(_(config.keys.showBlockInfo.get()))
self.root.commandRow.labels[0].text = config.keys.newWorld.get()
self.root.commandRow.labels[1].text = config.keys.quickLoad.get()
self.root.commandRow.labels[2].text = config.keys.open.get()
self.dismiss()
def _update_center(self, event=None):
x, y = self.center_x.var.get(), self.center_y.var.get()
if not x or not y:
return False
try:
center = tuple((x, y))
except ValueError:
logging.error("Malformed center fix params!")
return False
config.center = center
config.save()
logging.info("Updated center fix: %s", str(center))
return True
def _update_roi(self, event=None):
try:
roi = tuple(int(v.var.get()) for v in self.roi_entries)
except ValueError:
logging.error("Malformed ROI params!")
return False
if roi[0] < roi[2] and roi[1] < roi[3]:
config.roi = roi
config.save()
logging.info("Updated region of interest: %s", str(roi))
return True
else:
logging.warning("Invalid ROI params!")
def check():
import update_from_github
current_version = update_from_github.current_version()
last_run_version = config.last_run_version
if last_run_version == "0.0.0":
postUpdateStat = "isNew"
elif last_run_version != current_version:
postUpdateStat = "isPostUpdate"
run(last_run_version)
else:
return
config.postUpdateStat = postUpdateStat
config.last_run_version = current_version
config.save()
def calculate_sign(self, dt=None):
"""
encrypt the request data according to the secret
:param dt: data need to be encrypted, Default is None
:type dt: dict
:return: Usign
"""
# deepcopy dt
datas = copy.deepcopy(dt)
# sign request data
if not datas:
datas = ""
result = ''
for index in sorted(datas):
if isinstance(datas[index], list):
# if data is list need to change a string
temp = ''
for data in datas[index]:
if isinstance(data, bool):
if data:
data = 'true'
else:
data = 'false'
else:
data = str(data)
temp += data
datas[index] = temp
if isinstance(datas[index], bool):
if datas[index]:
datas[index] = 'true'
else:
datas[index] = 'false'
result = result + str(index) + str(datas[index])
del datas
if (self.curtime + (5 * 60 - 1)) < int(time.time()):
self.curtime = int(time.time())
ulordconfig.update({'ulord_curtime': self.curtime})
USign = self.appkey + result + self.ulord_secret + str(self.curtime)
self.USign = utils.generateMD5(USign).upper()
ulordconfig.update({
'ulord_head': {
'U-AppKey': self.appkey,
'U-CurTime': str(self.curtime),
'U-Sign': self.USign
}
})
config.save()
self.ulord_head = ulordconfig.get('ulord_head')
return self.USign
def req_config_handler(self):
req = urlparse.urlparse(self.path).query
reqs = urlparse.parse_qs(req, keep_blank_values=True)
data = ''
appid_updated = False
try:
if reqs['cmd'] == ['get_config']:
ret_config = {
"appid": "|".join(config.GAE_APPIDS),
"auto_adjust_scan_ip_thread_num": config.auto_adjust_scan_ip_thread_num,
"scan_ip_thread_num": config.max_scan_ip_thread_num,
"use_ipv6": config.use_ipv6
}
data = json.dumps(ret_config, default=lambda o: o.__dict__)
elif reqs['cmd'] == ['set_config']:
appids = self.postvars['appid'][0]
if appids != "|".join(config.GAE_APPIDS):
if appids and (front.ip_manager.good_ipv4_num + front.ip_manager.good_ipv6_num):
fail_appid_list = test_appids(appids)
if len(fail_appid_list):
fail_appid = "|".join(fail_appid_list)
return self.send_response_nc('text/html', '{"res":"fail", "reason":"appid fail:%s"}' % fail_appid)
appid_updated = True
if appids:
xlog.info("set appids:%s", appids)
config.GAE_APPIDS = appids.split("|")
else:
config.GAE_APPIDS = []
config.save()
config.load()
front.appid_manager.reset_appid()
if appid_updated:
front.http_dispatcher.close_all_worker()
front.ip_manager.reset()
data = '{"res":"success"}'
self.send_response_nc('text/html', data)
#http_request("http://127.0.0.1:8085/init_module?module=gae_proxy&cmd=restart")
return
except Exception as e:
xlog.exception("req_config_handler except:%s", e)
data = '{"res":"fail", "except":"%s"}' % e
self.send_response_nc('text/html', data)
def resetDefault(self):
for key in self.saveOldConfig.keys():
if "AttrRef" in str(key):
key.set(config.settings.blockBuffer.default / 1048576)
elif "lang" not in str(key):
key.set(key.default)
if config.settings.langCode.get() != "en_US":
config.settings.langCode.set("en_US")
self.changeLanguage()
if "Fixed" not in self.portableVar.get():
self.portableVar.set("Install Mode: Fixed")
self.togglePortable()
config.save()
def cancel(self):
if self.changesNum:
result = albow.ask("Do you want to save your changes?", ["Save", "Don't Save", "Cancel"])
if result == "Save":
self.done()
elif result == "Don't Save":
for k in self.changes.keys():
config.keys[config.convert(k)].set(self.changes[k])
self.changesNum = False
self.changes = {}
self.choiceButton.selectedChoice = self.oldChoice
config.save()
self.dismiss()
else:
self.dismiss()
def resetDefault(self):
self.reshowNumberFields()
for key in self.saveOldConfig.keys():
if "AttrRef" in str(key):
key.set(config.settings.blockBuffer.default / 1048576)
elif "lang" not in str(key):
key.set(key.default)
if config.settings.langCode.get() != "en_US":
config.settings.langCode.set("en_US")
self.changeLanguage()
if "Fixed" != self.portableVar.get():
self.portableVar.set("Fixed")
self.togglePortable()
config.save()
def dismiss(self, *args, **kwargs):
"""Used to change the font proportion."""
# If font proportion setting has changed, update the UI.
if config.settings.fontProportion.get() != self.saveOldConfig[config.settings.fontProportion]:
albow.resource.reload_fonts(proportion=config.settings.fontProportion.get())
self.mcedit.root.set_update_ui(True)
self.mcedit.root.set_update_ui(False)
self.mcedit.editor.set_update_ui(True)
self.mcedit.editor.set_update_ui(False)
self.reshowNumberFields()
for key in self.saveOldConfig.keys():
self.saveOldConfig[key] = key.get()
config.save()
Dialog.dismiss(self, *args, **kwargs)
def req_scan_ip_handler(self):
req = urlparse.urlparse(self.path).query
reqs = urlparse.parse_qs(req, keep_blank_values=True)
data = ""
if reqs['cmd'] == ['get_range']:
data = front.ipv4_source.load_range_content()
elif reqs['cmd'] == ['update']:
#update ip_range if needed
content = self.postvars['ip_range'][0]
#check ip_range checksums, update if needed
default_digest = hashlib.md5(front.ipv4_source.load_range_content(default=True)).hexdigest()
old_digest = hashlib.md5(front.ipv4_source.load_range_content()).hexdigest()
new_digest = hashlib.md5(content).hexdigest()
if new_digest == default_digest:
front.ipv4_source.remove_user_range()
else:
if old_digest != new_digest:
front.ipv4_source.update_range_content(content)
if old_digest != new_digest:
front.ipv4_source.load_ip_range()
#update auto_adjust_scan_ip and scan_ip_thread_num
should_auto_adjust_scan_ip = int(self.postvars['auto_adjust_scan_ip_thread_num'][0])
thread_num_for_scan_ip = int(self.postvars['scan_ip_thread_num'][0])
use_ipv6 = self.postvars['use_ipv6'][0]
if config.use_ipv6 != use_ipv6:
xlog.debug("use_ipv6 change to %s", use_ipv6)
config.use_ipv6 = use_ipv6
#update user config settings
config.auto_adjust_scan_ip_thread_num = should_auto_adjust_scan_ip
config.max_scan_ip_thread_num = thread_num_for_scan_ip
config.save()
config.load()
front.ip_manager.adjust_scan_thread_num()
#reponse
data='{"res":"success"}'
mimetype = 'text/plain'
self.send_response_nc(mimetype, data)
def confirm_quit(self):
#-# saving language template
if hasattr(albow.translate, "saveTemplate"):
albow.translate.saveTemplate()
#-#
self.saveWindowPosition()
config.save()
if self.editor.unsavedEdits:
result = albow.ask(_("There are {0} unsaved changes.").format(self.editor.unsavedEdits),
responses=["Save and Quit", "Quit", "Cancel"])
if result == "Save and Quit":
self.saveAndQuit()
elif result == "Quit":
self.justQuit()
elif result == "Cancel":
return False
else:
raise SystemExit
def resized(self, dw, dh):
"""
Handle window resizing events.
"""
GLViewport.resized(self, dw, dh)
(w, h) = self.size
if w == 0 and h == 0:
# The window has been minimized, no need to draw anything.
self.editor.renderer.render = False
return
if not self.editor.renderer.render:
self.editor.renderer.render = True
dis = None
if sys.platform == 'linux2' and mcplatform.hasXlibDisplay:
dis = mcplatform.Xlib.display.Display()
win = dis.create_resource_object('window', display.get_wm_info()['window'])
geom = win.query_tree().parent.get_geometry()
if w >= 1000 and h >= 700:
config.settings.windowWidth.set(w)
config.settings.windowHeight.set(h)
config.save()
if dis:
win.configure(height=geom.height, width=geom.width)
elif w !=0 and h !=0:
config.settings.windowWidth.set(1000)
config.settings.windowHeight.set(700)
config.save()
if dis:
win.configure(height=700, width=1000)
if dw > 20 or dh > 20:
if not hasattr(self, 'resizeAlert'):
self.resizeAlert = self.shouldResizeAlert
if self.resizeAlert:
albow.alert(
"Window size increased. You may have problems using the cursor until MCEdit is restarted.")
self.resizeAlert = False
if dis:
dis.sync()
def confirm_quit(self):
#-# saving language template
if hasattr(albow.translate, "saveTemplate"):
albow.translate.saveTemplate()
#-#
self.saveWindowPosition()
config.save()
if self.editor.unsavedEdits:
# if config.settings.savePositionOnClose.get():
# self.editor.waypointManager.saveLastPosition(self.editor.mainViewport, self.editor.level.getPlayerDimension())
# self.editor.waypointManager.save()
result = albow.ask(_("There are {0} unsaved changes.").format(self.editor.unsavedEdits),
responses=["Save and Quit", "Quit", "Cancel"])
if result == "Save and Quit":
self.saveAndQuit()
elif result == "Quit":
self.justQuit()
elif result == "Cancel":
return False
else:
raise SystemExit
def done(self):
self.changesNum = False
self.changes = {}
config.save()
self.editor.movements = [
config.keys.left.get(),
config.keys.right.get(),
config.keys.forward.get(),
config.keys.back.get(),
config.keys.up.get(),
config.keys.down.get()
]
self.editor.cameraPan = [
config.keys.panLeft.get(),
config.keys.panRight.get(),
config.keys.panUp.get(),
config.keys.panDown.get()
]
self.dismiss()
def getRowData(self, i):
if self.root is None:
self.root = self.get_root()
if self.editor is None:
self.editor = self.root.editor
configKey = self.keyConfigKeys[i]
if self.isConfigKey(configKey):
key = config.keys[config.convert(configKey)].get()
try:
oldKey = key
key = self.editor.different_keys[key]
if key != oldKey:
config.keys[config.convert(configKey)].set(key)
config.save()
except:
pass
if configKey in self.otherNames.keys():
configKey = self.otherNames[configKey]
else:
key = ""
return configKey, key
def cancel(self, *args, **kwargs):
Changes = False
self.reshowNumberFields()
for key in self.saveOldConfig.keys():
if key.get() != self.saveOldConfig[key]:
Changes = True
oldLanguage = self.saveOldConfig[config.settings.langCode]
if config.settings.langCode.get() != oldLanguage:
Changes = True
newPortable = self.portableVar.get()
if newPortable != self.saveOldPortable:
Changes = True
if not Changes:
Dialog.dismiss(self, *args, **kwargs)
return
result = albow.ask("Do you want to save your changes?", ["Save", "Don't Save", "Cancel"])
if result == "Cancel":
return
if result == "Save":
self.dismiss(*args, **kwargs)
return
if config.settings.langCode.get() != oldLanguage:
self.languageButton.selectedChoice = self.sgnal[oldLanguage]
self.changeLanguage()
if _(newPortable) != _(self.saveOldPortable):
self.portableVar.set(newPortable)
self.togglePortable()
for key in self.saveOldConfig.keys():
key.set(self.saveOldConfig[key])
config.save()
Dialog.dismiss(self, *args, **kwargs)
def refresh(self):
# Try refresh token. Returns new refresh token if successful, otherwise makes new authorization request.
self.verifier = None
cmdrs = config.get('cmdrs')
idx = cmdrs.index(self.cmdr)
tokens = config.get('fdev_apikeys') or []
tokens = tokens + [''] * (len(cmdrs) - len(tokens))
if tokens[idx]:
try:
data = {
'grant_type': 'refresh_token',
'client_id': CLIENT_ID,
'refresh_token': tokens[idx],
}
r = self.session.post(SERVER_AUTH + URL_TOKEN, data=data, timeout=auth_timeout)
if r.status_code == requests.codes.ok:
data = r.json()
tokens[idx] = data.get('refresh_token', '')
config.set('fdev_apikeys', tokens)
config.save() # Save settings now for use by command-line app
return data.get('access_token')
else:
print 'Auth\tCan\'t refresh token for %s' % self.cmdr.encode('utf-8')
self.dump(r)
except:
print 'Auth\tCan\'t refresh token for %s' % self.cmdr.encode('utf-8')
print_exc()
else:
print 'Auth\tNo token for %s' % self.cmdr.encode('utf-8')
# New request
print 'Auth\tNew authorization request'
self.verifier = self.base64URLEncode(os.urandom(32))
self.state = self.base64URLEncode(os.urandom(8))
# Won't work under IE: https://blogs.msdn.microsoft.com/ieinternals/2011/07/13/understanding-protocols/
webbrowser.open('%s%s?response_type=code&audience=frontier&scope=capi&client_id=%s&code_challenge=%s&code_challenge_method=S256&state=%s&redirect_uri=%s' % (SERVER_AUTH, URL_AUTH, CLIENT_ID, self.base64URLEncode(hashlib.sha256(self.verifier).digest()), self.state, protocolhandler.redirect))
def main(cls):
PlayerCache().load()
displayContext = GLDisplayContext(splash.splash, caption=(('MCEdit ~ ' + release.get_version()%_("for")).encode('utf-8'), 'MCEdit'))
os.environ['SDL_VIDEO_CENTERED'] = '0'
rootwidget = RootWidget(displayContext.display)
mcedit = MCEdit(displayContext)
rootwidget.displayContext = displayContext
rootwidget.confirm_quit = mcedit.confirm_quit
rootwidget.mcedit = mcedit
rootwidget.add(mcedit)
rootwidget.focus_switch = mcedit
if 0 == len(pymclevel.alphaMaterials.yamlDatas):
albow.alert("Failed to load minecraft.yaml. Check the console window for details.")
if mcedit.droppedLevel:
mcedit.loadFile(mcedit.droppedLevel)
cls.version_lock = threading.Lock()
cls.version_info = None
cls.version_checked = False
fetch_version_thread = threading.Thread(target=cls.fetch_version)
fetch_version_thread.start()
# Disabled old update code
# if hasattr(sys, 'frozen'):
# # We're being run from a bundle, check for updates.
# import esky
#
# app = esky.Esky(
# sys.executable.decode(sys.getfilesystemencoding()),
# 'https://bitbucket.org/codewarrior0/mcedit/downloads'
# )
# try:
# update_version = app.find_update()
# except:
# # FIXME: Horrible, hacky kludge.
# update_version = None
# logging.exception('Error while checking for updates')
#
# if update_version:
# answer = albow.ask(
# 'Version "%s" is available, would you like to '
# 'download it?' % update_version,
# [
# 'Yes',
# 'No',
# ],
# default=0,
# cancel=1
# )
# if answer == 'Yes':
# def callback(args):
# status = args['status']
# status_texts = {
# 'searching': u"Finding updates...",
# 'found': u"Found version {new_version}",
# 'downloading': u"Downloading: {received} / {size}",
# 'ready': u"Downloaded {path}",
# 'installing': u"Installing {new_version}",
# 'cleaning up': u"Cleaning up...",
# 'done': u"Done."
# }
# text = status_texts.get(status, 'Unknown').format(**args)
#
# panel = Dialog()
# panel.idleevent = lambda event: panel.dismiss()
# label = albow.Label(text, width=600)
# panel.add(label)
# panel.size = (500, 250)
# panel.present()
#
# try:
# app.auto_update(callback)
# except (esky.EskyVersionError, EnvironmentError):
# albow.alert(_("Failed to install update %s") % update_version)
# else:
# albow.alert(_("Version %s installed. Restart MCEdit to begin using it.") % update_version)
# raise SystemExit()
if config.settings.closeMinecraftWarning.get():
answer = albow.ask(
"Warning: Only open a world in one program at a time. If you open a world at the same time in MCEdit and in Minecraft, you will lose your work and possibly damage your save file.\n\n If you are using Minecraft 1.3 or earlier, you need to close Minecraft completely before you use MCEdit.",
["Don't remind me again.", "OK"], default=1, cancel=1)
if answer == "Don't remind me again.":
config.settings.closeMinecraftWarning.set(False)
# Disabled Crash Reporting Option
# if not config.settings.reportCrashesAsked.get():
# answer = albow.ask(
# "When an error occurs, MCEdit can report the details of the error to its developers. "
# "The error report will include your operating system version, MCEdit version, "
# "OpenGL version, plus the make and model of your CPU and graphics processor. No personal "
# "information will be collected.\n\n"
# "Error reporting can be enabled or disabled in the Options dialog.\n\n"
# "Enable error reporting?",
# ["Yes", "No"],
# default=0)
# config.settings.reportCrashes.set(answer == "Yes")
# config.settings.reportCrashesAsked.set(True)
config.settings.reportCrashes.set(False)
config.settings.reportCrashesAsked.set(True)
config.save()
if "update" in config.version.version.get():
answer = albow.ask("There are new default controls. Do you want to replace your current controls with the new ones?", ["Yes", "No"])
if answer == "Yes":
for configKey, k in keys.KeyConfigPanel.presets["WASD"]:
config.keys[config.convert(configKey)].set(k)
config.version.version.set("1.1.2.0")
config.save()
if "-causeError" in sys.argv:
raise ValueError("Error requested via -causeError")
while True:
try:
rootwidget.run()
except (SystemExit, KeyboardInterrupt):
print "Shutting down..."
exc_txt = traceback.format_exc()
if mcedit.editor.level:
if config.settings.savePositionOnClose.get():
mcedit.editor.waypointManager.saveLastPosition(mcedit.editor.mainViewport, mcedit.editor.level.getPlayerDimension())
mcedit.editor.waypointManager.save()
# The following Windows specific code won't be executed if we're using '--debug-wm' switch.
if not USE_WM and sys.platform == "win32" and config.settings.setWindowPlacement.get():
(flags, showCmd, ptMin, ptMax, rect) = mcplatform.win32gui.GetWindowPlacement(
display.get_wm_info()['window'])
X, Y, r, b = rect
#w = r-X
#h = b-Y
if (showCmd == mcplatform.win32con.SW_MINIMIZE or
showCmd == mcplatform.win32con.SW_SHOWMINIMIZED):
showCmd = mcplatform.win32con.SW_SHOWNORMAL
config.settings.windowX.set(X)
config.settings.windowY.set(Y)
config.settings.windowShowCmd.set(showCmd)
# Restore the previous language if we ran with '-tt' (update translation template).
if albow.translate.buildTemplate:
logging.warning('Restoring %s.'%orglang)
config.settings.langCode.set(orglang)
#
config.save()
mcedit.editor.renderer.discardAllChunks()
mcedit.editor.deleteAllCopiedSchematics()
if mcedit.editor.level:
mcedit.editor.level.close()
mcedit.editor.root.RemoveEditFiles()
if 'SystemExit' in traceback.format_exc() or 'KeyboardInterrupt' in traceback.format_exc():
raise
else:
if 'SystemExit' in exc_txt:
raise SystemExit
if 'KeyboardInterrupt' in exc_txt:
raise KeyboardInterrupt
except MemoryError:
traceback.print_exc()
mcedit.editor.handleMemoryError()
def resized(self, dw, dh):
"""
Handle window resizing events.
"""
if DEBUG_WM:
print "############################ RESIZED ############################"
(w, h) = self.size
config_w, config_h = config.settings.windowWidth.get(), config.settings.windowHeight.get()
win = self.displayContext.win
if DEBUG_WM and win:
print "dw", dw, "dh", dh
print "self.size (w, h) 1", self.size, "win.get_size", win.get_size()
print "size 1", config_w, config_h
elif DEBUG_WM and not win:
print "win is None, unable to print debug messages"
if win:
x, y = win.get_position()
if DEBUG_WM:
print "position", x, y
print "config pos", (config.settings.windowX.get(), config.settings.windowY.get())
if w == 0 and h == 0:
# The window has been minimized, no need to draw anything.
self.editor.renderer.render = False
return
# Mac window handling works better now, but `win`
# doesn't exist. So to get this alert to show up
# I'm checking if the platform is darwin. This only
# works because the code block never actually references
# `win`, otherwise it WOULD CRASH!!!
# You cannot change further if statements like this
# because they reference `win`
if win or sys.platform == "darwin":
# Handling too small resolutions.
# Dialog texts.
# "MCEdit does not support window resolutions below 1000x700.\nYou may not be able to access all functions at this resolution."
# New buttons:
# "Don't warn me again": disable the window popup across sessions.
# Tooltip: "Disable this message. Definitively. Even the next time you start MCEdit."
# "OK": dismiss the window and let go, don't pop up again for the session
# Tooltip: "Continue and not see this message until you restart MCEdit"
# "Cancel": resizes the window to the minimum size
# Tooltip: "Resize the window to the minimum recommended resolution."
# If the config showWindowSizeWarning is true and self.resizeAlert is true, show the popup
if (w < 1000 or h < 680) and config.settings.showWindowSizeWarning.get():
_w = w
_h = h
if self.resizeAlert:
answer = "_OK"
# Force the size only for the dimension that needs it.
if w < 1000 and h < 680:
_w = 1000
_h = 680
elif w < 1000:
_w = 1000
elif h < 680:
_h = 680
if not albow.dialogs.ask_tied_to:
answer = albow.ask(
"MCEdit does not support window resolutions below 1000x700.\nYou may not be able to access all functions at this resolution.",
["Don't remind me again.", "OK", "Cancel"], default=1, cancel=1,
responses_tooltips = {"Don't remind me again.": "Disable this message. Definitively. Even the next time you start MCEdit.",
"OK": "Continue and not see this message until you restart MCEdit",
"Cancel": "Resize the window to the minimum recommended resolution."},
tie_widget_to=True)
else:
if not albow.dialogs.ask_tied_to._visible:
albow.dialogs.ask_tied_to._visible = True
answer = albow.dialogs.ask_tied_to.present()
if answer == "Don't remind me again.":
config.settings.showWindowSizeWarning = False
self.resizeAlert = False
elif answer == "OK":
w, h = self.size
self.resizeAlert = False
elif answer == "Cancel":
w, h = _w, _h
else:
if albow.dialogs.ask_tied_to:
albow.dialogs.ask_tied_to.dismiss("_OK")
del albow.dialogs.ask_tied_to
albow.dialogs.ask_tied_to = None
elif (w >= 1000 or h >= 680):
if albow.dialogs.ask_tied_tos:
for ask_tied_to in albow.dialogs.ask_tied_tos:
ask_tied_to._visible = False
ask_tied_to.dismiss("_OK")
ask_tied_to.set_parent(None)
del ask_tied_to
if not win:
if w < 1000:
config.settings.windowWidth.set(1000)
w = 1000
x = config.settings.windowX.get()
if h < 680:
config.settings.windowHeight.set(680)
h = 680
y = config.settings.windowY.get()
if not self.editor.renderer.render:
self.editor.renderer.render = True
save_geom = True
if win:
maximized = win.get_state() == mcplatform.MAXIMIZED
sz = map(max, win.get_size(), (w, h))
if DEBUG_WM:
print "sz", sz
print "maximized", maximized, "self.maximized", self.maximized
if maximized:
if DEBUG_WM:
print "maximize, saving maximized size"
config.settings.windowMaximizedWidth.set(sz[0])
config.settings.windowMaximizedHeight.set(sz[1])
config.save()
self.saved_pos = config.settings.windowX.get(), config.settings.windowY.get()
save_geom = False
self.resizing = 0
win.set_mode(sz, self.displayContext.displayMode())
else:
if DEBUG_WM:
print "size 2", config.settings.windowWidth.get(), config.settings.windowHeight.get()
print "config_w", config_w, "config_h", config_h
print "pos", config.settings.windowX.get(), config.settings.windowY.get()
if self.maximized != maximized:
if DEBUG_WM:
print "restoring window pos and size"
print "(config.settings.windowX.get(), config.settings.windowY.get())", (config.settings.windowX.get(), config.settings.windowY.get())
(w, h) = (config_w, config_h)
win.set_state(1, (w, h), self.saved_pos)
else:
if DEBUG_WM:
print "window resized"
print "setting size to", (w, h), "and pos to", (x,y)
win.set_mode((w, h), self.displayContext.displayMode())
win.set_position((x, y))
config.settings.windowMaximizedWidth.set(0)
config.settings.windowMaximizedHeight.set(0)
config.save()
self.maximized = maximized
if DEBUG_WM:
print "self.size (w, h) 2", self.size, (w, h)
surf = pygame.display.get_surface()
print "display surf rect", surf.get_rect()
if win:
if hasattr(win.base_handler, 'get_geometry'):
print "win.base_handler geometry", win.base_handler.get_geometry()
print "win.base_handler.parent geometry", win.base_handler.query_tree().parent.get_geometry()
print "win.base_handler.parent.parent geometry", win.base_handler.query_tree().parent.query_tree().parent.get_geometry()
if save_geom:
config.settings.windowWidth.set(w)
config.settings.windowHeight.set(h)
config.save()
# The alert window is disabled if win is not None
if not win and (dw > 20 or dh > 20):
if not hasattr(self, 'resizeAlert'):
self.resizeAlert = self.shouldResizeAlert
if self.resizeAlert:
albow.alert(
"Window size increased. You may have problems using the cursor until MCEdit is restarted.")
self.resizeAlert = False
if win:
win.sync()
GLViewport.resized(self, dw, dh)
def reset(self, splash=None, caption=("", "")):
pygame.key.set_repeat(500, 100)
try:
display.gl_set_attribute(pygame.GL_SWAP_CONTROL, config.settings.vsync.get())
except Exception as e:
logging.warning('Unable to set vertical sync: {0!r}'.format(e))
display.gl_set_attribute(pygame.GL_ALPHA_SIZE, 8)
if DEBUG_WM:
print "config.settings.windowMaximized.get()", config.settings.windowMaximized.get()
wwh = self.getWindowSize()
if DEBUG_WM:
print "wwh 1", wwh
d = display.set_mode(wwh, self.displayMode())
# Let initialize OpenGL stuff after the splash.
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glAlphaFunc(GL.GL_NOTEQUAL, 0)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
# textures are 256x256, so with this we can specify pixel coordinates
# GL.glMatrixMode(GL.GL_TEXTURE)
# GL.glScale(1 / 256., 1 / 256., 1 / 256.)
display.set_caption(*caption)
if mcplatform.WindowHandler:
self.win = mcplatform.WindowHandler(mode=self.displayMode())
# The following Windows specific code won't be executed if we're using '--debug-wm' switch.
if not USE_WM and sys.platform == 'win32' and config.settings.setWindowPlacement.get():
config.settings.setWindowPlacement.set(False)
config.save()
X, Y = config.settings.windowX.get(), config.settings.windowY.get()
if X:
hwndOwner = display.get_wm_info()['window']
flags, showCmd, ptMin, ptMax, rect = mcplatform.win32gui.GetWindowPlacement(hwndOwner)
realW = rect[2] - rect[0]
realH = rect[3] - rect[1]
showCmd = config.settings.windowShowCmd.get()
rect = (X, Y, X + realW, Y + realH)
mcplatform.win32gui.SetWindowPlacement(hwndOwner, (0, showCmd, ptMin, ptMax, rect))
config.settings.setWindowPlacement.set(True)
config.save()
elif self.win:
maximized = config.settings.windowMaximized.get()
if DEBUG_WM:
print "maximized", maximized
if maximized:
geom = self.win.get_root_rect()
in_w, in_h = self.win.get_size()
x, y = int((geom[2] - in_w) / 2), int((geom[3] - in_h) / 2)
os.environ['SDL_VIDEO_CENTERED'] = '1'
else:
os.environ['SDL_VIDEO_CENTERED'] = '0'
x, y = config.settings.windowX.get(), config.settings.windowY.get()
wwh = self.win.get_size()
if DEBUG_WM:
print "x", x, "y", y
print "wwh 2", wwh
if splash:
# Setup the OGL display
GL.glLoadIdentity()
GLU.gluOrtho2D(0, wwh[0], 0, wwh[1])
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_ACCUM_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT)
swh = splash.get_size()
_x, _y = (wwh[0] / 2 - swh[0] / 2, wwh[1] / 2 - swh[1] / 2)
w, h = swh
try:
data = image.tostring(splash, 'RGBA_PREMULT', 1)
except ValueError:
data = image.tostring(splash, 'RGBA', 1)
except ValueError:
data = image.tostring(splash, 'RGB', 1)
# Set the raster position
GL.glRasterPos(_x, _y)
GL.glDrawPixels(w, h,
GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, numpy.fromstring(data, dtype='uint8'))
if splash:
display.flip()
if self.win:
if not maximized:
wwh = self.getWindowSize()
if DEBUG_WM:
print "wwh 3", wwh
self.win.set_position((x, y), update=True)
if DEBUG_WM:
print "* self.win.get_position()", self.win.get_position()
try:
iconpath = os.path.join(directories.getDataDir(), 'favicon.png')
iconfile = file(iconpath, 'rb')
icon = pygame.image.load(iconfile, 'favicon.png')
display.set_icon(icon)
except Exception as e:
logging.warning('Unable to set icon: {0!r}'.format(e))
# Let initialize OpenGL stuff after the splash.
# GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
# GL.glAlphaFunc(GL.GL_NOTEQUAL, 0)
# GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
# textures are 256x256, so with this we can specify pixel coordinates
GL.glMatrixMode(GL.GL_TEXTURE)
GL.glScale(1 / 256., 1 / 256., 1 / 256.)
self.display = d
self.loadTextures()
