<?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>0.8.0</version>
  <mincmsversion>1.6</mincmsversion>
	<help><![CDATA[<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 {cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
<select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
<option value=&quot;&quot;>Select A target</option>
{foreach from=$items item=thisone}
   <option value=&quot;{$thisone.link}&quot;>{$thisone.title}</option>
{/foreach}
</select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
{eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
{eval var=$entry->input assign=thisAttr}{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 &quot;itemname_f_1_400_1.jpg&quot; - 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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</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"><sjg@cmsmodules.com></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; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. 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><h3>Parametre</h3><ul><li><em>(optional)</em> lang="en_US" - Parametret angiver hvilket sprog der skal bruges til visning for bes&oslash;gende. Ikke alle moduler underst&oslash;tter eller beh&oslash;ver dette.</li></ul>]]></help>
	<about><![CDATA[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]]></about>
	<description><![CDATA[Katalogindstillinger]]></description>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/action.adminattrs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.adminprefs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
if (!isset($gCms)) 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[PD9waHAKCQlpZiAoIWlzc2V0KCRnQ21zKSkgZXhpdDsKCQlmb3JlYWNoICgkcGFyYW1zIGFzICRrZXk9PiR2YWwpCgkJCXsKCQkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCRrZXksICRwYXJhbXNbJGtleV0pOwoJCQl9CiAJCWlmICghIGlzc2V0KCRwYXJhbXNbJ3JlY3Vyc2UnXSkpCiAJCQl7CiAJCQkkcGFyYW1zWydyZWN1cnNlJ10gPSAnaXRlbXNfYWxsJzsKIAkJIAl9CgogCQlsaXN0KCRjdXJQYWdlLCRjYXRlZ29yeUl0ZW1zKSA9ICR0aGlzLT5nZXRDYXRhbG9nSXRlbXNMaXN0KCRwYXJhbXMpOwoKICAgICAgICBpZiAoaXNzZXQoJHBhcmFtc1snZ2xvYmFsX3NvcnQnXSkpCiAJCQl7CgkJCWlmICgkcGFyYW1zWydnbG9iYWxfc29ydCddID09ICdhbHBoYScpCiAgICAgICAgICAgIAl7CiAgICAgICAgICAgIAl1c29ydCgkY2F0ZWdvcnlJdGVtcyxhcnJheSgiQ2F0YWxvZ2VyIiwgImNvbnRlbnRhbHBoYSIpKTsKICAgICAgICAgICAgCX0KCQkJZWxzZSBpZiAoJHBhcmFtc1snZ2xvYmFsX3NvcnQnXSA9PSAnZGF0ZScpCgkJCQl7CgkgICAgICAgICAgICB1c29ydCgkY2F0ZWdvcnlJdGVtcyxhcnJheSgiQ2F0YWxvZ2VyIiwgImNyZWF0ZWQiKSk7CgkJCQl9CgkJCWVsc2UgaWYgKCRwYXJhbXNbJ2dsb2JhbF9zb3J0J10gPT0gJ21kYXRlJykKCQkJCXsKCSAgICAgICAgICAgIHVzb3J0KCRjYXRlZ29yeUl0ZW1zLGFycmF5KCJDYXRhbG9nZXIiLCAiY2hyb25vIikpOwoJCQkJfQoJCQl9CgkJaWYgKGlzc2V0KCRwYXJhbXNbJ2dsb2JhbF9zb3J0X2RpciddKSAmJiAkcGFyYW1zWydnbG9iYWxfc29ydF9kaXInXT09J2FzYycpCgkJCXsKCQkJJGNhdGVnb3J5SXRlbXMgPSBhcnJheV9yZXZlcnNlKCRjYXRlZ29yeUl0ZW1zKTsKCQkJfQoKICAgICAgICAkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2l0ZW1zJywkY2F0ZWdvcnlJdGVtcyk7CgkJJHRoaXMtPnNtYXJ0eUJhc2ljcygpOwoKCQllY2hvICR0aGlzLT5Qcm9jZXNzVGVtcGxhdGVGcm9tRGF0YWJhc2UoJHRoaXMtPmdldFRlbXBsYXRlRnJvbUFsaWFzKCRwYXJhbXNbJ3N1Yl90ZW1wbGF0ZSddKSk7Cj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.compare.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCQlpZiAoIWlzc2V0KCRnQ21zKSkgZXhpdDsKCQkkaXRlbWxpc3QgPSBhcnJheSgpOwoJCWlmIChpc3NldCgkX1JFUVVFU1RbJ2l0ZW1zJ10pKQoJCQl7CgkJCSRwYXJhbXNbJ2l0ZW1zJ10gPSAkX1JFUVVFU1RbJ2l0ZW1zJ107CgkJCX0KCQlpZiAoISBpc19hcnJheSgkcGFyYW1zWydpdGVtcyddKSkKCQkJewoJCQkkcGFyYW1zWydpdGVtcyddID0gZXhwbG9kZSgnLCcsJHBhcmFtc1snaXRlbXMnXSk7CQoJCQl9CgkJZm9yZWFjaCAoJHBhcmFtc1snaXRlbXMnXSBhcyAkdGhpc0l0ZW0pCgkJCXsKCQkJJHBhZ2UgPSAkdGhpcy0+Z2V0Q2F0YWxvZ0l0ZW0oJHRoaXNJdGVtKTsKCQkJYXJyYXlfcHVzaCgkaXRlbWxpc3QsJHBhZ2UpOwkKCQkJfQoJCWlmIChjb3VudCgkaXRlbWxpc3QpPjApCgkJCXsKCQkJJHZhcnMgPSAmJGdDbXMtPnZhcmlhYmxlczsKCQkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdhdHRybGlzdCcsJHZhcnNbJ2NhdGFsb2dfYXR0cnMnXSk7CgkJCX0KCQllbHNlCgkJCXsKCQkJLy8gYmxhbmsgYXJyYXkKCQkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdhdHRybGlzdCcsJGl0ZW1saXN0KTsKCQkJfQoKIAkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdpdGVtcycsJGl0ZW1saXN0KTsKCQkkdGhpcy0+c21hcnR5QmFzaWNzKCk7CgkJZWNobyAkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlRnJvbURhdGFiYXNlKCR0aGlzLT5nZXRUZW1wbGF0ZUZyb21BbGlhcygkcGFyYW1zWydzdWJfdGVtcGxhdGUnXSkpOwo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/action.default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.defaultadmin.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.defaultcategory.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.defaultprintable.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.deletetempl.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYgKCFpc3NldCgkZ0NtcykpIGV4aXQ7CmlmICghICR0aGlzLT5DaGVja0FjY2VzcygpKSBleGl0OwoKCQlpZiAoISBlbXB0eSgkcGFyYW1zWyd0ZW1wbGF0ZV9pZCddKSkKCQkJewoJCQkkcXVlcnkgPSAnREVMRVRFIEZST00gJy4gY21zX2RiX3ByZWZpeCgpLgoJCQkJJ21vZHVsZV9jYXRhbG9nX3RlbXBsYXRlIFdIRVJFIGlkPT8nOwoJCQkkZGJyZXN1bHQgPSAkZGItPkV4ZWN1dGUoJHF1ZXJ5LGFycmF5KCRwYXJhbXNbJ3RlbXBsYXRlX2lkJ10pKTsKCQkJfQoJCSR0aGlzLT5EZWxldGVUZW1wbGF0ZSgnZ2xvc3NhcnlfJy4kcGFyYW1zWyd0ZW1wbGF0ZV9pZCddKTsKCgkJJHBhcmFtc1snbWVzc2FnZSddID0gJHRoaXMtPkxhbmcoJ3RlbXBsYXRlZGVsZXRlZCcpOwoJCSR0aGlzLT5Eb0FjdGlvbignZGVmYXVsdGFkbWluJywgJGlkLCAkcGFyYW1zKTsKCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.edittempl.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
if (!isset($gCms)) 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'];
			$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'].'}, ';
					}
				}
        	}
        $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>';

        
		$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_by_ref('avail_attrs',$cattrs);		
				}
			else if ($type_id == CTEMPLATE_CATALOG)
				{
				$this->smarty->assign_by_ref('avail_attrs',$pcattrs);		
				}
			else if ($type_id == CTEMPLATE_COMPARISON)
				{
				$this->smarty->assign_by_ref('avail_attrs',$compattrs);		
				}
			else if ($type_id == CTEMPLATE_FEATURE)
				{
				$this->smarty->assign_by_ref('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_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')));
		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[PD9waHAKaWYgKCFpc3NldCgkZ0NtcykpIGV4aXQ7CmlmICghICR0aGlzLT5DaGVja0FjY2VzcygpKSBleGl0OwoKCQlpZiAoaXNzZXQoJHBhcmFtc1snaXRlbV9zb3J0X29yZGVyJ10pICYmCgkJCSRwYXJhbXNbJ2l0ZW1fc29ydF9vcmRlciddICE9ICdub2NoYW5nZScpCgkJCXsKCQkJLy8gdXBkYXRlIGFsbCBpdGVtIHNvcnQgb3JkZXIKCQkJJHF1ZXJ5ID0gInVwZGF0ZSAiLgoJCQkJY21zX2RiX3ByZWZpeCgpLiJjb250ZW50X3Byb3BzIGNwLCAiLgoJCQkJY21zX2RiX3ByZWZpeCgpLiJjb250ZW50IGMgc2V0IGNwLmNvbnRlbnQ9PyB3aGVyZSAiLgoJCQkJImNwLmNvbnRlbnRfaWQ9Yy5jb250ZW50X2lkIGFuZCAiLgoJCQkJImMudHlwZT0nY2F0YWxvZ2NhdGVnb3J5JyBhbmQgY3AucHJvcF9uYW1lPSdzb3J0X29yZGVyJyI7CgkJCSRkYnJlc3VsdCA9ICRkYi0+RXhlY3V0ZSgkcXVlcnksYXJyYXkoJHBhcmFtc1snaXRlbV9zb3J0X29yZGVyJ10pKTsKCQkJfQoJCWlmIChpc3NldCgkcGFyYW1zWydjYXRlZ29yeV9yZWN1cnNlJ10pICYmCgkJCSRwYXJhbXNbJ2NhdGVnb3J5X3JlY3Vyc2UnXSAhPSAnbm9jaGFuZ2UnKQoJCQl7CgkJCS8vIHVwZGF0ZSBkaXNwbGF5IHJ1bGVzCgkJCSRxdWVyeSA9ICJ1cGRhdGUgIi4KCQkJCWNtc19kYl9wcmVmaXgoKS4iY29udGVudF9wcm9wcyBjcCwgIi4KCQkJCWNtc19kYl9wcmVmaXgoKS4iY29udGVudCBjICBzZXQgY3AuY29udGVudD0/IHdoZXJlICIuCgkJCQkiY3AuY29udGVudF9pZD1jLmNvbnRlbnRfaWQgYW5kICIuCgkJCQkiYy50eXBlPSdjYXRhbG9nY2F0ZWdvcnknIGFuZCBjcC5wcm9wX25hbWU9J3JlY3Vyc2UnIjsKCQkJJGRicmVzdWx0ID0gJGRiLT5FeGVjdXRlKCRxdWVyeSxhcnJheSgkcGFyYW1zWydjYXRlZ29yeV9yZWN1cnNlJ10pKTsKCQkJCgkJCX0KCQlpZiAoaXNzZXQoJHBhcmFtc1snaXRlbXNfcGVyX3BhZ2UnXSkgJiYKCQkJJHBhcmFtc1snaXRlbXNfcGVyX3BhZ2UnXSAhPSAtMSkKCQkJewoJCQkvLyB1cGRhdGUgZGlzcGxheSBydWxlcwoJCQkkcXVlcnkgPSAidXBkYXRlICIuCgkJCQljbXNfZGJfcHJlZml4KCkuImNvbnRlbnRfcHJvcHMgY3AsICIuCgkJCQljbXNfZGJfcHJlZml4KCkuImNvbnRlbnQgYyBzZXQgY3AuY29udGVudD0/IHdoZXJlICIuCgkJCQkiY3AuY29udGVudF9pZD1jLmNvbnRlbnRfaWQgYW5kICIuCgkJCQkiYy50eXBlPSdjYXRhbG9nY2F0ZWdvcnknIGFuZCAiLgoJCQkJImNwLnByb3BfbmFtZT0naXRlbXNfcGVyX3BhZ2UnIjsKCQkJJGRicmVzdWx0ID0gJGRiLT5FeGVjdXRlKCRxdWVyeSxhcnJheSgkcGFyYW1zWydpdGVtc19wZXJfcGFnZSddKSk7CgkJCX0KCgoJCSRwYXJhbXNbJ21lc3NhZ2UnXSA9ICR0aGlzLT5MYW5nKCdnbG9iYWxseXVwZGF0ZWQnKTsKICAgICAgICAkdGhpcy0+RG9BY3Rpb24oJ2dsb2JhbG9wcycsICRpZCwgJHBhcmFtcyk7Cgo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/action.random.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCQlpZiAoIWlzc2V0KCRnQ21zKSkgZXhpdDsKCQlmb3JlYWNoICgkcGFyYW1zIGFzICRrZXk9PiR2YWwpCgkJCXsKCQkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCRrZXksICRwYXJhbXNbJGtleV0pOwoJCQl9CiAJCWlmICghIGlzc2V0KCRwYXJhbXNbJ3JlY3Vyc2UnXSkpCiAJCQl7CiAJCQkkcGFyYW1zWydyZWN1cnNlJ10gPSAnaXRlbXNfYWxsJzsKIAkJIAl9CgkJCiAJCWxpc3QoJGN1clBhZ2UsJGNhdGVnb3J5SXRlbXMpID0gJHRoaXMtPmdldENhdGFsb2dJdGVtc0xpc3QoJHBhcmFtcyk7CiAgICAgICAgJGNvdW50ID0gbWluKGNvdW50KCRjYXRlZ29yeUl0ZW1zKSwkcGFyYW1zWydjb3VudCddKTsKICAgICAgICAkdGhpc1VybCA9ICRfU0VSVkVSWydSRVFVRVNUX1VSSSddOwogICAgICAgICR0aGlzVXJsID0gcHJlZ19yZXBsYWNlKCcvKFw/KSooXCYpKnN0YXJ0PVxkKy8nLCcnLCR0aGlzVXJsKTsKICAgICAgICBpZiAoJGNvdW50ID09IDEpCiAgICAgICAgCXsKICAgICAgICAJJHRoaXNLZXkgPSBhcnJheV9yYW5kKCRjYXRlZ29yeUl0ZW1zLDEpOwogICAgICAgICAkY2F0VG1wID0gYXJyYXkoKTsKICAgICAgIAlhcnJheV9wdXNoKCRjYXRUbXAsJGNhdGVnb3J5SXRlbXNbJHRoaXNLZXldKTsKICAgICAgICAJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdpdGVtcycsJGNhdFRtcCk7CiAgICAgICAgCX0KICAgICAgICBlbHNlIGlmICgkY291bnQgPT0gMCkKICAgICAgICAJewogICAgICAgIAkkdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2l0ZW1zJyxhcnJheSgpKTsKICAgICAgICAJfQogICAgICAgIGVsc2UKICAgICAgICAJewogICAgICAgIAkkY2F0ZWdvcnlJdGVtS2V5cyA9IGFycmF5X3JhbmQoJGNhdGVnb3J5SXRlbXMsICRjb3VudCk7CiAgICAgICAgCSRjYXRUbXAgPSBhcnJheSgpOwogICAgICAgIAlmb3JlYWNoKCRjYXRlZ29yeUl0ZW1LZXlzIGFzICR0aGlzS2V5KQogICAgICAgIAkJewogICAgICAgIAkJYXJyYXlfcHVzaCgkY2F0VG1wLCRjYXRlZ29yeUl0ZW1zWyR0aGlzS2V5XSk7CiAgICAgICAgCQl9CiAgICAgICAgCSR0aGlzLT5zbWFydHktPmFzc2lnbignaXRlbXMnLCRjYXRUbXApOwogICAgICAgIAl9CiAgICAgICAgCiAJCSR0aGlzLT5zbWFydHlCYXNpY3MoKTsKCQllY2hvICR0aGlzLT5Qcm9jZXNzVGVtcGxhdGVGcm9tRGF0YWJhc2UoJHRoaXMtPmdldFRlbXBsYXRlRnJvbUFsaWFzKCRwYXJhbXNbJ3N1Yl90ZW1wbGF0ZSddKSk7Cj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.recent.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCQlpZiAoIWlzc2V0KCRnQ21zKSkgZXhpdDsKCQlmb3JlYWNoICgkcGFyYW1zIGFzICRrZXk9PiR2YWwpCgkJCXsKCQkJJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCRrZXksICRwYXJhbXNbJGtleV0pOwoJCQl9CiAJCWlmICghIGlzc2V0KCRwYXJhbXNbJ3JlY3Vyc2UnXSkpCiAJCQl7CiAJCQkkcGFyYW1zWydyZWN1cnNlJ10gPSAnaXRlbXNfYWxsJzsKIAkJIAl9CgkJCiAJCWxpc3QoJGN1clBhZ2UsJGNhdGVnb3J5SXRlbXMpID0gJHRoaXMtPmdldENhdGFsb2dJdGVtc0xpc3QoJHBhcmFtcyk7CgoJCWlmICghaXNzZXQoJHBhcmFtc1snZ2xvYmFsX3NvcnQnXSkgfHwgJHBhcmFtc1snZ2xvYmFsX3NvcnQnXT09J2RhdGUnKQoJCQl7CiAgICAgICAgCXVzb3J0KCRjYXRlZ29yeUl0ZW1zLGFycmF5KCJDYXRhbG9nZXIiLCAiY3JlYXRlZCIpKTsKICAgICAgICAJfQoJCWVsc2UKCQkJewoJCSAgICB1c29ydCgkY2F0ZWdvcnlJdGVtcyxhcnJheSgiQ2F0YWxvZ2VyIiwgImNocm9ubyIpKTsKCQkJfQoKCQlpZiAoaXNzZXQoJHBhcmFtc1snZ2xvYmFsX3NvcnRfZGlyJ10pICYmICRwYXJhbXNbJ2dsb2JhbF9zb3J0X2RpciddPT0nYXNjJykKCQkJewoJCQkkY2F0ZWdvcnlJdGVtcyA9IGFycmF5X3JldmVyc2UoJGNhdGVnb3J5SXRlbXMpOwoJCQl9CgkJCQogICAgICAgICRjb3VudCA9IGNvdW50KCRjYXRlZ29yeUl0ZW1zKTsKICAgICAgICAkc3RhcnQgPSAwOwogICAgICAgICRlbmQgPSBtaW4oJGNvdW50LCRwYXJhbXNbJ2NvdW50J10pOwogICAgICAgICR0aGlzVXJsID0gJF9TRVJWRVJbJ1JFUVVFU1RfVVJJJ107CiAgICAgICAgJHRoaXNVcmwgPSBwcmVnX3JlcGxhY2UoJy8oXD8pKihcJikqc3RhcnQ9XGQrLycsJycsJHRoaXNVcmwpOwogICAgICAgICRjYXRlZ29yeUl0ZW1zID0gYXJyYXlfc3BsaWNlKCRjYXRlZ29yeUl0ZW1zLCAkc3RhcnQsICRlbmQpOwogICAgICAgICR0aGlzLT5zbWFydHktPmFzc2lnbignaXRlbXMnLCRjYXRlZ29yeUl0ZW1zKTsKIAkJCgkJJHRoaXMtPnNtYXJ0eUJhc2ljcygpOwoJCWVjaG8gJHRoaXMtPlByb2Nlc3NUZW1wbGF0ZUZyb21EYXRhYmFzZSgkdGhpcy0+Z2V0VGVtcGxhdGVGcm9tQWxpYXMoJHBhcmFtc1snc3ViX3RlbXBsYXRlJ10pKTsKPz4K]]></data>
	</file>
	<file>
	  <filename>/action.reimport.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYgKCFpc3NldCgkZ0NtcykpIGV4aXQ7CmlmICghICR0aGlzLT5DaGVja0FjY2VzcygpKSBleGl0OwoJCgkJJHRoaXMtPmltcG9ydFNhbXBsZVRlbXBsYXRlcygpOwoJCSRwYXJhbXNbJ21lc3NhZ2UnXSA9ICR0aGlzLT5MYW5nKCdyZWltcG9ydGVkJyk7CgkJJHRoaXMtPkRvQWN0aW9uKCdkZWZhdWx0YWRtaW4nLCAkaWQsICRwYXJhbXMpOwoKPz4K]]></data>
	</file>
	<file>
	  <filename>/action.submitattrs.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></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[PD9waHAKCQlpZiAoIWlzc2V0KCRnQ21zKSkgZXhpdDsKCQlpZiAoIWlzc2V0KCRwYXJhbXNbJ25hbWUnXSkpCgkJCXsKCQkJZWNobyAnPCEtLSBwbGVhc2Ugc3BlY2lmeSBhIENhdGFsb2dlciB2YXJpYWJsZSBuYW1lIHRvIHJldHJpZXZlIC0tPic7CgkJCXJldHVybjsKCQkJfQoKCQkkcGFnZWF0dHJzID0gJiRnQ21zLT52YXJpYWJsZXNbJ2NhdGFsb2dfYXR0cnMnXTsKCSAgICAkbWFuYWdlciA9JiAkZ0Ntcy0+R2V0SGllcmFyY2h5TWFuYWdlcigpOwoJCSRwYWdlaW5mbyA9ICYkZ0Ntcy0+dmFyaWFibGVzWydwYWdlaW5mbyddOwoJCWlmICgkcGFnZWluZm8tPmNvbnRlbnRfaWQgIT0gLTEpCgkJCXsKCQkJJG5vZGUgPSYgJG1hbmFnZXItPnN1cmVHZXROb2RlQnlJZCgkcGFnZWluZm8tPmNvbnRlbnRfaWQpOwoJCQkkY29udGVudCA9JiAkbm9kZS0+R2V0Q29udGVudCgpOwoJCQlpZiAoJGNvbnRlbnQtPlR5cGUoKSAhPSAnY2F0YWxvZ2l0ZW0nICYmICRjb250ZW50LT5UeXBlKCkgIT0gJ2NhdGFsb2djYXRlZ29yeScgJiYgJGNvbnRlbnQtPlR5cGUoKSAhPSAnY2F0YWxvZ3ByaW50YWJsZScpCgkJCQl7CgkJCQlyZXR1cm47CgkJCQl9CgkJCSRjb250ZW50LT5Qb3B1bGF0ZVBhcmFtcygkcGFyYW1zKTsKCQkJJGZvdW5kID0gZmFsc2U7CgkgICAgCWZvcmVhY2ggKCRwYWdlYXR0cnMgYXMgJHRoaXNQYXJhbSkKCQkJCXsKCQkJCSRzYWZlYXR0ciA9IHN0cnRvbG93ZXIocHJlZ19yZXBsYWNlKCcvXFcvJywnJywgJHRoaXNQYXJhbS0+YXR0cikpOwoJCQkJaWYgKCRwYXJhbXNbJ25hbWUnXSA9PSAkc2FmZWF0dHIpCgkJCQkJewoJCQkJCSR0bXAgPSAkY29udGVudC0+R2V0UHJvcGVydHlWYWx1ZSgkdGhpc1BhcmFtLT5hdHRyKTsKCQkJCQkkZm91bmQgPSB0cnVlOwoJCQkJCX0KCQkJCX0KCQkJfQoKCQlpZiAoISAkZm91bmQpCgkJCXsKCQkJaWYgKGlzc2V0KCRwYXJhbXNbJ2RlZmF1bHQnXSkpCgkJCQl7CgkJCQkkdG1wID0gJHBhcmFtc1snZGVmYXVsdCddOwoJCQkJfQoJCQllbHNlCgkJCQl7CgkJCQkkdG1wID0gJyc7CgkJCQl9CgkJCX0KCQllY2hvICR0bXA7Cj8+]]></data>
	</file>
	<file>
	  <filename>/Cataloger.Image.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKCXJlcXVpcmVfb25jZShkaXJuYW1lKF9fRklMRV9fKS4nLy4uLy4uL2luY2x1ZGUucGhwJyk7CgkKCSRjYXRtb2QgPSBuZXcgQ2F0YWxvZ2VyKCk7CglpZiAoJGNhdG1vZCA9PSBudWxsKQoJCXsKCQllY2hvICJFcnJvciEgQ2Fubm90IGFjY2VzcyBDYXRhbG9nZXIgbW9kdWxlLiI7CgkJZXhpdDsKCQl9CgkKCSRzcGVjID0gJF9HRVRbJ2knXTsKCSRkZWJ1ZyA9IGlzc2V0KCRfR0VUWydkZWJ1ZyddKTsKCSRhbnRpY2FjaGUgPSBpc3NldCgkX0dFVFsnYWMnXSk7Cgkkc3BlYyA9IHByZWdfcmVwbGFjZSgnLyhcLlwufFwvKS8nLCcnLCRzcGVjKTsKCWlmICghIHByZWdfbWF0Y2goJy9cLmpwZyQvaScsJHNwZWMpKQoJCXsKCQlyZXR1cm4gcmV0dXJuTWlzc2luZygkY29uZmlnWydyb290X3VybCddLCB0cnVlLCAkZGVidWcpOwoJCX0KCQkKCWlmICgkZGVidWcpIGVycm9yX2xvZygiQ2hlY2tpbmcgb24gIi4kY29uZmlnWyd1cGxvYWRzX3BhdGgnXS4kY2F0bW9kLT5nZXRBc3NldFBhdGgoJ2knKS4nLycuJHNwZWMpOwoJJHNpemVkID0gQHN0YXQoJGNvbmZpZ1sndXBsb2Fkc19wYXRoJ10uJGNhdG1vZC0+Z2V0QXNzZXRQYXRoKCdpJykuJy8nLiRzcGVjKTsKCgkkc3BlYyA9IHN1YnN0cigkc3BlYywgMCwgc3RycnBvcygkc3BlYywnLicpKTsKCSRwYXJ0cyA9IGV4cGxvZGUoJ18nLCRzcGVjKTsKCSRwYXJ0cyA9IGFycmF5X3JldmVyc2UoJHBhcnRzKTsKCQkKCSRzaG93TWlzc2luZyA9ICRwYXJ0c1swXSA9PSAnMSc7Cgkkc2l6ZSA9ICRwYXJ0c1sxXTsKCSRpbWdubyA9ICRwYXJ0c1syXTsKCSR0eXBlID0gJHBhcnRzWzNdOwoJJG5hbWUgPSAnJzsKCWZvciAoJGo9Y291bnQoJHBhcnRzKS0xOyRqPjM7JGotLSkKCQl7CgkJJG5hbWUgLj0gJHBhcnRzWyRqXS4nXyc7CgkJfQoJJHNyY1NwZWMgPSAkY29uZmlnWyd1cGxvYWRzX3BhdGgnXS4kY2F0bW9kLT5nZXRBc3NldFBhdGgoJ3MnKS4nLycuJG5hbWU7Cgkkc3JjU3BlYyAuPSAnc3JjXycuJGltZ25vLicuanBnJzsKCWlmICgkZGVidWcpCgkJewoJCWVycm9yX2xvZygiQ2F0YWxvZ2VySW1hZ2U6IHNyYyBpbWFnZSAiLiRzcmNTcGVjKTsKCQl9Cgkkb3JpZyA9IEBzdGF0KCRzcmNTcGVjKTsKCSRuZXdJbWFnZSA9IGZhbHNlOwoJaWYgKCRvcmlnID09PSBmYWxzZSkKCQl7CgkJaWYgKCRkZWJ1ZykgZXJyb3JfbG9nKCJDYW4ndCBmaW5kICIuJHNyY1NwZWMpOwoJCXJldHVybiByZXR1cm5NaXNzaW5nKCRjb25maWdbJ3Jvb3RfdXJsJ10sICRzaG93TWlzc2luZyk7CgkJfQoJaWYgKCEkc2l6ZWQgfHwgJHNpemVkWydtdGltZSddIDwgJG9yaWdbJ210aW1lJ10pCgkJewoJCWlmICgkZGVidWcpIGVycm9yX2xvZygibmV3ZXIgdGhhbiBleGlzdGVudCwgdHJhbnNmb3JtaW5nIik7CgkJLy8gd2UgZG9uJ3QgaGF2ZSBhIGNhY2hlZCB2ZXJzaW9uIHdlIGNhbiB1c2UKCQkkZGVzdFNwZWMgPSAkY29uZmlnWyd1cGxvYWRzX3BhdGgnXS4kY2F0bW9kLT5nZXRBc3NldFBhdGgoJ2knKS4nLycuJHNwZWMuJy5qcGcnOwoJCS8vIHNvIHdlIG1ha2Ugb25lCgkJaW1hZ2VUcmFuc2Zvcm0oJHNyY1NwZWMsICRkZXN0U3BlYywgJHNpemUsICRjb25maWcpOwoJCSRuZXdJbWFnZSA9IHRydWU7CgkJfQoKCSRkZXN0ID0gIkxvY2F0aW9uOiAiLiRjb25maWdbJ3VwbG9hZHNfdXJsJ10uCgkJJGNhdG1vZC0+Z2V0QXNzZXRQYXRoKCdpJykuJy8nLiRzcGVjLicuanBnJzsKCWlmICgkbmV3SW1hZ2UgfHwgJGFudGljYWNoZSkKCQl7CgkJaGVhZGVyKCJFeHBpcmVzOiBNb24sIDI2IEp1bCAxOTk3IDA1OjAwOjAwIEdNVCIpOwoJCWhlYWRlcigiTGFzdC1Nb2RpZmllZDogIiAuIGdtZGF0ZSgiRCwgZCBNIFkgSDppOnMiKSAuICIgR01UIik7CgkJaGVhZGVyKCJDYWNoZS1Db250cm9sOiBuby1jYWNoZSwgY2FjaGVoYWNrPSIudGltZSgpKTsKCQloZWFkZXIoIkNhY2hlLUNvbnRyb2w6IG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUiKTsKCQloZWFkZXIoIkNhY2hlLUNvbnRyb2w6IHBvc3QtY2hlY2s9LTEsIHByZS1jaGVjaz0tMSIsIGZhbHNlKTsKCQkkZGVzdCAuPSAnP2FjPSc7CgkJZm9yICgkaT0wOyRpPDU7JGkrKykKCQkJewoJCQkkZGVzdCAuPSByYW5kKDAsOSk7CgkJCX0KCQl9CglpZiAoJGRlYnVnKSBlcnJvcl9sb2coJGRlc3QpOwoJaGVhZGVyKCRkZXN0KTsKCXJldHVybjsKCgoJZnVuY3Rpb24gcmV0dXJuTWlzc2luZygkcm9vdFVybCwgJHNob3dNaXNzaW5nLCAkZGVidWc9ZmFsc2UpCgl7CgkJLy8gaWYgc28gZGVzaXJlZCwgZG9uJ3QgNDA0LCBidXQgc2VuZCBhbiBpbWFnZQoJCWlmICgkZGVidWcpCgkJCXsKCQkJZXJyb3JfbG9nKCJDYXRhbG9nZXJJbWFnZTogbm8gaW1hZ2UgYXQgJHJvb3RVcmwiKTsKCQkJfQoJCWlmICghICRzaG93TWlzc2luZykKCQkJewoJCQloZWFkZXIoIkxvY2F0aW9uOiAiLiRyb290VXJsLgoJCQkJJy9tb2R1bGVzL0NhdGFsb2dlci9pbWFnZXMvdHJhbnMuZ2lmJyk7CgkJCX0KCQllbHNlCgkJCXsKCQkJaGVhZGVyKCJMb2NhdGlvbjogIi4kcm9vdFVybC4KCQkJCScvbW9kdWxlcy9DYXRhbG9nZXIvaW1hZ2VzL25vLWltYWdlLmdpZicpOwkJCQoJCQl9CgkJcmV0dXJuOwoJCgl9CgogICAgZnVuY3Rpb24gaW1hZ2VUcmFuc2Zvcm0oJHNyY1NwZWMsICRkZXN0U3BlYywgJHNpemUsICYkY29uZmlnLCAkYXNwZWN0X3JhdGlvPScnKQogICAgewogICAgICAgIHJlcXVpcmVfb25jZShkaXJuYW1lKF9fRklMRV9fKS4nLy4uLy4uL2xpYi9maWxlbWFuYWdlci9JbWFnZU1hbmFnZXIvQ2xhc3Nlcy9UcmFuc2Zvcm0ucGhwJyk7CgogICAgICAgICRpdCA9IG5ldyBJbWFnZV9UcmFuc2Zvcm07CiAgICAgICAgJGltZyA9ICRpdC0+ZmFjdG9yeSgkY29uZmlnWydpbWFnZV9tYW5pcHVsYXRpb25fcHJvZyddKTsKICAgICAgICAkaW1nLT5sb2FkKCRzcmNTcGVjKTsKICAgICAgICBpZiAoJGltZy0+aW1nX3ggPCAkaW1nLT5pbWdfeSkKICAgICAgICAgICAgewogICAgICAgICAgICAkbG9uZ19heGlzID0gJGltZy0+aW1nX3k7CiAgICAgICAgICAgIH0KICAgICAgICBlbHNlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgJGxvbmdfYXhpcyA9ICRpbWctPmltZ194OwogICAgICAgICAgICB9CgogICAgICAgIGlmICgkbG9uZ19heGlzID4gJHNpemUpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgJGltZy0+c2NhbGVCeUxlbmd0aCgkc2l6ZSk7CiAgICAgICAgICAgICRpbWctPnNhdmUoJGRlc3RTcGVjLCAnanBlZycpOwogICAgICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgICAgICB7CiAgICAgICAgICAgICRpbWctPnNhdmUoJGRlc3RTcGVjLCAnanBlZycpOwogICAgICAgICAgICB9CiAgICAgICAgJGltZy0+ZnJlZSgpOwogICAgfQo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/Cataloger.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.4
#
# 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
{
  var $attrs = array();
  var $fetched = false;
  var $showMissing = '';

  function Cataloger()
  {
    parent::CMSModule();
    $this->RegisterContentType('CatalogItem',
			       dirname(__FILE__).DIRECTORY_SEPARATOR.'contenttype.catalogitem.php',
			       $this->Lang('item_page'));
    $this->RegisterContentType('CatalogCategory',
			       dirname(__FILE__).DIRECTORY_SEPARATOR.'contenttype.catalogcategory.php',
			       $this->Lang('category_page'));
    $this->RegisterContentType('CatalogPrintable',
			       dirname(__FILE__).DIRECTORY_SEPARATOR.'contenttype.catalogprintable.php',
			       $this->Lang('catalog_printable'));
  }

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

  function IsPluginModule()
  {
    return true;
  }

  function HasAdmin()
  {
    return true;
  }

  function GetVersion()
  {
    return '0.8.0';
  }

  function MinimumCMSVersion()
  {
    return '1.6';
  }

  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('count',CLEAN_INT);
  $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);
  }

  function getTemplateFromAlias($alias)
  {
    global $gCms;
    $db = $gCms->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')
  {
    global $gCms;
    $db = $gCms->GetDb();
    $dir=opendir(dirname(__FILE__).'/includes');
    $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)
      {
	$file = file(dirname(__FILE__).'/includes/'.$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));
	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);
      }
	
  }

  function contentalpha($a, $b)
  {
    return strcasecmp($a['title'], $b['title']);
  }

  function chrono($a, $b)
  {
    if ($a['modifieddate'] > $b['modifieddate'])
      {
      	return -1;
      }
    if ($a['modifieddate'] < $b['modifieddate'])
      {
      	return 1;
      }
    return 0;
  }

  function created($a, $b)
  {
    if ($a['createdate'] > $b['createdate'])
      {
      	return -1;
      }
    if ($a['createdate'] < $b['createdate'])
      {
      	return 1;
      }
    return 0;
  }


  function initAdminNav($id, &$params, $returnid)
  {
    global $gCms;
    $this->smarty->assign('innernav',
			  $this->CreateLink($id, 'defaultadmin', $returnid,
					    $gCms->variables['admintheme']->DisplayImage('icons/topfiles/template.gif',
											 $this->Lang('listtempl'),'','','systemicon'), array()) .
			  $this->CreateLink($id, 'defaultadmin', $returnid, $this->Lang('listtempl'), array()) .
			  ' : ' .
			  $this->CreateLink($id, 'adminattrs', $returnid,
					    $gCms->variables['admintheme']->DisplayImage('icons/topfiles/images.gif',
											 $this->Lang('manageattrs'),'','','systemicon'), array()) .
			  $this->CreateLink($id, 'adminattrs', $returnid, $this->Lang('manageattrs'), array()) .
			  ' : ' .
			  $this->CreateLink($id, 'globalops', $returnid,
					    '<img class="systemicon" alt="'.$this->Lang('globalops').'" title="'.$this->Lang('globalops').'" src="'.$gCms->config['root_url'].'/modules/Cataloger/images/global.gif" />') .
			  $this->CreateLink($id, 'globalops', $returnid, $this->Lang('globalops'), array()) .
			  ' : ' .
			  $this->CreateLink($id, 'adminprefs', $returnid,
					    $gCms->variables['admintheme']->DisplayImage('icons/topfiles/siteprefs.gif',
											 $this->Lang('manageprefs'),'','','systemicon'), array()) .
			  $this->CreateLink($id, 'adminprefs', $returnid, $this->Lang('manageprefs'), array()));
  }

  function GetAdminCategory()
  {
    return 'extensions';
  }

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


  function GetHelp($lang='en_US')
  {
    return $this->Lang('helptext');
  }

  function GetAuthor()
  {
    return 'SjG';
  }

  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 'sjg@cmsmodules.com';
  }

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


  function & getSubContent($startNodeId)
    {
      global $gCms;
      $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()
    {
      global $gCms;
      $content = array();
      $hm = $gCms->GetHierarchyManager();
		
      $rn = $hm->GetRootNode(); 
      $count = 0;
      $hm->getFlattenedChildren($rn, $content, $count);
      return $content;
    }


  function getUserAttributes($global_ref='catalog_attrs')
  {
    global $gCms;
    $vars = &$gCms->variables;
    $db = $gCms->GetDb();
    if (! isset($vars[$global_ref]) || ! is_array($vars[$global_ref]))
      {
	$vars[$global_ref] = array();
	$query = "SELECT attribute, alias, defaultval, length, is_textarea 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->is_text = $row['is_textarea'];
		$thisAttr->length = $row['length'];
		$thisAttr->default = $row['defaultval'];
		$thisAttr->safe = strtolower(preg_replace('/\W/','',$row['attribute']));
	    array_push($vars[$global_ref],$thisAttr);
		}
      }
  }


/*
if ($as_array)
	{
	$thisAttr = $row;
	$thisAttr['name'] = $row['attribute'];
	$thisAttr['is_text'] = $row['is_textarea'];
	$thisAttr['default'] = $row['defaultval'];
	$thisAttr['safe'] = strtolower(preg_replace('/\W/','',$row['attribute']));
   	array_push($ret,$thisAttr);
	}
else
	{
	*/

  function &getCatalogItem($alias)
	{
	    global $gCms;

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

   	    return $node;
	}


  function smartyBasics()
	{
	global $gCms;
	$this->smarty->assign('root_url',$gCms->config['root_url']);
	$this->smarty->assign('image_root',$gCms->config['root_url'].
			'/modules/Cataloger/Cataloger.Image.php');
	}

  function getCatalogItemsList(&$params)
  {
    global $gCms;

    $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 ContentBase();
      }
    else
      {
   	if (isset($params['content_id']))
   	  {
   	    $curPageID = $gCms->variables[$params['content_id']];
   	    $curPageNode = $hm->sureGetNodeById($curPageID);
   	    $curPage = $curPageNode->GetContent();
   	  }
   	else if (isset($params['alias']))
   	  {
   	    $curPageNode = $hm->sureGetNodeByAlias($params['alias']);
   		 $curPage = $curPageNode->GetContent();
   	    $curPageID = $curPage->Id();
   	  }
   	else if (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;
	  }
	else if ((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)
  {
    global $gCms;
  	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 $gCms->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)
  {
  	global $gCms;
  	if ($this->showMissing == '')
  		{
  		$this->showMissing = $this->GetPreference('show_missing','1');
  		}

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

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


  function getFiles($alias)
  {
	global $gCms;
	$dirspec = $gCms->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)
  {
  	global $gCms;
  	$srcDir = $gCms->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)
  {
  	global $gCms;
	$srcSpec = $gCms->config['uploads_path'].$this->getAssetPath('s').'/'.$alias .
			'_src_'.$imageNumber.'.jpg';
	unlink($srcSpec);
  }


  function renameImages($old, $newAlias)
  {
  	global $gCms;
	if ($handle = opendir($gCms->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 ($gCms->config['uploads_path'].$this->getAssetPath('s').'/'.$file,$gCms->config['uploads_path'].$this->getAssetPath('s').'/'.$newspec);
	        	}
	    	}
	    closedir($handle);
		}
  }


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

	function HandlesEvents()
	{
		return true;
	}

  // handle alias name changes	
	function DoEvent( $originator, $eventname, &$params )
	{
		if ($originator == 'Core' && $eventname=='ContentEditPost')
			{
			$content = &$params['content'];
			if ( ($content->Type() == 'catalogitem' ||
				  $content->Type() == 'catalogcategory' ||
				  $content->Type() == 'catalogprintable'
			     ) && $content->Alias() != $content->mOldAlias)
					{
					if ($content->mOldAlias && $content->Alias())
						{
							$this->renameImages($content->mOldAlias, $content->Alias());
						}
					}
			}
	}


	// type can be "s" - source image, "i" - processed image, or "f" - file
	function getAssetPath($type="i", $default=false)
	{
		global $gCms;
		$uploadbase = str_replace($gCms->config['uploads_path'],$gCms->config['root_path'],'');
		if ($default)
			{
			switch ($type)
				{
				case 's':
					return $uploadbase.'/images/catalog_src';
				case 'i':
					return $uploadbase.'/images/catalog';
				case 'f':
					return $uploadbase.'/catalogerfiles';
				}
			}
			switch ($type)
				{
				case 's':
					return $this->GetPreference('image_upload_path',$uploadbase.'/images/catalog_src');
				case 'i':
					return $this->GetPreference('image_proc_path',$uploadbase.'/images/catalog');
				case 'f':
					return $this->GetPreference('file_upload_path',$uploadbase.'/catalogerfiles');
				}
		
	}

}

# vim:ts=4 sw=4 noet
?>
]]></data>
	</file>
	<file>
	  <filename>/contenttype.catalogcategory.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.6
#
# Copyright (c) 2007, 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 CMSModuleContentType
{
  var $attrs;
  var $validation=FALSE;

  function ModuleName()
  {
    return 'Cataloger';
  }

  function IsCopyable()
  {
  return true;
  }

  function SetProperties()
  {
	 parent::SetProperties();
  	$this->getUserAttributes();
    foreach ($this->attrs as $thisAttr)
      {
	  $this->AddExtraProperty($thisAttr->attr);
      }

    $this->AddExtraProperty('sort_order');
    $this->AddExtraProperty('recurse');
    $this->AddExtraProperty('sub_template');
    $this->AddExtraProperty('items_per_page', 'int');
		
#Turn on preview
    $this->mPreview = true;

#Turn off caching
    $this->mCachable = false;
  }

  function getUserAttributes()
  {
	global $gCms;
	Cataloger::getUserAttributes('catalog_cat_attrs');
	$vars = &$gCms->variables;
	$this->attrs = &$vars['catalog_cat_attrs'];

  }

  function &getAttrs()
    {
      $this->getUserAttributes();
      return $this->attrs;
    }

  function GetCreationDate()
  {
    return $this->mCreationDate;
  }
	
  function GetModifiedDate()
  {
    return $this->mModifiedDate;
  }

  function TabNames()
  {
    return array(lang('main'), $this->lang('nameimages'), lang('options'), $this->lang('Permissions'));
  }

  function EditAsArray($adding = false, $tab = 0, $showadmin=false)
  {
    global $gCms;
    $config = &$gCms->config;
    $module = $this->GetModuleInstance();
    $db = $gCms->GetDb();
    $wysiwyg = (strlen(get_preference(get_userid(), 'wysiwyg')) > 0);
    $ret = array();
    $stylesheet = '';
    if ($this->TemplateId() > 0)
      {
	$stylesheet = '../stylesheet.php?templateid='.$this->TemplateId();
      }
    else
      {
	$templateops = $gCms->GetTemplateOperations();
	$defaulttemplate = $templateops->LoadDefaultTemplate();
	if (isset($defaulttemplate))
	  {
	    $this->mTemplateId = $defaulttemplate->id;
	    $stylesheet = '../stylesheet.php?templateid='.$this->TemplateId();
	  }
      }

    if ($tab == 0)
      {
        $query = "SELECT id, title FROM ".
	  cms_db_prefix()."module_catalog_template WHERE type_id=2 ORDER by title";
        $subTemplates = array();
        $dbresult = $db->Execute($query);

	$templateops = $gCms->GetTemplateOperations();
        while ($dbresult !== false && $row = $dbresult->FetchRow())
	  {
	    $subTemplates[$row['title']]=$row['id'];
	  }		

	array_push($ret,array(lang('title'),'<input type="text" name="title" value="'.htmlspecialchars($this->mName).'" />'));
	array_push($ret,array(lang('menutext'),'<input type="text" name="menutext" value="'.htmlspecialchars($this->mMenuText,ENT_QUOTES).'" />'));
	if (!($config['auto_alias_content'] == true && $adding))
	  {
	    array_push($ret,array(lang('pagealias'),'<input type="text" name="alias" value="'.htmlspecialchars($this->mAlias,ENT_QUOTES).'" />'));
	  }
	$contentops = $gCms->GetContentOperations();
	$templateops = $gCms->GetTemplateOperations();
	array_push($ret,array(lang('parent').'/'.$this->Lang('category_page'),$contentops->CreateHierarchyDropdown($this->mId, $this->mParentId)));
	array_push($ret,array($this->Lang('namepage').' '.lang('template'),$templateops->TemplateDropdown('template_id', $this->mTemplateId)));
	array_push($ret,array($this->Lang('Sub').' '.lang('template'),$module->CreateInputDropdown('', 'sub_template', $subTemplates, -1, $this->GetPropertyValue('sub_template'))));
        
	$this->getUserAttributes();
	foreach ($this->attrs as $thisAttr)
	  {
            $v = $this->GetPropertyValue($thisAttr->attr);
			if (empty($v) && !empty($thisAttr->default))
				{
				$v = $thisAttr->default;
				}
			if ($thisAttr->is_text)
				{
				$ret[] = array($thisAttr->attr,
					create_textarea($wysiwyg, $v, $thisAttr->safe, '', $thisAttr->attr, '', $stylesheet, 80, 10));	
				}
			else
				{
				$l = $thisAttr->length;
				if (empty($l))
					{
					$l = 25;
					$m = 1024;
					}
				else
					{
					$m = $l;
					}
	    		$ret[] = array($thisAttr->attr,
					'<input type="text" name="'.$thisAttr->safe.'" value="'.
			   		htmlspecialchars($v,ENT_QUOTES).'" size="'.$l.'" maxlength="'.$m.'" />');
				}
	  }
      }


    

	   if ($tab == 1)
       {
		$imgcount = get_site_preference('Cataloger_mapi_pref_category_image_count', '1');
		$thumbsize = get_site_preference('Cataloger_mapi_pref_category_image_size_thumbnail', '90');
	if ($imgcount != 0){ // check if is not 0
	  $imgsrc = '<table>';
	for ($i=1; $i<= $imgcount; $i++)
	  {
	    $imgsrc .= '<tr><td style="vertical-align:top;">'.$this->lang('nameimages').' '.$i.':</td><td style="vertical-align:top;">';
	    $imgsrc .= '<img alt="'.$this->lang('nameimages').'" title="'.$this->lang('nameimages').'" src="'.
$config['root_url'].'/modules/Cataloger/Cataloger.Image.php?i='.$this->mAlias.'_ct_'.$i.'_'.$thumbsize.'_1.jpg&amp;ac='.rand(0,9).rand(0,9).rand(0,9).'" />';	    
	    $imgsrc .= '</td><td style="vertical-align:top;">&nbsp;<input type="file" name="image'.$i.'" />';
	    $imgsrc .= '<input type="checkbox" id="rm_image_'.$this->mAlias.
	    	'_'.$i.'" name="rm_image_'.$this->mAlias.
	    	'_'.$i.'" /><label for="rm_image_'.$this->mAlias.
	    	'_'.$i.'">'.$this->lang('deleteimage').'</label>';
	    
	    $imgsrc .= '</td></tr>';
	  }
	$imgsrc .= '</table>';
	array_push($ret,array($this->lang('nameimages').':', $imgsrc));
   }// end  if ($imgcount != 0)  
	 else{
	echo '<div class="pagetext"><img alt="'.$this->lang('nameimages').'" title="'.$this->lang('nameimages').'" src="/modules/Cataloger/images/no-image.gif" /></div>'; 
	  }// end else
	  
    }


    if ($tab == 2)
      {
	$ipp = $this->GetPropertyValue('items_per_page');
	if ($ipp == -1)
	  {
	    $ipp = get_site_preference('Cataloger_mapi_pref_category_items_per_page', '10');
	  }
	$so = $this->GetPropertyValue('sort_order');
	if ($so == '')
	  {
	    $so = get_site_preference('Cataloger_mapi_pref_category_sort_order', 'natural');
	  }
	array_push($ret,array($this->Lang('title_global_items_per_page2'),$module->CreateInputDropdown('', '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, $ipp)));

	array_push($ret,array($this->Lang('title_global_item_sort_order2'),$module->CreateInputDropdown('', 'sort_order',
									   array($this->Lang('natural_order')=>'natural', $this->Lang('alpha_order')=>'alpha'), -1, $so)));

	$recurse = $this->GetPropertyValue('recurse');
	if ($recurse == '')
	  {
	    $recurse = get_site_preference('Cataloger_mapi_pref_category_recurse', 'mixed_one');
	  }
	array_push($ret,array($this->Lang('title_global_category_recurse2'),
			      '<table><tr><td><input type="radio" name="recurse" value="items_all" '.(($recurse=='items_all')?'checked="checked"':'').'/>&nbsp;'.$this->Lang('title_category_recurse_items_all').'</td></tr>'.
			      '<tr><td><input type="radio" name="recurse" value="items_one" '.(($recurse=='items_one')?'checked="checked"':'').'/>&nbsp;'.$this->Lang('title_category_recurse_items_one').'</td></tr>' .
			      '<tr><td><input type="radio" name="recurse" value="categories_all" '.(($recurse=='categories_all')?'checked="checked"':'').'/>&nbsp;'.$this->Lang('title_category_recurse_categories_all').'</td></tr>' .
			      '<tr><td><input type="radio" name="recurse" value="categories_one" '.(($recurse=='categories_one')?'checked="checked"':'').'/>&nbsp;'.$this->Lang('title_category_recurse_categories_one').'</td></tr>' .
			      '<tr><td><input type="radio" name="recurse" value="mixed_all" '.(($recurse=='mixed_all')?'checked="checked"':'').'/>&nbsp;'.$this->Lang('title_category_recurse_mixed_all').'</td></tr>' .
			      '<tr><td><input type="radio" name="recurse" value="mixed_one" '.(($recurse=='mixed_one')?'checked="checked"':'').'/>&nbsp;'.$this->Lang('title_category_recurse_mixed_one').'</td></tr></table>'));
      }

    if ($tab == 3)
      {        
	array_push($ret,array(lang('active'),'<input type="checkbox" name="active"'.($this->mActive?' checked="checked"':'').'/>'));
	array_push($ret,array(lang('showinmenu'),'<input type="checkbox" name="showinmenu"'.($this->mShowInMenu?' checked="checked"':'').' />'));

			array_push($ret, array(lang('metadata').':',create_textarea(false, $this->Metadata(), 'metadata', 'pagesmalltextarea', 'metadata', '', '', '80', '6')));
			array_push($ret, array(lang('titleattribute').':','<input type="text" name="titleattribute" maxlength="255" value="'.cms_htmlentities($this->mTitleAttribute).'" />'));
			array_push($ret, array(lang('tabindex').':','<input type="text" name="tabindex" maxlength="10" value="'.cms_htmlentities($this->mTabIndex).'" />'));
			array_push($ret, array(lang('accesskey').':','<input type="text" name="accesskey" maxlength="5" value="'.cms_htmlentities($this->mAccessKey).'" />'));


	if (!$adding && $showadmin)
	  {
	    $userops = $gCms->GetUserOperations();
	    array_push($ret, array($this->lang('Owner').':',@$userops->GenerateDropdown($this->Owner())));
	  }
	if ($adding || $showadmin)
	  {
	    array_push($ret, $this->ShowAdditionalEditors());
	  }
      }

    return $ret;
  }

  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)
  {
    global $gCms;
    $config = &$gCms->config;
	$this->validation = FALSE;
	$this->mCachable = false;
    
    $db = $gCms->GetDb();

    if (isset($params))
      {
	$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]);
	      }
	  }

	if (isset($params['title']))
	  {
	    $this->mName = $params['title'];
	  }
	if (isset($params['menutext']))
	  {
	    $this->mMenuText = $params['menutext'];
	  }
	if (isset($params['template_id']))
	  {
	    $this->mTemplateId = $params['template_id'];
	  }
	if (isset($params['alias']))
	  {
	    $this->SetAlias($params['alias']);
	  }
	else
	  {
	    $this->SetAlias('');
	  }
	if (isset($params['parent_id']))
	  {
	    if ($this->mParentId != $params['parent_id'])
	      {
		$this->mHierarchy = '';
		$this->mItemOrder = -1;
	      }
	    $this->mParentId = $params['parent_id'];
	  }
	if (isset($params['active']))
	  {
	    $this->mActive = true;
	  }
	else
	  {
	    $this->mActive = false;
	  }
	if (isset($params['showinmenu']))
	  {
	    $this->mShowInMenu = true;
	  }
	else
	  {
	    $this->mShowInMenu = false;
	  }
	  
			if (isset($params['metadata']))
				$this->mMetadata = $params['metadata'];
			if (isset($params['accesskey']))
				$this->mAccessKey = $params['accesskey'];
			if (isset($params['titleattribute']))
				$this->mTitleAttribute = $params['titleattribute'];
			if (isset($params['tabindex']))
				$this->mTabIndex = $params['tabindex'];

	  
	// Copy and resize the image files...
	$imgcount = get_site_preference('Cataloger_mapi_pref_category_image_count', '1');
	$herosize = get_site_preference('Cataloger_mapi_pref_category_image_size_hero', '400');
	$thumbsize = get_site_preference('Cataloger_mapi_pref_category_image_size_thumbnail', '90');
    $pf = new Cataloger();
	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($pf->Lang('badimageformat',$_FILES['image'.$i]['name']));
				}
			  else
				{
		$cres = copy($_FILES['image'.$i]['tmp_name'],
		     dirname($config['uploads_path'].
			     $pf->getAssetPath('s').'/index.html') .
		     '/'.$this->mAlias.'_src_'.$i.'.jpg');
		  if (!$cres)
			{
			$this->validationError($pf->Lang('badimage',$_FILES['image'.$i]['name']));
			}
			}
	      }
	  }
	  foreach ($params as $thisParam=>$thisParamVal)
	  {
	  	if (substr($thisParam,0,9) == 'rm_image_')
	  		{
	  		$imageSpecParts = explode('_',$thisParam);
	  		$pf->purgeAllImage($imageSpecParts[2],$imageSpecParts[3]);
	  		}
	  }

      }
		parent::FillParams($params);
	}


  function PopulateParams(&$params)
  {
    global $gCms;
    $config = &$gCms->config;
    $db = $gCms->GetDb();

    $parameters = array('sub_template', 'sort_order', 'recurse', 'items_per_page');
    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;

  }



  function Show()
  {
    global $gCms;

    $params = array();

    $this->PopulateParams($params);

    $pf = new Cataloger();

    @ob_start();
    $pf->DoAction('defaultcategory', 'catalogmodule', $params);
    $text = @ob_get_contents();
    @ob_end_clean();
    return '{literal}'.$text.'{/literal}';
  }

  function FriendlyName()
  {
    return $this->Lang('category_page');
  }
}

# vim:ts=4 sw=4 noet
?>
]]></data>
	</file>
	<file>
	  <filename>/contenttype.catalogitem.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.6
#
# 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 CMSModuleContentType
{
  var $attrs;
  var $validation=FALSE;

  function CatalogItem()
  {
	$this->ContentBase();
  }

  function ModuleName()
  {
    return 'Cataloger';
  }

  function IsCopyable()
  {
  return true;
  }

  function SetProperties()
  {
	 parent::SetProperties();
  	$this->getUserAttributes();
    foreach ($this->attrs as $thisAttr)
      {
	  $this->AddExtraProperty($thisAttr->attr);
      }
	  
	$this->AddExtraProperty('sub_template');

	#Turn on preview
    $this->mPreview = true;

	#Turn off caching
    $this->mCachable = false;
  }

  function getUserAttributes()
  {
	global $gCms;
	Cataloger::getUserAttributes('catalog_attrs');
    $vars = &$gCms->variables;
	$this->attrs = &$vars['catalog_attrs'];
  }
    
  function getItemAttr($name)
  {
      $this->getUserAttributes();
      return $this->attrs[$name];

  }
    
  function &getAttrs()
    {
      $this->getUserAttributes();
      return $this->attrs;
    }

  function GetCreationDate()
  {
    return $this->mCreationDate;
  }
	
  function GetModifiedDate()
  {
    return $this->mModifiedDate;
  }

  function TabNames()
  {
    $ret = array(lang('main'));
	if (get_site_preference('Cataloger_mapi_pref_item_image_count', 0)>0) array_push($ret, $this->lang('nameimages'));
	if (get_site_preference('Cataloger_mapi_pref_item_file_count', 0)>0) array_push($ret, $this->lang('namefiles'));
	array_push($ret, lang('options'));
	return $ret;
  }

  function EditAsArray($adding = false, $tab = 0, $showadmin=false)
  {
    global $gCms;
    $config = &$gCms->config;
    $module = $this->GetModuleInstance();
    $db = $gCms->GetDb();
    $wysiwyg = (strlen(get_preference(get_userid(), 'wysiwyg')) > 0);
    $has_images = (get_site_preference('Cataloger_mapi_pref_item_image_count', 0)>0);
    $has_files = (get_site_preference('Cataloger_mapi_pref_item_file_count', 0)>0);
    if ($tab == 1)
 		{
		if (! $has_images && ! $has_files)
			{
			$tab = 3;
			}
		else if (!$has_images) $tab=2;
		}
	else if ($tab == 2)
	 	{
		if (!$has_images || !$has_files) $tab = 3;
		}
    $ret = array();
    $stylesheet = '';
    if ($this->TemplateId() > 0)
      {
	$stylesheet = '../stylesheet.php?templateid='.$this->TemplateId();
      }
    else
      {
	$templateops = $gCms->GetTemplateOperations();
	$defaulttemplate = $templateops->LoadDefaultTemplate();
	if (isset($defaulttemplate))
	  {
	    $this->mTemplateId = $defaulttemplate->id;
	    $stylesheet = '../stylesheet.php?templateid='.$this->TemplateId();
	  }
      }

    if ($tab == 0)
      {
        $query = "SELECT id, title FROM ".
	  cms_db_prefix().
	  "module_catalog_template WHERE type_id=1 ORDER by title";
        $subTemplates = array();
        $dbresult = $db->Execute($query);

        while ($dbresult !== false && $row = $dbresult->FetchRow())
	  {
	    $subTemplates[$row['title']]=$row['id'];
	  }		

	$ret[] = array(lang('title'),
			     '<input type="text" name="title" value="'.htmlspecialchars($this->mName,ENT_QUOTES).'" />');
	$ret[] = array(lang('menutext'),
			      '<input type="text" name="menutext" value="'.
			      htmlspecialchars($this->mMenuText, ENT_QUOTES).'" />');
	if (!($config['auto_alias_content'] == true && $adding))
	  {
	    $ret[] = array(lang('pagealias'),
				  '<input type="text" name="alias" value="'.
				  htmlspecialchars($this->mAlias, ENT_QUOTES).'" />');
	  }
	$contentops = $gCms->GetContentOperations();
	$ret[] = array(lang('parent').
			      '/'.$this->Lang('category_page'),
			      $contentops->CreateHierarchyDropdown($this->mId,
								      $this->mParentId));
	$templateops = $gCms->GetTemplateOperations();
	$ret[] = array($this->Lang('namepage').' '.
			      lang('template'),
			      $templateops->TemplateDropdown('template_id',
							     $this->mTemplateId));
	$val = $this->GetPropertyValue('sub_template');
	$ret[] = array($this->Lang('Sub').' '.
			      lang('template'),
			      $module->CreateInputDropdown('',
							   'sub_template', $subTemplates, -1, $val));
	$this->getUserAttributes();
	foreach ($this->attrs as $thisAttr)
	  {
            $v = $this->GetPropertyValue($thisAttr->attr);
			if (empty($v) && !empty($thisAttr->default))
				{
				$v = $thisAttr->default;
				}
			if ($thisAttr->is_text)
				{
				$ret[] = array($thisAttr->attr,
					create_textarea($wysiwyg, $v, $thisAttr->safe, '', $thisAttr->attr, '', $stylesheet, 80, 10));	
				}
			else
				{
				$l = $thisAttr->length;
				if (empty($l))
					{
					$l = 25;
					$m = 1024;
					}
				else
					{
					$m = $l;
					}
	    		$ret[] = array($thisAttr->attr,
					'<input type="text" name="'.$thisAttr->safe.'" value="'.
			   		htmlspecialchars($v,ENT_QUOTES).'" size="'.$l.'" maxlength="'.$m.'" />');
				}
	  }
      }
    if ($tab == 1)
      {
	$imgcount = get_site_preference('Cataloger_mapi_pref_item_image_count', '2');
	$thumbsize = get_site_preference('Cataloger_mapi_pref_item_image_size_thumbnail', '70');
	if ($imgcount != 0){ // check if is not 0
	$imgsrc = '<table>';
	for ($i=1; $i<= $imgcount; $i++)
	  {
	    $imgsrc .= '<tr><td style="vertical-align:top;">'.$this->lang('nameimages').' '.$i.':</td><td style="vertical-align:top;">';
	    $imgsrc .= '<img alt="'.$this->lang('nameimages').'" title="'.$this->lang('nameimages').'" src="'.
$config['root_url'].'/modules/Cataloger/Cataloger.Image.php?i='.$this->mAlias.'_t_'.$i.'_'.$thumbsize.'_1.jpg&amp;ac='.rand(0,9).rand(0,9).rand(0,9).'" />';
	    $imgsrc .= '</td><td style="vertical-align:top;">&nbsp;<input type="file" name="image'.$i.'" />';
	    $imgsrc .= '<input type="checkbox" id="rm_image_'.$this->mAlias.
	    	'_'.$i.'" name="rm_image_'.$this->mAlias.
	    	'_'.$i.'" /><label for="rm_image_'.$this->mAlias.
	    	'_'.$i.'">'.$this->lang('deleteimage').'</label>';

	    $imgsrc .= '</td></tr>';
	  }
	$imgsrc .= '</table>';
	$ret[] = array($this->lang('nameimages').':', $imgsrc);
	 }// end  if ($imgcount != 0)  
	 else{
	echo '<div class="pagetext"><img alt="'.$this->lang('nameimages').'" title="'.$this->lang('nameimages').'" src="/modules/Cataloger/images/no-image.gif" /></div>'; 
	  }// end else
	
      }
	if ($tab == 2)
		{
				$filecount = get_site_preference('Cataloger_mapi_pref_item_file_count', '0');
				if ($filecount != 0){ // check if is not 0
				list($filelist,$filetype) = $module->getFiles($this->mAlias);
				$filesrc = '<table>';
				for ($i=0; $i< $filecount; $i++)
				  {
				    $filesrc .= '<tr><td style="vertical-align:middle;">';
					if (isset($filelist[$i]))
						{
						$filesrc .= '<img src="'.$gCms->config['root_url'].'/modules/FileManager/icons/themes/default/extensions/16px/'.
							$filetype[$i].'.png" /></td><td style="vertical-align:middle">';
						$filesrc .= $filelist[$i];
						}
					else
						{
						$filesrc .= $this->lang('namefile').'</td><td style="vertical-align:middle">#'.($i+1);
						}
				
					$filesrc .='</td><td style="vertical-align:middle;">';
				    $filesrc .= '<td style="vertical-align:middle;">&nbsp;<input type="file" name="file'.$i.'" />';
					if (isset($filelist[$i]))
						{
				    	$filesrc .= '<input type="checkbox" id="rm_file_'.$this->mAlias.
				    	'_'.$i.'" name="rm_file_'.$filelist[$i].'" value="'.$filelist[$i].'"/><label for="rm_file_'.$this->mAlias.
				    	'_'.$i.'">'.$this->lang('deletefile').'</label>';
						}
				    $filesrc .= '</td></tr>';
				  }
				$filesrc .= '</table>';
				$ret[] = array($this->lang('namefiles').':', $filesrc);
			}
			 else{
			echo '<div class="pagetext"><img alt="'.$this->lang('namefiles').'" title="'.$this->lang('namefiles').'" src="/modules/Cataloger/images/no-image.gif" /></div>'; 
			  }
				
		}
    if ($tab == 3)
      {
        $ret[] = array(lang('active'),'<input type="checkbox" name="active"'.($this->mActive?' checked="checked"':'').' />');
	$ret[] = array(lang('showinmenu'),'<input type="checkbox" name="showinmenu"'.($this->mShowInMenu?' checked="checked"':'').' />');

			array_push($ret, array(lang('metadata').':',create_textarea(false, $this->Metadata(), 'metadata', 'pagesmalltextarea', 'metadata', '', '', '80', '6')));
			array_push($ret, array(lang('titleattribute').':','<input type="text" name="titleattribute" maxlength="255" value="'.cms_htmlentities($this->mTitleAttribute).'" />'));
			array_push($ret, array(lang('tabindex').':','<input type="text" name="tabindex" maxlength="10" value="'.cms_htmlentities($this->mTabIndex).'" />'));
			array_push($ret, array(lang('accesskey').':','<input type="text" name="accesskey" maxlength="5" value="'.cms_htmlentities($this->mAccessKey).'" />'));

	if (!$adding && $showadmin)
	  {
	    $userops = $gCms->GetUserOperations();
	    $ret[] = array($this->lang('Owner').':',@$userops->GenerateDropdown($this->Owner()));
	  }
	if ($adding || $showadmin)
	  {
	    $ret[] = $this->ShowAdditionalEditors();
	  }
      }
    return $ret;
  }

  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)
  {
    global $gCms;
    $config = &$gCms->config;
    $db = $gCms->GetDb();
    $this->validation = FALSE;

    if (isset($params))
      {
	$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]);
	      }
	  }
	
	if (isset($params['title']))
	  {
	    $this->mName = $params['title'];
	  }
	if (isset($params['menutext']))
	  {
	    $this->mMenuText = $params['menutext'];
	  }
	if (isset($params['template_id']))
	  {
	    $this->mTemplateId = $params['template_id'];
	  }
	if (isset($params['alias']))
	  {
	    $this->SetAlias($params['alias']);
	  }
	else
	  {
	    $this->SetAlias('');
	  }
	if (isset($params['parent_id']))
	  {
	    if ($this->mParentId != $params['parent_id'])
	      {
		$this->mHierarchy = '';
		$this->mItemOrder = -1;
	      }
	    $this->mParentId = $params['parent_id'];
	  }
	if (isset($params['active']))
	  {
	    $this->mActive = true;
	  }
	else
	  {
	    $this->mActive = false;
	  }
	if (isset($params['showinmenu']))
	  {
	    $this->mShowInMenu = true;
	  }
	else
	  {
	    $this->mShowInMenu = false;
	  }

			if (isset($params['metadata']))
				$this->mMetadata = $params['metadata'];
			if (isset($params['accesskey']))
				$this->mAccessKey = $params['accesskey'];
			if (isset($params['titleattribute']))
				$this->mTitleAttribute = $params['titleattribute'];
			if (isset($params['tabindex']))
				$this->mTabIndex = $params['tabindex'];

			
	// Copy the image files...
	$imgcount = get_site_preference('Cataloger_mapi_pref_item_image_count', '2');
	$herosize = get_site_preference('Cataloger_mapi_pref_item_image_size_hero', '400');
	$thumbsize = get_site_preference('Cataloger_mapi_pref_item_image_size_thumbnail', '70');
	$catalogsize = get_site_preference('Cataloger_mapi_pref_item_image_size_catalog', '100');
	$categorysize = get_site_preference('Cataloger_mapi_pref_item_image_size_category', '70');
    $pf = new Cataloger();

	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($pf->Lang('badimageformat',$_FILES['image'.$i]['name']));
			}
		  else
			{
		$cres = copy($_FILES['image'.$i]['tmp_name'],
		     dirname($config['uploads_path'].
			     $pf->getAssetPath('s').'/index.html') .
		     '/'.$this->mAlias.'_src_'.$i.'.jpg');
		  if (!$cres)
			{
			$this->validationError($pf->Lang('badimage',$_FILES['image'.$i]['name']));
			}
			}
	      }
	  }
	  foreach ($params as $thisParam=>$thisParamVal)
	  {
	  	if (substr($thisParam,0,9) == 'rm_image_')
	  		{
	  		$imageSpecParts = explode('_',$thisParam);
	  		$pf->purgeAllImage($imageSpecParts[2],$imageSpecParts[3]);
	  		}
	  }
	
	// and uploaded files  
	$filecount = get_site_preference('Cataloger_mapi_pref_item_file_count', 0);
	$typelist = get_site_preference('Cataloger_mapi_pref_item_file_types', 'pdf,swf,flv,doc,odt,ods,xls');
	$types = explode(',',$typelist);
	if ($filecount > 0)
		{
		$dirspec = $config['uploads_path'].$pf->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))
					{
					$pf->Audit( 0, $pf->Lang('friendlyname'), $pf->Lang('uploaded',array($tspec,$this->mAlias)));
					$cres = copy($_FILES['file'.$i]['tmp_name'],
		     			$dirspec.'/'.$tspec);
				  	if (!$cres)
						{
						$this->validationError($pf->Lang('badimage',$_FILES['image'.$i]['name']));
						}
					}
				else
					{
					$pf->Audit( 0, $pf->Lang('friendlyname'), $pf->Lang('badfile',$tspec));
					$this->validationError($pf->Lang('badfile',$tspec));
					}
	      		}
			}
	  }
	  foreach ($params as $thisParam=>$thisParamVal)
	  {
	  	if (substr($thisParam,0,8) == 'rm_file_')
	  		{
			$pSpec = preg_replace('/\.\.|\//','',$thisParamVal);
			$spec = $config['uploads_path'].$pf->getAssetPath('f').'/'.$this->mAlias.'/'.$pSpec;
	  		unlink($spec);
	  		}
	  }
      }
		parent::FillParams($params);
	}

  function PopulateParams(&$params)
  {
    global $gCms;
    $config = &$gCms->config;
    $db = $gCms->GetDb();

    $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['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='')
  {
    global $gCms;

    $params = array();

    $this->PopulateParams($params);

    $pf = new Cataloger();

    @ob_start();
    $pf->DoAction('default', 'catalogmodule', $params);
    $text = @ob_get_contents();
    @ob_end_clean();
    return '{literal}'.$text.'{/literal}';
  }


  function FriendlyName()
  {
    return $this->Lang('item_page');
  }
}

# vim:ts=4 sw=4 noet
?>
]]></data>
	</file>
	<file>
	  <filename>/contenttype.catalogprintable.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: Cataloger - build a catalog or portfolio of stuff
# Version: 0.6
#
# 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
#
#-------------------------------------------------------------------------
require_once(dirname(__FILE__).'/contenttype.catalogitem.php');

class CatalogPrintable extends CMSModuleContentType
{
  var $attrs;

  function ModuleName()
  {
    return 'Cataloger';
  }

  function IsCopyable()
  {
  return true;
  }

	
  function SetProperties()
  {
 	 parent::SetProperties();
  	$this->getUserAttributes();
    foreach ($this->attrs as $thisAttr)
      {
	  $this->AddExtraProperty($thisAttr->attr);
      }

    $this->AddExtraProperty('sort_order');
    $this->AddExtraProperty('sub_template');
    $this->AddExtraProperty('fieldlist');
		
#Turn on preview
    $this->mPreview = true;

#Turn off caching
    $this->mCachable = false;
  }

  function getUserAttributes()
  {
	global $gCms;
	Cataloger::getUserAttributes('catalog_print_attrs');
	$vars = &$gCms->variables;
	$this->attrs = &$vars['catalog_print_attrs'];

  }

  function &getAttrs()
    {
      $this->getUserAttributes();
      return $this->attrs;
    }


  function GetCreationDate()
  {
    return $this->mCreationDate;
  }
	
  function GetModifiedDate()
  {
    return $this->mModifiedDate;
  }

  function TabNames()
  {
    return array(lang('main'), lang('options'), $this->lang('Owner'));
  }

  function EditAsArray($adding = false, $tab = 0, $showadmin=false)
  {
    global $gCms;
    $config = &$gCms->config;
    $db = $gCms->GetDb();
    $wysiwyg = (strlen(get_preference(get_userid(), 'wysiwyg')) > 0);
    $ret = array();
    $stylesheet = '';
    if ($this->TemplateId() > 0)
      {
	$stylesheet = '../stylesheet.php?templateid='.$this->TemplateId();
      }
    else
      {
	$templateops = $gCms->GetTemplateOperations();
	$defaulttemplate = $templateoperations->LoadDefaultTemplate();
	if (isset($defaulttemplate))
	  {
	    $this->mTemplateId = $defaulttemplate->id;
	    $stylesheet = '../stylesheet.php?templateid='.$this->TemplateId();
	  }
      }

    if ($tab == 0)
      {
        $query = "SELECT id, title FROM ".
	  cms_db_prefix()."module_catalog_template WHERE type_id=3 ORDER by title";
        $subTemplates = array();
        $dbresult = $db->Execute($query);

	$templateops = $gCms->GetTemplateOperations();
        while ($dbresult !== false && $row = $dbresult->FetchRow())
	  {
	    $subTemplates[$row['title']]=$row['id'];
	  }		

	array_push($ret,array(lang('title'),'<input type="text" name="title" value="'.htmlspecialchars($this->mName).'" />'));
	array_push($ret,array(lang('menutext'),'<input type="text" name="menutext" value="'.htmlspecialchars($this->mMenuText,ENT_QUOTES).'" />'));
	if (!($config['auto_alias_content'] == true && $adding))
	  {
	    array_push($ret,array(lang('pagealias'),'<input type="text" name="alias" value="'.htmlspecialchars($this->mAlias,ENT_QUOTES).'" />'));
	  }
	$contentops = $gCms->GetContentOperations();
	array_push($ret,array(lang('parent').'/'.$this->Lang('category_page'),$contentops->CreateHierarchyDropdown($this->mId, $this->mParentId)));
	array_push($ret,array($this->Lang('namepage').' '.lang('template'),$templateops->TemplateDropdown('template_id', $this->mTemplateId)));
	$module =& $this->GetModuleInstance();
	
	array_push($ret,array($this->Lang('Sub').' '.lang('template'),$module->CreateInputDropdown('', 'sub_template', $subTemplates, -1, $this->GetPropertyValue('sub_template'))));
        
	$this->getUserAttributes();
	foreach ($this->attrs as $thisAttr)
	  {
            $v = $this->GetPropertyValue($thisAttr->attr);
			if (empty($v) && !empty($thisAttr->default))
				{
				$v = $thisAttr->default;
				}
			if ($thisAttr->is_text)
				{
				$ret[] = array($thisAttr->attr,
					create_textarea($wysiwyg, $v, $thisAttr->safe, '', $thisAttr->attr, '', $stylesheet, 80, 10));	
				}
			else
				{
				$l = $thisAttr->length;
				if (empty($l))
					{
					$l = 25;
					$m = 1024;
					}
				else
					{
					$m = $l;
					}
	    		$ret[] = array($thisAttr->attr,
					'<input type="text" name="'.$thisAttr->safe.'" value="'.
			   		htmlspecialchars($v,ENT_QUOTES).'" size="'.$l.'" maxlength="'.$m.'" />');
				}
	  }

      }
    if ($tab == 1)
      {
	$so = $this->GetPropertyValue('sort_order');
	if ($so == '')
	  {
	    $so = get_site_preference('Cataloger_mapi_pref_printable_sort_order', 'natural');
	  }

	$module =& $this->GetModuleInstance();
	array_push($ret,array($this->Lang('title_global_item_sort_order2'),$module->CreateInputDropdown('', 'sort_order',
									   array($this->Lang('natural_order')=>'natural', $this->Lang('alpha_order')=>'alpha'), -1, $so)));

   $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 />';
	  }
	array_push($ret,array($this->Lang('which_attributes'),$attrPick));
      }
    if ($tab == 2)
      {        
	array_push($ret,array(lang('active'),'<input type="checkbox" name="active"'.($this->mActive?' checked="checked"':'').' />'));
	array_push($ret,array(lang('showinmenu'),'<input type="checkbox" name="showinmenu"'.($this->mShowInMenu?' checked="checked"':'').' />'));
	if (!$adding && $showadmin)
	  {
	    $userops = $gCms->GetUserOperations();
	    array_push($ret, array($this->lang('Owner'),@$userops->GenerateDropdown($this->Owner())));
	  }
	if ($adding || $showadmin)
	  {
	    array_push($ret, $this->ShowAdditionalEditors());
	  }
      }
    return $ret;
  }

  function FillParams(&$params)
  {
    global $gCms;
    $config = &$gCms->config;
    $db = $gCms->GetDb();
    $this->mCachable = false;

    if (isset($params))
      {
	$parameters = array('sub_template', 'sort_order');

	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]);
	      }
	  }

	if (isset($params['title']))
	  {
	    $this->mName = $params['title'];
	  }
	if (isset($params['menutext']))
	  {
	    $this->mMenuText = $params['menutext'];
	  }
	if (isset($params['template_id']))
	  {
	    $this->mTemplateId = $params['template_id'];
	  }
	if (isset($params['alias']))
	  {
	    $this->SetAlias($params['alias']);
	  }
	else
	  {
	    $this->SetAlias('');
	  }
	if (isset($params['parent_id']))
	  {
	    if ($this->mParentId != $params['parent_id'])
	      {
		$this->mHierarchy = '';
		$this->mItemOrder = -1;
	      }
	    $this->mParentId = $params['parent_id'];
	  }
	if (isset($params['active']))
	  {
	    $this->mActive = true;
	  }
	else
	  {
	    $this->mActive = false;
	  }
	if (isset($params['showinmenu']))
	  {
	    $this->mShowInMenu = true;
	  }
	else
	  {
	    $this->mShowInMenu = false;
	  }
	  
			if (isset($params['metadata']))
				$this->mMetadata = $params['metadata'];
			if (isset($params['accesskey']))
				$this->mAccessKey = $params['accesskey'];
			if (isset($params['titleattribute']))
				$this->mTitleAttribute = $params['titleattribute'];
			if (isset($params['tabindex']))
				$this->mTabIndex = $params['tabindex'];

	if (isset($params['fieldlist']))
	  {
	    if (! is_array($params['fieldlist']))
	      {
		    $params['fieldlist'] = array($params['fieldlist']);
	      }

	    $this->SetPropertyValue('fieldlist', implode(',',$params['fieldlist']));
	  }
      }
		parent::FillParams($params);
	}


  function PopulateParams(&$params)
  {
    global $gCms;
    $config = &$gCms->config;
    $db = $gCms->GetDb();

    $parameters = array('sub_template', 'sort_order','fieldlist');
    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['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()
  {
    global $gCms;

    $params = array();

    $this->PopulateParams($params);

    $pf = new Cataloger();

    @ob_start();
    $pf->DoAction('defaultprintable', 'catalogmodule', $params);
    $text = @ob_get_contents();
    @ob_end_clean();
    return '{literal}'.$text.'{/literal}';
  }

  function FriendlyName()
  {
    return $this->Lang('catalog_printable');
  }
}

# vim:ts=4 sw=4 noet
?>
]]></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/global.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/images/icon.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></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/trans.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhAQABAIAAAAAAAAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==]]></data>
	</file>
	<file>
	  <filename>/includes/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/includes/Category-CSS-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGgxPnskdGl0bGV9PC9oMT4Ne3NlY3Rpb24gbmFtZT1udW1pbWcgbG9vcD0kaW1hZ2VfdXJsX2FycmF5fTxpbWcgc3JjPSJ7JGltYWdlX3VybF9hcnJheVtudW1pbWddfSIgYWx0PSJ7JHRpdGxlfSIgdGl0bGU9InskdGl0bGV9IiAvPnsvc2VjdGlvbn0NeyRub3Rlc30NPGRpdiBjbGFzcz0iY2F0ZWdvcnlfaXRlbXMiPg0gICB7aWYgJGhhc25hdiA9PSAxfQ08ZGl2IGNsYXNzPSJjYXRuYXYiPnskcHJldn17JG5hdnN0cn17JG5leHR9PC9kaXY+DQl7L2lmfQ0gICAge3NlY3Rpb24gbmFtZT1udW1sb29wIGxvb3A9JGl0ZW1zfQ0gICAgICAgIDxkaXYgY2xhc3M9ImNhdGVnb3J5X2l0ZW0iPjxhIGhyZWY9InskaXRlbXNbbnVtbG9vcF0ubGlua30iPjxpbWcgc3JjPSJ7JGl0ZW1zW251bWxvb3BdLmltYWdlfSIgdGl0bGU9InskaXRlbXNbbnVtbG9vcF0udGl0bGV9IiBhbHQ9InskaXRlbXNbbnVtbG9vcF0udGl0bGV9Ii8+PC9hPjxiciAvPjxhIGhyZWY9InskaXRlbXNbbnVtbG9vcF0ubGlua30iPnskaXRlbXNbbnVtbG9vcF0udGl0bGV9PC9hPjwvZGl2Pg0gICAgey9zZWN0aW9ufQ0gICAge2lmICRoYXNuYXYgPT0gMX0NeyogDVRoZSBudW1iZXIgdGhhdCBpcyB3aXRob3V0IGEgbGluayAoYSBocmVmKSBoYXZlIGEgPHNwYW4gY2xhc3M9Im5vbGluayIgKSBoYXZlIGEgbG9vayBpbiBzb3VyY2UgY29kZS1odG1sDSp9DTxkaXYgY2xhc3M9ImNhdG5hdiI+eyRwcmV2fXskbmF2c3RyfXskbmV4dH08L2Rpdj4NCXsvaWZ9DTwvZGl2Pg0=]]></data>
	</file>
	<file>
	  <filename>/includes/Category-Table-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2Fzc2lnbiB2YXI9ImNvbHMiIHZhbHVlPSIzIn08aDE+eyR0aXRsZX08L2gxPg17c2VjdGlvbiBuYW1lPW51bWltZyBsb29wPSRpbWFnZV91cmxfYXJyYXl9PGltZyBzcmM9InskaW1hZ2VfdXJsX2FycmF5W251bWltZ119IiB0aXRsZT0ieyR0aXRsZX0iIGFsdD0ieyR0aXRsZX0iIC8+ey9zZWN0aW9ufQ17JG5vdGVzfQ08dGFibGUgc3R5bGU9ImJvcmRlcjogc29saWQgMXB4IGJsYWNrOyI+DTx0cj4NICAgIHtzZWN0aW9uIG5hbWU9bnVtbG9vcCBsb29wPSRpdGVtc30NICAgICAgICA8dGQgc3R5bGU9IndpZHRoOiAyMDBweDsiPjxhIGhyZWY9InskaXRlbXNbbnVtbG9vcF0ubGlua30iPjxpbWcgc3JjPSJ7JGl0ZW1zW251bWxvb3BdLmltYWdlfSIgdGl0bGU9InskaXRlbXNbbnVtbG9vcF0udGl0bGV9IiBhbHQ9InskaXRlbXNbbnVtbG9vcF0udGl0bGV9Ii8+PC9hPjxiciAvPjxhIGhyZWY9InskaXRlbXNbbnVtbG9vcF0ubGlua30iPnskaXRlbXNbbnVtbG9vcF0udGl0bGV9PC9hPjwvdGQ+DSAgICAgICAge2lmIG5vdCAoJHNtYXJ0eS5zZWN0aW9uLm51bWxvb3Aucm93bnVtIG1vZCAkY29scyl9DSAgICAgICAgICAgICAgICB7aWYgbm90ICRzbWFydHkuc2VjdGlvbi5udW1sb29wLmxhc3R9DSAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyPg0gICAgICAgICAgICAgICAgey9pZn0NICAgICAgICB7L2lmfQ0gICAgICAgIHtpZiAkc21hcnR5LnNlY3Rpb24ubnVtbG9vcC5sYXN0fQ0gICAgICAgICAgICAgICAge21hdGggZXF1YXRpb24gPSAibiAtIGEgJSBuIiBuPSRjb2xzIGE9JGl0ZW1zfEBjb3VudCBhc3NpZ249ImNlbGxzIn0NICAgICAgICAgICAgICAgIHtpZiAkY2VsbHMgbmUgJGNvbHN9DSAgICAgICAgICAgICAgICB7c2VjdGlvbiBuYW1lPXBhZCBsb29wPSRjZWxsc30NICAgICAgICAgICAgICAgICAgICAgICAgPHRkIHN0eWxlPSJ3aWR0aDogMjAwcHg7Ij4mbmJzcDs8L3RkPg0gICAgICAgICAgICAgICAgey9zZWN0aW9ufQ0gICAgICAgICAgICAgICAgey9pZn0NICAgICAgICAgICAgICAgIDwvdHI+DSAgICAgICAgey9pZn0NICAgIHsvc2VjdGlvbn0KICAgIHtpZiAkaGFzbmF2ID09IDF9DTx0cj48dGR7aWYgJGNvbHMgZ3QgMX0gY29sc3Bhbj0ieyRjb2xzfSJ7L2lmfSBzdHlsZT0iYm9yZGVyLXRvcDogc29saWQgMXB4IGJsYWNrOyI+eyRwcmV2fXskbmF2c3RyfXskbmV4dH08L3RkPjwvdHI+Cgl7L2lmfQ08L3RhYmxlPg0=]]></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/Item-CSS-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0iY2F0YWxvZ19pdGVtIj4NPHA+eyR0aXRsZX08L3A+DTxkaXYgY2xhc3M9Iml0ZW1faW1hZ2VzIj48aW1nIGlkPSJpdGVtX2ltYWdlIiBuYW1lPSJpdGVtX2ltYWdlIiAgc3JjPSJ7JGltYWdlXzFfdXJsfSIgYWx0PSJ7JHRpdGxlfSIgdGl0bGU9InskdGl0bGV9IiAvPg08ZGl2IGNsYXNzPSJpdGVtX3RodW1ibmFpbHMiPntzZWN0aW9uIG5hbWU9aW5kIGxvb3A9JGltYWdlX3VybF9hcnJheX0NPGEgaHJlZj0iamF2YXNjcmlwdDpyZXBsKCd7JGltYWdlX3VybF9hcnJheVtpbmRdfScpIj48aW1nIHNyYz0ieyRpbWFnZV90aHVtYl91cmxfYXJyYXlbaW5kXX0iIHRpdGxlPSJ7JHRpdGxlfSIgYWx0PSJ7JHRpdGxlfSIgLz48L2E+DXsvc2VjdGlvbn08L2Rpdj48L2Rpdj4Ne3NlY3Rpb24gbmFtZT1hdCBsb29wPSRhdHRybGlzdH0NPGRpdiBjbGFzcz0iaXRlbV9hdHRyaWJ1dGVfbmFtZSI+eyRhdHRybGlzdFthdF0ubmFtZX06PC9kaXY+PGRpdiBjbGFzcz0iaXRlbV9hdHRyaWJ1dGVfdmFsIj57ZXZhbCB2YXI9JGF0dHJsaXN0W2F0XS5rZXl9PC9kaXY+DXsvc2VjdGlvbn0Ne2xpdGVyYWx9DTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NZnVuY3Rpb24gcmVwbChpbWcpDSAgIHsNICAgZG9jdW1lbnQuaXRlbV9pbWFnZS5zcmM9aW1nOw0gICB9DTwvc2NyaXB0Pg17L2xpdGVyYWx9DXtpZiAkZmlsZV9jb3VudCA+IDB9DTx1bCBjbGFzcz0iZmlsZXMiPntzZWN0aW9uIG5hbWU9aW5kIGxvb3A9JGZpbGVfbmFtZV9hcnJheX0NPGxpPjxhIGhyZWY9InskZmlsZV91cmxfYXJyYXlbaW5kXX0iPnskZmlsZV9uYW1lX2FycmF5W2luZF19PC9hPjwvbGk+DXsvc2VjdGlvbn0NPC91bD4Ney9pZn0NDTwvZGl2Pg0=]]></data>
	</file>
	<file>
	  <filename>/includes/Item-Table-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBjbGFzcz0iaXRlbSI+DTxwPnskdGl0bGV9PC9wPg08dGFibGU+PHRyPjx0ZD48aW1nIGlkPSJpdGVtX2ltYWdlIiBuYW1lPSJpdGVtX2ltYWdlIiAgc3JjPSJ7JGltYWdlXzFfdXJsfSIgdGl0bGU9InskdGl0bGV9IiBhbHQ9InskdGl0bGV9IiAvPjwvdGQ+DTx0ZD57c2VjdGlvbiBuYW1lPWluZCBsb29wPSRpbWFnZV91cmxfYXJyYXl9DTxhIGhyZWY9ImphdmFzY3JpcHQ6cmVwbCgneyRpbWFnZV91cmxfYXJyYXlbaW5kXX0nKSI+PGltZyBzcmM9InskaW1hZ2VfdGh1bWJfdXJsX2FycmF5W2luZF19IiB0aXRsZT0ieyR0aXRsZX0iIGFsdD0ieyR0aXRsZX0iIC8+PC9hPg17L3NlY3Rpb259PC90ZD48L3RyPjwvdGFibGU+DXtzZWN0aW9uIG5hbWU9YXQgbG9vcD0kYXR0cmxpc3R9DTxwPjxzdHJvbmc+eyRhdHRybGlzdFthdF0ubmFtZX08L3N0cm9uZz46IHtldmFsIHZhcj0kYXR0cmxpc3RbYXRdLmtleX08L3A+DXsvc2VjdGlvbn0Ne2xpdGVyYWx9DTxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NZnVuY3Rpb24gcmVwbChpbWcpDSAgIHsNICAgZG9jdW1lbnQuaXRlbV9pbWFnZS5zcmM9aW1nOw0gICB9DTwvc2NyaXB0Pg17L2xpdGVyYWx9DTwvZGl2Pg0=]]></data>
	</file>
	<file>
	  <filename>/includes/Printable-Catalog-Table-based.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2Fzc2lnbiB2YXI9ImNvbHMiIHZhbHVlPSIzIn08aDE+eyR0aXRsZX08L2gxPg17JG5vdGVzfQ08dGFibGUgc3R5bGU9ImJvcmRlcjogc29saWQgMXB4IGJsYWNrOyI+DTx0cj4NICAgIHtzZWN0aW9uIG5hbWU9bnVtbG9vcCBsb29wPSRpdGVtc30NICAgICAgICA8dGQgc3R5bGU9IndpZHRoOiAyMDBweDsiPjxhIGhyZWY9InskaXRlbXNbbnVtbG9vcF0ubGlua30iPjxpbWcgc3JjPSJ7JGl0ZW1zW251bWxvb3BdLmltYWdlfSIgdGl0bGU9InskaXRlbXNbbnVtbG9vcF0udGl0bGV9IiBhbHQ9InskaXRlbXNbbnVtbG9vcF0udGl0bGV9Ii8+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_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_is_textfield']='Text Area?';
$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 does not apply to Text Areas)';


$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; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&lt;sjg@cmsmodules.com&gt;</a>. 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/ext/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/ext/cs_CZ.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['needpermission'] = 'Pro toto je třeba nastavit %s.';
$lang['friendlyname'] = 'Spr&aacute;vce katalogu';
$lang['admindescription'] = 'Upravit nastaven&iacute; katalogu';
$lang['areyousure'] = 'Opravdu chcete smazat %s?';
$lang['uniquecode'] = 'Unik&aacute;tn&iacute; k&oacute;d';
$lang['templatelist'] = 'Pod-&scaron;ablona';
$lang['listtempl'] = 'Spravovat pod-&scaron;ablony';
$lang['title_item_tab'] = 'Vlastnosti položky';
$lang['title_category_tab'] = 'Vlastnosti kategorie';
$lang['title_printable_tab'] = 'Nastaven&iacute; tisknuteln&eacute;ho katalogu';
$lang['title_item_image_tab'] = 'Velikosti obr&aacute;zků položky';
$lang['title_category_image_tab'] = 'Nastaven&iacute; str&aacute;nky kategori&iacute;';
$lang['title_is_textfield'] = 'Text Area?';
$lang['title_delete'] = 'Smazat?';
$lang['title_aspect_tab'] = 'Poměr stran obr&aacute;zku';
$lang['title_image_tab'] = 'Jin&aacute; nastaven&iacute; obr&aacute;zků';
$lang['title_item_template_vars'] = 'Proměnn&eacute; &scaron;ablony položek';
$lang['title_cat_template_vars'] = 'Proměnn&eacute; &scaron;ablony kategori&iacute;';
$lang['title_feature_template_vars'] = 'Features Template Variables';
$lang['title_show_only_existing_images'] = 'Don&#039;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['cataloger'] = 'Spr&aacute;vce katalogu';
$lang['item_page'] = 'Str&aacute;nka položky';
$lang['category_page'] = 'Str&aacute;nka kategorie';
$lang['catalog_printable'] = 'Tisknuteln&yacute; katalog';
$lang['catalog_datasheet'] = 'Katalogov&yacute; list';
$lang['catalog_short_list'] = 'Seznam vlastnost&iacute;';
$lang['title_global_item_sort_order'] = 'Řadit položky';
$lang['title_global_items_per_page'] = 'Nastavit počet položek na str&aacute;nku na';
$lang['title_global_category_recurse'] = 'Nastavit chov&aacute;n&iacute; zobrazov&aacute;n&iacute; kategori&iacute; na';
$lang['title_item_sort_order'] = 'V&yacute;choz&iacute; tř&iacute;děn&iacute; položek';
$lang['title_printable_sort_order'] = 'V&yacute;choz&iacute; tř&iacute;děn&iacute; tisknuteln&eacute;ho katalogu';
$lang['title_items_per_page'] = 'V&yacute;choz&iacute; počet položek na str&aacute;nku';
$lang['title_avail_attrs'] = 'Dostupn&eacute; atributy položky pro &scaron;ablonu';
$lang['title_avail_imattrs'] = 'Dostupn&eacute; obr&aacute;zky položky pro &scaron;ablonu';
$lang['title_item_image_size_hero'] = 'Velikost obr&aacute;zku str&aacute;nky položky (del&scaron;&iacute; strana v pixelech)';
$lang['title_item_image_size_thumbnail'] = 'Velikost n&aacute;hledu str&aacute;nky položky (del&scaron;&iacute; strana v pixelech)';
$lang['title_item_image_size_category'] = 'Velikost n&aacute;hledu položky na str&aacute;nce kategorie (del&scaron;&iacute; strana v pixelech)';
$lang['title_item_image_size_catalog'] = 'Velikost n&aacute;hledu položky katalogov&eacute;m listu (del&scaron;&iacute; strana v pixelech)';
$lang['title_category_image_size_hero'] = 'Velikost obr&aacute;zku katalogov&eacute;ho listu (del&scaron;&iacute; strana v pixelech)';
$lang['title_category_image_size_thumbnail'] = 'Velikost n&aacute;hledu katalogov&eacute;ho listu (del&scaron;&iacute; strana v pixelech)';
$lang['title_template'] = '&Scaron;ablona';
$lang['title_template_type'] = 'Typ &scaron;ablony';
$lang['title_title'] = 'Titulek';
$lang['title_item_image_count'] = 'Maxim&aacute;ln&iacute; počet zobrazen&iacute; každ&eacute; položky';
$lang['title_category_image_count'] = 'Maxim&aacute;ln&iacute; počet bannerů pro kažkou str&aacute;nku kategori&iacute;';
$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. Blank out or type over an existing attribute to remove or replace it.';
$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. Blank out or type over an existing attribute to remove or replace it.';
$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. Blank out or type over an existing attribute to remove or replace it.';
$lang['title_force_aspect_ratio'] = 'Vnutit obr&aacute;zkům určit&yacute; poměr stran?';
$lang['title_force_aspect_ratio_label'] = 'Vnutit poměr stran (zat&iacute;m nedostupn&eacute;)';
$lang['title_image_aspect_ratio'] = 'Poměr stran (zad&aacute;v&aacute; se jako &quot;4:3&quot; or &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = '<b>Tato funkce nen&iacute; zat&iacute;m implementov&aacute;na</b>';
$lang['title_category_sort'] = 'Category Page Item-list sort order';
$lang['title_category_recurse'] = 'Zobrazovat jako ve v&yacute;choz&iacute; kategorii';
$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'] = 'Uk&aacute;zat obr&aacute;zek &quot;No image&quot; v p&iacute;padě, že obr&aacute;zek chyb&iacute;';
$lang['title_show_missing_images_long'] = 'Uk&aacute;že speci&aacute;ln&iacute; obr&aacute;zek s n&aacute;pisem &quot;No image&quot; m&iacute;sto chyběj&iacute;c&iacute;ch obr&aacute;zků (užitečn&eacute; pro odstraňov&aacute;n&iacute; chyb). Pokud volba nen&iacute; zvolena, bude použit 1px průhledn&yacute; obr&aacute;zek';
$lang['natural_order'] = 'Pořad&iacute; podle navigace';
$lang['alpha_order'] = 'Pořad&iacute; podle abecedy';
$lang['manageprefs'] = 'Spravovat volby';
$lang['manageattrs'] = 'Spravovat uživatelem definovan&eacute; vlastnosti';
$lang['globalops'] = 'Operace, t&yacute;kaj&iacute;c&iacute; se cel&eacute;ho katalogu';
$lang['addtemplate'] = 'Přidat nvou pod&scaron;ablonu';
$lang['reimporttemplates'] = 'Znovu importovat př&iacute;klady d&iacute;lč&iacute;ch &scaron;ablon';
$lang['reimported'] = 'Př&iacute;klady d&iacute;lč&iacute;ch &scaron;ablon byly importov&aacute;ny.';
$lang['templateupdated'] = '&Scaron;ablona byla přid&aacute;na / aktulizov&aacute;na';
$lang['templatedeleted'] = '&Scaron;ablona smaz&aacute;na.';
$lang['prefsupdated'] = 'Možnosti aktualizov&aacute;ny.';
$lang['installed'] = 'Modul versze %s je nainstalov&aacute;n.';
$lang['upgraded'] = 'Modul je aktualizov&aacute;n na verzi %s.';
$lang['uninstalled'] = 'Modul odinstalov&aacute;n.';
$lang['attrsupdated'] = 'Vlastnosti aktualizov&aacute;ny.';
$lang['noglobalchange'] = 'Neměnit';
$lang['globallyupdated'] = 'Změny byly glob&aacute;lně provedeny.';
$lang['edittemplate'] = 'Upravit &scaron;ablonu';
$lang['subtemplates'] = 'D&iacute;lč&iacute; &scaron;ablony katalogu';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Upravit';
$lang['delete'] = 'Smazat';
$lang['notemplates'] = 'Ž&aacute;dn&eacute; pod&scaron;ablony nejsou nainstalov&aacute;ny!';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (a module available at <a href=&quot;http://www.cmsmodules.com/ContentAliases.html&quot;>CMSModules.com</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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 note. There are three kinds of templates: one kind for Catalog Items, one kind for Catalog Categories, and one kind for Printable Catalogs.</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&#039;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>
<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 or buy commercial support, please visit SjG&#039;s
module homepage at <a href=&quot;http://www.cmsmodules.com&quot;>CMSModules.com</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&quot;http://forum.cmsmadesimple.org&quot;>CMS Made Simple Forums</a>.</li>
<li>The author, SjG, can often be found in the <a href=&quot;irc://irc.freenode.net/#cms&quot;>CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly.</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; 2005, Samuel Goldstein <a href=&quot;mailto:sjg@cmsmodules.com&quot;><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Ujistěte se, že jste nastavili &quot;Modify Catalog Settings&quot; opr&aacute;vněn&iacute; v&scaron;em uživatelům, kteř&iacute; budou spravovat katalog.';
$lang['utmz'] = '156861353.1198093101.296.65.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utma'] = '156861353.880267837.1180991669.1198152444.1199470887.298';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/da_DK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Billeder';
$lang['deleteimage'] = 'Slet billede';
$lang['Owner'] = 'Ejer';
$lang['CatalogItem'] = 'Katalogis&eacute;r element';
$lang['namepage'] = 'Side';
$lang['Permissions'] = 'Tilladelser';
$lang['Sub'] = 'Under -';
$lang['title_global_item_sort_order2'] = 'Sorteringsorden for element';
$lang['title_global_items_per_page2'] = 'Elementer pr. side';
$lang['title_global_category_recurse2'] = 'Visningstype';
$lang['which_attributes'] = 'Hvilke egenskaber skal vises i kataloget';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'Du er n&oslash;dt til at s&aelig;tte %s for at g&oslash;re s&aring;dan.';
$lang['friendlyname'] = 'Katalogisering';
$lang['admindescription'] = 'Katalogindstillinger';
$lang['areyousure'] = 'Er du sikker p&aring;, at du vil slette %s?';
$lang['uniquecode'] = 'Unik kode';
$lang['templatelist'] = 'Underskabeloner';
$lang['listtempl'] = 'Administration af underskabeloner';
$lang['title_item_tab'] = 'Egenskaber for element';
$lang['title_category_tab'] = 'Egenskaber for kategori';
$lang['title_printable_tab'] = 'Indstillinger for udskrift af katalog';
$lang['title_item_image_tab'] = 'St&oslash;rrelse p&aring; element-billeder';
$lang['title_category_image_tab'] = 'Indstillinger for kategori-sider';
$lang['title_is_textfield'] = 'Tekstboks?';
$lang['title_delete'] = 'Slet?';
$lang['title_aspect_tab'] = 'St&oslash;rrelsesforhold for billeder';
$lang['title_image_tab'] = 'Andre indstillinger for billeder';
$lang['title_item_template_vars'] = 'Variable for element-skabeloner';
$lang['title_cat_template_vars'] = 'Variable for kategori-skabeloner';
$lang['title_feature_template_vars'] = 'Features Template Variables';
$lang['title_show_only_existing_images'] = 'Inklud&eacute;r ikke manglende billeder';
$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['cataloger'] = 'Katalogisering';
$lang['item_page'] = 'Element-side';
$lang['category_page'] = 'Kategori-side';
$lang['catalog_printable'] = 'Udskrivning af katalog';
$lang['catalog_datasheet'] = 'Catalog Datasheet';
$lang['catalog_short_list'] = 'Feature List';
$lang['title_global_item_sort_order'] = 'Set item sort order to';
$lang['title_global_items_per_page'] = 'S&aelig;t antallet af elementer pr. side til';
$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_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_force_aspect_ratio'] = 'Force images to a specified Aspect ratio?';
$lang['title_force_aspect_ratio_label'] = 'Force aspect ratio (not yet implemented)';
$lang['title_image_aspect_ratio'] = 'Aspect ratio (specify as &quot;4:3&quot; or &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = 'If you force an image to a specified aspect ratio, it will be scaled to fit exactly that aspect ratio (or its inverse, so you can have both portrait and landscape formats). Otherwise, images will preserve their aspect ratio, and be scaled so their long axis is the size specified. <b>this is not yet implemented!</b>';
$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 &quot;No Image&quot; image for missing images';
$lang['title_show_missing_images_long'] = 'Show a special &quot;No Image&quot; 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 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['uninstalled'] = 'Module Uninstalled.';
$lang['attrsupdated'] = 'Attributes updated.';
$lang['noglobalchange'] = 'Do not change';
$lang['globallyupdated'] = 'Changes propagated globally.';
$lang['edittemplate'] = 'Edit Template';
$lang['subtemplates'] = 'Catalog Sub-templates';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$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 &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 {cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
<select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
<option value=&quot;&quot;>Select A target</option>
{foreach from=$items item=thisone}
   <option value=&quot;{$thisone.link}&quot;>{$thisone.title}</option>
{/foreach}
</select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
{eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
{eval var=$entry->input assign=thisAttr}{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 &quot;itemname_f_1_400_1.jpg&quot; - 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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</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"><sjg@cmsmodules.com></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; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. 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['changelog'] = '<ul>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Make sure to set the &quot;Modify Catalog Settings&quot; permission on users who will be administering the catalog.';
$lang['utma'] = '156861353.1094114404.1206635603.1217043646.1217048745.52';
$lang['utmz'] = '156861353.1216830754.40.31.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=cms made simple';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Bilder';
$lang['namefiles'] = 'Dateien';
$lang['namefile'] = 'Datei';
$lang['deleteimage'] = 'Bilder l&ouml;schen';
$lang['deletefile'] = 'Datei l&ouml;schen';
$lang['Owner'] = 'Eigent&uuml;mer';
$lang['CatalogItem'] = 'Eintrags-Katalog';
$lang['namepage'] = 'Seite';
$lang['Permissions'] = 'Berechtigungen';
$lang['Sub'] = 'Unter -';
$lang['title_global_item_sort_order2'] = 'Sortier-Reihenfolge der Eintr&auml;ge';
$lang['title_global_items_per_page2'] = 'Eintr&auml;ge pro Seite';
$lang['title_global_category_recurse2'] = 'Eigenschaften der Anzeige';
$lang['which_attributes'] = 'Welche Atribute sollen im Katalog angezeigt werden';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'Sie m&uuml;ssen %s setzen, um das zu tun.';
$lang['friendlyname'] = 'Katalog';
$lang['admindescription'] = 'Katalogeinstellungen verwalten';
$lang['areyousure'] = 'Wollen Sie %s wirklich l&ouml;schen?';
$lang['uniquecode'] = 'Eindeutiger Code';
$lang['templatelist'] = 'Untertemplates';
$lang['listtempl'] = 'Untertemplates verwalten';
$lang['title_item_tab'] = 'Eigenschaften des Eintrags';
$lang['title_category_tab'] = 'Eigenschaften der Kategorie';
$lang['title_printable_tab'] = 'Einstellungen des druckbaren Katalogs';
$lang['title_item_image_tab'] = 'Bildgr&ouml;&szlig;e der Eintr&auml;ge';
$lang['title_category_image_tab'] = 'Einstellungen der Kategorie-Seite';
$lang['title_path_tab'] = 'Pfade';
$lang['title_is_textfield'] = 'Textbereich?';
$lang['title_delete'] = 'L&ouml;schen?';
$lang['title_file_tab'] = 'Datei-Einstellungen f&uuml;r Eintr&auml;ge';
$lang['title_image_tab'] = 'Weitere Bild-Einstellungen';
$lang['title_item_template_vars'] = 'Variablen des Eintrags-Templates';
$lang['title_cat_template_vars'] = 'Variablen des Kategorie-Templates';
$lang['title_catalog_template_vars'] = 'Katalog-Template-Variablen';
$lang['title_compare_template_vars'] = 'Vergleichs-Template-Variablen';
$lang['title_feature_template_vars'] = 'Features-Template-Variablen';
$lang['title_show_only_existing_images'] = 'Fehlende Bilder nicht mit einschlie&szlig;en';
$lang['title_show_only_existing_images_help'] = 'Wenn das Bild existiert, wird mit dieser Funktion nur die Referenz auf das Bild in die Liste aufgenommen.<br />(Normalerweise ist das nicht schlecht, aber wenn Sie wenn Sie clevere Sachen wie Image-<br />Array-Indizes verwenden, kann dies Probleme verursachen.)';
$lang['title_flush_cats'] = 'Zwischenspeicher der Kategorie-Seite l&ouml;schen';
$lang['title_flush_cats_help'] = 'Wenn in einer Kategorie eine sehr gro&szlig;e Anzahl von Eintr&auml;gen<br />angezeigt werden soll, kann es bei bestimmten PHP-Installationen<br />dazu kommen, dass die Seite nicht korrekt angezeigt wird. Aktivieren Sie diese Box, um das Problem zu beheben.';
$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'] = 'Katalog';
$lang['title_attr_order_by'] = 'Sortierung';
$lang['title_attr_alias'] = 'Attribut-Alias (Smarty-freundlich)';
$lang['title_attr_length'] = 'L&auml;nge*';
$lang['title_attr_default'] = 'Voreinstellter Wert';
$lang['title_attr_length_help'] = '(*Die L&auml;nge hat keine Auswirkungen auf Textbereiche)';
$lang['item_page'] = 'Eintrags-Seite';
$lang['category_page'] = 'Kategorie-Seite';
$lang['catalog_printable'] = 'Katalogdruck';
$lang['catalog_datasheet'] = 'Katalog-Datenblatt';
$lang['catalog_short_list'] = 'Feature-Liste';
$lang['item_comparison'] = 'Eintrags-Vergleich';
$lang['title_global_item_sort_order'] = 'Sortierreihenfolge der Eintr&auml;ge';
$lang['title_global_items_per_page'] = 'Anzahl der Eintr&auml;ge pro Seite';
$lang['title_global_category_recurse'] = 'Verhalten der Kategorie-Anzeige';
$lang['title_item_sort_order'] = 'Voreingestellte Sortierreihenfolge f&uuml;r die Eintr&auml;ge';
$lang['title_printable_sort_order'] = 'Voreingestellte Sortierreihenfolge f&uuml;r den Katalogdruck';
$lang['title_items_per_page'] = 'Voreingestellte Anzahl der Eintr&auml;ge pro Seite';
$lang['title_avail_attrs'] = 'F&uuml;r das Template verf&uuml;gbare Eigenschaften der Eintr&auml;ge';
$lang['title_avail_imattrs'] = 'F&uuml;r das Template verf&uuml;gbare Bilder der Eintr&auml;ge';
$lang['title_item_image_size_hero'] = 'Bildgr&ouml;&szlig;e f&uuml;r die Eintrags-Seite (Breite in Pixel)';
$lang['title_item_image_size_thumbnail'] = 'Gr&ouml;&szlig;e der Vorschaubilder f&uuml;r die Eintrags-Seite (Breite in Pixel)';
$lang['title_item_image_size_category'] = 'Gr&ouml;&szlig;e der Vorschaubilder f&uuml;r die Eintr&auml;ge auf der Kategorie-Seite (Breite in Pixel)';
$lang['title_item_image_size_catalog'] = 'Gr&ouml;&szlig;e der Vorschaubilder f&uuml;r Eintr&auml;ge auf der Katalog-Seite (Breite in Pixel)';
$lang['title_category_image_size_hero'] = 'Bildgr&ouml;&szlig;e f&uuml;r die Kategorie-Seite (Breite in Pixel)';
$lang['title_category_image_size_thumbnail'] = 'Gr&ouml;&szlig;e der Vorschaubilder f&uuml;r die Kategorie-Seite (Breite in Pixel)';
$lang['title_template'] = 'Template ';
$lang['title_template_type'] = 'Template-Typ';
$lang['title_title'] = 'Titel';
$lang['title_item_image_count'] = 'Maximale Anzahl der Anzeigen f&uuml;r jeden Eintrag';
$lang['title_item_file_count'] = 'Maximale Anzahl der anderen Dateien, die jedem Eintrag zugeordnet werden k&ouml;nnen';
$lang['title_category_image_count'] = 'Maximale Anzahl der Bannerbilder f&uuml;r jede Kategorieseite';
$lang['title_item_attributes_help'] = 'Jede hier eingegebene Eigenschaft wird der Titel eines Feldes sein, den zur Beschreibung eines speziellen Eintrags verwendet werden kann. Dieses Feld wird dann zusammen mit diesem Eintrag angezeigt. Zur Anzeige dieser Eigenschaften m&uuml;ssen Sie zuvor Ihr Template aktualisieren. Um eine bereits existierende Eigenschaft zu &auml;ndern, l&ouml;schen Sie eine bereits existierende Eigenschaft  oder &uuml;berschreiben diese mit dem gew&uuml;nschten Wert.';
$lang['title_category_attributes_help'] = 'Jede hier eingegebene Eigenschaft wird der Titel eines Feldes sein, den zur Beschreibung einer bestimmten Kategorie verwendet werden kann. Dieses Feld wird dann auf der Kategorieseite angezeigt. Zur Anzeige dieser Eigenschaften m&uuml;ssen Sie zuvor Ihr Template aktualisieren. Um eine bereits existierende Eigenschaft zu &auml;ndern, l&ouml;schen Sie die bereits existierende Eigenschaft  oder &uuml;berschreiben diese mit dem gew&uuml;nschten Wert.';
$lang['title_catalog_attributes_help'] = 'Jede hier eingegebene Eigenschaft wird der Titel eines Feldes sein, den Sie zur Beschreibung des gesamten Katalogs verwenden k&ouml;nnen. Dieses Feld wird dann auf der druckbaren Katalogseite angezeigt. Zur Anzeige dieser Eigenschaften m&uuml;ssen Sie zuvor Ihr Template aktualisieren. Um eine bereits existierende Eigenschaft zu &auml;ndern, l&ouml;schen Sie die bereits existierende Eigenschaft  oder &uuml;berschreiben diese mit dem gew&uuml;nschten Wert.';
$lang['title_category_sort'] = 'Sortierreihenfolge der Eintr&auml;ge auf der Kategorie-Seite';
$lang['title_category_recurse'] = 'Voreingestelltes Verhalten f&uuml;r die Kategorie-Anzeige';
$lang['title_category_recurse_items_all'] = 'Schlie&szlig;t alle Eintr&auml;ge in der Kategorie ein (auch die Eintr&auml;ge in Unter-Kategorien)';
$lang['title_category_recurse_items_one'] = 'Schlie&szlig;t alle Eintr&auml;ge in der Kategorie ein (aber nicht die Eintr&auml;ge in Unter-Kategorien)';
$lang['title_category_recurse_categories_all'] = 'Schlie&szlig;t alle Kategorien in dieser Kategorie ein (auch die Kategorien in Unter-Kategorien)';
$lang['title_category_recurse_categories_one'] = 'Schlie&szlig;t alle Kategorien in dieser Kategorie ein (aber nicht die Kategorien in Unter-Kategorien)';
$lang['title_category_recurse_mixed_all'] = 'Schlie&szlig;t alle Eintr&auml;ge und Kategorien in dieser Kategorie ein (auch die Eintr&auml;ge und Kategorien in Unter-Kategorien)';
$lang['title_category_recurse_mixed_one'] = 'Schlie&szlig;t alle Eintr&auml;ge und Kategorien in dieser Kategorie ein (aber nicht die Eintr&auml;ge und Kategorien in Unter-Kategorien)';
$lang['title_show_missing_images'] = 'Ein &quot;No Image&quot;-Bild f&uuml;r fehlende Bilder anzeigen';
$lang['title_show_missing_images_long'] = 'Zeigt ein bestimmtes &quot;No Image&quot;-Bild, wenn Bilder fehlen (anderenfalls wird ein transparentes Bild mit 1 Pixel Gr&ouml;&szlig;e verwendet).';
$lang['natural_order'] = 'Navigationsreihenfolge';
$lang['alpha_order'] = 'Alphabetische Reihenfolge';
$lang['manageprefs'] = 'Einstellungen verwalten';
$lang['manageattrs'] = 'Benutzerdefinierte Eigenschaften verwalten';
$lang['globalops'] = 'Globale Katalog-Optionen';
$lang['addtemplate'] = 'Ein neues Unter-Template hinzuf&uuml;gen';
$lang['reimporttemplates'] = 'Beispiel-Unter-Templates erneut importieren';
$lang['reimported'] = 'Die Beispiel-Unter-Templates wurden importiert.';
$lang['templateupdated'] = 'Template hinzugef&uuml;gt/aktualisiert.';
$lang['templatedeleted'] = 'Template gel&ouml;scht.';
$lang['prefsupdated'] = 'Einstellungen aktualisiert.';
$lang['installed'] = 'Modulversion %s installiert.';
$lang['upgraded'] = 'Modul auf Version %s aktualisiert.';
$lang['badfile'] = 'File &quot;%s&quot; is not an acceptable format.';
$lang['badimage'] = 'Problem uploading &quot;%s&quot; (check file size and/or server permissions).';
$lang['badimageformat'] = '&quot;%s&quot; is not valid. Only jpegs are supported for the time being.';
$lang['uploaded'] = 'File &quot;%s&quot; uploaded for item %s.';
$lang['uninstalled'] = 'Modul deinstalliert.';
$lang['attrsupdated'] = 'Eigenschaften aktualisiert.';
$lang['noglobalchange'] = 'Bitte nicht ver&auml;ndern';
$lang['globallyupdated'] = 'Die &Auml;nderungen wurden global angewendet.';
$lang['edittemplate'] = 'Template bearbeiten';
$lang['subtemplates'] = 'Katalog-Untertemplates';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Bearbeiten';
$lang['delete'] = 'L&ouml;schen';
$lang['notemplates'] = 'Es sind keine Untertemplates installiert!';
$lang['helptext'] = '<h3>Was macht dieses Modul?</h3>
<p>Mit diesem Modul k&ouml;nnen Sie Online-Kataloge erstellen. Zum einen bestehen Kataloge aus Katalog-Eintr&auml;gen. Das k&ouml;nnen Produkte, Kunstwerke oder &auml;hnliches sein. Zum anderen enthalten Kataloge entsprechende Katalog-Kategorien. Diese unterteilen den Katalog in bestimmte Kategorien oder andere nat&uuml;rliche Trennungen.</p>
<p>Kategorien lassen sich mit der Standardinhaltsliste von CMS made simple hierarchisch definieren. Die Kategorie-Seiten kann die Eintr&auml;ge in der Kategorie und/oder Unterkategorie anzeigen, optional auch rekursiv in den Unterkategorien. Dieses Verhalten kann jeweils pro Kategorie eingestellt werden.</p>
<p>Es ist auch der Ausdruck eines Kataloges m&ouml;glich. Dieser stellt den gesamten Kataloginhalt auf einer einzelnen Seite dar (aktuell ist dies jedoch schlecht implementiert und zudem ziemlich langsam).</p>
<p>Au&szlig;erdem kann das Modul auch in Verbindung mit dem &quot;Content Aliases&quot;-Modul eingesetzt werden, um einen Katalog-Eintrag in mehreren Katalogkategorien anzeigen zu lassen.</p>
<h3>Wie wird es eingesetzt?</h3>
<p>Wenn Sie dieses Modul installieren, werden drei neue Inhaltstypen erzeugt: &quot;Catalog Item&quot; (=Katalog-Eintrag), &quot;Catalog Category&quot; (=Katalog-Kategorie) und &quot;Printable Catalog&quot; (=Katalogdruck). Das bedeutet, dass Sie in der Administration Katalog-Kategorien und Katalog-Eintr&auml;ge wie jede andere beliebige Seite erzeugen k&ouml;nnen. Klicken Sie auf &quot;Inhalte > Seiten > Inhalt hinzuf&uuml;gen&quot; aus. Dann k&ouml;nnen Sie unter Inhaltstyp &quot;Catalog Item&quot; oder &quot;Catalog Category&quot; ausw&auml;hlen.</p>
<h4>Katalog-Eintr&auml;ge</h4>
<p>Ein Katalog-Eintrag wird genau so hinzugef&uuml;gt wie eine ganz normale Seite vom Typ &quot;Content&quot;. Lediglich die Datenfelder f&uuml;r diesen Eintrag sind nicht genau die gleichen. Im Reiter &quot;Images&quot; k&ouml;nnen Sie mehrere Bilder f&uuml;r einen Eintrag hoch laden. Wenn Sie die Bilder hochladen, wird deren Gr&ouml;&szlig;e f&uuml;r den Katalog angepasst, ein Vorschaubild f&uuml;r die Seite der Katalog-Eintr&auml;ge und die Kategorie-Seiten erzeugt, usw. Daf&uuml;r ist es jedoch erforderlich, dass auf Ihrem Host die GD Lib oder ein anderes Programm zur Bildverarbeitung installiert ist. Aktuell wird nur das JPEG-Format unterst&uuml;tzt.</p>
<h4>Katalog-Kategorien</h4>
<p>Eine Katalog-Kategorie wird zur Organisation von Katalog-Eintr&auml;gen eingesetzt. Es wird eine Liste mit dem gesamten Inhalt des Katalogs angezeigt. Ein Katalog-Eintrag ist nur dann ein Teil einer Katalog-Kategorie, wenn er in der Seitenhierarchie unterhalb dieser Kategorie eingeordnet wurde. Kategorien k&ouml;nnen auch weitere Unterkategorien enthalten.</p>
<p>F&uuml;r die Katalog-Kategorien sind eine Reihe von Einstellungen verf&uuml;gbar, mit denen festgelegt werden kann, wie die Kategorien und die in ihr enthaltenen Eintr&auml;ge angezeigt werden sollen: im Reiter &quot;Optionen&quot; k&ouml;nnen Sie ausw&auml;hlen, wie viele Eintr&auml;ge und/oder Kategorien und in welcher Reihenfolge diese angezeigt werden sollen, ob entweder nur die Eintr&auml;ge oder nur die Kategorien oder beides angezeigt werden sollen und wie viele Ebenen einer Kategorie angezeigt werden sollen.</p>
<p>Nehmen wir zum Beispiel mal die folgende Struktur an:</p>
<ol>
	<li><b>Kopfbekleidung</b>
		<ol>
			<li><b>Mode</b>
			 	<ol>
			 		<li>Federhut</li><li>Filzhut</li><li>Baseballm&uuml;tze</li>
			 	</ol>
			 </li>
		 	<li><b>Arbeit</b>
		    	<ol>
		    		<li>Schutzhelm</li><li>Taucherhelm</li>
		    	</ol>
		    </li>
		</ol>
	</li>
</ol>
<p>In diesem Diagramm entsprechen die fett gedruckten Eintr&auml;ge den Kalalog-Kategorien und die einfach dargestellten Eintr&auml;ge den Katalog-Eintr&auml;ge. In Abh&auml;ngigkeit von Ihren Einstellungen kann die Kategorie-Seite &quot;Kopfbekleidung&quot; entweder nur die Eintr&auml;ge f&uuml;r die Kategorien &quot;Mode&quot; und &quot;Arbeit&quot; oder aber auch die Eintr&auml;ge f&uuml;r die Kategorien &quot;Mode&quot; und &quot;Arbeit&quot; und deren Katalog-Eintr&auml;ge anzeigen.</p>
<p>Sie k&ouml;nnen jetzt einstellen, ob die Eintr&auml;ge in ihrer &quot;nat&uuml;rlichen&quot; Reihenfolge (d.h. in der Reihenfolge der Eintr&auml;ge in der CMSms-Inhaltshierarchie), oder in alphabetischer Reihenfolge dargestellt werden.</p>
<p>Wenn Sie in einer Kategorie eine gro&szlig;e Anzahl von Eintr&auml;gen haben, k&ouml;nnen Sie festlegen, wieviele Eintr&auml;ge auf einer Kategorieseite angezeigt werden sollen. Auf der Seite werden dann automatisch Links auf die folgenden Seiten erzeugt.</p>
<p>Sie k&ouml;nnen f&uuml;r jede Kategorieseite getrennt festlegen, in welcher Reihenfolge die Eintr&auml;ge sortiert, wie viele Ebenen und wie viele Eintr&auml;ge pro Seite angezeigt werden sollen. Dies erfolgt in der Administration im Men&uuml; &quot;Erweiterungen > Cataloger > Einstellungen verwalten&quot;. Wenn Sie dies sp&auml;ter f&uuml;r den s&auml;mtliche Katalogseiten &auml;ndern m&ouml;chten, k&ouml;nnen Sie dies in der Administration im Men&uuml; &quot;Erweiterungen > Cataloger > Globale Katalog-Optionen&quot; tun.</p>
<h4>Bilder</h4>
<p>Mit dem Cataloger-Modul k&ouml;nnen Sie f&uuml;r die Kategorieseiten, die Seiten mit den einzelnen Eintr&auml;gen und die Seiten der Druckausgabe unterschiedliche Bildgr&ouml;&szlig;en  festlegen. Dies erfolgt in der Administration im Men&uuml; &quot;Erweiterungen > Cataloger > Einstellungen verwalten&quot;.</p>
<p>Wenn Sie Bilder hochladen, wird das Original eingelagert. Wenn dann jemand eine Cataloger-Seite besucht, werden die reduzierten Gr&ouml;&szlig;en in einer speziellen URL &uuml;bergeben, welche dann auf ein skaliertes Bild umgeleitet wird, falls dieses bereits existiert bzw. zun&auml;chst das skalierte Bild erzeugt. Damit k&ouml;nnen Sie die Gr&ouml;&szlig;e der Bilder &auml;ndern, ohne diese erneut hochladen zu m&uuml;ssen oder diese per hand zu skalieren.</p>
<p>F&uuml;r die Bildskalierung ist es erforderlich, dass entweder ImageMagick oder die GD lib f&uuml;r Ihren Host installiert ist, und diese in der config.php von CMS made simple entsprechend konfiguriert wurde.</p>
<h3>Feature-Listen</h3>
<p>Seit Version 0.4 ist die Anzeige sogenannter &quot;Feature-Listen&quot; m&ouml;glich, welche eine bestimmte Anzahl der zuletzt hinzugef&uuml;gten Katalogeintr&auml;ge oder eine zuf&auml;llige Auswahl aus allen Katalog-Eintr&auml;gen anzeigt.</p>
<h4>Feature-Liste &quot;zuletzt hinzugef&uuml;gte Eintr&auml;ge&quot;</h4>
<p>Mit diesem Feature ist es m&ouml;glich, eine bestimmte Anzahl der zuletzt hinzugef&uuml;gten Katalog-Eintr&auml;ge ausgehend von einer bestimmten Stelle in der Hierarchie Ihrer Seite anzeigen zu lassen.</p>
<p>Der Syntax f&uuml;r eine Liste der zuletzt hinzugef&uuml;gten Eintr&auml;ge ist folgender:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, wobei sub_template das Template ist, welches zum Rendern der Liste verwendet wird. Es gibt zwei weitere, optionale Parameter, count=&#039;3&#039; alias=&#039;page_alias&#039;, wobei count die Anzahl der anzuzeigenden Eintr&auml;ge meint und der Wert page_alias f&uuml;r dem Urspung der Anzeige steht (z.Bsp. eine Stelle in Ihrer Men&uuml;-Hierarchie, typischerweise eine Kategorie-Seite), unter der nach neuen Eintr&auml;gen gesucht werden soll. Ein besonderer Wert f&uuml;r &quot;page_alias&quot; ist &quot;/&quot;, mit dem <i>alle</i> Seiten einer Homepage verwendet werden.</p>
<h4>Feature-Liste &quot;Zufalls-Eintr&auml;ge&quot;</h4>
<p>Der Syntax f&uuml;r eine &quot;zuf&auml;llige&quot; Liste ist folgender:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, wobei sub_template das Template ist, welches zum Rendern der Liste verwendet wird. Es gibt zwei weitere, optionale Parameter, count=&#039;3&#039; alias=&#039;page_alias&#039;, wobei count die Anzahl der anzuzeigenden Eintr&auml;ge meint und der Wert page_alias f&uuml;r dem Urspung der Anzeige steht (z.Bsp. eine Stelle in Ihrer Men&uuml;-Hierarchie, typischerweise eine Kategorie-Seite), unter der nach neuen Eintr&auml;gen gesucht werden soll. Ein besonderer Wert f&uuml;r &quot;page_alias&quot; ist &quot;/&quot;, mit dem <i>alle</i> Seiten einer Homepage verwendet werden.</p>
<h3>Anpassung und weitere Themen</h3>
<h4>Eigenschaften der Katalog-Eintr&auml;ge</h4>
<p>Die Standardeigenschaften f&uuml;r die Katalog-Eintr&auml;ge sind typisch f&uuml;r einen Produktkatalog. &Uuml;ber das Men&uuml; &quot;Erweiterungen > Cataloger > Benutzerdefinierte Eigenschaften verwalten&quot; k&ouml;nnen die Eigenschaften ge&auml;ndert werden. Es hat sich als g&uuml;nstig erwiesen, wenn Sie diese Eigenschaften festlegen, bevor Sie mit der Eingabe der Katalog-Eintr&auml;ge beginnen.</p>
<p>Bitte beachten Sie, dass die von Ihnen definierten Eigenschaften noch dem f&uuml;r die Katalog-Eintr&auml;ge verwendeten Template hinzugef&uuml;gt werden m&uuml;ssen. Weitere Informationen dazu finden Sie im folgenden Abschnitt &quot;Anpassung der Templates&quot;.</p>
<h4>Eigenschaften der Katalog-Kategorien</h4>
<p>Auch f&uuml;r die Kategorien k&ouml;nnen Eigenschaften festgelegt werden. Und auch hier m&uuml;ssen die von Ihnen definierten Eigenschaften noch dem f&uuml;r die Katalog-Kategorien verwendeten Template hinzugef&uuml;gt werden. Weitere Informationen dazu finden Sie im folgenden Abschnitt &quot;Anpassung der Templates&quot;.</p>
<h4>Eigenschaften f&uuml;r die Druckausgabe</h4>
<p>Wie sollte es auch anders sein - f&uuml;r die Druckausgabe k&ouml;nnen gleicherma&szlig;en Eigenschaften festgelegt werden, die ebenfalls noch dem f&uuml;r die Druckausgabe verwendeten Template hinzugef&uuml;gt werden m&uuml;ssen. Weitere Informationen dazu finden Sie im folgenden Abschnitt &quot;Anpassung der Templates&quot;.</p>
<h4>Anpassung der Templates</h4>
<p>Wenn Sie sich mit der Verwendung von Smarty-Templates auskennen, k&ouml;nnen Sie das Layout jeder vom Cataloger-Modul generierten Seiten ver&auml;ndern. Dies sollte jeden Entwickler gl&uuml;cklich machen, der Rest des ineffizienten Codes sicherlich nicht. Es werden drei Template-Typen mitgeliefert: eins f&uuml;r die Katalog-Eintr&auml;ge, eins f&uuml;r die Katalog-Kategorien und eins f&uuml;r die Druckausgabe.</p>
<p>Wenn Sie ein Template bearbeiten, wird in der Administration eine Liste der f&uuml;r das jeweilige Template verf&uuml;gbaren Smarty-Tags angezeigt. Das funktioniert jedoch nur, wenn das Modul wei&szlig;, welchen Template-Typ Sie gerade bearbeiten. Wenn Sie das erste Mal ein Template mit dem Cataloger-Modul erstellen, werden alle bekannten Smarty-Tags angezeigt, von denen jedoch nur einige eingesetzt werden k&ouml;nnen.</p>
<h3>Support</h3>
<p>Dieses Modul beinhaltet keinen kommerziellen Support. Sie k&ouml;nnen jedoch &uuml;ber folgende M&ouml;glichkeiten Hilfe zu dem Modul erhalten:</p>
<ul>
<li>F&uuml;r die letzte Version dieses Moduls, FAQs, dem Versand eines Fehlerreports oder dem Kauf kommerziellen Support besuchen Sie bitte SjG\&#039;s
Modul-Homepage unter <a href="http://www.cmsmodules.com">CMSModules.com</a>.</li>
<li>Eine weitere Diskussion zu diesem Modul ist auch in den Foren von <a href="http://forum.cmsmadesimple.org">CMS Made Simple</a> zu finden.</li>
<li>Der Autor SjG ist h&auml;ufig im <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a> zu finden.</li>
<li>Letztlich erreichen Sie den Autor auch &uuml;ber eine direkte Email.</li>  
</ul>
<p>Nach der GPL wird diese Software so ver&ouml;ffentlicht, wie sie ist. Bitte lesen Sie den Lizenztext f&uuml;r den vollen Haftungsausschluss.</p>
<h3>Copyright und Lizenz</h3>
<p>Copyright &copy; 2006, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">sjg@cmsmodules.com</a>. Alle Rechte vorbehalten.</p>
<p>Dieses Modul wurde unter der <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a> ver&ouml;ffentlicht. Sie m&uuml;ssen dieser Lizenz zustimmen, bevor Sie das Modul verwenden.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.7.3 - 16 June 2009. Bug fixes by Nuno. Made max CMS version 1.5.4 in prep for CMS 1.6 release.</li>
<li>Version 0.7.2 - 14 March 2009. Bug fixes by Nuno Costa.</li>
<li>Version 0.7.1 - 29 Sept 2008. Added Variable method for Javier San Juan Costilas.</li>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Stellen Sie sicher, dass die Anwender, die den Katalog administrieren sollen, die Berechtigung &quot;Modify Catalog Settings&quot; haben.';
$lang['utma'] = '156861353.1233875176.1284137789.1284137789.1284139766.2';
$lang['utmc'] = '156861353';
$lang['utmz'] = '156861353.1284137789.1.1.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utmb'] = '156861353.1.10.1284139766';
$lang['qca'] = 'P0-1868693967-1284142594605';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/es_ES.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Imagenes';
$lang['deleteimage'] = 'Borrar Imagen';
$lang['Owner'] = 'Owner';
$lang['CatalogItem'] = 'Item Cataloger';
$lang['namepage'] = 'P&aacute;gina';
$lang['Permissions'] = 'Permisos';
$lang['Sub'] = 'Sub -';
$lang['title_global_item_sort_order2'] = 'Ordenar Producto Por';
$lang['title_global_items_per_page2'] = 'Productos por P&aacute;gina';
$lang['title_global_category_recurse2'] = 'Display Behavior';
$lang['which_attributes'] = 'Which attributes should be shown in catalog';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'Necesita activar %s para hacer eso.';
$lang['friendlyname'] = 'Cat&aacute;logo';
$lang['admindescription'] = 'Administrar Ajustes del Cat&aacute;logo';
$lang['areyousure'] = 'Est&aacute; seguro que desea borrar este %s?';
$lang['uniquecode'] = 'C&oacute;digo &Uacute;nico';
$lang['templatelist'] = 'Sub-plantillas';
$lang['listtempl'] = 'Administrar Sub-plantillas';
$lang['title_item_tab'] = 'Atributos del Producto';
$lang['title_category_tab'] = 'Atributos de Categoria';
$lang['title_printable_tab'] = 'Ajustes Cat&aacute;logo Imprimible';
$lang['title_item_image_tab'] = 'Item Image Sizes';
$lang['title_category_image_tab'] = 'Ajustes P&aacute;gina de Categor&iacute;a';
$lang['title_is_textfield'] = 'Area de Texto?';
$lang['title_delete'] = 'Borrar?';
$lang['title_aspect_tab'] = 'Image Aspect Ratios';
$lang['title_image_tab'] = 'Otros Ajustes de Imagen';
$lang['title_item_template_vars'] = 'Variables Plantilla Producto';
$lang['title_cat_template_vars'] = 'Variables Plantilla de Categor&iacute;a';
$lang['title_feature_template_vars'] = 'Variables Plantilla Destacados';
$lang['title_show_only_existing_images'] = 'No incluir imagenes que faltan';
$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['cataloger'] = 'Cat&aacute;logo';
$lang['item_page'] = 'P&aacute;gina de Producto';
$lang['category_page'] = 'P&aacute;gina de Categoria';
$lang['catalog_printable'] = 'Cat&aacute;logo Imprimible';
$lang['catalog_datasheet'] = 'Datasheet del Cat&aacute;logo';
$lang['catalog_short_list'] = 'Lista de Caracter&iacute;sticas';
$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'] = 'Orden por defecto de productos';
$lang['title_printable_sort_order'] = 'Orden por defecto del catalgo imprimible';
$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'] = 'Plantilla';
$lang['title_template_type'] = 'Tipo de Plantilla';
$lang['title_title'] = 'Titulo';
$lang['title_item_image_count'] = 'Maximum number of views for 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. Blank out or type over an existing attribute to remove or replace it.';
$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. Blank out or type over an existing attribute to remove or replace it.';
$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. Blank out or type over an existing attribute to remove or replace it.';
$lang['title_force_aspect_ratio'] = 'Force images to a specified Aspect ratio?';
$lang['title_force_aspect_ratio_label'] = 'Force aspect ratio (not yet implemented)';
$lang['title_image_aspect_ratio'] = 'Aspect ratio (specify as &quot;4:3&quot; or &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = 'If you force an image to a specified aspect ratio, it will be scaled to fit exactly that aspect ratio (or its inverse, so you can have both portrait and landscape formats). Otherwise, images will preserve their aspect ratio, and be scaled so their long axis is the size specified. <b>this is not yet implemented!</b>';
$lang['title_category_sort'] = 'Category Page Item-list sort order';
$lang['title_category_recurse'] = 'Default Category Display Behavior';
$lang['title_category_recurse_items_all'] = 'Incluir todos los productos inmediatas dentro de esta categor&iacute;a, incluyendo productos dentro de sub-categor&iacute;as';
$lang['title_category_recurse_items_one'] = 'Incluir todos los productos inmediatas dentro de esta categor&iacute;a, pero no productos dentro de sub-categor&iacute;as';
$lang['title_category_recurse_categories_all'] = 'Incluir todas las categor&iacute;as inmediatas dentro de esta categor&iacute;a, incluyendo categor&iacute;as dentro de sub-categor&iacute;as';
$lang['title_category_recurse_categories_one'] = 'Incluir todas las categor&iacute;as inmediatas dentro de esta categor&iacute;a, pero no categor&iacute;as dentro de sub-categor&iacute;as';
$lang['title_category_recurse_mixed_all'] = 'Incluir todos los productos y categor&iacute;as inmediatas dentro de esta categor&iacute;a, incluyendo productos y categor&iacute;as en sub-categor&iacute;as';
$lang['title_category_recurse_mixed_one'] = 'Incluir todos los productos y categor&iacute;as inmediatas dentro de esta categor&iacute;a, pero no los productos &oacute; categor&iacute;as en sub-categor&iacute;as.';
$lang['title_show_missing_images'] = 'Show &quot;No Image&quot; image for missing images';
$lang['title_show_missing_images_long'] = 'Show a special &quot;No Image&quot; image if there are missing images (useful for debugging. Otherwise will use a single pixel transparent image).';
$lang['natural_order'] = 'Orden de Navegaci&oacute;n';
$lang['alpha_order'] = 'Orden Alfabetico';
$lang['manageprefs'] = 'Administrar Preferencias';
$lang['manageattrs'] = 'Administrar Atributos Definidos por el Usuario';
$lang['globalops'] = 'Operaciones Globales de Cat&aacute;logo';
$lang['addtemplate'] = 'Agregar Plantilla';
$lang['reimporttemplates'] = 'Re-importar ejemplos de Sub-Plantillas';
$lang['reimported'] = 'Las sub-plantillas de ejemplo han sido importadas.';
$lang['templateupdated'] = 'Plantilla Agregada/Actualizada';
$lang['templatedeleted'] = 'Plantilla Eliminada.';
$lang['prefsupdated'] = 'Prefecrencias Actualizadas.';
$lang['installed'] = 'Versi&oacute;n de Modulo %s instalada.';
$lang['upgraded'] = 'Modulo mejorado a versi&oacute;n %s.';
$lang['uninstalled'] = 'Modulo desinstalado';
$lang['attrsupdated'] = 'Atributos actualizados.';
$lang['noglobalchange'] = 'No cambiar';
$lang['globallyupdated'] = 'Cambios propagados globalmente.';
$lang['edittemplate'] = 'Editar Plantilla';
$lang['subtemplates'] = 'Sub-Plantillas de Cat&aacute;logo';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Editar';
$lang['delete'] = 'Eliminar';
$lang['notemplates'] = 'No hay Sub-Plantillas instaladas!';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (a module available at <a href="http://www.cmsmodules.com/ContentAliases.html">CMSModules.com</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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 note. There are three kinds of templates: one kind for Catalog Items, one kind for Catalog Categories, and one kind for Printable Catalogs.</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&#039;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>
<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 or buy commercial support, please visit SjG&#039;s
module homepage at <a href="http://www.cmsmodules.com">CMSModules.com</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, SjG, 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.</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; 2005, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. 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['changelog'] = '<li>Version 0.1.5 - 17 Noviembre 2005. Lanzamiento Inicial. Jesus, Vaya que tom&oacute; tiempo!.</li>
<li>Version 0.1 - 19 Marzo 2005. Iniciaci&oacute;n del Proyecto.</li>
</ul>';
$lang['postinstall'] = 'Asegurese de fijar los permisos de &quot;Ajustes De Cat&aacute;logo&quot; para usuarios que van a administrar el cat&aacute;logo.';
$lang['utma'] = '156861353.602294786.1221783771.1223337923.1223402362.45';
$lang['utmz'] = '156861353.1223402362.45.33.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,13133.0.html|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/et_EE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Pildid';
$lang['deleteimage'] = 'Kustuta pilt';
$lang['Owner'] = 'Omanik';
$lang['CatalogItem'] = 'Eseme katalogiseerija';
$lang['namepage'] = 'Leht';
$lang['Permissions'] = '&Otilde;igused';
$lang['Sub'] = 'Alam -';
$lang['title_global_item_sort_order2'] = 'Eseme sortimisj&auml;rjekord';
$lang['title_global_items_per_page2'] = 'Esemeid lehe kohta';
$lang['title_global_category_recurse2'] = 'Display Behavior';
$lang['which_attributes'] = 'Milliseid omadusi peaks n&auml;itama kataloogis';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'Selleks tegevuseks on sul vaja %s.';
$lang['friendlyname'] = 'Kataloogija';
$lang['admindescription'] = 'Halda Kataloogi Seadeid';
$lang['areyousure'] = 'Oled sa kindel, et soovid kustutada %s?';
$lang['uniquecode'] = 'Unikaalne Kood';
$lang['templatelist'] = 'Alam-mallid';
$lang['listtempl'] = 'Halda Alam-malle';
$lang['title_item_tab'] = 'Eseme omadused';
$lang['title_category_tab'] = 'Kategooria omadused';
$lang['title_printable_tab'] = 'Prinditava kataloogi seaded';
$lang['title_item_image_tab'] = 'Eseme pildi suurus';
$lang['title_category_image_tab'] = 'Kategooria lehe seaded';
$lang['title_is_textfield'] = 'Tekstiala?';
$lang['title_delete'] = 'Kustuta?';
$lang['title_aspect_tab'] = 'Pildi laiuse ja k&otilde;rguse suhe';
$lang['title_image_tab'] = 'Muud pildi seaded';
$lang['title_item_template_vars'] = 'Eseme malli muutujad';
$lang['title_cat_template_vars'] = 'Kategooria malli muutujad';
$lang['title_feature_template_vars'] = 'Omaduste malli muutujad';
$lang['title_show_only_existing_images'] = '&Auml;ra lisa puuduvaid pilte';
$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'] = 'T&uuml;hjenda kategooria lehe puhvrid';
$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['cataloger'] = 'Kataloogija';
$lang['item_page'] = 'Eseme leht';
$lang['category_page'] = 'Kategooria leht';
$lang['catalog_printable'] = 'Prinditav kataloog';
$lang['catalog_datasheet'] = 'Kataloogi andmeleht';
$lang['catalog_short_list'] = 'Omaduste list';
$lang['title_global_item_sort_order'] = 'Esemete sorteerimise j&auml;rjekord';
$lang['title_global_items_per_page'] = 'Esemete arv &uuml;hel lehel';
$lang['title_global_category_recurse'] = 'Kategooria vaate k&auml;itumine';
$lang['title_item_sort_order'] = 'Vaikimisi sorteerimine';
$lang['title_printable_sort_order'] = 'Vaikimisi prinditava kataloogi sorteerimine';
$lang['title_items_per_page'] = 'Vaikimisi esmeid &uuml;hel lehel';
$lang['title_avail_attrs'] = 'Malli jaoks saadaval olevad esme omadused';
$lang['title_avail_imattrs'] = 'Malli jaoks saadaval olevad esme pildid';
$lang['title_item_image_size_hero'] = 'Pildi suurus eseme lehel (laius pikslites)';
$lang['title_item_image_size_thumbnail'] = 'Eelvaate pildi suurus (laisu pikslites)';
$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_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. Blank out or type over an existing attribute to remove or replace it.';
$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. Blank out or type over an existing attribute to remove or replace it.';
$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. Blank out or type over an existing attribute to remove or replace it.';
$lang['title_force_aspect_ratio'] = 'Force images to a specified Aspect ratio?';
$lang['title_force_aspect_ratio_label'] = 'Force aspect ratio (not yet implemented)';
$lang['title_image_aspect_ratio'] = 'Aspect ratio (specify as &quot;4:3&quot; or &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = 'If you force an image to a specified aspect ratio, it will be scaled to fit exactly that aspect ratio (or its inverse, so you can have both portrait and landscape formats). Otherwise, images will preserve their aspect ratio, and be scaled so their long axis is the size specified. <b>this is not yet implemented!</b>';
$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 &quot;No Image&quot; image for missing images';
$lang['title_show_missing_images_long'] = 'Show a special &quot;No Image&quot; image if there are missing images (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 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['uninstalled'] = 'Moodul eemaldatud.';
$lang['attrsupdated'] = 'Omadused uuendatud.';
$lang['noglobalchange'] = '&Auml;ra muuda';
$lang['globallyupdated'] = 'Changes propagated globally.';
$lang['edittemplate'] = 'Muuda malli';
$lang['subtemplates'] = 'Kataloogi alam-mallid';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Muuda';
$lang['delete'] = 'Kustuta';
$lang['notemplates'] = 'Alam-malle ei ole installeeritud!';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content &amp;gt; Pages &amp;gt; Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 &amp;gt; Cataloger &amp;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 &amp;gt; Cataloger &amp;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 &amp;gt; Cataloger &amp;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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 &amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
&amp;lt;select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
&amp;lt;option value=&quot;&quot;>Select A target&amp;lt;/option>
&amp;#123;foreach from=$items item=thisone}
   &amp;lt;option value=&quot;&amp;#123;$thisone.link}&quot;>&amp;#123;$thisone.title}&amp;lt;/option>
&amp;#123;/foreach}
&amp;lt;/select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;variable&#039; name=&#039;itemnotes&#039; default=&#039;no notes&#039;}, 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>
<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 &amp;gt; Cataloger &amp;gt; Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
&amp;#123;eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
&amp;#123;eval var=$entry->input assign=thisAttr}&amp;#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;amp;ac=82888
</p>
<p>The interesting thing is &quot;itemname_f_1_400_1.jpg&quot; - the stuff before is just a call to the program, and the &amp;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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</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">&amp;lt;sjg@cmsmodules.com&amp;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 &amp;copy; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. 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['changelog'] = '<ul>
<li>Version 0.7.4 - 22 June 2009. Incorporated Calguy&#039;s fixes for 1.6.</li>
<li>Version 0.7.3 - 16 June 2009. Bug fixes by Nuno. Made max CMS version 1.5.4 in prep for CMS 1.6 release.</li>
<li>Version 0.7.2 - 14 March 2009. Bug fixes by Nuno Costa.</li>
<li>Version 0.7.1 - 29 Sept 2008. Added Variable method for Javier San Juan Costilas.</li>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Make sure to set the &quot;Modify Catalog Settings&quot; permission on users who will be administering the catalog.';
$lang['utma'] = '156861353.3215545266732019000.1241091787.1253112986.1253118106.116';
$lang['utmz'] = '156861353.1253112986.115.25.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,15318.0.html|utmcmd=referral';
$lang['qca'] = '1240683615-58409973-79915303';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fi_FI.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Kuvat';
$lang['deleteimage'] = 'Poista kuva';
$lang['Owner'] = 'Omistaja';
$lang['CatalogItem'] = 'Tuotteiden luetteloija';
$lang['namepage'] = 'Sivu';
$lang['Permissions'] = 'Oikeudet';
$lang['Sub'] = 'Sub -';
$lang['title_global_item_sort_order2'] = 'Tuotteiden j&auml;rjestyskriteeri';
$lang['title_global_items_per_page2'] = 'Tuotteita per sivu';
$lang['title_global_category_recurse2'] = 'N&auml;ytt&ouml;tavan asetukset';
$lang['which_attributes'] = 'Mitk&auml; tiedot n&auml;ytet&auml;&auml;n luettelossa';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'Tarvitset %s suorittaaksesi toiminnon.';
$lang['friendlyname'] = 'Luettelo';
$lang['admindescription'] = 'Hallitse luettelon asetuksia.';
$lang['areyousure'] = 'Oletko varma ett&auml; haluat tuhota %s?';
$lang['uniquecode'] = 'Uniikki koodi';
$lang['templatelist'] = 'Alipohja';
$lang['listtempl'] = 'Hallitse alipohjia';
$lang['title_item_tab'] = 'Tuotteen ominaisuudet';
$lang['title_category_tab'] = 'Kategorian ominaisuudet';
$lang['title_printable_tab'] = 'Tulostettavan luettelon asetukset';
$lang['title_item_image_tab'] = 'Tuotteen kuvan koot';
$lang['title_category_image_tab'] = 'Kategoriasivun asetukset';
$lang['title_is_textfield'] = 'Text Area?';
$lang['title_delete'] = 'Poista?';
$lang['title_aspect_tab'] = 'Kuvasuhde';
$lang['title_image_tab'] = 'Muut kuva-asetukset';
$lang['title_item_template_vars'] = 'Tuote pohjan muuttujat';
$lang['title_cat_template_vars'] = 'Kategoriapohjan muuttujat ';
$lang['title_feature_template_vars'] = 'Features-pohjan muuttujat';
$lang['title_show_only_existing_images'] = 'J&auml;t&auml; pois puuttuvat kuvat';
$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'] = 'Jos sinulla on valtava m&auml;&auml;r&auml; tuotteita n&auml;ytett&auml;v&auml;ksi<br />kategoriassa, jotkut PHP-asennukset ep&auml;onnistuvat sivun n&auml;ytt&auml;misess&auml;<br />oikein. Valitse t&auml;m&auml; korjataksesi ongelman (testaa my&ouml;s tuleeko sivuvaikutuksia)';
$lang['cataloger'] = 'Luetteloija';
$lang['item_page'] = 'Tuotesivu';
$lang['category_page'] = 'Kategoriasivu';
$lang['catalog_printable'] = 'Tulostettava luettelo';
$lang['catalog_datasheet'] = 'Luettelon datalehti';
$lang['catalog_short_list'] = 'Ominaisuuslista';
$lang['title_global_item_sort_order'] = 'Aseta j&auml;rjestys';
$lang['title_global_items_per_page'] = 'Kuinka monta tuotetta sivulla';
$lang['title_global_category_recurse'] = 'Kategoriassa naytet&auml;&auml;n';
$lang['title_item_sort_order'] = 'Oletusj&auml;rjestys';
$lang['title_printable_sort_order'] = 'Tulostettavan luettelon oletusj&auml;rjestys';
$lang['title_items_per_page'] = 'Tuotetta sivulla oletusarvo';
$lang['title_avail_attrs'] = 'Tuotteen ominaisuudet, joita voit k&auml;ytt&auml;&auml; t&auml;ss&auml; pohjassa';
$lang['title_avail_imattrs'] = 'Tuotekuvat, joita voit k&auml;ytt&auml;&auml; t&auml;ss&auml; pohjassa';
$lang['title_item_image_size_hero'] = 'Kuvan koko tuotesivulla (pitk&auml; sivu pikselein&auml;)';
$lang['title_item_image_size_thumbnail'] = 'Pienoiskuvan koko tuotesivulla (pitk&auml; sivu pikselein&auml;)';
$lang['title_item_image_size_category'] = 'Pienoiskuvan koko kategoriasivulla (pitk&auml; sivu pikselein&auml;)';
$lang['title_item_image_size_catalog'] = 'Pienoiskuvan koko luettelosivulla (pitk&auml; sivu pikselein&auml;)';
$lang['title_category_image_size_hero'] = 'Kuvan koko kategoriasivulla (pitk&auml; sivu pikselein&auml;)';
$lang['title_category_image_size_thumbnail'] = 'Pienoiskuvan koko kategoriasivulla (pitk&auml; sivu pikselein&auml;)';
$lang['title_template'] = 'Pohja';
$lang['title_template_type'] = 'Pohjan tyyppi';
$lang['title_title'] = 'Otsikko';
$lang['title_item_image_count'] = 'Maksimim&auml;&auml;r&auml; n&auml;ytt&ouml;j&auml; kullekin tuotteelle';
$lang['title_category_image_count'] = 'Bannereiden maksimim&auml;&auml;r&auml; joikaiselle kategoriasivulle';
$lang['title_item_attributes_help'] = 'Jokainen t&auml;h&auml;n sy&ouml;tt&auml;m&auml;si ominaisuus tulee olemaan otsikko kent&auml;lle, jota voit k&auml;ytt&auml;&auml; yksitt&auml;isen tuotteen kuvaamiseen ja se n&auml;ytet&auml;&auml;n kyseisen tuotteen kuvauksessa. Voit joutua p&auml;ivitt&auml;m&auml;&auml;n pohjan, jotta muutokset n&auml;kyv&auml;t. Tyhjenn&auml; nimi poistaaksesi ominaisuuden.';
$lang['title_category_attributes_help'] = 'Jokainen t&auml;h&auml;n sy&ouml;tt&auml;m&auml;si ominaisuus tulee olemaan otsikko kent&auml;lle, jota voit k&auml;ytt&auml;&auml; yksitt&auml;isen tuotteen kuvaamiseen kategoria sivulla ja se n&auml;ytet&auml;&auml;n kyseisen tuotteen kuvauksessa. Voit joutua p&auml;ivitt&auml;m&auml;&auml;n pohjan, jotta muutokset n&auml;kyv&auml;t. Tyhjenn&auml; nimi poistaaksesi ominaisuuden.';
$lang['title_catalog_attributes_help'] = 'Jokainen t&auml;h&auml;n sy&ouml;tt&auml;m&auml;si ominaisuus tulee olemaan otsikko kent&auml;lle, jota voit k&auml;ytt&auml;&auml; yksitt&auml;isen tuotteen kuvaamiseen tulostus sivulla ja se n&auml;ytet&auml;&auml;n kyseisen tuotteen kuvauksessa. Voit joutua p&auml;ivitt&auml;m&auml;&auml;n pohjan, jotta muutokset n&auml;kyv&auml;t. Tyhjenn&auml; nimi poistaaksesi ominaisuuden.';
$lang['title_force_aspect_ratio'] = 'Pakota kuvat m&auml;&auml;r&auml;ttyyn suhteeseen';
$lang['title_force_aspect_ratio_label'] = 'Pakota sivu suhde';
$lang['title_image_aspect_ratio'] = 'sivu suhde (k&auml;yt&auml; muotoa &quot;4:3&quot; tai &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = 'Jos pakotat kuvan m&auml;&auml;r&auml;ttyyn sivusuhteeseen se skaalataan mahtumaan juuri t&auml;h&auml;n kokoon (kuitenkin tarkistaen onko kyseess&auml; pysty vai vaakakuva). Muuten kuvan s&auml;ilytt&auml;v&auml;t oman sivusuhteensa ja skaalataan niin, ett&auml; pidempi akseli on m&auml;&auml;r&auml;tyn kokoinen. <b>ei viel&auml; toteutettu</b>';
$lang['title_category_sort'] = 'Kategoriasivun tuotteiden j&auml;rjestys';
$lang['title_category_recurse'] = 'Kategorialistauksen oletus k&auml;ytt&auml;ytyminen';
$lang['title_category_recurse_items_all'] = 'Sis&auml;llyt&auml; kaikki tuotteet, mukaanlukien alikategoriat.';
$lang['title_category_recurse_items_one'] = 'Sis&auml;llyt&auml; kaikki t&auml;m&auml;n kategorian tuotteet, ei alikategorioita';
$lang['title_category_recurse_categories_all'] = 'Sis&auml;llyt&auml; kaikki kategoriat, mukaanlukien kategoriat alikategorioissa';
$lang['title_category_recurse_categories_one'] = 'Sis&auml;llyt&auml; kaikki t&auml;m&auml;n kategorian kategoriat, ei ali-alikategorioita';
$lang['title_category_recurse_mixed_all'] = 'Sis&auml;llyt&auml; kaikki tuotteet ja alikategoriat, mukaanlukien tuotteet ja kategoriat alikategorioissa';
$lang['title_category_recurse_mixed_one'] = 'Sis&auml;llyt&auml; kaikki t&auml;m&auml;n kategorian tuotteet ja alikategoriat, ei ali kategorioita tai niiden tuotteita';
$lang['title_show_missing_images'] = 'N&auml;yt&auml; &quot;ei kuvaa&quot;-kuva puuttuville kuville';
$lang['title_show_missing_images_long'] = 'N&auml;yt&auml; erityinen &quot;ei kuvaa&quot;-kuva puuttuvien kuvien kohdalla (Auttaa virheenetsinn&auml;ss&auml;. Muutoin k&auml;ytet&auml;&auml;n yhden pikselin kokoista l&auml;pin&auml;kyv&auml;&auml; kuvaa.)';
$lang['natural_order'] = 'Selailuj&auml;rjestys';
$lang['alpha_order'] = 'Aakkosj&auml;rjestys';
$lang['manageprefs'] = 'Hallitse asetuksia';
$lang['manageattrs'] = 'Hallitse k&auml;ytt&auml;j&auml;n m&auml;&auml;rittelemi&auml; ominaisuuksia';
$lang['globalops'] = 'Globaalit luettelojen toimenpiteet';
$lang['addtemplate'] = 'Lis&auml;&auml; pohja';
$lang['reimporttemplates'] = 'Tuo alipohjat uudelleen';
$lang['reimported'] = 'Esimerkkialipohjat on palautettu.';
$lang['templateupdated'] = 'Pohja lis&auml;tty tai p&auml;ivitetty onnistuneesti';
$lang['templatedeleted'] = 'Pohja poistettu';
$lang['prefsupdated'] = 'Asetukset p&auml;ivitetty';
$lang['installed'] = 'Moduulin versio %s asennettu.';
$lang['upgraded'] = 'Moduuli p&auml;ivitetty versioon %s.';
$lang['uninstalled'] = 'Moduuli poistettu.';
$lang['attrsupdated'] = 'Ominaisuudet p&auml;ivitetty';
$lang['noglobalchange'] = '&Auml;l&auml; vaihda';
$lang['globallyupdated'] = 'Muutokset tallennettu globaalisti';
$lang['edittemplate'] = 'Muokkaa pohjaa';
$lang['subtemplates'] = 'Luettelon alipohjat';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Muokkaa';
$lang['delete'] = 'Poista';
$lang['notemplates'] = 'Ei alipohjia asennettuna';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (a module available at <a href=&quot;http://dev.cmsmadesimple.org/projects/contentaliases/&quot;>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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>
<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=&quot;http://dev.cmsmadesimple.org&quot;>Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href=&quot;mailto:sjg@cmsmodules.com&quot;><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&quot;http://forum.cmsmadesimple.org&quot;>CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href=&quot;irc://irc.freenode.net/#cms&quot;>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; 2006, Samuel Goldstein <a href=&quot;mailto:sjg@cmsmodules.com&quot;><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Aseta &quot;Modify Catalog Settings&quot; -oikeudet k&auml;ytt&auml;jille, jotka tulevat hallitsemaan luetteloa.';
$lang['utma'] = '156861353.1959547193.1213865783.1214176384.1214210354.18';
$lang['utmz'] = '156861353.1214056345.10.4.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/forum/forum.php|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fr_FR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Images&nbsp;';
$lang['namefiles'] = 'Fichiers';
$lang['namefile'] = 'Fichier';
$lang['deleteimage'] = 'Supprimer l&#039;image';
$lang['deletefile'] = 'Supprimer un fichier';
$lang['Owner'] = 'Propri&eacute;taire';
$lang['CatalogItem'] = 'Catalogue d&#039;articles';
$lang['namepage'] = 'Page&nbsp;';
$lang['Permissions'] = 'Permissions&nbsp;';
$lang['Sub'] = 'Sous -';
$lang['title_global_item_sort_order2'] = 'Ordre du tri des articles';
$lang['title_global_items_per_page2'] = 'article par page';
$lang['title_global_category_recurse2'] = 'Montrer le comportement';
$lang['which_attributes'] = 'Quels attributs doivent figurer dans le catalogue';
$lang['navTab'] = ' |&nbsp;';
$lang['needpermission'] = 'Vous avez besoin que %s soit d&eacute;fini pour effectuer cette action.';
$lang['friendlyname'] = 'Catalogue';
$lang['admindescription'] = 'Gestion des param&egrave;tres du catalogue';
$lang['areyousure'] = '&Ecirc;tes-vous s&ucirc;r de vouloir supprimer %s?';
$lang['uniquecode'] = 'Code unique';
$lang['templatelist'] = 'Sous-gabarits';
$lang['listtempl'] = 'Gestion des sous-gabarits';
$lang['title_item_tab'] = 'Attributs d&#039;article';
$lang['title_category_tab'] = 'Attributs de cat&eacute;gories';
$lang['title_printable_tab'] = 'Param&egrave;tres du catalogue imprimable';
$lang['title_item_image_tab'] = 'Tailles des images d&#039;articles';
$lang['title_category_image_tab'] = 'Param&egrave;tres des pages de cat&eacute;gories';
$lang['title_path_tab'] = 'Chemins d&#039;acc&egrave;s';
$lang['title_is_textfield'] = 'Zone de texte?';
$lang['title_delete'] = 'Supprimer?';
$lang['title_file_tab'] = 'Autres param&egrave;tres de fichiers';
$lang['title_image_tab'] = 'Autres param&egrave;tres d&#039;images';
$lang['title_item_template_vars'] = 'Variables des gabarits d&#039;articles';
$lang['title_cat_template_vars'] = 'Variables des gabarits de cat&eacute;gories';
$lang['title_catalog_template_vars'] = 'Variables de gabarit catalogue';
$lang['title_compare_template_vars'] = 'Variables de gabarit comparaison';
$lang['title_feature_template_vars'] = 'Variables du gabarits des options';
$lang['title_show_only_existing_images'] = 'N&#039;inclut pas les images manquantes';
$lang['title_show_only_existing_images_help'] = 'Ceci va seulement mettre les r&eacute;f&eacute;rences des images dans des listes si l&#039;image existe.<br />(Normalement, cela fonctionne, mais si vous faites des op&eacute;rations complexes avec les images ou les array index,ceci peut poser des probl&egrave;mes.)';
$lang['title_flush_cats'] = 'Vide la m&eacute;moire tampon de la page';
$lang['title_flush_cats_help'] = 'Si vous avez un grand nombre d&#039;objets affich&eacute;s dans une cat&eacute;gorie, certaines installations de PHP n&#039;afficheront pas la page correctement. Cochez cette case pour r&eacute;soudre ce probl&egrave;me (testez pour v&eacute;rifier qu&#039;il n&#039;y ait pas d&#039;effet secondaire).';
$lang['title_item_file_types'] = 'Types de fichiers autoris&eacute;s';
$lang['title_image_upload_path'] = 'Emplacement des fichiers d&#039;images charg&eacute;s sur le serveur';
$lang['title_file_upload_path'] = 'Emplacement des autres fichiers d&#039;articles charg&eacute;s sur le serveur';
$lang['title_image_proc_path'] = 'Emplacement des images modifi&eacute;es (vignettes, images r&eacute;duites, etc)';
$lang['path_help'] = 'Vous pouvez pr&eacute;ciser o&ugrave; le Cataloger entrepose les fichiers. Ces chemins d&#039;acc&egrave;s sont relatifs au chemin d&#039;acc&egrave;s <i>uploads_path</i> d&eacute;fini dans le fichier config.php<br />REMARQUE : Si vous modifiez ces chemins d&#039;acc&egrave;s apr&egrave;s que des fichiers ou des images aient &eacute;t&eacute; charg&eacute;s sur le serveur, le Cataloger perdra les fichiers qui ont d&eacute;j&agrave; &eacute;t&eacute; charg&eacute;s sur le serveur (ils seront toujours l&agrave; mais le Cataloger ne les verra pas. Vous devrez donc les charger de nouveau sur le serveur pour qu&#039;il puisse les voir).';
$lang['cataloger'] = 'Catalogue';
$lang['title_attr_order_by'] = 'Ordre';
$lang['title_attr_alias'] = 'Alias de l&#039;attribut (compatible avec Smarty)';
$lang['title_attr_length'] = 'Longueur*';
$lang['title_attr_default'] = 'Valeur par d&eacute;faut';
$lang['title_attr_length_help'] = '(*la longueur ne s&#039;applique par aux zones de texte)';
$lang['item_page'] = 'Page Article';
$lang['category_page'] = 'Page Cat&eacute;gorie';
$lang['catalog_printable'] = 'Catalogue imprimable';
$lang['catalog_datasheet'] = 'Feuille de donn&eacute;e du catalogue';
$lang['catalog_short_list'] = 'Liste des options';
$lang['item_comparison'] = 'Comparaison d&#039;articles';
$lang['title_global_item_sort_order'] = 'D&eacute;finir l&#039;ordre de tri des articles &agrave;';
$lang['title_global_items_per_page'] = 'D&eacute;finir le nombre d&#039;articles par page &agrave; ';
$lang['title_global_category_recurse'] = 'D&eacute;finir l&#039;affichage des cat&eacute;gories &agrave;';
$lang['title_item_sort_order'] = 'Ordre de tri des articles par d&eacute;faut';
$lang['title_printable_sort_order'] = 'Ordre de tri du catalogue imprimable';
$lang['title_items_per_page'] = 'Nombre d&#039;articles par page par d&eacute;faut';
$lang['title_avail_attrs'] = 'Attibuts d&#039;articles disponibles pour le gabarit';
$lang['title_avail_imattrs'] = 'Images d&#039;articles disponibles pour le gabarit';
$lang['title_item_image_size_hero'] = 'Taille de l&#039;image pour la page Article (axe long en pixels)';
$lang['title_item_image_size_thumbnail'] = 'Taille de la vignette de l&#039;image pour la page Article (axe long en pixels)';
$lang['title_item_image_size_category'] = 'Taille de la vignette de l&#039;image de l&#039;article sur la page Cat&eacute;gorie (axe long en pixels)';
$lang['title_item_image_size_catalog'] = 'Taille de la vignette de l&#039;image de l&#039;article sur la page Catalogue (axe long en pixels)';
$lang['title_category_image_size_hero'] = 'Taille de l&#039;image de l&#039;article sur la page Cat&eacute;gorie (axe long en pixels)';
$lang['title_category_image_size_thumbnail'] = 'Taille de la vignette de l&#039;image de l&#039;article sur la page Cat&eacute;gorie (axe long en pixels)';
$lang['title_template'] = 'Gabarit';
$lang['title_template_type'] = 'Type de gabarit';
$lang['title_title'] = 'Titre';
$lang['title_item_image_count'] = 'Nombre maximal de vues pour chaque article';
$lang['title_item_file_count'] = 'Nombre maximum d&#039;autres fichiers associ&eacute;s &agrave; chaque article';
$lang['title_category_image_count'] = 'Nombre maximal d&#039;images banni&egrave;res pour chaque page de cat&eacute;gorie';
$lang['title_item_attributes_help'] = 'Chaque attribut entr&eacute; ici sera le titre d&#039;un champ que vous pouvez utiliser pour d&eacute;crire un article, et sera affich&eacute; avec cet article. Il se peut que vous ayez &agrave; mettre &agrave; jour votre gabarit pour refl&eacute;ter ces attributs. Videz un attribut existant pour le supprimer, ou r&eacute;&eacute;crivez par dessus pour le remplacer.';
$lang['title_category_attributes_help'] = 'Chaque attribut entr&eacute; ici sera le titre d&#039;un champ que vous pouvez utiliser pour d&eacute;crire une cat&eacute;gorie d&#039;articles, et sera affich&eacute; sur la page cat&eacute;gorie. Il se peut que vous ayez &agrave; mettre &agrave; jour votre gabarit pour refl&eacute;ter ces attributs. Videz un attribut existant pour le supprimer, ou r&eacute;&eacute;crivez par dessus pour le remplacer.';
$lang['title_catalog_attributes_help'] = 'Chaque attribut entr&eacute; ici sera le titre d&#039;un champ que vous pouvez utiliser pour d&eacute;crire un catalogue entier, et sera affich&eacute; sur le catalogue. Il se peut que vous ayez &agrave; mettre &agrave; jour votre gabarit pour refl&eacute;ter ces attributs. Videz un attribut existant pour le supprimer, ou r&eacute;&eacute;crivez par dessus pour le remplacer.';
$lang['title_category_sort'] = 'Ordre de tri de la liste des articles sur la page cat&eacute;gorie';
$lang['title_category_recurse'] = 'Affichage par d&eacute;faut de la cat&eacute;gorie';
$lang['title_category_recurse_items_all'] = 'Inclus tous les articles de cette cat&eacute;gorie, y compris les articles dans les sous-cat&eacute;gories';
$lang['title_category_recurse_items_one'] = 'Inclus tous les articles de cette cat&eacute;gorie, mais pas les articles des sous-cat&eacute;gories';
$lang['title_category_recurse_categories_all'] = 'Inclus toutes les sous-cat&eacute;gories dans cette cat&eacute;gorie, y compris les sous-cat&eacute;gories des sous-cat&eacute;gories';
$lang['title_category_recurse_categories_one'] = 'Inclus toutes les sous-cat&eacute;gories imm&eacute;diatement dans cette cat&eacute;gorie, mais pas les sous-cat&eacute;gories des sous-cat&eacute;gories';
$lang['title_category_recurse_mixed_all'] = 'Inclus tous les articles et toutes les sous-cat&eacute;gories dans cette cat&eacute;gorie, y compris les articles et sous-cat&eacute;gories des sous-cat&eacute;gories';
$lang['title_category_recurse_mixed_one'] = 'Inclus tous les articles et toutes les sous-cat&eacute;gories imm&eacute;diatement dans cette cat&eacute;gorie, mais pas les articles et sous-cat&eacute;gories des sous-cat&eacute;gories';
$lang['title_show_missing_images'] = 'Affiche une image &quot;No Image&quot; lorsqu&#039;une image est manquante';
$lang['title_show_missing_images_long'] = 'Affiche une image &quot;No Image&quot; sp&eacute;ciale s&#039;il y a des images manquantes (utile lors du d&eacute;bogage, autrement une simple image transparente de 1 pixel sera utilis&eacute;e).';
$lang['natural_order'] = 'Ordre de navigation';
$lang['alpha_order'] = 'Ordre alphab&eacute;tique';
$lang['manageprefs'] = 'Gestion des pr&eacute;f&eacute;rences';
$lang['manageattrs'] = 'Gestion des attributs d&eacute;fini par l&#039;utilisateur';
$lang['globalops'] = 'Op&eacute;rations globales du catalogue';
$lang['addtemplate'] = 'Ajout d&#039;un nouveau sous-gabarit';
$lang['reimporttemplates'] = 'R&eacute;importation des sous-gabarits d&#039;exemple';
$lang['reimported'] = 'Les sous-gabarits d&#039;exemple ont &eacute;t&eacute; import&eacute;s.';
$lang['templateupdated'] = 'Gabarit ajout&eacute;/mis &agrave; jour.';
$lang['templatedeleted'] = 'Gabarit supprim&eacute;.';
$lang['prefsupdated'] = 'Pr&eacute;f&eacute;rences mises &agrave; jour';
$lang['installed'] = 'La version %s du module a &eacute;t&eacute; install&eacute;e.';
$lang['upgraded'] = 'Le module a &eacute;t&eacute; mis &agrave; jour &agrave; la version %s.';
$lang['badfile'] = 'Le t&eacute;l&eacute;chargement invalide &quot;%s&quot; n&#039;a pas &eacute;t&eacute; effectu&eacute;.';
$lang['badimage'] = 'Probl&egrave;me lors du t&eacute;l&eacute;chargement de &quot;%s&quot; (v&eacute;rifiez la taille et/ou les droits d&#039;acc&egrave;s au serveur)';
$lang['badimageformat'] = '&quot;%s&quot; n&#039;est pas valide. Seuls les jpegs sont support&eacute;s pour l&#039;instant.';
$lang['uploaded'] = 'Le fichier &quot;%s&quot; a &eacute;t&eacute; t&eacute;l&eacute;charg&eacute; pour l&#039;article %s.';
$lang['uninstalled'] = 'Module d&eacute;sinstall&eacute;.';
$lang['attrsupdated'] = 'Attributs mis &agrave; jour.';
$lang['noglobalchange'] = 'Ne change pas.';
$lang['globallyupdated'] = 'Changements propag&eacute;s au niveau global';
$lang['edittemplate'] = '&Eacute;diter le gabarit';
$lang['subtemplates'] = 'Sous-gabarits du catalogue';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = '&Eacute;diter';
$lang['delete'] = 'Supprimer';
$lang['notemplates'] = 'Aucun sous-gabarit install&eacute; !';
$lang['helptext'] = '<h3>Que fait ce module?</h3>
<p>Ce module vous permet de cr&eacute;er un catalogue ou un portofolio. Les catalogues sont des listes d&#039;articles qui peuvent &ecirc;tre des produits, des oeuvres d&#039;art, ou des listes similaires, et les &quot;cat&eacute;gories de catalogue&quot; qui sont les cat&eacute;gories d&#039;articles ou autres division naturelles du catalogue.</p>
<p>Les cat&eacute;gories peuvent &ecirc;tre d&eacute;finie hi&eacute;rarchiquement (utilise la liste de contenu standard de CMS Made Simple). Les pages de cat&eacute;gories affichent les articles de cette cat&eacute;gorie et/ou des sous-cat&eacute;gories, r&eacute;cursivement sur option. Ce comportement peut aussi &ecirc;tre configur&eacute; par cat&eacute;gorie.</p>
<p>Un catalogue imprimable est disponible, ce qui repr&eacute;sente toute le collection des articles du catalogue sur une page (ceci est pour le moment mal impl&eacute;ment&eacute; et prendra du temps au chargement).</p>
<p>Le module inclus le support pour &quot;Content Aliases&quot; (un module est disponible &agrave; l&#039;adresse <a href="http://dev.cmsmadesimple.org/projects/contentaliases/" target="_blank">CMSModules.com</a>), et vous permet de placer un article dans des cat&eacute;gories multiples.</p>
<h3>Comment l&#039;utiliser</h3>
<p>Quand vous installez ce module, il cr&eacute;e trois nouveaux types de contenu&nbsp;: Catalog Item (objet catalogue), Catalog Category (cat&eacute;gorie de catalogue), et Printable Catalog  (catalogue imprimable). Quand vous &ecirc;tes dans l&#039;administration de votre cat&eacute;gorie, vous pouvez ajouter des articles et des cat&eacute;gories de catalogue comme vous le feriez pour n&#039;importe quelle autre page. S&eacute;lectionnez Contenu > Pages > Ajout d&#039;un nouveau contenu, et s&eacute;lectionnez &quot;Catalog Item&quot; ou &quot;Catalog Category&quot; dans la liste d&eacute;roulante.</p>
<h4>Articles de catalogue</h4>
<p>Ajouter un article de catalogue est tr&egrave;s similaire &agrave; l&#039;ajout d&#039;une page ordinaire de votre site. Cependant, les champs d&#039;ajout ne sont pas exactement les m&ecirc;mes. Notez aussi que dans l&#039;onglet &quot;images&quot;, vous pouvez s&eacute;lectionner plusieurs images pour les t&eacute;l&eacute;charger pour votre article. Quand vous t&eacute;l&eacute;chargez des images, le syst&egrave;me va les redimensionner de fa&ccedil;on appropri&eacute;e pour le catalogue, va cr&eacute;er les vignettes pour la page d&#039;articles, cr&eacute;er les vignettes pour les pages de cat&eacute;gories, etc. Ceci requiert que vous ayez GD ou une librairie d&#039;images install&eacute;e sur votre serveur internet. seules les images au format jpeg sont support&eacute;es.</p>
<h4>Cat&eacute;gories du catalogue</h4>
<p>Une cat&eacute;gorie de catalogue est utilis&eacute;e pour l&#039;organisation des articles de votre catalogue. Il consiste en une page qui liste le contenu du catalogue. Un article de catalogue est consid&eacute;r&eacute; comme faisant partie d&#039;une cat&eacute;gorie de catalogue et se trouve sous cette cat&eacute;gorie dans la hi&eacute;rarchie du site. De m&ecirc;me, les cat&eacute;gories peuvent &ecirc;tre incluses &agrave; d&#039;autres cat&eacute;gories.</p>
<p>Les cat&eacute;gories de catalogues ont des param&egrave;tres pour d&eacute;finir comment elles doivent afficher les articles et sous-cat&eacute;gories qu&#039;elles contiennent&nbsp;: si vous regardez l&#039;onglet &quot;Options&quot;, vous pouvez choisir le nombre d&#039;articles et/ou cat&eacute;gories &agrave; afficher, dans quel ordre les afficher, s&#039;il faut afficher les articles seuls ou les cat&eacute;gories seules, ou les deux, et combien de niveau de la hi&eacute;rarchie afficher dans la page de cat&eacute;gorie.</p>
<p>Consid&eacute;rer, par exemple, la structure suivante&nbsp;:</p>
<ol>
	<li><b>Chapeaux et couvre-chefs</b>
		<ol>
			<li><b>Mode</b>
			 	<ol>
			 		<li>Chapeau &agrave; plume</li><li>Fedora </li><li>Casquette de base-ball</li>
			 	</ol>
			 </li>
		 	<li><b>Casques</b>
		    	<ol>
		    		<li>Casque dur</li><li>Casque de plong&eacute;e</li>
		    	</ol>
		    </li>
		</ol>
	</li>
</ol>
<p>Dans ce diagramme, les &eacute;ll&eacute;ments en gras sont les cat&eacute;gorie du catalogue, et ceux en non-gras sont les articles. Selon vos options, la page de la cat&eacute;gorie Chapeaux et couvre-chefs peut afficher les entr&eacute;es des pages des sous-cat&eacute;gories Mode et Casques seulement, ou afficher les articles pour Mode et Casques et tous les articles list&eacute;s en-dessous.</p>
<p>Vous pouvez opter pour l&#039;affichage en ordre &quot;naturel&quot; (l&#039;ordre dans lequel les articles apparaissent dans la hi&eacute;rarchie de CMS Made Simple), ou dans l&#039;ordre alphab&eacute;tique.</p>
<p>Si vous avez un grand nombre d&#039;articles dans une cat&eacute;gorie, vous pouvez d&eacute;finir le nombre maximal &agrave; afficher dans une page de cat&eacute;gorie, et la page va automatiquement cr&eacute;er les liens de navigation &agrave; travers la liste.</p>
<p>Toutes les pages de cat&eacute;gorie peuvent avoir des param&egrave;tres diff&eacute;rents pour l&#039;ordre d&#039;affichage, les niveau &agrave; afficher, et le nombre d&#039;objets. Vous pouvez d&eacute;finir les valeurs par d&eacute;faut dans Extensions -> Catalogue -> Gestion des pr&eacute;f&eacute;rences. Si, &agrave; une date ult&eacute;rieure, vous d&eacute;sirez changer un param&egrave;tre pour toutes vos pages de cat&eacute;gories, vous pouvez aller sous Extensions -> Catalogue -> Options globales du catalogue, et effectuer ces changements.</p>
<h4>Images</h4>
<p>Le catalogue vous permet de s&eacute;lectionner diff&eacute;rentes tailles d&#039;images pour les articles, les pages de cat&eacute;gories, et le catalogue imprimable. Vous pouvez d&eacute;finir ces options dans Extensions -> Catalogue -> Gestion des pr&eacute;f&eacute;rences.</p>
<p>Quand vous t&eacute;l&eacute;chargez des images, l&#039;original est enregistr&eacute;. Quand quelqu&#039;un visite la page, les images r&eacute;duites sont appel&eacute;es avec une URL sp&eacute;ciale, qui redirigera le navigateur de l&#039;utilisateur sur une image redimensionn&eacute;e, qui sera cr&eacute;&eacute;e si elle n&#039;existe pas. Ceci vous permet de changer la taille des images, sans avoir besoin de ret&eacute;l&eacute;charger toutes les images, ou de les redimensionner toutes d&#039;un coup.</p>
<p>Le code de redimensionnement requiert que vous ayez soit ImageMagick ou la librairie GD install&eacute;, et configur&eacute; dans le fichier config.php de CMS Made Simple.</p>

<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 &amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
&amp;lt;select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
&amp;lt;option value=&quot;&quot;>Select A target&amp;lt;/option>
&amp;#123;foreach from=$items item=thisone}
   &amp;lt;option value=&quot;&amp;#123;$thisone.link}&quot;>&amp;#123;$thisone.title}&amp;lt;/option>
&amp;#123;/foreach}
&amp;lt;/select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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>&amp;#123;Cataloger action=&#039;variable&#039; name=&#039;itemnotes&#039; default=&#039;no notes&#039;}, 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>&amp;#123;cCataloger action=&#039;compare&#039; sub_template=&#039;my_sub_template&#039; items=&#039;item1,item2,item3&#039;}, 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 &quot;items&quot; 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>Personalisation et fonctions avanc&eacute;es</h3>
<h4>Attributs d&#039;articles du catalogue</h4>
<p>Les attributs par d&eacute;faut sont typiquement utiles pour un catalogue de produits, ou d&#039;objets d&#039;art, mais en allant dans Extensions -> Catalogue -> Gestion des attributs personnalis&eacute;s, vous pouvez changer les attributs. Il est mieux de d&eacute;finir les attributs avant de commencer &agrave; entrer des articles dans le catalogue.</p>
<p>Notez que les attributs que vous d&eacute;finissez peuvent devoir &ecirc;tre ajout&eacute;s au gabarit que allez utiliser pour l&#039;affichage des articles de catalogue -- voir gabarits personnalis&eacute;s ci-dessous.</p>
<h4>Attributs des cat&eacute;gories du catalogue</h4>
<p>De m&ecirc;me, vous pouvez d&eacute;finir les attributs pour les cat&eacute;gories. De nouveau, les attributs que vous d&eacute;finissez peuvent devoir &ecirc;tre ajout&eacute;s au gabarit que vous utiliserez pour l&#039;affichage des cat&eacute;gories -- voir les gabarits personnalis&eacute;s ci-dessous.</p>
<h4>Attributs du catalogue imprimable</h4>
<p>Vous pouvez &eacute;galement d&eacute;finir les attributs pour le catalogue imprimable. De nouveau, les attributs que vous d&eacute;finissez peuvent devoir &ecirc;tre ajout&eacute;s au gabarit que vous utiliserez pour l&#039;affichage du catalogue imprimable -- voir les gabarits personnalis&eacute;s ci-dessous.</p>
<h4>Gabarits personnalis&eacute;s</h4>
<p>Si vous d&eacute;sirez vous attaquer aux Gabarits Smarty, vous pourrez changer la disposition de n&#039;importe quelle page g&eacute;n&eacute;r&eacute;e par le Catalogue. Ceci devrait satisfaire certains d&eacute;veloppeurs. Il y a 4 sortes de gabarits&nbsp;: un pour les articles, un pour les cat&eacute;gories,un pour le catalogue imprimable et un pour la liste des fonctions, telle que &quot;articles r&eacute;cemment ajout&eacute;s, ou encore les s&eacute;lections au hasard</p>
<p>Quand vous &eacute;ditez un gabarit, l&#039;&eacute;cran d&#039;administration va lister les balises Smarty disponibles pour ce type de gabarit. Cela n&#039;arrivera qu&#039;une fois que le module sait quel type de gabarit vous &ecirc;tes entrain d&#039;&eacute;diter, donc lorsque vous cr&eacute;ez le gabarit, il va lister toutes les balises Smarty qu&#039;il connait, et seulement certaines d&#039;entre elles seront applicables.</p>

<h4>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
&amp;#123;eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
&amp;#123;eval var=$entry->input assign=thisAttr}&amp;#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;amp;ac=82888
</p>
<p>The interesting thing is &quot;itemname_f_1_400_1.jpg&quot; - the stuff before is just a call to the program, and the &amp;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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</p>

<h3>Support</h3>
<p>Ce module ne contient aucun support commercial. Cependant, ces ressources sont disponibles pour vous aider:</p>
<ul>
<li>Pour la derni&egrave;re version de ce module, les FAQs, ou pour annoncer un bug, veuillez visiter la <a href="http://dev.cmsmadesimple.org/" target="_blank">forge de CMS Made Simple</a>.</li>
<li>Pour acheter du support commercial, veuillez visiter 
la page des modules de SjG <a href="http://www.cmsmodules.com" target="_blank">CMSModules.com</a>.</li>
<li>Des discussions compl&eacute;mentaires relatives &agrave; ce module peuvent aussi &ecirc;tre trouv&eacute;es sur les <a href="http://forum.cmsmadesimple.org" target="_blank">Forums CMS Made Simple</a>.</li>
<li>L&#039;auteur, SjG, est souvent sur IRC sur canal #cms: irc.freenode.net/#cms</li>
<li>Et enfin, vous pouvez rencontrer un certain succ&egrave;s en envoyant un email directement &agrave; l&#039;auteur.</li>  
</ul>
<p>Conform&eacute;ment &agrave; la licence GPL, ce module est distribu&eacute; tel quel. Veuillez vous r&eacute;f&eacute;rer directement &agrave; la licence pour tout avis de non responsabilit&eacute;.</p>

<h3>Copyright et Licence</h3>
<p>Copyright &copy; 2005, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. Tous droits r&eacute;serv&eacute;s.</p>
<p>Ce module est distribu&eacute; sous la licence <a href="http://www.gnu.org/licenses/licenses.html#GPL" target="_blank">GNU Public License</a>. Vous devez agr&eacute;er aux termes de cette licence pour pouvoir utiliser ce module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.7.7 - Feb 2010. Added files associated with Items. Added item comparison action.</li>
<li>Version 0.7.6 - 10 Sept 2009. Fix for that last fix. Doh!</li>
<li>Version 0.7.5 - 10 Sept 2009. Fixed Printable Catalog... did that ever work??</li>
<li>Version 0.7.4 - 22 June 2009. Incorporated Calguy&#039;s fixes for 1.6.</li>
<li>Version 0.7.3 - 16 June 2009. Bug fixes by Nuno. Made max CMS version 1.5.4 in prep for CMS 1.6 release.</li>
<li>Version 0.7.2 - 14 March 2009. Bug fixes by Nuno Costa.</li>
<li>Version 0.7.1 - 29 Sept 2008. Added Variable method for Javier San Juan Costilas.</li>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 Mai 2006. Correction pour les attributs dans les pages cat&eacute;gories. Ajout&eacute; &quot;/&quot; page_alias pour la liste des propri&eacute;t&eacute;s.</li>
<li>Version 0.4.1 - 23 Mai 2006. Correction pour faire fonctionner le modules avec les versions plus anciennes de CMSMS.</li>
<li>Version 0.4 - 22 Mai 2006. Corrections et liste de propri&eacute;t&eacute;s.</li>
<li>Version 0.3 - (non publi&eacute;e, seulement svn)</li>
<li>Version 0.2 - 23 Mars 2006. Grand nombre de corrections. Am&eacute;lioration des performances. Optimisation m&eacute;moire. Utilise maintenant l&#039;API des modules de la version CMS 0.12.</li>
<li>Version 0.1.5 - 17 Novembre 2005. Version initiale. C&#039;&eacute;tait long!.</li>
<li>Version 0.1 - 19 Mars 2005. D&eacute;marrage du projet.</li>
</ul>';
$lang['postinstall'] = 'Assurez-vous de d&eacute;finir la permission &quot;Modify Catalog Settings&quot; pour les utilisateurs qui administreront le catalogue.';
$lang['utma'] = '156861353.1931346077.1269817649.1269817649.1269997133.2';
$lang['utmz'] = '156861353.1269997133.2.2.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=cms made simple';
$lang['qca'] = 'P0-1611851018-1269817649176';
$lang['utmb'] = '156861353.2.10.1269997133';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/it_IT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Immagini';
$lang['deleteimage'] = 'Cancella Immagini';
$lang['Owner'] = 'Proprietario';
$lang['CatalogItem'] = 'Item di Cataloger';
$lang['namepage'] = 'Pagina';
$lang['Permissions'] = 'Permessi';
$lang['Sub'] = 'Sotto -';
$lang['title_global_item_sort_order2'] = 'Ordine per gli Item';
$lang['title_global_items_per_page2'] = 'Items per Pagina';
$lang['title_global_category_recurse2'] = 'Comportamento di visualizzazione';
$lang['which_attributes'] = 'Quale attributi dovrebbero essere mostrati in catalog';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'Devi configurare %s per fare questo.';
$lang['friendlyname'] = 'Cataloger';
$lang['admindescription'] = 'Configurazioni Catalogo';
$lang['areyousure'] = 'Sei sicuro che vuoi cancellare questo %s?';
$lang['uniquecode'] = 'Codice unico';
$lang['templatelist'] = 'Sotto-Modelli';
$lang['listtempl'] = 'Gestione Sotto-Modelli';
$lang['title_item_tab'] = 'Attributi articolo';
$lang['title_category_tab'] = 'Attributi categoria';
$lang['title_printable_tab'] = 'Configurazioni catalogo stampabile';
$lang['title_item_image_tab'] = 'Dimensioni immagine articolo';
$lang['title_category_image_tab'] = 'Configurazioni pagina categorie';
$lang['title_is_textfield'] = 'Text Area?';
$lang['title_delete'] = 'Cancella?';
$lang['title_aspect_tab'] = 'Rapporto delle dimensioni immagine';
$lang['title_image_tab'] = 'Altre configurazioni delle immagini';
$lang['title_item_template_vars'] = 'Variabili Modello articolo';
$lang['title_cat_template_vars'] = 'Variabili Modello categoria';
$lang['title_feature_template_vars'] = 'Variabili Modello feature';
$lang['title_show_only_existing_images'] = 'Non include immagini vuote';
$lang['title_show_only_existing_images_help'] = 'Questo metter&agrave; riferimenti di immagini in liste se l&#039;mmagine esiste.<br />(Normalmente, va bene, ma se volete fare qualcos&#039;altro con gli indici<br />di array di immagini, questo pu&ograve; comportare problemi.)';
$lang['title_flush_cats'] = 'Svuota i buffer della pagina categoria';
$lang['title_flush_cats_help'] = 'Se avete un numero elevato di item da visualizzare<br />in una categoria, alcune installazione di PHP falliscono<br />di visualizzare la pagina correttamente. Check questo box per risolvre il problema (test per gli effetti).';
$lang['cataloger'] = 'Cataloger';
$lang['item_page'] = 'Item Pagina articolo';
$lang['category_page'] = 'Pagina Category';
$lang['catalog_printable'] = 'Catalogo stampabile';
$lang['catalog_datasheet'] = 'Foglio dati';
$lang['catalog_short_list'] = 'Lista feature';
$lang['title_global_item_sort_order'] = 'Configura articoli ordinati per';
$lang['title_global_items_per_page'] = 'Configura numero di articoli per pagina a';
$lang['title_global_category_recurse'] = 'Configura il comportamento della visualizzazione della categoria a';
$lang['title_item_sort_order'] = 'Ordine predefinito articoli';
$lang['title_printable_sort_order'] = 'Ordine predefinito stampa catalogo';
$lang['title_items_per_page'] = 'Numero predefinito di articoli per pagina';
$lang['title_avail_attrs'] = 'Attributi articolo utilizzabili per il Modello';
$lang['title_avail_imattrs'] = 'Immagini articolo utilizzabili per il Modello';
$lang['title_item_image_size_hero'] = 'Dimensione immagine per la pagina articolo (asse lungo in pixels)';
$lang['title_item_image_size_thumbnail'] = 'Dimensione dell&#039;immagine miniatura per la pagina articolo (asse lungo in pixels)';
$lang['title_item_image_size_category'] = 'Dimensione dell&#039;immagine miniatura per gli articoli sulla pagina categoria (asse lungo in pixels)';
$lang['title_item_image_size_catalog'] = 'Dimensione dell&#039;immagine miniatura per gli articoli sulla pagina catalogo (asse lungo in pixels)';
$lang['title_category_image_size_hero'] = 'Dimensione immagine per la pagina categoria (asse lungo in pixels)';
$lang['title_category_image_size_thumbnail'] = 'Dimensione dell&#039;immagine miniatura per la pagina categoria (asse lungo in pixels)';
$lang['title_template'] = 'Modello';
$lang['title_template_type'] = 'Tipo di Modello';
$lang['title_title'] = 'Titolo';
$lang['title_item_image_count'] = 'Massimo numero di viste per ciascun articolo';
$lang['title_category_image_count'] = 'Numero massimo di immagini Banner per ciascuna pagina di categoria';
$lang['title_item_attributes_help'] = 'Ciascun attributo inserito sar&agrave; il titolo di un campo che potete usare per descrivere un articolo individuale e sar&agrave; visualizzato con quel articolo. Dovete aggiornare il vostro Modello per riflettere questi attributi. Lasciare in bianco o inserire un attributo esistente per rimuovere o sostituire.';
$lang['title_category_attributes_help'] = 'Ciascun attributo inserito sar&agrave; il titolo di un campo che potete usare per descrivere una categoria e sar&agrave; visualizzato nella pagina categoria. Dovete aggiornare il vostro Modello per riflettere questi attributi. Lasciare in bianco o inserire un attributo esistente per rimuovere o sostituire.';
$lang['title_catalog_attributes_help'] = 'Ciascun attributo inserito sar&agrave; il titolo di un campo che potete usare per descrivere l&#039;intero catalogo e sar&agrave; visualizzato sulla pagina del catalogo stampato. Dovete aggiornare il vostro Modello per riflettere questi attributi. Lasciare in bianco o inserire un attributo esistente per rimuovere o sostituire.';
$lang['title_force_aspect_ratio'] = 'Forzo le immagini ad uno specifico rapporto delle dimensioni?';
$lang['title_force_aspect_ratio_label'] = 'Forzo il rapporto delle dimensioni (non ancora implementato)';
$lang['title_image_aspect_ratio'] = 'Rapporto delle dimensioni (specificare come &quot;4:3&quot; o &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = 'Se forzate una immagine ad uno specifico rapporto delle dimensioni, allora sar&agrave; scalata per adattare esattamente a quel rapporto (o l&#039;inverso, cos&igrave; da avere entrambi i formati orrizontale e vertcale). Altrimenti, le immagini preserveranno il loro rapporto delle dimensioni e scaleranno in modo che l&#039;asse lungo &egrave; la dimensione specificata. <b>Non ancora implementato!</b>';
$lang['title_category_sort'] = 'Ordine della lista articoli nella pagina categoria';
$lang['title_category_recurse'] = 'Comportamento predefinito della visualizzazione della categoria';
$lang['title_category_recurse_items_all'] = 'Include tutti gli articoli di quella categoria, incluso gli articoli nelle sotto-categorie';
$lang['title_category_recurse_items_one'] = 'Include tutti gli articoli di quella categoria, ma non gli articoli nelle sotto-categorie';
$lang['title_category_recurse_categories_all'] = 'Include tutte le categorie di quella categoria, incluso le categorie nelle sotto-categorie';
$lang['title_category_recurse_categories_one'] = 'Include tutte le categorie di quella categoria, ma non le categorie nelle sotto-categorie';
$lang['title_category_recurse_mixed_all'] = 'Include tutti gli articoli e categorie di quella categoria, incluso gli articoli e categorie nelle sotto-categorie';
$lang['title_category_recurse_mixed_one'] = 'Include tutti gli articoli e categorie di quella categoria, ma non gli articoli e categorie nelle sotto-categorie';
$lang['title_show_missing_images'] = 'Mostra una immagine &quot;No Image&quot; per immagini mancanti';
$lang['title_show_missing_images_long'] = 'Mostra una speciale immagine &quot;No Image&quot; se ci sono immagini mancanti (altrimenti user&agrave; una immagine trasparente con un singolo pixel).';
$lang['natural_order'] = 'Ordine di navigazione';
$lang['alpha_order'] = 'Ordine alfabetico';
$lang['manageprefs'] = 'Gestione preferenze';
$lang['manageattrs'] = 'Gestione attributi definiti dall&#039;Utente';
$lang['globalops'] = 'Operazioni globali sul catalogo';
$lang['addtemplate'] = 'Aggiungi un nuovo Sotto-Modello';
$lang['reimporttemplates'] = 'Re-importa i Sotto-Modelli di esempio';
$lang['reimported'] = 'I Sotto-Modelli di esempio sono stati importati.';
$lang['templateupdated'] = 'Modello aggiunto/aggiornato.';
$lang['templatedeleted'] = 'Modello cancellato.';
$lang['prefsupdated'] = 'Preferenze aggiornate.';
$lang['installed'] = 'Versione del modulo %s installata.';
$lang['upgraded'] = 'Modulo aggiornato alla versione %s.';
$lang['uninstalled'] = 'Modulo disinstallato.';
$lang['attrsupdated'] = 'Attributi aggiornati.';
$lang['noglobalchange'] = 'Non cambiare';
$lang['globallyupdated'] = 'I cambiamenti sono stati propagati globalmente.';
$lang['edittemplate'] = 'Modifica Modello';
$lang['subtemplates'] = 'Sotto-Modelli per catalogo';
$lang['next'] = ':&amp;#187;';
$lang['prev'] = '&amp;#171;:';
$lang['edit'] = 'Modifica';
$lang['delete'] = 'Cancellazione';
$lang['notemplates'] = 'Nessun Sotto-Modello installato!';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content &amp;gt; Pages &amp;gt; Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 {cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
<select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
<option value=&quot;&quot;>Select A target</option>
{foreach from=$items item=thisone}
   <option value=&quot;{$thisone.link}&quot;>{$thisone.title}</option>
{/foreach}
</select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<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 &amp;gt; Cataloger &amp;gt; Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
&amp;#123;eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
&amp;#123;eval var=$entry->input assign=thisAttr}&amp;#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;amp;ac=82888
</p>
<p>The interesting thing is &quot;itemname_f_1_400_1.jpg&quot; - the stuff before is just a call to the program, and the &amp;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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</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">&amp;lt;sjg@cmsmodules.com&amp;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 &amp;copy; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. 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['changelog'] = '<ul>
<li>Version 0.7.2 - 14 March 2009. Bug fixes by Nuno Costa.</li>
<li>Version 0.7.1 - 29 Sept 2008. Added Variable method for Javier San Juan Costilas.</li>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Essere sicuri di configurare il permesso &quot;Modifica configurazione Catalog&quot; agli utenti che amministreranno il catalogo.';
$lang['utma'] = '156861353.568727937.1236340171.1239004875.1239006902.15';
$lang['utmz'] = '156861353.1239004875.14.14.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/lt_LT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['needpermission'] = 'Jums reikia nustatyti %s, kad atlikti tai.';
$lang['friendlyname'] = 'Cataloger';
$lang['admindescription'] = 'Valdyti Katalogo nuostatas';
$lang['areyousure'] = 'Ar tikrai norite pa&scaron;alinti %s?';
$lang['uniquecode'] = 'Unikalus kodas';
$lang['templatelist'] = 'Sub-&scaron;ablonas';
$lang['listtempl'] = 'Valdyti Sub-&scaron;ablonus';
$lang['title_item_tab'] = 'Elemento savybės';
$lang['title_category_tab'] = 'Kategorijos savybės';
$lang['title_printable_tab'] = 'Spausdinamo katalogo nuostatos';
$lang['title_item_image_tab'] = 'Elemento vaizdo dydis';
$lang['title_category_image_tab'] = 'Kategorijos puslapio nuostatos';
$lang['title_is_textfield'] = 'Teksto sritis?';
$lang['title_delete'] = '&Scaron;alinti?';
$lang['title_aspect_tab'] = 'Vaizdų proporcijos';
$lang['title_image_tab'] = 'Kitos vaizdo nuostatos';
$lang['title_item_template_vars'] = 'Elemento &scaron;ablono kintamieji';
$lang['title_cat_template_vars'] = 'Kategorijos &scaron;ablono kintamieji';
$lang['title_feature_template_vars'] = 'Savybių &scaron;ablono kintamieji';
$lang['title_show_only_existing_images'] = 'Neįterpti dingusių vaizdų';
$lang['title_show_only_existing_images_help'] = 'Tai tik įterps vaizdo nuorodas į sąra&scaron;ą jei vaizdas egzistuoja.<br />(Paprastai tai yra  gerai, bet jei darote kažką gudraus su vaizdais<br />array indexes, tai gali sukelti problemų.)';
$lang['title_flush_cats'] = 'Flush category page buffers';
$lang['title_flush_cats_help'] = 'Jei turite labai didelį rodomų elementų kiekį<br />kategorijoje, kai kurie PHP įdiegimai gali neberodyti puslapio<br />teisingai. Pažymėkite čia, i&scaron;spręsti &scaron;ią problemą (testas &scaron;alutiniams poveikiams).';
$lang['cataloger'] = 'Cataloger';
$lang['item_page'] = 'Elemento puslapis';
$lang['category_page'] = 'Kategorijos puslapis';
$lang['catalog_printable'] = 'Spausdinamas katalogas';
$lang['catalog_datasheet'] = 'Katalogo Datasheet';
$lang['catalog_short_list'] = 'Savybių sąra&scaron;as';
$lang['title_global_item_sort_order'] = 'Nustatyti elementų rikiavimą į';
$lang['title_global_items_per_page'] = 'Nustatyti elementų kiekį per puslapį';
$lang['title_global_category_recurse'] = 'Kategorijos rodymo elgesys';
$lang['title_item_sort_order'] = 'Įprastas elementų rikiavimas';
$lang['title_printable_sort_order'] = 'Įprastas spausdinamo katalogo rikiavimas';
$lang['title_items_per_page'] = 'Įprastas elementų kiekis per puslapį';
$lang['title_avail_attrs'] = 'Galimos elemento savybės &scaron;ablonui';
$lang['title_avail_imattrs'] = 'Galimi elemento vaizdai &scaron;ablonui';
$lang['title_item_image_size_hero'] = 'Vaizdo dydis Elemento puslapiui (ilgoji a&scaron;is, pikseliais)';
$lang['title_item_image_size_thumbnail'] = 'Thumbail Vaizdo dydis Elemento puslapiui  (ilgoji a&scaron;is, pikseliais)';
$lang['title_item_image_size_category'] = 'Thumbnail Vaizdo dydis Kategorijos puslapiui  (ilgoji a&scaron;is, pikseliais)';
$lang['title_item_image_size_catalog'] = 'Thumbnail Vaizdo dydis Katalogo puslapiui  (ilgoji a&scaron;is, pikseliais)';
$lang['title_category_image_size_hero'] = 'Vaizdo dydis Kategorijos puslapiui  (ilgoji a&scaron;is, pikseliais)';
$lang['title_category_image_size_thumbnail'] = 'Thumbail Vaizdo dydis Kategorijospuslapiui  (ilgoji a&scaron;is, pikseliais)';
$lang['title_template'] = '&Scaron;ablonas';
$lang['title_template_type'] = '&Scaron;ablono tipas';
$lang['title_title'] = 'Pavadinimas';
$lang['title_item_image_count'] = 'Maksimalus peržiūrų kiekis kiekvieno elemento';
$lang['title_category_image_count'] = 'Maksimalus Banerio vaizdų kiekvienam kategorijos puslapiui';
$lang['title_item_attributes_help'] = 'Kiekviena savybė kurią jūs įvedate čia bus lauko pavadinimas, kurį jūs galite panaudoti, kad apibūdintumėte individualų elementą, ir būs rodomas su tuo elementu. Jūs turite atnaujinti savo &scaron;abloną, kad atspindėtumėte &scaron;ituos požymius.';
$lang['title_category_attributes_help'] = 'Kiekviena savybė kurią jūs įvedate čia bus lauko pavadinimas, kurį jūs galite panaudoti, kad apibūdintumėte kategoriją, ir būs rodomas su ta kategorija. Jūs turite atnaujinti savo &scaron;abloną, kad atspindėtumėte &scaron;ituos požymius.';
$lang['title_catalog_attributes_help'] = 'Kiekviena savybė kurią jūs įvedate čia bus lauko pavadinimas, kurį jūs galite panaudoti, kad apibūdintumėte visą katalogą, ir būs rodomas spausdinamo katalogo puslapyje. Jūs turite atnaujinti savo &scaron;abloną, kad atspindėtumėte &scaron;ituos požymius.';
$lang['title_force_aspect_ratio'] = 'Priversti vaizdus laikyti proporcijos?';
$lang['title_force_aspect_ratio_label'] = 'Priverstinė proporcija (dar nerealizuota)';
$lang['title_image_aspect_ratio'] = 'Proporcija (nurodykite &quot;4:3&quot; ar &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = 'Jei nustatysite priverstinę proporcija, vaizdų dysis bus pakeistas, kad tiksliai atitiktų nurodytą proporcija. Jei ne - vaizdai i&scaron;laikys savo proporcijas, bet bus pakeistas dydis pagal ilgąją a&scaron;į. Kaip nustatyta. <b>Priverstinė proporcija dar nerealizuota!</b>';
$lang['title_category_sort'] = 'Kategorijos puslapio elementų sąra&scaron;o rikiavimas';
$lang['title_category_recurse'] = 'Įprastas Kategorijos rodymo elgesys';
$lang['title_category_recurse_items_all'] = 'Įterpti visus elementus &scaron;ios kategorijos, įskaitant ir sub-kategorijas';
$lang['title_category_recurse_items_one'] = 'Įterpti visus elementus &scaron;ios kategorijos, bet ne elementus esančius sub-kategorijose';
$lang['title_category_recurse_categories_all'] = 'Įterpti visas Kategorijas esančias &scaron;iose kategorijoje, įskaitant kategorijas esančias sub-kategorijose';
$lang['title_category_recurse_categories_one'] = 'Įterpti visas Kategorijas esančias &scaron;iose kategorijoje, bet ne kategorijas esančias sub-kategorijose';
$lang['title_category_recurse_mixed_all'] = 'Įterpti visas Kategorijas ir Elementus esančias &scaron;iose kategorijoje, įskaitant kategorijas ir elementus esančius sub-kategorijose';
$lang['title_category_recurse_mixed_one'] = 'Įterpti visas Kategorijas ir Elementus esančias &scaron;iose kategorijoje, bet ne kategorijas ir elementus esančius sub-kategorijose';
$lang['title_show_missing_images'] = 'Rodyti &quot;Nėra vaizdo&quot; paveikslėlį jei nėra vaizdo.';
$lang['title_show_missing_images_long'] = 'Rodyti specialų  &quot;Nėra vaizdo&quot; paveikslėlį jei nėra vaizdo. (Naudinga derinimo metu . Kitu atveju naudokite vieno pikselio permatomą vaizdą).';
$lang['natural_order'] = 'Navigacijos tvarka';
$lang['alpha_order'] = 'Abėcėlinė tvarka';
$lang['manageprefs'] = 'Valdyti nustatymus';
$lang['manageattrs'] = 'Valdyti vartotojų sukurtas savybes';
$lang['globalops'] = 'Visuotiniai katalogo veiksmai';
$lang['addtemplate'] = 'Pridėti &scaron;abloną';
$lang['reimporttemplates'] = 'I&scaron;naujo importuoti pavyzdinius sub-&scaron;ablonus';
$lang['reimported'] = 'Pavyzdiniai sub-&scaron;ablonai importuoti';
$lang['templateupdated'] = '&Scaron;ablonas pridėtas/atnaujintas.';
$lang['templatedeleted'] = '&Scaron;ablonas pa&scaron;alintas.';
$lang['prefsupdated'] = 'Nustatymai atnaujinti.';
$lang['installed'] = 'Modulio versija %s įdiegta.';
$lang['upgraded'] = 'Modulis atnaujintas į %s versija.';
$lang['uninstalled'] = 'Modulis pa&scaron;alintas.';
$lang['attrsupdated'] = 'Savybės atnaujintos.';
$lang['noglobalchange'] = 'Nekeisti';
$lang['globallyupdated'] = 'Pakeitimai įsigalios visuotinai.';
$lang['edittemplate'] = 'Redaguoti &scaron;abloną';
$lang['subtemplates'] = 'Katalogo sub-&scaron;ablonas';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Redaguoti';
$lang['delete'] = '&Scaron;alinti';
$lang['notemplates'] = 'Sub-&scaron;ablonas neįdiegtas!';
$lang['helptext'] = '<h3>Ką jis daro?</h3>
<p>&Scaron;is modulis leidžia jus kurti internetinius katalogus ar portfelius. Katalogai susideda i&scaron; &quot;Katalogo elementų &quot;, kurie gali būti produktais, meno kūriniais, ar pana&scaron;iomis, ir &quot;Katalogo Kategorijomis&quot;, kurios gali būti elemento kategorijomis ar kitais natūraliais katalogo skyriais.</p>
<p>Kategorijos gali būti apibrėžtos hierarchiniai (naudojantis standartinį CMS Made Simple turinio sąra&scaron;ą). Kategorijos puslapiai gali rodyti elementus kategorijoje ir/ar subkategorijose, pasirinktinai i&scaron; naujo keikiančiose per subkategorijas. &Scaron;is elgesys gali būti formuotas pagrindu per kategoriją.</p>
<p>Taip pat yra Spausdintinas Katalogas, kuris atstovauja visai kolekcijai Katalogo elementų  vienam puslapiui (tai &scaron;iuo metu įgyvendinama baisiai, ir pakraus lėtai).</P>
<p>The module has built-in support for &quot;Content Aliases&quot; (a module available at <a href=&quot;http://dev.cmsmadesimple.org/projects/contentaliases/&quot;>the Developer Forge</a>), which allows you to place any Catalog Item into multiple Catalog Categories.</p>
<h3>Kaip jį naudoti</h3>
<p>Kai jūs įdiegiate &scaron;į modulį, jis kuria tris naujus Turinio Tipus: Katalogo elementas, Katalogo Kategorija, ir Spausdintinas Katalogas. Kai jūs esate savo svetainės administracijos kategorijoje, jūs pridedate Katalogo elementus ir Katalogo Kategorijas kaip tik taip, kaip jūs bet kokia kita puslapio rū&scaron;is. I&scaron;rinkite Turinį>, Puslapiai> Pridėti Turinį, ir paskui renka &quot;Katalogo elementas &quot; ar &quot;Katalogo Kategoriją&quot; nuo turinio Tipo pulldown.</p>
<p>Catalog Items</p>
<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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 {cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
<select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
<option value=&quot;&quot;>Select A target</option>
{foreach from=$items item=thisone}
   <option value=&quot;{$thisone.link}&quot;>{$thisone.title}</option>
{/foreach}
</select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
{eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
{eval var=$entry->input assign=thisAttr}{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 &quot;itemname_f_1_400_1.jpg&quot; - 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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</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=&quot;http://dev.cmsmadesimple.org&quot;>Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href=&quot;mailto:sjg@cmsmodules.com&quot;><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&quot;http://forum.cmsmadesimple.org&quot;>CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href=&quot;irc://irc.freenode.net/#cms&quot;>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; 2007, Samuel Goldstein <a href=&quot;mailto:sjg@cmsmodules.com&quot;><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>
';
$lang['changelog'] = '<ul>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Įsitikite, kad &quot;Modify Catalog Settings&quot; leidimas suteiktas vartotojams kurie administruos katalogą.';
$lang['utma'] = '156861353.2131519532.1201621519.1202112386.1202120311.8';
$lang['utmz'] = '156861353.1201792846.6.6.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,18622.15.html|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nb_NO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Bilder';
$lang['namefiles'] = 'Filer';
$lang['namefile'] = 'Fil';
$lang['deleteimage'] = 'Slett bilder';
$lang['deletefile'] = 'Slett fil';
$lang['Owner'] = 'Eier';
$lang['CatalogItem'] = 'Artikkel katalog';
$lang['namepage'] = 'Side';
$lang['Permissions'] = 'Rettigheter';
$lang['Sub'] = 'Under -';
$lang['title_global_item_sort_order2'] = 'Artikkel sorterings rekkef&oslash;lge';
$lang['title_global_items_per_page2'] = 'Artikler pr side';
$lang['title_global_category_recurse2'] = 'Visnings oppf&oslash;rsel';
$lang['which_attributes'] = 'Hvilke attributter skal vises i katalogen';
$lang['navTab'] = '  | ';
$lang['needpermission'] = 'Du trenger %s satt for &aring; gj&oslash;re det.';
$lang['friendlyname'] = 'Cataloger ';
$lang['admindescription'] = 'Behandle Catalog innstillnger';
$lang['areyousure'] = 'Er du sikker p&aring; at du vil slette dette %s?';
$lang['uniquecode'] = 'Unik kode';
$lang['templatelist'] = 'Sub-maler';
$lang['listtempl'] = 'Behandle sub-maler';
$lang['title_item_tab'] = 'Artikkel kjennetegn';
$lang['title_category_tab'] = 'Kategori kjennetegn';
$lang['title_printable_tab'] = 'Utskrivbar Katalog innstillinger';
$lang['title_item_image_tab'] = 'Artikkel Bilde st&oslash;rrelse';
$lang['title_category_image_tab'] = 'Kategori side innstillinger';
$lang['title_path_tab'] = 'Stier';
$lang['title_is_textfield'] = 'Tekstomr&aring;de?';
$lang['title_delete'] = 'Slette?';
$lang['title_file_tab'] = 'Andre filinnstillinger';
$lang['title_image_tab'] = 'Andre bildeinnstillinger';
$lang['title_item_template_vars'] = 'Artikkel mal variabler';
$lang['title_cat_template_vars'] = 'Kategori mal variabler';
$lang['title_catalog_template_vars'] = 'Catalogmal variabler';
$lang['title_compare_template_vars'] = 'Sammenligningsmal variabler';
$lang['title_feature_template_vars'] = 'Egenskapslistemal variabler';
$lang['title_show_only_existing_images'] = 'Ikke inkluder manglende bilder';
$lang['title_show_only_existing_images_help'] = 'Dette vil kun sette bildereferanser inn i listene om bildet eksisterer.<br />(Normalt er dette bra, men om du gj&oslash;r noe smart med bildet<br />indekseres arrayet, dette kan gi deg tr&oslash;bbel.)';
$lang['title_flush_cats'] = 'T&oslash;m kategoriside bufre';
$lang['title_flush_cats_help'] = 'Om du har et stort antall enheter vist<br />i en kategori, vil noen PHP installasjoner feile &aring; vise siden<br />korrekt. Hak av i denne boksen for &aring; l&oslash;se dette problemet (test for eventuelle bi-effekter).';
$lang['title_item_file_types'] = 'Tillatte filtyper';
$lang['title_image_upload_path'] = 'Plassering for opplastede bildefiler';
$lang['title_file_upload_path'] = 'Plassering for andre opplastede ertikkelbildefiler';
$lang['title_image_proc_path'] = 'Plassering for behandlede bilder (miniatyrbilder, skalerte bilder, osv.)';
$lang['path_help'] = 'Du kan spesifisere hvor Cataloger lagrer filer. Disse stiene er relative til <i>uploads_path</i> definert i din config.php<br />MERK: Om du endrer disse stiene etter at filer eller bilder har blitt lastet opp, s&aring; vil Cataloger miste &#039;allerede opplastet&#039; egenskapen (de vil fortsatt v&aelig;re der, men Cataloger vil ikke vite om dem, s&aring; du m&aring; laste dem opp p&aring; ny for at Cataloger skal klare &aring; finne det ut).';
$lang['cataloger'] = 'Cataloger ';
$lang['title_attr_order_by'] = 'Rekkef&oslash;lge';
$lang['title_attr_alias'] = 'Attributt alias (Smarty-vennlig)';
$lang['title_attr_length'] = 'Lengde*';
$lang['title_attr_default'] = 'Standard verdi';
$lang['title_attr_length_help'] = '(*Lengde har ikke innvirkning p&aring; Tekstomr&aring;der)';
$lang['item_page'] = 'Artikkel side';
$lang['category_page'] = 'Kategori side';
$lang['catalog_printable'] = 'Utskrivbar Katalog';
$lang['catalog_datasheet'] = 'Katalog datablad';
$lang['catalog_short_list'] = 'Egenskap liste';
$lang['item_comparison'] = 'Artikkel sammenligning';
$lang['title_global_item_sort_order'] = 'Sett artikkel sortering rekkef&oslash;lge til';
$lang['title_global_items_per_page'] = 'Sett antall artikler pr side til';
$lang['title_global_category_recurse'] = 'Sett kategori visning oppf&oslash;rsel til';
$lang['title_item_sort_order'] = 'Standard artikkel sorteringsrekkef&oslash;lge';
$lang['title_printable_sort_order'] = 'Standard utskrivbar katalog sorteringsrekkef&oslash;lge';
$lang['title_items_per_page'] = 'Standard antall artikler pr side';
$lang['title_avail_attrs'] = 'Artikkel attributter tilgjengelig for malen';
$lang['title_avail_imattrs'] = 'Artikkelbilder tilgjengelig for malen';
$lang['title_item_image_size_hero'] = 'Bildest&oslash;rrelse for artikkel side (lang akse i pixler)';
$lang['title_item_image_size_thumbnail'] = 'Thumbnail bildest&oslash;rrelse for artikkelside (lang akse i pixler)';
$lang['title_item_image_size_category'] = 'Thumbnail bildest&oslash;rrelse for artikkel p&aring; kategoriside (lang akse i pixler)';
$lang['title_item_image_size_catalog'] = 'Thumbnail bildest&oslash;rrelse for artikkel p&aring; katalogside (long axis in pixels)';
$lang['title_category_image_size_hero'] = 'Bilde st&oslash;rrelse for kategoriside (lang akse i pixler)';
$lang['title_category_image_size_thumbnail'] = 'Thumbnail bildest&oslash;rrelse for kategoriside (lang akse i pixler)';
$lang['title_template'] = 'Mal';
$lang['title_template_type'] = 'Mal type';
$lang['title_title'] = 'Tittel';
$lang['title_item_image_count'] = 'Maksimum antall visninger for hver artikkel';
$lang['title_item_file_count'] = 'Maksimum antall andre filer assosiert med hver artikkel';
$lang['title_category_image_count'] = 'Maksimum antall banner-bilder for hver kategoriside';
$lang['title_item_attributes_help'] = 'Hver attributt du angir her vil bli tittel p&aring; et felt som du kan bruke til &aring; beskrive en individuell artikkel og vil bli vist ved denne artikkel. Du m&aring; kanskje oppdatere din mal for &aring; reflektere disse attributter. Blank ut eller skriv over en eksisterende attributt for &aring; fjerne eller bytte den ut.';
$lang['title_category_attributes_help'] = 'Hver attributt du angir her vil bli tittel p&aring; et felt som du kan bruke til &aring; beskrive en individuell artikkel kategori og vil bli vist p&aring; denne kategorisiden. Du m&aring; kanskje oppdatere din mal for &aring; reflektere disse attributter.';
$lang['title_catalog_attributes_help'] = 'Hver attributt du angir her vil bli tittel p&aring; et felt som du kan bruke til &aring; beskrive hele katalogen og vil bli vist p&aring; den skrivbare katalogsiden. Du m&aring; kanskje oppdatere din mal for &aring; reflektere disse attributter.';
$lang['title_category_sort'] = 'Kategoriside artikkel-liste sorteringsrekkef&oslash;lge';
$lang['title_category_recurse'] = 'Standard kategori visnings oppf&oslash;rsel';
$lang['title_category_recurse_items_all'] = 'Inkluder alle artikler innefor denne kategori, inkludert artikler i under-kategorier';
$lang['title_category_recurse_items_one'] = 'Inkluder alle artikler i akkurat denne kategori, men ikke fra under-kategorier';
$lang['title_category_recurse_categories_all'] = 'Inkluder alle kategorier innenfor denne kategorien, inkludert innen under-kategorier';
$lang['title_category_recurse_categories_one'] = 'Inkluder alle kategorier i akkurat denne kategorien, men ikke kategorier i under-kategorier';
$lang['title_category_recurse_mixed_all'] = 'Inkluder alle artikler og kategorier i denne kategorien, inkludert artikler og kategorier i under-kategorier';
$lang['title_category_recurse_mixed_one'] = 'Inkluder alle artikler og kategorier i akkurat denne kategorien, men ikke artikler og kategorier i under-kategorier';
$lang['title_show_missing_images'] = 'Vis &quot;Ingen bilde&quot; bilde for manglende bilder';
$lang['title_show_missing_images_long'] = 'Vis et spesielt &quot;Ingen Bilde&quot; bilde om det mangler bilder (ellers blir det brukt et en-pixel transparent bilde).';
$lang['natural_order'] = 'Navigerings-rekkef&oslash;lge';
$lang['alpha_order'] = 'Alfabetisk rekkef&oslash;lge';
$lang['manageprefs'] = 'Behandle innstillinger';
$lang['manageattrs'] = 'Behandle brukerdefinerte attributter';
$lang['globalops'] = 'Global katalog handlinger';
$lang['addtemplate'] = 'Legg til mal';
$lang['reimporttemplates'] = 'Gjen-inporter eksempel under-maler';
$lang['reimported'] = 'Eksempel under-maler har blitt importerte';
$lang['templateupdated'] = 'Mal lag til/oppdatert.';
$lang['templatedeleted'] = 'Mal slettet.';
$lang['prefsupdated'] = 'Innstillinger har blitt oppdatert.';
$lang['installed'] = 'Module versjon %s innstallert.';
$lang['upgraded'] = 'Modul oppgradert til versjon %s.';
$lang['badfile'] = 'Filen &quot;%s&quot; er ikke av et godkjent format.';
$lang['badimage'] = 'Problem med &aring; laste opp &quot;%s&quot; (sjekk filst&oslash;rrelse og/eller rettigheter p&aring; server).';
$lang['badimageformat'] = '&quot;%s&quot; er ikke gyldig. Kun jpeg-filer er st&oslash;ttet akkurat n&aring;.';
$lang['uploaded'] = 'Filen &quot;%s&quot; lastet opp for artikkel %s.';
$lang['uninstalled'] = 'Modul avinstallert.';
$lang['attrsupdated'] = 'Attributter oppdatert';
$lang['noglobalchange'] = 'Ikke endre';
$lang['globallyupdated'] = 'Endringer forplantet globalt';
$lang['edittemplate'] = 'Rediger mal';
$lang['subtemplates'] = 'Katalog under-maler';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Rediger';
$lang['delete'] = 'Slett';
$lang['notemplates'] = 'Ingen under-maler er installert!';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content &amp;gt; Pages &amp;gt; Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 &amp;gt; Cataloger &amp;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 &amp;gt; Cataloger &amp;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 &amp;gt; Cataloger &amp;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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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 &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>&amp;#123;Cataloger action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 &amp;#123;Cataloger action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
&amp;lt;select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
&amp;lt;option value=&quot;&quot;>Select A target&amp;lt;/option>
&amp;#123;foreach from=$items item=thisone}
   &amp;lt;option value=&quot;&amp;#123;$thisone.link}&quot;>&amp;#123;$thisone.title}&amp;lt;/option>
&amp;#123;/foreach}
&amp;lt;/select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your hierarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
&amp;#123;Cataloger action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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 &#039;global_sort&#039; 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 &#039;global_sort_dir&#039; parameter, which will allow &#039;asc&#039; or &#039;desc&#039;.</p>
<p>So, for a thorough example:</p>
<p>&amp;#123;Cataloger action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039; global_sort=&#039;alpha&#039; global_sort_dir=&#039;asc&#039;}</p>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>&amp;#123;Cataloger action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There are four optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, global_sort=&#039;date&#039;, global_sort_dir=&#039;desc&#039; 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 &quot;page_alias&quot; is &quot;/&quot;, which means
to use <i>all</i> pages in the site. global_sort may be &#039;date&#039; (for item creation date) or &#039;mdate&#039; for modification date, and
global_sort_dir may be &#039;asc&#039; or &#039;desc&#039;.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>&amp;#123;cCataloger action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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>&amp;#123;Cataloger action=&#039;variable&#039; name=&#039;itemnotes&#039; default=&#039;no notes&#039;}, 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>&amp;#123;cCataloger action=&#039;compare&#039; sub_template=&#039;my_sub_template&#039; items=&#039;item1,item2,item3&#039;}, 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 &quot;items&quot; 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 &amp;gt; Cataloger &amp;gt; Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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 &quot;Gl&uuml;cklichkeit&quot;, there will be a Smarty variable {$glcklichkeit}. Note that the &quot;&uuml;&quot; is omitted.</p>
<p>Fortunately, this is simplified by the $attrlist list available. This is a list of attributes by formal name (&quot;Gl&uuml;cklichkeit&quot;) and their key (&quot;glcklichkeit&quot;). For example:
<pre>
	{section name=at loop=$attrlist}
	&amp;lt;div class=&quot;item_attribute_name&quot;>{$attrlist[at].name}:&amp;lt;/div>&amp;lt;div class=&quot;item_attribute_val&quot;>{eval var=$attrlist[at].key}&amp;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 &quot;gluecklichkeit&quot;).</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&#039;s &quot;attr&quot; 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 &quot;Gl&uuml;cklichkeit&quot;, the item will have $item.glcklichkeit and $item.attrs[&#039;glcklichkeit&#039;]. Note that the &quot;&uuml;&quot; 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 (&quot;Gl&uuml;cklichkeit&quot;) and their key (&quot;glcklichkeit&quot;). 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 &quot;gluecklichkeit&quot;).</p>
<h4>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
&amp;#123;eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
&amp;#123;eval var=$entry->input assign=thisAttr}&amp;#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;amp;ac=82888
</p>
<p>The interesting thing is &quot;itemname_f_1_400_1.jpg&quot; - the stuff before is just a call to the program, and the &amp;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 &quot;image missing&quot; image if this image doesn&#039;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 &quot;cataloger_src&quot; 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&#039;d generate the URL manually.</p>
<p>So on a category page, for example, instead of using {$items[numloop].image} you&#039;d use &quot;/uploads/images/cataloger_src/{$items[numloop].alias}_src_1.jpg&quot;.</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">&amp;lt;sjg@cmsmodules.com&amp;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 &amp;copy; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. 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['changelog'] = '<ul>
<li>Version 0.7.7 - Feb 2010. Added files associated with Items. Added item comparison action.</li>
<li>Version 0.7.6 - 10 Sept 2009. Fix for that last fix. Doh!</li>
<li>Version 0.7.5 - 10 Sept 2009. Fixed Printable Catalog... did that ever work??</li>
<li>Version 0.7.4 - 22 June 2009. Incorporated Calguy&#039;s fixes for 1.6.</li>
<li>Version 0.7.3 - 16 June 2009. Bug fixes by Nuno. Made max CMS version 1.5.4 in prep for CMS 1.6 release.</li>
<li>Version 0.7.2 - 14 March 2009. Bug fixes by Nuno Costa.</li>
<li>Version 0.7.1 - 29 Sept 2008. Added Variable method for Javier San Juan Costilas.</li>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Husk &aring; sette &quot;Modify Catalog Settings&quot; rettighet til brukere som skal administrere katalogen.';
$lang['utmz'] = '156861353.1268088551.2485.51.utmcsr=cmstest2.helminikon.no|utmccn=(referral)|utmcmd=referral|utmcct=/index.php/banners';
$lang['utma'] = '156861353.179052623084110100.1210423577.1268945393.1268948206.2515';
$lang['qca'] = '1210971690-27308073-81952832';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.2.10.1268948206';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nl_NL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Afbeeldingen';
$lang['namefiles'] = 'Bestanden';
$lang['namefile'] = 'Bestand';
$lang['deleteimage'] = 'Verwijder afbeelding';
$lang['deletefile'] = 'Verwijder bestand';
$lang['Owner'] = 'Eigenaar';
$lang['CatalogItem'] = 'Artikel Catalogus';
$lang['namepage'] = 'Pagina';
$lang['Permissions'] = 'Permissies';
$lang['Sub'] = 'Sub - ';
$lang['title_global_item_sort_order2'] = 'Artikel Sorteervolgorde';
$lang['title_global_items_per_page2'] = 'Artikelen per pagina';
$lang['title_global_category_recurse2'] = 'Toongedrag';
$lang['which_attributes'] = 'Te tonen attributen in Catalogus';
$lang['navTab'] = '  |  ';
$lang['needpermission'] = 'U moet %s instellen om dit uit te voeren.';
$lang['friendlyname'] = 'Cataloger ';
$lang['admindescription'] = 'Beheer catalogus instellingen';
$lang['areyousure'] = 'Weet u zeker dat u %s wilt verwijderen?';
$lang['uniquecode'] = 'Unieke code';
$lang['templatelist'] = 'Sub-sjablonen';
$lang['listtempl'] = 'Beheer sub-sjablonen';
$lang['title_item_tab'] = 'Artikel attributen';
$lang['title_category_tab'] = 'Categorie attributen';
$lang['title_printable_tab'] = 'Printbare catalogus instellingen';
$lang['title_item_image_tab'] = 'Artikel afbeeldingsafmetingen';
$lang['title_category_image_tab'] = 'Categorie pagina instellingen';
$lang['title_path_tab'] = 'Pad';
$lang['title_is_textfield'] = 'Tekstgebied?';
$lang['title_delete'] = 'Verwijder?';
$lang['title_file_tab'] = 'Overige bestandsinstellingen';
$lang['title_image_tab'] = 'Overige afbeeldinginstellingen';
$lang['title_item_template_vars'] = 'Artikel sjabloon variabelen';
$lang['title_cat_template_vars'] = 'Categorie sjabloon variabelen';
$lang['title_catalog_template_vars'] = 'Catalogus Sjabloon  Variabelen';
$lang['title_compare_template_vars'] = 'Vergelijking Sjabloon Variabelen';
$lang['title_feature_template_vars'] = 'Features Sjabloon Variabelen';
$lang['title_show_only_existing_images'] = 'Missende afbeeldingen niet gebruiken';
$lang['title_show_only_existing_images_help'] = 'Dit plaatst alleen afbeeldingsreferenties in lijsten als de afbeelding bestaat.<br />(Dit in normaal gesproken goed, maar als u iets slims doet met de afbeelding<br />array indexen, kan dit problemen veroorzaken.)';
$lang['title_flush_cats'] = 'Wis categorie pagina buffers';
$lang['title_flush_cats_help'] = 'Als u een groot aantal items wilt tonen<br />in een categorie, dan falen sommige PHP-installaties in het goed weergeven van de pagina<br />. Vink dit vakje aan om het probleem te verhelpen (test op neveneffecten).';
$lang['title_item_file_types'] = 'Toegestane bestandstypen';
$lang['title_image_upload_path'] = 'Map voor de ge&uuml;ploade afbeeldingen';
$lang['title_file_upload_path'] = 'Map voor de overige ge&uuml;ploade bestanden';
$lang['title_image_proc_path'] = 'Map voor de bewerkte afbeeldingen (miniaturen, verschaalde afbeeldingen, enz.)';
$lang['path_help'] = 'U kunt bepalen waar Cataloger bestanden opslaat. Het pad is relatief tot het <i>uploads_path</i> uit de config.php<br />LET OP: Als u dit pad wijzigt nadat er al bestanden zijn ge&uuml;pload zal de Cataloger module de verbinding tot het bestand verliezen. Het bestand zelf zal niet worden verwijderd, alleen de verbinding er na toe. U zult de afbeeldingen opnieuw moeten uploaden!';
$lang['cataloger'] = 'Cataloger ';
$lang['title_attr_order_by'] = 'Volgorde';
$lang['title_attr_alias'] = 'Attribuut Alias (Smarty Vriendelijk)';
$lang['title_attr_length'] = 'Lengte*';
$lang['title_attr_default'] = 'Standaard Waarde';
$lang['title_attr_length_help'] = '(* Lengte geldt niet voor Tekstblokken)';
$lang['item_page'] = 'Item Pagina';
$lang['category_page'] = 'Categoriepagina';
$lang['catalog_printable'] = 'Printbare Catalogus';
$lang['catalog_datasheet'] = 'Catalogus datasheet';
$lang['catalog_short_list'] = 'Lijst met mogelijkheden';
$lang['item_comparison'] = 'Artikel Vergelijking';
$lang['title_global_item_sort_order'] = 'Zet de sorteervolgorde op';
$lang['title_global_items_per_page'] = 'Stel aantal artikelen per pagina in op';
$lang['title_global_category_recurse'] = 'Stel Category-weergavegedrag in op';
$lang['title_item_sort_order'] = 'Standaard Artikel Volgorde';
$lang['title_printable_sort_order'] = 'Standaard printbare catalogus volgorde';
$lang['title_items_per_page'] = 'Standaard aantal artikelen per pagina';
$lang['title_avail_attrs'] = 'Artikel attributen beschikbaar voor het sjabloon';
$lang['title_avail_imattrs'] = 'Artikel afbeeldingen beschikbaar voor het sjabloon';
$lang['title_item_image_size_hero'] = 'Afbeeldinggrootte voor artikelpagina (lange as in pixels)';
$lang['title_item_image_size_thumbnail'] = 'Miniatuur-grootte voor artikelpagina (lange as in pixels)';
$lang['title_item_image_size_category'] = 'Miniatuur-grootte voor het artikel in de Categorie pagina (lange as in pixels)';
$lang['title_item_image_size_catalog'] = 'Miniatuur-grootte voor het artikel in de Catalogus pagina (lange as in pixels)';
$lang['title_category_image_size_hero'] = 'Afbeeldingsgrootte voor categoriepagina (lange as in pixels)';
$lang['title_category_image_size_thumbnail'] = 'Miniatuur-grootte voor categoriepagina (lange as in pixels)';
$lang['title_template'] = 'Sjabloon';
$lang['title_template_type'] = 'Sjabloontype';
$lang['title_title'] = 'Titel';
$lang['title_item_image_count'] = 'Maximum aantal weergaven voor ieder artikel';
$lang['title_item_file_count'] = 'Maximaal aantal andere bestanden die per artikel worden geassocieerd';
$lang['title_category_image_count'] = 'Maximum aantal banner-afbeeldingen voor iedere categoriepagina ';
$lang['title_item_attributes_help'] = 'Ieder attribuut die u hier invoert, zal de titel van een veld zijn die u kunt gebruiken om een individueel item te beschrijven en zal getoond worden bij dat item. Mogelijk moet u uw sjabloon bijwerken om deze attributen te gebruiken. Maak een bestaande attribuut leeg of vervang de inhoud om het attribuut te verwijderen of te vervangen.';
$lang['title_category_attributes_help'] = 'Ieder attribuut die u hier invoert, zal de titel van een veld zijn die u kunt gebruiken om een itemcategorie te beschrijven en zal getoond worden op die categoriepagina. Mogelijk moet u uw sjabloon bijwerken om deze attributen te gebruiken. Maak een bestaande attribuut leeg of vervang de inhoud om het attribuut te veEach 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. Blank out or type over an existing attribute to remove or replace it.rwijderen of te vervangen.';
$lang['title_catalog_attributes_help'] = 'Ieder attribuut die u invoert, zal de titel van een veld zijn die u kunt gebruiken om een gehele categorie te beschrijven en zal getoond worden op de printbare categoriepagina. Mogelijk moet u uw sjabloon bijwerken om deze attributen te gebruiken. Maak een bestaande attribuut leeg of vervang de inhoud om het attribuut te verwijderen of te vervangen.';
$lang['title_category_sort'] = 'Categoriepagina Artikel-lijst volgorde';
$lang['title_category_recurse'] = 'Standaard gedrag voor categorieweergave';
$lang['title_category_recurse_items_all'] = 'Voeg alle artikelen binnen deze categorie toe, inclusief artikelen in subcategorie&euml;n.';
$lang['title_category_recurse_items_one'] = 'Voeg alle artikelen binnen deze categorie toe, behalve artikelen in de subcategorie&euml;n.';
$lang['title_category_recurse_categories_all'] = 'Voeg alle categorie&euml;n binnen deze categorie toe, inclusief categorie&euml;n in subcategorie&euml;n';
$lang['title_category_recurse_categories_one'] = 'Voeg alle Items en Categorie&euml;n toe in deze Categorie, behalve items en categorie&euml;n uit sub-categorie&euml;n';
$lang['title_category_recurse_mixed_all'] = 'Voeg alle Items en Categorie&euml;n toe in deze Categorie, inclusief items en categorie&euml;n uit subcategorie&euml;n';
$lang['title_category_recurse_mixed_one'] = 'Voeg alle Items en Categorie&euml;n direct aan deze categorie toe, behalve items of categorie&euml;n in de subcategorie&euml;n';
$lang['title_show_missing_images'] = 'Toon &quot;Geen Afbeelding&quot; plaatje als betreffende afbeeldingen ontbreken';
$lang['title_show_missing_images_long'] = 'Toon een speciale &quot;Geen Afbeelding&quot; afbeelding als er een afbeelding ontbreekt (makkelijk voor debugging. Anders wordt er een transparante afbeelding gebruikt).';
$lang['natural_order'] = 'Navigatie volgorde';
$lang['alpha_order'] = 'Alfabetische volgorde';
$lang['manageprefs'] = 'Beheer voorkeuren';
$lang['manageattrs'] = 'Beheer gebruikergedefinieerde attributen';
$lang['globalops'] = 'Algemene Catalogus taken';
$lang['addtemplate'] = 'Voeg sjabloon toe';
$lang['reimporttemplates'] = 'Herimporteer voorbeeldsub-sjablonen';
$lang['reimported'] = 'Voorbeeld sub-sjablonen zijn ge&iuml;mporteerd';
$lang['templateupdated'] = 'Sjabloon toegevoegd/ge&uuml;pdate.';
$lang['templatedeleted'] = 'Sjabloon verwijderd.';
$lang['prefsupdated'] = 'Voorkeuren ge&uuml;pdate.';
$lang['installed'] = 'Moduleversie %s ge&iuml;nstalleerd.';
$lang['upgraded'] = 'Module ge&uuml;pdate naar versie %s.';
$lang['badfile'] = 'Bestand &quot;%s&quot; heeft een niet toegestane extentie.';
$lang['badimage'] = 'Probleem bij uploaden &quot;%s&quot; (controleer bestandgrootte of serverinstellingen).';
$lang['badimageformat'] = '&quot;%s&quot; is niet correct. Aleen jpegs zijn op dit moment toegestaan.';
$lang['uploaded'] = 'Bestand &quot;%s&quot; ge&uuml;pload voor artikel %s.';
$lang['uninstalled'] = 'Module gede&iuml;nstalleerd';
$lang['attrsupdated'] = 'Attributen ge&uuml;pdate.';
$lang['noglobalchange'] = 'Niet veranderen';
$lang['globallyupdated'] = 'Aanpassingen doorgevoerd.';
$lang['edittemplate'] = 'Pas sjabloon aan';
$lang['subtemplates'] = 'Catalogus Sub-sjablonen';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Aanpassen';
$lang['delete'] = 'Verwijderen';
$lang['notemplates'] = 'Er zijn geen sub-sjablonen ge&iuml;nstalleerd';
$lang['helptext'] = '<h3>What Does This Do?</h3> 
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content &amp;gt; Pages &amp;gt; Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 &amp;gt; Cataloger &amp;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 &amp;gt; Cataloger &amp;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 &amp;gt; Cataloger &amp;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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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 &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>&amp;#123;Cataloger action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 &amp;#123;Cataloger action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
&amp;lt;select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
&amp;lt;option value=&quot;&quot;>Select A target&amp;lt;/option>
&amp;#123;foreach from=$items item=thisone}
   &amp;lt;option value=&quot;&amp;#123;$thisone.link}&quot;>&amp;#123;$thisone.title}&amp;lt;/option>
&amp;#123;/foreach}
&amp;lt;/select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your hierarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
&amp;#123;Cataloger action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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 &#039;global_sort&#039; 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 &#039;global_sort_dir&#039; parameter, which will allow &#039;asc&#039; or &#039;desc&#039;.</p>
<p>So, for a thorough example:</p>
<p>&amp;#123;Cataloger action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039; global_sort=&#039;alpha&#039; global_sort_dir=&#039;asc&#039;}</p>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>&amp;#123;Cataloger action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There are four optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, global_sort=&#039;date&#039;, global_sort_dir=&#039;desc&#039; 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 &quot;page_alias&quot; is &quot;/&quot;, which means
to use <i>all</i> pages in the site. global_sort may be &#039;date&#039; (for item creation date) or &#039;mdate&#039; for modification date, and
global_sort_dir may be &#039;asc&#039; or &#039;desc&#039;.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>&amp;#123;cCataloger action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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>&amp;#123;Cataloger action=&#039;variable&#039; name=&#039;itemnotes&#039; default=&#039;no notes&#039;}, 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>&amp;#123;cCataloger action=&#039;compare&#039; sub_template=&#039;my_sub_template&#039; items=&#039;item1,item2,item3&#039;}, 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 &quot;items&quot; 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 &amp;gt; Cataloger &amp;gt; Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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 &quot;Gl&uuml;cklichkeit&quot;, there will be a Smarty variable {$glcklichkeit}. Note that the &quot;&uuml;&quot; is omitted.</p>
<p>Fortunately, this is simplified by the $attrlist list available. This is a list of attributes by formal name (&quot;Gl&uuml;cklichkeit&quot;) and their key (&quot;glcklichkeit&quot;). For example:
<pre>
	{section name=at loop=$attrlist}
	&amp;lt;div class=&quot;item_attribute_name&quot;>{$attrlist[at].name}:&amp;lt;/div>&amp;lt;div class=&quot;item_attribute_val&quot;>{eval var=$attrlist[at].key}&amp;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 &quot;gluecklichkeit&quot;).</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&#039;s &quot;attr&quot; 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 &quot;Gl&uuml;cklichkeit&quot;, the item will have $item.glcklichkeit and $item.attrs[&#039;glcklichkeit&#039;]. Note that the &quot;&uuml;&quot; 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 (&quot;Gl&uuml;cklichkeit&quot;) and their key (&quot;glcklichkeit&quot;). 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 &quot;gluecklichkeit&quot;).</p>
<h4>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
&amp;#123;eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
&amp;#123;eval var=$entry->input assign=thisAttr}&amp;#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;amp;ac=82888
</p>
<p>The interesting thing is &quot;itemname_f_1_400_1.jpg&quot; - the stuff before is just a call to the program, and the &amp;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 &quot;image missing&quot; image if this image doesn&#039;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 &quot;cataloger_src&quot; 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&#039;d generate the URL manually.</p>
<p>So on a category page, for example, instead of using {$items[numloop].image} you&#039;d use &quot;/uploads/images/cataloger_src/{$items[numloop].alias}_src_1.jpg&quot;.</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">&amp;lt;sjg@cmsmodules.com&amp;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 &amp;copy; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. 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['changelog'] = '<ul>
<li>Version 0.7.7 - Feb 2010. Added files associated with Items. Added item comparison action.</li>
<li>Version 0.7.6 - 10 Sept 2009. Fix for that last fix. Doh!</li>
<li>Version 0.7.5 - 10 Sept 2009. Fixed Printable Catalog... did that ever work??</li>
<li>Version 0.7.4 - 22 June 2009. Incorporated Calguy&#039;s fixes for 1.6.</li>
<li>Version 0.7.3 - 16 June 2009. Bug fixes by Nuno. Made max CMS version 1.5.4 in prep for CMS 1.6 release.</li>
<li>Version 0.7.2 - 14 March 2009. Bug fixes by Nuno Costa.</li>
<li>Version 0.7.1 - 29 Sept 2008. Added Variable method for Javier San Juan Costilas.</li>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Zorg dat u het &quot;Modify Catalog Settings&quot; recht voor de gebruikers die de Catalogus moeten beheren.';
$lang['utma'] = '156861353.509382990.1276370458.1277129258.1277134820.60';
$lang['utmz'] = '156861353.1276965290.51.9.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=inline popup';
$lang['qca'] = 'P0-26515958-1276370458481';
$lang['utmb'] = '156861353.2.10.1277134820';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/pl_PL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Obrazki';
$lang['deleteimage'] = 'Skasuj obrazek';
$lang['Owner'] = 'Właściciel';
$lang['CatalogItem'] = 'Katalog pozycji';
$lang['namepage'] = 'Strona';
$lang['Permissions'] = 'Uprawnienia';
$lang['Sub'] = 'Sub -';
$lang['title_global_item_sort_order2'] = 'Kolejność sortowania pozycji';
$lang['title_global_items_per_page2'] = 'Pozycji na stronę';
$lang['title_global_category_recurse2'] = 'Rodzaj wyświetlania';
$lang['which_attributes'] = 'Kt&oacute;re atrybuty powinny być pokazane w katalogu';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'Musisz ustawić %s aby to zrobić.';
$lang['friendlyname'] = 'Katalog';
$lang['admindescription'] = 'Zarządzaj ustawieniami katalogu';
$lang['areyousure'] = 'Czy na pewno chcesz to usunąć %s?';
$lang['uniquecode'] = 'Unikalny kod';
$lang['templatelist'] = 'Szablony';
$lang['listtempl'] = 'Zarządzaj szablonami';
$lang['title_item_tab'] = 'Atrybuty pozycji';
$lang['title_category_tab'] = 'Atrybuty kategorii';
$lang['title_printable_tab'] = 'Ustawienia wersji do druku';
$lang['title_item_image_tab'] = 'Rozmiar zdjęcia pozycji katalogu';
$lang['title_category_image_tab'] = 'Ustawienia strony kategorii';
$lang['title_is_textfield'] = 'Pole tekstowe (textarea)?';
$lang['title_delete'] = 'Skasować?';
$lang['title_aspect_tab'] = 'Wsp&oacute;łczynniki proporcji obrazu';
$lang['title_image_tab'] = 'Inne ustawienia obraz&oacute;w';
$lang['title_item_template_vars'] = 'Zmienne szablonu pozycji katalogu';
$lang['title_cat_template_vars'] = 'Zmienne szablonu kategorii';
$lang['title_feature_template_vars'] = 'Zmienne szablonu Features';
$lang['title_show_only_existing_images'] = 'Nie dołączaj brakujących obrazk&oacute;w';
$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'] = 'Wyczyść pamięć podręczną katalogu';
$lang['title_flush_cats_help'] = 'Jeżeli masz dużo pozycji w kategorii<br />niekt&oacute;re instalacje PHP mogą pokazywać strony niepoprawnie.<br />Zaznacz tę opcję by rozwiązać problem (sprawdź też czy nie ma jakichś efekt&oacute;w ubocznych.';
$lang['cataloger'] = 'Katalog';
$lang['item_page'] = 'Strona pozycji katalogu';
$lang['category_page'] = 'Strona kategorii';
$lang['catalog_printable'] = 'Katalog w wersji do druku';
$lang['catalog_datasheet'] = 'Arkusz danych katalogu';
$lang['catalog_short_list'] = 'Lista cech';
$lang['title_global_item_sort_order'] = 'Ustaw porządek sortowania pozycji';
$lang['title_global_items_per_page'] = 'Ustaw liczbę pozycji na stronę';
$lang['title_global_category_recurse'] = 'Ustaw spos&oacute;b wyświetlania kategorii';
$lang['title_item_sort_order'] = 'Domyślny porządek sortowania pozycji';
$lang['title_printable_sort_order'] = 'Domyślny porządek sortowania katalogu w wersji do druku';
$lang['title_items_per_page'] = 'Domyślna liczba pozycji na stronę';
$lang['title_avail_attrs'] = 'Atrybuty pozycji dostępne w szablonie';
$lang['title_avail_imattrs'] = 'Obrazy pozycji dostępne w szablonie';
$lang['title_item_image_size_hero'] = 'Wielkość obrazu dla strony pozycji (dłuższa krawędź w pikselach)';
$lang['title_item_image_size_thumbnail'] = 'Wielkość miniaturki dla strony pozycji (dłuższa krawędź w pikselach)';
$lang['title_item_image_size_category'] = 'Wielkość miniaturki dla pozycji na stronie kategorii (dłuższa krawędź w pikselach)';
$lang['title_item_image_size_catalog'] = 'Wielkość miniaturki dla pozycji na stronie katalogu (dłuższa krawędź w pikselach)';
$lang['title_category_image_size_hero'] = 'Wielkość obrazu dla strony kategorii (dłuższa krawędź w pikselach)';
$lang['title_category_image_size_thumbnail'] = 'Wielkość miniaturki dla strony kategorii (dłuższa krawędź w pikselach)';
$lang['title_template'] = 'Szablon';
$lang['title_template_type'] = 'Typ szablonu';
$lang['title_title'] = 'Tytuł';
$lang['title_item_image_count'] = 'Maksymalna liczba obraz&oacute;w dla każdej pozycji katalogu';
$lang['title_category_image_count'] = 'Maksymalna liczba Banner&oacute;w dla każdej strony kategorii';
$lang['title_item_attributes_help'] = 'Każdy z atrybut&oacute;w, kt&oacute;re tu wprowadzisz będzie tytułem pola, kt&oacute;re możesz użyć do opisania danej pozycji katalogu, i będzie wyświetlany wraz z tą pozycją. Możesz ustalić spos&oacute;b wyświetlania atrybut&oacute;w uaktualniając szablon. Wyczyść pole istniejącego atrybutu aby go usunąć lub wpisz tekst na istniejącym aby zamienić.';
$lang['title_category_attributes_help'] = 'Każdy z atrybut&oacute;w, kt&oacute;re tu wprowadzisz będzie tytułem pola, kt&oacute;re możesz użyć do opisania danej kategorii katalogu, i będzie wyświetlany wraz z tą pozycją. Możesz ustalić spos&oacute;b wyświetlania atrybut&oacute;w uaktualniając szablon. Wyczyść pole istniejącego atrybutu aby go usunąć lub wpisz tekst na istniejącym aby zamienić.';
$lang['title_catalog_attributes_help'] = 'Każdy z atrybut&oacute;w, kt&oacute;re tu wprowadzisz będzie tytułem pola, kt&oacute;re możesz użyć do opisania całego katalogu, i będzie wyświetlany na stronie katalogu w wersji do wydruku. Możesz ustalić spos&oacute;b wyświetlania atrybut&oacute;w uaktualniając szablon. Wyczyść pole istniejącego atrybutu aby go usunąć lub wpisz tekst na istniejącym aby zamienić.';
$lang['title_force_aspect_ratio'] = 'Wymusić wyświetlanie obraz&oacute;w w ustalonym wsp&oacute;łczynniku proporcji?';
$lang['title_force_aspect_ratio_label'] = 'Wymuś wsp&oacute;łczynnik proporcji (jeszcze nie zaimplementowane)';
$lang['title_image_aspect_ratio'] = 'Wsp&oacute;łczynnik proporcji (ustal jako \&quot;4:3\&quot; lub \&quot;1:2.5\&quot;)';
$lang['title_aspect_ratio_help'] = 'Jeśli wymusisz wyświetlanie obrazu w ustalonym wsp&oacute;łczynniku proporcji, będzie on przeskalowany dokładnie do tego wsp&oacute;łczynnika proporcji (lub jego odwrotności, w ten spos&oacute;b otrzymasz oba formaty: orientację pionową i poziomą). W przeciwnym wypadku, obrazy zachowają ich proporcje i zostaną przeskalowane tak aby ich dłuższa krawędź miała ustaloną długość. <b>jeszcze nie zaimplementowane!</b>';
$lang['title_category_sort'] = 'Kolejność sortowania listy pozycji na stronie kategorii';
$lang['title_category_recurse'] = 'Domyślny spos&oacute;b wyświetlania kategorii';
$lang['title_category_recurse_items_all'] = 'Wyświetl wszystkie pozycje wewnątrz tej kategorii, włączając pozycje z podkategorii';
$lang['title_category_recurse_items_one'] = 'Wyświetl od razu wszystkie pozycje wewnątrz tej kategorii, ale bez pozycji z podkategorii';
$lang['title_category_recurse_categories_all'] = 'Wyświetl wszystkie kategorie wewnątrz tej kategorii, włączając kategorie w podkategoriach';
$lang['title_category_recurse_categories_one'] = 'Wyświetl od razu wszystkie kategorie wewnątrz tej kategorii, ale bez kategorii w podkategoriach';
$lang['title_category_recurse_mixed_all'] = 'Wyświetl wszystkie pozycje i kategorie wewnątrz tej kategorii, włączając pozycje i kategorie w podkategoriach';
$lang['title_category_recurse_mixed_one'] = 'Wyświetl od razu wszystkie pozycje i kategorie wewnątrz tej kategorii, ale bez pozycji i kategorii w podkategoriach';
$lang['title_show_missing_images'] = 'Pokaż obraz \&quot;Brak obrazka\&quot; dla brakujących obraz&oacute;w';
$lang['title_show_missing_images_long'] = 'Pokaż specjalny obrazek \&quot;Brak obrazka\&quot; jeśli brakuje obraz&oacute;w (w przeciwnym wypadku zostanie użyty obraz - przezroczysty piksel).';
$lang['natural_order'] = 'Porządek nawigacji';
$lang['alpha_order'] = 'Porządek alfabetyczny';
$lang['manageprefs'] = 'Zarządzaj ustawieniami';
$lang['manageattrs'] = 'Zarządzaj atrybutami użytkownika';
$lang['globalops'] = 'Globalne ustawienia katalogu';
$lang['addtemplate'] = 'Dodaj szablon';
$lang['reimporttemplates'] = 'Zaimportuj ponownie przykładowe szablony (uważaj na tą opcję!)';
$lang['reimported'] = 'Przykładowe szablony zostały zaimportowane.';
$lang['templateupdated'] = 'Szablon został dodany/uaktualniony.';
$lang['templatedeleted'] = 'Szablon został usunięty.';
$lang['prefsupdated'] = 'Ustawienia zostały uaktualnione.';
$lang['installed'] = 'Moduł w wersji %s został zainstalowany.';
$lang['upgraded'] = 'Moduł został uaktualniony do wersji %s.';
$lang['uninstalled'] = 'Moduł został odinstalowany.';
$lang['attrsupdated'] = 'Atrybuty zostały uaktualnione.';
$lang['noglobalchange'] = 'Bez zmian';
$lang['globallyupdated'] = 'Zmiany zostały rozpropagowane globalnie.';
$lang['edittemplate'] = 'Edytuj szablon';
$lang['subtemplates'] = 'Szablony katalogu';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Edytuj';
$lang['delete'] = 'Usuń';
$lang['notemplates'] = 'Brak zainstalowanych szablon&oacute;w!';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of \&quot;Catalog Items\&quot; which could be products, works of art, or the like, and \&quot;Catalog Categories\&quot; 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 \&quot;Content Aliases\&quot; (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\&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select \&quot;Catalog Item\&quot; or \&quot;Catalog Category\&quot; 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 \&quot;Images\&quot; 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\&#039;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 \&quot;Options\&quot; 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 \&quot;natural\&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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\&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn\&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have \&quot;feature lists\&quot; 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>Recently Added Feature List</h4>
<p>To use a \&quot;most-recently added\&quot; 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 \&quot;most recently added\&quot; list is like:</p>
<p>{cms_module module=\&#039;Cataloger\&#039; action=\&#039;recent\&#039; sub_template=\&#039;my_sub_template\&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=\&#039;3\&#039; alias=\&#039;page_alias\&#039;, 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 \&quot;page_alias\&quot; is \&quot;/\&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a \&quot;random\&quot; list is like:</p>
<p>{cms_module module=\&#039;Cataloger\&#039; action=\&#039;random\&#039; sub_template=\&#039;my_sub_template\&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=\&#039;3\&#039; alias=\&#039;page_alias\&#039;, 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 \&quot;page_alias\&quot; is \&quot;/\&quot;, which means to use <i>all</i> pages in the site.</p>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It\&#039;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\&#039;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\&#039;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\&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you\&#039;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 \&quot;Feature\&quot; 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\&#039;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>
<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\"><sjg@cmsmodules.com></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; 2006, Samuel Goldstein <a href=\"mailto:sjg@cmsmodules.com\"><sjg@cmsmodules.com></a>. 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['changelog'] = '<ul>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added \&quot;/\&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Upewnij się że zostały ustawione prawa \&quot;Modify Catalog Settings\&quot; dla użytkownik&oacute;w, kt&oacute;rzy będą administrować katalogiem.';
$lang['utma'] = '156861353.2359145497878676500.1213200278.1219666310.1219757278.98';
$lang['utmz'] = '156861353.1219266170.93.18.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/softwaremap/trove_list.php|utmcmd=referral';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/pt_PT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Imagens';
$lang['deleteimage'] = 'Eliminar Imagens';
$lang['Owner'] = 'Propriet&aacute;rio';
$lang['CatalogItem'] = 'Cat&aacute;logo Item ';
$lang['namepage'] = 'P&aacute;gina';
$lang['Permissions'] = 'Permiss&otilde;es';
$lang['Sub'] = 'Sub - ';
$lang['title_global_item_sort_order2'] = 'Ordena&ccedil;&atilde;o do Item';
$lang['title_global_items_per_page2'] = 'Items por P&aacute;gina';
$lang['title_global_category_recurse2'] = 'Mostrar Comportamento';
$lang['which_attributes'] = 'Atributos que devem ser mostrados no cat&aacute;logo';
$lang['navTab'] = '  |  ';
$lang['needpermission'] = 'Necessita %s para ter premiss&otilde;es';
$lang['friendlyname'] = 'Cat&aacute;logo';
$lang['admindescription'] = 'Gerir Configura&ccedil;&otilde;es do Cat&aacute;logo';
$lang['areyousure'] = 'Tem a Certeza que Pretende Eliminar %s?';
$lang['uniquecode'] = 'C&oacute;digo &Uacute;nico';
$lang['templatelist'] = 'Sub - templates';
$lang['listtempl'] = 'Gerir Sub-templates';
$lang['title_item_tab'] = 'Atributos do Item';
$lang['title_category_tab'] = 'Atributos da Categoria';
$lang['title_printable_tab'] = 'Atributos de Impress&atilde;o do Cat&aacute;logo';
$lang['title_item_image_tab'] = 'Item Tamanho de Imagens';
$lang['title_category_image_tab'] = 'Configura&ccedil;&otilde;es para a Categoria';
$lang['title_is_textfield'] = '&Aacute;rea de Texto?';
$lang['title_delete'] = 'Eliminar?';
$lang['title_aspect_tab'] = 'Aspect Ratios da Imagem';
$lang['title_image_tab'] = 'Outras Configura&ccedil;&otilde;es das Imagens';
$lang['title_item_template_vars'] = 'Vari&aacute;veis do Template para Item';
$lang['title_cat_template_vars'] = 'Vari&aacute;veis do Template para Categoria';
$lang['title_feature_template_vars'] = 'Caracter&iacute;sticas  das vari&aacute;veis do Template';
$lang['title_show_only_existing_images'] = 'N&atilde;o Incluir a Falta de Imagens';
$lang['title_show_only_existing_images_help'] = 'Isso s&oacute; ir&aacute; colocar refer&ecirc;ncias na imagem em listas, se a imagem existir.

(Normalmente, isso &eacute; &oacute;ptimo, mas se voc&ecirc; est&aacute; a fazer algo inteligente com a imagem

Array &iacute;ndices, isso poderia causar problemas.)';
$lang['title_flush_cats'] = 'Flush category page buffers';
$lang['title_flush_cats_help'] = 'Se tem um grande n&uacute;mero de itens
em uma categoria, algumas instala&ccedil;&otilde;es do PHP n&atilde;o v&atilde;o deixar exibir a p&aacute;gina correctamente. 
Marque essa caixa para resolver este problema (teste de efeitos secund&aacute;rios).';
$lang['cataloger'] = 'Cat&aacute;logo';
$lang['item_page'] = 'Cat&aacute;logo Item';
$lang['category_page'] = 'Cat&aacute;logo Categoria ';
$lang['catalog_printable'] = 'Cat&aacute;logo Imprim&iacute;vel';
$lang['catalog_datasheet'] = 'Cat&aacute;logo Datasheet';
$lang['catalog_short_list'] = 'Lista de Recursos';
$lang['title_global_item_sort_order'] = 'Definir ordena&ccedil;&atilde;o do item para';
$lang['title_global_items_per_page'] = 'Definir n&uacute;mero de items por p&aacute;gina para';
$lang['title_global_category_recurse'] = 'Definir o comportamento para exibir na categoria  para';
$lang['title_item_sort_order'] = 'Ordena&ccedil;&atilde;o do item por defeito';
$lang['title_printable_sort_order'] = 'Ordena&ccedil;&atilde;o do Cat&aacute;logo Imprim&iacute;vel por defeito';
$lang['title_items_per_page'] = 'Ordena&ccedil;&atilde;o por defeito do n&uacute;mero de items por p&aacute;gina';
$lang['title_avail_attrs'] = 'Item atributos dispon&iacute;veis para o template';
$lang['title_avail_imattrs'] = 'Item imagens dispon&iacute;veis para o template';
$lang['title_item_image_size_hero'] = 'Tamanho da imagem para o item na p&aacute;gina (Longo eixo em pixels)';
$lang['title_item_image_size_thumbnail'] = 'Tamanho das Miniaturas para o item na  p&aacute;gina (Longo eixo em pixels)';
$lang['title_item_image_size_category'] = 'Tamanho das Miniaturas para o item da categoria na  p&aacute;gina (Longo eixo em pixels)';
$lang['title_item_image_size_catalog'] = 'Tamanho das Miniaturas para o item no Cat&aacute;logo na p&aacute;gina (Longo eixo em pixels)';
$lang['title_category_image_size_hero'] = 'Tamanho da imagem para para a Categoria na  p&aacute;gina (Longo eixo em pixels)';
$lang['title_category_image_size_thumbnail'] = 'Tamanho das Miniaturas para a Categoria na  p&aacute;gina (Longo eixo em pixels)';
$lang['title_template'] = 'Template ';
$lang['title_template_type'] = 'Tipo de Template';
$lang['title_title'] = 'Titulo';
$lang['title_item_image_count'] = 'N&uacute;mero m&aacute;ximo de imagens por cada item';
$lang['title_category_image_count'] = 'N&uacute;mero m&aacute;ximo de imagens Banner para cada categoria';
$lang['title_item_attributes_help'] = 'Cada atributo que adicionar nesta &aacute;rea, ser&aacute; o t&iacute;tulo de um campo, que, pode usar para descrever um determinado item, e ser&aacute; exibido com esse item. Pode ter que actualizar o seu template para reflectir estes atributos. Em branco, ou por cima de um tipo de atributo existente para remover ou substituir.';
$lang['title_category_attributes_help'] = 'Cada atributo que adicionar nesta &aacute;rea, ser&aacute; o t&iacute;tulo de um campo, que, pode usar para descrever um determinado item, e ser&aacute; exibido com esse item. Pode ter que actualizar o seu template para reflectir estes atributos. Em branco, ou por cima de um tipo de atributo existente para remover ou substituir.';
$lang['title_catalog_attributes_help'] = 'Cada atributo que adicionar nesta &aacute;rea, ser&aacute; o t&iacute;tulo de um campo, que, pode usar para descrever um determinado item, e ser&aacute; exibido com esse item. Pode ter que actualizar o seu template para reflectir estes atributos. Em branco, ou por cima de um tipo de atributo existente para remover ou substituir.';
$lang['title_force_aspect_ratio'] = 'For&ccedil;ar imagens a para ';
$lang['title_force_aspect_ratio_label'] = 'For&ccedil;arr Aspecto ratio (n&atilde;o implementado ainda!)';
$lang['title_image_aspect_ratio'] = 'Aspecto ratio (especificar como &quot;4:3&quot; ou &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = 'If you force an image to a specified aspect ratio, it will be scaled to fit exactly that aspect ratio (or its inverse, so you can have both portrait and landscape formats). Otherwise, images will preserve their aspect ratio, and be scaled so their long axis is the size specified. <b>this is not yet implemented!</b>';
$lang['title_category_sort'] = 'Ordena&ccedil;&atilde;o da lista de items na p&aacute;gina da Categoria';
$lang['title_category_recurse'] = 'Exibir comportamento da categoria por defeito';
$lang['title_category_recurse_items_all'] = 'Incluir todos os itens dentro desta categoria, incluindo itens em sub-categorias';
$lang['title_category_recurse_items_one'] = 'Incluir todos os itens imediatamente dentro desta categoria, mas n&atilde;o os itens em sub-categorias';
$lang['title_category_recurse_categories_all'] = 'Incluir todos Categorias dentro desta categoria, incluindo as categorias de sub-categorias&#039;';
$lang['title_category_recurse_categories_one'] = 'Incluir todos Categorias imediatamente dentro desta categoria, mas n&atilde;o nas categorias sub-categorias';
$lang['title_category_recurse_mixed_all'] = 'Incluir todos os itens e categorias dentro desta categoria, incluindo itens e categorias de sub-categorias';
$lang['title_category_recurse_mixed_one'] = 'Incluir todos os itens e categorias imediatamente dentro desta categoria, mas n&atilde;o itens ou categorias de sub-categorias';
$lang['title_show_missing_images'] = 'Mostrar &quot;Sem Imagem&quot; para imagens em falta';
$lang['title_show_missing_images_long'] = 'Mostrar uma especial &quot;Sem Imagem&quot; se existir uma imagem em falta (&uacute;til para debugging. Ou insira um .gif transparente ).';
$lang['natural_order'] = 'Ordem por Navega&ccedil;&atilde;o';
$lang['alpha_order'] = 'Ordem Alfab&eacute;tica';
$lang['manageprefs'] = 'Gerir Prefer&ecirc;ncias';
$lang['manageattrs'] = 'Gerir atributos personalizados';
$lang['globalops'] = 'Opera&ccedil;&otilde;es Globais do Cat&aacute;logo';
$lang['addtemplate'] = 'Adicionar novo Sub-template';
$lang['reimporttemplates'] = 'Re-importar exemplo sub-templates';
$lang['reimported'] = 'Exemplo do sub-template foi importado.';
$lang['templateupdated'] = 'Template adicionado/actualizado.';
$lang['templatedeleted'] = 'Template eliminado.';
$lang['prefsupdated'] = 'Prefer&ecirc;ncias actualizadas.';
$lang['installed'] = 'Vers&atilde;o do Modulo %s instalado.';
$lang['upgraded'] = 'Modulo actualizado para vers&atilde;o %s.';
$lang['uninstalled'] = 'Modulo desinstalado.';
$lang['attrsupdated'] = 'Atributos actualizados.';
$lang['noglobalchange'] = 'N&atilde;o alterar';
$lang['globallyupdated'] = 'Mudan&ccedil;as propagadas globalmente.';
$lang['edittemplate'] = 'Editar Template';
$lang['subtemplates'] = 'Cat&aacute;logo Sub-templates';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Editar';
$lang['delete'] = 'Eliminar';
$lang['notemplates'] = 'Sem Sub-templates instalados';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (a module available at <a href=&quot;http://dev.cmsmadesimple.org/projects/contentaliases/&quot;>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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content &amp;gt; Pages &amp;gt; Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 &amp;gt; Cataloger &amp;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 &amp;gt; Cataloger &amp;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 &amp;gt; Cataloger &amp;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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 &amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
&amp;lt;select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
&amp;lt;option value=&quot;&quot;>Select A target&amp;lt;/option>
&amp;#123;foreach from=$items item=thisone}
   &amp;lt;option value=&quot;&amp;#123;$thisone.link}&quot;>&amp;#123;$thisone.title}&amp;lt;/option>
&amp;#123;/foreach}
&amp;lt;/select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>&amp;#123;cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<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 &amp;gt; Cataloger &amp;gt; Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
&amp;#123;eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
&amp;#123;eval var=$entry->input assign=thisAttr}&amp;#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;amp;ac=82888
</p>
<p>The interesting thing is &quot;itemname_f_1_400_1.jpg&quot; - the stuff before is just a call to the program, and the &amp;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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</p>
<h3>Credits</h3>
<p>Thanks to <a href=&quot;http://www.id-a.co.uk&quot;>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=&quot;http://dev.cmsmadesimple.org&quot;>Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href=&quot;mailto:sjg@cmsmodules.com&quot;>&amp;lt;sjg@cmsmodules.com&amp;gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&quot;http://forum.cmsmadesimple.org&quot;>CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href=&quot;irc://irc.freenode.net/#cms&quot;>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 &amp;copy; 2007, Samuel Goldstein <a href=&quot;mailto:sjg@cmsmodules.com&quot;>&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>
<h3>Tradu&ccedil;&atilde;o de Nuno Costa:</h3>
<p><a href=&quot;mailto:nuno.mfcosta@sapo.pt&quot;><nuno.mfcosta@sapo.pt></a>. All Rights Are Reserved.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Certifique-se de definir as permiss&otilde;es  &quot;Modificar Configura&ccedil;&otilde;es do Cat&aacute;logo &quot; para que os usu&aacute;rios possam administrar o cat&aacute;logo.';
$lang['utma'] = '156861353.1100698504968474900.1215720965.1215778668.1215784816.3';
$lang['utmz'] = '156861353.1215720965.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none)';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.1.10.1215784816';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/ro_RO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Imagini';
$lang['namefiles'] = 'Fisiere';
$lang['namefile'] = 'Fisier';
$lang['deleteimage'] = 'Sterge Imagine';
$lang['deletefile'] = 'Stergere Fisier';
$lang['Owner'] = 'Propietar';
$lang['CatalogItem'] = 'Lista Catalog';
$lang['namepage'] = 'Pagina';
$lang['Permissions'] = 'Permisiune';
$lang['Sub'] = 'Sub - ';
$lang['title_global_item_sort_order2'] = 'Ordoneaza dupa articol';
$lang['title_global_items_per_page2'] = 'Articol pe pagina';
$lang['title_global_category_recurse2'] = 'Arata Comportare';
$lang['which_attributes'] = 'Ce atributii ar trebui aratate in catalog';
$lang['navTab'] = '  |  ';
$lang['needpermission'] = 'Aveti nevoie de %s activata pentru aceasta.';
$lang['friendlyname'] = 'Catalog';
$lang['admindescription'] = 'Gestioneaza setari catalog';
$lang['areyousure'] = 'Sunteti sigur(a) ca doriti sa stergeti %s?';
$lang['uniquecode'] = 'Cod unic';
$lang['templatelist'] = 'Sub-sablon';
$lang['listtempl'] = 'Gestioneaza sub-sablon';
$lang['title_item_tab'] = 'Atribute articol';
$lang['title_category_tab'] = 'Atribute categorie';
$lang['title_printable_tab'] = 'Setari catalog tiparibil';
$lang['title_item_image_tab'] = 'Dimensiuni imagine element';
$lang['title_category_image_tab'] = 'Setari pagina categorie';
$lang['title_path_tab'] = 'Cai';
$lang['title_is_textfield'] = 'Zona Text?';
$lang['title_delete'] = 'Sterge?';
$lang['title_file_tab'] = 'Setari Fisier Obiect';
$lang['title_image_tab'] = 'Alte setari imagine';
$lang['title_item_template_vars'] = 'Sablon variabile element';
$lang['title_cat_template_vars'] = 'Sablon variabile  categorie';
$lang['title_catalog_template_vars'] = 'Variabile Template Catalog';
$lang['title_compare_template_vars'] = 'Variabile Template Comparatie';
$lang['title_feature_template_vars'] = 'Sablon variabile facilitati';
$lang['title_show_only_existing_images'] = 'Nu include imagini lipsa';
$lang['title_show_only_existing_images_help'] = 'Aceasta va doar va plasa referintele imaginii in liste, daca imaginea exista.<br />(In mod normal, este ok, dar daca utilizati in mod inteligent indecsii tabloului imaginii, <br />aceasta va poate pricinui probleme.)';
$lang['title_flush_cats'] = 'Goleste tampoanele paginii categorii';
$lang['title_flush_cats_help'] = 'Daca aveti afisat un numar urias de elemente<br />intr-o categorie, anumite instalari PHP vor esua in afisarea corecte <br />a paginii. Bifati aceasta casuta pentru a rezolva aceasta problema (test pentru efecte secundare).';
$lang['title_item_file_types'] = 'Tipuri de fisiere permise';
$lang['title_image_upload_path'] = 'Locatie pentru fisierele imagini uploadate';
$lang['title_file_upload_path'] = 'Locatie pentru alte fisiere uploadate';
$lang['title_image_proc_path'] = 'Locatie pentru imagini procesate (miniaturi, imagini redimensionate, etc)';
$lang['path_help'] = 'Se poate specifica unde anume stocheaza Cataloger fisierele. Aceste cai sunt relative fata de <i>uploads_path</i> definita in config.php<br />NOTA: Daca se schimba aceste cai dupa ce fisierele sau imaginile au fost uploadate, Cataloger va pierde obiectele gata uploadate (ele vor fi acolo, dar Cataloger nu va sti de ele, deci vor trebui re-uploadate).';
$lang['cataloger'] = 'Catalog';
$lang['title_attr_order_by'] = 'Ordine';
$lang['title_attr_alias'] = 'Alias Atribut (Prietenos cu Smarty)';
$lang['title_attr_length'] = 'Lungime*';
$lang['title_attr_default'] = 'Valoare Implicita';
$lang['title_attr_length_help'] = '(*Lungimea nu se aplica campurilor Text Area)';
$lang['item_page'] = 'Pagina element';
$lang['category_page'] = 'Pagina categorie';
$lang['catalog_printable'] = 'Catalog tiparibil';
$lang['catalog_datasheet'] = 'Foaie de calcul catalog';
$lang['catalog_short_list'] = 'Lista facilitati';
$lang['item_comparison'] = 'Comparatie obiecte';
$lang['title_global_item_sort_order'] = 'Stabileste ordinea de sortare la';
$lang['title_global_items_per_page'] = 'Stabileste numarul de elemente per pagina la';
$lang['title_global_category_recurse'] = 'Stabileste comportamentul de afisare a categoriilor la';
$lang['title_item_sort_order'] = 'Ordinea implicita de sortare a elementelor';
$lang['title_printable_sort_order'] = 'Ordinea implicita de sortare a cataloagelor tiparibile';
$lang['title_items_per_page'] = 'Numarul implicit de elemente per pagina';
$lang['title_avail_attrs'] = 'Atributele elementului disponibile pentru sablon';
$lang['title_avail_imattrs'] = 'Imaginile elementului disponibile pentru sablon';
$lang['title_item_image_size_hero'] = 'Dimensiunea imaginii pentru pagina element (axele lungi in pixeli)';
$lang['title_item_image_size_thumbnail'] = 'Dimensiunea imaginii pictograme pentru pagina elementului (axele lungi in pixeli)';
$lang['title_item_image_size_category'] = 'Dimensiunea imaginii pictograme pentru elementul din pagina categorie (axele lungi in pixeli)';
$lang['title_item_image_size_catalog'] = 'Dimensiunea imaginii pictograme pentru elementul din pagina catalog (axele lungi in pixeli)';
$lang['title_category_image_size_hero'] = 'Dimensiunea imaginii pentru pagina categorie (axele lungi in pixeli)';
$lang['title_category_image_size_thumbnail'] = 'Dimensiunea imaginii pictograme pentru pagina categorie (axele lungi in pixeli)';
$lang['title_template'] = 'Sablon';
$lang['title_template_type'] = 'Tip sablon';
$lang['title_title'] = 'Titlu';
$lang['title_item_image_count'] = 'Numar maxim vederi pentru fiecare element';
$lang['title_item_file_count'] = 'Numarul maxim de alte fisiere asociate cu fiecare obiect.';
$lang['title_category_image_count'] = 'Numar maxim de imagini baner pentru fiecare pagina categorie';
$lang['title_item_attributes_help'] = 'Fiecare atribut introdus aici va fi titlul unui camp pe care-l puteti folosi pentru descrierea unui element individual si va fi afisat impreuna cu acel element. Veti fi nevoit(a) sa actualizati sablonul dumneavoastra pentru reflectarea acestor atribute. Goliti sau suprascrieti peste un atribut existent pentru stergerea sau inlocuirea lui.';
$lang['title_category_attributes_help'] = 'Fiecare atribut introdus aici va fi titlul unui camp pe care-l puteti folosi pentru descrierea unei categorii de elemente si va fi afisat in pagina de categorii. Veti fi nevoit(a) sa actualizati sablonul dumneavoastra pentru reflectarea acestor atribute. Goliti sau suprascrieti peste un atribut existent pentru stergerea sau inlocuirea lui.';
$lang['title_catalog_attributes_help'] = 'Fiecare atribut introdus aici va fi titlul unui camp pe care-l puteti folosi pentru descrierea intregului catalog si va fi afisat in pagina catalogului tiparibil. Veti fi nevoit(a) sa actualizati sablonul dumneavoastra pentru reflectarea acestor atribute.  Goliti sau suprascrieti peste un atribut existent pentru stergerea sau inlocuirea lui.';
$lang['title_category_sort'] = 'Ordinea de sortarea a listei elementelor din pagina categoriei';
$lang['title_category_recurse'] = 'Coportamentul implicit de afisare a categoriei';
$lang['title_category_recurse_items_all'] = 'Include toate elementele din aceasta categorie, inclusiv pe cele din sub-categorii';
$lang['title_category_recurse_items_one'] = 'Include imediat toate elementele acestei categorii, dar nu si pe cele din sub-categorii';
$lang['title_category_recurse_categories_all'] = 'Include toate categoriile din aceasta categorie, inclusiv categoriile din sub-categorii';
$lang['title_category_recurse_categories_one'] = 'Include imediat toate categoriile din aceata categorie, dar nu si categoriile din sub-categorii';
$lang['title_category_recurse_mixed_all'] = 'Include toate elementele si categoriile din aceasta categorie, inclusiv elementele si si categoriile din sub-categorii';
$lang['title_category_recurse_mixed_one'] = 'Include imediat toate elementele si categoriile din aceasta categorie, dar nu si elementele/categoriile din sub-categorii';
$lang['title_show_missing_images'] = 'Afiseaza imaginea &quot;No Image&quot; pentru imaginile lipsa';
$lang['title_show_missing_images_long'] = 'Afiseaza o imagine speciala &quot;No Image&quot; daca exista imagini lipsa (folositor la depanare. Altfel va fi folosita o imagina transparenta cu un singur pixel).';
$lang['natural_order'] = 'Ordonare dupa navigare';
$lang['alpha_order'] = 'Ordonare alfabetica';
$lang['manageprefs'] = 'Gestioneaza preferintele';
$lang['manageattrs'] = 'Gestioneaza atributele definite de utilizator';
$lang['globalops'] = 'Operatii catalog global';
$lang['addtemplate'] = 'Adauga sablon';
$lang['reimporttemplates'] = 'Re-importa sub-sabloanele exemplu';
$lang['reimported'] = 'Sub-sabloanele exemplu au fost importate.';
$lang['templateupdated'] = 'Sablon adaugat/actualizat.';
$lang['templatedeleted'] = 'Sablon sters.';
$lang['prefsupdated'] = 'Preferinte actualizate.';
$lang['installed'] = 'Versiunea %s a modulului a fost instalata.';
$lang['upgraded'] = 'Modulul a fost actualizat la versiunea %s.';
$lang['badfile'] = 'Fisierul &quot;%s&quot; nu este intr-un format acceptabil.';
$lang['badimage'] = 'Problema la uploadarea &quot;%s&quot; (verificati dimensiunea fisierului si/sau permisiunile).';
$lang['badimageformat'] = '&quot;%s&quot; nu este valid. Numai fisiere jpeg sunt suportate in acest moment.';
$lang['uploaded'] = 'Fisierul &quot;%s&quot; a fost uploadat pentru obiectul %s.';
$lang['uninstalled'] = 'Modul dezinstalat.';
$lang['attrsupdated'] = 'Atribute actualizate.';
$lang['noglobalchange'] = 'Nu schimbati';
$lang['globallyupdated'] = 'Schimbarile propagate la nivel global.';
$lang['edittemplate'] = 'Editeaza sablon';
$lang['subtemplates'] = 'Sub-sabloane catalog';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Editeaza';
$lang['delete'] = 'Sterge';
$lang['notemplates'] = 'Nu exista sub-sabloane instalate!';
$lang['helptext'] = '<h3>Ce realizeaza acest modul?</h3>
<p>Acest modul va permite sa creati cataloage sau portofolii online. Cataloagele consta din &quot;Elemente catalog&quot; care pot fi produse, opere de arta, sau altele, si &quot;Categorii catalog&quot; care pot fi categorii de elemente sau alte diviziuni naturale ale catalogului.</p>
<p>Categoriile pot fi definite ierarhic (folosind lista continut a CMS Realizat Usor). Paginile categorii pot afisa elementele din categorie si/sau sub-categorii, optional recursiv sub-categoriile. Acest comportament poate fi configurat la nivel de categorie.</P>
<p>Exista de asemenea un catalog tiparibil, care reprezinta intreaga colectie de elemente din catalog intr-o singura pagina (deocamdata acesta este slab implementat si se va incarca foarte greu).</p>
<p>Modulul are inclus suportul pentru &quot;Aliasuri continut&quot; (modul disponibil la <a href="http://dev.cmsmadesimple.org/projects/contentaliases/">the Developer Forge</a>), care va permite plasarea oricarui element din catalog in categorii multiple.</p>
<h3>Cum il folosesc</h3>
<p>Atunci cand instalati modulul, el creaza trei noi tipuri de continut: Element Catalog, Categorie Catalog si Catalog tiparibil. Cand va aflati in categoria de administrare a site-ului, puteti adauga elemente si categorii catalog la fel cum ati proceda si cu alte tipuri de pagini. Selectati Continut > Pagini > Adauga Continut si apoi selectati &quot;Element Catalog&quot; sau &quot;Categorie Catalog&quot; din casuta expandabila Tip continut.</p>
<h4>Elemente Catalog</h4>
<p>Adaugarea unui Element Catalog este similara cu cea a unei pagini obisnuite in site-ul dumneavoastra. Campurile de date pentru element nu sunt insa exact la fel. De asemenea puteti observa ca in sectiunea &quot;Imagini&quot;, puteti selecta incarcarea de imagini multiple pentru element. Cand incarcati imagini, sistemul le va dimensiona in mod corespunzator pentru catalog, va crea pictograme pentru folosirea in pagina elementului, a paginii categoriei si altele. Pentru aceasta trebuie sa aveti instalata biblioteca de imagini GD sau una similara. Deocamdata, doar formatul de imagini jpeg este suportat.</p>
<h4>Categorii Catalog</h4>
<p>O Categorie Catalog este folosita pentru a va organiza elementele catalog. Ofera o pagina care listeaza continutul Catalogului. Un element catalog este considerat ca face parte dintr-o categorie catalog daca este sub aceasta in ierarhia site-ului. Similar, categoriile pot include alte categorii.</p>
<p>Categoriile catalog au un numar de setari pentru a determina felul cum vor fi afisate elementele si categoriile pe care le contin: daca va uitati in sectiunea &quot;Optiuni&quot;, puteti alege cate elemente si/sau categorii vor fi afisate, ordinea lor de afisare, daca vor fi afisate doar elementele sau doar categoriile sau ambele si cate nivele din ierarhie vor fi afisate in pagina categoriei.</p>
<p>De exemplu, considerati urmatoarea structura:</p>
<ol>
	<li><b>Palarii</b>
		<ol>
			<li><b>La moda</b>
			 	<ol>
			 		<li>Palarie cu pana</li><li>Fedora </li><li>Sapca de baseball</li>
			 	</ol>
			 </li>
		 	<li><b>Palarii de lucru</b>
		    	<ol>
		    		<li>Casca de protectie</li><li>Casca pentru scufundari</li>
		    	</ol>
		    </li>
		</ol>
	</li>
</ol>
<p>In aceasta diagrama, intrarile ingrosate sunt categorii catalog iar cele neingrosate sunt elemente catalog. Dependent de modul in care ati ales optiunile, pagina Categoria Palarii poate afisa doar intrarile pentru La moda si Palarii de lucru sau poate afisa intrarile pentru La moda, Palarii de lucru si toate palariile listate sub ele.</p>
<p>Puteti opta pentru afisarea elementelor in ordinea &quot;naturala&quot; (ex: ordinea de afisare a elementelor din ierarhia continut CMS), sau in ordine alfabetica.</P>
<p>Daca aveti un numar mare de elemente intr-o categorie, puteti stabili numarul maxim de elemente ce vor fi afisate intr-o pagina categorie si, pagina automat va crea legaturi prin care sa puteti naviga in cadrul listei.</p>
<p>Fiecare pagina categorie poate avea setari diferite pentru ordinea de sortare, nivelele afisate si numarul de elemente. Puteti seta valorile implicite pentru aceste valori in Extensii > Catalog > Getioneaza preferinte. Daca, ulterior doriti sa schimbati anumite setari pentru toate paginile categorii, puteti intra in Extensii > Catalog > Optiuni global catalog si sa efectuati acele schimbari.</p>
<h4>Imagini</h4>
<p>Catalogul va permite sa selectati imagini cu dimensiuni diferite pentru paginile element, paginile categorii si catalogul tiparibil. Puteti seta valorile lor implicite in Extensii > Catalog > Gestioneaza preferinte.</p>
<p>Cand incarcati imaginile, originalele se vor stoca. Cand cineva viziteaza o pagina, imaginile de dimensiuni reduse sunt accesate printr-o legatura URL speciala, care va redirectiona browser-ul utilizatorului la imaginea scalata, daca exista si o va crea daca aceasta nu exista. Prin aceasta aveti posibilitatea sa schimbati dimensiunile imaginilor fara a mai fi necesar sa incarcati sau sa scalati toate imaginile.</p>
<p>Acest cod de rescalare a imaginilor necesita sa aveti instalat si configurat fie ImageMagick fie GD.</p>
<h3>Lista facilitati</h3>
<p>Incepand cu versiunea 0.4, puteti avea &quot;lista facilitati&quot; care contine <i>n</i> elementele cel mai recent adaugate, sau o colectie de <i>k</i> elemente aleatoare din catalog.</p>
<h4>Lista facilitati &quot;All&quot; </h4>
<p>Pentru a obtine o lista a tuturor elementelor din catalog (optional sub o parte specifica din ierarhie) pentru a fi procesate prin sablon, puteti folosi lista facilitati &quot;All&quot;.</p>
<p>Sintaxa pentru o lista &quot;all&quot; este:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, unde sub_template este sablonul folosit pentru generarea listei.
Exista un parametru optional, alias=&#039;page_alias&#039;, unde page_alias indica varful arborelui (ex: o locatie in meniul ierarhie, tipic o pagina categorie) unde se vor cauta elementele noi. O valoare speciala pentru &quot;page_alias&quot; este &quot;/&quot;, care inseamna pornirea de la radacina.</p>
<p>Este utila pentru operatii variate asupra catalogului. De exemplu, pentru a obtine o lista a tuturor categoriilor (si a realiza ceva cu ele), puteti folosi eticheta {cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Sablonul dumneavoastra va putea atunci sa plaseze aceste categorii intr-un meniu contextual care va redirectat in acea pagina a categoriei, de exemplu:</p>
<pre>
<select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
<option value=&quot;&quot;>Alegeti o destinatie</option>
{foreach from=$items item=thisone}
   <option value=&quot;{$thisone.link}&quot;>{$thisone.title}</option>
{/foreach}
</select>
</pre>
<p>Daca doriti doar sa afisati categoriile din nivelul cel mai sus din ierarhie, inlocuiti recurse=&#039;categories_all&#039; cu
recurse=&#039;categories_one&#039;. Sau daca doriti toate elementele din catalog in loc de categorii, puteti folosi o eticheta ca aceasta:
{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similar, puteti alege sa listati doar categoriile din pagina curenta (prin omiterea &quot;alias=&#039;/&#039;&quot;). Combinatiile sunt practic nelimitate!</p>
<p>Toate valorile suportate de recurse sunt:<ul>
<li>items_one - Elemente catalog, nu mai mult de un nivel sub nivelul paginii curente (sau punct alias)</li>
<li>items_all - Elemente catalog, la orice nivel inferior paginii curente (sau punct alias)</li>
<li>categories_one - Categorii, nu mai mult de un nivel mai jos de cel al paginii curente (sau punct alias)</li>
<li>categories_all - Categorii, la orice nivel inferior paginii curente (sau punct alias)</li>
<li>mixed_one - Elemente si categorii catalog, nu mai mult de un nivel mai jos de cel al paginii curente (sau punct alias)</li>
<li>mixed_all - Elemente si categorii catalog, la orice nivel inferior paginii curente (sau punct alias)</li>
</ul>
</p>
<h4>Facilitatea Lista cel mai recent adaugate</h4>
<p>Prin folosirea listei &quot;cel mai recent adaugate&quot; veti obtine afisarea elementelor catalog cel mai recent adaugate sub o locatie specificata din ierarhie.</p>
<p>Sintaxa pentru lista &quot;cel mai recent adaugate&quot; este de forma:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, unde sub_template este sablonul folosit pentru generarea listei. Exista doi parametri optionali: count=&#039;3&#039; alias=&#039;page_alias&#039;, unde count reprezinta numarul elementelor incluse si page_alias indica varful arborelui (ex: o locatie in meniul ierarhie, tipic o pagina categorie) unde vor fi cautate elementele noi. O valoare speciala pentru &quot;page_alias&quot; este &quot;/&quot; si inseamna folosirea <i>tuturor</i> paginilor din site.</p>
<h4>Facilitatea Lista elemente aleatoare</h4>
<p>Sintaxa pentru o lista &quot;aleatoare&quot; este de forma:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, unde sub_template este sablonul folosit pentru generarea listei. Exista doi parametri optionali: count=&#039;3&#039; alias=&#039;page_alias&#039;, unde count reprezinta numarul elementelor incluse si page_alias indica varful arborelui (ex: o locatie in meniul ierarhie, tipic o pagina categorie) unde vor fi cautate elementele noi. O valoare speciala pentru &quot;page_alias&quot; este &quot;/&quot; si inseamna folosirea <i>tuturor</i> paginilor din site.</p>
<h3>Particularizare si subiecte avansate</h3>
<h4>Atribute element catalog</h4>
<p>Atributele implicite ale elementului sunt tipice pentru un catalog de produse de arta, dar daca mergei in Extensii > Catalog > Gestioneaza atribute definite de utilizator, puteti modifica atributele. Este recomandat ca sa definiti atributele inainte de introducerea elementelor catalog.</p>
<p>De mentionat ca atributele pe care le puteti defini pot necesita adaugarea lor in sablonul pe care-l folositi pentru afisarea elementelor catalog -- vezi mai jos Sabloane particularizate.</p>
<h4>Atribute categorii catalog</h4>
<p>Similar, puteti definit atribute pentru categorii. Din nou, atributele pe care le definiti pot necesita adaugarea lor la sablonul pe care-l folositi pentru afisarea categoriilor catalogului -- vezi mai jos Sabloane particularizate.</p>
<h4>Atribute catalog tiparibil</h4>
<p>La fel, puteti defini atribute pentru catalogul tiparibil. Din nou, atributele pe care le definiti pot necesita adaugarea lor la sablonul pe care-l folositi pentru afisarea categoriilor catalogului -- vezi mai jos Sabloane particularizate.</p>
<h4>Sabloane particularizate</h4>
<p>Daca doriti sa va jucati cu sabloane Smarty, puteti schimba organizarea oricarei pagini generate de catre Catalog. Aceasta ar putea face fericiti anumiti dezvoltatori chiar daca ineficienta restului de cod nu. Exista patru tipuri de sabloane: un tip pentru Elemente catalog, un tip pentru Categorii catalog, un tip pentru Catalog tiparibil si unul pentru liste &quot;Facilitati&quot; cum sunt cele mai recent adaugate elemente sau selectii aleatoare.</p>
<p>Cand editati un sablon, ecranul de administrare va afisa lista de etichete Smarty disponibile pentru acel tip de sablon. Aceasta va avea loc de indata ce modulul stie ce tip de sablon editati si atunci cand initial creati sablonul, va afisa toate etichetele Smarty pe care le cunoaste, fiind aplicabile doar o parte.</p>
<h4>Etichete Smarty in atribute</h4>
<p>Uneori veti dori ca descrierea elementelor dumneavoastra sa includa etichete Smarty (ex: cms_selflink). Pentru a face acest lucru posibil, va trebui sa actualizati sablonul dumneavoastra. Pentru atributele unde doriti ca etichetele Smarty sa fie active, va trebui sa incuibati evaluarile Smarty in sablonul dumneavoastra. De exemplu:</p>
<pre>
{eval var=$attrlist[at].key}
</pre>
<p>devine:</p>
<pre>
{eval var=$entry->input assign=thisAttr}{eval var=$thisAttr}
</pre>
<p>Urat? Da, dar functioneaza.</p>
<h3>Suport</h3>
<p>Acest modul nu include suport comercial. Totusi, exista un numar de resurse disponibile pentru a va fi de ajutor:</p>
<ul>
<li>Pentru ultima versiune a acestui modul, FAQ-uri, sau pentru a raporta un Bug, va rog sa vizitati pagina CMS Realizat Usor  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>Pentru a obtine suport comercial, trimiteti va rog un e-mail autorului la <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Discutii referitoare la acest modul pot fi gasite la <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>Autorul poate fi adesea gasit la <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>In final, puteti avea sansa de reusita contactand autorul printr-un e-mail si cerand ajutor gratuit.</li>
</ul>
<p>Referitor la GPL, acest soft este oferit asa cum este. Va rog sa cititi textul licentei pentru intreaga disculpare.</p>
<h3>Drept de copiere si licenta</h3>
<p>Copyright &copy; 2006, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. Toate drepturile sunt rezervate.</p>
<p>Acest modul a fost livrat sub <a href="http://www.gnu.org/licenses/licenses.html#GPL">Licenta publica GNU</a>. Trebuie sa fiti de acord cu aceasta inainte de folosirea modulului.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Asigurati-va ca ati setat permisiuni &quot;Modify Catalog Settings&quot; pentru utilizatorii care vor administra catalogul.';
$lang['utma'] = '156861353.1477009656.1272913798.1272913798.1274603745.2';
$lang['utmz'] = '156861353.1274603746.2.3.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=cms ms';
$lang['qca'] = 'P0-1739349973-1272913798681';
$lang['utmb'] = '156861353.2.10.1274603745';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/ru_RU.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Изображения';
$lang['deleteimage'] = 'Удалить изображение';
$lang['Owner'] = 'Владелец';
$lang['CatalogItem'] = 'Классификатор элементов';
$lang['namepage'] = 'Страница';
$lang['Permissions'] = 'Разрешения';
$lang['Sub'] = 'Подкатегории - ';
$lang['title_global_item_sort_order2'] = 'Порядок сортировки элементов';
$lang['title_global_items_per_page2'] = 'Элементов на страницу';
$lang['title_global_category_recurse2'] = 'Монитор поведения';
$lang['which_attributes'] = 'Какие атрибуты должны быть указаны в каталоге';
$lang['navTab'] = ' |  ';
$lang['needpermission'] = 'Вам необходимо %s установить для этого';
$lang['friendlyname'] = 'Классификатор';
$lang['admindescription'] = 'Управление настройками каталога';
$lang['areyousure'] = 'Вы уверены, что хотите удалить %s?';
$lang['uniquecode'] = 'Уникальный код';
$lang['templatelist'] = 'Шаблон подкатегорий';
$lang['listtempl'] = 'Управление шаблонами подкатегорий';
$lang['title_item_tab'] = 'Атрибуты элемента';
$lang['title_category_tab'] = 'Атрибуты категории';
$lang['title_printable_tab'] = 'Настройки печати';
$lang['title_item_image_tab'] = 'Размер изображения элемента';
$lang['title_category_image_tab'] = 'Настройки страницы категории';
$lang['title_is_textfield'] = 'Текстовое поле?';
$lang['title_delete'] = 'Удалить?';
$lang['title_aspect_tab'] = 'Пропорции изображения';
$lang['title_image_tab'] = 'Другие настройки изображений';
$lang['title_item_template_vars'] = 'Переменные шаблона элемента';
$lang['title_cat_template_vars'] = 'Переменные шаблона категории';
$lang['title_feature_template_vars'] = 'Переменные шаблона характеристик';
$lang['title_show_only_existing_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['cataloger'] = 'Классификатор';
$lang['item_page'] = 'Страница Элемента';
$lang['category_page'] = 'Страница Категории';
$lang['catalog_printable'] = 'Каталог для печати';
$lang['catalog_datasheet'] = 'Каталог спецификации';
$lang['catalog_short_list'] = 'Список компонентов';
$lang['title_global_item_sort_order'] = 'Установить сортировку элементов по';
$lang['title_global_items_per_page'] = 'Установить количество элементов на странице';
$lang['title_global_category_recurse'] = 'Set Category Display Behavior to';
$lang['title_item_sort_order'] = 'Сортировка элементов по умолчанию';
$lang['title_printable_sort_order'] = 'Default printable catalog sort order';
$lang['title_items_per_page'] = 'Количество элементов на странице по умолчанию';
$lang['title_avail_attrs'] = 'Атрибуты элемента доступные для шаблона';
$lang['title_avail_imattrs'] = 'Изображения элемента доступные для шаблона';
$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'] = 'Шаблон';
$lang['title_template_type'] = 'Тип Шаблона';
$lang['title_title'] = 'Название';
$lang['title_item_image_count'] = 'Maximum number of views for each Item';
$lang['title_category_image_count'] = 'Maximum number of Banner images for each Category Page';
$lang['title_item_attributes_help'] = 'Каждый атрибут введённый здесь будет названием поля, которое можно использовать для описания отдельного элемента, и будут показаны вместе с ним. Возможно, вам придется обновить свой шаблон, чтобы отобразить эти атрибуты.';
$lang['title_category_attributes_help'] = 'Каждый атрибут введённый здесь будет названием места, которое можно использовать для описания категории, и будет показано на странице этой категории. Возможно, вам придется обновить свой шаблон, чтобы отобразить эти атрибуты.';
$lang['title_catalog_attributes_help'] = 'Каждый атрибут введённый здесь будет названием места, которое можно использовать для описания всего каталога, который будет отображаться на странице каталога печати. Возможно, вам придется обновлять свой шаблон, чтобы отобразить эти атрибуты.';
$lang['title_force_aspect_ratio'] = 'Force images to a specified Aspect ratio?';
$lang['title_force_aspect_ratio_label'] = 'Force aspect ratio (not yet implemented)';
$lang['title_image_aspect_ratio'] = 'Aspect ratio (specify as "4:3" or "1:2.5")';
$lang['title_aspect_ratio_help'] = 'If you force an image to a specified aspect ratio, it will be scaled to fit exactly that aspect ratio (or its inverse, so you can have both portrait and landscape formats). Otherwise, images will preserve their aspect ratio, and be scaled so their long axis is the size specified. <b>this is not yet implemented!</b>';
$lang['title_category_sort'] = 'Category Page Item-list sort order';
$lang['title_category_recurse'] = 'Default Category Display Behavior';
$lang['title_category_recurse_items_all'] = 'Включить все элементы в рамках данной категории, в том числе элементы в подкатегории';
$lang['title_category_recurse_items_one'] = 'Включить все элементы непосредственно этой категории, но не элементы в подкатегории';
$lang['title_category_recurse_categories_all'] = 'Включение всех категорий в рамках этой категории, в том числе в категории подкатегории';
$lang['title_category_recurse_categories_one'] = 'Включение всех категорий непосредствено этой категории, но не включая категории подкатегории';
$lang['title_category_recurse_mixed_all'] = 'Включить все элементы и категории в этой категории, в том числе элементы и категории в подкатегории';
$lang['title_category_recurse_mixed_one'] = 'Включить все элементы и категории непосредственно этой категории, но не элементы или категорий в подкатегории';
$lang['title_show_missing_images'] = 'Показывать "No Image" для отсутсвующих изображений';
$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'] = 'Настройки';
$lang['manageattrs'] = 'Управление Атрибутами';
$lang['globalops'] = 'Общии операции с каталогом';
$lang['addtemplate'] = 'Добавить шаблон';
$lang['reimporttemplates'] = 'Вернуть демонстрационные шаблоны';
$lang['reimported'] = 'Демонстрационные шаблоны подкатегорий успешно импортированы';
$lang['templateupdated'] = 'Шаблон добавлен / обновлён';
$lang['templatedeleted'] = 'Шаблон удален';
$lang['prefsupdated'] = 'Настройки обновлены';
$lang['installed'] = 'Модуль версии %s установлен';
$lang['upgraded'] = 'Модуль обновлен до версии %s.';
$lang['uninstalled'] = 'Модуль удален';
$lang['attrsupdated'] = 'Атрибуты обновлены';
$lang['noglobalchange'] = '<Не выбрано>';
$lang['globallyupdated'] = 'Изменения распространяются на глобальном уровне';
$lang['edittemplate'] = 'Изменить шаблон';
$lang['subtemplates'] = 'Каталог шаблонов подкатегорий';
$lang['next'] = ':»';
$lang['prev'] = '«:';
$lang['edit'] = 'Редактировать';
$lang['delete'] = 'Удалить';
$lang['notemplates'] = 'Нет установленных шаблонов подкатегорий';
$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 > Pages > 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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>
<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>{cms_module module=\'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 {cms_module module=\'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>
<select name="foo" onchange="document.location=this.options[this.selectedIndex].value;">
<option value="">Select A target</option>
{foreach from=$items item=thisone}
   <option value="{$thisone.link}">{$thisone.title}</option>
{/foreach}
</select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, 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:
{cms_module module=\'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>
<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>{cms_module module=\'Cataloger\' action=\'recent\' 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>Random Items Feature List</h4>
<p>The syntax for a "random" list is like:</p>
<p>{cms_module module=\'Cataloger\' 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>
<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 > Cataloger > 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>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>
{eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
{eval var=$entry->input assign=thisAttr}{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&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 &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
</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"><sjg@cmsmodules.com></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 © 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. 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['changelog'] = '<ul>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from "content" to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don\'t get "lost" when page alias changes.</li>
<li>Bug fix: Attribute content doesn\'t get "lost" when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for \'recent\' action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added "all" feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added "/" page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Убедитесь в том, чтобы были установленны права на "Изменение настройки каталога" для пользователей, которые будут управлять каталогом.';
$lang['utmz'] = '156861353.1237555608.29.24.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,27626.0.html|utmcmd=referral';
$lang['utma'] = '156861353.1512485689.1236874721.1237555608.1237558117.30';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sk_SK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Obr&aacute;zky';
$lang['deleteimage'] = 'Odstr&aacute;niť obr&aacute;zkom';
$lang['Owner'] = 'Vlastn&iacute;k';
$lang['CatalogItem'] = 'Item Cataloger';
$lang['namepage'] = 'Strana';
$lang['Permissions'] = 'Opr&aacute;vnenia';
$lang['Sub'] = 'Pod -';
$lang['title_global_item_sort_order2'] = 'Triedenie položiek';
$lang['title_global_items_per_page2'] = 'Položiek na str&aacute;nku';
$lang['title_global_category_recurse2'] = 'Zobraziť spr&aacute;vanie';
$lang['which_attributes'] = 'Which attributes should be shown in catalog';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'Potrebujete nastaviť %s pre t&uacute;to akciu.';
$lang['friendlyname'] = 'Kataloger';
$lang['admindescription'] = 'Upraviť nastavenia katal&oacute;gu';
$lang['areyousure'] = 'Ste rozhodnut&iacute; zmazať %s?';
$lang['uniquecode'] = 'Unik&aacute;tny k&oacute;d';
$lang['templatelist'] = 'Pod&scaron;ablony';
$lang['listtempl'] = 'Upraviť pod&scaron;ablony';
$lang['title_item_tab'] = 'Atrib&uacute;ty položiek';
$lang['title_category_tab'] = 'Atrib&uacute;ty kateg&oacute;rie';
$lang['title_printable_tab'] = 'Nastavenie str&aacute;nky pre tlač';
$lang['title_item_image_tab'] = 'Veľkosť obr&aacute;zku položky';
$lang['title_category_image_tab'] = 'Nastavenie str&aacute;nky kateg&oacute;ri&iacute;';
$lang['title_is_textfield'] = 'Textov&aacute; oblasť?';
$lang['title_delete'] = 'Odstr&aacute;niť?';
$lang['title_aspect_tab'] = 'Pomer str&aacute;n obr&aacute;zku';
$lang['title_image_tab'] = 'Ďal&scaron;ie nastavenia pre obr&aacute;zok';
$lang['title_item_template_vars'] = 'Premenn&eacute; &scaron;ablony položky';
$lang['title_cat_template_vars'] = 'Premenn&eacute; &scaron;ablony kategorie';
$lang['title_feature_template_vars'] = 'Features Template Variables';
$lang['title_show_only_existing_images'] = 'Don&#039;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['cataloger'] = 'Kataloger';
$lang['item_page'] = 'Str&aacute;nka položky';
$lang['category_page'] = 'Str&aacute;nka kateg&oacute;rie';
$lang['catalog_printable'] = 'Katal&oacute;g na vytlačenie';
$lang['catalog_datasheet'] = 'Tabuľka katalogu';
$lang['catalog_short_list'] = 'Feature List';
$lang['title_global_item_sort_order'] = 'Nastaviť triedenie položiek';
$lang['title_global_items_per_page'] = 'Nastaviť počet položiek na str&aacute;nku';
$lang['title_global_category_recurse'] = 'Nastaviť popisok kateg&oacute;rie';
$lang['title_item_sort_order'] = 'Z&aacute;kladn&eacute; nastavenie triedenia položiek';
$lang['title_printable_sort_order'] = 'Predvolen&eacute; triedenie tlačen&eacute;ho katal&oacute;gu';
$lang['title_items_per_page'] = 'Predvolen&yacute; počet položiek na str&aacute;nku';
$lang['title_avail_attrs'] = 'Atrib&uacute;ty položky použiteľn&eacute; pre &scaron;ablonu';
$lang['title_avail_imattrs'] = 'Obr&aacute;zky položky použiteľn&eacute; pre &scaron;ablonu';
$lang['title_item_image_size_hero'] = 'Veľkosť obr&aacute;zku v str&aacute;nke položky (dlh&scaron;ia strana v pixeloch)';
$lang['title_item_image_size_thumbnail'] = 'Veľkosť n&aacute;hľadu položky v str&aacute;nke položky (dlh&scaron;ia strana v pixeloch)';
$lang['title_item_image_size_category'] = 'Veľkosť n&aacute;hľadu položky v kategoriach (dlh&scaron;ia strana v pixeloch)';
$lang['title_item_image_size_catalog'] = 'Veľkosť obr&aacute;zku položky v katalogu (dlh&scaron;ia strana v pixeloch)';
$lang['title_category_image_size_hero'] = 'Veľkosť obr&aacute;zku v str&aacute;nke kateg&oacute;rie (dlh&scaron;ia strana v pixeloch)';
$lang['title_category_image_size_thumbnail'] = 'Veľkosť n&aacute;hľadu v str&aacute;nke kateg&oacute;rie (dlh&scaron;ia strana v pixeloch)';
$lang['title_template'] = '&Scaron;ablona';
$lang['title_template_type'] = 'Typ &scaron;ablony';
$lang['title_title'] = 'Titulok';
$lang['title_item_image_count'] = 'Maxim&aacute;lny počet zobrazen&iacute; každej položky';
$lang['title_category_image_count'] = 'Maxim&aacute;lny počet zobrazen&iacute; baneru pre každ&uacute; str&aacute;nku kateg&oacute;rie';
$lang['title_item_attributes_help'] = 'Každ&yacute; atrib&uacute;t, ktor&yacute; tu zad&aacute;te bude titulok poľa, ktor&yacute; možete použiť na popis jednotlivej položky, a bude zobrazen&yacute; s touto položkou. M&ocirc;žete upraviť va&scaron;e &scaron;ablony pre použitie t&yacute;chto atributov. Nap&iacute;&scaron;te nov&yacute;, alebo prep&iacute;&scaron;te už existuj&uacute;ci atrib&uacute;t.';
$lang['title_category_attributes_help'] = 'Každ&yacute; atrib&uacute;t, ktor&yacute; tu zad&aacute;te bude titulok poľa, ktor&yacute; možete použiť na popis položky kategorie a bude zobrazen&yacute; na str&aacute;nke kategorie. M&ocirc;žete upraviť va&scaron;e &scaron;ablony pre použitie t&yacute;chto atributov. Nap&iacute;&scaron;te nov&yacute;, alebo prep&iacute;&scaron;te už existuj&uacute;ci atrib&uacute;t.';
$lang['title_catalog_attributes_help'] = 'Každ&yacute; atrib&uacute;t, ktor&yacute; tu zad&aacute;te bude titulok poľa, ktor&yacute; možete použiť na popis cel&eacute;ho katalogu, a bude zobrazen&yacute; na tlačenej str&aacute;nke katalogu. M&ocirc;žete upraviť va&scaron;e &scaron;ablony pre použitie t&yacute;chto atributov. Nap&iacute;&scaron;te nov&yacute;, alebo prep&iacute;&scaron;te už existuj&uacute;ci atrib&uacute;t.';
$lang['title_force_aspect_ratio'] = 'Upraviť obr&aacute;zky na &scaron;pecifick&yacute; pomer str&aacute;n?';
$lang['title_force_aspect_ratio_label'] = 'Upraviť pomer str&aacute;n (e&scaron;te nie je implementovan&eacute;)';
$lang['title_image_aspect_ratio'] = 'Pomer str&aacute;n (nastavte napr. &quot;4:3&quot; alebo &quot;1:2.5&quot;)';
$lang['title_aspect_ratio_help'] = 'Ak nastav&iacute;te obr&aacute;zok na &scaron;pecifick&yacute; pomer str&aacute;n, bude upraven&yacute; na presn&yacute; pomer str&aacute;n (alebo jeho opak, takže m&ocirc;žete mať portr&eacute;t, aj obr&aacute;zok krajiny). Obr&aacute;zky bud&uacute; upraven&eacute; na veľkosť podľa &scaron;pecifik&aacute;cie dlh&scaron;ej strany. <b>toto e&scaron;te nie je implementovan&eacute;!</b>';
$lang['title_category_sort'] = 'Str&aacute;nka kategorie, List položiek triedenie';
$lang['title_category_recurse'] = 'Z&aacute;kladn&eacute; nastavenie zobrazovania kategorie';
$lang['title_category_recurse_items_all'] = 'Vr&aacute;tane v&scaron;etk&yacute;ch položiek v tejto kategorii, vr&aacute;tane položiek v podkategoriach';
$lang['title_category_recurse_items_one'] = 'Vr&aacute;tane v&scaron;etk&yacute;ch položiek priamo v tejto kategorii, ale nie položky v podkategoriach';
$lang['title_category_recurse_categories_all'] = 'Vr&aacute;tane v&scaron;etk&yacute;ch kategorii v tejto kategorii, vr&aacute;tane položiek v podkategoriach';
$lang['title_category_recurse_categories_one'] = 'Vr&aacute;tane v&scaron;etk&yacute;ch kategorii priamo v tejto kategorii, ale nie kategorie v podkategoriach';
$lang['title_category_recurse_mixed_all'] = 'Vr&aacute;tane v&scaron;etk&yacute;ch položiek a kategorii v tejto kategorii, vr&aacute;tane položiek a kategorii v podkategoriach';
$lang['title_category_recurse_mixed_one'] = 'Vr&aacute;tane v&scaron;etk&yacute;ch položiek a kategorii priamo v tejto kategorii, ale nie položky, alebo kategorie v podkategoriach';
$lang['title_show_missing_images'] = 'Show &quot;No Image&quot; image for missing images';
$lang['title_show_missing_images_long'] = 'Show a special &quot;No Image&quot; image if there are missing images (useful for debugging. Otherwise will use a single pixel transparent image).';
$lang['natural_order'] = 'Triedenie podľa navig&aacute;cie';
$lang['alpha_order'] = 'Triedenie podľa abecedy';
$lang['manageprefs'] = 'Nastaviť predvoľby';
$lang['manageattrs'] = 'Nastaviť použ&iacute;vateľsk&eacute; atrib&uacute;ty';
$lang['globalops'] = 'Glob&aacute;lne nastavenie katal&oacute;gu';
$lang['addtemplate'] = 'Pridať nov&uacute; pod&scaron;ablonu';
$lang['reimporttemplates'] = 'Znovu importovať pr&iacute;klady pod&scaron;ablon';
$lang['reimported'] = 'Pr&iacute;klady pod&scaron;ablon boli importovan&eacute;.';
$lang['templateupdated'] = '&Scaron;ablona pridan&aacute;/upraven&aacute;.';
$lang['templatedeleted'] = '&Scaron;ablona bola zmazan&aacute;.';
$lang['prefsupdated'] = 'NAstavenia boli upraven&eacute;.';
$lang['installed'] = 'Modul verzie %s nain&scaron;talovan&yacute;.';
$lang['upgraded'] = 'Modul upgradovan&yacute; na verziu %s.';
$lang['uninstalled'] = 'Modul odin&scaron;talovan&yacute;.';
$lang['attrsupdated'] = 'Atrib&uacute;ty boli upraven&eacute;.';
$lang['noglobalchange'] = 'Nemeniť';
$lang['globallyupdated'] = 'Zmeny boli vykonan&eacute; glob&aacute;lne.';
$lang['edittemplate'] = 'Upraviť &scaron;abl&oacute;nu';
$lang['subtemplates'] = 'Katal&oacute;gov&eacute; Sub-&scaron;abl&oacute;ny';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'Upraviť';
$lang['delete'] = 'Odstr&aacute;niť';
$lang['notemplates'] = 'Žiadne pod&scaron;ablony neboli nain&scaron;talovan&eacute;!';
$lang['helptext'] = '<h3>Čo rob&iacute; tento modul?</h3>
<p>Tento modul V&aacute;m umožn&iacute; vytvoriť online katalogy, alebo portfolia. Katalogy obsahuj&uacute; &quot;Položky katalogu&quot;, ktor&eacute; m&ocirc;žu byť produkty, umeleck&eacute; diela, alebo čo chcete, a &quot;Kategorie katalogu&quot;, ktor&eacute; m&ocirc;žu byť položky katalogu, alebo in&eacute; prirodzen&eacute; členenie katalogu</p>
<p>Kategorie m&ocirc;žu byť hierarchicky definovan&eacute; (ako &scaron;tandartn&yacute; CMS Made Simple zoznam obsahu). Str&aacute;nky kategorie m&ocirc;žu zobrazovať položky v kategorii a/alebo podkategoriach, voliteľne aj vo v&scaron;etk&yacute;ch podkategoriach. T&aacute;to voľba m&ocirc;že byť nastaven&aacute; v nastaven&iacute; kategorii.</P>
<p>Je tu tiež tlačen&yacute; katalog, ktor&yacute; obsahuje pln&uacute; kolekciu položiek katalogu na jednej str&aacute;nke.</p>
<p>Modul spolupracuje s &quot;Content Aliases&quot; (modul dostupn&yacute; na <a href="http://www.cmsmodules.com/ContentAliases.html">CMSModules.com</a>), ktor&yacute; V&aacute;m umožn&iacute; vložiť položky katalogu do viacer&yacute;ch kategorii.</p>
<h3>Ako ho použijem?</h3>
<p>Keď ste nain&scaron;talovali tento modul, vytvorili sa tri nov&eacute; typy obsahu: Položky katalogu, Kategorie katalogu, a Katalog na tlač. Keď ste na str&aacute;nke administr&aacute;cie kategorie, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; from the Content Type pulldown.</p>
<h4>Položky katalogu</h4>
<p>Pridať položku do katalogu je podobn&eacute;, ako pridať str&aacute;nku do va&scaron;ej prezent&aacute;cie. Av&scaron;ak datov&eacute; polia pre položku nie s&uacute; &uacute;plne rovnak&eacute;. Daľ&scaron;ia pozn&aacute;mka, že v &quot;Images&quot; z&aacute;ložke m&ocirc;žete vybrať nahrať viac obr&aacute;zkov pre položku. Keď nahr&aacute;te obr&aacute;zky, syst&eacute;m uprav&iacute; ich veľkosť pre použitie v katalogu, vytvor&iacute; n&aacute;hľady pre použitie v str&aacute;nke položky, vytvor&iacute; n&aacute;hľady pre str&aacute;nku kategorii ... a je to. Vyžaduje si to, že m&aacute;te in&scaron;talovan&uacute; GD kližnicu, alebo podobn&uacute; pre pr&aacute;cu s obr&aacute;zkami. Aktu&aacute;lne je iba JPG form&aacute;t podporovan&yacute;.</p>
<h4>Kategorie katalogu</h4>
<p>Kategorie s&uacute; použit&eacute; pre zorganizovanie Va&scaron;&iacute;ch položiek. Vytvor&iacute; to str&aacute;nku obsahuj&uacute;cu zoznam položiek. Položka katalogu je považovan&aacute; za s&uacute;časť kategorie katalogu, ak je pod touto kategoriou v hierarchi webu. Kategorie m&ocirc;žu podobne obsahovať daľ&scaron;ie kategorie.</p>
<p>Kategorie katalogu maj&uacute; veľa nastaven&iacute; ako ovplyvniť zobrazenie položiek a kategorii, ktor&eacute; obsahuj&uacute;: ak sa pozriete na &quot;Nastaviť predvoľby&quot; z&aacute;ložku, m&ocirc;žete si vybrať koľko položiek a/alebo kategorii sa m&aacute; zobraziť, v akom trieden&iacute; sa maj&uacute; zobrazovať, či sa maj&uacute; zobrazovať iba položky, alebo iba kategorie, alebo oboje, a koľko stupňov v hierarchii sa m&aacute; zobraziť pod str&aacute;nkou kategorie.</p>
<h3>Nastavenie a daľ&scaron;ie inform&aacute;cie</h3>
<h4>Atrib&uacute;ty položky katalogu</h4>
<p>Z&aacute;kladn&eacute; atrib&uacute;ty položky s&uacute; typick&eacute; pre katalog produktov, alebo umeleck&yacute;ch diel, ale m&ocirc;žete &iacute;sť do Roz&scaron;&iacute;renia > Cataloger > Manage Nastaviť použ&iacute;vateľsk&eacute; atrib&uacute;ty, kde m&ocirc;žete zmeniť atrib&uacute;ty. Je to najlep&scaron;ie miesto pre defin&iacute;ciu atrib&uacute;tov
<h4>Atrib&uacute;ty kategorie katalogu</h4>
<h4>Už&iacute;vateľsk&eacute; &scaron;abl&oacute;ny</h4>
<p></p>
<h3>Podpora</h3>
<p>Tento modul neobsahuje komerčn&uacute; podporu. Ale existuje viacej možnost&iacute;, ako si m&ocirc;žete pom&ocirc;cť:</p>
<ul>
<li>Pre posledn&eacute; verzie tohto modulu, FAQs, alebo s&uacute;bory a chybov&eacute; hl&aacute;senia,  alebo pre komerčn&uacute; podporu, pros&iacute;m nav&scaron;t&iacute;vte SjG&#039;s
module dom&aacute;cu str&aacute;nku na <a href="http://www.cmsmodules.com">CMSModules.com</a>.</li>
<li>Daľ&scaron;ia diskusia k tomuto modulu m&ocirc;že byť najden&aacute; na <a href="http://forum.cmsmadesimple.org">CMS Made Simple F&oacute;rum</a>.</li>
<li>Autor, SjG, m&ocirc;že byť často n&aacute;jden&yacute; na <a href="irc://irc.freenode.net/#cms">CMS IRC Kan&aacute;li</a>.</li>
<li>Nakoniec, m&ocirc;žete priamo autorovi niečo nap&iacute;sať emailom.</li>  
</ul>
<p>Ako pre GPL, aj tento software je vytvoren&yacute; tak, ako-je. Pros&iacute;m č&iacute;tajte zvy&scaron;ok licencie
pre pln&eacute; pochopenie.</p>
<h3>Vlastn&iacute;cke pr&aacute;va a licencia</h3>
<p>Copyright &copy; 2005, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. V&scaron;etky pr&aacute;va vyhraden&eacute;.</p>
<p>Tento modul bol vydan&yacute; pod <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>.Mus&iacute;te s&uacute;hlasiť s touto licenciou, predt&yacute;m, ako ho použijete.</p>';
$lang['changelog'] = '<li>Verzia 0.1.5 - 17 November 2005. Prv&aacute; verzia. Ježi&scaron;i, to trvalo dlho.</li>
<li>Verzia 0.1 - 19 Marec 2005. Začiatok projektu.</li>
</ul>';
$lang['postinstall'] = 'Uistite sa, že ste nastavili &quot;Modify Catalog Settings/Upraviť nastavenia Katal&oacute;gu&quot; opr&aacute;vnenia pre už&iacute;vateľov, ktor&iacute; bud&uacute; nastavovať katal&oacute;g.';
$lang['utmz'] = '156861353.1215854861.352.64.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utma'] = '156861353.1344409053.1180802494.1217201473.1217279900.389';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.1.10.1217279900';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sv_SE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Bilder';
$lang['namefiles'] = 'Filer';
$lang['namefile'] = 'Fil';
$lang['deleteimage'] = 'Radera bild';
$lang['deletefile'] = 'Radera fil';
$lang['Owner'] = '&Auml;garen';
$lang['CatalogItem'] = 'Artikelkatalog';
$lang['namepage'] = 'Sida';
$lang['Permissions'] = 'Beh&ouml;righeter';
$lang['Sub'] = 'Sub  -';
$lang['title_global_item_sort_order2'] = 'Objekt sorteringsordning';
$lang['title_global_items_per_page2'] = 'Antal objekt per sida';
$lang['title_global_category_recurse2'] = 'Display Behavior';
$lang['which_attributes'] = 'Vilka attributer ska visas i katalogen';
$lang['navTab'] = '  | ';
$lang['needpermission'] = 'Du beh&ouml;ver ha %s inst&auml;lld f&ouml;r att g&ouml;ra s&aring;.';
$lang['friendlyname'] = 'Cataloger Modulen';
$lang['admindescription'] = 'Hantera kataloginst&auml;llningarna';
$lang['areyousure'] = '&Auml;r du s&auml;ker p&aring; att du vill radera denna %s?';
$lang['uniquecode'] = 'Unik kod';
$lang['templatelist'] = 'Sub-mallar';
$lang['listtempl'] = 'Hantera sub-mallar';
$lang['title_item_tab'] = 'Artikel attributer';
$lang['title_category_tab'] = 'Kategori attributer';
$lang['title_printable_tab'] = 'Printable Kataloginst&auml;llningar';
$lang['title_item_image_tab'] = 'Artikelns bildstorlekar';
$lang['title_category_image_tab'] = 'Kategorisidan inst&auml;llningar';
$lang['title_path_tab'] = 'S&ouml;kv&auml;gar';
$lang['title_is_textfield'] = 'Textyta?';
$lang['title_delete'] = 'Radera?';
$lang['title_file_tab'] = 'Item File Settings';
$lang['title_image_tab'] = 'Andra bildinst&auml;llningar';
$lang['title_item_template_vars'] = 'Objektmalls variabler';
$lang['title_cat_template_vars'] = 'Kategorimalls variabler';
$lang['title_catalog_template_vars'] = 'Catalog Template Variables';
$lang['title_compare_template_vars'] = 'Comparison Template Variables';
$lang['title_feature_template_vars'] = 'Funktionsmalls variabler';
$lang['title_show_only_existing_images'] = 'Don&#039;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'] = 'Till&aring;tna filtyper';
$lang['title_image_upload_path'] = 'Plats f&ouml;r uppladdade bildfiler';
$lang['title_file_upload_path'] = 'Plats f&ouml;r andra uppladdade filer';
$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 (Katalog)';
$lang['title_attr_order_by'] = 'Ordning';
$lang['title_attr_alias'] = 'Attribute Alias (Smarty Friendly)';
$lang['title_attr_length'] = 'L&auml;ngd*';
$lang['title_attr_default'] = 'Standardv&auml;rde';
$lang['title_attr_length_help'] = '(*L&auml;ngd g&auml;ller inte f&ouml;r Text Areas)';
$lang['item_page'] = 'Objekt sida';
$lang['category_page'] = 'Kategorisida';
$lang['catalog_printable'] = 'Utskrivbar Katalog';
$lang['catalog_datasheet'] = 'Katalog Datablad';
$lang['catalog_short_list'] = 'Funktionslista';
$lang['item_comparison'] = 'Item Comparison';
$lang['title_global_item_sort_order'] = 'Ange sorteringsordningen f&ouml;r objekt till';
$lang['title_global_items_per_page'] = 'Ange antal objekt per sida';
$lang['title_global_category_recurse'] = 'St&auml;ll in kategorivisnings beteende till';
$lang['title_item_sort_order'] = 'Standard sorteringsordning f&ouml;r Objekt';
$lang['title_printable_sort_order'] = 'Standard sorteringsordning f&ouml;r utskirvbar katalog';
$lang['title_items_per_page'] = 'Standardantal med artiklar f&ouml;r varje sida';
$lang['title_avail_attrs'] = 'Objektattribut tillg&auml;ngliga f&ouml;r mallen';
$lang['title_avail_imattrs'] = 'Objektbilder tillg&auml;ngliga f&ouml;r mallen';
$lang['title_item_image_size_hero'] = 'Bildstorlek f&ouml;r Objektsidan (l&auml;ngdriktning i bildpunkter)';
$lang['title_item_image_size_thumbnail'] = 'Thumbnailstorlek f&ouml;r Objektsidan (l&auml;ngdriktning i bildpunkter)';
$lang['title_item_image_size_category'] = 'Thumbnailstorlek f&ouml;r objekt p&aring; Kategorisida (l&auml;ngdriktning i bildpunkter)';
$lang['title_item_image_size_catalog'] = 'Thumbnailstorlek f&ouml;r objekt p&aring; Katalogsida (l&auml;ngdriktning i bildpunkter)';
$lang['title_category_image_size_hero'] = 'Bildstorlek f&ouml;r Kategorisida (l&auml;ngdriktning i bildpunkter)';
$lang['title_category_image_size_thumbnail'] = 'Thumbnailstorlek f&ouml;r Kategorisida (long axis in pixels)';
$lang['title_template'] = 'Mall';
$lang['title_template_type'] = 'Mall typ';
$lang['title_title'] = 'Titel';
$lang['title_item_image_count'] = 'H&ouml;gsta antal visningar f&ouml;r varje Artikel';
$lang['title_item_file_count'] = 'Maximum number of other files associated with each item';
$lang['title_category_image_count'] = 'Maximalt antal Bannerbilder f&ouml;r varje kategorisida';
$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'] = 'Sorteringsordning av Objekt-listan p&aring; Kategorisidan';
$lang['title_category_recurse'] = 'Default Category Display Behavior';
$lang['title_category_recurse_items_all'] = 'Inkludera alla poster i den h&auml;r kategorin, inklusive poster i sub-kategorier';
$lang['title_category_recurse_items_one'] = 'Inkludera alla objekt omedelbart inom denna kategori, men inte poster i sub-kategorier';
$lang['title_category_recurse_categories_all'] = 'Include all Categories within this category, including categories i sub-categories';
$lang['title_category_recurse_categories_one'] = 'Inkludera alla kategorier inom denna kategori, &auml;ven kategorier i sub-kategorier';
$lang['title_category_recurse_mixed_all'] = 'Inkludera alla objekt och kategorier inom denna kategori, &auml;ven artiklar och kategorier i sub-kategorier';
$lang['title_category_recurse_mixed_one'] = 'Inkludera alla objekt och kategorier omedelbart inom denna kategori, men inte objekt eller kategorier i sub-kategorier';
$lang['title_show_missing_images'] = 'Visa &quot;Ingen bild&quot; bilden f&ouml;r objekt utan bilder';
$lang['title_show_missing_images_long'] = 'Show a special &quot;No Image&quot; image if there are missing images (useful for debugging. Otherwise will use a single pixel transparent image).';
$lang['natural_order'] = 'Navigationsordning';
$lang['alpha_order'] = 'Alfabetiskordning';
$lang['manageprefs'] = 'Hantera inst&auml;llningar';
$lang['manageattrs'] = 'Hantera Anv&auml;ndarattributer';
$lang['globalops'] = 'Globala Katalog Operationer';
$lang['addtemplate'] = 'L&auml;gg till mall';
$lang['reimporttemplates'] = '&Aring;terimportera exempel sub-mallarna ';
$lang['reimported'] = 'Prov submallarna har importerats.';
$lang['templateupdated'] = 'Mallen tillagd/uppdaterad';
$lang['templatedeleted'] = 'Mallen raderad.';
$lang['prefsupdated'] = 'Inst&auml;llningarna uppdaterade.';
$lang['installed'] = 'Modul version %s installerad';
$lang['upgraded'] = 'Modulen uppgraderad till version %s.';
$lang['badfile'] = 'Fil &quot;%s&quot; &auml;r inte ett till&aring;tet format';
$lang['badimage'] = 'Problem med uppladdning av &quot;%s&quot; (kontrollera filstorlek och/eller server r&auml;ttigheter).';
$lang['badimageformat'] = '&quot;%s&quot; &auml;r inte giltig. Endast jpegs st&ouml;ds f&ouml;r tillf&auml;llet.';
$lang['uploaded'] = 'File &quot;%s&quot; uploaded for item %s.';
$lang['uninstalled'] = 'Modulen avinstallerad.';
$lang['attrsupdated'] = 'Attributer uppdaterade.';
$lang['noglobalchange'] = '&Auml;ndra inte';
$lang['globallyupdated'] = 'Globala f&ouml;r&auml;ndringar gjordes';
$lang['edittemplate'] = '&Auml;ndra mall';
$lang['subtemplates'] = 'Katalog Submallar';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = '&Auml;ndra';
$lang['delete'] = 'Radera';
$lang['notemplates'] = 'Inga submallar installerade';
$lang['helptext'] = '<h3>What Does This Do?</h3>
<p>This module lets you create online catalogs or portfolios. Catalogs consist of &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 {cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
<select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
<option value=&quot;&quot;>Select A target</option>
{foreach from=$items item=thisone}
   <option value=&quot;{$thisone.link}&quot;>{$thisone.title}</option>
{/foreach}
</select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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>{cms_module module=&#039;Cataloger&#039; action=&#039;variable&#039; name=&#039;itemnotes&#039; default=&#039;no notes&#039;}, 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>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
{eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
{eval var=$entry->input assign=thisAttr}{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 &quot;itemname_f_1_400_1.jpg&quot; - 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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</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"><sjg@cmsmodules.com></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; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. 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['changelog'] = '<ul>
<li>Version 0.7.1 - 29 Sept 2008. Added Variable method for Javier San Juan Costilas.</li>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Make sure to set the &quot;Modify Catalog Settings&quot; permission on users who will be administering the catalog.';
$lang['qca'] = 'P0-1231872325-1269359321195';
$lang['utma'] = '156861353.1269777603.1269359342.1269359342.1269359342.1';
$lang['utmb'] = '156861353.1.10.1269359342';
$lang['utmc'] = '156861353';
$lang['utmz'] = '156861353.1269359342.1.1.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=cmsms';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/tr_TR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['nameimages'] = 'Resimler';
$lang['namefiles'] = 'Dosyalar';
$lang['namefile'] = 'Dosya';
$lang['deleteimage'] = 'Resimleri Sil';
$lang['deletefile'] = 'Dosya Sil';
$lang['Owner'] = 'Sahip';
$lang['CatalogItem'] = '&Uuml;r&uuml;n Kataloğu';
$lang['namepage'] = 'Sayfa';
$lang['Permissions'] = 'İzinler';
$lang['Sub'] = 'Alt -';
$lang['title_global_item_sort_order2'] = '&Uuml;r&uuml;n Sıralama';
$lang['title_global_items_per_page2'] = 'Sayfadaki &Uuml;r&uuml;n Sayısı';
$lang['title_global_category_recurse2'] = 'G&ouml;sterim durumu';
$lang['which_attributes'] = 'Hangi &ouml;zellikler katalogta g&ouml;sterilecek';
$lang['navTab'] = ' | ';
$lang['needpermission'] = 'You need %s set to do that.';
$lang['friendlyname'] = 'Katalog';
$lang['admindescription'] = 'Katalog Ayarları Y&ouml;netimi';
$lang['areyousure'] = 'Silmek istediğinize emin misiniz %s?';
$lang['uniquecode'] = 'Benzersiz Kod';
$lang['templatelist'] = 'Alt-şablonlar';
$lang['listtempl'] = 'Alt-şablon Y&ouml;netimi';
$lang['title_item_tab'] = '&Uuml;r&uuml;n Nitelikleri';
$lang['title_category_tab'] = 'Kategori Nitelikleri';
$lang['title_printable_tab'] = 'Yazdırılabilir Katalog Ayarları';
$lang['title_item_image_tab'] = '&Uuml;r&uuml;n Resim Boyutları';
$lang['title_category_image_tab'] = 'Kategori Sayfası Ayarları';
$lang['title_path_tab'] = 'Paths';
$lang['title_is_textfield'] = 'Yazı Alanı?';
$lang['title_delete'] = 'Sil?';
$lang['title_file_tab'] = 'Item File Settings';
$lang['title_image_tab'] = 'Diğer Resim Ayarları';
$lang['title_item_template_vars'] = '&Uuml;r&uuml;n Şablonu Değişkenleri';
$lang['title_cat_template_vars'] = 'Kategori Şablonu Değişkenleri';
$lang['title_catalog_template_vars'] = 'Catalog Template Variables';
$lang['title_compare_template_vars'] = 'Comparison Template Variables';
$lang['title_feature_template_vars'] = '&Ouml;zellikler Şablonu Değişkenleri';
$lang['title_show_only_existing_images'] = 'Kayıp resimleri dahil etme';
$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'] = 'Katalog';
$lang['title_attr_order_by'] = 'Sipariş';
$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 does not apply to Text Areas)';
$lang['item_page'] = '&Uuml;r&uuml;n Sayfası';
$lang['category_page'] = 'Kategori Sayfası';
$lang['catalog_printable'] = 'Yazılabilir Katalog';
$lang['catalog_datasheet'] = 'Katalog Verisayfası';
$lang['catalog_short_list'] = '&Ouml;zellik Listesi';
$lang['item_comparison'] = '&uuml;r&uuml;n Karşılaştırma';
$lang['title_global_item_sort_order'] = '&Uuml;r&uuml;n sıralamasını belirle';
$lang['title_global_items_per_page'] = 'Sayfadaki &uuml;r&uuml;n sayısını belirle';
$lang['title_global_category_recurse'] = 'Set Category Display Behavior to';
$lang['title_item_sort_order'] = 'Varsayılan Sırlama';
$lang['title_printable_sort_order'] = 'Varsayılan yazdırılabilir katalog sıralaması';
$lang['title_items_per_page'] = 'Varsayılan sayfadaki &uuml;r&uuml;n sayısı';
$lang['title_avail_attrs'] = 'Item attributes available for the template';
$lang['title_avail_imattrs'] = 'Bu şablon i&ccedil;in uygun &uuml;r&uuml;n resimleri';
$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'] = 'Şablon';
$lang['title_template_type'] = 'Şablon Tipi';
$lang['title_title'] = 'Başlık';
$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 &quot;No Image&quot; image for missing images';
$lang['title_show_missing_images_long'] = 'Show a special &quot;No Image&quot; image if there are missing images (useful for debugging. Otherwise will use a single pixel transparent image).';
$lang['natural_order'] = 'Dolaşım Sıralamsı';
$lang['alpha_order'] = 'Alfabetik Sıralama';
$lang['manageprefs'] = '&Ouml;zellikleri Y&ouml;net';
$lang['manageattrs'] = 'Manage User-Defined Attributes';
$lang['globalops'] = 'Genel Katalog Y&ouml;netimi';
$lang['addtemplate'] = 'Şablon Ekle';
$lang['reimporttemplates'] = 'Re-import example sub-templates';
$lang['reimported'] = 'Sample sub-templates have been imported.';
$lang['templateupdated'] = 'Şablon eklendi/g&uuml;ncellendi.';
$lang['templatedeleted'] = 'Şablon eklendi.';
$lang['prefsupdated'] = '&Ouml;zellikler g&uuml;ncellendi.';
$lang['installed'] = 'Module version %s installed.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['badfile'] = 'File &quot;%s&quot; is not an acceptable format.';
$lang['badimage'] = 'Problem uploading &quot;%s&quot; (check file size and/or server permissions).';
$lang['badimageformat'] = '&quot;%s&quot; is not valid. Only jpegs are supported for the time being.';
$lang['uploaded'] = 'File &quot;%s&quot; uploaded for item %s.';
$lang['uninstalled'] = 'Module Uninstalled.';
$lang['attrsupdated'] = 'Attributes updated.';
$lang['noglobalchange'] = 'Değiştirme';
$lang['globallyupdated'] = 'Changes propagated globally.';
$lang['edittemplate'] = 'Şablon D&uuml;zenle';
$lang['subtemplates'] = 'Catalog Sub-templates';
$lang['next'] = ':&raquo;';
$lang['prev'] = '&laquo;:';
$lang['edit'] = 'D&uuml;zenle';
$lang['delete'] = 'Sil';
$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 &quot;Catalog Items&quot; which could be products, works of art, or the like, and &quot;Catalog Categories&quot; 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 &quot;Content Aliases&quot; (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&#039;re in your site administration category, you add Catalog Items and Catalog Categories just as you would any other kind of page. Select Content > Pages > Add Content, and then select &quot;Catalog Item&quot; or &quot;Catalog Category&quot; 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 &quot;Images&quot; 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&#039;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 &quot;Options&quot; 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 &quot;natural&quot; 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 > Cataloger > Manage Preferences. If, at a later date, you wish to change some setting on all of your Category pages, you can go into Extensions > Cataloger > 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 > Cataloger > 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&#039;s browser to the scaled image if it exists, and creating the scaled image if it doesn&#039;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>
<h3>Feature Lists</h3>
<p>You can, as of version 0.4, have &quot;feature lists&quot; 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>&quot;All&quot; 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 &quot;all&quot; feature list.</p>
<p>The syntax for an &quot;all&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list.
There is an optional parameter, alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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 {cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;categories_all&#039;}. Your template could then throw
those categories into a pulldown menu that redirected you to that category&#039;s page, for example:</p>
<pre>
<select name=&quot;foo&quot; onchange=&quot;document.location=this.options[this.selectedIndex].value;&quot;>
<option value=&quot;&quot;>Select A target</option>
{foreach from=$items item=thisone}
   <option value=&quot;{$thisone.link}&quot;>{$thisone.title}</option>
{/foreach}
</select>
</pre>
<p>If you wanted that to only show categories that were in the very top level of your heirarchy, you&#039;d replace the recurse=&#039;categories_all&#039; with
recurse=&#039;categories_one&#039;. Or if you wanted it to be all catalog Items instead of categories, you could use a tag like:
{cms_module module=&#039;Cataloger&#039; action=&#039;all&#039; sub_template=&#039;my_sub_template&#039; alias=&#039;/&#039; recurse=&#039;items_all&#039;}
<p>Similarly, you could have it list only categories under the current page (by omitting the &quot;alias=&#039;/&#039;&quot;). 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>
<h4>Recently Added Feature List</h4>
<p>To use a &quot;most-recently added&quot; 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 &quot;most recently added&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;recent&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, which means to use <i>all</i> pages in the site.</p>
<h4>Random Items Feature List</h4>
<p>The syntax for a &quot;random&quot; list is like:</p>
<p>{cms_module module=&#039;Cataloger&#039; action=&#039;random&#039; sub_template=&#039;my_sub_template&#039;}, where sub_template is the template to use to render the list. There are two optional parameters, count=&#039;3&#039; alias=&#039;page_alias&#039;, 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 &quot;page_alias&quot; is &quot;/&quot;, 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>{cms_module module=&#039;Cataloger&#039; action=&#039;variable&#039; name=&#039;itemnotes&#039; default=&#039;no notes&#039;}, 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>
<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 > Cataloger > Manage User-Defined Attributes, you can change the attributes. It&#039;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&#039;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&#039;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&#039;re using to display your Printable Catalog -- see Custom Templates below.</p>
<h4>Custom Templates</h4>
<p>If you&#039;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 &quot;Feature&quot; 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&#039;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>Smarty tags in Attributes</h4>
<p>Sometimes, you&#039;ll want the descriptions of your items to include smarty tags (e.g., cms_selflink). To make that work, you&#039;ll need to
update your template. For the attributes where you want smarty tags to be active, you&#039;ll need to nest the smarty evaluations in your template. For example:</p>
<pre>
{eval var=$attrlist[at].key}
</pre>
<p>becomes:</p>
<pre>
{eval var=$entry->input assign=thisAttr}{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 &quot;itemname_f_1_400_1.jpg&quot; - 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 &quot;image missing&quot; image if this image doesn&#039;t exist, 0 otherwise</li>
</ul>
<p>
This will take an image in root_path/uploads/images/catalog_src/itemname_src_1
</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"><sjg@cmsmodules.com></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; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. 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['changelog'] = '<ul>
<li>Version 0.7.1 - 29 Sept 2008. Added Variable method for Javier San Juan Costilas.</li>
<li>Version 0.7 - 17 March 2008. <em>Finally</em> added per-page meta-data. And there was great celebration in the streets, and dancing in the town square. Also added in many HTML and localization fixes contributed by Nuno Costa.</li>
<li>Version 0.6.2 - 7 January 2007. Fixed nasty bug where upgrading makes it look like all your note fields are lost.</li>
<li>Version 0.6.1 - 2 January 2007. Fixed nasty bug where changing content type from &quot;content&quot; to catalog content types renamed all catalog images.</li>
<li>Version 0.6 - 29 December 2007. <ul>
<li>Bug fix: Images don&#039;t get &quot;lost&quot; when page alias changes.</li>
<li>Bug fix: Attribute content doesn&#039;t get &quot;lost&quot; when attributes are renamed.</li>
<li>Bug fix: Fixed Printable Catalog. Works for first time since v.0.4 or thereabouts.</li>
<li>Bug fix: Now honors system preference for WYSIWYG editing of text areas.</li>
<li>Feature: Attributes may now be text areas.</li>
</ul>
</li>
<li>Version 0.5.6 - 10 December 2007. Tardy rollout of fixes: <ul>
<li>Added code to prevent showing of non-uploaded images, category page buffer flushing for extreme cases, minor bug fixes</li>
<li>Fix for &#039;recent&#039; action when alias is /</li>
<li>Fix for the problem where catalogs with more than ten categories have items displayed in incorrect categories</li></ul></li>
<li>Version 0.5.5 - 20 June 2007. Fix for Content Alias support - requires Content Alias v. 0.6.1.</li>
<li>Version 0.5.4 - 19 June 2007. Added &quot;all&quot; feature list.</li>
<li>Version 0.5.3 - 21 September 2006. Added links to source (non-rescaled) images, and added image delete functionality.</li>
<li>Version 0.5.2 - 17 September 2006. Removed debug output, revised image system (fixed bugs). Caching bug seems to remain.</li>
<li>Version 0.5.1 - 24 August 2006. (calguy1000), Upped MinimumCMSVersion to 1.0-svn, and more 1.0 changes were added (removed static methods)</li>
<li>Version 0.5 - 16 August 2006. Assorted contributed bug fixes for CMS MS 1.0,  new options for images.</li>
<li>Version 0.4.2 - 28 May 2006. Bug fix for attributes in category pages. Added &quot;/&quot; page_alias for feature lists.</li>
<li>Version 0.4.1 - 23 May 2006. Bug fix to make work with older versions of CMS MS.</li>
<li>Version 0.4 - 22 May 2006. Bug fixes, Feature Lists.</li>
<li>Version 0.3 - (unreleased, published from svn)</li>
<li>Version 0.2 - 23 March 2006. Numerous bug fixes. Performance improvements. Memory footprint optimizations. Now uses the CMS 0.12 Module API.</li>
<li>Version 0.1.5 - 17 November 2005. Initial Release. Jesus, that took a long time.</li>
<li>Version 0.1 - 19 March 2005. Project Initiation.</li>
</ul>';
$lang['postinstall'] = 'Make sure to set the &quot;Modify Catalog Settings&quot; permission on users who will be administering the catalog.';
$lang['utma'] = '156861353.1664897565.1272759163.1277761254.1277765691.32';
$lang['utmz'] = '156861353.1277765691.32.5.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/project/files/250|utmcmd=referral';
$lang['qca'] = 'P0-1960756361-1272759163370';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></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>/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/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/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>
