<?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>Bookmarks</name>
	<version>2.0.1</version>
  <mincmsversion>1.0-beta3</mincmsversion>
	<help>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</help>
	<about>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</about>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/Bookmarks.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
# Bookmarks. A plugin for CMS - CMS Made Simple
# Copyright (c) 2004 by Rob Allen <rob@akrabat.com>
#
# CMS- CMS Made Simple is Copyright (c) Ted Kulp (wishy@users.sf.net)
#
# 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


class Bookmarks extends CMSModule
{
	var $categories_table_name;
	var $bookmarks_to_categories_table_name;
	var $bookmarks_table_name;
	
	function Bookmarks()
	{
		$this->CMSModule();
		
		$this->categories_table_name = cms_db_prefix() . 'module_bookmarks_categories';
		$this->bookmarks_to_categories_table_name = cms_db_prefix().'module_bookmarks_to_categories';
		$this->bookmarks_table_name = cms_db_prefix().'module_bookmarks';	
	}
	
	function GetName()
	{
		return 'Bookmarks';
	}

	function GetFriendlyName()
	{
		return $this->Lang('friendlyname');
	}
		
	function GetAuthor()
	{
		return 'Rob Allen';
	}
	
	function GetAuthorEmail()
	{
		return 'rob@akrabat.com';
	}

	function IsPluginModule()
	{
		return true;
	}

	function HasAdmin()
	{
		return true;
	}
	
	function GetAdminSection()
	{
		return 'content';
	}

	function GetVersion()
	{
		return '2.0.1';
	}

	function GetDescription($lang = 'en_US')
	{
		return $this->Lang('moddescription');
	}

	function GetHelp($lang = 'en_US')
	{
		return $this->Lang('help'); 
	}

	function GetChangeLog()
	{
		return $this->Lang('changelog'); 
	}

	function Install()
	{
		$db = $this->cms->db;				/* @var $db ADOConnection */
		$dict = NewDataDictionary($db); 	/* @var $dict ADODB_DataDict */
	
		// create categories table
		$fields = "
			category_id I KEY,
			category_name C(255),
			category_order I
		";
	
		$table_opt_array = array('mysql' => 'TYPE=MyISAM');
		$sql_array = $dict->CreateTableSQL(cms_db_prefix()."module_bookmarks_categories",
		$fields, $table_opt_array );
		$dict->ExecuteSQLArray( $sql_array );
	
		$db->CreateSequence( cms_db_prefix()."module_bookmarks_categories_seq" );
	
		// create bookmarks table
		$fields = "
			bookmark_id I KEY,
			bookmark_title C(255),
			bookmark_url C(255),
			bookmark_summary X,
			bookmark_created_by I,
			bookmark_approved I1 DEFAULT 0,
			bookmark_create_date DT,
			bookmark_modified_date DT
		";
	
		$table_opt_array = array('mysql' => 'TYPE=MyISAM');
		$sql_array = $dict->CreateTableSQL(cms_db_prefix()."module_bookmarks",
		$fields, $table_opt_array );
		$dict->ExecuteSQLArray( $sql_array );
	
		$db->CreateSequence( cms_db_prefix()."module_bookmarks_seq" );
	
		// create bookmarks_to_categories table
		$fields = "
			category_id I KEY,
			bookmark_id I KEY
		";
	
		$table_opt_array = array('mysql' => 'TYPE=MyISAM');
		$sql_array = $dict->CreateTableSQL(cms_db_prefix()."module_bookmarks_to_categories",
		$fields, $table_opt_array );
		$dict->ExecuteSQLArray( $sql_array );
	
		$this->CreatePermission('Modify Bookmarks', 'Modify Bookmarks');
	}

	function InstallPostMessage()
	{
		return $this->Lang('postinstall'); 
	}

	function Upgrade($oldversion, $newversion)
	{
		// No database changes yet!
	}

	function Uninstall()
	{
		$db = $this->cms->db; /* @var $db ADOConnection */
		$dict = NewDataDictionary($db);
	
		$sqlarray = $dict->DropTableSQL(cms_db_prefix()."module_bookmarks");
		$dict->ExecuteSQLArray($sqlarray);
	
		$sqlarray = $dict->DropTableSQL(cms_db_prefix()."module_bookmarks_to_categories");
		$dict->ExecuteSQLArray($sqlarray);
	
		$sqlarray = $dict->DropTableSQL(cms_db_prefix()."module_bookmarks_categories");
		$dict->ExecuteSQLArray($sqlarray);
	
		$db->DropSequence(cms_db_prefix()."module_bookmarks_seq");
		$db->DropSequence(cms_db_prefix()."module_bookmarks_categories_seq");
		$this->RemovePermission('Modify Bookmarks');
	}

  /*---------------------------------------------------------
   UninstallPostMessage()
   ---------------------------------------------------------*/
	function UninstallPostMessage() {
		return $this->Lang('postuninstall');
	}		

	function SetParameters()
	{
		$this->CreateParameter('email_from', 'userid', $this->lang('help_param_emailfrom'));
		$this->CreateParameter('email_to', 'userid', $this->lang('help_param_emailto'));
		$this->CreateParameter('include_back_button', 'true', $this->lang('help_param_backbutton'));
		$this->CreateParameter('addform', 'true', $this->lang('help_param_addform'));
		$this->CreateParameter('target', '_blank', $this->lang('help_param_target'));
		$this->CreateParameter('summaries', 'true', $this->lang('help_param_summaries'));
		$this->CreateParameter('makerssbutton', 'true', $this->lang('help_param_makerssbutton'));
		$this->CreateParameter('auto_detect_link', 'true', $this->lang('help_param_autodetectlink'));
		$this->CreateParameter('order_by_date', 'true', $this->lang('help_param_orderbydate'));
		$this->CreateParameter('type', 'text', $this->lang('help_param_type'));
		$this->CreateParameter('number', '25', $this->lang('help_param_number'));
		$this->CreateParameter('display_unapproved', 'true', $this->lang('help_param_display_unapproved'));
		$this->CreateParameter('show_category_with_title', 'true', $this->lang('help_param_show_catwithtitle'));
		$this->CreateParameter('category', 'retailers', $this->lang('help_param_category'));
		$this->CreateParameter('columns', '2', $this->lang('help_param_columns'));
	}

	function GetBookmark($bookmark_id, $default_to_approved=0) {
		$db = $this->cms->db; /* @var $db ADOConnection */
		$bookmarks_table_name = cms_db_prefix().'module_bookmarks';
		$bookmarks_to_categories_table_name = cms_db_prefix().'module_bookmarks_to_categories';
	
		$sql = "SELECT * from $bookmarks_table_name WHERE bookmark_id = $bookmark_id";
		$rs = $db->Execute($sql);
		if($rs->RecordCount() > 0)
		{
			$result = $rs->FetchRow();
			$result['categories'] = array();
			// now pick up categories
			$sql = "SELECT category_id from $bookmarks_to_categories_table_name WHERE bookmark_id = $bookmark_id";
			$rs = $db->Execute($sql);
			while($row = $rs->FetchRow())
			{
				$result['categories'][] = $row['category_id'];
			}
		}
		else
		{
			// create an empty record
			$result = array();
			$result['bookmark_id'] = -1;
			$result['bookmark_title'] = '';
			$result['bookmark_url'] = '';
			$result['bookmark_summary'] = '';
			$result['bookmark_created_by'] = -1;
			$result['bookmark_approved'] = $default_to_approved;
			$result['bookmark_create_date'] = NULL;
			$result['bookmark_modified_date'] = NULL;
			$result['categories'] = array();
		}
	
		return $result;
	}

		
	function GetCategories($order_by='category_order, category_name')
	{
		$db = $this->cms->db; /* @var $db ADOConnection */
		$categories_table_name = $this->categories_table_name;
		$sql = "SELECT * FROM $categories_table_name";
		if($order_by != '')
	    {
	        $sql .= " ORDER BY $order_by";
	    }
	
	    $result = array();
	    $rs = $db->Execute($sql);
	    if($rs && $rs->RecordCount() > 0)
	        $result = $rs->GetArray();
	    return $result;
	}	
	
	function AllowAccess($permission='Modify Bookmarks') {
		$access = $this->CheckPermission($permission);
		if (!$access)  {
			DisplayErrorPage($id, $params, $returnid, $this->Lang('needpermission'));
			
			return false;
		}
		else return true;
	
	}
	
	function DoAction($name, $id, $parameters, $returnid='')
	{
		switch($name)
		{
			case 'default':  // default user front end page
				$this->UserDisplay($id, $parameters, $returnid);
				break;
				
			case 'bookmarks_useradd':
				$this->UserAddBookmark($id, $parameters, $returnid);
				break;
				
			case 'defaultadmin': // default admin page
				if($this->AllowAccess()) {
					
					$this->AdminDisplayDefaultAdminPage($id, $parameters, $returnid);
				}
				break;
				
			case 'admin_categories_update':
				if($this->AllowAccess())
				{
					$this->AdminUpdateCategories($id, $parameters, $returnid);
				}
				break;
				
			case 'admin_add_bookmark':
			case 'admin_edit_bookmark':
				if($this->AllowAccess())
				{
					$this->AdminDisplayAddBookmark($id, $parameters, $returnid);
				}
				break;
				
			case 'admin_manage_categories':
				if($this->AllowAccess())
				{
					$this->AdminDisplayCategories($id, $parameters, $returnid);
				}
				break;
				
			case 'admin_bookmarks_update':
				if($this->AllowAccess())
				{
					$this->AdminUpdateBookmarks($id, $parameters, $returnid);
					$url = $this->CreateLink($id, 'defaultadmin', $returnid, $contents='', $params=array('result'=>'1'), '', true);
					$url = str_replace('&amp;', '&', $url);
					
					redirect($url);
				}
				break;
				
			case 'admin_delete_bookmark':
				if($this->AllowAccess())
				{
					$this->AdminDeleteBookmark($id, $parameters, $returnid);
					$url = $this->CreateLink($id, 'defaultadmin', $returnid, $contents='', $params=array('result'=>'1'), '', true);
					$url = str_replace('&amp;', '&', $url);
					
					redirect($url);
				}
				break;
				
			case 'set_approve_false':
            	if ($this->AllowAccess()) {
					$this->SetStatus($id, $parameters, $returnid, 0);
				}
				break;

			case 'set_approve_true':
            	if ($this->AllowAccess()) {
					$this->SetStatus($id, $parameters, $returnid, 1);
				}
				break;

			case 'editcat':
            	if ($this->AllowAccess()) {
            		$this->EditCat($id, $parameters, $returnid);
            	}
				break;
				
			case 'savecat':
				if ($this->AllowAccess()) {
            		$this->SaveCat($id, $parameters, $returnid);
            	}
				break;
			case 'delcat':
            	if ($this->AllowAccess()) {
            		$this->DeleteCat($id, $parameters, $returnid);
            	}
				break;


			default:
				break;
		}
	}

	/*---------------------------------------------------------
	   DisplayErrorPage($id, $params, $returnid, $message)
	   NOT PART OF THE MODULE API

	   This is an example of a simple method to display
	   error information on the admin side.
	---------------------------------------------------------*/
    function DisplayErrorPage($id, &$params, $returnid, $message='') {
		$this->smarty->assign('title_error', $this->Lang('error'));
		if ($message != '')
			{
			$this->smarty->assign_by_ref('message', $message);
			}

        // Display the populated template
        echo $this->ProcessTemplate('error.tpl');
    }
	
	/*************************************************************
		DisplayAdminNav:
			Show the top nav with the links for managing cats and 
			links.  Changed this to tabs.
	**************************************************************/
	
	function DisplayAdminNav ($id, &$params, $returnid, $catcount, $showtab) {
        global $gCms;

        $this->smarty->assign('tab_headers',$this->StartTabHeaders().
            $this->SetTabHeader('links',$this->Lang('title_links_tab')).
            $this->SetTabHeader('categories',$this->Lang('title_categories_tab'),($catcount=0||$showtab=='cat'?true:false)).
            $this->EndTabHeaders().$this->StartTabContent());
        $this->smarty->assign('end_tab',$this->EndTab());
        $this->smarty->assign('tab_footers',$this->EndTabContent());
        $this->smarty->assign('start_links_tab',$this->StartTab('links'));
        $this->smarty->assign('start_cats_tab',$this->StartTab('categories'));

	} // End DisplayAdminNav
	
	/*************************************************************
		DisplayLinksFilter:
			Show the filter for the manage links.  Ripped from the 
			code to display links. 
			Put into a template.
	**************************************************************/
	function DisplayLinksFilter ($id, &$params, $returnid) {
        global $gCms;
        
        $keyword = isset($params['keyword']) ? $params['keyword'] : '';
		
		$not_approved_only = get_parameter_value($params, 'not_approved_only', 0, 'Bookmarks-not_approved_only');

		$this->smarty->assign('start_links_filter_form', $this->CreateFormStart($id, 'defaultadmin', $returnid, $method='get', $enctype=''));
		$this->smarty->assign('end_links_filter_form', $this->CreateFormEnd());
		
		$this->smarty->assign('title_filter_by', $this->Lang('filterby'));
		$this->smarty->assign('title_app_status', $this->Lang('approvalstatus'));
		
		$this->smarty->assign('input_filter_by', $this->CreateInputText($id, 'keyword', $keyword, 25));
		$this->smarty->assign('input_app_status', $this->CreateInputDropdown($id, 'not_approved_only', array($this->Lang('anystatus')=>0,$this->Lang('not_approved_only')=>1), $not_approved_only));
		$this->smarty->assign('input_filter_button', $this->CreateInputSubmit($id, 'submit', $this->Lang('sortgo')));
		
	} // End DisplayLinksFilter
	
	
	function AdminDisplayDefaultAdminPage($id, $parameters, $returnid, $message='', $showtab='') {
		
		// We need to display the nav, and pass in whether or not categories is selected.

		$db = &$this->cms->db; /* @var $db ADOConnection */
		$categories = $this->GetCategories();
					
		$this->DisplayAdminNav($id, $parameters, $returnid, count($categories), $showtab);

		// Build up the category tab.
		$this->AdminDisplayCategories($id, $parameters, $returnid);
					
		// then the boomkark tab.
		$this->AdminDisplayManageBookmarks($id, $parameters, $returnid);

        if ($message != "") {
            $this->smarty->assign_by_ref('message', $message);
		}
				
		// render the template.  Doing it here to make sure everything is handled before passing it off
		echo $this->ProcessTemplate('adminpanel.tpl');
	
	}

	function EditCat($id, &$params, $returnid, $message="") {

		// Init the DB
        $db = &$this->cms->db;

		if (isset($params['category_id'])) {
			$query = "SELECT * FROM " . cms_db_prefix() . "module_bookmarks_categories WHERE category_id=?";
			$dbresult = $db->Execute($query,array($params['category_id']));
			if ($dbresult !== false && $row = $dbresult->FetchRow()) {
				$title = $row['category_name'];
				$sort = $row['category_order'];
			}
		} else {
			$title='';

			// To make things easier on the user, we are going to get the max sort order from the db and add 10... this way they dont have to.
			$query = "SELECT max(category_order) max_sort FROM " . cms_db_prefix() . "module_bookmarks_categories";
			$dbresult = $db->Execute($query);
			if ($dbresult !== false && $row = $dbresult->FetchRow()) {
				$sort = $row['max_sort'] + 10;
			} else {
				$sort=10;
			}
		}
		
		$this->smarty->assign('startform', $this->CreateFormStart($id, 'savecat', $returnid));
		$this->smarty->assign('endform', $this->CreateFormEnd());
		$this->smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', 'Submit'));

        $this->smarty->assign('title_name',$this->Lang('form_title'));
        $this->smarty->assign('title_sort',$this->Lang('form_sort'));
		
        $this->smarty->assign('input_name',$this->CreateInputText($id, 'title', $title, 50));
        $this->smarty->assign('input_sort',$this->CreateInputText($id, 'sort', $sort, 10));

		$this->smarty->assign ('cancel',$this->CreateInputSubmit ($id, 'cancel','Cancel'));
		
        if (isset($params['category_id']))
        {
            $this->smarty->assign(
                'hidden',
                $this->CreateInputHidden($id,'category_id',$params['category_id']) .
                $this->CreateInputHidden($id,'start', isset($params['start']) ? $params['start'] : '')
            );
        }
        if($message != '') {
            $this->smarty->assign('message',$message);
		}

        echo $this->ProcessTemplate('editcat.tpl');

	}
	
	function SaveCat($id, &$params, $returnid) {
		$db = &$this->cms->db;
		$message = '';

    	if (isset($params['category_id'])) {
    	   	// updating
            $query = 'UPDATE '. cms_db_prefix().
				'module_bookmarks_categories set category_name=?, category_order=? WHERE category_id=?';
            $dbresult = $db->Execute($query,array(
                    $params['title'],$params['sort'],$params['category_id']));
            if ($dbresult === false) {
                return $this->DisplayErrorPage($id, $params, $returnid, $db->ErrorMsg());
			}
            $term_id = $params['category_id'];
			$message = $this->Lang('catedited');
		} elseif (isset ($params['cancel'])) {
			// This is a cancel handling... Go back to menu.
			return $this->AdminDisplayDefaultAdminPage($id, $params, $returnid, $message, 'cat');
		} else {
    	   	// new record
    	   	$term_id = $db->GenID(cms_db_prefix().'module_bookmarks_categories_seq');
			// Status and Sort order will be added at a later date.  As the program progresses.
			$query = 'INSERT INTO '. cms_db_prefix(). 'module_bookmarks_categories (category_id, category_name, category_order) VALUES (?,?,?)';

			$dbresult = $db->Execute($query,array($term_id,$params['title'],$params['sort']));
			$message = $this->Lang('catadded');

            if ($dbresult === false) {
                return $this->DisplayErrorPage($id, $params, $returnid, $db->ErrorMsg());
			}
        }
		
      
        return $this->AdminDisplayDefaultAdminPage($id, $params, $returnid, $message, 'cat');
	}
	
	function DeleteCat($id, &$params, $returnid) {
		$db = &$this->cms->db;
    	if (isset($params['category_id'])) {
			// Delete the category
            $query = 'DELETE FROM '. cms_db_prefix().'module_bookmarks_categories WHERE category_id=?';
            $dbresult = $db->Execute($query,array($params['category_id']));
            if ($dbresult === false) {
                return $this->DisplayErrorPage($id, $params, $returnid, $db->ErrorMsg());
            }
			
			// Delete all the links to the category
            $query = 'DELETE FROM '. cms_db_prefix().'module_bookmarks_to_categories WHERE category_id=?';
            $dbresult = $db->Execute($query,array($params['category_id']));
            if ($dbresult === false) {
                return $this->DisplayErrorPage($id, $params, $returnid, $db->ErrorMsg());
            }
    	}
        return $this->AdminDisplayDefaultAdminPage($id, $params, $returnid, $this->Lang('catdeleted'), 'cat');
    }
		
	function AdminDisplayAddBookmark($id, $params, $returnid) {
			
		$db = &$this->cms->db;

		$cats = array();
		$membercats=array();
		$status = array();

		$status[$this->Lang('status_notapproved')] = 0;
		$status[$this->Lang('status_approved')] = 1;
		
		$message = '';
		
		$query = "SELECT category_id, category_name FROM " . cms_db_prefix() . "module_bookmarks_categories";
		$dbresult = $db->Execute($query);
		
		while ($dbresult !== false && $row = $dbresult->FetchRow()) {
			$cats[$row['category_name']] = $row['category_id'];
		}
		
		if (isset($params['bookmark_id'])) {
			$query = "SELECT * FROM " . cms_db_prefix() . "module_bookmarks WHERE bookmark_id=?";
			$dbresult = $db->Execute($query,array($params['bookmark_id']));
			
			if ($dbresult !== false && $row = $dbresult->FetchRow()) {
				$title = $row['bookmark_title'];
				$descript = $row['bookmark_summary'];
				$url = $row['bookmark_url'];
				if ($row['bookmark_approved'] == 1) {
					$rowstatus = 1;
				} else {
					$rowstatus = 0;
				}
			}
			$query = "SELECT category_id FROM " . cms_db_prefix() . "module_bookmarks_to_categories WHERE bookmark_id=?";
			$dbresult = $db->Execute($query,array($params['bookmark_id']));
			while ($dbresult !== false && $row = $dbresult->FetchRow()) {
				array_push($membercats, $row['category_id']);
			}

		} else {
			$title='';
			$descript='';
			$url='';
			$rowstatus = 1;
		}
	
		$this->smarty->assign('startform', $this->CreateFormStart($id, 'admin_bookmarks_update', $returnid));
		$this->smarty->assign('endform', $this->CreateFormEnd());
		$this->smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', 'Submit'));

        $this->smarty->assign('title_field_title',$this->Lang('form_title'));
        $this->smarty->assign('title_field_descript',$this->Lang('form_descript'));
        $this->smarty->assign('title_field_cats',$this->Lang('form_cats'));
        $this->smarty->assign('title_field_url',$this->Lang('form_url'));
        $this->smarty->assign('title_field_status',$this->Lang('form_status'));

        $this->smarty->assign('input_field_title',$this->CreateInputText($id, 'title', $title, 50));
        $this->smarty->assign('input_field_url',$this->CreateInputText($id, 'url', $url, 50));
                
		$this->smarty->assign('input_field_descript',$this->CreateTextArea(false, $id, $descript, 'descript'));
        $this->smarty->assign('input_field_cats',$this->CreateInputSelectList($id, 'cats[]', $cats, $membercats, 5));
        $this->smarty->assign('input_field_status',$this->CreateInputDropdown($id, 'status', $status, $rowstatus));

		$this->smarty->assign ('cancel',$this->CreateInputSubmit ($id, 'cancel','Cancel'));
		
        if (isset($params['bookmark_id'])) {
            $this->smarty->assign('hidden',$this->CreateInputHidden($id,'bookmark_id',$params['bookmark_id']));
		}
        if($message != '') {
            $this->smarty->assign('message',$message);
		}

        echo $this->ProcessTemplate('editlinks.tpl');
	}
	

