Çözüldü Localization Sistem Syserr

    def __init__(self, filename, mode = 'rb'):
        assert mode in ('r', 'rb')
        if not pack.Exist(filename):
            raise IOError, 'No file or directory'

    def BINARY_Localization_Append(self, register_callback, idx1, idx2, idx3, idx4, idx5, idx6, idx7, idx8, idx9, idx10, idx11, idx12, idx13, idx14):
        self.wndPlayerLocalization.Append([int(register_callback), int(idx1), int(idx2), int(idx3), int(idx4), int(idx5), int(idx6), int(idx7), int(idx8), int(idx9), int(idx10), int(idx11), int(idx12), int(idx13), int(idx14)])

import ui
import wndMgr
import os as _server
import player as p
import net as server
import uiCommon as message
import localeInfo as translate

Y_PASS_ELEMENTS = 65

GET_LOCALIZATION_IMG = {
    0    : "d:/ymir work/ui/public/parameter_slot_06.sub",
    1    : "d:/ymir work/ui/game/localization_btn/btn_edit_01.tga",
    2    : "d:/ymir work/ui/game/localization_btn/btn_edit_02.tga",
    3    : "d:/ymir work/ui/game/localization_btn/btn_edit_03.tga",
    4    : "d:/ymir work/ui/public/Large_Button_01.sub",
    5    : "d:/ymir work/ui/public/Large_Button_02.sub",
    6    : "d:/ymir work/ui/public/Large_Button_03.sub"
}

