resedit 1.3.1

data/lib/resedit/app/mz_command.rb

@@ -0,0 +1,192 @@
+require 'resedit/app/app'
+require 'resedit/app/app_command'
+require 'resedit/mz/mz'
+require 'resedit/mz/mzenv'
+
+
+module Resedit
+
+    class MZCommand < AppCommand
+        def initialize
+            super(['mz'])
+            addParam('cmd', "mz command","")
+            addParam('p1', "mz command parameter","")
+            addParam('p2', "mz command parameter","")
+            addParam('p3', "mz command parameter","")
+            addParam('p4', "mz command parameter","")
+            addParam('p5', "mz command parameter","")
+            addOption('help', 'h', nil, 'help on mz commands')
+            @cmds = {
+                "help"=>[method(:help), "show help on mz commands", {"command" => "command to show help on"}],
+                "use"=>[method(:use), "select mz file", {"file" => "path to mz file"}],
+                "save"=>[method(:save), "save current file",{"filename" => "filename fir saving", "final"=>"don't save changes"}],
+                "close"=>[method(:close), "close file", {"file" => "path or id of file to close"}],
+                "print"=>[method(:info), "print info about mz objects", {"what" => "files/header/reloc/changes", "how" => "original/modified"}],
+                "append"=>[method(:append), "add bytes to current file", {"value" => "value", "type" => "value type", }],
+                "replace"=>[method(:replace), "replace added bytes", {"value" => "value", "type"=>"value type"}],
+                "change"=>[method(:change), "change bytes at offset", {"ofs" => "data ofset", "value" => "value", "disp" => "code/file", "type"=>"value type"}],
+                "revert"=>[method(:revert), "revert changes", {"ofs"=>"change offset/all"}],
+                "hex"=>[method(:hex), "print hex file", {"ofs" => "data offset", "size" => "data size", "how"=>"original/modified", "disp" => "code/file"}],
+                "dasm"=>[method(:dasm), "print disasm", {"ofs" => "data offset", "size" => "data size", "how"=>"original/modified"}],
+            }
+            @files = []
+            @cur = nil
+        end
+
+
+        def help(params)
+            if params['command']
+                raise "Unknown mz command: " + params['command'] if !@cmds[params['command']]
+                cmd = @cmds[params['command']]
+                puts(params['command'] + "\t-" + cmd[1])
+                if cmd[2]
+                    puts
+                    puts("params:")
+                    cmd[2].each{|k,v|
+                        puts k + "\t-" + v
+                    }
+                end
+            else
+                puts("available mz commands:")
+                @cmds.each{|k,v|
+                    puts k + "\t-" + v[1]
+                }
+            end
+            puts
+        end
+
+
+        def getfile(id)
+            return @cur if id == nil
+            i,res=MZEnv.instance.s2i_nt(id)
+            if res
+                raise "Bad file id: " + i.to_s if @files.length < i || i < 0
+                return @files[i]
+            end
+            @files.each{|mz|
+                return mz if mz.is?(id)
+            }
+            return nil
+        end
+
+
+        def info(params=nil)
+            what = params['what'] if params
+            if what == nil || what == "files"
+                if @files.length != 0
+                    curid = -1
+                    puts "Opened files:"
+                    @files.each.with_index{|mz,i|
+                        puts "#{i}:\t#{mz.path}"
+                        curid=i if mz == @cur
+                    }
+                    puts "Current file: (#{curid}) #{@cur.path}"
+                    puts
+                else
+                    puts "No files opened"
+                end
+            else
+                raise "MZ file not loaded" if !@cur
+                @cur.print(what, params['how'])
+            end
+        end
+
+
+        def use(params)
+            App::get().col.on = true
+            mz = getfile(params['file'])
+            if mz==nil
+                mz = MZ.new(params['file'])
+                @files+=[mz]
+            end
+            @cur = mz
+            info()
+        end
+
+
+        def close(params)
+            mz = getfile(params['file'])
+            raise "File not found: "+fn if nil == fl
+            @files -= [mz]
+            @cur = nil if @cur == mz
+            mz.close()
+            mz = nil
+            @cur = @files[0] if !@cur && @files.length > 0
+            App::get().col.on = false if @files.length == 0
+            info()
+        end
+
+
+        def cur()
+            raise "No MZ selected." if !@cur
+            return @cur
+        end
+
+
+        def save(params)
+            cur().save(params['filename'], params['final'])
+        end
+
+
+        def append(params)
+            cur().append(params['value'], params['type'])
+        end
+
+
+        def replace(params)
+            cur().replace(params['value'], params['type'])
+        end
+
+
+        def change(params)
+            cur().change(params['ofs'], params['value'], params['disp'], params['type'])
+        end
+
+
+        def revert(params)
+            cur().revert(params['ofs'])
+        end
+
+
+        def hex(params)
+            cur().hex(params['ofs'], params['size'], params['how'], params['disp'])
+        end
+
+
+        def dasm(params)
+            cur().dasm(params['ofs'], params['size'], params['how'])
+        end
+
+
+        def job(params)
+            cmd = params['cmd']
+            if cmd.length==0 || File.exist?(cmd)
+                App::get().setShell('mz')
+                return if cmd.length == 0
+                params['p1'] = cmd
+                cmd = "use"
+            end
+            if cmd=="valueof"
+                cur().valueof(params['p1'], params['p2'])
+                return
+            end
+            if params['help']
+                params['command'] = params['help']
+                help(params)
+                return
+            end
+            raise "Unknown command: "+cmd if !@cmds[cmd]
+            scmd = @cmds[cmd]
+            if scmd[2]
+                scmd[2].keys.each.with_index{|k,i|
+                    params[k] = params["p#{i+1}"]
+                    params[k] = nil if params[k].length == 0
+                }
+            end
+            scmd[0].call(params)
+        end
+
+
+    end
+
+end