	function AdminDisplayCategories($id, $parameters, $returnid)
	{
    	global $gCms;
	
        $entryarray = array();
        $message = '';

		// Init the DB
        $db = &$this->cms->db;

		// pull the initial query for the cats
        $query = "SELECT category_id, category_name FROM ".cms_db_prefix().'module_bookmarks_categories'.
            " ORDER by category_order, category_name";
        $dbresult =  $db->Execute($query);

        $rowclass = 'row1';

        while ($dbresult !== false && $row = $dbresult->FetchRow()) {
			
			$onerow = new stdClass();

			$onerow->id = $row['category_id'];
			$onerow->name = $this->CreateLink($id, 'editcat', $returnid, $row['category_name'], array('category_id'=>$row['category_id']));
			$onerow->rowclass = $rowclass;
		   
			$onerow->editlink = $this->CreateLink($id, 'editcat', $returnid,
				$gCms->variables['admintheme']->DisplayImage('icons/system/edit.gif',$this->Lang('editcat'),'','','systemicon'),
				array('category_id'=>$row['category_id']),'','',true);
	       $onerow->dellink = $this->CreateLink($id, 'delcat', $returnid,
	       		$gCms->variables['admintheme']->DisplayImage('icons/system/delete.gif',$this->Lang('deletecat'),'','','systemicon'),
	       		array('category_id'=>$row['category_id']),$this->Lang('suredeletecat',$row['category_name']));

	       array_push($entryarray, $onerow);

	       ($rowclass=="row1"?$rowclass="row2":$rowclass="row1");
		}
		
        $this->smarty->assign('column_category', $this->Lang('column_category'));
        $this->smarty->assign('column_action', $this->Lang('column_action'));

    	$this->smarty->assign('title_section', $this->Lang('title_cat_list'));

        $this->smarty->assign('addcat', $this->CreateLink($id, 'editcat', $returnid,
            $gCms->variables['admintheme']->DisplayImage('icons/system/newobject.gif',
                $this->Lang('addcat'),'','','systemicon'),
                array(),
                '', false, false, '') .' '.
            $this->CreateLink($id, 'editcat', $returnid, $this->Lang('addcat'),
                array(),
                '',false, false, 'class="pageoptions"'));

        $this->smarty->assign_by_ref('cats', $entryarray);
        $this->smarty->assign('catcount', count($entryarray));

        if ($message != "")
            {
            $this->smarty->assign_by_ref('message', $message);
            }
				
		// lastly assign the no cats message if its needed.
		$this->smarty->assign('nocats', $this->Lang('nocats'));
		
	}
	
	
	function AdminUpdateBookmarks($id, $params, $returnid) {
		$db = &$this->cms->db;

		$user_id = $this->cms->variables['user_id'];		

    	if (isset($params['bookmark_id'])) {
    	   	// updating
            $query = 'UPDATE '. cms_db_prefix().'module_bookmarks SET 
						bookmark_title=?,
						bookmark_summary=?,
						bookmark_url=?,
						bookmark_approved=?,
						bookmark_modified_date=NOW() 
					WHERE bookmark_id=?';
					
            $dbresult = $db->Execute($query,array($params['title'],$params['descript'],$params['url'],$params['status'],$params['bookmark_id']));
			
            if ($dbresult === false) {
                return $this->DisplayErrorPage($id, $params, $returnid, $db->ErrorMsg());
			}
            $link_id = $params['bookmark_id'];
			$message = $this->Lang('bookmarkedited');

		} elseif (isset($params['cancel'])) {
			// This is a cancel handling... Go back to menu.
			return $this->AdminDisplayDefaultAdminPage($id, $params, $returnid, $message, '');
			
		} else {
			echo "here";
    	   	// new record
    	   	$link_id = $db->GenID(cms_db_prefix().'module_bookmarks_seq');
			$query = 'INSERT INTO '. cms_db_prefix().'module_bookmarks 
						(bookmark_id, bookmark_title, bookmark_summary, bookmark_url, bookmark_approved, bookmark_create_date, bookmark_modified_date, bookmark_created_by) 
					VALUES 
						(?,?,?,?,?,NOW(),NOW(),?)';

			$dbresult = $db->Execute($query,array($link_id,$params['title'],$params['descript'],$params['url'],$params['status'],$user_id));
			
            if ($dbresult === false) {
                return $this->DisplayErrorPage($id, $params, $returnid, $db->ErrorMsg());
			}

			$message = $this->Lang('bookmarkadded');
			
		}
        
		if (isset($params['cats'])) {
            if (! is_array($params['cats'])) {
                $params['cats'] = array($params['cats']);
			}
			$query = 'DELETE FROM '. cms_db_prefix().'module_bookmarks_to_categories where bookmark_id=?';
			$dbresult = $db->Execute($query,array($link_id));
			
            if ($dbresult === false) {
                return $this->DisplayErrorPage($id, $params, $returnid,$db->ErrorMsg());
			}
            
			foreach ($params['cats'] as $thisCat) {
                $query = 'INSERT INTO '. cms_db_prefix().'module_bookmarks_to_categories (bookmark_id, category_id) VALUES (?,?)';
                $dbresult = $db->Execute($query,array($link_id, $thisCat));
                if ($dbresult === false) {
                    return $this->DisplayErrorPage($id, $params, $returnid,$db->ErrorMsg());
				}
			}
		}	
		return $this->AdminDisplayDefaultAdminPage($id, $params, $returnid, $message, 'bookmark');
	}
	
	function AdminDeleteBookmark($id, $parameters, $returnid)
	{
		$db = $this->cms->db; /* @var $db ADOConnection */
		$bookmarks_table_name = $this->bookmarks_table_name;
		$bookmarks_to_categories_table_name = $this->bookmarks_to_categories_table_name;
	
		$bookmark_id = get_parameter_value($parameters, 'bookmark_id', -1);
	
		// delete current bookmarks_to_categories records for this bookmark
		$sql = "DELETE FROM $bookmarks_to_categories_table_name WHERE bookmark_id = $bookmark_id";
		$db->Execute($sql);
	
		// delete this bookmark
		$sql = "DELETE FROM $bookmarks_table_name WHERE bookmark_id = $bookmark_id";
		$db->Execute($sql);
	}

	function SetStatus($id, $params, $returnid, $newstatus) {
		$db = &$this->cms->db;

		$query = 'UPDATE '. cms_db_prefix(). 
			'module_bookmarks set bookmark_approved=? WHERE bookmark_id=?';
		
		$dbresult = $db->Execute($query,array($newstatus,$params['bookmark_id']));
		if ($dbresult === false) {
		echo "here";
			return $this->DisplayErrorPage($id, $params, $returnid, $db->ErrorMsg());
		}
		
		if ($newstatus == 0) {
			$status = $this->Lang('set_status_notapproved');
		} else {
			$status = $this->Lang('set_status_approved');
		}
		return $this->AdminDisplayDefaultAdminPage($id, $params, $returnid );
		
	}
	
	function AdminDisplayManageBookmarks($id, $parameters, $returnid, $message='') {
		global $gCms;

		// Array Inits for the display... Please if theres a better way to do this... someone tell me... 
		
		$categories = array();  // For the categories
		$entryarray = array();
		$catentry = array($entryarray);  // To attach the rows of the links to something we can parse in the template... Like i said... if you know an easier way show me please :)
		$itemcount = array();  // this is for error checking in the template,  so we can show a "no links for cat" error when there are none.

		
		$keyword = get_parameter_value($parameters, 'keyword', '', 'Bookmarks-keyword');
		$not_approved_only = get_parameter_value($parameters, 'not_approved_only', 0, 'Bookmarks-not_approved_only');
	
		// Removed the Links filter to its own function to clean things up a bit.
		$this->DisplayLinksFilter($id, $parameters, $returnid);
		
		$db = &$this->cms->db;

		$db->debug = false;
	
		// Set up the categories pull.  We need to maintain an array to hold the data we are pusing to the template.  This makes things easier in the long run.
		$catsql = "SELECT category_name, category_id FROM ". $this->categories_table_name . " ";
		
		$order_by = get_parameter_value($parameters, 'order_by', '');
		
		if(!empty($order_by))
		{
			$catsql .= "ORDER BY ". $this->bookmarks_table_name . ".modified_date";
		}
		else
		{
			$catsql .= "ORDER BY ". $this->categories_table_name . ".category_order
	    				,". $this->categories_table_name . ".category_name";
		}
		
        $catrs =  $db->Execute($catsql);
		$i = 0;
		while ($catrs !== false && $catrow = $catrs->FetchRow()) {
			
			// now that we have the cats starting, we need to pull in the bookmarks for that cat.  This is rather than the large join and the parse to write html.
			$sql = "SELECT ". $this->bookmarks_table_name . ".* 
			FROM ". $this->bookmarks_table_name ."
			LEFT JOIN ". $this->bookmarks_to_categories_table_name . "
			   ON ". $this->bookmarks_table_name . ".bookmark_id = ". $this->bookmarks_to_categories_table_name . ".bookmark_id ";
			
			$sql .= "WHERE ". $this->bookmarks_table_name . ".bookmark_id=" . $this->bookmarks_to_categories_table_name . ".bookmark_id 
			AND " . $this->bookmarks_to_categories_table_name . ".category_id=" . $catrow['category_id'] . " ";

			if($not_approved_only) {
				$sql .= "AND ". $this->bookmarks_table_name . ".bookmark_approved = 0 ";
			}
			
			if(!empty($keyword)) {
				$sql .= "AND (". $this->bookmarks_table_name . ".bookmark_title LIKE '%$keyword%'
					OR ". $this->bookmarks_table_name . ".bookmark_url LIKE '%$keyword%'
					OR ". $this->bookmarks_table_name . ".bookmark_summary LIKE '%$keyword%') ";
			}
		
			if(!empty($order_by)) {
				$sql .= "ORDER BY ". $this->bookmarks_table_name . ".modified_date";
			} else {
				$sql .= "ORDER BY ". $this->bookmarks_table_name . ".bookmark_title ";
			}
			
			$linkrs = $db->Execute($sql);

			$j = 0;
			$entryarray = array();
			if ($linkrs && $linkrs->RecordCount() > 0) {

				while($linkrow = $linkrs->FetchRow()) {
					
					$onerow = new stdClass();
					
					$rowclass = isset($rowclass) ? $rowclass : 'row1';

					$onerow->id = $linkrow['bookmark_id'];
					$onerow->namelink = $this->CreateLink($id, 'admin_edit_bookmark', $returnid,$linkrow['bookmark_title'],array('bookmark_id'=>$linkrow['bookmark_id'], '','',true));

					$onerow->name = $linkrow['bookmark_title'];
					$onerow->url = "<a href=\"" . $linkrow['bookmark_url'] . "\" target=\"_blank\">" . $linkrow['bookmark_url'] . "</a>";
					$onerow->rowclass = $rowclass;
					$onerow->definition = strip_tags($linkrow['bookmark_summary']);
					if ($linkrow["bookmark_approved"] == 1) {
						$onerow->active = $this->CreateLink($id, 'set_approve_false', $returnid,
							$gCms->variables['admintheme']->DisplayImage('icons/system/true.gif',$this->Lang('set_approve_false'),'','','systemicon'), 
							array('bookmark_id'=>$linkrow['bookmark_id']));
					} else {
						$onerow->active = $this->CreateLink($id, 'set_approve_true', $returnid,
							$gCms->variables['admintheme']->DisplayImage('icons/system/false.gif',$this->Lang('set_approve_true'),'','','systemicon'), 
							array('bookmark_id'=>$linkrow['bookmark_id']));
					}

					// Edit Link
					$onerow->editlink = $this->CreateLink($id, 'admin_edit_bookmark', $returnid,
						$gCms->variables['admintheme']->DisplayImage('icons/system/edit.gif',$contents=$this->Lang('managebookmarks'),'','','systemicon'),
						array('bookmark_id'=>$linkrow['bookmark_id']));
				
					// Delete Link
					$onerow->dellink = $this->CreateLink($id, 'admin_delete_bookmark', $returnid,
						$gCms->variables['admintheme']->DisplayImage('icons/system/delete.gif',$this->Lang('delete'),'','','systemicon'),
						array('bookmark_id'=>$linkrow['bookmark_id']),$this->Lang('suredelete',$linkrow['bookmark_title']));

					// Push it out to the array for displaying later.
					array_push($entryarray, $onerow);

					// Set the row class so it alternates correctly
					($rowclass=="row1"?$rowclass="row2":$rowclass="row1");
					$j++;
				}
			}
			
			$categories[$i] = $catrow['category_name'];
			$itemcount[$i] = $j;
			$catentry[$i] = $entryarray;
			
			$i++;
			
		}
		
		// Now we have to check to see if there are any links not assigned to a category.
		// When we delete a cat we do not delete the links.  it is possible that we have links without cats.
		$sql = "SELECT ". $this->bookmarks_table_name . ".* FROM ". $this->bookmarks_table_name . " ";
						
		$sql .= "WHERE ". $this->bookmarks_table_name . ".bookmark_id NOT IN (SELECT DISTINCT bookmark_id FROM " . $this->bookmarks_to_categories_table_name . ") ";

		if($not_approved_only) {
			$sql .= "AND ". $this->bookmarks_table_name . ".bookmark_approved = 0 ";
		}
			
