wirispluginengine 3.62.0.1322

data/lib/com/wiris/util/xml/XmlWriter.rb

@@ -0,0 +1,279 @@
+module WirisPlugin
+include  Wiris
+require('com/wiris/util/xml/WXmlUtils.rb')
+  class XmlWriter
+  include Wiris
+
+  INDENT_STRING = "   "
+  ECHO_FILTER = 2
+  AUTO_IGNORING_SPACE_FILTER = 1
+  PRETTY_PRINT_FILTER = 0
+  @prettyPrint = true
+    attr_accessor :prettyPrint
+  @xmlDeclaration = false
+    attr_accessor :xmlDeclaration
+  @autoIgnoringWhitespace = true
+    attr_accessor :autoIgnoringWhitespace
+    attr_accessor :inlineElements
+    attr_accessor :filter
+    attr_accessor :tagOpen
+    attr_accessor :firstLine
+    attr_accessor :inline
+    attr_accessor :inlineMark
+    attr_accessor :depth
+    attr_accessor :cdataSection
+    attr_accessor :currentPrefixes
+    attr_accessor :hasWhiteSpace
+    attr_accessor :nameSpace
+    attr_accessor :whiteSpace
+    attr_accessor :sb
+    def initialize()
+      super()
+      @filter = PRETTY_PRINT_FILTER
+      @xmlDeclaration = false
+      @inlineElements = Array.new()
+      @firstLine = generateFirstLine("UTF-8")
+      reset()
+    end
+    def setFilter(filterType)
+      @filter = filterType
+    end
+    def getFilter()
+      return @filter
+    end
+    def setXmlDeclaration(xmlFragment)
+      @xmlDeclaration = xmlFragment
+    end
+    def isXmlDeclaration()
+      return @xmlDeclaration
+    end
+    def setInlineElements(inlineElements)
+      if inlineElements!=nil
+        @inlineElements = inlineElements
+      else 
+        @inlineElements = Array.new()
+      end
+    end
+    def getInlineElements()
+      return @inlineElements
+    end
+    def startDocument()
+      reset()
+      if @xmlDeclaration
+        write(@firstLine)
+      end
+      if !@prettyPrint
+        write("\n")
+      end
+    end
+    def endDocument()
+      closeOpenTag(false)
+    end
+    def startPrefixMapping(prefix,uri)
+      if (uri==@currentPrefixes::get(prefix))
+        return 
+      end
+      if uri::length()==0
+        return 
+      end
+      pref = prefix
+      if prefix::length()>0
+        pref = ":"+prefix
+      end
+      ns = (((" xmlns"+pref)+"=\"")+uri)+"\""
+      @nameSpace::add(ns)
+      @currentPrefixes::set(prefix,uri)
+    end
+    def endPrefixMapping(prefix)
+      @currentPrefixes::remove(prefix)
+    end
+    def startElement(uri,localName,qName,atts)
+      closeOpenTag(false)
+      processWhiteSpace(@inline||!(@autoIgnoringWhitespace||@prettyPrint))
+      if @prettyPrint&&!@inline
+        writeIndent()
+      end
+      name = qName
+      if (name==nil)||(name::length()==0)
+        name = localName
+      end
+      write("<"+name)
+      writeAttributes(atts)
+      if @nameSpace!=nil
+        write(@nameSpace::toString())
+        @nameSpace = nil
+      end
+      @tagOpen = true
+      if !@inline&&@inlineElements::contains_(name)
+        @inlineMark = @depth
+        @inline = true
+      end
+      @depth+=1
+    end
+    def endElement(uri,localName,qName)
+      name = qName
+      if (name==nil)||(name::length()==0)
+        name = localName
+      end
+      writeSpace = (@tagOpen||@inline)||!(@autoIgnoringWhitespace||@prettyPrint)
+      processWhiteSpace(writeSpace)
+      @depth-=1
+      if @tagOpen
+        closeOpenTag(true)
+      else 
+        if (!@inline&&@prettyPrint)&&!writeSpace
+          writeIndent()
+        end
+        write(("</"+name)+">")
+      end
+      if @inline&&(@inlineMark==@depth)
+        @inline = false
+        @inlineMark = -1
+      end
+    end
+    def startCDATA()
+      closeOpenTag(false)
+      write("<![CDATA[")
+      @cdataSection = true
+    end
+    def endCDATA()
+      @cdataSection = false
+      write("]]>")
+    end
+    def characters(ch,start,length)
+      if @cdataSection
+        writeChars(ch,start,length)
+      else 
+        if !@inline
+          if self.class.isWhiteSpace(ch,start,length)
+            @hasWhiteSpace = true
+              for i in start..start+length-1
+                @whiteSpace::addChar(ch[i])
+                i+=1
+              end
+            return 
+          else 
+            processWhiteSpace(true)
+            @inlineMark = @depth-1
+            @inline = true
+          end
+        end
+        closeOpenTag(false)
+        writeTextChars(ch,start,length)
+      end
+    end
+    def writeChars(ch,start,length)
+        for i in start..start+length-1
+          @sb::addChar(ch[i])
+          i+=1
+        end
+    end
+    def write(s)
+      @sb::add(s)
+    end
+    def writeText(s)
+      @sb::add(WXmlUtils::htmlEscape(s))
+    end
+    def writeTextChars(ch,start,length)
+      s = StringBuf.new()
+        for i in start..start+length-1
+          s::addChar(ch[i])
+          i+=1
+        end
+      @sb::add(WXmlUtils::htmlEscape(s::toString()))
+    end
+    def self.isWhiteSpace(chars,start,length)
+        for i in start..start+length-1
+          c = chars[i]
+          if !((((c==' ')||(c=="\n"))||(c=="\r"))||(c=="\t"))
+            return false
+          end
+          i+=1
+        end
+      return true
+    end
+    def closeOpenTag(endElement)
+      if @tagOpen
+        if endElement
+          write("/")
+        end
+        write(">")
+        @tagOpen = false
+      end
+    end
+    def writeAttributes(atts)
+      if atts==nil
+        return 
+      end
+        for i in 0..atts::getLength()-1
+          name = atts::getName(i)
+          value = atts::getValue(i)
+          if name::startsWith("xmlns")
+            prefix = nil
+            uri = value
+            if name::length()>5
+              if name::charAt(6)==':'
+                prefix = name::substring(6)
+              end
+            else 
+              prefix = ""
+            end
+            if (prefix!=nil)&&(uri==@currentPrefixes::get(prefix))
+                next
+            end
+          end
+          write(" ")
+          write(name)
+          write("=\"")
+          writeText(value)
+          write("\"")
+          i+=1
+        end
+    end
+    def processWhiteSpace(write)
+      if @hasWhiteSpace&&write
+        closeOpenTag(false)
+        writeText(@whiteSpace::toString())
+      end
+      @whiteSpace = StringBuf.new()
+      @hasWhiteSpace = false
+    end
+    def writeIndent()
+      write("\n")
+        for i in 0..@depth-1
+          write(INDENT_STRING)
+          i+=1
+        end
+    end
+    def generateFirstLine(encoding)
+      return ("<?xml version=\"1.0\" encoding=\""+encoding)+"\"?>"
+    end
+    def reset()
+      @tagOpen = false
+      @inline = false
+      @inlineMark = -1
+      @depth = 0
+      @cdataSection = false
+      @hasWhiteSpace = false
+      @currentPrefixes = Hash.new()
+      @whiteSpace = StringBuf.new()
+      @nameSpace = StringBuf.new()
+      @sb = StringBuf.new()
+      if @filter==PRETTY_PRINT_FILTER
+        @autoIgnoringWhitespace = true
+        @prettyPrint = true
+      else 
+        if @filter==AUTO_IGNORING_SPACE_FILTER
+          @autoIgnoringWhitespace = true
+          @prettyPrint = false
+        else 
+          @autoIgnoringWhitespace = false
+          @prettyPrint = false
+        end
+      end
+    end
+    def toString()
+      return sb::toString()
+    end
+  end
+end

