resedit 1.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b1b2afae945b0bfe8559010f9de3ecd21889a036
+  data.tar.gz: 9ec879c124f71706f9d5e90b988c88a1a7576457
+SHA512:
+  metadata.gz: 85ac7bb3ccf16019f0314d6ffed992c47636ebe0a20451e4988a3afde9e03d67dea91dee2c0a003e619b018189538f962e45398bf6d058efde2796abdb85f6ea
+  data.tar.gz: 9cbbafcba61f4bc3fef2787a70f9c4e971d80edf508e56b979ee13e891a54431c110d0a1d94dd6dd7e2b1dd9980547a319c643a0c1ae36417468e2bfa5be59c5

data/bin/resedit

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'resedit'
+
+class App < Resedit::App
+    def initialize()
+        super('resedit',Resedit::VERSION, nil, true, "by bjfn (c) old-games.ru, 2017")
+    end
+end
+
+App.new().run()

data/lib/resedit.rb

@@ -0,0 +1,17 @@
+
+require 'resedit/font/font'
+require 'resedit/font/font_char'
+require 'resedit/image/image_factory'
+require 'resedit/text/escaper'
+require 'resedit/text/text'
+require 'resedit/app/app'
+require 'resedit/text/huffman'
+require 'resedit/app/font_convert'
+require 'resedit/app/text_convert'
+require 'resedit/convert/bitconv'
+require 'resedit/mz/mz'
+
+
+module Resedit
+    VERSION = "1.3.1"
+end

data/lib/resedit/app/app.rb

@@ -0,0 +1,160 @@
+require 'resedit/app/std_commands'
+require 'resedit/app/mz_command'
+require 'resedit/app/colorizer'
+require 'logger'
+require 'readline'
+
+module Resedit
+
+    class App
+        HIST_FILE = "~/.resedithist"
+        attr_reader :name, :version, :commands, :logger, :copyright, :cmdInterface, :shell, :col
+
+        def self.get()
+            return @@instance
+        end
+
+        def initialize(name, version, commands, cmdInterface=true, copyright="(c) old-games.ru")
+            @@instance = self
+            @name, @version, @copyright = name, version, copyright
+            @cmdInterface = cmdInterface
+            @logger = Logger.new(STDOUT)
+            @logger.level= Logger::INFO
+            logger.formatter = proc { |severity, datetime, progname, msg|
+                msg
+            }
+            @shell = nil;
+            @commands = []
+            @commands += commands if commands
+            @commands += [HelpCommand.new(), VersionCommand.new(), ExitCommand.new(),
+                        ScriptCommand.new(), MZCommand.new(), ShellCommand.new()]
+            @cmds={}
+            @commands.each{|c|
+                c.names.each{|n|
+                    @cmds[n] = c;
+                }
+            }
+            @col = Colorizer.new(false)
+        end
+
+
+        def logd(fmt, *args)
+            @logger.debug(@col.gray(sprintf(fmt+"\n",*args)))
+        end
+        def log(fmt, *args)
+            @logger.info(sprintf(fmt+"\n",*args))
+        end
+        def loge(fmt, *args)
+            @logger.error(@col.red(sprintf(fmt+"\n",*args)))
+        end
+
+
+        def quit
+            begin
+                strt = Readline::HISTORY.length-64
+                open(File.expand_path(HIST_FILE),"w"){|f|
+                    Readline::HISTORY.each.with_index{|ln,i|
+                        f.write(ln+"\n") if i > strt
+                    }
+                }
+            rescue
+            end
+            @stop=true
+        end
+
+        def setShell(sname)
+            sname=nil if sname.length==0
+            raise "Unknown shell: "+sname if sname && !@cmds[sname]
+            @shell = sname
+        end
+
+        def parseCommand(string)
+            cmd = []
+            string.split().each {|w|
+                if w[0]=='-' && w.length()>2 && w[1]!='-'
+                    w[1..-1].each_char{|c|
+                        cmd+=["-#{c}"]
+                    }
+                else
+                    cmd+=[w]
+                end
+            }
+            logd("parsing command #{cmd.to_s}")
+            return nil if cmd.length()==0 || cmd[0][0]=='#'
+            c = @cmds[cmd[0]]
+            raise "Unknown command: #{cmd[0]}" if !c
+            res=[]
+            prms = c.parseParams(cmd[1..-1])
+            return c,prms
+        end
+
+
+        def runCommand(string)
+            if @shell
+                cmd=string.split()[0]
+                if !@cmds[cmd] || !['Resedit::ExitCommand','Resedit::ShellCommand'].include?(@cmds[cmd].class.name)
+                    string = @shell+" "+string
+                end
+            end
+            logd("running command %s", string)
+            cmd = parseCommand(string)
+            cmd[0].run(cmd[1])
+        end
+
+
+        def commandInterface()
+            @cmds['version'].run('')
+            begin
+                open(File.expand_path(HIST_FILE),"r").each_line {|ln|
+                    ln.chomp!
+                    Readline::HISTORY.push(ln) if ln.length>0
+                }
+            rescue
+            end
+            @stop=false
+            while(!@stop)
+                sh=@shell ? " "+@shell : ""
+                begin
+                    cmd = Readline.readline("#{@name}#{sh}>", true)
+                    Readline::HISTORY.pop if cmd=='' || (Readline::HISTORY.length>1 && cmd==Readline::HISTORY[-2])
+                    runCommand(cmd)
+                rescue StandardError => e
+                    puts @col.red("Error: #{e.to_s()}")
+                    puts e.backtrace if App::get().logger.level == Logger::DEBUG
+                end
+            end
+            return 0
+        end
+
+
+        def run()
+            begin
+                if ARGV.length()==0
+                    commandInterface() if @cmdInterface
+                    if !@cmdInterface
+                        puts "Command not specified. Known commands are:"
+                        runCommand('help')
+                    end
+                else
+                    if (@cmds[ARGV[0]])
+                        #check command
+                        runCommand(ARGV.join(' '))
+                        commandInterface() if @shell
+                    elsif ARGV.length()==1 && File.exists?(ARGV[0])
+                        #check script
+                        runCommand('script '+ARGV[0])
+                    else
+                        raise "unknown command #{ARGV[0]}"
+                    end
+                end
+                exit(0)
+            rescue StandardError => e
+                puts "Error: #{e.to_s()}"
+                puts e.backtrace
+                exit(1)
+            end
+        end
+
+    end
+
+end