		if(!empty($keyword)) {
			$sql .= "AND (". $this->bookmarks_table_name . ".bookmark_title LIKE '%$keyword%'
				OR ". $this->bookmarks_table_name . ".bookmark_url LIKE '%$keyword%'
				OR ". $this->bookmarks_table_name . ".bookmark_summary LIKE '%$keyword%') ";
		}
		
		if(!empty($order_by)) {
			$sql .= "ORDER BY ". $this->bookmarks_table_name . ".modified_date";
		} else {
			$sql .= "ORDER BY ". $this->bookmarks_table_name . ".bookmark_title ";
		}

		$linkrs = $db->Execute($sql);

		$j = 0;
		$entryarray = array();
		if ($linkrs && $linkrs->RecordCount() > 0) {

			while($linkrow = $linkrs->FetchRow()) {
				$onerow = new stdClass();

				$onerow->id = $linkrow['bookmark_id'];
				$onerow->namelink = $this->CreateLink($id, 'admin_edit_bookmark', $returnid,$linkrow['bookmark_title'],array('bookmark_id'=>$linkrow['bookmark_id'], '','',true));

				$onerow->name = $linkrow['bookmark_title'];
				$onerow->url = "<a href=\"" . $linkrow['bookmark_url'] . "\" target=\"_blank\">" . $linkrow['bookmark_url'] . "</a>";
				$onerow->rowclass = $rowclass;
				$onerow->definition = strip_tags($linkrow['bookmark_summary']);
				if ($linkrow["bookmark_approved"] == 1) {
					$onerow->active = $this->CreateLink($id, 'set_approve_false', $returnid,
						$gCms->variables['admintheme']->DisplayImage('icons/system/true.gif',$this->Lang('set_approve_false'),'','','systemicon'), 
						array('bookmark_id'=>$linkrow['bookmark_id']));
				} else {
					$onerow->active = $this->CreateLink($id, 'set_approve_true', $returnid,
						$gCms->variables['admintheme']->DisplayImage('icons/system/false.gif',$this->Lang('set_approve_true'),'','','systemicon'), 
						array('bookmark_id'=>$linkrow['bookmark_id']));
				}

				// Edit Link
				$onerow->editlink = $this->CreateLink($id, 'admin_edit_bookmark', $returnid,
					$gCms->variables['admintheme']->DisplayImage('icons/system/edit.gif',$contents=$this->Lang('managebookmarks'),'','','systemicon'),
					array('bookmark_id'=>$linkrow['bookmark_id']));
			
				// Delete Link
				$onerow->dellink = $this->CreateLink($id, 'admin_delete_bookmark', $returnid,
					$gCms->variables['admintheme']->DisplayImage('icons/system/delete.gif',$this->Lang('delete'),'','','systemicon'),
					array('bookmark_id'=>$linkrow['bookmark_id']),$this->Lang('suredelete',$linkrow['bookmark_title']));

				// Push it out to the array for displaying later.
				array_push($entryarray, $onerow);

				// Set the row class so it alternates correctly
				($rowclass=="row1"?$rowclass="row2":$rowclass="row1");
				$j++;
			}
			
			// now push this data out to the variables so we can use it :)
			$categories[$i] = $this->Lang('no_category');
			$itemcount[$i] = $j;
			$catentry[$i] = $entryarray;
		}

			
		$this->smarty->assign('categories',$categories);
		$this->smarty->assign('linklist',$catentry);
		$this->smarty->assign('itemcount',$itemcount);
		
		// Assign the included templates, so it knows where to get them... I hope
		$this->smarty->assign('listlinkstpl','module_file_tpl:'.$this->GetName().';listlinks.tpl');
		$this->smarty->assign('listcatstpl','module_file_tpl:'.$this->GetName().';listcats.tpl');
		$this->smarty->assign('linksfilter','module_file_tpl:'.$this->GetName().';linksfilter.tpl');
		
		// Assign other stuff
		$this->smarty->assign('category_head_text',$this->Lang('category_head_text'));
        $this->smarty->assign('column_title', $this->Lang('column_title'));
        $this->smarty->assign('column_url', $this->Lang('column_url'));
        $this->smarty->assign('column_summary', $this->Lang('column_summary'));
        $this->smarty->assign('column_action', $this->Lang('column_action'));
        $this->smarty->assign('column_approve', $this->Lang('column_approve'));

        $this->smarty->assign('addlink', $this->CreateLink($id, 'admin_edit_bookmark', $returnid,
            $gCms->variables['admintheme']->DisplayImage('icons/system/newobject.gif',
                $this->Lang('addlink'),'','','systemicon'),
                array(),
                '', false, false, '') .' '.
            $this->CreateLink($id, 'admin_edit_bookmark', $returnid, $this->Lang('addlink'),
                array(),
                '',false, false, 'class="pageoptions"'));		
				
	}
	
	function UserDisplay($id, $parameters, $returnid)
	{
		// handling of display of {cms_module module=Bookmarks}
		if(isset($parameters['makerssbutton']))
		{
			echo $this->CreateLink($id, $returnid, 'default', '<img border="0" src="images/cms/xml_rss.gif" alt="'.$this->Lang("rssfeed").'" />',
					array('showtemplate'=>'false','type'=>'rss'));
			return;
		}
	
		if(isset($parameters['auto_detect_link']))
		{
			$title = empty($parameters['title']) ? $this->Lang("bookmarks_rss") : $parameters['title'];
			$url = $this->CreateLink($id, $returnid, $this->Lang("default"), '',
					array('showtemplate'=>'false','type'=>'rss'), '', true);
		
			echo "<link rel='alternate' type='application/rss+xml' title='$title' href='$url' />";
			return;
		}
	
		if(isset($parameters["addform"]))
		{
			$this->DisplayAddBookmarkForm($id, $parameters, $returnid);
			return;
		}
	
		$type = get_parameter_value($parameters, 'type', 'text');
		$display_unapproved = get_parameter_value($parameters, display_unapproved, false);
		$show_category_with_title = get_parameter_value($parameters, 'show_category_with_title', true);
		$category = get_parameter_value($parameters, 'category', '');
		$number = get_parameter_value($parameters, 'number', '');
		$order_by_date = get_parameter_value($parameters, 'order_by_date', false);
		if($order_by_date)
		{
			$show_category_with_title = false;
		}
			
		$categories_table_name = $this->categories_table_name;
		$bookmarks_to_categories_table_name = $this->bookmarks_to_categories_table_name;
		$bookmarks_table_name = $this->bookmarks_table_name;
	
		$db = $this->cms->db;
		if($type == "text")
		{
			$sql = "SELECT $bookmarks_to_categories_table_name.category_id
						,$categories_table_name.category_name
						,$bookmarks_table_name.*
				FROM $bookmarks_table_name
				INNER JOIN $bookmarks_to_categories_table_name
				   ON $bookmarks_table_name.bookmark_id = $bookmarks_to_categories_table_name.bookmark_id
				INNER JOIN $categories_table_name
				   ON $bookmarks_to_categories_table_name.category_id = $categories_table_name.category_id
			";
	
			$where = 'WHERE';
			if($display_unapproved == false)
			{
				$sql .= "$where $bookmarks_table_name.bookmark_approved <> 0 ";
				$where = 'AND';
			}
			if($category)
			{
				$cats = explode(',', $category);
				$sql .= $where . ' (';
				$count = 0;
				foreach($cats as $cat)
				{
					$cat = trim($cat);
					if($count != 0)
					{
						$sql .= ' OR ';
					}
					$count++;
					$sql .= "$categories_table_name.category_name LIKE '$cat' ";
				}
				$sql .=	') ';
			}
	
			if($order_by_date)
			{
				$sql .= "ORDER BY $bookmarks_table_name.bookmark_modified_date";
			}
			else
			{
				$sql .= "ORDER BY $categories_table_name.category_order
		    				,$categories_table_name.category_name
		        	        ,$bookmarks_table_name.bookmark_title ";
			}
		}
		else
		{
			$sql = "SELECT DISTINCT $bookmarks_table_name.*
				FROM $bookmarks_table_name
				INNER JOIN $bookmarks_to_categories_table_name
				   ON $bookmarks_table_name.bookmark_id = $bookmarks_to_categories_table_name.bookmark_id
				INNER JOIN $categories_table_name
				   ON $bookmarks_to_categories_table_name.category_id = $categories_table_name.category_id
				";
	
			$where = 'WHERE';
			if($display_unapproved == false)
			{
				$sql .= "$where $bookmarks_table_name.bookmark_approved <> 0 ";
				$where = 'AND';
			}
	
			if($category)
			{
				$cats = explode(',', $category);
				$sql .= $where . ' (';
				$count = 0;
				foreach($cats as $cat)
				{
					$cat = trim($cat);
					if($count != 0)
					{
						$sql .= ' OR ';
					}
					$count++;
					$sql .= "$categories_table_name.category_name LIKE '$cat' ";
				}
				$sql .=	') ';
			}
	
			$sql .= "ORDER BY $bookmarks_table_name.bookmark_modified_date DESC";
		}

		if($number)
		{
			$dbresult = $db->SelectLimit($sql,$number); /* @var $dbresult ADORecordSet */
		}
		else
		{
			$dbresult = $db->Execute( $sql ); /* @var $dbresult ADORecordSet */
		}
	
		if(isset($parameters['assign']))
		{
			// if assigning, just return array of data
			return $dbresult->GetArray();
		}
	
		if ($dbresult && $dbresult->RecordCount() > 0)
		{
			if ($type == "rss")
			{
				// find most recent date - first record as we are date_ordered
				$date = $dbresult->fields['bookmark_modified_date'];
				$date = date('r', strtotime($date));
				$title = $this->Lang("friendlyname");
	
				if (isset($parameters[$id."title"]))
					$title = $parameters[$id."title"];
				while(@ob_end_clean());
				header('Content-type: text/xml');
	
				echo "<?xml version='1.0'?>\n";
				echo "<rss version='2.0'>\n";
				echo "   <channel>\n";
				echo "   <title>$title</title>\n";
				echo "   <link>{$cms->config['root_url']}</link>\n";
				echo "   <pubDate>$date</pubDate>\n";
				echo "   <lastBuildDate>$date</lastBuildDate>\n";
				if(isset($parameters["category"]))
					echo "   <description>{$parameters["category"]} ".$this->Lang("friendlyname")."</description>\n";
				else
					echo "   <description>".$this->Lang("friendlyname")."</description>\n";
	
			}
			else
			{
				$number_of_columns = get_parameter_value($parameters, 'columns', 3);
	
				$num_rows = $dbresult->RecordCount();
				$rows_per_column = intval($num_rows / $number_of_columns) + 10; /* 10 is a fudge factor to make it look better! */
	
				$current_category_name = '';
				$columns = array();
				$col_number = 0;
				ob_start();
	
			}
			
			$target = '';
			if(isset($parameters['target']))
			{
				$target = ' target = "' . $parameters["target"] . '" ';
			}
	
			$row_count = 0;
			while( ($row = $dbresult->FetchRow()) )
			{
				$row_count++;
				$category_name = $row['category_name'];
				$bookmark_title = $row['bookmark_title'];
				$bookmark_url = $row['bookmark_url'];
	
				if(strstr($bookmark_url, '//') === false)
				{
					$bookmark_url = 'http://' . $bookmark_url;
				}
	
				if ($type == "rss")
				{
					$bookmark_modified_date = $row['bookmark_modified_date'];
					$bookmark_modified_date_rfc822 = date('r', strtotime($bookmark_modified_date));
					$bookmark_summary = $row['bookmark_summary'];
	
					echo "   <item>\n";
					echo "      <title>$bookmark_title</title>\n";
					echo "      <link>$bookmark_url</link>\n";
					if($bookmark_summary)
						echo "      <description>$bookmark_summary</description>\n";
					echo "      <pubDate>$bookmark_modified_date_rfc822</pubDate>\n";
					echo "   </item>\n";
				}
				else
				{
					$bookmark_summary = empty($parameters["summaries"]) ? '' : "<div class='cms-module-bookmarks-summary'>" . $row['bookmark_summary'] . "</div>";
	
					if($current_category_name != $category_name)
					{
						// new category - can we start a new column?
						$current_category_name = $category_name;
	
						// close the list
						if($row_count != 1)
						{
							echo "\t\t</ul>\n";
							$string = ob_get_contents();
							ob_end_clean();
							$columns[$col_number] .= $string;
							$col_number++;
							if($col_number >= $number_of_columns)
								$col_number = 0;
						ob_start();
						}
	
						// start new column
						if($show_category_with_title)
							echo "\t\t<div class='cms-module-bookmarks-header'>$current_category_name</div>\n";
						echo "\t\t<ul class='cms-module-bookmarks-list'>\n";
					}
	
					echo "\t\t\t<li><a class='bookmark-link' $target href='$bookmark_url'>$bookmark_title</a>$bookmark_summary</li>\n";
				}
			}
	
			if ($type == 'rss')
			{
				echo "   </channel>\n";
				echo "</rss>\n";
				exit;
			}
			else
			{
				// close off final column
				echo "\t\t</ul>\n";
				$string = ob_get_contents();
				ob_end_clean();
				$columns[$col_number] .= $string;
	
				// display in a table
				echo "<!-- Bookmarks Module: number of bookmarks: $num_rows -->\n";
				echo "<table id='cms-module-bookmarks' border='0' cellpadding='0' cellspacing='0'>\n<tr>\n";
	
				foreach($columns as $col)
				{
					echo "<td valign='top'>\n";
					echo $col;
					echo "</td>\n";
				}
				echo "</tr>\n</table>\n";
				echo "<!-- End of Bookmarks Module -->\n";
			}
		}		
	}
	
	function DisplayAddBookmarkForm($id, $parameters, $returnid) {
		$db = &$this->cms->db;
		
		// set up the cats array for use.
		$cats = array();
		$membercats = array();
		$query = "SELECT category_id, category_name FROM " . cms_db_prefix() . "module_bookmarks_categories";
		$dbresult = $db->Execute($query);
		
		while ($dbresult !== false && $row = $dbresult->FetchRow()) {
			$cats[$row['category_name']] = $row['category_id'];
		}

		// Set the default vaules of the forms... always nothing here
		$title='';
		$descript='';
		$url='';
		$hidden = '';
		
		// pull the parameters
		$include_back_button = get_parameter_value($parameters, 'include_back_button', false);
		$email_to = get_parameter_value($parameters, 'email_to', 0);
		$email_from = get_parameter_value($parameters, 'email_from', 0);
	
		if($email_to > 0) {
			$hidden .= $this->CreateInputHidden($id, 'email_to', $email_to);
		}
		if($email_from > 0) {
			$hidden .= $this->CreateInputHidden($id, 'email_from', $email_from);
		}

		// Assign some hidden fields
		$hidden .= $this->CreateInputHidden($id, 'bookmark_id', $bookmark_id);
		$hidden .= $this->CreateInputHidden($id, 'referer', $_SERVER['SCRIPT_NAME']);
		
		$this->smarty->assign('startform', $this->CreateFormStart($id, 'bookmarks_useradd', $returnid));
		$this->smarty->assign('endform', $this->CreateFormEnd());
		$this->smarty->assign('submit', $this->CreateInputSubmit($id, 'submit', $this->Lang("add")));

		$this->smarty->assign('hidden',$hidden);
		
        $this->smarty->assign('title_field_title',$this->Lang('form_title'));
        $this->smarty->assign('title_field_descript',$this->Lang('form_descript'));
        $this->smarty->assign('title_field_cats',$this->Lang('form_cats'));
        $this->smarty->assign('title_field_url',$this->Lang('form_url'));

        $this->smarty->assign('input_field_title',$this->CreateInputText($id, 'bookmark_title', $title, 50));
        $this->smarty->assign('input_field_url',$this->CreateInputText($id, 'bookmark_url', $url, 50));
                
		$this->smarty->assign('input_field_descript',$this->CreateTextArea(false, $id, $descript, 'bookmark_summary','','','','',50,5,''));
        $this->smarty->assign('input_field_cats',$this->CreateInputSelectList($id, 'cats[]', $cats, $membercats, 5));
		
		echo $this->ProcessTemplate('addbookmark.tpl');

	}
	
	function UserAddBookmark($id, $parameters, $returnid)
	{
		$parameters['bookmark_approved']=0;
		$this->UserUpdateBookmarks($id, $parameters, $returnid);
		$email_to = get_parameter_value($parameters, 'email_to', 0);
		if($email_to > 0)
		{
			// get email address to send email to:
			$sql = 'SELECT email FROM ' .cms_db_prefix().'users WHERE user_id=' . $email_to;
			$rs = $this->cms->db->SelectLimit($sql, 1);
			$email_to = '';
			if($rs)
			{
				$email_to = $rs->fields['email'];
			}
			if($email_to != '')
			{
				// get from email address.
				$email_from = get_parameter_value($parameters, 'email_from', 0);
				if($email_from <= 0)
				{
					// none set - pick up first email we can find.
					$email_from = 'bookmarksmodule@example.com';
					$sql = 'SELECT email FROM ' .cms_db_prefix().'users WHERE email IS NOT NULL ORDER BY user_id ASC';
					$rs = $this->cms->db->SelectLimit($sql, 1);
					if($rs)
						$email_from = $rs->fields['email'];
				}
		
				$subject = $this->Lang("new_bookmark_submitted_subject");
				$body = $this->Lang("new_bookmark_submitted_body")."\n\n";
				$body .= $this->Lang("title"). ": {$parameters[$module_id.'title']}\n";
				$body .= $this->Lang("url").": {$parameters[$module_id.'url']}\n";
				$body .= $this->Lang("summary").": {$parameters[$module_id.'summary']}\n";
		
				$headers = $this->Lang("mailheader_from").": ".$this->Lang("mailheader_sender")." <$email_from>\r\n"
		    	    ."Return-Path: ".$this->Lang("mailheader_sender")." <$email_from>\r\n"
			        ."X-Mailer: PHP/" . phpversion();
			        
			    $result = @mail($email_to, $subject, $body, $headers);
			}
		}

		$link = $this->CreateReturnLink($id, $returnid, $this->Lang("return"));
		echo "<p class='cms-module-bookmarks-submitted'>".$this->Lang("thank_you_for_submission")." . $link.</p>";
		
		
	}
	
	
	function UserUpdateBookmarks($id, $params, $returnid) {
		$db = &$this->cms->db;

		$user_id = 1;		

   	   	// new record
		$link_id = $db->GenID(cms_db_prefix().'module_bookmarks_seq');
		$query = 'INSERT INTO '. cms_db_prefix().'module_bookmarks 
					(bookmark_id, bookmark_title, bookmark_summary, bookmark_url, bookmark_approved, bookmark_create_date, bookmark_modified_date, bookmark_created_by) 
				VALUES 
					(?,?,?,?,?,NOW(),NOW(),?)';

		$dbresult = $db->Execute($query,array($link_id,$params['bookmark_title'],$params['bookmark_summary'],$params['bookmark_url'],0,$user_id));
			
		if ($dbresult === false) {
			return $this->DisplayErrorPage($id, $params, $returnid, $db->ErrorMsg());
		}

		if (isset($params['cats'])) {
            if (! is_array($params['cats'])) {
                $params['cats'] = array($params['cats']);
			}
			$query = 'DELETE FROM '. cms_db_prefix().'module_bookmarks_to_categories where bookmark_id=?';
			$dbresult = $db->Execute($query,array($link_id));
			
            if ($dbresult === false) {
                return $this->DisplayErrorPage($id, $params, $returnid,$db->ErrorMsg());
			}
            
			foreach ($params['cats'] as $thisCat) {
                $query = 'INSERT INTO '. cms_db_prefix().'module_bookmarks_to_categories (bookmark_id, category_id) VALUES (?,?)';
                $dbresult = $db->Execute($query,array($link_id, $thisCat));
                if ($dbresult === false) {
                    return $this->DisplayErrorPage($id, $params, $returnid,$db->ErrorMsg());
				}
			}
		}	
		
		//redirect('index.php');
	}	
	
};
?>]]></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['friendlyname'] = 'Bookmarks';
$lang['moddescription'] = 'Bookmarks is a module for displaying bookmarks on your page. When the module is installed, a Bookmarks admin page is added to the Content menu that will allow you to manage your bookmarks.';
$lang['postinstall'] = 'Make sure to set the "Modify Bookmarks" permission on users who will be administering bookmarks.';
$lang['postuninstall'] = 'Module is uninstalled.';
$lang['needpermission'] = 'You need the \'$permission\' permission to perform that function.';
$lang['addbookmark'] ='Add Bookmark';
$lang['managecategories'] = 'Manage Categories';			
$lang['add'] = 'Add';
$lang['update'] = 'Update';
$lang['managebookmarks'] = 'Manage Bookmarks';
$lang['title'] = 'Title';
$lang['address'] = 'Address (incl. http://)';
$lang['approved'] = 'Approved';
$lang['summary'] = 'Summary';
$lang['categories'] = 'Categories';
$lang['name'] = 'Name';
$lang['order'] = 'Order';
$lang['updatecategories'] = 'Update Categories';
$lang['filterby'] = 'Filter By';
$lang['approvalstatus'] = 'Approval Status';
$lang['sortgo'] = 'Go';
$lang['anystatus'] = 'Any';
$lang['not_approved_only'] = 'Not Approved Only';
$lang['none'] = '== None ==';
$lang['category'] = 'Category';
$lang['url'] = 'url';
$lang['default'] = 'Default';
$lang['bookmarks_rss'] = 'Bookmarks RSS';
$lang['rssfeed'] = 'RSS Feed';
$lang['submit'] = 'Submit';
$lang['new_bookmark_submitted_subject'] = 'New Bookmark Submitted';
$lang['new_bookmark_submitted_body'] = 'A new bookmark has been submitted';
$lang['mailheader_from'] = 'From';
$lang['mailheader_sender'] = 'CMSMS Bookmarks Module';
$lang['return'] = 'Return';
$lang['thank_you_for_submission'] = 'Thank you for your submission';
$lang['category_head_text'] = 'Category: ';
$lang['addcat'] = 'Add a Category';
$lang['addlink'] = 'Add a Bookmark';
$lang['filter_results'] = 'filter_results';
$lang['set_status_approved'] = 'Bookmark status set to approved';
$lang['set_status_notapproved'] = 'Bookmark status set to not approved';
$lang['title_error'] = 'There has been an error';
$lang['error'] = 'Error';

// Delete comfirm and messages
$lang['suredelete'] = 'Are you sure you want to delete the link %s?';
$lang['delete'] = 'Delete Bookmark';
$lang['catdeleted'] = 'Category Deleted';
$lang['linkdeleted'] = 'Bookmark Deleted';
$lang['suredeletecat'] = 'Are you sure you want to delete the category %s?';
$lang['deletecat'] = 'Delete Category';

// Added and edited messages
$lang['catadded'] = 'Category Added';
$lang['catedited'] = 'Category Updated';
$lang['bookmarkadded'] = 'Bookmark Added';
$lang['bookmarkedited'] = 'Bookmark Updated';
$lang['editcat'] = 'Edit Category';

// Tab Stuff
$lang['title_categories_tab'] = "Categories";
$lang['title_links_tab'] = "Bookmarks";

// Column Headings.
// for Bookmarks
$lang['column_title'] = 'Title';
$lang['column_url'] = 'URL';
$lang['column_summary'] = 'Summary';
$lang['column_action'] = 'Actions';
$lang['column_approve'] = 'Approved';
$lang['column_category'] = 'Categories';

// No cats and items error messages
$lang['nolinks'] = 'There are no links in the database.';
$lang['nocats'] = 'There are no categories in the database.';
$lang['no_category'] = 'No Category';

// Form Titles.
$lang['form_title'] = 'Title';
$lang['form_descript'] = 'Description';
$lang['form_url'] = 'URL';
$lang['form_sort'] = 'Sort Order';
$lang['form_status'] = 'Status';
$lang['form_cats'] = 'Categories';

// Status fields
$lang['status_approved'] = 'Approved';
$lang['status_notapproved'] = 'Not Approved';

// Parameter help text
$lang['help_param_emailfrom'] = 'Used with addform=true. Set to the user id to be used in the "from" field for email notifications. In general, you would user the admin user\'s id (1), but you must set an email address for the admin user as initially it does not have one.';
$lang['help_param_emailto'] = 'Used with addform=true. Set to the user id of the user to which email notifications of new bookmarks will be sent. Note that you should choose an id for a user that has an email address set up. By default, the admin user does not have an email address set.';
$lang['help_param_backbutton'] = 'Used with addform=true. When set, will include a back button on the form.';
$lang['help_param_addform'] = 'Set to "true" to display a form allowing users to submit bookmarks.';
$lang['help_param_target'] = 'Set to "_blank" to get all links to open in a new window.';
$lang['help_param_summaries'] = 'Set to "true" to display the summary information.';
$lang['help_param_makerssbutton'] = 'Set to display an RSS image that links to the RSS feed.';
$lang['help_param_autodetectlink'] = 'set to "true" to output the RSS autodetect <link> element for use in <head>. Best used in the "Advanced"->"Head Tags" section of content.';
$lang['help_param_orderbydate'] = 'Set to "true" to order the list of bookmarks by date. If set to true, will turn off show_category_with_title.';
$lang['help_param_type'] = 'Set to "text" for html display or "rss" for an rss feed. Default if not set is "text".';
$lang['help_param_number'] = 'Set to the maximum number of bookmarks to display. Most useful when used with order_by_date. ';
$lang['help_param_display_unapproved'] = 'Display unapproved bookmarks. (true or false)';
$lang['help_param_show_catwithtitle'] = 'Display the category at the start of the list. ';
$lang['help_param_category'] = 'Only display items for that category. Leaving unset, will show all categories. Note that you can limit to muliple categories by separating each one with a comman.';
$lang['help_param_columns'] = 'Number of columns to display the bookmark list in.';


// The help screen
$lang['help'] = '
		<h3>What does this do?</h3>
		<p>Bookmarks is a module for displaying bookmarks on your page. When the
		module is installed, a Bookmarks admin page is added to the Content menu
		that will allow you to manage your bookmarks.</p>
		<h3>Security</h3>
		<p>The user must belong to a group with the "Modify Bookmarks" permission
		in order to add, edit, or delete Bookmarks entries.</p>
		<h3>How do I use it?</h3>
		<p>The easiest way to use it is in conjunction with the cms_module tag.
		This will insert the module into your template or page anywhere you wish,
		and display bookmarks.  The code would look something like:
		<code>{cms_module module="bookmarks" columns="2" category="humour"}</code></p>';