data/lib/loader.rb

@@ -0,0 +1,12 @@
+module Wiris
+	p "Loadin WirisPlugin..."
+	if !defined?(Quizzesproxy)
+		Dir[File.dirname(__FILE__) + '/src-generic/**/*.rb'].each {|file| require file}
+		Dir[File.dirname(__FILE__) + '/src-generic/**/*/*.rb'].each {|file| require file}
+	else
+		require 'src-generic/RubyConfigurationUpdater.rb'
+	end
+
+	p "WirisPlugin loaded."
+  
+end

data/lib/src-generic/Array.rb

@@ -0,0 +1,23 @@
+module Wiris
+	class Array < Array
+		def iterator
+			return Iterator.new(self)
+		end
+
+		def get(i)
+			return self[i]
+		end
+
+		def _(i, e=nil)
+			if e.nil?
+				return get(i)
+			else
+				self[i] = e
+			end
+		end
+
+		def contains_(key)
+			return self.include? key
+		end
+	end
+end

data/lib/src-generic/ArrayInt.rb

@@ -0,0 +1,32 @@
+module Wiris
+	class ArrayInt < ::Array
+		def sort()
+			for i in 1..length()
+				j = i
+				b = get(i)
+				while ((j>0) && get(j-1) > b)
+					insert(j,get(j-1))
+					j -=1
+				end
+				insert(j, b)
+				i += 1
+			end
+		end
+
+		def splice(i, len)
+			na = slice!(i, len)
+		end
+
+		def get(i)
+				return self[i]
+		end
+
+		def _(i, e=nil)
+			if e.nil?
+				return get(i)
+			else
+				self[i] = e
+			end
+		end
+	end
+end