data/lib/resedit/app/std_commands.rb

@@ -0,0 +1,69 @@
+require 'resedit/app/app_command'
+require 'resedit'
+
+module Resedit
+
+    class VersionCommand < AppCommand
+        def initialize
+            super(['version','--version'])
+        end
+        def job(params)
+            log('%s v%s %s. Resedit v%s.',App::get().name, App.get().version, App::get().copyright, Resedit::VERSION)
+        end
+    end
+
+    class ExitCommand < AppCommand
+        def initialize
+            super(['quit','q', 'exit'])
+        end
+        def job(params)
+            App::get().quit();
+        end
+    end
+
+
+    class HelpCommand < AppCommand
+        def initialize
+            super(['help','--help','-h','/?'])
+            addParam('command', 'help on specific command', '')
+        end
+        def job(params)
+            App.get().commands.each{|c|
+                puts c.names[0]
+            }
+        end
+    end
+
+
+    class ScriptCommand < AppCommand
+        def initialize
+            super(['script', '--script', '-s'])
+            addParam('file', 'script file')
+        end
+        def job(params)
+            App::get().logd("running script %s", params['file']);
+            script = []
+            text=File.open(params['file']).read
+            text.gsub!(/\r\n?/, "\n")
+            text.each_line {|line|
+                script += [App.get().parseCommand(line.chomp())]
+            }
+            script.each{|cmd|
+                cmd[0].run(cmd[1]) if cmd
+            }
+        end
+    end
+
+
+    class ShellCommand < AppCommand
+        def initialize
+            super(['shell'])
+            addParam('shell', 'script file', "")
+        end
+        def job(params)
+            App::get().setShell(params['shell'])
+        end
+    end
+
+
+end

data/lib/resedit/app/text_convert.rb