$lang['changelog'] = '
			<p>Author: Rob Allen &lt;rob@akrabat.com&gt;</p>
			<dl>
				<dt>Version: 0.1</dt>
				<dd>Initial release. The code framework is based on the News module by Robert
					Campbell &lt;rob@techcom.dydnsns.org&gt;</dd>
				<dt>Version: 0.9</dt>
					<dd>First release of code to rest of world!</dd>
				<dt>Version: 0.9.1</dt>
					<dd>Bug fixes to help, column handling and the admin list.</dd>
				<dt>Version: 1.0</dt>
					<dd>Support email notifications from the submit bookmarks form. Addded delete option.
					Admin list now displays bookmarks that are not attached to any category.<br />
					Now required CommonCode 1.1<br />
					Tidied up code.<br />
					</dd>
				<dt>Version: 1.0.1</dt>
					<dd>Bug fixes that prevented display of the user facing submit form.</dd>
				<dt>Version: 1.0.2</dt>
					<dd>Uses CMS functions for CommonCode dependency.</dd>
				<dt>Version: 1.1</dt>
					<dd>Update to 0.8.</dd>
				<dt>Version: 1.3</dt>
					<dd>Update to 0.9.</dd>
				<dt>Version: 1.3.1</dt>
					<dd>Fix all default options so that the documented default is used. This is most obvious
					for the display code so that if type is not set, we correctly assume "text" rather than 
					"rss" now!. Also, fixed the API calls so that About works.</dd>
				<dt>Version: 1.3.2</dt>
					<dd>Minor tidy up and bug fixing.</dd>
				<dt>Version: 1.4 (Unreleased)</dt>
					<dd>Start of the Localization inplementation from westis.  This version was unreleased. (westis)</dd>
				<dt>Version: 2.0</dt>
					<dd>More Localization changes (NamantH)<br />
					Moved all rendered pages from code into templates. (NamantH)<br />
					Minor Bug fixing. (NamantH)<br />
					Added cancel button for forms, back to bookmarks menu. (NamantH)<br />
					Added handling for bookmarks that were not attached to categories. (NamantH)<br />
					Added quick Approve/Disapprove link on the bookmark list. (NamantH)<br />
					Changed the way categories are edited.  Instead of a list with two input fields, you have a seperate form. (NamantH)<br />
					Broke out the user add form into a template (NamantH).
					Broke out a seperate function to handle the user add form (NamantH).
					</dd>
			</dl>';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/ext/da_DK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Bogm&aelig;rker';
$lang['moddescription'] = 'Bookmarks is a module for displaying bookmarks on your page. When the module is installed, a Bookmarks admin page is added to the Content menu that will allow you to manage your bookmarks.';
$lang['postinstall'] = 'Make sure to set the &quot;Modify Bookmarks&quot; permission on users who will be administering bookmarks.';
$lang['postuninstall'] = 'Bogm&aelig;rker blev afinstalleret';
$lang['needpermission'] = 'You need the &#039;$permission&#039; permission to perform that function.';
$lang['addbookmark'] = 'Tilf&oslash;j bogm&aelig;rke';
$lang['managecategories'] = 'H&aring;ndt&eacute;r kategorier';
$lang['add'] = 'Tilf&oslash;j';
$lang['update'] = 'Opdat&eacute;r';
$lang['managebookmarks'] = 'H&aring;ndt&eacute;r bogm&aelig;rker';
$lang['title'] = 'Titel';
$lang['address'] = 'Adresse (med http://)';
$lang['approved'] = 'Godkendt';
$lang['summary'] = 'Resum&eacute;';
$lang['categories'] = 'Kategorier';
$lang['name'] = 'Navn';
$lang['order'] = 'R&aelig;kkef&oslash;lge';
$lang['updatecategories'] = 'Opdat&eacute;r kategorier';
$lang['filterby'] = 'Filtr&eacute;r p&aring;';
$lang['approvalstatus'] = 'Status for godkendelse';
$lang['sortgo'] = 'Go';
$lang['anystatus'] = 'Alle';
$lang['not_approved_only'] = 'Not Approved Only';
$lang['none'] = '== Ingen ==';
$lang['category'] = 'Kategori';
$lang['url'] = 'url';
$lang['default'] = 'Default';
$lang['bookmarks_rss'] = 'Bookmarks RSS';
$lang['rssfeed'] = 'RSS Feed';
$lang['submit'] = 'Submit';
$lang['new_bookmark_submitted_subject'] = 'New Bookmark Submitted';
$lang['new_bookmark_submitted_body'] = 'A new bookmark has been submitted';
$lang['mailheader_from'] = 'From';
$lang['mailheader_sender'] = 'CMSMS Bookmarks Module';
$lang['return'] = 'Return';
$lang['thank_you_for_submission'] = 'Thank you for your submission';
$lang['suredelete'] = 'Are you sure you want to delete the link %s?';
$lang['delete'] = 'Delete Bookmark';
$lang['title_categories_tab'] = 'Categories';
$lang['title_links_tab'] = 'Bookmarks';
$lang['help'] = '		<h3>What does this do?</h3>
		<p>Bookmarks is a module for displaying bookmarks on your page. When the
		module is installed, a Bookmarks admin page is added to the Content menu
		that will allow you to manage your bookmarks.</p>
		<h3>Security</h3>
		<p>The user must belong to a group with the &quot;Modify Bookmarks&quot; permission
		in order to add, edit, or delete Bookmarks entries.</p>
		<h3>How do I use it?</h3>
		<p>The easiest way to use it is in conjunction with the cms_module tag.
		This will insert the module into your template or page anywhere you wish,
		and display bookmarks.  The code would look something like:
		<code>{cms_module module=&quot;bookmarks&quot; columns=&quot;2&quot; category=&quot;humour&quot;}</code></p>
		<h3>What Parameters Exist?</h3>
		<table border=0 cellpadding=3 cellspacing=0>
		<tr>
			<td>columns</td>
			<td>Number of columns to display the bookmark list in. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>category</td>
			<td>Only display items for that category. Leaving unset, will show all categories. Note that
			you can limit to muliple categories by separating each one with a comman.<em>(optional)</em></td>
		</tr>
		<tr>
			<td>show_category_with_title</td>
			<td> Display the category at the start of the list. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>display_unapproved</td>
			<td>Display unapproved bookmarks. (true or false)<em>(optional)</em></td>
		</tr>
		<tr>
			<td>number</td>
			<td>Set to the maximum number of bookmarks to display. Most useful when used with
			order_by_date. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>type</td>
			<td>Set to &quot;text&quot; for html display or &quot;rss&quot; for an rss feed. Default if not set is
			&quot;text&quot;. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>order_by_date</td>
			<td>Set to &quot;true&quot; to order the list of bookmarks by date. If set to true, will turn
			off show_category_with_title. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>auto_detect_link</td>
			<td>set to &quot;true&quot; to output the RSS autodetect <link> element for use in
			<head>. Best used in the &quot;Advanced&quot;->&quot;Head Tags&quot; section of content.<em>(optional)</em></td>
		</tr>
		<tr>
			<td>makerssbutton</td>
			<td>Set to display an RSS image that links to the RSS feed. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>summaries</td>
			<td>Set to &quot;true&quot; to display the summary information. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>target</td>
			<td>Set to &quot;_blank&quot; to get all links to open in a new window. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>addform</td>
			<td>Set to &quot;true&quot; to display a form allowing users to submit bookmarks. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>include_back_button</td>
			<td>Used with addform=true. When set, will include a back button on the form. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>email_to</td>
			<td>Used with addform=true. Set to the user id of the user to which email notifications of
			new bookmarks will be sent. Note that you should choose an id for a user that has an email address
			set up. By default, the admin user does not have an email address set.<em>(optional)</em></td>
		</tr>
		<tr>
			<td>email_from</td>
			<td>Used with addform=true. Set to the user id to be used in the &quot;from&quot; field
			for email notifications. In general, you would user the admin user&#039;s id (1), but you must set an
			email address for the admin user as initially it does not have one.<em>(optional)</em></td>
		</tr>
		</table>';
$lang['changelog'] = '			<p>Author: Rob Allen <rob@akrabat.com></p>
			<dl>
				<dt>Version: 0.1</dt>
				<dd>Initial release. The code framework is based on the News module by Robert
					Campbell <rob@techcom.dydnsns.org></dd>
				<dt>Version: 0.9</dt>
					<dd>First release of code to rest of world!</dd>
				<dt>Version: 0.9.1</dt>
					<dd>Bug fixes to help, column handling and the admin list.</dd>
				<dt>Version: 1.0</dt>
					<dd>Support email notifications from the submit bookmarks form. Addded delete option.
					Admin list now displays bookmarks that are not attached to any category.<br />
					Now required CommonCode 1.1<br />
					Tidied up code.<br />
					</dd>
				<dt>Version: 1.0.1</dt>
					<dd>Bug fixes that prevented display of the user facing submit form.</dd>
				<dt>Version: 1.0.2</dt>
					<dd>Uses CMS functions for CommonCode dependency.</dd>
				<dt>Version: 1.1</dt>
					<dd>Update to 0.8.</dd>
				<dt>Version: 1.3</dt>
					<dd>Update to 0.9.</dd>
				<dt>Version: 1.3.1</dt>
					<dd>Fix all default options so that the documented default is used. This is most obvious
					for the display code so that if type is not set, we correctly assume &quot;text&quot; rather than 
					&quot;rss&quot; now!. Also, fixed the API calls so that About works.</dd>
				<dt>Version: 1.3.2</dt>
					<dd>Minor tidy up and bug fixing.</dd>
			</dl>';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Lesezeichen';
$lang['moddescription'] = 'Bookmarks ist ein Modul f&uuml;r die Anzeige von Lesezeichen auf ihrer Seite. Wenn das Modul installiert ist, wird dem Inhaltsmen&uuml; eine Link zur Verwaltung der Lesezeichen hinzugef&uuml;gt.';
$lang['postinstall'] = 'Stellen sie sicher, dass die User, welche die Lesezeichen verwalten sollen, die Berechtigung &quot;Modify Bookmarks&quot; haben.';
$lang['postuninstall'] = 'Modul ist deinstalliert.';
$lang['needpermission'] = 'Sie ben&ouml;tigen die Berechtigung &#039;$permission&#039;, um diese Funktion auszuf&uuml;hren.';
$lang['addbookmark'] = 'Lesezeichen hinzuf&uuml;gen';
$lang['managecategories'] = 'Kategorien verwalten';
$lang['add'] = 'Hinzuf&uuml;gen';
$lang['update'] = 'Aktualisieren';
$lang['managebookmarks'] = 'Lesezeichen verwalten';
$lang['title'] = 'Titel';
$lang['address'] = 'Adresse (incl. http://)';
$lang['approved'] = 'Genehmigt';
$lang['summary'] = 'Zusammenfassung';
$lang['categories'] = 'Kategorien';
$lang['name'] = 'Name';
$lang['order'] = 'Reihenfolge';
$lang['updatecategories'] = 'Kategorien aktualisieren';
$lang['filterby'] = 'Filtern nach';
$lang['approvalstatus'] = 'Genehmigungs-Status';
$lang['sortgo'] = 'Los';
$lang['anystatus'] = 'Egal';
$lang['not_approved_only'] = 'Noch nicht genehmigt';
$lang['none'] = '== Nichts ==';
$lang['category'] = 'Kategorie';
$lang['url'] = 'URL';
$lang['default'] = 'Standard';
$lang['bookmarks_rss'] = 'Bookmark-RSS';
$lang['rssfeed'] = 'RSS-Feed';
$lang['new_bookmark_submitted_subject'] = 'Neues Lesezeichen &uuml;bermittelt';
$lang['new_bookmark_submitted_body'] = 'Ein neues Lesezeichen wurde &uuml;bermittelt.';
$lang['mailheader_from'] = 'Von';
$lang['mailheader_sender'] = 'CMSms Lesezeichen Modul';
$lang['return'] = 'Zur&uuml;ck';
$lang['thank_you_for_submission'] = 'Vielen Dank f&uuml;r Ihre &Uuml;bermittlung';
$lang['category_head_text'] = 'Kategorien: ';
$lang['filter_results'] = 'Filter-Ergebnisse';
$lang['set_status_approved'] = 'Lesezeichen wurde als best&auml;tigt markiert.';
$lang['set_status_notapproved'] = 'Lesezeichen wurde als nicht best&auml;tigt markiert.';
$lang['title_error'] = 'Es ist ein Fehler aufgetreten.';
$lang['error'] = 'Fehler';
$lang['allcats'] = 'Alle Kategorien';
$lang['submit'] = 'Absenden';
$lang['cancel'] = 'Abbrechen';
$lang['addcat'] = 'Eine Kategorie hinzuf&uuml;gen';
$lang['addlink'] = 'Ein Lesezeichen hinzuf&uuml;gen';
$lang['addtemplate'] = 'Ein Template hinzuf&uuml;gen';
$lang['edittemplate'] = 'Ein Template bearbeiten';
$lang['suredelete'] = 'Sind Sie sicher, dass Sie das Lesezeichen %s l&ouml;schen m&ouml;chten?';
$lang['delete'] = 'Lesezeichen l&ouml;schen';
$lang['catdeleted'] = 'Kategorie gel&ouml;scht';
$lang['linkdeleted'] = 'Lesezeichen gel&ouml;scht';
$lang['templatedeleted'] = 'Template gel&ouml;scht';
$lang['suredeletecat'] = 'Sind Sie sicher, dass Sie die Kategorie %s l&ouml;schen m&ouml;chten?';
$lang['deletecat'] = 'Kategorie l&ouml;schen';
$lang['deletetemplate'] = 'Template l&ouml;schen';
$lang['catadded'] = 'Kategorien hinzugef&uuml;gt';
$lang['catedited'] = 'Kategorie aktualisiert';
$lang['bookmarkadded'] = 'Lesezeichen hinzugef&uuml;gt';
$lang['bookmarkedited'] = 'Lesezeichen aktualisiert';
$lang['templateadded'] = 'Template hinzugef&uuml;gt';
$lang['templateedited'] = 'Template aktualisiert';
$lang['settingsupdated'] = 'Einstellungen aktualisiert';
$lang['title_categories_tab'] = 'Kategorien';
$lang['title_links_tab'] = 'Lesezeichen';
$lang['title_templates_tab'] = 'Templates';
$lang['title_settings_tab'] = 'Einstellungen';
$lang['column_title'] = 'Titel';
$lang['column_url'] = 'URL';
$lang['column_summary'] = 'Zusammenfassung';
$lang['column_action'] = 'Aktionen';
$lang['column_approve'] = 'Best&auml;tigt';
$lang['column_category'] = 'Kategorien';
$lang['column_template'] = 'Templates';
$lang['column_bookid'] = 'ID';
$lang['nolinks'] = 'Es sind keine Lesezeichen in der Datenbank.';
$lang['nocats'] = 'Es sind keine Kategorien in der Datenbank.';
$lang['notemplates'] = 'Es sind keine Templates in der Datenbank.';
$lang['no_category'] = 'Keine Kategorie';
$lang['form_title'] = 'Titel';
$lang['form_descript'] = 'Beschreibung';
$lang['form_url'] = 'URL';
$lang['form_sort'] = 'Sortierreihenfolge';
$lang['form_status'] = 'Status';
$lang['form_cats'] = 'Kategorien';
$lang['form_logo'] = 'Logo';
$lang['form_template'] = 'Template';
$lang['title_default_template'] = 'Standard-Template';
$lang['title_show_linkids'] = 'Lesezeichen-ID&#039;s anzeigen';
$lang['status_approved'] = 'Best&auml;tigt';
$lang['status_notapproved'] = 'Nicht best&auml;tigt';
$lang['help_param_emailfrom'] = 'wird verwendet mit addform=true. Setzen sie hier die User-ID ein, dessen Email-Adresse im Feld &quot;from&quot; der Emailbenachrichtigung stehen soll. Grunds&auml;tzlich werden sie hier die User-ID des Administrators nutzen wollen (1). Beachten sie aber, da&szlig; sie f&uuml;r den Administrator eine g&uuml;ltige Email-Adresse eintragen m&uuml;ssen, falls sie es noch nicht getan haben.';
$lang['help_param_emailto'] = 'wird verwendet mit addform=true. Tragen sie hier die User-ID des Users ein, der per Email benachrichtigt werden soll, wenn ein neues Lesezeichen eingesandt wurde. Beachten sie aber, dass sie nur die ID eines Users ausw&auml;hlen sollten, f&uuml;r den auch eine Email-Adresse in der Datenbank existiert. Standardm&auml;&szlig;ig mu&szlig; der Administrator keine Email-Adresse angeben.';
$lang['help_param_backbutton'] = 'wird verwendet mit addform=true. Wenn dieser Wert gesetzt ist, wird im Formular ein &quot;Zur&uuml;ck&quot;-Button angezeigt.';
$lang['help_param_addform'] = 'Setzen sie den Wert auf &quot;true&quot;, um ein Formular anzuzeigen, mit dem User Lesezeichen &uuml;bermitteln k&ouml;nnen.';
$lang['help_param_target'] = 'Setzen sie den Wert auf &quot;_blank&quot;, um alle Lesezeichen in einem neuen Fenster zu &ouml;ffnen.';
$lang['help_param_summaries'] = 'Setzen sie den Wert auf &quot;true&quot;, um eine Zusammenfassung anzuzeigen.';
$lang['help_param_makerssbutton'] = 'Setzen sie diesen Wert, um ein RSS-Piktogramm mit einem Link zum RSS-Feed anzuzeigen.';
$lang['help_param_autodetectlink'] = 'Setzen sie den Wert auf &quot;true&quot;,  um das im <head>-Bereich der Standard-Templates vorhandene RSS-autodetect-<link>-Element zu nutzen. Sehr n&uuml;tzlich, wenn sie bei der Erstellung einer Seite eigene Metadaten eingeben (Tab Optionen).';
$lang['help_param_orderbydate'] = 'Setzen sie den Wert auf &quot;true&quot;, um die Lesezeichen nach Daum zu sortieren. Wenn er auf &quot;true&quot; gesetzt wurde, wird die Anzeige der Kategorie mit Titel deaktiviert.';
$lang['help_param_type'] = 'Setzen sie den Wert auf &quot;text&quot; f&uuml;r eine HTML-Anzeige oder auf &quot;rss&quot; f&uuml;r einen RSS-Feed. Standard ist &quot;text&quot;.';
$lang['help_param_number'] = 'Setzen sie den Wert f&uuml;r die maximal angezeigten Lesezeichen. Sehr n&uuml;tzlich, wenn es mit der Sortierung nach Datum angewendet wird.';
$lang['help_param_display_unapproved'] = 'zeigt nicht best&auml;tigte Lesezeichen an. (true oder false)';
$lang['help_param_show_catwithtitle'] = 'zeigt die Kategorie am Anfang der Liste an.';
$lang['help_param_category'] = 'zeigt nur Eintr&auml;ge f&uuml;r diese Kategorie an. Wird hier kein Wert angegeben, werden alle Kategorien angezeigt. <i>Hinweis:</i> Es k&ouml;nnen hier mehrere Kategorien angegeben werden. Diese m&uuml;ssen jeweils durch Komma voneinander getrennt werden.';
$lang['help_param_columns'] = 'Anzahl der Spalten f&uuml;r die Liste der Lesezeichen';
$lang['help_param_singlelink'] = 'Lesezeichen-ID.  Hiermit wird nur das Lesezeichen angezeigt, welches ausgew&auml;hlt wurde.  Mit dieser Einstellung wird nur der Template-Parameter ber&uuml;cksichtigt.';
$lang['help'] = '<h3>Was macht dieses Modul?</h3>
		<p>Bookmarks ist ein Modul zur Anzeige von Lesezeichen auf ihrer Seite. Wenn das
		Modul installiert ist, wird dem Men&uuml; &quot;Inhalt&quot; in der Administration ein Eintrag Bookmarks hinzugef&uuml;gt,
		&uuml;ber den sie ihre Lesezeichen verwalten k&ouml;nnen.</p>
		<h3>Sicherheit</h3>
		<p>Der User mu&szlig; einer Gruppe angeh&ouml;ren, die die Berechtigung &quot;Modify Bookmarks&quot; hat,
		Um Lesezeicheneintr&auml;ge hinzuf&uuml;gen, bearbeiten oder l&ouml;schen zu k&ouml;nnen.</p>
		<h3>wie wird es eingesetzt?</h3>
		<p>Der einfachste Weg ist die Verwendung in Verbindung mit dem cms_module-Tag.
		Dieser f&uuml;gt das Modul in ihr Template, ihre Seite oder an einem anderen gew&uuml;nschten Ort ein 
                und zeigt die Lesezeigen an. Der einzuf&uuml;gende Code sollte wie folgt aussehen:
		<code>{cms_module module=&quot;bookmarks&quot; columns=&quot;2&quot; category=&quot;humour&quot;}</code></p>';