class Initializate(ui.ScriptWindow):
    def __init__(self):   
        ui.ScriptWindow.__init__(self)
        self.LoadWindowLocalization()

    def __del__(self):
        ui.ScriptWindow.__del__(self)

    def EditLocalizationBtn(self, parent, buttonName, tooltipText, x, y, func, UpVisual, OverVisual, DownVisual):
        btn = ui.Button()
        if parent != None:
            btn.SetParent(parent)
        btn.SetPosition(x, y)
        btn.SetUpVisual(UpVisual)
        btn.SetOverVisual(OverVisual)
        btn.SetDownVisual(DownVisual)
        btn.SetText(buttonName)
        btn.SetToolTipText(tooltipText)
        btn.Show()
        btn.SetEvent(func)
        return btn

    def LoadWindowLocalization(self):
        pyScrLoader = ui.PythonScriptLoader()
        pyScrLoader.LoadScriptFile(self, "uiscript/script_localization.py")
        getObject = self.GetChild

        self.Board = getObject("board")
        self.Board.SetSize(450, 60 + (7 * 40))
        self.Board.SetTitleName(translate.LOCALIZATION_TITLE)
        self.Board.SetCloseEvent(self.Close)

        self.btnEdit = {}
        idx = 1
        posY = 1 + Y_PASS_ELEMENTS
        while idx <= 7:
            self.btnEdit[idx] = self.EditLocalizationBtn(self.Board, "", translate.LOCALIZATION_DESC_BTN_EDIT, 233, posY-3, (lambda arg1 = "%d" % (idx-1), boolSave = "%d" % (999): self.RenameLocation(int(arg1), int(boolSave))), GET_LOCALIZATION_IMG[1], GET_LOCALIZATION_IMG[2], GET_LOCALIZATION_IMG[3])
            idx = idx + 1
            posY = posY + 40

        self.tmpBtn = []
        self.tmpFieldLocation = []
        self.tmpFieldPosition = []

        for tmp in xrange(0, 7):
            btn = ui.Button()
            btn.SetParent(self.Board)
            btn.SetPosition(10, Y_PASS_ELEMENTS + (tmp * 40))
            btn.SetUpVisual(GET_LOCALIZATION_IMG[0])
            btn.SetOverVisual(GET_LOCALIZATION_IMG[0])
            btn.SetDownVisual(GET_LOCALIZATION_IMG[0])
            btn.Show()

            textLine_Location = ui.EditLine()
            textLine_Location.SetParent(btn)
            textLine_Location.SetPosition(1, 1)
            textLine_Location.SetText("")
            textLine_Location.Disable()
            textLine_Location.Show()

            textLine_Position = ui.EditLine()
            textLine_Position.SetParent(btn)
            textLine_Position.SetPosition(166, 1)
            textLine_Position.SetText("(x, y)")
            textLine_Position.Disable()
            textLine_Position.Show()

            self.tmpBtn.append(btn)
            self.tmpFieldLocation.append(textLine_Location)
            self.tmpFieldPosition.append(textLine_Position)

            btn = ui.Button()
            btn.SetParent(self.Board)
            btn.SetPosition(263, Y_PASS_ELEMENTS + (tmp * 40))
            btn.SetUpVisual(GET_LOCALIZATION_IMG[4])
            btn.SetOverVisual(GET_LOCALIZATION_IMG[5])
            btn.SetDownVisual(GET_LOCALIZATION_IMG[6])
            btn.SetEvent(lambda ch = "/localization teleport %d" % (tmp): server.SendChatPacket(ch))
            btn.SetText(translate.LOCALIZATION_TELEPORT)
            btn.Show()

            self.tmpBtn.append(btn)

            btn = ui.Button()
            btn.SetParent(self.Board)
            btn.SetPosition(353, Y_PASS_ELEMENTS + (tmp*40))
            btn.SetUpVisual(GET_LOCALIZATION_IMG[4])
            btn.SetOverVisual(GET_LOCALIZATION_IMG[5])
            btn.SetDownVisual(GET_LOCALIZATION_IMG[6])
            btn.SetEvent(lambda arg = "%d" % (tmp), boolSave = "%d" % (tmp): self.RenameLocation(int(arg), int(boolSave)))
            btn.SetText(translate.LOCALIZATION_SAVE)
            btn.Show()

            self.tmpBtn.append(btn)

    def Close(self):
        self.Hide()
        for rmf in xrange(1, 8):
            self.btnEdit[rmf].Hide()

    def Show(self):
        wndMgr.Show(self.hWnd)
        self.Board.Show()

    def Destroy(self):
        self.Hide()
        self.tmpFieldLocation = []
        self.tmpFieldPosition = []
        self.tmpBtn = []

    def OnPressEscapeKey(self):
        self.Close()

    def Append(self, arg):
        myPathFile = "lib//localization//save_localization__%s.txt" % str(p.GetName())
        myPathCreate = "lib//localization"

        if not _server.path.exists("lib"):
            _server.mkdir("lib")

        if not _server.path.exists(myPathCreate):
            _server.mkdir(myPathCreate)

        if not _server.path.exists(myPathFile):
            tmpCreateFile = open(myPathFile, 'w')
            tmpCreateFile.write('-\n-\n-\n-\n-\n-\n-\n')
            tmpCreateFile.close()

        for idx in xrange(0, 7):
            lines = pack_open(myPathFile, "r").readlines()
            result = lines[idx]
            self.tmpFieldLocation[idx].SetText(result)   

        self.tmpFieldPosition[0].SetText("(%s, %s)" % (str(arg[1]), str(arg[2])))
        self.tmpFieldPosition[1].SetText("(%s, %s)" % (str(arg[3]), str(arg[4])))
        self.tmpFieldPosition[2].SetText("(%s, %s)" % (str(arg[5]), str(arg[6])))
        self.tmpFieldPosition[3].SetText("(%s, %s)" % (str(arg[7]), str(arg[8])))
        self.tmpFieldPosition[4].SetText("(%s, %s)" % (str(arg[9]), str(arg[10])))
        self.tmpFieldPosition[5].SetText("(%s, %s)" % (str(arg[11]), str(arg[12])))
        self.tmpFieldPosition[6].SetText("(%s, %s)" % (str(arg[13]), str(arg[14])))

        for i in xrange(1, 8):
            self.btnEdit[i].Show()

        if int(arg[0]) < 1:
            wndMgr.Show(self.hWnd)
            self.Board.Show()

    def CloseDialog(self):
        self.inputDialog.Hide()

    def RenameLocation(self, tmpIndex, boolSave):
        myPathFile = "lib//localization//save_localization__%s.txt" % str(p.GetName())

        for mex in range(tmpIndex + 1):
            lines = pack_open(myPathFile, "r").readlines()
            result = lines[mex]

        self.inputDialog = message.EditLineLocalization()
        self.inputDialog.SetMaxLength(35)

        if int(boolSave) == 999:
            self.inputDialog.SetAcceptEvent(lambda arg = "%d" % (tmpIndex), boolSave = "%d" % (tmpIndex): self.Get(int(arg), int(999)))
        else:
            self.inputDialog.SetAcceptEvent(lambda arg = "%d" % (tmpIndex), boolSave = "%d" % (tmpIndex): self.Get(int(arg), int(boolSave)))

        self.inputDialog.SetCancelEvent(ui.__mem_func__(self.CloseDialog))
        self.inputDialog.SetAcceptText(translate.LOCALIZATION_EDIT)
        self.inputDialog.SetCancelText(translate.LOCALIZATION_CANCEL)
        self.inputDialog.SetTitle(translate.LOCALIZATION_CHANGE_NAME)
        self.inputDialog.SetDescription(translate.LOCALIZATION_CURRENT_LINE + " " + str(result))
        self.inputDialog.Open()

    def Get(self, tmpIndex, boolSave):
        myPathFile = "lib//localization//save_localization__%s.txt" % str(p.GetName())

        textLine = self.inputDialog.GetText()
        saveLocationArray = []

        if _server.path.exists(myPathFile):
            tmpFile = open(myPathFile, "r")

            for mLine in tmpFile:
                saveLocationArray.append(mLine)
            tmpFile.close()

        while len(saveLocationArray) < int(tmpIndex+1):
            saveLocationArray.append("")

        saveLocationArray[int(tmpIndex + 1)-1] = str(textLine)
        tmpFile = open(myPathFile, "w")

        for mLine in saveLocationArray:
            tmpFile.write(mLine)

            if (len(mLine) > 0 and mLine[-1:] != "\n") or len(mLine) == 0:
                tmpFile.write("\n")
        tmpFile.close()

        if int(boolSave) != 999:
            server.SendChatPacket("/localization save %d" % (int(boolSave)))
            server.SendChatPacket("/localization refresh")

        self.CloseDialog()
        self.RefreshCurrentLine()

    def RefreshCurrentLine(self):
        myPathFile = "lib//localization//save_localization__%s.txt" % str(p.GetName())

        for ret in xrange(0, 7):
            lines = pack_open(myPathFile, "r").readlines()
            result = lines[ret]
            self.tmpFieldLocation[ret].SetText(result)

        for idx in xrange(0, 7):
            lines = pack_open(myPathFile, "r").readlines()
            result = lines[idx]
            self.tmpFieldLocation[idx].SetText(result)

        for idx in xrange(0, 7):
            lines = old_open(myPathFile, "r").readlines()
            result = lines[idx]
            self.tmpFieldLocation[idx].SetText(result)

import sys
import app
import dbg
import os

sys.path.append("lib")

class TraceFile:
    def write(self, msg):
        dbg.Trace(msg)

class TraceErrorFile:
    def write(self, msg):
        dbg.TraceError(msg)
        dbg.RegisterExceptionString(msg)

class LogBoxFile:
    def __init__(self):
        self.stderrSave = sys.stderr
        self.msg = ""

    def __del__(self):
        self.restore()

    def restore(self):
        sys.stderr = self.stderrSave

    def write(self, msg):
        self.msg = self.msg + msg

    def show(self):
        dbg.LogBox(self.msg,"Error")

sys.stdout = TraceFile()
sys.stderr = TraceErrorFile()

#
# pack file support (must move to system.py, systemrelease.pyc)
#

import marshal
import imp
import pack

class pack_file_iterator(object):
    def __init__(self, packfile):
        self.pack_file = packfile
      
    def next(self):
        tmp = self.pack_file.readline()
        if tmp:
            return tmp
        raise StopIteration

_chr = __builtins__.chr

class pack_file(object):

    def __init__(self, filename, mode = 'rb'):
        assert mode in ('r', 'rb')
        if not pack.Exist(filename):
            raise IOError, 'No file or directory'
        self.data = pack.Get(filename)
        if mode == 'r':
            self.data=_chr(10).join(self.data.split(_chr(13)+_chr(10)))

    def __iter__(self):
        return pack_file_iterator(self)

    def read(self, len = None):
        if not self.data:
            return ''
        if len:
            tmp = self.data[:len]
            self.data = self.data[len:]
            return tmp
        else:
            tmp = self.data
            self.data = ''
            return tmp

    def readline(self):
        return self.read(self.data.find(_chr(10))+1)

    def readlines(self):
        return [x for x in self]

__builtins__.pack_open = pack_open = pack_file

_ModuleType = type(sys)

old_import = __import__
def _process_result(code, fqname):
    # did get_code() return an actual module? (rather than a code object)
    is_module = isinstance(code, _ModuleType)

    # use the returned module, or create a new one to exec code into
    if is_module:
        module = code
    else:
        module = imp.new_module(fqname)

    # insert additional values into the module (before executing the code)
    #module.__dict__.update(values)

    # the module is almost ready... make it visible
    sys.modules[fqname] = module

    # execute the code within the module's namespace
    if not is_module:
        exec code in module.__dict__

    # fetch from sys.modules instead of returning module directly.
    # also make module's __name__ agree with fqname, in case
    # the "exec code in module.__dict__" played games on us.
    module = sys.modules[fqname]
    module.__name__ = fqname
    return module

