added a test to check how exception handling works with Win32 SEH; corrected copyright

[wxWidgets.git] / wxPython / wx / tools / pywxrc.py

#----------------------------------------------------------------------
# Name:        wx.tools.pywxrc
# Purpose:     XML resource compiler
#
# Author:      Robin Dunn
#              Based on wxrc.cpp by Vaclav Slavik, Eduardo Marques
#              Ported to Python in order to not require yet another
#              binary in wxPython distributions
#
# RCS-ID:      $Id$
# Copyright:   (c) 2004 by Total Control Software, 2000 Vaclav Slavik
# Licence:     wxWindows license
#----------------------------------------------------------------------

"""
pywxrc -- XML resource compiler

Usage: wxrc [-h] [-v] [-e] [-c] [-p] [-g] [-n <str>] [-o <str>] input file(s)...
  -h, --help            show help message
  -v, --verbose         be verbose
  -e, --extra-cpp-code  output C++ header file with XRC derived classes
  -c, --cpp-code        output C++ source rather than .xrs file
  -p, --python-code     output wxPython source rather than .rsc file
  -g, --gettext         output list of translatable strings (to stdout or file if -o used)
  -n, --function str    C++/Python function name (with -c or -p) [InitXmlResource]
  -o, --output str      output file [resource.xrs/cpp/py]
"""

import sys, os, getopt, glob
import wx
import wx.xrc


#----------------------------------------------------------------------

class XRCWidgetData:
    def __init__(self, vname, vclass):
        self.name = vname
        self.klass = vclass
    def GetName(self):
        return self.name
    def GetClass(self):
        return self.klass


#----------------------------------------------------------------------

class XRCWndClassData:
    def __init__(self, className, parentClassName, node):
        self.className = className
        self.parentClassName = parentClassName
        self.BrowseXmlNode(node.GetChildren())
        self.wdata = []


    def BrowseXmlNode(self, node):
        while node:
            if node.GetName() == "object" and node.HasProp("class") and node.HasProp("name"):
                classVal = node.GetPropVal("class", "")
                nameVal  = node.GetPropVal("name", "")
                self.wdata.append(XRCWidgetData(nameVal, classVal))
            children = node.GetChildren()
            if children:
                    self.BrowseXmlNode(children)
            node = node.GetNext()

            
    def GetWidgetData(self):
        return self.wdata

    
    def IsRealClass(self, name):
        if name in ['tool', 'unknown', 'notebookpage', 'separator',
                    'sizeritem', 'wxMenuItem']:
            return False
        else:
            return True


    def GenerateHeaderCode(self, file):
        file.write("class %s : public %s {\nprotected:\n" % (self.className, self.parentClassName))

        for w in self.wdata:
            if not self.IsRealClass(w.GetClass()):
                continue
            if not w.GetName():
                continue
            file.write(" " + w.GetClass() + "* " + w.GetName() + ";\n")
        
        file.write("\nprivate:\n void InitWidgetsFromXRC(){\n",
                   + "  wxXmlResource::Get()->LoadObject(this,NULL,\""
                   +  self.className
                   +  "\",\""
                   +  self.parentClassName
                   +  "\");\n");
            
        for w in self.wdata:
            if not self.IsRealClass(w.GetClass()):
                continue
            if not w.GetName():
                continue
            file.write( "  "
                        + w.GetName()
                        + " = XRCCTRL(*this,\""
                        + w.GetName()
                        + "\","
                        + w.GetClass()
                        + ");\n")
 
        file.write(" }\n")
        file.write("public:\n"
                   + self.className
                   + "::"
                   + self.className
                   + "(){\n"
                   + "  InitWidgetsFromXRC();\n"
                   + " }\n"
                   + "};\n")
                


#----------------------------------------------------------------------


