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 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 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 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 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()
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()