@@ -0,0 +1,60 @@
+require 'resedit/app/io_commands'
+
+module Resedit
+
+    class TextConvertCommand < ConvertCommand
+
+        def initialize(fname)
+            super('text', fname)
+            @font = nil
+            addOption('format','f',nil,'output file format')
+            addOption('encodinc','e',nil,'output file encoding')
+        end
+
+        def import(inname)
+            logd("importing text #{inname} to #{@resname}")
+            back = backup()
+            File.open(back,"rb"){|file|
+                @text = mktext(file, @params['format'], @params['encoding'])
+                @text.load(inname, linesCount())
+                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 txet #{@resname} to #{outname}")
+            File.open(@resname, "rb"){|file|
+                @text = mktext(file, @params['format'], @params['encoding'])
+                unpack(file) if @text
+            }
+            raise "Text not unpacked" if !@text
+            @text.save(outname)
+        end
+
+
+        def mktext(file, format, encoding)
+            raise "Not implemented."
+        end
+
+        def linesCount(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/convert/bitconv.rb

@@ -0,0 +1,48 @@
+module Resedit
+
+    class BitConverter
+
+        def self.bits2Bytes(bits, width)
+            i=0
+            res=[]
+            while i<bits.length
+                buf=0
+                cw=0
+                bsz=0
+                while cw<width
+                    if bsz==0
+                        buf = bits[i]
+                        i+=1
+                        bsz=8
+                    end
+                    bsz-=1
+                    cw+=1
+                    res << ((buf>>bsz) & 1)
+                end
+            end
+            return res
+        end
+
+        def self.bytes2Bits(bytes, rwidth, bwidth)
+            res=[]
+            for i in 0..(bytes.length/rwidth)-1
+                row=bytes[i*rwidth..i*rwidth+rwidth-1]
+                while row.length < bwidth*8
+                    row << 0
+                end
+                b=0
+                for j in 0..row.length-1
+                    b <<= 1
+                    b |= row[j]
+                    if (j+1)%8==0
+                        res << (b & 0xFF)
+                        b=0
+                    end
+                end
+            end
+            return res
+        end
+
+    end
+
+end

data/lib/resedit/font/font.rb

@@ -0,0 +1,82 @@
+require 'resedit/font/font_char'
+require 'resedit/image/image_factory'
+
+module Resedit
+
+    class Font
+        attr_reader :count, :width, :height
+        attr_accessor :gridColor, :charColor, :userData, :widthColor
+
+        # charWidth, charHeight, characters count
+        def initialize(width, height, count=256)
+            @width, @height, @count = width, height, count
+            @gridColor = 0xFFEEEEEE
+            @charColor = 0xFF000000
+            @bgColor = 0xFFFFFFFF
+            @widthColor = 0xFFFF0000
+            @chars = {}
+            @userData = nil
+        end
+
+        def setChar(id, data, width=nil)
+            width=@width if !width
+            @chars[id] = FontChar.new(@width, @height, id, data, width)
+        end
+
+        def getChar(id)
+            @chars[id].data if @chars[id]
+        end
+
+        def minChar
+            return @chars.keys().min
+        end
+
+        def maxChar
+            return @chars.keys().max
+        end
+
+        def charWidth(id)
+            return nil if !@chars[id]
+            return @chars[id].realWidth ? @chars[id].realWidth : @width
+        end
+
+        def save(filename)
+            rows = @count/16 + (@count%16 == 0 ? 0 : 1)
+            img = Resedit.createImage(@width*16+17 , @height*rows+rows+1, filename)
+            img.fill(@bgColor)
+            #draw grid
+            for i in 0..16
+                img.vline(i*(@width+1), gridColor)
+            end
+            for j in 0..rows
+                img.hline(j*(@height+1), gridColor)
+            end
+            #draw letters
+            @chars.each { |idx,c|
+                x = idx%16
+                y = idx/16
+                x += 1+x*@width
+                y += 1+y*@height
+                c.draw(img, @charColor, x, y, @widthColor)
+            }
+            img.save(filename)
+        end
+
+        def load(filename)
+            img = Resedit.loadImage(filename)
+            rows = @count/16 + (@count%16 == 0 ? 0 : 1)
+            raise "Wrong image size" if (img.width!=@width*16+17 || img.height!=@height*rows+rows+1)
+            for idx in 0..@count-1
+                x = idx%16
+                y = idx/16
+                x += 1+x*@width
+                y += 1+y*@height
+                c = FontChar.new(width,height,idx)
+                c.scan(img, @charColor, x, y, @widthColor)
+                @chars[c.index] = c if c.data
+            end
+        end
+
+    end
+
+end