resedit 1.3.1

data/lib/resedit/font/font_char.rb

@@ -0,0 +1,49 @@
+module Resedit
+
+    class FontChar
+        attr_accessor :index, :data, :realWidth
+
+        def initialize(width, height, index, data=nil, realWidth=nil)
+            @width, @height, @index = width, height, index
+            @realWidth=realWidth
+            @data=data if (data && data.length==width*height)
+        end
+
+        def hasPixel(x, y)
+            @data[y*@width+x] != 0
+        end
+
+        def draw(image, color, x, y, wColor)
+            for j in 0..@height-1
+                for i in 0..@width-1
+                    image.setPixel(x+i, y+j, color) if hasPixel(i,j)
+                end
+            end
+            if @realWidth && @realWidth<@width
+                image.setPixel(x+realWidth, y, wColor)
+            end
+        end
+
+        def scan(image, color, x, y, wColor)
+            @data=[0]*@width*@height
+            @realWidth = nil
+            _hasData = false
+            for j in 0..@height-1
+                for i in 0..@width-1
+                    col=image.getPixel(x+i, y+j)
+                    if col==color
+                        @data[j*@width+i]= 1
+                        _hasData = true
+                    end
+                    if col ==wColor
+                        @realWidth = i
+                    end
+                end
+            end
+            @data=nil if !_hasData
+            return @data!=nil
+        end
+
+    end
+
+end

data/lib/resedit/image/image.rb

@@ -0,0 +1,47 @@
+
+module Resedit
+    
+    class Image
+        # Abstract image class
+        attr_accessor :width, :height
+        TYPE_PNG = 'png'
+        TYPE_BMP = 'bmp'
+        FORMAT_INDEXED = 0
+        FORMAT_32BIT = 1
+
+
+        def fill(color)
+            for j in (0..@height-1)
+                for i in (0..@width-1)
+                    setPixel(i, j, color)
+                end
+            end
+        end
+
+
+        def hline(y, color)
+            for i in (0..@width-1)
+                setPixel(i, y, color)
+            end
+        end
+
+
+        def vline(x, color)
+            for j in (0..@height-1)
+                setPixel(x, j, color)
+            end
+        end
+
+
+        #abstract interface
+        def getPixel(x, y); end
+        def setPixel(x, y, color); end
+
+        def save(filename); end
+
+        protected
+        def create(width, height, format); end
+        def load(filename); end
+
+    end
+end

data/lib/resedit/image/image_factory.rb

@@ -0,0 +1,33 @@
+require 'resedit/image/png_image'
+require 'resedit/image/image'
+
+module Resedit
+    
+    module_function
+
+    def createImage(width, height, type=Image::TYPE_PNG, format=Image::FORMAT_INDEXED)
+        type = type[-3..-1] if type.length>3
+        case type
+        when Image::TYPE_PNG
+            img = PngImage.new()
+        else
+            raise "Unknown format #{type}"
+        end
+        img.create(width, height, format)
+        return img
+    end
+
+        
+    def loadImage(filename)
+        ext = filename[-3..-1].downcase()
+        case ext
+        when Image::TYPE_PNG
+            img=PngImage.new()
+        else
+            raise "Unknown file format #{filename}"
+        end
+        img.load(filename)
+        return img
+    end
+
+end

data/lib/resedit/image/png_image.rb

@@ -0,0 +1,38 @@
+require 'resedit/image/image'
+require 'chunky_png'
+
+module Resedit
+
+    class PngImage < Image
+
+        def initialize
+            @img = nil
+        end
+
+        def getPixel(x, y)
+            col = @img[x, y]
+            return (col<<24 & 0xFFFFFFFF) | (col>>8)
+        end
+
+        def setPixel(x, y, color)
+            @img[x, y] =  ((color<<8 & 0xFFFFFFFF) | (color>>24))
+        end
+
+        def create(width, height, format)
+            @width, @height = width, height
+            @img = ChunkyPNG::Image.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+        end
+
+        def save(filename)
+            filename+='.png' if filename[-4..-1].downcase() != '.png'
+            @img.save(filename)
+        end
+
+        def load(filename)
+            @img = ChunkyPNG::Image.from_file(filename)
+            @width = @img.width
+            @height = @img.height
+        end
+    end
+
+end

data/lib/resedit/mz/changeable.rb

