deplate 0.7.3 → 0.8

data/lib/deplate/counters.rb

@@ -0,0 +1,254 @@
+# counters.rb
+# @Author:      Thomas Link (samul AT web de)
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     31-Dez-2005.
+# @Last Change: 04-Jan-2006.
+# @Revision:    0.8
+
+class Deplate::Counters
+    def initialize(deplate)
+        @deplate  = deplate
+        @counters = {}
+    end
+    
+    def def_counter(name, args={})
+        parent_counter = args[:parent]
+        if parent_counter
+            parent, parent_level = parent_counter.split(/[.,:;@-_<> ]+/)
+            parent_level = parent_level.to_i
+            if parent_level > 0
+                parent_level -= 1
+            end
+            pc = @counters[parent]
+            if pc
+                pc[:children] << {:name => name, :level => parent_level}
+            else
+                Deplate::Core.log(['Unknown counter', pc], :error)
+            end
+        else
+            parent = nil
+            parent_level = nil
+        end
+        init = args[:init] || [0]
+        @counters[name] = {
+            :value        => init.dup,
+            :init         => init.dup,
+            :children     => [],
+            :parent       => parent,
+            :parent_level => parent_level,
+        }
+    end
+
+    def is_defined?(name)
+        @counters.keys.include?(name)
+    end
+    
+    def get(name, compound=false)
+        c = @counters[name]
+        if c
+            if compound
+                c
+            else
+                [get_parent(name), c[:value]].compact.flatten
+            end
+        else
+            Deplate::Core.log(['Unknown counter', name], :error)
+            nil
+        end
+    end
+    
+    def get_parent(name, compound=false)
+        c = get(name, true)
+        p = c[:parent]
+        if p
+            pl = c[:parent_level]
+            v  = get(p, compound)
+            if compound or !pl
+                v
+            else
+                v[0..pl]
+            end
+        else
+            nil
+        end
+    end
+    
+    def set(name, value)
+        c = get(name, true)
+        if c
+            c[:value] = value
+        end
+        self
+    end
+
+    def reset(name=nil, args={})
+        if name
+            c = get(name, true)
+            if c
+                c[:value] = c[:init].dup
+                # i = c[:init].dup
+                # l = args[:level]
+                # if l
+                #     v = c[:value]
+                #     v = v[0..(l - 1)]
+                # else
+                #     v = i
+                # end
+                # set(name, v)
+                c[:children].each do |cn, cl|
+                    reset(cn, :level => l)
+                end
+            end
+        else
+            for name in @counters.keys
+                reset(name)
+            end
+        end
+    end
+ 
+    # Increase a counter. Optional arguments:
+    #     +:by+:: The value to add
+    #     +:level+:: If the counter is hierarchical (an array), increase 
+    #                    this level & reset all sublevels
+    #     +:to_s+:: Return the counter as string
+    def increase(name, args={})
+        by = args[:by] || 1
+        cc = get(name, true)
+        if cc
+            c = cc[:value]
+            mx = c.size - 1
+            lv = args[:level]
+            lv = lv ? (lv.to_i - 1) : mx
+            if lv < 0
+                lv = 0
+            end
+            if lv < mx
+                c = c[0..lv]
+            end
+            if lv > mx
+                for i in (mx+1)..(lv-1)
+                    c[i] = 0
+                end
+                c[lv] = by
+            else
+                c[lv] += by
+            end
+            set(name, c)
+            cc[:children].each do |child|
+                cn = child[:name]
+                cl = child[:level]
+                if cl >= lv
+                    reset(cn)
+                end
+            end
+            if args[:to_s]
+                return value_to_string(get(name))
+            else
+                return self
+            end
+        else
+            Deplate::Core.log(['Unknown counter', name], :error)
+            return nil
+        end
+    end
+
+    def get_s(name, args={})
+        c = get(name)
+        value_to_string(c, args)
+    end
+
+    def is_hierarchical?(name)
+        c = get(name)
+        c.kind_of?(Array)
+    end
+    
+    def value_to_string(value, args={})
+        delta = (args['delta'] || '').split(/[ .,;]/)
+        if value.empty?
+            delta.join('.')
+        else
+            value = value.dup
+            depth = args['depth'].to_i - 1
+            if depth >= 0
+                value = value[0..depth]
+            end
+            delta.each_with_index do |d,i|
+                value[i] = (value[i] || 0) + d.to_i
+            end
+            value.join('.')
+        end
+    end
+end
+
+
+class Deplate::Listings
+    def initialize(deplate)
+        @deplate  = deplate
+        @listings = {}
+    end
+    
+    def def_listing(name, init=nil, props=nil)
+        init  ||= []
+        props ||= {}
+        @listings[name] = {
+            :value => init, 
+            :init  => init,
+            :props => props,
+        }
+    end
+
+    def is_defined?(name)
+        @listings.keys.include?(name)
+    end
+ 
+    def each
+        @listings.each do |key, val|
+            yield(key, val)
+        end
+    end
+    
+    def get(name, compound=false)
+        c = @listings[name]
+        if c
+            if compound
+                c
+            else
+                c[:value]
+            end
+        else
+            Deplate::Core.log(['Unknown list', name], :error)
+            nil
+        end
+    end
+    
+    def get_prop(name, prop)
+        c = @listings[name]
+        if c
+            c[:props][prop]
+        else
+            Deplate::Core.log(['Unknown list', name], :error)
+            nil
+        end
+    end
+    
+    def push(name, value)
+        c = get(name)
+        if c
+            c << value
+        end
+    end
+
+    def reset(name=nil)
+        if name
+            c = get(name, true)
+            if c
+                set(name, c[:init])
+            end
+        else
+            for name in @listings.keys
+                reset(name)
+            end
+        end
+    end
+end
+