data/lib/resedit/app/app_command.rb

@@ -0,0 +1,100 @@
+module Resedit
+
+    class AppCommand
+        attr_reader :names, :type, :params
+        def initialize(names, type=:std)
+            @names, @continue = names, type
+            @names = [@names] if not @names.kind_of?(Array)
+            @opts = {}
+            @params = []
+            @ohash = {}
+            addOption('verbose','v',false, 'verbose output')
+            addOption('unverbose',nil,false, 'unverbose output')
+            addOption('quiet','q',false, 'supress output')
+            addOption('color',nil,false, 'set colored output')
+            addOption('uncolor',nil,false, 'unset colored output')
+        end
+
+        def addParam(name, descr, default = nil, type=:std)
+            @params +=[{:name => name, :def => default, :descr => descr}]
+        end
+
+        def addOption(longname, shortname, param, descr, type = :std, setter= proc{|val, opt| val})
+            @opts[longname] = {:name => longname, :param => param, :descr => descr, :type => type, :setter => setter}
+            @ohash[shortname] = longname if shortname
+        end
+
+        def parseParams(params)
+            res = {}
+            pidx = 0
+            idx=0
+            @params.each{|p|
+                res[p[:name]] = p[:def]
+            }
+            @opts.each{|k,o|
+                res[k] = o[:param]
+            }
+            while idx<params.length
+                p = params[idx]
+                idx+=1
+                if p[0]=='-'
+                    val = true
+                    s=p.split('=')
+                    if s.length==2
+                        val=s[1]
+                        p=s[0]
+                    end
+                    if (p[1]=='-')
+                        opt = @opts[p[2..-1]]
+                    else
+                        opt = @opts[@ohash[p[1..-1]]] || @opts[p[1..-1]]
+                    end
+                    raise "Unknown option #{p}" if !opt
+                    if opt[:param]!=false and val==true
+                        raise "No option #{p} value" if idx>=params.length
+                        val = params[idx]
+                        idx+=1
+                    end
+                    proc = opt[:setter]
+                    res[opt[:name]] = proc.call(val, opt)
+                else
+                    raise "Unknown param #{p}" if !@params[pidx]
+                    if (@params[pidx][:type] == :text)
+                        p = params[idx-1..-1]
+                        idx=params.length
+                    end
+                    res[@params[pidx][:name]] = p
+                    pidx+=1
+                end
+            end
+            @params.each{|p|
+                raise "Expected parameter #{p[:name]}" if res[p[:name]]==nil
+            }
+            return res
+        end
+
+        def run(params)
+            App::get().logger.level = Logger::DEBUG if params['verbose']
+            App::get().logger.level = Logger::INFO if params['unverbose']
+            App::get().logger.level = Logger::ERROR if params['quiet']
+            App::get().col.on = true if params['color']
+            App::get().col.on = false if params['uncolor']
+            job(params)
+        end
+
+        def job(params)
+            raise "Unimplemented command #{@names[0]}"
+        end
+
+        def logd(fmt, *args)
+            App::get().logd(fmt,*args)
+        end
+        def log(fmt, *args)
+            App::get().log(fmt,*args)
+        end
+        def loge(fmt, *args)
+            App::get().loge(fmt,*args)
+        end
+    end
+
+end