$lang['changelog'] = '<p>Author: Rob Allen &amp;lt;rob@akrabat.com&amp;gt;</p>
			<dl>
				<dt>Version: 0.1</dt>
				<dd>Initial release. The code framework is based on the News module by Robert
					Campbell &amp;lt;rob@techcom.dydnsns.org&amp;gt;</dd>
				<dt>Version: 0.9</dt>
					<dd>First release of code to rest of world!</dd>
				<dt>Version: 0.9.1</dt>
					<dd>Bug fixes to help, column handling and the admin list.</dd>
				<dt>Version: 1.0</dt>
					<dd>Support email notifications from the submit bookmarks form. Addded delete option.
					Admin list now displays bookmarks that are not attached to any category.<br />
					Now required CommonCode 1.1<br />
					Tidied up code.<br />
					</dd>
				<dt>Version: 1.0.1</dt>
					<dd>Bug fixes that prevented display of the user facing submit form.</dd>
				<dt>Version: 1.0.2</dt>
					<dd>Uses CMS functions for CommonCode dependency.</dd>
				<dt>Version: 1.1</dt>
					<dd>Update to 0.8.</dd>
				<dt>Version: 1.3</dt>
					<dd>Update to 0.9.</dd>
				<dt>Version: 1.3.1</dt>
					<dd>Fix all default options so that the documented default is used. This is most obvious
					for the display code so that if type is not set, we correctly assume &quot;text&quot; rather than 
					&quot;rss&quot; now!. Also, fixed the API calls so that About works.</dd>
				<dt>Version: 1.3.2</dt>
					<dd>Minor tidy up and bug fixing.</dd>
				<dt>Version: 1.4 (Unreleased)</dt>
					<dd>Start of the Localization inplementation from westis.  This version was unreleased. (westis)</dd>
				<dt>Version: 2.0</dt>
					<dd>More Localization changes (NamantH)<br />
					Moved all rendered pages from code into templates. (NamantH)<br />
					Minor Bug fixing. (NamantH)<br />
					Added cancel button for forms, back to bookmarks menu. (NamantH)<br />
					Added handling for bookmarks that were not attached to categories. (NamantH)<br />
					Added quick Approve/Disapprove link on the bookmark list. (NamantH)<br />
					Changed the way categories are edited.  Instead of a list with two input fields, you have a seperate form. (NamantH)<br />
					Broke out the user add form into a template (NamantH).
					Broke out a seperate function to handle the user add form (NamantH).
					</dd>
				<dt>Version: 2.1</dt>
					<dd>Added in a Logo field for bookmarks<br />
					Added in filter by category in the filter<br />
					Added in templates table and sequence for holding the database templates for the user display<br />
					Added in a templates tab for editing the templates<br />
					Added in a settings tab.<br />
					Added Setting: Default template<br />
					Added Setting: Show Link ID&#039;s<br />
					Fixed listlinks.tpl to correctly show the ID when setting is selected.<br />
					Added in three templates for use:
					<ol>
					<li>Default: This is the standard multi column template.</li>
					<li>DescriptionLogo: Shows the bookmarks in a list with logo and description.</li>
					<li>SingleLink: This will show only one link.</li>
					</ol><br />
					
					</dd>
			</dl>';
$lang['utma'] = '156861353.21083652.1147240667.1147240667.1147240667.1';
$lang['utmz'] = '156861353.1147240667.1.1.utmccn=(direct)|utmcsr=(direct)|utmcmd=(none)';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fr_FR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Bookmarks';
$lang['moddescription'] = 'Bookmarks est un module pour afficher des liens sur vos pages. Quand le module est install&eacute;, une page d&#039;administration des lien est ajout&eacute;e au menu Contenu, qui vous permettra de g&eacute;rer les liens.';
$lang['postinstall'] = 'Assurez-vous de d&eacute;finir la permission &quot;Modify Bookmarks&quot; pour les utilisateurs qui g&eacute;reront les liens.';
$lang['postuninstall'] = 'Le module est d&eacute;sinstall&eacute;.';
$lang['needpermission'] = 'Vous avez besoin de la permission &#039;$permission&#039; pour effectuer cette fonction';
$lang['addbookmark'] = 'Ajout de lien';
$lang['managecategories'] = 'Gestion des cat&eacute;gories';
$lang['add'] = 'Ajout';
$lang['update'] = 'Mise &agrave; jour';
$lang['managebookmarks'] = 'Gestion des liens';
$lang['title'] = 'Titre';
$lang['address'] = 'Adresse (incl. http://)';
$lang['approved'] = 'Approuv&eacute;';
$lang['summary'] = 'Sommaire';
$lang['categories'] = 'Cat&eacute;gories';
$lang['name'] = 'Nom';
$lang['order'] = 'Ordre';
$lang['updatecategories'] = 'Mise &agrave; jour des cat&eacute;gories';
$lang['filterby'] = 'Filtrer par';
$lang['approvalstatus'] = 'Statut d&#039;approbation';
$lang['sortgo'] = 'Allez';
$lang['anystatus'] = 'N&#039;importe lequel';
$lang['not_approved_only'] = 'Seulement les liens non approuv&eacute;s';
$lang['none'] = '== Aucune ==';
$lang['category'] = 'Cat&eacute;gorie';
$lang['url'] = 'url';
$lang['default'] = 'D&eacute;faut';
$lang['bookmarks_rss'] = 'Flux RSS des liens';
$lang['rssfeed'] = 'Flux RSS';
$lang['new_bookmark_submitted_subject'] = 'Nouveau lien soumis';
$lang['new_bookmark_submitted_body'] = 'Un nouveau lien a &eacute;t&eacute; soumis';
$lang['mailheader_from'] = 'De';
$lang['mailheader_sender'] = 'Module de liens de CMSMS';
$lang['return'] = 'Retour';
$lang['thank_you_for_submission'] = 'Merci pour votre soumission';
$lang['category_head_text'] = 'Cat&eacute;gorie&nbsp;:';
$lang['filter_results'] = 'filter_results';
$lang['set_status_approved'] = 'Statut du lien approuv&eacute;';
$lang['set_status_notapproved'] = 'Statut du lien non approuv&eacute;';
$lang['title_error'] = 'Il y a eu une erreur';
$lang['error'] = 'Erreur';
$lang['allcats'] = 'Toutes les cat&eacute;gories';
$lang['submit'] = 'Soumettre';
$lang['cancel'] = 'Annuler';
$lang['addcat'] = 'Ajouter une cat&eacute;gorie';
$lang['addlink'] = 'Ajouter un lien';
$lang['addtemplate'] = 'Ajouter un gabarit';
$lang['edittemplate'] = '&Eacute;diter un gabarit';
$lang['suredelete'] = '&Ecirc;tes-vous s&ucirc;r de vouloir supprimer le lien %s?';
$lang['delete'] = 'Supprimer le lien';
$lang['catdeleted'] = 'Cat&eacute;gorie supprim&eacute;e';
$lang['linkdeleted'] = 'Lien supprim&eacute;';
$lang['templatedeleted'] = 'Gabarit supprim&eacute;';
$lang['suredeletecat'] = '&Ecirc;tes-vous s&ucirc;r de vouloir supprimer la cat&eacute;gorie %s?';
$lang['deletecat'] = 'Supprimer la cat&eacute;gorie';
$lang['deletetemplate'] = 'Supprimer le gabarit';
$lang['catadded'] = 'Cat&eacute;gorie ajout&eacute;e';
$lang['catedited'] = 'Cat&eacute;gorie mise &agrave; jour';
$lang['bookmarkadded'] = 'Lien ajout&eacute;';
$lang['bookmarkedited'] = 'Lien mis &agrave; jour';
$lang['templateadded'] = 'Gabarit ajout&eacute;';
$lang['templateedited'] = 'Gabarit mis &agrave; jour';
$lang['settingsupdated'] = 'Param&egrave;tres mis &agrave; jour';
$lang['title_categories_tab'] = 'Cat&eacute;gories';
$lang['title_links_tab'] = 'Liens';
$lang['title_templates_tab'] = 'Gabarits';
$lang['title_settings_tab'] = 'Param&egrave;tres';
$lang['column_title'] = 'Titre';
$lang['column_url'] = 'URL';
$lang['column_summary'] = 'Sommaire';
$lang['column_action'] = 'Actions';
$lang['column_approve'] = 'Approuv&eacute;';
$lang['column_category'] = 'Cat&eacute;gories';
$lang['column_template'] = 'Gabarits';
$lang['column_bookid'] = 'ID';
$lang['nolinks'] = 'Il n&#039;y a aucun lien dans la base de donn&eacute;es';
$lang['nocats'] = 'Il n&#039;y a aucune cat&eacute;gorie dans la base de donn&eacute;es';
$lang['notemplates'] = 'Il n&#039;y a aucun gabarit dans la base de donn&eacute;es';
$lang['no_category'] = 'Aucune cat&eacute;gorie';
$lang['form_title'] = 'Titre';
$lang['form_descript'] = 'Description';
$lang['form_url'] = 'URL';
$lang['form_sort'] = 'Ordre de tri';
$lang['form_status'] = 'Statut';
$lang['form_cats'] = 'Cat&eacute;gories';
$lang['form_logo'] = 'Logo';
$lang['form_template'] = 'Gabarit';
$lang['title_default_template'] = 'Gabarit par d&eacute;faut';
$lang['title_show_linkids'] = 'Afficher les ID des liens';
$lang['status_approved'] = 'Approuv&eacute;';
$lang['status_notapproved'] = 'Non approuv&eacute;';
$lang['help_param_emailfrom'] = 'Utilis&eacute; avec addform=true. D&eacute;fini l&#039;ID utilisateur qui doit &ecirc;tre l&#039;exp&eacute;diteur des notifications par email. En g&eacute;n&eacute;ral, vous d&eacute;finissezr l?ID de l&#039;admin(1), mais vous devez vous assurer qu&#039;une adresse email est entr&eacute;e pour l&#039;administrateur, car par d&eacute;faut, il n&#039;y en a pas.';
$lang['help_param_emailto'] = 'Utilis&eacute; avec addform=true. D&eacute;fini l&#039;utilisateur destinataire des emails de notification lorsqu&#039;un nouveau lien est soumis. Assurez-vous qu&#039;une adresse email soit d&eacute;finie pour cet utilisateur.';
$lang['help_param_backbutton'] = 'Utilis&eacute; avec addform=true. Quand d&eacute;fini, un bouton de retour sera inclus dans le formulaire.';
$lang['help_param_addform'] = 'D&eacute;finir en &quot;true&quot; pour afficher un formulaire autorisant les utilisateurs &agrave; soumettre des liens.';
$lang['help_param_target'] = 'D&eacute;finir en &quot;_blank&quot; pour que tous les liens s&#039;ouvrent dans un nouvelle fen&ecirc;tre';
$lang['help_param_summaries'] = 'D&eacute;finir en &quot;true&quot; pour afficher le sommaire des liens';
$lang['help_param_makerssbutton'] = 'D&eacute;finir pour afficher une image RSS qui lie au flux RSS.';
$lang['help_param_autodetectlink'] = 'D&eacute;finir en &quot;true&quot; pour g&eacute;n&eacute;rer automatiquement l&#039;&eacute;l&eacute;ment <link> &agrave; utiliser dans <head>. Meilleure utilisation dans &quot;Options&quot;->&quot;M&eacute;tadonn&eacute;es&quot; du contenu.';
$lang['help_param_orderbydate'] = 'D&eacute;finir en &quot;true&quot; pour trier la liste des liens par date. Si d&eacute;fini, cela d&eacute;sactivera show_category_with_title.';
$lang['help_param_type'] = 'D&eacute;finir en &quot;text&quot; pour l&#039;affichage html ou &quot;rss&quot; p&egrave;our le flux rss. Si non d&eacute;fini, &quot;text&quot; par d&eacute;faut.';
$lang['help_param_number'] = 'D&eacute;fini le nombre maximal de liens &agrave; afficher. Utile lorqu&#039;il est utilis&eacute; avec order_by_date. ';
$lang['help_param_display_unapproved'] = 'Afficher les liens non approuv&eacute;s. (true ou false)';
$lang['help_param_show_catwithtitle'] = 'Affiche la cat&eacute;gorie au d&eacute;but de la liste';
$lang['help_param_category'] = 'Affiche seulement les liens de cette cat&eacute;gorie. Si non d&eacute;finir, tous les liens de toutes les cat&eacute;gories seront affich&eacute;s. Vous pouvez choisir des cat&eacute;gories multiples en les s&eacute;parant par une virgule.';
$lang['help_param_columns'] = 'Nombre de colonnes pour l&#039;affichage des liens';
$lang['help_param_singlelink'] = 'bookmark_id.  Ceci n&#039;affichera que le lien sp&eacute;cifi&eacute;. Le seul param&egrave;tre utilisable avec ceci est le gabarit.';
$lang['help'] = '		<h3>Que fait ce module?</h3>
		<p>Le module Liens (Bookmarks) est un module pour afficher des liens sur vos pages. Quand le module est install&eacute;, un panneau d&#039;administration des Liens est ajout&eacute; au menu Contenu, qui vous permettra de g&eacute;rer vos liens. 
		<h3>Securit&eacute;</h3>
		<p>L&#039;utilisateur doit appartenir &agrave; un groupe ayant la permission &quot;Modify Bookmarks&quot; pour pouvoir ajouter, &eacute;diter ou supprimer des Liens</p>
		<h3>Comment l&#039;utiliser?</h3>
		<p>Le meilleur moyen est de l&#039;utiliser avec le tag cms_module.
		Cec i va ins&eacute;rer le module dans votre gabarit ou page, &agrave; l&#039;endroit d&eacute;sir&eacute; et va afficher les Liens. Le code sera tel que <code>{cms_module module=&quot;bookmarks&quot; columns=&quot;2&quot; category=&quot;humour&quot;}</code></p>';
$lang['changelog'] = '			<p>Auteur: Rob Allen <rob@akrabat.com></p>
			<dl>
				<dt>Version: 0.1</dt>
				<dd>Version initiale. Le code de d&eacute;part est bas&eacute; sur le module News par Robert Campbell <rob@techcom.dydnsns.org></dd>
				<dt>Version: 0.9</dt>
					<dd>Premi&egrave;re version disponible pour le reste du monde!</dd>
				<dt>Version: 0.9.1</dt>
					<dd>Correction apport&eacute;e dans l&#039;aide, support des colonnes, et au panneau d&#039;adminsitration.</dd>
				<dt>Version: 1.0</dt>
					<dd>Support des notification par email depuis le formulaire de soumission. Ajout de l&#039;option de supprssion. La liste dans l&#039;administration affiche maintenant le liens qui ne sont attach&eacute;s &agrave; aucune cat&eacute;gorie.<br />
					Requiert maintenant CommonCode 1.1<br />
					Nettoyage du code.<br />
					</dd>
				<dt>Version: 1.0.1</dt>
					<dd>Correction du d&eacute;faut qui ne permettait pas l&#039;affichage su formulaire.</dd>
				<dt>Version: 1.0.2</dt>
					<dd>Utilise les fonction CMS pour la d&eacute;pendance &agrave; CommonCode.</dd>
				<dt>Version: 1.1</dt>
					<dd>Mis &agrave; jour &agrave; 0.8.</dd>
				<dt>Version: 1.3</dt>
					<dd>Mis &agrave; jour &agrave; 0.9.</dd>
				<dt>Version: 1.3.1</dt>
					<dd>Correction de toutes les options par d&eacute;faut, afin que les valeurs par d&eacute;faut soient utilis&eacute;es correctement. Le plus flagrant est l&#039;option type, nous assumons maintenant correctement que le type par d&eacute;faut est &quot;text&quot; plut&ocirc;t que &quot;rss&quot;. Aussi, correction des appels API, pour que la partie &quot;&Agrave; propos&quot; fonctionne.</dd>
				<dt>Version: 1.3.2</dt>
					<dd>Nettoyage et correction mineurs.</dd>
				<dt>Version: 1.4 (Unreleased)</dt>
					<dd>D&eacute;but de la localisation par westis.  Cette version n&#039;est pas publi&eacute;e. (westis)</dd>
				<dt>Version: 2.0</dt>
					<dd>D&#039;autres changements de localisation (NamantH)<br />
					D&eacute;placement de tous les rendus dans des gabarits. (NamantH)<br />
					Corrections mineures. (NamantH)<br />
					Ajout d&#039;un bouton Annuler sur les formulaires, et Retour au menu des Liens. (NamantH)<br />
					Ajout du support des lIens qui ne sont attach&eacute;s &agrave; aucune cat&eacute;gorie. (NamantH)<br />
					Ajout d&#039;un lien rapide pour l&#039;approbation et d&eacute;sapprobation dans la liste du panneau d&#039;administration des Liens. (NamantH)<br />
					Chang&eacute; la fa&ccedil;on dont les cat&eacute;gories sont &eacute;dit&eacute;es. Au lieu d&#039;une liste avec 2 champs, il y a un formulaire s&eacute;par&eacute;. (NamantH)<br />
					Formulaire utilisateur pour l&#039;ajout transform&eacute; en gabarit (NamantH).
					Gestion du formulaire utilisateur transform&eacute;e en fonction(NamantH).
					</dd>
				<dt>Version: 2.1</dt>
					<dd>Ajout d&#039;un champ Logo pour les Liens<br />
					Ajout du filtre par cat&eacute;gorie<br />
					Ajout d&#039;une s&eacute;quence dans la table des gabarits pour la gestion des gabarits se trouvant dans la base de donn&eacute;es (affichage utilisateur)<br />
					Ajout d&#039;un onglet pour l&#039;&eacute;dition des gabarit<br />
					Ajout d&#039;un onglet pour l&#039;&eacute;dition des param&egrave;tres<br />
					Ajout du param&egrave;tre &quot;Gabarit par d&eacute;faut&quot;<br />
					Ajout du param&egrave;tre &quot;Afficher l&#039;ID du Lien&quot;<br />
					Correction de listlinks.tpl pour l&#039;affichage de l&#039;ID quand ce param&egrave;tre est d&eacute;fini.<br />
					Ajout de trois gabarits pour l&#039;utilisation&nbsp;:
					<ol>
					<li>Default: c&#039;est le gabarit standard, avec 3 colonnes.</li>
					<li>DescriptionLogo: Affiche les Liens dans une liste, avec Logo et description.</li>
					<li>SingleLink: Affiche un lien unique.</li>
					</ol><br />
					
					</dd>
			</dl>';