@@ -0,0 +1,248 @@
+require 'resedit/app/colorizer'
+require 'resedit/mz/hexwriter'
+require 'resedit/mz/mzenv'
+
+module Resedit
+
+    class Changeable
+        HOW_CHANGED = 0
+        HOW_ORIGINAL = 1
+        COL_CHANGED = Colorizer::YELLOW
+        COL_ORIGINAL = Colorizer::PURPLE
+
+        attr_reader :mz, :bytes, :add, :changes, :realSize, :realOfs
+
+        def initialize(mz, file, size)
+            @mz = mz
+            @bytes = file.read(size)
+            @realOfs = 0
+            @realSize = @bytes.size
+            @add = nil
+            @changes = {}
+            @c2 = []
+            @col = App::get().col
+            @mode = HOW_ORIGINAL
+        end
+
+        def readMore(file, size)
+            @bytes += file.read(size)
+            @realSize = @bytes.size
+        end
+
+
+        def mode(how)
+            return if @mode == how
+            if how == HOW_CHANGED
+                @bytes += @add if @add
+            else
+                @add = @bytes[@realSize..-1] if @bytes.length > @realSize
+                @bytes = @bytes[0, @realSize]
+            end
+            @changes.each{|c,bts|
+                @changes[c] = @bytes[c, bts.length]
+                bts.each_byte{|b|
+                    @bytes[c] = b.chr
+                    c += 1
+                }
+            }
+            @mode = how
+        end
+
+        def append(bytes)
+            mode(HOW_ORIGINAL)
+            pos = @bytes.length + (@add ? @add.length : 0)
+            @add = @add ? @add + bytes : bytes
+            return pos
+        end
+
+        def removeAppend()
+            mode(HOW_ORIGINAL)
+            @add = nil
+            @bytes = @bytes[0,@realSize]
+            return true
+        end
+
+
+        def changed?(ofs, size=2)
+            return true if ofs+size > @realSize
+            lower = @c2.find { |e| e < (ofs + size) }
+            return false if !lower
+            return lower + @changes[lower].length > ofs
+        end
+
+        def nextChange(ofs)
+            return ofs if changed?(ofs,1)
+            return @c2.reverse.find { |e| e > ofs }
+        end
+
+        def checkRange(ofs, size)
+            raise "Wrong offset: "+ofs.to_s if ofs < 0 || ofs >= @bytes.length
+            raise "Byte range overflow: " + ((ofs + size)-@bytes.length).to_s if ofs + size > @bytes.length
+        end
+
+        def bufWrite(buf, str, index)
+            return buf[0, index] + str + buf[index+str.length .. -1]
+        end
+
+        def change(ofs, bytes)
+            if ofs > @realSize
+                mode(HOW_CHANGED)
+                checkRange(ofs, bytes.length)
+                bytes.each_byte{|b|
+                    @bytes[ofs] = b.chr
+                    ofs += 1
+                }
+                return ofs
+            end
+            mode(HOW_ORIGINAL)
+            checkRange(ofs, bytes.length)
+            if changed?(ofs,bytes.length)
+                lower = @c2.find { |e| e < ofs + bytes.length }
+                strt = [lower, ofs].min()
+                en = [lower+@changes[lower].length, ofs+bytes.length].max()
+                buf = ("\0" * (en-strt)).force_encoding(Encoding::ASCII_8BIT)
+                buf = bufWrite(buf, @changes[lower], lower - strt)
+                buf = bufWrite(buf, bytes, ofs - strt)
+                @changes.delete(lower)
+                @c2.delete(lower)
+                change(strt, buf)
+            else
+                @changes[ofs] = bytes
+                @c2 = @changes.keys.reverse
+            end
+            return ofs
+        end
+
+        def revertChange(ofs)
+            raise sprintf("Change not found at: ") if !@changes[ofs]
+            mode(HOW_ORIGINAL)
+            @changes.delete(ofs)
+            @c2 = @changes.keys.reverse
+            return ofs
+        end
+
+        def revert(what)
+            mode(HOW_ORIGINAL)
+            if what=='all'
+                removeAppend()
+                @changes = {}
+                @c2=[]
+                return true
+            end
+            if what == 'append' || what==@realSize+@realOfs
+                removeAppend()
+                return true
+            end
+            return false if !@changes[what-@realOfs]
+            revertChange(what-@realOfs)
+            return true
+        end
+
+
+        def curcol() return @mode == HOW_ORIGINAL ? COL_ORIGINAL : COL_CHANGED end
+
+        def colVal(ofs, size)
+            fmt = "%#{size*2}.#{size*2}X"
+            u = size == 2 ? "v" : V
+            return colStr( sprintf(fmt, getData(ofs, size).unpack(u)[0]) , changed?(ofs,size))
+        end
+
+        def colStr(str, cond=true)
+            str = sprintf("%04X", str) if !str.is_a?(String)
+            return str if !cond
+            return @col.color(curcol(), str)
+        end
+
+        def getData(ofs, size)
+            checkRange(ofs, size)
+            return @bytes[ofs,size]
+        end
+
+
+        def parseHow(how)
+            return HOW_CHANGED if !how || how == HOW_CHANGED
+            return HOW_ORIGINAL if how == HOW_ORIGINAL
+            return HOW_ORIGINAL if how[0] == 'o' || how[0] == 'O'
+            return HOW_CHANGED
+        end
+
+        def print(what, how)
+            mode(parseHow(how))
+            if what=="changes"
+                @changes.each{|ofs,bts|
+                    bts = getData(ofs, bts.length)
+                    printf("%08X: %s\n", ofs+@realOfs, colStr(bts.bytes.map { |b| sprintf("%02X",b) }.join))
+                }
+                if @add
+                    printf("%08X: %s\n", @realSize+@realOfs, colStr(@add.bytes.map { |b| sprintf("%02X",b) }.join))
+                end
+                puts
+                return true
+            end
+            return false
+        end
+
+
+        def hex(writer, ofs, size, how)
+            mode(parseHow(how))
+            col = curcol()
+            return size if ofs > @bytes.length
+            while size > 0
+                if ofs>=@realSize
+                    sz = [size, @bytes.length - ofs].min
+                    if sz
+                        writer.addBytes(@bytes[ofs, sz], col)
+                        size -= sz
+                    end
+                    return size
+                end
+                x = nextChange(ofs)
+                x = @realSize if !x
+                sz = [size, x-ofs].min
+                if sz
+                    writer.addBytes(@bytes[ofs, sz], nil)
+                    size -= sz
+                    ofs += sz
+                end
+                return 0 if size == 0
+                if @changes[x]
+                    sz = [size, @changes[x].length].min
+                    if sz
+                        writer.addBytes(@bytes[ofs, sz], col)
+                        size -= sz
+                        ofs += sz
+                    end
+                end
+            end
+        end
+
+        def saveData(file)
+            mode(HOW_CHANGED)
+            file.write(@bytes)
+        end
+
+        def saveChanges(file)
+            mode(HOW_CHANGED)
+            file.write([@realSize, @changes.length].pack('VV'))
+            @changes.each{|c,bts|
+                file.write([c, bts.length].pack('VV'))
+                file.write(bts)
+            }
+        end
+
+        def loadChanges(file)
+            mode(HOW_CHANGED)
+            @realSize,clen=file.read(8).unpack('VV')
+            @add = @bytes[@realSize..-1] if @bytes.length > @realSize
+            @bytes = @bytes[0, @realSize]
+            for i in 0..clen-1
+                ofs, bts = file.read(8).unpack('VV')
+                @changes[ofs] = file.read(bts)
+            end
+            @c2 = @changes.keys.reverse
+            mode(HOW_ORIGINAL)
+        end
+
+    end
+
+end

