<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE module [
  <!ELEMENT module (dtdversion,name,version,description*,help*,about*,requires*,file+)>
  <!ELEMENT dtdversion (#PCDATA)>
  <!ELEMENT name (#PCDATA)>
  <!ELEMENT version (#PCDATA)>
  <!ELEMENT mincmsversion (#PCDATA)>
  <!ELEMENT description (#PCDATA)>
  <!ELEMENT help (#PCDATA)>
  <!ELEMENT about (#PCDATA)>
  <!ELEMENT requires (requiredname,requiredversion)>
  <!ELEMENT requiredname (#PCDATA)>
  <!ELEMENT requiredversion (#PCDATA)>
  <!ELEMENT file (filename,isdir,data)>
  <!ELEMENT filename (#PCDATA)>
  <!ELEMENT isdir (#PCDATA)>
  <!ELEMENT data (#PCDATA)>
]>
<module>
	<dtdversion>1.3</dtdversion>
	<name>Cataloger</name>
	<version>1.0.1</version>
    <mincmsversion>2.1</mincmsversion>
	<help><![CDATA[<div id="page_tabs">
  <div id="general">
    What Is It
  </div>    
  <div id="how">
    How To Use It
  </div>    
  <div id="featurelists">
    Feature Lists
  </div>    
  <div id="imagesys">
    Cataloger Image System
  </div>
  <div id="advanced">
    Customization and Advanced Topics
  </div>
  <div id="whatsnew">
    What's new
  </div>
  <div id="about">
    About
  </div>
</div>       


<div class="clearb"></div>


<div id="page_content">


  <div id="general_c">
    <h3>What Does This Do?</h3>
    <p>This module lets you create online catalogs or portfolios. Catalogs consist of <strong></strong>"Catalog Items"</strong> which could be products, works of art, or the like, and <strong>"Catalog Categories"</strong> which could be item categories or other natural divisions of the catalog.</p>
    <p>Categories may be defined hierarchically (using the standard CMS Made Simple content list). Category pages can display items in the category and/or subcategories, optionally recursing through sub-categories. This behavior can be configured on a per-category basis.</P>
    <p>There is also a <strong>"Printable Catalog"</strong>, which represents the whole collection of Catalog Items on a single page.</p>
    <p>The module has built-in support for <strong>"Content Aliases"</strong> (a module available at <a href="http://dev.cmsmadesimple.org/projects/contentaliases">the Developer Forge</a>), which allows you to place any Catalog Item into multiple Catalog Categories.</p>
    <p><div class='warning'>As of version 1.0 Cataloger only works on CMSMS 2.x.</div></p>
  </div>
  
  
  <div id="how_c">
    <h3>How Do I Use It</h3>
    <p>When you install this module, it creates three new Content Types: <strong>Catalog Item</strong>, <strong>Catalog Category</strong>, and <strong>Printable Catalog</strong>. When you're in your site administration category, you add <strong>Catalog Items</strong> and <strong>Catalog Categories</strong> just as you would any other kind of page. Select Content &gt; Pages &gt; Add Content, and then select <strong>"Catalog Item"</strong> or <strong>"Catalog Category"</strong> from the <strong>Content Type pulldown</strong>.</p>
    <h4>Catalog Items</h4>
    <p>Adding a <strong>Catalog Item</strong> is similar to adding an ordinary page to your site. The data fields for the Item are not exactly the same, however. Also note that in the "Images" tab, you can select multiple images to upload for the item. When you upload images, the system will size them appropriately for the catalog, create thumbnails for use in the Item's page, create thumbnails for any Category pages, and so on.</p>
    <p><div class='warning'>See image use below.</div></p>

    <h4>Catalog Categories</h4>
    <p>A <strong>Catalog Category</strong> is used for organizing your catalog items. It provides a page that lists Cataloger content that is contained by it. A Catalog Item is considered to be part of a Catalog Category if it is below that Category in the Site Hierarchy. Categories can similarly include other Categories.</p>
    <p>Catalog Categories have a number of settings to determine how they should display the Items and Categories they contain: if you look at the <strong>"Options"</strong> tab, you can choose how many items and/or categories to show, what order to show them in, whether to display only items or only categories or both, and how many levels of the hierarchy to display below the category page.</p>
    <br>
    <p>For example, consider the following structure:</p>
    <ol>
      <li><b>Hats</b>
        <ol>
          <li><b>Fashion</b>
             <ol>
               <li>Feathered Hat</li><li>Fedora </li><li>Baseball Hat</li>
             </ol>
           </li>
           <li><b>Work Hats</b>
              <ol>
                <li>Hard Hat</li><li>Diving Helmet</li>
              </ol>
            </li>
        </ol>
      </li>
    </ol>
    <p>In this diagram, items in bold are Catalog Categories, all other items are Catalog Items. Depending upon how you set your options, the <strong>Hats</strong> Category Page can show only entries for the <strong>Fashion</strong> and <strong>Work Hats</strong> Category Pages, or it can show entries for <strong>Fashion</strong>, <strong>Work Hats</strong>, and all the hats listed below them.</p>
    <p>You can opt to show the items in "natural" order (i.e., the order the Items show up in the CMS Content Hierarchy), or in alphabetical order.</P>
    <p>If you have large numbers of items in a Category, you can set the maximum number to be displayed in a Category Page, and the page will automatically create links to navigate through the list.</p>
    <p>Each Category page can have different settings for sort order, levels to display, and number of items. You can set the default for these values in <strong><em>Extensions &gt; Cataloger &gt; Manage Preferences</em></strong>. If, at a later date, you wish to change some setting on all of your Category pages, you can go into <strong><em>Extensions &gt; Cataloger &gt; Global Catalog Options</em></strong>, and make those changes.</p>
    <h4>Images</h4>
    <p>Cataloger allows you to select different size images for Item pages, Category pages, and the Printable Catalog. You can set these defaults in <strong><em>Extensions &gt; Cataloger &gt; Manage Preferences</em></strong>.</p>
    <p>When you upload images, the original is stored. When someone visits a page, the reduced size images are requested using a special URL, which will load the scaled image if it exists, creating it if it doesn't. This allows you to change the size of images, without having to re-upload all the images, or rescaling them all at once.</p>
    <p><div class='warning'>The image rescaling code requires that you have either ImageMagick or GD lib installed.</div></p>
    <p><div class='information'>Currently, only jpeg format images are supported.</div></p>
    <h4>Files</h4>
    <p>Cataloger allows you to associate arbitrary files with any Item page. These are uploaded via the admin, just like images.
    <p><div class='warning'>There have been rudimentary security considerations (e.g., file-extension-based restrictions), however, as with any file upload capability that puts files inside the web root, if you do not trust your uploaders, you are at some degree of risk. You have been warned.</div></p>
  </div>
  
  
  <div id="featurelists_c">
    <h3>Feature Lists</h3>
    <p>You can, as of <strong>version 0.4</strong>, have <strong>"feature lists"</strong> which are the <strong><em>n</em></strong> most-recently added catalog items, or a collection of <strong><em>k</em></strong> random items from the catalog.</p>
    <h4>"All" Feature List</h4>
    <p>To get a list of all catalog items (optionally under a specified part of your hierarchy) for processing via a template, you can use
    the <strong>"all"</strong> feature list.</p>
    <p>The syntax for an <strong>"all"</strong> list is like:</p>
    <pre><strong>&#123;Cataloger action='all' sub_template='my_sub_template'}</strong></pre>
    <p>where sub_template is the template to use to render the list.</p>
    <p>There is an optional parameter, <strong>alias='page_alias'</strong>, where page_alias indicates the top of the tree (e.g., a place in your menu
    hierarchy, typically a category page) in which to look for new items. A special value for <strong>"page_alias"</strong> is <strong>"/"</strong>, which means to start at the root.</p>
    <p>This is useful for catalog-wide operations. For example, to get a list of all categories (and do something with them),
    you could use the tag:</p> 
    <pre><strong>&#123;Cataloger action='all' sub_template='my_sub_template' alias='/' recurse='categories_all'}</strong></pre>   
    <p>Your template could then throw those categories into a pulldown menu that redirected you to that category's page, for example:</p>
    <pre>
    &lt;select name="foo" onchange="document.location=this.options[this.selectedIndex].value;">
    &lt;option value="">Select A target&lt;/option>
    &#123;foreach from=$items item=thisone}
       &lt;option value="&#123;$thisone.link}">&#123;$thisone.title}&lt;/option>
    &#123;/foreach}
    &lt;/select></pre>
    <p>If you wanted that to only show categories that were in the very top level of your hierarchy, you'd replace the <strong>recurse='categories_all'</strong> with <strong>recurse='categories_one'</strong>. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:</p>
    <pre><strong>&#123;Cataloger action='all' sub_template='my_sub_template' alias='/' recurse='items_all'}</strong></pre>
    <p>Similarly, you could have it list only categories under the current page (by omitting the <strong>"alias='/'"</strong>). The combinations are basically limitless!</p>
    <p>All supported values of recurse include:
    <ul>
      <li><strong>items_one</strong> - Catalog items, no more than one level below the current page (or alias point)</li>
      <li><strong>items_all</strong> - Catalog items, at any level below the current page (or alias point)</li>
      <li><strong>categories_one</strong> - Categories, no more than one level below the current page (or alias point)</li>
      <li><strong>categories_all</strong> - Categories, at any level below the current page (or alias point)</li>
      <li><strong>mixed_one</strong> - Catalog items and Categories, no more than one level below the current page (or alias point)</li>
      <li><strong>mixed_all</strong> - Catalog items and Categories, at any level below the current page (or alias point)</li>
    </ul>
    </p>
    <p>Items in these lists come back in hierarchy order. You can change this using the <strong>'global_sort'</strong> parameter. Your choices are:</p>
    <ul>
      <li><strong>alpha</strong> - alphabetically by title</li>
      <li><strong>date</strong> - in order of item creation date</li>
      <li><strong>mdate</strong> - in order of item modification date</li>
    </ul>
    <p>You may order these sorts using the <strong>'global_sort_dir'</strong> parameter, which will allow <strong>'asc'</strong> or <strong>'desc'</strong>.</p>
    <p>So, for a thorough example:</p>
    <pre><strong>&#123;Cataloger action='all' sub_template='my_sub_template' alias='/' recurse='categories_all' global_sort='alpha' global_sort_dir='asc'}</strong></pre> 
    <h4>Recently Added Feature List</h4>
    <p>To use a "most-recently added" list will allow you to display the most recently-added catalog items under a specified part of your hierarchy.</p>
    <p>The syntax for a "most recently added" list is like:</p>
    <pre><strong>&#123;Cataloger action='recent' sub_template='my_sub_template'}</strong></pre> 
    <p>where sub_template is the template to use to render the list. There are four optional parameters, <strong>count='3'</strong>, <strong>alias='page_alias'</strong>, <strong>global_sort='date'</strong>, <strong>global_sort_dir='desc'</strong> where <strong>count</strong> is the number of items to include, <strong>page_alias</strong> indicates the top of the tree (e.g., a place in your menu hierarchy, typically a category page) in which to look for new items. A special value for <strong>"page_alias"</strong> is <strong>"/"</strong>, which means to use <i>all</i> pages in the site. <strong>global_sort</strong> may be <strong>'date'</strong> (for item creation date) or </strong>'mdate'</strong> for modification date, and <strong>global_sort_dir</strong> may be <strong>'asc'</strong> or <strong>'desc'</strong>.</p>
    <h4>Random Items Feature List</h4>
    <p>The syntax for a "random" list is like:</p>
    <pre><strong>&#123;Cataloger action='random' sub_template='my_sub_template'}</strong></pre> 
    <p>where sub_template is the template to use to render the list. There are two optional parameters, <strong>count='3'</strong> and <strong>alias='page_alias'</strong>, where <strong>count</strong> is the number of items to include, and <strong>page_alias</strong> indicates the top of the tree (e.g., a place in your menu hierarchy, typically a category page) in which to look for new items. A special value for <strong>"page_alias"</strong> is <strong>"/"</strong>, which means to use <i>all</i> pages in the site.</p>
  </div>
  
  
  <div id="imagesys_c">
    <h3>Cataloger Image System</h3>
    <p>Cataloger has an image system that will allow you to dynamically change the image display size. If you do not like it, you can alter
    the templates and use any image system you want.</p>
    <p>When you upload an image using Cataloger, it gets put in a special set of directories to make the imaging easier. You will see more
    about this later.</p>
    <p>It works by calling a PHP program instead of directly referencing the image. The program uses the filename to see if the
    image already exists in the correct size. If so, it uses that image. Otherwise, it uses your <strong>GDLIB</strong> or <strong>ImageMagick</strong> to create the image in the correct size, and then redirects to it.</p>
    <h4>Cataloger Image Filespec Explanation</h4>
    <p>A cataloger image has a filespec like:</p>
    <pre>&lsaquo;root&rsaquo;/cataloger_image(.page_extention)?i=itemname_f_1_400_1.jpg&amp;ac=82888</pre>
    <p><div class='information'>There are differences in image handling in <strong>Cataloger</strong> since <strong>version 1.0</strong>.<br>The old spec has been removed, and is no longer used,<br> i.e.: <strong>&lsaquo;root_path&rsaquo;/modules/Cataloger/Cataloger.Image.php?i=itemname_f_1_400_1.jpg&ac=82888</strong> spec as explained and used on previous versions <strong>no longer works</strong>.<br>To be more precise, <strong>Cataloger.Image.php</strong> is no longer valid as it used an unsupported method of calling CMSMS core functions. However the filename specs still apply, such as <strong>itemname_f_1_400_1.jpg&ac=82888</strong> along with the <strong>ac</strong> parameter as explained below.</div></p>
    <p><div class='warning'><strong>Cataloger.Image.php</strong> has been replaced by a module action and <strong>Cataloger</strong> will use the new method automatically. No changes in the sub-templates should be needed unless the developer/designer has, for some reason, hard-coded part of the url on the templates instead of using the generated links.</div></p>
    <p>The interesting thing is <strong>"itemname_f_1_400_1.jpg"</strong> - the stuff before is just a call to the program, and the <strong>&amp;ac=82888</strong> is a random thing that is designed to prevent browser caching. So examining the name piece by piece (separating at the underscores), we have:</p>
    <ul>
      <li><strong>item name</strong> - this is the alias of the item/category page containing the image.</li>
      <li><strong>image type</strong> - this is a designation for image type:
        <ul>
          <li><strong>f</strong> - item full-size image</li>
          <li><strong>t</strong> - item thumbnail</li>
          <li><strong>cf</strong> - category full-sized image</li>
          <li><strong>ct</strong> - category thumbnail</li>
          <li><strong>ctf</strong> - printable catalog full-sized image</li>
        </ul>
      </li>
      <li><strong>image number</strong> - so a given item/catalog/etc can have multiple images</li>
      <li><strong>long dimension</strong> - long dimension of the image, in pixels</li>
      <li><strong>missing flag</strong> - 1 if you want to show an "image missing" image if this image doesn't exist, 0 otherwise</li>
    </ul>
    <p>
    This will take an image in <strong>root_path/uploads/images/catalog_src/itemname_src_1</strong>
    <p>As of <strong>version 1.0 Cataloger</strong> has changed the way it handles images. The <strong>Cataloger.Image.php</strong> file as been removed and all image handling is done through a module action used specifically for that purpose.  This allowed better support to pretty URLs, and file obfuscation as the action doesn't redirect to the generated image but generates a copy of the image without revealing the original image location.</p>
    <h4>Accessing your Original Image</h4>
    <p>When Cataloger uploads images, it puts them into a directory called <strong>"cataloger_src"</strong> in your <strong>uploads/images/</strong> directory. The images are named according to the alias of the page: <strong>alias_src_#.jpg</strong> where # is the image number for that page.</p>
    <p>So, to access the originally uploaded images on a Category page, you'd generate the URL manually.</p>
    <p>So on a category page, for example, instead of using <strong>{$items[numloop].image}</strong> you'd use <strong>"/uploads/images/cataloger_src/{$items[numloop].alias}_src_1.jpg"</strong>.</p>
  </div>
  
  
  <div id="advanced_c">
    <h3>Customization and Advanced Topics</h3>
    <h4>Catalog Item Attributes</h4>
    <p>The default item attributes are typical for a catalog of products or artworks, but by going into <strong><em>Extensions &gt; Cataloger &gt; Manage User-Defined Attributes</em></strong>, you can change the attributes. It's best to define the attributes before you start entering Catalog Items.</p>
    <p><div class='information'>Note that the attributes you define may need to be added to the template that you're using to display Catalog Items:  see Custom Templates below.</div></p>
    <h4>Catalog Category Attributes</h4>
    <p>Similarly, you can set attributes for Categories. As with Items, the attributes you define may need to be added to the template that you're using to display Catalog Categories.</p>
    <h4>Printable Catalog Attributes</h4>
    <p>Likewise, you can set attributes for Printable Catalogs. As with Items and Categories, the attributes you define may need to be added to the template that you're using to display your Printable Catalog.</p>
    <h4>Variable Action</h4>
    <p>You can grab variables (attributes) outside of your Cataloger templates, using the <strong>variable</strong> action parameter. The syntax looks like:</p>
    <pre><strong>&#123;Cataloger action='variable' name='itemnotes' default='no notes'}</strong></pre> 
    <p>where name is the attribute to display (using the same all lower-case, punctuation-free representation like the smarty template variables), and default is the value to use if the attribute is not defined.</p>
    <h4>Item Comparisons</h4>
    <p>As of <strong>version 0.7.7</strong>, there is a <strong>product comparison</strong> action:</p>
    <pre><strong>&#123;Cataloger action='compare' sub_template='my_sub_template' items='item1,item2,item3'}</strong></pre>
    <p>where sub_template is the template to use to render the list, and items is a comma-delimited list of item page aliases to compare. Bolder users may also choose to pass in the items to compare as request variables, thereby enabling dynamic comparisons based on user selections. Do this by setting the <strong>"items"</strong> variable on the request passed to the page containing the Cataloger tag with a compare action.</p>
    <p>The default item comparison template could use some styling, e.g.,:</p>
    <pre>
    .item_comparison th {font-weight: bold; padding: 5px; text-align:center;}
    .item_comparison td {border: 1px solid gray; padding: 3px 5px;text-align:right;}</pre>
  
    <h4>Custom Templates</h4>
    <p>If you're willing to mess around with <strong>Smarty Templates</strong>, you can change the layout of any of the pages generated by Cataloger. There are four kinds of templates: one kind for <strong>Catalog Items</strong>, one kind for <strong>Catalog Categories</strong>, and one kind for <strong>Printable Catalogs</strong>, and one kind for <strong>"Feature"</strong> lists, such as recently added items or random selections.</p>
    <p>When editing a Template, the admin screen will display a list of Smarty tags available to you for that kind of template. This
    will only happen once the module knows what kind of template you're editing, so when you first create the template, it displays all
    the Smarty tags it knows about, only some of which being applicable.</p>
    <h4>Displaying Attributes on Item Pages</h4>
    <p>Attributes are available to Smarty as top-level variables. They are stored as sanitized versions of the attribute names, which means
    it is converted to lower case and all punctuation and non-US-ASCII characters get removed. This is because Smarty is finicky, and will not handle these characters.</p>
    <p>So, for example, if you have an attribute called <strong>"Glücklichkeit"</strong>, there will be a Smarty variable <strong><br />
<font size='1'><table class='xdebug-error xe-notice' dir='ltr' border='1' cellspacing='0' cellpadding='1'>
<tr><th align='left' bgcolor='#f57900' colspan="5"><span style='background-color: #cc0000; color: #fce94f; font-size: x-large;'>( ! )</span> Notice: Undefined index: glcklichkeit in D:\wamp64\www\cmsms.2.1.5\tmp\templates_c\Cataloger^fa466162d07af544546be007fce5c5107503341a.module_file_tpl.Cataloger;help.tpl.php on line <i>237</i></th></tr>
<tr><th align='left' bgcolor='#e9b96e' colspan='5'>Call Stack</th></tr>
<tr><th align='center' bgcolor='#eeeeec'>#</th><th align='left' bgcolor='#eeeeec'>Time</th><th align='left' bgcolor='#eeeeec'>Memory</th><th align='left' bgcolor='#eeeeec'>Function</th><th align='left' bgcolor='#eeeeec'>Location</th></tr>
<tr><td bgcolor='#eeeeec' align='center'>1</td><td bgcolor='#eeeeec' align='center'>0.0077</td><td bgcolor='#eeeeec' align='right'>392256</td><td bgcolor='#eeeeec'>{main}(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\admin\moduleinterface.php' bgcolor='#eeeeec'>...\moduleinterface.php<b>:</b>0</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>2</td><td bgcolor='#eeeeec' align='center'>0.1679</td><td bgcolor='#eeeeec' align='right'>6589536</td><td bgcolor='#eeeeec'>CMSModule->DoActionBase(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\admin\moduleinterface.php' bgcolor='#eeeeec'>...\moduleinterface.php<b>:</b>76</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>3</td><td bgcolor='#eeeeec' align='center'>0.1680</td><td bgcolor='#eeeeec' align='right'>6590624</td><td bgcolor='#eeeeec'>CMSModule->DoAction(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.CMSModule.php' bgcolor='#eeeeec'>...\class.CMSModule.php<b>:</b>1477</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>4</td><td bgcolor='#eeeeec' align='center'>0.2220</td><td bgcolor='#eeeeec' align='right'>6607112</td><td bgcolor='#eeeeec'>include( <font color='#00bb00'>'D:\wamp64\www\cmsms.2.1.5\modules\JMDevTools\action.dorelease.php'</font> )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.CMSModule.php' bgcolor='#eeeeec'>...\class.CMSModule.php<b>:</b>1410</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>5</td><td bgcolor='#eeeeec' align='center'>0.2367</td><td bgcolor='#eeeeec' align='right'>6895736</td><td bgcolor='#eeeeec'>ModuleOperations->CreateXMLPackage(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\modules\JMDevTools\action.dorelease.php' bgcolor='#eeeeec'>...\action.dorelease.php<b>:</b>49</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>6</td><td bgcolor='#eeeeec' align='center'>0.3078</td><td bgcolor='#eeeeec' align='right'>6917496</td><td bgcolor='#eeeeec'>CMSModule->GetHelpPage(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.moduleoperations.inc.php' bgcolor='#eeeeec'>...\class.moduleoperations.inc.php<b>:</b>232</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>7</td><td bgcolor='#eeeeec' align='center'>0.3274</td><td bgcolor='#eeeeec' align='right'>6933744</td><td bgcolor='#eeeeec'>cms_module_GetHelpPage(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.CMSModule.php' bgcolor='#eeeeec'>...\class.CMSModule.php<b>:</b>405</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>8</td><td bgcolor='#eeeeec' align='center'>0.3274</td><td bgcolor='#eeeeec' align='right'>6950240</td><td bgcolor='#eeeeec'>Cataloger->GetHelp(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\internal\module_support\modmisc.inc.php' bgcolor='#eeeeec'>...\modmisc.inc.php<b>:</b>56</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>9</td><td bgcolor='#eeeeec' align='center'>0.3275</td><td bgcolor='#eeeeec' align='right'>6950920</td><td bgcolor='#eeeeec'>CMSModule->ProcessTemplate(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\modules\Cataloger\Cataloger.module.php' bgcolor='#eeeeec'>...\Cataloger.module.php<b>:</b>414</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>10</td><td bgcolor='#eeeeec' align='center'>0.3279</td><td bgcolor='#eeeeec' align='right'>6951008</td><td bgcolor='#eeeeec'>cms_module_ProcessTemplate(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.CMSModule.php' bgcolor='#eeeeec'>...\class.CMSModule.php<b>:</b>2606</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>11</td><td bgcolor='#eeeeec' align='center'>0.3279</td><td bgcolor='#eeeeec' align='right'>6951112</td><td bgcolor='#eeeeec'>Smarty_CMS->fetch(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\internal\module_support\modtemplates.inc.php' bgcolor='#eeeeec'>...\modtemplates.inc.php<b>:</b>142</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>12</td><td bgcolor='#eeeeec' align='center'>0.3280</td><td bgcolor='#eeeeec' align='right'>6954896</td><td bgcolor='#eeeeec'>Smarty_Internal_TemplateBase->fetch(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\internal\class.Smarty_CMS.php' bgcolor='#eeeeec'>...\class.Smarty_CMS.php<b>:</b>365</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>13</td><td bgcolor='#eeeeec' align='center'>0.3329</td><td bgcolor='#eeeeec' align='right'>7052464</td><td bgcolor='#eeeeec'>content_58039ead524b31_33672088(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\smarty\sysplugins\smarty_internal_templatebase.php' bgcolor='#eeeeec'>...\smarty_internal_templatebase.php<b>:</b>182</td></tr>
</table></font>
<br />
<font size='1'><table class='xdebug-error xe-notice' dir='ltr' border='1' cellspacing='0' cellpadding='1'>
<tr><th align='left' bgcolor='#f57900' colspan="5"><span style='background-color: #cc0000; color: #fce94f; font-size: x-large;'>( ! )</span> Notice: Trying to get property of non-object in D:\wamp64\www\cmsms.2.1.5\tmp\templates_c\Cataloger^fa466162d07af544546be007fce5c5107503341a.module_file_tpl.Cataloger;help.tpl.php on line <i>237</i></th></tr>
<tr><th align='left' bgcolor='#e9b96e' colspan='5'>Call Stack</th></tr>
<tr><th align='center' bgcolor='#eeeeec'>#</th><th align='left' bgcolor='#eeeeec'>Time</th><th align='left' bgcolor='#eeeeec'>Memory</th><th align='left' bgcolor='#eeeeec'>Function</th><th align='left' bgcolor='#eeeeec'>Location</th></tr>
<tr><td bgcolor='#eeeeec' align='center'>1</td><td bgcolor='#eeeeec' align='center'>0.0077</td><td bgcolor='#eeeeec' align='right'>392256</td><td bgcolor='#eeeeec'>{main}(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\admin\moduleinterface.php' bgcolor='#eeeeec'>...\moduleinterface.php<b>:</b>0</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>2</td><td bgcolor='#eeeeec' align='center'>0.1679</td><td bgcolor='#eeeeec' align='right'>6589536</td><td bgcolor='#eeeeec'>CMSModule->DoActionBase(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\admin\moduleinterface.php' bgcolor='#eeeeec'>...\moduleinterface.php<b>:</b>76</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>3</td><td bgcolor='#eeeeec' align='center'>0.1680</td><td bgcolor='#eeeeec' align='right'>6590624</td><td bgcolor='#eeeeec'>CMSModule->DoAction(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.CMSModule.php' bgcolor='#eeeeec'>...\class.CMSModule.php<b>:</b>1477</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>4</td><td bgcolor='#eeeeec' align='center'>0.2220</td><td bgcolor='#eeeeec' align='right'>6607112</td><td bgcolor='#eeeeec'>include( <font color='#00bb00'>'D:\wamp64\www\cmsms.2.1.5\modules\JMDevTools\action.dorelease.php'</font> )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.CMSModule.php' bgcolor='#eeeeec'>...\class.CMSModule.php<b>:</b>1410</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>5</td><td bgcolor='#eeeeec' align='center'>0.2367</td><td bgcolor='#eeeeec' align='right'>6895736</td><td bgcolor='#eeeeec'>ModuleOperations->CreateXMLPackage(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\modules\JMDevTools\action.dorelease.php' bgcolor='#eeeeec'>...\action.dorelease.php<b>:</b>49</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>6</td><td bgcolor='#eeeeec' align='center'>0.3078</td><td bgcolor='#eeeeec' align='right'>6917496</td><td bgcolor='#eeeeec'>CMSModule->GetHelpPage(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.moduleoperations.inc.php' bgcolor='#eeeeec'>...\class.moduleoperations.inc.php<b>:</b>232</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>7</td><td bgcolor='#eeeeec' align='center'>0.3274</td><td bgcolor='#eeeeec' align='right'>6933744</td><td bgcolor='#eeeeec'>cms_module_GetHelpPage(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.CMSModule.php' bgcolor='#eeeeec'>...\class.CMSModule.php<b>:</b>405</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>8</td><td bgcolor='#eeeeec' align='center'>0.3274</td><td bgcolor='#eeeeec' align='right'>6950240</td><td bgcolor='#eeeeec'>Cataloger->GetHelp(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\internal\module_support\modmisc.inc.php' bgcolor='#eeeeec'>...\modmisc.inc.php<b>:</b>56</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>9</td><td bgcolor='#eeeeec' align='center'>0.3275</td><td bgcolor='#eeeeec' align='right'>6950920</td><td bgcolor='#eeeeec'>CMSModule->ProcessTemplate(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\modules\Cataloger\Cataloger.module.php' bgcolor='#eeeeec'>...\Cataloger.module.php<b>:</b>414</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>10</td><td bgcolor='#eeeeec' align='center'>0.3279</td><td bgcolor='#eeeeec' align='right'>6951008</td><td bgcolor='#eeeeec'>cms_module_ProcessTemplate(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\class.CMSModule.php' bgcolor='#eeeeec'>...\class.CMSModule.php<b>:</b>2606</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>11</td><td bgcolor='#eeeeec' align='center'>0.3279</td><td bgcolor='#eeeeec' align='right'>6951112</td><td bgcolor='#eeeeec'>Smarty_CMS->fetch(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\internal\module_support\modtemplates.inc.php' bgcolor='#eeeeec'>...\modtemplates.inc.php<b>:</b>142</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>12</td><td bgcolor='#eeeeec' align='center'>0.3280</td><td bgcolor='#eeeeec' align='right'>6954896</td><td bgcolor='#eeeeec'>Smarty_Internal_TemplateBase->fetch(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\classes\internal\class.Smarty_CMS.php' bgcolor='#eeeeec'>...\class.Smarty_CMS.php<b>:</b>365</td></tr>
<tr><td bgcolor='#eeeeec' align='center'>13</td><td bgcolor='#eeeeec' align='center'>0.3329</td><td bgcolor='#eeeeec' align='right'>7052464</td><td bgcolor='#eeeeec'>content_58039ead524b31_33672088(  )</td><td title='D:\wamp64\www\cmsms.2.1.5\lib\smarty\sysplugins\smarty_internal_templatebase.php' bgcolor='#eeeeec'>...\smarty_internal_templatebase.php<b>:</b>182</td></tr>
</table></font>
</strong>. Note that the "ü" is omitted.</p>
    <p>Fortunately, this is simplified by the $attrlist list available. This is a list of attributes by formal name ("Glücklichkeit") and their key ("glcklichkeit"). For example:
    <pre>
      {section name=at loop=$attrlist}
      &lt;div class="item_attribute_name">{$attrlist[at].name}:&lt;/div>&lt;div class="item_attribute_val">{eval var=$attrlist[at].key}&lt;/div>
      {/section}</pre>
    <p>As of <strong>version 0.8</strong>, you can assign an alias to each attribute. These aliases need to be US-ASCII and contain no punctuation. They can be used instead of the sanitized attribute name (e.g., you could use the alias "gluecklichkeit").</p>
    <h4>Displaying Attributes on Pages with Lists of Items</h4>
    <p>Attributes are included in the <strong>$itemlists[#]</strong> in two different ways: top-level attributes of the item, and as part of the item's <strong>"attr"</strong> array. They are stored as sanitized versions of the attribute names, which means they are converted to lower case and all punctuation and non-US-ASCII characters get removed. This is because Smarty is finicky, and will not handle these characters.</p>
    <p>So, for example, if you have an attribute called <strong>"Glücklichkeit"</strong>, the item will have <strong>$item.glcklichkeit</strong> and <strong>$item.attrs['glcklichkeit']</strong>. Note that the <strong>"ü"</strong> is omitted. You can refer to this attribute in your template
    with Smarty code like: <strong>{$itemlist[index].glcklickkeit}</strong> or <strong>{$itemlist[index].attrs.glcklichkeit}</strong>.</p>
    <p>Fortunately, this is simplified by the <strong>$attrlist</strong> list available. This is a list of attributes by formal name ("Glücklichkeit") and their key ("glcklichkeit"). For example:
    <pre>
        {foreach from=$attrlist item=attr key=k}
        {$attr}: {$items[numloop][$k]}
        {/foreach}</pre>
    <p>As of <strong>version 0.8</strong>, you can assign an alias to each attribute. These aliases need to be <strong>US-ASCII</strong> and contain no punctuation. They can be used instead of the sanitized attribute name (e.g., you could use the alias "gluecklichkeit").</p>
    <h4>Smarty tags in Attributes</h4>
    <p>Sometimes, you'll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you'll need to
    update your template. For the attributes where you want smarty tags to be active, you'll need to nest the smarty evaluations in your template. For example:</p>
    <pre>&#123;eval var=$attrlist[at].key}</pre>
    <p>becomes:</p>
    <pre>&#123;eval var=$entry->input assign=thisAttr}&#123;eval var=$thisAttr}</pre>
  </div>
  
  
  <div id="whatsnew_c">
    <div class="pageoverflow">
      <h3>What's new</h3>
      <p>This is a summary of the most important changes the module as gone through. For details, please consult the changelog.</p>
      <ul>
        <li>
          Cataloger is now exclusively compatible with CMSMS 2.x;
        </li> 
        <li>
          Cataloger is now compatible PHP 7.x;
        </li>  
        <li>
          Cataloger admin menu has moved to content section;
        </li> 
        <li>
          content types now behave, for the most part, like CMSMS core content types:
          <ul>
            <li>all attribute of the typical content type can be found and used;</li>
            <li>additional content blocks can now be used on page templates - Cataloger will allow it's use;</li>
            <li>cataloger pages can now be previewed by Content Manager - Preview tab;</li>
          </ul>
        </li>
        <li>
          sub templates have a new variable with the main content block giving users some freedom regarding its placement;
        </li> 
        <li>
          image tabs will only be visible if there are images set to be used in the module settings;
        </li>  
        <li>
          file tabs will only be visible if there are files set to be used in the module settings;
        </li>   
        <li>
          there have been some changes to sub-templates although backwards compatibility was kept as much as possible;
        </li>    
        <li>
          the location dir of the images is now concealed if Cataloger native image handling is used;
        </li>    
        <li>
          a huge number of <em>under the hood</em> modifications and optimizations was made to the code;
        </li>    
      </ul>
      <p>Although all efforts have been made to test and make sure the module works without issues, given the number of modifications, minor bugs are expected to exist, so please file a Bug Report if you find one.</p>
      <p><div class='warning'>It is strongly recommended a full backup of files and database before an upgrade. Some, more complex, installations may have issues: most, if not all, of them should be solved by clearing CMSMS cache and/or tweaking sub-templates.</div></p>
    </div> 
  </div>
  
  
  <div id="about_c">
    
    <h3>Support</h3>
    <div class="pageoverflow">
      <p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
      <ul>
        <li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
        <li>To obtain commercial support, please send an email to the author at <a href="mailto:jomorg@sm-art-lab.com">&lt;jomorg@sm-art-lab.com&gt;</a>.</li>
        <li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
        <li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
        <li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
      </ul>
     </div>
       
    <h3>Copyright and License</h3>
    <div class="pageoverflow">    
      <p>As per the GPL, this software is provided as-is. Please read the text of the license for the full disclaimer.</p>

      <p>Copyright &copy; 2012 - 2016, Fernando Morgado (JoMorg) <a href="mailto:jomorg@sm-art-lab.com">&lt;jomorg@sm-art-lab.com&gt;</a>. All Rights Are Reserved.</p>
      <p>Copyright &copy; 2008, Samuel Goldstein. All Rights Are Reserved.</p>
    </div>
    <div class="pageoverflow">  
      <p style="font-size:85%;font-weight: bold;">This program is free software;<br /> you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation;<br /> either version 2 of the License, or (at your option) any later version.</p>
      <p style="font-size:85%;font-weight: bold;">This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;<br /> without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.</p>
      <p style="font-size:85%;font-weight: bold;">See theGNU General Public License for more details.</p>
      <p style="font-size:85%;font-weight: bold;">You should have received a copy of the GNU General Public License along with this program;<br /> if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA <a target="_blank" href="http://www.gnu.org/licenses/licenses.html#GPL">or read it online</a>.</p>
      <p style="font-size:85%;font-weight: bold;">You must agree to this license before using the module.</p>
    </div>
    
    <h3>Credits</h3>
    <p>This module has been originaly created, developed and maintained for a number of years by Samuel Goldstein. Fernando Morgado took over and has been maintaining it (for better or for worst) since 2012.</p>
    <p></p>
    <ul>
      <li><strong>Samuel Goldstein (sjg)</strong> - Creation and development;</li>
      <li><strong>Nuno</strong> - code contributions;</li>
      <li><strong>Morten Poulsen (silmarillion)</strong> - code contributions;</li>
      <li><strong>Fernando Morgado (JoMorg)</strong> - development and maintenance;</li>
    </ul>
    
    <h3>Contributors</h3>
    <ul>
      <li><a target="_blank" href="http://www.id-a.co.uk" rel="external">Paul Cooper</a> - sponsored the development of textarea attributes;</li>
      <li><a target="_blank" href="http://www.matthornsby.ca" rel="external">Matt Homsby (DIGI3)</a> - sponsorship;</li>
    </ul>
    <p>Thanks to numerous patient users and bug testers (many of whom had no idea what they were getting into).</p> 
  </div>
</div>


]]></help>
	<about><![CDATA[PGJyIC8+QXV0aG9yOiBKb01vcmcgJmx0O2pvbW9yZy5tb3JnQGdtYWlsLmNvbSZndDs8YnIgLz48YnIgLz5WZXJzaW9uOiAxLjAuMTxiciAvPjxiciAvPkNoYW5nZSBIaXN0b3J5OjxiciAvPjx1bD4KPGxpPlZlcnNpb24gMC4xMS4zIC0gRGVjZW1iZXIgMjAxMi4KICAgIDx1bD4KICAgICAgICA8bGk+PHN0cm9uZz5CdWcgZml4OiBbIzQ3ODFdIC0gIDwvc3Ryb25nPiBjbXNfc2VsZmxpbmsgZG9lc250IHdvcmsgPC9zdHJvbmc+LjwvbGk+CiAgICA8L3VsPgo8L2xpPgo8bGk+VmVyc2lvbiAwLjExLjIgLSBOb3ZlbWJlciAyMDEyLgogICAgPHVsPgogICAgICAgIDxsaT48c3Ryb25nPkJ1ZyBmaXg6IC0ge0NhdGFsb2dlciBhY3Rpb249J2FsbCcgc3ViX3RlbXBsYXRlPSdteV9zdWJfdGVtcGxhdGUnIGFsaWFzPScvJ308L3N0cm9uZz4gYnJlYWtzIHdpdGggYSBQSFAgZXJyb3IuPC9saT4KICAgIDwvdWw+CjwvbGk+CjxsaT5WZXJzaW9uIDAuMTEuMSAtIE9jdG9iZXIgMjAxMi4KICAgIDx1bD4KICAgICAgICA8bGk+PHN0cm9uZz5CdWcgZml4OiBbIzg0MF0gLTwvc3Ryb25nPiBSZXBlYXRlZCBjb250ZW50IG91dHB1dCBpZiBtdWx0aXBsZSBjb250ZW50IHRhZ3MgaW4gdGVtcGxhdGUuPC9saT4KICAgICAgICA8bGk+PHN0cm9uZz5CdWcgZml4OiBbIzgzODFdIC0ge3Byb2Nlc3MgcGFnZWRhdGF9PC9zdHJvbmc+IGJyZWFrcyBjYXRhbG9nZXIgdGVtcGxhdGUuPC9saT4KICAgIDwvdWw+CjwvbGk+CjxsaT5WZXJzaW9uIDAuMTEuMCAtIEF1Z3VzdCAyMDEyLgogIDx1bD4KICAgIDxsaT5OdW1lcm91cyBmaXhlcyBmb3IgQ01TTVMgMS4xMSBjb21wYXRpYmlsaXR5OzwvbGk+CiAgICA8bGk+Rm9yZ2UgUnVsZXMgY29tcGxpYW50OzwvbGk+CiAgPC91bD4KPC9saT4KPGxpPlZlcnNpb24gMC45LjEgLSBKYW4gMjAxMS4gQnVnIGZpeCBmb3IgY2hlY2tib3ggaXRlbSBhdHRyaWJ1dGUgdHlwZXMuPC9saT4KPGxpPlZlcnNpb24gMC45IC0gTm92IDIwMTAuCiAgPHVsPgogICAgPGxpPk51bWVyb3VzIGZpeGVzIGZvciBDTVNNUyAxLjkgY29tcGF0aWJpbGl0eTwvbGk+CiAgICA8bGk+VGVkJ3MgZXhjZWxsZW50IGRyb3Bkb3duIGF0dHJpYnV0ZSB0eXBlPC9saT4KCTxsaT5PcHRpbWl6ZWQgInJhbmRvbSIgYWN0aW9uIGZvciBzaXRlcyB3aXRoIGh1Z2UgbnVtYmVycyBvZiBpdGVtIHBhZ2VzPC9saT4KICAgIDxsaT5DaGVja2JveCBhdHRyaWJ1dGUgdHlwZTwvbGk+CiAgPC91bD4KPC9saT4KPGxpPlZlcnNpb24gMC44LjEgKHVucmVsZWFzZWQsIHNlZSAwLjkpPC9saT4KPGxpPlZlcnNpb24gMC44LjAgLSBTZXAgMjAxMC4KICA8dWw+CiAgICA8bGk+UmVvcmRlcmluZyBvZiBhdHRyaWJ1dGVzPC9saT4KICAgIDxsaT5BdHRyJ3Mgbm93IGNhbiBoYXZlIGxlbmd0aHMgYW5kIGRlZmF1bHQgdmFsdWVzPC9saT4KICAgIDxsaT5BcHBseSBidXR0b24gZm9yIHRlbXBsYXRlczwvbGk+CiAgICA8bGk+Rml4ZWQgdG8gcHJpbnRhYmxlIGNhdGFsb2ctc3R1ZmY8L2xpPgogICAgPGxpPkJ1aWx0LWluIHNvcnRpbmcgZnVuY3Rpb25hbGl0eTwvbGk+CiAgICA8bGk+QXNzb3J0ZWQgYnVnZml4ZXMsIGNsZWFudXBzIGV0YzwvbGk+CiAgPC91bD4KPC9saT4KPGxpPlZlcnNpb24gMC43LjcgLSBGZWIgMjAxMC4gQWRkZWQgZmlsZXMgYXNzb2NpYXRlZCB3aXRoIEl0ZW1zLiBBZGRlZCBpdGVtIGNvbXBhcmlzb24gYWN0aW9uLjwvbGk+CjxsaT5WZXJzaW9uIDAuNy42IC0gMTAgU2VwdCAyMDA5LiBGaXggZm9yIHRoYXQgbGFzdCBmaXguIERvaCE8L2xpPgo8bGk+VmVyc2lvbiAwLjcuNSAtIDEwIFNlcHQgMjAwOS4gRml4ZWQgUHJpbnRhYmxlIENhdGFsb2cuLi4gZGlkIHRoYXQgZXZlciB3b3JrPz88L2xpPgo8bGk+VmVyc2lvbiAwLjcuNCAtIDIyIEp1bmUgMjAwOS4gSW5jb3Jwb3JhdGVkIENhbGd1eVwncyBmaXhlcyBmb3IgMS42LjwvbGk+CjxsaT5WZXJzaW9uIDAuNy4zIC0gMTYgSnVuZSAyMDA5LiBCdWcgZml4ZXMgYnkgTnVuby4gTWFkZSBtYXggQ01TIHZlcnNpb24gMS41LjQgaW4gcHJlcCBmb3IgQ01TIDEuNiByZWxlYXNlLjwvbGk+CjxsaT5WZXJzaW9uIDAuNy4yIC0gMTQgTWFyY2ggMjAwOS4gQnVnIGZpeGVzIGJ5IE51bm8gQ29zdGEuPC9saT4KPGxpPlZlcnNpb24gMC43LjEgLSAyOSBTZXB0IDIwMDguIEFkZGVkIFZhcmlhYmxlIG1ldGhvZCBmb3IgSmF2aWVyIFNhbiBKdWFuIENvc3RpbGFzLjwvbGk+CjxsaT5WZXJzaW9uIDAuNyAtIDE3IE1hcmNoIDIwMDguIDxlbT5GaW5hbGx5PC9lbT4gYWRkZWQgcGVyLXBhZ2UgbWV0YS1kYXRhLiBBbmQgdGhlcmUgd2FzIGdyZWF0IGNlbGVicmF0aW9uIGluIHRoZSBzdHJlZXRzLCBhbmQgZGFuY2luZyBpbiB0aGUgdG93biBzcXVhcmUuIEFsc28gYWRkZWQgaW4gbWFueSBIVE1MIGFuZCBsb2NhbGl6YXRpb24gZml4ZXMgY29udHJpYnV0ZWQgYnkgTnVubyBDb3N0YS48L2xpPgo8bGk+VmVyc2lvbiAwLjYuMiAtIDcgSmFudWFyeSAyMDA3LiBGaXhlZCBuYXN0eSBidWcgd2hlcmUgdXBncmFkaW5nIG1ha2VzIGl0IGxvb2sgbGlrZSBhbGwgeW91ciBub3RlIGZpZWxkcyBhcmUgbG9zdC48L2xpPgo8bGk+VmVyc2lvbiAwLjYuMSAtIDIgSmFudWFyeSAyMDA3LiBGaXhlZCBuYXN0eSBidWcgd2hlcmUgY2hhbmdpbmcgY29udGVudCB0eXBlIGZyb20gImNvbnRlbnQiIHRvIGNhdGFsb2cgY29udGVudCB0eXBlcyByZW5hbWVkIGFsbCBjYXRhbG9nIGltYWdlcy48L2xpPgo8bGk+VmVyc2lvbiAwLjYgLSAyOSBEZWNlbWJlciAyMDA3LiA8dWw+CjxsaT5CdWcgZml4OiBJbWFnZXMgZG9uXCd0IGdldCAibG9zdCIgd2hlbiBwYWdlIGFsaWFzIGNoYW5nZXMuPC9saT4KPGxpPkJ1ZyBmaXg6IEF0dHJpYnV0ZSBjb250ZW50IGRvZXNuXCd0IGdldCAibG9zdCIgd2hlbiBhdHRyaWJ1dGVzIGFyZSByZW5hbWVkLjwvbGk+CjxsaT5CdWcgZml4OiBGaXhlZCBQcmludGFibGUgQ2F0YWxvZy4gV29ya3MgZm9yIGZpcnN0IHRpbWUgc2luY2Ugdi4wLjQgb3IgdGhlcmVhYm91dHMuPC9saT4KPGxpPkJ1ZyBmaXg6IE5vdyBob25vcnMgc3lzdGVtIHByZWZlcmVuY2UgZm9yIFdZU0lXWUcgZWRpdGluZyBvZiB0ZXh0IGFyZWFzLjwvbGk+CjxsaT5GZWF0dXJlOiBBdHRyaWJ1dGVzIG1heSBub3cgYmUgdGV4dCBhcmVhcy48L2xpPgo8L3VsPgo8L2xpPgo8bGk+VmVyc2lvbiAwLjUuNiAtIDEwIERlY2VtYmVyIDIwMDcuIFRhcmR5IHJvbGxvdXQgb2YgZml4ZXM6IDx1bD4KPGxpPkFkZGVkIGNvZGUgdG8gcHJldmVudCBzaG93aW5nIG9mIG5vbi11cGxvYWRlZCBpbWFnZXMsIGNhdGVnb3J5IHBhZ2UgYnVmZmVyIGZsdXNoaW5nIGZvciBleHRyZW1lIGNhc2VzLCBtaW5vciBidWcgZml4ZXM8L2xpPgo8bGk+Rml4IGZvciAncmVjZW50JyBhY3Rpb24gd2hlbiBhbGlhcyBpcyAvPC9saT4KPGxpPkZpeCBmb3IgdGhlIHByb2JsZW0gd2hlcmUgY2F0YWxvZ3Mgd2l0aCBtb3JlIHRoYW4gdGVuIGNhdGVnb3JpZXMgaGF2ZSBpdGVtcyBkaXNwbGF5ZWQgaW4gaW5jb3JyZWN0IGNhdGVnb3JpZXM8L2xpPjwvdWw+PC9saT4KPGxpPlZlcnNpb24gMC41LjUgLSAyMCBKdW5lIDIwMDcuIEZpeCBmb3IgQ29udGVudCBBbGlhcyBzdXBwb3J0IC0gcmVxdWlyZXMgQ29udGVudCBBbGlhcyB2LiAwLjYuMS48L2xpPgo8bGk+VmVyc2lvbiAwLjUuNCAtIDE5IEp1bmUgMjAwNy4gQWRkZWQgImFsbCIgZmVhdHVyZSBsaXN0LjwvbGk+CjxsaT5WZXJzaW9uIDAuNS4zIC0gMjEgU2VwdGVtYmVyIDIwMDYuIEFkZGVkIGxpbmtzIHRvIHNvdXJjZSAobm9uLXJlc2NhbGVkKSBpbWFnZXMsIGFuZCBhZGRlZCBpbWFnZSBkZWxldGUgZnVuY3Rpb25hbGl0eS48L2xpPgo8bGk+VmVyc2lvbiAwLjUuMiAtIDE3IFNlcHRlbWJlciAyMDA2LiBSZW1vdmVkIGRlYnVnIG91dHB1dCwgcmV2aXNlZCBpbWFnZSBzeXN0ZW0gKGZpeGVkIGJ1Z3MpLiBDYWNoaW5nIGJ1ZyBzZWVtcyB0byByZW1haW4uPC9saT4KPGxpPlZlcnNpb24gMC41LjEgLSAyNCBBdWd1c3QgMjAwNi4gKGNhbGd1eTEwMDApLCBVcHBlZCBNaW5pbXVtQ01TVmVyc2lvbiB0byAxLjAtc3ZuLCBhbmQgbW9yZSAxLjAgY2hhbmdlcyB3ZXJlIGFkZGVkIChyZW1vdmVkIHN0YXRpYyBtZXRob2RzKTwvbGk+CjxsaT5WZXJzaW9uIDAuNSAtIDE2IEF1Z3VzdCAyMDA2LiBBc3NvcnRlZCBjb250cmlidXRlZCBidWcgZml4ZXMgZm9yIENNUyBNUyAxLjAsICBuZXcgb3B0aW9ucyBmb3IgaW1hZ2VzLjwvbGk+CjxsaT5WZXJzaW9uIDAuNC4yIC0gMjggTWF5IDIwMDYuIEJ1ZyBmaXggZm9yIGF0dHJpYnV0ZXMgaW4gY2F0ZWdvcnkgcGFnZXMuIEFkZGVkICIvIiBwYWdlX2FsaWFzIGZvciBmZWF0dXJlIGxpc3RzLjwvbGk+CjxsaT5WZXJzaW9uIDAuNC4xIC0gMjMgTWF5IDIwMDYuIEJ1ZyBmaXggdG8gbWFrZSB3b3JrIHdpdGggb2xkZXIgdmVyc2lvbnMgb2YgQ01TIE1TLjwvbGk+CjxsaT5WZXJzaW9uIDAuNCAtIDIyIE1heSAyMDA2LiBCdWcgZml4ZXMsIEZlYXR1cmUgTGlzdHMuPC9saT4KPGxpPlZlcnNpb24gMC4zIC0gKHVucmVsZWFzZWQsIHB1Ymxpc2hlZCBmcm9tIHN2bik8L2xpPgo8bGk+VmVyc2lvbiAwLjIgLSAyMyBNYXJjaCAyMDA2LiBOdW1lcm91cyBidWcgZml4ZXMuIFBlcmZvcm1hbmNlIGltcHJvdmVtZW50cy4gTWVtb3J5IGZvb3RwcmludCBvcHRpbWl6YXRpb25zLiBOb3cgdXNlcyB0aGUgQ01TIDAuMTIgTW9kdWxlIEFQSS48L2xpPgo8bGk+VmVyc2lvbiAwLjEuNSAtIDE3IE5vdmVtYmVyIDIwMDUuIEluaXRpYWwgUmVsZWFzZS4gSmVzdXMsIHRoYXQgdG9vayBhIGxvbmcgdGltZS48L2xpPgo8bGk+VmVyc2lvbiAwLjEgLSAxOSBNYXJjaCAyMDA1LiBQcm9qZWN0IEluaXRpYXRpb24uPC9saT4KPC91bD48YnIgLz4=]]></about>
	<description><![CDATA[Manage Catalog settings]]></description>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/action.adminattrs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCmlmKCFkZWZpbmVkKCdDTVNfVkVSU0lPTicpKSBleGl0Ow0KaWYoISR0aGlzLT5DaGVja0FjY2VzcygpKSBleGl0Ow0KDQokdGhpcy0+aW5pdEFkbWluTmF2KCRpZCwgJHBhcmFtcywgJHJldHVybmlkKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbignc3RhcnRmb3JtJywgJHRoaXMtPkNyZWF0ZUZvcm1TdGFydCgkaWQsICdzdWJtaXRhdHRycycsICRyZXR1cm5pZCkpOw0KJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdlbmRmb3JtJywgJHRoaXMtPkNyZWF0ZUZvcm1FbmQoKSk7DQokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ3N1Ym1pdCcsICR0aGlzLT5DcmVhdGVJbnB1dFN1Ym1pdCgkaWQsICdzdWJtaXQnLCAnU3VibWl0JykpOw0KJGF0dHJpYnV0ZXMgICAgID0gYXJyYXkoKTsNCiRxdWVyeSAgICAgICAgICA9ICJTRUxFQ1QgaWQsIGF0dHJpYnV0ZSwgYWxpYXMsIGRlZmF1bHR2YWwsIHR5cGVfaWQsIGxlbmd0aCwgb3JkZXJfYnksIGZpZWxkX3R5cGUsIHNlbGVjdF92YWx1ZXMgRlJPTSAiIC4gY21zX2RiX3ByZWZpeCgpIC4gIm1vZHVsZV9jYXRhbG9nX2F0dHIgT1JERVIgQlkgb3JkZXJfYnkgQVNDIjsNCiRkYnJlc3VsdCAgICAgICA9ICRkYi0+RXhlY3V0ZSgkcXVlcnkpOw0KDQokY291bnRieXR5cGUgICAgPSBhcnJheSgpOw0KJGNvdW50Ynl0eXBlWzFdID0gMDsNCiRjb3VudGJ5dHlwZVsyXSA9IDA7DQokY291bnRieXR5cGVbM10gPSAwOw0KDQp3aGlsZSgkZGJyZXN1bHQgIT09IGZhbHNlICYmICRyb3cgPSAkZGJyZXN1bHQtPkZldGNoUm93KCkpDQp7DQogICRvbmVyb3cgICAgICAgICAgICAgICAgPSBuZXcgc3RkQ2xhc3MoKTsNCiAgJG9uZXJvdy0+aW5wdXQgICAgICAgICA9ICR0aGlzLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnYXR0cl8nIC4gJHJvd1sndHlwZV9pZCddIC4gJ18nIC4gJGNvdW50Ynl0eXBlWyRyb3dbJ3R5cGVfaWQnXV0sICRyb3dbJ2F0dHJpYnV0ZSddLCAxNSwgMTAwKTsNCiAgJG9uZXJvdy0+ZGVmYXVsdGlucHV0ICA9ICR0aGlzLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnZGVmYXVsdF8nIC4gJHJvd1sndHlwZV9pZCddIC4gJ18nIC4gJGNvdW50Ynl0eXBlWyRyb3dbJ3R5cGVfaWQnXV0sICRyb3dbJ2RlZmF1bHR2YWwnXSwgMTUsIDEwMjQpOw0KICAkb25lcm93LT5sZW5pbnB1dCAgICAgID0gJHRoaXMtPkNyZWF0ZUlucHV0VGV4dCgkaWQsICdsZW5fJyAuICRyb3dbJ3R5cGVfaWQnXSAuICdfJyAuICRjb3VudGJ5dHlwZVskcm93Wyd0eXBlX2lkJ11dLCAoIWVtcHR5KCRyb3dbJ2xlbmd0aCddKSA/ICRyb3dbJ2xlbmd0aCddIDogMjUpLCAyLCA0KTsNCiAgJG9uZXJvdy0+YWxpYXNpbnB1dCAgICA9ICR0aGlzLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnYWxpYXNfJyAuICRyb3dbJ3R5cGVfaWQnXSAuICdfJyAuICRjb3VudGJ5dHlwZVskcm93Wyd0eXBlX2lkJ11dLCAkcm93WydhbGlhcyddLCAxNSwgMjU1KTsNCiAgJG9uZXJvdy0+aGlkZGVuICAgICAgICA9ICR0aGlzLT5DcmVhdGVJbnB1dEhpZGRlbigkaWQsICdvbGRfJyAuICRyb3dbJ3R5cGVfaWQnXSAuICdfJyAuICRjb3VudGJ5dHlwZVskcm93Wyd0eXBlX2lkJ11dLCAkcm93WydpZCddKTsNCiAgJG9uZXJvdy0+dHlwZSAgICAgICAgICA9ICRyb3dbJ3R5cGVfaWQnXTsNCiAgJG9uZXJvdy0+ZmllbGRfdHlwZSAgICA9ICR0aGlzLT5DcmVhdGVJbnB1dERyb3Bkb3duKCRpZCwgJ2ZpZWxkX3R5cGVfJyAuICRyb3dbJ3R5cGVfaWQnXSAuICdfJyAuICRjb3VudGJ5dHlwZVskcm93Wyd0eXBlX2lkJ11dLCBhcnJheV9mbGlwKCR0aGlzLT5nZXRGaWVsZFR5cGVzKCkpLCAtIDEsICRyb3dbJ2ZpZWxkX3R5cGUnXSk7DQogICRvbmVyb3ctPnNlbGVjdF92YWx1ZXMgPSAkdGhpcy0+Q3JlYXRlSW5wdXRUZXh0KCRpZCwgJ3NlbGVjdF92YWx1ZXNfJyAuICRyb3dbJ3R5cGVfaWQnXSAuICdfJyAuICRjb3VudGJ5dHlwZVskcm93Wyd0eXBlX2lkJ11dLCAkcm93WydzZWxlY3RfdmFsdWVzJ10sIDE1LCAyNTUpOw0KICAkb25lcm93LT5vcmRlcl9ieSAgICAgID0gJHJvd1snb3JkZXJfYnknXTsNCiAgJG9uZXJvdy0+Y2J0ICAgICAgICAgICA9ICRjb3VudGJ5dHlwZVskcm93Wyd0eXBlX2lkJ11dOw0KICAkb25lcm93LT5kZWxldGUgICAgICAgID0gJHRoaXMtPkNyZWF0ZUlucHV0Q2hlY2tib3goJGlkLCAnZGVsZXRlXycgLiAkcm93Wyd0eXBlX2lkJ10gLiAnXycgLiAkY291bnRieXR5cGVbJHJvd1sndHlwZV9pZCddXSwgMSwgMCk7DQogICRjb3VudGJ5dHlwZVskcm93Wyd0eXBlX2lkJ11dKys7DQogIGFycmF5X3B1c2goJGF0dHJpYnV0ZXMsICRvbmVyb3cpOw0KfQ0KDQpmb3IoJGkgPSAwOyAkaSA8IDM7ICRpKyspDQp7DQogIGZvcigkaiA9IDE7ICRqIDwgNDsgJGorKykNCiAgew0KICAgICRvbmVyb3cgICAgICAgICAgICAgICAgPSBuZXcgc3RkQ2xhc3MoKTsNCiAgICAkb25lcm93LT5pbnB1dCAgICAgICAgID0gJHRoaXMtPkNyZWF0ZUlucHV0VGV4dCgkaWQsICdhdHRyXycgLiAkaiAuICdfJyAuICRjb3VudGJ5dHlwZVskal0sICcnLCAxNSwgMjU1KTsNCiAgICAkb25lcm93LT5hbGlhc2lucHV0ICAgID0gJHRoaXMtPkNyZWF0ZUlucHV0VGV4dCgkaWQsICdhbGlhc18nIC4gJGogLiAnXycgLiAkY291bnRieXR5cGVbJGpdLCAnJywgMTUsIDI1NSk7DQogICAgJG9uZXJvdy0+ZGVmYXVsdGlucHV0ICA9ICR0aGlzLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnZGVmYXVsdF8nIC4gJGogLiAnXycgLiAkY291bnRieXR5cGVbJGpdLCAnJywgMTUsIDEwMjQpOw0KICAgICRvbmVyb3ctPmxlbmlucHV0ICAgICAgPSAkdGhpcy0+Q3JlYXRlSW5wdXRUZXh0KCRpZCwgJ2xlbl8nIC4gJGogLiAnXycgLiAkY291bnRieXR5cGVbJGpdLCAyNSwgMiwgNCk7DQogICAgJG9uZXJvdy0+ZmllbGRfdHlwZSAgICA9ICR0aGlzLT5DcmVhdGVJbnB1dERyb3Bkb3duKCRpZCwgJ2ZpZWxkX3R5cGVfJyAuICRqIC4gJ18nIC4gJGNvdW50Ynl0eXBlWyRqXSwgYXJyYXlfZmxpcCgkdGhpcy0+Z2V0RmllbGRUeXBlcygpKSwgLSAxLCAkcm93WydmaWVsZF90eXBlJ10pOw0KICAgICRvbmVyb3ctPnNlbGVjdF92YWx1ZXMgPSAkdGhpcy0+Q3JlYXRlSW5wdXRUZXh0KCRpZCwgJ3NlbGVjdF92YWx1ZXNfJyAuICRqIC4gJ18nIC4gJGNvdW50Ynl0eXBlWyRqXSwgJycsIDE1LCAyNTUpOw0KICAgICRvbmVyb3ctPmRlbGV0ZSAgICAgICAgPSAnJzsNCiAgICAkb25lcm93LT5oaWRkZW4gICAgICAgID0gJyc7DQogICAgJG9uZXJvdy0+dHlwZSAgICAgICAgICA9ICRqOw0KICAgICRvbmVyb3ctPm9yZGVyX2J5ICAgICAgPSAkY291bnRieXR5cGVbJGpdICsgMTsNCiAgICAkb25lcm93LT5jYnQgICAgICAgICAgID0gJGNvdW50Ynl0eXBlWyRqXSsrOw0KICAgIGFycmF5X3B1c2goJGF0dHJpYnV0ZXMsICRvbmVyb3cpOw0KICB9DQp9DQoNCmZvcigkaSA9IDE7ICRpIDwgNDsgJGkrKykNCnsNCiAgJHNjID0gYXJyYXkoKTsNCiAgZm9yKCRqID0gMDsgJGogPD0gJGNvdW50Ynl0eXBlWyRpXTsgJGorKykNCiAgew0KICAgICRzY1skal0gPSAkajsNCiAgfQ0KICANCiAgZm9yKCRrID0gMDsgJGsgPCBjb3VudCgkYXR0cmlidXRlcyk7ICRrKyspDQogIHsNCiAgICBpZigkYXR0cmlidXRlc1ska10tPnR5cGUgPT0gJGkpDQogICAgew0KICAgICAgJGF0dHJpYnV0ZXNbJGtdLT5vcmRlcl9zZWwgPSAkdGhpcy0+Q3JlYXRlSW5wdXREcm9wZG93bigkaWQsICdvcmRlcmJ5XycgLiAkaSAuICdfJyAuICRhdHRyaWJ1dGVzWyRrXS0+Y2J0LCAkc2MsIC0gMSwgJGF0dHJpYnV0ZXNbJGtdLT5vcmRlcl9ieSk7DQogICAgfQ0KICAgICRhdHRyaWJ1dGVzWyRrXS0+aXN0ZXh0ID0gRkFMU0U7DQogIH0NCn0NCg0KLy9kZWJ1Z19kaXNwbGF5KCRhdHRyaWJ1dGVzKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbigndGFiX2hlYWRlcnMnLCAkdGhpcy0+U3RhcnRUYWJIZWFkZXJzKCkgLiAkdGhpcy0+U2V0VGFiSGVhZGVyKCdpdGVtJywgJHRoaXMtPkxhbmcoJ3RpdGxlX2l0ZW1fdGFiJykpIC4gJHRoaXMtPlNldFRhYkhlYWRlcignY2F0ZWdvcnknLCAkdGhpcy0+TGFuZygndGl0bGVfY2F0ZWdvcnlfdGFiJykpIC4gJHRoaXMtPlNldFRhYkhlYWRlcignY2F0YWxvZycsICR0aGlzLT5MYW5nKCd0aXRsZV9wcmludGFibGVfdGFiJykpIC4gJHRoaXMtPkVuZFRhYkhlYWRlcnMoKSAuICR0aGlzLT5TdGFydFRhYkNvbnRlbnQoKSk7DQokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2VuZF90YWInLCAkdGhpcy0+RW5kVGFiKCkpOw0KJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCd0YWJfZm9vdGVycycsICR0aGlzLT5FbmRUYWJDb250ZW50KCkpOw0KJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdzdGFydF9pdGVtX3RhYicsICR0aGlzLT5TdGFydFRhYignaXRlbScpKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbignc3RhcnRfY2F0ZWdvcnlfdGFiJywgJHRoaXMtPlN0YXJ0VGFiKCdjYXRlZ29yeScpKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbignc3RhcnRfY2F0YWxvZ190YWInLCAkdGhpcy0+U3RhcnRUYWIoJ2NhdGFsb2cnKSk7DQokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ21lc3NhZ2UnLCBpc3NldCgkcGFyYW1zWydtZXNzYWdlJ10pID8gJHBhcmFtc1snbWVzc2FnZSddIDogJycpOw0KJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdhdHRyaWJ1dGVfaW5wdXRzJywgJGF0dHJpYnV0ZXMpOw0KJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCd0aXRsZV9pdGVtX2F0dHJpYnV0ZXMnLCAkdGhpcy0+TGFuZygndGl0bGVfaXRlbV90YWInKSk7DQokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ3RpdGxlX2F0dHJfYWxpYXMnLCAkdGhpcy0+TGFuZygndGl0bGVfYXR0cl9hbGlhcycpKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbigndGl0bGVfYXR0cl9sZW5ndGgnLCAkdGhpcy0+TGFuZygndGl0bGVfYXR0cl9sZW5ndGgnKSk7DQokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ3RpdGxlX2F0dHJfbGVuZ3RoX2hlbHAnLCAkdGhpcy0+TGFuZygndGl0bGVfYXR0cl9sZW5ndGhfaGVscCcpKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbigndGl0bGVfYXR0cl9kZWZhdWx0JywgJHRoaXMtPkxhbmcoJ3RpdGxlX2F0dHJfZGVmYXVsdCcpKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbigndGl0bGVfYXR0cl9vcmRlcl9ieScsICR0aGlzLT5MYW5nKCd0aXRsZV9hdHRyX29yZGVyX2J5JykpOw0KJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCd0aXRsZV9jYXRhbG9nX2F0dHJpYnV0ZXMnLCAkdGhpcy0+TGFuZygndGl0bGVfcHJpbnRhYmxlX3RhYicpKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbigndGl0bGVfY2F0ZWdvcnlfYXR0cmlidXRlcycsICR0aGlzLT5MYW5nKCd0aXRsZV9jYXRlZ29yeV90YWInKSk7DQokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ3RpdGxlX2l0ZW1fYXR0cmlidXRlc19oZWxwJywgJHRoaXMtPkxhbmcoJ3RpdGxlX2l0ZW1fYXR0cmlidXRlc19oZWxwJykpOw0KJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCd0aXRsZV9jYXRhbG9nX2F0dHJpYnV0ZXNfaGVscCcsICR0aGlzLT5MYW5nKCd0aXRsZV9jYXRhbG9nX2F0dHJpYnV0ZXNfaGVscCcpKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbigndGl0bGVfY2F0ZWdvcnlfYXR0cmlidXRlc19oZWxwJywgJHRoaXMtPkxhbmcoJ3RpdGxlX2NhdGVnb3J5X2F0dHJpYnV0ZXNfaGVscCcpKTsNCiR0aGlzLT5zbWFydHktPmFzc2lnbigndGl0bGVfc2VsZWN0X3ZhbHVlcycsICR0aGlzLT5MYW5nKCd0aXRsZV9zZWxlY3RfdmFsdWVzJykpOw0KJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCd0aXRsZV9maWVsZF90eXBlJywgJHRoaXMtPkxhbmcoJ3RpdGxlX2ZpZWxkX3R5cGUnKSk7DQokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ3RpdGxlX2RlbGV0ZScsICR0aGlzLT5MYW5nKCd0aXRsZV9kZWxldGUnKSk7DQokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2NhdGVnb3J5JywgJHRoaXMtPkxhbmcoJ21hbmFnZWF0dHJzJykpOw0KLy8gRGlzcGxheSB0ZW1wbGF0ZQ0KZWNobyAkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlKCdhZG1pbmF0dHJzLnRwbCcpOw0KPz4NCg==]]></data>
	</file>
	<file>
	  <filename>/action.adminprefs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
if( !defined('CMS_VERSION') ) exit;
if (! $this->CheckAccess()) exit;

		$this->initAdminNav($id, $params, $returnid);

		$this->smarty->assign('startform', $this->CreateFormStart($id, 'submitprefs', $returnid));
		$this->smarty->assign('endform', $this->CreateFormEnd());
		$this->smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', 'Submit'));

        $this->smarty->assign('tab_headers',$this->StartTabHeaders().
        $this->SetTabHeader('itemimage',$this->Lang('title_item_image_tab')).
        $this->SetTabHeader('file',$this->Lang('title_file_tab')).
        $this->SetTabHeader('categoryimage',$this->Lang('title_category_image_tab')).
        $this->SetTabHeader('printable',$this->Lang('title_printable_tab')).
        $this->SetTabHeader('image',$this->Lang('title_image_tab')).
        $this->SetTabHeader('path',$this->Lang('title_path_tab')).
        $this->EndTabHeaders().$this->StartTabContent());
        $this->smarty->assign('end_tab',$this->EndTab());
        $this->smarty->assign('tab_footers',$this->EndTabContent());
        $this->smarty->assign('start_item_image_tab',$this->StartTab('itemimage'));
        $this->smarty->assign('start_category_image_tab',$this->StartTab('categoryimage'));
        $this->smarty->assign('start_printable_tab',$this->StartTab('printable'));
        $this->smarty->assign('start_file_tab',$this->StartTab('file'));
        $this->smarty->assign('start_path_tab',$this->StartTab('path'));
	$this->smarty->assign('start_image_tab',$this->StartTab('image'));

        $this->smarty->assign('title_item_image_count', $this->Lang('title_item_image_count'));
        $this->smarty->assign('title_item_file_count', $this->Lang('title_item_file_count'));
       $this->smarty->assign('title_item_file_types', $this->Lang('title_item_file_types'));
        $this->smarty->assign('title_flush_cats', $this->Lang('title_flush_cats'));
        $this->smarty->assign('title_show_only_existing_images',
        	$this->Lang('title_show_only_existing_images'));
        $this->smarty->assign('title_show_missing_images',
        	$this->Lang('title_show_missing_images'));
        $this->smarty->assign('title_category_image_count', $this->Lang('title_category_image_count'));
        $this->smarty->assign('title_item_image_size_hero', $this->Lang('title_item_image_size_hero'));
        $this->smarty->assign('title_item_image_size_thumbnail', $this->Lang('title_item_image_size_thumbnail'));
        $this->smarty->assign('title_category_image_size_hero', $this->Lang('title_category_image_size_hero'));
        $this->smarty->assign('title_category_image_size_thumbnail', $this->Lang('title_category_image_size_thumbnail'));
        $this->smarty->assign('title_item_image_size_category', $this->Lang('title_item_image_size_category'));
        $this->smarty->assign('title_item_image_size_catalog', $this->Lang('title_item_image_size_catalog'));
        $this->smarty->assign('title_category_recurse',$this->Lang('title_category_recurse'));
        $this->smarty->assign('title_printable_sort_order',$this->Lang('title_printable_sort_order'));

        $this->smarty->assign('title_image_upload_path',$this->Lang('title_image_upload_path'));
        $this->smarty->assign('title_file_upload_path',$this->Lang('title_file_upload_path'));
        $this->smarty->assign('title_image_proc_path',$this->Lang('title_image_proc_path'));
        $this->smarty->assign('path_help',$this->Lang('path_help'));

        $number = array();
        for ($i=0;$i<16;$i++)
        	{
        	$number[$i]=$i;
        	}
        $this->smarty->assign('input_item_image_count', $this->CreateInputDropdown($id, 'item_image_count', $number, -1,  $this->GetPreference('item_image_count', '2')));
        $this->smarty->assign('input_category_image_count', $this->CreateInputDropdown($id, 'category_image_count', $number, -1,  $this->GetPreference('category_image_count', '1')));
        $this->smarty->assign('input_item_file_count', $this->CreateInputDropdown($id, 'item_file_count', $number, -1,  $this->GetPreference('item_file_count', '0')));
        $this->smarty->assign('input_item_file_types', $this->CreateInputText($id, 'item_file_types',$this->GetPreference('item_file_types', 'pdf,swf,flv,doc,odt,ods,xls')));

		
       $this->smarty->assign('input_image_upload_path', $this->CreateInputText($id, 'image_upload_path',$this->GetPreference('image_upload_path', $this->getAssetPath('s',true))));
       $this->smarty->assign('input_image_proc_path', $this->CreateInputText($id, 'image_proc_path',$this->GetPreference('image_proc_path', $this->getAssetPath('i',true))));
       $this->smarty->assign('input_file_upload_path', $this->CreateInputText($id, 'file_upload_path',$this->GetPreference('file_upload_path', $this->getAssetPath('f',true))));


		$recurse =  $this->GetPreference('category_recurse', 'mixed_one'); 
		$this->smarty->assign('input_category_recurse',
			'<input type="radio" name="'.$id.'category_recurse" value="items_all"' .
				($recurse == 'items_all'?' checked="checked"':'').' />'.
				$this->Lang('title_category_recurse_items_all').'<br />'.
			'<input type="radio" name="'.$id.'category_recurse" value="items_one"' .
				($recurse == 'items_one'?' checked="checked"':'').' />'.
				$this->Lang('title_category_recurse_items_one').'<br />'.
			'<input type="radio" name="'.$id.'category_recurse" value="categories_all"' .
				($recurse == 'categories_all'?' checked="checked"':'').' />'.
				$this->Lang('title_category_recurse_categories_all').'<br />'.
			'<input type="radio" name="'.$id.'category_recurse" value="categories_one"' .
				($recurse == 'categories_one'?' checked="checked"':'').' />'.
				$this->Lang('title_category_recurse_categories_one').'<br />'.
			'<input type="radio" name="'.$id.'category_recurse" value="mixed_all"' .
				($recurse == 'mixed_all'?' checked="checked"':'').' />'.
				$this->Lang('title_category_recurse_mixed_all').'<br />'.
			'<input type="radio" name="'.$id.'category_recurse" value="mixed_one"' .
				($recurse == 'mixed_one'?' checked="checked"':'').' />'.
				$this->Lang('title_category_recurse_mixed_one'));
        $this->smarty->assign('input_item_image_size_hero', $this->CreateInputText($id, 'item_image_size_hero', $this->GetPreference('item_image_size_hero', '400'), 10, 10));
        $this->smarty->assign('input_item_image_size_thumbnail', $this->CreateInputText($id, 'item_image_size_thumbnail', $this->GetPreference('item_image_size_thumbnail', '70'), 10, 10));
        $this->smarty->assign('input_category_image_size_hero', $this->CreateInputText($id, 'category_image_size_hero', $this->GetPreference('category_image_size_hero', '400'), 10, 10));
        $this->smarty->assign('input_category_image_size_thumbnail', $this->CreateInputText($id, 'category_image_size_thumbnail', $this->GetPreference('category_image_size_thumbnail', '90'), 10, 10));
        $this->smarty->assign('input_item_image_size_category', $this->CreateInputText($id, 'item_image_size_category', $this->GetPreference('item_image_size_category', '70'), 10, 10));
        $this->smarty->assign('input_item_image_size_catalog', $this->CreateInputText($id, 'item_image_size_catalog', $this->GetPreference('item_image_size_catalog', '100'), 10, 10));

$this->smarty->assign('input_show_missing_images',$this->CreateInputHidden($id,'show_missing','0').$this->CreateInputCheckbox($id, 'show_missing', 1, $this->GetPreference('show_missing','1')). $this->Lang('title_show_missing_images_long'));		

$this->smarty->assign('input_show_only_existing_images',$this->CreateInputHidden($id,'show_extant','0').$this->CreateInputCheckbox($id, 'show_extant', 1, $this->GetPreference('show_extant','1')). $this->Lang('title_show_only_existing_images_help'));		

$this->smarty->assign('input_flush_cats',$this->CreateInputHidden($id,'flush_cats','0').$this->CreateInputCheckbox($id, 'flush_cats', 1, $this->GetPreference('flush_cats','0')). $this->Lang('title_flush_cats_help'));		

        $this->smarty->assign('title_items_per_page',$this->Lang('title_items_per_page'));
        $this->smarty->assign('input_items_per_page',$this->CreateInputDropdown($id,
         		'items_per_page',
                array('1'=>'1','2'=>'2','3'=>'3','4'=>'4','5'=>'5','6'=>'6',
                	'7'=>'7','8'=>'8','9'=>'9','10'=>'10','11'=>'11','12'=>'12',
                	'13'=>'13','14'=>'14','15'=>'15','16'=>'16','17'=>'17','18'=>'18',
                	'19'=>'19','20'=>'20','24'=>'24','25'=>'25','30'=>'30','40'=>'40',
                	'50'=>'50', '1000'=>'1000'), -1, $this->GetPreference('category_items_per_page','10')));
        $this->smarty->assign('title_item_sort_order',$this->Lang('title_item_sort_order'));
		$this->smarty->assign('input_item_sort_order',$this->CreateInputDropdown($id,
		 	'item_sort_order',array($this->Lang('natural_order')=>'natural',
		 	$this->Lang('alpha_order')=>'alpha'), -1, $this->GetPreference('category_sort_order','natural')));
		$this->smarty->assign('input_printable_sort_order',$this->CreateInputDropdown($id,
		 	'printable_sort_order',array($this->Lang('natural_order')=>'natural',
		 	$this->Lang('alpha_order')=>'alpha'), -1, $this->GetPreference('printable_sort_order','natural')));

        $this->smarty->assign('message',isset($params['message'])?$params['message']:'');

        $this->smarty->assign('category', $this->Lang('manageprefs'));

        #Display template
        echo $this->ProcessTemplate('adminprefs.tpl');
?>
]]></data>
	</file>
	<file>
	  <filename>/action.all.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCQlpZiggIWRlZmluZWQoJ0NNU19WRVJTSU9OJykgKSBleGl0OwoJCWZvcmVhY2ggKCRwYXJhbXMgYXMgJGtleT0+JHZhbCkKCQkJewoJCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJGtleSwgJHBhcmFtc1ska2V5XSk7CgkJCX0KIAkJaWYgKCEgaXNzZXQoJHBhcmFtc1sncmVjdXJzZSddKSkKIAkJCXsKIAkJCSRwYXJhbXNbJ3JlY3Vyc2UnXSA9ICdpdGVtc19hbGwnOwogCQkgCX0KCiAJCWxpc3QoJGN1clBhZ2UsJGNhdGVnb3J5SXRlbXMpID0gJHRoaXMtPmdldENhdGFsb2dJdGVtc0xpc3QoJHBhcmFtcyk7CgogICAgICAgIGlmIChpc3NldCgkcGFyYW1zWydnbG9iYWxfc29ydCddKSkKIAkJCXsKCQkJaWYgKCRwYXJhbXNbJ2dsb2JhbF9zb3J0J10gPT0gJ2FscGhhJykKICAgICAgICAgICAgCXsKICAgICAgICAgICAgCXVzb3J0KCRjYXRlZ29yeUl0ZW1zLGFycmF5KCJDYXRhbG9nZXIiLCAiY29udGVudGFscGhhIikpOwogICAgICAgICAgICAJfQoJCQllbHNlIGlmICgkcGFyYW1zWydnbG9iYWxfc29ydCddID09ICdkYXRlJykKCQkJCXsKCSAgICAgICAgICAgIHVzb3J0KCRjYXRlZ29yeUl0ZW1zLGFycmF5KCJDYXRhbG9nZXIiLCAiY3JlYXRlZCIpKTsKCQkJCX0KCQkJZWxzZSBpZiAoJHBhcmFtc1snZ2xvYmFsX3NvcnQnXSA9PSAnbWRhdGUnKQoJCQkJewoJICAgICAgICAgICAgdXNvcnQoJGNhdGVnb3J5SXRlbXMsYXJyYXkoIkNhdGFsb2dlciIsICJjaHJvbm8iKSk7CgkJCQl9CgkJCX0KCQlpZiAoaXNzZXQoJHBhcmFtc1snZ2xvYmFsX3NvcnRfZGlyJ10pICYmICRwYXJhbXNbJ2dsb2JhbF9zb3J0X2RpciddPT0nYXNjJykKCQkJewoJCQkkY2F0ZWdvcnlJdGVtcyA9IGFycmF5X3JldmVyc2UoJGNhdGVnb3J5SXRlbXMpOwoJCQl9CgogICAgICAgICR0aGlzLT5zbWFydHktPmFzc2lnbignaXRlbXMnLCRjYXRlZ29yeUl0ZW1zKTsKCQkkdGhpcy0+c21hcnR5QmFzaWNzKCk7CgoJCWVjaG8gJHRoaXMtPlByb2Nlc3NUZW1wbGF0ZUZyb21EYXRhYmFzZSgkdGhpcy0+Z2V0VGVtcGxhdGVGcm9tQWxpYXMoJHBhcmFtc1snc3ViX3RlbXBsYXRlJ10pKTsKPz4K]]></data>
	</file>
	<file>
	  <filename>/action.compare.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCQlpZiggIWRlZmluZWQoJ0NNU19WRVJTSU9OJykgKSBleGl0OwoJCSRpdGVtbGlzdCA9IGFycmF5KCk7CgkJaWYgKGlzc2V0KCRfUkVRVUVTVFsnaXRlbXMnXSkpCgkJCXsKCQkJJHBhcmFtc1snaXRlbXMnXSA9ICRfUkVRVUVTVFsnaXRlbXMnXTsKCQkJfQoJCWlmICghIGlzX2FycmF5KCRwYXJhbXNbJ2l0ZW1zJ10pKQoJCQl7CgkJCSRwYXJhbXNbJ2l0ZW1zJ10gPSBleHBsb2RlKCcsJywkcGFyYW1zWydpdGVtcyddKTsJCgkJCX0KCQlmb3JlYWNoICgkcGFyYW1zWydpdGVtcyddIGFzICR0aGlzSXRlbSkKCQkJewoJCQkkcGFnZSA9ICR0aGlzLT5nZXRDYXRhbG9nSXRlbSgkdGhpc0l0ZW0pOwoJCQlhcnJheV9wdXNoKCRpdGVtbGlzdCwkcGFnZSk7CQoJCQl9CgkJaWYgKGNvdW50KCRpdGVtbGlzdCk+MCkKCQkJewoJCQkkdmFycyA9ICYkZ0Ntcy0+dmFyaWFibGVzOwoJCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2F0dHJsaXN0JywkdmFyc1snY2F0YWxvZ19hdHRycyddKTsKCQkJfQoJCWVsc2UKCQkJewoJCQkvLyBibGFuayBhcnJheQoJCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2F0dHJsaXN0JywkaXRlbWxpc3QpOwoJCQl9CgogCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2l0ZW1zJywkaXRlbWxpc3QpOwoJCSR0aGlzLT5zbWFydHlCYXNpY3MoKTsKCQllY2hvICR0aGlzLT5Qcm9jZXNzVGVtcGxhdGVGcm9tRGF0YWJhc2UoJHRoaXMtPmdldFRlbXBsYXRlRnJvbUFsaWFzKCRwYXJhbXNbJ3N1Yl90ZW1wbGF0ZSddKSk7Cj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCgkJaWYoICFkZWZpbmVkKCdDTVNfVkVSU0lPTicpICkgZXhpdDsNCgkJZm9yZWFjaCAoJHBhcmFtcyBhcyAka2V5PT4kdmFsKQ0KCQkJew0KCQkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCRrZXksICRwYXJhbXNbJGtleV0pOw0KCQkJfQ0KCQkkc2hvd01pc3NpbmcgPSAnXycuICR0aGlzLT5HZXRQcmVmZXJlbmNlKCdzaG93X21pc3NpbmcnLCcxJyk7DQoJCSRpbWFnZUFycmF5ID0gYXJyYXkoKTsNCgkJJGZpbGVBcnJheSA9IGFycmF5KCk7DQoJCSRmaWxlVXJsQXJyYXkgPSBhcnJheSgpOw0KCQkkZmlsZVR5cGVBcnJheSA9IGFycmF5KCk7DQoJCSRzcmNJbWdBcnJheSA9IGFycmF5KCk7DQoJCSR0aHVtYkFycmF5ID0gYXJyYXkoKTsNCiAgICAgICAgJGltZ2NvdW50ID0gJHRoaXMtPkdldFByZWZlcmVuY2UoJ2l0ZW1faW1hZ2VfY291bnQnLCAyKTsNCiAgICAgICAgJGZpbGVjb3VudCA9ICR0aGlzLT5HZXRQcmVmZXJlbmNlKCdpdGVtX2ZpbGVfY291bnQnLCAwKTsNCiAgICAgICAgJGZ1bGxTaXplID0gJHRoaXMtPkdldFByZWZlcmVuY2UoJ2l0ZW1faW1hZ2Vfc2l6ZV9oZXJvJywgJzQwMCcpOw0KICAgICAgICAkdGh1bWJTaXplID0gJHRoaXMtPkdldFByZWZlcmVuY2UoJ2l0ZW1faW1hZ2Vfc2l6ZV90aHVtYm5haWwnLCAnNzAnKTsNCiAgICAgICAgJHBydW5lbGlzdCA9ICgkdGhpcy0+R2V0UHJlZmVyZW5jZSgnc2hvd19leHRhbnQnLCcxJykgPT0gJzEnKTsNCgkJJGFjdHVhbGZpbGVjb3VudCA9IDA7DQoJCWlmICgkaW1nY291bnQgPiAwKQ0KCQkJew0KCSAgICAgICAgZm9yICgkaT0xOyRpPD0kaW1nY291bnQ7JGkrKykNCgkgICAgICAgICAgICB7DQoJICAgICAgICAgICAgaWYgKCEgJHBydW5lbGlzdCB8fCAkdGhpcy0+c3JjRXhpc3RzKCRwYXJhbXNbJ2FsaWFzJ10sICRpKSkNCgkgICAgICAgICAgICAJew0KCQkJCQlhcnJheV9wdXNoKCRpbWFnZUFycmF5LCANCgkJCQkJCSR0aGlzLT5pbWFnZVNwZWMoJHBhcmFtc1snYWxpYXMnXSwgJ2YnLCAkaSwgJGZ1bGxTaXplKSk7ICAgICAgICAgICAgDQoJCQkJCWFycmF5X3B1c2goJHRodW1iQXJyYXksDQoJCQkJCQkkdGhpcy0+aW1hZ2VTcGVjKCRwYXJhbXNbJ2FsaWFzJ10sICd0JywgJGksICR0aHVtYlNpemUpKTsNCgkJCQkJYXJyYXlfcHVzaCgkc3JjSW1nQXJyYXksDQoJCQkJCQkkdGhpcy0+c3JjSW1hZ2VTcGVjKCRwYXJhbXNbJ2FsaWFzJ10sICRpKSk7DQoJCQkJCSR0aGlzLT5zbWFydHktPmFzc2lnbignaW1hZ2VfJy4kaS4nX3VybCcsDQoJCQkJCQkkdGhpcy0+aW1hZ2VTcGVjKCRwYXJhbXNbJ2FsaWFzJ10sICdmJywgJGksICRmdWxsU2l6ZSkpOyAgICAgICAgICAgIA0KCQkJCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2ltYWdlX3RodW1iXycuJGkuJ191cmwnLA0KCQkJCQkJJHRoaXMtPmltYWdlU3BlYygkcGFyYW1zWydhbGlhcyddLCAndCcsICRpLCAkdGh1bWJTaXplKSk7DQoJCQkJCSR0aGlzLT5zbWFydHktPmFzc2lnbignc3JjX2ltYWdlXycuJGkuJ191cmwnLA0KCQkJCQkJJHRoaXMtPnNyY0ltYWdlU3BlYygkcGFyYW1zWydhbGlhcyddLCAkaSkpOw0KCQkJCQl9DQoJICAgICAgICAgICAgfQ0KCQkJfQ0KCQlpZiAoJGZpbGVjb3VudCA+IDApDQoJCQl7DQoJCQlsaXN0KCRmaWxlQXJyYXksJGZpbGVUeXBlQXJyYXkpID0gJHRoaXMtPmdldEZpbGVzKCRwYXJhbXNbJ2FsaWFzJ10pOw0KDQoJCQlmb3JlYWNoICgkZmlsZUFycmF5IGFzICRpPT4kdikNCgkJCSAgICB7DQoJCQkJCSR0aGlzLT5zbWFydHktPmFzc2lnbignZmlsZV8nLigkaSsxKS4nX3VybCcsDQoJCQkJCQkkZ0Ntcy0+Y29uZmlnWyd1cGxvYWRzX3VybCddLiR0aGlzLT5nZXRBc3NldFBhdGgoJ2YnKS4nLycuJHBhcmFtc1snYWxpYXMnXS4nLycuJGZpbGVBcnJheVskaV0pOw0KCQkJCQlhcnJheV9wdXNoKCRmaWxlVXJsQXJyYXksJGdDbXMtPmNvbmZpZ1sndXBsb2Fkc191cmwnXS4kdGhpcy0+Z2V0QXNzZXRQYXRoKCdmJykuJy8nLiRwYXJhbXNbJ2FsaWFzJ10uJy8nLiRmaWxlQXJyYXlbJGldKTsNCgkJCQkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdmaWxlXycuKCRpKzEpLidfbmFtZScsDQoJCQkJCQkkZmlsZUFycmF5WyRpXSk7DQoJCQkJCSR0aGlzLT5zbWFydHktPmFzc2lnbignZmlsZV8nLigkaSsxKS4nX2V4dCcsDQoJCQkJCQkkZmlsZVR5cGVBcnJheVskaV0pOw0KCQkJCQkkYWN0dWFsZmlsZWNvdW50ICs9IDE7DQoJCQkJfQ0KDQoJCQl9DQoJCSR0aGlzLT5zbWFydHktPmFzc2lnbignYXR0cmxpc3QnLCRwYXJhbXNbJ2F0dHJsaXN0J10pOw0KCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2ltYWdlX3VybF9hcnJheScsJGltYWdlQXJyYXkpOw0KCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2ZpbGVfdXJsX2FycmF5JywkZmlsZVVybEFycmF5KTsNCgkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdmaWxlX25hbWVfYXJyYXknLCRmaWxlQXJyYXkpOw0KCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2ZpbGVfZXh0X2FycmF5JywkZmlsZVR5cGVBcnJheSk7DQoJCSR0aGlzLT5zbWFydHktPmFzc2lnbignZmlsZV9jb3VudCcsJGFjdHVhbGZpbGVjb3VudCk7DQogICAgICAgICR0aGlzLT5zbWFydHktPmFzc2lnbignaW1hZ2VfdGh1bWJfdXJsX2FycmF5JywkdGh1bWJBcnJheSk7DQogICAgICAgICR0aGlzLT5zbWFydHktPmFzc2lnbignc3JjX2ltYWdlX3VybF9hcnJheScsJHNyY0ltZ0FycmF5KTsNCgkJJHRoaXMtPnNtYXJ0eUJhc2ljcygpOw0KCQkNCiAgICBlY2hvICR0aGlzLT5Qcm9jZXNzVGVtcGxhdGVGcm9tRGF0YWJhc2UoJ2NhdGFsb2dfJyAuICRwYXJhbXNbJ3N1Yl90ZW1wbGF0ZSddKTsNCiAgICAjIyB0aGUgbmV4dCBsaW5lcyB3ZXJlIGEgbWlzdGFrZS4uLiB0byBiZSByZW1vdmVkDQovLyAgICAkdG1wX1QgPSAkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlRnJvbURhdGFiYXNlKCdjYXRhbG9nXycgLiAkcGFyYW1zWydzdWJfdGVtcGxhdGUnXSk7DQovLyAgICBlY2hvICAkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlRnJvbURhdGEoJHRtcF9UKTsNCiAgICAjZWNobyAkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlRnJvbURhdGFiYXNlKCdjYXRhbG9nXycuJHBhcmFtc1snc3ViX3RlbXBsYXRlJ10pOwkNCj8+]]></data>
	</file>
	<file>
	  <filename>/action.defaultadmin.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.deletetempl.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYoICFkZWZpbmVkKCdDTVNfVkVSU0lPTicpICkgZXhpdDsKaWYgKCEgJHRoaXMtPkNoZWNrQWNjZXNzKCkpIGV4aXQ7CgoJCWlmICghIGVtcHR5KCRwYXJhbXNbJ3RlbXBsYXRlX2lkJ10pKQoJCQl7CgkJCSRxdWVyeSA9ICdERUxFVEUgRlJPTSAnLiBjbXNfZGJfcHJlZml4KCkuCgkJCQknbW9kdWxlX2NhdGFsb2dfdGVtcGxhdGUgV0hFUkUgaWQ9Pyc7CgkJCSRkYnJlc3VsdCA9ICRkYi0+RXhlY3V0ZSgkcXVlcnksYXJyYXkoJHBhcmFtc1sndGVtcGxhdGVfaWQnXSkpOwoJCQl9CgkJJHRoaXMtPkRlbGV0ZVRlbXBsYXRlKCdnbG9zc2FyeV8nLiRwYXJhbXNbJ3RlbXBsYXRlX2lkJ10pOwoKCQkkcGFyYW1zWydtZXNzYWdlJ10gPSAkdGhpcy0+TGFuZygndGVtcGxhdGVkZWxldGVkJyk7CgkJJHRoaXMtPkRvQWN0aW9uKCdkZWZhdWx0YWRtaW4nLCAkaWQsICRwYXJhbXMpOwoKPz4K]]></data>
	</file>
	<file>
	  <filename>/action.edittempl.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
if( !defined('CMS_VERSION') ) exit;
if (! $this->CheckAccess()) exit;

$this->initAdminNav($id, $params, $returnid);

$params['message']='';
if (isset($params['submit']) || isset($params['apply']))
{
	if (! empty($params['template_id']))
	{
		// updating a template
		$query = 'UPDATE '
              . cms_db_prefix()
              . 'module_catalog_template set title=?, template=?, type_id=? WHERE id=?';
              
		$dbresult = $db->Execute(
                              $query,
                              array(
                                      $params['title'],
                                      $params['templ'],
			                                $params['type_id'], 
                                      $params['template_id']
                                    )
                            );
                            
		$template_id = $params['template_id'];
	}
	else
	{
		// creating a template
		$query = 'INSERT INTO '
              . cms_db_prefix()
              . 'module_catalog_template (id, title, type_id, template) VALUES (?,?,?,?)';
              
		$template_id = $db->GenID(cms_db_prefix() . 'module_catalog_template_seq');
    
		$dbresult = $db->Execute(
                              $query,
                              array(
                                      $template_id,
                                      $params['title'],
                                      $params['type_id'],
                                      $params['templ']
                                    )
                            );
	}

	// force a cache clear?
	$this->DeleteTemplate('catalog_'.$template_id);
	// and recreate
	$this->SetTemplate('catalog_'.$template_id,$params['templ']);

	$params['message'] = $this->Lang('templateupdated');
	
	if (isset($params['submit']))
	{
		$this->DoAction('defaultadmin', $id, $params);
		return;
	}
}


$typeids = array();
$query = 'SELECT type_id, name FROM ' 
         . cms_db_prefix()
         . 'module_catalog_template_type';
         
$dbresult = $db->Execute($query);

while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $typeids[$row['name']] = $row['type_id'];
}

if (isset($params['template_id']))
{
	// editing a template
	$query = 'SELECT title, template, type_id FROM '
            . cms_db_prefix()
            . 'module_catalog_template WHERE id=?';
            
	$dbresult = $db->Execute( $query, array( $params['template_id']) );
  
	$row = $dbresult->FetchRow();
	$templateid = $params['template_id'];
	$title=$row['title'];
	$template=$row['template'];
	$type_id=$row['type_id'];
	$smarty->assign('op', $this->Lang('edittemplate'));
}
else
{
	// adding a template
	$templateid = '';
	$title = '';
	$template = '';
	$smarty->assign( 'op', $this->Lang('addtemplate') );
}

$query = "SELECT attribute, alias, type_id FROM " . cms_db_prefix() . "module_catalog_attr";
$dbresult = $db->Execute($query);
        
$attrs_title = '<h3>' . $this->Lang('title_item_template_vars') . '</h3>';
$attrs_array = array(
                      '{$title}',
                      '{$main_content}'
                    );
                    
$cattrs_title = '<h3>' . $this->Lang('title_cat_template_vars') . '</h3>';
$cattrs_array = array(
                        '{$title}',
                        '{$main_content}',
                        '{$prev}',
                        '{$prevurl}',
                        '{$navstr}',
                        '{$next}',
                        '{$nexturl}',
                        '{$items}'
                      );
                    

$pcattrs_title = '<h3>' . $this->Lang('title_catalog_template_vars') . '</h3>';
$pcattrs_array = array(
                        '{$items}',
                        '{$main_content}',
                        '{$attrlist}',
                        '{$root_url}',
                        '{$image_root}'
                      );        

$compattrs_title = '<h3>' . $this->Lang('title_compare_template_vars') . '</h3>';
$compattrs_array = array(
                          '{$items}',
                          '{$main_content}',
                          '{$attrlist}',
                          '{$root_url}',
                          '{$image_root}'
                        ); 

$feattrs_title = '<h3>' . $this->Lang('title_feature_template_vars') . '</h3>';
$feattrs_array = array(
                        '{$items}',
                        '{$main_content}',
                        '{$attrlist}',
                        '{$root_url}',
                        '{$image_root}'
                      );

while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $safeattr = strtolower(preg_replace('/\W/','',$row['attribute']));
  
  if ($row['type_id'] == CTEMPLATE_ITEM)
  {
    $attrs_array[] = '{$' . $safeattr . '}';

		if ($row['alias'] != '')
		{
			$attrs_array[] = '{$' . $row['alias'] . '}';
		}
  }
  else if ($row['type_id'] == CTEMPLATE_CATEGORY)
  {
		$cattrs_array[] = '{$' . $safeattr . '}';
		
    if ($row['alias'] != '')
		{
			$cattrs_array[] = '{$' . $row['alias'] . '}';
		}
	}
  else if ($row['type_id'] == CTEMPLATE_CATALOG)
  {
		$pcattrs_array[] = '{$' . $safeattr . '}';
		if ($row['alias'] != '')
		{
			$pcattrs_array[] = '{$' . $row['alias'] . '}';
		}
	}
}
          
$image_count = $this->GetPreference('item_image_count', '1');

for ($i=1;$i<=$image_count;$i++)
{
  $attrs_array[] = '{$image_' . $i . '_url}';
  $attrs_array[] = '{$image_thumb_' . $i . '_url}';
}

$attrs_array[] = '{$image_url_array}';
$attrs_array[] = '{$src_image_url_array}';
$attrs_array[] = '{$image_thumb_url_array}';

$file_count = $this->GetPreference('item_file_count', 0);

for ($i=1; $i <= $file_count; $i++)
{
  $attrs_array[] = '{$file_count}, {$file_'.$i.'_name}, {$file_'.$i.'_url}, {$file_'.$i;
  $attrs_array[] = '_ext}, ';
}
    
$attrs_array[] = '{$file_url_array}';
$attrs_array[] = '{$file_name_array}';
$attrs_array[] = '{$file_ext_array}';
$attrs_array[] = '{$root_url}';
$attrs_array[] = '{$image_root}';

$attrs = $attrs_title . '<p><strong>' . implode(', ', $attrs_array). '</strong></p>';

$image_count = $this->GetPreference('category_image_count', '1');

for ($i=1;$i<=$image_count;$i++)
{
  $cattrs_array[] = '{$image_' . $i . '_url}';
  $cattrs_array[] = '{$image_thumb_' . $i . '_url}';
  $cattrs_array[] = '{$src_image_' . $i . '_url}';
}

$cattrs_array[] = '{$image_url_array}, ';
$cattrs_array[] = '{$src_image_url_array}, ';
$cattrs_array[] = '{$image_thumb_url_array}';
$cattrs_array[] = '{$root_url}';
$cattrs_array[] = '{$image_root}';

$cattrs = $cattrs_title . '<p><strong>' . implode(', ', $cattrs_array). '</strong></p>';

$cattrs_it_title = '<h3>$items array contents:</h3>';
$cattrs_it_array = array(
                          '$items[].title',
                          '$items[].link',
                          '$items[].image',
                          '$items[].cat',
                          '$items[].<i>attribute_name</i>',
                          '$items[].<i>attribute_alias</i>'
                        );
                        
$cattrs .= $cattrs_it_title . '<p><strong>' . implode(', ', $cattrs_it_array) . '</strong></p>';

$pcattrs = $pcattrs_title . '<p><strong>' . implode(', ', $pcattrs_array). '</strong></p>';

$pcattrs .= '<h3>$items array contents:</h3>';
$pcattrs .= '$items[].title, $items[].link, $items[].image, $items[].cat, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
$pcattrs .= '<h3>$attrlist array contents:</h3>';
$pcattrs .= '$attrlist[]->attr, $attrlist[]->safe';

$compattrs = $compattrs_title . '<p><strong>' . implode(', ', $compattrs_array). '</strong></p>';
$compattrs .= '<h3>$items array contents:</h3>';
$compattrs .= '$items[].title, $items[].link, $items[].image, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
$compattrs .= '<h3>$attrlist array contents:</h3>';
$compattrs .= '$attrlist[]->attr, $attrlist[]->safe';

$feattrs = $feattrs_title . '<p><strong>' . implode(', ', $feattrs_array). '</strong></p>';
$feattrs .= '<h3>$items array contents:</h3>';
$feattrs .= '$items[].title, $items[].link, $items[].image, $items[].cat, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';

    
$smarty->assign('startform', $this->CreateFormStart($id, 'edittempl', $returnid));
$smarty->assign('endform', $this->CreateFormEnd());
$smarty->assign('hidden',$this->CreateInputHidden($id, 'template_id', $templateid));
$smarty->assign('title_title',$this->Lang('title_title'));
$smarty->assign('title_template',$this->Lang('title_template'));
$smarty->assign('title_template_type',$this->Lang('title_template_type'));
$smarty->assign('title_avail_attrs',$this->Lang('title_avail_attrs'));

if (isset($type_id))
{
  if ($type_id == CTEMPLATE_ITEM)
	{
	  $smarty->assign('avail_attrs',$attrs);
	}
  else if ($type_id == CTEMPLATE_CATEGORY)
	{
	  $smarty->assign('avail_attrs',$cattrs);		
	}
  else if ($type_id == CTEMPLATE_CATALOG)
	{
	  $smarty->assign('avail_attrs',$pcattrs);		
	}
  else if ($type_id == CTEMPLATE_COMPARISON)
	{
	  $smarty->assign('avail_attrs',$compattrs);		
	}
  else if ($type_id == CTEMPLATE_FEATURE)
	{
	  $smarty->assign('avail_attrs',$feattrs);		
	}
}
else
{
  $smarty->assign('avail_attrs', $attrs . ', ' . $cattrs.', ' . $feattrs);
}

//$smarty->assign('title_avail_imattrs',$this->Lang('title_avail_imattrs'));		
//$smarty->assign('avail_imattrs',$imattrs);
$smarty->assign('input_template_type',$this->CreateInputDropdown($id, 'type_id', $typeids, -1, isset($type_id)?$type_id:''));

$smarty->assign('message',$params['message']);
$smarty->assign('input_title',$this->CreateInputText($id, 'title', $title, 20, 255));
$smarty->assign('input_template',$this->CreateTextArea(false, $id, $template, 'templ'));

$smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', lang('submit')));
$smarty->assign('apply', $this->CreateInputSubmit($id, 'apply', lang('apply')));
echo $this->ProcessTemplate('edittemplate.tpl');
?>]]></data>
	</file>
	<file>
	  <filename>/action.globalops.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.globalsubmit.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.image.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.random.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCQlpZiggIWRlZmluZWQoJ0NNU19WRVJTSU9OJykgKSBleGl0OwoJCWZvcmVhY2ggKCRwYXJhbXMgYXMgJGtleT0+JHZhbCkKCQkJewoJCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJGtleSwgJHBhcmFtc1ska2V5XSk7CgkJCX0KIAkJaWYgKCEgaXNzZXQoJHBhcmFtc1sncmVjdXJzZSddKSkKIAkJCXsKIAkJCSRwYXJhbXNbJ3JlY3Vyc2UnXSA9ICdpdGVtc19hbGwnOwogCQkgCX0KCgkJCSRsaXN0ID0gJHRoaXMtPmdldENhdGFsb2dJdGVtc0lETGlzdCgkcGFyYW1zKTsKCiAgICAgICAgJGNvdW50ID0gbWluKGNvdW50KCRsaXN0KSwkcGFyYW1zWydjb3VudCddKTsKICAgICAgICAkdGhpc1VybCA9ICRfU0VSVkVSWydSRVFVRVNUX1VSSSddOwogICAgICAgICR0aGlzVXJsID0gcHJlZ19yZXBsYWNlKCcvKFw/KSooXCYpKnN0YXJ0PVxkKy8nLCcnLCR0aGlzVXJsKTsKICAgICAgICBpZiAoJGNvdW50ID09IDApCiAgICAgICAgCXsKICAgICAgICAJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdpdGVtcycsYXJyYXkoKSk7CiAgICAgICAgCX0KICAgICAgICBlbHNlCiAgICAgICAgCXsKICAgICAgICAJJGNhdGVnb3J5SXRlbUtleXMgPSBhcnJheV9yYW5kKCRsaXN0LCAkY291bnQpOwoJCQkJCWlmICghaXNfYXJyYXkoJGNhdGVnb3J5SXRlbUtleXMpKQoJCQkJCQl7CgkJCQkJCSRjYXRlZ29yeUl0ZW1LZXlzID0gYXJyYXkoJGNhdGVnb3J5SXRlbUtleXMpOwoJCQkJCQl9CiAgICAgICAgCSRjYXRUbXAgPSBhcnJheSgpOwogICAgICAgIAlmb3JlYWNoKCRjYXRlZ29yeUl0ZW1LZXlzIGFzICR0aGlzS2V5KQogICAgICAgIAkJewoJCQkJCQkkbm9kZSA9ICR0aGlzLT5nZXRDYXRhbG9nSXRlbUJ5SWQoJGxpc3RbJHRoaXNLZXldKTsKICAgICAgICAJCWFycmF5X3B1c2goJGNhdFRtcCwkbm9kZSk7CiAgICAgICAgCQl9CiAgICAgICAgCSR0aGlzLT5zbWFydHktPmFzc2lnbignaXRlbXMnLCRjYXRUbXApOwogICAgICAgIAl9CiAgICAgICAgCiAJCSR0aGlzLT5zbWFydHlCYXNpY3MoKTsKCQllY2hvICR0aGlzLT5Qcm9jZXNzVGVtcGxhdGVGcm9tRGF0YWJhc2UoJHRoaXMtPmdldFRlbXBsYXRlRnJvbUFsaWFzKCRwYXJhbXNbJ3N1Yl90ZW1wbGF0ZSddKSk7Cj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.recent.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCQlpZiggIWRlZmluZWQoJ0NNU19WRVJTSU9OJykgKSBleGl0OwoJCWZvcmVhY2ggKCRwYXJhbXMgYXMgJGtleT0+JHZhbCkKCQkJewoJCQkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJGtleSwgJHBhcmFtc1ska2V5XSk7CgkJCX0KIAkJaWYgKCEgaXNzZXQoJHBhcmFtc1sncmVjdXJzZSddKSkKIAkJCXsKIAkJCSRwYXJhbXNbJ3JlY3Vyc2UnXSA9ICdpdGVtc19hbGwnOwogCQkgCX0KCQkKIAkJbGlzdCgkY3VyUGFnZSwkY2F0ZWdvcnlJdGVtcykgPSAkdGhpcy0+Z2V0Q2F0YWxvZ0l0ZW1zTGlzdCgkcGFyYW1zKTsKCgkJaWYgKCFpc3NldCgkcGFyYW1zWydnbG9iYWxfc29ydCddKSB8fCAkcGFyYW1zWydnbG9iYWxfc29ydCddPT0nZGF0ZScpCgkJCXsKICAgICAgICAJdXNvcnQoJGNhdGVnb3J5SXRlbXMsYXJyYXkoIkNhdGFsb2dlciIsICJjcmVhdGVkIikpOwogICAgICAgIAl9CgkJZWxzZQoJCQl7CgkJICAgIHVzb3J0KCRjYXRlZ29yeUl0ZW1zLGFycmF5KCJDYXRhbG9nZXIiLCAiY2hyb25vIikpOwoJCQl9CgoJCWlmIChpc3NldCgkcGFyYW1zWydnbG9iYWxfc29ydF9kaXInXSkgJiYgJHBhcmFtc1snZ2xvYmFsX3NvcnRfZGlyJ109PSdhc2MnKQoJCQl7CgkJCSRjYXRlZ29yeUl0ZW1zID0gYXJyYXlfcmV2ZXJzZSgkY2F0ZWdvcnlJdGVtcyk7CgkJCX0KCQkJCiAgICAgICAgJGNvdW50ID0gY291bnQoJGNhdGVnb3J5SXRlbXMpOwogICAgICAgICRzdGFydCA9IDA7CiAgICAgICAgJGVuZCA9IG1pbigkY291bnQsJHBhcmFtc1snY291bnQnXSk7CiAgICAgICAgJHRoaXNVcmwgPSAkX1NFUlZFUlsnUkVRVUVTVF9VUkknXTsKICAgICAgICAkdGhpc1VybCA9IHByZWdfcmVwbGFjZSgnLyhcPykqKFwmKSpzdGFydD1cZCsvJywnJywkdGhpc1VybCk7CiAgICAgICAgJGNhdGVnb3J5SXRlbXMgPSBhcnJheV9zcGxpY2UoJGNhdGVnb3J5SXRlbXMsICRzdGFydCwgJGVuZCk7CiAgICAgICAgJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdpdGVtcycsJGNhdGVnb3J5SXRlbXMpOwogCQkKCQkkdGhpcy0+c21hcnR5QmFzaWNzKCk7CgkJZWNobyAkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlRnJvbURhdGFiYXNlKCR0aGlzLT5nZXRUZW1wbGF0ZUZyb21BbGlhcygkcGFyYW1zWydzdWJfdGVtcGxhdGUnXSkpOwo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/action.reimport.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYoICFkZWZpbmVkKCdDTVNfVkVSU0lPTicpICkgZXhpdDsKaWYgKCEgJHRoaXMtPkNoZWNrQWNjZXNzKCkpIGV4aXQ7CgkKCQkkdGhpcy0+aW1wb3J0U2FtcGxlVGVtcGxhdGVzKCk7CgkJJHBhcmFtc1snbWVzc2FnZSddID0gJHRoaXMtPkxhbmcoJ3JlaW1wb3J0ZWQnKTsKCQkkdGhpcy0+RG9BY3Rpb24oJ2RlZmF1bHRhZG1pbicsICRpZCwgJHBhcmFtcyk7Cgo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/action.submitattrs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
if( !defined('CMS_VERSION') ) exit;
if( !$this->CheckAccess() ) exit;

$contentops = cmsms()->GetContentOperations();

$types = array(
                 '',
                 'catalogitem',
                 'catalogcategory',
                 'catalogprintable'
              );

foreach($params as $thisParamKey => $thisParamValue)
{
  if( substr($thisParamKey, 0, 4) == 'attr') # is attr_*_*_*   (JM)
  {
    # at this point $thisParamKey should hold something like 'attr_attrType_attrNum' whatever they may represent... (JM)
    list($attr, $attrType, $attrNum) = explode('_', $thisParamKey);
    $thisalias = $params['alias_' . $attrType . '_' . $attrNum];

    if( 
        (strlen($thisParamValue) > 0) 
        && (!isset($params['delete_' . $attrType . '_' . $attrNum])
        || $params['delete_' . $attrType . '_' . $attrNum] == '0') )
    {
      // new attribute or updating old?
      if( isset($params['old_' . $attrType . '_' . $attrNum]) )
      {
        // it's an old record

        // get old value to update content table
        $query = 'SELECT attribute,alias FROM ' . cms_db_prefix() . 'module_catalog_attr where id=?';
        $r = $db->GetArray( $query, array ($params['old_' . $attrType . '_' . $attrNum]) );  
        //$r = $db->GetOne($query, array ($params['old_' . $attrType . '_' . $attrNum]));  
//                   
//        if($r)
//        {
//          $oldval = $r['attribute'];
//          $oldalias = $r['alias'];
//        }
        if($r)
        {
          $oldval = isset($r['attribute']) ? $r['attribute'] : '';
          $oldval = isset($r['alias']) ? $r['alias'] : '';
        }
        //$oldval = $db->GetOne($query, array ($params['old_' . $attrType . '_' . $attrNum]));


        // write new value
        $query =  'UPDATE ' 
                  . cms_db_prefix()
                  . 'module_catalog_attr SET attribute=?, alias=?, order_by=?, defaultval=?, length=?, select_values=?, field_type=? where id=?';
                  
        $dbresult = $db->Execute($query, array
        (
           $thisParamValue,
           $params['alias_'           . $attrType . '_' . $attrNum],
           $params['orderby_'         . $attrType . '_' . $attrNum],
           $params['default_'         . $attrType . '_' . $attrNum],
           $params['len_'             . $attrType . '_' . $attrNum],
           $params['select_values_'   . $attrType . '_' . $attrNum],
           $params['field_type_'      . $attrType . '_' . $attrNum],
           $params['old_'             . $attrType . '_' . $attrNum]
        ));

        if ( $dbresult === false )
        {
          return $this->displayError( $db->ErrorMsg() );
        }

        // update content table
        if($oldval != $thisParamValue)
        {
          $query =  'SELECT c.content_id from ' 
                    . cms_db_prefix() 
                    . 'content c, ' 
                    . cms_db_prefix()
                    . 'content_props p where c.type=? and p.prop_name=? and c.content_id=p.content_id';
          
          $dbresult = $db->Execute(
                                    $query, 
                                    array(
                                           $types[$attrType],
                                           $oldval
                                          )
                                  );
                                                
          $clist = array ();

          while( $dbresult !== false && $row = $dbresult->FetchRow() )
          {
            $clist[] = $row['content_id'];
          }

          if ( count($clist) > 0 ) # if our list isn't empty
          {
            foreach( $clist as $one )
            {
              $obj = $contentops->LoadContentFromId($one, TRUE);
              $obj->UpdatePropertyName($oldalias, $thisalias);
              $obj->save();
            }
          }
        }
      }
      else # it's a new attribute
      {
        $new_id = $db->GenID(cms_db_prefix() . 'module_catalog_attr_seq');
        
        $query =  'INSERT INTO ' 
                  . cms_db_prefix()
                  . 'module_catalog_attr (id,type_id,attribute,alias,defaultval,length,order_by,select_values,field_type) VALUES (?,?,?,?,?,?,?,?,?)';
        
        $dbresult = $db->Execute($query, array
        (
           $new_id,
           $attrType,
           $thisParamValue,
           $params['alias_' . $attrType . '_' . $attrNum],
           $params['default_' . $attrType . '_' . $attrNum],
           $params['len_' . $attrType . '_' . $attrNum],
           $params['orderby_' . $attrType . '_' . $attrNum],
           $params['select_values_' . $attrType . '_' . $attrNum],
           $params['field_type_' . $attrType . '_' . $attrNum]
        ));

        if ( $dbresult === false )
        {
          return $this->displayError($db->ErrorMsg());
        }

        // update content table for existent records!
        if( !empty($params['default_' . $attrType . '_' . $attrNum]) )
        {
          $query = 'SELECT content_id' . cms_db_prefix() . 'content where type=?';
          $dbresult = $db->Execute($query, array ($types[$attrType]));
          $clist = array ();

          while( $dbresult !== false && $row = $dbresult->FetchRow() )
          {
            $clist[] = $row['content_id'];
          }

          if ( count($clist) > 0 )
          {
            foreach( $clist as $one )
            {
              $obj = $contentops->LoadContentFromId($one, TRUE);
              $obj->AddProperty($thisalias);
              $obj->save();
            }
          }
        }
      }
    }
    elseif( isset($params['delete_' . $attrType . '_' . $attrNum])
        && $params['delete_' . $attrType . '_' . $attrNum] == '1' )
    // this is a delete operation (JM)
    {
      // delete from Content Table as well!
      $query = 'SELECT attribute FROM ' . cms_db_prefix() . 'module_catalog_attr where id=?';
      $did = $db->GetOne($query, array ($params['old_' . $attrType . '_' . $attrNum]));

      $query = 'SELECT content_id from ' . cms_db_prefix() . 'content where type=?';
      $dbresult = $db->Execute($query, array ($types[$attrType]));
      $clist = array ();

      while( $dbresult !== false && $row = $dbresult->FetchRow() )
      {
        $clist[] = $row['content_id'];
      }

      if ( count($clist) > 0 )
      {
        foreach( $clist as $one )
        {
          $obj = $contentops->LoadContentFromId($one, TRUE);
          $obj->DeleteProperty($thisParamValue);
          $obj->save();
        }
      }

      // handle deletes explicitly now.
      $query = 'DELETE FROM ' . cms_db_prefix() . 'module_catalog_attr where id=?';
      $dbresult = $db->Execute($query, array ($params['old_' . $attrType . '_' . $attrNum]));
    }
  }
}

$gCms = cmsms();
//$gCms->clear_cached_files();   --> apparently an illegal op too.... (JM) Unless it only clears own cached files...
$params['module_message'] = $this->Lang('attrsupdated');
$this->DoAction('adminattrs', $id, $params);
?>]]></data>
	</file>
	<file>
	  <filename>/action.submitprefs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.variable.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCQlpZiggIWRlZmluZWQoJ0NNU19WRVJTSU9OJykgKSBleGl0OwoJCWlmICghaXNzZXQoJHBhcmFtc1snbmFtZSddKSkKCQkJewoJCQllY2hvICc8IS0tIHBsZWFzZSBzcGVjaWZ5IGEgQ2F0YWxvZ2VyIHZhcmlhYmxlIG5hbWUgdG8gcmV0cmlldmUgLS0+JzsKCQkJcmV0dXJuOwoJCQl9CgoJCQkkZm91bmQgPSBmYWxzZTsKCQkJJGdDbXMgPSBjbXNtcygpOwoJCQkkY29udGVudG9wcyA9ICRnQ21zLT5HZXRDb250ZW50T3BlcmF0aW9ucygpOwoJCQkkY29udGVudF9vYmogPSAkY29udGVudG9wcy0+Z2V0Q29udGVudE9iamVjdCgpOwkJCQoJCWlmICgkY29udGVudF9vYmopCgkJCXsKCQkJaWYgKCRjb250ZW50X29iai0+VHlwZSgpICE9ICdjYXRhbG9naXRlbScgJiYgJGNvbnRlbnRfb2JqLT5UeXBlKCkgIT0gJ2NhdGFsb2djYXRlZ29yeScgJiYgJGNvbnRlbnRfb2JqLT5UeXBlKCkgIT0gJ2NhdGFsb2dwcmludGFibGUnKQoJCQkJewoJCQkJcmV0dXJuOwoJCQkJfQoJCQkkYXR0cnMgPSAkY29udGVudF9vYmotPmdldEF0dHJzKCk7CgkJCSR0ZXN0YXR0ciA9IHN0cnRvbG93ZXIoJHBhcmFtc1snbmFtZSddKTsKCQkJCgkJCWZvcmVhY2ggKCRhdHRycyBhcyAkdGhpc0F0dHIpCgkJCQl7CgkJCQkkY29tcGF0dHIgPSBzdHJ0b2xvd2VyKCR0aGlzQXR0ci0+YXR0cik7CgkJCQlpZiAoJGNvbXBhdHRyID09ICR0ZXN0YXR0cikKCQkJCQl7CgkJCQkJJHRtcCA9ICRjb250ZW50X29iai0+R2V0UHJvcGVydHlWYWx1ZSgkdGhpc0F0dHItPmF0dHIpOwoJCQkJCSRmb3VuZCA9IHRydWU7CgkJCQkJfQoJCQkJZWxzZSBpZiAoJHRoaXNBdHRyLT5hbGlhcyA9PSAkdGVzdGF0dHIpCgkJCQkJewoJCQkJCSR0bXAgPSAkY29udGVudF9vYmotPkdldFByb3BlcnR5VmFsdWUoJHRoaXNBdHRyLT5hbGlhcyk7CgkJCQkJJGZvdW5kID0gdHJ1ZTsKCQkJCQl9CgkJCQllbHNlCgkJCQkJewoJCQkJCSRzYWZlYXR0ciA9IHN0cnRvbG93ZXIocHJlZ19yZXBsYWNlKCcvXFcvJywnJywgJHBhcmFtc1snbmFtZSddKSk7CgkJCQkJaWYgKCRjb21wYXR0ciA9PSAgJHNhZmVhdHRyIHx8ICR0aGlzQXR0ci0+YWxpYXMgPT0gJHNhZmVhdHRyKQoJCQkJCQl7CgkJCQkJCSR0bXAgPSAkY29udGVudF9vYmotPkdldFByb3BlcnR5VmFsdWUoJHNhZmVhdHRyKTsKCQkJCQkJJGZvdW5kID0gdHJ1ZTsKCQkJCQkJfQoJCQkJCX0KCQkJCX0KCQkJfQoKCQlpZiAoISAkZm91bmQpCgkJCXsKCQkJaWYgKGlzc2V0KCRwYXJhbXNbJ2RlZmF1bHQnXSkpCgkJCQl7CgkJCQkkdG1wID0gJHBhcmFtc1snZGVmYXVsdCddOwoJCQkJfQoJCQllbHNlCgkJCQl7CgkJCQkkdG1wID0gJyc7CgkJCQl9CgkJCX0KCQllY2hvICR0bXA7Cj8+]]></data>
	</file>
	<file>
	  <filename>/admin_default_new.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
if ( !is_object( cmsms() ) ) exit;

$this->initAdminNav($id, $params, $returnid);

# now for the templates

# Items 

$ItemPageArray = array();
 
$query = "SELECT id, title FROM "
         . cms_db_prefix()
         . "module_catalog_template WHERE type_id = 1 ORDER by title";
      
$dbresult = $db->Execute($query);

while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $onerow = new stdClass();

  $onerow->id = $row['id'];
  $onerow->type = $row['type'];
  $onerow->title = $this->CreateLink(
                                      $id, 
                                      'edittempl', 
                                      $returnid,
                                      $row['title'], 
                                      array('template_id' => $row['id'], 'type_id' => 1)
                                    );
  
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/edit.gif',
                                                        $this->Lang('edit'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );

  $onerow->editlink = $this->CreateLink(
                                          $id, 
                                          'edittempl', 
                                          $returnid,
                                          $Icon,
                                          array('template_id' => $row['id'], 'type_id' => 1)
                                        );
                                        
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/delete.gif',
                                                        $this->Lang('delete'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );
      
  $onerow->deletelink = $this->CreateLink(
                                            $id, 
                                            'deletetempl', 
                                            $returnid,
                                            $Icon,
                                            array('template_id' => $row['id']), 
                                            $this->Lang('areyousure','Template')
                                          );
                                          
  array_push($ItemPageArray, $onerow);

}


# Categories

$CategoryPageArray = array();
 
$query = "SELECT id, title FROM "
         . cms_db_prefix()
         . "module_catalog_template WHERE type_id = 2 ORDER by title";
      
$dbresult = $db->Execute($query);

while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $onerow = new stdClass();

  $onerow->id = $row['id'];
  $onerow->type = $row['type'];
  $onerow->title = $this->CreateLink(
                                      $id, 
                                      'edittempl', 
                                      $returnid,
                                      $row['title'], 
                                      array('template_id' => $row['id'], 'type_id' => 2)
                                    );
  
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/edit.gif',
                                                        $this->Lang('edit'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );

  $onerow->editlink = $this->CreateLink(
                                          $id, 
                                          'edittempl', 
                                          $returnid,
                                          $Icon,
                                          array('template_id' => $row['id'], 'type_id' => 2)
                                        );
                                        
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/delete.gif',
                                                        $this->Lang('delete'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );
      
  $onerow->deletelink = $this->CreateLink(
                                            $id, 
                                            'deletetempl', 
                                            $returnid,
                                            $Icon,
                                            array('template_id'=>$row['id']), 
                                            $this->Lang('areyousure','Template')
                                          );
                                          
  array_push($CategoryPageArray, $onerow);

}

# Printable Catalog

$PrintableCatalogArray = array();
 
$query = "SELECT id, title FROM "
         . cms_db_prefix()
         . "module_catalog_template WHERE type_id = 3 ORDER by title";
      
$dbresult = $db->Execute($query);

while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $onerow = new stdClass();

  $onerow->id = $row['id'];
  $onerow->type = $row['type'];
  $onerow->title = $this->CreateLink(
                                      $id, 
                                      'edittempl', 
                                      $returnid,
                                      $row['title'], 
                                      array('template_id' => $row['id'], 'type_id' => 3)
                                    );
  
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/edit.gif',
                                                        $this->Lang('edit'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );

  $onerow->editlink = $this->CreateLink(
                                          $id, 
                                          'edittempl', 
                                          $returnid,
                                          $Icon,
                                          array('template_id' => $row['id'], 'type_id' => 3)
                                        );
                                        
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/delete.gif',
                                                        $this->Lang('delete'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );
      
  $onerow->deletelink = $this->CreateLink(
                                            $id,  
                                            'deletetempl', 
                                            $returnid,
                                            $Icon,
                                            array('template_id'=>$row['id']), 
                                            $this->Lang('areyousure','Template')
                                          );
                                          
  array_push($PrintableCatalogArray, $onerow);

}


# Item Comparison

$ItemComparisonArray = array();
 
$query = "SELECT id, title FROM "
         . cms_db_prefix()
         . "module_catalog_template WHERE type_id = 4 ORDER by title";
      
$dbresult = $db->Execute($query);

while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $onerow = new stdClass();

  $onerow->id = $row['id'];
  $onerow->type = $row['type'];
  $onerow->title = $this->CreateLink(
                                      $id,  
                                      'edittempl', 
                                      $returnid,
                                      $row['title'], 
                                      array('template_id' => $row['id'], 'type_id' => 4)
                                    );
  
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/edit.gif',
                                                        $this->Lang('edit'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );

  $onerow->editlink = $this->CreateLink(
                                          $id, 
                                          'edittempl', 
                                          $returnid,
                                          $Icon,
                                          array('template_id' => $row['id'], 'type_id' => 4)
                                        );
                                        
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/delete.gif',
                                                        $this->Lang('delete'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );
      
  $onerow->deletelink = $this->CreateLink(
                                            $id, 
                                            'deletetempl', 
                                            $returnid,
                                            $Icon,
                                            array('template_id'=>$row['id']), 
                                            $this->Lang('areyousure','Template')
                                          );
                                          
  array_push($ItemComparisonArray, $onerow);

}

# Feature List

$FeatureListArray = array();
 
$query = "SELECT id, title FROM "
         . cms_db_prefix()
         . "module_catalog_template WHERE type_id = 5 ORDER by title";
      
$dbresult = $db->Execute($query);

while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $onerow = new stdClass();

  $onerow->id = $row['id'];
  $onerow->type = $row['type'];
  $onerow->title = $this->CreateLink(
                                      $id, 
                                      'edittempl', 
                                      $returnid,
                                      $row['title'], 
                                      array('template_id' => $row['id'], 'type_id' => 5)
                                    );
  
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/edit.gif',
                                                        $this->Lang('edit'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );

  $onerow->editlink = $this->CreateLink(
                                          $id,
                                          'edittempl', 
                                          $returnid,
                                          $Icon,
                                          array('template_id' => $row['id'], 'type_id' => 5)
                                        );
                                        
  $Icon = $gCms->variables['admintheme']->DisplayImage(
                                                        'icons/system/delete.gif',
                                                        $this->Lang('delete'),
                                                        '',
                                                        '',
                                                        'systemicon'
                                                       );
      
  $onerow->deletelink = $this->CreateLink(
                                            $id,  
                                            'deletetempl', 
                                            $returnid,
                                            $Icon,
                                            array('template_id'=>$row['id']), 
                                            $this->Lang('areyousure','Template')
                                          );
                                          
  array_push($FeatureListArray, $onerow);

}

$current_tab = isset($params['tab']) ? $params['tab'] : 'item_page_templates';

/**
* Smarty stuff
*/

$tab_headers = $this->StartTabHeaders()
               . $this->SetTabHeader('item_page_templates',         $this->Lang('title_item_page_templates_tab'), $current_tab == 'item_page_templates')
               . $this->SetTabHeader('category_page_templates',     $this->Lang('title_category_page_templates_tab'), $current_tab == 'category_page_templates')
               . $this->SetTabHeader('printable_catalog_templates', $this->Lang('title_printable_catalog_templates_tab'), $current_tab == 'printable_catalog_templates')
               . $this->SetTabHeader('item_comparison_templates',   $this->Lang('title_item_comparison_templates_tab'), $current_tab == 'item_comparison_templates')
               . $this->SetTabHeader('feature_list_templates',      $this->Lang('title_feature_list_templates_tab'), $current_tab == 'feature_list_templates')
               . $this->EndTabHeaders()
               . $this->StartTabContent();

$smarty->assign('tab_headers', $tab_headers);
                      
$smarty->assign('end_tab', $this->EndTab());

$smarty->assign('tab_footers', $this->EndTabContent());

$smarty->assign('start_item_page_templates_tab', $this->StartTab('item_page_templates'));
$smarty->assign('start_category_page_templates_tab', $this->StartTab('category_page_templates'));
$smarty->assign('start_printable_catalog_templates_tab', $this->StartTab('printable_catalog_templates'));
$smarty->assign('start_item_comparison_templates_tab', $this->StartTab('item_comparison_templates'));
$smarty->assign('start_feature_list_templates_tab', $this->StartTab('feature_list_templates'));

$smarty->assign('PageItems', $ItemPageArray);
$smarty->assign('PageCategories', $CategoryPageArray);
$smarty->assign('PrintableCatalogs', $PrintableCatalogArray);
$smarty->assign('ItemComparisons', $ItemComparisonArray);
$smarty->assign('FeatureLists', $FeatureListArray);

// Content defines and Form stuff for the admin
$smarty->assign('start_form', $this->CreateFormStart($id, 'save_admin_prefs', $returnid));
$smarty->assign('input_allow_add',$this->CreateInputCheckbox($id, 'allow_add', 1,
$this->GetPreference('allow_add','0')). $this->Lang('title_allow_add_help'));
$smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', lang('submit')));

// translated strings
$smarty->assign('title_allow_add',$this->Lang('title_allow_add'));
$smarty->assign('welcome_text',$this->Lang('welcome_text'));###
$smarty->assign('message',isset($params['message'])?$params['message']:'');
$smarty->assign('section',$this->Lang('subtemplates'));

$icon = $gCms->variables['admintheme']->DisplayImage(
                                                      'icons/system/newobject.gif',
                                                      $this->Lang('addtemplate'),
                                                      '',
                                                      '',
                                                      'systemicon'
                                                     );

$link = $this->CreateLink(
                            $id, 
                            'edittempl', 
                            $returnid, 
                            $icon, 
                            array(),
                            '', 
                            false, 
                            false, ''
                          );
$link .= ' ';

$link .= $this->CreateLink($id, 'edittempl', $returnid,
              $this->Lang('addtemplate'), array(), '', false, false, 'class="pageoptions"');

$link .= '&nbsp;&nbsp;';

$icon = '<img src="'
        . $gCms->config['root_url']
        . '/modules/Cataloger/images/reload.gif" class="systemicon" alt="'
        . $this->Lang('reimporttemplates')
        . '"  title="'
        . $this->Lang('reimporttemplates')
        . '" />';

$link .= $this->CreateLink(
                            $id, 
                            'reimport', 
                            $returnid,
                            $icon, 
                            array(), 
                            '', 
                            false, 
                            false, 
                            ''
                           );

$link .= ' ';

$link .= $this->CreateLink(
                            $id, 
                            'reimport', 
                            $returnid,
                            $this->Lang('reimporttemplates'), 
                            array(), 
                            '', 
                            false, 
                            false, 
                            'class="pageoptions"'
                          );
                          

$smarty->assign('addlink', $link);


$smarty->assign('title_template',$this->Lang('title_template'));
$smarty->assign('title_template_type',$this->Lang('title_template_type'));
$smarty->assign('notemplates',$this->Lang('notemplates'));

// TODO 0 -o JoMorg -c bugfix task: differentiate addlink for each type of sub-template
echo $this->ProcessTemplate('adminpanel.tpl');
?>
]]></data>
	</file>
	<file>
	  <filename>/admin_default_old.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/admin_edittempl_new.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
if ( !is_object( cmsms() ) ) exit;
if ( !$this->CheckAccess() ) exit;

if (isset($params['submit']) || isset($params['apply']))
{
  if (! empty($params['template_id']))
  {
    // updating a template
    $query = 'UPDATE '
             . cms_db_prefix()
             . 'module_catalog_template set title=?, template=?, type_id=? WHERE id=?';
    
    $qArr = array($params['title'],
                  $params['templ'],
                  $params['type_id'], 
                  $params['template_id']);
             
    $dbresult = $db->Execute($query, $qArr);
                             
    $template_id = $params['template_id'];
  }
  else
  {
    // creating a template
    $query = 'INSERT INTO '
             . cms_db_prefix()
             . 'module_catalog_template (id, title, type_id, template) VALUES (?,?,?,?)';
             
    $template_id = $db->GenID(cms_db_prefix().'module_catalog_template_seq');
    
    $qArr = array($template_id,
                  $params['title'],
                  $params['type_id'],
                  $params['templ']);
    
    $dbresult = $db->Execute($query, $qArr);
  }

  # this DOES clear Cataloger cached files (?????)
  $this->clear_cache();
  
  // force a cache clear? # note: from this point on, things seem to be duplicated (JM)
  $this->DeleteTemplate('catalog_' . $template_id);
  // and recreate
  $this->SetTemplate('catalog_' . $template_id, $params['templ']);

  $params['message'] = $this->Lang('templateupdated');

  if (isset($params['submit']))
  {
    $this->DoAction('defaultadmin', $id, $params);
    return;
  }
}

$typeids = array();
$typeids = catTemplateOperations::GetCatalogerTemplateTypes();
#echo '<------>';
#print_r($typeids);
#die();

/* old method JM
$query = 'SELECT type_id, name FROM ' .
cms_db_prefix(). 'module_catalog_template_type';
$dbresult = $db->Execute($query);
while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $typeids[$row['name']] = $row['type_id'];
}
*/
if (isset($params['template_id']))
{
  // editing a template
  
  $query = 'SELECT title, template, type_id FROM ' 
           . cms_db_prefix()
           . 'module_catalog_template WHERE id=?';
  
  $dbresult = $db->Execute($query,array($params['template_id']));
  
  $row = $dbresult->FetchRow();
  $templateid = $params['template_id'];
  $title=$row['title'];
  $template=$row['template'];
  $type_id=$row['type_id'];
  $this->smarty->assign('op', $this->Lang('edittemplate'));
}
else
{
  // adding a template
  $templateid = '';
  $title='';
  $template='';
  $this->smarty->assign('op', $this->Lang('addtemplate'));
}
        
$query = "SELECT attribute, alias, type_id FROM "
         . cms_db_prefix()
         . "module_catalog_attr";
         
$dbresult = $db->Execute($query);
        
$attrs = '<h3>'.$this->Lang('title_item_template_vars')
         . '</h3>{$title}, {$notes}, ';
         
$cattrs = '<h3>'
          . $this->Lang('title_cat_template_vars')
          . '</h3>{$title}, {$notes}, {$prev}, {$prevurl}, {$navstr}, {$next}, {$nexturl}, {$items}, ';
          
$pcattrs = '<h3>'
           . $this->Lang('title_catalog_template_vars')
           . '</h3>{$items}, {$attrlist}, {$root_url}, {$image_root}, ';
           
$compattrs = '<h3>'
             . $this->Lang('title_compare_template_vars')
             . '</h3>{$items}, {$attrlist}, {$root_url}, {$image_root}';
             
$feattrs = '<h3>'
           . $this->Lang('title_feature_template_vars')
           . '</h3>{$items}, {$root_url}, {$image_root}';

while ($dbresult !== false && $row = $dbresult->FetchRow())
{
  $safeattr = strtolower(preg_replace('/\W/','',$row['attribute']));
  
  if ($row['type_id'] == CTEMPLATE_ITEM)
  {
    $attrs .= '{$'.$safeattr.'}, ';
    if ($row['alias'] != '')
    {
      $attrs .= '{$'.$row['alias'].'}, ';
    }
  }
  else if ($row['type_id'] == CTEMPLATE_CATEGORY)
  {
    $cattrs .= '{$'.$safeattr.'}, ';
    
    if ($row['alias'] != '')
    {
      $cattrs .= '{$'.$row['alias'].'}, ';
    }
  }
  else if ($row['type_id'] == CTEMPLATE_CATALOG)
  {
    $pcattrs .= '{$'.$safeattr.'}, ';
    
    if ($row['alias'] != '')
    {
      $pcattrs .= '{$'.$row['alias'].'}, ';
    }
  }
}

$image_count = $this->GetPreference('item_image_count', '1');

for ($i=1;$i<=$image_count;$i++)
{
  $attrs .= '{$image_'.$i.'_url}, {$image_thumb_'.$i;
  $attrs .= '_url}, {$src_image_'.$i.'_url}, ';
}

$attrs .= '{$image_url_array}, ';
$attrs .= '{$src_image_url_array}, ';
$attrs .= '{$image_thumb_url_array}';
$file_count = $this->GetPreference('item_file_count', 0);

for ($i=1;$i<=$file_count;$i++)
{
  $attrs .= '{$file_count}, {$file_'.$i.'_name}, {$file_'.$i.'_url}, {$file_'.$i;
  $attrs .= '_ext}, ';
}

$attrs .= '{$file_url_array}, {$file_name_array}, ';
$attrs .= '{$file_ext_array}, {$root_url}, {$image_root}';
$attrs = rtrim($attrs,', ');

$image_count = $this->GetPreference('category_image_count', '1');

for ($i=1;$i<=$image_count;$i++)
{
  $cattrs .= '{$image_'.$i.'_url}, {$image_thumb_'.$i;
  $cattrs .= '_url}, {$src_image_'.$i.'_url}, ';
}

$cattrs .= '{$image_url_array}, ';
$cattrs .= '{$src_image_url_array}, ';
$cattrs .= '{$image_thumb_url_array}, {$root_url}, {$image_root}';
$cattrs = rtrim($cattrs,', ');
$cattrs .= '<h3>$items array contents:</h3>';
$cattrs .= '$items[].title, $items[].link, $items[].image, $items[].cat, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
$pcattrs .= '<h3>$items array contents:</h3>';
$pcattrs .= '$items[].title, $items[].link, $items[].image, $items[].cat, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
$pcattrs .= '<h3>$attrlist array contents:</h3>';
$pcattrs .= '$attrlist[]->attr, $attrlist[]->safe';
$compattrs .= '<h3>$items array contents:</h3>';
$compattrs .= '$items[].title, $items[].link, $items[].image, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
$compattrs .= '<h3>$attrlist array contents:</h3>';
$compattrs .= '$attrlist[]->attr, $attrlist[]->safe';
$feattrs .= '<h3>$items array contents:</h3>';
$feattrs .= '$items[].title, $items[].link, $items[].image, $items[].cat, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';

###############################################################################################################
###############################################################################################################
/**
* Smarty stuff
*/
###############################################################################################################
###############################################################################################################
// Give the form id to smarty
$smarty->assign('formid', $id);

$this->smarty->assign('startform', $this->CreateFormStart($id, 'submitprefs', $returnid));
$this->smarty->assign('endform', $this->CreateFormEnd());
$this->smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', 'Submit'));

$tab_headers = $this->StartTabHeaders()
               . $this->SetTabHeader('item_page_templates',         $this->Lang('item_page_templates_tab'))
               . $this->SetTabHeader('category_page_templates',     $this->Lang('category_page_templates_tab'))
               . $this->SetTabHeader('item_page_templates',         $this->Lang('title_category_image_tab'))
               . $this->SetTabHeader('item_page_templates',         $this->Lang('title_printable_tab'))
               . $this->SetTabHeader('item_page_templates',         $this->Lang('title_image_tab'))
               . $this->SetTabHeader('item_page_templates',         $this->Lang('title_path_tab'))
               . $this->EndTabHeaders()
               . $this->StartTabContent();

$this->smarty->assign('tab_headers', $tab_headers);
                      
$this->smarty->assign('end_tab', $this->EndTab());

$this->smarty->assign('tab_footers', $this->EndTabContent());

$this->smarty->assign('start_item_image_tab', $this->StartTab('itemimage'));
$this->smarty->assign('start_category_image_tab', $this->StartTab('categoryimage'));
$this->smarty->assign('start_printable_tab', $this->StartTab('printable'));
$this->smarty->assign('start_file_tab', $this->StartTab('file'));
$this->smarty->assign('start_path_tab', $this->StartTab('path'));
$this->smarty->assign('start_image_tab', $this->StartTab('image'));
$this->smarty->assign('title_item_image_count', $this->Lang('title_item_image_count'));
$this->smarty->assign('title_item_file_count', $this->Lang('title_item_file_count'));
$this->smarty->assign('title_item_file_types', $this->Lang('title_item_file_types'));
$this->smarty->assign('title_flush_cats', $this->Lang('title_flush_cats'));

      
$this->smarty->assign('startform', $this->CreateFormStart($id, 'edittempl', $returnid));
$this->smarty->assign('endform', $this->CreateFormEnd());
$this->smarty->assign('hidden',$this->CreateInputHidden($id, 'template_id', $templateid));
$this->smarty->assign('title_title',$this->Lang('title_title'));
$this->smarty->assign('title_template',$this->Lang('title_template'));
$this->smarty->assign('title_template_type',$this->Lang('title_template_type'));
$this->smarty->assign('title_avail_attrs',$this->Lang('title_avail_attrs'));

if (isset($type_id))
{
  if ($type_id == CTEMPLATE_ITEM)
  {
    $this->smarty->assign_by_ref('avail_attrs',$attrs);
  }
  else if ($type_id == CTEMPLATE_CATEGORY)
  {
    $this->smarty->assign('avail_attrs',$cattrs);    
  }
  else if ($type_id == CTEMPLATE_CATALOG)
  {
    $this->smarty->assign('avail_attrs',$pcattrs);    
  }
  else if ($type_id == CTEMPLATE_COMPARISON)
  {
  $this->smarty->assign('avail_attrs',$compattrs);    
  }
  else if ($type_id == CTEMPLATE_FEATURE)
  {
    $this->smarty->assign('avail_attrs',$feattrs);    
  }
}
else
{
  $this->smarty->assign('avail_attrs', $attrs . ', ' . $cattrs . ', ' . $feattrs);
}

//    $this->smarty->assign('title_avail_imattrs',$this->Lang('title_avail_imattrs'));
//    $this->smarty->assign('avail_imattrs',$imattrs);
$this->smarty->assign('input_template_type',$this->CreateInputDropdown($id, 'type_id', $typeids, -1, isset($type_id)?$type_id:''));

$this->smarty->assign('message',$params['message']);
$this->smarty->assign('input_title',$this->CreateInputText($id, 'title', $title, 20, 255));
$this->smarty->assign('input_template',$this->CreateTextArea(false, $id, $template, 'templ'));

$this->smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', lang('submit')));
$this->smarty->assign('apply', $this->CreateInputSubmit($id, 'apply', lang('apply')));
echo $this->ProcessTemplate('edittemplate.tpl');

?>
]]></data>
	</file>
	<file>
	  <filename>/admin_edittempl_old.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
if ( !is_object( cmsms() ) ) exit;

$type_id = $params['type_id'];

if (isset($params['submit']) || isset($params['apply']))
{
  if ( !empty($params['template_id']) )
  {
    // updating a template
    if ( !catTemplateOperations::SaveTemplateChanges($params) )
    {
      $params['err'] = 'ERROR SAVING CHANGES'; // TODO task: add a lang entry
    }
                             
    $template_id = $params['template_id'];
  }
  else
  {
    // creating a template
    $query = 'INSERT INTO '
             . cms_db_prefix()
             . 'module_catalog_template (id, title, type_id, template) VALUES (?,?,?,?)';
             
    $template_id = $db->GenID(cms_db_prefix().'module_catalog_template_seq');
    
    $qArr = array($template_id,
                  $params['title'],
                  $params['type_id'],
                  $params['templ']);
    
    $dbresult = $db->Execute($query, $qArr);
  }

  // force a cache clear?
  $this->DeleteTemplate('catalog_' . $template_id);
  // and recreate
  $this->SetTemplate('catalog_' . $template_id, $params['templ']);

  $params['message'] = $this->Lang('templateupdated');

  if (isset($params['submit']))
  {
    $this->DoAction('defaultadmin', $id, $params);
    return;
  }
}

$typeids = array();
$typeids = catTemplateOperations::GetCatalogerTemplateTypes();

if (isset($params['template_id']))
{
  // editing a template  
  $row = catTemplateOperations::GetTemplateFromID($params['template_id']);
  $templateid = $params['template_id'];
  $title=$row['title'];
  $template=$row['template'];
  $type_id=$row['type_id'];
  $this->smarty->assign('op', $this->Lang('edittemplate'));
}
else
{
  // adding a template
  $templateid = '';
  $title='';
  $template='';
  $this->smarty->assign('op', $this->Lang('addtemplate'));
}
   

if (isset($type_id)) 
{
  $attrs = array();

  $attrs['fixed'] = catTemplateOperations::GetAttListFromType( $params['type_id']);
  $attrs['user'] =  catTemplateOperations::GetUserAttList( $params['type_id']);

  $image_count = $this->GetPreference('item_image_count', '1');

  if ($image_count > 0)
  {
    $attrs['images'] = array();

    for ($i=1;$i<=$image_count;$i++)
    {
      $currImg = array(
                        'image_url'       => '{$image_' . $i . '_url}',
                        'image_thumb_url' => '{$image_thumb_' . $i . '_url}',
                        'image_src_url'   => '{$src_image_' . $i . '_url}'
                      );
      
      array_push($attrs['images'] , $currImg);
    }

    array_push($attrs['fixed'] , '{$image_url_array}');
    array_push($attrs['fixed'], '{$src_image_url_array}');
    array_push($attrs['fixed'] , '{$image_thumb_url_array}');

  }  

  $file_count = $this->GetPreference('item_file_count', 0);

  if ($file_count > 0)
  {
    $attrs['files'] = array();
    
    for ($i=1;$i<=$file_count;$i++)
    {
      $currFile = array(
                    'filename'  => '{$file_'.$i.'_name}',
                    'url'       => '{$file_'.$i.'_url}',
                    'ext'       => '{$file_'.$i. '_ext}'
                  );
      array_push( $attrs['files'] , $currFile);
    }

    array_push($attrs['fixed'] , '{$file_count}');
    array_push($attrs['fixed'] , '{$file_name_array');
    array_push($attrs['fixed'] , '{$file_url_array}');
    array_push($attrs['fixed'] , '{$file_ext_array}');
    array_push($attrs['fixed'] , '{$root_url}');
    array_push($attrs['fixed'] , '{$image_root}');
  }
  
  if (isset($type_id))
  { 
    switch ($type_id)
    {
      case CTEMPLATE_ITEM:
        $this->smarty->assign('title_template_vars', $this->Lang('title_item_template_vars') );
        $this->smarty->assign_by_ref('avail_attrs', $attrs);
      break;  
      
      case CTEMPLATE_CATEGORY:  
        $this->smarty->assign('title_template_vars', $this->Lang('title_cat_template_vars') );
        $this->smarty->assign_by_ref('avail_attrs', $cattrs);  
      break;
      
      case CTEMPLATE_CATALOG: 
        $this->smarty->assign('title_template_vars', $this->Lang('title_catalog_template_vars') );
        $this->smarty->assign_by_ref('avail_attrs', $pcattrs);    
      break;
      
      case CTEMPLATE_COMPARISON:
        $this->smarty->assign('title_template_vars', $this->Lang('title_compare_template_vars') );
        $this->smarty->assign_by_ref('avail_attrs', $compattrs);   
      break;
      
      case CTEMPLATE_FEATURE:
        $this->smarty->assign('title_template_vars', $this->Lang('title_feature_template_vars') );
        $this->smarty->assign_by_ref('avail_attrs', $feattrs);    
      break;
    }
  }
  else 
  {
    $this->smarty->assign('avail_attrs',$attrs.', '.$cattrs.', '.$feattrs);  
  }     

/*
$attrs = '{$title}, {$notes}, ';
         
$cattrs = '{$title}, {$notes}, {$prev}, {$prevurl}, {$navstr}, {$next}, {$nexturl}, {$items}, ';
          
$pcattrs = '{$items}, {$attrlist}, {$root_url}, {$image_root}, ';
           
$compattrs = '{$items}, {$attrlist}, {$root_url}, {$image_root}';
             
$feattrs = '{$items}, {$root_url}, {$image_root}';
*/




/*
$image_count = $this->GetPreference('category_image_count', '1');

for ($i=1;$i<=$image_count;$i++)
{
  $cattrs .= '{$image_'.$i.'_url}, {$image_thumb_'.$i;
  $cattrs .= '_url}, {$src_image_'.$i.'_url}, ';
}

$cattrs .= '{$image_url_array}, ';
$cattrs .= '{$src_image_url_array}, ';
$cattrs .= '{$image_thumb_url_array}, {$root_url}, {$image_root}';
$cattrs = rtrim($cattrs,', ');
$cattrs .= '<h3>$items array contents:</h3>';
$cattrs .= '$items[].title, $items[].link, $items[].image, $items[].cat, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
$pcattrs .= '<h3>$items array contents:</h3>';
$pcattrs .= '$items[].title, $items[].link, $items[].image, $items[].cat, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
$pcattrs .= '<h3>$attrlist array contents:</h3>';
$pcattrs .= '$attrlist[]->attr, $attrlist[]->safe';
$compattrs .= '<h3>$items array contents:</h3>';
$compattrs .= '$items[].title, $items[].link, $items[].image, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
$compattrs .= '<h3>$attrlist array contents:</h3>';
$compattrs .= '$attrlist[]->attr, $attrlist[]->safe';
$feattrs .= '<h3>$items array contents:</h3>';
$feattrs .= '$items[].title, $items[].link, $items[].image, $items[].cat, $items[].<i>attribute_name</i>, $items[].<i>attribute_alias</i>';
*/
        
$this->smarty->assign('startform', $this->CreateFormStart($id, 'edittempl', $returnid));
$this->smarty->assign('endform', $this->CreateFormEnd());
$this->smarty->assign('hidden',$this->CreateInputHidden($id, 'template_id', $templateid));
$this->smarty->assign('title_title',$this->Lang('title_title'));
$this->smarty->assign('title_template',$this->Lang('title_template'));
$this->smarty->assign('title_template_type',$this->Lang('title_template_type'));
$this->smarty->assign('title_avail_attrs',$this->Lang('title_avail_attrs'));
$this->smarty->assign('image_count', $image_count);
$this->smarty->assign('file_count', $file_count);



//    $this->smarty->assign('title_avail_imattrs',$this->Lang('title_avail_imattrs'));
//    $this->smarty->assign_by_ref('avail_imattrs',$imattrs);
$this->smarty->assign('input_template_type',$this->CreateInputDropdown($id, 'type_id', $typeids, -1, isset($type_id)?$type_id:''));

$this->smarty->assign('message',$params['message']);
$this->smarty->assign('input_title',$this->CreateInputText($id, 'title', $title, 20, 255));
$this->smarty->assign('input_template',$this->CreateTextArea(false, $id, $template, 'templ'));

$this->smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', lang('submit')));
$this->smarty->assign('apply', $this->CreateInputSubmit($id, 'apply', lang('apply')));
$this->smarty->assign('cancel', $this->CreateInputSubmit($id, 'cancel', lang('cancel')));
echo $this->ProcessTemplate('edittemplate.tpl');
?>
]]></data>
	</file>
	<file>
	  <filename>/Cataloger.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 1.0
#
# Copyright (c) 2012, Fernando Morgado (JoMorg) jomorg.morg@gmail.com
# Copyright (c) 2006, Samuel Goldstein <sjg@cmsmodules.com>
# For Information, Support, Bug Reports, etc, please visit the
# CMS Made Simple Forge at http://dev.cmsmadesimple.org
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http://www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
define('CTEMPLATE_ITEM',        1);
define('CTEMPLATE_CATEGORY',    2);
define('CTEMPLATE_CATALOG',     3);
define('CTEMPLATE_COMPARISON',  4);
define('CTEMPLATE_FEATURE',     5);

class Cataloger extends CMSModule
{
  # deprecated
  var $attrs = array();
  
  var $fetched = false;
  var $showMissing = '';

  function __construct()
  {
    $cnt_types = array('Catalog Item', 'Catalog Category', 'Catalog Printable');
    
    $path = cms_join_path(
                            $this->GetModulePath(),
                            'lib'
                          );
                            
    $contentops = cmsms()->GetContentOperations();

    foreach($cnt_types as $friendlyname)
    {
      $type = str_replace(' ', '', $friendlyname);
      $file = 'class.' . $type . '.php';
      $fn = cms_join_path($path, $file);
      $obj = new CmsContentTypePlaceholder();
      $obj->class = $type;
      $obj->type = strtolower($type);
      $obj->filename = $fn;
      $obj->loaded = false;
      $obj->friendlyname = ($friendlyname != '' ? $friendlyname : $type);
      $result = $contentops->register_content_type($obj); // TODO error handling
    }
    
    cms_route_manager::del_static('',$this->GetName());
    $route = new CmsRoute( '/cataloger_image$/', $this->GetName(), array('action' => 'image') );
    cms_route_manager::add_static($route);    
    parent::__construct(); 
  }

  function GetName()
  {
    return 'Cataloger';
  }

  function GetFriendlyName()
  {
    return $this->Lang('friendlyname');
  }

  function IsPluginModule()
  {
    return true;
  }

  function HasAdmin()
  {
    return true;
  }

  function GetVersion()
  {
    return '1.0.1';
  }

  function MinimumCMSVersion()
  {
    return '2.1';
  }

  function GetAdminDescription()
  {
    return $this->Lang('admindescription');
  }

  function InstallPostMessage()
  {
    return $this->Lang('postinstall');
  }

  function SetParameters()
  {
    $this->RegisterModulePlugin();
    $this->RestrictUnknownParams();

    $this->SetParameterType('sub_template',     CLEAN_STRING);
    $this->SetParameterType('recent',           CLEAN_STRING);
    $this->SetParameterType('alias',            CLEAN_STRING);
    $this->SetParameterType('random',           CLEAN_STRING);
    $this->SetParameterType('action',           CLEAN_STRING);
    $this->SetParameterType('recurse',          CLEAN_STRING);
    $this->SetParameterType('items',            CLEAN_STRING);
    $this->SetParameterType('global_sort',      CLEAN_STRING);
    $this->SetParameterType('global_sort_dir',  CLEAN_STRING);
    $this->SetParameterType('name',             CLEAN_STRING);
    $this->SetParameterType('default',          CLEAN_STRING);
    $this->SetParameterType('count',            CLEAN_INT);
  }

  function getTemplateFromAlias($alias)
  {
    $db = $this->GetDb();
    $dbresult = $db->Execute(
                              'SELECT id from ' 
                              . cms_db_prefix() 
                              . 'module_catalog_template where title=?', array($alias) 
                            );
    
    if($dbresult !== false && $row = $dbresult->FetchRow() )
    {
      return 'catalog_' . $row['id'];
    }
    return '';
  }

  function importSampleTemplates($onlytype = 'all')
  {
    $db = $this->GetDb();
    
    $path = cms_join_path(
                            $this->GetModulePath(),
                            'includes'
                          );
    $dir = opendir($path);
    $temps = array();
    
    while($filespec = readdir($dir) )
    {
      if(!preg_match('/\.tpl$/i', $filespec) )
      {
        continue;
      }
      array_push($temps, $filespec);
    }
    
    sort($temps);
    $query = 'INSERT INTO ' 
              . cms_db_prefix() 
              . 'module_catalog_template (id, type_id, title, template) VALUES (?,?,?,?)';

    foreach($temps as $filespec)
    {
      $fn = cms_join_path($path, $filespec);
      $file = file($fn);
      $template = implode('', $file);
      $temp_name = preg_replace('/\.tpl$/i', '', $filespec);
      // check if it already exists
      $excheck = 'SELECT id from ' . cms_db_prefix() . 'module_catalog_template where title=?';
      $dbcount = $db->Execute($excheck, array($temp_name) );
      
      while($dbcount && $dbcount->RecordCount() > 0)
      {
        $temp_name .= '_new';
        $dbcount = $db->Execute($excheck, array($temp_name) );
      }
      
      $type_id =  - 1;
      $type = substr($temp_name, 0, strpos($temp_name, '-') );
      
      if($type == 'Item' && ($onlytype == 'all' || $onlytype = 'Item') )
      {
        $type_id = CTEMPLATE_ITEM;
      }
      else if($type == 'Category' && ($onlytype == 'all' || $onlytype = 'Category') )
      {
        $type_id = CTEMPLATE_CATEGORY;
      }
      else if($type == 'Printable' && ($onlytype == 'all' || $onlytype = 'Printable') )
      {
        $type_id = CTEMPLATE_CATALOG;
      }
      else if($type == 'Comparison' && ($onlytype == 'all' || $onlytype = 'Comparison') )
      {
        $type_id = CTEMPLATE_COMPARISON;
      }
      else if($type == 'Feature' && ($onlytype == 'all' || $onlytype = 'Feature') )
      {
        $type_id = CTEMPLATE_FEATURE;
      }

      $temp_id = $db->GenID(cms_db_prefix() . 'module_catalog_template_seq');
      $dbresult = $db->Execute($query, array($temp_id, $type_id, $temp_name, $template) );
      $this->SetTemplate('catalog_' . $temp_id, $template);
    }

  }

  # deprecated: moved to catFilesOperations
  function contentalpha($a, $b)
  {
    return strcasecmp($a['title'], $b['title']);
  }

  # deprecated: moved to catFilesOperations 
  function chrono($a, $b)
  {
    if($a['modifieddate'] > $b['modifieddate'])
    {
      return -1;
    }
    
    if($a['modifieddate'] < $b['modifieddate'])
    {
      return 1;
    }
    
    return 0;
  }

  # deprecated: moved to catFilesOperations
  function created($a, $b)
  {
    if($a['createdate'] > $b['createdate'])
    {
      return -1;
    }
    
    if($a['createdate'] < $b['createdate'])
    {
      return 1;
    }
    
    return 0;
  }
  
  function _display_icon($icon = '')
  {
    $image_path = cms_join_path($this->GetModulePath(), 'images', $icon);
    return $image_path;
  }

  function initAdminNav($id, &$params, $returnid)
  {
    $config = $this->GetConfig();
    $vars = $this->GetVariables();
    $innernav = "<div class='pageoverflow'>\n";
    
    $sep = ' | ';
    
    # default admin
    
    $tempImage = '<img class="systemicon" alt="'
                     . $this->Lang('globalops')
                     . '" title="'
                     . $this->Lang('globalops')
                     . '" src="'
                     . $config['root_url']
                     . '/modules/Cataloger/images/templates.png" />';
    
    $innernav .= $this->CreateLink(
                                    $id, 
                                    'defaultadmin', 
                                    $returnid,
                                    $tempImage, 
                                    array()
                                  );     
    
    $innernav .= ' ';
    
    $innernav .= $this->CreateLink(
                                      $id, 
                                      'defaultadmin', 
                                      $returnid,
                                      $this->Lang('listtempl'), 
                                      array()
                                    );  

    # Manage Attributes
   
    $tempImage = '<img class="systemicon" alt="'
                     . $this->Lang('globalops')
                     . '" title="'
                     . $this->Lang('globalops')
                     . '" src="'
                     . $config['root_url']
                     . '/modules/Cataloger/images/attributes.png" />';
    
    $innernav .= $sep;
    
    $innernav .= $this->CreateLink(
                                    $id, 
                                    'adminattrs', 
                                    $returnid,
                                    $tempImage, 
                                    array()
                                  );
    
    
    $innernav .= ' ' . $this->CreateLink(
                                          $id, 
                                          'adminattrs', 
                                          $returnid,
                                          $this->Lang('manageattrs'), 
                                          array()
                                        );
    
    $innernav .= $sep;
    
    # Global Operations
    
    $tempImage = '<img class="systemicon" alt="'
                     . $this->Lang('globalops')
                     . '" title="'
                     . $this->Lang('globalops')
                     . '" src="'
                     . $config['root_url']
                     . '/modules/Cataloger/images/global.png" />';
    
    $innernav .= $this->CreateLink(
                                    $id, 
                                    'globalops', 
                                    $returnid,
                                    $tempImage, 
                                    array()
                                  );
                                  
    
    $innernav .= ' ' . $this->CreateLink(
                                    $id, 
                                    'globalops', 
                                    $returnid,
                                    $this->Lang('globalops'),
                                    array()
                                  );
                                  
    $innernav .= $sep;
    
    # Admin Prefs
   
    $tempImage = '<img class="systemicon" alt="'
                     . $this->Lang('globalops')
                     . '" title="'
                     . $this->Lang('globalops')
                     . '" src="'
                     . $config['root_url']
                     . '/modules/Cataloger/images/admin.png" />';
    
    $innernav .= $this->CreateLink(
                                    $id, 
                                    'adminprefs', 
                                    $returnid,
                                    $tempImage, 
                                    array()
                                  );     
                        
    
    $innernav .= ' ' . $this->CreateLink(
                                          $id, 
                                          'adminprefs', 
                                          $returnid,
                                          $this->Lang('manageprefs'),
                                          array()
                                        );
    $innernav .= "\n</div>\n";
    
    $this->smarty->assign('innernav', $innernav);

  }

  function GetAdminSection()
  {
    return 'content';
  }
  
  function VisibleToAdminUser()
  {
    return $this->CheckPermission('Modify Catalog Settings');
  }

  function GetHelp($lang = 'en_US')
  {
    //return $this->Lang('helptext');
    $smarty = cmsms()->GetSmarty();
    $config = cmsms()->GetConfig();
        
    $smarty->assign('root_url', $config['root_url']);

    $smarty->assign('mod', $this);
    return $this->ProcessTemplate('help.tpl');
  }

  function GetAuthor()
  {
    return 'JoMorg';
  }

  function CheckAccess($permission = 'Modify Catalog Settings')
  {
    $access = $this->CheckPermission($permission);

    if(!$access)
    {
      echo"<p class=\"error\">" . $this->Lang('needpermission', $permission) . "</p>";
      return false;
    }

    return true;
  }


  function GetAuthorEmail()
  {
    return 'jomorg.morg@gmail.com';
  }

  function GetChangeLog()
  {
    return $this->ProcessTemplate("changelog.tpl");
    //$this->Lang('changelog');
  }


  function &getSubContent($startNodeId)
  {
    $gCms = cmsms();
    $content = array();
    $hm = $gCms->GetHierarchyManager();
    /* Works with new addition to Tree, but getFlatList is default
    $rn = $hm->sureGetNodeById($startNodeId);
    $count = 0;
    $hm->getFlattenedChildren($rn, $content, $count);
     */
    $content = $hm->getFlatList();
    return $content;
  }

  function &getAllContent()
  {
    $gCms = cmsms();
    $content = array();
    $hm = $gCms->GetHierarchyManager();

    $rn = $hm->GetRootNode();
    $count = 0;
    $hm->getFlattenedChildren($rn, $content, $count);
    return $content;
  }

   // deprecated
//  function getUserAttributes($global_ref = 'catalog_attrs')
//  {
//    $db = cmsms()->GetDb();
//    if(!isset($this->attrs[$global_ref]) || !is_array($this->attrs[$global_ref]) )
//    {
//      $this->attrs[$global_ref] = array();
//      $query = "SELECT attribute, alias, defaultval, length, field_type, select_values FROM ".cms_db_prefix()."module_catalog_attr WHERE type_id=? ORDER BY order_by ASC";
//      $type_id = 1;
//      
//      if($global_ref == 'catalog_cat_attrs')
//      {
//        $type_id = 2;
//      }
//      elseif($global_ref == 'catalog_print_attrs')
//      {
//        $type_id = 3;
//      }
//      
//      $dbresult = $db->Execute($query, array($type_id) );
//      
//      while($dbresult !== false && $row = $dbresult->FetchRow() )
//      {
//        $thisAttr = new stdClass();
//        $thisAttr->attr = $row['attribute'];
//        $thisAttr->alias = $row['alias'];
//        $thisAttr->length = $row['length'];
//        $thisAttr->default = $row['defaultval'];
//        $thisAttr->select_values = $row['select_values'];
//        $thisAttr->field_type = $row['field_type'];
//        $thisAttr->safe = strtolower(preg_replace('/\W/', '', $row['attribute']) );
//        array_push($this->attrs[$global_ref], $thisAttr);
//      }
//    }
//    
//    return $this->attrs;
//  }

  function &getCatalogItem($alias)
  {
    $gCms = cmsms();

    $hm = $gCms->GetHierarchyManager();
    $pageNode = $hm->sureGetNodeByAlias($alias);
    $page = $pageNode->GetContent();
    $node = $this->itemToArray($page, '');
    return $node;
  }

  function & getCatalogItemById($id)
  {
    $gCms = cmsms();

    $hm = $gCms->GetHierarchyManager();
    $pageNode = $hm->sureGetNodeById($id);
    $page = $pageNode->GetContent();
    $node = $this->itemToArray($page, '');
    return $node;
  }


  function smartyBasics()
  {
    $config = $this->GetConfig();
    $smarty = $this->GetActionTemplateObject();
    
    if( empty($smarty) ) $smarty = cmsms()->GetSmarty();
    
    # deprecated
    //$smarty->assign('image_root', $config['root_url'].'/modules/Cataloger/Cataloger.Image.php');
    $smarty->assign('image_root', '');
    
    # deprecated
    //$smarty->assign('root_url', $config['root_url']);
    $smarty->assign('root_url', '');
    
    // type can be "s" - source image, "i" - processed image, or "f" - file
    $smarty->assign( 'original_images_path', catFilesOperations::getAssetPath('s') );
    $smarty->assign( 'processed_images_path', catFilesOperations::getAssetPath('i') );
    $smarty->assign( 'files_path', catFilesOperations::getAssetPath('f') ); 
  }

  // more fixes needed _____________________________________________>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  function getCatalogItemsIDList(&$params)
  {
    $gCms = cmsms();
    $db = $gCms->GetDb();
    $ret = array();
    
    if(!isset($params['alias']) || $params['alias'] == '/')
    {
      $dbresult = $db->Execute('SELECT content_id from '.cms_db_prefix().'content where type=\'catalogitem\'');
    }
    else
    {
      $base_hierarchy = $db->GetOne('SELECT hierarchy from '.cms_db_prefix().'content where content_alias=?', array($params['alias']) );
      
      if(!$base_hierarchy)
      {
        return $ret;
      }
      $dbresult = $db->Execute(
                                'SELECT content_id from '
                                . cms_db_prefix()
                                . 'content where type=\'catalogitem\' and hierarchy LIKE \''
                                . $base_hierarchy.'%\''
                              );
    }
    
    while($dbresult !== false && $row = $dbresult->FetchRow() )
    {
      array_push($ret, $row['content_id']);
    }
    
    return $ret;
  }

  function getCatalogItemsList(&$params)
  {
    $gCms = cmsms();
    $vars = $this->GetVariables();

    $hm = $gCms->GetHierarchyManager();
    $lastcat = "";
    $lastcatfull = null;

    if(isset($params['alias']) && $params['alias'] == '/')
    {
      $content = $hm->getFlatList();
      $curHierDepth = isset($params['start_depth']) ? $params['start_depth']:  - 1;
      $curHierarchy = '';
      $curHierLen = 0;
      $curPage = new CMSModuleContentType();
    }
    else
    {
      if(isset($params['content_id']) )
      {
        $curPageID = $vars[$params['content_id']];
        $curPageNode = $hm->sureGetNodeById($curPageID);
        $curPage = $curPageNode->GetContent();
      }
      elseif(isset($params['alias']) )
      {
        $curPageNode = $hm->sureGetNodeByAlias($params['alias']);
        $curPage = $curPageNode->GetContent();
        $curPageID = $curPage->Id();
      }
      elseif(isset($gCms->variables['content_id']) )
      {
        $curPageID = $gCms->variables['content_id'];
        $curPageNode = $hm->sureGetNodeById($curPageID);
        $curPage = $curPageNode->GetContent();
      }

      $curHierarchy = $curPage->Hierarchy();
      $curHierLen = strlen($curHierarchy);
      $curHierDepth = substr_count($curHierarchy, '.');
      $content = $this->getSubContent($curPageID);
    }

    $categoryItems = array();

    foreach($content as $thisPage)
    {
      $thispagecontent = $thisPage->GetContent();

      if(!$thispagecontent)
      {
        continue;
      }

      if(method_exists($thispagecontent, 'Active') && !$thispagecontent->Active() )
      {
        continue;
      }

      if($thispagecontent->Id() == $curPage->Id() )
      {
        continue;
      }

      $type_ok = false;
      $depth_ok = false;

      if($thispagecontent->Type() == 'contentalias')
      {
        $thispagecontent = $thispagecontent->GetAliasContent();
        $curHierLen = strlen($curHierarchy);
        $curHierDepth = substr_count($curHierarchy, '.');
      }

      if($thispagecontent->Type() == 'catalogcategory')
      {
        $lastcat = $thispagecontent->Name();
        //debug_display($thispagecontent);
      }

      if($thispagecontent->Type() == 'catalogitem' && ($params['recurse'] ==
        'items_one' || $params['recurse'] == 'items_all' || $params['recurse']
        == 'mixed_one' || $params['recurse'] == 'mixed_all'
      ))
      {
        $type_ok = true;
      }
      else if($thispagecontent->Type() == 'catalogcategory' &&
        ($params['recurse'] == 'categories_one' || $params['recurse'] ==
        'categories_all' || $params['recurse'] == 'mixed_one' ||
        $params['recurse'] == 'mixed_all'
      ))
      {
        $type_ok = true;
      }

      if(!$type_ok)
      {
        continue;
      }

      if(($params['recurse'] == 'items_one' || $params['recurse'] ==
        'categories_one' || $params['recurse'] == 'mixed_one') && substr_count
        ($thispagecontent->Hierarchy(), '.') == ($curHierDepth + 1) && substr
        ($thispagecontent->Hierarchy(), 0, $curHierLen + 1) == $curHierarchy.'.'
      )
      {
        $depth_ok = true;
      }
      elseif( (isset($params['alias']) && $params['alias'] == '/') || (
        ($params['recurse'] == 'items_all' || $params['recurse'] ==
        'categories_all' || $params['recurse'] == 'mixed_all') && substr
        ($thispagecontent->Hierarchy(), 0, $curHierLen + 1) == $curHierarchy.'.'
      ))
      {
        $depth_ok = true;
      }


      if(!$depth_ok)
      {
        continue;
      }

      // in the category, and approved for addition
      $thisItem = $this->itemToArray($thispagecontent, $lastcat);
      array_push($categoryItems, $thisItem);
    }

    return array($curPage, $categoryItems);
  }

  function itemToArray($pagecontent, $lastcat)
  {
    $thisItem = array();
    $catThumbSize = $this->GetPreference('category_image_size_thumbnail', 90);
    $itemThumbSize = $this->GetPreference('item_image_size_category', 70);
    $missingImage = $this->GetPreference('show_missing', '1');
    switch($pagecontent->Type() )
    {
      case 'catalogitem':
        $thisItem['image'] = $this->imageSpec($pagecontent->Alias(), 's', 1, $itemThumbSize);
        $thisItem['image_src'] = $this->srcImageSpec($pagecontent->Alias(), 1);
        break;
      case 'catalogcategory':
        $thisItem['image'] = $this->imageSpec($pagecontent->Alias(), 'ct', 1, $catThumbSize);
        break;
    }
    $thisItem['link'] = $pagecontent->GetUrl();
    $thisItem['title'] = $pagecontent->Name();
    $thisItem['alias'] = $pagecontent->Alias();
    $thisItem['menutitle'] = $pagecontent->MenuText();
    $thisItem['modifieddate'] = $pagecontent->GetModifiedDate();
    $thisItem['category'] = $lastcat;
    $thisItem['cat'] = $lastcat;
    $thisItem['createdate'] = $pagecontent->GetCreationDate();
    $thisItem['attrs'] = array();
    $theseAttrs = $pagecontent->getAttrs();
    foreach($theseAttrs as $thisAttr)
    {
      //$safeattr = strtolower(preg_replace('/\W/','',$thisAttr->attr));
      $thisItem[$thisAttr->safe] = $pagecontent->GetPropertyValue($thisAttr->attr);
      $thisItem['attrs'][$thisAttr->safe] = $pagecontent->GetPropertyValue($thisAttr->attr);
      if(isset($thisAttr->alias) && $thisAttr->alias != '')
      {
        $thisItem[$thisAttr->alias] = $pagecontent->GetPropertyValue($thisAttr->attr);
        $thisItem['attrs'][$thisAttr->alias] = $pagecontent->GetPropertyValue($thisAttr->attr);
      }
    }
    return $thisItem;

  }


  function imageSpec($alias, $type, $image_number, $size, $anticache = true, $forceshowmissing = false)
  {
    $config = $this->GetConfig();
    if($this->showMissing == '')
    {
      $this->showMissing = $this->GetPreference('show_missing', '1');
    }
    $extender = '';
    if($anticache)
    {
      $extender = '&amp;ac=';
      for($r = 0; $r < 5; $r++)
      {
        $extender .= rand(0, 9);
      }
    }

    return $config['root_url'].'/modules/Cataloger/Cataloger.Image.php?i='.$alias.'_'.$type.'_'.$image_number. '_'.$size.($forceshowmissing ? '_1' : '_'.$this->showMissing).'.jpg'.$extender;
  }

  function srcImageSpec($alias, $image_number)
  {
    $config = $this->GetConfig();
    if($this->showMissing == '')
    {
      $this->showMissing = $this->GetPreference('show_missing', '1');
    }

    if(!$this->srcExists($alias, $image_number) )
    {
      if($this->showMissing != '1')
      {
        return $config['root_url'].'/modules/Cataloger/images/trans.gif';
      }
      else
      {
        return $config['root_url'].'/modules/Cataloger/images/no-image.gif';
      }
    }
    else
    {
      return $config['uploads_url'].$this->getAssetPath('s').'/'.$alias.'_src_'.$image_number.'.jpg';
    }
  }

  function srcExists($alias, $image_number)
  {
    $config = $this->GetConfig();
    $srcSpec = $config['uploads_path'].$this->getAssetPath('s').'/'.$alias.'_src_'.$image_number.'.jpg';
    return file_exists($srcSpec);
  }


  function getFiles($alias)
  {
    $config = $this->GetConfig();

    $dirspec = $config['uploads_path'].$this->getAssetPath('f').'/'.$alias;
    $files = array();
    $types = array();
    if(is_dir($dirspec) )
    {
      $dh = opendir($dirspec);
      while(false !== ($filename = readdir($dh) ) )
      {
        if($filename != '.' && $filename != '..')
        {
          $files[] = $filename;
          if(strpos($filename, '.') !== false)
          {
            $types[] = substr($filename, strrpos($filename, '.') + 1);
          }
          else
          {
            $types[] = '?';
          }
        }
      }
    }
    return array($files, $types);
  }

  function purgeAllImage($alias, $imageNumber)
  {
    $this->purgeScaledImages($alias, $imageNumber);
    $this->purgeSourceImage($alias, $imageNumber);
  }

  function purgeScaledImages($alias, $imageNumber)
  {
    $config = $this->GetConfig();
    $srcDir = $config['uploads_path'].$this->getAssetPath('f').'/';
    $toDel = array();
    if($dh = opendir($srcDir) )
    {
      while( ($file = readdir($dh) ) !== false)
      {
        $fileParts = explode('_', $file);
        if($fileParts[0] == $alias && $fileParts[2] == $imageNumber)
        {
          array_push($toDel, $srcDir.'/'.$file);
        }
      }
      closedir($dh);
    }
    foreach($toDel as $thisDel)
    {
      unlink($thisDel);
    }
  }

  function purgeSourceImage($alias, $imageNumber)
  {
    $config = $this->GetConfig();
    $srcSpec = $config['uploads_path'].$this->getAssetPath('s').'/'.$alias.'_src_'.$imageNumber.'.jpg';
    unlink($srcSpec);
  }


  function renameImages($old, $newAlias)
  {
    $config = $this->GetConfig();
    if($handle = opendir($config['uploads_path'].$this->getAssetPath('s').'/') )
    {
      while(false !== ($file = readdir($handle) ) )
      {
        if(substr($file, 0, strlen($old) ) == $old)
        {
          $newspec = $newAlias.substr($file, strlen($old) );
          rename($config['uploads_path'].$this->getAssetPath('s').'/'.$file, $config['uploads_path'].$this->getAssetPath('s').'/'.$newspec);
        }
      }
      closedir($handle);
    }
  }


  function displayError($message)
  {
    $this->smarty->assign('error',$message);
    echo $this->ProcessTemplate('error.tpl');
  }

  function getFieldTypes()
  {
    return array('text' => $this->Lang('text'), 'select' => $this->Lang('dropdown'), 'textarea' => $this->Lang('textarea'), 'checkbox' => $this->Lang('checkbox'));
  }

  // deprecated
  function attributeInput($owner, $thisAttr, $wysiwyg = true, $stylesheet = '')
  {
    $v = $owner->GetPropertyValue($thisAttr->attr);

    if(empty($v) && !empty($thisAttr->default) )
    {
      $v = $thisAttr->default;
    }

    if($thisAttr->field_type == 'select')
    {
      $select_values = array();
      if(isset($thisAttr->select_values) && $thisAttr->select_values != '')
      {
        $select_values = array_map('trim', explode(',', htmlspecialchars($thisAttr->select_values, ENT_QUOTES) ) );
      }
      
      $to_ret = '<select type="dropdown" name="'.$thisAttr->safe.'">';
      
      foreach($select_values as $one_val)
      {
        $to_ret .= '<option value="'.$one_val.'"';
        if(htmlspecialchars($v, ENT_QUOTES) == $one_val)
        {
          $to_ret .= ' selected="selected"';
        }
        $to_ret .= '>'.$one_val.'</option>';
      }
      
      $to_ret .= '</select>';
      
      return array($thisAttr->attr, $to_ret);
    }
    else if($thisAttr->field_type == 'textarea')
    {
      return array($thisAttr->attr, create_textarea($wysiwyg, $v, $thisAttr->safe, '', $thisAttr->attr, '', $stylesheet, 80, 10) );
    }
    else if($thisAttr->field_type == 'checkbox')
    {
      if(isset($thisAttr->select_values) && strpos($thisAttr->select_values, ',') !== false)
      {
        list($is, $isnt) = explode(',', $thisAttr->select_values);
      }
      else
      {
        $is = 'Yes';
        $isnt = 'No';
      }
      
      $to_ret = '<input type="hidden" name="'.$thisAttr->safe.'" value="'.htmlspecialchars($isnt, ENT_QUOTES).'"/>';
      $to_ret .= '<input type="checkbox" id="'.$thisAttr->safe .'" name="'.$thisAttr->safe.'" value="'.htmlspecialchars($is, ENT_QUOTES).'"';
      
      if($v == $is)
      {
        $to_ret .= ' checked="checked"';
      }
      $to_ret .= '><label for="'.$thisAttr->safe.'">'.$is.'</label>';
      return array($thisAttr->attr, $to_ret);
    }
    else
    {
      $l = $thisAttr->length;

      if(empty($l) )
      {
        $l = 25;
        $m = 1024;
      }
      else
      {
        $m = $l;
      }
      return array($thisAttr->attr, '<input type="text" name="'.$thisAttr->safe.'" value="'.htmlspecialchars($v, ENT_QUOTES).'" size="'.$l.'" maxlength="'.$m.'" />');
    }
  }

}
?>]]></data>
	</file>
	<file>
	  <filename>/docs/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/docs/COPYING</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

  The precise terms and conditions for copying, distribution and
modification follow.

                       TERMS AND CONDITIONS

  0. Definitions.

  "This License" refers to version 3 of the GNU General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

  "The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

  To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

  A "covered work" means either the unmodified Program or a work based
on the Program.

  To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

  An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

  1. Source Code.

  The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

  A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

  The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

  The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

  The Corresponding Source for a work in source code form is that
same work.

  2. Basic Permissions.

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

  4. Conveying Verbatim Copies.

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

  5. Conveying Modified Source Versions.

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

  6. Conveying Non-Source Forms.

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

  A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

  "Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

  8. Termination.

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

  9. Acceptance Not Required for Having Copies.

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

  An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

  11. Patents.

  A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

  A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

  In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

  A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

  12. No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

  13. Use with the GNU Affero General Public License.

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

  15. Disclaimer of Warranty.

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. Limitation of Liability.

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

  17. Interpretation of Sections 15 and 16.

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

                     END OF TERMS AND CONDITIONS

            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

Also add information on how to contact you by electronic and paper mail.

  If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:

    <program>  Copyright (C) <year>  <name of author>
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".

  You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.

  The GNU General Public License does not permit incorporating your program
into proprietary programs.  If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.  But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
]]></data>
	</file>
	<file>
	  <filename>/docs/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/images/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/images/admin.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhIAAgAPfCAIKHNftGD6GmUj1HSLzGw/T09PLy8v7+/mRtcGBqbKWnplNbXUpcXWh4eWl6e0pTVObn5jlBQeDh4I+Uk0FKSzpBQXWMinR9fPj4+PX19e7u7m2EgWZuazpKSf3+/TtCQnB5fVtjYWN5eWp+e2lycW10cv7+/fHx8bvFv8HEwt/hxIuOmePk5fb372FlZvz8/IGVkrrCv1NeW1lraOPo55uenqqsr2dscPf4+Pn5+dzd3Jqcntna2cTHxT9IR1ZiXkhSUqi7tvj5+fv7952cp/Dw4+bm5neAfz5KSnqDiKCipk9hYISHh29wdayvrW+KiIaIioWHkpybq2Jqbu/v78XGyLe6ufDw8F1nZ8jLymJvbqSmqLe6vHl/fbCysZSXl+vu7p6opVNZXJCppGdvbl9obHqXk0xaWOHh4WFrbKyurWFrbcbIyX6SlDxERn6TlcnLybm7u0NWVOrr2GyCgDU8PLO7nGdwbj5GRTI5OWRrbXd8fOzs7JicnE1XVzpDQnyYmYOhnzZBQUxeXYyKmlhgZHqVkIGCj/r7+niBh5iXp3uYlHyFiY+loVdjYFpkYbCysuzt7Jeqqa+ysX+Di6+5ti01NLq9vH+Bi0JNTa2wrt/i4fT19Obn587Qz/X27WVucKWrqsLEw0JMS/X29l5hZ3d+ffDx8DtERllhZElZV5aZbHV+hIGZlVdpaf39/f///5udpN3h4Hh7gfT16zhEQ+bp6Pv8+/j5+EZTUWRpbeDi4Wd0dkVNUHB6eUlaWe7v4DxHR////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAMIALAAAAAAgACAAAAj/AIUJFBggwMCDCBMqRFgkgIqFECMSLPhJokWEBQteHHhgE4FKuxRmNLhRWIxFhsJwUggggAAAQzYaoBPI1kJaAAS8BLARjStAYBYCy7lzY5ZfTyTh8EADoQkARHlaLKBFzhIzY4I0SjgHKlQUEguQ6TBI1YxWMGQpbLEKgB0CBAos1HBBBIMzoUTBoRJRAtwOd+QivELCwgZHnUpCyMVAxAUNByX4ejMiBISSAg382GCBxCmBPGQ0cMDBAOaBGUKMaHPEiA4swWqVyHD6IAYODho8QsALSRcMtROWEDSgeJ8XwRNaMZVpgJ8EyQ8ecIIAwYBRQCgoOBD91YQpSShAiErwx0edFMlxfVnDCtUlgQosgUrgpfaJPQ9A4NF0UEEvRmVMcBEpbHCxhR4VfFBBDwlN4kYiaViUQyyHrBBFKgvk4QlEEYDwQESw2DBLDS5QgokYcVj0QQQQIaJGJMLw0YQUNwhx0QKFXLSDIkpEl5AHLBBBSBU+HmQAE7qUAsUtRTbp5JPBBQQAOw==]]></data>
	</file>
	<file>
	  <filename>/images/admin.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAC4jAAAuIwF4pT92AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAKhJREFUeNq1k0EKgCAQRb1EIHS/oG0QBN0mCLqBq1kJ4YmCIKiEHww2ahEtPg35fc6Mo3LOqYQIinpUBrBDjwADTtOnasQXgPBPIx4kgIV5ZRtDbfhaCeDpS2LzpQXeG6BiJp9Ff6qE+iCzKlWCVyc0rGPrMweQkGYhAArBR37BfAAYbpgzJbSxEmJNbNBtjTjbxM/XSMGwpAaJJMD0YpTHXx6TJANFPQebPshL7MfAkQAAAABJRU5ErkJggg==]]></data>
	</file>
	<file>
	  <filename>/images/attributes.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAC4jAAAuIwF4pT92AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAH9JREFUeNpjOHHiBAMQCwHxJSD+TyS+BNXDANLMCTXEDIg/EKH5A1QtWC+IOA/EilABUjBIzyUGqKlPyDAApOc/A5LTYBKEvICijiYGEIv/j3qBygY8J8MLz2EGXAViLTIMAOm5CmLwQAUMgPgtEV54C1UL1gszTZSM7AzSwwAAHFLfZLjCjywAAAAASUVORK5CYII=]]></data>
	</file>
	<file>
	  <filename>/images/global.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/images/global.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAC4jAAAuIwF4pT92AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAK1JREFUeNpjOHHiBAMlGETYA/FtIH4CxF1ArIJHgwpUzROoHnsGKOc/Gt4LxOFAzAbF4VAxdHVPGJA4ZkA8B4g/I4m9gmIY/zNUjRlMDNkAEDsNiCWg9BkkufNAnAnE0lA5BlwGzATi51CaKDl8LiBKbtQFVHLBcyjnJBAnE+GCZKhakPhzWF54jpbaQLYYI4kZAPE0IP6AJPYclhcYCKR3fPmEgVCOuwfFOHMqAK6A4/8vH/ZVAAAAAElFTkSuQmCC]]></data>
	</file>
	<file>
	  <filename>/images/icon.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/images/icon.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/images/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/images/no-image.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhRwAwANUAAP////7+/v39/fz8/Pv7+/r6+vn5+fj4+Pf39/b29vX19fT09PPz8/Ly8vHx8e/v7+7u7u3t7ezs7Ovr6+np6ejo6Ofn5+bm5uXl5eTk5OPj4+Li4uHh4eDg4N/f397e3t3d3dzc3Nvb29ra2tnZ2djY2NfX19bW1tTU1NLS0tHR0c/Pz8zMzP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEHAC0ALAAAAABHADAAAAb/QJZwSCwaj8ikcmlsOZ/QqHRKrVqvT2GLNQF4v+CweEwum8mSxZbVIng8ibN8Ti8jOh3EuuWNhCgDdYKDZBcoEV57XwYcIwqEkIIKJB0FX4pgEiUXApGeZAQXHxABYJhgBRsgC5+tXgohGwZip2EOJxulrpAYKg5ktWIaKL+7dQ0jGARlwWINHRqzxmYEGiUNZ81iBRggDbrTtikVc9pjDCYegeFeBhshj+VaghYnD+wQHxfLdOZlCiI6HNhVoAOJeHX8mZlwossnCCguQFJoxgCJEAMJIfjwAUEkimckiAAkqMIICeAIgTyD4I1HOQpGgLD0aaWcCCsomBlAIQRK/1c25QzoMIKVGAQgOGQEOm/aAxAY1nnJkKKYsaB0CGwggY0BCQ6dwmGt84CEWQcprzZl96BECRFo2QEYK0crVwBewbKja+ZpVDBUre7iO2Zo0TFIlaplswunzjI8faaduDZSSw8vz8Sc2YqwF5Ek65j8+bGyIIsYIW3sWJoxIYYOPUWISNl1HYACCRpE2M/0mXr3wuXbl9A3GXTq5AJwB6+37TLcvE0O52CcvOdjnkVTLqbatWzGvwwTzD0MMmXMwt/KVf5ML/KXfKda1X4OLFm0TGviVD+rKFKmrMWII/0NMkkl8bnmR2gFDmIIBIlo4QYcDXpyRx57cFGhK2nsgQ/FhyCGCCITJJZo4olCBAEAOw==]]></data>
	</file>
	<file>
	  <filename>/images/reload.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhEAAQAPeXAAAAAP///4GkxYytzOL2/2eYxm6UuVN+q1aArAYHBwICAvj7//v+//n///r8//Pz842uzeHz+1N9qi80ONXs9y8wMkNGSU5OTpeZm+L0/M3p+1yAqfH6/9vl7dDR02doat7l7luJuVyFsMrm/c/k8d/y+1F8qmVucklUXFOJu+Hy+YaqyREREXd3d3WJmu3x9BUXGDMzNF9gYm5wcq+vr3t9f6mpqoCAgGiJqxQWF/7+/ubu9IyOkvP19vX6/2Jrbuv9/zg6Pef19xAREfj8/1uEsOT4/9/f3+71+l2Dqejz/2KKtKampnCNrIiftur0/9Xs+jpAQo+amhscHAQEBLy/wgYGBr3O00xQVElJSYKXt/P6/8Tk/FiEslRZXX+Kj3egxZyzwvb6/w8PEP3+/4uszEVjhFxeYbzb8khXYOLz+fb8/+X3//v7+9zi5yA0SOTz+gUGBvP29hETE5Cdojs7O0FBQeL1/b3M01xcXfz//yk4SFZjbCYxQFh/qQ4ODkBBQU1UVz5DRYeIiOz2/5CcofX19eL0+xsdHn+Eic/q+zdTcM/p/t7v8b+/vzM2N8bGxqCyvM7Q0leBrV2CqKm1uC4vMCxIEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAJcALAAAAAAQABAAAAj2AC/hGABhgMGDA8pAWNHk0iUBASJGPFLHkcQABhxCjPigxR8AgDwsYKAn48MAOgzdAMASwJAZLxqYhPjAjhWWCmJYAiBDSAiNAdrQGJRnCoAaboIA+NIFaAAyDBxU+cDjyZU5ORZphGSjhwMiYpA0MhIhEIA3GrOwkLTABwc4Kgjc+QGgj8YLADBsIQQkAwECJaIA2OMQDBMFFTooYfNXTaEEE8w4LCDnDAALeCL8pQMjQaQkkxuAwAIAkZcTguJQkQKF0uQAa3YkGtPyUaVDFDY4TMFoBBc0LtKg4BNGAwlFfhw6MXFAgoQDB4ogQDBJxBItlwICADs=]]></data>
	</file>
	<file>
	  <filename>/images/templates.png</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAC4jAAAuIwF4pT92AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAJxJREFUeNq1U0EKwCAM8+TDPPmwgTDYezx59yGC4Ce2OqoUqdIhO0RmJDGtnYoxasABSIBbiIQarWBxH4QjXDUouDEAJYRBTVHErR3SkhrXIxPu1XEGjuF6ZIkBV1KPLDEY9zOeNQiLhrYUYWXg8dsyBhbP/K8l0CZa5vay+4ynxKAOywXIhMvIsYNUFo2bwdJR3vmZzjGyVNhLegBIuOj9M4S+bQAAAABJRU5ErkJggg==]]></data>
	</file>
	<file>
	  <filename>/images/trans.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhAQABAIAAAAAAAAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==]]></data>
	</file>
	<file>
	  <filename>/includes/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/includes/admin.css</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[dGFibGUubW9kdWxlX2NhdF90YWJsZSB7Zm9udC1zaXplOiAxMHB4OyB3aWR0aDo3MDBweDsgbWFyZ2luOiAwO30KLmNhdF9sZWdfaGVhZHtjb2xvcjpzaWx2ZXI7YmFja2dyb3VuZC1jb2xvcjogIzIzMjMyMzt9Ci5jYXRfc3VibGVnX2hlYWR7Y29sb3I6c2lsdmVyO2JhY2tncm91bmQtY29sb3I6IGdyYXk7fQoubW9kdWxlX2NhdF9hcmVhX3dpZGUge3dpZHRoOiA1NTdweDt9Ci5tb2R1bGVfY2F0X2xlZ2VuZHtmb250LXNpemU6IDlweDsgbWFyZ2luOiA2cHggMDsgYm9yZGVyOiAxcHggc29saWQgYmxhY2s7IG1heC13aWR0aDo4MCU7bWluLXdpZHRoOjMwJTt9Ci5tb2R1bGVfY2F0X2FyZWFfc2hvcnQge3dpZHRoOiA1MDBweDsgaGVpZ2h0OiAxMDBweDt9Ci5tb2R1bGVfY2F0X2xpbmsge3RleHQtZGVjb3JhdGlvbjogdW5kZXJsaW5lO30KLm1vZHVsZV9jYXRfZmllbGRzZXQge21hcmdpbi1ib3R0b206MmVtO30KLm1vZHVsZV9jYXRyX3RhYmxlIHRyLnJvdzE6aG92ZXIsIC5tb2R1bGVfY2F0cl90YWJsZSB0ci5yb3cyOmhvdmVye2JhY2tncm91bmQ6ICNDQ0RCREQ7fQoub2RkIHtiYWNrZ3JvdW5kLWNvbG9yOiAjZmZmO3RleHQtYWxpZ246bGVmdDt2ZXJ0aWNhbC1hbGlnbm1lbnQ6IHRvcDt9Ci5ldmVuIHtiYWNrZ3JvdW5kLWNvbG9yOiAjZGRkO3RleHQtYWxpZ246bGVmdDt2ZXJ0aWNhbC1hbGlnbm1lbnQ6IHRvcDt9Ci5pbnB1dGhlbHAgIHsgY29sb3I6ICMzODQ2NTQ7IHBhZGRpbmc6IDA7IG1hcmdpbjogMDsgd2lkdGg6IGF1dG87IHRleHQtYWxpZ246bGVmdDsgfQ==]]></data>
	</file>
	<file>
	  <filename>/includes/Category-CSS-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e3NlY3Rpb24gbmFtZT1udW1pbWcgbG9vcD0kaW1hZ2VfdXJsX2FycmF5fTxpbWcgc3JjPSJ7JGltYWdlX3VybF9hcnJheVtudW1pbWddfSIgYWx0PSJ7dGl0bGV9IiB0aXRsZT0ie3RpdGxlfSIgLz57L3NlY3Rpb259DXskbm90ZXN9DTxkaXYgY2xhc3M9ImNhdGVnb3J5X2l0ZW1zIj4NICAge2lmICRoYXNuYXYgPT0gMX0NPGRpdiBjbGFzcz0iY2F0bmF2Ij57JHByZXZ9eyRuYXZzdHJ9eyRuZXh0fTwvZGl2Pg0Jey9pZn0NICAgIHtzZWN0aW9uIG5hbWU9bnVtbG9vcCBsb29wPSRpdGVtc30NICAgICAgICA8ZGl2IGNsYXNzPSJjYXRlZ29yeV9pdGVtIj48YSBocmVmPSJ7JGl0ZW1zW251bWxvb3BdLmxpbmt9Ij48aW1nIHNyYz0ieyRpdGVtc1tudW1sb29wXS5pbWFnZX0iIHRpdGxlPSJ7JGl0ZW1zW251bWxvb3BdLnRpdGxlfSIgYWx0PSJ7JGl0ZW1zW251bWxvb3BdLnRpdGxlfSIvPjwvYT48YnIgLz48YSBocmVmPSJ7JGl0ZW1zW251bWxvb3BdLmxpbmt9Ij57JGl0ZW1zW251bWxvb3BdLnRpdGxlfTwvYT48L2Rpdj4NICAgIHsvc2VjdGlvbn0NICAgIHtpZiAkaGFzbmF2ID09IDF9DXsqIA1UaGUgbnVtYmVyIHRoYXQgaXMgd2l0aG91dCBhIGxpbmsgKGEgaHJlZikgaGF2ZSBhIDxzcGFuIGNsYXNzPSJub2xpbmsiICkgaGF2ZSBhIGxvb2sgaW4gc291cmNlIGNvZGUtaHRtbA0qfQ08ZGl2IGNsYXNzPSJjYXRuYXYiPnskcHJldn17JG5hdnN0cn17JG5leHR9PC9kaXY+DQl7L2lmfQ08L2Rpdj4N]]></data>
	</file>
	<file>
	  <filename>/includes/Category-Table-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2Fzc2lnbiB2YXI9ImNvbHMiIHZhbHVlPSIzIn0NCntzZWN0aW9uIG5hbWU9bnVtaW1nIGxvb3A9JGltYWdlX3VybF9hcnJheX08aW1nIHNyYz0ieyRpbWFnZV91cmxfYXJyYXlbbnVtaW1nXX0iIHRpdGxlPSJ7dGl0bGV9IiBhbHQ9Int0aXRsZX0iIC8+ey9zZWN0aW9ufQ0KPHRhYmxlIHN0eWxlPSJib3JkZXI6IHNvbGlkIDFweCBibGFjazsiPg0KPHRyPg0KICAgIHtzZWN0aW9uIG5hbWU9bnVtbG9vcCBsb29wPSRpdGVtc30NCiAgICAgICAgPHRkIHN0eWxlPSJ3aWR0aDogMjAwcHg7Ij48YSBocmVmPSJ7JGl0ZW1zW251bWxvb3BdLmxpbmt9Ij48aW1nIHNyYz0ieyRpdGVtc1tudW1sb29wXS5pbWFnZX0iIHRpdGxlPSJ7JGl0ZW1zW251bWxvb3BdLnRpdGxlfSIgYWx0PSJ7JGl0ZW1zW251bWxvb3BdLnRpdGxlfSIvPjwvYT48YnIgLz48YSBocmVmPSJ7JGl0ZW1zW251bWxvb3BdLmxpbmt9Ij57JGl0ZW1zW251bWxvb3BdLnRpdGxlfTwvYT48L3RkPg0KICAgICAgICB7aWYgbm90ICgkc21hcnR5LnNlY3Rpb24ubnVtbG9vcC5yb3dudW0gbW9kICRjb2xzKX0NCiAgICAgICAgICAgICAgICB7aWYgbm90ICRzbWFydHkuc2VjdGlvbi5udW1sb29wLmxhc3R9DQogICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0cj4NCiAgICAgICAgICAgICAgICB7L2lmfQ0KICAgICAgICB7L2lmfQ0KICAgICAgICB7aWYgJHNtYXJ0eS5zZWN0aW9uLm51bWxvb3AubGFzdH0NCiAgICAgICAgICAgICAgICB7bWF0aCBlcXVhdGlvbiA9ICJuIC0gYSAlIG4iIG49JGNvbHMgYT0kaXRlbXN8QGNvdW50IGFzc2lnbj0iY2VsbHMifQ0KICAgICAgICAgICAgICAgIHtpZiAkY2VsbHMgbmUgJGNvbHN9DQogICAgICAgICAgICAgICAge3NlY3Rpb24gbmFtZT1wYWQgbG9vcD0kY2VsbHN9DQogICAgICAgICAgICAgICAgICAgICAgICA8dGQgc3R5bGU9IndpZHRoOiAyMDBweDsiPiZuYnNwOzwvdGQ+DQogICAgICAgICAgICAgICAgey9zZWN0aW9ufQ0KICAgICAgICAgICAgICAgIHsvaWZ9DQogICAgICAgICAgICAgICAgPC90cj4NCiAgICAgICAgey9pZn0NCiAgICB7L3NlY3Rpb259DQogICAge2lmICRoYXNuYXYgPT0gMX0NCjx0cj48dGR7aWYgJGNvbHMgZ3QgMX0gY29sc3Bhbj0ieyRjb2xzfSJ7L2lmfSBzdHlsZT0iYm9yZGVyLXRvcDogc29saWQgMXB4IGJsYWNrOyI+eyRwcmV2fXskbmF2c3RyfXskbmV4dH08L3RkPjwvdHI+DQoJey9pZn0NCjwvdGFibGU+DQo=]]></data>
	</file>
	<file>
	  <filename>/includes/Comparison-Table-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0iaXRlbV9jb21wYXJpc29uIj4NPHRhYmxlPg0JPHRyPg0JCTx0aD48L3RoPg0JCXtzZWN0aW9uIG5hbWU9YXQgbG9vcD0kYXR0cmxpc3R9DQkJCTx0aD57JGF0dHJsaXN0W2F0XS0+YXR0cn08L3RoPg0JCXsvc2VjdGlvbn0NCTwvdHI+DQl7Zm9yZWFjaCBmcm9tPSRpdGVtcyBpdGVtPXRpfQ0JCTx0cj4NCQkJPHRkPg0JCQkJPGEgaHJlZj0ieyR0aS5saW5rfSI+DQkJCQk8aW1nIHNyYz0ieyRpbWFnZV9yb290fT9pPXskdGkuYWxpYXN9X3RfMV81MF8xLmpwZyIgLz48L2E+PGJyIC8+DQkJCQl7JHRpLnRpdGxlfQ0JCQk8L3RkPg0JCQl7c2VjdGlvbiBuYW1lPWF0IGxvb3A9JGF0dHJsaXN0fQ0JCQkJPHRkPg0JCQkJCXthc3NpZ24gdmFyPWF0dHJrZXkgdmFsdWU9YCRhdHRybGlzdFthdF0tPnNhZmVgfXskdGlbJGF0dHJrZXldfQ0JCQkJPC90ZD4NCQkJey9zZWN0aW9ufQ0JCTwvdHI+DQl7L2ZvcmVhY2h9DTwvdGFibGU+DTwvZGl2Pg0=]]></data>
	</file>
	<file>
	  <filename>/includes/Feature-CSS-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0iZmVhdHVyZV9pdGVtcyI+DSAgICB7c2VjdGlvbiBuYW1lPW51bWxvb3AgbG9vcD0kaXRlbXN9DSAgICAgICAgPGRpdiBjbGFzcz0iZmVhdHVyZV9pdGVtIj48YSBocmVmPSJ7JGl0ZW1zW251bWxvb3BdLmxpbmt9Ij48aW1nIHNyYz0ieyRpdGVtc1tudW1sb29wXS5pbWFnZX0iIHRpdGxlPSJ7JGl0ZW1zW251bWxvb3BdLnRpdGxlfSIgYWx0PSJ7JGl0ZW1zW251bWxvb3BdLnRpdGxlfSIvPjwvYT48YnIgLz48YSBocmVmPSJ7JGl0ZW1zW251bWxvb3BdLmxpbmt9Ij57JGl0ZW1zW251bWxvb3BdLnRpdGxlfTwvYT48L2Rpdj4NICAgIHsvc2VjdGlvbn0NPC9kaXY+DQ==]]></data>
	</file>
	<file>
	  <filename>/includes/Feature-Table-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2Fzc2lnbiB2YXI9ImNvbHMiIHZhbHVlPSIxIn0NPHRhYmxlIHN0eWxlPSJib3JkZXI6IHNvbGlkIDFweCBibGFjazsiPg08dHI+DSAgICB7c2VjdGlvbiBuYW1lPW51bWxvb3AgbG9vcD0kaXRlbXN9DSAgICAgICAgPHRkIHN0eWxlPSJ3aWR0aDogMjAwcHg7Ij48YSBocmVmPSJ7JGl0ZW1zW251bWxvb3BdLmxpbmt9Ij48aW1nIHNyYz0ieyRpdGVtc1tudW1sb29wXS5pbWFnZX0iIHRpdGxlPSJ7JGl0ZW1zW251bWxvb3BdLnRpdGxlfSIgYWx0PSJ7JGl0ZW1zW251bWxvb3BdLnRpdGxlfSIvPjwvYT48YnIgLz48YSBocmVmPSJ7JGl0ZW1zW251bWxvb3BdLmxpbmt9Ij57JGl0ZW1zW251bWxvb3BdLnRpdGxlfTwvYT48L3RkPg0gICAgICAgIHtpZiBub3QgKCRzbWFydHkuc2VjdGlvbi5udW1sb29wLnJvd251bSBtb2QgJGNvbHMpfQ0gICAgICAgICAgICAgICAge2lmIG5vdCAkc21hcnR5LnNlY3Rpb24ubnVtbG9vcC5sYXN0fQ0gICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0cj4NICAgICAgICAgICAgICAgIHsvaWZ9DSAgICAgICAgey9pZn0NICAgICAgICB7aWYgJHNtYXJ0eS5zZWN0aW9uLm51bWxvb3AubGFzdH0NICAgICAgICAgICAgICAgIHttYXRoIGVxdWF0aW9uID0gIm4gLSBhICUgbiIgbj0kY29scyBhPSRpdGVtc3xAY291bnQgYXNzaWduPSJjZWxscyJ9DSAgICAgICAgICAgICAgICB7aWYgJGNlbGxzIG5lICRjb2xzfQ0gICAgICAgICAgICAgICAge3NlY3Rpb24gbmFtZT1wYWQgbG9vcD0kY2VsbHN9DSAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBzdHlsZT0id2lkdGg6IDIwMHB4OyI+Jm5ic3A7PC90ZD4NICAgICAgICAgICAgICAgIHsvc2VjdGlvbn0NICAgICAgICAgICAgICAgIHsvaWZ9DSAgICAgICAgICAgICAgICA8L3RyPg0gICAgICAgIHsvaWZ9DSAgICB7L3NlY3Rpb259CjwvdGFibGU+DQ==]]></data>
	</file>
	<file>
	  <filename>/includes/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/includes/Item-CSS-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0iY2F0YWxvZ19pdGVtIj4NPGRpdiBjbGFzcz0iaXRlbV9pbWFnZXMiPjxpbWcgaWQ9Iml0ZW1faW1hZ2UiIG5hbWU9Iml0ZW1faW1hZ2UiICBzcmM9InskaW1hZ2VfMV91cmx9IiBhbHQ9Int0aXRsZX0iIHRpdGxlPSJ7dGl0bGV9IiAvPg08ZGl2IGNsYXNzPSJpdGVtX3RodW1ibmFpbHMiPntzZWN0aW9uIG5hbWU9aW5kIGxvb3A9JGltYWdlX3VybF9hcnJheX0NPGEgaHJlZj0iamF2YXNjcmlwdDpyZXBsKCd7JGltYWdlX3VybF9hcnJheVtpbmRdfScpIj48aW1nIHNyYz0ieyRpbWFnZV90aHVtYl91cmxfYXJyYXlbaW5kXX0iIHRpdGxlPSJ7dGl0bGV9IiBhbHQ9Int0aXRsZX0iIC8+PC9hPg17L3NlY3Rpb259PC9kaXY+PC9kaXY+DXtzZWN0aW9uIG5hbWU9YXQgbG9vcD0kYXR0cmxpc3R9DTxkaXYgY2xhc3M9Iml0ZW1fYXR0cmlidXRlX25hbWUiPnskYXR0cmxpc3RbYXRdLm5hbWV9OjwvZGl2PjxkaXYgY2xhc3M9Iml0ZW1fYXR0cmlidXRlX3ZhbCI+e2V2YWwgdmFyPSRhdHRybGlzdFthdF0ua2V5fTwvZGl2Pg17L3NlY3Rpb259DTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NZnVuY3Rpb24gcmVwbChpbWcpDXsNICBkb2N1bWVudC5pdGVtX2ltYWdlLnNyYz1pbWc7DX0NPC9zY3JpcHQ+DQ17aWYgJGZpbGVfY291bnQgPiAwfQ08dWwgY2xhc3M9ImZpbGVzIj57c2VjdGlvbiBuYW1lPWluZCBsb29wPSRmaWxlX25hbWVfYXJyYXl9DTxsaT48YSBocmVmPSJ7JGZpbGVfdXJsX2FycmF5W2luZF19Ij57JGZpbGVfbmFtZV9hcnJheVtpbmRdfTwvYT48L2xpPg17L3NlY3Rpb259DTwvdWw+DXsvaWZ9DQ08L2Rpdj4N]]></data>
	</file>
	<file>
	  <filename>/includes/Item-Table-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0iaXRlbSI+DTx0YWJsZT48dHI+PHRkPjxpbWcgaWQ9Iml0ZW1faW1hZ2UiIG5hbWU9Iml0ZW1faW1hZ2UiICBzcmM9InskaW1hZ2VfMV91cmx9IiB0aXRsZT0ie3RpdGxlfSIgYWx0PSJ7dGl0bGV9IiAvPjwvdGQ+DTx0ZD57c2VjdGlvbiBuYW1lPWluZCBsb29wPSRpbWFnZV91cmxfYXJyYXl9DTxhIGhyZWY9ImphdmFzY3JpcHQ6cmVwbCgneyRpbWFnZV91cmxfYXJyYXlbaW5kXX0nKSI+PGltZyBzcmM9InskaW1hZ2VfdGh1bWJfdXJsX2FycmF5W2luZF19IiB0aXRsZT0ie3RpdGxlfSIgYWx0PSJ7dGl0bGV9IiAvPjwvYT4Ney9zZWN0aW9ufTwvdGQ+PC90cj48L3RhYmxlPg17c2VjdGlvbiBuYW1lPWF0IGxvb3A9JGF0dHJsaXN0fQ08cD48c3Ryb25nPnskYXR0cmxpc3RbYXRdLm5hbWV9PC9zdHJvbmc+OiB7ZXZhbCB2YXI9JGF0dHJsaXN0W2F0XS5rZXl9PC9wPg17L3NlY3Rpb259DTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NZnVuY3Rpb24gcmVwbChpbWcpDXsNIGRvY3VtZW50Lml0ZW1faW1hZ2Uuc3JjPWltZzsNfQ08L3NjcmlwdD4NPC9kaXY+DQ==]]></data>
	</file>
	<file>
	  <filename>/includes/misc/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/includes/misc/fls_lst.inc</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCiRjYXRfZmlsZXNfMl9yZW1vdmUgPSBhcnJheSgNCidjb250ZW50dHlwZS5jYXRhbG9nY2F0ZWdvcnkucGhwJywNCidjb250ZW50dHlwZS5jYXRhbG9naXRlbS5waHAnLA0KJ2NvbnRlbnR0eXBlLmNhdGFsb2dwcmludGFibGUucGhwJw0KKTsgIA0KPz4=]]></data>
	</file>
	<file>
	  <filename>/includes/misc/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/includes/Printable-Catalog-Table-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2Fzc2lnbiB2YXI9ImNvbHMiIHZhbHVlPSIzIn0NPHRhYmxlIHN0eWxlPSJib3JkZXI6IHNvbGlkIDFweCBibGFjazsiPg08dHI+DXtzZWN0aW9uIG5hbWU9bnVtbG9vcCBsb29wPSRpdGVtc30NICAgICAgICA8dGQgc3R5bGU9IndpZHRoOiAyMDBweDsiPjxhIGhyZWY9InskaXRlbXNbbnVtbG9vcF0ubGlua30iPjxpbWcgc3JjPSJ7JGl0ZW1zW251bWxvb3BdLmltYWdlfSIgdGl0bGU9InskaXRlbXNbbnVtbG9vcF0udGl0bGV9IiBhbHQ9InskaXRlbXNbbnVtbG9vcF0udGl0bGV9Ii8+PC9hPjxiciAvPjxhIGhyZWY9InskaXRlbXNbbnVtbG9vcF0ubGlua30iPnskaXRlbXNbbnVtbG9vcF0udGl0bGV9PC9hPjxiciAvPkNhdGVnb3J5OiB7JGl0ZW1zW251bWxvb3BdLmNhdH08YnIgLz4Ne2ZvcmVhY2ggZnJvbT0kYXR0cmxpc3QgaXRlbT1hdHRyIGtleT1rfQ17JGF0dHJ9OiB7JGl0ZW1zW251bWxvb3BdWyRrXX0NPGJyIC8+DXsvZm9yZWFjaH0NPC90ZD4NICAgICAgICB7aWYgbm90ICgkc21hcnR5LnNlY3Rpb24ubnVtbG9vcC5yb3dudW0gbW9kICRjb2xzKX0NICAgICAgICAgICAgICAgIHtpZiBub3QgJHNtYXJ0eS5zZWN0aW9uLm51bWxvb3AubGFzdH0NICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHI+DSAgICAgICAgICAgICAgICB7L2lmfQ0gICAgICAgIHsvaWZ9DSAgICAgICAge2lmICRzbWFydHkuc2VjdGlvbi5udW1sb29wLmxhc3R9DSAgICAgICAgICAgICAgICB7bWF0aCBlcXVhdGlvbiA9ICJuIC0gYSAlIG4iIG49JGNvbHMgYT0kaXRlbXN8QGNvdW50IGFzc2lnbj0iY2VsbHMifQ0gICAgICAgICAgICAgICAge2lmICRjZWxscyBuZSAkY29sc30NICAgICAgICAgICAgICAgIHtzZWN0aW9uIG5hbWU9cGFkIGxvb3A9JGNlbGxzfQ0gICAgICAgICAgICAgICAgICAgICAgICA8dGQgc3R5bGU9IndpZHRoOiAyMDBweDsiPiZuYnNwOzwvdGQ+DSAgICAgICAgICAgICAgICB7L3NlY3Rpb259DSAgICAgICAgICAgICAgICB7L2lmfQ0gICAgICAgICAgICAgICAgPC90cj4NICAgICAgICB7L2lmfQ0gICB7L3NlY3Rpb259DTwvdGFibGU+DXskY29weXJpZ2h0fQ==]]></data>
	</file>
	<file>
	  <filename>/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/lang/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/en_US.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages']='Images';
$lang['namefiles']='Files';
$lang['namefile']='File';
$lang['deleteimage']='Delete Image';
$lang['deletefile']='Delete File';
$lang['Owner']='Owner';
$lang['CatalogItem']='Item Cataloger';
$lang['namepage']='Page';
$lang['Permissions']='Permissions';
$lang['Sub']='Sub -';
$lang['title_global_item_sort_order2'] = 'Item Sort Order';
$lang['title_global_items_per_page2']= 'Items Per Page';
$lang['title_global_category_recurse2'] = 'Display Behavior';
$lang['which_attributes'] = 'Which attributes should be shown in catalog';
$lang['navTab'] = ' | ';  

$lang['needpermission']='You need %s set to do that.';
$lang['friendlyname']='Cataloger';
$lang['admindescription']='Manage Catalog settings';
$lang['areyousure']='Are you sure you want to delete this %s?';
$lang['uniquecode']='Unique Code';
$lang['templatelist']='Sub-templates';
$lang['listtempl']='Manage Sub-templates';
$lang['title_upload'] = 'Upload';
$lang['title_field_type'] = 'Field Type';
$lang['title_select_values'] = 'Value';
$lang['title_item_tab']='Item Attributes';
$lang['title_category_tab']='Category Attributes';
$lang['title_printable_tab']='Printable Catalog Attributes';
$lang['title_item_image_tab']='Item Image Settings';
$lang['title_category_image_tab']='Category Page Settings';
$lang['title_printable_tab']='Printable Catalog Settings';
$lang['title_path_tab']='Paths';
$lang['title_delete']='Delete?';
$lang['title_file_tab']='Item File Settings';
$lang['title_image_tab']='Other Image Settings';
$lang['title_item_template_vars'] = 'Item Template Variables';
$lang['title_cat_template_vars'] = 'Category Template Variables';
$lang['title_catalog_template_vars']='Catalog Template Variables';
$lang['title_compare_template_vars']='Comparison Template Variables';
$lang['title_feature_template_vars']='Feature list Template Variables';
$lang['title_show_only_existing_images']='Don\'t include missing images';
$lang['title_show_only_existing_images_help']='This will only put image references into lists if the image exists.<br />(Normally, this is fine, but if you are doing something clever with image<br />array indexes, this could cause you trouble.)';
$lang['title_flush_cats']='Flush category page buffers';
$lang['title_flush_cats_help']='If you have a huge number of items displayed<br />in a category, some PHP installs will fail to display the page<br />correctly. Check this box to solve this problem (test for side effects).';
$lang['title_item_file_types']='Permitted file types';
$lang['title_image_upload_path']='Location for uploaded image files';
$lang['title_file_upload_path']='Location for other uploaded item files';
$lang['title_image_proc_path']='Location for processed images (thumbnails, scaled images, etc)';
$lang['path_help']='You can specify where Cataloger stores files. These paths are relative to the <i>uploads_path</i> defined in your config.php<br />NOTE: If you change these paths after files or images have been uploaded, Cataloger will lose the already-uploaded assets (they will still be there, but Cataloger will not know about them, so you will need to re-upload them for Cataloger to figure it out).';

$lang['cataloger']='Cataloger';

$lang['title_attr_order_by']='Order';
$lang['title_attr_alias']='Attribute Alias (Smarty Friendly)';
$lang['title_attr_length']='Length*';
$lang['title_attr_default']='Default Value';
$lang['title_attr_length_help']='*Length only applies to "Text"<br />Value is a comma-delimited list of options for Dropdowns<br />Value should contain the checked value, a comma, and the unchecked value for checkbox';

$lang['text'] = 'Text';
$lang['dropdown'] = 'Dropdown';
$lang['textarea'] = 'Text Area';
$lang['checkbox'] = 'Checkbox';

$lang['tab_advanced_options'] = 'Cataloger Adv. Opts';
$lang['tab_fields_list'] = 'Cataloger Fields List';
$lang['tab_images'] = 'Cataloger Images';
$lang['tab_files'] = 'Cataloger Files';


$lang['item_page'] = 'Item Page';
$lang['category_page'] = 'Category Page';
$lang['catalog_printable'] = 'Printable Catalog';
$lang['catalog_datasheet'] = 'Catalog Datasheet';
$lang['catalog_short_list']='Feature List';
$lang['item_comparison'] = 'Item Comparison';

$lang['title_global_item_sort_order'] = 'Set item sort order to';
$lang['title_global_items_per_page']= 'Set number of items per page to';
$lang['title_global_category_recurse'] = 'Set Category Display Behavior to';

$lang['title_item_sort_order'] = 'Default item sort order';
$lang['title_printable_sort_order'] = 'Default printable catalog sort order';
$lang['title_items_per_page']= 'Default number of items per page';
$lang['title_avail_attrs'] = 'Item attributes available for the template';
$lang['title_avail_imattrs'] = 'Item images available for the template';
$lang['title_item_image_size_hero'] = 'Image size for Item Page (long axis in pixels)';
$lang['title_item_image_size_thumbnail'] = 'Thumbail image size for Item Page (long axis in pixels)';
$lang['title_item_image_size_category'] = 'Thumbnail image size for Item on Category Page (long axis in pixels)';
$lang['title_item_image_size_catalog'] = 'Thumbnail image size for Item on Catalog Page (long axis in pixels)';
$lang['title_category_image_size_hero'] = 'Image size for Category Page (long axis in pixels)';
$lang['title_category_image_size_thumbnail'] = 'Thumbail image size for Category Page (long axis in pixels)';
$lang['title_template']='Template';
$lang['title_template_type']='Template Type';
$lang['title_title']='Title';
$lang['title_item_image_count']='Maximum number of views for each Item';
$lang['title_item_file_count']='Maximum number of other files associated with each item';
$lang['title_category_image_count']='Maximum number of Banner images for each Category Page';
$lang['title_item_attributes_help']='Each attribute you enter here will be the title of a field that you can use to describe an individual item, and will be displayed with that item. You may have to update your template to reflect these attributes.';
$lang['title_category_attributes_help']='Each attribute you enter here will be the title of a field that you can use to describe an item category, and will be displayed on that category page. You may have to update your template to reflect these attributes.';
$lang['title_catalog_attributes_help']='Each attribute you enter here will be the title of a field that you can use to describe the entire catalog, and will be displayed on the printable catalog page. You may have to update your template to reflect these attributes.';
$lang['title_category_sort'] = 'Category Page Item-list sort order';
$lang['title_category_recurse'] = 'Default Category Display Behavior';
$lang['title_category_recurse_items_all'] = 'Include all Items within this category, including items in sub-categories';
$lang['title_category_recurse_items_one'] = 'Include all Items immediately within this category, but not items in sub-categories';
$lang['title_category_recurse_categories_all'] = 'Include all Categories within this category, including categories in sub-categories';
$lang['title_category_recurse_categories_one'] = 'Include all Categories immediately within this category, but not categories in sub-categories';
$lang['title_category_recurse_mixed_all'] = 'Include all Items and Categories within this category, including items and categories in sub-categories';
$lang['title_category_recurse_mixed_one'] = 'Include all Items and Categories immediately within this category, but not items or categories in sub-categories';
$lang['title_show_missing_images'] = 'Show "No Image" image for missing images';
$lang['title_show_missing_images_long'] = 'Show a special "No Image" image if there are missing images (useful for debugging. Otherwise will use a single pixel transparent image).';
$lang['natural_order'] = 'Navigation Order';
$lang['alpha_order'] = 'Alphabetical Order';

$lang['manageprefs']='Manage Preferences';
$lang['manageattrs']='Manage User-Defined Attributes';
$lang['globalops']='Global Catalog Operations';
$lang['addtemplate']='Add a new Sub-template';
$lang['reimporttemplates']='Re-import example sub-templates';
$lang['reimported'] = 'Sample sub-templates have been imported.';
$lang['templateupdated']='Template added/updated.';
$lang['templatedeleted']='Template deleted.';
$lang['prefsupdated']='Preferences updated.';
$lang['installed'] = 'Module version %s installed.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['badfile'] = 'File "%s" is not an acceptable format.';
$lang['badimage'] = 'Problem uploading "%s" (check file size and/or server permissions).';
$lang['badimageformat'] = '"%s" is not valid. Only jpegs are supported for the time being.';
$lang['uploaded'] = 'File "%s" uploaded for item %s.';
$lang['uninstalled'] = 'Module Uninstalled.';
$lang['attrsupdated'] = 'Attributes updated.';
$lang['noglobalchange'] = 'Do not change';
$lang['globallyupdated'] = 'Changes propagated globally.';
$lang['addtemplate'] = 'Add Template';
$lang['edittemplate'] = 'Edit Template';
$lang['subtemplates'] = 'Catalog Sub-templates';
$lang['next'] = ':&#187;';
$lang['prev'] = '&#171;:';
$lang['edit'] = 'Edit';
$lang['delete']='Delete';
$lang['notemplates']='No Sub-templates are installed!';

$lang['helptext']='
<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of "Catalog Items" which could be products, works of art, or the like, and "Catalog Categories" which could be item categories or other natural divisions of the catalog.</p>
<p>Categories may be defined hierarchically (using the standard CMS Made Simple content list). Category pages can display items in the category and/or subcategories, optionally recursing through sub-categories. This behavior can be configured on a per-category basis.</P>
<p>There is also a Printable Catalog, which represents the whole collection of Catalog Items on a single page (this is currently implemented badly, and will load slowly).</p>
<p>The module has built-in support for "Content Aliases" (a module available at <a href="http://dev.cmsmadesimple.org/projects/contentaliases/">the Developer Forge</a>), which allows you to place any Catalog Item into multiple Catalog Categories.</p>
<h3>How Do I Use It</h3>
<p>When you install this module, it creates three new Content Types: Catalog Item, Catalog Category, and Printable Catalog. When you\'re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content &gt; Pages &gt; Add Content, and then select "Catalog Item" or "Catalog Category" from the Content Type pulldown.</p>
<h4>Catalog Items</h4>
<p>Adding a Catalog Item is similar to adding an ordinary page to your site. The data fields for the Item are not exactly the same, however. Also note that in the "Images" tab, you can select multiple images to upload for the item. When you upload images, the system will size them appropriately for the catalog, create thumbnails for use in the Item\'s page, create thumbnails for any Category pages, and so on. This requires that you have GD or a similar image library installed. Currently, only jpeg format images are supported.</p>
<h4>Catalog Categories</h4>
<p>A Catalog Category is used for organizing your catalog items. It provides a page that lists Cataloger content that is contained by it. A Catalog Item is considered to be part of a Catalog Category if it is below that Category in the Site Hierarchy. Categories can similarly include other Categories.</p>
<p>Catalog Categories have a number of settings to determine how they should display the Items and Categories they contain: if you look at the "Options" tab, you can choose how many items and/or categories to show, what order to show them in, whether to display only items or only categories or both, and how many levels of the hierarchy to display below the category page.</p>
<p>For example, consider the following structure:</p>
<ol>
	<li><b>Hats</b>
		<ol>
			<li><b>Fashion</b>
			 	<ol>
			 		<li>Feathered Hat</li><li>Fedora </li><li>Baseball Hat</li>
			 	</ol>
			 </li>
		 	<li><b>Work Hats</b>
		    	<ol>
		    		<li>Hard Hat</li><li>Diving Helmet</li>
		    	</ol>
		    </li>
		</ol>
	</li>
</ol>
<p>In this diagram, bolded items are Catalog Categories, and non-bolded items are Catalog Items. Depending upon how you set your options, the Hats Category Page can show only entries for the Fashion and Work Hats Category Pages, or it can show entries for Fashion, Work Hats, and all the hats listed below them.</p>
<p>You can opt to show the items in "natural" order (i.e., the order the Items show up in the CMS Content Hierarchy), or in alphabetical order.</P>
<p>If you have large numbers of items in a Category, you can set the maximum number to be displayed in a Category Page, and the page will automatically create links to navigate through the list.</p>
<p>Each Category page can have different settings for sort order, levels to display, and number of items. You can set the default for these values in Extensions &gt; Cataloger &gt; Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions &gt; Cataloger &gt; Global Catalog Options, and make those changes.</p>
<h4>Images</h4>
<p>Cataloger allows you to select different size images for Item pages, Category pages, and the Printable Catalog. You can set these defaults in Extensions &gt; Cataloger &gt; Manage Preferences.</p>
<p>When you upload images, the original is stored. When someone visits a page, the reduced size images are requested using a special URL, which will redirect the user\'s browser to the scaled image if it exists, and creating the scaled image if it doesn\'t. This allows you to change the size of images, without having to re-upload all the images, or rescaling them all at once.</p>
<p>This image rescaling code requires that you have either ImageMagick or GD lib installed, and configured in your CMS Made Simple config.php.</p>
<h4>Files</h4>
<p>Cataloger allows you to associate arbitrary files with any Item page. These are uploaded via the admin, just like images. There
have been rudimentary security considerations (e.g., file-extension-based restrictions), however, as with any file upload
capability that puts files inside the web root, if you do not trust your uploaders, you are at some degree of risk. You have been warned.</p>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have "feature lists" which are the <i>n</i> most-recently added catalog items, or a collection of <i>k</i> random items from the catalog.</p>
<h4>"All" Feature List</h4>
<p>To get a list of all catalog items (optionally under a specified part of your hierarchy) for processing via a template, you can use
the "all" feature list.</p>
<p>The syntax for an "all" list is like:</p>
<p>&#123;Cataloger action=\'all\' sub_template=\'my_sub_template\'}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=\'page_alias\', where page_alias indicates the top of the tree (e.g., a place in your menu
hierarchy, typically a category page) in which to look for new items. A special value for "page_alias" is "/", which means to
start at the root.</p>
<p>This is useful for catalog-wide operations. For example, to get a list of all categories (and do something with them),
you could use the tag &#123;Cataloger action=\'all\' sub_template=\'my_sub_template\' alias=\'/\' recurse=\'categories_all\'}. Your template could then throw
those categories into a pulldown menu that redirected you to that category\'s page, for example:</p>
<pre>
&lt;select name="foo" onchange="document.location=this.options[this.selectedIndex].value;">
&lt;option value="">Select A target&lt;/option>
&#123;foreach from=$items item=thisone}
   &lt;option value="&#123;$thisone.link}">&#123;$thisone.title}&lt;/option>
&#123;/foreach}
&lt;/select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your hierarchy, you\'d replace the recurse=\'categories_all\' with
recurse=\'categories_one\'. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
&#123;Cataloger action=\'all\' sub_template=\'my_sub_template\' alias=\'/\' recurse=\'items_all\'}
<p>Similarly, you could have it list only categories under the current page (by omitting the "alias=\'/\'"). The combinations are basically limitless!</p>
<p>All supported values of recurse include:<ul>
<li>items_one - Catalog items, no more than one level below the current page (or alias point)</li>
<li>items_all - Catalog items, at any level below the current page (or alias point)</li>
<li>categories_one - Categories, no more than one level below the current page (or alias point)</li>
<li>categories_all - Categories, at any level below the current page (or alias point)</li>
<li>mixed_one - Catalog items and Categories, no more than one level below the current page (or alias point)</li>
<li>mixed_all - Catalog items and Categories, at any level below the current page (or alias point)</li>
</ul>
</p>
<p>Items in these lists come back in hierarchy order. You can change this using the \'global_sort\' parameter. Your choices are:</p>
<ul>
<li>alpha - alphabetically by title</li>
<li>date - in order of item creation date</li>
<li>mdate - in order of item modification date</li>
</ul>
<p>You may order these sorts using the \'global_sort_dir\' parameter, which will allow \'asc\' or \'desc\'.</p>
<p>So, for a thorough example:</p>
<p>&#123;Cataloger action=\'all\' sub_template=\'my_sub_template\' alias=\'/\' recurse=\'categories_all\' global_sort=\'alpha\' global_sort_dir=\'asc\'}</p>
<h4>Recently Added Feature List</h4>
<p>To use a "most-recently added" list will allow you to display the most recently-added catalog items under a specified part of your hierarchy.</p>
<p>The syntax for a "most recently added" list is like:</p>
<p>&#123;Cataloger action=\'recent\' sub_template=\'my_sub_template\'}, where sub_template is the template to use to render the list.
There are four optional parameters, count=\'3\' alias=\'page_alias\', global_sort=\'date\', global_sort_dir=\'desc\' where count
is the number of items to include, page_alias indicates the top of the tree (e.g., a place in your menu hierarchy,
typically a category page) in which to look for new items. A special value for "page_alias" is "/", which means
to use <i>all</i> pages in the site. global_sort may be \'date\' (for item creation date) or \'mdate\' for modification date, and
global_sort_dir may be \'asc\' or \'desc\'.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a "random" list is like:</p>
<p>&#123;cCataloger action=\'random\' sub_template=\'my_sub_template\'}, where sub_template is the template to use to render the list. There are two optional parameters, count=\'3\' alias=\'page_alias\', where count is the number of items to include, and page_alias indicates the top of the tree (e.g., a place in your menu hierarchy, typically a category page) in which to look for new items. A special value for "page_alias" is "/", which means to use <i>all</i> pages in the site.</p>
<h4>Variable</h4>
<p>You can grab variables (attributes) outside of your Cataloger templates, say in a global content block, using the variable method. The syntax looks like:</p>
<p>&#123;Cataloger action=\'variable\' name=\'itemnotes\' default=\'no notes\'}, where name is the attribute to display (using the same all lower-case, punctuation-free representation like the smarty template variables), and default is the value to use if the attribute is not defined.</p>
<h4>Item Comparisons</h4>
<p>As of version 0.7.7, there is a product comparison action:</p>
<p>&#123;cCataloger action=\'compare\' sub_template=\'my_sub_template\' items=\'item1,item2,item3\'}, where sub_template is the template to use to render the list, and items is a comma-delimited list of item page aliases to compare. Bolder users may also choose to pass in the items to compare as request variables, thereby enabling dynamic comparisons based on user selections. Do this by setting the "items" variable on the request passed to the page containing the Cataloger tag with a compare action.</p>
<p>The default item comparison template could use some styling, e.g.,:</p>
<pre>
.item_comparison th {font-weight: bold; padding: 5px; text-align:center;}
.item_comparison td {border: 1px solid gray; padding: 3px 5px;text-align:right;}
</pre>
<h3>Customization and Advanced Topics</h3>
<h4>Catalog Item Attributes</h4>
<p>The default item attributes are typical for a catalog of products or artworks, but by going into Extensions &gt; Cataloger &gt; Manage User-Defined Attributes, you can change the attributes. It\'s best to define the attributes before you start entering Catalog Items.</p>
<p>Note that the attributes you define may need to be added to the template that you\'re using to display Catalog Items -- see Custom Templates below.</p>
<h4>Catalog Category Attributes</h4>
<p>Similarly, you can set attributes for Categories. Again, the attributes you define may need to be added to the template that you\'re using to display Catalog Categories -- see Custom Templates below.</p>
<h4>Printable Catalog Attributes</h4>
<p>Likewise, you can set attributes for Printable Catalogs. Again, the attributes you define may need to be added to the template that you\'re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you\'re willing to mess around with Smarty Templates, you can change the layout of any of the pages generated by Cataloger. This should make certain developers very happy, even if the inefficiency of the rest of the code will not. There are four kinds of templates: one kind for Catalog Items, one kind for Catalog Categories, and one kind for Printable Catalogs, and one kind for "Feature" lists, such as recently added items or random selections.</p>
<p>When editing a Template, the admin screen will display a list of Smarty tags available to you for that kind of template. This
will only happen once the module knows what kind of template you\'re editing, so when you first create the template, it displays all
the Smarty tags it knows about, only some of which being applicable.</p>
<h4>Displaying Attributes on Item Pages</h4>
<p>Attributes are available to Smarty as top-level variables. They are stored as sanitized versions of the attribute names, which means
it is converted to lower case and all punctuation and non-US-ASCII characters get removed. This is because Smarty is finicky, and will not handle these characters.</p>
<p>So, for example, if you have an attribute called "Glücklichkeit", there will be a Smarty variable {$glcklichkeit}. Note that the "ü" is omitted.</p>
<p>Fortunately, this is simplified by the $attrlist list available. This is a list of attributes by formal name ("Glücklichkeit") and their key ("glcklichkeit"). For example:
<pre>
	{section name=at loop=$attrlist}
	&lt;div class="item_attribute_name">{$attrlist[at].name}:&lt;/div>&lt;div class="item_attribute_val">{eval var=$attrlist[at].key}&lt;/div>
	{/section}
</pre>
<p>As of version 0.8, you can assign an alias to each attribute. These aliases need to be US-ASCII and contain no punctuation. They can be used instead of the sanitized attribute name (e.g., you could use the alias "gluecklichkeit").</p>
<h4>Displaying Attributes on Pages with Lists of Items</h4>
<p>Attributes are included in the $itemlists[#] in two different ways: top-level attributes of the item, and as part of the item\'s "attr" array. They are stored as sanitized versions of the attribute names, which means
it is converted to lower case and all punctuation and non-US-ASCII characters get removed. This is because Smarty is finicky, and will not handle these characters.</p>
<p>So, for example, if you have an attribute called "Glücklichkeit", the item will have $item.glcklichkeit and $item.attrs[\'glcklichkeit\']. Note that the "ü" is omitted. You can refer to this attribute in your template
with Smarty code like: {$itemlist[index].glcklickkeit} or {$itemlist[index].attrs.glcklichkeit}.</p>
<p>Fortunately, this is simplified by the $attrlist list available. This is a list of attributes by formal name ("Glücklichkeit") and their key ("glcklichkeit"). For example:
<pre>
    {foreach from=$attrlist item=attr key=k}
    {$attr}: {$items[numloop][$k]}
    {/foreach}
</pre>
<p>As of version 0.8, you can assign an alias to each attribute. These aliases need to be US-ASCII and contain no punctuation. They can be used instead of the sanitized attribute name (e.g., you could use the alias "gluecklichkeit").</p>
<h4>Smarty tags in Attributes</h4>
<p>Sometimes, you\'ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you\'ll need to
update your template. For the attributes where you want smarty tags to be active, you\'ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
&#123;eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
&#123;eval var=$entry->input assign=thisAttr}&#123;eval var=$thisAttr}
</pre>
<p>Ugly? Yup. But it works.</p>
<h3>Cataloger Image System</h3>
<p>Cataloger has an image system that will allow you to dynamically change the image display size. If you do not like it, you can alter
the templates and use any image system you want.</p>
<p>When you upload an image using Cataloger, it gets put in a special set of directories to make the imaging easier. You will see more
about this later.</p>
<p>It works by calling a PHP program instead of directly referencing the image. The program uses the filename to see if the
image already exists in the correct size. If so, it redirects to that image. Otherwise, it uses your GDLIB or ImageMagick to create
the image in the correct size, and then redirects to it.
</p>
<h4>Cataloger Image Filespec Explanation</h4>
<p>A cataloger image has a filespec like:
<br />
root_path/modules/Cataloger/Cataloger.Image.php?i=itemname_f_1_400_1.jpg&amp;ac=82888
</p>
<p>The interesting thing is "itemname_f_1_400_1.jpg" - the stuff before is just a call to the program, and the &amp;ac=82888 is a random thing that
is designed to prevent browser caching. So examining the name piece by piece (separating at the underscores), we have:</p>
<ul>
<li>item name - this is the alias of the item/category page containing the image.</li>
<li>image type - this is a designation for image type:<ul>
<li>f - item full-size image</li>
<li>t - item thumbnail</li>
<li>cf - category full-sized image</li>
<li>ct - category thumbnail</li>
<li>ctf - printable catalog full-sized image</li>
</ul>
</li>
<li>image number - so a given item/catalog/etc can have multiple images</li>
<li>long dimension - long dimension of the image, in pixels</li>
<li>missing flag - 1 if you want to show an "image missing" image if this image doesn\'t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
<h4>Accessing your Original Image</h4>
<p>When Cataloger uploads images, it puts them into a directory called "cataloger_src" in your uploads/images/ directory. They images are named according to the alias of the page:
alias_src_#.jpg where # is the image number for that page.</p>
<p>So, to access the originally uploaded images on a Category page, you\'d generate the URL manually.</p>
<p>So on a category page, for example, instead of using {$items[numloop].image} you\'d use "/uploads/images/cataloger_src/{$items[numloop].alias}_src_1.jpg".</p>
<h3>Credits</h3>
<p>Thanks to <a href="http://www.id-a.co.uk">Paul Cooper</a> for sponsoring the development of textarea attributes.</p>
<p>Thanks to numerous patient users and bug testers (many of whom had no idea what they were getting into.)</p> 
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com">&lt;sjg@cmsmodules.com&gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2012, Fernando Morgado (JoMorg) <a href="mailto:jomorg.morg@gmail.com">&lt;jomorg.morg@gmail.com&gt;</a>. All Rights Are Reserved.</p>
<p>Copyright &copy; 2008, Samuel Goldstein. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';

$lang['postinstall']='Make sure to set the "Modify Catalog Settings" permission on users who will be administering the catalog.';
?>
]]></data>
	</file>
	<file>
	  <filename>/lang/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/lib/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/class.catAdminOps.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCmNsYXNzIGNhdEFkbWluT3BzDQp7DQogICNBZG1pbiBDb25zb2xlIEZpZWxkcw0KICAjc3RhdGljIGZ1bmN0aW9uIA0KfQ0KPz4NCg==]]></data>
	</file>
	<file>
	  <filename>/lib/class.CatalogCategory.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.12
#
# Copyright (c) 2012, Fernando Morgado (JoMorg) jomorg.morg@gmail.com
# Copyright (c) 2006, Samuel Goldstein <sjg@cmsmodules.com>
# For Information, Support, Bug Reports, etc, please visit the
# CMS Made Simple Forge at http://dev.cmsmadesimple.org
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http://www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
class CatalogCategory extends Content
{
  const TAB_CAT_OPTIONS = 'cc_cataloger_options';
  const TAB_CAT_IMAGES = 'cc_cataloger_images';
  private $_mod;
  private $attrs;
  private $_attr_list = array();

  function __construct()
  {
    parent::__construct();
    $this->mCachable = false;
  }
  
  function ModuleName()
  {
    return 'Cataloger';
  } 

  function IsCopyable()
  {
    return true;
  }
  
  function IsDefaultPossible()
  {
    return FALSE;
  }  
    
  function FriendlyName()
  {
    return $this->Lang('category_page');
  }
  
  function Lang($key)
  {
    return $this->get_mod()->Lang($key);
  }
        
  function get_lang($key)
  {
    return $this->get_mod()->Lang($key);
  }
  
  function get_mod()
  {
    if( is_null($this->_mod) )
    {
      $this->_mod = cms_utils::get_module('Cataloger');
    }
    return $this->_mod;
  }

  public function GetTabNames()
  {
    $mod = $this->get_mod();
    $has_images = (bool)$mod->GetPreference('category_image_count', 0);
    $out = parent::GetTabNames();
    
    if( isset($out[self::TAB_CAT_OPTIONS]) ) 
    {
      $out[self::TAB_CAT_OPTIONS] = $mod->lang('tab_advanced_options');
    }
    
    if( isset($out[self::TAB_CAT_OPTIONS]) ) 
    {
      $out[self::TAB_CAT_OPTIONS] = $mod->lang('tab_advanced_options');
    }
    
    if( isset($out[self::TAB_CAT_IMAGES]) )
    {
      if($has_images)
      {
        $out[self::TAB_CAT_IMAGES] = $mod->lang('tab_images');
      }
       else
      {
        unset($out[self::TAB_CAT_IMAGES]);
      }
    }
    return $out;
  }
  
  function HasAttributes()
  {
    return is_array($this->attrs) && (count($this->attrs) > 0);
  }
  
  function getAttrs()
  {
    $this->getUserAttributes();
    return $this->attrs;
  }
  
  function getUserAttributes()
  {
    if( empty($this->attrs) ) 
    {
      $this->attrs = catUserDefAttributesOps::getUserAttributes('catalog_cat_attrs');
      $this->_attr_list = array_keys($this->attrs); 
    } 
  }
  
  // to revisit... copied from feu_protected_page
  // its just a hack to avoid caching issues... but not the best
  public function GetModifiedDate()
  {
    // on frontend requests this will force the template to be recompiled
    // and therefore evaluation to be done for each request.
    if( cmsms()->is_frontend_request() ) return time();
    return parent::GetModifiedDate();
  }

  function SetProperties()
  {
    parent::SetProperties();
    
    $this->AddProperty('sub_template',    0, self::TAB_CAT_OPTIONS);
    $this->AddProperty('sort_order',      1, self::TAB_CAT_OPTIONS);
    $this->AddProperty('recurse',         2, self::TAB_CAT_OPTIONS);
    $this->AddProperty('items_per_page',  3, self::TAB_CAT_OPTIONS);
    $this->AddProperty('images',          0, self::TAB_CAT_IMAGES);
    
    $this->getUserAttributes();
    
    #lets add the fields
    if(is_array($this->attrs))
    {
      foreach ($this->attrs as $k => $thisAttr)
      {
        $this->AddProperty($thisAttr->alias, 110 + $thisAttr->field_order, self::TAB_MAIN);
      }
    }
    
  }
  
  function AddProperty($name, $priority, $tab = self::TAB_MAIN, $required = FALSE)
  {
    parent::AddProperty($name, $priority, $tab, $required);
  }
  
  protected function display_single_element($one, $adding)
  {
    $gCms = cmsms();
    $mod = $this->get_mod();
    $smarty = $gCms->GetSmarty();

    if( in_array($one, $this->_attr_list) )
    {
      return catFields::RenderInput( $this->attrs[$one], $this->GetPropertyValue($this->attrs[$one]->attr) );
    } 

    switch($one)
    {
      
      case 'sub_template':
      {
        $subTemplates = catTemplateOperations::GetTemplateListFromID(2);

        $ret = array(
                      '<label for="in_sub_template">' 
                      . $mod->lang('Sub') 
                      . ' '
                      . lang('template') 
                      . ':</label>',
                      $mod->CreateInputDropdown(
                                                  '', 
                                                  'sub_template', 
                                                  $subTemplates, 
                                                  -1, 
                                                  $this->GetPropertyValue('sub_template')
                                                )
                    );
         
         return $ret;
      }
      break;
      
      case 'recurse':
          $ret = array($mod->Lang('title_category_recurse'), CatalogerHelper::RenderRecursiveInput( $this->GetPropertyValue('recurse') ) );          
          return $ret;     
      break;
      
      case 'images':
      {
        $ret = array('', CatalogerHelper::RenderPageImageUpLoader($this->mAlias, 'category'));
        return $ret;
      }
      break;
      
      case 'sort_order':
      {
        $ret = array();
        
        $so = $this->GetPropertyValue('sort_order');

        if ($so == '')
        {
            $so = $mod->GetPreference('category_sort_order', 'natural');
        }
                                                            
        $ret = array(
                      $mod->Lang('title_global_item_sort_order2'), 
                      $mod->CreateInputDropdown(
                                                  '',
                                                  'sort_order', 
                                                  array(
                                                          $mod->Lang('natural_order')=>'natural',                                                                $mod->Lang('alpha_order')=>'alpha'
                                                        ), 
                                                        -1, 
                                                        $so
                                                )
                     );
        return $ret;
        
      }
      break;
          
      case 'items_per_page':
      {
        $ipp = $this->GetPropertyValue('items_per_page');
        if ($ipp == "" || $ipp == -1)
        {
          $ipp = get_site_preference('Cataloger_mapi_pref_category_items_per_page', '10');
        }
        
        $dpArr =  array(
                          '1'=>'1', 
                          '2'=>'2', 
                          '3'=>'3', 
                          '4'=>'4', 
                          '5'=>'5', 
                          '6'=>'6', 
                          '7'=>'7', 
                          '8'=>'8', 
                          '9'=>'9', 
                          '10'=>'10', 
                          '11'=>'11', 
                          '12'=>'12', 
                          '13'=>'13', 
                          '14'=>'14', 
                          '15'=>'15', 
                          '16'=>'16', 
                          '17'=>'17', 
                          '18'=>'18', 
                          '19'=>'19', 
                          '20'=>'20', 
                          '24'=>'24', 
                          '25'=>'25', 
                          '30'=>'30', 
                          '40'=>'40', 
                          '50'=>'50', 
                          '1000'=>'1000'
                        );
        
        $ret = array(
                      $mod->Lang('title_global_items_per_page2'), 
                      $mod->CreateInputDropdown(
                                                  '', 
                                                  'items_per_page', 
                                                  $dpArr,
                                                  -1, 
                                                  $ipp
                                                )
                      );
        return $ret;
      }
      break;
      
      default:
        return parent::display_single_element($one, $adding);
    }
  }
  
  
  function ValidateData()
  {
    $v = parent::ValidateData();

    if ($v !== FALSE)
    {
      return $v;
    }

    return $this->validation;
  }

  function validationError($msg)
  {
    if (!is_array($this->validation))
    {
      $this->validation = array();
    }

    array_push($this->validation, $msg);
  }

  function FillParams($params, $editing = false)
  {   
    if( !isset($params) ) return;
    
    $config = cmsms()->GetConfig();
    $mod = $this->get_mod();
        
    $parameters = array('sub_template', 'sort_order', 'recurse', 'items_per_page');

    foreach($parameters as $oneparam)
    {
      if (isset($params[$oneparam]))
      {
        $this->SetPropertyValue($oneparam, $params[$oneparam]);
      }       
    }

    $this->getUserAttributes();

    foreach ($this->attrs as $thisAttr)
    {
      if (isset($params[$thisAttr->safe]))
      {
          $this->SetPropertyValue($thisAttr->attr, $params[$thisAttr->safe]);
      }
    }
    
    // Copy and resize the image files...
    $imgcount = $mod->GetPreference('category_image_count', '1');
    $herosize = $mod->GetPreference('category_image_size_hero', '400');
    $thumbsize = $mod->GetPreference('category_image_size_thumbnail', '90');
    
    for ($i=1; $i<= $imgcount; $i++)
    {

      if (isset($_FILES['image' . $i]['size']) && $_FILES['image' . $i]['size'] > 0)
      {

        if (! preg_match('/\.jpg$|\.jpeg$/i', $_FILES['image' . $i]['name']))
        {
          $this->validationError($mod->Lang('badimageformat', $_FILES['image' . $i]['name']));
        }
        else
        {
          $source = $_FILES['image' . $i]['tmp_name'];
          $target = cms_join_path(
                                    $config['uploads_path'],
                                    catFilesOperations::getAssetPath('s'),
                                    $this->mAlias . '_src_' . $i . '.jpg'
                                  );
          $cres = copy($source, $target);

          if (!$cres)
          {
            $this->validationError( $mod->Lang('badimage', $_FILES['image' . $i]['name']) );
          }
        }
      }
    }

    foreach ($params as $thisParam => $thisParamVal)
    {

      if (substr($thisParam, 0, 9) == 'rm_image_')
      {
        $imageSpecParts = explode('_', $thisParam);
        catFilesOperations::purgeAllImage($imageSpecParts[2], $imageSpecParts[3]);
      }
    }
    

    parent::FillParams($params);
  }

  function PopulateParams(&$params)
  { 

    $parameters = array('sub_template', 'sort_order', 'recurse', 'items_per_page');

    # this may be better implemented in validate?  (JM)
    foreach ($parameters as $oneparam)
    {
      $tmp = $this->GetPropertyValue($oneparam);

      if (isset($tmp) && !empty($tmp))
      {
        $params[$oneparam] = $tmp;
      }
    }

    $this->getUserAttributes();

    $safeattrlist = array();

    foreach ($this->attrs as $thisAttr)
    {
      $tmp = $this->GetPropertyValue($thisAttr->attr);

      if (isset($tmp) && $tmp != '')
      {
          $params[$thisAttr->safe] = $tmp;

          if (isset($thisAttr->alias) && $thisAttr->alias!='')
          {
            $params[$thisAttr->alias] = $tmp;
          }

          $thisSafeAttr = array();
          $thisSafeAttr['name'] = ucfirst($thisAttr->attr);
          $thisSafeAttr['key'] = '{$' . $thisAttr->safe . '}';

          if ($thisAttr->alias != '')
          {
            $thisSafeAttr['aliaskey'] = '{$' . $thisAttr->alias . '}';
          }

          array_push($safeattrlist, $thisSafeAttr);
      }
    }
        
    $params['title'] = $this->mName;
    $params['menutext'] = $this->mMenuText;
    $params['template_id'] = $this->mTemplateId;
    $params['alias'] = $this->mAlias;
    $params['parent_id'] = $this->mParentId;
    $params['active'] = $this->mActive;
    $params['showinmenu']=$this->mShowInMenu;
    $params['attrlist'] = $safeattrlist;
    $params['_i_content_id'] = $this->mId; #if needed at all (???????)

  }

 
  function Show($param = '')
  {
    $param = trim($param);
    
    if( !$param ) $param = 'content_en';
    $param = str_replace(' ','_',$param); 
    
    if ($param == 'content_en')
    {
      $this->PopulateParams($params);
      $params['content_en'] = parent::Show($param);
      return $this->RenderContent($params);;  
    }
    else
    {
      return parent::Show($param);
    }
  }


  protected function Update()
  {
    parent::Update();
    if( ($this->mOldAlias != $this->Alias()) && $this->mOldAlias && $this->Alias() )
    {
      catFilesOperations::renameImages($this->mOldAlias, $this->Alias());
    }
  }

  protected function Insert()
  {
    parent::Insert();
    
    if( ($this->mOldAlias != $this->Alias()) && $this->mOldAlias && $this->Alias() )
    {
      catFilesOperations::renameImages($this->mOldAlias,$this->Alias());
    }
  }

  function UpdatePropertyName($propName, $propNewName)
  {
    $tempValue = '';
    
    if ($this->is_known_property($propName))
    {
      $tempValue = $this->GetPropertyValue($propName);
      $this->RemoveProperty($propName, false);   
    }
    
    $this->AddExtraProperty($propName);
    $this->SetPropertyValue($propNewName, $tempValue);
  }   

  function DeleteProperty($propName)
  {
    $this->RemoveProperty($propName, false);    
  }
  /**
  * #
  * 
  * @param mixed $params
  */
  function RenderContent($params)
  {    
    $mod = $this->get_mod();
    
    $smarty = $mod->GetActionTemplateObject();
    
    if( empty($smarty) ) $smarty = cmsms()->GetSmarty();
    
    $cntObj = new stdClass();
  
    $showMissing = '_' . $mod->GetPreference('show_missing', '1');

    foreach ($params as $key => $val)
    {
      $smarty->assign($key, $params[$key]);
      $cntObj->$key = $params[$key];
    }

    list($curPage, $categoryItems) = catContentOperations::getCatalogItemsList($params);

    if (isset($params['sort_order']) && $params['sort_order'] == 'alpha')
    {
      usort( $categoryItems, array('catContentOperations', 'contentalpha') );
    }
    
    $cntObj->items = $categoryItems;
    $cntObj->default_content = $params['content_en'];
    
    $smarty->assign('items', $categoryItems);
    $smarty->assign('main_content', $params['content_en']);
    
    list($nav, $categoryItems) = $this->pagination($categoryItems, $params);
    
    foreach ($nav as $key=>$val)
    {
      $smarty->assign($key, $nav[$key]);
    }
    
    $cntObj->nav = $nav;
    
    $imgcount = $mod->GetPreference('category_image_count', '1');
    $fullSize = $mod->GetPreference('category_image_size_hero', '400');
    $thumbSize = $mod->GetPreference('category_image_size_thumbnail', '90');
    
    $cntObj->imgcount = $imgcount;
    $cntObj->fullSize = $fullSize;
    $cntObj->thumbSize = $thumbSize;
    
    $imageArray = array();
    $srcImgArray = array();
    $thumbArray = array();

    for($i = 1; $i <= $imgcount; $i++)
    {
      $is = catFilesOperations::imageSpec($curPage->Alias(), 'cf', $i, $fullSize);
      array_push( $imageArray, $is);
      $is = catFilesOperations::imageSpec($curPage->Alias(), 'ct', $i, $thumbSize);
      array_push($thumbArray, $is);
      $sis = catFilesOperations::srcImageSpec($curPage->Alias(), $i);  
      array_push($srcImgArray, $sis);

      $is = catFilesOperations::imageSpec($curPage->Alias(), 'cf', $i, $fullSize);                                         
      $smarty->assign('image_' . $i . '_url', $is);
      $sis = catFilesOperations::srcImageSpec($params['alias'], $i);                     
      $smarty->assign('src_image_' . $i . '_url', $sis);
      $is =  catFilesOperations::imageSpec($curPage->Alias(), 'ct', $i, $thumbSize);                     
      $smarty->assign('image_thumb_' . $i . '_url', $is);
    }
    
    $smarty->assign('ctlg', $cntObj); 
    $smarty->assign('image_url_array', $imageArray);
    $smarty->assign('src_image_url_array', $srcImgArray);
    $smarty->assign('image_thumb_url_array', $thumbArray);
    $mod->smartyBasics();

    $cache_id = '_ctg_' . md5( serialize($params) );
    $compile_id = 'Cataloger_' . $this->mId;

    return $smarty->fetch(
                            $mod->GetDatabaseResource('catalog_' . $params['sub_template']),
                            $cache_id,
                            $compile_id
                          );
  }
  
  function pagination($categoryItems, $params)
  {
    $mod = self::get_mod();  
    $count = count($categoryItems);

    if ( isset($_REQUEST['start']) )
    {
      $start = $_REQUEST['start'];
    }
    else
    {
      $start = 0;
    }

    if ( isset($params['items_per_page']) )
    {
      $end = max($params['items_per_page'], 1);
    }
    else
    {
      $end = max($count, 1);
    }

    $thisUrl = $_SERVER['REQUEST_URI'];
    $thisUrl = preg_replace('/(\?)*(\&)*start=\d+/', '', $thisUrl);

    if (strpos($thisUrl, '?') === false)
    {
      $delim = '?';
    }
    else
    {
      $delim = '&';
    }

    $nav = array();

    if ($start > 0)
    {
      $nav['prev'] = '<a href="' . $thisUrl . $delim 
                     . 'start=' . max(0, $start-$end) . '">' 
                     . $this->Lang('prev') . '</a>';

      $nav['prevurl'] =  $thisUrl . $delim . 'start=' . max(0, $start - $end);
    }
    else
    {
      $nav['prev'] = '';
      $nav['prevurl'] = '';
    }

    if ($start + $end < $count)
    {
      $nav['next'] = '<a href="' . $thisUrl . $delim . 'start=' 
                     . ($start + $end) . '">' . $mod->Lang('next') . '</a>';
                              
      $nav['nexturl'] = $thisUrl . $delim . 'start=' . ($start + $end);
    }
    else
    {
      $nav['next'] = '';
      $nav['nexturl'] = '';
    }

    $navstr = '';
    $pageInd = 1;
    
    for ( $i = 0; $i < $count; $i += $end )
    {
      if ($i == $start)
      {
        $navstr .= "<span class=\"p-" . $pageInd . "  nolink\">" . $pageInd . "</span>";
      }
      else
      {
        $navstr .=  '<a href="' . $thisUrl . $delim . 'start='  . $i . '">' . $pageInd . '</a>';
      }

      $navstr .= $mod->Lang('navTab');
      $pageInd++;
    }

    $navstr = rtrim( $navstr, $mod->Lang('navTab') );
    $categoryItems = array_splice($categoryItems, $start, $end);

    if (strlen($navstr) > 1)
    {
      $nav['navstr'] =  $navstr;
      $nav['hasnav'] = true;
    }
    else
    {
      $nav['navstr'] =  '';
      $nav['hasnav'] = false;
    }
    
    $ret = array($nav, $categoryItems);
   
    return $ret;
        
  }

}
?>]]></data>
	</file>
	<file>
	  <filename>/lib/class.CatalogerHelper.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.12
#
# Copyright (c) 2012-2013, Fernando Morgado (JoMorg) jomorg.morg@gmail.com
# Copyright (c) 2006, Samuel Goldstein <sjg@cmsmodules.com>
# For Information, Support, Bug Reports, etc, please visit the
# CMS Made Simple Forge at http://dev.cmsmadesimple.org
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http://www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
/**
* A helper Class for the Cataloger Module
* @version 1.0
* @author Jo Morg (Fernando Morgado)
*/
class CatalogerHelper
{
  static private $_initialized = FALSE;
  static private $_cms;
  static private $_smarty;
  static private $_config;
  static private $_mod;
  
  /**
  * A few basics
  */
  
  private static function _initialize()
  {
    if(!self::$_initialized)
    {
      self::$_cms = cmsms();
      self::$_config = self::$_cms->GetConfig();
      self::$_smarty = self::$_cms->GetSmarty();
      self::$_mod = self::$_cms->GetModuleInstance('Cataloger');
      self::$_initialized = TRUE;  
    }
  }
  
  #deprecated
  static function get_mod()
  {
    self::_initialize();
    return self::$_mod;
  }

  #### Admin UI helper methods
  static private function _admImageUploaderTableHeader()
  {
    if (!isset($html))
    {
      $mod = self::get_mod();
      $html = '';
      $html .= "\n\n<table class='pagetable'>\n";
      $html .= "<thead>";
      $html .= "\n<tr>\n<th style=\"vertical-align:center;text-align:right;\">#</th>\n<th>";
      $html .= $mod->lang('nameimages'); 
      $html .= "</th>\n<th style=\"vertical-align:center;text-align:center;\">\n";
      $html .= $mod->lang('title_upload');
      $html .= "</th>\n<th class=\"pageicon\">\n";
      $html .= $mod->lang('deleteimage');
      $html .= "</th>\n</tr>\n";
      $html .= '</thead>';
      $html .= "\n";
    }
    
    return $html;
  }
  
  static private function _admFileUploaderTableHeader()
  {
    if (!isset($html))
    {
      $mod = self::get_mod();
      $html = '';
      $html .= "\n\n<table class='pagetable'>\n";
      $html .= "<thead>";
      $html .= "\n<tr>\n<th style=\"vertical-align:center;text-align:center;\">#</th>\n";
      $html .= "\n<th style=\"vertical-align:center;text-align:center;\">Icon</th>\n";
      $html .= "<th style=\"vertical-align:center;text-align:left;\">\n"; 
      $html .= $mod->lang('namefiles');  
      $html .= "</th>\n";  
      $html .= "<th style=\"vertical-align:center;text-align:left;\">\n";
      $html .= $mod->lang('title_upload');
      $html .= "</th>\n<th class=\"pageicon\">\n";
      $html .= $mod->lang('deletefile'); 
      $html .= "</th>\n</tr>\n";
      $html .= '</thead>';
      $html .= "\n";
    }
    
    return $html;
  }
  
  static function &RenderPageImageUpLoader($alias, $type = 'item')
  {
    if ($type == 'category'){$t = '_ct_';} 
    if ($type == 'item'){$t = '_it_';} 
    
    $mod = self::get_mod();
    $imgcount = $mod->GetPreference('category_image_count', '1');
    $thumbsize = $mod->GetPreference('category_image_size_thumbnail', '90');
    $RootURL = $mod->GetPreference('RootURL', cmsms()->config['root_url']);
    
    if ($imgcount != 0)
    {
      $html = self::_admImageUploaderTableHeader(); 
      $html .= "<tbody>\n";
      
      $imgsrc = '';
      $urlext = $mod->create_url( 'm1_', 'image', null, array() );
            
      for ($i = 1 ; $i <= $imgcount ; $i++)
      {
        $imgsrc .=  '<tr><td style="vertical-align:center;text-align:right;">'
                   . sprintf("%03d", $i)
                   . '</td><td style="vertical-align:center;text-align:center;">';
                  
        $tmptxt = '<img alt="'
                   . $mod->lang('nameimages')
                   . '" title="'
                   . $mod->lang('nameimages')
                   . '" src="'
                   //. $RootURL
                   . $urlext . '&i='
                   . $alias
                   . $t
                   . $i
                   . '_'
                   . $thumbsize
                   . '_1.jpg&ac='
                   . rand(0,9)
                   . rand(0,9)
                   . rand(0,9)
                   . '" />';
                   
        $imgsrc .= str_replace('&amp;', '&', $tmptxt);

        $imgsrc .= '</td><td style="vertical-align:center;"><input type="file" name="image'
                   . $i
                   . '" />';
                   
        $imgsrc .= '</td><td style="vertical-align:center;text-align:right"><input type="checkbox" id="rm_image_' 
                   . $alias
                   . '_'
                   . $i
                   . '" name="rm_image_'
                   . $alias
                   . '_'
                   . $i
                   . '" />';
                   
        $imgsrc .= '</td></tr>';
      }
       
        $html .= $imgsrc; 
        
        $html .= "<tbody>\n</table>\n";

      }
      else
      {

        $html .= '<div class="pagetext">';
        $html .= '<img alt="';
        $html .=  $mod->lang('nameimages');
        $html .=  '" title="';
        $html .=  $mod->lang('nameimages');
        $html .=  '" src=" ';
        $html .=  $RootURL;
        $html .=  '/modules/Cataloger/images/no-image.gif" />';
        $html .=  '</div>';


      }
      
      return $html;
  }
  
  static function &RenderPageFileUpLoader($alias)
  {
    $mod = self::get_mod();
    $filecount = $mod->GetPreference('item_file_count', 0);
    
    if ($filecount == 0) return ''; # we shouldn't even get here but return empty nevertheless....

    list($filelist, $filetype) = catFilesOperations::getFiles($alias);
    
    $html = self::_admFileUploaderTableHeader(); 
    $html .= "<tbody>\n<tr>\n";
    
    $filecount = $mod->GetPreference('item_file_count', 0);

    for ($i = 0; $i < $filecount; $i++)
    {
       $filesrc = '';
    
      $filesrc .= '<td style="vertical-align:center;text-align:right;">'
                  . sprintf("%03d", $i)
                  . '</td>'; 

      if (isset($filelist[$i]))
      {
         
        $typeimg = '<img src="'
                   . cmsms()->config['root_url']
                   . '/modules/FileManager/icons/themes/default/extensions/16px/'
                   . $filetype[$i]
                   . '.png" />';
        
        $currfile = $filelist[$i];
        
        $deleteHTML = '<input type="checkbox"" id="rm_file_'
                      . $alias
                      . '_'
                      . $i
                      . '" name="rm_file_'
                      . $filelist[$i]
                      . '" value="'
                      . $filelist[$i]
                      . '"/>';
      }
      else
      {
        $typeimg = '<img src="'
                   . cmsms()->config['root_url']
                   . '/modules/FileManager/icons/themes/default/extensions/16px/0.png" />';
                   
        $currfile = $mod->lang('namefile')
                   . ' # '
                   . ($i + 1);
                   
        $deleteHTML = '&nbsp';
      }
      
      $filesrc .= '<td style="vertical-align:center;text-align:center;">'
                  .  $typeimg
                  . '</td>';
                  
      
      $filesrc .= '<td style="vertical-align:center;text-align:left;">'
                  .  $currfile
                  . '</td>';
      
      $filesrc .= '<td style="vertical-align:middle;">&nbsp;<input type="file" name="file'
                  . $i
                  . '" />';
                        
      $filesrc .= '<td style="vertical-align:middle;text-align:right;">'
                  . $deleteHTML
                  . '</td>';
                  

      $html .= $filesrc;

      $html .= "</td>\n</tr>\n";
    }

    $html .= "<tbody>\n</table>\n";

    return $html;
    
  }
  
  static function RenderRecursiveInput($mode = 'items_one')
  {
    $mod = self::get_mod();
    
    $ret = '<fieldset>'; 
    $ret .= '<legend>' . $mod->lang('title_global_category_recurse2') . '</legend>'; 
    $ret .= "<table>\n"; 
    $ret .= "<tr>\n"; 
    $ret .= "<td>\n"; 
    $ret .= '<input type="radio" name="recurse" value="items_all" '; 
    $ret .= ( ($mode == 'items_all') ? 'checked="checked"' : '' ); 
    $ret .= '/>&nbsp;' . $mod->lang('title_category_recurse_items_all'); 
    $ret .= '</td>'; 
    $ret .= '</tr>'; 
    $ret .= '<tr>'; 
    $ret .= '<td>';
    $ret .= '<input type="radio" name="recurse" value="items_one" ';
    $ret .= ( ($mode == 'items_one') ? 'checked="checked"' : '');
    $ret .= '/>&nbsp;' . $mod->lang('title_category_recurse_items_one') . '</td></tr>';
    $ret .= '<tr><td><input type="radio" name="recurse" value="categories_all" ';
    $ret .= ( ( $mode == 'categories_all' ) ? 'checked="checked"' : '' );
    $ret .= '/>&nbsp;'.$mod->lang('title_category_recurse_categories_all') . '</td></tr>';
    $ret .= '<tr><td><input type="radio" name="recurse" value="categories_one" ';
    $ret .= ( ($mode == 'categories_one') ? 'checked="checked"' :'' );
    $ret .= '/>&nbsp;'.$mod->lang('title_category_recurse_categories_one') . '</td></tr>';
    $ret .= '<tr><td><input type="radio" name="recurse" value="mixed_all" ';
    $ret .= ( ($mode == 'mixed_all') ? 'checked="checked"' : '');
    $ret .= '/>&nbsp;'.$mod->lang('title_category_recurse_mixed_all').'</td></tr>';
    $ret .= '<tr><td><input type="radio" name="recurse" value="mixed_one" ';
    $ret .= ( ($mode == 'mixed_one') ? 'checked="checked"' : '' );
    $ret .= '/>&nbsp;' . $mod->lang('title_category_recurse_mixed_one') . '</td></tr></table>';
    $ret .= '</fieldset>';
    
    return $ret;
  }
  
  ### convenience methods - update module ###
  
  /**
  * A few methods to clean up a bit the Cataloger upgrade method....
  * @author Jo Morg
  * @since Cataloger 1.12
  */
  
  static function Update056()
  {
    $db = cmsms()->GetDb();
    
    $sqlarray = $dict->AddColumnSQL(
                                      cms_db_prefix() 
                                      . "module_catalog_attr",
                                      "is_textarea I"
                                    );
    
    $dict->ExecuteSQLArray($sqlarray);
    
    $query = 'INSERT INTO '
             . cms_db_prefix()
             . 'module_catalog_attr (id,type_id,is_textarea,attribute) VALUES (?,?,?,?)';
    
    $new_id = $db->GenID(cms_db_prefix() . 'module_catalog_attr_seq');
    $dbresult = $db->Execute($query,array($new_id, 1, 1, 'notes'));

    $new_id = $db->GenID(cms_db_prefix().'module_catalog_attr_seq');
    $dbresult = $db->Execute($query,array($new_id, 2, 1, 'notes'));

    $new_id = $db->GenID(cms_db_prefix().'module_catalog_attr_seq');
    $dbresult = $db->Execute($query,array($new_id, 3, 1, 'notes')); 
  }
  
  static function render_admin_nav($id, &$params, $returnid)
  {
    $config = self::$_config;
    $theme = cms_utils::get_theme_object();
    
    $link_a_icon = $this->CreateLink(
                                      $id, 
                                      'defaultadmin', 
                                      $returnid, 
                                      $theme->DisplayImage(
                                                            'icons/topfiles/template.gif', 
                                                            $this->Lang('listtempl'), 
                                                            '', '', 
                                                            'systemicon'
                                                          ),
                                      array() 
                                    );
    
    $link_a = $this->CreateLink(
                                  $id, 
                                  'defaultadmin', 
                                  $returnid, 
                                  $this->Lang('listtempl'), 
                                  array() 
                                );
                                      
    $link_b_icon = $this->CreateLink(
                                      $id, 
                                      'adminattrs', 
                                      $returnid, 
                                      $theme->DisplayImage(
                                                            'icons/topfiles/images.gif', 
                                                            $this->Lang('manageattrs'), 
                                                            '', '', 
                                                            'systemicon'
                                                          ), 
                                      array()
                                    );
                                      
    
    $link_b = $this->CreateLink(
                                  $id, 
                                  'adminattrs', 
                                  $returnid, 
                                  $this->Lang('manageattrs'), 
                                  array() 
                                );
                                
    $link_c_icon = $this->CreateLink($id, 'globalops', $returnid, '<img class="systemicon" alt="'.$this->Lang('globalops').'" title="'.$this->Lang('globalops').'" src="'.$config['root_url'].'/modules/Cataloger/images/global.gif" />');
    $link_c = $this->CreateLink($id, 'globalops', $returnid, $this->Lang('globalops'), array() ).' : '.$this->CreateLink($id, 'adminprefs', $returnid, $theme->DisplayImage('icons/topfiles/siteprefs.gif', $this->Lang('manageprefs'), '', '', 'systemicon'), array() ).$this->CreateLink($id, 'adminprefs', $returnid, $this->Lang('manageprefs'), array() );
                                      
    $nav = $link_a_icon . $link_a . ' : ' . $link_b_icon . $link_b . ' : '  . $link_c_icon . $link_c;
                                
    self::$_smarty->assign('innernav', $nav);
  }

  /**
  * A few methods to clean up a bit the Cataloger upgrade method....
  * END
  */
  
}
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/class.CatalogItem.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.12
#
# Copyright (c) 2012, Fernando Morgado (JoMorg) jomorg.morg@gmail.com
# Copyright (c) 2006, Samuel Goldstein <sjg@cmsmodules.com>
# For Information, Support, Bug Reports, etc, please visit the
# CMS Made Simple Forge at http://dev.cmsmadesimple.org
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http://www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
class CatalogItem extends Content
{
  const TAB_ITEM_OPTIONS  = 'cc_cataloger_options';
  const TAB_ITEM_IMAGES   = 'cc_cataloger_images';
  const TAB_ITEM_FILES    = 'cc_cataloger_files';
  private $_mod;
  private $attrs;
  private $_attr_list = array();
  protected $validation = FALSE;
   
  function __construct()
  {
    parent::__construct();
    $this->mCachable = false;
  }

  function ModuleName()
  {
    return 'Cataloger';
  } 

  function IsCopyable()
  {
    return true;
  }
  
  function IsDefaultPossible()
  {
    return FALSE;
  }  

  function FriendlyName()
  {
    return $this->Lang('item_page');
  }
  
  function Lang($key)
  {
    return $this->get_mod()->Lang($key);
  }
        
  function get_lang($key)
  {
    return $this->get_mod()->Lang($key);
  }
    
  function get_mod()
  {
    if( is_null($this->_mod) )
    {
      $this->_mod = cms_utils::get_module('Cataloger');
    }
    return $this->_mod;
  }
  
  public function GetTabNames()
  {
    $mod = $this->get_mod();
    $has_images = (bool)$mod->GetPreference('item_image_count', 0);
    $has_files = (bool)$mod->GetPreference('item_file_count', 0); 
    
    $out = parent::GetTabNames();
    
    if( isset($out[self::TAB_ITEM_OPTIONS]) ) 
    {
      $out[self::TAB_ITEM_OPTIONS] = $mod->lang('tab_advanced_options');
    }
    
    if( isset($out[self::TAB_ITEM_IMAGES]) )
    {
      if($has_images)
      {
        $out[self::TAB_ITEM_IMAGES] = $mod->lang('tab_images');
      }
       else
      {
        unset($out[self::TAB_ITEM_IMAGES]);
      }
    }
    
    if( $out[self::TAB_ITEM_FILES] )
    {
      if($has_files)
      {
        $out[self::TAB_ITEM_FILES] = $mod->lang('tab_files');
      }
       else
      {
        unset($out[self::TAB_ITEM_FILES]);
      }
    }

    return $out;
  }
  
  function HasAttributes()
  {
    return is_array($this->attrs) && (count($this->attrs) > 0);
  }

  function getUserAttributes()
  {
    if( empty($this->attrs) ) 
    {
      $this->attrs = catUserDefAttributesOps::getUserAttributes('catalog_attrs');
      $this->_attr_list = array_keys($this->attrs); 
    } 
  }
  
  function getAttrs()
  {
    $this->getUserAttributes();
    return $this->attrs;
  }
  
  // to revisit... copied from feu_protected_page
  // its just a hack to avoid caching issues... but not the best
  public function GetModifiedDate()
  {
    // on frontend requests this will force the template to be recompiled
    // and therefore evaluation to be done for each request.
    if( cmsms()->is_frontend_request() ) return time();
    return parent::GetModifiedDate();
  }

  function SetProperties()
  {
    parent::SetProperties();
    $this->AddProperty('sub_template',    0, self::TAB_ITEM_OPTIONS);
    $this->AddProperty('images',          0, self::TAB_ITEM_IMAGES);
    $this->AddProperty('files',           0, self::TAB_ITEM_FILES);
    
    $this->getUserAttributes();
    
    #lets add the fields
    if(is_array($this->attrs))
    {
      foreach ($this->attrs as $k => $thisAttr)
      {
        $this->AddProperty($thisAttr->alias, 110 + $thisAttr->field_order, self::TAB_MAIN);
      }
    }   
  }
  
  protected function display_single_element($one, $adding = false)
  {
    $gCms = cmsms();
    $mod = $this->get_mod();
    $smarty = $gCms->GetSmarty();

    if( in_array($one, $this->_attr_list) )
    {      
      return catFields::RenderInput( $this->attrs[$one], $this->GetPropertyValue($this->attrs[$one]->attr) );
    }     

    switch($one)
    {
      
    case 'sub_template':
    {
      $subTemplates = catTemplateOperations::GetTemplateListFromID(1);

      $ret = array(
                    '<label for="in_sub_template">' 
                    . $mod->lang('Sub') 
                    . ' '
                    . lang('template') 
                    . ':</label>',
                    $mod->CreateInputDropdown(
                                                '', 
                                                'sub_template', 
                                                $subTemplates, 
                                                -1, 
                                                $this->GetPropertyValue('sub_template')
                                              )
                  );
       
       return $ret;
    }
    break;
    
    case 'images':
    {
      
      if ($this->mAlias == '')
      {
        $ret = array('new page message | Images');  
      }
      else
      {
        $ret = array('', CatalogerHelper::RenderPageImageUpLoader($this->mAlias));
      }
      
      return $ret;
    }
    break;
        
    case 'files':
    {
      
      if ($this->mAlias == '')
      {
        $ret = array('new page message | Files');  
      }
      else
      {
        $ret = array('', CatalogerHelper::RenderPageFileUpLoader($this->mAlias));
      }
      
      return $ret;
      
    }
    break;

    default:
      return parent::display_single_element($one, $adding);
    }
  }


  function ValidateData()
  {
    $v = parent::ValidateData();

    if ($v !== FALSE)
    {
      return $v;
    }

    return $this->validation;
  }
 
  function validationError($msg)
  {
    
    if (!is_array($this->validation))
    {
      $this->validation = array();
    }

    array_push($this->validation, $msg);
  }

  function FillParams($params, $editing = false)
  {
    if( !isset($params) ) return;
    
    $config = cmsms()->GetConfig();
    $mod = $this->get_mod();    

    $this->validation = FALSE;
    
    $parameters = array('sub_template');

    foreach($parameters as $oneparam)
    {
      if (isset($params[$oneparam]))
      {
        $this->SetPropertyValue($oneparam, $params[$oneparam]);
      }
    }
    
    $this->getUserAttributes();
    
    foreach ($this->attrs as $thisAttr)
    {
      if (isset($params[$thisAttr->safe]))
      {
        $this->SetPropertyValue($thisAttr->attr, $params[$thisAttr->safe]);
      }
    }     
      
    $mod = $this->get_mod();

    // Copy the image files...
    $imgcount = $mod->GetPreference('item_image_count', '2');
    $herosize = $mod->GetPreference('item_image_size_hero', '400');
    $thumbsize = $mod->GetPreference('item_image_size_thumbnail', '70');
    $catalogsize = $mod->GetPreference('item_image_size_catalog', '100');
    $categorysize = $mod->GetPreference('item_image_size_category', '70');

    for ($i=1; $i<= $imgcount; $i++)
    {

      if (isset($_FILES['image' . $i]['size']) && $_FILES['image' . $i]['size'] > 0)
      {

        if (! preg_match('/\.jpg$|\.jpeg$/i', $_FILES['image' . $i]['name']))
        {
          $this->validationError($mod->Lang('badimageformat', $_FILES['image' . $i]['name']));
        }
        else
        {
          $source = $_FILES['image' . $i]['tmp_name'];
          
          $target = cms_join_path(
                                    $config['uploads_path'],
                                    catFilesOperations::getAssetPath('s'),
                                    $this->mAlias . '_src_' . $i . '.jpg'
                                  );
                                                                   
          $cres = copy($source, $target);

          if (!$cres)
          {
            $this->validationError( $mod->Lang('badimage', $_FILES['image' . $i]['name']) );
          }
        }
      }
    }


    foreach ($params as $thisParam => $thisParamVal)
    {

      if (substr($thisParam, 0, 9) == 'rm_image_')
      {
        $imageSpecParts = explode('_', $thisParam);
        $mod->purgeAllImage($imageSpecParts[2], $imageSpecParts[3]);
      }
    }
    
    // and uploaded files
    $filecount = $mod->GetPreference('item_file_count', 0);
    $typelist = $mod->GetPreference('item_file_types', 'pdf,swf,flv,doc,odt,ods,xls');
    $types = explode(',' , $typelist);

    if ($filecount > 0)
    {
      $dirspec = cms_join_path(
                                $config['uploads_path'],
                                catFilesOperations::getAssetPath('f'),
                                $this->mAlias 
                              );

      if (!is_dir($dirspec))
      {
        mkdir($dirspec);
      }

      for ($i=0; $i< $filecount; $i++)
      {

        if (isset($_FILES['file' . $i]['size']) && $_FILES['file' . $i]['size'] > 0)
        {
          $tspec = preg_replace('/[^\w\d\.\-_]+/', '_', $_FILES['file' . $i]['name']);
          // keep original image
          $extension = substr($tspec, strrpos($tspec, '.') + 1);

          if (!empty($extension) && in_array($extension, $types))
          {
            $mod->Audit(0, $mod->Lang('friendlyname'), $mod->Lang('uploaded', array($tspec, $this->mAlias)));
            
            $target = cms_join_path($dirspec, $tspec);
            $cres = copy($_FILES['file' . $i]['tmp_name'], $target);

            if (!$cres)
            {
              $this->validationError($mod->Lang('badimage', $_FILES['image' . $i]['name']));
            }
          }
          else
          {
            $mod->Audit(0, $mod->Lang('friendlyname'), $mod->Lang('badfile', $tspec));
            $this->validationError($mod->Lang('badfile', $tspec));
          }
        }
      }
    }

    foreach ($params as $thisParam => $thisParamVal)
    {

      if (substr($thisParam, 0, 8) == 'rm_file_')
      {
        $pSpec = preg_replace('/\.\.|\//', '', $thisParamVal);

        $spec = cms_join_path(
                                $config['uploads_path'],
                                catFilesOperations::getAssetPath('f'),
                                $this->mAlias,
                                $pSpec
                              );
        unlink($spec);
      }
    }

    parent::FillParams($params);
  }

  function PopulateParams(&$params)
  {
    $parameters = array('sub_template');

    foreach ($parameters as $oneparam)
    {
      $tmp = $this->GetPropertyValue($oneparam);

      if (isset($tmp) && ! empty($tmp))
      {
        $params[$oneparam] = $tmp;
      }
    }
    
    $this->getUserAttributes();
    $safeattrlist = array();

    foreach ($this->attrs as $thisAttr)
    {
      $tmp = $this->GetPropertyValue($thisAttr->attr);

      if (isset($tmp) && $tmp!='')
      {
        $params[$thisAttr->safe] = $tmp;

        if (isset($thisAttr->alias) && $thisAttr->alias!='')
        {
          $params[$thisAttr->alias] = $tmp;
        }

        $thisSafeAttr = array();
        $thisSafeAttr['name'] = ucfirst($thisAttr->attr);
        $thisSafeAttr['key'] = '{$' . $thisAttr->safe . '}';

        if ($thisAttr->alias != '')
        {
          $thisSafeAttr['aliaskey'] = '{$' . $thisAttr->alias . '}';
        }

        array_push($safeattrlist, $thisSafeAttr);
      }
      else
      {
        $params[$thisAttr->safe] = '';
        $params[$thisAttr->alias] = '';
      }
    }
    $params['attrlist'] = $safeattrlist;
  } 
  
  function Show($param = '')
  {
    $param = trim($param);
    
    if( !$param ) $param = 'content_en';
    $param = str_replace(' ','_',$param); 
    
    if ($param == 'content_en')
    {
      $this->PopulateParams($params);
      $params['content_en'] = parent::Show($param);
      return $this->RenderContent($params); 
    }
    else
    {
      return parent::Show($param);
    }
  }
 
  protected function Update()
  {
    parent::Update();
    
    if( ($this->mOldAlias != $this->Alias()) && $this->mOldAlias && $this->Alias() )
    {
      cms_utils::get_module('Cataloger')->renameImages($this->mOldAlias,$this->Alias());
    }
    
  }

  protected function Insert()
  {
    parent::Insert();
    
    if( ($this->mOldAlias != $this->Alias()) && $this->mOldAlias && $this->Alias() )
    {
      cms_utils::get_module('Cataloger')->renameImages($this->mOldAlias,$this->Alias());
    }
    
  }
  
  function AddProperty($name, $priority, $tab = self::TAB_MAIN, $required = FALSE)
  {
    parent::AddProperty($name, $priority, $tab, $required);
  }
 
  function UpdatePropertyName($propName, $propNewName)
  {
    $tempValue = '';
    
    if ($this->is_known_property($propName))
    {
      $tempValue = $this->GetPropertyValue($propName);
      $this->RemoveProperty($propName,false);   
    }
    
    $this->AddExtraProperty($propName);
    $this->SetPropertyValue($propNewName, $tempValue);  
  }   
 
  function DeleteProperty($propName)
  {
    $this->RemoveProperty($propName,false);       
  }

  /**
  * #
  * 
  * @param mixed $params
  */
  function RenderContent($params)
  {
    $mod = $this->get_mod();
    //$smarty = $mod->GetActionTemplateObject();
    $config = cmsms()->GetConfig();
    
    if( empty($smarty) ) $smarty = cmsms()->GetSmarty();
    $cntObj = new stdClass();
    
    $showMissing = '_' . $mod->GetPreference('show_missing', '1');

    $imageArray     = array();
    $fileArray      = array();
    $fileUrlArray   = array();
    $fileTypeArray  = array();
    $srcImgArray    = array();
    $thumbArray     = array();
    
    $imgcount = $mod->GetPreference('item_image_count', 2);
    $filecount = $mod->GetPreference('item_file_count', 0);
    $fullSize = $mod->GetPreference('item_image_size_hero', '400');
    $thumbSize = $mod->GetPreference('item_image_size_thumbnail', '70');
    $prunelist = ($mod->GetPreference('show_extant', '1') == '1');
    
    $actualfilecount = 0;

    foreach ($params as $key => $val)
    {
      $smarty->assign($key, $params[$key]);
      $cntObj->$key = $params[$key];
    }
    
    $cntObj->default_content = $params['content_en'];
    $smarty->assign('main_content', $params['content_en']);
    
    if ($imgcount > 0)
    {
      $smarty->assign('ImageCount', $imgcount); # new in 1.12 (JM)
      $cntObj->ImageCount = $imgcount;          # new in 1.12 (JM)

      for ($i = 1 ; $i <= $imgcount ; $i++)
      {
        
        if (! $prunelist || catFilesOperations::srcExists($this->mAlias, $i))
        {
          $propvalue = catFilesOperations::imageSpec($this->mAlias, 'f', $i, $fullSize);
          $propName = 'image_' . $i . '_url';
          $cntObj->$propName = $propvalue;
          $smarty->assign($propName, $propvalue);
          array_push($imageArray, $propvalue);

          $propvalue = catFilesOperations::imageSpec($this->mAlias, 't', $i, $thumbSize);
          $propName = 'image_thumb_' . $i . '_url';
          $cntObj->$propName = $propvalue;
          $smarty->assign($propName, $propvalue);
          array_push($thumbArray, $propvalue);
          
          $propvalue = catFilesOperations::srcImageSpec($this->mAlias, $i);
          $propName = 'src_image_' . $i . '_url';
          $cntObj->$propName = $propvalue;
          $smarty->assign($propName, $propvalue);
          array_push($srcImgArray, $propvalue);          
        }
                  
      }
          
    }
    
    if ($filecount > 0)
    {
      list($fileArray, $fileTypeArray) = catFilesOperations::getFiles($this->mAlias);

      foreach ($fileArray as $i => $v)
      {   
        $propvalue = $config['uploads_url']
                     . '/' 
                     . catFilesOperations::getAssetPath('f')
                     . '/'
                     . $this->mAlias
                     . '/'
                     . $fileArray[$i];

        $propName = 'file_' . ($i + 1) . '_url';
        $cntObj->$propName = $propvalue;
        $smarty->assign($propName, $propvalue);
        array_push($fileUrlArray, $propvalue);
        
        $propvalue = $fileArray[$i];
        $propName = 'file_' . ($i + 1) . '_name';
        $cntObj->$propName = $propvalue;           
        $smarty->assign($propName, $propvalue); 
               
        $propvalue = $fileTypeArray[$i];
        $propName = 'file_' . ($i + 1) . '_ext';
        $cntObj->$propName = $propvalue;           
        $smarty->assign($propName, $propvalue);

        $actualfilecount += 1;
      }
    }  
    
    $cntObj->attrlist = $params['attrlist'];
    $cntObj->image_url_array = $imageArray;
    $cntObj->file_url_array = $fileUrlArray;
    $cntObj->file_name_array = $fileArray;
    $cntObj->file_ext_array = $fileTypeArray;
    $cntObj->file_count = $filecount;
    $cntObj->image_thumb_url_array = $thumbArray;
    $cntObj->src_image_url_array = $srcImgArray;
        
    $smarty->assign('attrlist', $params['attrlist']);
    $smarty->assign('image_url_array', $imageArray);
    $smarty->assign('file_url_array', $fileUrlArray);
    $smarty->assign('file_name_array', $fileArray);
    $smarty->assign('file_ext_array', $fileTypeArray);
    $smarty->assign('file_count', $filecount);
    $smarty->assign('image_thumb_url_array', $thumbArray);
    $smarty->assign('src_image_url_array', $srcImgArray);
    $mod->smartyBasics();
    

    $smarty->assign('ctlg', $cntObj);

    $cache_id = '_itm_' . md5( serialize($params) );
    $compile_id = 'Cataloger_' . $this->mId;

    return $smarty->fetch(
                            $mod->GetDatabaseResource('catalog_' . $params['sub_template']),
                            $cache_id,
                            $compile_id
                          );
  }

}
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/class.CatalogPrintable.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.12
#
# Copyright (c) 2012, Fernando Morgado (JoMorg) jomorg.morg@gmail.com
# Copyright (c) 2006, Samuel Goldstein <sjg@cmsmodules.com>
# For Information, Support, Bug Reports, etc, please visit the
# CMS Made Simple Forge at http://dev.cmsmadesimple.org
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http://www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
class CatalogPrintable extends Content
{
  const TAB_PRINT_OPTIONS     = 'cc_cataloger_options';
  const TAB_PRINT_FIELDSLIST  = 'cc_cataloger_fieldslist';
  
  private $_mod;
  private $attrs;
  private $_attr_list = array();
  protected $validation = FALSE;
    
  
  function __construct()
  {
    parent::__construct();
    $this->mCachable = false;
  }
  
  function ModuleName()
  {
    return 'Cataloger';
  } 

  function IsCopyable()
  {
    return true;
  }
  
  function IsDefaultPossible()
  {
    return FALSE;
  } 
  
  function FriendlyName()
  {
    return $this->Lang('catalog_printable');
  }
  
  function Lang($key)
  {
    return $this->get_mod()->Lang($key);
  }
        
  function get_lang($key)
  {
    return $this->get_mod()->Lang($key);
  }
    
  function get_mod()
  {
    if( is_null($this->_mod) )
    {
      $this->_mod = cms_utils::get_module('Cataloger');
    }
    return $this->_mod;
  }

  public function GetTabNames()
  {
    $mod = $this->get_mod();
    $out = parent::GetTabNames();
    
    if( isset($out[self::TAB_PRINT_OPTIONS]) ) 
    {
      $out[self::TAB_PRINT_OPTIONS] = $mod->lang('tab_advanced_options');
    }
        
    if( isset($out[self::TAB_PRINT_FIELDSLIST]) ) 
    {
      $out[self::TAB_PRINT_FIELDSLIST] = $mod->lang('tab_fields_list');
    }

    return $out;
  }
  
   function HasAttributes()
  {
    return is_array($this->attrs) && (count($this->attrs) > 0);
  }
  
  function getAttrs()
  {
    $this->getUserAttributes();
    return $this->attrs;
  }
  
  function getUserAttributes()
  {
    if( empty($this->attrs) ) 
    {
      $this->attrs = catUserDefAttributesOps::getUserAttributes('catalog_cat_attrs');
      $this->_attr_list = array_keys($this->attrs); 
    } 
  }
  
  // to revisit... copied from feu_protected_page
  // its just a hack to avoid caching issues... but not the best
  public function GetModifiedDate()
  {
    // on frontend requests this will force the template to be recompiled
    // and therefore evaluation to be done for each request.
    if( cmsms()->is_frontend_request() ) return time();
    return parent::GetModifiedDate();
  }
  
  function SetProperties()
  {
    parent::SetProperties();
    $this->AddProperty('sub_template',    0, self::TAB_PRINT_OPTIONS);
    $this->AddProperty('sort_order',      1, self::TAB_PRINT_OPTIONS);
    $this->AddProperty('fieldlist',       0, self::TAB_PRINT_FIELDSLIST);
    #Turn on preview
    $this->mPreview = true;
    #Turn off caching
    $this->mCachable = false;
  }
  
  protected function display_single_element($one, $adding = false)
  {
    $gCms = cmsms();
    $mod = $this->get_mod();
    $smarty = $gCms->GetSmarty();

    switch($one)
    {
      
    case 'fieldlist':
    {
      $item = new CatalogItem();
      $itemAttrs = $item->getAttrs();
      $attrPick = '';
      $selAttrs = explode( ',', $this->GetPropertyValue('fieldlist') );
      
      foreach ($itemAttrs as $thisAttr)
      {
        $attrPick .= '<input type="checkbox" name="fieldlist[]" value="' . $thisAttr->attr . '" ';
        
        if ( in_array($thisAttr->attr, $selAttrs) )
        {
          $attrPick .= ' checked="checked"';
        }
        
        $attrPick .= ' />&nbsp;' . $thisAttr->attr . '<br />';
      }

      $ret = array($this->Lang('which_attributes'), $attrPick);
       
       return $ret;
    }
             
    case 'sub_template':
    {
      $subTemplates = catTemplateOperations::GetTemplateListFromID(3);

      $ret = array(
                    '<label for="in_sub_template">' 
                    . $mod->lang('Sub') 
                    . ' '
                    . lang('template') 
                    . ':</label>',
                    $mod->CreateInputDropdown(
                                                '', 
                                                'sub_template', 
                                                $subTemplates, 
                                                -1, 
                                                $this->GetPropertyValue('sub_template')
                                              )
                  );
       
       return $ret;
    }
    break;

    case 'sort_order':
    {
      $ret = array();
      
      $so = $this->GetPropertyValue('sort_order');

      if ($so == '')
      {
          $so = $mod->GetPreference('category_sort_order', 'natural');
      }
                                                          
      $ret = array(
                    $mod->Lang('title_global_item_sort_order2'), 
                    $mod->CreateInputDropdown(
                                                '',
                                                'sort_order', 
                                                array(
                                                        $mod->Lang('natural_order')=>'natural',                                                                $mod->Lang('alpha_order')=>'alpha'
                                                      ), 
                                                      -1, 
                                                      $so
                                              )
                   );
      return $ret;
      
    }
    break;    

    default:
      return parent::display_single_element($one, $adding);
    }
  }
  

  function FillParams($params, $editing = true)
  { 
    if( !isset($params) ) return;

    $this->mCachable = false;

    $parameters = array('sub_template', 'sort_order');

    foreach ($parameters as $oneparam)
    {
      if (isset($params[$oneparam]))
      {
        $this->SetPropertyValue($oneparam, $params[$oneparam]);
      }
    }

    if(isset($params['fieldlist']))
    {
      if (! is_array($params['fieldlist']))
      {
        $params['fieldlist'] = array($params['fieldlist']);
      }

      $this->SetPropertyValue('fieldlist', implode(',', $params['fieldlist']));
    }
    else
    {
      $this->SetPropertyValue('fieldlist', '');
    }

		parent::FillParams($params);
	}

  function PopulateParams(&$params)
  {   
    $parameters = array('sub_template', 'sort_order', 'fieldlist');

    foreach($parameters as $oneparam)
    {
      $tmp = $this->GetPropertyValue($oneparam);
      
      if (isset($tmp) && !empty($tmp))
      {
        if($oneparam  == 'fieldlist')
        {
           $params[$oneparam] = $tmp;
           continue;
        }
        
        $params[$oneparam] = $tmp;
      }
    }
		
    $this->getUserAttributes();
    $safeattrlist = array();

    foreach ($this->attrs as $thisAttr)
    {
      $tmp = $this->GetPropertyValue($thisAttr->attr);
      
      if (isset($tmp) && $tmp!='')
      {
        $params[$thisAttr->safe] = $tmp;
        
        if (isset($thisAttr->alias) && $thisAttr->alias!='')
        {
          $params[$thisAttr->alias] = $tmp;
        }
        
        $thisSafeAttr = array();
        $thisSafeAttr['name'] = ucfirst($thisAttr->attr);
        $thisSafeAttr['key'] = '{$' . $thisAttr->safe . '}';
        
        if ($thisAttr->alias != '')
        {
          $thisSafeAttr['aliaskey'] = '{$' . $thisAttr->alias . '}';
        }
        array_push($safeattrlist, $thisSafeAttr);
      }
      else
      {
        $params[$thisAttr->safe] = '';
        $params[$thisAttr->alias] = '';			
      }
    }
    
    $params['title'] = $this->mName;
    $params['menutext'] = $this->mMenuText;
    $params['template_id'] = $this->mTemplateId;
    $params['alias'] = $this->mAlias;
    $params['parent_id'] = $this->mParentId;
    $params['active'] = $this->mActive;
    $params['showinmenu']=$this->mShowInMenu;
    $params['attrlist'] = $safeattrlist; 
  }
  
  function Show($param = '')
  {
    $param = trim($param);
    
    if( !$param ) $param = 'content_en';
    $param = str_replace(' ','_',$param); 
    
    if ($param == 'content_en')
    {
      $this->PopulateParams($params);
      $params['content_en'] = parent::Show($param);
      return $this->RenderContent($params);;  
    }
    else
    {
      return parent::Show($param);
    }
  }

  protected function Update()
  {
    parent::Update();
    
    if( ($this->mOldAlias != $this->Alias()) && $this->mOldAlias && $this->Alias() )
    {
      cms_utils::get_module('Cataloger')->renameImages($this->mOldAlias,$this->Alias());
    }
  }

  protected function Insert()
  {
    parent::Insert();
    
    if( ($this->mOldAlias != $this->Alias()) && $this->mOldAlias && $this->Alias() )
    {
      catFilesOperations::renameImages( $this->mOldAlias, $this->Alias() );
    }
  }
   
  function UpdatePropertyName($propName, $propNewName)
  {
     $tempValue = '';
     if ($this->is_known_property($propName))
     {
          $tempValue = $this->GetPropertyValue($propName);
          $this->RemoveProperty($propName,false);   
     }
     $this->AddExtraProperty($propName);
     $this->SetPropertyValue($propNewName, $tempValue);  
  }   

  function DeleteProperty($propName)
  {
    $this->RemoveProperty($propName,false);       
  }

  function RenderContent($params)
  {
    $mod = $this->get_mod();
    $smarty = cmsms()->GetSmarty();
    $cntObj = new stdClass();
    
    $showMissing = '_' . $mod->GetPreference('show_missing', '1');
    $params['alias'] = '/';           # ????
    $params['recurse'] = 'items_all'; # ????

    foreach ($params as $key=>$val)
    {
      $smarty->assign($key, $params[$key]);
      $cntObj->$key = $params[$key];
    }
    
    $cntObj->default_content = $params['content_en'];
    $smarty->assign('main_content', $params['content_en']);

    list($curPage, $pageItems) = catContentOperations::getCatalogItemsList($params);

    if (isset($params['sort_order']) && $params['sort_order'] == 'alpha')
    {
      usort( $pageItems, array("catContentOperations", "contentalpha") );
    }

    $count = count($pageItems);
    
    $fl = array();
    
    if( isset($params['fieldlist']) )
    {
      $fl = explode(',', $params['fieldlist']);
    }
     
    $fldlist = array();

    foreach($fl as $tk => $tv)
    {
      $attr = strtolower(preg_replace('/\W/', '', $tv));
      $fldlist[$attr] = $tv;
    }
    
    $cntObj->FieldList = $fldlist;
    $cntObj->attrlist = $fldlist;
    $cntObj->Items = $pageItems;
    //debug_display($pageItems);
    $smarty->assign('items', $pageItems);
    $fullSize = $mod->GetPreference('item_image_size_catalog', '100');
    
    
    $imageArray = array();
    //$fileArray = array();
    //$fileUrlArray = array();
    //$fileTypeArray = array();
    $srcImgArray = array();
    $thumbArray = array();
    
    $imageArray = array();
    $srcImgArray = array();
    $_images = array();
    
    $imgcount = $mod->GetPreference('item_image_count', 2);
    $filecount = $mod->GetPreference('item_file_count', 0);
    $fullSize = $mod->GetPreference('item_image_size_hero', '400');
    $thumbSize = $mod->GetPreference('item_image_size_thumbnail', '70');
    $prunelist = ($mod->GetPreference('show_extant', '1') == '1');
    
    for ($i = 1 ; $i <= $imgcount ; $i++)
    {
      $_url = catFilesOperations::imageSpec($curPage->Alias(), 'ctf', $i, $fullSize);
      $_src_url = catFilesOperations::srcImageSpec($curPage->Alias(), $i);
      array_push($imageArray, $_url);
      array_push($srcImgArray, $_src_url);
      $_images[$i]['url'] = $_url;
      $_images[$i]['src_url'] = $_src_url;
      $smarty->assign('image_' . $i . '_url', $_url);
      $smarty->assign('src_image_'.$i.'_url', $_src_url);
      #$smarty->assign('src_image_'.$i.'_url', catFilesOperations::srcImageSpec($params['alias'], $i)); wtf????
    }

    $cntObj->ImagesArray = $_images;
    $cntObj->image_url_array = $imageArray;
    $cntObj->image_thumb_url_array = $thumbArray;
    
    $smarty->assign('attrlist', $fldlist);

    $smarty->assign('image_url_array', $imageArray);
    $smarty->assign('src_image_url_array', $srcImgArray);
    $smarty->assign('image_thumb_url_array', $thumbArray);
    $mod->smartyBasics();
    
    #####################################################################
//    $cntObj->default_content = $params['_default_cnt'];
//    $cntObj->main_content = $params['_default_cnt'];
//    $smarty->assign('main_content', $params['_default_cnt']);
    ##################################################################### 

    $smarty->assign('ctlg', $cntObj);    
                     
    $cache_id = '_prt_' . md5( serialize($params) );
    $compile_id = 'Cataloger_' . $this->mId;
    
    return $smarty->fetch(
                            $mod->GetDatabaseResource('catalog_' . $params['sub_template']),
                            $cache_id,
                            $compile_id
                          );
  }
}
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/class.CatContentBaseType.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
class CatContentBaseType extends Content
{
  # internal
  protected $_mod;
  protected $validation = FALSE;
  
  # we need these to set some defaults
  protected $catExpired;
  protected $catUseExpirationDate;
  protected $catExpirationStartDate;
  protected $catExpirationEndDate;
  
  # user attributes array
  protected $attrs;

  function __construct()
  {
    parent::__construct();
  }
    
  function &get_mod()
  {
    if( is_null($this->_mod) )
    {
      $this->_mod = cms_utils::get_module('Cataloger');
    }
    return $this->_mod;
  }
      
  function Lang($key)
  {
    return $this->get_mod()->Lang($key);
  }
        
  function get_lang($key)
  {
    return $this->get_mod()->Lang($key);
  }
  
  function GetAdminThemeName()
  {
    return cms_utils::get_theme_object()->GetDefaultTheme(); 
  }
  
  protected function SetDefaults()
  {
    $temp = $this->GetPropertyValue('expired');
    
    if( !isset($temp) )
    {
      $this->SetPropertyValue('expired', $this->catExpired);
    }
    
    $temp = $this->GetPropertyValue('use_expiration_date');
    
    if( !isset($temp) )
    {
      $this->SetPropertyValue('use_expiration_date', $this->catUseExpirationDate);
    }
    
    $temp = $this->GetPropertyValue('expiration_start_date');
    
    if( !isset($temp) )
    {
      $this->SetPropertyValue('expiration_start_date', $this->catExpirationStartDate);
    }
    
    $temp = $this->GetPropertyValue('expiration_end_date');
    
    if( !isset($temp) )
    {
      $this->SetPropertyValue('expiration_end_date', $this->catExpirationEndDate);
    }
    
  }
  
  function ModuleName()
  {
    return 'Cataloger';
  } 

  function IsCopyable()
  {
    return true;
  }
  
  function IsDefaultPossible()
  {
    return FALSE;
  }

  function GetCreationDate()
  {
    return $this->mCreationDate;
  }

  function GetModifiedDate()
  {
    return $this->mModifiedDate;
  }

  function HasAttributes()
  {
    return is_array($this->attrs) && (count($this->attrs) > 0);
  }
  
  function SetProperties()
  {
    parent::SetProperties();
    
    $this->getUserAttributes();
    
    #lets add the fields
    if (is_array($this->attrs))
    {
      foreach ($this->attrs as $thisAttr)
      {
        $this->AddContentProperty($thisAttr->attr, 100 + $thisAttr->field_order);
      }
    }

    # since 0.12 (JoMorg)
    $this->AddContentProperty('expired', 101);
    $this->AddContentProperty('use_expiration_date', 102);

    $this->AddContentProperty('expiration_start_date', 103);
    $this->AddContentProperty('expiration_end_date', 104);
         
    # let's set defaults   
    
    // turn on preview
    $this->mPreview = true;

    // turn off caching
    $this->mCachable = false;
    
    // not expired by default
    $this->catExpired = false;
    
    // don't use expiration date
    $this->actUseExpirationDate = false;
    
    $now = time();
    
    // defaults to now
    $this->actExpirationStartDate = $now;

    $ndays = (int)$this->get_mod()->GetPreference('expiry_interval', 180);
    if( $ndays == 0 )
    {
      $nyears = 1;
      $end_date = strtotime( sprintf( "+%d years", $nyears ), time() ); 
    }
    else
    {
      $end_date = strtotime( sprintf( "+%d days", $ndays ), time() );
    }
    
    $this->actExpirationEndDate = $end_date;

  }
  
  function getUserAttributes()
  {
    # just so we don't get an error
  }
  
  function getAttrs()
  {
    $this->getUserAttributes();
    return $this->attrs;
  }

  function FillParams($params, $editing = false)
  {
    
    if( !isset($params) ) return;

    $parameters = array('sub_template', 'use_expiration_date');

    foreach($parameters as $oneparam)
    { 
      if( isset($params[$oneparam]) )
      {
        $this->SetPropertyValue($oneparam, $params[$oneparam]);
      }
    }
      
    # special cases
    if( isset($params['StartDate_Month']) )
    {
      
      $startdate = catContentOperations::makeTimeStamp(
                                                        $params['StartTime_Hour'], 
                                                        $params['StartTime_Minute'], 
                                                        $params['StartTime_Second'],
                                                        $params['StartTime_Year'], 
                                                        $params['StartDate_Month'], 
                                                        $params['StartDate_Day']
                                                      );
                                          
      $this->SetPropertyValue('expiration_start_date', $startdate);
    }      
    
    if( isset($params['EndDate_Month']) )
    {
      
      $enddate = catContentOperations::makeTimeStamp(
                                                        $params['EndTime_Hour'], 
                                                        $params['EndTime_Minute'], 
                                                        $params['EndTime_Second'],
                                                        $params['EndDate_Year'], 
                                                        $params['EndDate_Month'], 
                                                        $params['EndDate_Day']
                                                      );
                                                      
      $this->SetPropertyValue('expiration_end_date', $enddate);
    }
    
    if( isset($params['expired']) )
    {
      $mod = $this->get_mod();
      $ExpiryAction = $mod->GetPreference('OnExpiryAction', 3);
      
      if ($this->catExpired <> $params['expired'])
      {
        $this->catExpired = $params['expired'];
        if ($params['expired'])
        {
          $this->_doExpire($ExpiryAction, true, false); 
        }
        else
        {
          $this->_doUnExpire(true, false); 
        }

      }
    }
    
    parent::FillParams($params);
  }

  
  function ValidateData()
  {
    $errors = parent::ValidateData();
    
    if( $errors === FALSE )
    {
      $errors = array();
    }

    return ( count($errors) > 0 ? $errors : FALSE );
  }

  /**
  * Add extra tabs
  */
 
  protected function _TabLogic()
  {
    $hash = array('main', 'options', 'cataloger_options');
    
    if ( $this->HasAttributes() )
    {
      array_push($hash, 'attributes');
    }

    return $hash;
  }
 
  public function TabNames()
  {
    $ret = parent::TabNames();
    $mod = $this->get_mod();
    array_push( $ret, $mod->lang('title_cataloger_extras') );
    
    if ( $this->HasAttributes() )
    {
      array_push( $ret, $mod->lang('title_cataloger_attrs') );
    }

    return $ret;
  }
  
  function EditAsArray($adding = false, $tab = 0, $showadmin = false)
  {
    $mod = $this->get_mod();
    $ret = parent::EditAsArray($adding, $tab, $showadmin);
    
    $tabHash = $this->_TabLogic();
    
    if ($tabHash[$tab] == 'attributes')
    { 
      $this->getUserAttributes();

      foreach ($this->attrs as $thisAttr)
      {
        $ret[] = catFields::RenderInput($thisAttr, $this->GetPropertyValue($thisAttr->attr));
      }
    }
    
    if ($tabHash[$tab] == 'cataloger_options')
    {
      ## some Warnings here #####################################################
      if ($this->mAlias == '')
      {
        $warningimg = '<img alt="'
                      . $mod->Lang('no_alias_warning')
                      . '" src="'
                      . $this->GetWarningImage()
                      . '" />';
        $warning = $mod->Lang('no_alias_warning');
        
        $ret[] = array ($warningimg, $warning);
        $ret[]= array('<hr />');
      }
            
      if (!$this->HasAttributes())
      {
        $warningimg = '<img alt="'
                      . $mod->Lang('no_attrs_warning')
                      . '" src="'
                      . $this->GetWarningImage()
                      . '" />';
        $warning = $mod->Lang('no_attrs_warning');
        
        $ret[] = array ($warningimg, $warning);
        $ret[]= array('<hr />');
      }
      ##                    #####################################################

      $ret[]= $this->display_single_element_ext('use_expiration_date');
      $ret[]= $this->display_single_element_ext('expired');
//      $ret[]= array('<hr />');
//      $ret[]= $this->display_single_element_ext('expiration_start_date');
//      $ret[]= $this->display_single_element_ext('expiration_start_time'); #special case
      $ret[]= array('<hr />');
      $ret[]= $this->display_single_element_ext('expiration_end_date');
      $ret[]= $this->display_single_element_ext('expiration_end_time');   #special case
    }

    return $ret;
  }
   
  /**
  * We override this to make shure all properties
  * are known to CMSMS, and call parent method
  * to enforce the default behaviour.
  * But we deal with the actual displaying
  * of the elements on our own extended version
  * of this method. ( display_single_element_ext() )
  *  
  * 
  * @param mixed $one
  * @param mixed $adding
  * @return void
  */
  protected function display_single_element($one, $adding)
  {
    # we just want to make sure the new ones are known to CMSMS
    $this->getUserAttributes();
    $elements = array();
    
    foreach ($this->attrs as $element)
    {
      array_push($elements, $element->attr);
    }
    
    if (in_array($one, $elements))
    {
      $r = array();
      return $r;
    }
    
    $elements = array(
                        'use_expiration_date', 
                        'expired',
                        'expiration_start_date',  
                        'expiration_end_date'
                      );
    
    if (in_array($one, $elements))
    {
      $r = array();
      return $r;
    }
    
    return parent::display_single_element($one, $adding);

  }
  
  /**
  * Our own version of display_single_element()
  * prevents displaying properties out of the pertinent tabs
  * and allows for some expecial treatment of date and time fields  
  * 
  * @param mixed $one
  * @param mixed $adding
  */
  protected function display_single_element_ext($one, $adding = false)
  {
    $gCms = cmsms();
    $mod = $this->get_mod();
    $smarty = $gCms->GetSmarty();
    $this->SetDefaults();

    switch($one)
    {
      
      case 'use_expiration_date':
      {
        $warningimg = '<img alt="'
                      . $mod->Lang('no_attrs_warning')
                      . '" src="'
                      . $this->GetWarningImage()
                      . '" />';
                      
        $warning = $warningimg . ' ' . $mod->Lang('warning_prompt_use_expiration');
        
        $global = $mod->GetPreference('UseExpDate', FALSE);
        $value = $this->GetPropertyValue('use_expiration_date');
        $r = array (
                      '<label for="in_use_expiration_date">'
                      . $mod->Lang('prompt_use_expiration')
                      . ':</label>',
                      '<input type="hidden" name="use_expiration_date" value="0"/>
                      <input id="in_use_expiration_date" class="pagecheckbox" type="checkbox" value="1" name="use_expiration_date"'
                      . ($value ? ' checked = "checked"' :'' )
                      . ' />',
                      $mod->Lang('help_prompt_use_expiration')
                      . ($global ? '' :( '<br /><em>' . $warning . '</em>'  ) )
                    );
        return $r;
      }
      break;
      
//      case 'expiration_start_date':   #still needs more work
//      {
//        $value = $this->GetPropertyValue('expiration_start_date');
//        $field = '{html_select_date  prefix=\'StartDate_\' field_order=\'DMY\' start_year=\'-1\' end_year=\'+100\' time=' . $value .'}';
//        $r = array ($mod->Lang('prompt_expiration_start_date') . ':', $smarty->fetch('eval:'.$field));
//        return $r;        
//      }
//      break;
//      
//      case 'expiration_start_time':
//      {
//        $value = $this->GetPropertyValue('expiration_start_date');
//        $field = '{html_select_time  prefix=\'StartTime_\' time=' . $value .'}';
//        $r = array ($mod->Lang('prompt_expiration_start_time') . ':', $smarty->fetch('eval:'.$field));
//        return $r;        
//      }
//      break;
          
      case 'expiration_end_date':
      {
        $value = $this->GetPropertyValue('expiration_end_date');
        $field = '{html_select_date  prefix=\'EndDate_\' field_order=\'DMY\' start_year=\'-1\' end_year=\'+100\' time=' . $value .'}';
        $r = array ($mod->Lang('prompt_expiration_end_date') . ':', $smarty->fetch('eval:'.$field));
        return $r;    
      }
      break;
    
      case 'expiration_end_time':
      {
        $value = $this->GetPropertyValue('expiration_end_date');
        $field = '{html_select_time  prefix=\'EndTime_\' time=' . $value .'}';
        $r = array ($mod->Lang('prompt_expiration_end_time') . ':', $smarty->fetch('eval:'.$field));
        return $r;     
      }
      break;
       
      case 'expired':
      {
        $warningimg = '<img alt="'
                      . $mod->Lang('no_attrs_warning')
                      . '" src="'
                      . $this->GetWarningImage()
                      . '" />';
                      
        $warning = $warningimg . ' ' . $mod->Lang('warning_prompt_expired');
        
        $global = $mod->GetPreference('UseExpDate', FALSE);
        $value = $this->GetPropertyValue('expired');
        $r = array (
                      '<label for="in_expired">'
                      . $mod->Lang('prompt_expired')
                      . ':</label>',
                      '<input type="hidden" name="expired" value="0"/>
                      <input id="in_expired" class="pagecheckbox" type="checkbox" value="1" name="expired"'
                      . ($value ? ' checked = "checked"' :'' )
                      . ' />',
                      $mod->Lang('help_prompt_expired')
                      . ($global ? '' :( '<br /><em>' . $warning . '</em>' ) )
                    );
        return $r;
      }
    
    }
    
  }

  function Show($param='')
  {
    $txt = '';
    $cnts = parent::Show($param);

    if( $param != 'content_en' && $param != 'content' ) 
    {
      // must be displaying some other block.
      return $cnts;
    }
    
    $mod = $this->get_mod();
    $global = $mod->GetPreference('UseExpDate', FALSE);
    $local = $this->GetPropertyValue('use_expiration_date');
    
    if ( ($global && $local) ) # so we have to process expiration dates
    {
      $txt = $this->ProcessExpiration();
    }
    else # we don't have to process expiration dates
    {
      $txt .= $this->_doShow();
    }
    
    return $txt;
  }
  
  function _doShow()
  {
    $params = array();
    $this->PopulateParams($params);
    $params['_default_cnt'] = $cnts;
    return $this->RenderContent($params);
  }

  /**
  * #
  * 
  * @param mixed $params
  */
  function RenderContent($params)
  {
    return '';
  }
  
  function ProduceExpiredContent($ExpiryAction)
  {
    $mod = $this->get_mod();   
    
    switch ($ExpiryAction) 
    {
       case 0:
       {
         # If we get here something gone wrong... we just send to _doExpire again...
         $this->_doExpire($ExpiryAction, false, true);
         # and hope it is for good this time... 
       }
       break;

       case 1:
       {
         # here we assume alias exists and is valid
         $redirect = $mod->GetPreference('expire_redirect_alias');
         $url = catContentOperations::URLfromAlias($redirect);
         catContentOperations::ErrorHandler301($url);
       }
       break;
       
       case 2:
       {
         # here we assume alias exists and is valid
         $redirect = $mod->GetPreference('expire_redirect_alias');
         $mod->redirectContent($redirect);
       }
       break;

       case 3:
       {
         $text = $mod->GetPreference('ExpirationText', $this->Lang('default_exp_text') );   
       }
       break;
    }

      # we only arrive here if no redirection or 301 status occur
      return $text; 
  }
  
  function ProcessExpiration()
  {
    $mod = $this->get_mod();
    $ExpiryAction = $mod->GetPreference('OnExpiryAction', 3);
    $expired = $this->GetPropertyValue('expired');
    $ExpirationStartDate = $this->GetPropertyValue('expiration_start_date');
    $ExpirationEndDate = $this->GetPropertyValue('expiration_end_date');
    #$un_expire =  catContentOperations::to_UnExpire($ExpirationStartDate);
    $expire = catContentOperations::to_Expire($ExpirationEndDate);
    
//    echo '<------------------------------------------------------><br>';
//    echo 'EXP_ACT = ' . $ExpiryAction . '<br>';
//    echo 'Exp = ' . ($expired ? 'true' : 'false' ) . '<br>';
//    echo 'Exp st date = ' . $ExpirationStartDate . '<br>';
//    echo 'Exp end date = ' . $ExpirationEndDate . '<br>';
//    echo 'Exp diff date = ' . ($ExpirationEndDate - $ExpirationStartDate) . '<br>';
//    echo 'now = ' . time() . '<br>';
//    echo 'End diff = ' . ( $ExpirationEndDate - time() ) . '<br>';
//    echo 'Start diff = ' . ( $ExpirationStartDate - time() ) . '<br>';
//    echo 'UnExp = ' . ($un_expire ? 'true' : 'false' ) . '<br>';
//    echo 'To Exp = ' . ($expire ? 'true' : 'false' ) . '<br>';
//    echo '<------------------------------------------------------><br>';
    
    
//      
//    if ($ExpirationStartDate >= $ExpirationEndDate)
//    {
//      # this should never happen
//      echo 'Expiration Date Range ERROR!';
//      exit;
//    }

    
    if ($expired) # already expired: either is marked for un_expired or just keep expired 
    {
      /*  TODO
      if ($un_expire)
      {
        $this->_doUnExpire(false, true);  
      }
      else
      */
      {
        return $this->ProduceExpiredContent($ExpiryAction);
      }

    }
    else # not expired? ok, so test for expiration or keep it on
    {
      
      if ($expire)
      {
        $this->_doExpire($ExpiryAction, false, true);  
      }
      else
      {
        $txt .= $this->_doShow();
      } 
    }
    
    return $txt;
  }  
  
  
  # Misc
  
  protected function _doExpire($mode, $editing = false, $trigger = false)
  {

    $mod = $this->get_mod();
    /**
    * Actions :
    *  0 - Deactivate and throws a 404).
    *     (Note: this is permanent dead as far as automation goes.... 
    *                       object won't get show() called if not active)
    *  1 - redirect 301 to alias
    *  2 - Redirect to alias
    *  3 - Replace the content by a text
    */ 

    
    # needs optimizing....
    switch ($mode) 
    {
       case 0:
       {
         $this->mActive = false;
         $this->mShowInMenu = false;
         $this->catExpired = true;
         $this->Update();
         $mod->clear_cache($this->mId);
         if ($trigger){$this->_doTrigger();}
         $mod->Audit($this->mId, $this->mType, 'Expired');
         #by redirecting to itself we leave the handling of the 401 to the CMSMS Core settings
         if (!$editing){$mod->redirectContent($this->mAlias);}
       }
       break;
       
       case 1:
       {
         $this->mShowInMenu = false;
         $this->catExpired = true;
         $this->Update();
         $mod->clear_cache($this->mId);
         if ($trigger){$this->_doTrigger();}
         $mod->Audit($this->mId, $this->mType, 'Expired');
         #redirect?
         if (!$editing){$mod->redirectContent($this->mAlias);}
       }
       break;
       
       case 2:
       {
         $this->mShowInMenu = false;
         $this->catExpired = true;
         $this->Update();
         $mod->clear_cache($this->mId);
         if ($trigger){$this->_doTrigger();}
         $mod->Audit($this->mId, $this->mType, 'Expired');
         #redirect?
         if (!$editing){$mod->redirectContent($this->mAlias);}
       }
       break;
              
       case 3:
       {
         $this->mShowInMenu = true;
         $this->catExpired = true;
         $this->Update();
         $mod->clear_cache($this->mId);
         if ($trigger){$this->_doTrigger();}
         $mod->Audit($this->mId, $this->mType, 'Expired');
         #redirect?
         if (!$editing){$mod->redirectContent($this->mAlias);}
       }
       break;
    }
  }
  
  protected function _doTrigger()
  {
    $mod = $this->get_mod();
    $now = time();
    
    $event_params = array(
                            'content'     => $this,
                            'timestamp'   => $now
                          );
                          
    $mod->SendEvent('OnContentEndDate', $event_params); 
  }
  
  protected function _doUnExpire($editing = false, $trigger = false)
  {
   
   $mod = $this->get_mod();
   $this->mShowInMenu = true;
   $this->catExpired = false;
   $this->Update();
   $mod->clear_cache($this->mId);
    
    if ($trigger)
    { # we trigger an event
    
      $event_params = array(
                              'content'     => $this,
                              'timestamp'   => $now
                            );
                            
      $mod->SendEvent('OnContentStartDate', $event_params);
    }
    
    $mod->Audit($this->mId, $this->mType, 'Un-Expired');
    die('duh');
    #if (!$editing){$mod->redirectContent($this->mAlias);}
  }
  
  protected function GetWarningImage()
  {
    $config = cmsms()->GetConfig();
    return $config['root_url']
           . '/admin/themes/'
           . $this->GetAdminThemeName()
           . '/images/icons/system/warning.gif';
  }
  
  function Save()
  {
    $this->SetPropertyValue('expired', $this->catExpired);
    parent::Save();
  }
  
  protected function Update()
  {
    $this->SetPropertyValue('expired', $this->catExpired);
    parent::Update();
  }

  protected function Insert()
  {
    parent::Insert();
  }
  
  
}

?>]]></data>
	</file>
	<file>
	  <filename>/lib/class.catContentOperations.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
class catContentOperations
{
  private static $_cms;
  private static $_mod;
  private static $_db;
  private static $_initialized = FALSE;
  
  private static function _initialize()
  {
    if(!self::$_initialized)
    {
      self::$_cms = cmsms();
      self::$_mod = self::$_cms->GetModuleInstance('Cataloger');
      self::$_db = self::$_cms->GetDb();
      self::$_initialized = TRUE; 
    } 
  }
  
  # deprecated
  private static function _getMod()
  {
    self::_initialize();
    return self::$_mod; 
  }  
  
  #deprecated
  private static function _getDB()
  {
    self::_initialize();
    return self::$_db;    
  }
   
  static function &GetContentFromParams(&$params)
  {
    $gCms= cmsms();
    $mod = self::_getMod();
    $vars = $mod->GetVariables(); # need a new way to get this....
    $hm = $gCms->GetHierarchyManager();
    
    if ( isset($params['alias']) && $params['alias'] == '/' )
    { # alias is root (/)
      $content = $hm->getFlatList();
      $curHierDepth = isset($params['start_depth']) ? $params['start_depth'] : -1;
      $curHierarchy = '';
      $curHierLen = 0;
      $curPage = new Content();
    }
    else
    { # either alias is NOT set or not root or neither
       if (isset($params['content_id']))
       { # we have a content_id
          $curPageID = $vars[$params['content_id']];
          $curPageNode = $hm->sureGetNodeById($curPageID);
          $curPage = $curPageNode->GetContent();
       }
       elseif (isset($params['alias']))
       { # we have an alias
          $curPageNode = $hm->sureGetNodeByAlias($params['alias']);
          $curPage = $curPageNode->GetContent();
          $curPageID = $curPage->Id();
       }
       else
       { 
          $ci = $gCms->get_content_id(); 
         if( isset($ci) )
         { # no id, no alias: get content_id from CMSMS application variables : deprecated in core.....
            $curPageID = $ci;
            $curPageNode = $hm->sureGetNodeById($curPageID);
            $curPage = $curPageNode->GetContent();
         }
       }  
      
       $curHierarchy = $curPage->Hierarchy();
       $curHierLen = strlen($curHierarchy);
       $curHierDepth = substr_count($curHierarchy, '.');     
       $content = self::getSubContent($curPageID);
    }  

    $ret = array($content, $curPage, $curHierarchy, $curHierLen, $curHierDepth);
    return $ret;
  } 
  
  static function &getSubContent($startNodeId)
  {
    $gCms = cmsms();
    $content = array();
    $hm = $gCms->GetHierarchyManager();
    /* Works with new addition to Tree, but getFlatList is default
     $rn = $hm->sureGetNodeById($startNodeId); 
     $count = 0;
     $hm->getFlattenedChildren($rn, $content, $count);
    */
    $content = $hm->getFlatList();
    return $content;
  }

  static function &getAllContent()
  {
    $gCms = cmsms();
    $content = array();
    $hm = $gCms->GetHierarchyManager();
    $rn = $hm->GetRootNode(); 
    $count = 0;
    $hm->getFlattenedChildren($rn, $content, $count);
    return $content;
  }

  static function getCatalogItemsList(&$params)
  {
    $lastcat = "";
    $lastcatfull = null;
    
    list($content, $curPage, $curHierarchy, $curHierLen, $curHierDepth) = self::GetContentFromParams($params);
    
    $categoryItems = array();

    foreach ($content as $thisPage)
    {
      $thispagecontent = $thisPage->GetContent();

      if( empty($thispagecontent) ) continue; 
      if( !self::_IsValid($thispagecontent) ) continue; 
      if( !$thispagecontent->Id() == $curPage->Id() ) continue;
            
      if ($thispagecontent->Type() == 'contentalias')
      {
         $thispagecontent = $thispagecontent->GetAliasContent();
         $curHierLen = strlen($curHierarchy);
         $curHierDepth = substr_count($curHierarchy, '.');
      }
      
      if ($thispagecontent->Type() == 'catalogcategory')
      {
        $lastcat = $thispagecontent->Name();
      }
    
      if ( !self::_IsValidType($thispagecontent, $params) )
      {
        continue;
      }

      if ( ! self::_IsValidDepth($thispagecontent, $params, $curHierDepth, $curHierLen, $curHierarchy) )
      {
          continue;
      }
     
      // in the category, and approved for addition
      $thisItem = self::itemToArray($thispagecontent, $lastcat);
      array_push($categoryItems, $thisItem);
    }

    return array($curPage, $categoryItems);
  }

  static function getCatalogItemsIDList(&$params)
  {
    $gCms = cmsms();
    $db = $gCms->GetDb();
    $ret = array();
    
    if (!isset($params['alias']) || $params['alias']=='/')
    {
      $dbresult = $db->Execute('SELECT content_id from ' . cms_db_prefix() . 
           'content where type=\'catalogitem\'');
    }
    else
    {
      $base_hierarchy = $db->GetOne('SELECT hierarchy from ' . cms_db_prefix() . 
           'content where content_alias=?',array($params['alias']));
      if (! $base_hierarchy)
      {
        return $ret;
      }
      $dbresult = $db->Execute('SELECT content_id from '.cms_db_prefix().
           'content where type=\'catalogitem\' and hierarchy LIKE \'' . $base_hierarchy . '%\'');
    }
    
    while ($dbresult !== false && $row = $dbresult->FetchRow())
    {
      array_push($ret,$row['content_id']);
    }
        
    return $ret;
  }
  
  static function &getCatalogItem($alias)
  {
    $gCms = cmsms();
    $mod = cms_utils::get_module('Cataloger');
    $hm = $gCms->GetHierarchyManager();
    $pageNode = $hm->sureGetNodeByAlias($alias);
    $page = $pageNode->GetContent();
    $node = self::itemToArray($page, '');
    return $node;
  }

  static function &getCatalogItemById($id)
  {
    $gCms = cmsms();
    $mod = cms_utils::get_module('Cataloger');
    $hm = $gCms->GetHierarchyManager();
    $pageNode = $hm->sureGetNodeById($id);
    $page = $pageNode->GetContent();
    $node = self::itemToArray($page, '');
    return $node;
  }


  static function itemToArray($pagecontent, $lastcat)
  {
    $mod = self::_getMod();
    $thisItem = array();
    $catThumbSize = $mod->GetPreference('category_image_size_thumbnail', 90);
    $itemThumbSize = $mod->GetPreference('item_image_size_category', 70);
    $missingImage = $mod->GetPreference('show_missing', '1');
    
    switch ($pagecontent->Type())
    {
      
      case 'catalogitem':
      {
        $thisItem['image'] = catFilesOperations::imageSpec(
                                                            $pagecontent->Alias(),
                                                            's', 
                                                            1, 
                                                            $itemThumbSize
                                                          );
                                              
        $thisItem['image_src'] = catFilesOperations::srcImageSpec(
                                                                    $pagecontent->Alias(),
                                                                    1
                                                                  );
      }
      break;
                          
      case 'catalogcategory':
      {
        $thisItem['image'] = catFilesOperations::imageSpec(
                                                              $pagecontent->Alias(),
                                                              'ct', 
                                                              1, 
                                                              $catThumbSize
                                                           );
      }
      break;
    }
      
    $thisItem['link'] = $pagecontent->GetUrl();
    $thisItem['title'] = $pagecontent->Name();
    $thisItem['alias'] = $pagecontent->Alias();
    $thisItem['menutitle'] = $pagecontent->MenuText();
    $thisItem['modifieddate'] = $pagecontent->GetModifiedDate();
    $thisItem['category'] = $lastcat;
    $thisItem['cat'] = $lastcat;
    $thisItem['createdate'] = $pagecontent->GetCreationDate();
    $thisItem['attrs'] = array();
    $theseAttrs = $pagecontent->getAttrs();

    foreach ($theseAttrs as $thisAttr)
    {
      $safeattr = strtolower(preg_replace('/\W/', '', $thisAttr->attr));
      $thisItem[$thisAttr->safe] = $pagecontent->GetPropertyValue($thisAttr->attr);
      $thisItem['attrs'][$thisAttr->safe] = $pagecontent->GetPropertyValue($thisAttr->attr);
      
      if( !isset($thisAttr->alias) || empty($thisAttr->alias) )
      {
        $thisAttr->alias = strtolower( preg_replace('/\W/', '', $thisAttr->attr) );
      }
      
      # prolly redundant 'if' and to be revoved if so... (JM)
      if( isset($thisAttr->alias) && !empty($thisAttr->alias) )
      {
        $thisItem[$thisAttr->alias] = $pagecontent->GetPropertyValue($thisAttr->attr);
        $thisItem['attrs'][$thisAttr->alias] = $pagecontent->GetPropertyValue($thisAttr->attr);  
      }
    }
    
    return $thisItem;
  }
  
  static protected function _IsActive(&$content)
  {
    return ( method_exists($content, 'Active') && $content->Active() );
  }  
    
  static protected function _IsValid(&$content)
  {
    return ( is_object($content) || ( !self::_IsActive($content) ) );
  }
  
  static protected function _IsValidType(&$content, &$params)
  {
    $type_ok = FALSE;
    $ct = $content->Type();
    
    switch ($ct)
    {
      case 'catalogitem':
      {
        $RecursiveModes = array('items_one', 'items_all', 'mixed_one', 'mixed_all');

        if ( in_array( $params['recurse'], $RecursiveModes) )
        {
          $type_ok = TRUE; 
        } 
      }
      break;
      
      case 'catalogcategory':
      {
        $RecursiveModes = array('categories_one', 'categories_all', 'mixed_one', 'mixed_all');

        if ( in_array( $params['recurse'], $RecursiveModes) )
        {
          $type_ok = TRUE; 
        } 
        
      }
      break;
    }
  
    return $type_ok;
  }
  
  
  static protected function _IsValidDepth(&$content, &$params, $curHierDepth, $curHierLen, $curHierarchy)
  {
    $depth_ok = false;

    $RecursiveModesOne = array('items_one', 'categories_one', 'mixed_one');
    $RecursiveModesAll = array('items_all', 'categories_all', 'mixed_all');
    $dot = substr( $content->Hierarchy(), 0, $curHierLen + 1 ) == $curHierarchy . '.';
    
    
    if (  
          in_array( $params['recurse'], $RecursiveModesOne)  &&
          substr_count( $content->Hierarchy(), '.' ) == ( $curHierDepth + 1 ) &&
          $dot 
       )
    {
      $depth_ok = true;
    }
    elseif ( 
              ( isset($params['alias']) && $params['alias'] == '/') ||
              ( in_array( $params['recurse'], $RecursiveModesAll)  && $dot )
           )
    {
      $depth_ok = true;
    }
    
    return $depth_ok;
  } 
  
  ######################################################
  # Sorting
  ######################################################
  
  static function contentalpha($a, $b)
  {
    return strcasecmp($a['title'], $b['title']);
  }
  

  static function chrono($a, $b)
  {
    #return self::CompareDates($a['modifieddate'], $b['modifieddate']);
    # reverse to keep compatibility with previous
    return self::CompareDates($b['modifieddate'], $a['modifieddate']);
    /*
    if ($a['modifieddate'] > $b['modifieddate'])
    {
      return -1;
    }
    if ($a['modifieddate'] < $b['modifieddate'])
    {
      return 1;
    }
    return 0;
    */
  }

  static function created($a, $b)
  {
    #return self::CompareDates($a['createdate'], $b['createdate']);
    # reverse to keep compatibility with previous
    return self::CompareDates($b['createdate'], $a['createdate']);
    
    /*
    if ($a['createdate'] > $b['createdate'])
    {
      return -1;
    }
    if ($a['createdate'] < $b['createdate'])
    {
      return 1;
    }
    return 0;
    */
  } 
  ###################################################### 
  
  ######################################################
  # datetime
  ######################################################
  
  static function makeTimeStamp($hour = '', $minute = '', $second = '', $year = '', $month = '', $day = '')
  {
     if(empty($hour)) 
     {
         $hour = strftime('%H');
     }
     if(empty($minute)) 
     {
         $minute = strftime('%M');
     }
     if(empty($second)) 
     {
         $second = strftime('%S');
     }
     if(empty($year)) 
     {
         $year = strftime('%Y');
     }
     if(empty($month)) 
     {
         $month = strftime('%m');
     }
     if(empty($day)) 
     {
         $day = strftime('%d');
     }

     return mktime($hour, $minute, $second, $month, $day, $year);
  }

  static function Now()
  {
    return self::_getDB()->DbTimeStamp(time());
  }
  
  #
  # Redirect
  #
  
  /**
  * Shows a very close approximation of an Apache generated 301 error.
  * It also sends the actual header along as well, so that generic
  * browser error pages (like what IE does) will be displayed.
  */
  static function ErrorHandler301($url)
  {
    // TODO 0 -o JoMorg -c  task: Clean $url
    // TODO 0 -o JoMorg -c  task: Localize... maybe?
    @ob_end_clean();
    #header($_SERVER["SERVER_PROTOCOL"] . ' 301 Moved Permanently'); # maybe????
    header('HTTP/1.1 301 Moved Permanently');
    header("Status: 301  Moved Permanently");
    # make sure browsers don't cache 
    header("Cache-Control: no-cache, must-revalidate"); // HTTP/1.1
    header("Expires: Sat, 26 Jul 1997 05:00:00 GMT"); // Date in the past
    header('Location: ' . $url );
    $html = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"; 
    $html .= "<html>\n"; 
    $html .= "<head>\n"; 
    $html .= "<title>Moved</title>\n"; 
    $html .= "</head>\n"; 
    $html .= "<body>\n"; 
    $html .= "<h1>Moved</h1>\n"; 
    $html .= "<p>This page has moved to <a href=\"" . $url . "\">" . $url . "</a>.</p>\n"; 
    $html .= "</body>\n"; 
    $html .= "</html>\n"; 
    echo $html;
    exit();
  }
  
  /**
   * Given a page ID or an alias, redirect to it
   * Retrieves the URL of the specified page, and performs a redirect
   *
   * @param mixed An integer page id or a string page alias.
   * @return void
   */
  static function URLfromAlias($alias)
  {
    $manager = cmsms()->GetHierarchyManager();
    $node = $manager->sureGetNodeByAlias($alias);
    
    if( !$node ) 
    {
      audit('', 'Cataloger', 'Attempt to redirect to invalid alias: ' . $alias);
      return;
    }
    
    $content = $node->GetContent();
    
    if (!is_object($content)) 
    {
      audit('', 'Cataloger', 'Attempt to redirect to invalid alias: ' . $alias);
      return;
    }
    
    return $content->GetURL();
  }
  
  static function IsValidAlias($alias)
  {
    $manager = cmsms()->GetHierarchyManager();
    $node = $manager->sureGetNodeByAlias($alias);

    if( !$node ) 
    {
      return false;
    }
    
    $content = $node->GetContent();
    
    if (!is_object($content)) 
    {
      return false;
    }
    
    return true; 
  }

  static function  is_Expired($date)
  {
    return (bool)( 1 === self::CompareDates( time(), $date ) );
  }
  
  static function  to_Expire($date)
  {
    return (bool)( 1 === self::CompareDates( time(), $date ) );
  }
  
  static function to_UnExpire($date)
  {
    return (bool)( 1 === self::CompareDates( $date, time() ) ); 
  }
  
  static function CompareDates($a, $b)
  {
    # make sure they're integers....
    $a = (int)$a;
    $b = (int)$b;
    $r = 0;
      
    if ($a > $b)
    {
      $r = 1;
    }
    
    if ($a < $b)
    {
      $r = -1;
    }
    
    return (int)$r;
  }
  
}
?>]]></data>
	</file>
	<file>
	  <filename>/lib/class.catFields.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/class.catFilesOperations.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
class catFilesOperations
{
  protected static $_initialized = FALSE;
  protected static $_mod;
  protected static $_cms;
  protected static $_config;
  
  private static function _initialize()
  {
    if(!self::$_initialized)
    {
      self::$_mod = cms_utils::get_module('Cataloger');
      self::$_cms = cmsms();
      self::$_config = self::$_cms->GetConfig();
    }
  }
  
  // type can be "s" - source image, "i" - processed image, or "f" - file
  static function getAssetPath( $type = "i", $default = false )
  {
    self::_initialize();
    $mod = self::$_mod;
    $config = self::$_config;
    $rootPath = $config['root_path'];
   
    $uploadbase = str_replace(['uploads_path'], $rootPath, '');
    
    if($default)
    {
      switch($type)
      {
        case 's': $ret = cms_join_path($uploadbase, 'images', 'catalog_src'); break; 
        case 'i': $ret = cms_join_path($uploadbase, 'images', 'catalog'); break; 
        case 'f': $ret = cms_join_path($uploadbase, 'catalogerfiles'); break; 
      }
      
      # just in case there are mismatched DIRECTORY SEPARATOR chars
      $ret = str_replace('/', DIRECTORY_SEPARATOR, $ret);
      $ret = str_replace('\\', DIRECTORY_SEPARATOR, $ret);
      
      return trim($ret, DIRECTORY_SEPARATOR);
    }
      
    switch ($type)
    {
      case 's':
      {
        $_ByDefault = cms_join_path($uploadbase, 'images', 'catalog_src');
        $ret = $mod->GetPreference('image_upload_path', $_ByDefault); 
      }
      break; 

      
      case 'i':
      {
        $_ByDefault = cms_join_path($uploadbase, 'images', 'catalog');
        $ret = $mod->GetPreference('image_proc_path', $_ByDefault);  
      }
      break; 
      
      case 'f':
      {
        $_ByDefault = cms_join_path($uploadbase, 'catalogerfiles');
        $ret = $mod->GetPreference('file_upload_path', $_ByDefault);  
      }
      break; 
      
    }

    # just in case there are mismatched DIRECTORY SEPARATOR chars
    $ret = str_replace('/', DIRECTORY_SEPARATOR, $ret);
    $ret = str_replace('\\', DIRECTORY_SEPARATOR, $ret);
    
    return trim($ret, DIRECTORY_SEPARATOR);   
  }
  
  static function Extender()
  {
    $ret = '&amp;ac=';
    
    for ($r = 0; $r < 5; $r++)
    {
      $ret .= rand(0,9);
    }
    
    return $ret;
  }


  static function imageSpec($alias, $type, $image_number, $size, $anticache=true, $forceshowmissing=false)
  {
    self::_initialize();
    $mod = self::$_mod;
    $config = self::$_config;
    
    $contentops = self::$_cms->GetContentOperations();
    $returnid = $contentops->GetDefaultContent();
    
    $pretty_url = 'cataloger_image/';
    $url = $mod->create_url('cntnt01', 'image', $returnid, array(), FALSE, FALSE, $pretty_url);
    
    if ($mod->showMissing == '')
    {
      $mod->showMissing = $mod->GetPreference('show_missing', '1');
    }
    
    $ext = '';
    
    if ($anticache)
    {
      $ext = self::Extender();
    }
    
    $r = $url
         . ( ($config['url_rewriting'] == 'mod_rewrite') ? '?i=' : '&amp;i=' ) 
         . $alias
         . '_'
         . $type
         . '_'
         . $image_number
         . '_'
         . $size
         . ($forceshowmissing ? '_1' : '_' . $mod->showMissing)
         . '.jpg'
         . $ext;

      return $r;
  }

  static function srcImageSpec($alias, $image_number)
  {
    self::_initialize();
    $mod = self::$_mod;
    
    if ($mod->showMissing == '')
    {
      $mod->showMissing = $mod->GetPreference('show_missing', '1');
    }

    if( !self::srcExists($alias, $image_number) )
    {
      if ($mod->showMissing != '1')
      {
        return $mod->GetRootURL()
               . '/modules/Cataloger/images/trans.gif';
      }
      else
      {
        return $mod->GetRootURL()
               . '/modules/Cataloger/images/no-image.gif';
      }
    }
    else
    {
      return $mod->GetUploadsURL()
             . self::getAssetPath('s')
             . '/'
             . $alias 
             . '_src_'
             . $image_number
             . '.jpg';
    }
  }

  static function srcExists($alias, $image_number)
  {
    self::_initialize();
    $mod = self::$_mod;
    $config = self::$_config;
    
    $srcSpec = cms_join_path(
                              $config['uploads_path'],
                              self::getAssetPath('s'),
                              $alias . '_src_' . $image_number . '.jpg'
                            );
    
    return file_exists($srcSpec);
  }


  static function getFiles($alias)
  {
    self::_initialize();
    $mod = self::$_mod;
    $config = self::$_config;
    
    $dirspec = cms_join_path(
                              $config['uploads_path'],
                              self::getAssetPath('f'),
                              $alias
                             );
  
    $files = array();
    $types = array();
    
    if (is_dir($dirspec))
    {  
      $dh  = opendir($dirspec);
      
      while ( false !== ( $filename = readdir($dh) ) )
      {
        
        if ($filename != '.' && $filename != '..')
        {
          $files[] = $filename;
          
          if (strpos($filename, '.') !== false)
          {
            $types[] = substr($filename, strrpos($filename, '.') + 1);
          }
          else
          {
            $types[] = '?';
          }
          
        }
        
      }
    }
    
    return array($files,$types);
  }

  static function purgeAllImage($alias, $imageNumber)
  {   
    self::purgeScaledImages($alias, $imageNumber);
    self::purgeSourceImage($alias, $imageNumber);        
  }
  
  static function purgeScaledImages($alias, $imageNumber)
  {
    self::_initialize();
    $mod = self::$_mod;
    $config = self::$_config;
    $assets_path = self::getAssetPath('f');
    
    $srcDir = cms_join_path(
                              $config['uploads_path'],
                              $assets_path
                            );
    
    $toDel = array();
    
    if ($dh = opendir($srcDir))
    {
    
      while (($file = readdir($dh)) !== false)
      {
        $fileParts = explode('_', $file);
        
        if ($fileParts[0] == $alias && $fileParts[2] == $imageNumber)
        {
          array_push($toDel, $srcDir . '/' . $file);
        }
        
      }
      
      closedir($dh);
    }
        
    foreach ($toDel as $thisDel)
    {
      unlink($thisDel);
    }
  }

  static function purgeSourceImage($alias, $imageNumber)
  {
    self::_initialize();
    $mod = self::$_mod;
    $config = self::$_config;
    
    $fn = $alias 
         . '_src_'
         . $imageNumber
         . '.jpg';
        
    $srcSpec =  cms_join_path(
                                $config['uploads_path'],
                                self::getAssetPath('s'),
                                $fn 
                              );
                              
    unlink($srcSpec);
    
  }


  static function renameImages($old, $newAlias)
  {
    self::_initialize();
    $mod = self::$_mod;
    $config = self::$_config;
    
    $path = cms_join_path(
                            $config['uploads_path'],
                            self::getAssetPath('s')
                          );
    
    
    if ($handle = opendir($path) )
    {
      
      while ( false !== ( $file = readdir($handle )) )
      {
        if ( substr($file, 0, strlen($old) ) == $old)
        {
          $newspec = $newAlias . substr( $file, strlen($old) );
          
          $old_file = cms_join_path($path, $file);
          $new_file = cms_join_path($path, $newspec);
          
          rename($old_file, $new_file);
        }
      }
      
      closedir($handle);
    }
  }
  
  ###### generic.....
  
  /**
  * Delete a file or recursively delete a directory
  *
  * @param string $str Path to file or directory
  */
  static function recursiveDelete($str)
  {
    $Result = is_file($str);
    
    if($Result)
    {
      $Result = @unlink($str);
    }
    else
    {
      $Result = is_dir($str);
      
      if($Result)
      {
        $scan = glob( rtrim($str, '/') . '/*' );
        
        foreach($scan as $index=>$path)
        {
          $Result = $Result && recursiveDelete($path);
        }
        
        $Result = $Result && @rmdir($str);     
      }
    }
    
    return $Result;
  }
  
  /**
  * @method DeleteFile
  * Just a convinience function to silently delete files
  * May fail on some enviroments
  * 
  * @param mixed $filename
  * @returns True if success, otherwise false
  */
  static function DeleteFile($filename)
  {
    $result = file_exists($filename);
    if ($result) $result = @unlink($filename);
    return $result;
  }
  
  static function DeleteFileWMask($mask)
  {
    array_walk(glob($mask), 'unlink');
  }

}
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/class.catTemplateOperations.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.12
#
# Copyright (c) 2012, Fernando Morgado (JoMorg) jomorg.morg@gmail.com
# Copyright (c) 2006, Samuel Goldstein <sjg@cmsmodules.com>
# For Information, Support, Bug Reports, etc, please visit the
# CMS Made Simple Forge at http://dev.cmsmadesimple.org
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http://www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
/**
* class catTemplate_Operations
* @author Jo Morg (Fernando Morgado)
* @copyright ©2013 Jo Morg
*/
class catTemplateOperations
{
  protected static $_db;
  
  private static function _getDB()
  {
    
    if ( !is_object(self::$_db) )
    {
      self::$_db = cmsms()->GetDb();
    }
    
    return self::$_db;
    
  }
  
  /**
  * Remove all non-word characters
  * 
  * @param mixed $text
  */
  private static function _safeAtt($text)
  {
    return strtolower(preg_replace('/\W/', '', $text)); 
  }
  
  /**
  * returns an array with the current Template types
  * @author JoMorg (Fernando Morgado)
  * @since 0.12
  * @static
  * @returns a ref to an array
  */
  static function &GetCatalogerTemplateTypes()
  {
    $db = self::_getDB();
    $types = array();

    $query = 'SELECT type_id, name FROM ' 
             . cms_db_prefix()
             . 'module_catalog_template_type';
             
    $dbresult = $db->Execute($query);
    
    while ($dbresult !== false && $row = $dbresult->FetchRow())
    {
      $types[$row['name']] = $row['type_id'];
    }
    
    return $types;
  }
  
  /**
  * SaveTemplate...
  * 
  * @param mixed $type_id
  * @param mixed $temp_name
  * @param mixed $template
  */
  static function SaveTemplate($type_id, $temp_name, $template)
  {
    $db = self::_getDB();
    
    $temp_id = $db->GenID(cms_db_prefix() . 'module_catalog_template_seq');

    $query = 'INSERT INTO '
           . cms_db_prefix()
           . 'module_catalog_template (id, type_id, title, template) '
           . ' VALUES (?,?,?,?)';
           
    $arr = array($temp_id, $type_id, $temp_name, $template);
    
    $dbresult = $db->Execute($query, $arr);
    
    return $dbresult;
  }
   
  /**
  * SaveTemplateChanges
  * 
  * @param mixed $params
  * @return Boolean = TRUE if success
  * @since 0.12
  */
  static function SaveTemplateChanges($params)
  {
    $err = FALSE;
    
    if (!is_array($params))
    {
      $errDescrp = 'Saving Template (error: $params not an array)';
      audit($params['template_id'], __METHOD__, $errDescrp);
      $err = TRUE;
      return $err;
    }
    
    $db = self::_getDB();
    
    $query = 'UPDATE '
             . cms_db_prefix()
             . 'module_catalog_template set title=?, template=?, type_id=? WHERE id=?';
    
    $qArr = array($params['title'],
                  $params['templ'],
                  $params['type_id'], 
                  $params['template_id']);
             
    $dbresult = $db->Execute($query, $qArr);
    
    if (!$dbresult)
    {
      $errDescrp = 'Saving Template (error: No results from query)';
      audit($params['template_id'], __METHOD__, $errDescrp);
      $err = TRUE;
    }
    
    return $err;
  }
  
  static function GetTemplateFromID($id)
  {
    $db = self::_getDB();
    
    $query = 'SELECT title, template, type_id, id FROM ' 
             . cms_db_prefix()
             . 'module_catalog_template WHERE id=? ORDER by title';
  
    $dbresult = $db->Execute($query, array($id));
    return $dbresult->FetchRow();
  }
  
  static function &GetTemplateListFromID($id)
  {
    $db = self::_getDB();
    
    $query = 'SELECT title, template, type_id, id FROM ' 
             . cms_db_prefix()
             . 'module_catalog_template WHERE type_id=? ORDER by title';
  
    $dbresult = $db->Execute($query, array($id));
    
    while ($dbresult !== false && $row = $dbresult->FetchRow())
    {
      $subTemplates[$row['title']] = $row['id'];
    }
    
    return $subTemplates;
  }
  
  static function &GetAttsFromType($id)
  {
    $db = self::_getDB();
    
    $query = "SELECT attribute, alias, type_id FROM "
             . cms_db_prefix()
             . "module_catalog_attr WHERE type_id=?";
         
    $dbresult = $db->Execute($query, array($id));

    return $dbresult;
      
  }
  
  
  static function getTemplateFromAlias($alias)
  {
    $db = self::_getDB();
    $query = 'SELECT id from ' . cms_db_prefix() . 'module_catalog_template where title=?';
    $dbresult = $db->Execute($query, array($alias) );
                            
    if ($dbresult !== false && $row = $dbresult->FetchRow())
    {
      return 'catalog_' . $row['id'];
    }
    
      return '';  
  }
  
  
  static function &GetUserAttList($id)
  {
    # for the moment leave at as is but more changes are needed.... (JM)
    $dbresult = self::GetAttsFromType($id);
    
    $attrs = array();

    while ($dbresult !== false && $row = $dbresult->FetchRow())
    {
      $safeattr = self::_safeAtt($row['attribute']);
      
      $attr = array(
                      'name'  => '{$' . $safeattr . '}',
                      'alias' => '{$' . $row['alias'] . '}'
                    );
      
      array_push($attrs, $attr);
    }
    
    return $attrs;
  }
  
  
  static function GetAttListFromType($TemplateType)
  {
    $a = array();
    
    switch ($TemplateType)
    {
      case CTEMPLATE_ITEM:
                
                array_push($a, '{$title}');
                array_push($a, '{$notes}');
                break;
                
      case CTEMPLATE_CATEGORY:
      
                array_push($a, '{$title}');
                array_push($a, '{$notes}');
                array_push($a, '{$prev}');
                array_push($a, '{$prevurl}');
                array_push($a, '{$navstr}');
                array_push($a, '{$next}');
                array_push($a, '{$nexturl}');
                array_push($a, '{$items}');
                break;
       
      case CTEMPLATE_CATALOG:
                                
                array_push($a, '{$items}');
                array_push($a, '{$attrlist}');
                array_push($a, '{$root_url}');
                array_push($a, '{$image_root}');
                break; 
      
      case CTEMPLATE_COMPARISON:
                
                array_push($a, '{$items}');
                array_push($a, '{$attrlist}');
                array_push($a, '{$root_url}');
                array_push($a, '{$image_root}');
                break;  
                
      case CTEMPLATE_FEATURE:

                array_push($a, '{$items}');
                array_push($a, '{$root_url}');
                array_push($a, '{$image_root}');
                break; 
      
    }
    
    #self::GetAttList($a, $TemplateType);

    return $a;
  }
  
  static function importSampleTemplates( $onlytype = 'all' )
  {
    $db = self::_getDB();
    $dir = opendir( dirname(__FILE__) . DIRECTORY_SEPARATOR . 'includes');
    $temps = array();
    
    while( $filespec = readdir($dir) )
    {
      if(! preg_match('/\.tpl$/i', $filespec))
      {
        continue;
      }
      
        array_push($temps, $filespec);
    }
            
    sort($temps);

    foreach ($temps as $filespec)
    {
      $file = file(
                    dirname(__FILE__)
                    . DIRECTORY_SEPARATOR 
                    . 'includes'
                    . DIRECTORY_SEPARATOR
                    . $filespec
                  );
              
      $template = implode('', $file);
      
      $temp_name = preg_replace('/\.tpl$/i', '', $filespec);
      
      #
      // check if it already exists
      $excheck = 'SELECT id from ' . cms_db_prefix() . 'module_catalog_template where title=?';
      $dbcount = $db->Execute($excheck , array($temp_name));
      #
      
      # rename???
      while ($dbcount && $dbcount->RecordCount() > 0)
      {
        $temp_name .= '_new';
        $dbcount = $db->Execute( $excheck, array($temp_name) );
      }
      
      $type_id = -1;
      $type = substr( $temp_name, 0, strpos($temp_name, '-') );
      
      if ( $type == 'Item' && ($onlytype=='all' || $onlytype='Item') )
      {
        $type_id = CTEMPLATE_ITEM;
      }
      else if ( $type == 'Category' && ($onlytype=='all' || $onlytype='Category') )
      {
        $type_id = CTEMPLATE_CATEGORY;
      }
      else if ( $type == 'Printable' && ($onlytype=='all' || $onlytype='Printable') )
      {
        $type_id = CTEMPLATE_CATALOG;
      }
      else if ( $type == 'Comparison' && ($onlytype=='all' || $onlytype='Comparison') )
      {
        $type_id = CTEMPLATE_COMPARISON;
      }
      else if ( $type == 'Feature' && ($onlytype=='all' || $onlytype='Feature') )
      {
        $type_id = CTEMPLATE_FEATURE;
      }
      
      catTemplate_Operations::SaveTemplate($type_id, $temp_name, $template);
      
      # 
      /*   
      $temp_id = $db->GenID(cms_db_prefix() . 'module_catalog_template_seq');

      $query = 'INSERT INTO '
             . cms_db_prefix()
             . 'module_catalog_template (id, type_id, title, template) '
             . ' VALUES (?,?,?,?)';
             
      $arr = array($temp_id,$type_id, $temp_name,$template);
      
      $dbresult = $db->Execute($query, $arr);
      */
      #
                              
      $this->SetTemplate( 'catalog_' . $temp_id, $template);
    }
  
  }
 
}
?>]]></data>
	</file>
	<file>
	  <filename>/lib/class.catUserDefAttributesOps.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCmNsYXNzIGNhdFVzZXJEZWZBdHRyaWJ1dGVzT3BzDQp7DQogIHByaXZhdGUgc3RhdGljICRhdHRycyA9IGFycmF5KCk7DQogIHByaXZhdGUgc3RhdGljICRfZGI7DQogIA0KICBwcml2YXRlIHN0YXRpYyBmdW5jdGlvbiBfZ2V0REIoKQ0KICB7DQogICAgDQogICAgaWYgKCAhaXNfb2JqZWN0KHNlbGY6OiRfZGIpICkNCiAgICB7DQogICAgICBzZWxmOjokX2RiID0gY21zbXMoKS0+R2V0RGIoKTsNCiAgICB9DQogICAgDQogICAgcmV0dXJuIHNlbGY6OiRfZGI7DQogICAgDQogIH0NCiAgDQogIHN0YXRpYyBmdW5jdGlvbiAmZ2V0VXNlckF0dHJpYnV0ZXMoJGdsb2JhbF9yZWYgPSAnY2F0YWxvZ19hdHRycycpDQogIHsNCiAgICAgICRkYiA9IHNlbGY6Ol9nZXREQigpOw0KICAgICAgc2VsZjo6JGF0dHJzWyRnbG9iYWxfcmVmXSA9IGFycmF5KCk7DQogICAgICANCiAgICAgICRxdWVyeSA9ICJTRUxFQ1QgYXR0cmlidXRlLCBhbGlhcywgZGVmYXVsdHZhbCwgbGVuZ3RoLCBmaWVsZF90eXBlLCBzZWxlY3RfdmFsdWVzLCBvcmRlcl9ieSBGUk9NICINCiAgICAgICAgICAgICAgIC4gY21zX2RiX3ByZWZpeCgpDQogICAgICAgICAgICAgICAuICJtb2R1bGVfY2F0YWxvZ19hdHRyIFdIRVJFIHR5cGVfaWQ9PyBPUkRFUiBCWSBvcmRlcl9ieSBBU0MiOw0KICAgICAgICAgICAgICAgDQogICAgICAkdHlwZV9pZCA9IDE7DQogICAgICANCiAgICAgIGlmICgkZ2xvYmFsX3JlZiA9PSAnY2F0YWxvZ19jYXRfYXR0cnMnKQ0KICAgICAgew0KICAgICAgICAkdHlwZV9pZCA9IDI7DQogICAgICB9DQogICAgICBlbHNlaWYgKCRnbG9iYWxfcmVmID09ICdjYXRhbG9nX3ByaW50X2F0dHJzJykNCiAgICAgIHsNCiAgICAgICAgJHR5cGVfaWQgPSAzOw0KICAgICAgfQ0KICAgICAgDQogICAgICAkZGJyZXN1bHQgPSAkZGItPkV4ZWN1dGUoJHF1ZXJ5LCBhcnJheSgkdHlwZV9pZCkpOw0KICAgICAgDQogICAgICB3aGlsZSAoJGRicmVzdWx0ICE9PSBmYWxzZSAmJiAkcm93ID0gJGRicmVzdWx0LT5GZXRjaFJvdygpKQ0KICAgICAgew0KICAgICAgICAkQXR0ciA9IG5ldyBzdGRDbGFzcygpOw0KICAgICAgICAkQXR0ci0+YXR0ciA9ICRyb3dbJ2F0dHJpYnV0ZSddOw0KICAgICAgICAkQXR0ci0+YWxpYXMgPSAhZW1wdHkoJHJvd1snYWxpYXMnXSkgPyAkcm93WydhbGlhcyddIDogc3RydG9sb3dlciggcHJlZ19yZXBsYWNlKCcvXFcvJywgJycsICRyb3dbJ2F0dHJpYnV0ZSddKSApOw0KICAgICAgICAkQXR0ci0+bGVuZ3RoID0gJHJvd1snbGVuZ3RoJ107DQogICAgICAgICRBdHRyLT5kZWZhdWx0ID0gJHJvd1snZGVmYXVsdHZhbCddOw0KICAgICAgICAkQXR0ci0+c2VsZWN0X3ZhbHVlcyA9ICRyb3dbJ3NlbGVjdF92YWx1ZXMnXTsNCiAgICAgICAgJEF0dHItPmZpZWxkX3R5cGUgPSAkcm93WydmaWVsZF90eXBlJ107DQogICAgICAgICRBdHRyLT5maWVsZF9vcmRlciA9ICRyb3dbJ29yZGVyX2J5J107DQogICAgICAgICRBdHRyLT5zYWZlID0gc3RydG9sb3dlciggcHJlZ19yZXBsYWNlKCcvXFcvJywgJycsICRyb3dbJ2F0dHJpYnV0ZSddKSApOw0KICAgICAgICBzZWxmOjokYXR0cnNbJGdsb2JhbF9yZWZdWyRBdHRyLT5hbGlhc10gPSAkQXR0cjsNCiAgICAgIH0NCg0KICAgIHJldHVybiBzZWxmOjokYXR0cnNbJGdsb2JhbF9yZWZdOw0KICB9ICANCn0NCj8+DQo=]]></data>
	</file>
	<file>
	  <filename>/lib/external/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/external/Image/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/external/Image/Files.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/GD.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/***********************************************************************
** Title.........:  GD Driver
** Version.......:  1.0
** Author........:  Xiang Wei ZHUO <wei@zhuo.org>
** Filename......:  GD.php
** Last changed..:  30 Aug 2003 
** Notes.........:  Orginal is from PEAR
**/
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2002 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Peter Bowyer <peter@mapledesign.co.uk>                      |
// |          Alan Knowles <alan@akbkhome.com>                            |
// +----------------------------------------------------------------------+
//
//    Usage :
//    $img    = new Image_Transform_GD();
//    $angle  = -78;
//    $img->load('magick.png');
//
//    if($img->rotate($angle,array('autoresize'=>true,'color_mask'=>array(255,0,0)))){
//        $img->addText(array('text'=>"Rotation $angle",'x'=>0,'y'=>100,'font'=>'/usr/share/fonts/default/TrueType/cogb____.ttf'));
//        $img->display();
//    } else {
//        echo "Error";
//    }
//
//
// $Id: GD.php 7184 2011-07-20 19:11:50Z calguy1000 $
//
// Image Transformation interface using the GD library
//

require_once(dirname(__FILE__)."/Transform.php");

Class Image_Transform_Driver_GD extends Image_Transform
{
    /**
     * Holds the image file for manipulation
     */
    var $imageHandle = '';

    /**
     * Holds the original image file
     */
    var $old_image = '';

    /**
     * Check settings
     *
     * @return mixed true or  or a PEAR error object on error
     *
     * @see PEAR::isError()
     */
    function Image_Transform_GD()
    {
        return;
    } // End function Image

    /**
     * Load image
     *
     * @param string filename
     *
     * @return mixed none or a PEAR error object on error
     * @see PEAR::isError()
     */
    function load($image)
    {
        $this->uid = md5($_SERVER['REMOTE_ADDR']);
        $this->image = $image;
        $this->_get_image_details($image);
        $functionName = 'ImageCreateFrom' . $this->type;
		if(function_exists($functionName))
		{
			$this->imageHandle = $functionName($this->image);
		}
    } // End load

    /**
     * addText
     *
     * @param   array   options     Array contains options
     *                              array(
     *                                  'text'  The string to draw
     *                                  'x'     Horizontal position
     *                                  'y'     Vertical Position
     *                                  'Color' Font color
     *                                  'font'  Font to be used
     *                                  'size'  Size of the fonts in pixel
     *                                  'resize_first'  Tell if the image has to be resized
     *                                                  before drawing the text
     *                              )
     *
     * @return none
     * @see PEAR::isError()
     */
    function addText($params)
    {
        $default_params = array(
                                'text' => 'This is Text',
                                'x' => 10,
                                'y' => 20,
                                'color' => array(255,0,0),
                                'font' => 'Arial.ttf',
                                'size' => '12',
                                'angle' => 0,
                                'resize_first' => false // Carry out the scaling of the image before annotation?  Not used for GD
                                );
        $params = array_merge($default_params, $params);
        extract($params);

        if( !is_array($color) ){
            if ($color[0]=='#'){
                $this->colorhex2colorarray( $color );
            } else {
                include_once('Image/Transform/Driver/ColorsDefs.php');
                $color = isset($colornames[$color])?$colornames[$color]:false;
            }
        }

        $c = imagecolorresolve ($this->imageHandle, $color[0], $color[1], $color[2]);

        if ('ttf' == substr($font, -3)) {
            ImageTTFText($this->imageHandle, $size, $angle, $x, $y, $c, $font, $text);
        } else {
            ImagePSText($this->imageHandle, $size, $angle, $x, $y, $c, $font, $text);
        }
        return true;
    } // End addText


    /**
     * Rotate image by the given angle
     * Uses a fast rotation algorythm for custom angles
     * or lines copy for multiple of 90 degrees
     *
     * @param int       $angle      Rotation angle
     * @param array     $options    array(  'autoresize'=>true|false,
     *                                      'color_mask'=>array(r,g,b), named color or #rrggbb
     *                                   )
     * @author Pierre-Alain Joye
     * @return mixed none or a PEAR error object on error
     * @see PEAR::isError()
     */
    function rotate($angle, $options=null)
    {
        if(function_exists('imagerotate') && false) {
            $white = imagecolorallocate ($this->imageHandle, 255, 255, 255);
			$this->imageHandle = imagerotate($this->imageHandle, $angle, $white);
            return true;
        }

        if ( $options==null ){
            $autoresize = true;
            $color_mask = array(255,255,0);
        } else {
            extract( $options );
        }

        while ($angle <= -45) {
            $angle  += 360;
        }
        while ($angle > 270) {
            $angle  -= 360;
        }

        $t      = deg2rad($angle);

        if( !is_array($color_mask) ){
            if ($color[0]=='#'){
                $this->colorhex2colorarray( $color_mask );
            } else {
                include_once('Image/Transform/Driver/ColorDefs.php');
                $color = isset($colornames[$color_mask])?$colornames[$color_mask]:false;
            }
        }

        // Do not round it, too much lost of quality
        $cosT   = cos($t);
        $sinT   = sin($t);

        $img    =& $this->imageHandle;

        $width  = $max_x  = $this->img_x;
        $height = $max_y  = $this->img_y;
        $min_y  = 0;
        $min_x  = 0;

        $x1     = round($max_x/2,0);
        $y1     = round($max_y/2,0);

        if ( $autoresize ){
            $t      = abs($t);
            $a      = round($angle,0);
            switch((int)($angle)){
                case 0:
                        $width2     = $width;
                        $height2    = $height;
                    break;
                case 90:
                        $width2     = $height;
                        $height2    = $width;
                    break;
                case 180:
                        $width2     = $width;
                        $height2    = $height;
                    break;
                case 270:
                        $width2     = $height;
                        $height2    = $width;
                    break;
                default:
                    $width2     = (int)(abs(sin($t) * $height + cos($t) * $width));
                    $height2    = (int)(abs(cos($t) * $height+sin($t) * $width));
            }

            $width2     -= $width2%2;
            $height2    -= $height2%2;

            $d_width    = abs($width - $width2);
            $d_height   = abs($height - $height2);
            $x_offset   = $d_width/2;
            $y_offset   = $d_height/2;
            $min_x2     = -abs($x_offset);
            $min_y2     = -abs($y_offset);
            $max_x2     = $width2;
            $max_y2     = $height2;
        }

        if(function_exists('ImageCreateTrueColor')){
            $img2 =ImageCreateTrueColor($width2,$height2);
        } else {
            $img2 =ImageCreate($width2,$height2);
        }
	

        if ( !is_resource($img2) ){
            return false;/*PEAR::raiseError('Cannot create buffer for the rotataion.',
                                null, PEAR_ERROR_TRIGGER, E_USER_NOTICE);*/
        }

        $this->img_x = $width2;
        $this->img_y = $height2;


        imagepalettecopy($img2,$img);

        $mask   = imagecolorresolve($img2,$color_mask[0],$color_mask[1],$color_mask[2]);

        // use simple lines copy for axes angles
        switch((int)($angle)){
            case 0:
                imagefill ($img2, 0, 0,$mask);
                for ($y=0; $y < $max_y; $y++) {
                    for ($x = $min_x; $x < $max_x; $x++){
                        $c  = @imagecolorat ( $img, $x, $y);
                        imagesetpixel($img2,$x+$x_offset,$y+$y_offset,$c);
                    }
                }
                break;
            case 90:
                imagefill ($img2, 0, 0,$mask);
                for ($x = $min_x; $x < $max_x; $x++){
                    for ($y=$min_y; $y < $max_y; $y++) {
                        $c  = imagecolorat ( $img, $x, $y);
                        imagesetpixel($img2,$max_y-$y-1,$x,$c);
                    }
                }
                break;
            case 180:
                imagefill ($img2, 0, 0,$mask);
                for ($y=0; $y < $max_y; $y++) {
                    for ($x = $min_x; $x < $max_x; $x++){
                        $c  = @imagecolorat ( $img, $x, $y);
                        imagesetpixel($img2, $max_x2-$x-1, $max_y2-$y-1, $c);
                    }
                }
                break;
            case 270:
                imagefill ($img2, 0, 0,$mask);
                for ($y=0; $y < $max_y; $y++) {
                    for ($x = $max_x; $x >= $min_x; $x--){
                        $c  = @imagecolorat ( $img, $x, $y);
                        imagesetpixel($img2,$y,$max_x-$x-1,$c);
                    }
                }
                break;
            // simple reverse rotation algo
            default:
                $i=0;
                for ($y = $min_y2; $y < $max_y2; $y++){

                    // Algebra :)
                    $x2 = round((($min_x2-$x1) * $cosT) + (($y-$y1) * $sinT + $x1),0);
                    $y2 = round((($y-$y1) * $cosT - ($min_x2-$x1) * $sinT + $y1),0);

                    for ($x = $min_x2; $x < $max_x2; $x++){

                        // Check if we are out of original bounces, if we are
                        // use the default color mask
                        if ( $x2>=0 && $x2<$max_x && $y2>=0 && $y2<$max_y ){
                            $c  = imagecolorat ( $img, $x2, $y2);
                        } else {
                            $c  = $mask;
                        }
                        imagesetpixel($img2,$x+$x_offset,$y+$y_offset,$c);

                        // round verboten!
                        $x2  += $cosT;
                        $y2  -= $sinT;
                    }
                }
                break;
        }
        $this->old_image    = $this->imageHandle;
        $this->imageHandle  =  $img2;
        return true;
    }


   /**
    * Resize Action
    *
    * For GD 2.01+ the new copyresampled function is used
    * It uses a bicubic interpolation algorithm to get far
    * better result.
    *
    * @param $new_x int  new width
    * @param $new_y int  new height
    *
    * @return true on success or pear error
    * @see PEAR::isError()
    */
    function _resize($new_x = 0, $new_y = 0) {
        if ($this->resized === true) {
            return false; /*PEAR::raiseError('You have already resized the image without saving it.  Your previous resizing will be overwritten', null, PEAR_ERROR_TRIGGER, E_USER_NOTICE);*/
        }
        if(function_exists('ImageCreateTrueColor')){
            $new_img =ImageCreateTrueColor($new_x,$new_y);
        } else {
            $new_img =ImageCreate($new_x,$new_y);
        }
        if(function_exists('ImageCopyResampled')){
            ImageCopyResampled($new_img, $this->imageHandle, 0, 0, 0, 0, $new_x, $new_y, $this->img_x, $this->img_y);
        } else {
            ImageCopyResized($new_img, $this->imageHandle, 0, 0, 0, 0, $new_x, $new_y, $this->img_x, $this->img_y);
        }
        $this->old_image = $this->imageHandle;
        $this->imageHandle = $new_img;
        $this->resized = true;

        $this->new_x = $new_x;
        $this->new_y = $new_y;
        return true;
    }

    /**
     * Crop the image
     *
     * @param int $crop_x left column of the image
     * @param int $crop_y top row of the image
     * @param int $crop_width new cropped image width
     * @param int $crop_height new cropped image height
     */
    function crop($new_x, $new_y, $new_width, $new_height) 
    {
        if(function_exists('ImageCreateTrueColor')){
            $new_img =ImageCreateTrueColor($new_width,$new_height);
        } else {
            $new_img =ImageCreate($new_width,$new_height);
        }
        if(function_exists('ImageCopyResampled')){
            ImageCopyResampled($new_img, $this->imageHandle, 0, 0, $new_x, $new_y,$new_width,$new_height,$new_width,$new_height);
        } else {
            ImageCopyResized($new_img, $this->imageHandle, 0, 0, $new_x, $new_y, $new_width,$new_height,$new_width,$new_height);
        }
        $this->old_image = $this->imageHandle;
        $this->imageHandle = $new_img;
        $this->resized = true;

        $this->new_x = $new_x;
        $this->new_y = $new_y;
        return true;
    }
   
    /**
     * Flip the image horizontally or vertically
     *
     * @param boolean $horizontal true if horizontal flip, vertical otherwise
     */
    function flip($horizontal)
    {
        if(!$horizontal) {
            $this->rotate(180);
        }

        $width = imagesx($this->imageHandle); 
        $height = imagesy($this->imageHandle); 

        for ($j = 0; $j < $height; $j++) { 
                $left = 0; 
                $right = $width-1; 


                while ($left < $right) { 
                    //echo " j:".$j." l:".$left." r:".$right."\n<br>";
                    $t = imagecolorat($this->imageHandle, $left, $j); 
                    imagesetpixel($this->imageHandle, $left, $j, imagecolorat($this->imageHandle, $right, $j)); 
                    imagesetpixel($this->imageHandle, $right, $j, $t); 
                    $left++; $right--; 
                } 
            
        }

        return true;
    }


    /**
     * Adjust the image gamma
     *
     * @param float $outputgamma
     *
     * @return none
     */
    function gamma($outputgamma=1.0) {
        ImageGammaCorrect($this->imageHandle, 1.0, $outputgamma);
    }

    /**
     * Save the image file
     *
     * @param $filename string  the name of the file to write to
     * @param $quality  int     output DPI, default is 85
     * @param $types    string  define the output format, default
     *                          is the current used format
     *
     * @return none
     */
    function save($filename, $type = '', $quality = 85)
    {
		$type           = $type==''? $this->type : $type;
		$functionName   = 'image' . $type;

		if(function_exists($functionName))
		{
			$this->old_image = $this->imageHandle;
			if($type=='jpeg')
				$functionName($this->imageHandle, $filename, $quality);
			else
				$functionName($this->imageHandle, $filename);
			$this->imageHandle = $this->old_image;
			$this->resized = false;
		}
    } // End save


    /**
     * Display image without saving and lose changes
     *
     * @param string type (JPG,PNG...);
     * @param int quality 75
     *
     * @return none
     */
    function display($type = '', $quality = 75)
    {
        if ($type != '') {
            $this->type = $type;
        }
        $functionName = 'Image' . $this->type;
		if(function_exists($functionName))
		{
			header('Content-type: image/' . strtolower($this->type));
			$functionName($this->imageHandle, '', $quality);
			$this->imageHandle = $this->old_image;
			$this->resized = false;
			ImageDestroy($this->old_image);
			$this->free();
		}
    }

    /**
     * Destroy image handle
     *
     * @return none
     */
    function free()
    {
        if ($this->imageHandle){
            ImageDestroy($this->imageHandle);
        }
    }

} // End class ImageGD
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/IM.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

/***********************************************************************
** Title.........:  ImageMagick Driver
** Version.......:  1.0
** Author........:  Xiang Wei ZHUO <wei@zhuo.org>
** Filename......:  IM.php
** Last changed..:  30 Aug 2003 
** Notes.........:  Orginal is from PEAR
**/

// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2002 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Peter Bowyer <peter@mapledesign.co.uk>                      |
// +----------------------------------------------------------------------+
//
// $Id: IM.php 4169 2007-09-21 06:28:49Z silmarillion $
//
// Image Transformation interface using command line ImageMagick
//

require_once(dirname(__FILE__)."/Transform.php");

Class Image_Transform_Driver_IM extends Image_Transform
{
    /**
     * associative array commands to be executed
     * @var array
     */
    var $command = array();

    /**
     *
     *
     */
    function Image_Transform_Driver_IM()
    {
        return true;
    } // End Image_IM

    /**
     * Load image
     *
     * @param string filename
     *
     * @return mixed none or a PEAR error object on error
     * @see PEAR::isError()
     */
    function load($image)
    {

        $this->uid = md5($_SERVER['REMOTE_ADDR']);
        /*if (!file_exists($image)) {
            return PEAR::raiseError('The image file ' . $image . ' does\'t exist', true);
        }*/
        $this->image = $image;
        $this->_get_image_details($image);
    } // End load

    /**
     * Resize Action
     *
     * @param int   new_x   new width
     * @param int   new_y   new height
     *
     * @return none
     * @see PEAR::isError()
     */
    function _resize($new_x, $new_y)
    {
        /*if (isset($this->command['resize'])) {
            return PEAR::raiseError("You cannot scale or resize an image more than once without calling save or display", true);
        }*/
        $this->command['resize'] = "-geometry ${new_x}x${new_y}!";

        $this->new_x = $new_x;
        $this->new_y = $new_y;
    } // End resize

    /**
     * Crop the image
     *
     * @param int $crop_x left column of the image
     * @param int $crop_y top row of the image
     * @param int $crop_width new cropped image width
     * @param int $crop_height new cropped image height
     */
    function crop($crop_x, $crop_y, $crop_width, $crop_height) 
    {
        $this->command['crop'] = "-crop {$crop_width}x{$crop_height}+{$crop_x}+{$crop_y}";
    }

    /**
     * Flip the image horizontally or vertically
     *
     * @param boolean $horizontal true if horizontal flip, vertical otherwise
     */
    function flip($horizontal) 
    {
        if($horizontal)
            $this->command['flop'] = "-flop";
        else
            $this->command['flip'] = "-flip";
    }
    /**
     * rotate
     *
     * @param   int     angle   rotation angle
     * @param   array   options no option allowed
     *
     */
    function rotate($angle, $options=null)
    {
        if ('-' == $angle{0}) {
            $angle = 360 - substr($angle, 1);
        }
         $this->command['rotate'] = "-rotate $angle";
    } // End rotate

    /**
     * addText
     *
     * @param   array   options     Array contains options
     *                              array(
     *                                  'text'  The string to draw
     *                                  'x'     Horizontal position
     *                                  'y'     Vertical Position
     *                                  'Color' Font color
     *                                  'font'  Font to be used
     *                                  'size'  Size of the fonts in pixel
     *                                  'resize_first'  Tell if the image has to be resized
     *                                                  before drawing the text
     *                              )
     *
     * @return none
     * @see PEAR::isError()
     */
    function addText($params)
    {
        $default_params = array(
                                'text' => 'This is Text',
                                'x' => 10,
                                'y' => 20,
                                'color' => 'red',
                                'font' => 'Arial.ttf',
                                'resize_first' => false // Carry out the scaling of the image before annotation?
                                );
         $params = array_merge($default_params, $params);
         extract($params);
         if (true === $resize_first) {
             // Set the key so that this will be the last item in the array
            $key = 'ztext';
         } else {
            $key = 'text';
         }
         $this->command[$key] = "-font $font -fill $color -draw 'text $x,$y \"$text\"'";
         // Producing error: gs: not found gs: not found convert: Postscript delegate failed [No such file or directory].
    } // End addText

    /**
     * Adjust the image gamma
     *
     * @param float $outputgamma
     *
     * @return none
     */
    function gamma($outputgamma=1.0) {
        $this->command['gamma'] = "-gamma $outputgamma";
    }

    /**
     * Save the image file
     *
     * @param $filename string  the name of the file to write to
     * @param $quality  quality image dpi, default=75
     * @param $type     string  (JPG,PNG...)
     *
     * @return none
     */
    function save($filename, $type='', $quality = 85)
    {
        $type == '' ? $this->type : $type;
        $cmd = '' . IMAGE_TRANSFORM_LIB_PATH . 'convert ';
		$cmd .= implode(' ', $this->command) . " -quality $quality ";
		$cmd .= '"'.($this->image) . '" "' . ($filename) . '" 2>&1';
        
        //$cmd = str_replace('/', '\\', $cmd);
		//echo($cmd.'<br>');
        exec($cmd,$retval);
    } // End save

    /**
     * Display image without saving and lose changes
     *
     * @param string type (JPG,PNG...);
     * @param int quality 75
     *
     * @return none
     */
    function display($type = '', $quality = 75)
    {
        if ($type == '') {
            header('Content-type: image/' . $this->type);
            passthru(IMAGE_TRANSFORM_LIB_PATH . 'convert ' . implode(' ', $this->command) . " -quality $quality "  . escapeshellarg($this->image) . ' ' . strtoupper($this->type) . ":-");
        } else {
            header('Content-type: image/' . $type);
            passthru(IMAGE_TRANSFORM_LIB_PATH . 'convert ' . implode(' ', $this->command) . " -quality $quality "  . escapeshellarg($this->image) . ' ' . strtoupper($type) . ":-");
        }
    }


    /**
     * Destroy image handle
     *
     * @return none
     */
    function free()
    {
        return true;
    }

} // End class ImageIM
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/ImageEditor.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/**
 * Image Editor. Editing tools, crop, rotate, scale and save.
 * @author $Author: Wei Zhuo $
 * @version $Id: ImageEditor.php 4169 2007-09-21 06:28:49Z silmarillion $
 * @package ImageManager
 */

require_once(dirname(__FILE__)."/Transform.php");

/**
 * Handles the basic image editing capbabilities.
 * @author $Author: Wei Zhuo $
 * @version $Id: ImageEditor.php 4169 2007-09-21 06:28:49Z silmarillion $
 * @package ImageManager
 * @subpackage Editor
 */
class ImageEditor 
{
	/**
	 * ImageManager instance.
	 */
	var $manager;

	/**
	 * user based on IP address
	 */
	var $_uid;

	/**
	 * tmp file storage time.
	 */
	var $lapse_time =900; //15 mins

	var $filesaved = 0;

	/**
	 * Create a new ImageEditor instance. Editing requires a 
	 * tmp file, which is saved in the current directory where the
	 * image is edited. The tmp file is assigned by md5 hash of the
	 * user IP address. This hashed is used as an ID for cleaning up
	 * the tmp files. In addition, any tmp files older than the
	 * the specified period will be deleted.
	 * @param ImageManager $manager the image manager, we need this
	 * for some file and path handling functions.
	 */
	function ImageEditor($manager) 
	{
		$this->manager = $manager;
		$this->_uid = md5($_SERVER['REMOTE_ADDR']);
	}
	
	/**
	 * Did we save a file?
	 * @return int 1 if the file was saved sucessfully, 
	 * 0 no save operation, -1 file save error.
	 */
	function isFileSaved() 
	{
		Return $this->filesaved;
	}

	/**
	 * Process the image, if not action, just display the image.
	 * @return array with image information, empty array if not an image.
	 * <code>array('src'=>'url of the image', 'dimensions'=>'width="xx" height="yy"',
	 * 'file'=>'image file, relative', 'fullpath'=>'full path to the image');</code>
	 */
	function processImage() 
	{
		if(isset($_GET['img']))
			$relative = rawurldecode($_GET['img']);
		else
			Return array();
		
		//$relative = '/Series2004NoteFront.jpg';

		$imgURL = $this->manager->getFileURL($relative);
		$fullpath = $this->manager->getFullPath($relative);
		
		$imgInfo = @getImageSize($fullpath);
		if(!is_array($imgInfo))
			Return array();

		$action = $this->getAction();

		if(!is_null($action))
		{
			$image = $this->processAction($action, $relative, $fullpath);
		}
		else
		{
			$image['src'] = $imgURL;
			$image['dimensions'] = $imgInfo[3];
			$image['file'] = $relative;
			$image['fullpath'] = $fullpath;
		}

		Return $image;
	}

	/**
	 * Process the actions, crop, scale(resize), rotate, flip, and save.
	 * When ever an action is performed, the result is save into a
	 * temporary image file, see createUnique on the filename specs.
	 * It does not return the saved file, alway returning the tmp file.
	 * @param string $action, should be 'crop', 'scale', 'rotate','flip', or 'save'
	 * @param string $relative the relative image filename
	 * @param string $fullpath the fullpath to the image file
	 * @return array with image information
	 * <code>array('src'=>'url of the image', 'dimensions'=>'width="xx" height="yy"',
	 * 'file'=>'image file, relative', 'fullpath'=>'full path to the image');</code>
	 */
	function processAction($action, $relative, $fullpath) 
	{
		$params = '';
		
		if(isset($_GET['params']))
			$params = $_GET['params'];

		$values =  explode(',',$params,4);
		$saveFile = $this->getSaveFileName($values[0]);

		$img = Image_Transform::factory(IMAGE_CLASS);
		$img->load($fullpath);

		switch ($action) 
		{
			case 'crop':
				$img->crop(intval($values[0]),intval($values[1]),
							intval($values[2]),intval($values[3]));
			break;
			case 'scale':
				$img->resize(intval($values[0]),intval($values[1]));
				break;
			case 'rotate':
				$img->rotate(floatval($values[0]));
				break;
			case 'flip':
				if ($values[0] == 'hoz')
					$img->flip(true);
				else if($values[0] == 'ver') 
					$img->flip(false);
				break;
			case 'save':
				if(!is_null($saveFile))
				{
					$quality = intval($values[1]);
		            if($quality <0) $quality = 85;
					$newSaveFile = $this->makeRelative($relative, $saveFile);
					$newSaveFile = $this->getUniqueFilename($newSaveFile);
					
					//get unique filename just returns the filename, so
					//we need to make the relative path once more.
					$newSaveFile = $this->makeRelative($relative, $newSaveFile);
					$newSaveFullpath = $this->manager->getFullPath($newSaveFile);
					$img->save($newSaveFullpath, $values[0], $quality);
					if(is_file($newSaveFullpath))
						$this->filesaved = 1;
					else
						$this->filesaved = -1;
				}
				break;
		}
		
		//create the tmp image file
		$filename = $this->createUnique($fullpath);
		$newRelative = $this->makeRelative($relative, $filename);
		$newFullpath = $this->manager->getFullPath($newRelative);
		$newURL = $this->manager->getFileURL($newRelative);
		
		//save the file.
		$img->save($newFullpath);
		$img->free();

		//get the image information
		$imgInfo = @getimagesize($newFullpath);

		$image['src'] = $newURL;
		$image['dimensions'] = $imgInfo[3];
		$image['file'] = $newRelative;
		$image['fullpath'] = $newFullpath;

		Return $image;
	
	}

	/**
	 * Get the file name base on the save name
	 * and the save type.
	 * @param string $type image type, 'jpeg', 'png', or 'gif'
	 * @return string the filename according to save type
	 */
	function getSaveFileName($type) 
	{
		if(!isset($_GET['file']))
			Return null;

		$filename = Files::escape(rawurldecode($_GET['file']));
		$index = strrpos($filename,'.');
		$base = substr($filename,0,$index);
		$ext = strtolower(substr($filename,$index+1,strlen($filename)));

		if($type == 'jpeg' && !($ext=='jpeg' || $ext=='jpg'))
		{
			Return $base.'.jpeg';
		}
		if($type=='png' && $ext != 'png')
			Return $base.'.png';
		if($type=='gif' && $ext != 'gif')
			Return $base.'.gif';

		Return $filename;
	}

	/**
	 * Get the default save file name, used by editor.php.
	 * @return string a suggestive filename, this should be unique
	 */
	function getDefaultSaveFile() 
	{
		if(isset($_GET['img']))
			$relative = rawurldecode($_GET['img']);
		else
			Return null;

		Return $this->getUniqueFilename($relative);
	}

	/**
	 * Get a unique filename. If the file exists, the filename
	 * base is appended with an increasing integer.
	 * @param string $relative the relative filename to the base_dir
	 * @return string a unique filename in the current path
	 */
	function getUniqueFilename($relative) 
	{
		$fullpath = $this->manager->getFullPath($relative);
		
		$pathinfo = pathinfo($fullpath);

		$path = Files::fixPath($pathinfo['dirname']);
		$file = Files::escape($pathinfo['basename']);
		
		$filename = $file;

		$dotIndex = strrpos($file, '.');
		$ext = '';

		if(is_int($dotIndex)) 
		{
			$ext = substr($file, $dotIndex);
			$base = substr($file, 0, $dotIndex);
		}

		$counter = 0;
		while(is_file($path.$filename)) 
		{
			$counter++;
			$filename = $base.'_'.$counter.$ext;
		}
		
		Return $filename;
		
	}

	/**
	 * Specifiy the original relative path, a new filename
	 * and return the new filename with relative path.
	 * i.e. $pathA (-filename) + $file
	 * @param string $pathA the relative file
	 * @param string $file the new filename
	 * @return string relative path with the new filename
	 */
	function makeRelative($pathA, $file) 
	{
		$index = strrpos($pathA,'/');
		if(!is_int($index))
			Return $file;

		$path = substr($pathA, 0, $index);
		Return Files::fixPath($path).$file;
	}

	/**
	 * Get the action GET parameter
	 * @return string action parameter
	 */
	function getAction() 
	{
		$action = null;
		if(isset($_GET['action']))
			$action = $_GET['action'];
		Return $action;
	}

	/**
	 * Generate a unique string based on md5(microtime()).
	 * Well not so uniqe, as it is limited to 6 characters
	 * @return string unique string.
	 */
    function uniqueStr()
    {
      return substr(md5(microtime()),0,6);
    }

	/**
	 * Create unique tmp image file name.
	 * The filename is based on the tmp file prefix
	 * specified in config.inc.php plus 
	 * the UID (basically a md5 of the remote IP)
	 * and some random 6 character string.
	 * This function also calls to clean up the tmp files.
	 * @param string $file the fullpath to a file
	 * @return string a unique filename for that path
	 * NOTE: it only returns the filename, path no included.
	 */
	function createUnique($file) 
	{
		$pathinfo = pathinfo($file);
		$path = Files::fixPath($pathinfo['dirname']);
		$imgType = $this->getImageType($file);

		$unique_str = $this->manager->getTmpPrefix().$this->_uid.'_'.$this->uniqueStr().".".$imgType;

	   //make sure the the unique temp file does not exists
        while (file_exists($path.$unique_str))
        {
            $unique_str = $this->manager->getTmpPrefix().$this->_uid.'_'.$this->uniqueStr().".".$imgType;
        }

		$this->cleanUp($path,$pathinfo['basename']);

		Return $unique_str;
	}

	/**
	 * Delete any tmp image files.
	 * @param string $path the full path 
	 * where the clean should take place.
	 */
	function cleanUp($path,$file) 
	{
		$path = Files::fixPath($path);

		if(!is_dir($path))
			Return false;

		$d = @dir($path);
		
		$tmp = $this->manager->getTmpPrefix();
		$tmpLen = strlen($tmp);

		$prefix = $tmp.$this->_uid;
		$len = strlen($prefix);

		while (false != ($entry = $d->read())) 
		{
			//echo $entry."<br>";
			if(is_file($path.$entry) && $this->manager->isTmpFile($entry))
			{
				if(substr($entry,0,$len)==$prefix && $entry != $file)
					Files::delFile($path.$entry);
				else if(substr($entry,0,$tmpLen)==$tmp && $entry != $file)
				{
					if(filemtime($path.$entry)+$this->lapse_time < time())
						Files::delFile($path.$entry);
				}
			}
		}
		$d->close();
	}

	/**
	 * Get the image type base on an image file.
	 * @param string $file the full path to the image file.
	 * @return string of either 'gif', 'jpeg', 'png' or 'bmp'
	 * otherwise it will return null.
	 */
	function getImageType($file) 
	{
		$imageInfo = @getImageSize($file);

		if(!is_array($imageInfo))
			Return null;

		switch($imageInfo[2]) 
		{
			case 1:
				Return 'gif';
			case 2:
				Return 'jpeg';
			case 3:
				Return 'png';
			case 6:
				Return 'bmp';
		}

		Return null;
	}

	/**
	 * Check if the specified image can be edit by GD
	 * mainly to check that GD can read and save GIFs
	 * @return int 0 if it is not a GIF file, 1 is GIF is editable, -1 if not editable.
	 */
	function isGDEditable() 
	{
		if(isset($_GET['img']))
			$relative = rawurldecode($_GET['img']);
		else
			Return 0;
		if(IMAGE_CLASS != 'GD')
			Return 0;

		$fullpath = $this->manager->getFullPath($relative);

		$type = $this->getImageType($fullpath);
		if($type != 'gif')
			Return 0;

		if(function_exists(strtolower('ImageCreateFrom'.$type))
			&& function_exists(strtolower('image'.$type)))
			Return 1;
		else
			Return -1;
	}

	/**
	 * Check if GIF can be edit by GD.
	 * @return int 0 if it is not using the GD library, 1 is GIF is editable, -1 if not editable.
	 */
	function isGDGIFAble() 
	{
		if(IMAGE_CLASS != 'GD')
			Return 0;

		if(function_exists('ImageCreateFromGif')
			&& function_exists('imagegif'))
			Return 1;
		else
			Return -1;
	}
}

?>
]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/ImageManager.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/**
 * ImageManager, list images, directories, and thumbnails.
 * @author $Author: Wei Zhuo $
 * @version $Id: ImageManager.php 8553 2012-12-08 17:03:10Z calguy1000 $
 * @package ImageManager
 */

require_once(dirname(__FILE__).'/Files.php');

/**
 * ImageManager Class.
 * @author $Author: Wei Zhuo $
 * @version $Id: ImageManager.php 8553 2012-12-08 17:03:10Z calguy1000 $
 */
class ImageManager 
{
	/**
	 * Configuration array.
	 */
	var $config;

	/**
	 * Array of directory information.
	 */
	var $dirs;

	/**
	 * Constructor. Create a new Image Manager instance.
	 * @param array $config configuration array, see config.inc.php
	 */
	function ImageManager($config) 
	{
		$this->config = $config;
	}

	/**
	 * Get the base directory.
	 * @return string base dir, see config.inc.php
	 */
	function getBaseDir() 
	{
		Return $this->config['base_dir'];
	}

	/**
	 * Get the base URL.
	 * @return string base url, see config.inc.php
	 */
	function getBaseURL() 
	{
		Return $this->config['base_url'];
	}

	function isValidBase()
	{
		return is_dir($this->getBaseDir());
	}

	/**
	 * Get the tmp file prefix.
     * @return string tmp file prefix.
	 */
	function getTmpPrefix() 
	{
		Return $this->config['tmp_prefix'];
	}

	/**
	 * Get the sub directories in the base dir.
	 * Each array element contain
	 * the relative path (relative to the base dir) as key and the 
	 * full path as value.
	 * @return array of sub directries
	 * <code>array('path name' => 'full directory path', ...)</code>
	 */
	function getDirs() 
	{
		if(is_null($this->dirs))
		{
			$dirs = $this->_dirs($this->getBaseDir(),'/');
			ksort($dirs);
			$this->dirs = $dirs;
		}
		return $this->dirs;
	}

	/**
	 * Recursively travese the directories to get a list
	 * of accessable directories.
	 * @param string $base the full path to the current directory
	 * @param string $path the relative path name
	 * @return array of accessiable sub-directories
	 * <code>array('path name' => 'full directory path', ...)</code>
	 */
	function _dirs($base, $path) 
	{
		$base = Files::fixPath($base);
		$dirs = array();

		if($this->isValidBase() == false)
			return $dirs;

		$d = @dir($base);
		if( !$d ) return $dirs;
	
		while (false !== ($entry = $d->read())) 
		{
			//If it is a directory, and it doesn't start with
			// a dot, and if is it not the thumbnail directory
			if(is_dir($base.$entry) 
				&& substr($entry,0,1) != '.'
				&& $this->isThumbDir($entry) == false) 
			{
				$relative = Files::fixPath($path.$entry);
				$fullpath = Files::fixPath($base.$entry);
				$dirs[$relative] = $fullpath;
				$dirs = array_merge($dirs, $this->_dirs($fullpath, $relative));
			}
		}
		$d->close();

		Return $dirs;
	}

	/**
	 * Get all the files and directories of a relative path.
	 * @param string $path relative path to be base path.
	 * @return array of file and path information.
	 * <code>array(0=>array('relative'=>'fullpath',...), 1=>array('filename'=>fileinfo array(),...)</code>
	 * fileinfo array: <code>array('url'=>'full url', 
	 *                       'relative'=>'relative to base', 
	 *                        'fullpath'=>'full file path', 
	 *                        'image'=>imageInfo array() false if not image,
	 *                        'stat' => filestat)</code>
	 */
	function getFiles($path) 
	{
		$files = array();
		$dirs = array();

		if($this->isValidBase() == false)
			return array($files,$dirs);

		$path = Files::fixPath($path);
		$base = Files::fixPath($this->getBaseDir());
		$fullpath = Files::makePath($base,$path);

		$d = @dir($fullpath);
		if( $d ) {
		  while (false !== ($entry = $d->read())) {
		    //not a dot file or directory
		    if(substr($entry,0,1) != '.') {
		      if(is_dir($fullpath.$entry)
			 && $this->isThumbDir($entry) == false) {
			$relative = Files::fixPath($path.$entry);
			$full = Files::fixPath($fullpath.$entry);
			$count = $this->countFiles($full);
			$dirs[$relative] = array('fullpath'=>$full,'entry'=>$entry,'count'=>$count);
		      }
		      else if(is_file($fullpath.$entry) && 
			      $this->isThumb($entry)==false && $this->isTmpFile($entry) == false) {
			$img = $this->getImageInfo($fullpath.$entry);

			if(!(!is_array($img)&&$this->config['validate_images'])) {
			  $file['url'] = Files::makePath($this->config['base_url'],$path).$entry;
			  $file['relative'] = $path.$entry;
			  $file['fullpath'] = $fullpath.$entry;
			  $file['image'] = $img;
			  $file['stat'] = stat($fullpath.$entry);
			  $files[$entry] = $file;
			}
		      }
		    }
		  }
		  $d->close();
		}

			//Add a back directory
			
			$backpath = $fullpath.'/..';
			$backpath = realpath($backpath);
			if (substr($backpath,0,strlen($this->getBaseDir())) == $this->getBaseDir())
				{
				$backpath = substr($backpath,strlen($this->getBaseDir()));
				}
//		    echo '<p class="pageheader">'.$path.'</p>';
			if($path != '/') {
					$relative = Files::fixPath($backpath);
					$full = Files::fixPath($backpath);
					$count = $this->countFiles($full);
					$entry = '..';
					$dirs[$relative] = array('fullpath'=>$full,'entry'=>$entry,'count'=>$count);			  
			}

		ksort($dirs);
		ksort($files);
		
		Return array($dirs, $files);
	}	

	/**
	 * Count the number of files and directories in a given folder
	 * minus the thumbnail folders and thumbnails.
	 */
	function countFiles($path) 
	{
		$total = 0;
		global $config;
		if(($path != "/") && (is_dir($config['image_uploads_path']."/".$path)))
		{
			$d = @dir($config['image_uploads_path']."/".$path);

			while (false !== ($entry = $d->read())) 
			{
				//echo $entry."<br>";
				if(substr($entry,0,1) != '.'
					&& $this->isThumbDir($entry) == false
					&& $this->isTmpFile($entry) == false
					&& $this->isThumb($entry) == false) 
				{
					$total++;
				}
			}
			$d->close();
		}
		return $total;
	}

	/**
	 * Get image size information.
	 * @param string $file the image file
	 * @return array of getImageSize information, 
	 *  false if the file is not an image.
	 */
	function getImageInfo($file) 
	{
		Return @getImageSize($file);
	}

	/**
	 * Check if the file contains the thumbnail prefix.
	 * @param string $file filename to be checked
	 * @return true if the file contains the thumbnail prefix, false otherwise.
	 */
	function isThumb($file) 
	{
		$len = strlen($this->config['thumbnail_prefix']);
		if(substr($file,0,$len)==$this->config['thumbnail_prefix'])
			Return true;
		else
			Return false;
	}

	/**
	 * Check if the given directory is a thumbnail directory.
	 * @param string $entry directory name
	 * @return true if it is a thumbnail directory, false otherwise
	 */
	function isThumbDir($entry) 
	{
		if($this->config['thumbnail_dir'] == false
			|| strlen(trim($this->config['thumbnail_dir'])) == 0)
			Return false;		
		else
			Return ($entry == $this->config['thumbnail_dir']);
	}

	/**
	 * Check if the given file is a tmp file.
	 * @param string $file file name
	 * @return boolean true if it is a tmp file, false otherwise
	 */
	function isTmpFile($file) 
	{
		$len = strlen($this->config['tmp_prefix']);
		if(substr($file,0,$len)==$this->config['tmp_prefix'])
			Return true;
		else
			Return false;	 	
	}

	/**
	 * For a given image file, get the respective thumbnail filename
	 * no file existence check is done.
	 * @param string $fullpathfile the full path to the image file
	 * @return string of the thumbnail file
	 */
	function getThumbName($fullpathfile) 
	{
		$path_parts = pathinfo($fullpathfile);
		
		$thumbnail = $this->config['thumbnail_prefix'].$path_parts['basename'];

		if($this->config['safe_mode'] == true
			|| strlen(trim($this->config['thumbnail_dir'])) == 0)
		{
	
			Return Files::makeFile($path_parts['dirname'],$thumbnail);
		}
		else
		{
			if(strlen(trim($this->config['thumbnail_dir'])) > 0)
			{
				$path = Files::makePath($path_parts['dirname'],$this->config['thumbnail_dir']);
				if(!is_dir($path))
					Files::createFolder($path);
				Return Files::makeFile($path,$thumbnail);
			}
			else //should this ever happen?
			{
				//error_log('ImageManager: Error in creating thumbnail name');
			}
		}
	}
	
	/**
	 * Similar to getThumbName, but returns the URL, base on the
	 * given base_url in config.inc.php
	 * @param string $relative the relative image file name, 
	 * relative to the base_dir path
	 * @return string the url of the thumbnail
	 */
	function getThumbURL($relative) 
	{
		$path_parts = pathinfo($relative);
		$thumbnail = $this->config['thumbnail_prefix'].$path_parts['basename'];
		if($path_parts['dirname']=='\\') $path_parts['dirname']='/';

		if($this->config['safe_mode'] == true
			|| strlen(trim($this->config['thumbnail_dir'])) == 0)
		{

			$path = Files::makePath($path_parts['dirname'],'');
			$url_path = Files::makePath($this->getBaseURL(), $path);
			Return Files::makeFile($url_path,$thumbnail);
//			Return Files::makeFile($this->getBaseURL(),$thumbnail);
		}
		else
		{
			if(strlen(trim($this->config['thumbnail_dir'])) > 0)
			{

				$path = Files::makePath($path_parts['dirname'],$this->config['thumbnail_dir']);
				$url_path = Files::makePath($this->getBaseURL(), $path);
				Return Files::makeFile($url_path,$thumbnail);
			}
			else //should this ever happen?
			{
				//error_log('ImageManager: Error in creating thumbnail url');
			}

		}
	}

	/**
	 * Check if the given path is part of the subdirectories
	 * under the base_dir.
	 * @param string $path the relative path to be checked
	 * @return boolean true if the path exists, false otherwise
	 */
	function validRelativePath($path) 
	{
		$dirs = $this->getDirs();
		if($path == '/' || $path == '\/') return true; // stupid windoze.
		//check the path given in the url against the 
		//list of paths in the system.
		for($i = 0; $i < count($dirs); $i++)
		{
			$key = key($dirs);
			//we found the path
			if($key == $path) {
			  return true;
			}
		
			next($dirs);
		}
		return false;
	}

	/**
	 * Process uploaded files, assumes the file is in 
	 * $_FILES['upload'] and $_POST['dir'] is set.
	 * The dir must be relative to the base_dir and exists.
	 * If 'validate_images' is set to true, only file with
	 * image dimensions will be accepted.
	 * @return null
	 */
	function processUploads() 
	{
		if($this->isValidBase() == false)
			return;

		$relative = null;

		if(isset($_POST['dir'])) 
			$relative = rawurldecode($_POST['dir']);
		else
			return;

		//check for the file, and must have valid relative path
		if(isset($_FILES['upload']) && $this->validRelativePath($relative))
		{
			$this->_processFiles($relative, $_FILES['upload']);
		}
	}

	/**
	 * Process upload files. The file must be an 
	 * uploaded file. If 'validate_images' is set to
	 * true, only images will be processed. Any duplicate
	 * file will be renamed. See Files::copyFile for details
	 * on renaming.
	 * @param string $relative the relative path where the file
	 * should be copied to.
	 * @param array $file the uploaded file from $_FILES
	 * @return boolean true if the file was processed successfully, 
	 * false otherwise
	 */
	function _processFiles($relative, $file)
	{
	  if( !$this->validRelativePath($relative) ) return false;
		
		if($file['error']!=0)
		{
			Return false;
		}

		if(!is_file($file['tmp_name']))
		{
			Return false;
		}

		if(!is_uploaded_file($file['tmp_name']))
		{
			Files::delFile($file['tmp_name']);
			Return false;
		}
		

		if($this->config['validate_images'] == true)
		{
			$imgInfo = @getImageSize($file['tmp_name']);
			if(!is_array($imgInfo))
			{
				Files::delFile($file['tmp_name']);
				Return false;
			}
		}

		//now copy the file
		$path = Files::makePath($this->getBaseDir(),$relative);

		$filespec = preg_replace('/\.php/','',$file['name']);
		$result = Files::copyFile($file['tmp_name'], $path, $filespec);

		//no copy error
		if(!is_int($result))
		{
			Files::delFile($file['tmp_name']);
			Return true;
		}

		//delete tmp files.
		Files::delFile($file['tmp_name']);
		Return false;
	}

	/**
	 * Get the URL of the relative file.
	 * basically appends the relative file to the 
	 * base_url given in config.inc.php
	 * @param string $relative a file the relative to the base_dir
	 * @return string the URL of the relative file.
	 */
	function getFileURL($relative) 
	{
		Return Files::makeFile($this->getBaseURL(),$relative);
	}

	/**
	 * Get the fullpath to a relative file.
	 * @param string $relative the relative file.
	 * @return string the full path, .ie. the base_dir + relative.
	 */
	function getFullPath($relative) 
	{
		Return Files::makeFile($this->getBaseDir(),$relative);;
	}

	/**
	 * Get the default thumbnail.
	 * @return string default thumbnail, empty string if 
	 * the thumbnail doesn't exist.
	 */
	function getDefaultThumb() 
	{
		if(is_file($this->config['default_thumbnail']))
			Return $this->config['default_thumbnail'];
		else 
			Return '';
	}


	/**
	 * Get the thumbnail url to be displayed. 
	 * If the thumbnail exists, and it is up-to-date
	 * the thumbnail url will be returns. If the 
	 * file is not an image, a default image will be returned.
	 * If it is an image file, and no thumbnail exists or 
	 * the thumbnail is out-of-date (i.e. the thumbnail 
	 * modified time is less than the original file)
	 * then a thumbs.php?img=filename.jpg is returned.
	 * The thumbs.php url will generate a new thumbnail
	 * on the fly. If the image is less than the dimensions
	 * of the thumbnails, the image will be display instead.
	 * @param string $relative the relative image file.
	 * @return string the url of the thumbnail, be it
	 * actually thumbnail or a script to generate the
	 * thumbnail on the fly.
	 */
	function getThumbnail($relative) 
	{
		$fullpath = Files::makeFile($this->getBaseDir(),$relative);
		//not a file???
		if(!is_file($fullpath))
			Return $this->getDefaultThumb();

		$imgInfo = @getImageSize($fullpath);
		
		//not an image
		if(!is_array($imgInfo))
			Return $this->getDefaultThumb();

		$thumbnail = $this->getThumbName($fullpath);
		
		//check for thumbnails, if exists and
		// it is up-to-date, return the thumbnail url
		if(is_file($thumbnail))
		{
			if(filemtime($thumbnail) >= filemtime($fullpath))
				Return $this->getThumbURL($relative);
		}

		//well, no thumbnail was found, so ask the thumbs.php
		//to generate the thumbnail on the fly.
		Return 'thumbs.php?img='.rawurlencode($relative);
	}

	/**
	 * Delete and specified files.
	 * @return boolean true if delete, false otherwise
	 */
	function deleteFiles() 
	{
	  if(isset($_GET['delf']))
	    $this->_delFile(rawurldecode($_GET['delf']));
	}

	/**
	 * Delete and specified directories.
	 * @return boolean true if delete, false otherwise
	 */
	function deleteDirs() 
	{
	  if(isset($_GET['deld']) ) {
	    return $this->_delDir(rawurldecode($_GET['deld']));
	  }
	  return false;
	}

	/**
	 * Delete the relative file, and any thumbnails.
	 * @param string $relative the relative file.
	 * @return boolean true if deleted, false otherwise.
	 */
	function _delFile($relative) 
	{ 
          $r2 = Files::fixPath(dirname($relative));
	  if( !$this->validRelativePath($r2) ) return false;
	  
	  $fullpath = Files::makeFile($this->getBaseDir(),$relative);
		
		//check that the file is an image
		if($this->config['validate_images'] == true)
		{
			if(!is_array($this->getImageInfo($fullpath)))
				return false; //hmmm not an Image!!???
		}

		$thumbnail = $this->getThumbName($fullpath);

		if(Files::delFile($fullpath))
			Return Files::delFile($thumbnail);
		else
			Return false;
	}

	/**
	 * Delete directories recursively.
	 * @param string $relative the relative path to be deleted.
	 * @return boolean true if deleted, false otherwise.
	 */
	function _delDir($relative) 
	{
	  if( !$this->validRelativePath($relative) ) return false;
		$fullpath = Files::makePath($this->getBaseDir(),$relative);
		if($this->countFiles($fullpath) <= 0)
			return Files::delFolder($fullpath,true); //delete recursively.
		else
			Return false;
	}

	/**
	 * Create new directories.
	 * If in safe_mode, nothing happens.
	 * @return boolean true if created, false otherwise.
	 */
	function processNewDir() 
	{
		if($this->config['safe_mode'] == true)
			Return false;

		if(isset($_GET['newDir']) && isset($_GET['dir']))
		{
			$newDir = rawurldecode($_GET['newDir']);
			$dir = rawurldecode($_GET['dir']);
			$path = Files::makePath($this->getBaseDir(),$dir);
			$fullpath = Files::makePath($path, Files::escape($newDir));
			if(is_dir($fullpath))
				Return false;

			Return Files::createFolder($fullpath);
		}
	}

	/**
	 * Do some graphic library method checkings
	 * @param string $library the graphics library, GD, NetPBM, or IM.
	 * @param string $method the method to check.
	 * @return boolean true if able, false otherwise.
	 */
	function validGraphicMethods($library,$method)
	{
		switch ($library)
		{
			case 'GD':
				return $this->_checkGDLibrary($method);
				break;
			case 'NetPBM':
				return $this->_checkNetPBMLibrary($method);
				break;
			case 'IM':
				return $this->_checkIMLibrary($method);
		}
		return false;
	}

	function _checkIMLibrary($method)
	{
		//ImageMagick goes throught 1 single executable
		if(is_file(Files::fixPath(IMAGE_TRANSFORM_LIB_PATH).'convert'))
			return true;
		else
			return false;
	}

	/**
	 * Check the GD library functionality.
	 * @param string $library the graphics library, GD, NetPBM, or IM.
	 * @return boolean true if able, false otherwise.
	 */
	function _checkGDLibrary($method)
	{
		$errors = array();
		switch($method)
		{
			case 'create':
				$errors['createjpeg'] = function_exists('imagecreatefromjpeg');
				$errors['creategif'] = function_exists('imagecreatefromgif');
				$errors['createpng'] = function_exists('imagecreatefrompng');
				break;
			case 'modify':
				$errors['create'] = function_exists('ImageCreateTrueColor') || function_exists('ImageCreate');
				$errors['copy'] = function_exists('ImageCopyResampled') || function_exists('ImageCopyResized');
				break;
			case 'save':
				$errors['savejpeg'] = function_exists('imagejpeg');
				$errors['savegif'] = function_exists('imagegif');
				$errors['savepng'] = function_exists('imagepng');
				break;
		}

		return $errors;
	}
}

?>
]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBkdW1teSBpbmRleC5odG1sIC0tPgo=]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/NetPBM.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/***********************************************************************
** Title.........:  NetPBM Driver
** Version.......:  1.0
** Author........:  Xiang Wei ZHUO <wei@zhuo.org>
** Filename......:  NetPBM.php
** Last changed..:  30 Aug 2003 
** Notes.........:  Orginal is from PEAR
**/

// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2002 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Peter Bowyer <peter@mapledesign.co.uk>                      |
// +----------------------------------------------------------------------+
//
// $Id: NetPBM.php 6879 2011-01-29 18:27:08Z calguy1000 $
//
// Image Transformation interface using command line NetPBM

require_once(dirname(__FILE__)."/Transform.php");

Class Image_Transform_Driver_NetPBM extends Image_Transform
{

    /**
     * associative array commands to be executed
     * @var array
     */
    var $command = array();

    /**
     * Class Constructor
     */
    function Image_Transform_Driver_NetPBM()
    {
        $this->uid = md5($_SERVER['REMOTE_ADDR']);
            
        return true;
    } // End function Image_NetPBM

    /**
     * Load image
     *
     * @param string filename
     *
     * @return mixed none or a PEAR error object on error
     * @see PEAR::isError()
     */
    function load($image)
    {
        //echo $image;
        $this->image = $image;
        $this->_get_image_details($image);
    } // End load

    /**
     * Resizes the image
     *
     * @return none
     * @see PEAR::isError()
     */
    function _resize($new_x, $new_y)
    {
        // there's no technical reason why resize can't be called multiple
        // times...it's just silly to do so

        $this->command[] = IMAGE_TRANSFORM_LIB_PATH .
                           "pnmscale -width $new_x -height $new_y";

        $this->_set_new_x($new_x);
        $this->_set_new_y($new_y);
    } // End resize

    /**
     * Crop the image
     *
     * @param int $crop_x left column of the image
     * @param int $crop_y top row of the image
     * @param int $crop_width new cropped image width
     * @param int $crop_height new cropped image height
     */
    function crop($crop_x, $crop_y, $crop_width, $crop_height) 
    {
        $this->command[] = IMAGE_TRANSFORM_LIB_PATH .
                            "pnmcut -left $crop_x -top $crop_y -width $crop_width -height $crop_height";
    }

    /**
     * Rotates the image
     *
     * @param int $angle The angle to rotate the image through
     */
    function rotate($angle)
    {
        $angle = -1*floatval($angle);

        if($angle > 90)
        {   
            $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "pnmrotate -noantialias 90";
            $this->rotate(-1*($angle-90));
        }
        else if ($angle < -90)
        {
            $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "pnmrotate -noantialias -90";
            $this->rotate(-1*($angle+90));
        }
        else
            $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "pnmrotate -noantialias $angle";
    } // End rotate

    /**
     * Flip the image horizontally or vertically
     *
     * @param boolean $horizontal true if horizontal flip, vertical otherwise
     */
    function flip($horizontal) 
    {
        if($horizontal) 
            $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "pnmflip -lr";
        else
            $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "pnmflip -tb";
    }

    /**
     * Adjust the image gamma
     *
     * @param float $outputgamma
     *
     * @return none
     */
    function gamma($outputgamma = 1.0) {
        $this->command[13] = IMAGE_TRANSFORM_LIB_PATH . "pnmgamma $outputgamma";
    }

    /**
     * adds text to an image
     *
     * @param   array   options     Array contains options
     *             array(
     *                  'text'          // The string to draw
     *                  'x'             // Horizontal position
     *                  'y'             // Vertical Position
     *                  'Color'         // Font color
     *                  'font'          // Font to be used
     *                  'size'          // Size of the fonts in pixel
     *                  'resize_first'  // Tell if the image has to be resized
     *                                  // before drawing the text
     *                   )
     *
     * @return none
     */
    function addText($params)
    {
        $default_params = array('text' => 'This is Text',
                                'x' => 10,
                                'y' => 20,
                                'color' => 'red',
                                'font' => 'Arial.ttf',
                                'size' => '12',
                                'angle' => 0,
                                'resize_first' => false);
        // we ignore 'resize_first' since the more logical approach would be
        // for the user to just call $this->_resize() _first_ ;)
        extract(array_merge($default_params, $params));
        $this->command[] = "ppmlabel -angle $angle -colour $color -size "
                           ."$size -x $x -y ".$y+$size." -text \"$text\"";
    } // End addText

    function _postProcess($type, $quality, $save_type)
    {
        $type = is_null($type) || $type==''? $this->type : $type;
        $save_type = is_null($save_type) || $save_type==''? $this->type : $save_type;
        //echo "TYPE:". $this->type;
        array_unshift($this->command, IMAGE_TRANSFORM_LIB_PATH
                      . $type.'topnm '. $this->image);
        $arg = '';
        switch(strtolower($save_type)){
            case 'gif':
                $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "ppmquant 256";
                $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "ppmto$save_type";
                break;
            case 'jpg':
            case 'jpeg':
                $arg = "--quality=$quality";
                $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "ppmto$save_type $arg";
                break;
            default:
                $this->command[] = IMAGE_TRANSFORM_LIB_PATH . "pnmto$save_type $arg";
                break;
        } // switch
        return implode('|', $this->command);
    } 

    /**
     * Save the image file
     *
     * @param $filename string the name of the file to write to
     * @param string $type (jpeg,png...);
     * @param int $quality 75
     * @return none
     */
    function save($filename, $type=null, $quality = 85)
    {
        $cmd = $this->_postProcess('', $quality, $type) . ">$filename";
            
		//if we have windows server
        if(isset($_ENV['OS']) && eregi('@window@',$_ENV['OS']))
			$cmd = str_replace('/','\\',$cmd);
        //echo $cmd."##";
        $output = system($cmd);
		error_log('NETPBM: '.$cmd);
		//error_log($output);
        $this->command = array();
    } // End save


    /**
     * Display image without saving and lose changes
     *
     * @param string $type (jpeg,png...);
     * @param int $quality 75
     * @return none
     */
    function display($type = null, $quality = 75)
    {
        header('Content-type: image/' . $type);
        $cmd = $this->_postProcess($type, $quality);
        
        passthru($cmd);
        $this->command = array();
    }

    /**
     * Destroy image handle
     *
     * @return none
     */
    function free()
    {
        // there is no image handle here
        return true;
    }


} // End class NetPBM
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/package.xml</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/Thumbnail.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/Transform.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/***********************************************************************
** Title.........:  Image Transformation Interface
** Version.......:  1.0
** Author........:  Xiang Wei ZHUO <wei@zhuo.org>
** Filename......:  Transform.php
** Last changed..:  30 Aug 2003 
** Notes.........:  Orginal is from PEAR
                    
                    Added a few extra,
                        - create unique filename in a particular directory,
                          used for temp image files.
                        - added cropping to GD, NetPBM, ImageMagick
**/

// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2002 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Peter Bowyer <peter@mapledesign.co.uk>                      |
// |          Alan Knowles <alan@akbkhome.com>                            |
// |          Vincent Oostindie <vincent@sunlight.tmfweb.nl>              |
// +----------------------------------------------------------------------+
//
// $Id: Transform.php 7997 2012-05-28 15:14:38Z calguy1000 $
//
// Image Transformation interface
//


/**
 * The main "Image_Resize" class is a container and base class which
 * provides the static methods for creating Image objects as well as
 * some utility functions (maths) common to all parts of Image Resize.
 *
 * The object model of DB is as follows (indentation means inheritance):
 *
 * Image_Resize The base for each Image implementation.  Provides default
 * |            implementations (in OO lingo virtual methods) for
 * |            the actual Image implementations as well as a bunch of
 * |            maths methods.
 * |
 * +-Image_GD   The Image implementation for the PHP GD extension .  Inherits
 *              Image_Resize
 *              When calling DB::setup for GD images the object returned is an
 *              instance of this class.
 *
 * @package  Image Resize
 * @version  1.00
 * @author   Peter Bowyer <peter@mapledesign.co.uk>
 * @since    PHP 4.0
 */
Class Image_Transform
{
    /**
     * Name of the image file
     * @var string
     */
    var $image = '';
    /**
     * Type of the image file (eg. jpg, gif png ...)
     * @var string
     */
    var $type = '';
    /**
     * Original image width in x direction
     * @var int
     */
    var $img_x = '';
    /**
     * Original image width in y direction
     * @var int
     */
    var $img_y = '';
    /**
     * New image width in x direction
     * @var int
     */
    var $new_x = '';
    /**
     * New image width in y direction
     * @var int
     */
    var $new_y = '';
    /**
     * Path the the library used
     * e.g. /usr/local/ImageMagick/bin/ or
     * /usr/local/netpbm/
     */
    var $lib_path = '';
    /**
     * Flag to warn if image has been resized more than once before displaying
     * or saving.
     */
     var $resized = false;


     var $uid = '';

     var $lapse_time =900; //15 mins

    /**
     * Create a new Image_resize object
     *
     * @param string $driver name of driver class to initialize
     *
     * @return mixed a newly created Image_Transform object, or a PEAR
     * error object on error
     *
     * @see PEAR::isError()
     * @see Image_Transform::setOption()
     */
    public static function &factory($driver)
    {
        if ('' == $driver) {
            die("No image library specified... aborting.  You must call ::factory() with one parameter, the library to load.");

        }

        include_once (dirname(__FILE__)."/$driver.php");

        $classname = "Image_Transform_Driver_{$driver}";
        $obj = new $classname;
        $obj->uid = md5($_SERVER['REMOTE_ADDR']);
        return $obj;
    }


    /**
     * Resize the Image in the X and/or Y direction
     * If either is 0 it will be scaled proportionally
     *
     * @access public
     *
     * @param mixed $new_x (0, number, percentage 10% or 0.1)
     * @param mixed $new_y (0, number, percentage 10% or 0.1)
     *
     * @return mixed none or PEAR_error
     */
    function resize($new_x = 0, $new_y = 0)
    {
        // 0 means keep original size
        $new_x = (0 == $new_x) ? $this->img_x : $this->_parse_size($new_x, $this->img_x);
        $new_y = (0 == $new_y) ? $this->img_y : $this->_parse_size($new_y, $this->img_y);
        // Now do the library specific resizing.
        return $this->_resize($new_x, $new_y);
    } // End resize


    /**
     * Scale the image to have the max x dimension specified.
     *
     * @param int $new_x Size to scale X-dimension to
     * @return none
     */
    function scaleMaxX($new_x)
    {
        $new_y = round(($new_x / $this->img_x) * $this->img_y, 0);
        return $this->_resize($new_x, $new_y);
    } // End resizeX

    /**
     * Scale the image to have the max y dimension specified.
     *
     * @access public
     * @param int $new_y Size to scale Y-dimension to
     * @return none
     */
    function scaleMaxY($new_y)
    {
        $new_x = round(($new_y / $this->img_y) * $this->img_x, 0);
        return $this->_resize($new_x, $new_y);
    } // End resizeY

    /**
     * Scale Image to a maximum or percentage
     *
     * @access public
     * @param mixed (number, percentage 10% or 0.1)
     * @return mixed none or PEAR_error
     */
    function scale($size)
    {
        if ((strlen($size) > 1) && (substr($size,-1) == '%')) {
            return $this->scaleByPercentage(substr($size, 0, -1));
        } elseif ($size < 1) {
            return $this->scaleByFactor($size);
        } else {
            return $this->scaleByLength($size);
        }
    } // End scale

    /**
     * Scales an image to a percentage of its original size.  For example, if
     * my image was 640x480 and I called scaleByPercentage(10) then the image
     * would be resized to 64x48
     *
     * @access public
     * @param int $size Percentage of original size to scale to
     * @return none
     */
    function scaleByPercentage($size)
    {
        return $this->scaleByFactor($size / 100);
    } // End scaleByPercentage

    /**
     * Scales an image to a factor of its original size.  For example, if
     * my image was 640x480 and I called scaleByFactor(0.5) then the image
     * would be resized to 320x240.
     *
     * @access public
     * @param float $size Factor of original size to scale to
     * @return none
     */
    function scaleByFactor($size)
    {
        $new_x = round($size * $this->img_x, 0);
        $new_y = round($size * $this->img_y, 0);
        return $this->_resize($new_x, $new_y);
    } // End scaleByFactor

    /**
     * Scales an image so that the longest side has this dimension.
     *
     * @access public
     * @param int $size Max dimension in pixels
     * @return none
     */
    function scaleByLength($size)
    {
         if ($this->img_x >= $this->img_y) {
            $new_x = $size;
            $new_y = round(($new_x / $this->img_x) * $this->img_y, 0);
        } else {
            $new_y = $size;
            $new_x = round(($new_y / $this->img_y) * $this->img_x, 0);
        }
        return $this->_resize($new_x, $new_y);
    } // End scaleByLength


    /**
     *
     * @access public
     * @return void
     */
    function _get_image_details($image)
    {
        //echo $image;
        $data = @GetImageSize($image);
        #1 = GIF, 2 = JPG, 3 = PNG, 4 = SWF, 5 = PSD, 6 = BMP, 7 = TIFF(intel byte order), 8 = TIFF(motorola byte order,
        # 9 = JPC, 10 = JP2, 11 = JPX, 12 = JB2, 13 = SWC
        if (is_array($data)){
            switch($data[2]){
                case 1:
                    $type = 'gif';
                    break;
                case 2:
                    $type = 'jpeg';
                    break;
                case 3:
                    $type = 'png';
                    break;
                case 4:
                    $type = 'swf';
                    break;
                case 5:
                    $type = 'psd';
                case 6:
                    $type = 'bmp';
                case 7:
                case 8:
                    $type = 'tiff';
                default:
                    echo("We do not recognize this image format");
            }
            $this->img_x = $data[0];
            $this->img_y = $data[1];
            $this->type = $type;

            return true;
        } else {
            echo("Cannot fetch image or images details.");
            return null;
        }
        /*
        $output = array(
                        'width' => $data[0],
                        'height' => $data[1],
                        'type' => $type
                        );
        return $output;
        */
    }


    /**
     * Parse input and convert
     * If either is 0 it will be scaled proportionally
     *
     * @access private
     *
     * @param mixed $new_size (0, number, percentage 10% or 0.1)
     * @param int $old_size
     *
     * @return mixed none or PEAR_error
     */
    function _parse_size($new_size, $old_size)
    {
        if ('%' == $new_size) {
            $new_size = str_replace('%','',$new_size);
            $new_size = $new_size / 100;
        }
        if ($new_size > 1) {
            return (int) $new_size;
        } elseif ($new_size == 0) {
            return (int) $old_size;
        } else {
            return (int) round($new_size * $old_size, 0);
        }
    }


    function uniqueStr()
    {
      return substr(md5(microtime()),0,6);
    }

    //delete old tmp files, and allow only 1 file per remote host.
    function cleanUp($id, $dir)
    {
        $d = dir($dir);
        $id_length = strlen($id);

        while (false !== ($entry = $d->read())) {
            if (is_file($dir.'/'.$entry) && substr($entry,0,1) == '.' && !preg_match('@'.$entry.'@', $this->image))
            {
                //echo filemtime($this->directory.'/'.$entry)."<br>"; 
                //echo time();

                if (filemtime($dir.'/'.$entry) + $this->lapse_time < time())
                    unlink($dir.'/'.$entry);

                if (substr($entry, 1, $id_length) == $id)
                {
                    if (is_file($dir.'/'.$entry))
                        unlink($dir.'/'.$entry);
                }
            }
        }
        $d->close();
    }


    function createUnique($dir)
    {
       $unique_str = '.'.$this->uid.'_'.$this->uniqueStr().".".$this->type;
        
       //make sure the the unique temp file does not exists
        while (file_exists($dir.$unique_str))
        {
            $unique_str = '.'.$this->uid.'_'.$this->uniqueStr().".".$this->type;
        }
        
      $this->cleanUp($this->uid, $dir);

       return $unique_str;
    }


    /**
     * Set the image width
     * @param int $size dimension to set
     * @since 29/05/02 13:36:31
     * @return
     */
    function _set_img_x($size)
    {
        $this->img_x = $size;
    }

    /**
     * Set the image height
     * @param int $size dimension to set
     * @since 29/05/02 13:36:31
     * @return
     */
    function _set_img_y($size)
    {
        $this->img_y = $size;
    }

    /**
     * Set the image width
     * @param int $size dimension to set
     * @since 29/05/02 13:36:31
     * @return
     */
    function _set_new_x($size)
    {
        $this->new_x = $size;
    }

    /**
     * Set the image height
     * @param int $size dimension to set
     * @since 29/05/02 13:36:31
     * @return
     */
    function _set_new_y($size)
    {
        $this->new_y = $size;
    }

    /**
     * Get the type of the image being manipulated
     *
     * @return string $this->type the image type
     */
    function getImageType()
    {
        return $this->type;
    }

    /**
     *
     * @access public
     * @return string web-safe image type
     */
    function getWebSafeFormat()
    {
        switch($this->type){
            case 'gif':
	    	return 'gif';
		break;
            case 'png':
                return 'png';
                break;
            default:
                return 'jpeg';
        } // switch
    }

    /**
     * Place holder for the real resize method
     * used by extended methods to do the resizing
     *
     * @access private
     * @return PEAR_error
     */
    function _resize() {
        return null; //PEAR::raiseError("No Resize method exists", true);
    }

    /**
     * Place holder for the real load method
     * used by extended methods to do the resizing
     *
     * @access public
     * @return PEAR_error
     */
    function load($filename) {
        return null; //PEAR::raiseError("No Load method exists", true);
    }

    /**
     * Place holder for the real display method
     * used by extended methods to do the resizing
     *
     * @access public
     * @param string filename
     * @return PEAR_error
     */
    function display($type, $quality) {
        return null; //PEAR::raiseError("No Display method exists", true);
    }

    /**
     * Place holder for the real save method
     * used by extended methods to do the resizing
     *
     * @access public
     * @param string filename
     * @return PEAR_error
     */
    function save($filename, $type='', $quality=85) {
        return null; //PEAR::raiseError("No Save method exists", true);
    }

    /**
     * Place holder for the real free method
     * used by extended methods to do the resizing
     *
     * @access public
     * @return PEAR_error
     */
    function free() {
        return null; //PEAR::raiseError("No Free method exists", true);
    }

    /**
     * Reverse of rgb2colorname.
     *
     * @access public
     * @return PEAR_error
     *
     * @see rgb2colorname
     */
    function colorhex2colorarray($colorhex) {
        $r = hexdec(substr($colorhex, 1, 2));
        $g = hexdec(substr($colorhex, 3, 2));
        $b = hexdec(substr($colorhex, 4, 2));
        return array($r,$g,$b);
    }

    /**
     * Reverse of rgb2colorname.
     *
     * @access public
     * @return PEAR_error
     *
     * @see rgb2colorname
     */
    function colorarray2colorhex($color) {
        $color = '#'.dechex($color[0]).dechex($color[1]).dechex($color[2]);
        return strlen($color)>6?false:$color;
    }


    /* Methods to add to the driver classes in the future */
    function addText($params)
    {
        return null; //PEAR::raiseError("No addText method exists", true);
    }

    function addDropShadow()
    {
        return null; //PEAR::raiseError("No AddDropShadow method exists", true);
    }

    function addBorder()
    {
        return null; //PEAR::raiseError("No addBorder method exists", true);
    }

    function crop($new_x, $new_y, $new_width, $new_height)
    {
        return null; //PEAR::raiseError("No crop method exists", true);
    }

    function flip($horizontal) 
    {
        return null;
    }

    function gamma()
    {
        return null; //PEAR::raiseError("No gamma method exists", true);
    }
}
?>
]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

/* vim: set expandtab tabstop=4 shiftwidth=4: */

/**
 * Simple and cross-library package to doing image transformations and
 * manipulations.
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category  Image
 * @package   Image_Transform
 * @author    Vincent Oostindie <vincent@sunlight.tmfweb.nl>
 * @author    Alan Knowles <alan@akbkhome.com>
 * @author    Peter Bowyer <peter@mapledesign.co.uk>
 * @author    Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright 2002-2007 The PHP Group
 * @license   http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version   CVS: $Id: Transform.php 322659 2012-01-24 11:56:22Z clockwerx $
 * @link      http://pear.php.net/package/Image_Transform
 */

/**
 * Include for error handling
 */
//require_once 'PEAR.php';

/**
 * Error code for unsupported library, image format or methods
 */
define('IMAGE_TRANSFORM_ERROR_UNSUPPORTED', 1);

/**
 * Error code for failed transformation operations
 */
define('IMAGE_TRANSFORM_ERROR_FAILED', 2);

/**
 * Error code for failed i/o (Input/Output) operations
 */
define('IMAGE_TRANSFORM_ERROR_IO', 3);

/**
 * Error code for invalid arguments
 */
define('IMAGE_TRANSFORM_ERROR_ARGUMENT', 4);

/**
 * Error code for out-of-bound related errors
 */
define('IMAGE_TRANSFORM_ERROR_OUTOFBOUND', 5);

/**
 * Error code for inexsitant driver errors
 */
define('IMAGE_TRANSFORM_DRIVER_FILE_MISSING', 6);

/**
 * Base class with factory method for backend driver
 *
 * The main "Image_Transform" class is a container and base class which
 * provides a static method for creating an Image object as well as
 * some utility functions (maths) common to all parts of Image_Transform.
 *
 * @category  Image
 * @package   Image_Transform
 * @author    Alan Knowles <alan@akbkhome.com>
 * @author    Peter Bowyer <peter@mapledesign.co.uk>
 * @author    Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright 2002-2007 The PHP Group
 * @license   http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version   Release: @package_version@
 * @link      http://pear.php.net/package/Image_Transform
 * @since     PHP 4.0
 */
class Image_Transform
{
    /**
     * Name of the image file
     * @var string
     */
    var $image = '';

    /**
     * Type of the image file (eg. jpg, gif png ...)
     * @var string
     */
    var $type = '';

    /**
     * Original image width in x direction
     * @var int
     */
    var $img_x = '';

    /**
     * Original image width in y direction
     * @var int
     */
    var $img_y = '';

    /**
     * New image width in x direction
     * @var int
     */
    var $new_x = '';

    /**
     * New image width in y direction
     * @var int
     */
    var $new_y = '';

    /**
     * Path to the library used
     * e.g. /usr/local/ImageMagick/bin/ or
     * /usr/local/netpbm/
     */
    var $lib_path = '';

    /**
     * Flag to warn if image has been resized more than once before displaying
     * or saving.
     */
    var $resized = false;

    /**
     * @var array General options
     * @access protected
     */
    var $_options = array(
        'quality'     => 75,
        'scaleMethod' => 'smooth',
        'canvasColor' => array(255, 255, 255),
        'pencilColor' => array(0, 0, 0),
        'textColor'   => array(0, 0, 0)
        );

    /**
     * Flag for whether settings should be discarded on saving/display of image
     * @var bool
     * @see Image_Transform::keepSettingsOnSave
     */
    var $keep_settings_on_save = false;

    /**
     * Supported image types
     * @var array
     * @access protected
     */
    var $_supported_image_types = array();

    /**
     * Initialization error tracking
     * @var object
     * @access private
     **/
    var $_error = null;

    /**
     * associative array that tracks existence of programs
     * (for drivers using shell interface and a tiny performance
     * improvement if the clearstatcache() is used)
     * @var array
     * @access protected
     */
    var $_programs = array();

     /**
      * Default parameters used in the addText methods.
      */
    var $default_text_params = array(
        'text' => 'Default text',
        'x'     => 10,
        'y'     => 20,
        'color' => 'red',
        'font'  => 'Arial.ttf',
        'size'  => 12,
        'angle' => 0,
        'resize_first' => false
    );

    /**
     * Creates a new Image_Transform object
     *
     * @param string $driver name of driver class to initialize. If no driver
     *               is specified the factory will attempt to use 'Imagick' first
     *               then 'GD' second, then 'Imlib' last
     *
     * @return object an Image_Transform object, or PEAR_Error on error
     *
     * @see PEAR::isError()
     * @see Image_Transform::setOption()
     */
    public static function &factory($driver)
    {
        if ('' == $driver) {
            die("No image library specified... aborting.  You must call ::factory() with one parameter, the library to load.");

        }

        include_once (dirname(__FILE__)."/Transform/$driver.php");

        $classname = "Image_Transform_Driver_{$driver}";
        $obj = new $classname;
        $obj->uid = md5($_SERVER['REMOTE_ADDR']);
        return $obj;
    }

    /**
     * Returns/sets an error when the instance couldn't initialize properly
     *
     * @param object $error PEAR_Error object when setting an error
     *
     * @return mixed FALSE or PEAR_Error object
     * @access protected
     */
    function &isError($error = null)
    {
        if (!is_null($error)) {
            $this->_error =& $error;
        }
        return $this->_error;
    }

    /**
     * Resizes the image in the X and/or Y direction(s)
     *
     * If either is 0 it will keep the original size for that dimension
     *
     * @param mixed $new_x   (0, number, percentage 10% or 0.1)
     * @param mixed $new_y   (0, number, percentage 10% or 0.1)
     * @param array $options Options
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    function resize($new_x = 0, $new_y = 0, $options = null)
    {
        // 0 means keep original size
        $new_x = (0 == $new_x)
                 ? $this->img_x
                 : $this->_parse_size($new_x, $this->img_x);
        $new_y = (0 == $new_y)
                 ? $this->img_y
                 : $this->_parse_size($new_y, $this->img_y);

        // Now do the library specific resizing.
        return $this->_resize($new_x, $new_y, $options);
    } // End resize

    /**
     * Scales the image to the specified width
     *
     * This method preserves the aspect ratio
     *
     * @param int $new_x Size to scale X-dimension to
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    function scaleByX($new_x)
    {
        if ($new_x <= 0) {
            return PEAR::raiseError('New size must be strictly positive',
                                        IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        $new_y = round(($new_x / $this->img_x) * $this->img_y, 0);
        return $this->_resize(max(1, $new_x), max(1, $new_y));
    } // End scaleByX

    /**
     * Alias for resize()
     *
     * @see resize()
     */
    function scaleByXY($new_x = 0, $new_y = 0, $options = null)
    {
        return $this->resize($new_x, $new_y, $options);
    } // End scaleByXY

    /**
     * Scales the image to the specified height.
     *
     * This method preserves the aspect ratio
     *
     * @param int $new_y Size to scale Y-dimension to
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    function scaleByY($new_y)
    {
        if ($new_y <= 0) {
            return PEAR::raiseError('New size must be strictly positive',
                                        IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        $new_x = round(($new_y / $this->img_y) * $this->img_x, 0);
        return $this->_resize(max(1, $new_x), max(1, $new_y));
    } // End scaleByY

    /**
     * Scales an image by a percentage, factor or a given length
     *
     * This method preserves the aspect ratio
     *
     * @param mixed $size (number, percentage 10% or 0.1)
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     * @see scaleByPercentage, scaleByFactor, scaleByLength
     */
    function scale($size)
    {
        if ((strlen($size) > 1) && (substr($size, -1) == '%')) {
            return $this->scaleByPercentage(substr($size, 0, -1));
        } elseif ($size < 1) {
            return $this->scaleByFactor($size);
        } else {
            return $this->scaleByLength($size);
        }
    } // End scale

    /**
     * Scales an image to a percentage of its original size.  For example, if
     * my image was 640x480 and I called scaleByPercentage(10) then the image
     * would be resized to 64x48
     *
     * @param int $size Percentage of original size to scale to
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    function scaleByPercentage($size)
    {
        return $this->scaleByFactor($size / 100);
    } // End scaleByPercentage

    /**
     * Scales an image to a factor of its original size.  For example, if
     * my image was 640x480 and I called scaleByFactor(0.5) then the image
     * would be resized to 320x240.
     *
     * @param float $size Factor of original size to scale to
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    function scaleByFactor($size)
    {
        if ($size <= 0) {
            return PEAR::raiseError('New size must be strictly positive',
                                        IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        $new_x = round($size * $this->img_x, 0);
        $new_y = round($size * $this->img_y, 0);
        return $this->_resize(max(1, $new_x), max(1, $new_y));
    } // End scaleByFactor

    /**
     * Scales an image so that the longest side has the specified dimension.
     *
     * This method preserves the aspect ratio
     *
     * @param int $size Max dimension in pixels
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     */
    function scaleMaxLength($size)
    {
        if ($size <= 0) {
            return PEAR::raiseError('New size must be strictly positive',
                                        IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        if ($this->img_x >= $this->img_y) {
            $new_x = $size;
            $new_y = round(($new_x / $this->img_x) * $this->img_y, 0);
        } else {
            $new_y = $size;
            $new_x = round(($new_y / $this->img_y) * $this->img_x, 0);
        }
        return $this->_resize(max(1, $new_x), max(1, $new_y));
    } // End scaleMaxLength

    /**
     * Alias for scaleMaxLength
     *
     * @param int $size Max dimension in pixels
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     * @see scaleMaxLength()
     */
    function scaleByLength($size)
    {
        return $this->scaleMaxLength($size);
    }

    /**
     * Fits the image in the specified box size
     *
     * If the image is bigger than the box specified by $width and $height,
     * it will be scaled down to fit inside of it.
     * If the image is smaller, nothing is done.
     *
     * @param integer $width  Width of the box in pixels
     * @param integer $height Height of the box in pixels
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access public
     */
    function fit($width, $height)
    {
        if ($width <= 0 || $height <= 0) {
            return PEAR::raiseError("Invalid arguments.",
                IMAGE_TRANSFORM_ERROR_ARGUMENT);
        }
        $x = $this->img_x / $width;
        $y = $this->img_y / $height;
        if ($x <= 1 && $y <= 1) {
            return true;
        } elseif ($x > $y) {
            return $this->scaleByX($width);
        } else {
            return $this->scaleByY($height);
        }
    }

    /**
     * This works as per fit, but creates the canvas of size $width x $height
     * and positions the resized image on it, by default in the centre.
     *
     * @param unknown_type $width
     * @param unknown_type $height
     * @param unknown_type $posn
     *
     * @return unknown
     */
    function fitOnCanvas($width, $height, $posn='center')
    {
        return PEAR::raiseError('fitOnCanvas() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Fits the image in the specified width
     *
     * If the image is wider than the width specified by $width,
     * it will be scaled down to fit inside of it.
     * If the image is smaller, nothing is done.
     *
     * @param integer $width Maximum width in pixels
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access public
     */
    function fitX($width)
    {
        return ($this->img_x <= $width) ? true : $this->scaleByX($width);
    }

    /**
     * Fits the image in the specified height
     *
     * If the image is taller than the height specified by $height,
     * it will be scaled down to fit inside of it.
     * If the image is smaller, nothing is done.
     *
     * @param integer $height Maximum height in pixels
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access public
     */
    function fitY($height)
    {
        return ($this->img_y <= $height) ? true : $this->scaleByY($height);
    }

    /**
     * Sets one options
     *
     * @param string $name  Name of option
     * @param mixed  $value Value of option
     *
     * @return void
     * @access public
     * @see setOptions()
     */
    function setOption($name, $value)
    {
        $this->_options[$name] = $value;
    }

    /**
     * Sets multiple options at once
     *
     * Associative array of options:
     *  - quality     (Integer: 0: poor - 100: best)
     *  - scaleMethod ('smooth', 'pixel')
     *
     * @param array $options Array of options
     *
     * @return void
     * @access public
     */
    function setOptions($options)
    {
        $this->_options = array_merge($this->_options, $options);
    }

    /**
     * Sets the image type (in lowercase letters), the image height and width.
     *
     * @param string $image Image filename
     *
     * @return mixed TRUE or PEAR_error
     * @access protected
     * @see PHP_Compat::image_type_to_mime_type()
     * @link http://php.net/getimagesize
     */
    function _get_image_details($image)
    {
        $data = @getimagesize($image);
        //  1 = GIF,   2 = JPG,  3 = PNG,  4 = SWF,  5 = PSD,  6 = BMP,
        //  7 = TIFF (intel byte order),   8 = TIFF (motorola byte order),
        //  9 = JPC,  10 = JP2, 11 = JPX, 12 = JB2, 13 = SWC, 14 = IFF,
        // 15 = WBMP, 16 = XBM
        if (!is_array($data)) {
            return PEAR::raiseError("Cannot fetch image or images details.", true);
        }

        switch ($data[2]) {
            case IMAGETYPE_GIF:
                $type = 'gif';
                break;
            case IMAGETYPE_JPEG:
                $type = 'jpeg';
                break;
            case IMAGETYPE_PNG:
                $type = 'png';
                break;
            case IMAGETYPE_SWF:
                $type = 'swf';
                break;
            case IMAGETYPE_PSD:
                $type = 'psd';
                break;
            case IMAGETYPE_BMP:
                $type = 'bmp';
                break;
            case IMAGETYPE_TIFF_II:
            case IMAGETYPE_TIFF_MM:
                $type = 'tiff';
                break;
            case IMAGETYPE_JPC:
                $type = 'jpc';
                break;
            case IMAGETYPE_JP2:
                $type = 'jp2';
                break;
            case IMAGETYPE_JPX:
                $type = 'jpx';
                break;
            case IMAGETYPE_JB2:
                $type = 'jb2';
                break;
            case IMAGETYPE_SWC:
                $type = 'swc';
                break;
            case IMAGETYPE_IFF:
                $type = 'iff';
                break;
            case IMAGETYPE_WBMP:
                $type = 'wbmp';
                break;
            case IMAGETYPE_XBM:
                $type = 'xbm';
                break;
            default:
                return PEAR::raiseError("Cannot recognize image format",
                    IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }
        $this->img_x = $this->new_x = $data[0];
        $this->img_y = $this->new_y = $data[1];
        $this->type  = $type;

        return true;
    }

    /**
     * Returns the matching IMAGETYPE_* constant for a given image type
     *
     * @param mixed $type String (GIF, JPG,...)
     *
     * @return mixed string or integer or input on error
     * @access protected
     * @see PHP_Compat::image_type_to_mime_type()
     **/
    function _convert_image_type($type)
    {
        switch (strtolower($type)) {
            case 'gif':
                return IMAGETYPE_GIF;
            case 'jpeg':
            case 'jpg':
                return IMAGETYPE_JPEG;
            case 'png':
                return IMAGETYPE_PNG;
            case 'swf':
                return IMAGETYPE_SWF;
            case 'psd':
                return IMAGETYPE_PSD;
            case 'bmp':
                return IMAGETYPE_BMP;
            case 'tiff':
                return IMAGETYPE_TIFF_II;
                //IMAGETYPE_TIFF_MM;
            case 'jpc':
                return IMAGETYPE_JPC;
            case 'jp2':
                return IMAGETYPE_JP2;
            case 'jpx':
                return IMAGETYPE_JPX;
            case 'jb2':
                return IMAGETYPE_JB2;
            case 'swc':
                return IMAGETYPE_SWC;
            case 'iff':
                return IMAGETYPE_IFF;
            case 'wbmp':
                return IMAGETYPE_WBMP;
            case 'xbm':
                return IMAGETYPE_XBM;
            default:
                return $type;
        }

        return (isset($types[$t = strtolower($type)])) ? $types[$t] : $type;
    }

    /**
     * Parses input for number format and convert
     *
     * If either parameter is 0 it will be scaled proportionally
     *
     * @param mixed $new_size (0, number, percentage 10% or 0.1)
     * @param int   $old_size
     *
     * @return mixed Integer or PEAR_error
     * @access protected
     */
    function _parse_size($new_size, $old_size)
    {
        if (substr($new_size, -1) == '%') {
            $new_size = substr($new_size, 0, -1);
            $new_size = $new_size / 100;
        }
        if ($new_size > 1) {
            return (int) $new_size;
        } elseif ($new_size == 0) {
            return (int) $old_size;
        } else {
            return (int) round($new_size * $old_size, 0);
        }
    }

    /**
     * Returns an angle between 0 and 360 from any angle value
     *
     * @param float $angle The angle to normalize
     *
     * @return float the angle
     * @access protected
     */
    function _rotation_angle($angle)
    {
        $angle %= 360;
        return ($angle < 0) ? $angle + 360 : $angle;
    }

    /**
     * Returns the current value of $this->default_text_params.
     *
     * @return array $this->default_text_params The current text parameters
     * @access protected
     */
    function _get_default_text_params()
    {
        return $this->default_text_params;
    }

    /**
     * Sets the image width
     *
     * @param int $size dimension to set
     *
     * @return void
     * @access protected
     * @since 29/05/02 13:36:31
     */
    function _set_img_x($size)
    {
        $this->img_x = $size;
    }

    /**
     * Sets the image height
     *
     * @param int $size dimension to set
     *
     * @return void
     * @access protected
     * @since 29/05/02 13:36:31
     */
    function _set_img_y($size)
    {
        $this->img_y = $size;
    }

    /**
     * Sets the new image width
     *
     * @param int $size dimension to set
     *
     * @return void
     * @access protected
     * @since 29/05/02 13:36:31
     */
    function _set_new_x($size)
    {
        $this->new_x = $size;
    }

    /**
     * Sets the new image height
     *
     * @param int $size dimension to set
     *
     * @return void
     * @since 29/05/02 13:36:31
     * @access protected
     */
    function _set_new_y($size)
    {
        $this->new_y = $size;
    }

    /**
     * Returns the image handle so that one can further try
     * to manipulate the image
     *
     * @return resource
     *
     * @access public
     */
    function getHandle()
    {
        return PEAR::raiseError('getHandle() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }//function getHandle()

    /**
     * Returns the type of the image being manipulated
     *
     * @return string the image type
     * @access public
     */
    function getImageType()
    {
        return $this->type;
    }

    /**
     * Returns the MIME type of the image being manipulated
     *
     * @param string $type Image type to get MIME type for
     *
     * @return string The MIME type if available, or an empty string
     * @access public
     * @see PHP_Compat::image_type_to_mime_type()
     * @link http://php.net/image_type_to_mime_type
     */
    function getMimeType($type = null)
    {
        return image_type_to_mime_type($this->_convert_image_type(($type) ? $type : $this->type));
    }

    /**
     * Returns the new image width
     *
     * This function returns the width
     * of the new image.
     *
     * @access public
     * @return int  The width of the new image.
     */
    function getNewImageWidth()
    {
        if (isset($this->new_x)) {
            return (int)$this->new_x;
        }

        return false;
    }

    /**
     * Return new image Y
     *
     * This function will retrieve the
     * new image 'Y' and return it's value
     * if it's set.
     *
     * @access public
     * @return int  The new height of the image.
     */
    function getNewImageHeight()
    {
        if (isset($this->new_y)) {
            return (int)$this->new_y;
        }

        return false;
    }

    /**
     * Returns the image width
     *
     * @return int the width of the image
     * @access public
     */
    function getImageWidth()
    {
        return $this->img_x;
    }

    /**
      * Returns the image height
      *
      * @return int the width of the image
      * @access public
      */
    function getImageHeight()
    {
        return $this->img_y;
    }

    /**
     * Returns the image size and extra format information
     *
     * @return array The width and height of the image
     * @access public
     * @see PHP::getimagesize()
     */
    function getImageSize()
    {
        return array(
            $this->img_x,
            $this->img_y,
            $this->_convert_image_type($this->type),
            'height="' . $this->img_y . '" width="' . $this->img_x . '"',
            'mime' => $this->getMimeType());
    }

    /**
     * This looks at the current image type and attempts to determine which
     * web-safe format will be most suited.  It does not work brilliantly with
     * *.png images, because it is very difficult to know whether they are
     * 8-bit or greater.  Guess I need to have fatter code here :-)
     *
     * @return string web-safe image type
     * @access public
     */
    function getWebSafeFormat()
    {
        switch ($this->type){
            case 'gif':
            case 'png':
                return 'png';
                break;
            default:
                return 'jpeg';
        } // switch
    }

    /**
     * Handles space in path and Windows/UNIX difference
     *
     * @param string $path    Base dir
     * @param string $command Command to execute
     * @param string $args    Arguments to pass to the command
     *
     * @return string A prepared string suitable for exec()
     * @access protected
     */
    function _prepare_cmd($path, $command, $args = '')
    {
        if (!OS_WINDOWS
            || !preg_match('/\s/', $path)) {
            return $path . $command . ' ' . $args;
        }
        return 'start /D "' . $path . '" /B ' . $command . ' ' . $args;
    }

    /**
     * Place holder for the real resize method
     * used by extended methods to do the resizing
     *
     * @return PEAR_error
     * @access protected
     */
    function _resize()
    {
        return PEAR::raiseError('Resize method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Normalizes the colors, gamma and other properties of an image
     * (this should give a result equivalent to a Photoshop autolevels)
     *
     * @return PEAR_error
     * @access public
     */
    function normalize()
    {
        return PEAR::raiseError('Normalize method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Loads an image file to work with
     *
     * Place holder for the real load method
     * used by extended methods to do the resizing
     *
     * @param string $filename Full name of file
     *
     * @return PEAR_error
     * @access public
     */
    function load($filename)
    {
        return PEAR::raiseError('load() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Outputs the image to standard output
     *
     * Place holder for the real display method
     * used by extended methods to do the resizing
     *
     * @param string $type    Format of image to save as
     * @param mixed  $quality Format-dependent
     *
     * @return PEAR_error
     * @access public
     */
    function display($type, $quality = null)
    {
        return PEAR::raiseError('display() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Returns if the driver supports a given image type
     *
     * @param string $type Image type (GIF, PNG, JPEG...)
     * @param string $mode 'r' for read, 'w' for write, 'rw' for both
     *
     * @return TRUE if type (and mode) is supported FALSE otherwise
     * @access public
     */
    function supportsType($type, $mode = 'rw')
    {
        return (strpos(@$this->_supported_image_types[strtolower($type)], $mode) === false) ? false : true;
    }

    /**
     * Saves image to file
     *
     * Place holder for the real save method
     * used by extended methods to do the resizing
     *
     * @param string $filename Filename to save image to
     * @param string $type     Format of image to save as
     * @param mixed  $quality  Format-dependent
     *
     * @return PEAR_error
     * @access public
     */
    function save($filename, $type, $quality = null)
    {
        return PEAR::raiseError('save() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Releases resource
     *
     * Place holder for the real free method
     * used by extended methods to do the resizing
     *
     * @return PEAR_error
     * @access public
     */
    function free()
    {
        return PEAR::raiseError('free() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Converts a color string into an array of RGB values
     *
     * @param string $colorhex A color following the #FFFFFF format
     *
     * @return array 3-element array with 0-255 values
     * @access public
     *
     * @see rgb2colorname
     * @see colorarray2colorhex
     */
    function colorhex2colorarray($colorhex)
    {
        $r = hexdec(substr($colorhex, 1, 2));
        $g = hexdec(substr($colorhex, 3, 2));
        $b = hexdec(substr($colorhex, 5, 2));
        return array($r, $g, $b, 'type' => 'RGB');
    }

    function _send_display_headers($type)
    {
        // Find the filename of the original image:
        $filename = explode('.', basename($this->image));
        $filename = $filename[0];
        header('Content-type: ' . $this->getMimeType($type));
        header('Content-Disposition: inline; filename=' . $filename . '.' . $type);
    }

    /**
     * Converts an array of RGB value into a #FFFFFF format color.
     *
     * @param array $color 3-element array with 0-255 values
     *
     * @return mixed A color following the #FFFFFF format or FALSE
     *               if the array couldn't be converted
     * @access public
     *
     * @see rgb2colorname
     * @see colorhex2colorarray
     */
    function colorarray2colorhex($color)
    {
        if (!is_array($color)) {
            return false;
        }
        $color = sprintf('#%02X%02X%02X', @$color[0], @$color[1], @$color[2]);
        return (strlen($color) != 7) ? false : $color;
    }

    /**
     * Returns the temp directory according to either the TMP, TMPDIR, or TEMP env
     * variables. If these are not set it will also check for the existence of
     * /tmp, %WINDIR%\temp
     *
     * @access public
     * @return string The system tmp directory
     */
    function getTempDir()
    {
        include_once 'System.php';
        return System::tmpdir();
    }

    /**
     * Returns a temporary filename using tempnam() and the above getTmpDir() function.
     *
     * @param string $dirname Optional directory name for the tmp file
     *
     * @return string Filename and path of the tmp file
     * @access public
     */
    function getTempFile($dirname = null)
    {
        if (is_null($dirname)) {
            include_once 'System.php';
            $dirname = System::tmpdir();
        }

        return tempnam($dirname, 'temp.');
    }

    function keepSettingsOnSave($bool)
    {
        $this->keep_settings_on_save = $bool;
    }

    /**
     * Methods to add to the driver classes in the future
     *
     * @return void
     */
    function addText()
    {
        return PEAR::raiseError('addText() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    function addDropShadow()
    {
        return PEAR::raiseError('addDropShadow() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    function addBorder()
    {
        return PEAR::raiseError('addBorder() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Crops an image
     *
     * @param int $width  Cropped image width
     * @param int $height Cropped image height
     * @param int $x      X-coordinate to crop at
     * @param int $y      Y-coordinate to crop at
     *
     * @return mixed TRUE or a PEAR_Error object on error
     * @access public
     **/
    function crop($width, $height, $x = 0, $y = 0)
    {
        return PEAR::raiseError('crop() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    function canvasResize()
    {
        return PEAR::raiseError('canvasResize() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Corrects the gamma of an image
     *
     * @param float $outputgamma Gamma correction factor
     *
     * @return mixed TRUE or a PEAR_error object on error
     * @access public
     **/
    function gamma($outputgamma = 1.0)
    {
        return PEAR::raiseError('gamma() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Rotates the image clockwise
     *
     * @param float $angle   Angle of rotation in degres
     * @param mixed $options Rotation options
     *
     * @return bool|PEAR_Error TRUE on success, PEAR_Error object on error
     * @access public
     */
    function rotate($angle, $options = null)
    {
        return PEAR::raiseError('rotate() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Horizontal mirroring
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     * @see flip()
     **/
    function mirror()
    {
        return PEAR::raiseError('mirror() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Vertical mirroring
     *
     * @return TRUE or PEAR Error object on error
     * @access public
     * @see mirror()
     **/
    function flip()
    {
        return PEAR::raiseError('flip() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Converts an image into greyscale colors
     *
     * @return mixed TRUE or a PEAR error object on error
     * @access public
     **/
    function greyscale()
    {
        return PEAR::raiseError('greyscale() method not supported by driver',
            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
    }

    /**
     * Converts an image into greyscale colors
     *
     * @return mixed TRUE or a PEAR error object on error
     * @see greyscale()
     **/
    function grayscale()
    {
        return $this->greyscale();
    }

    /**
     * Returns a color option
     *
     * @param string $colorOf one of 'canvasColor', 'pencilColor', 'fontColor'
     * @param array  $options configuration options
     * @param array  $default default value to return if color not found
     *
     * @return array an RGB color array
     * @access protected
     */
    function _getColor($colorOf, $options = array(), $default = array(0, 0, 0))
    {
        $opt = array_merge($this->_options, (array) $options);
        if (isset($opt[$colorOf])) {
            $color = $opt[$colorOf];
            if (is_array($color)) {
                return $color;
            }
            if ($color{0} == '#') {
                return $this->colorhex2colorarray($color);
            }
            static $colornames = array();
            include_once 'Image/Transform/Driver/ColorsDefs.php';
            return (isset($colornames[$color])) ? $colornames[$color] : $default;
        }
        return $default;
    }

    /**
     * Returns an option
     *
     * @param string $name    name of option
     * @param array  $options local override option array
     * @param mixed  $default default value to return if option is not found
     *
     * @return mixed the option
     * @access protected
     */
    function _getOption($name, $options = array(), $default = null)
    {
        $opt = array_merge($this->_options, (array) $options);
        return (isset($opt[$name])) ? $opt[$name] : $default;
    }

    /**
     * Checks if the rectangle passed intersects with the current image
     *
     * @param int $width  Width of rectangle
     * @param int $height Height of rectangle
     * @param int $x      X-coordinate
     * @param int $y      Y-coordinate
     *
     * @return bool|PEAR_Error TRUE if intersects, FALSE if not,
     *                         and PEAR_Error on error
     * @access public
     */
    function intersects($width, $height, $x, $y)
    {
        $left  = $x;
        $right = $x + $width;
        if ($right < $left) {
            $left  = $right;
            $right = $x;
        }
        $top    = $y;
        $bottom = $y + $height;
        if ($bottom < $top) {
            $top    = $bottom;
            $bottom = $y;
        }
        return (bool) ($left < $this->new_x
                       && $right >= 0
                       && $top < $this->new_y
                       && $bottom >= 0);
    }
}
]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/Cairowrapper.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* vim: set expandtab tabstop=4 shiftwidth=4: */

/**
 * Cairo implementation for Image_Transform package
 *
 * PHP versions 4 and 5
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_Cairowrapper
 * @author     Christian Weiske <cweiske@php.net>
 * @copyright  2008 The PHP Group
 * @license    http://www.gnu.org/copyleft/lesser.html LGPL
 * @version    CVS: $Id: Cairowrapper.php 288112 2009-09-06 21:02:37Z cweiske $
 * @link       http://pear.php.net/package/Image_Transform
 */
require_once 'Image/Transform.php';

/**
 * Cairo implementation for Image_Transform package using pecl's cairo_wrapper
 * extension.
 *
 * Supports png files only.
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_Cairowrapper
 * @author     Christian Weiske <cweiske@php.net>
 * @copyright  2008 The PHP Group
 * @license    http://www.gnu.org/copyleft/lesser.html LGPL
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/Image_Transform
 */
class Image_Transform_Driver_Cairowrapper extends Image_Transform
{
    var $surface = null;

    /**
     * Supported image types
     *
     * @var    array
     * @access protected
     */
    var $_supported_image_types = array(
        'png' => 'rw'
    );

    /**
     * Check settings
     */
    function Image_Transform_Driver_Cairowrapper()
    {
        $this->__construct();
    }



    /**
     * Create object and check if cairo_wrapper is loaded
     */
    function __construct()
    {
        if (!PEAR::loadExtension('cairo_wrapper')) {
            $this->isError(
                PEAR::raiseError(
                    'cairo_wrapper extension is not available.',
                    IMAGE_TRANSFORM_ERROR_UNSUPPORTED
                )
            );
        }
    }



    /**
     * Loads an image from file
     *
     * @param string $image filename
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     *
     * @access public
     */
    function load($image)
    {
        $this->free();

        $this->image = $image;
        $result = $this->_get_image_details($image);
        if (PEAR::isError($result)) {
            return $result;
        }
        if (!$this->supportsType($this->type, 'r')) {
            return PEAR::raiseError('Image type not supported for input',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }

        $this->surface = cairo_image_surface_create_from_png($this->image);
        if (cairo_surface_status($this->surface) != CAIRO_STATUS_SUCCESS) {
            $this->surface = null;
            return PEAR::raiseError('Error while loading image file.',
                IMAGE_TRANSFORM_ERROR_IO);
        }

        return true;
    }//function load(..)



    /**
     * Resize the image
     *
     * @param int   $new_x   New width
     * @param int   $new_y   New height
     * @param array $options Optional parameters
     *
     * @return bool|PEAR_Error TRUE on success or PEAR_Error object on error
     *
     * @access protected
     */
    function _resize($new_x, $new_y, $options = null)
    {
        if ($this->resized === true) {
            return PEAR::raiseError(
                'You have already resized the image without saving it.'
                . ' Your previous resizing will be overwritten',
                null, PEAR_ERROR_TRIGGER, E_USER_NOTICE
            );
        }

        if ($this->new_x == $new_x && $this->new_y == $new_y) {
            return true;
        }

        $xFactor = $new_x / $this->img_x;
        $yFactor = $new_y / $this->img_y;

        $outputSurface = cairo_image_surface_create(
            CAIRO_FORMAT_ARGB32, $new_x, $new_y
        );
        $outputContext = cairo_create($outputSurface);

        cairo_scale($outputContext, $xFactor, $yFactor);

        cairo_set_source_surface($outputContext, $this->surface, 0, 0);
        cairo_paint($outputContext);

        cairo_destroy($outputContext);

        cairo_surface_destroy($this->surface);

        $this->surface = $outputSurface;

        $this->new_x = $new_x;
        $this->new_y = $new_y;
        return true;
    }//function _resize(..)



    /**
     * Saves the scaled image into a file.
     *
     * @param string $filename The filename to save to
     * @param mixed  $type     ignored
     * @param mixed  $quality  ignored
     *
     * @return bool|PEAR_Error TRUE on success or PEAR_Error object on error
     *
     * @access public
     */
    function save($filename, $type = null, $quality = null)
    {
        cairo_surface_write_to_png($this->surface, $filename);
        $this->free();
        return true;
    }//function save(..)



    /**
     * Returns the surface of the image so it can be modified further
     *
     * @return resource
     *
     * @access public
     */
    function getHandle()
    {
        return $this->surface;
    }//function getHandle()



    /**
     * Frees cairo handles
     *
     * @return void
     *
     * @access public
     */
    function free()
    {
        $this->resized = false;
        if (is_resource($this->surface)) {
            cairo_surface_destroy($this->surface);
        }
        $this->surface = null;
    }//function free()



    /**
     * Mirrors the image vertically
     * Uses an affine transformation matrix to flip the image.
     *
     * @return void
     */
    function flip()
    {
        $outputSurface = cairo_image_surface_create(
            CAIRO_FORMAT_ARGB32, $this->img_x, $this->img_y
        );
        $outputContext = cairo_create($outputSurface);
        //                            xx, yx, xy, yy, x0, y0
        $matrix = cairo_matrix_create(1,  0,  0,  -1,  0, $this->img_y);

        cairo_set_matrix($outputContext, $matrix);
        cairo_set_source_surface($outputContext, $this->surface, 0, 0);
        cairo_paint($outputContext);

        cairo_destroy($outputContext);
        cairo_surface_destroy($this->surface);

        $this->surface = $outputSurface;
    }//function flip()



    /**
     * Mirrors the image horizontally.
     * Uses an affine transformation matrix to mirror the image.
     *
     * 123 -> 321
     *
     * @return void
     */
    function mirror()
    {
        $outputSurface = cairo_image_surface_create(
            CAIRO_FORMAT_ARGB32, $this->img_x, $this->img_y
        );
        $outputContext = cairo_create($outputSurface);
        //                            xx, yx, xy, yy, x0, y0
        $matrix = cairo_matrix_create(-1, 0,  0,  1, $this->img_x, 0);

        cairo_set_matrix($outputContext, $matrix);
        cairo_set_source_surface($outputContext, $this->surface, 0, 0);
        cairo_paint($outputContext);

        cairo_destroy($outputContext);
        cairo_surface_destroy($this->surface);

        $this->surface = $outputSurface;
    }//function mirror()

}//class Image_Transform_Driver_Cairowrapper extends Image_Transform
?>]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/ColorsDefs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
    /**
    * Mapping from named colors to RGB values.
    *
    * @var  array
    */
    $colornames = array(
        'aliceblue'     => array(240, 248, 255),
        'antiquewhite'  => array(250, 235, 215),
        'aqua'          => array(0, 255, 255),
        'aquamarine'    => array(127, 255, 212),
        'azure'         => array(240, 255,  255),
        'beige'         => array(245, 245, 220),
        'bisque'        => array(255, 228, 196),
        'black'         => array(0, 0, 0),
        'blanchedalmond'=> array(255, 235, 205),
        'blue'          => array(0, 0, 255),
        'blueviolet'    => array(138, 43, 226),
        'brown'         => array(165, 42, 42),
        'burlywood'     => array(222, 184, 135),
        'cadetblue'     => array(95, 158, 160),
        'chartreuse'    => array(127, 255, 0),
        'chocolate'     => array(210, 105, 30),
        'coral'         => array(255, 127, 80),
        'cornflowerblue'=> array(100, 149,  237),
        'cornsilk'      => array(255, 248, 220),
        'crimson'       => array(220, 20, 60),
        'cyan'          => array(0, 255, 255),
        'darkblue'      => array(0, 0, 13),
        'darkcyan'      => array(0, 139, 139),
        'darkgoldenrod' => array(184, 134, 11),
        'darkgray'      => array(169, 169, 169),
        'darkgreen'     => array(0, 100, 0),
        'darkkhaki'     => array(189, 183, 107),
        'darkmagenta'   => array(139, 0, 139),
        'darkolivegreen'=> array(85, 107, 47),
        'darkorange'    => array(255, 140, 0),
        'darkorchid'    => array(153, 50, 204),
        'darkred'       => array(139, 0, 0),
        'darksalmon'    => array(233, 150, 122),
        'darkseagreen'  => array(143, 188, 143),
        'darkslateblue' => array(72, 61, 139),
        'darkslategray' => array(47, 79, 79),
        'darkturquoise' => array(0, 206, 209),
        'darkviolet'    => array(148, 0, 211),
        'deeppink'      => array(255, 20, 147),
        'deepskyblue'   => array(0, 191, 255),
        'dimgray'       => array(105, 105, 105),
        'dodgerblue'    => array(30, 144, 255),
        'firebrick'     => array(178, 34, 34),
        'floralwhite'   => array(255, 250, 240),
        'forestgreen'   => array(34, 139, 34),
        'fuchsia'       => array(255, 0, 255),
        'gainsboro'     => array(220, 220, 220),
        'ghostwhite'    => array(248, 248, 255),
        'gold'          => array(255, 215, 0),
        'goldenrod'     => array(218, 165, 32),
        'gray'          => array(128, 128, 128),
        'green'         => array(0, 128, 0),
        'greenyellow'   => array(173, 255, 47),
        'honeydew'      => array(240, 255, 240),
        'hotpink'       => array(255, 105, 180),
        'indianred'     => array(205, 92, 92),
        'indigo'        => array(75, 0, 130),
        'ivory'         => array(255, 255, 240),
        'khaki'         => array(240, 230, 140),
        'lavender'      => array(230, 230, 250),
        'lavenderblush' => array(255, 240, 245),
        'lawngreen'     => array(124, 252,  0),
        'lemonchiffon'  => array(255, 250, 205),
        'lightblue'     => array(173, 216, 230),
        'lightcoral'    => array(240, 128, 128),
        'lightcyan'     => array(224, 255, 255),
        'lightgoldenrodyellow' => array(250, 250, 210),
        'lightgreen'    => array(144, 238, 144),
        'lightgrey'     => array(211, 211, 211),
        'lightpink'     => array(255, 182, 193),
        'lightsalmon'   => array(255, 160, 122),
        'lightseagreen' => array(32, 178, 170),
        'lightskyblue'  => array(135, 206, 250),
        'lightslategray'=> array(119, 136, 153),
        'lightsteelblue'=> array(176, 196, 222),
        'lightyellow'   => array(255, 255, 224),
        'lime'          => array(0, 255, 0),
        'limegreen'     => array(50, 205, 50),
        'linen'         => array(250, 240, 230),
        'magenta'       => array(255, 0, 255),
        'maroon'        => array(128, 0, 0),
        'mediumaquamarine' => array(102, 205, 170),
        'mediumblue'    => array(0, 0, 205),
        'mediumorchid'  => array(186, 85, 211),
        'mediumpurple'  => array(147, 112, 219),
        'mediumseagreen'=> array(60, 179, 113),
        'mediumslateblue'   => array(123, 104, 238),
        'mediumspringgreen' => array(0, 250, 154),
        'mediumturquoise'   => array(72, 209, 204),
        'mediumvioletred'   => array(199, 21, 133),
        'midnightblue'  => array(25, 25, 112),
        'mintcream'     => array(245, 255, 250),
        'mistyrose'     => array(255, 228, 225),
        'moccasin'      => array(255, 228, 181),
        'navajowhite'   => array(255, 222, 173),
        'navy'          => array(0, 0, 128),
        'oldlace'       => array(253, 245, 230),
        'olive'         => array(128, 128, 0),
        'olivedrab'     => array(107, 142, 35),
        'orange'        => array(255, 165, 0),
        'orangered'     => array(255,69,0),
        'orchid'        => array(218,112,214),
        'palegoldenrod' => array(238,232,170),
        'palegreen'     => array(152,251,152),
        'paleturquoise' => array(175,238,238),
        'palevioletred' => array(219,112,147),
        'papayawhip'    => array(255,239,213),
        'peachpuff'     => array(255,218,185),
        'peru' => array(205,133,63),
        'pink' => array(255,192,203),
        'plum' => array(221,160,221),
        'powderblue' => array(176,224,230),
        'purple' => array(128,0,128),
        'red' => array(255,0,0),
        'rosybrown' => array(188,143,143),
        'royalblue' => array(65,105,225),
        'saddlebrown' => array(139,69,19),
        'salmon' => array(250,128,114),
        'sandybrown' => array(244,164,96),
        'seagreen' => array(46,139,87),
        'seashell' => array(255,245,238),
        'sienna' => array(160,82,45),
        'silver' => array(192,192,192),
        'skyblue' => array(135,206,235),
        'slateblue' => array(106,90,205),
        'slategray' => array(112,128,144),
        'snow' => array(255,250,250),
        'springgreen' => array(0,255,127),
        'steelblue' => array(70,130,180),
        'tan' => array(210,180,140),
        'teal' => array(0,128,128),
        'thistle' => array(216,191,216),
        'tomato' => array(255,99,71),
        'turquoise' => array(64,224,208),
        'violet' => array(238,130,238),
        'wheat' => array(245,222,179),
        'white' => array(255,255,255),
        'whitesmoke' => array(245,245,245),
        'yellow' => array(255,255,0),
        'yellowgreen' => array(154,205,50)
    );
?>]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/GD.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

/* vim: set expandtab tabstop=4 shiftwidth=4: */

/**
 * GD implementation for Image_Transform package
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_GD
 * @author     Alan Knowles <alan@akbkhome.com>
 * @author     Peter Bowyer <peter@mapledesign.co.uk>
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2002-2005 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    CVS: $Id: GD.php 322661 2012-01-24 12:02:59Z clockwerx $
 * @link       http://pear.php.net/package/Image_Transform
 */

require_once 'Image/Transform.php';

/**
 * GD implementation for Image_Transform package
 *
 * Usage :
 *    $img    =& Image_Transform::factory('GD');
 *    $angle  = -78;
 *    $img->load('magick.png');
 *
 *    if ($img->rotate($angle, array(
 *               'autoresize' => true,
 *               'color_mask' => array(255, 0, 0)))) {
 *        $img->addText(array(
 *               'text' => 'Rotation ' . $angle,
 *               'x' => 0,
 *               'y' => 100,
 *               'font' => '/usr/share/fonts/default/TrueType/cogb____.ttf'));
 *        $img->display();
 *    } else {
 *        echo "Error";
 *    }
 *    $img->free();
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_GD
 * @author     Alan Knowles <alan@akbkhome.com>
 * @author     Peter Bowyer <peter@mapledesign.co.uk>
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2002-2005 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/Image_Transform
 * @since      PHP 4.0
 */
class Image_Transform_Driver_GD extends Image_Transform
{
    /**
     * Holds the image resource for manipulation
     *
     * @var resource $imageHandle
     * @access protected
     */
    var $imageHandle = null;

    /**
     * Holds the original image file
     *
     * @var resource $imageHandle
     * @access protected
     */
    var $oldImage = null;

    /**
     * Check settings
     */
    function Image_Transform_Driver_GD()
    {
        $this->__construct();
    } // End function Image

    /**
     * Check settings
     *
     * @since PHP 5
     */
    function __construct()
    {
        if (!PEAR::loadExtension('gd')) {
            $this->isError(PEAR::raiseError("GD library is not available.",
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED));
        } else {
            $types = ImageTypes();
            if ($types & IMG_PNG) {
                $this->_supported_image_types['png'] = 'rw';
            }
            if (($types & IMG_GIF)
                || function_exists('imagegif')) {
                $this->_supported_image_types['gif'] = 'rw';
            } elseif (function_exists('imagecreatefromgif')) {
                $this->_supported_image_types['gif'] = 'rw';
            }
            if ($types & IMG_JPG) {
                $this->_supported_image_types['jpeg'] = 'rw';
            }
            if ($types & IMG_WBMP) {
                $this->_supported_image_types['wbmp'] = 'rw';
            }
            if (!$this->_supported_image_types) {
                $this->isError(PEAR::raiseError("No supported image types available", IMAGE_TRANSFORM_ERROR_UNSUPPORTED));
            }
        }

    } // End function Image

    /**
     * Loads an image from file
     *
     * @param string $image filename
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function load($image)
    {
        $this->free();

        $this->image = $image;
        $result = $this->_get_image_details($image);
        if (PEAR::isError($result)) {
            return $result;
        }
        if (!$this->supportsType($this->type, 'r')) {
            return PEAR::raiseError('Image type not supported for input',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }

        $functionName = 'ImageCreateFrom' . $this->type;
        $this->imageHandle = $functionName($this->image);
        if (!$this->imageHandle) {
            $this->imageHandle = null;
            return PEAR::raiseError('Error while loading image file.',
                IMAGE_TRANSFORM_ERROR_IO);
        }
        return true;

    } // End load

    /**
     * Returns the GD image handle
     *
     * @return resource
     *
     * @access public
     */
    function getHandle()
    {
        return $this->imageHandle;
    }//function getHandle()

    /**
     * Adds a border of constant width around an image
     *
     * @param int $border_width Width of border to add
     * @author Peter Bowyer
     * @return bool TRUE
     * @access public
     */
    function addBorder($border_width, $color = '')
    {
        $this->new_x = $this->img_x + 2 * $border_width;
        $this->new_y = $this->img_y + 2 * $border_width;

        $new_img = $this->_createImage($new_x, $new_y, $this->true_color);

        $options = array('pencilColor', $color);
        $color = $this->_getColor('pencilColor', $options, array(0, 0, 0));
        if ($color) {
            if ($this->true_color) {
                $c = imagecolorresolve($this->imageHandle, $color[0], $color[1], $color[2]);
                imagefill($new_img, 0, 0, $c);
            } else {
                imagecolorset($new_img, imagecolorat($new_img, 0, 0), $color[0], $color[1], $color[2]);
            }
        }
        ImageCopy($new_img, $this->imageHandle, $border_width, $border_width, 0, 0, $this->img_x, $this->img_y);
        $this->imageHandle = $new_img;
        $this->resized = true;

        return true;
    }

    /**
     * addText
     *
     * @param   array   $params     Array contains options
     *                              array(
     *                                  'text'  The string to draw
     *                                  'x'     Horizontal position
     *                                  'y'     Vertical Position
     *                                  'color' Font color
     *                                  'font'  Font to be used
     *                                  'size'  Size of the fonts in pixel
     *                                  'resize_first'  Tell if the image has to be resized
     *                                                  before drawing the text
     *                              )
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     */
    function addText($params)
    {
        $this->oldImage = $this->imageHandle;
        $params = array_merge($this->_get_default_text_params(), $params);
        extract($params);

        $options = array('fontColor' => $color);
        $color = $this->_getColor('fontColor', $options, array(0, 0, 0));

        $c = imagecolorresolve ($this->imageHandle, $color[0], $color[1], $color[2]);

        if ('ttf' == substr($font, -3)) {
            ImageTTFText($this->imageHandle, $size, $angle, $x, $y, $c, $font, $text);
        } else {
            ImagePSText($this->imageHandle, $size, $angle, $x, $y, $c, $font, $text);
        }

        return true;
    } // End addText

    /**
     * Rotates image by the given angle
     *
     * Uses a fast rotation algorythm for custom angles
     * or lines copy for multiple of 90 degrees
     *
     * @param int   $angle   Rotation angle
     * @param array $options array(
     *                             'canvasColor' => array(r ,g, b), named color or #rrggbb
     *                            )
     * @author Pierre-Alain Joye
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function rotate($angle, $options = null)
    {
        if (($angle % 360) == 0) {
            return true;
        }

        $color_mask = $this->_getColor('canvasColor', $options,
                                        array(255, 255, 255));

        $mask = imagecolorresolve($this->imageHandle, $color_mask[0], $color_mask[1], $color_mask[2]);

        $this->oldImage = $this->imageHandle;

        // Multiply by -1 to change the sign, so the image is rotated clockwise
        $this->imageHandle = ImageRotate($this->imageHandle, $angle * -1, $mask);
        return true;
    }

    /**
     * Horizontal mirroring
     *
     * @return mixed TRUE or PEAR_Error object on error
     * @access public
     * @see flip()
     **/
    function mirror()
    {
        $new_img = $this->_createImage();
        for ($x = 0; $x < $this->new_x; ++$x) {
            imagecopy($new_img, $this->imageHandle, $x, 0,
                $this->new_x - $x - 1, 0, 1, $this->new_y);
        }
        imagedestroy($this->imageHandle);
        $this->imageHandle = $new_img;
        return true;
    }

    /**
     * Vertical mirroring
     *
     * @return TRUE or PEAR Error object on error
     * @access public
     * @see mirror()
     **/
    function flip()
    {
        $new_img = $this->_createImage();
        for ($y = 0; $y < $this->new_y; ++$y) {
            imagecopy($new_img, $this->imageHandle, 0, $y,
                0, $this->new_y - $y - 1, $this->new_x, 1);
        }
        imagedestroy($this->imageHandle);
        $this->imageHandle = $new_img;

        /* for very large images we may want to use the following
           Needs to find out what is the threshhold
        for ($x = 0; $x < $this->new_x; ++$x) {
            for ($y1 = 0; $y1 < $this->new_y / 2; ++$y1) {
                $y2 = $this->new_y - 1 - $y1;
                $color1 = imagecolorat($this->imageHandle, $x, $y1);
                $color2 = imagecolorat($this->imageHandle, $x, $y2);
                imagesetpixel($this->imageHandle, $x, $y1, $color2);
                imagesetpixel($this->imageHandle, $x, $y2, $color1);
            }
        } */
        return true;
    }

    /**
     * Crops image by size and start coordinates
     *
     * @param int width Cropped image width
     * @param int height Cropped image height
     * @param int x X-coordinate to crop at
     * @param int y Y-coordinate to crop at
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function crop($width, $height, $x = 0, $y = 0)
    {
        // Sanity check
        if (!$this->intersects($width, $height, $x, $y)) {
            return PEAR::raiseError('Nothing to crop', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        $x = min($this->new_x, max(0, $x));
        $y = min($this->new_y, max(0, $y));
        $width   = min($width,  $this->new_x - $x);
        $height  = min($height, $this->new_y - $y);
        $new_img = $this->_createImage($width, $height);

        if (!imagecopy($new_img, $this->imageHandle, 0, 0, $x, $y, $width, $height)) {
            imagedestroy($new_img);
            return PEAR::raiseError('Failed transformation: crop()',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        $this->oldImage = $this->imageHandle;
        $this->imageHandle = $new_img;
        $this->resized = true;

        $this->new_x = $width;
        $this->new_y = $height;
        return true;
    }

    /**
     * Converts the image to greyscale
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function greyscale() {
        imagecopymergegray($this->imageHandle, $this->imageHandle, 0, 0, 0, 0, $this->new_x, $this->new_y, 0);
        return true;
    }

    /**
     * Resize Action
     *
     * For GD 2.01+ the new copyresampled function is used
     * It uses a bicubic interpolation algorithm to get far
     * better result.
     *
     * @param int   $new_x   New width
     * @param int   $new_y   New height
     * @param array $options Optional parameters
     * <ul>
     *  <li>'scaleMethod': "pixel" or "smooth"</li>
     * </ul>
     *
     * @return bool|PEAR_Error TRUE on success or PEAR_Error object on error
     * @access protected
     */
    function _resize($new_x, $new_y, $options = null)
    {
        if ($this->resized === true) {
            return PEAR::raiseError('You have already resized the image without saving it.  Your previous resizing will be overwritten', null, PEAR_ERROR_TRIGGER, E_USER_NOTICE);
        }

        if ($this->new_x == $new_x && $this->new_y == $new_y) {
            return true;
        }

        $scaleMethod = $this->_getOption('scaleMethod', $options, 'smooth');

        // Make sure to get a true color image if doing resampled resizing
        // otherwise get the same type of image
        $trueColor = ($scaleMethod == 'pixel') ? null : true;
        $new_img = $this->_createImage($new_x, $new_y, $trueColor);

        $icr_res = null;
        if ($scaleMethod != 'pixel' && function_exists('ImageCopyResampled')) {
            $icr_res = ImageCopyResampled($new_img, $this->imageHandle, 0, 0, 0, 0, $new_x, $new_y, $this->img_x, $this->img_y);
        }
        if (!$icr_res) {
            ImageCopyResized($new_img, $this->imageHandle, 0, 0, 0, 0, $new_x, $new_y, $this->img_x, $this->img_y);
        }
        $this->oldImage = $this->imageHandle;
        $this->imageHandle = $new_img;
        $this->resized = true;

        $this->new_x = $new_x;
        $this->new_y = $new_y;
        return true;
    }

    /**
     * Adjusts the image gamma
     *
     * @param float $outputgamma
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function gamma($outputgamma = 1.0)
    {
        if ($outputgamma != 1.0) {
            ImageGammaCorrect($this->imageHandle, 1.0, $outputgamma);
        }
        return true;
    }

    /**
     * Helper method to save to a file or output the image
     *
     * @param string $filename the name of the file to write to (blank to output)
     * @param string $types    define the output format, default
     *                          is the current used format
     * @param int    $quality  output DPI, default is 75
     *
     * @return bool|PEAR_Error TRUE on success or PEAR_Error object on error
     * @access protected
     */
    function _generate($filename, $type = '', $quality = null)
    {
        $type = strtolower(($type == '') ? $this->type : $type);
        $options = (is_array($quality)) ? $quality : array();
        switch ($type) {
            case 'jpg':
                $type = 'jpeg';
            case 'jpeg':
                if (is_numeric($quality)) {
                    $options['quality'] = $quality;
                }
                $quality = $this->_getOption('quality', $options, 75);
                break;
        }
        if (!$this->supportsType($type, 'w')) {
            return PEAR::raiseError('Image type not supported for output',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }

        if ($filename == '') {
            header('Content-type: ' . $this->getMimeType($type));
            $action = 'output image';
        } else {
            $action = 'save image to file';
        }

        $functionName = 'image' . $type;
        switch ($type) {
            case 'jpeg':
                $result = $functionName($this->imageHandle, $filename, $quality);
                break;
            default:
                if ($filename == '') {
                    $result = $functionName($this->imageHandle);
                } else {
                    $result = $functionName($this->imageHandle, $filename);
                }
        }
        if (!$result) {
            return PEAR::raiseError('Couldn\'t ' . $action,
                IMAGE_TRANSFORM_ERROR_IO);
        }
        $this->imageHandle = $this->oldImage;
        if (!$this->keep_settings_on_save) {
            $this->free();
        }
        return true;

    } // End save

    /**
     * Displays image without saving and lose changes.
     *
     * This method adds the Content-type HTTP header
     *
     * @param string $type (JPEG, PNG...);
     * @param int    $quality 75
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access public
     */
    function display($type = '', $quality = null)
    {
        return $this->_generate('', $type, $quality);
    }

    /**
     * Saves the image to a file
     *
     * @param string $filename the name of the file to write to
     * @param string $type     the output format, default
     *                          is the current used format
     * @param int    $quality  default is 75
     *
     * @return bool|PEAR_Error TRUE on success or PEAR_Error object on error
     * @access public
     */
    function save($filename, $type = '', $quality = null)
    {
        if (!trim($filename)) {
            return PEAR::raiseError('Filename missing',
                IMAGE_TRANSFORM_ERROR_ARGUMENT);
        }
        return $this->_generate($filename, $type, $quality);
    }

    /**
     * Destroys image handle
     *
     * @access public
     */
    function free()
    {
        $this->resized = false;
        if (is_resource($this->imageHandle)) {
            ImageDestroy($this->imageHandle);
        }
        $this->imageHandle = null;
        if (is_resource($this->oldImage)){
            ImageDestroy($this->oldImage);
        }
        $this->oldImage = null;
    }

    /**
     * Returns a new image for temporary processing
     *
     * @param int $width width of the new image
     * @param int $height height of the new image
     * @param bool $trueColor force which type of image to create
     * @return resource a GD image resource
     * @access protected
     */
    function _createImage($width = -1, $height = -1, $trueColor = null)
    {
        if ($width == -1) {
            $width = $this->new_x;
        }
        if ($height == -1) {
            $height = $this->new_y;
        }

        $new_img = null;
        if (is_null($trueColor)) {
            if (function_exists('imageistruecolor')) {
                $createtruecolor = imageistruecolor($this->imageHandle);
            } else {
                $createtruecolor = true;
            }
        } else {
            $createtruecolor = $trueColor;
        }
        if ($createtruecolor
            && function_exists('ImageCreateTrueColor')) {
            $new_img = @ImageCreateTrueColor($width, $height);
            //GIF Transparent Patch
            if ($this->type!='gif') {
                imagealphablending($new_img, false);
                imagesavealpha($new_img, true);
            }
            //End GIF Transparent Patch
        }
        if (!$new_img) {
            $new_img = ImageCreate($width, $height);
            imagepalettecopy($new_img, $this->imageHandle);
            $color = imagecolortransparent($this->imageHandle);
            if ($color != -1) {
                imagecolortransparent($new_img, $color);
                imagefill($new_img, 0, 0, $color);
            }
        }
        
        //GIF Transparent Patch
        if ($this->type=='gif') {
            $transparencyIndex = imagecolortransparent($this->imageHandle);
            $transparencyColor = array('red' => 255, 'green' => 255, 'blue' => 255);
            
            if ($transparencyIndex >= 0) {
                $transparencyColor = imagecolorsforindex($this->imageHandle, $transparencyIndex);   
            }
           
            $transparencyIndex = imagecolorallocate($new_img, $transparencyColor['red'], $transparencyColor['green'], $transparencyColor['blue']);
            imagefill($new_img, 0, 0, $transparencyIndex);
            imagecolortransparent($new_img, $transparencyIndex);
        }
        //End GIF Transparent Patch
        
        
        return $new_img;
    }
}]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/GD1.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Peter Bowyer <peter@mapledesign.co.uk>                      |
// |          Alan Knowles <alan@akbkhome.com>                            |
// +----------------------------------------------------------------------+

require_once 'Image/Transform/Driver/GD.php';

/**
 * This driver is for GD1 or the non-bundled version of GD2
 *
 * @package
 * @author NAWAL ASWAN
 * @copyright Copyright (c) 2003
 * @version $Id: GD1.php 234123 2007-04-19 16:36:09Z dufuz $
 * @access public
 **/
Class Image_Transform_Driver_GD1 extends Image_Transform_Driver_GD
{
    /**
     * Check settings
     *
     * @return mixed true or  or a PEAR error object on error
     *
     * @see PEAR::isError()
     */
    function Image_Transform_Driver_GD1()
    {
        $this->__construct();
    } // End function Image

    /**
     * Check settings
     *
     * @return mixed true or  or a PEAR error object on error
     *
     * @see PEAR::isError()
     */
    function __construct()
    {
        parent::__construct();
    } // End function Image

   /**
    * Resize Action
    *
    * For GD 2.01+ the new copyresampled function is used
    * It uses a bicubic interpolation algorithm to get far
    * better result.
    *
    * @param $new_x int  new width
    * @param $new_y int  new height
    * @param mixed $options Optional parameters
    *
    * @return true on success or PEAR Error object on error
    * @see PEAR::isError()
    */
    function _resize($new_x, $new_y, $options = null)
    {
        if ($this->resized === true) {
            return PEAR::raiseError('You have already resized the image without saving it.  Your previous resizing will be overwritten', null, PEAR_ERROR_TRIGGER, E_USER_NOTICE);
        }
        $new_img =ImageCreate($new_x,$new_y);
        ImageCopyResized($new_img, $this->imageHandle, 0, 0, 0, 0, $new_x, $new_y, $this->img_x, $this->img_y);
        $this->old_image = $this->imageHandle;
        $this->imageHandle = $new_img;
        $this->resized = true;

        $this->new_x = $new_x;
        $this->new_y = $new_y;
        return true;
    }


    function rotate($angle, $options = null)
    {
        if ($options == null){
            $autoresize = true;
            $color_mask = array(255,255,0);
        } else {
            extract($options);
        }

        while ($angle <= -45) {
            $angle  += 360;
        }
        while ($angle > 270) {
            $angle  -= 360;
        }

        $t = deg2rad($angle);

        if (!is_array($color_mask)) {
            // Not already in numberical format, so we convert it.
            if ($color_mask{0} == '#'){
                $color_mask = $this->colorhex2colorarray($color_mask);
            } else {
                include_once 'Image/Transform/Driver/ColorsDefs.php';
                $color_mask = isset($colornames[$color_mask])?$colornames[$color_mask]:false;
            }
        }

        // Do not round it, too much lost of quality
        $cosT   = cos($t);
        $sinT   = sin($t);

        $img    =& $this->imageHandle;

        $width  = $max_x  = $this->img_x;
        $height = $max_y  = $this->img_y;
        $min_y  = 0;
        $min_x  = 0;

        $x1     = round($max_x/2,0);
        $y1     = round($max_y/2,0);

        if ( $autoresize ){
            $t      = abs($t);
            $a      = round($angle,0);
            switch((int)($angle)){
                case 0:
                        $width2     = $width;
                        $height2    = $height;
                    break;
                case 90:
                        $width2     = $height;
                        $height2    = $width;
                    break;
                case 180:
                        $width2     = $width;
                        $height2    = $height;
                    break;
                case 270:
                        $width2     = $height;
                        $height2    = $width;
                    break;
                default:
                    $width2     = (int)(abs(sin($t) * $height + cos($t) * $width));
                    $height2    = (int)(abs(cos($t) * $height+sin($t) * $width));
            }

            $width2     -= $width2%2;
            $height2    -= $height2%2;

            $d_width    = abs($width - $width2);
            $d_height   = abs($height - $height2);
            $x_offset   = $d_width/2;
            $y_offset   = $d_height/2;
            $min_x2     = -abs($x_offset);
            $min_y2     = -abs($y_offset);
            $max_x2     = $width2;
            $max_y2     = $height2;
        }

        $img2   = @imagecreateTrueColor($width2,$height2);

        if (!is_resource($img2)) {
            return PEAR::raiseError('Cannot create buffer for the rotataion.',
                                null, PEAR_ERROR_TRIGGER, E_USER_NOTICE);
        }

        $this->img_x = $width2;
        $this->img_y = $height2;


        imagepalettecopy($img2,$img);

        $mask   = imagecolorresolve($img2,$color_mask[0],$color_mask[1],$color_mask[2]);

        // use simple lines copy for axes angles
        switch ((int)($angle)) {
            case 0:
                imagefill($img2, 0, 0,$mask);
                for ($y = 0; $y < $max_y; $y++) {
                    for ($x = $min_x; $x < $max_x; $x++){
                        $c  = @imagecolorat ( $img, $x, $y);
                        imagesetpixel($img2,$x+$x_offset,$y+$y_offset,$c);
                    }
                }
                break;
            case 90:
                imagefill ($img2, 0, 0,$mask);
                for ($x = $min_x; $x < $max_x; $x++){
                    for ($y=$min_y; $y < $max_y; $y++) {
                        $c  = imagecolorat ( $img, $x, $y);
                        imagesetpixel($img2,$max_y-$y-1,$x,$c);
                    }
                }
                break;
            case 180:
                imagefill ($img2, 0, 0,$mask);
                for ($y=0; $y < $max_y; $y++) {
                    for ($x = $min_x; $x < $max_x; $x++){
                        $c  = @imagecolorat ( $img, $x, $y);
                        imagesetpixel($img2, $max_x2-$x-1, $max_y2-$y-1, $c);
                    }
                }
                break;
            case 270:
                imagefill ($img2, 0, 0,$mask);
                for ($y=0; $y < $max_y; $y++) {
                    for ($x = $max_x; $x >= $min_x; $x--){
                        $c  = @imagecolorat ( $img, $x, $y);
                        imagesetpixel($img2,$y,$max_x-$x-1,$c);
                    }
                }
                break;
            // simple reverse rotation algo
            default:
                $i=0;
                for ($y = $min_y2; $y < $max_y2; $y++){

                    // Algebra :)
                    $x2 = round((($min_x2-$x1) * $cosT) + (($y-$y1) * $sinT + $x1),0);
                    $y2 = round((($y-$y1) * $cosT - ($min_x2-$x1) * $sinT + $y1),0);

                    for ($x = $min_x2; $x < $max_x2; $x++){

                        // Check if we are out of original bounces, if we are
                        // use the default color mask
                        if ( $x2>=0 && $x2<$max_x && $y2>=0 && $y2<$max_y ){
                            $c  = imagecolorat ( $img, $x2, $y2);
                        } else {
                            $c  = $mask;
                        }
                        imagesetpixel($img2,$x+$x_offset,$y+$y_offset,$c);

                        // round verboten!
                        $x2  += $cosT;
                        $y2  -= $sinT;
                    }
                }
                break;
        }

        $this->imageHandle  =  $img2;
        return true;
    }
} // End class ImageGD]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/IM.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

/* vim: set expandtab tabstop=4 shiftwidth=4: */

/**
 * ImageMagick binaries implementation for Image_Transform package
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category   Image
 * @package    Image_Transform
 * @author     Peter Bowyer <peter@mapledesign.co.uk>
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2002-2005 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    CVS: $Id: IM.php 266859 2008-09-30 22:28:47Z dufuz $
 * @link       http://pear.php.net/package/Image_Transform
 */

require_once 'Image/Transform.php';
require_once 'System.php';

/**
 * ImageMagick binaries implementation for Image_Transform package
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_IM
 * @author     Peter Bowyer <peter@mapledesign.co.uk>
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2002-2005 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/Image_Transform
 * @link http://www.imagemagick.org/
 **/
class Image_Transform_Driver_IM extends Image_Transform
{
    /**
     * associative array commands to be executed
     * @var array
     * @access private
     */
    var $command;

    /**
     * Class constructor
     */
    function Image_Transform_Driver_IM()
    {
        $this->__construct();
    } // End Image_IM

    /**
     * Class constructor
     */
    function __construct()
    {
        $this->_init();
        if (!defined('IMAGE_TRANSFORM_IM_PATH')) {
            $path = dirname(System::which('convert'))
                    . DIRECTORY_SEPARATOR;
            define('IMAGE_TRANSFORM_IM_PATH', $path);
        }
        if (System::which(IMAGE_TRANSFORM_IM_PATH . 'convert' . ((OS_WINDOWS) ? '.exe' : ''))) {
            include 'Image/Transform/Driver/Imagick/ImageTypes.php';
        } else {
            $this->isError(PEAR::raiseError('Couldn\'t find "convert" binary',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED));
        }
    } // End Image_IM

    /**
     * Initialize the state of the object
     **/
    function _init()
    {
        $this->command = array();
    }

    /**
     * Load an image.
     *
     * This method doesn't support remote files.
     *
     * @param string filename
     *
     * @return mixed TRUE or a PEAR error object on error
     * @see PEAR::isError()
     */
    function load($image)
    {
        $this->_init();
        if (!file_exists($image)) {
            return PEAR::raiseError('The image file ' . $image
                . ' doesn\'t exist', IMAGE_TRANSFORM_ERROR_IO);
        }
        $this->image = $image;
        $result = $this->_get_image_details($image);
        if (PEAR::isError($result)) {
            return $result;
        }
        return true;

    } // End load

    /**
     * Image_Transform_Driver_IM::_get_image_details()
     *
     * @param string $image the path and name of the image file
     * @return none
     */
    function _get_image_details($image)
    {
        $retval = Image_Transform::_get_image_details($image);
        if (PEAR::isError($retval)) {
            unset($retval);

            if (!System::which(IMAGE_TRANSFORM_IM_PATH . 'identify' . ((OS_WINDOWS) ? '.exe' : ''))) {
                $this->isError(PEAR::raiseError('Couldn\'t find "identify" binary', IMAGE_TRANSFORM_ERROR_UNSUPPORTED));
            }
            $cmd = $this->_prepare_cmd(IMAGE_TRANSFORM_IM_PATH,
                'identify',
                '-format %w:%h:%m ' . escapeshellarg($image));
            exec($cmd, $res, $exit);

            if ($exit != 0) {
                return PEAR::raiseError("Cannot fetch image or images details.", true);
            }

            $data  = explode(':', $res[0]);
            $this->img_x = $data[0];
            $this->img_y = $data[1];
            $this->type  = strtolower($data[2]);
            $retval = true;

        }

        return $retval;
    }

    /**
     * Resize the image.
     *
     * @access private
     *
     * @param int   $new_x   New width
     * @param int   $new_y   New height
     * @param mixed $options Optional parameters
     *
     * @return true on success or PEAR Error object on error
     * @see PEAR::isError()
     */
    function _resize($new_x, $new_y, $options = null)
    {
        if (isset($this->command['resize'])) {
            return PEAR::raiseError('You cannot scale or resize an image more than once without calling save() or display()', true);
        }
        $this->command['resize'] = '-geometry '
            . ((int) $new_x) . 'x' . ((int) $new_y) . '!';

        $this->new_x = $new_x;
        $this->new_y = $new_y;

        return true;
    } // End resize

    /**
     * rotate
     *
     * @param   int     angle   rotation angle
     * @param   array   options no option allowed
     * @return mixed TRUE or a PEAR error object on error
     */
    function rotate($angle, $options = null)
    {
        $angle = $this->_rotation_angle($angle);
        if ($angle % 360) {
            $this->command['rotate'] = '-rotate ' . (float) $angle;
        }
        return true;

    } // End rotate

    /**
     * Crop image
     *
     * @author Ian Eure <ieure@websprockets.com>
     * @since 0.8
     *
     * @param int width Cropped image width
     * @param int height Cropped image height
     * @param int x X-coordinate to crop at
     * @param int y Y-coordinate to crop at
     *
     * @return mixed TRUE or a PEAR error object on error
     */
    function crop($width, $height, $x = 0, $y = 0) {
        // Do we want a safety check - i.e. if $width+$x > $this->img_x then we
        // raise a warning? [and obviously same for $height+$y]
        $this->command['crop'] = '-crop '
            . ((int) $width)  . 'x' . ((int) $height)
            . '+' . ((int) $x) . '+' . ((int) $y) . '!';

        // I think that setting img_x/y is wrong, but scaleByLength() & friends
        // mess up the aspect after a crop otherwise.
        $this->new_x = $this->img_x = $width - $x;
        $this->new_y = $this->img_y = $height - $y;

        return true;
    }

    /**
     * addText
     *
     * @param   array   options     Array contains options
     *                              array(
     *                                  'text'  The string to draw
     *                                  'x'     Horizontal position
     *                                  'y'     Vertical Position
     *                                  'Color' Font color
     *                                  'font'  Font to be used
     *                                  'size'  Size of the fonts in pixel
     *                                  'resize_first'  Tell if the image has to be resized
     *                                                  before drawing the text
     *                              )
     *
     * @return mixed TRUE or a PEAR error object on error
     * @see PEAR::isError()
     */
    function addText($params)
    {
        $this->old_image = $this->imageHandle;
         $params = array_merge($this->_get_default_text_params(), $params);
         extract($params);

         if (true === $resize_first) {
             // Set the key so that this will be the last item in the array
            $key = 'ztext';
         } else {
            $key = 'text';
         }
         $this->command[$key] = '-font ' . escapeshellarg($font)
            . ' -fill ' . escapeshellarg($color)
            . ' -draw \'text ' . escapeshellarg($x . ',' . $y)
            . ' "' . escapeshellarg($text) . '"\'';
         // Producing error: gs: not found gs: not found convert: Postscript delegate failed [No such file or directory].
        return true;

    } // End addText

    /**
     * Adjust the image gamma
     *
     * @access public
     * @param float $outputgamma
     * @return mixed TRUE or a PEAR error object on error
     */
    function gamma($outputgamma = 1.0) {
        if ($outputgamme != 1.0) {
            $this->command['gamma'] = '-gamma ' . (float) $outputgamma;
        }
        return true;
    }

    /**
     * Convert the image to greyscale
     *
     * @access public
     * @return mixed TRUE or a PEAR error object on error
     */
    function greyscale() {
        $this->command['type'] = '-type Grayscale';
        return true;
    }

    /**
     * Horizontal mirroring
     *
     * @access public
     * @return TRUE or PEAR Error object on error
     */
    function mirror() {
        // We can only apply "flop" once
        if (isset($this->command['flop'])) {
            unset($this->command['flop']);
        } else {
            $this->command['flop'] = '-flop';
        }
        return true;
    }

    /**
     * Vertical mirroring
     *
     * @access public
     * @return TRUE or PEAR Error object on error
     */
    function flip() {
        // We can only apply "flip" once
        if (isset($this->command['flip'])) {
            unset($this->command['flip']);
        } else {
            $this->command['flip'] = '-flip';
        }
        return true;
    }

    /**
     * Save the image file
     *
     * @access public
     *
     * @param $filename string  the name of the file to write to
     * @param $quality  quality image dpi, default=75
     * @param $type     string  (JPEG, PNG...)
     *
     * @return mixed TRUE or a PEAR error object on error
     */
    function save($filename, $type = '', $quality = null)
    {
        $type = strtoupper(($type == '') ? $this->type : $type);
        switch ($type) {
            case 'JPEG':
                $type = 'JPG';
                break;
        }
        $options = array();
        if (!is_null($quality)) {
            $options['quality'] = $quality;
        }
        $quality = $this->_getOption('quality', $options, 75);

        $cmd = $this->_prepare_cmd(
            IMAGE_TRANSFORM_IM_PATH,
            'convert',
            implode(' ', $this->command)
               . ' -quality ' . ((int) $quality) . ' '
               . escapeshellarg($this->image) . ' ' . $type . ':'
               . escapeshellarg($filename) . ' 2>&1');
        exec($cmd, $res, $exit);

        if (!$this->keep_settings_on_save) {
            $this->free();
        }

        return ($exit == 0) ? true : PEAR::raiseError(implode('. ', $res),
            IMAGE_TRANSFORM_ERROR_IO);
    } // End save

    /**
     * Display image without saving and lose changes
     *
     * This method adds the Content-type HTTP header
     *
     * @access public
     *
     * @param string type (JPEG,PNG...);
     * @param int quality 75
     *
     * @return mixed TRUE or a PEAR error object on error
     */
    function display($type = '', $quality = null)
    {
        $type    = strtoupper(($type == '') ? $this->type : $type);
        switch ($type) {
            case 'JPEG':
                $type = 'JPG';
                break;
        }
        $options = array();
        if (!is_null($quality)) {
            $options['quality'] = $quality;
        }
        $quality = $this->_getOption('quality', $options, 75);

        $this->_send_display_headers($type);

        $cmd = $this->_prepare_cmd(
            IMAGE_TRANSFORM_IM_PATH,
            'convert',
            implode(' ', $this->command) . " -quality $quality "  .
                   $this->image . ' ' . $type . ":-");
        passthru($cmd);

        if (!$this->keep_settings_on_save) {
            $this->free();
        }
        return true;
    }

    /**
     * Destroy image handle
     *
     * @return void
     */
    function free()
    {
        $this->command = array();
        $this->image = '';
        $this->type = '';
    }

} // End class ImageIM
]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/Imagick/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/Imagick/ImageTypes.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/Imagick/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/Imagick2.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

/* vim: set expandtab tabstop=4 shiftwidth=4: */

/**
 * imagick PECL extension implementation for Image_Transform package
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_Imagick2
 * @author     Alan Knowles <alan@akbkhome.com>
 * @author     Peter Bowyer <peter@mapledesign.co.uk>
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2002-2005 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    CVS: $Id: Imagick2.php 266907 2008-10-01 21:10:50Z dufuz $
 * @link       http://pear.php.net/package/Image_Transform
 */

require_once 'Image/Transform.php';

/**
 * imagick PECL extension implementation for Image_Transform package
 *
 * WARNING: For version < 2.0 of the extension. For version 2.0 and up use
 * Imagick3 driver instead
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_Imagick2
 * @author     Alan Knowles <alan@akbkhome.com>
 * @author     Peter Bowyer <peter@mapledesign.co.uk>
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2002-2005 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/Image_Transform
 * @since      PHP 4.0
 */
class Image_Transform_Driver_Imagick2 extends Image_Transform
{
    /**
     * Handler of the imagick image ressource
     * @var array
     */
    var $imageHandle = null;

    /**
     * Handler of the image ressource before
     * the last transformation
     * @var array
     */
    var $oldImage;

    /**
     * @see __construct()
     */
    function Image_Transform_Driver_Imagick2()
    {
        $this->__construct();
    } // End Image_Transform_Driver_Imagick2

    /**
     * @see http://www.imagemagick.org/www/formats.html
     */
    function __construct()
    {
        if (PEAR::loadExtension('imagick')) {
            include 'Image/Transform/Driver/Imagick/ImageTypes.php';
        } else {
            $this->isError(PEAR::raiseError('Couldn\'t find the imagick extension.',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED));
        }
    }

    /**
     * Loads an image
     *
     * @param string $image filename
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function load($image)
    {
        if (!($this->imageHandle = imagick_readimage($image))) {
            $this->free();
            return $this->raiseError('Couldn\'t load image.',
                IMAGE_TRANSFORM_ERROR_IO);
        }
        if (imagick_iserror($this->imageHandle)) {
            return $this->raiseError('Couldn\'t load image.',
                IMAGE_TRANSFORM_ERROR_IO);
        }

        $this->image = $image;
        $result = $this->_get_image_details($image);
        if (PEAR::isError($result)) {
            return $result;
        }

        return true;
    } // End load

    /**
     * Resize Action
     *
     * @param int   $new_x   New width
     * @param int   $new_y   New height
     * @param mixed $options Optional parameters
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access protected
     */
    function _resize($new_x, $new_y, $options = null)
    {
        if (!imagick_resize($this->imageHandle, $new_x, $new_y, IMAGICK_FILTER_UNKNOWN , 1, '!')) {
            return $this->raiseError('Couldn\'t resize image.',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        $this->new_x = $new_x;
        $this->new_y = $new_y;
        return true;

    } // End resize

    /**
     * Rotates the current image
     * Note: color mask are currently not supported
     *
     * @param   int     Rotation angle in degree
     * @param   array   No options are currently supported
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function rotate($angle, $options = null)
    {
        if (($angle % 360) == 0) {
            return true;
        }
        if (!imagick_rotate($this->imageHandle, $angle)) {
            return $this->raiseError('Cannot create a new imagick image for the rotation.',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        $this->new_x = imagick_getwidth($this->imageHandle);
        $this->new_y = imagick_getheight($this->imageHandle);
        return true;

    } // End rotate

    /**
     * addText
     *
     * @param   array   options     Array contains options
     *                              array(
     *                                  'text'  The string to draw
     *                                  'x'     Horizontal position
     *                                  'y'     Vertical Position
     *                                  'Color' Font color
     *                                  'font'  Font to be used
     *                                  'size'  Size of the fonts in pixel
     *                                  'resize_first'  Tell if the image has to be resized
     *                                                  before drawing the text
     *                              )
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function addText($params)
    {
        $this->oldImage= $this->imageHandle;
        $params = array_merge($this->_get_default_text_params(), $params);

        if (is_array($params['color'])) {
            $params['color'] = $this->colorarray2colorhex($params['color']);
        } else {
            $params['color'] = strtolower($params['color']);
        }

        static $cmds = array(
            'setfillcolor' => 'color',
            'setfontsize'  => 'size',
            'setfontface'  => 'font'
        );
        imagick_begindraw($this->imageHandle);

        foreach ($cmds as $cmd => $v) {
            if (!call_user_func('imagick_' . $cmd, $this->imageHandle, $params[$v])) {
                return $this->raiseError("Problem with adding Text::{$v} = {$params[$v]}",
                    IMAGE_TRANSFORM_ERROR_FAILED);
            }
        }
        if (!imagick_drawannotation($this->imageHandle, $params['x'], $params['y'], $params['text'])) {
            return $this->raiseError('Problem with adding Text',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        return true;

    } // End addText


    /**
     * Saves the image to a file
     *
     * @param $filename string the name of the file to write to
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function save($filename, $type = '', $quality = null)
    {
        $options = (is_array($quality)) ? $quality : array();
        if (is_numeric($quality)) {
            $options['quality'] = $quality;
        }
        $quality = $this->_getOption('quality', $options, 75);
        imagick_setcompressionquality($this->imageHandle, $quality);

        if ($type && strcasecmp($type, $this->type)
            && !imagick_convert($this->imageHandle, $type)) {
            return $this->raiseError('Couldn\'t save image to file (conversion failed).',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        if (!imagick_write($this->imageHandle, $filename)) {
            return $this->raiseError('Couldn\'t save image to file.',
                IMAGE_TRANSFORM_ERROR_IO);
        }

        if (!$this->keep_settings_on_save) {
            $this->free();
        }

        return true;

    } // End save

    /**
     * Displays image without saving and lose changes
     *
     * This method adds the Content-type HTTP header
     *
     * @param string type (JPG,PNG...);
     * @param int quality 75
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function display($type = '', $quality = null)
    {
        $options = (is_array($quality)) ? $quality : array();
        if (is_numeric($quality)) {
            $options['quality'] = $quality;
        }
        $quality = $this->_getOption('quality', $options, 75);
        imagick_setcompressionquality($this->imageHandle, $quality);

        if ($type && strcasecmp($type, $this->type)
            && !imagick_convert($this->imageHandle, $type)) {
            return $this->raiseError('Couldn\'t save image to file (conversion failed).',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }
        if (!($image = imagick_image2blob($this->imageHandle))) {
            return $this->raiseError('Couldn\'t display image.',
                IMAGE_TRANSFORM_ERROR_IO);
        }
        header('Content-type: ' . imagick_getmimetype($this->imageHandle));
        echo $image;
        $this->free();
        return true;
    }

    /**
     * Adjusts the image gamma
     *
     * @param float $outputgamma
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function gamma($outputgamma = 1.0) {
        if ($outputgamma != 1.0) {
            imagick_gamma($this->imageHandle, $outputgamma);
        }
        return true;
    }

    /**
     * Crops the image
     *
     * @param int width Cropped image width
     * @param int height Cropped image height
     * @param int x X-coordinate to crop at
     * @param int y Y-coordinate to crop at
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function crop($width, $height, $x = 0, $y = 0)
    {
        // Sanity check
        if (!$this->intersects($width, $height, $x, $y)) {
            return PEAR::raiseError('Nothing to crop', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        if (!imagick_crop($this->imageHandle, $x, $y, $width, $height)) {
            return $this->raiseError('Couldn\'t crop image.',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        // I think that setting img_x/y is wrong, but scaleByLength() & friends
        // mess up the aspect after a crop otherwise.
        $this->new_x = $width;
        $this->new_y = $height;

        return true;
    }

    /**
     * Horizontal mirroring
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function mirror()
    {
        if (!imagick_flop($this->imageHandle)) {
            return $this->raiseError('Couldn\'t mirror the image.',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }
        return true;
    }

    /**
     * Vertical mirroring
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function flip()
    {
        if (!imagick_flip($this->imageHandle)) {
            return $this->raiseError('Couldn\'t flip the image.',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }
        return true;
    }

    /**
     * Destroy image handle
     *
     * @access public
     */
    function free()
    {
        if (is_resource($this->imageHandle)) {
            imagick_destroyhandle($this->imageHandle);
        }
        $this->imageHandle = null;
    }

    /**
     * RaiseError Method - shows imagick Raw errors.
     *
     * @param string $message message = prefixed message..
     * @param int    $code error code
     * @return PEAR error object
     * @access protected
     */
    function raiseError($message, $code = 0)
    {
        if (is_resource($this->imageHandle)) {
            $message .= "\nReason: "
                        .  imagick_failedreason($this->imageHandle)
                        . "\nDescription: "
                        . imagick_faileddescription($this->imageHandle);
        }
        return PEAR::raiseError($message, $code);
    }

} // End class Image_Transform_Driver_Imagick2]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/Imagick3.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

/* vim: set expandtab tabstop=4 shiftwidth=4: */

/**
 * imagick PECL extension implementation for Image_Transform package
 *
 * PHP version 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_Imagick3
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2007 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    CVS: $Id: Imagick3.php 266908 2008-10-01 21:11:07Z dufuz $
 * @link       http://pear.php.net/package/Image_Transform
 */

require_once 'Image/Transform.php';

/**
 * imagick PECL extension implementation for Image_Transform package
 *
 * For use of version 2+ of the extension. For version 0.9.* use Imagick2 driver
 * instead
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_Imagick3
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2007 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/Image_Transform
 * @since      0.9.2
 * @since      PHP 5.1.3
 * @since      PECL Imagick 2.0.0a1
 */
class Image_Transform_Driver_Imagick3 extends Image_Transform
{
    /**
     * Instance of imagick
     * @var Imagick
     */
    var $imagick = null;

    /**
     * Handler of the image resource before
     * the last transformation
     * @var array
     */
    var $oldImage;

    /**
     * @see __construct()
     */
    function Image_Transform_Driver_Imagick3()
    {
        $this->__construct();
    }

    /**
     * @see http://www.imagemagick.org/www/formats.html
     */
    function __construct()
    {
        if (PEAR::loadExtension('imagick')) {
            include 'Image/Transform/Driver/Imagick/ImageTypes.php';
        } else {
            $this->isError(PEAR::raiseError('Could not find the imagick extension.',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED));
        }
    }

    /**
     * Loads an image
     *
     * @param string $image filename
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function load($image)
    {
        $this->free();
        $this->imagick = new Imagick();
        try {
            $this->imagick->readImage($image);

        } catch (ImagickException $e) {
            $this->free();
            return $this->raiseError('Could not load image:'.$e->getMessage(),
                IMAGE_TRANSFORM_ERROR_IO);
        }

        $this->image = $image;
        $result = $this->_get_image_details($image);
        if (PEAR::isError($result)) {
            return $result;
        }

        return true;
    }

    /**
     * Resizes the image
     *
     * @param integer $new_x   New width
     * @param integer $new_y   New height
     * @param mixed $options Optional parameters
     * <ul>
     *  <li>'scaleMethod': "pixel" or "smooth"</li>
     * </ul>
     *
     * @return bool|PEAR_Error TRUE or PEAR_Error object on error
     * @access protected
     */
    function _resize($new_x, $new_y, $options = null)
    {
        try {
            $scaleMethod = $this->_getOption('scaleMethod', $options, 'smooth');
            $blur = ($scaleMethod == 'pixel') ? 0 : 1;
            $this->imagick->resizeImage($new_x, $new_y,
                                        imagick::FILTER_UNDEFINED, $blur);

        } catch (ImagickException $e) {
            return $this->raiseError('Could not resize image.',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        $this->new_x = $new_x;
        $this->new_y = $new_y;
        return true;

    } // End resize

    /**
     * Rotates the current image
     *
     * @param float $angle Rotation angle in degree
     * @param array $options Supported options:
     * <ul>
     *  <li>'canvasColor' : array(r ,g, b), named color or #rrggbb</li>
     * </ul>
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function rotate($angle, $options = null)
    {
        if (($angle % 360) == 0) {
            return true;
        }
        $color = $this->_getColor('canvasColor', $options, array(255, 255, 255));
        if (is_array($color)) {
            $color = $this->colorarray2colorhex($color);
        }
        $pixel = new ImagickPixel($color);
        try {
            $this->imagick->rotateImage($pixel, $angle);

        } catch (ImagickException $e) {
            return $this->raiseError('Cannot create a new imagick image for the rotation: '.$e->getMessage(),
                IMAGE_TRANSFORM_ERROR_FAILED);
        }
        $info = $this->imagick->getImageGeometry();
        $this->new_x = $info['width'];
        $this->new_y = $info['height'];
        return true;

    } // End rotate

    /**
     * Adds text to the image
     *
     * @param   array   $params Array contains options:
     * <ul>
     *  <li>'text' (string) The string to draw</li>
     *  <li>'x'    (integer) Horizontal position</li>
     *  <li>'y'    (integer) Vertical Position</li>
     *  <li>'Color' (mixed) Font color</li>
     *  <li>'font' (string) Font to be used</li>
     *  <li>'size' (integer) Size of the fonts in pixel</li>
     * </ul>
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function addText($params)
    {
        $this->oldImage = clone $this->imagick;
        $params = array_merge($this->_get_default_text_params(), $params);

        if (is_array($params['color'])) {
            $params['color'] = $this->colorarray2colorhex($params['color']);
        } else {
            $params['color'] = strtolower($params['color']);
        }

        static $cmds = array(
            'setFillColor' => 'color',
            'setFontSize'  => 'size',
            'setFontFace'  => 'font'
        );
        $this->imagick->beginDraw();

        foreach ($cmds as $cmd => $v) {
            if (!$this->imagick->$cmd($params[$v])) {
                return $this->raiseError("Problem with adding Text::{$v} = {$params[$v]}",
                    IMAGE_TRANSFORM_ERROR_FAILED);
            }
        }
        if (!$this->imagick->drawAnnotation($params['x'], $params['y'], $params['text'])) {
            return $this->raiseError('Problem with adding Text',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        return true;

    } // End addText


    /**
     * Saves the image to a file
     *
     * @param $filename string the name of the file to write to
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function save($filename, $type = '', $quality = null)
    {
        $options = (is_array($quality)) ? $quality : array();
        if (is_numeric($quality)) {
            $options['quality'] = $quality;
        }
        $quality = $this->_getOption('quality', $options, 75);
        $this->imagick->setImageCompression($quality);

        if ($type && strcasecmp($type, $this->type)) {
            try {
                $this->imagick->setImageFormat($type);

            } catch (ImagickException $e) {
                return $this->raiseError('Could not save image to file (conversion failed).',
                IMAGE_TRANSFORM_ERROR_FAILED);
            }
        }

        try {
            $this->imagick->writeImage($filename);

        } catch (ImagickException $e) {
            return $this->raiseError('Could not save image to file: '.$e->getMessage(),
                IMAGE_TRANSFORM_ERROR_IO);
        }

        if (!$this->keep_settings_on_save) {
            $this->free();
        }

        return true;

    } // End save

    /**
     * Displays image without saving and lose changes
     *
     * This method adds the Content-type HTTP header
     *
     * @param string type (JPG,PNG...);
     * @param int quality 75
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function display($type = '', $quality = null)
    {
        $options = (is_array($quality)) ? $quality : array();
        if (is_numeric($quality)) {
            $options['quality'] = $quality;
        }
        $quality = $this->_getOption('quality', $options, 75);
        $this->imagick->setImageCompression($quality);

        if ($type && strcasecmp($type, $this->type)) {
            try {
                $this->imagick->setImageFormat($type);

            } catch (ImagickException $e) {
                return $this->raiseError('Could not save image to file (conversion failed).',
                IMAGE_TRANSFORM_ERROR_FAILED);
            }
        }
        try {
            $image = $this->imagick->getImageBlob();

        } catch (ImagickException $e) {
            return $this->raiseError('Could not display image.',
                IMAGE_TRANSFORM_ERROR_IO);
        }
        header('Content-type: ' . $this->getMimeType($type));
        echo $image;
        $this->free();
        return true;
    }

    /**
     * Adjusts the image gamma
     *
     * @param float $outputgamma
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function gamma($outputgamma = 1.0) {
        if ($outputgamma != 1.0) {
            $this->imagick->setImageGamma($outputgamma);
        }
        return true;
    }

    /**
     * Crops the image
     *
     * @param integer $width Cropped image width
     * @param integer $height Cropped image height
     * @param integer $x X-coordinate to crop at
     * @param integer $y Y-coordinate to crop at
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function crop($width, $height, $x = 0, $y = 0)
    {
        // Sanity check
        if (!$this->intersects($width, $height, $x, $y)) {
            return PEAR::raiseError('Nothing to crop', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        try {
            $this->imagick->cropImage($width, $height, $x, $y);

        } catch (ImagickException $e) {
            return $this->raiseError('Could not crop image',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }

        // I think that setting img_x/y is wrong, but scaleByLength() & friends
        // mess up the aspect after a crop otherwise.
        $this->new_x = $width;
        $this->new_y = $height;

        return true;
    }

    /**
     * Converts the image to greyscale
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function greyscale() {
        $this->imagick->setImageType(Imagick::IMGTYPE_GRAYSCALE);
        /*$this->imagick->setImageColorSpace(Imagick::COLORSPACE_GRAY);
        $this->imagick->setImageDepth(8);
        $this->imagick->separateImageChannel(Imagick::CHANNEL_GRAY);
        $this->imagick->setImageChannelDepth(Imagick::CHANNEL_GRAY, 8);*/
        return true;
    }

    /**
     * Horizontal mirroring
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function mirror()
    {
        try {
            $this->imagick->flopImage();
        } catch (ImagickException $e) {
            return $this->raiseError('Could not mirror the image.',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }
        return true;
    }

    /**
     * Vertical mirroring
     *
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function flip()
    {
        try {
            $this->imagick->flipImage();

        } catch (ImagickException $e) {
            return $this->raiseError('Could not flip the image.',
                IMAGE_TRANSFORM_ERROR_FAILED);
        }
        return true;
    }

    /**
     * Destroy image handle
     *
     * @access public
     */
    function free()
    {
        if (isset($this->imagick)) {
            $this->imagick->destroy();
            $this->imagick = null;
        }
    }

    /**
     * RaiseError Method - shows imagick Raw errors.
     *
     * @param string $message message = prefixed message..
     * @param int    $code error code
     * @return PEAR error object
     * @access protected
     */
    function raiseError($message, $code = 0)
    {
        return PEAR::raiseError($message, $code);
    }
}]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/Imlib.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Jason Rust <jrust@rustyparts.com>                           |
// +----------------------------------------------------------------------+
// $Id: Imlib.php 258825 2008-04-30 23:00:13Z cweiske $
// {{{ requires

require_once 'Image/Transform.php';

// }}}
// {{{ example usage

//    $img    = new Image_Transform::factory('Imlib');
//    $angle  = -90;
//    $img->load('test.png');
//    $img->rotate($angle);
//    $img->addText(array('text'=>"Rotation $angle",'x'=>0,'y'=>100,'font'=>'arial.ttf','color'=>'#ffffff'));
//    $img->display();

// }}}
// {{{ class Image_Transform_Driver_Imlib

/**
 * Performs image manipulation with the imlib library.
 *
 * @see http://mmcc.cx/php_imlib/index.php
 * @version Revision: 1.0
 * @author  Jason Rust <jrust@rustyparts.com>
 * @package Image_Transform
 */

// }}}
class Image_Transform_Driver_Imlib extends Image_Transform {
    // {{{ properties

    /**
     * Holds the image file for manipulation
     */
    var $imageHandle = '';

    /**
     * Holds the original image file
     */
    var $oldHandle = '';

    // }}}
    // {{{ constructor

    /**
     * Check settings
     *
     * @see __construct()
     */
    function Image_Transform_Imlib()
    {
        $this->__construct();
    }

    /**
     * Check settings
     *
     * @return mixed true or  or a PEAR error object on error
     *
     * @see PEAR::isError()
     */
    function __construct()
    {
        if (!PEAR::loadExtension('imlib')) {
            $this->isError(
                PEAR::raiseError(
                    'Couldn\'t find the imlib extension.',
                    IMAGE_TRANSFORM_ERROR_UNSUPPORTED
                )
            );
        }
    }

    // }}}
    // {{{ load()

    /**
     * Load image
     *
     * @param string filename
     *
     * @return mixed TRUE or a PEAR error object on error
     * @see PEAR::isError()
     */
    function load($image)
    {
        $this->image = $image;
        $this->imageHandle = imlib_load_image($this->image);
        $result =& $this->_get_image_details($image);
        if (PEAR::isError($result)) {
            return $result;
        }

        return true;
    }

    // }}}
    // {{{ addText()

    /**
     * Adds text to the image.  Note that the angle should be one of the following
     * constants:  IMLIB_TEXT_TO_RIGHT, IMLIB_TEXT_TO_LEFT, IMLIB_TEXT_TO_DOWN,
     * IMLIB_TEXT_TO_UP, IMLIB_TEXT_TO_ANGLE
     *
     * @param   array   options     Array contains options
     *                              array(
     *                                  'text'  The string to draw
     *                                  'x'     Horizontal position
     *                                  'y'     Vertical Position
     *                                  'color' Font color
     *                                  'font'  Font to be used
     *                                  'size'  Size of the fonts in pixel
     *                                  'angle' A imlib direction constant
     *                              )
     *
     * @return TRUE or PEAR Error object on error
     * @see PEAR::isError()
     */
    function addText($params)
    {
        $default_params = array(
                                'text' => 'This is Text',
                                'x' => 10,
                                'y' => 20,
                                'color' => array(255,0,0),
                                'font' => 'Arial.ttf',
                                'size' => '12',
                                'angle' => IMLIB_TEXT_TO_RIGHT,
                                );
        $params = array_merge($default_params, $params);
        extract($params);

        if (!is_array($color)){
            if ($color[0] == '#'){
                $color = $this->colorhex2colorarray($color);
            } else {
                include_once 'Image/Transform/Driver/ColorsDefs.php';
                $color = isset($colornames[$color]) ? $colornames[$color] : false;
            }
        }

        $fontResource = imlib_load_font($font . '/' . $size);
        imlib_text_draw($this->imageHandle, $fontResource, $x, $y, $text, $angle, $color[0], $color[1], $color[2], 255);
        return true;
    }

    // }}}
    // {{{ rotate()

    /**
     * Rotate image by the given angle
     *
     * @param int       $angle      Rotation angle
     *
     * @return TRUE or PEAR Error object on error
     */
    function rotate($angle)
    {
        $this->oldHandle = $this->imageHandle;
        $this->imageHandle = imlib_create_rotated_image($this->imageHandle, $angle);
        $new_x = imlib_image_get_width($this->imageHandle);
        $new_y = imlib_image_get_height($this->imageHandle);
        // when rotating it creates a bigger picture than before so that it can rotate at any angle
        // so for right angles we crop it back to the original size
        if ($angle % 90 == 0) {
            if (abs($angle) == 90 || $angle == 270) {
                $y_pos = ($new_x - $this->img_x) / 2;
                $x_pos = ($new_y - $this->img_y) / 2;
                $y_pos++;
                $x_pos++;
                $this->crop($this->img_y, $this->img_x, $x_pos, $y_pos);
            } else {
                $x_pos = ($new_x - $this->img_x) / 2;
                $y_pos = ($new_y - $this->img_y) / 2;
                $this->crop($this->img_x, $this->img_y, $x_pos, $y_pos);
            }
        } else {
            $this->img_x = $new_x;
            $this->img_y = $new_y;
        }

        return true;
    }

    // }}}
    // {{{ crop()

    /**
     * Crops the current image to a specified height and width
     *
     * @param int $in_cropWidth The width of the new image
     * @param int $in_cropHeight The height of the new image
     * @param int $in_cropX The X coordinate on the image to start the crop
     * @param int $in_cropY The Y coordinate on the image to start the crop
     *
     * @access public
     * @return TRUE or PEAR Error object on error
     */
    function crop($in_cropWidth, $in_cropHeight, $in_cropX, $in_cropY)
    {
        // Sanity check
        if (!$this->_intersects($in_cropWidth, $in_cropHeight, $in_cropX, $in_cropY)) {
            return PEAR::raiseError('Nothing to crop', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        $this->oldHandle = $this->imageHandle;
        $this->imageHandle = imlib_create_cropped_image($this->imageHandle, $in_cropX, $in_cropY, $in_cropWidth, $in_cropHeight);
        $this->img_x = $in_cropWidth;
        $this->img_y = $in_cropHeight;
        return true;
    }

    // }}}
    // {{{ save()

    /**
     * Save the image file.  Determines what type of image to save based on extension.
     *
     * @param $filename string  the name of the file to write to
     * @param $type     string  (optional) define the output format, default
     *                          is the current used format
     * @param $quality  int     (optional) output DPI, default is 75
     *
     * @return TRUE on success or PEAR Error object on error
     */
    function save($filename, $type = '', $quality = 75)
    {
        if (!is_resource($this->imageHandle)) {
            return PEAR::raiseError('Invalid image', true);
        }

        $err = 0;
        $type    = ($type == '') ? $this->type : $type;
        $quality = (is_null($quality)) ? $this->_options['quality'] : $quality;
        imlib_image_set_format($this->imageHandle, $type);
        $return = imlib_save_image($this->imageHandle, $filename, $err, $quality);
        $this->imageHandle = $this->oldHandle;
        $this->resized = false;
        if (!$return) {
            return PEAR::raiseError('Couldn\'t save image. Reason: ' . $err, true);
        }
        return true;
    }

    // }}}
    // {{{ display()

    /**
     * Display image without saving and lose changes
     *
     * This method adds the Content-type HTTP header
     *
     * @param string $type (optional) (JPG,PNG...);
     * @param int $quality (optional) 75
     *
     * @return TRUE on success or PEAR Error object on error
     */
    function display($type = '', $quality = null)
    {
        if (!is_resource($this->imageHandle)) {
            return PEAR::raiseError('Invalid image', true);
        }

        $type    = ($type == '') ? $this->type : $type;
        $quality = (is_null($quality)) ? $this->_options['quality'] : $quality;
        imlib_image_set_format($this->imageHandle, $type);
        $err = 0;
        header('Content-type: ' . $this->getMimeType($type));
        $return = imlib_dump_image($this->imageHandle, $err, $quality);
        $this->imageHandle = $this->oldHandle;
        $this->resized = false;
        imlib_free_image($this->oldHandle);
        if (!$return) {
            return PEAR::raiseError('Couldn\'t output image. Reason: ' . $err, true);
        }
        return true;
    }

    // }}}
    // {{{ free()

    /**
     * Destroy image handle
     *
     * @return void
     */
    function free()
    {
        if (is_resource($this->imageHandle)) {
            imlib_free_image($this->imageHandle);
        }
    }

    // }}}
    // {{{ _resize()

    /**
     * Resize the image.
     *
     * @access private
     *
     * @param int   $new_x   New width
     * @param int   $new_y   New height
     * @param mixed $options Optional parameters
     *
     * @return TRUE on success or PEAR Error object on error
     * @see PEAR::isError()
     */
    function _resize($new_x, $new_y, $options = null)
    {
        if ($this->resized === true) {
            return PEAR::raiseError('You have already resized the image without saving it.  Your previous resizing will be overwritten', null, PEAR_ERROR_TRIGGER, E_USER_NOTICE);
        }

        $this->oldHandle = $this->imageHandle;
        $this->imageHandle = imlib_create_scaled_image($this->imageHandle, $new_x, $new_y);
        $this->img_x = $new_x;
        $this->img_y = $new_y;
        $this->resized = true;
        return true;
    }

    // }}}
    // {{{ _get_image_details()

    /**
     * Gets the image details
     *
     * @access private
     * @return TRUE on success or PEAR Error object on error
     */
    function _get_image_details()
    {
        $this->img_x = imlib_image_get_width($this->imageHandle);
        $this->img_y = imlib_image_get_height($this->imageHandle);
        $this->type = imlib_image_format($this->imageHandle);
        $this->type = ($this->type == '') ? 'png' : $this->type;
        return true;
    }

    // }}}

    /**
     * Horizontal mirroring
     *
     * @return TRUE on success, PEAR Error object on error
     */
    function mirror()
    {
        imlib_image_flip_horizontal($this->imageHandle);
        return true;
    }

    /**
     * Vertical mirroring
     *
     * @return TRUE on success, PEAR Error object on error
     */
    function flip()
    {
        imlib_image_flip_vertical($this->imageHandle);
        return true;
    }
}]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/Driver/NetPBM.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php

/* vim: set expandtab tabstop=4 shiftwidth=4: */

/**
 * NetPBM implementation for Image_Transform package
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category   Image
 * @package    Image_Transform
 * @author     Peter Bowyer <peter@mapledesign.co.uk>
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2002-2005 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    CVS: $Id: NetPBM.php 236527 2007-05-28 16:36:09Z dufuz $
 * @link       http://pear.php.net/package/Image_Transform
 */

require_once 'Image/Transform.php';
require_once 'System.php';

/**
 * NetPBM implementation for Image_Transform package
 *
 * @category   Image
 * @package    Image_Transform
 * @subpackage Image_Transform_Driver_NetPBM
 * @author     Peter Bowyer <peter@mapledesign.co.uk>
 * @author     Philippe Jausions <Philippe.Jausions@11abacus.com>
 * @copyright  2002-2005 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: @package_version@
 * @link       http://pear.php.net/package/Image_Transform
 * @link       http://netpbm.sourceforge.net/
 */
class Image_Transform_Driver_NetPBM extends Image_Transform
{
    /**
     * associative array commands to be executed
     * @var array
     */
    var $command = array();

    /**
     * Class Constructor
     */
    function Image_Transform_Driver_NetPBM()
    {
        $this->__construct();

    } // End function Image_NetPBM

    /**
     * Class Constructor
     */
    function __construct()
    {
        if (!defined('IMAGE_TRANSFORM_NETPBM_PATH')) {
            $path = dirname(System::which('pnmscale'))
                    . DIRECTORY_SEPARATOR;
            define('IMAGE_TRANSFORM_NETPBM_PATH', $path);
        }
        if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH . 'pnmscale'
                             . ((OS_WINDOWS) ? '.exe' : ''))) {
            $this->isError(PEAR::raiseError('Couldn\'t find "pnmscale" binary',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED));
        }
    } // End function Image_NetPBM

    /**
     * Load image
     *
     * @param string filename
     * @return bool|PEAR_Error TRUE or a PEAR_Error object on error
     * @access public
     */
    function load($image)
    {
        $this->image = $image;
        $result = $this->_get_image_details($image);
        if (PEAR::isError($result)) {
            return $result;
        }
        return true;

    } // End load

    /**
     * Resize the image.
     *
     * @access private
     *
     * @param int   $new_x   New width
     * @param int   $new_y   New height
     * @param mixed $options Optional parameters
     *
     * @return true on success or PEAR Error object on error
     * @see PEAR::isError()
     */
    function _resize($new_x, $new_y, $options = null)
    {
        // there's no technical reason why resize can't be called multiple
        // times...it's just silly to do so
        $scaleMethod = $this->_getOption('scaleMethod', $options, 'smooth');
        switch ($scaleMethod) {
            case 'pixel':
                $scale_x = $new_x / $this->img_x;
                if ($scale_x == $new_y / $this->img_x
                    && $scale_x > 1
                    && floor($scale_x) == $scale_x) {
                    if (System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                                           'pnmenlarge'
                                           . ((OS_WINDOWS) ? '.exe' : ''))) {
                        $this->command[] = $this->_prepare_cmd(
                            IMAGE_TRANSFORM_NETPBM_PATH,
                            'pnmenlarge',
                            $scale_x);
                    } else {
                        return PEAR::raiseError('Couldn\'t find "pnmenlarge" binary',
                            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
                    }
                } else {
                    $this->command[] = $this->_prepare_cmd(
                        IMAGE_TRANSFORM_NETPBM_PATH,
                        'pnmscale',
                        '-nomix -width ' . ((int) $new_x)
                            . ' -height ' . ((int) $new_y));
                }
                break;

            case 'smooth':
            default:
                $this->command[] = $this->_prepare_cmd(
                    IMAGE_TRANSFORM_NETPBM_PATH,
                    'pnmscale',
                    '-width ' . ((int) $new_x) . ' -height '
                        . ((int) $new_y));
                // Smooth things if scaling by a factor more than 3
                // (see pnmscale man page)
                if ($new_x / $this->img_x > 3
                    || $new_y / $this->img_y > 3) {
                    if (System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                                           'pnmsmooth' . ((OS_WINDOWS) ? '.exe' : ''))) {
                        $this->command[] = $this->_prepare_cmd(
                            IMAGE_TRANSFORM_NETPBM_PATH,
                            'pnmsmooth');
                    } else {
                        return PEAR::raiseError('Couldn\'t find "pnmsmooth" binary',
                            IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
                    }
                }
        } // End [SWITCH]

        $this->_set_new_x($new_x);
        $this->_set_new_y($new_y);
        return true;

    } // End resize

    /**
     * Rotates the image
     *
     * @param int $angle The angle to rotate the image through
     * @param array $options
     * @return bool|PEAR_Error TRUE on success, PEAR_Error object on error
     */
    function rotate($angle, $options = null)
    {
        if (!($angle == $this->_rotation_angle($angle))) {
            // No rotation needed
            return true;
        }

        // For pnmrotate, we want to limit rotations from -45 to +45 degrees
        // even if acceptable range is -90 to +90 (see pnmrotate man page)
        // Bring image to that range by using pamflip
        if ($angle > 45 && $angle < 315) {
            if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                                   'pamflip' . ((OS_WINDOWS) ? '.exe' : ''))) {
                return PEAR::raiseError('Couldn\'t find "pamflip" binary',
                    IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
            }

            $quarters = floor(ceil($angle / 45) / 2);
            $this->command[] = $this->_prepare_cmd(
                IMAGE_TRANSFORM_NETPBM_PATH,
                'pamflip',
                '-rotate' . (360 - $quarters * 90));
            $angle -= $quarters * 90;
        }

        if ($angle != 0) {
            if ($angle > 45) {
                $angle -= 360;
            }

            if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                                   'pnmrotate' . ((OS_WINDOWS) ? '.exe' : ''))) {
                return PEAR::raiseError('Couldn\'t find "pnmrotate" binary',
                    IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
            }

            $bgcolor = $this->_getColor('canvasColor', $options,
                                            array(255, 255, 255));
            $bgcolor = $this->colorarray2colorhex($bgcolor);

            $scaleMethod = $this->_getOption('scaleMethod', $options, 'smooth');
            if ($scaleMethod != 'pixel') {
                $this->command[] = $this->_prepare_cmd(
                    IMAGE_TRANSFORM_NETPBM_PATH,
                    'pnmrotate',
                    '-background=' . $bgcolor . ' -' . (float) $angle);
            } else {
                $this->command[] = $this->_prepare_cmd(
                    IMAGE_TRANSFORM_NETPBM_PATH,
                    'pnmrotate',
                    '-background=' . $bgcolor . ' -noantialias -' . (float) $angle);
            }
        }
        return true;
    } // End rotate

    /**
     * Crop an image
     *
     * @param int $width Cropped image width
     * @param int $height Cropped image height
     * @param int $x positive X-coordinate to crop at
     * @param int $y positive Y-coordinate to crop at
     *
     * @return mixed TRUE or a PEAR error object on error
     * @todo keep track of the new cropped size
     **/
    function crop($width, $height, $x = 0, $y = 0)
    {
        // Sanity check
        if (!$this->intersects($width, $height, $x, $y)) {
            return PEAR::raiseError('Nothing to crop', IMAGE_TRANSFORM_ERROR_OUTOFBOUND);
        }
        if ($x != 0 || $y != 0
            || $width != $this->img_x
            || $height != $this->img_y) {
            if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                                   'pnmcut' . ((OS_WINDOWS) ? '.exe' : ''))) {
                return PEAR::raiseError('Couldn\'t find "pnmcut" binary',
                    IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
            }

            $this->command[] = $this->_prepare_cmd(
                IMAGE_TRANSFORM_NETPBM_PATH,
                'pnmcut',
                '-left ' . ((int) $x)
                    . ' -top ' . ((int) $y)
                    . ' -width ' . ((int) $width)
                    . ' -height ' . ((int) $height));
        }
        return true;
    } // End crop

    /**
     * Adjust the image gamma
     *
     * @param float $outputgamma
     *
     * @return mixed TRUE or a PEAR error object on error
     */
    function gamma($outputgamma = 1.0) {
        if ($outputgamme != 1.0) {
            if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                                   'pnmgamma' . ((OS_WINDOWS) ? '.exe' : ''))) {
                return PEAR::raiseError('Couldn\'t find "pnmgamma" binary',
                    IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
            }
            $this->command[] = $this->_prepare_cmd(
                IMAGE_TRANSFORM_NETPBM_PATH,
                'pnmgamma',
                (float) $outputgamma);
        }
        return true;
    }

    /**
     * Vertical mirroring
     *
     * @see mirror()
     * @return TRUE or PEAR Error object on error
     **/
    function flip()
    {
        if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                               'pamflip' . ((OS_WINDOWS) ? '.exe' : ''))) {
            return PEAR::raiseError('Couldn\'t find "pamflip" binary',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }
        $this->command[] = $this->_prepare_cmd(
            IMAGE_TRANSFORM_NETPBM_PATH,
            'pamflip',
            '-topbottom');
        return true;
    }

    /**
     * Horizontal mirroring
     *
     * @see flip()
     * @return TRUE or PEAR Error object on error
     **/
    function mirror()
    {
        if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                               'pamflip' . ((OS_WINDOWS) ? '.exe' : ''))) {
            return PEAR::raiseError('Couldn\'t find "pamflip" binary',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }
        $this->command[] = $this->_prepare_cmd(
            IMAGE_TRANSFORM_NETPBM_PATH,
            'pamflip',
            '-leftright');
        return true;
    }

    /**
     * Converts an image into greyscale colors
     *
     * @access public
     * @return mixed TRUE or a PEAR error object on error
     **/
    function greyscale()
    {
        if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                               'ppmtopgm' . ((OS_WINDOWS) ? '.exe' : ''))) {
            return PEAR::raiseError('Couldn\'t find "ppmtopgm" binary',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }
        $this->command[] = $this->_prepare_cmd(
            IMAGE_TRANSFORM_NETPBM_PATH,
            'ppmtopgm');
        return true;
    }

    /**
     * adds text to an image
     *
     * @param   array   options     Array contains options
     *             array(
     *                  'text'          // The string to draw
     *                  'x'             // Horizontal position
     *                  'y'             // Vertical Position
     *                  'color'         // Font color
     *                  'font'          // Font to be used
     *                  'size'          // Size of the fonts in pixel
     *                  'resize_first'  // Tell if the image has to be resized
     *                                  // before drawing the text
     *                   )
     *
     * @return void
     */
    function addText($params)
    {
        if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH .
                               'ppmlabel' . ((OS_WINDOWS) ? '.exe' : ''))) {
            return PEAR::raiseError('Couldn\'t find "ppmlabel" binary',
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }

        // we ignore 'resize_first' since the more logical approach would be
        // for the user to just call $this->_resize() _first_ ;)
        extract(array_merge($this->_get_default_text_params(), $params));

        $options = array('colorFont' => $color);
        $color = $this->_getColor('colorFont', $options, array(0, 0, 0));
        $color = $this->colorarray2colorhex($color);

        $this->command[] = $this->_prepare_cmd(
            IMAGE_TRANSFORM_NETPBM_PATH,
            'ppmlabel',
            '-angle ' . ((int) $angle)
                . ' -colour ' . escapeshellarg($color)
                . ' -size ' . ((float) $size)
                . ' -x ' . ((int) $x)
                . ' -y ' . ((int) ($y + $size))
                . ' -text ' . escapeshellarg($text));

    } // End addText

    /**
     * Image_Transform_Driver_NetPBM::_postProcess()
     *
     * @param $type
     * @param $quality
     * @return string A chain of shell command
     * @link http://netpbm.sourceforge.net/doc/directory.html
     */
    function _postProcess($type, $quality)
    {
        array_unshift($this->command, $this->_prepare_cmd(
            IMAGE_TRANSFORM_NETPBM_PATH,
            strtolower($this->type) . 'topnm',
            escapeshellarg($this->image)));
        $arg = '';
        $type = strtolower($type);
        $program = '';
        switch ($type) {
            // ppmto* converters
            case 'gif':
                if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH . 'ppmquant'
                                    . ((OS_WINDOWS) ? '.exe' : ''))) {
                    return PEAR::raiseError('Couldn\'t find "ppmquant" binary',
                        IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
                }
                $this->command[] = $this->_prepare_cmd(
                    IMAGE_TRANSFORM_NETPBM_PATH,
                    'ppmquant',
                    256);
            case 'acad':
            case 'bmp':
            case 'eyuv':
            case 'ilbm':
            case 'leaf':
            case 'lj':
            case 'mitsu':
            case 'mpeg':
            case 'neo':
            case 'pcx':
            case 'pi1':
            case 'pict':
            case 'pj':
            case 'pjxl':
            case 'puzz':
            case 'sixel':
            case 'tga':
            case 'uil':
            case 'xpm':
            case 'yuv':
                $program = 'ppmto' . $type;
                break;

            // Windows icon
            case 'winicon':
            case 'ico':
                $type = 'winicon';
                $program = 'ppmto' . $type;
                break;

            // pbmto* converters
            case 'ascii':
            case 'text':
            case 'txt':
                $type = 'ascii';
            case 'atk':
            case 'bbubg':
            case 'epsi':
            case 'epson':
            case 'escp2':
            case 'icon':    // Sun icon
            case 'gem':
            case 'go':
            case 'lj':
            case 'ln03':
            case 'lps':
            case 'macp':
            case 'mda':
            case 'mgr':
            case 'pi3':
            case 'pk':
            case 'plot':
            case 'ptx':
            case 'wbp':
            case 'xbm':
            case 'x10bm':
            case 'ybm':
            case 'zinc':
            case '10x':
                $program = 'pbmto' . $type;
                break;

            // pamto* converters
            case 'jpc':
                $type = 'jpeg2k';
            case 'html':
            case 'pfm':
            case 'tga':
                $program = 'pamto' . $type;
                break;

            // pnmto* converters
            case 'jpc':
                $type = 'jpeg2k';
                break;
            case 'wfa':
                $type = 'fiasco';
                break;
            case 'jpg':
                $type = 'jpeg';
            case 'jpeg':
                $arg = '--quality=' . $quality;
            case 'jbig':
            case 'fits':
            case 'palm':
            case 'pclxl':
            case 'png':
            case 'ps':
            case 'rast':
            case 'rle':
            case 'sgi':
            case 'sir':
            case 'tiff':
            case 'xwd':
                $program = 'pnmto' . $type;
                break;

        } // switch

        if ($program == '') {
            $program = 'pnmto' . $type;
        }

        if (!System::which(IMAGE_TRANSFORM_NETPBM_PATH . $program
                            . ((OS_WINDOWS) ? '.exe' : ''))) {
            return PEAR::raiseError("Couldn't find \"$program\" binary",
                IMAGE_TRANSFORM_ERROR_UNSUPPORTED);
        }
        $this->command[] = $this->_prepare_cmd(
            IMAGE_TRANSFORM_NETPBM_PATH,
            $program);
        return implode('|', $this->command);
    }

    /**
     * Save the image file
     *
     * @param $filename string the name of the file to write to
     * @param string $type (jpeg,png...);
     * @param int $quality 75
     * @return TRUE or PEAR Error object on error
     */
    function save($filename, $type = null, $quality = 75)
    {
        $type    = (is_null($type)) ? $this->type : $type;
        $options = array();
        if (!is_null($quality)) {
            $options['quality'] = $quality;
        }
        $quality = $this->_getOption('quality', $options, $quality);

        $nullDevice = (OS_WINDOWS) ? 'nul' : '/dev/null';

        $cmd = $this->_postProcess($type, $quality) . '> "' . $filename . '"';
        exec($cmd . ' 2>  ' . $nullDevice, $res, $exit);
        if (!$this->keep_settings_on_save) {
            $this->free();
        }

        return ($exit == 0) ? true : PEAR::raiseError(implode('. ', $res),
            IMAGE_TRANSFORM_ERROR_IO);
    } // End save

    /**
     * Display image without saving and lose changes
     *
     * @param string $type (jpeg,png...);
     * @param int $quality 75
     * @return TRUE or PEAR Error object on error
     */
    function display($type = null, $quality = null)
    {
        $type    = (is_null($type)) ? $this->type : $type;
        $options = array();
        if (!is_null($quality)) {
            $options['quality'] = $quality;
        }
        $quality = $this->_getOption('quality', $options, 75);

        header('Content-type: ' . $this->getMimeType($type));
        $cmd = $this->_postProcess($type, $quality);
        passthru($cmd . ' 2>&1');
        if (!$this->keep_settings_on_save) {
            $this->free();
        }

        return true;
    }

    /**
     * Destroy image handle
     *
     * @return void
     */
    function free()
    {
        $this->command = array();
    }
} // End class ImageIM]]></data>
	</file>
	<file>
	  <filename>/lib/external/Image/~backup/Transform/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/lib/external/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/lib/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/method.install.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.uninstall.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.upgrade.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/moduleinfo.ini</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[W21vZHVsZV0KbmFtZSA9IENhdGFsb2dlcgp2ZXJzaW9uID0gMS4wLjEKZGVzY3JpcHRpb24gPSAKYXV0aG9yID0gSm9Nb3JnCmF1dGhvcmVtYWlsID0gam9tb3JnLm1vcmdAZ21haWwuY29tCm1pbmNtc3ZlcnNpb24gPSAyLjEKbGF6eWxvYWRhZG1pbiA9IDAKbGF6eWxvYWRmcm9udGVuZCA9IDAK]]></data>
	</file>
	<file>
	  <filename>/templates/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/adminattrs.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/adminglobalops.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRpbm5lcm5hdn0KPGJyIC8+CjxoMz57JGNhdGVnb3J5fTwvaDM+CntpZiAkbWVzc2FnZSE9Jyd9PGg0PnskbWVzc2FnZX08L2g0PnsvaWZ9Cnskc3RhcnRmb3JtfQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgICAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfY2F0ZWdvcnlfcmVjdXJzZX08L3A+CiAgICAgICAgPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRpbnB1dF9jYXRlZ29yeV9yZWN1cnNlfTwvcD4KCTwvZGl2PgoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KICAgICAgICA8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfaXRlbXNfcGVyX3BhZ2V9PC9wPgogICAgICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfaXRlbXNfcGVyX3BhZ2V9PC9wPgoJPC9kaXY+Cgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgogICAgICAgIDxwIGNsYXNzPSJwYWdldGV4dCI+eyR0aXRsZV9pdGVtX3NvcnRfb3JkZXJ9PC9wPgogICAgICAgIDxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfaXRlbV9zb3J0X29yZGVyfTwvcD4KCTwvZGl2PgoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCQk8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1Ym1pdH08L3A+Cgk8L2Rpdj4KeyRlbmRmb3JtfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/adminpanel.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/adminprefs.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/changelog.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/edittemplate.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmICRtZXNzYWdlIT0nJ308cCBjbGFzcz0icGFnZW1lc3NhZ2UiPnskbWVzc2FnZX08L3A+ey9pZn0NCnskaW5uZXJuYXZ9DQo8YnIgLz4NCjxoMz57JG9wfTwvaDM+DQoNCnskc3RhcnRmb3JtfQ0KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+DQoJCTxwIGNsYXNzPSJwYWdldGV4dCI+KnskdGl0bGVfdGl0bGV9OjwvcD4NCgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRpbnB1dF90aXRsZX08L3A+DQoJPC9kaXY+DQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4qeyR0aXRsZV90ZW1wbGF0ZV90eXBlfTo8L3A+DQoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfdGVtcGxhdGVfdHlwZX08L3A+DQoJPC9kaXY+DQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4qeyR0aXRsZV90ZW1wbGF0ZX06PC9wPg0KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X3RlbXBsYXRlfTwvcD4NCgk8L2Rpdj4NCgk8ZGl2IGlkPSJhdmFpbGFibGUiPnskYXZhaWxfYXR0cnN9PC9kaXY+DQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+DQoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaGlkZGVufXskc3VibWl0fSB7JGFwcGx5fTwvcD4NCgk8L2Rpdj4NCnskZW5kZm9ybX0NCg==]]></data>
	</file>
	<file>
	  <filename>/templates/error.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGgxPnskZXJyb3J9PC9oMT4KeyRlcnJvcn0=]]></data>
	</file>
	<file>
	  <filename>/templates/help.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[{* Tabs Headers *}
<div id="page_tabs">
  <div id="general">
    What Is It
  </div>    
  <div id="how">
    How To Use It
  </div>    
  <div id="featurelists">
    Feature Lists
  </div>    
  <div id="imagesys">
    Cataloger Image System
  </div>
  <div id="advanced">
    Customization and Advanced Topics
  </div>
  <div id="whatsnew">
    What's new
  </div>
  <div id="about">
    About
  </div>
</div>       
{* Tabs Headers *}

<div class="clearb"></div>

{* Tabs Contents *}
<div id="page_content">
{*************************************************************************************}
{* What Is It *}
  <div id="general_c">
    <h3>What Does This Do?</h3>
    <p>This module lets you create online catalogs or portfolios. Catalogs consist of <strong></strong>"Catalog Items"</strong> which could be products, works of art, or the like, and <strong>"Catalog Categories"</strong> which could be item categories or other natural divisions of the catalog.</p>
    <p>Categories may be defined hierarchically (using the standard CMS Made Simple content list). Category pages can display items in the category and/or subcategories, optionally recursing through sub-categories. This behavior can be configured on a per-category basis.</P>
    <p>There is also a <strong>"Printable Catalog"</strong>, which represents the whole collection of Catalog Items on a single page.</p>
    <p>The module has built-in support for <strong>"Content Aliases"</strong> (a module available at <a href="http://dev.cmsmadesimple.org/projects/contentaliases">the Developer Forge</a>), which allows you to place any Catalog Item into multiple Catalog Categories.</p>
    <p><div class='warning'>As of version 1.0 Cataloger only works on CMSMS 2.x.</div></p>
  </div>
  {*************************************************************************************}
  {* How To Use It *}
  <div id="how_c">
    <h3>How Do I Use It</h3>
    <p>When you install this module, it creates three new Content Types: <strong>Catalog Item</strong>, <strong>Catalog Category</strong>, and <strong>Printable Catalog</strong>. When you're in your site administration category, you add <strong>Catalog Items</strong> and <strong>Catalog Categories</strong> just as you would any other kind of page. Select Content &gt; Pages &gt; Add Content, and then select <strong>"Catalog Item"</strong> or <strong>"Catalog Category"</strong> from the <strong>Content Type pulldown</strong>.</p>
    <h4>Catalog Items</h4>
    <p>Adding a <strong>Catalog Item</strong> is similar to adding an ordinary page to your site. The data fields for the Item are not exactly the same, however. Also note that in the "Images" tab, you can select multiple images to upload for the item. When you upload images, the system will size them appropriately for the catalog, create thumbnails for use in the Item's page, create thumbnails for any Category pages, and so on.</p>
    <p><div class='warning'>See image use below.</div></p>

    <h4>Catalog Categories</h4>
    <p>A <strong>Catalog Category</strong> is used for organizing your catalog items. It provides a page that lists Cataloger content that is contained by it. A Catalog Item is considered to be part of a Catalog Category if it is below that Category in the Site Hierarchy. Categories can similarly include other Categories.</p>
    <p>Catalog Categories have a number of settings to determine how they should display the Items and Categories they contain: if you look at the <strong>"Options"</strong> tab, you can choose how many items and/or categories to show, what order to show them in, whether to display only items or only categories or both, and how many levels of the hierarchy to display below the category page.</p>
    <br>
    <p>For example, consider the following structure:</p>
    <ol>
      <li><b>Hats</b>
        <ol>
          <li><b>Fashion</b>
             <ol>
               <li>Feathered Hat</li><li>Fedora </li><li>Baseball Hat</li>
             </ol>
           </li>
           <li><b>Work Hats</b>
              <ol>
                <li>Hard Hat</li><li>Diving Helmet</li>
              </ol>
            </li>
        </ol>
      </li>
    </ol>
    <p>In this diagram, items in bold are Catalog Categories, all other items are Catalog Items. Depending upon how you set your options, the <strong>Hats</strong> Category Page can show only entries for the <strong>Fashion</strong> and <strong>Work Hats</strong> Category Pages, or it can show entries for <strong>Fashion</strong>, <strong>Work Hats</strong>, and all the hats listed below them.</p>
    <p>You can opt to show the items in "natural" order (i.e., the order the Items show up in the CMS Content Hierarchy), or in alphabetical order.</P>
    <p>If you have large numbers of items in a Category, you can set the maximum number to be displayed in a Category Page, and the page will automatically create links to navigate through the list.</p>
    <p>Each Category page can have different settings for sort order, levels to display, and number of items. You can set the default for these values in <strong><em>Extensions &gt; Cataloger &gt; Manage Preferences</em></strong>. If, at a later date, you wish to change some setting on all of your Category pages, you can go into <strong><em>Extensions &gt; Cataloger &gt; Global Catalog Options</em></strong>, and make those changes.</p>
    <h4>Images</h4>
    <p>Cataloger allows you to select different size images for Item pages, Category pages, and the Printable Catalog. You can set these defaults in <strong><em>Extensions &gt; Cataloger &gt; Manage Preferences</em></strong>.</p>
    <p>When you upload images, the original is stored. When someone visits a page, the reduced size images are requested using a special URL, which will load the scaled image if it exists, creating it if it doesn't. This allows you to change the size of images, without having to re-upload all the images, or rescaling them all at once.</p>
    <p><div class='warning'>The image rescaling code requires that you have either ImageMagick or GD lib installed.</div></p>
    <p><div class='information'>Currently, only jpeg format images are supported.</div></p>
    <h4>Files</h4>
    <p>Cataloger allows you to associate arbitrary files with any Item page. These are uploaded via the admin, just like images.
    <p><div class='warning'>There have been rudimentary security considerations (e.g., file-extension-based restrictions), however, as with any file upload capability that puts files inside the web root, if you do not trust your uploaders, you are at some degree of risk. You have been warned.</div></p>
  </div>
  {*************************************************************************************}
  {* Feature Lists *}
  <div id="featurelists_c">
    <h3>Feature Lists</h3>
    <p>You can, as of <strong>version 0.4</strong>, have <strong>"feature lists"</strong> which are the <strong><em>n</em></strong> most-recently added catalog items, or a collection of <strong><em>k</em></strong> random items from the catalog.</p>
    <h4>"All" Feature List</h4>
    <p>To get a list of all catalog items (optionally under a specified part of your hierarchy) for processing via a template, you can use
    the <strong>"all"</strong> feature list.</p>
    <p>The syntax for an <strong>"all"</strong> list is like:</p>
    <pre><strong>&#123;Cataloger action='all' sub_template='my_sub_template'}</strong></pre>
    <p>where sub_template is the template to use to render the list.</p>
    <p>There is an optional parameter, <strong>alias='page_alias'</strong>, where page_alias indicates the top of the tree (e.g., a place in your menu
    hierarchy, typically a category page) in which to look for new items. A special value for <strong>"page_alias"</strong> is <strong>"/"</strong>, which means to start at the root.</p>
    <p>This is useful for catalog-wide operations. For example, to get a list of all categories (and do something with them),
    you could use the tag:</p> 
    <pre><strong>&#123;Cataloger action='all' sub_template='my_sub_template' alias='/' recurse='categories_all'}</strong></pre>   
    <p>Your template could then throw those categories into a pulldown menu that redirected you to that category's page, for example:</p>
    <pre>
    &lt;select name="foo" onchange="document.location=this.options[this.selectedIndex].value;">
    &lt;option value="">Select A target&lt;/option>
    &#123;foreach from=$items item=thisone}
       &lt;option value="&#123;$thisone.link}">&#123;$thisone.title}&lt;/option>
    &#123;/foreach}
    &lt;/select></pre>
    <p>If you wanted that to only show categories that were in the very top level of your hierarchy, you'd replace the <strong>recurse='categories_all'</strong> with <strong>recurse='categories_one'</strong>. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:</p>
    <pre><strong>&#123;Cataloger action='all' sub_template='my_sub_template' alias='/' recurse='items_all'}</strong></pre>
    <p>Similarly, you could have it list only categories under the current page (by omitting the <strong>"alias='/'"</strong>). The combinations are basically limitless!</p>
    <p>All supported values of recurse include:
    <ul>
      <li><strong>items_one</strong> - Catalog items, no more than one level below the current page (or alias point)</li>
      <li><strong>items_all</strong> - Catalog items, at any level below the current page (or alias point)</li>
      <li><strong>categories_one</strong> - Categories, no more than one level below the current page (or alias point)</li>
      <li><strong>categories_all</strong> - Categories, at any level below the current page (or alias point)</li>
      <li><strong>mixed_one</strong> - Catalog items and Categories, no more than one level below the current page (or alias point)</li>
      <li><strong>mixed_all</strong> - Catalog items and Categories, at any level below the current page (or alias point)</li>
    </ul>
    </p>
    <p>Items in these lists come back in hierarchy order. You can change this using the <strong>'global_sort'</strong> parameter. Your choices are:</p>
    <ul>
      <li><strong>alpha</strong> - alphabetically by title</li>
      <li><strong>date</strong> - in order of item creation date</li>
      <li><strong>mdate</strong> - in order of item modification date</li>
    </ul>
    <p>You may order these sorts using the <strong>'global_sort_dir'</strong> parameter, which will allow <strong>'asc'</strong> or <strong>'desc'</strong>.</p>
    <p>So, for a thorough example:</p>
    <pre><strong>&#123;Cataloger action='all' sub_template='my_sub_template' alias='/' recurse='categories_all' global_sort='alpha' global_sort_dir='asc'}</strong></pre> 
    <h4>Recently Added Feature List</h4>
    <p>To use a "most-recently added" list will allow you to display the most recently-added catalog items under a specified part of your hierarchy.</p>
    <p>The syntax for a "most recently added" list is like:</p>
    <pre><strong>&#123;Cataloger action='recent' sub_template='my_sub_template'}</strong></pre> 
    <p>where sub_template is the template to use to render the list. There are four optional parameters, <strong>count='3'</strong>, <strong>alias='page_alias'</strong>, <strong>global_sort='date'</strong>, <strong>global_sort_dir='desc'</strong> where <strong>count</strong> is the number of items to include, <strong>page_alias</strong> indicates the top of the tree (e.g., a place in your menu hierarchy, typically a category page) in which to look for new items. A special value for <strong>"page_alias"</strong> is <strong>"/"</strong>, which means to use <i>all</i> pages in the site. <strong>global_sort</strong> may be <strong>'date'</strong> (for item creation date) or </strong>'mdate'</strong> for modification date, and <strong>global_sort_dir</strong> may be <strong>'asc'</strong> or <strong>'desc'</strong>.</p>
    <h4>Random Items Feature List</h4>
    <p>The syntax for a "random" list is like:</p>
    <pre><strong>&#123;Cataloger action='random' sub_template='my_sub_template'}</strong></pre> 
    <p>where sub_template is the template to use to render the list. There are two optional parameters, <strong>count='3'</strong> and <strong>alias='page_alias'</strong>, where <strong>count</strong> is the number of items to include, and <strong>page_alias</strong> indicates the top of the tree (e.g., a place in your menu hierarchy, typically a category page) in which to look for new items. A special value for <strong>"page_alias"</strong> is <strong>"/"</strong>, which means to use <i>all</i> pages in the site.</p>
  </div>
  {*************************************************************************************}
  {* Image System *}
  <div id="imagesys_c">
    <h3>Cataloger Image System</h3>
    <p>Cataloger has an image system that will allow you to dynamically change the image display size. If you do not like it, you can alter
    the templates and use any image system you want.</p>
    <p>When you upload an image using Cataloger, it gets put in a special set of directories to make the imaging easier. You will see more
    about this later.</p>
    <p>It works by calling a PHP program instead of directly referencing the image. The program uses the filename to see if the
    image already exists in the correct size. If so, it uses that image. Otherwise, it uses your <strong>GDLIB</strong> or <strong>ImageMagick</strong> to create the image in the correct size, and then redirects to it.</p>
    <h4>Cataloger Image Filespec Explanation</h4>
    <p>A cataloger image has a filespec like:</p>
    <pre>&lsaquo;root&rsaquo;/cataloger_image(.page_extention)?i=itemname_f_1_400_1.jpg&amp;ac=82888</pre>
    <p><div class='information'>There are differences in image handling in <strong>Cataloger</strong> since <strong>version 1.0</strong>.<br>The old spec has been removed, and is no longer used,<br> i.e.: <strong>&lsaquo;root_path&rsaquo;/modules/Cataloger/Cataloger.Image.php?i=itemname_f_1_400_1.jpg&ac=82888</strong> spec as explained and used on previous versions <strong>no longer works</strong>.<br>To be more precise, <strong>Cataloger.Image.php</strong> is no longer valid as it used an unsupported method of calling CMSMS core functions. However the filename specs still apply, such as <strong>itemname_f_1_400_1.jpg&ac=82888</strong> along with the <strong>ac</strong> parameter as explained below.</div></p>
    <p><div class='warning'><strong>Cataloger.Image.php</strong> has been replaced by a module action and <strong>Cataloger</strong> will use the new method automatically. No changes in the sub-templates should be needed unless the developer/designer has, for some reason, hard-coded part of the url on the templates instead of using the generated links.</div></p>
    <p>The interesting thing is <strong>"itemname_f_1_400_1.jpg"</strong> - the stuff before is just a call to the program, and the <strong>&amp;ac=82888</strong> is a random thing that is designed to prevent browser caching. So examining the name piece by piece (separating at the underscores), we have:</p>
    <ul>
      <li><strong>item name</strong> - this is the alias of the item/category page containing the image.</li>
      <li><strong>image type</strong> - this is a designation for image type:
        <ul>
          <li><strong>f</strong> - item full-size image</li>
          <li><strong>t</strong> - item thumbnail</li>
          <li><strong>cf</strong> - category full-sized image</li>
          <li><strong>ct</strong> - category thumbnail</li>
          <li><strong>ctf</strong> - printable catalog full-sized image</li>
        </ul>
      </li>
      <li><strong>image number</strong> - so a given item/catalog/etc can have multiple images</li>
      <li><strong>long dimension</strong> - long dimension of the image, in pixels</li>
      <li><strong>missing flag</strong> - 1 if you want to show an "image missing" image if this image doesn't exist, 0 otherwise</li>
    </ul>
    <p>
    This will take an image in <strong>root_path/uploads/images/catalog_src/itemname_src_1</strong>
    <p>As of <strong>version 1.0 Cataloger</strong> has changed the way it handles images. The <strong>Cataloger.Image.php</strong> file as been removed and all image handling is done through a module action used specifically for that purpose.  This allowed better support to pretty URLs, and file obfuscation as the action doesn't redirect to the generated image but generates a copy of the image without revealing the original image location.</p>
    <h4>Accessing your Original Image</h4>
    <p>When Cataloger uploads images, it puts them into a directory called <strong>"cataloger_src"</strong> in your <strong>uploads/images/</strong> directory. The images are named according to the alias of the page: <strong>alias_src_#.jpg</strong> where # is the image number for that page.</p>
    <p>So, to access the originally uploaded images on a Category page, you'd generate the URL manually.</p>
    <p>So on a category page, for example, instead of using {literal}<strong>{$items[numloop].image}</strong>{/literal} you'd use <strong>"/uploads/images/cataloger_src/{literal}{$items[numloop].alias}_src_1.jpg"</strong>{/literal}.</p>
  </div>
  {*************************************************************************************}
  {* Customization and Advanced Topics *}
  <div id="advanced_c">
    <h3>Customization and Advanced Topics</h3>
    <h4>Catalog Item Attributes</h4>
    <p>The default item attributes are typical for a catalog of products or artworks, but by going into <strong><em>Extensions &gt; Cataloger &gt; Manage User-Defined Attributes</em></strong>, you can change the attributes. It's best to define the attributes before you start entering Catalog Items.</p>
    <p><div class='information'>Note that the attributes you define may need to be added to the template that you're using to display Catalog Items:  see Custom Templates below.</div></p>
    <h4>Catalog Category Attributes</h4>
    <p>Similarly, you can set attributes for Categories. As with Items, the attributes you define may need to be added to the template that you're using to display Catalog Categories.</p>
    <h4>Printable Catalog Attributes</h4>
    <p>Likewise, you can set attributes for Printable Catalogs. As with Items and Categories, the attributes you define may need to be added to the template that you're using to display your Printable Catalog.</p>
    <h4>Variable Action</h4>
    <p>You can grab variables (attributes) outside of your Cataloger templates, using the <strong>variable</strong> action parameter. The syntax looks like:</p>
    <pre><strong>&#123;Cataloger action='variable' name='itemnotes' default='no notes'}</strong></pre> 
    <p>where name is the attribute to display (using the same all lower-case, punctuation-free representation like the smarty template variables), and default is the value to use if the attribute is not defined.</p>
    <h4>Item Comparisons</h4>
    <p>As of <strong>version 0.7.7</strong>, there is a <strong>product comparison</strong> action:</p>
    <pre><strong>&#123;Cataloger action='compare' sub_template='my_sub_template' items='item1,item2,item3'}</strong></pre>
    <p>where sub_template is the template to use to render the list, and items is a comma-delimited list of item page aliases to compare. Bolder users may also choose to pass in the items to compare as request variables, thereby enabling dynamic comparisons based on user selections. Do this by setting the <strong>"items"</strong> variable on the request passed to the page containing the Cataloger tag with a compare action.</p>
    <p>The default item comparison template could use some styling, e.g.,:</p>
    <pre>{literal}
    .item_comparison th {font-weight: bold; padding: 5px; text-align:center;}
    .item_comparison td {border: 1px solid gray; padding: 3px 5px;text-align:right;}{/literal}</pre>
  
    <h4>Custom Templates</h4>
    <p>If you're willing to mess around with <strong>Smarty Templates</strong>, you can change the layout of any of the pages generated by Cataloger. There are four kinds of templates: one kind for <strong>Catalog Items</strong>, one kind for <strong>Catalog Categories</strong>, and one kind for <strong>Printable Catalogs</strong>, and one kind for <strong>"Feature"</strong> lists, such as recently added items or random selections.</p>
    <p>When editing a Template, the admin screen will display a list of Smarty tags available to you for that kind of template. This
    will only happen once the module knows what kind of template you're editing, so when you first create the template, it displays all
    the Smarty tags it knows about, only some of which being applicable.</p>
    <h4>Displaying Attributes on Item Pages</h4>
    <p>Attributes are available to Smarty as top-level variables. They are stored as sanitized versions of the attribute names, which means
    it is converted to lower case and all punctuation and non-US-ASCII characters get removed. This is because Smarty is finicky, and will not handle these characters.</p>
    <p>So, for example, if you have an attribute called <strong>"Glücklichkeit"</strong>, there will be a Smarty variable <strong>{$glcklichkeit}</strong>. Note that the "ü" is omitted.</p>
    <p>Fortunately, this is simplified by the $attrlist list available. This is a list of attributes by formal name ("Glücklichkeit") and their key ("glcklichkeit"). For example:
    <pre>{literal}
      {section name=at loop=$attrlist}
      &lt;div class="item_attribute_name">{$attrlist[at].name}:&lt;/div>&lt;div class="item_attribute_val">{eval var=$attrlist[at].key}&lt;/div>
      {/section}{/literal}</pre>
    <p>As of <strong>version 0.8</strong>, you can assign an alias to each attribute. These aliases need to be US-ASCII and contain no punctuation. They can be used instead of the sanitized attribute name (e.g., you could use the alias "gluecklichkeit").</p>
    <h4>Displaying Attributes on Pages with Lists of Items</h4>
    <p>Attributes are included in the <strong>$itemlists[#]</strong> in two different ways: top-level attributes of the item, and as part of the item's <strong>"attr"</strong> array. They are stored as sanitized versions of the attribute names, which means they are converted to lower case and all punctuation and non-US-ASCII characters get removed. This is because Smarty is finicky, and will not handle these characters.</p>
    <p>So, for example, if you have an attribute called <strong>"Glücklichkeit"</strong>, the item will have <strong>$item.glcklichkeit</strong> and <strong>$item.attrs['glcklichkeit']</strong>. Note that the <strong>"ü"</strong> is omitted. You can refer to this attribute in your template
    with Smarty code like: {literal}<strong>{$itemlist[index].glcklickkeit}</strong> or <strong>{$itemlist[index].attrs.glcklichkeit}</strong>{/literal}.</p>
    <p>Fortunately, this is simplified by the <strong>$attrlist</strong> list available. This is a list of attributes by formal name ("Glücklichkeit") and their key ("glcklichkeit"). For example:
    <pre>{literal}
        {foreach from=$attrlist item=attr key=k}
        {$attr}: {$items[numloop][$k]}
        {/foreach}{/literal}</pre>
    <p>As of <strong>version 0.8</strong>, you can assign an alias to each attribute. These aliases need to be <strong>US-ASCII</strong> and contain no punctuation. They can be used instead of the sanitized attribute name (e.g., you could use the alias "gluecklichkeit").</p>
    <h4>Smarty tags in Attributes</h4>
    <p>Sometimes, you'll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you'll need to
    update your template. For the attributes where you want smarty tags to be active, you'll need to nest the smarty evaluations in your template. For example:</p>
    <pre>{literal}&#123;eval var=$attrlist[at].key}</pre>
    <p>becomes:</p>{/literal}
    <pre>&#123;eval var=$entry->input assign=thisAttr}&#123;eval var=$thisAttr}</pre>
  </div>
  {*************************************************************************************}
  {* what is new *}
  <div id="whatsnew_c">
    <div class="pageoverflow">
      <h3>What's new</h3>
      <p>This is a summary of the most important changes the module as gone through. For details, please consult the changelog.</p>
      <ul>
        <li>
          Cataloger is now exclusively compatible with CMSMS 2.x;
        </li> 
        <li>
          Cataloger is now compatible PHP 7.x;
        </li>  
        <li>
          Cataloger admin menu has moved to content section;
        </li> 
        <li>
          content types now behave, for the most part, like CMSMS core content types:
          <ul>
            <li>all attribute of the typical content type can be found and used;</li>
            <li>additional content blocks can now be used on page templates - Cataloger will allow it's use;</li>
            <li>cataloger pages can now be previewed by Content Manager - Preview tab;</li>
          </ul>
        </li>
        <li>
          sub templates have a new variable with the main content block giving users some freedom regarding its placement;
        </li> 
        <li>
          image tabs will only be visible if there are images set to be used in the module settings;
        </li>  
        <li>
          file tabs will only be visible if there are files set to be used in the module settings;
        </li>   
        <li>
          there have been some changes to sub-templates although backwards compatibility was kept as much as possible;
        </li>    
        <li>
          the location dir of the images is now concealed if Cataloger native image handling is used;
        </li>    
        <li>
          a huge number of <em>under the hood</em> modifications and optimizations was made to the code;
        </li>    
      </ul>
      <p>Although all efforts have been made to test and make sure the module works without issues, given the number of modifications, minor bugs are expected to exist, so please file a Bug Report if you find one.</p>
      <p><div class='warning'>It is strongly recommended a full backup of files and database before an upgrade. Some, more complex, installations may have issues: most, if not all, of them should be solved by clearing CMSMS cache and/or tweaking sub-templates.</div></p>
    </div> 
  </div>
  {*************************************************************************************}
  {* About / Credits *}
  <div id="about_c">
    
    <h3>Support</h3>
    <div class="pageoverflow">
      <p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
      <ul>
        <li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
        <li>To obtain commercial support, please send an email to the author at <a href="mailto:jomorg@sm-art-lab.com">&lt;jomorg@sm-art-lab.com&gt;</a>.</li>
        <li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
        <li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
        <li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
      </ul>
     </div>
       
    <h3>Copyright and License</h3>
    <div class="pageoverflow">    
      <p>As per the GPL, this software is provided as-is. Please read the text of the license for the full disclaimer.</p>

      <p>Copyright &copy; 2012 - {$smarty.now|date_format:'%Y'}, Fernando Morgado (JoMorg) <a href="mailto:jomorg@sm-art-lab.com">&lt;jomorg@sm-art-lab.com&gt;</a>. All Rights Are Reserved.</p>
      <p>Copyright &copy; 2008, Samuel Goldstein. All Rights Are Reserved.</p>
    </div>
    <div class="pageoverflow">  
      <p style="font-size:85%;font-weight: bold;">This program is free software;<br /> you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation;<br /> either version 2 of the License, or (at your option) any later version.</p>
      <p style="font-size:85%;font-weight: bold;">This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;<br /> without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.</p>
      <p style="font-size:85%;font-weight: bold;">See theGNU General Public License for more details.</p>
      <p style="font-size:85%;font-weight: bold;">You should have received a copy of the GNU General Public License along with this program;<br /> if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA <a target="_blank" href="http://www.gnu.org/licenses/licenses.html#GPL">or read it online</a>.</p>
      <p style="font-size:85%;font-weight: bold;">You must agree to this license before using the module.</p>
    </div>
    
    <h3>Credits</h3>
    <p>This module has been originaly created, developed and maintained for a number of years by Samuel Goldstein. Fernando Morgado took over and has been maintaining it (for better or for worst) since 2012.</p>
    <p></p>
    <ul>
      <li><strong>Samuel Goldstein (sjg)</strong> - Creation and development;</li>
      <li><strong>Nuno</strong> - code contributions;</li>
      <li><strong>Morten Poulsen (silmarillion)</strong> - code contributions;</li>
      <li><strong>Fernando Morgado (JoMorg)</strong> - development and maintenance;</li>
    </ul>
    
    <h3>Contributors</h3>
    <ul>
      <li><a target="_blank" href="http://www.id-a.co.uk" rel="external">Paul Cooper</a> - sponsored the development of textarea attributes;</li>
      <li><a target="_blank" href="http://www.matthornsby.ca" rel="external">Matt Homsby (DIGI3)</a> - sponsorship;</li>
    </ul>
    <p>Thanks to numerous patient users and bug testers (many of whom had no idea what they were getting into).</p> 
  </div>
</div>


]]></data>
	</file>
	<file>
	  <filename>/templates/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PCEtLSBEVU1NWSBIVE1MIEZJTEUgLS0+]]></data>
	</file>
	<file>
	  <filename>/templates/templatelist.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRpbm5lcm5hdn0KPGJyIC8+CjxoMz57JHNlY3Rpb259PC9oMz4Ke2lmICRtZXNzYWdlIT0nJ308cD57JG1lc3NhZ2V9PC9wPnsvaWZ9CntpZiAkaXRlbWNvdW50ID4gMH0KPHRhYmxlIGNlbGxzcGFjaW5nPSIwIiBjbGFzcz0icGFnZXRhYmxlIj4KCTx0aGVhZD4KCQk8dHI+CgkJCTx0aD57JHRpdGxlX3RlbXBsYXRlfTwvdGg+CgkJCTx0aD57JHRpdGxlX3RlbXBsYXRlX3R5cGV9PC90aD4KCQkJPHRoIGNsYXNzPSJwYWdlaWNvbiI+Jm5ic3A7PC90aD4KCQkJPHRoIGNsYXNzPSJwYWdlaWNvbiI+Jm5ic3A7PC90aD4KCQk8L3RyPgoJPC90aGVhZD4KCTx0Ym9keT4KCXtmb3JlYWNoIGZyb209JGl0ZW1zIGl0ZW09ZW50cnl9CgkJPHRyIGNsYXNzPSJ7JGVudHJ5LT5yb3djbGFzc30iIG9ubW91c2VvdmVyPSJ0aGlzLmNsYXNzTmFtZT0neyRlbnRyeS0+cm93Y2xhc3N9aG92ZXInOyIgb25tb3VzZW91dD0idGhpcy5jbGFzc05hbWU9J3skZW50cnktPnJvd2NsYXNzfSc7Ij4KCQkJPHRkPnskZW50cnktPnRpdGxlfTwvdGQ+CgkJCTx0ZD57JGVudHJ5LT50eXBlfTwvdGQ+CgkJCTx0ZD57JGVudHJ5LT5lZGl0bGlua308L3RkPgoJCQk8dGQ+eyRlbnRyeS0+ZGVsZXRlbGlua308L3RkPgoJCTwvdHI+Cgl7L2ZvcmVhY2h9Cgk8L3Rib2R5Pgo8L3RhYmxlPgp7ZWxzZX0KPHA+eyRub3RlbXBsYXRlc308L3A+CnsvaWZ9CjxkaXYgY2xhc3M9InBhZ2VvcHRpb25zIj4KCTxwIGNsYXNzPSJwYWdlb3B0aW9ucyI+eyRhZGRsaW5rfTwvcD4KPC9kaXY+Cg==]]></data>
	</file>
</module>