module_do = lambda x:None

def __pack_import(name,globals=None,locals=None,fromlist=None):
    if name in sys.modules:
        return sys.modules[name]

    filename = name + '.py'

    if pack.Exist(filename):
        dbg.Trace('importing from pack %s\\n' % name)

        newmodule = _process_result(compile(pack_file(filename,'r').read(),filename,'exec'),name)      

        module_do(newmodule)
        return newmodule
        #return imp.load_module(name, pack_file(filename,'r'),filename,('.py','r',imp.PY_SOURCE))
    else:
        dbg.Trace('importing from lib %s\\n' % name)
        return old_import(name,globals,locals,fromlist)

def splitext(p):
    root, ext = '', ''
    for c in p:
        if c in ['/']:
            root, ext = root + ext + c, ''
        elif c == '.':
            if ext:
                root, ext = root + ext, c
            else:
                ext = c
        elif ext:
            ext = ext + c
        else:
            root = root + c
    return root, ext

class PythonExecutioner:

    def Run(kPESelf, sFileName, kDict):
        if kPESelf.__IsCompiledFile__(sFileName):
            kCode=kPESelf.__LoadCompiledFile__(sFileName)
        else:
            kCode=kPESelf.__LoadTextFile__(sFileName)

        exec(kCode, kDict)

    def __IsCompiledFile__(kPESelf, sFileName):

        sBase, sExt = splitext(sFileName)
        sExt=sExt.lower()

        if sExt==".pyc" or sExt==".pyo":
            return 1
        else:
            return 0

    def __LoadTextFile__(kPESelf, sFileName):
        sText=pack_open(sFileName,'r').read()
        return compile(sText, sFileName, "exec")

    def __LoadCompiledFile__(kPESelf, sFileName):
        kFile=pack_open(sFileName)

        if kFile.read(4)!=imp.get_magic():
            raise

        kFile.read(4)

        kData=kFile.read()
        return marshal.loads(kData)

def execfile(fileName, dict):
    kPE=PythonExecutioner()
    kPE.Run(fileName, dict)

def exec_add_module_do(mod):
    global execfile
    mod.__dict__['execfile'] = execfile

import __builtin__
__builtin__.__import__ = __pack_import
module_do = exec_add_module_do

"""
#
# PSYCO installation (must move to system.py, systemrelease.pyc)
#
try:
    import psyco
    #from psyco.classes import *

    def bind_me(bindable_list):
        try:
            for x in bindable_list:
                try:
                    psyco.bind(x)
                except:
                    pass
        except:
            pass      

    _prev_psyco_old_module_do = module_do
    def module_bind(module):
        _prev_psyco_old_module_do(module)
        #print 'start binding' + str(module)
        try:
            psyco.bind(module)
        except:
            pass
        for x in module.__dict__.itervalues():
            try:
                psyco.bind(x)
            except:
                pass      
        #print 'end binding'

    dbg.Trace("PSYCO installed\\n")

except Exception, msg:
    bind_me = lambda x:None
    dbg.Trace("No PSYCO support : %s\\n" % msg)
"""

def GetExceptionString(excTitle):
    (excType, excMsg, excTraceBack)=sys.exc_info()
    excText=""
    excText+=_chr(10)

    import traceback
    traceLineList=traceback.extract_tb(excTraceBack)

    for traceLine in traceLineList:
        if traceLine[3]:
            excText+="%s(line:%d) %s - %s" % (traceLine[0], traceLine[1], traceLine[2], traceLine[3])
        else:
            excText+="%s(line:%d) %s"  % (traceLine[0], traceLine[1], traceLine[2])

        excText+=_chr(10)
  
    excText+=_chr(10)
    excText+="%s - %s:%s" % (excTitle, excType, excMsg)      
    excText+=_chr(10)

    return excText

def ShowException(excTitle):
    excText=GetExceptionString(excTitle)
    dbg.TraceError(excText)
    app.Abort()

    return 0

def RunMainScript(name):
    try:      
        execfile(name, __main__.__dict__)
    except RuntimeError, msg:
        msg = str(msg)

        import locale
        if locale.error:
            msg = locale.error.get(msg, msg)

        dbg.LogBox(msg)
        app.Abort()

    except:  
        msg = GetExceptionString("Run")
        dbg.LogBox(msg)
        app.Abort()
  
import debugInfo
debugInfo.SetDebugMode(__DEBUG__)

loginMark = "-cs"

app.__COMMAND_LINE__ = __COMMAND_LINE__
RunMainScript("prototype.py")