$lang['utmz'] = '156861353.1152973895.15.5.utmccn=(referral)|utmcsr=nukketaiteilijat.org|utmcct=/index.php|utmcmd=referral';
$lang['utma'] = '156861353.441775673.1149914315.1153314789.1153496953.18';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/it_IT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Bookmarks';
$lang['moddescription'] = 'Bookmarks &egrave; un modulo per visualizzare link sulla vostra pagina. Quando il modulo &egrave; installato, un link alla pagina di amministrazione dei Bookmarks che permette di gestire i vostri segnalibri &egrave; aggiunto in fondo al menu.';
$lang['postinstall'] = 'Essere sicuri di settare il permesso &quot;Modifica Bookmarks&quot; agli utenti che amministreranno i link.';
$lang['postuninstall'] = 'Modulo disinstallato.';
$lang['needpermission'] = 'Hai bisogno del permesso &#039;$permission&#039; per utilizzare questa funzione.';
$lang['addbookmark'] = 'Aggiungi link';
$lang['managecategories'] = 'Gestione categorie';
$lang['add'] = 'Aggiungi';
$lang['update'] = 'Aggiorna';
$lang['managebookmarks'] = 'Gestione link';
$lang['title'] = 'Titolo';
$lang['address'] = 'Indirizzo (incluso http://)';
$lang['approved'] = 'Approvato';
$lang['summary'] = 'Sommario';
$lang['categories'] = 'Categorie';
$lang['name'] = 'Nome';
$lang['order'] = 'Ordine';
$lang['updatecategories'] = 'Aggiorna categorie';
$lang['filterby'] = 'Filtrato per';
$lang['approvalstatus'] = 'Stato di approvato';
$lang['sortgo'] = 'Vai';
$lang['anystatus'] = 'Molti';
$lang['not_approved_only'] = 'Non approvato';
$lang['none'] = '== Nessuno ==';
$lang['category'] = 'Categoria';
$lang['url'] = 'indirizzo';
$lang['default'] = 'Predefinito';
$lang['bookmarks_rss'] = 'Link RSS';
$lang['rssfeed'] = 'Feed RSS';
$lang['new_bookmark_submitted_subject'] = 'Nuovo link inoltrato';
$lang['new_bookmark_submitted_body'] = 'Un nuovo link &egrave; stato inoltrato';
$lang['mailheader_from'] = 'Da';
$lang['mailheader_sender'] = 'Modulo Bookmarks';
$lang['return'] = 'Ritorno';
$lang['thank_you_for_submission'] = 'Grazie per il vostro inoltro';
$lang['category_head_text'] = 'Categoria: ';
$lang['filter_results'] = 'filtro_risultati';
$lang['set_status_approved'] = 'Stato del link configurato come approvato';
$lang['set_status_notapproved'] = 'Stato del link configurato come non approvato';
$lang['title_error'] = 'Si &egrave; verificato un errore';
$lang['error'] = 'Errore';
$lang['allcats'] = 'Tutte le categorie';
$lang['submit'] = 'Inoltra';
$lang['cancel'] = 'Cancella';
$lang['addcat'] = 'Aggiungi una categoria';
$lang['addlink'] = 'Aggiungi un link';
$lang['addtemplate'] = 'Aggiungi un Modello';
$lang['edittemplate'] = 'Modifica un Modello';
$lang['suredelete'] = 'Sei sicuro che vuoi cancellare il link %s?';
$lang['delete'] = 'Cancella link';
$lang['catdeleted'] = 'Categoria cancellata';
$lang['linkdeleted'] = 'Link cancellato';
$lang['templatedeleted'] = 'Modello cancellato';
$lang['suredeletecat'] = 'Sei sicuro di voler cancellare la categoria %s?';
$lang['deletecat'] = 'Cancella categoria';
$lang['deletetemplate'] = 'Cancellazione Modello';
$lang['catadded'] = 'Categoria aggiunta';
$lang['catedited'] = 'Categoria aggiornata';
$lang['bookmarkadded'] = 'Link aggiunto';
$lang['bookmarkedited'] = 'Link aggiornato';
$lang['templateadded'] = 'Modello aggiunto';
$lang['templateedited'] = 'Modello aggiornato';
$lang['settingsupdated'] = 'Configurazioni aggiornate';
$lang['title_categories_tab'] = 'Categorie';
$lang['title_links_tab'] = 'Links';
$lang['title_templates_tab'] = 'Modelli';
$lang['title_settings_tab'] = 'Configurazioni';
$lang['column_title'] = 'Titolo';
$lang['column_url'] = 'Indirizzo URL';
$lang['column_summary'] = 'Sommario';
$lang['column_action'] = 'Azione';
$lang['column_approve'] = 'Approvato';
$lang['column_category'] = 'Categorie';
$lang['column_template'] = 'Modelli';
$lang['column_bookid'] = 'ID';
$lang['nolinks'] = 'Non ci sono link nel database.';
$lang['nocats'] = 'Non ci sono categorie nel database.';
$lang['notemplates'] = 'Non ci sono Modelli nel database.';
$lang['no_category'] = 'Nessuna categoria';
$lang['form_title'] = 'Titolo';
$lang['form_descript'] = 'Descrizione';
$lang['form_url'] = 'Indirizzo URL';
$lang['form_sort'] = 'Ordine';
$lang['form_status'] = 'Stato';
$lang['form_cats'] = 'Categorie';
$lang['form_logo'] = 'Logo';
$lang['form_template'] = 'Modello';
$lang['title_default_template'] = 'Modello predefinito';
$lang['title_show_linkids'] = 'Mostra ID dei link';
$lang['status_approved'] = 'Approvato';
$lang['status_notapproved'] = 'Non approvato';
$lang['help_param_emailfrom'] = 'Usato con addform=true. Configurare allo user ID dell&#039;utente da utilizzarlo come mittente nel campo &quot;Da&quot; della email di notifica. In generale, dovreste usare l&#039;ID dell&#039;utente amministratore (=1), ma deve essere configurato con un indirizzo email.';
$lang['help_param_emailto'] = 'Usato con addform=true. Configurare allo user ID dell&#039;utente al quale si notifica via email dell&#039;avvenuto inserimento di un nuovo link. Si nota che dovete scegliere un user ID di un utente che abbia configurato un indirizzo email, ad esempio, lo user admin non ha predefinito un indirizzo email.';
$lang['help_param_backbutton'] = 'Usato con addform=true. Quando configurato, include un bottone di ritorno sul modulo..';
$lang['help_param_addform'] = 'Configurato a &quot;true&quot; visualizza un modulo per permettere agli utenti di inoltrare link.';
$lang['help_param_target'] = 'Configurato a &quot;_blank&quot; porta ad aprire tutti i link in una nuova finestra.';
$lang['help_param_summaries'] = 'Configurato a &quot;true&quot; visualizza le informazioni del sommario.';
$lang['help_param_makerssbutton'] = 'Se configurato visualizza una immagine con la scritta RSS ed il link al feed RSS.';
$lang['help_param_autodetectlink'] = 'Configurato a &quot;true&quot; fa uscire l&#039;elemento <link> del RSS autodetect per usarlo in <head>. L&#039;uso migliore &egrave; nella sezione &quot;Avanzate&quot;->&quot;Head Tags&quot; del contenuto.';
$lang['help_param_orderbydate'] = 'Configurato a &quot;true&quot; ordina la lista per data. Si noti che questo comporta la configurazione a &quot;false&quot; di show_category_with_title.';
$lang['help_param_type'] = 'Configurato a &quot;text&quot; visualizza in formato html oppure &quot;rss&quot; per formato rss feed. Predefinito, se non configurato, &egrave; &quot;text&quot;.';
$lang['help_param_number'] = 'Configura il massimo numero di link da visualizzare. Molto utile se usato assieme a order_by_date.';
$lang['help_param_display_unapproved'] = 'Visualizza link non approvati. (true o false)';
$lang['help_param_show_catwithtitle'] = 'Visualizza la categoria all&#039;inizio della lista. ';
$lang['help_param_category'] = 'Visualizza solo i link di quella categoria. Lasciando vuoto, mostrer&agrave; tutte le categorie. Si nota che puoi limitare a multiple categorie separando ciascuna con una virgola.';
$lang['help_param_columns'] = 'Numero di colonne da visualizzare la lista del link.';
$lang['help_param_singlelink'] = 'bookmark_id. Con questo Viene mostrato solo il link selezionato. Solo il parametro template sar&agrave; usato con questo parametro.';
$lang['help'] = '		<h3>Che cosa fa?</h3>
		<p>Bookmarks &egrave; un modulo per visualizzare link sulla vostra pagina. Quando il modulo &egrave; installato, un link alla pagina di amministrazione dei Bookmarks che permette di gestire i vostri segnalibri &egrave; aggiunto in fondo al menu.</p>
		<h3>Sicurezza</h3>
		<p>L&#039;utente deve appartenere ad un gruppo con il permesso &quot;Modifica Bookmarks&quot; per aggiungere, modificare o cancellare link.</p>
		<h3>Come usarlo?</h3>
		<p>Il modo pi&ugrave; semplice &egrave; in con il tag cms_module.
		Questo, inserito dove preferite il modulo nel template o pagina, visualizzer&agrave; i link. Esempio di sintassi:
		<code>{cms_module module=&quot;bookmarks&quot; columns=&quot;2&quot; category=&quot;humour&quot;}</code></p>';
$lang['changelog'] = '			<p>Author: Rob Allen <rob@akrabat.com></p>
			<dl>
				<dt>Version: 0.1</dt>
				<dd>Initial release. The code framework is based on the News module by Robert
					Campbell <rob@techcom.dydnsns.org></dd>
				<dt>Version: 0.9</dt>
					<dd>First release of code to rest of world!</dd>
				<dt>Version: 0.9.1</dt>
					<dd>Bug fixes to help, column handling and the admin list.</dd>
				<dt>Version: 1.0</dt>
					<dd>Support email notifications from the submit bookmarks form. Addded delete option.
					Admin list now displays bookmarks that are not attached to any category.<br />
					Now required CommonCode 1.1<br />
					Tidied up code.<br />
					</dd>
				<dt>Version: 1.0.1</dt>
					<dd>Bug fixes that prevented display of the user facing submit form.</dd>
				<dt>Version: 1.0.2</dt>
					<dd>Uses CMS functions for CommonCode dependency.</dd>
				<dt>Version: 1.1</dt>
					<dd>Update to 0.8.</dd>
				<dt>Version: 1.3</dt>
					<dd>Update to 0.9.</dd>
				<dt>Version: 1.3.1</dt>
					<dd>Fix all default options so that the documented default is used. This is most obvious
					for the display code so that if type is not set, we correctly assume &quot;text&quot; rather than 
					&quot;rss&quot; now!. Also, fixed the API calls so that About works.</dd>
				<dt>Version: 1.3.2</dt>
					<dd>Minor tidy up and bug fixing.</dd>
				<dt>Version: 1.4 (Unreleased)</dt>
					<dd>Start of the Localization inplementation from westis.  This version was unreleased. (westis)</dd>
				<dt>Version: 2.0</dt>
					<dd>More Localization changes (NamantH)<br />
					Moved all rendered pages from code into templates. (NamantH)<br />
					Minor Bug fixing. (NamantH)<br />
					Added cancel button for forms, back to bookmarks menu. (NamantH)<br />
					Added handling for bookmarks that were not attached to categories. (NamantH)<br />
					Added quick Approve/Disapprove link on the bookmark list. (NamantH)<br />
					Changed the way categories are edited.  Instead of a list with two input fields, you have a seperate form. (NamantH)<br />
					Broke out the user add form into a template (NamantH).
					Broke out a seperate function to handle the user add form (NamantH).
					</dd>
				<dt>Version: 2.1</dt>
					<dd>Added in a Logo field for bookmarks<br />
					Added in filter by category in the filter<br />
					Added in templates table and sequence for holding the database templates for the user display<br />
					Added in a templates tab for editing the templates<br />
					Added in a settings tab.<br />
					Added Setting: Default template<br />
					Added Setting: Show Link ID&#039;s<br />
					Fixed listlinks.tpl to correctly show the ID when setting is selected.<br />
					Added in three templates for use:
					<ol>
					<li>Default: This is the standard multi column template.</li>
					<li>DescriptionLogo: Shows the bookmarks in a list with logo and description.</li>
					<li>SingleLink: This will show only one link.</li>
					</ol><br />
					
					</dd>
			</dl>';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nb_NO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Bokmerke';
$lang['moddescription'] = 'Bokmerke er en modul for &aring; vise bokmerker p&aring; din side. En bokmerke admin side blir lagt til p&aring; Content menyen, n&aring;r modulen er installert. Her vil du kunne administrere dine bokmerker.';
$lang['postinstall'] = 'Kryss av for &quot;Modifiser Bokmerker&quot; tilladelse p&aring; brukere som skal kunne administrere  bokmerkene.';
$lang['postuninstall'] = 'Modul er avinstallert.';
$lang['needpermission'] = 'Du trenger &#039;$permission&#039; tilladelse for &aring; utf&oslash;re denne funksjonen.';
$lang['addbookmark'] = 'Legg til bokmerke';
$lang['managecategories'] = 'Ordne Kategorier';
$lang['add'] = 'Legg til';
$lang['update'] = 'Opdater';
$lang['managebookmarks'] = 'Ordne Bokmerker';
$lang['title'] = 'Tittel';
$lang['address'] = 'Adresse (inkl. http://)';
$lang['approved'] = 'Godkjent';
$lang['summary'] = 'Sammendrag';
$lang['categories'] = 'Kategorier';
$lang['name'] = 'Navn';
$lang['order'] = 'Rekkef&oslash;lge';
$lang['updatecategories'] = 'Opdater Kategorier';
$lang['filterby'] = 'Filtrer ved ';
$lang['approvalstatus'] = 'Godkjennings-status';
$lang['sortgo'] = 'G&aring;';
$lang['anystatus'] = 'Alle';
$lang['not_approved_only'] = 'Bare ikke godkjente';
$lang['none'] = '== Ingen ==';
$lang['category'] = 'Kategori';
$lang['url'] = 'link';
$lang['default'] = 'Standard';
$lang['bookmarks_rss'] = 'RSS Bokmerker';
$lang['rssfeed'] = 'RSS feed ';
$lang['new_bookmark_submitted_subject'] = 'Nytt Bokmerke Lagret';
$lang['new_bookmark_submitted_body'] = 'Et nytt bokmerke har blitt lagret';
$lang['mailheader_from'] = 'Fra';
$lang['mailheader_sender'] = 'CMSMS Bokmerke Modul';
$lang['return'] = 'Tilbake';
$lang['thank_you_for_submission'] = 'Takk for ditt bidrag';
$lang['category_head_text'] = 'Kategori: ';
$lang['filter_results'] = 'filter resultat';
$lang['set_status_approved'] = 'Bokmerke godkjent';
$lang['set_status_notapproved'] = 'Bokmerke ikke godkjent';
$lang['title_error'] = 'Det oppstod en feil';
$lang['error'] = 'Feil';
$lang['allcats'] = 'Alle kategorier';
$lang['submit'] = 'Lagre';
$lang['cancel'] = 'Avbryt';
$lang['addcat'] = 'Legg til Kategori';
$lang['addlink'] = 'Legg til bokmerke';
$lang['addtemplate'] = 'Legg til mal';
$lang['edittemplate'] = 'Rediger mal';
$lang['suredelete'] = '&Oslash;nsker du virkelig &aring; slette linken %s?';
$lang['delete'] = 'Slett bokmerke';
$lang['catdeleted'] = 'Kategori slettet';
$lang['linkdeleted'] = 'Bokmerke slettet';
$lang['templatedeleted'] = 'Mal slettet';
$lang['suredeletecat'] = '&Oslash;nsker du virkelig &aring; slette kategorien %s?';
$lang['deletecat'] = 'Slett kategori';
$lang['deletetemplate'] = 'Slett mal';
$lang['catadded'] = 'Kategori lagt til';
$lang['catedited'] = 'Kategori endret';
$lang['bookmarkadded'] = 'Bokmerke lagt til';
$lang['bookmarkedited'] = 'Bokmerke endret';
$lang['templateadded'] = 'Mal lagt til';
$lang['templateedited'] = 'Mal endret';
$lang['settingsupdated'] = 'Instillinger oppdatert';
$lang['title_categories_tab'] = 'Kategorier';
$lang['title_links_tab'] = 'Bokmerker';
$lang['title_templates_tab'] = 'Maler';
$lang['title_settings_tab'] = 'Instillinger';
$lang['column_title'] = 'Tittel';
$lang['column_url'] = 'Link';
$lang['column_summary'] = 'Sammendrag';
$lang['column_action'] = 'Handlinger';
$lang['column_approve'] = 'Godkjent';
$lang['column_category'] = 'Kategorier';
$lang['column_template'] = 'Maler';
$lang['column_bookid'] = 'ID ';
$lang['nolinks'] = 'Det er ingen linker i databasen.';
$lang['nocats'] = 'Det er ingen kategorier i databasen.';
$lang['notemplates'] = 'Det er ingen maler i databasen.';
$lang['no_category'] = 'Ingen kategori';
$lang['form_title'] = 'Tittel';
$lang['form_descript'] = 'beskrivelse';
$lang['form_url'] = 'Link';
$lang['form_sort'] = 'Sorteringsrekkef&oslash;lge';
$lang['form_status'] = 'Status ';
$lang['form_cats'] = 'Kategorier';
$lang['form_logo'] = 'Logo ';
$lang['form_template'] = 'Mal';
$lang['title_default_template'] = 'Standard mal';
$lang['title_show_linkids'] = 'Vis bokmerke ID&#039;er';
$lang['status_approved'] = 'Godkjent';
$lang['status_notapproved'] = 'Ikke godkjent';
$lang['help_param_emailfrom'] = 'Brukt med addform=true. Satt til brukerens id for &aring; bli brukt i &quot;from&quot; feltet for email meldinger. Generelt vil du bruke admin brukerens id (1), men du m&aring; sette en emailadresse for admin brukeren da denne opprinnelig ikke har noen.';
$lang['help_param_emailto'] = 'Brukt med addform=true. Satt til brukerens id for den brukeren som skal ha tilsendt email meldinger om nye bokmerker. Du m&aring; velge en id for en bruker som har en emailadresse oppsatt. Standard, admin brukeren har ikke en emailadresse satt.';
$lang['help_param_backbutton'] = 'Brukt med addform=true. N&aring;r satt vil den inkludere en tilbake-knapp p&aring; skjemaet.';
$lang['help_param_addform'] = 'Satt til &quot;true&quot; for &aring; vise et skjema som tillater brukere &aring; legge til bokmerker.';
$lang['help_param_target'] = 'Satt til &quot;_blank&quot; for &aring; f&aring; alle linker til &aring; &aring;pnes i et nytt vindu.';
$lang['help_param_summaries'] = 'Satt til &quot;true&quot; for &aring; vise sammendrags informasjon.';
$lang['help_param_makerssbutton'] = 'Sett for &aring; vise et RSS bilde som lenker til RSS feed&#039;en.';
$lang['help_param_autodetectlink'] = 'Satt til &quot;true&quot; for &aring; sende ut RSS autodetect <link> elementet for bruk i <head>. Best brukt i &quot;Advanced&quot;->&quot;Head Tags&quot; seksjonen av innhold.';
$lang['help_param_orderbydate'] = 'Satt til &quot;true&quot; for &aring; sortere listen med bokmerker etter dato. Om satt til sann vil den sl&aring; av show_category_with_title.';
$lang['help_param_type'] = 'Satt til &quot;text&quot; for html visning eller &quot;rss&quot; for en rss feed. Standard om ikke satt er &quot;text&quot;.';
$lang['help_param_number'] = 'Sett maksimum antall bokmerker &aring; vise. Mest nyttig n&aring;r brukt med order_by_date. ';
$lang['help_param_display_unapproved'] = 'Vis ikke godkjente bokmerker. (true or false)';
$lang['help_param_show_catwithtitle'] = 'Vis kategorien p&aring; f&oslash;rsten av listen.';
$lang['help_param_category'] = 'Vis kun artikler for den kategorien. La v&aelig;re usatt, vil vise alle kategorier. Vi at du kan begrense til flere kategorier ved &aring; separere dem med komma.';
$lang['help_param_columns'] = 'Antall kolonner &aring; vise bokmerke listen i.';
$lang['help_param_singlelink'] = 'bookmark_id.  Dett vil vise kun linken som er valgt.  Kun mal parameteret vil bli brukt i dette oppsettet.';
$lang['help'] = '		<h3>What does this do?</h3>
		<p>Bookmarks is a module for displaying bookmarks on your page. When the
		module is installed, a Bookmarks admin page is added to the Content menu
		that will allow you to manage your bookmarks.</p>
		<h3>Security</h3>
		<p>The user must belong to a group with the &quot;Modify Bookmarks&quot; permission
		in order to add, edit, or delete Bookmarks entries.</p>
		<h3>How do I use it?</h3>
		<p>The easiest way to use it is in conjunction with the cms_module tag.
		This will insert the module into your template or page anywhere you wish,
		and display bookmarks.  The code would look something like:
		<code>{cms_module module=&quot;bookmarks&quot; columns=&quot;2&quot; category=&quot;humour&quot;}</code></p>
		<h3>What Parameters Exist?</h3>
		<table border=0 cellpadding=3 cellspacing=0>
		<tr>
			<td>columns</td>
			<td>Number of columns to display the bookmark list in. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>category</td>
			<td>Only display items for that category. Leaving unset, will show all categories. Note that
			you can limit to muliple categories by separating each one with a comman.<em>(optional)</em></td>
		</tr>
		<tr>
			<td>show_category_with_title</td>
			<td> Display the category at the start of the list. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>display_unapproved</td>
			<td>Display unapproved bookmarks. (true or false)<em>(optional)</em></td>
		</tr>
		<tr>
			<td>number</td>
			<td>Set to the maximum number of bookmarks to display. Most useful when used with
			order_by_date. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>type</td>
			<td>Set to &quot;text&quot; for html display or &quot;rss&quot; for an rss feed. Default if not set is
			&quot;text&quot;. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>order_by_date</td>
			<td>Set to &quot;true&quot; to order the list of bookmarks by date. If set to true, will turn
			off show_category_with_title. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>auto_detect_link</td>
			<td>set to &quot;true&quot; to output the RSS autodetect <link> element for use in
			<head>. Best used in the &quot;Advanced&quot;->&quot;Head Tags&quot; section of content.<em>(optional)</em></td>
		</tr>
		<tr>
			<td>makerssbutton</td>
			<td>Set to display an RSS image that links to the RSS feed. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>summaries</td>
			<td>Set to &quot;true&quot; to display the summary information. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>target</td>
			<td>Set to &quot;_blank&quot; to get all links to open in a new window. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>addform</td>
			<td>Set to &quot;true&quot; to display a form allowing users to submit bookmarks. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>include_back_button</td>
			<td>Used with addform=true. When set, will include a back button on the form. <em>(optional)</em></td>
		</tr>
		<tr>
			<td>email_to</td>
			<td>Used with addform=true. Set to the user id of the user to which email notifications of
			new bookmarks will be sent. Note that you should choose an id for a user that has an email address
			set up. By default, the admin user does not have an email address set.<em>(optional)</em></td>
		</tr>
		<tr>
			<td>email_from</td>
			<td>Used with addform=true. Set to the user id to be used in the &quot;from&quot; field
			for email notifications. In general, you would user the admin user&#039;s id (1), but you must set an
			email address for the admin user as initially it does not have one.<em>(optional)</em></td>
		</tr>
		</table>';
$lang['changelog'] = '			<p>Author: Rob Allen <rob@akrabat.com></p>
			<dl>
				<dt>Version: 0.1</dt>
				<dd>Initial release. The code framework is based on the News module by Robert
					Campbell <rob@techcom.dydnsns.org></dd>
				<dt>Version: 0.9</dt>
					<dd>First release of code to rest of world!</dd>
				<dt>Version: 0.9.1</dt>
					<dd>Bug fixes to help, column handling and the admin list.</dd>
				<dt>Version: 1.0</dt>
					<dd>Support email notifications from the submit bookmarks form. Addded delete option.
					Admin list now displays bookmarks that are not attached to any category.<br />
					Now required CommonCode 1.1<br />
					Tidied up code.<br />
					</dd>
				<dt>Version: 1.0.1</dt>
					<dd>Bug fixes that prevented display of the user facing submit form.</dd>
				<dt>Version: 1.0.2</dt>
					<dd>Uses CMS functions for CommonCode dependency.</dd>
				<dt>Version: 1.1</dt>
					<dd>Update to 0.8.</dd>
				<dt>Version: 1.3</dt>
					<dd>Update to 0.9.</dd>
				<dt>Version: 1.3.1</dt>
					<dd>Fix all default options so that the documented default is used. This is most obvious
					for the display code so that if type is not set, we correctly assume &quot;text&quot; rather than 
					&quot;rss&quot; now!. Also, fixed the API calls so that About works.</dd>
				<dt>Version: 1.3.2</dt>
					<dd>Minor tidy up and bug fixing.</dd>
			</dl>';
$lang['utma'] = '156861353.469342802.1148076752.1150839419.1150929235.16';
$lang['utmz'] = '156861353.1150736647.13.9.utmccn=(referral)|utmcsr=helminsen.no|utmcct=/om_nettstedet/|utmcmd=referral';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nl_NL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Bladwijzers';
$lang['moddescription'] = 'Bookmarks is een module om bladwijzers op je pagina te tonen. Als de module geinstalleerd is, is er een admin pagina aan het Content menu toegevoegd waar je de bladfwijzers kan beheeren.';
$lang['postinstall'] = 'Zorg ervoor dat personen die bladwijzers beheren &quot;Modify Bookmarks&quot; permissies hebben.';
$lang['postuninstall'] = 'De module is gedeinstalleerd.';
$lang['needpermission'] = 'Om deze funtie te gebruiken heb je &#039;$permission&#039; permissie nodig.';
$lang['addbookmark'] = 'Bladwijzer voevoegen';
$lang['managecategories'] = 'Categorieen beheren';
$lang['add'] = 'Toevoegen';
$lang['update'] = 'Bijwerken';
$lang['managebookmarks'] = 'Bladwijzers beheren';
$lang['title'] = 'Titel';
$lang['address'] = 'Adres (incl. http://)';
$lang['approved'] = 'Goedgekeurd';
$lang['summary'] = 'Samenvatting';
$lang['categories'] = 'Categorieen';
$lang['name'] = 'Naam';
$lang['order'] = 'Volgorde';
$lang['updatecategories'] = 'Categorieen bijwerken';
$lang['filterby'] = 'Filter op';
$lang['approvalstatus'] = 'Goedkeurings status';
$lang['sortgo'] = 'Ga';
$lang['anystatus'] = 'Willekeurig';
$lang['not_approved_only'] = 'Alleen niet goedgekeurd';
$lang['none'] = '== Geen ==';
$lang['category'] = 'Categorie';
$lang['url'] = 'URL';
$lang['default'] = 'Standaard';
$lang['bookmarks_rss'] = 'Bladwijzer RSS';
$lang['rssfeed'] = 'RSS Feed';
$lang['new_bookmark_submitted_subject'] = 'Nieuwe bladwijzer verstuurd';
$lang['new_bookmark_submitted_body'] = 'Een nieuwe bladwijzer is verstuurd';
$lang['mailheader_from'] = 'Van';
$lang['mailheader_sender'] = 'CMSMS bladwijzer module';
$lang['return'] = 'Terug';
$lang['thank_you_for_submission'] = 'Bedankt voor de bijdrage';
$lang['category_head_text'] = 'Categorie:';
$lang['filter_results'] = 'Filter resultaten';
$lang['set_status_approved'] = 'Bladwijzer status aangepast naar goedgekeurd';
$lang['set_status_notapproved'] = 'Bladwijzer status aangepast naar afgekeurd';
$lang['title_error'] = 'Er is een fout opgetreden';
$lang['error'] = 'Fout';
$lang['allcats'] = 'Alle categorieen';
$lang['submit'] = 'Opslaan';
$lang['cancel'] = 'Annuleren';
$lang['addcat'] = 'Voeg een categorie toe';
$lang['addlink'] = 'Voeg een bladwijzer toe';
$lang['addtemplate'] = 'Voeg een sjabloon toe';
$lang['edittemplate'] = 'Bewerk een sjabloon';
$lang['suredelete'] = 'Weet je zeker dat je de link %s wilt verwijderen?';
$lang['delete'] = 'Verwijder bladwijzer';
$lang['catdeleted'] = 'Categorie verwijderd';
$lang['linkdeleted'] = 'Bladwijzer verwijderd';
$lang['templatedeleted'] = 'Sjabloon verwijderd';
$lang['suredeletecat'] = 'De categorie %s verwijderen?';
$lang['deletecat'] = 'Verwijder categorie';
$lang['deletetemplate'] = 'Verwijder sjabloon';
$lang['catadded'] = 'Categorie toevoegen';
$lang['catedited'] = 'Categorie bijgewerkt';
$lang['bookmarkadded'] = 'Bladwijzer toegevoegd';
$lang['bookmarkedited'] = 'Bladwijzer bijgewerkt';
$lang['templateadded'] = 'Sjabloon toegevoegd';
$lang['templateedited'] = 'Sjabloon bijgewerkt';
$lang['settingsupdated'] = 'Instellingen bijgewerkt';
$lang['title_categories_tab'] = 'Categorieen';
$lang['title_links_tab'] = 'Bladwijzers';
$lang['title_templates_tab'] = 'Sjablonen';
$lang['title_settings_tab'] = 'Instellingen';
$lang['column_title'] = 'Titel';
$lang['column_url'] = 'URL';
$lang['column_summary'] = 'Samenvatting';
$lang['column_action'] = 'Acties';
$lang['column_approve'] = 'Goedgekeurd';
$lang['column_category'] = 'Categorieen';
$lang['column_template'] = 'Sjablonen';
$lang['column_bookid'] = 'ID';
$lang['nolinks'] = 'Er zijn geen links in de database.';
$lang['nocats'] = 'Er zijn geen categorieen in de database.';
$lang['notemplates'] = 'Er zijn geen sjablonen in de database.';
$lang['no_category'] = 'Geen Categorie';
$lang['form_title'] = 'Titel';
$lang['form_descript'] = 'Omschrijving';
$lang['form_url'] = 'URL';
$lang['form_sort'] = 'Sorteer Volgorde';
$lang['form_status'] = 'Status';
$lang['form_cats'] = 'Categorieen';
$lang['form_logo'] = 'Logo';
$lang['form_template'] = 'Sjabloon';
$lang['title_default_template'] = 'Standaard sjabloon';
$lang['title_show_linkids'] = 'Toon bladwijzer ID&#039;s';
$lang['status_approved'] = 'Goedgekeurd';
$lang['status_notapproved'] = 'Afgekeurd';
$lang['help_param_emailfrom'] = 'Used with addform=true. Set to the user id to be used in the &quot;from&quot; field for email notifications. In general, you would user the admin user&#039;s id (1), but you must set an email address for the admin user as initially it does not have one.';
$lang['help_param_emailto'] = 'Used with addform=true. Set to the user id of the user to which email notifications of new bookmarks will be sent. Note that you should choose an id for a user that has an email address set up. By default, the admin user does not have an email address set.';
$lang['help_param_backbutton'] = 'Used with addform=true. When set, will include a back button on the form.';
$lang['help_param_addform'] = 'Set to &quot;true&quot; to display a form allowing users to submit bookmarks.';
$lang['help_param_target'] = 'Set to &quot;_blank&quot; to get all links to open in a new window.';
$lang['help_param_summaries'] = 'Set to &quot;true&quot; to display the summary information.';
$lang['help_param_makerssbutton'] = 'Set to display an RSS image that links to the RSS feed.';
$lang['help_param_autodetectlink'] = 'set to &quot;true&quot; to output the RSS autodetect <link> element for use in <head>. Best used in the &quot;Advanced&quot;->&quot;Head Tags&quot; section of content.';
$lang['help_param_orderbydate'] = 'Set to &quot;true&quot; to order the list of bookmarks by date. If set to true, will turn off show_category_with_title.';
$lang['help_param_type'] = 'Set to &quot;text&quot; for html display or &quot;rss&quot; for an rss feed. Default if not set is &quot;text&quot;.';
$lang['help_param_number'] = 'Set to the maximum number of bookmarks to display. Most useful when used with order_by_date. ';
$lang['help_param_display_unapproved'] = 'Laat niet goedgekeurde bladwijzers zien. (ja of nee)';
$lang['help_param_show_catwithtitle'] = 'Laat de categorie aan het begin van de lijst zien.';
$lang['help_param_category'] = 'Only display items for that category. Leaving unset, will show all categories. Note that you can limit to muliple categories by separating each one with a comman.';
$lang['help_param_columns'] = 'Aantal kolommen om de lijst met bladwijzers in te tonen.';
$lang['help_param_singlelink'] = 'bookmark_id.  This will show only the link that is selected.  Only the template parameter will be used with this setting.';
$lang['help'] = '		<h3>What does this do?</h3>
		<p>Bookmarks is a module for displaying bookmarks on your page. When the
		module is installed, a Bookmarks admin page is added to the Content menu
		that will allow you to manage your bookmarks.</p>
		<h3>Security</h3>
		<p>The user must belong to a group with the &quot;Modify Bookmarks&quot; permission
		in order to add, edit, or delete Bookmarks entries.</p>
		<h3>How do I use it?</h3>
		<p>The easiest way to use it is in conjunction with the cms_module tag.
		This will insert the module into your template or page anywhere you wish,
		and display bookmarks.  The code would look something like:
		<code>{cms_module module=&quot;bookmarks&quot; columns=&quot;2&quot; category=&quot;humour&quot;}</code></p>';
$lang['changelog'] = '			<p>Author: Rob Allen <rob@akrabat.com></p>
			<dl>
				<dt>Version: 0.1</dt>
				<dd>Initial release. The code framework is based on the News module by Robert
					Campbell <rob@techcom.dydnsns.org></dd>
				<dt>Version: 0.9</dt>
					<dd>First release of code to rest of world!</dd>
				<dt>Version: 0.9.1</dt>
					<dd>Bug fixes to help, column handling and the admin list.</dd>
				<dt>Version: 1.0</dt>
					<dd>Support email notifications from the submit bookmarks form. Addded delete option.
					Admin list now displays bookmarks that are not attached to any category.<br />
					Now required CommonCode 1.1<br />
					Tidied up code.<br />
					</dd>
				<dt>Version: 1.0.1</dt>
					<dd>Bug fixes that prevented display of the user facing submit form.</dd>
				<dt>Version: 1.0.2</dt>
					<dd>Uses CMS functions for CommonCode dependency.</dd>
				<dt>Version: 1.1</dt>
					<dd>Update to 0.8.</dd>
				<dt>Version: 1.3</dt>
					<dd>Update to 0.9.</dd>
				<dt>Version: 1.3.1</dt>
					<dd>Fix all default options so that the documented default is used. This is most obvious
					for the display code so that if type is not set, we correctly assume &quot;text&quot; rather than 
					&quot;rss&quot; now!. Also, fixed the API calls so that About works.</dd>
				<dt>Version: 1.3.2</dt>
					<dd>Minor tidy up and bug fixing.</dd>
				<dt>Version: 1.4 (Unreleased)</dt>
					<dd>Start of the Localization inplementation from westis.  This version was unreleased. (westis)</dd>
				<dt>Version: 2.0</dt>
					<dd>More Localization changes (NamantH)<br />
					Moved all rendered pages from code into templates. (NamantH)<br />
					Minor Bug fixing. (NamantH)<br />
					Added cancel button for forms, back to bookmarks menu. (NamantH)<br />
					Added handling for bookmarks that were not attached to categories. (NamantH)<br />
					Added quick Approve/Disapprove link on the bookmark list. (NamantH)<br />
					Changed the way categories are edited.  Instead of a list with two input fields, you have a seperate form. (NamantH)<br />
					Broke out the user add form into a template (NamantH).
					Broke out a seperate function to handle the user add form (NamantH).
					</dd>
				<dt>Version: 2.1</dt>
					<dd>Added in a Logo field for bookmarks<br />
					Added in filter by category in the filter<br />
					Added in templates table and sequence for holding the database templates for the user display<br />
					Added in a templates tab for editing the templates<br />
					Added in a settings tab.<br />
					Added Setting: Default template<br />
					Added Setting: Show Link ID&#039;s<br />
					Fixed listlinks.tpl to correctly show the ID when setting is selected.<br />
					Added in three templates for use:
					<ol>
					<li>Default: This is the standard multi column template.</li>
					<li>DescriptionLogo: Shows the bookmarks in a list with logo and description.</li>
					<li>SingleLink: This will show only one link.</li>
					</ol><br />
					
					</dd>
			</dl>';