class XmlResApp:
    def __init__(self):
        self.flagVerbose = False
        self.flagCPP = False
        self.flagH = False
        self.flagPython = False
        self.flagGettext = False
        self.parOutput = ""
        self.parFuncname = "InitXmlResource"
        self.parFiles = []
        self.aXRCWndClassData = []
        

    #--------------------------------------------------
    def main(self, args):
        try:
            opts, args = getopt.getopt(args, "hvecpgn:o:",
                 "help verbose extra-cpp-code cpp-code python-code gettext function= output=".split())
        except getopt.GetoptError:
            print __doc__
            sys.exit(1)

        for opt, val in opts:
            if opt in ["-h", "--help"]:
                print __doc__
                sys.exit(1)

            if opt in ["-v", "--verbose"]:
                self.flagVerbose = True

            if opt in ["-e", "--extra-cpp-code"]:
                self.flagH = True

            if opt in ["-c", "--cpp-code"]:
                self.flagCPP = True

            if opt in ["-p", "--python-code"]:
                self.flagPython = True

            if opt in ["-g", "--gettext"]:
                self.flagGettext = True

            if opt in ["-n", "--function"]:
                self.parFuncname = val

            if opt in ["-o", "--output"]:
                self.parOutput = val

        if self.flagCPP + self.flagPython + self.flagGettext == 0:
            print __doc__
            print "\nYou must specify one of -c, -p or -g!\n"
            sys.exit(1)

        if self.flagCPP + self.flagPython + self.flagGettext > 1:
            print __doc__
            print "\n-c, -p and -g are mutually exclusive, specify only 1!\n"
            sys.exit(1)
            

        if self.parOutput:
            self.parOutput = os.path.normpath(self.parOutput)
            self.parOutputPath = os.path.split(self.parOutput)[0]
        else:
            self.parOutputPath = "."
            if self.flagCPP:
                self.parOutput = "resource.cpp"
            elif self.flagPython:
                self.parOutput = "resource.py"
            elif self.flagGettext:
                self.parOutput = ""
            else:
                self.parOutput = "resource.xrs"

        if not args:
            print __doc__
            sys.exit(1)
        for arg in args:
            self.parFiles += glob.glob(arg)

        self.retCode = 0
        if self.flagGettext:
            self.OutputGettext()
        else:
            self.CompileRes()



    #--------------------------------------------------
    def CompileRes(self):
        files = self.PrepareTempFiles()
        try:
            os.unlink(self.parOutput)
        except OSError:
            pass

        if not self.retCode:
            if self.flagCPP:
                self.MakePackageCPP(files)
                if self.flagH:
                    self.GenCPPHeader()

            elif self.flagPython:
                self.MakePackagePython(files)

            else:
                self.MakePackageZIP(files)

        self.DeleteTempFiles(files)


    #--------------------------------------------------
    def OutputGettext(self):
        pass
    

    #--------------------------------------------------
    def GetInternalFileName(self, name, flist):
        name2 = name;
        name2 = name2.replace(":", "_")
        name2 = name2.replace("/", "_")
        name2 = name2.replace("\\", "_")
        name2 = name2.replace("*", "_")
        name2 = name2.replace("?", "_")

        s = os.path.split(self.parOutput)[1] + "$" + name2

        if os.path.exists(s) and s not in flist:
            i = 0
            while True:
                s = os.path.split(self.parOutput)[1] + ("$%s%03d" % (name2, i))
                if not os.path.exists(s) or s in flist:
                    break
        return s;
   

    #--------------------------------------------------
    def PrepareTempFiles(self):
        flist = []
        for f in self.parFiles:
            if self.flagVerbose:
                print "processing %s..." % f

            doc = wx.xrc.EmptyXmlDocument()
            
            if not doc.Load(f):
                print "Error parsing file", f
                self.retCode = 1
                continue

            path, name = os.path.split(f)
            name, ext = os.path.splitext(name)

            self.FindFilesInXML(doc.GetRoot(), flist, path)
            if self.flagH:
                node = doc.GetRoot().GetChildren()
                while node:
                    if node.GetName() == "object" and node.HasProp("class") and node.HasProp("name"):
                        classVal = node.GetPropVal("class", "")
                        nameVal  = node.GetPropVal("name", "")
                        self.aXRCWndClassData.append(XRCWidgetData(nameVal, classVal))
                    node = node.GetNext()
            internalName = self.GetInternalFileName(f, flist)

            doc.Save(os.path.join(self.parOutputPath, internalName))
            flist.append(internalName)

        return flist
    
    
    #--------------------------------------------------
    # Does 'node' contain filename information at all?
    def NodeContainsFilename(self, node):
        # Any bitmaps:
        if node.GetName() == "bitmap":
            return True

        if node.GetName() == "icon":
            return True

        # URLs in wxHtmlWindow:
        if node.GetName() == "url":
            return True

        # wxBitmapButton:
        parent = node.GetParent()
        if parent != None and \
           parent.GetPropVal("class", "") == "wxBitmapButton" and \
           (node.GetName() == "focus" or node.etName() == "disabled" or
            node.GetName() == "selected"):
            return True

        # wxBitmap or wxIcon toplevel resources:
        if node.GetName() == "object":
            klass = node.GetPropVal("class", "")
            if klass == "wxBitmap" or klass == "wxIcon":
                return True

        return False

    #--------------------------------------------------
    # find all files mentioned in structure, e.g. <bitmap>filename</bitmap>
    def FindFilesInXML(self, node, flist, inputPath):
        # Is 'node' XML node element?
        if node is None: return
        if node.GetType() != wx.xrc.XML_ELEMENT_NODE: return

        containsFilename = self.NodeContainsFilename(node);

        n = node.GetChildren()
        while n:
            if (containsFilename and
                (n.GetType() == wx.xrc.XML_TEXT_NODE or
                 n.GetType() == wx.xrc.XML_CDATA_SECTION_NODE)):
                
                if os.path.isabs(n.GetContent()) or inputPath == "":
                    fullname = n.GetContent()
                else:
                    fullname = os.path.join(inputPath, n.GetContent())

                if self.flagVerbose:
                    print "adding     %s..." % fullname

                filename = self.GetInternalFileName(n.GetContent(), flist)
                n.SetContent(filename)

                if filename not in flist:
                    flist.append(filename)
                    
                inp = open(fullname)
                out = open(os.path.join(self.parOutputPath, filename), "w")
                out.write(inp.read())

            # subnodes:
            if n.GetType() == wx.xrc.XML_ELEMENT_NODE:
                self.FindFilesInXML(n, flist, inputPath);

            n = n.GetNext()
    


    #--------------------------------------------------
    def DeleteTempFiles(self, flist):
        for f in flist:
            os.unlink(os.path.join(self.parOutputPath, f))


    #--------------------------------------------------
    def MakePackageZIP(self, flist):
        files = " ".join(flist)

        if self.flagVerbose:
            print "compressing %s..." % self.parOutput

        cwd = os.getcwd()
        os.chdir(self.parOutputPath)
        cmd = "zip -9 -j "
        if not self.flagVerbose:
            cmd += "-q "
        cmd += self.parOutput + " " + files

        from distutils.spawn import spawn
        try:
            spawn(cmd.split())
            success = True
        except:
            success = False
            
        os.chdir(cwd)
    
        if not success:
            print "Unable to execute zip program. Make sure it is in the path."
            print "You can download it at http://www.cdrom.com/pub/infozip/"
            self.retCode = 1
    

    #--------------------------------------------------
    def FileToCppArray(self, filename, num):
        output = []
        buffer = open(filename, "rb").read()
        lng = len(buffer)

        output.append("static size_t xml_res_size_%d = %d;\n" % (num, lng))
        output.append("static unsigned char xml_res_file_%d[] = {\n" % num)
        # we cannot use string literals because MSVC is dumb wannabe compiler
        # with arbitrary limitation to 2048 strings :(

        linelng = 0
        for i in xrange(lng):
            tmp = "%i" % ord(buffer[i])
            if i != 0: output.append(',')
            if linelng > 70:
                linelng = 0
                output.append("\n")
        
            output.append(tmp)
            linelng += len(tmp)+1

        output.append("};\n\n")

        return "".join(output)


    
    #--------------------------------------------------
    def MakePackageCPP(self, flist):
        file = open(self.parOutput, "wt")

        if self.flagVerbose:
            print "creating C++ source file %s..." % self.parOutput

        file.write("""\
//
// This file was automatically generated by wxrc, do not edit by hand.
//

#include <wx/wxprec.h>

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include <wx/wx.h>
#endif

#include <wx/filesys.h>
#include <wx/fs_mem.h>
#include <wx/xrc/xmlres.h>
#include <wx/xrc/xh_all.h>

""")

        num = 0
        for f in flist:
            file.write(self.FileToCppArray(os.path.join(self.parOutputPath, f), num))
            num += 1
              

        file.write("void " + self.parFuncname + "()\n")
        file.write("""\
{

    // Check for memory FS. If not present, load the handler:
    {
        wxMemoryFSHandler::AddFile(wxT(\"XRC_resource/dummy_file\"), wxT(\"dummy one\"));
        wxFileSystem fsys;
        wxFSFile *f = fsys.OpenFile(wxT(\"memory:XRC_resource/dummy_file\"));
        wxMemoryFSHandler::RemoveFile(wxT(\"XRC_resource/dummy_file\"));
        if (f) delete f;
        else wxFileSystem::AddHandler(new wxMemoryFSHandler);
    }
""");

        for i in range(len(flist)):
            file.write("    wxMemoryFSHandler::AddFile(wxT(\"XRC_resource/" + flist[i])
            file.write("\"), xml_res_file_%i, xml_res_size_%i);\n" %(i, i))


        for i in range(len(self.parFiles)):
            file.write("    wxXmlResource::Get()->Load(wxT(\"memory:XRC_resource/" +
                       self.GetInternalFileName(self.parFiles[i], flist) +
                       "\"));\n")
    
        file.write("}\n")
        
    
    #--------------------------------------------------
    def GenCPPHeader(self):
        path, name = os.path.split(self.parOutput)
        name, ext = os.path.splitext(name)
        heaFileName = name+'.h'

        file = open(heaFileName, "wt")
        file.write("""\
//
// This file was automatically generated by wxrc, do not edit by hand.
//
""");
        file.write("#ifndef __"  + name + "_h__\n")
        file.write("#define __"  + name + "_h__\n")

        for data in self.aXRCWndClassData:
            data.GenerateHeaderCode(file)

        file.write("\nvoid \n" + self.parFuncname + "();\n#endif\n")
        

    #--------------------------------------------------
    def FileToPythonArray(self, filename, num):
        output = []
        buffer = open(filename, "rb").read()
        lng = len(buffer)

        output.append("    xml_res_file_%d = '''\\\n" % num)

        linelng = 0
        for i in xrange(lng):
            s = buffer[i]
            c = ord(s)
            if s == '\n':
                tmp = s
                linelng = 0
            elif c < 32 or c > 127 or s == "'":
                tmp = "\\x%02x" % c
            elif s == "\\":
                tmp = "\\\\"            
            else:
                tmp = s

            if linelng > 70:
                linelng = 0
                output.append("\\\n")

            output.append(tmp)
            linelng += len(tmp)

        output.append("'''\n\n")

        return "".join(output)

    #--------------------------------------------------
    def MakePackagePython(self, flist):
        file = open(self.parOutput, "wt")

        if self.flagVerbose:
            print "creating Python source file %s..." % self.parOutput
        
        file.write("""\
#
# This file was automatically generated by wxrc, do not edit by hand.
#

import wx
import wx.xrc

""")
        file.write("def " + self.parFuncname + "():\n")
        
        num = 0
        for f in flist:
            file.write(self.FileToPythonArray(os.path.join(self.parOutputPath, f), num))
            num += 1

        file.write("""
        
    # check if the memory filesystem handler has been loaded yet, and load it if not
    wx.MemoryFSHandler.AddFile('XRC_resource/dummy_file', 'dummy value')
    fsys = wx.FileSystem()
    f = fsys.OpenFile('memory:XRC_resource/dummy_file')
    wx.MemoryFSHandler.RemoveFile('XRC_resource/dummy_file')
    if f is not None:
        f.Destroy()
    else:
        wx.FileSystem.AddHandler(wx.MemoryFSHandler())

    # load all the strings as memory files and load into XmlRes
""")
        
        for i in range(len(flist)):
            file.write("    wx.MemoryFSHandler.AddFile('XRC_resource/" + flist[i] +
                       "', xml_res_file_%i)\n" % i)

        for pf in self.parFiles:
            file.write("    wx.xrc.XmlResource.Get().Load('memory:XRC_resource/" +
                       self.GetInternalFileName(pf, flist) + "')\n")
            
        
    #--------------------------------------------------
    def OutputGettext(self):
        strings = self.FindStrings()

        if not self.parOutput:
            out = sys.stdout
        else:
            out = open(self.parOutput, "wt")

        for st in strings:
            out.write("_(\"%s\")\n" % st)
            

        
    #--------------------------------------------------
    def FindStrings(self):
        strings = []
        for pf in self.parFiles:
            if self.flagVerbose:
                print "processing %s..." % pf

            doc = wx.xrc.EmptyXmlDocument()
            if not doc.Load(pf):
                print "Error parsing file", pf
                self.retCode = 1
                continue

            strings += self.FindStringsInNode(doc.GetRoot())

        return strings
            
   
    #--------------------------------------------------
    def ConvertText(self, st):
        st2 = ""
        dt = list(st)

        skipNext = False
        for i in range(len(dt)):
            if skipNext:
                skipNext = False
                continue
            
            if dt[i] == '_':
                if dt[i+1] == '_':
                    st2 += '_'
                    skipNext = True
                else:
                    st2 += '&'
            elif dt[i] == '\n':
                st2 += '\\n'
            elif dt[i] == '\t':
                st2 += '\\t'
            elif dt[i] == '\r':
                st2 += '\\r'
            elif dt[i] == '\\':
                if dt[i+1] not in ['n', 't', 'r']:
                    st2 += '\\\\'
                else:
                    st2 += '\\'
            elif dt[i] == '"':
                st2 += '\\"'
            else:            
                st2 += dt[i]

        return st2                
             
                
    
    #--------------------------------------------------
    def FindStringsInNode(self, parent):
        def is_number(st):
            try:
                i = int(st)
                return True
            except ValueError:
                return False
            
        strings = []
        if parent is None:
            return strings;
        child = parent.GetChildren()

        while child:
            if ((parent.GetType() == wx.xrc.XML_ELEMENT_NODE) and
                # parent is an element, i.e. has subnodes...
                (child.GetType() == wx.xrc.XML_TEXT_NODE or
                child.GetType() == wx.xrc.XML_CDATA_SECTION_NODE) and
                # ...it is textnode...
                (
                    parent.GetName() == "label" or
                    (parent.GetName() == "value" and
                                   not is_number(child.GetContent())) or
                    parent.GetName() == "help" or
                    parent.GetName() == "longhelp" or
                    parent.GetName() == "tooltip" or
                    parent.GetName() == "htmlcode" or
                    parent.GetName() == "title" or
                    parent.GetName() == "item"
                )):
                # ...and known to contain translatable string
                if (not self.flagGettext or
                    parent.GetPropVal("translate", "1") != "0"):

                    strings.append(self.ConvertText(child.GetContent()))

            # subnodes:
            if child.GetType() == wx.xrc.XML_ELEMENT_NODE:
                strings += self.FindStringsInNode(child)

            child = child.GetNext()

        return strings

#---------------------------------------------------------------------------

def main():
    XmlResApp().main(sys.argv[1:])


if __name__ == "__main__":
    main()