data/lib/resedit/mz/hexwriter.rb

@@ -0,0 +1,88 @@
+require 'resedit/app/app'
+
+module Resedit
+
+    class HexWriter
+
+        attr_accessor :written
+
+        def initialize(addr)
+            @written = 0
+            @charsInLine = 0x10
+            @addr = addr
+            @col = App::get().col
+            @size = 0
+            @line = nil
+            @cline = ''
+            @chr = ''
+            @cchr = ''
+            @pcol = nil
+            @segments = nil
+        end
+
+        def setSegments(segments, sfix)
+            @segments = segments.sort.reverse
+            @sfix = sfix
+        end
+
+        def addrFormat()
+            add = ''
+            if @segments
+                seg = (@addr-@sfix) >> 4
+                min = @segments.find{|e| e <= seg}
+                min = 0 if !min
+                add = sprintf(" %04X:%04X", min, @addr - @sfix - (min << 4))
+            end
+            res = sprintf("%08X%s | ", @addr, add)
+            @addr += @charsInLine
+            return res
+        end
+
+
+        def addBytes(bytes, color=nil)
+            bytes.each_byte{|b| addChar(b, color)}
+        end
+
+        def procColored()
+            @line += @col.color(@pcol, @cline)
+            @chr += @col.color(@pcol, @cchr)
+            @cline = ''
+            @cchr = ''
+        end
+
+        def buildLine()
+            procColored() if @pcol
+            puts @line+" | "+@chr
+            @line = nil
+            @chr=''
+            @size = 0
+        end
+
+        def addChar(c, color = nil)
+            c = c.ord
+            @line = addrFormat if !@line
+            procColored if color != @pcol && @pcol
+            if !color
+                @line += sprintf("%02X ",c)
+                @chr += (c<0x20 || c>0x7E) ? '.' : c.chr
+            else
+                @cline += sprintf("%02X ",c)
+                @cchr += (c<0x20 || c>0x7E) ? '.' : c.chr
+            end
+            @pcol = color
+            @size += 1
+            @written += 1
+            if @size == @charsInLine
+                buildLine()
+            end
+        end
+
+        def finish()
+            return if @size == 0
+            procColored() if @pcol
+            @line += "   " * (@charsInLine - @size)
+            buildLine()
+        end
+    end
+
+end