data/lib/resedit/app/colorizer.rb

@@ -0,0 +1,34 @@
+module Resedit
+
+    class Colorizer
+        GRAY = 90
+        RED = 91
+        GREEN = 92
+        YELLOW = 93
+        BLUE = 94
+        PURPLE = 95
+        CYAN = 96
+        WHITE = 97
+
+        attr_accessor :on
+
+        def initialize(on=true)
+            @on = on;
+        end
+
+        def color(col, text)
+            return text if !@on
+            return "\033[#{col}m#{text}\033[0m"
+        end
+
+        def gray(text) color(GRAY, text) end
+        def red(text) color(RED, text) end
+        def green(text) color(GREEN, text) end
+        def yellow(text) color(YELLOW, text) end
+        def blue(text) color(BLUE, text) end
+        def deep(text) color(PURPLE, text) end
+        def cyan(text) color(CYAN, text) end
+        def white(text) color(WHITE, text) end
+
+    end
+end

data/lib/resedit/app/font_convert.rb

@@ -0,0 +1,54 @@
+require 'resedit/app/io_commands'
+
+module Resedit
+
+    class FontConvertCommand < ConvertCommand
+
+        def initialize(fname)
+            super('font', fname)
+            @font = nil
+        end
+
+        def import(inname)
+            logd("importing font #{inname} to #{@resname}")
+            back = backup()
+            File.open(back,"rb"){|file|
+                @font = mkfont(file)
+                @font.load(inname+'.png')
+                StringIO.open("","w+b"){|stream|
+                    pack(file, stream)
+                    stream.seek(0)
+                    File.open(@resname,"wb"){|out|
+                        out.write(stream.read())
+                    }
+                }
+            }
+        end
+
+
+        def export(outname)
+            logd("exporting font #{@resname} to #{outname}")
+            File.open(@resname, "rb"){|file|
+                @font = mkfont(file)
+                unpack(file) if @font
+            }
+            raise "Font not unpacked" if !@font
+            @font.save(outname+'.png')
+        end
+
+
+        def mkfont(file)
+            raise "Not implemented."
+        end
+
+        def pack(file, outstream)
+            raise "Not implemented."
+        end
+
+        def unpack(file)
+            raise "Not implemented."
+        end
+
+    end
+
+end

data/lib/resedit/app/io_commands.rb

@@ -0,0 +1,74 @@
+require 'resedit/app/app_command'
+require 'fileutils'
+
+module Resedit
+
+    class ExportCommand < AppCommand
+        def initialize(name)
+            super([name])
+        end
+        def job(params)
+            raise 'Not implemented'
+        end
+    end
+
+
+    class ImportCommand < AppCommand
+        def initialize(name)
+            super([name])
+        end
+        def job(params)
+            raise 'Not implemented'
+        end
+    end
+
+
+    class ConvertCommand < AppCommand
+
+        attr_reader :fname
+
+
+        def initialize(name, fname)
+            super([name])
+            addParam('action','import/export action')
+            addParam('file','file to import/export')
+            addOption('output','o',nil,'converted file name')
+            @fname=fname
+        end
+
+
+        def getOutName()
+            return File.basename(@resname,File.extname(@resname))
+        end
+
+        def backup()
+            bname=@resname+'.bak'
+            FileUtils.cp(@resname,bname) if ! File.exist?(bname)
+            return bname
+        end
+
+        def job(params)
+            @params=params
+            @resname=params['file']
+            fname = getOutName()
+            fname = params['output'] if params['output']
+            if params['action']=='import'
+                import(fname)
+            elsif params['action']=='export'
+                export(fname)
+            else
+                raise "Unknown action #{params['action']}. import or export expected."
+            end
+
+        end
+
+        def import(infile)
+            raise 'Not implemented'
+        end
+
+        def export(outfile)
+            raise 'Not implemented'
+        end
+    end
+
+end