data/lib/deplate/css/article.css

@@ -1,8 +1,8 @@
 /* Layout and decoration */
 /* @Author:      Thomas Link (samul AT web.de) */
 /* @Created:     13-Apr-2004. */
-/* @Last Change: 09-Aug-2005. */
-/* @Revision:    0.787 */
+/* @Last Change: 06-Apr-2006. */
+/* @Revision:    0.788 */
 
 @page { 
     size:portrait;
@@ -257,7 +257,8 @@ ul.toc, li.toc {
 ul.toc {
 }
 a.toc:after { 
-    content: leader('.') target-counter(attr(href), page);
+    /* content: leader('.') target-counter(attr(href), page); */
+    content: target-counter(attr(href), page);
 }
 li.toc {
     padding: 0;

data/lib/deplate/css/deplate.css

@@ -1,8 +1,8 @@
 /* Layout and decoration */
 /* @Author:      Thomas Link (samul AT web.de) */
 /* @Created:     13-Apr-2004. */
-/* @Last Change: 19-Okt-2005. */
-/* @Revision:    0.1119 */
+/* @Last Change: 30-Apr-2006. */
+/* @Revision:    0.1197 */
 
 body {
     padding: 1px;
@@ -45,6 +45,7 @@ hr.pagebreak {
 }
 
 img {
+    border: 0;
 }
 img.latex {
     vertical-align: middle;
@@ -122,6 +123,51 @@ li {
     padding: 2px;
     margin-right: 20px;
 }
+ul.Task {
+    list-style-type: none;
+}
+li[class|=Task] {
+}
+li.Task-A {
+}
+li.Task-B {
+}
+li.Task-C {
+}
+li.Task-D {
+}
+li.Task-E {
+}
+li.Task-F {
+}
+li.done[class^=Task] {
+    color: #606060;
+    text-decoration: line-through;
+}
+span[class|=Task] {
+    font-weight: bold;
+    padding: 0 5px 0 5px;
+    position: relative;
+    right: 10px;
+}
+span.Task-A {
+    background-color: #ff7f7f;
+}
+span.Task-B {
+    background-color: #7fff7f;
+}
+span.Task-C {
+    background-color: #7f7fff;
+}
+span.Task-D {
+    background-color: #7fffff;
+}
+span.Task-E {
+    background-color: #ff7fff;
+}
+span.Task-F {
+    background-color: #ffff7f;
+}
 br.itempara {
 }
 p.itempara {
@@ -457,6 +503,14 @@ hr.list {
     margin: 0 45% 0 45%;
 }
 
+div#List_of_Examples * li {
+    list-style-type : none;
+    padding: 1px;
+}
+p.example {
+    margin-top: 10px;
+    font-weight: bold;
+}
 
 /* Mini Table of Contents */
 #Contents { 
@@ -524,10 +578,16 @@ li.footnotes {
     background-color: #e4f8fc;
     vertical-align: top;
     color: #30306f;
+    margin-right: 4px;
 }
-p.sdfootnote {
-    margin-left: 5%;
-    margin-right: 5%;
+
+.sdfootnote {
+    /* margin-left: 5%; */
+    /* margin-right: 5%; */
+    padding-top: 0;
+    padding-bottom: 0;
+    margin-bottom: 2px;
+    margin-top: 2px;
 }
 
 
@@ -697,3 +757,59 @@ li.todo[class~="dash"]:before {
 iframe {
     border: 0;
 }
+
+.bold {
+    font-weight: bold;
+    font-style: normal;
+}
+
+
+div.comment {
+    margin: 40px 80px 10px 80px;
+    font-size: 80%;
+    line-height: 135%;
+}
+span.comment_author {
+    font-weight: bold;
+}
+span.comment_author:after {
+    content: ": ";
+}
+span.comment_subject {
+    font-weight: bold;
+}
+span.comment_date {
+    font-style: italic;
+    font-size: 70%;
+}
+div.comment_title {
+}
+div.comment_text {
+    margin: 0 0 0 20px;
+}
+div.comment_form {
+    margin: 40px 80px 5px 80px;
+}
+table.comment_form {
+    border: 0;
+}
+tr.comment_form {
+    border: 0;
+}
+td.comment_form {
+    border: 0;
+    vertical-align: top;
+    font-size: 80%;
+    line-height: 135%;
+}
+
+input, textarea {
+    border: 1px solid #2f2f5f;
+    font-size: 90%;
+    line-height: 135%;
+}
+button {
+    font-size: 90%;
+    line-height: 135%;
+}
+