Sindbad~EG File Manager

Current Path : /var/www/web3/g2data/cache/repository/released/modules/
Upload File :
Current File : /var/www/web3/g2data/cache/repository/released/modules/rss-1.1.0-16041-base.package

<?php
function unpack_c19e8c72e9($outputDir) {
/* Create directory structure. */
@mkdir($outputDir . 'classes');
@mkdir($outputDir . 'classes/GalleryStorage');
@mkdir($outputDir . 'locale');
@mkdir($outputDir . 'po');
@mkdir($outputDir . 'templates');
@mkdir($outputDir . 'templates/blocks');
/* Recreate individual files. */
expand_c19e8c72e9($outputDir, 'Callbacks.inc', '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');
expand_c19e8c72e9($outputDir, 'EditFeed.inc', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 Bharat Mediratta
 *
 * 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., 51 Franklin Street - Fifth Floor, Boston, MA  02110-1301, USA.
 */

GalleryCoreApi::requireOnce('modules/rss/classes/RssMapHelper.class');
GalleryCoreApi::requireOnce('modules/rss/classes/RssHelper.class');

/**
 * Edit RSS feed settings
 * @package Rss
 * @subpackage UserInterface
 * @author Jonatan Heyman <http://heyman.info>,
 * @author Pierre-Luc Paour
 * @author Daniel Grund <http://www.photogrund.nl>
 * @version $Revision: 15513 $
 */
class EditFeedController extends GalleryController {

    /**
     * @see GalleryController::handleRequest
     */
    function handleRequest($form) {
	global $gallery;
	$status = $results = $error = array();

	$mode = empty($form['mode']) ? '' : $form['mode'];
	$itemId = !empty($form['itemId']) ? (int)$form['itemId']
					  : (int)GalleryUtilities::getRequestVariables('itemId');

	list ($ret, $item) = GalleryCoreApi::loadEntitiesById($itemId);
	if ($ret) {
	    return array($ret, null);
	}
	list ($ret, $param) = GalleryCoreApi::fetchAllPluginParameters('module', 'rss');
	if ($ret) {
	    return array($ret, null);
	}
	list ($ret) =
	    RssMapHelper::canConfigureFeed($item, $param, $gallery->getActiveUserId(), true);
	if ($ret) {
	    return array($ret, null);
	}

	/* Check which button was pressed */
	if (isset($form['action']['create']) || isset($form['action']['update'])) {
	    /*
	     * Either new feed settings where created or existing where updated.
	     * First do some error checking,
	     * if check fails display error on page
	     * first numerical values.
	     */
	    foreach (array('itemId',
			   'count',
			   'ttl') as $value) {
		if (!isset($form[$value]) || ((int)$form[$value]) < 0) {
		    $error[] = 'form[error][' . $value . ']';
		}
	    }

	    /* check strings may be '' or contain a value */
	    foreach (array('version',
			   'category',
			   'description',
			   'cloudDomain',
			   'cloudPath',
			   'cloudRegisterProcedure',
			   'cloudProtocol',
			   'cloudPort',
			   'language',
			   'feedName') as $value) {
		if (!isset($form[$value])) {
		    $error[] = 'form[error][' . $value . ']';
		}
	    }

	    /* check the name */
	    if (empty($form['feedName'])) {
		$error[] = 'form[error][feedName]';
	    }

	    /* conditionally check the recurse limit */
	    if ($form['feedType'] == 'photosRecurse' &&
		    (!isset($form['photosRecurseLimit']) ||
			((int)$form['photosRecurseLimit']) < 0)) {
		$error[] = 'form[error][photosRecurseLimit]';
	    }

	    /* If there are no form errors, create array to be saved to DB */
	    if (empty($error)) {
		$parameters = array('itemId' => $form['itemId'],
		    'feedType' => $form['feedType'],
		    'feedDate' => $form['feedDate'],
		    'version' => $form['version'],
		    'count' => $form['count'],
		    'ttl' => $form['ttl'],
		    'category' => $form['category'],
		    'language' => $form['language'],
		    'copyright' => $form['copyright'],
		    'description' => $form['description'],
		    'useImage' => (isset($form['useImage']) ? '1' : '0'),
		    'useEnclosure' => (isset($form['useEnclosure']) ? '1' : '0'),
		    'useCloud' => (isset($form['useCloud']) ? '1' : '0'));

		if ($parameters['feedType'] == 'photosRecurse') {
		    $parameters['photosRecurseLimit'] = $form['photosRecurseLimit'];
		}

		if (isset($form['useCloud'])) {
		    $parameters = array_merge($parameters,
			array('cloudDomain' => $form['cloudDomain'],
			      'cloudPort' => $form['cloudPort'],
			      'cloudPath' => $form['cloudPath'],
			      'cloudRegisterProcedure' => $form['cloudRegisterProcedure'],
			      'cloudProtocol' => $form['cloudProtocol']));
		}

		/* Check if we need to update a current feed, or create a new one */
		if (isset($form['action']['create'])) {
		    $ret = RssMapHelper::createFeed($form['feedName'], $parameters);
		} else {
		    $ret = RssMapHelper::updateFeed($form['feedName'], $parameters);
		}

		/* Check to see if DB update was successful */
		if ($ret) {
		    /* If we got anything other than a ERROR_COLLISION, exit */
		    if (!($ret->getErrorCode() & ERROR_COLLISION)) {
			return array($ret, null);
		    }

		    /*
		     * If it is state it is a 'feedNameCollision'
		     * Set our error status and fall back to the view.
		     */
		    $error[] = 'form[error][feedNameCollision]';
		} else {
		    /* Save was successful change status to refect this */
		    $status['saved'] = 1;
		    $mode = 'edit';
		}
	    } else {
		$mode = isset($form['action']['create'])?'new':'edit';
	    }
	} else if (isset($form['action']['cancel'])) {
	    /* Cancel button was pressed, do nothing, return to feedlist */
	    $mode = 'list';
	} else if (isset($form['action']['delete'])) {
	    /*
	     * Delete button was pressed, delete feed, return to feedlist.
	     * We might want to provide an 'are you sure' here in the future.
	     */
	    $ret = RssMapHelper::deleteFeed($form['action']['delete']);
	    if ($ret) {
		return array($ret, null);
	    }

	    $status['deleted'] = 1;
	    $mode = 'list';
	}

	/* figure out the method we will use */
	$method = empty($error) ? 'redirect' : 'delegate';
	$results['status'] = $status;
	$results['error'] = $error;
	$results[$method]['view'] = 'core.ItemAdmin';
	$results[$method]['subView'] = 'rss.EditFeed';
	$results[$method]['itemId'] = $itemId;
	$results[$method]['mode'] = $mode;

	if (empty($error)) {
	    $results[$method]['form'] = $form;
	}

	return array(null, $results);
    }
}


/**
 * This view will show a form to generate an URL to an RSS feed.
 */
class EditFeedView extends GalleryView {
    /**
     * @see GalleryView::loadTemplate
     */
    function loadTemplate(&$template, &$form) {
	global $gallery;

	/* Load the item */
	list ($ret, $item) = $this->getItem();
	if ($ret) {
	    return array($ret, null);
	}

	/* Fetch module parameters and save them in an array passed to the template engine */
	list ($ret, $param) = GalleryCoreApi::fetchAllPluginParameters('module', 'rss');
	if ($ret) {
	    return array($ret, null);
	}
	list ($ret) =
	    RssMapHelper::canConfigureFeed($item, $param, $gallery->getActiveUserId(), true);
	if ($ret) {
	    return array($ret, null);
	}

	$EditFeed = array();
	$EditFeed['itemId'] = GalleryUtilities::getRequestVariables('itemId');

	/* Fetch all feed definitions */
	list ($ret, $feeds) = RssMapHelper::fetchFeedsForItem($EditFeed['itemId']);
	if ($ret) {
	    return array($ret, null);
	}

	$EditFeed['mode'] = GalleryUtilities::getRequestVariables('mode');
	if (empty($EditFeed['mode'])) {
	    /* Entering this module, pick the first page */
	    if (empty($feeds)) {
		/* No feeds defined yet: show new */
		$EditFeed['mode'] = 'new';
	    } else {
		/* Otherwise show the list */
		$EditFeed['mode'] = 'list';
	    }
	}

	/* Switching on which page to display */
	if ($EditFeed['mode'] == 'new') {
	    /* Create new feed */
	    if (empty($form['error'])) {
		/* no error: load default parameters */
		$form['formName'] = 'EditFeed';

		if (GalleryUtilities::isA($item, 'GalleryAlbumItem')) {
		    $EditFeed['type'] = 'album';
		    $EditFeed['feedType'] = 'photos';
		} else if (GalleryUtilities::isA($item, 'GalleryDataItem')) {
		    $EditFeed['type'] = 'photo';
		    $EditFeed['feedType'] = 'commentsPhoto';
		}

		$feedDate = 'updated';

		/*
		 * Set some default values
		 * Use the default settings from the DB.
		 * All these settings can be overwritten by user.
		 */
		foreach (array('version' => $param['defaultVersion'],
			       'count' => $param['defaultCount'],
			       'useImage' => true,
			       'useEnclosure' => false,
			       'useCloud' => false,
			       'cloudDomain' => '',
			       'cloudPort' => '',
			       'cloudPath' => '',
			       'cloudRegisterProcedure' => '',
			       'cloudProtocol' => '',
			       'photosRecurseLimit' => '0',
			       'ttl' => $param['defaultTtl'],
			       'category' => '',
			       'description' => '',
			       'language' => 'en-us',
			       'copyright' => $param['defaultCopyright'],
			       'feedDate' => 'updated') as $key => $value) {
		    $EditFeed[$key] = $value;
		}

	    } else {
		/* There was an error: just leave the form the same it was */
		$EditFeed = array_merge($EditFeed, $form);
	    }
	} else if ($EditFeed['mode'] == 'edit') {
	    /*
	     * Editing a feed.
	     * Load the feed parameters
	     */
	    if (empty($form['error'])) {
		/* no error: load parameters from DB using the 'feedName' */
		list ($ret, $feed) = RssMapHelper::fetchFeed($form['feedName']);
		if ($ret) {
		    return array($ret, null);
		}

		$EditFeed = array_merge($EditFeed, $feed);

		if (GalleryUtilities::isA($item, 'GalleryAlbumItem')) {
		    $EditFeed['type'] = 'album';
		} else if (GalleryUtilities::isA($item, 'GalleryDataItem')) {
		    $EditFeed['type'] = 'photo';
		}

		$urlgenerator = $gallery->GetUrlGenerator();
		$EditFeed['feedUrl'] = $urlgenerator->generateUrl(
		    array('view' => 'rss.Render', 'name' => $form['feedName']),
			array('forceSessionId' => false, 'forceFullUrl' => true));
	    } else {
		/* There was an error: just leave the form the same it was */
		$EditFeed = array_merge($EditFeed, $form);
	    }
	} else {
	    /*
	     * No mode stated.
	     * Retieving all the feeds for this 'itemId'
	     * Fetch all feed definitions
	     */
	    list ($ret, $feeds) = RssMapHelper::fetchFeedsForItem($EditFeed['itemId']);
	    if ($ret) {
		return array($ret, null);
	    }

	    list ($ret, $EditFeed['types']) = RssHelper::getFeedTypeTranslation();
	    if ($ret) {
		return array($ret, null);
	    }

	    $EditFeed['feeds'] = $feeds;
	}

	$EditFeed['rssVersionList'] = array('0.91', '2.0');
	$template->setVariable('EditFeed', $EditFeed);
	$template->setVariable('param', $param);
	$template->setVariable('controller', 'rss.EditFeed');
	return array(null, array('body' => 'modules/rss/templates/EditFeed.tpl'));
    }
}
?>
');
expand_c19e8c72e9($outputDir, 'FeedList.inc', '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');
expand_c19e8c72e9($outputDir, 'MANIFEST', 'IyAkUmV2aXNpb246IDE2MDQxICQKIyBGaWxlIGNyYzMyIGNyYzMyKGNybGYpIHNpemUgc2l6ZShjcmxmKSAgb3IgIFIgRmlsZQptb2R1bGVzL3Jzcy9DYWxsYmFja3MuaW5jCTQwNTgyODI5NTkJMTQxMDE5NzU0OQkyMDk2CTIxNjcKbW9kdWxlcy9yc3MvRWRpdEZlZWQuaW5jCTQxMDQzNDI2NTcJNjA0OTc3OTIwCTEwNjI4CTEwOTcxCm1vZHVsZXMvcnNzL0ZlZWRMaXN0LmluYwkyNDQ0MzIyNzQyCTE4NjIwMDY0NDcJMTYwNwkxNjU1Cm1vZHVsZXMvcnNzL1ByZWxvYWRzLmluYwkxOTM3MTI3MzYwCTEwNDA3MzE3OQkxMjk5CTEzNDAKbW9kdWxlcy9yc3MvUmVuZGVyLmluYwkzNzQ1ODE0NjU1CTQyMjM1MjYwOTQJNTA0Ngk1MjI1Cm1vZHVsZXMvcnNzL1Jzc1NpdGVBZG1pbi5pbmMJMTgzMzE3Nzc3NQkzMTY5MTc2NDYwCTYyMDMJNjQxMwptb2R1bGVzL3Jzcy9TaW1wbGVSZW5kZXIuaW5jCTExNTk5ODYyMTIJMTQ5NjExOTc3NQkyNzI2CTI4MTgKbW9kdWxlcy9yc3MvY2xhc3Nlcy9HTlVtYWtlZmlsZQkxOTk1MzY2ODE5CTg0MzAyNTYzOQk1MQk1Mgptb2R1bGVzL3Jzcy9jbGFzc2VzL0dhbGxlcnlTdG9yYWdlL0dOVW1ha2VmaWxlCTE0NjU3NzY3ODIJMjAwOTE2MjYzMwk2MQk2Mgptb2R1bGVzL3Jzcy9jbGFzc2VzL0dhbGxlcnlTdG9yYWdlL3NjaGVtYS50cGwJMTg2OTcxNzI3MQkxNjc2MDM3NDIyCTMxMjYJMzIzNQptb2R1bGVzL3Jzcy9jbGFzc2VzL01hcHMuaW5jCTM3MzY4NzA5MTcJMTc1Mzk1MjE5Nwk0ODgJNDkyCm1vZHVsZXMvcnNzL2NsYXNzZXMvTWFwcy54bWwJOTIzNjcxMjU2CTYzOTc3NjQ3Mgk4NTAJODg0Cm1vZHVsZXMvcnNzL2NsYXNzZXMvUnNzR2VuZXJhdG9yLmNsYXNzCTMwNTcyNjU4NTQJNDY1NTI5ODA2CTk0MzcJOTc0MAptb2R1bGVzL3Jzcy9jbGFzc2VzL1Jzc0hlbHBlci5jbGFzcwkyNjQyMzg0Mzc2CTEzMTA2MTIyNTAJMTY1NjQJMTcxMjMKbW9kdWxlcy9yc3MvY2xhc3Nlcy9Sc3NNYXBIZWxwZXIuY2xhc3MJNjM4ODgwNDIJMjM1NjQ0NDg5MQk2OTE5CTcxNzgKbW9kdWxlcy9yc3MvbW9kdWxlLmluYwkzNzc4MDE0MjAxCTM3NzU0NTE3ODQJNTk4Ngk2MTk5Cm1vZHVsZXMvcnNzL3RlbXBsYXRlcy9FZGl0RmVlZC50cGwJNDA1MTI0NTAwMAkxNzI5OTQzMjkyCTE2MTkzCTE2NzEyCm1vZHVsZXMvcnNzL3RlbXBsYXRlcy9GZWVkTGlzdC50cGwJOTg2MzYxMTk3CTk4NzE4MTQxNAkxMDcyCTExMDUKbW9kdWxlcy9yc3MvdGVtcGxhdGVzL1Jzc0Jsb2NrSGVhZC50cGwJMjQ3MDczOTQzNAkyODY3MzcwOTcxCTU0NAk1NTgKbW9kdWxlcy9yc3MvdGVtcGxhdGVzL1Jzc1NpdGVBZG1pbi50cGwJMzY5OTUxMDE2NAkzNzI0NTAyNzEzCTE1NzYxCTE2MjA1Cm1vZHVsZXMvcnNzL3RlbXBsYXRlcy9ibG9ja3MvUnNzQmxvY2sudHBsCTMwNTE3NjM2MzEJMjQxNTY2NjgyCTc4MQk4MDQKbW9kdWxlcy9yc3MvdGVtcGxhdGVzL2Jsb2Nrcy9ibG9ja3MuaW5jCTIxMTA5ODM4ODQJMzY3OTkxNzU3NAk0NDgJNDY3Cg==');
expand_c19e8c72e9($outputDir, 'Preloads.inc', 'PD9waHAKLyoKICogR2FsbGVyeSAtIGEgd2ViIGJhc2VkIHBob3RvIGFsYnVtIHZpZXdlciBhbmQgZWRpdG9yCiAqIENvcHlyaWdodCAoQykgMjAwMC0yMDA3IEJoYXJhdCBNZWRpcmF0dGEKICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0CiAqIHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEsIFVTQS4KICovCgovKioKICogQHBhY2thZ2UgUnNzCiAqIEBhdXRob3IgSm9uYXRhbiBIZXltYW4gPGh0dHA6Ly9oZXltYW4uaW5mbz4KICogQGF1dGhvciBQaWVycmUtTHVjIFBhb3VyCiAqIEBhdXRob3IgRGFuaWVsIEdydW5kIDxodHRwOi8vd3d3LnBob3RvZ3J1bmQubmw+CiAqIEB2ZXJzaW9uICRSZXZpc2lvbjogMTU1MTMgJAogKi8KY2xhc3MgUnNzUHJlbG9hZHMgewogICAgZnVuY3Rpb24gcHJlbG9hZCgmJHRlbXBsYXRlLCAkcHJlbG9hZCwgJHBhcmFtU2V0KSB7CglnbG9iYWwgJGdhbGxlcnk7CgoJc3dpdGNoKCRwcmVsb2FkKSB7CgljYXNlICdSc3NCbG9jayc6CgkgICAgJHRlbXBsYXRlLT5oZWFkKCdtb2R1bGVzL3Jzcy90ZW1wbGF0ZXMvUnNzQmxvY2tIZWFkLnRwbCcpOwoJICAgIHJldHVybiBudWxsOwoJfQoKCXJldHVybiBHYWxsZXJ5Q29yZUFwaTo6ZXJyb3IoRVJST1JfQkFEX1BBUkFNRVRFUik7CiAgICB9Cn0KPz4K');
expand_c19e8c72e9($outputDir, 'Render.inc', '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');
expand_c19e8c72e9($outputDir, 'RssSiteAdmin.inc', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 Bharat Mediratta
 *
 * 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., 51 Franklin Street - Fifth Floor, Boston, MA  02110-1301, USA.
 */

GalleryCoreApi::requireOnce('modules/rss/classes/RssMapHelper.class');
GalleryCoreApi::requireOnce('modules/rss/classes/RssHelper.class');

/**
 * Settings for RSS
 * @package Rss
 * @subpackage UserInterface
 * @author Jonatan Heyman <http://heyman.info>
 * @author Pierre-Luc Paour
 * @author Daniel Grund <http://www.photogrund.nl>
 * @version $Revision: 15513 $
 */
class RssSiteAdminController extends GalleryController {

    /**
     * @see GalleryController::handleRequest
     */
    function handleRequest($form) {
	global $gallery;

	/* Make sure the user has permission to do this operation */
	$ret = GalleryCoreApi::assertUserIsSiteAdministrator();
	if ($ret) {
	    return array($ret, null);
	}

	$status = $results = $error = array();
	$mode = empty($form['mode']) ? '' : $form['mode'];

	if (isset($form['action']['save'])) {
	    if ($mode == 'settings') {
		/* error checking */
	       if (!isset($form['defaultVersion']) ||
			!($form['defaultVersion'] == '0.91' ||
			$form['defaultVersion'] == '2.0')) {
		    $error[] = 'form[error][defaultVersion]';
	       } else if (!isset($form['defaultCount']) || ((int)$form['defaultCount']) <= 0) {
		    $error[] = 'form[error][defaultCount]';
	       } else if (!isset($form['maxCount']) || ((int)$form['maxCount']) <= 0) {
		    $error[] = 'form[error][maxCount]';
	       } else if (!isset($form['defaultTtl']) || ((int)$form['defaultTtl']) < 0) {
		    $error[] = 'form[error][defaultTtl]';
	       } else if (!isset($form['defaultCopyright'])) {
		    $error[] = 'form[error][defaultCopyright]';
	       } else {
		    /* save parameters */
		    foreach (array('defaultVersion',
				   'defaultCount',
				   'maxCount',
				   'defaultCopyright',
				   'defaultTtl') as $setting) {
			$ret = GalleryCoreApi::setPluginParameter('module', 'rss',
								  $setting, $form[$setting]);
			if ($ret) {
			    return array($ret, null);
			}
		    }

		    foreach (array('allowSimpleFeed',
				   'allowConfigurableFeed',
				   'allowAlbums',
				   'allowPhotos',
				   'allowPhotosRecurse',
				   'allowCommentsPhoto',
				   'allowCommentsAlbum',
				   'allowCommentsRecursive') as $setting) {
			$ret = GalleryCoreApi::setPluginParameter('module', 'rss', $setting,
			    (isset($form[$setting]) && $form[$setting]) ? 1 : 0);
			if ($ret) {
			    return array($ret, null);
			}
		    }

		    $status['saved'] = 1;
		}
	    } else if ($mode == 'simplefeedsettings') {
		/* error checking */
		if (!isset($form['sfPhotosRecurseLimit'])
			|| ((int)$form['sfPhotosRecurseLimit']) < 0) {
		    $error[] = 'form[error][sfPhotosRecurseLimit]';
		} else {
		    /* save parameters */
		    foreach (array('sfAlbumType',
				   'sfPhotosRecurseLimit',
				   'sfDate') as $setting) {
			$ret = GalleryCoreApi::setPluginParameter('module', 'rss',
								  $setting, $form[$setting]);
			if ($ret) {
			    return array($ret, null);
			}
		    }

		    $status['saved'] = 1;
		}
	    }
	} else if (isset($form['action']['reset'])) {
	    /* do nothing */
	} else if (isset($form['action']['delete'])) {
	    $ret = RssMapHelper::deleteFeed($form['action']['delete']);
	    if ($ret) {
		return array($ret, null);
	    }

	    $mode = 'list';
	} else {
	    $error[] = 'form[error][unknownAction]';
	}

	/* figure out the method we will use */
	$method = empty($error) ? 'redirect' : 'delegate';
	$results['status'] = $status;
	$results['error'] = $error;
	$results[$method]['view'] = 'core.SiteAdmin';
	$results[$method]['subView'] = 'rss.RssSiteAdmin';
	$results[$method]['mode'] = $mode;

	return array(null, $results);
    }
}

/**
 * Settings for RSS
 */
class RssSiteAdminView extends GalleryView {

    /**
     * @see GalleryView::loadTemplate
     */
    function loadTemplate(&$template, &$form) {
	$form['formName'] = 'RssSiteAdmin';
	$RssSiteAdmin = array();
	$RssSiteAdmin['rssVersionList'] = array('0.91', '2.0');

	$ret = GalleryCoreApi::assertUserIsSiteAdministrator();
	if ($ret) {
	    return array($ret, null);
	}

	$RssSiteAdmin['mode'] = GalleryUtilities::getRequestVariables('mode');
	if (empty($RssSiteAdmin['mode'])) {
	    $RssSiteAdmin['mode'] = 'settings';
	}

	/* fetch module parameters and save them in form variable */
	list ($ret, $param) = GalleryCoreApi::fetchAllPluginParameters('module', 'rss');
	if ($ret) {
	    return array($ret, null);
	}
	foreach ($param as $key => $value) {
	    $form[$key] = $value;
	}

	if ($RssSiteAdmin['mode'] == 'list') {
	    /* fetch all feed definitions */
	    list ($ret, $feeds) = RssMapHelper::fetchFeedsForItem();
	    if ($ret) {
		return array($ret, null);
	    }

	    list ($ret, $RssSiteAdmin['types']) = RssHelper::getFeedTypeTranslation();
	    if ($ret) {
		return array($ret, null);
	    }

	    if (!empty($feeds)) {
		/* replace item Ids with actual items */
		$itemIds = array();
		foreach ($feeds as $feed) {
		    $itemIds[] = $feed['itemId'];
		}

		list ($ret, $items) = GalleryCoreApi::loadEntitiesById($itemIds);
		if ($ret) {
		    return array($ret, null);
		}

		for ($i = 0; $i < sizeof($feeds); $i++) {
		    $feeds[$i]['item'] = $items[$i];
		}
	    }

	    $RssSiteAdmin['feeds'] = $feeds;
	}

	$template->setVariable('RssSiteAdmin', $RssSiteAdmin);
	$template->setVariable('controller', 'rss.RssSiteAdmin');
	return array(null, array('body' => 'modules/rss/templates/RssSiteAdmin.tpl'));
    }
}
?>
');
expand_c19e8c72e9($outputDir, 'SimpleRender.inc', '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');
expand_c19e8c72e9($outputDir, 'classes/GNUmakefile', 'aW5jbHVkZSAuLi8uLi8uLi9saWIvdG9vbHMvYmluL0dOVW1ha2VmaWxlLmNsYXNzZXMK');
expand_c19e8c72e9($outputDir, 'classes/GalleryStorage/GNUmakefile', 'aW5jbHVkZSAuLi8uLi8uLi8uLi9saWIvdG9vbHMvYmluL0dOVW1ha2VmaWxlLkdhbGxlcnlTdG9yYWdlCg==');
expand_c19e8c72e9($outputDir, 'classes/GalleryStorage/schema.tpl', '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');
expand_c19e8c72e9($outputDir, 'classes/Maps.inc', 'PD9waHAKLyogVGhpcyBmaWxlIGlzIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGZyb20gTWFwcy54bWwgYnkgbGliL3Rvb2xzL2Jpbi9nZW5lcmF0ZS1tYXBzLnBocCAqLwokbWFwSW5mb1snUnNzTWFwJ10gPSBhcnJheSgnZmVlZE5hbWUnPT5hcnJheSgndHlwZSc9PlNUT1JBR0VfVFlQRV9TVFJJTkcsJ3NpemUnPT5TVE9SQUdFX1NJWkVfTUVESVVNLCdub3ROdWxsJz0+dHJ1ZSksJ2l0ZW1JZCc9PmFycmF5KCd0eXBlJz0+U1RPUkFHRV9UWVBFX0lOVEVHRVIsJ3NpemUnPT5TVE9SQUdFX1NJWkVfTUVESVVNLCdub3ROdWxsJz0+dHJ1ZSksJ293bmVySWQnPT5hcnJheSgndHlwZSc9PlNUT1JBR0VfVFlQRV9JTlRFR0VSLCdzaXplJz0+U1RPUkFHRV9TSVpFX01FRElVTSwnbm90TnVsbCc9PnRydWUpLCdwYXJhbXMnPT5hcnJheSgndHlwZSc9PlNUT1JBR0VfVFlQRV9URVhULCdzaXplJz0+U1RPUkFHRV9TSVpFX1NNQUxMLCdub3ROdWxsJz0+dHJ1ZSkpOwo/Pgo=');
expand_c19e8c72e9($outputDir, 'classes/Maps.xml', 'PCFET0NUWVBFIG1hcHMgU1lTVEVNICIuLi8uLi8uLi9saWIvdG9vbHMvZHRkL01hcHNEZWZpbml0aW9uMi4wLmR0ZCI+CjxtYXBzPgogIDxtYXA+CiAgICA8bWFwLW5hbWU+UnNzTWFwPC9tYXAtbmFtZT4KICAgIDxzY2hlbWE+CiAgICAgIDxzY2hlbWEtbWFqb3I+MTwvc2NoZW1hLW1ham9yPgogICAgICA8c2NoZW1hLW1pbm9yPjA8L3NjaGVtYS1taW5vcj4KICAgIDwvc2NoZW1hPgogICAgPG1lbWJlcj4KICAgICAgPG1lbWJlci1uYW1lPmZlZWROYW1lPC9tZW1iZXItbmFtZT4KICAgICAgPG1lbWJlci10eXBlPlNUUklORzwvbWVtYmVyLXR5cGU+CiAgICAgIDxtZW1iZXItc2l6ZT5NRURJVU08L21lbWJlci1zaXplPgogICAgICA8cHJpbWFyeS8+CiAgICA8L21lbWJlcj4KICAgIDxtZW1iZXI+CiAgICAgIDxtZW1iZXItbmFtZT5pdGVtSWQ8L21lbWJlci1uYW1lPgogICAgICA8bWVtYmVyLXR5cGU+SU5URUdFUjwvbWVtYmVyLXR5cGU+CiAgICAgIDxpbmRleGVkLz4KICAgICAgPHJlcXVpcmVkLz4KICAgIDwvbWVtYmVyPgogICAgPG1lbWJlcj4KICAgICAgPG1lbWJlci1uYW1lPm93bmVySWQ8L21lbWJlci1uYW1lPgogICAgICA8bWVtYmVyLXR5cGU+SU5URUdFUjwvbWVtYmVyLXR5cGU+CiAgICAgIDxpbmRleGVkLz4KICAgICAgPHJlcXVpcmVkLz4KICAgIDwvbWVtYmVyPgogICAgPG1lbWJlcj4KICAgICAgPG1lbWJlci1uYW1lPnBhcmFtczwvbWVtYmVyLW5hbWU+CiAgICAgIDxtZW1iZXItdHlwZT5URVhUPC9tZW1iZXItdHlwZT4KICAgICAgPG1lbWJlci1zaXplPlNNQUxMPC9tZW1iZXItc2l6ZT4KICAgICAgPHJlcXVpcmVkLz4KICAgIDwvbWVtYmVyPgogIDwvbWFwPgo8L21hcHM+Cg==');
expand_c19e8c72e9($outputDir, 'classes/RssGenerator.class', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 Bharat Mediratta
 *
 * 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., 51 Franklin Street - Fifth Floor, Boston, MA  02110-1301, USA.
 */

/**
 * @package Rss
 * @subpackage Classes
 * @author Jonatan Heyman <http://heyman.info>
 * @author Pierre-Luc Paour
 * @author Daniel Grund <http://www.photogrund.nl>
 * @version $Revision: 15513 $
 */
class RssGenerator {
    /**
     * An array of all the items (in the RSS sense of the term) in the feed
     *
     * @var array $_items
     * @access private
     */
    var $_items = array();

    /**
     * An array of global properties for the feed
     *
     * @var array $_properties
     * @access private
     */
    var $_properties = array();

    /**
     * Add an item to the RSS feed that will be generated
     *
     * @param array $properties item properties array
     * @param string $key optional key for the item array
     */
    function addItem($properties, $key='') {
	/* add the new item to our items array */
	if ($key == '') {
	    $this->_items[] = $properties;
	} else {
	    $this->_items[$key] = $properties;
	}
    }

    /**
     * Function to set the items array that will be used when generated the feed
     * @param array $items
     */
    function setItems($items) {
	$this->_items = $items;
    }

    /**
     * Add a channel property to the feed that will be generated
     *
     * @param string $name property name
     * @param string $value property value
     */
    function addProperty($name, $value) {
	$this->_properties[$name] = $value;
    }

    /**
     * Set the channel properties of the feed that will be generated
     *
     * @param array $properties properties
     */
    function setProperties($properties) {
	$this->_properties = $properties;
    }

    /**
     * Change the order of the items in the $_items array
     * (useful if $key variable is used when items are added)
     *
     * @param string $order Can either be ASC or DESC
     */
    function sortItems($order) {
	if ($order == 'ASC') {
	    ksort($this->_items);
	} else if ($order == 'DESC') {
	    krsort($this->_items);
	}
    }

    /**
     * Removes all items except the first $count items
     *
     * @param int $count
     */
    function sliceItems($count) {
	$this->_items = array_slice($this->_items, 0, $count);
    }

    /**
     * Generate the RSS data string of the items added by addItem()
     *
     * @param string $version the rss version number
     * @return string rss stream
     */
    function generate($version) {
	switch ($version) {
	case '0.91':
	    return $this->generate091();
	    break;
	case '2.0':
	    return $this->generate200();
	    break;
	}
    }

    /**
     * Generate RSS 0.91 data
     *
     * @return string rss stream
     */
    function generate091() {
	global $gallery;

	if (!isset($this->_properties['title']) ||
	    !isset($this->_properties['link']) ||
	    !isset($this->_properties['description']) ||
	    !count($this->_items))
	    return '';

	$platform =& $gallery->getPlatform();
	$lf = $platform->getLineEnding();

	$data = '<?xml version="1.0"?>' . $lf .
	    '<!DOCTYPE rss SYSTEM "http://my.netscape.com/publish/formats/rss-0.91.dtd">' . $lf .
	    '<rss version="0.91"><channel>' . $lf .
	    '<title>' . $this->cdata(GalleryUtilities::markup($this->_properties['title'])) .
	    '</title>' . $lf .
	    '<link>' . $this->_properties['link'] . '</link>' . $lf .
	    '<description>' .
	    $this->cdata(GalleryUtilities::markup($this->_properties['description'])) .
	    '</description>' . $lf .
	    (isset($this->_properties['language']) ?
		'<language>' . $this->_properties['language'] .
		'</language>' : '') . $lf .
	    (!empty($this->_properties['copyright']) ?
		'<copyright>' . GalleryUtilities::markup($this->_properties['copyright']) .
		'</copyright>' : '');

	if (isset($this->_properties['webmaster'])) {
	    $data .= '<webMaster>' . GalleryUtilities::markup($this->_properties['webmaster']) .
	    '</webMaster>' . $lf;
	}

	if (isset($this->_properties['image'])) {
	    $data .= '<image>' . $lf .
		' <title>' .
		$this->cdata(GalleryUtilities::markup($this->_properties['image']['title'])) .
		'</title>' . $lf .
		' <link>' . $this->_properties['image']['link'] . '</link>' . $lf .
		' <url>' . $this->_properties['image']['url'] . '</url>' . $lf .
		'</image>' . $lf;
	}

	foreach ($this->_items as $item) {
	    if (isset($item['title'])) {
		$data .= '<item>' . $lf .
		    ' <title>' . $this->cdata(GalleryUtilities::markup($item['title'])) .
		    '</title>' . $lf .
		    ' <link>' . $item['link'] . '</link>' . $lf .
		    ' <description>' .
		    $this->cdata(GalleryUtilities::markup($item['description'])) .
		    '</description>' . $lf .
		    '</item>' . $lf;
	    }
	}

	$data .= '</channel>' . $lf . '</rss>';

	return $data;
    }

    /**
     * Generate RSS 2.0 data
     *
     * @return string rss stream
     */
    function generate200() {
	global $gallery;

	$platform =& $gallery->getPlatform();
	$lf = $platform->getLineEnding();

	$data = '<rss version="2.0">' . $lf . '<channel>' . $lf .
	    '<title>' . $this->cdata(GalleryUtilities::markup($this->_properties['title'])) .
	    '</title>' . $lf .
	    '<link>' . $this->_properties['link'] . '</link>' . $lf .
	    '<description>' .
	    $this->cdata(GalleryUtilities::markup($this->_properties['description'])) .
	    '</description>' . $lf .
	    (isset($this->_properties['language']) ?
		'<language>' . $this->_properties['language'] . '</language>' . $lf  : '') .
	    (!empty($this->_properties['copyright']) ?
		'<copyright>' . GalleryUtilities::markup($this->_properties['copyright']) .
		'</copyright>' . $lf  : '') .
	    (!empty($this->_properties['category']) ?
		'<category>' . GalleryUtilities::markup($this->_properties['category']) .
		'</category>' . $lf  : '') .
	    (isset($this->_properties['generator']) ?
		'<generator>' . GalleryUtilities::markup($this->_properties['generator']) .
		'</generator>' . $lf  : '') .
	    (isset($this->_properties['lastBuildDate']) ?
		'<lastBuildDate>' . $this->_properties['lastBuildDate'] .
		'</lastBuildDate>' . $lf  : '') .
	    (isset($this->_properties['ttl']) ?
		'<ttl>' . $this->_properties['ttl'] . '</ttl>' . $lf : '') .
	    (isset($this->_properties['cloud']) ?
		'<cloud domain="' .
		GalleryUtilities::markup($this->_properties['cloud']['domain']) .
		'" port="' . $this->_properties['cloud']['port'] .
		'" path="' . GalleryUtilities::markup($this->_properties['cloud']['path']) .
		'" registerProcedure="' . $this->_properties['cloud']['registerProcedure'] .
		'" protocol="' . $this->_properties['cloud']['protocol'] . '" />' . $lf : '')
	    . (isset($this->_properties['image']) ?
		'<image><url>' . $this->_properties['image']['url'] . '</url>' . $lf .
	       ' <title>' .
	       $this->cdata(GalleryUtilities::markup($this->_properties['image']['title'])) .
		'</title>' . $lf .
		' <link>' . $this->_properties['image']['link'] . '</link></image>' : '');

	foreach ($this->_items as $item) {
	    if (isset($item['title']) && isset($item['link']) && isset($item['description'])) {
		$data .= '<item>' . $lf .
		    ' <title>' . $this->cdata(GalleryUtilities::markup($item['title'])) .
		    '</title>' . $lf .
		    ' <link>' . $item['link'] . '</link>' . $lf .
		    ' <guid isPermaLink="false">' . $item['link'] . '</guid>' . $lf .
		    ' <description>' .
		    $this->cdata(GalleryUtilities::markup($item['description']))
		    . '</description>' . $lf;

		if (isset($item['author'])) {
		    $data .= ' <author>' . GalleryUtilities::markup($item['author']) .
			     '</author>' . $lf;
		}

		if (isset($item['category'])) {
		    $data .= ' <category>' . GalleryUtilities::markup($item['category']) .
			     '</category>' . $lf;
		}

		if (isset($item['comments'])) {
		    $data .= ' <comments>' . GalleryUtilities::markup($item['comments']) .
			     '</comments>' . $lf;
		}

		if (isset($item['enclosure'])) {
		    $data .= ' <enclosure url="' . $item['enclosure']['url'] . '" length="' .
			$item['enclosure']['length'] . '" type="' .
			$item['enclosure']['type'] . '" />' . $lf;
		}

		if (isset($item['guid'])) {
		    $data .= ' <guid>' . $item['guid'] . '</guid>' . $lf;
		}

		if (isset($item['pubDate'])) {
		    $data .= ' <pubDate>' . $item['pubDate'] . '</pubDate>' . $lf;
		}

		if (isset($item['source'])) {
		    $data .= ' <source>' . $item['source'] . '</source>' . $lf;
		}

		$data .= '</item>' . $lf;
	    }
	}

	$data .= '</channel>' . $lf . '</rss>';
	return $data;
    }

    /**
     * Wrap a text element in <![CDATA .. ]]>
     * @param string $text
     * @return string wrapped text
     */
    function cdata($text) {
	return '<![CDATA[' . $text . ']]>';
    }
}
?>
');
expand_c19e8c72e9($outputDir, 'classes/RssHelper.class', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 Bharat Mediratta
 *
 * 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., 51 Franklin Street - Fifth Floor, Boston, MA  02110-1301, USA.
 */

/*
 * Check if the comments module exists and load GalleryCommentHelper in that case, which is used to
 * retrieve comments from the database for comments rss feeds.
 * @todo Don't access GalleryCommentHelper directly
 */
if (GalleryPlatform::file_exists(dirname(__FILE__)
	    . '/../../comment/classes/GalleryCommentHelper.class')) {
    GalleryCoreApi::requireOnce('modules/comment/classes/GalleryCommentHelper.class');
}

/**
 * Helper class for the RSS module
 * @package Rss
 * @subpackage Classes
 * @author Jonatan Heyman <http://heyman.info>
 * @author Pierre-Luc Paour
 * @author Daniel Grund <http://www.photogrund.nl>
 * @version $Revision: 15513 $
 * @static
 */
class RssHelper {
    /**
     * This function takes an RssGenerator as a pass-by-reference variable and adds gallery item
     * data to it, so that an rss feed can be generated.
     *
     * @param object RssGenerator $generator object that will get the data.
     * @param int $id Id of the album from where the photoitems shall be retrieved.
     * @param array $params Additional parameters.
     * @return object GalleryStatus
     */
    function getFeed(&$generator, $id, $param) {
	global $gallery;

	/* get gallery entity by id */
	list ($ret, $entity) = GalleryCoreApi::loadEntitiesById($id);
	if ($ret) {
	    return $ret;
	}

	/* get member data for the <channel> properties */
	$memberData = (array) $entity;

	/* generate url to the album and rss feed */
	$urlGenerator =& $gallery->getUrlGenerator();
	$albumUrl = $urlGenerator->generateUrl(
	    array(
		'view' => 'core.ShowItem',
		'itemId' => $memberData['id']),
	    array(
		'forceSessionId' => false,
		'forceFullUrl' => true));

	$generator->addProperty('title', $memberData['title']);
	$generator->addProperty('description', $memberData['description']);
	$generator->addProperty('link', $albumUrl);

	if ($param['useImage']) {
	    /* retrieve gallery thumbnail */
	    list ($ret, $thumbArrayl) = GalleryCoreApi::fetchThumbnailsByItemIds(array($id));
	    if ($ret) {
		return $ret;
	    }

	    /* check if image tag should be used */
	    if (!empty($thumbArrayl)) {
		$thumb = $thumbArrayl[$id];
		$imageUrl = $urlGenerator->generateUrl(
		    array(
			'view' => 'core.DownloadItem',
			'itemId' => $thumb->getId()),
		    array(
			'forceSessionId' => false,
			'forceFullUrl' => true));

		$generator->addProperty('image', array('title' => $memberData['title'],
		    'url' => $imageUrl, 'link' => $albumUrl));
	    }
	}

	/* check if the cloud tag should be used */
	if ($param['useCloud']) {
	    $cloud = array('domain' => $param['cloudDomain'],
			   'port' => $param['cloudPort'],
			   'path' => $param['cloudPath'],
			   'registerProcedure' => $param['cloudRegisterProcedure'],
			   'protocol' => $param['cloudProtocol']);
	    $generator->addProperty('cloud', $cloud);
	}

	/* add copyright, category and generator */
	if (isset($param['copyright'])) {
	    $generator->addProperty('copyright', $param['copyright']);
	}
	if (isset($param['category'])) {
	    $generator->addProperty('category', $param['category']);
	}
	list ($ret, $version) =
	    GalleryCoreApi::getPluginParameter('module', 'rss', '_version');
	$generator->addProperty('generator', 'Gallery 2 RSS Module, version ' . $version);
	$generator->addProperty('ttl', $param['ttl']);
	$vm = $gallery->getPhpVm();
	$generator->addProperty('lastBuildDate', date('r', $vm->time()));

	/* language tag */
	$generator->addProperty('language', $param['language']);

	$items = array();
	$newOnly = ($param['feedDate'] == 'new');

	switch ($param['feedType']) {
	    case 'album':
	    case 'photosRecurse':
		/* get sub-albums or items, ordered by date */
		list ($ret, $items) = RssHelper::fetchAlbumTree(
		    $entity->getId(),
		    $param['count'],
		    $newOnly,
		    $param['feedType'] != 'album',
		    $param['feedType'] == 'photosRecurse'?$param['photosRecurseLimit']:0);
		if ($ret) {
		    return $ret;
		}

		if (!empty($items)) {
		    list ($ret, $items) = GalleryCoreApi::loadEntitiesById($items);
		    if ($ret) {
			return $ret;
		    }

		    if ($param['feedType'] == 'photosRecurse') {
			/* load parents also, so we can display the name of the parent albums */
			$parentIds = array();

			foreach ($items as $item) {
			    if (!in_array($item->getParentId(), $parentIds)) {
				$parentIds[] = $item->getParentId();
			    }
			}

			list ($ret, $parents) = GalleryCoreApi::loadEntitiesById($parentIds);
			if ($ret) {
			    return $ret;
			}

			$parentsA = array();
			foreach ($parents as $parent) {
			    $parentsA[$parent->getId()] = $parent;
			}

			$param['parents'] = $parentsA;
		    }
		}

		break;

	    case 'photos':
		list ($ret, $items) = RssHelper::getPhotoFeed($entity, $newOnly);
		if ($ret) {
		    return $ret;
		}

		break;

	    case 'commentsAlbum':
	    case 'commentsPhoto':
		list ($ret, $items) = GalleryCommentHelper::fetchComments($id,
		    $param['count'], ORDER_DESCENDING);
		if ($ret) {
		    return $ret;
		}

		break;
	    case 'commentsRecursive':
		list ($ret, $items) = GalleryCommentHelper::fetchAllComments($id,
		    $param['count'], null, ORDER_DESCENDING);
		if ($ret) {
		    return $ret;
		}

		break;
	}

	/* go through subitems array and pass data to generator */
	if (!empty($items)) {
	    foreach ($items as $item) {
		$ret = RssHelper::addItem($generator, $item, $param);

		if ($ret) {
		    return $ret;
		}
	    }
	}

	return null;
    }

    /**
     * This function retrieves photos and put them in an array.
     *
     * @param object GalleryAlbumItem $entity Album that we shall retrieve photos/comments from.
     * @return array object GalleryStatus
     *               array  creationTimeStamp => GalleryItem
     */
    function getPhotoFeed($entity, $newOnly) {
	/* retrieve subitems' ids */
	list ($ret, $subIds) = GalleryCoreApi::fetchChildItemIds($entity);
	if ($ret) {
	    return array($ret, null);
	}

	$itemsAcc = array();
	$sortParam = $newOnly ? 'creationTimestamp' : 'modificationTimestamp';

	/* go through subitems array and pass data to generator */
	if (!empty($subIds)) {
	    /* retrieve array of subitems */
	    list ($ret, $subItems) = GalleryCoreApi::loadEntitiesById($subIds);
	    if ($ret) {
		return array($ret, null);
	    }

	    foreach ($subItems as $key => $subItem) {
		/* check if the subitem is a photo */
		if (GalleryUtilities::isA($subItem, 'GalleryDataItem')) {
		    $itemData = (array) $subItem;
		    $key = $itemData[$sortParam] . '_' . $itemData['id'];
		    $itemsAcc[$key] = $subItem;
		}
	    }
	}

	krsort($itemsAcc);

	return array(null, $itemsAcc);
    }

    /**
     * This function adds an item to the feed generator
     *
     * @param object RssGenerator $generator reference to the generator
     * @param object GalleryEntity $item item to add
     * @param array $param feed parameters
     * @return object GalleryStatus
     */
    function addItem(&$generator, $item, $param) {
	if (GalleryUtilities::isA($item, 'GalleryDataItem')
		|| GalleryUtilities::isA($item, 'GalleryAlbumItem')) {
	    return RssHelper::addPhotoOrAlbum($generator, $item, $param);
	} else if (GalleryUtilities::isA($item, 'GalleryComment')) {
	    return RssHelper::addComment($generator, $item, $param);
	} else {
	    return GalleryCoreApi::error(ERROR_INVALID_OBJECT);
	}
    }

    /**
     * This function adds a photo or an album item to the feed generator
     *
     * @param object RssGenerator $generator reference to the generator
     * @param object GalleryItem $item item to add
     * @param array $param feed parameters
     * @return object GalleryStatus
     */
    function addPhotoOrAlbum(&$generator, $item, $param) {
	global $gallery;

	/* generate url to the images */
	$urlGenerator =& $gallery->getUrlGenerator();
	$url = $urlGenerator->generateUrl(
	    array('view' => 'core.ShowItem', 'itemId' => $item->getId()),
	    array('forceSessionId' => false, 'forceFullUrl' => true));

	/* generate description */
	$description = $item->getDescription();
	if (!isset($description)) {
	    $description = '';
	}

	list ($ret, $thumbnails) = GalleryCoreApi::fetchThumbnailsByItemIds(array($item->getId()));
	if ($ret) {
	    return $ret;
	}

	if (!empty($thumbnails) && !empty($thumbnails[$item->getId()])) {
	    $thumbnail = $thumbnails[$item->getId()];
	    $imageUrl = $urlGenerator->generateUrl(
		array(
		    'view' => 'core.DownloadItem',
		    'itemId' => $thumbnail->getId()),
		array(
		    'forceSessionId' => false,
		    'forceFullUrl' => true));

	    $description = '<a href="' . $url .'"><img border="0" src="' . $imageUrl .
		'" width="' . $thumbnail->getWidth() .
		'" height="' . $thumbnail->getHeight() .
		'"/></a>' . (!empty($description) ? '<br/>' . $description : $description);
	}

	if ($param['feedType'] == 'photosRecurse') {
	    /* add a link to the parent album */
	    list ($ret, $module) = GalleryCoreApi::loadPlugin('module', 'rss');
	    if ($ret) {
		return $ret;
	    }

	    $url1 = $urlGenerator->generateUrl(
		array('view' => 'core.ShowItem', 'itemId' => $item->getParentId()),
		array('forceSessionId' => false, 'forceFullUrl' => true));

	    $description .= '<br/>' . $module->translate(
		array('text' => 'In album <a href="%s">%s</a>',
		'arg1' => $url1,
		'arg2' => $param['parents'][$item->getParentId()]->getTitle()));
	}

	$title = $item->getTitle();
	if (!isset($title)) {
	    $title = $item->getPathComponent();
	}

	$itemSettings = array('title' => $title,
			      'link' => $url,
			      'description' => $description);

	if (GalleryUtilities::isA($item, 'GalleryAlbumItem')) {
	    $itemSettings['category'] = 'album';
	} else {
	    $itemSettings['category'] = 'photo';
	}

	$itemSettings['pubDate'] = date('r', $item->getModificationTimestamp());

	/* check if the enclosure tag should be used */
	if (GalleryUtilities::isA($item, 'GalleryDataItem')
		&& isset($param['useEnclosure'])
		&& $param['useEnclosure'] == '1') {
	    $imageUrl = $urlGenerator->generateUrl(
		array(
		    'view' => 'core.DownloadItem',
		    'itemId' => $item->getId()),
		array(
		    'forceSessionId' => false,
		    'forceFullUrl' => true));
	    $itemSettings['enclosure'] = array(
		'url' => $imageUrl,
		'length' => $item->getSize(),
		'type' => $item->getMimeType());
	}

	$generator->addItem($itemSettings, $item->getId());

	return null;
    }

    /**
     * This function adds a comment item to the feed generator
     *
     * @param object RssGenerator $generator reference to the generator
     * @param object GalleryComment $item item to add
     * @param array $param feed parameters
     * @return object GalleryStatus
     */
    function addComment(&$generator, $item, $param) {
	global $gallery;

	/* generate url to the images */
	$urlGenerator =& $gallery->getUrlGenerator();
	$url = $urlGenerator->generateUrl(
	    array('view' => 'comment.ShowAllComments', 'itemId' => $item->getParentId()),
	    array('forceSessionId' => false, 'forceFullUrl' => true));

	$itemSettings = array(
	    'title' => $item->getSubject(),
	    'link' => $url,
	    'description' => $item->getComment());

	/* check if we should use the category tag */
	if (isset($param['useItemCategory']) && $param['useItemCategory'] == '1') {
	    $itemSettings['category'] = 'comment';
	}

	/* check if pubDate tag should be used */
	if (isset($param['usePubDate']) && $param['usePubDate']) {
	    $itemSettings['pubDate'] = date('r', $item->getDate());
	}

	$generator->addItem($itemSettings, $item->getId());

	return null;
    }

    /**
     * This function fetches albums or items inside a root album
     *
     * @param int $itemId the root album Id
     * @param int $limit the maximum number of items to fetch from the DB
     * @param boolean $newOnly if true, only select new items (not changed)
     * @param boolean $allowPhotos if true, returns photos; if false, albums
     * @param int $perAlbumLimit the maximum number of pictures to return from a single album
     * @return array object GalleryStatus
     *               array of item Ids
     *
     * copied and modified from GalleryItemHelper_simple
     */
    function fetchAlbumTree($itemId, $limit, $newOnly, $allowPhotos, $perAlbumLimit = 0) {
	global $gallery;
	$storage =& $gallery->getStorage();
	$userId = $gallery->getActiveUserId();

	list ($ret, $aclIds) = GalleryCoreApi::fetchAccessListIds('core.view', $userId);
	if (empty($aclIds)) {
	    return array(null, array());
	}
	$aclMarkers = GalleryUtilities::makeMarkers(count($aclIds));

	list ($ret, $parentSequence) = GalleryCoreApi::fetchParentSequence($itemId);
	if ($ret) {
	    return array($ret, null);
	}

	$ret = GalleryCoreApi::assertHasItemPermission($itemId, 'core.view');
	if ($ret) {
	    return array($ret, null);
	}
	$parentSequence[] = $itemId;
	$parentSequence = implode('/', $parentSequence);

	$timestamp = $newOnly ? 'creationTimestamp' : 'modificationTimestamp';
	$table = $allowPhotos ? 'GalleryDataItem' : 'GalleryAlbumItem';

	list ($ret, $newDays) =
	    GalleryCoreApi::getPluginParameter('module', 'newitems', 'days.new');
	if ($ret || !$newDays) {
	    $newDays = 1; /* Use default on error or zero setting */
	}
	$timeCutOff = time() - 3600 * 24 * $newDays;

	$query = "
	    SELECT
	      [$table::id]";

	if ($perAlbumLimit != 0) {
	    $query .= ', [GalleryItemAttributesMap::parentSequence]';
	}

	$query .= "
	    FROM
	      [$table], [GalleryItemAttributesMap],
	      [GalleryAccessSubscriberMap], [GalleryEntity]
	    WHERE
	      [GalleryEntity::$timestamp] >= $timeCutOff
	      AND
	      [$table::id] = [GalleryItemAttributesMap::itemId]
	      AND
	      [$table::id] = [GalleryEntity::id]";

	if (!empty($parentSequence)) {
	    $query .= "
	      AND
	      [GalleryItemAttributesMap::parentSequence] LIKE '$parentSequence/%'";
	}

	$query .= "
	      AND
	      [$table::id] = [GalleryAccessSubscriberMap::itemId]
	      AND
	      [GalleryAccessSubscriberMap::accessListId] IN ($aclMarkers)
	    ORDER BY
	      [GalleryEntity::$timestamp] DESC
	    ";

	$data = $aclIds;

	$params = array();

	if (isset($limit)) {
	    $params['limit'] = array('count' => $limit);
	}

	list ($ret, $searchResults) = $gallery->search($query, $data, $params);
	if ($ret) {
	    return array($ret, null);
	}

	$list = array();
	$perAlbum = array();
	while ($result = $searchResults->nextResult()) {
	    if ($perAlbumLimit != 0) {
		/*
		 * check number of items already accepted for this album
		 * is lower than the limit
		 */
		if (isset($perAlbum[$result[1]])) {
		    $n = $perAlbum[$result[1]];

		    if ($n < $perAlbumLimit) {
			/* under the limit */
			$perAlbum[$result[1]] = $n + 1;
			$list[] = $result[0];
		    }
		} else {
		    /* first item for this album: accept */
		    $perAlbum[$result[1]] = 1;
		    $list[] = $result[0];
		}
	    } else {
		/* include all results */
		$list[] = $result[0];
	    }
	}

	return array(null, $list);
    }

    /**
     * This provides a translation of the feed type codes
     *
     * @return array object GalleryStatus
     *               array of feedType => translation
     */
    function getFeedTypeTranslation() {
	list ($ret, $module) = GalleryCoreApi::loadPlugin('module', 'rss');
	if ($ret) {
	    return array($ret, null);
	}

	return array(null, array(
		'photos' => $module->translate('Items in an album'),
		'album' => $module->translate('Sub-albums of an album'),
		'photosRecurse' => $module->translate('Items in an album and its sub-albums'),
		'commentsAlbum' => $module->translate('Comments for an album'),
		'commentsPhoto' => $module->translate('Comments for an item'),
		'commentsRecursive' =>
		    $module->translate('Comments for an album and its subalbums'),
		));
    }
}
?>
');
expand_c19e8c72e9($outputDir, 'classes/RssMapHelper.class', '<?php
/*
 * Gallery - a web based photo album viewer and editor
 * Copyright (C) 2000-2007 Bharat Mediratta
 *
 * 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., 51 Franklin Street - Fifth Floor, Boston, MA  02110-1301, USA.
 */

/**
 * Utility functions useful in managing Rss
 * @package Rss
 * @subpackage Classes
 * @author Pierre-Luc Paour <gallery@paour.com>
 * @version $Revision: 15513 $
 * @static
 */
class RssMapHelper {

    /**
     * Return the feeds defined for a given item
     *
     * @param int $itemId (optional) item id or null for all feeds
     * @return array object GalleryStatus a status code
     *         array of array 'name' => feed name
     *                        'itemId' => item associated with the feed
     *                        'ownerId' => owner of the feed
     *                        'params' => feed definition
     */
    function fetchFeedsForItem($itemId=null) {
	global $gallery;

	if (isset($itemId)) {
	    list ($ret, $searchResults) = GalleryCoreApi::getMapEntry('RssMap',
		array('feedName', 'itemId', 'ownerId', 'params'),
		array('itemId' => $itemId));
	    if ($ret) {
		return array($ret, null);
	    }
	} else {
	    $query = '
	    SELECT
	      [RssMap::feedName], [RssMap::itemId], [RssMap::ownerId], [RssMap::params]
	    FROM
	      [RssMap]
	    ';

	    list ($ret, $searchResults) = $gallery->search($query);
	    if ($ret) {
		return array($ret, null);
	    }
	}

	$feeds = array();
	while ($result = $searchResults->nextResult()) {
	    $params = unserialize($result[3]);

	    if ($params != false) {
		$feed = array('name' => $result[0],
			      'itemId' => $result[1],
			      'ownerId' => $result[2],
			      'params' => $params);
		$feeds[] = $feed;
	    } else {
		/* unserialization error */
		return array(GalleryCoreApi::error(ERROR_STORAGE_FAILURE),
			     null);
	    }
	}
	return array(null, $feeds);
    }

    /**
     * Return all the feed names
     *
     * @param int $limit optional limit to the number of feeds
     * @return array object GalleryStatus a status code
     *         array of feed names
     */
    function fetchFeedNames($limit=0) {
	global $gallery;

	$query = '
	SELECT
	  [RssMap::feedName]
	FROM
	  [RssMap]
	';

	$params = array();
	if (isset($limit)) {
	    $params['limit'] = array('count' => $limit);
	}

	list ($ret, $searchResults) = $gallery->search($query, null, $params);
	if ($ret) {
	    return array($ret, null);
	}

	$names = array();
	while ($result = $searchResults->nextResult()) {
	    $names[] = $result[0];
	}

	return array(null, $names);
    }

    /**
     * Fetch a feed
     *
     * @param string $feedName
     * @return object GalleryStatus a status code
     */
    function fetchFeed($feedName) {
	list ($ret, $searchResults) = GalleryCoreApi::getMapEntry('RssMap',
	    array('params'), array('feedName' => $feedName));
	if ($ret) {
	    return array($ret, null);
	}

	$params = array();
	if ($result = $searchResults->nextResult()) {
	    $params = unserialize($result[0]);

	    if ($params != false) {
		return array(null, $params);
	    } else {
		/* unserialization error */
		return array(GalleryCoreApi::error(ERROR_STORAGE_FAILURE),
			     null);
	    }
	} else {
	    return array(GalleryCoreApi::error(ERROR_MISSING_OBJECT), null);
	}
    }

    /**
     * Create a feed
     *
     * @param string $feedName
     * @param array $params parameters
     * @return object GalleryStatus a status code
     */
    function createFeed($feedName, $params) {
	global $gallery;

	/* first, check for collision */
	list ($ret, $feed) = RssMapHelper::fetchFeed($feedName);
	if (!$ret) {
	    /* we expected an ERROR_MISSING_OBJECT, this means we have a collision. Throw it */
	    return GalleryCoreApi::error(ERROR_COLLISION);
	} else if (!$ret->getErrorCode() & ERROR_MISSING_OBJECT) {
	    return $ret;
	}

	$ret = GalleryCoreApi::addMapEntry('RssMap',
	    array('feedName' => $feedName,
		  'itemId' => $params['itemId'],
		  'ownerId' => $gallery->getActiveUserId(),
		  'params' => serialize($params)));
	if ($ret) {
	    return $ret;
	}

	return null;
    }

    /**
     * Update a feed
     *
     * @param string $feedName
     * @param array $params parameters
     * @return object GalleryStatus a status code
     */
    function updateFeed($feedName, $params) {
	$ret = GalleryCoreApi::updateMapEntry('RssMap',
	    array('feedName' => $feedName),
		  array('feedName' => $feedName,
			'itemId' => $params['itemId'],
			'params' => serialize($params)));
	if ($ret) {
	    return $ret;
	}

	return null;
    }

    /**
     * Delete a feed
     *
     * @param string $feedName
     * @return object GalleryStatus a status code
     */
    function deleteFeed($feedName) {
	$ret = GalleryCoreApi::removeMapEntry('RssMap', array('feedName' => $feedName));
	if ($ret) {
	    return $ret;
	}

	return null;
    }

    /**
     * Check whether configuring feeds is allowed.
     *
     * @param object GalleryItem $item
     * @param array $params module parameters
     * @param int $userId
     * @param boolean $assert (optional) if true, throw error if not allowed
     * @return array object GalleryStatus a status code
     *               boolean true if allowed
     */
    function canConfigureFeed($item, $params, $userId, $assert=false) {
	static $isAdmin;
	if (!isset($isAdmin[$userId])) {
	    list ($ret, $isAdmin[$userId]) = GalleryCoreApi::isUserInSiteAdminGroup($userId);
	    if ($ret) {
		return array($ret, null);
	    }
	}

	/*
	 * show the configure feeds link if:
	 *   - the user is the item owner or the admin
	 *   - configurable feeds are allowed
	 *   - and the allowed feeds are appropriate for this item type
	 */
	if ($params['allowConfigurableFeed'] == 1
		&& ($isAdmin[$userId] || $item->getOwnerId() == $userId)
		&& (
		    (GalleryUtilities::isA($item, 'GalleryAlbumItem')
		     && ($params['allowAlbums'] == 1
			 || $params['allowPhotos'] == 1
			 || $params['allowPhotosRecurse'] == 1
			 || $params['allowCommentsAlbum'] == 1))
		    || (GalleryUtilities::isA($item, 'GalleryDataItem') &&
			$params['allowCommentsPhoto'] == 1))) {
	    return array(null, true);
	}

	if ($assert) {
	    return array(GalleryCoreApi::error(ERROR_PERMISSION_DENIED), null);
	} else {
	    return array(null, false);
	}
    }
}
?>
');
expand_c19e8c72e9($outputDir, 'module.inc', 'PD9waHAKLyoKICogR2FsbGVyeSAtIGEgd2ViIGJhc2VkIHBob3RvIGFsYnVtIHZpZXdlciBhbmQgZWRpdG9yCiAqIENvcHlyaWdodCAoQykgMjAwMC0yMDA3IEJoYXJhdCBNZWRpcmF0dGEKICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0CiAqIHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEsIFVTQS4KICovCgovKioKICogSW1wbGVtZW50YXRpb24gb2YgdGhlIFJTUyBtb2R1bGUKICoKICogQHBhY2thZ2UgUnNzCiAqIEBhdXRob3IgSm9uYXRhbiBIZXltYW4gPGh0dHA6Ly9oZXltYW4uaW5mbz4KICogQGF1dGhvciBQaWVycmUtTHVjIFBhb3VyCiAqIEBhdXRob3IgRGFuaWVsIEdydW5kIDxodHRwOi8vd3d3LnBob3RvZ3J1bmQubmw+CiAqIEB2ZXJzaW9uICRSZXZpc2lvbjogMTYwMzQgJAogKi8KY2xhc3MgUnNzTW9kdWxlIGV4dGVuZHMgR2FsbGVyeU1vZHVsZSAvKiBhbmQgR2FsbGVyeUV2ZW50TGlzdGVuZXIgKi8gewoKICAgIGZ1bmN0aW9uIFJzc01vZHVsZSgpIHsKCWdsb2JhbCAkZ2FsbGVyeTsKCgkkdGhpcy0+c2V0SWQoJ3JzcycpOwoJJHRoaXMtPnNldE5hbWUoJGdhbGxlcnktPmkxOG4oJ1JTUycpKTsKCSR0aGlzLT5zZXREZXNjcmlwdGlvbigkZ2FsbGVyeS0+aTE4bignUlNTJykpOwoJJHRoaXMtPnNldFZlcnNpb24oJzEuMS4wJyk7CgkkdGhpcy0+c2V0R3JvdXAoJ2V4cG9ydCcsICRnYWxsZXJ5LT5pMThuKCdFeHBvcnQnKSk7CgkkdGhpcy0+c2V0Q2FsbGJhY2tzKCdnZXRTaXRlQWRtaW5WaWV3c3xnZXRJdGVtTGlua3N8cmVnaXN0ZXJFdmVudExpc3RlbmVycycpOwoJJHRoaXMtPnNldFJlcXVpcmVkQ29yZUFwaShhcnJheSg3LCAxMCkpOwoJJHRoaXMtPnNldFJlcXVpcmVkTW9kdWxlQXBpKGFycmF5KDMsIDEpKTsKICAgIH0KCiAgICAvKioKICAgICAqIEBzZWUgR2FsbGVyeU1vZHVsZTo6Z2V0U2l0ZUFkbWluVmlld3MKICAgICAqLwogICAgZnVuY3Rpb24gZ2V0U2l0ZUFkbWluVmlld3MoKSB7CglyZXR1cm4gYXJyYXkobnVsbCwgYXJyYXkoYXJyYXkoJ25hbWUnID0+ICR0aGlzLT50cmFuc2xhdGUoJ1JTUycpLAoJCQkJICAgICAgICd2aWV3JyA9PiAncnNzLlJzc1NpdGVBZG1pbicpKSk7CiAgICB9CgogICAgLyoqCiAgICAgKiBAc2VlIEdhbGxlcnlNb2R1bGU6OmdldEl0ZW1MaW5rcwogICAgICovCiAgICBmdW5jdGlvbiBnZXRJdGVtTGlua3MoJGl0ZW1zLCAkd2FudHNEZXRhaWxlZExpbmtzLCAkcGVybWlzc2lvbnMsICR1c2VySWQpIHsKCUdhbGxlcnlDb3JlQXBpOjpyZXF1aXJlT25jZSgnbW9kdWxlcy9yc3MvY2xhc3Nlcy9Sc3NNYXBIZWxwZXIuY2xhc3MnKTsKCSRsaW5rcyA9IGFycmF5KCk7CgoJLyogY2hlY2sgdGhhdCB0aGlzIHR5cGUgb2YgbGluayBpcyBhbGxvd2VkICovCglsaXN0ICgkcmV0LCAkcGFyYW0pID0gR2FsbGVyeUNvcmVBcGk6OmZldGNoQWxsUGx1Z2luUGFyYW1ldGVycygnbW9kdWxlJywgJ3JzcycpOwoJaWYgKCRyZXQpIHsKCSAgICByZXR1cm4gYXJyYXkoJHJldCwgbnVsbCk7Cgl9CgoJZm9yZWFjaCAoJGl0ZW1zIGFzICRpdGVtKSB7CgkgICAgJGl0ZW1JZCA9ICRpdGVtLT5nZXRJZCgpOwoJICAgIGlmICghaXNzZXQoJHdhbnRzRGV0YWlsZWRMaW5rc1skaXRlbUlkXSkpIHsKCQljb250aW51ZTsKCSAgICB9CgoJICAgIGlmICgkcGFyYW1bJ2FsbG93U2ltcGxlRmVlZCddID09IDEpIHsKCQkkaXRlbVR5cGVOYW1lcyA9IGFycmF5X21lcmdlKCRpdGVtLT5pdGVtVHlwZU5hbWUoKSwgJGl0ZW0tPml0ZW1UeXBlTmFtZShmYWxzZSkpOwoKCQkvKgoJCSAqIFNwZWNpZmljIHRyYW5zbGF0aW9uczoKCQkgKiBfKCdSU1MgRmVlZCBmb3IgdGhpcyBBbGJ1bScpCgkJICogXygnUlNTIEZlZWQgZm9yIHRoaXMgUGhvdG8nKQoJCSAqIF8oJ1JTUyBGZWVkIGZvciB0aGlzIE1vdmllJykKCQkgKi8KCQkkbGlua3NbJGl0ZW1JZF1bXSA9IGFycmF5KAoJCQkndGV4dCcgPT4gJHRoaXMtPl90cmFuc2xhdGUoYXJyYXkoCgkJCSAgICAndGV4dCcgPT4gJ1JTUyBGZWVkIGZvciB0aGlzICVzJywKCQkJICAgICdhcmcxJyA9PiAkaXRlbVR5cGVOYW1lc1swXSksICRpdGVtVHlwZU5hbWVzWzJdKSwKCQkJJ3BhcmFtcycgPT4gYXJyYXkoCgkJCSAgICAndmlldycgPT4gJ3Jzcy5TaW1wbGVSZW5kZXInLAoJCQkgICAgJ2l0ZW1JZCcgPT4gJGl0ZW1JZCkpOwoJICAgIH0KCgkgICAgbGlzdCAoJHJldCwgJGNhbkNvbmZpZ3VyZSkgPSBSc3NNYXBIZWxwZXI6OmNhbkNvbmZpZ3VyZUZlZWQoJGl0ZW0sICRwYXJhbSwgJHVzZXJJZCk7CgkgICAgaWYgKCRyZXQpIHsKCQlyZXR1cm4gYXJyYXkoJHJldCwgbnVsbCk7CgkgICAgfQoKCSAgICBpZiAoJGNhbkNvbmZpZ3VyZSkgewoJCSRsaW5rc1skaXRlbUlkXVtdID0gYXJyYXkoCgkJCSd0ZXh0JyA9PiAkdGhpcy0+dHJhbnNsYXRlKCdDb25maWd1cmUgUlNTIEZlZWRzJyksCgkJCSdwYXJhbXMnID0+IGFycmF5KAoJCQkgICAgJ3ZpZXcnID0+ICdjb3JlLkl0ZW1BZG1pbicsCgkJCSAgICAnc3ViVmlldycgPT4gJ3Jzcy5FZGl0RmVlZCcsCgkJCSAgICAnaXRlbUlkJyA9PiAkaXRlbUlkLAoJCQkgICAgJ3JldHVybicgPT4gMSkpOwoJICAgIH0KCX0KCglyZXR1cm4gYXJyYXkobnVsbCwgJGxpbmtzKTsKICAgIH0KCiAgICAvKioKICAgICAqIEBzZWUgR2FsbGVyeU1vZHVsZTo6Z2V0UmV3cml0ZVJ1bGVzCiAgICAgKi8KICAgIGZ1bmN0aW9uIGdldFJld3JpdGVSdWxlcygpIHsKCSRydWxlcyA9IGFycmF5KCk7CgkkcnVsZXNbXSA9IGFycmF5KAoJICAgICdjb21tZW50JyA9PiAkdGhpcy0+dHJhbnNsYXRlKCdTaW1wbGUgUlNTIEZlZWQnKSwKCSAgICAnbWF0Y2gnID0+IGFycmF5KCd2aWV3JyA9PiAncnNzLlNpbXBsZVJlbmRlcicpLAoJICAgICdwYXR0ZXJuJyA9PiAnc3Jzcy8laXRlbUlkJScsCgkgICAgJ2hlbHAnID0+ICR0aGlzLT50cmFuc2xhdGUoJ1Nob3J0IFVSTCBmb3IgU2ltcGxlIFJTUyBGZWVkcycpKTsKCgkkcnVsZXNbXSA9IGFycmF5KAoJICAgICdjb21tZW50JyA9PiAkdGhpcy0+dHJhbnNsYXRlKCdSU1MgRmVlZCcpLAoJICAgICdtYXRjaCcgPT4gYXJyYXkoJ3ZpZXcnID0+ICdyc3MuUmVuZGVyJyksCgkgICAgJ3BhdHRlcm4nID0+ICdyc3MvJW5hbWUlJywKCSAgICAna2V5d29yZHMnID0+IGFycmF5KAoJCSduYW1lJyA9PiBhcnJheSgKCQkgICAgJ3BhdHRlcm4nID0+ICcoW15cL1w/XSspJywKCQkgICAgJ2hlbHAnID0+ICR0aGlzLT50cmFuc2xhdGUoJ1RoZSBuYW1lIG9mIHRoZSBjb25maWd1cmVkIFJTUyBGZWVkJykpKSwKCSAgICAnaGVscCcgPT4gJHRoaXMtPnRyYW5zbGF0ZSgnU2hvcnQgVVJMIGZvciBDb25maWd1cmFibGUgUlNTIEZlZWRzJykpOwoKCXJldHVybiAkcnVsZXM7CiAgICB9CgogICAgLyoqCiAgICAgKiBAc2VlIEdhbGxlcnlNb2R1bGU6OnJlZ2lzdGVyRXZlbnRMaXN0ZW5lcnMKICAgICAqLwogICAgZnVuY3Rpb24gcmVnaXN0ZXJFdmVudExpc3RlbmVycygpIHsKCUdhbGxlcnlDb3JlQXBpOjpyZWdpc3RlckV2ZW50TGlzdGVuZXIoJ0dhbGxlcnlFbnRpdHk6OmRlbGV0ZScsIG5ldyBSc3NNb2R1bGUoKSk7CiAgICB9CgogICAgLyoqCiAgICAgKiBFdmVudCBIYW5kbGVyOiBnZXQgcmlkIG9mIGFueSBmZWVkcyBmb3IgaXRlbXMgdGhhdCBhcmUgZGVsZXRlZAogICAgICoKICAgICAqIEBzZWUgR2FsbGVyeUV2ZW50TGlzdGVuZXI6OmhhbmRsZUV2ZW50CiAgICAgKi8KICAgIGZ1bmN0aW9uIGhhbmRsZUV2ZW50KCRldmVudCkgewoJJGRhdGEgPSAkZXZlbnQtPmdldERhdGEoKTsKCglpZiAoJGV2ZW50LT5nZXRFdmVudE5hbWUoKSA9PSAnR2FsbGVyeUVudGl0eTo6ZGVsZXRlJykgewoJICAgICRlbnRpdHkgPSAkZXZlbnQtPmdldEVudGl0eSgpOwoJICAgIGlmIChHYWxsZXJ5VXRpbGl0aWVzOjppc0EoJGVudGl0eSwgJ0dhbGxlcnlJdGVtJykpIHsKCQlHYWxsZXJ5Q29yZUFwaTo6cmVxdWlyZU9uY2UoJ21vZHVsZXMvcnNzL2NsYXNzZXMvUnNzTWFwSGVscGVyLmNsYXNzJyk7CgkJbGlzdCAoJHJldCwgJHJlc3VsdHMpID0gUnNzTWFwSGVscGVyOjpmZXRjaEZlZWRzRm9ySXRlbSgkZW50aXR5LT5nZXRJZCgpKTsKCQlpZiAoJHJldCkgewoJCSAgICByZXR1cm4gYXJyYXkoJHJldCwgbnVsbCk7CgkJfQoKCQlmb3JlYWNoICgkcmVzdWx0cyBhcyAkZmVlZCkgewoJCSAgICAkcmV0ID0gUnNzTWFwSGVscGVyOjpkZWxldGVGZWVkKCRmZWVkWyduYW1lJ10pOwoJCSAgICBpZiAoJHJldCkgewoJCQlyZXR1cm4gYXJyYXkoJHJldCwgbnVsbCk7CgkJICAgIH0KCQl9CgkgICAgfQoJfQoKCXJldHVybiBhcnJheShudWxsLCBudWxsKTsKICAgIH0KCiAgICAvKioKICAgICAqIEBzZWUgR2FsbGVyeU1vZHVsZTo6dXBncmFkZQogICAgICovCiAgICBmdW5jdGlvbiB1cGdyYWRlKCRjdXJyZW50VmVyc2lvbikgewoJc3dpdGNoKCRjdXJyZW50VmVyc2lvbikgewoJICAgIGNhc2UgbnVsbDoKCQkvKiBJbml0aWFsIGluc3RhbGwgKi8KCgkJZm9yZWFjaCAoYXJyYXkoJ2RlZmF1bHRWZXJzaW9uJyA9PiAnMi4wJywKCQkJICAgICAgICdkZWZhdWx0Q291bnQnID0+IDEwLAoJCQkgICAgICAgJ21heENvdW50JyA9PiA1MCwKCQkJICAgICAgICdhbGxvd1NpbXBsZUZlZWQnID0+IDEsCgkJCSAgICAgICAnYWxsb3dDb25maWd1cmFibGVGZWVkJyA9PiAwLAoJCQkgICAgICAgJ2FsbG93QWxidW1zJyA9PiAwLAoJCQkgICAgICAgJ2FsbG93UGhvdG9zJyA9PiAwLAoJCQkgICAgICAgJ2FsbG93UGhvdG9zUmVjdXJzZScgPT4gMCwKCQkJICAgICAgICdhbGxvd0NvbW1lbnRzQWxidW0nID0+IDAsCgkJCSAgICAgICAnYWxsb3dDb21tZW50c1Bob3RvJyA9PiAwLAoJCQkgICAgICAgJ2RlZmF1bHRDb3B5cmlnaHQnID0+ICcnLAoJCQkgICAgICAgJ2RlZmF1bHRUdGwnID0+IDEyMCwKCQkJICAgICkgYXMgJGtleSA9PiAkdmFsdWUpIHsKCQkgICAgJHJldCA9ICR0aGlzLT5zZXRQYXJhbWV0ZXIoJGtleSwgJHZhbHVlKTsKCQkgICAgaWYgKCRyZXQpIHsKCQkJcmV0dXJuICRyZXQ7CgkJICAgIH0KCQl9CgkJLyoga2VlcCBnb2luZyAqLwoKCSAgICBjYXNlICcxLjAuMCc6CgkJZm9yZWFjaCAoYXJyYXkoJ3NmQWxidW1UeXBlJyA9PiAncGhvdG9zJywKCQkJICAgICAgICdzZkRhdGUnID0+ICduZXcnLAoJCQkgICAgICAgJ3NmUGhvdG9zUmVjdXJzZUxpbWl0JyA9PiAnMTAnLAoJCQkgICAgICAgJ2FsbG93Q29tbWVudHNSZWN1cnNpdmUnID0+IDAsCgkJCSAgICApIGFzICRrZXkgPT4gJHZhbHVlKSB7CgkJICAgICRyZXQgPSAkdGhpcy0+c2V0UGFyYW1ldGVyKCRrZXksICR2YWx1ZSk7CgkJICAgIGlmICgkcmV0KSB7CgkJCXJldHVybiAkcmV0OwoJCSAgICB9CgkJfQoJfQoKCXJldHVybiBudWxsOwogICAgfQp9Cj8+Cg==');
expand_c19e8c72e9($outputDir, 'po/GNUmakefile', 'R0FMTEVSWURJUiA/PSAuLi8uLi8uLgpUT09MRElSID89ICQoR0FMTEVSWURJUikvbGliL3Rvb2xzCgppbmNsdWRlICQoVE9PTERJUikvcG8vR05VbWFrZWZpbGUuaW5jCgo=');
expand_c19e8c72e9($outputDir, 'po/strings.raw', '# $Id: strings.raw 15342 2006-12-01 21:14:46Z andy_st $

/* Render.inc */
gettext("This feed no longer exists!")
gettext("Feeds of that type are not allowed!") /* also in: SimpleRender.inc */
gettext("Not permitted to view this item")
gettext("Incorrect feed type!")
gettext("Comments module is not active or comment feeds are not allowed!")
gettext("Not permitted to view comments for this item")

/* module.inc */
gettext("RSS")
gettext("Export")
gettext("RSS Feed for this Album")
gettext("RSS Feed for this Photo")
gettext("RSS Feed for this Movie")
gettext("Configure RSS Feeds")
gettext("Simple RSS Feed")
gettext("Short URL for Simple RSS Feeds")
gettext("RSS Feed")
gettext("The name of the configured RSS Feed")
gettext("Short URL for Configurable RSS Feeds")
gettext("RSS Feed for this %s")

/* classes/RssHelper.class */
gettext("Items in an album")
gettext("Sub-albums of an album")
gettext("Items in an album and its sub-albums")
gettext("Comments for an album")
gettext("Comments for an item")
gettext("Comments for an album and its subalbums") /* also in: templates/RssSiteAdmin.tpl */
gettext("In album <a href=\"%s\">%s</a>")

/* templates/EditFeed.tpl */
gettext("RSS Feeds") /* also in: templates/FeedList.tpl templates/blocks/RssBlock.tpl */
gettext("Settings have been saved") /* also in: templates/RssSiteAdmin.tpl */
gettext("Feed successfully deleted")
gettext("An error occured") /* also in: templates/RssSiteAdmin.tpl */
gettext("List") /* also in: templates/RssSiteAdmin.tpl */
gettext("Edit Feed")
gettext("New Feed")
gettext("Feed URL")
gettext("Feed name")
gettext("You can't change the name of the feed")
gettext("Pick name for your feed (this name will be referenced in the URL to your feed so try to use only letters)")
gettext("You must enter a name")
gettext("This name is already used, please select another one")
gettext("Description") /* also in: templates/FeedList.tpl */
gettext("Feed settings")
gettext("Choose what type of data that will be present in the feed") /* also in: templates/RssSiteAdmin.tpl */
gettext("Type of feed")
gettext("Items in this album")
gettext("Feeds of this type are disallowed by the administrator. Users won't be able to view them.")
gettext("Sub-albums of this album")
gettext("Items in this album and its subalbums")
gettext("Limit the number of items per album") /* also in: templates/RssSiteAdmin.tpl */
gettext("Invalid limit (must be a positive number, 0 to disable the limit)") /* also in: templates/RssSiteAdmin.tpl */
gettext("(enter 0 to disable the limit)") /* also in: templates/RssSiteAdmin.tpl */
gettext("Comments for this album")
gettext("Comments for this album and its subalbums")
gettext("Comments for this item")
gettext("Which items") /* also in: templates/RssSiteAdmin.tpl */
gettext("New items only") /* also in: templates/RssSiteAdmin.tpl */
gettext("New and updated items") /* also in: templates/RssSiteAdmin.tpl */
gettext("Choose the options for the feed")
gettext("RSS version") /* also in: templates/RssSiteAdmin.tpl */
gettext("Invalid version") /* also in: templates/RssSiteAdmin.tpl */
gettext("Number of items")
gettext("Invalid number")
gettext("language tag")
gettext("Invalid language value")
gettext("by default: en-us.")
gettext("List of all possible values")
gettext("category tag")
gettext("ttl tag")
gettext("Invalid time to live, this must be a number of minutes (0 to disable ttl)") /* also in: templates/RssSiteAdmin.tpl */
gettext("Time to live: this must be a number of minutes (0 to disable ttl) aggregators should wait between checks of whether the feed has been updated") /* also in: templates/RssSiteAdmin.tpl */
gettext("Copyright")
gettext("Invalid copyright")
gettext("Use image tag")
gettext("Include image tag")
gettext("This adds a main image to the feed, corresponding to the thumbnail for this item")
gettext("Invalid value")
gettext("Use enclosures")
gettext("Include enclosure tags")
gettext("This adds an enclosure to each image in the feed, that contains the full resolution image")
gettext("Cloud tag (RSS 2.0)")
gettext("If you want to use the cloud tag, you can set up its properties here")
gettext("Example: ")
gettext("domain")
gettext("port")
gettext("path")
gettext("registerProcedure")
gettext("protocol")
gettext("Cloud tag")
gettext("Include the cloud tag")
gettext("Invalid string") /* also in: templates/RssSiteAdmin.tpl */
gettext("Invalid port number")
gettext("Update Feed")
gettext("Create Feed")
gettext("Cancel")
gettext("RSS feeds for this item")
gettext("No feeds have yet been defined") /* also in: templates/FeedList.tpl templates/RssSiteAdmin.tpl templates/blocks/RssBlock.tpl */
gettext("Feed link") /* also in: templates/FeedList.tpl templates/RssSiteAdmin.tpl */
gettext("Feed type") /* also in: templates/RssSiteAdmin.tpl */
gettext("Actions") /* also in: templates/RssSiteAdmin.tpl */
gettext("delete") /* also in: templates/RssSiteAdmin.tpl */
gettext("edit") /* also in: templates/RssSiteAdmin.tpl */

/* templates/FeedList.tpl */
gettext("This is a list of all the feeds that are available on this Gallery")

/* templates/RssSiteAdmin.tpl */
gettext("RSS Settings")
gettext("Settings")
gettext("Simple Feed Settings")
gettext("General settings")
gettext("These are the default and maximum values that are used by all feeds on your Gallery")
gettext("Default number of items in feeds")
gettext("Invalid default number")
gettext("Maximum number of items in feeds")
gettext("Invalid maximum number")
gettext("Default ttl")
gettext("Default copyright")
gettext("Feed Types")
gettext("Configure which types of feeds are allowed")
gettext("Allow Simple RSS Feed to be used")
gettext("If you enable this, users will be able to subscribe to a feed for any album or photo they can view.")
gettext("To edit the settings for Simple Feeds, use the corresponding tab at the top of the screen.")
gettext("Allow configurable RSS feeds to be used")
gettext("Only album owners will be able to define such feeds. They can set parameters for the type of feed they want.")
gettext("Once a feed is defined, users will be able to subscribe to those feeds if they can view the associated item.")
gettext("Allow RSS feeds of photos inside an album")
gettext("Fast")
gettext("Allow RSS feeds of subalbums of an album")
gettext("Slow")
gettext("Allow RSS feeds of photos inside an album and its subalbums")
gettext("Slower")
gettext("Allow RSS feeds comments of a photo")
gettext("Allow RSS feeds comments of an album")
gettext("Allow RSS feeds comments for an album and its subalbums")
gettext("Save Settings")
gettext("Reset")
gettext("Helping users discover RSS feeds")
gettext("If you want to help users discover feeds in your Gallery, you can add the RSS block to the themes used in your Gallery.")
gettext("This will have two effects: the block itself, which users can see and pick feeds from (and get a list of all feeds); and hidden page headers that modern web browsers will use to make it easier for the user to subscribe to the feeds.")
gettext("Global list of RSS feeds")
gettext("On item")
gettext("Simple Feed settings")
gettext("For albums")
gettext("Items in the album")
gettext("Sub-albums of the album")
gettext("Items in the album and its subalbums")
gettext("Comments for the album")
gettext("For items")
gettext("Comments for items (always selected)")

/* templates/blocks/RssBlock.tpl */
gettext("List all RSS Feeds")

/* templates/blocks/blocks.inc */
gettext("List of RSS Feeds")
gettext("Number of feeds to display")
gettext("1")
gettext("5")
gettext("10")
gettext("all")
');
expand_c19e8c72e9($outputDir, 'templates/EditFeed.tpl', '{*
 * $Revision: 15342 $
 * If you want to customize this file, do not edit it directly since future upgrades
 * may overwrite it.  Instead, copy it into a new directory called "local" and edit that
 * version.  Gallery will look for that file first and use it if it exists.
 *}
<div class="gbBlock gcBackground1">
  <h2> {g->text text="RSS Feeds"} </h2>
</div>

{if !empty($status)}
<div class="gbBlock">
  <h2 class="giSuccess">
  {if isset($status.saved)}
    {g->text text="Settings have been saved"}
  {elseif isset($status.deleted)}  
    {g->text text="Feed successfully deleted"}
  {/if}
  </h2>
</div>
{elseif !empty($form.error)}
<div class="gbBlock">
  <h2 class="giError">
    {g->text text="An error occured"}
  </h2>
</div>
{/if}

<div class="gbTabBar">
  {if ($EditFeed.mode == 'list')}
    <span class="giSelected o"><span>
      {g->text text="List"}
    </span></span>
  {else}
    <span class="o"><span>
      <a href="{g->url arg1="view=core.ItemAdmin" arg2="subView=rss.EditFeed"
       arg3="mode=list" arg4="itemId=`$EditFeed.itemId`"}">{g->text text="List"}</a>
    </span></span>
  {/if}

  {if ($EditFeed.mode == 'edit')}
    <span class="giSelected o"><span>
      {g->text text="Edit Feed"}
    </span></span>
  {/if}

  {if ($EditFeed.mode == 'new')}
    <span class="giSelected o"><span>
      {g->text text="New Feed"}
    </span></span>
  {else}
    <span class="o"><span>
      <a href="{g->url arg1="view=core.ItemAdmin" arg2="subView=rss.EditFeed"
       arg3="mode=new" arg4="itemId=`$EditFeed.itemId`"}">{g->text text="New Feed"}</a>
    </span></span>
  {/if}
</div>

<input type="hidden" name="{g->formVar var="form[mode]"}" value="{$EditFeed.mode}" />

{if $EditFeed.mode == 'edit' || $EditFeed.mode == 'new' }

{if isset($EditFeed.feedUrl)}
  <div class="gbBlock">
  <h3> {g->text text="Feed URL"}</h3>
  <p><a href="{$EditFeed.feedUrl}">{$EditFeed.feedUrl}</a></p>
  </div>
{/if}

  <div class="gbBlock">
  <h3> {g->text text="Feed name"} </h3>
{if ($EditFeed.mode == 'edit')}
  <p class="giDescription">
    {g->text text="You can't change the name of the feed"}
  </p>

  <table class="gbDataTable">
  <tr>
    <td>{g->text text="Feed name"}</td>
    <td>{$form.feedName}
      <input type="hidden" name="{g->formVar var="form[feedName]"}" value="{$form.feedName}" />
    </td>
  </tr>
{else}
  <p class="giDescription">
    {g->text text="Pick name for your feed (this name will be referenced in the URL to your feed so try to use only letters)"}
  </p>

  <table class="gbDataTable">
  <tr>
    <td>{g->text text="Feed name"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[feedName]"}"
        {if isset($form.feedName)}value="{$form.feedName}"{/if} />
      {if isset($form.error.feedName)}
      <div class="giError">
        {g->text text="You must enter a name"}
      </div>
      {/if}
      {if isset($form.error.feedNameCollision)}
      <div class="giError">
        {g->text text="This name is already used, please select another one"}
      </div>
      {/if}
    </td>
  </tr>
{/if}
  <tr>
    <td valign="top">{g->text text="Description"}</td>
    <td>
      <textarea rows="4" cols="60" name="{g->formVar var="form[description]"}">
        {if isset($EditFeed.description)}{$EditFeed.description}{/if}
      </textarea>
    </td>
  </tr>
  </table>

  <h3> {g->text text="Feed settings"} </h3>
  <p class="giDescription">
    {g->text text="Choose what type of data that will be present in the feed"}
  </p>

  <input type="hidden" name="{g->formVar var="form[itemId]"}" value="{$EditFeed.itemId}" />
  <input type="hidden" name="{g->formVar var="form[type]"}" value="{$EditFeed.type}" />

  <table class="gbDataTable">

{if $EditFeed.type == 'album'}
  <tr valign="top">
    <td rowspan="5">{g->text text="Type of feed"}</td>
    <td>
      <input type="radio" name="{g->formVar var="form[feedType]"}"
        value="photos" {if $EditFeed.feedType=='photos'}checked="checked"{/if}
	id="EditFeed_typePhotos" />
    </td><td>
      <label for="EditFeed_typePhotos">
        {g->text text="Items in this album"}
      </label>
    {if !$param.allowPhotos}
      <br/>{g->text text="Feeds of this type are disallowed by the administrator. Users won't be able to view them."}
    {/if}
    </td>
  </tr><tr valign="top">
    <td>
      <input type="radio" name="{g->formVar var="form[feedType]"}"
        value="album" {if $EditFeed.feedType=='album'}checked="checked"{/if}
	id="EditFeed_typeAlbum" />
    </td><td>
      <label for="EditFeed_typeAlbum">
        {g->text text="Sub-albums of this album"}
      </label>
    {if !$param.allowAlbums}
      <br/>{g->text text="Feeds of this type are disallowed by the administrator. Users won't be able to view them."}
    {/if}
    </td>
  </tr><tr valign="top">
    <td>
      <input type="radio" name="{g->formVar var="form[feedType]"}"
        value="photosRecurse" {if $EditFeed.feedType=='photosRecurse'}checked="checked"{/if}
	id="EditFeed_typePhotosRecurse" />
    </td><td>
      <label for="EditFeed_typePhotosRecurse">
        {g->text text="Items in this album and its subalbums"}
      </label>
    {if !$param.allowPhotosRecurse}
      <br/>{g->text text="Feeds of this type are disallowed by the administrator. Users won't be able to view them."}
    {/if}
      <br/>
      <label for="EditFeed_typePhotosRecurseLimit">
        {g->text text="Limit the number of items per album"}
      </label>
      <input type="text" size="5" name="{g->formVar var="form[photosRecurseLimit]"}"
        {if isset($EditFeed.photosRecurseLimit)}value="{$EditFeed.photosRecurseLimit}"{/if}
	id="EditFeed_typePhotosRecurseLimit" />
      {if isset($form.error.photosRecurseLimit)}
      <div class="giError">
      {g->text text="Invalid limit (must be a positive number, 0 to disable the limit)"}
      </div>
      {else}
      {g->text text="(enter 0 to disable the limit)"}
      {/if}
    </td>
  </tr><tr valign="top">
    <td>
      <input type="radio" name="{g->formVar var="form[feedType]"}"
        value="commentsAlbum" {if $EditFeed.feedType=='commentsAlbum'}checked="checked"{/if}
	id="EditFeed_typeCommentsAlbum" />
    </td><td>
      <label for="EditFeed_typeCommentsAlbum">
        {g->text text="Comments for this album"}
      </label>
    {if !$param.allowCommentsAlbum}
      <br/>{g->text text="Feeds of this type are disallowed by the administrator. Users won't be able to view them."}
    {/if}
    </td>
  </tr><tr valign="top">
    <td>
      <input type="radio" name="{g->formVar var="form[feedType]"}"
        value="commentsRecursive" {if $EditFeed.feedType=='commentsRecursive'}checked="checked"{/if}
	id="EditFeed_typeCommentsRecursive" />
    </td><td>
      <label for="EditFeed_typeCommentsRecursive">
        {g->text text="Comments for this album and its subalbums"}
      </label>
    {if !$param.allowCommentsRecursive}
      <br/>{g->text text="Feeds of this type are disallowed by the administrator. Users won't be able to view them."}
    {/if}
    </td>
  </tr>
  {else}
  <tr valign="top">
    <td>{g->text text="Type of feed"}</td>
    <td><input type="radio" name="{g->formVar var="form[feedType]"}"
        value="commentsPhoto" checked="checked" id="EditFeed_typeCommentsPhoto" />
    </td><td>
      <label for="EditFeed_typeAlbum">
        {g->text text="Comments for this item"}
      </label>
    {if !$param.allowCommentsPhoto}
      <br/>{g->text text="Feeds of this type are disallowed by the administrator. Users won't be able to view them."}
    {/if}
    </td>
  </tr>
{/if}

  <tr><td>&nbsp;</td></tr>

  <tr>
    <td rowspan="2" valign="top">{g->text text="Which items"}</td>
    <td>
      <input type="radio" name="{g->formVar var="form[feedDate]"}"
        value="new" {if $EditFeed.feedDate=='new'}checked="checked"{/if} id="EditFeed_dateNew" />
    </td><td colspan="2">
      <label for="EditFeed_dateNew">{g->text text="New items only"}</label>
    </td>
  </tr><tr>
    <td>
      <input type="radio" name="{g->formVar var="form[feedDate]"}" value="updated"
        {if $EditFeed.feedDate=='updated'}checked="checked"{/if} id="EditFeed_dateUpdated" />
    </td><td colspan="2">
      <label for="EditFeed_dateUpdated">{g->text text="New and updated items"}</label>
    </td>
  </tr>
  </table>

  <p class="giDescription">
    {g->text text="Choose the options for the feed"}
  </p>

  <table class="gbDataTable">
  <tr>
    <td>{g->text text="RSS version"}</td>
    <td>
      <select name="{g->formVar var="form[version]"}">
        {html_options values=$EditFeed.rssVersionList selected=$EditFeed.version
	  output=$EditFeed.rssVersionList}
      </select>
    </td>
    <td>
      {if isset($form.error.version)}
      <div class="giError">
        {g->text text="Invalid version"}
      </div>
      {/if}
    </td>
  </tr>

  <tr>
    <td>{g->text text="Number of items"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[count]"}" value="{$EditFeed.count}" />
    </td>
    <td>
      {if isset($form.error.count)}
      <div class="giError">
        {g->text text="Invalid number"}
      </div>
      {/if}
    </td>
  </tr>

  <tr>
    <td>{g->text text="language tag"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[language]"}" value="{$EditFeed.language}" />
    </td>
    <td>
      {if isset($form.error.language)}
      <div class="giError">
        {g->text text="Invalid language value"}
      </div>
      {/if}
      {g->text text="by default: en-us."}
      <a href="http://blogs.law.harvard.edu/tech/stories/storyReader$15">
        {g->text text="List of all possible values"}
      </a>
    </td>
  </tr>

  <tr>
    <td>{g->text text="category tag"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[category]"}" value="{$EditFeed.category}" />
    </td>
  </tr>

  <tr>
    <td>{g->text text="ttl tag"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[ttl]"}" value="{$EditFeed.ttl}" />
    </td>
    <td>
      {if isset($form.error.ttl)}
      <div class="giError">
        {g->text text="Invalid time to live, this must be a number of minutes (0 to disable ttl)"}
      </div>
      {else}
        {g->text text="Time to live: this must be a number of minutes (0 to disable ttl) aggregators should wait between checks of whether the feed has been updated"}
      {/if}
    </td>
  </tr>

  <tr>
    <td>{g->text text="Copyright"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[copyright]"}" value="{$EditFeed.copyright}" />
    </td>
    <td>
      {if isset($form.error.copyright)}
      <div class="giError">
        {g->text text="Invalid copyright"}
      </div>
      {/if}
    </td>
  </tr>

  <tr>
    <td>{g->text text="Use image tag"}</td>
    <td>
      <input type="checkbox"
        {if isset($EditFeed.useImage) && $EditFeed.useImage} checked="checked"{/if}
        name="{g->formVar var="form[useImage]"}"/> {g->text text="Include image tag"}
    </td>
    <td>
      {g->text text="This adds a main image to the feed, corresponding to the thumbnail for this item"}
      {if isset($form.error.useImage)}
      <div class="giError">
        {g->text text="Invalid value"}
      </div>
      {/if}
    </td>
  </tr>

  <tr>
    <td>{g->text text="Use enclosures"}</td>
    <td>
      <input type="checkbox"
        {if isset($EditFeed.useEnclosure) && $EditFeed.useEnclosure} checked="checked"{/if}
        name="{g->formVar var="form[useEnclosure]"}"/> {g->text text="Include enclosure tags"}
    </td>
    <td>
      {g->text text="This adds an enclosure to each image in the feed, that contains the full resolution image"}
      {if isset($form.error.useEnclosure)}
      <div class="giError">
        {g->text text="Invalid value"}
      </div>
      {/if}
    </td>
  </tr>
  </table>

  <h3> {g->text text="Cloud tag (RSS 2.0)"} </h3>
  <p class="giDescription">
    {g->text text="If you want to use the cloud tag, you can set up its properties here"}
    <br />
    {g->text text="Example: "}
    &lt;cloud domain="<b>{g->text text="domain"}</b>"
	      port="<b>{g->text text="port"}</b>"
	      path="<b>{g->text text="path"}</b>"
	      registerProcedure="<b>{g->text text="registerProcedure"}</b>"
	      protocol="<b>{g->text text="protocol"}</b>" /&gt;
  </p>
  <table class="gbDataTable"><tr>
    <td>{g->text text="Cloud tag"}</td>
    <td>
      <input type="checkbox"
        {if isset($EditFeed.useCloud) && $EditFeed.useCloud} checked="checked"{/if}
        name="{g->formVar var="form[useCloud]"}"/> {g->text text="Include the cloud tag"}
    </td>
    <td>
      {if isset($form.error.useCloud)}
      <div class="giError">
        {g->text text="Invalid value"}
      </div>
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="domain"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[cloudDomain]"}"
	{if isset($EditFeed.cloudDomain)}value="{$EditFeed.cloudDomain}"{/if} />
    </td>
    <td>
      {if isset($form.error.cloudDomain)}
      <div class="giError">
        {g->text text="Invalid string"}
      </div>
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="port"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[cloudPort]"}"
        {if isset($EditFeed.cloudPort)}
          value="{$EditFeed.cloudPort}"
	{/if} />
    </td>
    <td>
      {if isset($form.error.cloudPort)}
      <div class="giError">
        {g->text text="Invalid port number"}
      </div>
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="path"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[cloudPath]"}"
        {if isset($EditFeed.cloudPath)}
	  value="{$EditFeed.cloudPath}"
	{/if} />
    </td>
    <td>
      {if isset($form.error.cloudPath)}
      <div class="giError">
        {g->text text="Invalid string"}
      </div>
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="registerProcedure"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[cloudRegisterProcedure]"}"
        {if isset($EditFeed.cloudRegisterProcedure)}
	  value="{$EditFeed.cloudRegisterProcedure}"
	{/if} />
    </td>
    <td>
      {if isset($form.error.cloudRegiserProcedure)}
      <div class="giError">
        {g->text text="Invalid string"}
      </div>
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="protocol"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[cloudProtocol]"}"
        {if isset($EditFeed.cloudProtocol)}
          value="{$EditFeed.cloudProtocol}"
	{/if} />
    </td>
    <td>
      {if isset($form.error.cloudProtocol)}
      <div class="giError">
        {g->text text="Invalid string"}
      </div>
      {/if}
    </td>
  </tr></table>
  </div>

<div class="gbBlock gcBackground1">
{if $EditFeed.mode == 'edit'}
  <input type="submit" name="{g->formVar var="form[action][update]"}"
    value="{g->text text="Update Feed"}"/>
{else}
  <input type="submit" name="{g->formVar var="form[action][create]"}"
    value="{g->text text="Create Feed"}"/>
{/if}
  <input type="submit" name="{g->formVar var="form[action][cancel]"}"
    value="{g->text text="Cancel"}"/>
</div>

{else}

<div class="gbBlock">
  <h3> {g->text text="RSS feeds for this item"} </h3>
  {if empty($EditFeed.feeds)}
    <p> {g->text text="No feeds have yet been defined"} </p>
  {else}

    <table class="gbDataTable">
    <tr>
      <th> {g->text text="Feed link"} </th>
      <th> {g->text text="Feed type"} </th>
      <th> {g->text text="Actions"} </th>
    </tr>
    {foreach from=$EditFeed.feeds item=feed}
	  <tr class="{cycle values="gbEven,gbOdd"}">
	    <td><a href="{g->url arg1="view=rss.Render" arg2="name=`$feed.name`"}">
	      {$feed.name}</a></td>
	    <td>{$EditFeed.types[$feed.params.feedType]}</td>
	    <td>
	      <a href="{g->url arg1="controller=rss.EditFeed"
	        arg2="form[action][delete]=`$feed.name`" arg3="itemId=`$feed.itemId`"}">
		{g->text text="delete"}</a>
	      <a href="{g->url arg1="view=core.ItemAdmin" arg2="subView=rss.EditFeed"
	        arg3="form[feedName]=`$feed.name`" arg4="itemId=`$feed.itemId`"
		arg5="mode=edit"}">
		{g->text text="edit"}</a>
	    </td>
	  </tr>
    {/foreach}
	</table>
  {/if}
</div>

{/if}
');
expand_c19e8c72e9($outputDir, 'templates/FeedList.tpl', 'eyoKICogJFJldmlzaW9uOiAxNTM0MiAkCiAqIElmIHlvdSB3YW50IHRvIGN1c3RvbWl6ZSB0aGlzIGZpbGUsIGRvIG5vdCBlZGl0IGl0IGRpcmVjdGx5IHNpbmNlIGZ1dHVyZSB1cGdyYWRlcwogKiBtYXkgb3ZlcndyaXRlIGl0LiAgSW5zdGVhZCwgY29weSBpdCBpbnRvIGEgbmV3IGRpcmVjdG9yeSBjYWxsZWQgImxvY2FsIiBhbmQgZWRpdCB0aGF0CiAqIHZlcnNpb24uICBHYWxsZXJ5IHdpbGwgbG9vayBmb3IgdGhhdCBmaWxlIGZpcnN0IGFuZCB1c2UgaXQgaWYgaXQgZXhpc3RzLgogKn0KPGRpdiBjbGFzcz0iZ2JCbG9jayBnY0JhY2tncm91bmQxIj4KICA8aDI+IHtnLT50ZXh0IHRleHQ9IlJTUyBGZWVkcyJ9IDwvaDI+CjwvZGl2PgoKPGRpdiBjbGFzcz0iZ2JCbG9jayI+CiAgPHAgY2xhc3M9ImdpRGVzY3JpcHRpb24iPgogICAge2ctPnRleHQgdGV4dD0iVGhpcyBpcyBhIGxpc3Qgb2YgYWxsIHRoZSBmZWVkcyB0aGF0IGFyZSBhdmFpbGFibGUgb24gdGhpcyBHYWxsZXJ5In0KICA8L3A+CgogIHtpZiBlbXB0eSgkRmVlZExpc3QuZmVlZHMpfQogICAgPHA+IHtnLT50ZXh0IHRleHQ9Ik5vIGZlZWRzIGhhdmUgeWV0IGJlZW4gZGVmaW5lZCJ9IDwvcD4KICB7ZWxzZX0KCiAgICA8dGFibGUgY2xhc3M9ImdiRGF0YVRhYmxlIj4KICAgIDx0cj4KICAgICAgPHRoPiB7Zy0+dGV4dCB0ZXh0PSJGZWVkIGxpbmsifSA8L3RoPgogICAgICA8dGg+IHtnLT50ZXh0IHRleHQ9IkRlc2NyaXB0aW9uIn0gPC90aD4KICAgIDwvdHI+CiAgICB7Zm9yZWFjaCBmcm9tPSRGZWVkTGlzdC5mZWVkcyBpdGVtPWZlZWR9CiAgICAgIDx0ciBjbGFzcz0ie2N5Y2xlIHZhbHVlcz0iZ2JFdmVuLGdiT2RkIn0iPgoJPHRkPjxhIGhyZWY9IntnLT51cmwgYXJnMT0idmlldz1yc3MuUmVuZGVyIiBhcmcyPSJuYW1lPWAkZmVlZC5uYW1lYCJ9Ij4KCSAgeyRmZWVkLm5hbWV9PC9hPjwvdGQ+Cgk8dGQ+e2lmIGlzc2V0KCRmZWVkLnBhcmFtcy5kZXNjcmlwdGlvbil9eyRmZWVkLnBhcmFtcy5kZXNjcmlwdGlvbn17L2lmfTwvdGQ+CiAgICAgIDwvdHI+CiAgICB7L2ZvcmVhY2h9Cgk8L3RhYmxlPgogIHsvaWZ9CjwvZGl2Pg==');
expand_c19e8c72e9($outputDir, 'templates/RssBlockHead.tpl', 'eyoKICogJFJldmlzaW9uOiAxNTM0MiAkCiAqIElmIHlvdSB3YW50IHRvIGN1c3RvbWl6ZSB0aGlzIGZpbGUsIGRvIG5vdCBlZGl0IGl0IGRpcmVjdGx5IHNpbmNlIGZ1dHVyZSB1cGdyYWRlcwogKiBtYXkgb3ZlcndyaXRlIGl0LiAgSW5zdGVhZCwgY29weSBpdCBpbnRvIGEgbmV3IGRpcmVjdG9yeSBjYWxsZWQgImxvY2FsIiBhbmQgZWRpdCB0aGF0CiAqIHZlcnNpb24uICBHYWxsZXJ5IHdpbGwgbG9vayBmb3IgdGhhdCBmaWxlIGZpcnN0IGFuZCB1c2UgaXQgaWYgaXQgZXhpc3RzLgogKn0Ke2ctPmNhbGxiYWNrIHR5cGU9InJzcy5GZWVkTGlzdCJ9CntpZiAhZW1wdHkoJGJsb2NrLnJzcy5mZWVkcyl9CiAge2ZvcmVhY2ggZnJvbT0kYmxvY2sucnNzLmZlZWRzIGl0ZW09ZmVlZH0KICAgIDxsaW5rIHJlbD0iYWx0ZXJuYXRlIiB0eXBlPSJhcHBsaWNhdGlvbi9yc3MreG1sIiB0aXRsZT0ieyRmZWVkfSIKICAgICAgaHJlZj0ie2ctPnVybCBhcmcxPSJ2aWV3PXJzcy5SZW5kZXIiIGFyZzI9Im5hbWU9YCRmZWVkYCJ9IiAvPgogIHsvZm9yZWFjaH0Key9pZn0KCg==');
expand_c19e8c72e9($outputDir, 'templates/RssSiteAdmin.tpl', '{*
 * $Revision: 15342 $
 * If you want to customize this file, do not edit it directly since future upgrades
 * may overwrite it.  Instead, copy it into a new directory called "local" and edit that
 * version.  Gallery will look for that file first and use it if it exists.
 *}
<div class="gbBlock gcBackground1">
  <h2>
    {g->text text="RSS Settings"}
  </h2>
</div>

{if isset($status.saved)}
<div class="gbBlock">
  <h2 class="giSuccess">
    {g->text text="Settings have been saved"}
  </h2>
</div>
{elseif !empty($form.error)}
<div class="gbBlock">
  <h2 class="giError">
    {g->text text="An error occured"}
  </h2>
</div>
{/if}

<div class="gbTabBar">
  {if ($RssSiteAdmin.mode == 'settings')}
    <span class="giSelected o"><span>
      {g->text text="Settings"}
    </span></span>
  {else}
    <span class="o"><span>
      <a href="{g->url arg1="view=core.SiteAdmin" arg2="subView=rss.RssSiteAdmin"
       arg3="mode=settings"}">{g->text text="Settings"}</a>
    </span></span>
  {/if}

  {if ($form.allowSimpleFeed) }
  {if ($RssSiteAdmin.mode == 'simplefeedsettings')}
    <span class="giSelected o"><span>
      {g->text text="Simple Feed Settings"}
    </span></span>
  {else}
    <span class="o"><span>
      <a href="{g->url arg1="view=core.SiteAdmin" arg2="subView=rss.RssSiteAdmin"
       arg3="mode=simplefeedsettings"}">{g->text text="Simple Feed Settings"}</a>
    </span></span>
  {/if}
  {/if}

  {if ($RssSiteAdmin.mode == 'list')}
    <span class="giSelected o"><span>
      {g->text text="List"}
    </span></span>
  {else}
    <span class="o"><span>
      <a href="{g->url arg1="view=core.SiteAdmin" arg2="subView=rss.RssSiteAdmin"
       arg3="mode=list"}">{g->text text="List"}</a>
    </span></span>
  {/if}
</div>

<input type="hidden" name="{g->formVar var="form[mode]"}" value="{$RssSiteAdmin.mode}" />

{if $RssSiteAdmin.mode == 'settings' }

<div class="gbBlock">
  <h3> {g->text text="General settings"} </h3>
  <p class="giDescription">
    {g->text text="These are the default and maximum values that are used by all feeds on your Gallery"}
  </p>

  <table class="gbDataTable">
  <tr>
    <td>{g->text text="RSS version"}</td>
    <td><select name="{g->formVar var="form[defaultVersion]"}">
        {html_options values=$RssSiteAdmin.rssVersionList selected=$form.defaultVersion output=$RssSiteAdmin.rssVersionList}
    </select></td>
    <td>
      {if isset($form.error.defaultVersion)}
      <div class="giError">
      {g->text text="Invalid version"}
      </div>
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="Default number of items in feeds"}</td>
    <td><input type="text" name="{g->formVar var="form[defaultCount]"}" value="{$form.defaultCount}" /></td>
    <td>
      {if isset($form.error.defaultCount)}
      <div class="giError">
        {g->text text="Invalid default number"}
      </div>
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="Maximum number of items in feeds"}</td>
    <td><input type="text" name="{g->formVar var="form[maxCount]"}" value="{$form.maxCount}" /></td>
    <td>
      {if isset($form.error.maxCount)}
      <div class="giError">
        {g->text text="Invalid maximum number"}
      </div>
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="Default ttl"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[defaultTtl]"}" value="{$form.defaultTtl}" />
    </td>
    <td>
      {if isset($form.error.defaultTtl)}
      <div class="giError">
        {g->text text="Invalid time to live, this must be a number of minutes (0 to disable ttl)"}
      </div>
      {else}
        {g->text text="Time to live: this must be a number of minutes (0 to disable ttl) aggregators should wait between checks of whether the feed has been updated"}
      {/if}
    </td>
  </tr><tr>
    <td>{g->text text="Default copyright"}</td>
    <td>
      <input type="text" name="{g->formVar var="form[defaultCopyright]"}" value="{$form.defaultCopyright}" />
    </td>
    <td>
      {if isset($form.error.defaultCopyright)}
      <div class="giError">
        {g->text text="Invalid string"}
      </div>
      {/if}
    </td>
  </tr></table>
</div>

<div class="gbBlock">
  <h3> {g->text text="Feed Types"} </h3>
  <p class="giDescription">
    {g->text text="Configure which types of feeds are allowed"}
  </p>
  <table><col width="1%"/><col width="1%"/><col width="50%"/><col width="48%"/>
    <tr><td>
      <input type="checkbox"{if $form.allowSimpleFeed} checked="checked" {/if}
        name="{g->formVar var="form[allowSimpleFeed]"}" id="Rss_allowSimpleFeed"/>
    </td><td colspan="2">
      <label for="Rss_allowSimpleFeed">
        {g->text text="Allow Simple RSS Feed to be used"}
      </label>
    </td><td>
    </td></tr>
    <tr><td></td><td colspan="3">
      {g->text text="If you enable this, users will be able to subscribe to a feed for any album or photo they can view."}
      <br/>
      {g->text text="To edit the settings for Simple Feeds, use the corresponding tab at the top of the screen."}
    </td></tr>

    <tr><td>
      <input type="checkbox"{if $form.allowConfigurableFeed} checked="checked" {/if}
        onclick="refresh(this.form)"
        name="{g->formVar var="form[allowConfigurableFeed]"}" id="Rss_allowConfigurableFeed"/>
    </td><td colspan="3">
      <label for="Rss_allowConfigurableFeed">
        {g->text text="Allow configurable RSS feeds to be used"}
      </label>
    </td></tr>
    <tr><td></td><td colspan="3">
      {g->text text="Only album owners will be able to define such feeds. They can set parameters for the type of feed they want."}
      <br/>
      {g->text text="Once a feed is defined, users will be able to subscribe to those feeds if they can view the associated item."}
    </td></tr>
    <tr><td>
    </td><td>
      <input type="checkbox"{if $form.allowPhotos} checked="checked"{/if}
        {if !$form.allowConfigurableFeed} disabled="disabled" {/if}
        name="{g->formVar var="form[allowPhotos]"}" id="Rss_allowPhotos"/>
    </td><td>
      <label for="Rss_allowPhotos">
        {g->text text="Allow RSS feeds of photos inside an album"}
      </label>
    </td><td>
      {g->text text="Fast"}
    </td></tr>
    <tr><td>
    </td><td>
      <input type="checkbox"{if $form.allowAlbums} checked="checked"{/if}
        {if !$form.allowConfigurableFeed} disabled="disabled" {/if}
        name="{g->formVar var="form[allowAlbums]"}" id="Rss_allowAlbums"/>
    </td><td>
      <label for="Rss_allowAlbums">
        {g->text text="Allow RSS feeds of subalbums of an album"}
      </label>
    </td><td>
      {g->text text="Slow"}
    </td></tr>
    <tr><td>
    </td><td>
      <input type="checkbox"{if $form.allowPhotosRecurse} checked="checked"{/if}
        {if !$form.allowConfigurableFeed} disabled="disabled" {/if}
        name="{g->formVar var="form[allowPhotosRecurse]"}" id="Rss_allowPhotosRecurse"/>
    </td><td>
      <label for="Rss_allowPhotosRecurse">
        {g->text text="Allow RSS feeds of photos inside an album and its subalbums"}
      </label>
    </td><td>
      {g->text text="Slower"}
    </td></tr>
    <tr><td>
    </td><td>
      <input type="checkbox"{if $form.allowCommentsPhoto} checked="checked"{/if}
        {if !$form.allowConfigurableFeed} disabled="disabled" {/if}
        name="{g->formVar var="form[allowCommentsPhoto]"}" id="Rss_allowCommentsPhoto"/>
    </td><td>
      <label for="Rss_allowCommentsPhoto">
        {g->text text="Allow RSS feeds comments of a photo"}
      </label>
    </td><td>
      {g->text text="Fast"}
    </td></tr>
    <tr><td>
    </td><td>
      <input type="checkbox"{if $form.allowCommentsAlbum} checked="checked"{/if}
        {if !$form.allowConfigurableFeed} disabled="disabled" {/if}
        name="{g->formVar var="form[allowCommentsAlbum]"}" id="Rss_allowCommentsAlbum"/>
    </td><td>
      <label for="Rss_allowCommentsAlbum">
        {g->text text="Allow RSS feeds comments of an album"}
      </label>
    </td><td>
      {g->text text="Fast"}
    </td></tr>
    <tr><td>
    </td><td>
      <input type="checkbox"{if $form.allowCommentsRecursive} checked="checked"{/if}
        {if !$form.allowConfigurableFeed} disabled="disabled" {/if}
        name="{g->formVar var="form[allowCommentsRecursive]"}" id="Rss_allowCommentsRecursive"/>
    </td><td>
      <label for="Rss_allowCommentsRecursive">
        {g->text text="Allow RSS feeds comments for an album and its subalbums"}
      </label>
    </td><td>
      {g->text text="Fast"}
    </td></tr>
  </table>
</div>

<div class="gbBlock gcBackground1">
  <input type="submit" name="{g->formVar var="form[action][save]"}" value="{g->text text="Save Settings"}"/>
  <input type="submit" name="{g->formVar var="form[action][reset]"}" value="{g->text text="Reset"}"/>
</div>

{g->addToTrailer}
<script type="text/javascript">
  // <![CDATA[
  function refresh(form) {ldelim}
    enabled = form.elements.namedItem('{g->formVar var="form[allowConfigurableFeed]"}').checked;

    form.elements.namedItem('{g->formVar var="form[allowAlbums]"}').disabled = !enabled;
    form.elements.namedItem('{g->formVar var="form[allowPhotos]"}').disabled = !enabled;
    form.elements.namedItem('{g->formVar var="form[allowPhotosRecurse]"}').disabled = !enabled;
    form.elements.namedItem('{g->formVar var="form[allowCommentsPhoto]"}').disabled = !enabled;
    form.elements.namedItem('{g->formVar var="form[allowCommentsAlbum]"}').disabled = !enabled;
    form.elements.namedItem('{g->formVar var="form[allowCommentsRecursive]"}').disabled = !enabled;
    {rdelim}
  // ]]>
</script>
{/g->addToTrailer}

{elseif $RssSiteAdmin.mode == 'list'}

<div class="gbBlock">
  <h3> {g->text text="Helping users discover RSS feeds"} </h3>
  <p>{g->text text="If you want to help users discover feeds in your Gallery, you can add the RSS block to the themes used in your Gallery."}</p>
  <p>{g->text text="This will have two effects: the block itself, which users can see and pick feeds from (and get a list of all feeds); and hidden page headers that modern web browsers will use to make it easier for the user to subscribe to the feeds."}</p>
</div>

<div class="gbBlock">
  <h3> {g->text text="Global list of RSS feeds"} </h3>
  {if empty($RssSiteAdmin.feeds)}
    <p> {g->text text="No feeds have yet been defined"} </p>
  {else}

    <table class="gbDataTable">
    <tr>
      <th> {g->text text="Feed link"} </th>
      <th> {g->text text="On item"} </th>
      <th> {g->text text="Feed type"} </th>
      <th> {g->text text="Actions"} </th>
    </tr>
    {foreach from=$RssSiteAdmin.feeds item=feed}
	  <tr class="{cycle values="gbEven,gbOdd"}">
	    <td><a href="{g->url arg1="view=rss.Render" arg2="name=`$feed.name`"}">
	      {$feed.name}</a></td>
	    <td><a href="{g->url arg1="view=core.ShowItem" arg2="itemId=`$feed.itemId`"}">
	      {$feed.item->getTitle()}</a></td>
	    <td>{$RssSiteAdmin.types[$feed.params.feedType]}</td>
	    <td>
	      <a href="{g->url arg1="controller=rss.RssSiteAdmin"
	        arg2="form[action][delete]=`$feed.name`"}">
		{g->text text="delete"}</a>
	      <a href="{g->url arg1="view=core.ItemAdmin" arg2="subView=rss.EditFeed"
	        arg3="form[feedName]=`$feed.name`" arg4="itemId=`$feed.itemId`"
		arg5="mode=edit"}">
		{g->text text="edit"}</a>
	    </td>
	  </tr>
    {/foreach}
	</table>
  {/if}
</div>

{else}

<div class="gbBlock">
  <h3> {g->text text="Simple Feed settings"} </h3>
  <p class="giDescription">
    {g->text text="Choose what type of data that will be present in the feed"}
  </p>

  <table class="gbDataTable">

  <tr valign="top">
    <td rowspan="5">{g->text text="For albums"}</td>
    <td>
      <input type="radio" name="{g->formVar var="form[sfAlbumType]"}"
        value="photos" {if $form.sfAlbumType=='photos'}checked="checked"{/if}
	id="RssSiteAdmin_typePhotos" />
    </td><td>
      <label for="RssSiteAdmin_typePhotos">
        {g->text text="Items in the album"}
      </label>
    </td><td>
      {g->text text="Fast"}
    </td>
  </tr><tr valign="top">
    <td>
      <input type="radio" name="{g->formVar var="form[sfAlbumType]"}"
        value="album" {if $form.sfAlbumType=='album'}checked="checked"{/if}
	id="RssSiteAdmin_typeAlbum" />
    </td><td>
      <label for="RssSiteAdmin_typeAlbum">
        {g->text text="Sub-albums of the album"}
      </label>
    </td><td>
      {g->text text="Slow"}
    </td>
  </tr><tr valign="top">
    <td>
      <input type="radio" name="{g->formVar var="form[sfAlbumType]"}"
        value="photosRecurse" {if $form.sfAlbumType=='photosRecurse'}checked="checked"{/if}
	id="RssSiteAdmin_typePhotosRecurse" />
    </td><td>
      <label for="RssSiteAdmin_typePhotosRecurse">
        {g->text text="Items in the album and its subalbums"}
      </label>
    </td><td>
      {g->text text="Slower"}
    </td>
  </tr><tr>
    <td></td>
    <td colspan="2" valign="top">
      <label for="RssSiteAdmin_typePhotosRecurseLimit">
        {g->text text="Limit the number of items per album"}
      </label>
      <input type="text" size="5" name="{g->formVar var="form[sfPhotosRecurseLimit]"}"
        {if isset($form.sfPhotosRecurseLimit)}value="{$form.sfPhotosRecurseLimit}"{/if}
	id="RssSiteAdmin_typePhotosRecurseLimit" />
      {if isset($form.error.sfPhotosRecurseLimit)}
      <div class="giError">
      {g->text text="Invalid limit (must be a positive number, 0 to disable the limit)"}
      </div>
      {else}
      {g->text text="(enter 0 to disable the limit)"}
      {/if}
    </td>
  </tr><tr>
    <td>
      <input type="radio" name="{g->formVar var="form[sfAlbumType]"}"
        value="commentsAlbum" {if $form.sfAlbumType=='commentsAlbum'}checked="checked"{/if}
	id="RssSiteAdmin_typeCommentsAlbum" />
    </td><td>
      <label for="RssSiteAdmin_typeCommentsAlbum">
        {g->text text="Comments for the album"}
      </label>
    </td><td>
      {g->text text="Fast"}
    </td>
  </tr><tr>
  <td></td>
    <td>
      <input type="radio" name="{g->formVar var="form[sfAlbumType]"}"
        value="commentsRecursive" {if $form.sfAlbumType=='commentsRecursive'}checked="checked"{/if}
	id="RssSiteAdmin_typeCommentsRecursive" />
    </td><td>
      <label for="RssSiteAdmin_typeCommentsRecursive">
        {g->text text="Comments for an album and its subalbums"}
      </label>
    </td><td>
      {g->text text="Fast"}
    </td>
  </tr>

  <tr><td>&nbsp;</td></tr>

  <tr valign="top">
    <td>{g->text text="For items"}</td>
    <td><input type="radio" name="fake"
        value="commentsPhoto" checked="checked" id="RssSiteAdmin_typeCommentsPhoto" />
    </td><td>
      <label for="RssSiteAdmin_typeAlbum">
        {g->text text="Comments for items (always selected)"}
      </label>
    </td><td>
      {g->text text="Fast"}
    </td>
  </tr>

  <tr><td>&nbsp;</td></tr>

  <tr>
    <td rowspan="2" valign="top">{g->text text="Which items"}</td>
    <td>
      <input type="radio" name="{g->formVar var="form[sfDate]"}" value="new"
        {if $form.sfDate=='new'}checked="checked"{/if} id="RssSiteAdmin_dateNew" />
    </td><td colspan="2">
      <label for="RssSiteAdmin_dateNew">{g->text text="New items only"}</label>
    </td>
  </tr><tr>
    <td>
      <input type="radio" name="{g->formVar var="form[sfDate]"}" value="updated"
        {if $form.sfDate=='updated'}checked="checked"{/if} id="RssSiteAdmin_dateUpdated" />
    </td><td colspan="2">
      <label for="RssSiteAdmin_dateUpdated">{g->text text="New and updated items"}</label>
    </td>
  </tr>
  </table>

</div>

<div class="gbBlock gcBackground1">
  <input type="submit" name="{g->formVar var="form[action][save]"}" value="{g->text text="Save Settings"}"/>
  <input type="submit" name="{g->formVar var="form[action][reset]"}" value="{g->text text="Reset"}"/>
</div>

{/if}
');
expand_c19e8c72e9($outputDir, 'templates/blocks/RssBlock.tpl', 'eyoKICogJFJldmlzaW9uOiAxNTM0MiAkCiAqIElmIHlvdSB3YW50IHRvIGN1c3RvbWl6ZSB0aGlzIGZpbGUsIGRvIG5vdCBlZGl0IGl0IGRpcmVjdGx5IHNpbmNlIGZ1dHVyZSB1cGdyYWRlcwogKiBtYXkgb3ZlcndyaXRlIGl0LiAgSW5zdGVhZCwgY29weSBpdCBpbnRvIGEgbmV3IGRpcmVjdG9yeSBjYWxsZWQgImxvY2FsIiBhbmQgZWRpdCB0aGF0CiAqIHZlcnNpb24uICBHYWxsZXJ5IHdpbGwgbG9vayBmb3IgdGhhdCBmaWxlIGZpcnN0IGFuZCB1c2UgaXQgaWYgaXQgZXhpc3RzLgogKn0Ke2ctPmNhbGxiYWNrIHR5cGU9InJzcy5GZWVkTGlzdCJ9CjxkaXYgY2xhc3M9InskY2xhc3N9Ij4KICA8aDM+IHtnLT50ZXh0IHRleHQ9IlJTUyBGZWVkcyJ9IDwvaDM+CiAge2lmIGVtcHR5KCRibG9jay5yc3MuZmVlZHMpfQogICAgPHA+IHtnLT50ZXh0IHRleHQ9Ik5vIGZlZWRzIGhhdmUgeWV0IGJlZW4gZGVmaW5lZCJ9IDwvcD4KICB7ZWxzZX0KICAgIHtmb3JlYWNoIGZyb209JGJsb2NrLnJzcy5mZWVkcyBpdGVtPWZlZWR9CiAgICAgIDxhIGhyZWY9IntnLT51cmwgYXJnMT0idmlldz1yc3MuUmVuZGVyIiBhcmcyPSJuYW1lPWAkZmVlZGAifSI+CiAgICAgICAgeyRmZWVkfTwvYT48YnIvPgogICAgey9mb3JlYWNofQogIHsvaWZ9CiAgCiAge2lmICRibG9jay5yc3Muc2hvd01vcmV9CiAgICA8cD48YSBocmVmPSJ7Zy0+dXJsIGFyZzE9InZpZXc9cnNzLkZlZWRMaXN0In0iPntnLT50ZXh0IHRleHQ9Ikxpc3QgYWxsIFJTUyBGZWVkcyJ9PC9hPjwvcD4KICB7L2lmfQo8L2Rpdj4KCg==');
expand_c19e8c72e9($outputDir, 'templates/blocks/blocks.inc', 'PD9waHAKJGJsb2Nrc1snUnNzQmxvY2snXSA9IGFycmF5KAogICAgJ2Rlc2NyaXB0aW9uJyA9PiAkZ2FsbGVyeS0+aTE4bignTGlzdCBvZiBSU1MgRmVlZHMnKSwKICAgICdkZWZhdWx0JyA9PiAndHJ1ZScsCiAgICAndmFycycgPT4gYXJyYXkoCgknbnVtYmVyJyA9PiBhcnJheSgKCSAgICAnZGVzY3JpcHRpb24nID0+ICRnYWxsZXJ5LT5pMThuKCdOdW1iZXIgb2YgZmVlZHMgdG8gZGlzcGxheScpLAoJICAgICd0eXBlJyA9PiAnY2hvaWNlJywKCSAgICAnZGVmYXVsdCcgPT4gJzUnLAoJICAgICdjaG9pY2VzJyA9PiBhcnJheSgKCQknMScgPT4gJGdhbGxlcnktPmkxOG4oJzEnKSwKCQknNScgPT4gJGdhbGxlcnktPmkxOG4oJzUnKSwKCQknMTAnID0+ICRnYWxsZXJ5LT5pMThuKCcxMCcpLAoJCSc5OTknID0+ICRnYWxsZXJ5LT5pMThuKCdhbGwnKSwKCSAgICApCgkpCiAgICApCik7Cj8+Cg==');
}
function expand_c19e8c72e9($outputDir, $relativePath, $data) {
$fd = fopen($outputDir . $relativePath, 'w');
fwrite($fd, base64_decode($data));
fclose($fd);
}
$unpackFunction = "unpack_c19e8c72e9";
?>

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists