Changeset 24450

Show
Ignore:
Timestamp:
23.08.2011 14:08:19 (8 years ago)
Author:
sjm84
Message:

Dictionary properties can now contain INTERFACE_NAME which will be replaced by the given interface name when they are evaluated

Location:
main/trunk/greenstone3
Files:
2 modified

Legend:

Unmodified
Added
Removed
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/util/XSLTUtil.java

    r24393 r24450  
    2626 
    2727import org.apache.log4j.*; 
    28 import org.w3c.dom.Node;  
     28import org.w3c.dom.Node; 
    2929 
    3030import org.apache.commons.lang3.StringUtils; 
    3131 
    32 /** a class to contain various static methods that are used by the xslt 
     32/** 
     33 * a class to contain various static methods that are used by the xslt 
    3334 * stylesheets 
    3435 */ 
    35 public class XSLTUtil { 
    36  
    37      static Logger logger = Logger.getLogger(org.greenstone.gsdl3.util.XSLTUtil.class.getName()); 
    38  
    39     /* some tests */ 
    40     public static boolean equals(String s1, String s2) { 
    41     return s1.equals(s2); 
    42     } 
    43     public static boolean notEquals(String s1, String s2) { 
    44     return !s1.equals(s2); 
    45     } 
    46     public static boolean exists(String s1, String s2) { 
    47     return !s1.equals(""); 
    48     } 
    49     public static boolean contains(String s1, String s2) { 
    50     return (s1.indexOf(s2) != -1); 
    51     } 
    52     public static boolean startsWith(String s1, String s2) { 
    53     return s1.startsWith(s2); 
    54     } 
    55     public static boolean endsWith(String s1, String s2) { 
    56     return s1.endsWith(s2); 
    57     } 
    58     public static boolean lessThan(String s1, String s2) { 
    59     return (s1.compareTo(s2) < 0); 
    60     } 
    61     public static boolean lessThanOrEquals(String s1, String s2) { 
    62     return (s1.compareTo(s2) <= 0); 
    63     } 
    64     public static boolean greaterThan(String s1, String s2) { 
    65     return (s1.compareTo(s2) > 0); 
    66     } 
    67     public static boolean greaterThanOrEquals(String s1, String s2) { 
    68     return (s1.compareTo(s2) >= 0); 
    69     } 
    70  
    71     /* some preprocessing functions */ 
    72     public static String toLower(String orig) { 
    73     return orig.toLowerCase(); 
    74     } 
    75     public static String toUpper(String orig) { 
    76     return orig.toUpperCase(); 
    77     } 
    78  
    79     public static byte[] toUTF8(String orig) { 
    80      
    81     try { 
    82         byte[] utf8 = orig.getBytes("UTF-8"); 
    83         return utf8; 
    84     } 
    85     catch (Exception e){ 
    86         logger.error("unsupported encoding"); 
    87         return orig.getBytes(); 
    88     } 
    89     } 
    90  
    91     public static String getNumberedItem(String list, int number) { 
    92     String [] items = StringUtils.split(list, ",", -1);  
    93     if (items.length > number) { 
    94         return items[number]; 
    95     } 
    96     return ""; // index out of bounds 
    97     } 
    98  
    99     /** Generates links to equivalent documents for a document with a default document icon/type.  
    100      * Links are generated from the parameters: a list of document icons which are each in turn embedded  
    101      * in the matching starting link tag in the list of docStartLinks (these starting links link to the  
    102      * equivalent documents in another format). Each link's start tag is closed with the corresponding  
    103      * closing tag in the docEndLinks list. Parameter token is the list separator. Parameter divider is  
    104      * the string that should separate each final link generated from the next. 
    105      * Returns a string that represents a sequence of links to equivalent documents, where the anchor is 
    106      * a document icon. */ 
    107     public static String getEquivDocLinks(String token, String docIconsString, String docStartLinksString,  
    108                       String docEndLinksString, String divider) 
    109     { 
    110     String [] docIcons = StringUtils.split(docIconsString, token, -1); 
    111     String [] startLinks = StringUtils.split(docStartLinksString, token, -1); 
    112     String [] endLinks = StringUtils.split(docEndLinksString, token, -1); 
    113  
    114     StringBuffer buffer = new StringBuffer(); 
    115     for(int i = 0; i < docIcons.length; i++) { 
    116         if(i > 0) { 
    117         buffer.append(divider); 
    118         } 
    119         buffer.append(startLinks[i]+docIcons[i]+endLinks[i]); 
    120     } 
    121      
    122     return buffer.toString(); 
    123     } 
    124  
    125      
    126     public static String tidyWhitespace(String original) { 
    127      
    128     if (original==null || original.equals("")) { 
    129         return original; 
    130     } 
    131     String new_s = original.replaceAll("\\s+", " "); 
    132     return new_s; 
    133     } 
    134  
    135  
    136     public static String getInterfaceText(String interface_name, String lang, String key) { 
    137     return getInterfaceText(interface_name, lang, key, null); 
    138     } 
    139     public static String getInterfaceText(String interface_name, String lang, String key, String args_str) { 
    140      
    141     key = key.replaceAll("__INTERFACE_NAME__", interface_name); 
    142          
    143     String [] args = null; 
    144     if (args_str!=null && !args_str.equals("")) { 
    145         args = StringUtils.split(args_str, ";"); 
    146     } 
    147     Dictionary dict = new Dictionary("interface_"+interface_name, lang); 
    148     String result = dict.get(key, args); 
    149     if (result == null) { // not found 
    150         //if not found, search a separate subdirectory named by the interface name 
    151         String sep_interface_dir = interface_name + File.separatorChar + lang + File.separatorChar + "interface";  
    152         dict = new Dictionary(sep_interface_dir, lang); 
    153         result = dict.get(key, args); 
    154         if(result != null) { 
    155             return result; 
    156         }    
    157      } 
    158  
    159     if (result == null && !interface_name.equals("default")) { // not found, try the default interface 
    160         dict = new Dictionary("interface_default", lang); 
    161         result = dict.get(key, args); 
    162     } 
    163          
    164         if (result == null) { // not found 
    165                 return "_"+key+"_"; 
    166         }  
    167         return result; 
    168     } 
    169  
    170     public static String getInterfaceTextWithDOM(String interface_name, String lang, String key, Node arg_node) { 
    171     String [] args = new String [1]; 
    172   
    173     String node_str = XMLConverter.getString(arg_node); 
    174     args[0] = node_str; 
    175     Dictionary dict = new Dictionary("interface_"+interface_name, lang); 
    176     String result = dict.get(key, args); 
    177     if (result == null) { // not found 
    178         //if not found, search a separate subdirectory named by the interface name 
    179         String sep_interface_dir = interface_name + File.separatorChar + lang + File.separatorChar + "interface";  
    180         dict = new Dictionary(sep_interface_dir, lang); 
    181         result = dict.get(key, args); 
    182         if(result != null) { 
     36public class XSLTUtil 
     37{ 
     38 
     39    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.util.XSLTUtil.class.getName()); 
     40 
     41    /* some tests */ 
     42    public static boolean equals(String s1, String s2) 
     43    { 
     44        return s1.equals(s2); 
     45    } 
     46 
     47    public static boolean notEquals(String s1, String s2) 
     48    { 
     49        return !s1.equals(s2); 
     50    } 
     51 
     52    public static boolean exists(String s1, String s2) 
     53    { 
     54        return !s1.equals(""); 
     55    } 
     56 
     57    public static boolean contains(String s1, String s2) 
     58    { 
     59        return (s1.indexOf(s2) != -1); 
     60    } 
     61 
     62    public static boolean startsWith(String s1, String s2) 
     63    { 
     64        return s1.startsWith(s2); 
     65    } 
     66 
     67    public static boolean endsWith(String s1, String s2) 
     68    { 
     69        return s1.endsWith(s2); 
     70    } 
     71 
     72    public static boolean lessThan(String s1, String s2) 
     73    { 
     74        return (s1.compareTo(s2) < 0); 
     75    } 
     76 
     77    public static boolean lessThanOrEquals(String s1, String s2) 
     78    { 
     79        return (s1.compareTo(s2) <= 0); 
     80    } 
     81 
     82    public static boolean greaterThan(String s1, String s2) 
     83    { 
     84        return (s1.compareTo(s2) > 0); 
     85    } 
     86 
     87    public static boolean greaterThanOrEquals(String s1, String s2) 
     88    { 
     89        return (s1.compareTo(s2) >= 0); 
     90    } 
     91 
     92    /* some preprocessing functions */ 
     93    public static String toLower(String orig) 
     94    { 
     95        return orig.toLowerCase(); 
     96    } 
     97 
     98    public static String toUpper(String orig) 
     99    { 
     100        return orig.toUpperCase(); 
     101    } 
     102 
     103    public static byte[] toUTF8(String orig) 
     104    { 
     105 
     106        try 
     107        { 
     108            byte[] utf8 = orig.getBytes("UTF-8"); 
     109            return utf8; 
     110        } 
     111        catch (Exception e) 
     112        { 
     113            logger.error("unsupported encoding"); 
     114            return orig.getBytes(); 
     115        } 
     116    } 
     117 
     118    public static String getNumberedItem(String list, int number) 
     119    { 
     120        String[] items = StringUtils.split(list, ",", -1); 
     121        if (items.length > number) 
     122        { 
     123            return items[number]; 
     124        } 
     125        return ""; // index out of bounds 
     126    } 
     127 
     128    /** 
     129     * Generates links to equivalent documents for a document with a default 
     130     * document icon/type. Links are generated from the parameters: a list of 
     131     * document icons which are each in turn embedded in the matching starting 
     132     * link tag in the list of docStartLinks (these starting links link to the 
     133     * equivalent documents in another format). Each link's start tag is closed 
     134     * with the corresponding closing tag in the docEndLinks list. Parameter 
     135     * token is the list separator. Parameter divider is the string that should 
     136     * separate each final link generated from the next. Returns a string that 
     137     * represents a sequence of links to equivalent documents, where the anchor 
     138     * is a document icon. 
     139     */ 
     140    public static String getEquivDocLinks(String token, String docIconsString, String docStartLinksString, String docEndLinksString, String divider) 
     141    { 
     142        String[] docIcons = StringUtils.split(docIconsString, token, -1); 
     143        String[] startLinks = StringUtils.split(docStartLinksString, token, -1); 
     144        String[] endLinks = StringUtils.split(docEndLinksString, token, -1); 
     145 
     146        StringBuffer buffer = new StringBuffer(); 
     147        for (int i = 0; i < docIcons.length; i++) 
     148        { 
     149            if (i > 0) 
     150            { 
     151                buffer.append(divider); 
     152            } 
     153            buffer.append(startLinks[i] + docIcons[i] + endLinks[i]); 
     154        } 
     155 
     156        return buffer.toString(); 
     157    } 
     158 
     159    public static String tidyWhitespace(String original) 
     160    { 
     161 
     162        if (original == null || original.equals("")) 
     163        { 
     164            return original; 
     165        } 
     166        String new_s = original.replaceAll("\\s+", " "); 
     167        return new_s; 
     168    } 
     169 
     170    public static String getInterfaceText(String interface_name, String lang, String key) 
     171    { 
     172        return getInterfaceText(interface_name, lang, key, null); 
     173    } 
     174 
     175    public static String getInterfaceText(String interface_name, String lang, String key, String args_str) 
     176    { 
     177        key = key.replaceAll("__INTERFACE_NAME__", interface_name); 
     178         
     179        String[] args = null; 
     180        if (args_str != null && !args_str.equals("")) 
     181        { 
     182            args = StringUtils.split(args_str, ";"); 
     183        } 
     184        Dictionary dict = new Dictionary("interface_" + interface_name, lang); 
     185        String result = dict.get(key, args); 
     186        if (result == null) 
     187        { // not found 
     188            //if not found, search a separate subdirectory named by the interface name 
     189            String sep_interface_dir = interface_name + File.separatorChar + lang + File.separatorChar + "interface"; 
     190            dict = new Dictionary(sep_interface_dir, lang); 
     191            result = dict.get(key, args); 
     192            if (result != null) 
     193            { 
     194                result = result.replaceAll("__INTERFACE_NAME__", interface_name); 
     195                return result; 
     196            } 
     197        } 
     198 
     199        if (result == null && !interface_name.equals("default")) 
     200        { // not found, try the default interface 
     201            dict = new Dictionary("interface_default", lang); 
     202            result = dict.get(key, args); 
     203        } 
     204 
     205        if (result == null) 
     206        { // not found 
     207            return "_" + key + "_"; 
     208        } 
     209        result = result.replaceAll("__INTERFACE_NAME__", interface_name); 
    183210        return result; 
    184         }    
    185     } 
    186  
    187     if (result == null && !interface_name.equals("default")) { // not found, try the default interface 
    188         dict = new Dictionary("interface_default", lang); 
    189         result = dict.get(key, args); 
    190     } 
    191          
    192         if (result == null) { // not found 
    193                 return "_"+key+"_"; 
    194         } 
    195  
    196         return result; 
    197     } 
    198     public static String getInterfaceTextWithDOM(String interface_name, String lang, String key, Node arg1_node, Node arg2_node) { 
    199     String [] args = new String [2]; 
    200   
    201     String node_str = XMLConverter.getString(arg1_node); 
    202     args[0] = node_str;  
    203     node_str = XMLConverter.getString(arg2_node); 
    204     args[1] = node_str; 
    205     Dictionary dict = new Dictionary("interface_"+interface_name, lang); 
    206     String result = dict.get(key, args); 
    207     if (result == null) { // not found 
    208         //if not found, search a separate subdirectory named by the interface name 
    209         String sep_interface_dir = interface_name + File.separatorChar + lang + File.separatorChar + "interface";  
    210         dict = new Dictionary(sep_interface_dir, lang); 
    211         result = dict.get(key, args); 
    212         if(result != null) { 
     211    } 
     212 
     213    public static String getInterfaceTextWithDOM(String interface_name, String lang, String key, Node arg_node) 
     214    { 
     215        String[] args = new String[1]; 
     216 
     217        String node_str = XMLConverter.getString(arg_node); 
     218        args[0] = node_str; 
     219        Dictionary dict = new Dictionary("interface_" + interface_name, lang); 
     220        String result = dict.get(key, args); 
     221        if (result == null) 
     222        { // not found 
     223            //if not found, search a separate subdirectory named by the interface name 
     224            String sep_interface_dir = interface_name + File.separatorChar + lang + File.separatorChar + "interface"; 
     225            dict = new Dictionary(sep_interface_dir, lang); 
     226            result = dict.get(key, args); 
     227            if (result != null) 
     228            { 
     229                return result; 
     230            } 
     231        } 
     232 
     233        if (result == null && !interface_name.equals("default")) 
     234        { // not found, try the default interface 
     235            dict = new Dictionary("interface_default", lang); 
     236            result = dict.get(key, args); 
     237        } 
     238 
     239        if (result == null) 
     240        { // not found 
     241            return "_" + key + "_"; 
     242        } 
     243 
    213244        return result; 
    214         }    
    215     } 
    216  
    217     if (result == null && !interface_name.equals("default")) { // not found, try the default interface 
    218         dict = new Dictionary("interface_default", lang); 
    219         result = dict.get(key, args); 
    220     } 
    221          
    222         if (result == null) { // not found 
    223                 return "_"+key+"_"; 
    224         } 
    225      
    226         return result; 
    227     } 
    228  
    229     public static boolean isImage(String mimetype) { 
    230     if (mimetype.startsWith("image/")) { 
    231         return true; 
    232     } 
    233     return false; 
    234     } 
    235  
    236     public static String formatDate(String date, String lang) { 
    237      
    238     String in_pattern = "yyyyMMdd"; 
    239     String out_pattern = "dd MMMM yyyy"; 
    240     if (date.length()==6) { 
    241         in_pattern = "yyyyMM"; 
    242     } 
    243      
    244     SimpleDateFormat formatter = new SimpleDateFormat(in_pattern, new Locale(lang)); 
    245     try { 
    246         Date d = formatter.parse(date); 
    247         formatter.applyPattern(out_pattern); 
    248         String new_date = formatter.format(d); 
    249         return new_date; 
    250     } catch (Exception e) { 
    251         return date; 
    252     } 
    253      
    254     } 
    255  
    256     public static String formatLanguage(String display_lang, String lang) { 
    257  
    258     return new Locale(display_lang).getDisplayLanguage(new Locale(lang)); 
    259     } 
    260  
    261     public static String cgiSafe(String original, String lang) { 
    262  
    263     original = original.replace('&', ' '); 
    264     original = original.replaceAll(" ", "%20"); 
    265     return original; 
    266     } 
    267  
    268     public static String formatBigNumber(String num){ 
    269  
    270     String num_str = num; 
    271     char[] num_chars = num_str.toCharArray(); 
    272     String zero_str = ""; 
    273     String formatted_str = ""; 
    274  
    275         for(int i = num_chars.length-4; i >=0; i--){ 
    276         zero_str += '0'; 
    277         } 
    278  
    279         String sig_str = ""; 
    280         for(int i = 0; i<3 && i < num_chars.length; i++){ 
    281         sig_str = sig_str + num_chars[i]; 
    282         if(i == 1 && i+1 < num_chars.length){ 
    283             sig_str = sig_str + "."; 
    284         } 
    285         } 
    286  
    287         int sig_int = Math.round(Float.parseFloat(sig_str)); 
    288         String new_sig_str = sig_int +""; 
    289         if(sig_str.length() > 2){ 
    290         new_sig_str = sig_int + "0"; 
    291         } 
    292  
    293         char[] final_chars = (new_sig_str+zero_str).toCharArray(); 
    294         int count = 1; 
    295         for(int i=final_chars.length -1 ; i>=0; i-- ){ 
    296         formatted_str = final_chars[i] + formatted_str ; 
    297         if(count == 3 && i !=0){ 
    298             formatted_str = "," +formatted_str; 
    299             count = 1; 
    300         } 
    301         else{ 
    302             count++; 
    303         } 
    304         } 
    305         return formatted_str; 
    306     } 
    307      
     245    } 
     246 
     247    public static String getInterfaceTextWithDOM(String interface_name, String lang, String key, Node arg1_node, Node arg2_node) 
     248    { 
     249        String[] args = new String[2]; 
     250 
     251        String node_str = XMLConverter.getString(arg1_node); 
     252        args[0] = node_str; 
     253        node_str = XMLConverter.getString(arg2_node); 
     254        args[1] = node_str; 
     255        Dictionary dict = new Dictionary("interface_" + interface_name, lang); 
     256        String result = dict.get(key, args); 
     257        if (result == null) 
     258        { // not found 
     259            //if not found, search a separate subdirectory named by the interface name 
     260            String sep_interface_dir = interface_name + File.separatorChar + lang + File.separatorChar + "interface"; 
     261            dict = new Dictionary(sep_interface_dir, lang); 
     262            result = dict.get(key, args); 
     263            if (result != null) 
     264            { 
     265                return result; 
     266            } 
     267        } 
     268 
     269        if (result == null && !interface_name.equals("default")) 
     270        { // not found, try the default interface 
     271            dict = new Dictionary("interface_default", lang); 
     272            result = dict.get(key, args); 
     273        } 
     274 
     275        if (result == null) 
     276        { // not found 
     277            return "_" + key + "_"; 
     278        } 
     279 
     280        return result; 
     281    } 
     282 
     283    public static boolean isImage(String mimetype) 
     284    { 
     285        if (mimetype.startsWith("image/")) 
     286        { 
     287            return true; 
     288        } 
     289        return false; 
     290    } 
     291 
     292    public static String formatDate(String date, String lang) 
     293    { 
     294 
     295        String in_pattern = "yyyyMMdd"; 
     296        String out_pattern = "dd MMMM yyyy"; 
     297        if (date.length() == 6) 
     298        { 
     299            in_pattern = "yyyyMM"; 
     300        } 
     301 
     302        SimpleDateFormat formatter = new SimpleDateFormat(in_pattern, new Locale(lang)); 
     303        try 
     304        { 
     305            Date d = formatter.parse(date); 
     306            formatter.applyPattern(out_pattern); 
     307            String new_date = formatter.format(d); 
     308            return new_date; 
     309        } 
     310        catch (Exception e) 
     311        { 
     312            return date; 
     313        } 
     314 
     315    } 
     316 
     317    public static String formatLanguage(String display_lang, String lang) 
     318    { 
     319 
     320        return new Locale(display_lang).getDisplayLanguage(new Locale(lang)); 
     321    } 
     322 
     323    public static String cgiSafe(String original, String lang) 
     324    { 
     325 
     326        original = original.replace('&', ' '); 
     327        original = original.replaceAll(" ", "%20"); 
     328        return original; 
     329    } 
     330 
     331    public static String formatBigNumber(String num) 
     332    { 
     333 
     334        String num_str = num; 
     335        char[] num_chars = num_str.toCharArray(); 
     336        String zero_str = ""; 
     337        String formatted_str = ""; 
     338 
     339        for (int i = num_chars.length - 4; i >= 0; i--) 
     340        { 
     341            zero_str += '0'; 
     342        } 
     343 
     344        String sig_str = ""; 
     345        for (int i = 0; i < 3 && i < num_chars.length; i++) 
     346        { 
     347            sig_str = sig_str + num_chars[i]; 
     348            if (i == 1 && i + 1 < num_chars.length) 
     349            { 
     350                sig_str = sig_str + "."; 
     351            } 
     352        } 
     353 
     354        int sig_int = Math.round(Float.parseFloat(sig_str)); 
     355        String new_sig_str = sig_int + ""; 
     356        if (sig_str.length() > 2) 
     357        { 
     358            new_sig_str = sig_int + "0"; 
     359        } 
     360 
     361        char[] final_chars = (new_sig_str + zero_str).toCharArray(); 
     362        int count = 1; 
     363        for (int i = final_chars.length - 1; i >= 0; i--) 
     364        { 
     365            formatted_str = final_chars[i] + formatted_str; 
     366            if (count == 3 && i != 0) 
     367            { 
     368                formatted_str = "," + formatted_str; 
     369                count = 1; 
     370            } 
     371            else 
     372            { 
     373                count++; 
     374            } 
     375        } 
     376        return formatted_str; 
     377    } 
     378 
    308379    public static String hashToSectionId(String hashString) 
    309380    { 
    310         if(hashString == null || hashString.length() == 0) {return "";} 
    311          
     381        if (hashString == null || hashString.length() == 0) 
     382        { 
     383            return ""; 
     384        } 
     385 
    312386        int firstDotIndex = hashString.indexOf("."); 
    313         if(firstDotIndex == -1) 
    314         {    
     387        if (firstDotIndex == -1) 
     388        { 
    315389            return ""; 
    316390        } 
    317          
     391 
    318392        String sectionString = hashString.substring(firstDotIndex + 1); 
    319          
     393 
    320394        return sectionString; 
    321395    } 
    322      
     396 
    323397    public static String hashToDepthClass(String hashString) 
    324398    { 
    325         if(hashString == null || hashString.length() == 0) {return "";} 
    326          
     399        if (hashString == null || hashString.length() == 0) 
     400        { 
     401            return ""; 
     402        } 
     403 
    327404        String sectionString = hashToSectionId(hashString); 
    328          
     405 
    329406        int count = sectionString.split("\\.").length; 
    330          
     407 
    331408        if (sectionString.equals("")) 
    332409        { 
    333410            return "sectionHeaderDepthTitle"; 
    334411        } 
    335         else  
     412        else 
    336413        { 
    337414            return "sectionHeaderDepth" + count; 
     
    339416    } 
    340417} 
    341  
  • main/trunk/greenstone3/web/WEB-INF/classes/interface_default.properties

    r24244 r24450  
    11#***** IMAGE URLS ***** 
    2 expand_image=interfaces/oran/images/expand.png 
    3 collapse_image=interfaces/oran/images/collapse.png 
    4 page_image=interfaces/oran/images/page.png 
    5 chapter_image=interfaces/oran/images/chapter.png 
    6 realistic_books_image=interfaces/oran/images/rbook.png 
    7 highlight_image=interfaces/oran/images/hl.png 
    8 bookshelf_image=interfaces/oran/images/bookshelf.png 
    9 book_image=interfaces/oran/images/book.png 
    10 loading_image=interfaces/oran/images/loading.gif 
     2expand_image=interfaces/__INTERFACE_NAME__/images/expand.png 
     3collapse_image=interfaces/__INTERFACE_NAME__/images/collapse.png 
     4page_image=interfaces/__INTERFACE_NAME__/images/page.png 
     5chapter_image=interfaces/__INTERFACE_NAME__/images/chapter.png 
     6realistic_books_image=interfaces/__INTERFACE_NAME__/images/rbook.png 
     7highlight_image=interfaces/__INTERFACE_NAME__/images/hl.png 
     8bookshelf_image=interfaces/__INTERFACE_NAME__/images/bookshelf.png 
     9book_image=interfaces/__INTERFACE_NAME__/images/book.png 
     10loading_image=interfaces/__INTERFACE_NAME__/images/loading.gif 
     11page_icon_image=interfaces/__INTERFACE_NAME__/images/itext.gif 
    1112 
    1213#***** TEXT FRAGMENTS *****