$lang['utmz'] = '156861353.1147855181.2.2.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/projects/embed/|utmcmd=referral';
$lang['utma'] = '156861353.1518633766.1147844927.1149065203.1149068300.23';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sv_SE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Bokm&auml;rken';
$lang['moddescription'] = 'Bokm&auml;rken (Bookmarks) &auml;r en modul f&ouml;r att visa bokm&auml;rken/l&auml;nkar p&aring; din sida. N&auml;r modulen &auml;r installeraad l&auml;ggs en l&auml;nk till Bokm&auml;rkesadministrationen till i Inneh&aring;llsmenyn. I administrationen kan du hantera dina bokm&auml;rken.';
$lang['postinstall'] = 'Se till att st&auml;llta in r&auml;ttigheten &quot;Modify Bookmarks&quot; f&ouml;r anv&auml;ndare som ska administrera bokm&auml;rken.';
$lang['postuninstall'] = 'Modulen &auml;r avinstallerad.';
$lang['needpermission'] = 'Du beh&ouml;ver r&auml;ttigheten &quot;Modify Bookmarks&quot; f&ouml;r att utf&ouml;ra den funktionen.';
$lang['addbookmark'] = 'L&auml;gg till bokm&auml;rke';
$lang['managecategories'] = 'Hantera kategorier';
$lang['add'] = 'L&auml;gg till';
$lang['update'] = 'Uppdatera';
$lang['managebookmarks'] = 'Hantera bokm&auml;rken';
$lang['title'] = 'Titel';
$lang['address'] = 'Adress (inkl. http://)';
$lang['approved'] = 'Godk&auml;nd';
$lang['summary'] = 'Sammanfattning';
$lang['categories'] = 'Kategorier';
$lang['name'] = 'Namn';
$lang['order'] = 'Ordning';
$lang['updatecategories'] = 'Uppdatera kategorier';
$lang['filterby'] = 'Filtrera p&aring;';
$lang['approvalstatus'] = 'Status f&ouml;r godk&auml;nnande';
$lang['sortgo'] = 'OK';
$lang['anystatus'] = 'Alla';
$lang['not_approved_only'] = 'Enbart ej godk&auml;nda';
$lang['none'] = '== Ingen ==';
$lang['category'] = 'Kategori';
$lang['url'] = 'URL';
$lang['default'] = 'Standard';
$lang['bookmarks_rss'] = 'RSS f&ouml;r bokm&auml;rken';
$lang['rssfeed'] = 'RSS-str&ouml;m';
$lang['new_bookmark_submitted_subject'] = 'Nytt bokm&auml;rke har lagts till';
$lang['new_bookmark_submitted_body'] = 'Ett nytt bokm&auml;rke har lagts till';
$lang['mailheader_from'] = 'Fr&aring;n';
$lang['mailheader_sender'] = 'CMSMS Bokm&auml;rkesmodulen';
$lang['return'] = 'Tillbaka';
$lang['thank_you_for_submission'] = 'Tack f&ouml;r ditt bidrag';
$lang['category_head_text'] = 'Kategori: ';
$lang['filter_results'] = 'filter_results';
$lang['set_status_approved'] = 'Status f&ouml;r bokm&auml;rke &auml;r satt till Godk&auml;nd';
$lang['set_status_notapproved'] = 'Status f&ouml;r bokm&auml;rke &auml;r satt till Ej Godk&auml;nd';
$lang['title_error'] = 'Ett fel har uppst&aring;tt';
$lang['error'] = 'Fel';
$lang['allcats'] = 'Alla kategorier';
$lang['submit'] = 'L&auml;gg till';
$lang['cancel'] = '&Aring;ngra';
$lang['addcat'] = 'L&auml;gg till en kategori';
$lang['addlink'] = 'L&auml;gg till ett bokm&auml;rke';
$lang['addtemplate'] = 'L&auml;gg till en mall';
$lang['edittemplate'] = 'Redigera en mall';
$lang['suredelete'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort l&auml;nken %s?';
$lang['delete'] = 'Ta bort bokm&auml;rke';
$lang['catdeleted'] = 'Kategori borttagen';
$lang['linkdeleted'] = 'Bokm&auml;rke borttaget';
$lang['templatedeleted'] = 'Mall borttagen';
$lang['suredeletecat'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort kategorin %s?';
$lang['deletecat'] = 'Ta bort kategori';
$lang['deletetemplate'] = 'Ta bort mall';
$lang['catadded'] = 'Kategorin har lagts till';
$lang['catedited'] = 'Kategorin har uppdaterats';
$lang['bookmarkadded'] = 'Bokm&auml;rket har lagts till';
$lang['bookmarkedited'] = 'Bokm&auml;rket har uppdaterats';
$lang['templateadded'] = 'Mallen har lagts till';
$lang['templateedited'] = 'Mallen har uppdaterats';
$lang['settingsupdated'] = 'Inst&auml;llningar uppdaterade';
$lang['title_categories_tab'] = 'Kategorier';
$lang['title_links_tab'] = 'Bokm&auml;rken';
$lang['title_templates_tab'] = 'Mallar';
$lang['title_settings_tab'] = 'Inst&auml;llningar';
$lang['column_title'] = 'Titel';
$lang['column_url'] = 'URL (adress)';
$lang['column_summary'] = 'Sammanfattning';
$lang['column_action'] = 'H&auml;ndelser';
$lang['column_approve'] = 'Godk&auml;nd';
$lang['column_category'] = 'Kategorier';
$lang['column_template'] = 'Mallar';
$lang['column_bookid'] = 'ID';
$lang['nolinks'] = 'Det finns inga l&auml;nkar i databasen.';
$lang['nocats'] = 'Det finns inga kategorier i databasen.';
$lang['notemplates'] = 'Det finns inga mallar i databasen.';
$lang['no_category'] = 'Ingen kategori';
$lang['form_title'] = 'Titel';
$lang['form_descript'] = 'Beskrivning';
$lang['form_url'] = 'URL (adress)';
$lang['form_sort'] = 'Sorteringsordning';
$lang['form_status'] = 'Status';
$lang['form_cats'] = 'Kategorier';
$lang['form_logo'] = 'Logga';
$lang['form_template'] = 'Mall';
$lang['title_default_template'] = 'Standardmall';
$lang['title_show_linkids'] = 'Visa bokm&auml;rkes-ID&#039;n';
$lang['status_approved'] = 'Godk&auml;nd';
$lang['status_notapproved'] = 'Ej godk&auml;nd';
$lang['help_param_emailfrom'] = 'Anv&auml;nds tillsammans med addform=true. V&auml;lj ett anv&auml;ndar-ID som ska anv&auml;ndas i &quot;fr&aring;n&quot;-f&auml;ltet vid epostnotifiering. Generellt sett anv&auml;nder till anv&auml;ndar-ID&#039;t f&ouml;r admin (1), men du m&aring;ste st&auml;lla in en epostadress f&ouml;r admin-anv&auml;ndaren eftersom den fr&aring;n b&ouml;rjan inte har n&aring;gon.';
$lang['help_param_emailto'] = 'Anv&auml;nds tillsammans med addform=true. V&auml;lj ett anv&auml;ndar-ID f&ouml;r den anv&auml;ndare som ska f&aring; epostnotifiering n&auml;r ett nytt bokm&auml;rke har lagts till. Notera att du b&ouml;r v&auml;lja ett ID f&ouml;r en anv&auml;ndare som har en e-postadress vald. Som standard har inte admin-anv&auml;ndaren n&aring;gon e-postadress vald. ';
$lang['help_param_backbutton'] = 'Anv&auml;nds tillsammans med addform=true. N&auml;r vald kommer en tillbaka-knapp att finnas i formul&auml;ret.';
$lang['help_param_addform'] = 'S&auml;tt till &quot;true&quot; f&ouml;r att visa ett formul&auml;r som l&aring;ter anv&auml;ndare skicka in bokm&auml;rken.';
$lang['help_param_target'] = 'S&auml;tt till &quot;_blank&quot; f&ouml;r att alla l&auml;nkar ska &ouml;ppnas i ett nytt f&ouml;nster.';
$lang['help_param_summaries'] = 'S&auml;tt till &quot;true&quot; f&ouml;r att visa sammanfattningsinformationen.';
$lang['help_param_makerssbutton'] = 'V&auml;lj f&ouml;r att visa en RSS-bild som l&auml;nkar till RSS-str&ouml;mmen.';
$lang['help_param_autodetectlink'] = 'S&auml;tt till &quot;true&quot; f&ouml;r att skriva ut RSS-autov&auml;lj <link> - elementet f&ouml;r att anv&auml;nda i <head>. Anv&auml;nds b&auml;st i sektionen &quot;Avancerat&quot;->&quot;Head-taggar&quot; i en sidas inneh&aring;ll.';
$lang['help_param_orderbydate'] = 'S&auml;tt till &quot;true&quot; f&ouml;r att lista bokm&auml;rken efter datum. Om satt till true st&auml;nger det av show_category_with_title.';
$lang['help_param_type'] = 'S&auml;tt till &quot;text&quot; f&ouml;r HTML-visning eller &quot;rss&quot; f&ouml;r en RSS-str&ouml;m. Standard om ej vald &auml;r &quot;text&quot;.';
$lang['help_param_number'] = 'S&auml;tt till maximalt antal bokm&auml;rken som ska visas. Mest anv&auml;ndbar n&auml;r den anv&auml;nds tillsammans med order_by_date.';
$lang['help_param_display_unapproved'] = 'Visa ej godk&auml;nda bokm&auml;rken (true eller false)';
$lang['help_param_show_catwithtitle'] = 'Visa kategorin i b&ouml;rjan av listan.';
$lang['help_param_category'] = 'Visa bara bokm&auml;rken i den kategorin. Om l&auml;mnas tom visas alla kategorier. Notera att du kan begr&auml;nsa till flera kategorier genom att separarera dem med kommatecken.';
$lang['help_param_columns'] = 'Antal kolumner som bokm&auml;rkeslistan ska visas i.';
$lang['help_param_singlelink'] = 'bookmark_id.  Detta visar bara l&auml;nken som &auml;r vald. Bara mallparametern kan anv&auml;ndas med denna inst&auml;llning.';
$lang['help'] = '		<h3>What does this do?</h3>
		<p>Bookmarks is a module for displaying bookmarks on your page. When the
		module is installed, a Bookmarks admin page is added to the Content menu
		that will allow you to manage your bookmarks.</p>
		<h3>Security</h3>
		<p>The user must belong to a group with the &quot;Modify Bookmarks&quot; permission
		in order to add, edit, or delete Bookmarks entries.</p>
		<h3>How do I use it?</h3>
		<p>The easiest way to use it is in conjunction with the cms_module tag.
		This will insert the module into your template or page anywhere you wish,
		and display bookmarks.  The code would look something like:
		<code>{cms_module module=&quot;bookmarks&quot; columns=&quot;2&quot; category=&quot;humour&quot;}</code></p>';
$lang['changelog'] = '			<p>Author: Rob Allen <rob@akrabat.com></p>
			<dl>
				<dt>Version: 0.1</dt>
				<dd>Initial release. The code framework is based on the News module by Robert
					Campbell <rob@techcom.dydnsns.org></dd>
				<dt>Version: 0.9</dt>
					<dd>First release of code to rest of world!</dd>
				<dt>Version: 0.9.1</dt>
					<dd>Bug fixes to help, column handling and the admin list.</dd>
				<dt>Version: 1.0</dt>
					<dd>Support email notifications from the submit bookmarks form. Addded delete option.
					Admin list now displays bookmarks that are not attached to any category.<br />
					Now required CommonCode 1.1<br />
					Tidied up code.<br />
					</dd>
				<dt>Version: 1.0.1</dt>
					<dd>Bug fixes that prevented display of the user facing submit form.</dd>
				<dt>Version: 1.0.2</dt>
					<dd>Uses CMS functions for CommonCode dependency.</dd>
				<dt>Version: 1.1</dt>
					<dd>Update to 0.8.</dd>
				<dt>Version: 1.3</dt>
					<dd>Update to 0.9.</dd>
				<dt>Version: 1.3.1</dt>
					<dd>Fix all default options so that the documented default is used. This is most obvious
					for the display code so that if type is not set, we correctly assume &quot;text&quot; rather than 
					&quot;rss&quot; now!. Also, fixed the API calls so that About works.</dd>
				<dt>Version: 1.3.2</dt>
					<dd>Minor tidy up and bug fixing.</dd>
			</dl>';
?>]]></data>
	</file>
	<file>
	  <filename>/templates/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/addbookmark.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19DQo8dGFibGUgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iNSIgY2VsbHNwYWNpbmc9IjAiPg0KCTx0cj4NCgkJPHRkIHZhbGlnbj0idG9wIj57JHRpdGxlX2ZpZWxkX3RpdGxlfTo8L3RkPg0KCQk8dGQ+eyRpbnB1dF9maWVsZF90aXRsZX08L3RkPg0KCTwvdHI+DQoJPHRyPg0KCQk8dGQgdmFsaWduPSJ0b3AiPnskdGl0bGVfZmllbGRfdXJsfTo8L3RkPg0KCQk8dGQ+eyRpbnB1dF9maWVsZF91cmx9PC90ZD4NCgk8L3RyPg0KCTx0cj4KCQk8dGQgdmFsaWduPSJ0b3AiPnskdGl0bGVfZmllbGRfY2F0c306PC90ZD4KCQk8dGQ+eyRpbnB1dF9maWVsZF9jYXRzfTwvdGQ+Cgk8L3RyPgoJPHRyPgoJCTx0ZCB2YWxpZ249InRvcCI+eyR0aXRsZV9maWVsZF9kZXNjcmlwdH06PC90ZD4KCQk8dGQ+eyRpbnB1dF9maWVsZF9kZXNjcmlwdH08L3RkPgoJPC90cj4KCTx0cj4NCgkJPHRkPiZuYnNwOzwvcD4NCgkJPHRkPnskaGlkZGVufXskc3VibWl0fXskY2FuY2VsfTwvdGQ+DQoJPC90cj4NCjwvdGFibGU+DQp7JGVuZGZvcm19DQo=]]></data>
	</file>
	<file>
	  <filename>/templates/adminpanel.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmICRtZXNzYWdlICE9ICIifTxwPnskbWVzc2FnZX08L3A+ey9pZn0KeyR0YWJfaGVhZGVyc30KeyRzdGFydF9saW5rc190YWJ9Cgl7aW5jbHVkZSBmaWxlPSIkbGlzdGxpbmtzdHBsIn0KeyRlbmRfdGFifQp7JHN0YXJ0X2NhdHNfdGFifQoJe2luY2x1ZGUgZmlsZT0iJGxpc3RjYXRzdHBsIn0KeyRlbmRfdGFifQp7JHRhYl9mb290ZXJzfQoK]]></data>
	</file>
	<file>
	  <filename>/templates/adminprefs.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGgzPnskdGl0bGVfc2VjdGlvbn08L2gzPgo8cD57JGFkbWluX25hdn08L3A+CntpZiAkbWVzc2FnZSE9Jyd9PHA+eyRtZXNzYWdlfTwvcD57L2lmfQp7JHN0YXJ0Zm9ybX0KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHRpdGxlX3NpbmdfbG91ZGx5fTo8L3A+CgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRpbnB1dF9zaW5nX2xvdWRseX08L3A+Cgk8L2Rpdj4KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRzdWJtaXR9PC9wPgoJPC9kaXY+CnskZW5kZm9ybX0K]]></data>
	</file>
	<file>
	  <filename>/templates/bookmarks.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e3NlY3Rpb24gbmFtZT1jYXRlZ29yeSBsb29wPSRjYXRlZ29yaWVzfQoJe2lmICRpdGVtY291bnRbY2F0ZWdvcnldID4gMH0KCTxoND57JGNhdGVnb3JpZXNbY2F0ZWdvcnldfTwvaDQ+Cgk8cD4KCQk8dWw+CgkJe3NlY3Rpb24gbmFtZT1saW5rIGxvb3A9JGxpbmtsaXN0W2NhdGVnb3J5XX0KCQkJPGxpPnskbGlua2xpc3RbY2F0ZWdvcnldW2xpbmtdfTwvbGk+CgkJey9zZWN0aW9ufQoJCTwvdWw+Cgk8L3A+Cgl7L2lmfQp7L3NlY3Rpb259]]></data>
	</file>
	<file>
	  <filename>/templates/editcat.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19DQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JHRpdGxlX25hbWV9OjwvcD4NCgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRpbnB1dF9uYW1lfTwvcD4NCgk8L2Rpdj4NCgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPg0KCQk8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfc29ydH06PC9wPg0KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGlucHV0X3NvcnR9PC9wPg0KCTwvZGl2Pg0KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+DQoJCTxwIGNsYXNzPSJwYWdldGV4dCI+Jm5ic3A7PC9wPg0KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JGhpZGRlbn17JHN1Ym1pdH17JGNhbmNlbH08L3A+DQoJPC9kaXY+DQp7JGVuZGZvcm19DQo=]]></data>
	</file>
	<file>
	  <filename>/templates/editlinks.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydGZvcm19CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+Cgk8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfZmllbGRfdGl0bGV9OjwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfZmllbGRfdGl0bGV9PC9wPgo8L2Rpdj4KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCTxwIGNsYXNzPSJwYWdldGV4dCI+eyR0aXRsZV9maWVsZF91cmx9OjwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfZmllbGRfdXJsfTwvcD4KPC9kaXY+CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+Cgk8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfZmllbGRfY2F0c306PC9wPgoJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRpbnB1dF9maWVsZF9jYXRzfTwvcD4KPC9kaXY+CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+Cgk8cCBjbGFzcz0icGFnZXRleHQiPnskdGl0bGVfZmllbGRfZGVzY3JpcHR9OjwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfZmllbGRfZGVzY3JpcHR9PC9wPgo8L2Rpdj4KPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4KCTxwIGNsYXNzPSJwYWdldGV4dCI+eyR0aXRsZV9maWVsZF9zdGF0dXN9OjwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfZmllbGRfc3RhdHVzfTwvcD4KPC9kaXY+CjxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+Cgk8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4KCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaGlkZGVufXskc3VibWl0fXskY2FuY2VsfTwvcD4KPC9kaXY+CnskZW5kZm9ybX0K]]></data>
	</file>
	<file>
	  <filename>/templates/error.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGgzPnskdGl0bGVfZXJyb3J9PC9oMz4Ke2lmICRtZXNzYWdlIT0nJ308cD57JG1lc3NhZ2V9PC9wPnsvaWZ9]]></data>
	</file>
	<file>
	  <filename>/templates/linksfilter.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRzdGFydF9saW5rc19maWx0ZXJfZm9ybX0NCjx0YWJsZSBjZWxsc3BhY2luZz0iMCI+DQoJPHRyPg0KCQk8dGQ+eyR0aXRsZV9maWx0ZXJfYnl9PC90ZD4NCgkJPHRkPnskaW5wdXRfZmlsdGVyX2J5fTwvdGQ+DQoJPC90cj4NCgk8dHI+DQoJCTx0ZD57JHRpdGxlX2FwcF9zdGF0dXN9PC90ZD4NCgkJPHRkPnskaW5wdXRfYXBwX3N0YXR1c308L3RkPg0KCTwvdHI+DQoJPHRyPg0KCQk8dGQ+PC90ZD4NCgkJPHRkPnskaW5wdXRfZmlsdGVyX2J1dHRvbn08L3RkPg0KCTwvdHI+DQo8L3RhYmxlPg0KeyRlbmRfbGlua3NfZmlsdGVyX2Zvcm19]]></data>
	</file>
	<file>
	  <filename>/templates/listcats.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGJyIC8+CjxkaXYgY2xhc3M9InBhZ2VvcHRpb25zIj4KICAgICAgICA8cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskYWRkY2F0fTwvcD4KPC9kaXY+CntpZiAkY2F0Y291bnQgPiAwfQo8dGFibGUgY2VsbHNwYWNpbmc9IjAiIGNsYXNzPSJwYWdldGFibGUiPgoJPHRoZWFkPgoJCTx0cj4KCQkJPHRoPnskY29sdW1uX2NhdGVnb3J5fTwvdGg+CgkJCTx0aCBjbGFzcz0icGFnZWljb24iIGNvbHNwYW49IjIiPnskY29sdW1uX2FjdGlvbn08L3RoPgoJCTwvdHI+Cgk8L3RoZWFkPgoJPHRib2R5PgoJe2ZvcmVhY2ggZnJvbT0kY2F0cyBpdGVtPWVudHJ5fQoJCTx0ciBjbGFzcz0ieyRlbnRyeS0+cm93Y2xhc3N9IiBvbm1vdXNlb3Zlcj0idGhpcy5jbGFzc05hbWU9J3skZW50cnktPnJvd2NsYXNzfWhvdmVyJzsiIG9ubW91c2VvdXQ9InRoaXMuY2xhc3NOYW1lPSd7JGVudHJ5LT5yb3djbGFzc30nOyI+CgkJCTx0ZD57JGVudHJ5LT5uYW1lfTwvdGQ+CgkJCTx0ZD57JGVudHJ5LT5lZGl0bGlua308L3RkPgoJCQk8dGQ+eyRlbnRyeS0+ZGVsbGlua308L3RkPgoJCTwvdHI+Cgl7L2ZvcmVhY2h9Cgk8L3Rib2R5Pgo8L3RhYmxlPgp7ZWxzZX0KPHA+eyRub2NhdHN9PC9wPgp7L2lmfQo8ZGl2IGNsYXNzPSJwYWdlb3B0aW9ucyI+Cgk8cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskYWRkY2F0fTwvcD4KPC9kaXY+Cg==]]></data>
	</file>
	<file>
	  <filename>/templates/listlinks.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGJyIC8+CntpbmNsdWRlIGZpbGU9IiRsaW5rc2ZpbHRlciJ9Cgo8ZGl2IGNsYXNzPSJwYWdlb3B0aW9ucyI+CiAgICAgICAgPHAgY2xhc3M9InBhZ2VvcHRpb25zIj57JGFkZGxpbmt9PC9wPgo8L2Rpdj4Ke3NlY3Rpb24gbmFtZT1jYXRlZ29yeSBsb29wPSRjYXRlZ29yaWVzfQp7aWYgJGl0ZW1jb3VudFtjYXRlZ29yeV0gPiAwfQo8YnIgLz48cD4KPHN0cm9uZz57JGNhdGVnb3J5X2hlYWRfdGV4dH17JGNhdGVnb3JpZXNbY2F0ZWdvcnldfTwvc3Ryb25nPjwvcD4KPHRhYmxlIGNlbGxzcGFjaW5nPSIwIiBjbGFzcz0icGFnZXRhYmxlIj4KCTx0aGVhZD4KCQk8dHI+CgkJCXtpZiAkc2hvd190ZXJtaWRzID09IDF9PHRoPnskY29sdW1uX2Jvb2tpZH08L3RoPnsvaWZ9CgkJCTx0aCB3aWR0aD0iMjAwIj57JGNvbHVtbl90aXRsZX08L3RoPgogICAgICAgICAgICA8dGggd2lkdGg9IjIwMCI+eyRjb2x1bW5fdXJsfTwvdGg+CiAgICAgICAgICAgIDx0aD57JGNvbHVtbl9zdW1tYXJ5fTwvdGg+CgkJCTx0aCB3aWR0aD0iODAiPnskY29sdW1uX2FwcHJvdmV9PC90aD4KCQkJPHRoIHdpZHRoPSI4MCIgY2xhc3M9InBhZ2VpY29uIiBjb2xzcGFuPSIyIj57JGNvbHVtbl9hY3Rpb259PC90aD4KCQk8L3RyPgoJPC90aGVhZD4KCTx0Ym9keT4KCXtzZWN0aW9uIG5hbWU9bGluayBsb29wPSRsaW5rbGlzdFtjYXRlZ29yeV19CgkJPHRyIGNsYXNzPSJ7JGxpbmtsaXN0W2NhdGVnb3J5XVtsaW5rXS0+cm93Y2xhc3N9IiBvbm1vdXNlb3Zlcj0idGhpcy5jbGFzc05hbWU9J3skbGlua2xpc3RbY2F0ZWdvcnldW2xpbmtdLT5yb3djbGFzc31ob3Zlcic7IiBvbm1vdXNlb3V0PSJ0aGlzLmNsYXNzTmFtZT0neyRsaW5rbGlzdFtjYXRlZ29yeV1bbGlua10tPnJvd2NsYXNzfSc7Ij4KICAgICAgICAgICAgPHRkIHdpZHRoPSIyMDAiPnskbGlua2xpc3RbY2F0ZWdvcnldW2xpbmtdLT5uYW1lbGlua308L3RkPgoJCQk8dGQgd2lkdGg9IjIwMCI+eyRsaW5rbGlzdFtjYXRlZ29yeV1bbGlua10tPnVybH08L3RkPgoJCQk8dGQ+eyRsaW5rbGlzdFtjYXRlZ29yeV1bbGlua10tPmRlZmluaXRpb258dHJ1bmNhdGU6NDA6Ii4uLiI6dHJ1ZX08L3RkPgoJCQk8dGQgd2lkdGg9IjgwIj57JGxpbmtsaXN0W2NhdGVnb3J5XVtsaW5rXS0+YWN0aXZlfTwvdGQ+CgkJCTx0ZD57JGxpbmtsaXN0W2NhdGVnb3J5XVtsaW5rXS0+ZWRpdGxpbmt9PC90ZD4KCQkJPHRkPnskbGlua2xpc3RbY2F0ZWdvcnldW2xpbmtdLT5kZWxsaW5rfTwvdGQ+CgkJPC90cj4KCXsvc2VjdGlvbn0KCTwvdGJvZHk+CjwvdGFibGU+CntlbHNlfQp7JG5vbGlua3N9CnsvaWZ9Cnsvc2VjdGlvbn0KCjxkaXYgY2xhc3M9InBhZ2VvcHRpb25zIj4KICAgICAgICA8cCBjbGFzcz0icGFnZW9wdGlvbnMiPnskYWRkbGlua308L3A+CjwvZGl2Pg==]]></data>
	</file>
	<file>
	  <filename>/templates/plugin.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGgzPnskbG91ZG5lc3N9PC9oMz4=]]></data>
	</file>
</module>