data/lib/src-generic/Base64.rb

@@ -0,0 +1,15 @@
+require 'base64'
+
+module Wiris
+	class Base64
+		def initialize()
+		end
+		def encodeBytes(b)
+			#Using '::' to call Base64 module out of the Wiris module scope.
+			return Bytes.ofString(::Base64::strict_encode64(b.toString()))
+		end
+
+		def decodeBytes(b)
+		end
+	end
+end

data/lib/src-generic/BaseCode.rb

@@ -0,0 +1,94 @@
+module Wiris
+    class BaseCode
+    	@bytes
+    	@nbits
+        @tbl = nil
+        @charSet
+        @base
+
+    	def initialize(base)
+    		@base = base
+            @charSet = base.toString()
+            n = base.length()
+            @nbits = 0
+            while(n>1)
+                @nbits+=1
+                n = n / 2
+            end
+    	end
+
+        def initTable()
+            @tbl = []
+
+
+            for i in 0..255
+                @tbl[i] = -1
+                i+=1
+            end
+
+            i = 0
+            for i in 0..@base.length()
+                if !@base.get(i).nil?
+                    @tbl[@base.get(i)] = i
+                end
+                i+=1
+            end
+
+        end
+
+        def decodeBytes(b)
+            if @tbl.nil?
+                initTable()
+            end
+
+            bitsize = b.length() * @nbits
+            size = bitsize/8
+            o = []
+            buf = 0
+            curbits = 0
+            pin = 0
+            pout = 0
+             while (pout < size)
+                while (curbits < 8)
+                    curbits += @nbits
+                    buf <<=  @nbits
+                    i = @tbl[b.get(pin)]
+                    pin+=1
+                    buf |= i
+                end
+                curbits -= 8
+                o[pout] = ((buf >> curbits) & 0xFF)
+                pout += 1;
+            end
+
+            return Bytes.ofData(o)
+        end
+
+        def encodeBytes(b)
+            bas = @base
+            size = (b.length()*8)/@nbits
+            o = []
+            buf = 0
+            curbits = 0
+            mask = (1 << @nbits) -1
+            pin = 0
+            pout = 0
+            while (pout < size)
+                while (curbits < @nbits)
+                    curbits += 8
+                    buf <<= 8
+                    buf |= b.get(pin)
+                    pin +=1
+                end
+                curbits -= @nbits
+                o[pout] = bas.get((buf >> curbits) & mask)
+                pout+=1
+            end
+            if (curbits > 0)
+                o[pout] = bas.get((buf << (@nbits - curbits)) & mask)
+                pout +=1
+            end
+            return Bytes.ofData(o)
+        end
+    end
+end