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/itemadd-1.0.0-16041-base.package

<?php
function unpack_a4483450cb($outputDir) {
/* Create directory structure. */
@mkdir($outputDir . 'locale');
@mkdir($outputDir . 'po');
@mkdir($outputDir . 'templates');
/* Recreate individual files. */
expand_a4483450cb($outputDir, 'ItemAddFromServer.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.
 */

/**
 * This plugin will handle the addition of an items from the server filesystem.
 * @package ItemAdd
 * @subpackage UserInterface
 * @author Bharat Mediratta <bharat@menalto.com>
 * @version $Revision: 15513 $
 */
class ItemAddFromServer extends ItemAddPlugin {

    /**
     * @see ItemAddPlugin::isAppropriate
     */
    function isAppropriate() {
	list ($ret, $param) = GalleryCoreApi::getPluginParameter('module', 'itemadd', 'fromserver');
	if ($ret) {
	    return array($ret, null);
	}
	if ($param == 'admin') {
	    list ($ret, $isAdmin) = GalleryCoreApi::isUserInSiteAdminGroup();
	    if ($ret) {
		return array($ret, null);
	    }
	    $param = $isAdmin ? 'on' : 'off';
	}
	return array(null, $param == 'on');
    }

    /**
     * @see ItemAddPlugin::handleRequest
     */
    function handleRequest($form, &$item) {
	global $gallery;
	$this->_platform =& $gallery->getPlatform();
	$this->_dirSep = $this->_platform->getDirectorySeparator();

	$status = $error = array();

	if (isset($form['action']['addFromLocalServer'])
		&& (!empty($form['localServerFiles']) || !empty($form['localServerDirectories']))) {
	    /* Add the selected items */
	    $textFields = array(
		'title' => (isset($form['set']['title'])) ? 1 : 0,
		'summary' => (isset($form['set']['summary'])) ? 1 : 0,
		'description' => (isset($form['set']['description'])) ? 1 : 0);

	    /*
	     * See loadTemplate: the input is in UTF-8,
	     * the filesystem needs the path in the system charset
	     */
	    $dir = GalleryCoreApi::convertFromUtf8($form['localServerPath']);
	    GalleryUtilities::unsanitizeInputValues($dir, false);

	    /* We need the localServerDirList only in the system charset */
	    list ($ret, $unused, $localServerDirList) = $this->fetchLocalServerDirList();
	    if ($ret) {
		return array($ret, null, null);
	    }

	    if (!GalleryUtilities::isPathInList($dir, $localServerDirList)) {
		return array(GalleryCoreApi::error(ERROR_BAD_PARAMETER),
			     null, null);
	    }
	    if ($dir{strlen($dir)-1} != $this->_dirSep) {
		$dir .= $this->_dirSep;
	    }

	    list ($ret, $lockId) = GalleryCoreApi::acquireReadLock($item->getId());
	    if ($ret) {
		return array($ret, null, null);
	    }

	    if (!empty($form['localServerFiles'])) {
		foreach ($form['localServerFiles'] as $fileKey => $data) {
		    if (!isset($data['selected'])) {
			continue;
		    }
		    $useSymlink = isset($data['useSymlink']);
		    $file = $dir . urldecode($fileKey);
		    if (!GalleryUtilities::isPathInList(dirname($file), $localServerDirList)) {
			/* Ensure malformed input like fileKey = ../foo doesn't work */
			continue;
		    }

		    $ret = $this->addItem($item->getId(), $file, $useSymlink,
					  $textFields, $status, $error);
		    if ($ret) {
			GalleryCoreApi::releaseLocks($lockId);
			return array($ret, null, null);
		    }
		}
	    }

	    if (!empty($form['localServerDirectories'])) {
		$this->_localServerDirList = $localServerDirList;

		/* Make sure we have permission to add subalbums */
		$ret = GalleryCoreApi::assertHasItemPermission($item->getId(), 'core.addAlbumItem');
		if ($ret) {
		    GalleryCoreApi::releaseLocks($lockId);
		    return array($ret, null, null);
		}

		foreach ($form['localServerDirectories'] as $directory => $data) {
		    /* Skip current or parent directory entries */
		    if (!isset($data['selected']) || $directory == "." || $directory == "..") {
			continue;
		    }
		    $useSymlink = isset($data['useSymlink']);

		    list ($ret, $albumId) = $this->addDirectory($item->getId(),
			$dir . urldecode($directory), $useSymlink, $textFields, $status, $error);
		    if ($ret) {
			GalleryCoreApi::releaseLocks($lockId);
			return array($ret, null, null);
		    }
		    if ($albumId) {
			$ret = $this->processDirectory($albumId, $dir . urldecode($directory),
			    $useSymlink, $textFields, $status, $error);
			if ($ret) {
			    GalleryCoreApi::releaseLocks($lockId);
			    return array($ret, null, null);
			}
		    }
		}
	    }

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

	return array(null, $error, $status);
    }

    function addItem($parentId, $file, $useSymlink, $textFields, &$status, &$error) {
	$fileName = basename($file);
	list ($base, $extension) = GalleryUtilities::getFileNameComponents($fileName);
	list ($ret, $mimeType) = GalleryCoreApi::convertExtensionToMime($extension);
	if ($ret) {
	    return $ret;
	}
	$base = GalleryCoreApi::convertToUtf8($base);
	GalleryUtilities::sanitizeInputValues($base);

	$title = ($textFields['title']) ? $base : '';
	$summary = ($textFields['summary']) ? $base : '';
	$description = ($textFields['description']) ? $base : '';

	list ($ret, $newItem) = GalleryCoreApi::addItemToAlbum($file,
							       $fileName,
							       $title,
							       $summary,
							       $description,
							       $mimeType,
							       $parentId,
							       $useSymlink);
	if ($ret) {
	    return $ret;
	}

	$status['addedFiles'][] = array('fileName' => GalleryCoreApi::convertToUtf8($fileName),
					'id' => $newItem->getId(),
					'warnings' => array());

	return null;
    }

    /** @return array object GalleryStatus, mixed id of new album or false */
    function addDirectory($parentId, $path, $useSymlink, $textFields, &$status, &$error) {
	global $gallery;

	if (!GalleryUtilities::isPathInList($path, $this->_localServerDirList)
		|| GalleryUtilities::isPathInList($path,
				     array($gallery->getConfig('data.gallery.albums')))) {
	    /*
	     * Silently skip directory if a symlink jumped us outside the approved
	     * directory list or we are trying to add from our own g2data albums.
	     * Also protects against malformed form input like directory = ../foo
	     */
	    return array(null, false);
	}

	/* Create new Album */
	$dirName = basename($path);
	$dirNameUtf8 = GalleryCoreApi::convertToUtf8($dirName);
	$dirTitle = $textFields['title'] ? $dirNameUtf8 : null;
	$dirSummary = $textFields['summary'] ? $dirNameUtf8 : null;
	$dirDescription = $textFields['description'] ? $dirNameUtf8 : null;
	list ($ret, $album) = GalleryCoreApi::createAlbum($parentId, $dirName, $dirTitle,
							  $dirSummary, $dirDescription, "");
	if ($ret) {
	    if ($ret->getErrorCode() & ERROR_COLLISION) {
		$error[] = 'form[error][pathComponent][collision]';
		return array(null, false);
	    } else {
		return array($ret, null);
	    }
	}

	if (!isset($album)) {
	    return array(GalleryCoreApi::error(ERROR_MISSING_OBJECT), null);
	}

	$ret = GalleryCoreApi::addUserPermission($album->getId(), $album->getOwnerId(),
						 'core.all', false);
	if ($ret) {
	    return array($ret, null);
	}

	return array(null, $album->getId());
    }

    function processDirectory($albumId, $path, $useSymlink, $textFields, &$status, &$error) {
	global $gallery;

	list ($ret, $lockId) = GalleryCoreApi::acquireReadLock($albumId);
	if ($ret) {
	    return $ret;
	}

	/* Look into the directory, add anything we find */
	$dirList = $albumList = array();
	$handle = $this->_platform->opendir($path);
	while (($fileName = $this->_platform->readdir($handle)) !== false) {
	    if ($fileName == '.' || $fileName == '..' || $fileName == '.svn') {
		continue;
	    }
	    $dirList[] = $fileName;
	}
	$this->_platform->closedir($handle);
	sort($dirList);

	foreach ($dirList as $fileName) {
	    $gallery->guaranteeTimeLimit(30);
	    $filePath = $path . $this->_dirSep . $fileName;
	    if ($this->_platform->is_readable($filePath)) {
		if ($this->_platform->is_dir($filePath)) {
		    list ($ret, $newAlbumId) = $this->addDirectory($albumId, $filePath,
			$useSymlink, $textFields, $status, $error);
		    if ($ret) {
			GalleryCoreApi::releaseLocks($lockId);
			return $ret;
		    }
		    if ($newAlbumId) {
			$albumList[$newAlbumId] = $filePath;
		    }
		} else {
		    $ret = $this->addItem($albumId, $filePath, $useSymlink,
					  $textFields, $status, $error);
		    if ($ret) {
			GalleryCoreApi::releaseLocks($lockId);
			return $ret;
		    }
		}
		if (!empty($error)) {
		    /* Bail out if an error has occurred */
		    break;
		}
	    }
	}

	$ret = GalleryCoreApi::releaseLocks($lockId);
	if ($ret) {
	    return $ret;
	}

	foreach ($albumList as $newAlbumId => $filePath) {
	    $ret = $this->processDirectory($newAlbumId, $filePath,
					   $useSymlink, $textFields, $status, $error);
	    if ($ret) {
		return $ret;
	    }
	    if (!empty($error)) {
		/* Bail out if an error has occurred */
		break;
	    }
	}

	return null;
    }

    /*
     * @return array (object GalleryStatus a status code,
     *                array of UTF-8 strings localServerDirList,
     *                array of system charset strings localServerDirList)
     */
    function fetchLocalServerDirList() {
	list ($ret, $param) = GalleryCoreApi::fetchAllPluginParameters('module', 'itemadd');
	if ($ret) {
	    return array($ret, null, null);
	}
	$localServerDirList = array();
	$localServerDirListInSystemCharset = array();
	for ($i = 1; !empty($param['uploadLocalServer.dir.' . $i]); $i++) {
	    $localServerDirList[] = $param['uploadLocalServer.dir.' . $i];
	    $localServerDirListInSystemCharset[] =
		GalleryCoreApi::convertFromUtf8($param['uploadLocalServer.dir.' . $i]);
	}
	return array(null, $localServerDirList,
		     $localServerDirListInSystemCharset);
    }

    /**
     * @see ItemAdd:loadTemplate
     */
    function loadTemplate(&$template, &$form, $item) {
	global $gallery;

	if ($form['formName'] != 'ItemAddFromServer') {
	    /* First time around, load the form with item data */
	    $form['localServerPath'] = '';
	    $form['formName'] = 'ItemAddFromServer';
	}

	list ($ret, $localServerDirList, $localServerDirListInSystemCharset) =
	    $this->fetchLocalServerDirList();
	if ($ret) {
	    return array($ret, null, null);
	}

	/* Look up the platform type */
	$platform =& $gallery->getPlatform();
	$slash = $platform->getDirectorySeparator();

	if (isset($form['action']['startOver'])) {
	    $form['localServerFiles'] = array();
	} else if (isset($form['action']['findFilesFromLocalServer'])) {
	    /* If we're uploading from the local server, get a file list now */
	    $localServerPath = trim($form['localServerPath']);
	    /*
	     * All input is UTF-8, whether it comes from the browser or from the database.
	     * When we use realpath, is_dir, opendir, readdir, .., we need the path in the system
	     * charset and not in UTF-8.
	     * Therefore, we use UTF-8 for everything (output, db input) but the filesystem
	     * interactions.
	     * $form['localServerPath'] is UTF-8, $localServerPath is in the system charset
	     */
	    $localServerPath = GalleryCoreApi::convertFromUtf8($localServerPath);
	    GalleryUtilities::unsanitizeInputValues($localServerPath, false);
	    $localServerPath = $platform->realpath($localServerPath);
	    $form['localServerPath'] = GalleryCoreApi::convertToUtf8($localServerPath);

	    /* Validate the path */
	    $form['localServerFiles'] = array();
	    if (empty($localServerPath)) {
		$form['error']['localServerPath']['missing'] = 1;
	    } else if (!$platform->file_exists($localServerPath) ||
		       !$platform->is_readable($localServerPath)) {
		$form['error']['localServerPath']['invalid'] = 1;
	    } else if (!GalleryUtilities::isPathInList($localServerPath,
						       $localServerDirListInSystemCharset)) {
		$form['error']['localServerPath']['illegal'] = 1;
	    } else {
		$gallery->guaranteeTimeLimit(30);
		$path = $localServerPath;
		if ($platform->is_dir($path)) {
		    $handle = $platform->opendir($path);
		    $mimeTypeItemMap = array();

		    /* Add path to the recent path list */
		    $session =& $gallery->getSession();
		    $recentPaths =
			$session->get('itemadd.view.ItemAdd.ItemAddFromServer.recentPaths');
		    /* Use the UTF-8 string, recent paths is only for the output */
		    $recentPaths[$form['localServerPath']] = 1;
		    $session->put('itemadd.view.ItemAdd.ItemAddFromServer.recentPaths',
				  $recentPaths);

		    while (($fileName = $platform->readdir($handle)) !== false) {
			if ($fileName == '.') {
			    continue;
			}
			$filePath = $path . $slash . $fileName;

			if ($platform->is_readable($filePath)) {
			    if ($platform->is_dir($filePath)) {
				$filePath = $platform->realpath($filePath);
				$legal =
				    GalleryUtilities::isPathInList($filePath,
							      $localServerDirListInSystemCharset);
				if (!$legal && $fileName == '..') {
				    continue;
				}
				$form['localServerFiles'][] =
				    array('type' => 'directory',
					  'fileName' => GalleryCoreApi::convertToUtf8($fileName),
					  'filePath' => GalleryCoreApi::convertToUtf8($filePath),
					  'fileKey' => urlencode($fileName),
					  'legal' => $legal,
					  'unknown' => false);
			    } else {
				list ($ret, $mimeType) = GalleryCoreApi::getMimeType($fileName);
				if ($ret) {
				    return array($ret, null, null);
				}
				if (!isset($mimeTypeItemMap[$mimeType])) {
				    list ($ret, $mimeTypeItem) =
					GalleryCoreApi::newItemByMimeType($mimeType);
				    if ($ret) {
					return array($ret, null, null);
				    }
				    /* Get localized and english names: */
				    $mimeTypeItem->setMimeType($mimeType);
				    $mimeTypeItemMap[$mimeType] =
					array_merge($mimeTypeItem->itemTypeName(),
						    $mimeTypeItem->itemTypeName(false));
				}

				$form['localServerFiles'][] =
				    array('type' => 'file',
					  'fileName' => GalleryCoreApi::convertToUtf8($fileName),
					  'stat' => $platform->stat($filePath),
					  'itemType' => $mimeTypeItemMap[$mimeType][0],
					  'unknown' => $mimeTypeItemMap[$mimeType][3] == 'unknown',
					  'fileKey' => urlencode($fileName));
			    }
			}
		    }
		    $platform->closedir($handle);

		} else if ($platform->is_file($path) && !$platform->is_link($path)) {
		    list ($ret, $mimeType) = GalleryCoreApi::getMimeType($path);
		    if ($ret) {
			return array($ret, null, null);
		    }
		    list ($ret, $mimeTypeItem) = GalleryCoreApi::newItemByMimeType($mimeType);
		    if ($ret) {
			return array($ret, null, null);
		    }
		    $mimeTypeItem->setMimeType($mimeType);
		    $mimeTypeItemName = array_merge($mimeTypeItem->itemTypeName(),
						    $mimeTypeItem->itemTypeName(false));

		    $fileName = basename($path);
		    $form['localServerFiles'][] =
			array('type' => 'file',
			      'fileName' => GalleryCoreApi::convertToUtf8($fileName),
			      'stat' => $platform->stat($path),
			      'itemType' => $mimeTypeItemName[0],
			      'unknown' => $mimeTypeItemName[3] == 'unknown',
			      'fileKey' => urlencode($fileName));

		    /* Change localServerPath from file path to parent dir */
		    $form['localServerPath'] = GalleryCoreApi::convertToUtf8(dirname($path));
		}
	    }
	}

	/* Do we have permission to add subalbums */
	list ($ret, $canAddAlbum) = GalleryCoreApi::hasItemPermission($item->getId(),
		'core.addAlbumItem');
	if ($ret) {
	    return array($ret, null, null);
	}
	$ItemAddFromServer = array('pathSeparator' => $slash,
				   'localServerDirList' => $localServerDirList,
				   'localServerFileCount' =>
				     isset($localServerFileCount) ? $localServerFileCount : null,
				   'canAddAlbum' => $canAddAlbum);

	if (!empty($form['localServerFiles'])) {
	    usort($form['localServerFiles'], array($this, '_sortFiles'));
	    $accumulator = '';
	    foreach ($platform->splitPath($form['localServerPath']) as $element) {
		$accumulator .= $element;
		$ItemAddFromServer['pathElements'][] = array(
		    'name' => $element, 'path' => $accumulator,
		    'legal' => GalleryUtilities::isPathInList(
			GalleryCoreApi::convertFromUtf8($accumulator),
			$localServerDirListInSystemCharset));
		if (count($ItemAddFromServer['pathElements']) > 1) {
		    $accumulator .= $slash;
		}
	    }
	}

	$session =& $gallery->getSession();
	$recentPaths = $session->get('itemadd.view.ItemAdd.ItemAddFromServer.recentPaths');
	if (!isset($recentPaths)) {
	    $recentPaths = array();
	}
	$ItemAddFromServer['recentPaths'] = array_keys($recentPaths);

	/*
	 * Set the ItemAdmin form's encoding type specially since legal paths may contain special
	 * characters like ampersands (&)
	 */
	if ($template->hasVariable('ItemAdmin')) {
	    $ItemAdmin =& $template->getVariableByReference('ItemAdmin');
	    $ItemAdmin['enctype'] = 'multipart/form-data';
	} else {
	    $ItemAdmin['enctype'] = 'multipart/form-data';
	    $template->setVariable('ItemAdmin', $ItemAdmin);
	}

	if (!isset($form['set'])) {
	    $form['set'] = array('title' => 1, 'summary' => 0, 'description' => 0);
	}

	/* Do we want to allow symlinks? */
	$ItemAddFromServer['showSymlink'] = $platform->isSymlinkSupported();

	$template->setVariable('ItemAddFromServer', $ItemAddFromServer);

	return array(null,
		     'modules/itemadd/templates/ItemAddFromServer.tpl',
		     'modules_itemadd');
    }

    /**
     * @see ItemAddPlugin::getTitle
     */
    function getTitle() {
	list ($ret, $module) = GalleryCoreApi::loadPlugin('module', 'itemadd');
	if ($ret) {
	    return array($ret, null);
	}

	return array(null, $module->translate('From Local Server'));
    }

    /**
     * Sort directory listing.. directory, known types, unknowns.
     * @access private
     */
    function _sortFiles($a, $b) {
	if (($a['type'] == 'directory' || $b['type'] == 'directory') && $a['type'] != $b['type']) {
	    return ($a['type'] == 'directory') ? -1 : 1;
	}
	if (($a['unknown'] || $b['unknown']) && $a['unknown'] != $b['unknown']) {
	    return $a['unknown'] ? 1 : -1;
	}
	return strcasecmp($a['fileName'], $b['fileName']);
    }
}
?>
');
expand_a4483450cb($outputDir, 'ItemAddFromWeb.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.
 */

/**
 * This plugin will handle the addition of items from other web pages.
 * @package ItemAdd
 * @subpackage UserInterface
 * @author Bharat Mediratta <bharat@menalto.com>
 * @version $Revision: 15513 $
 */
class ItemAddFromWeb extends ItemAddPlugin {

    /**
     * @see ItemAddPlugin::isAppropriate
     */
    function isAppropriate() {
	list ($ret, $param) = GalleryCoreApi::getPluginParameter('module', 'itemadd', 'fromweb');
	if ($ret) {
	    return array($ret, null);
	}
	if ($param == 'admin') {
	    list ($ret, $isAdmin) = GalleryCoreApi::isUserInSiteAdminGroup();
	    if ($ret) {
		return array($ret, null);
	    }
	    $param = $isAdmin ? 'on' : 'off';
	}
	return array(null, $param == 'on');
    }

    /**
     * @see ItemAddPlugin::handleRequest
     */
    function handleRequest($form, &$item) {
	global $gallery;

	$status = $error = array();

	if (isset($form['action']['findFilesFromWebPage'])) {
	    /* Delegate back to the same view */
	} else if (isset($form['action']['addFromWebPage']) && empty($form['webPageUrls'])) {
	    GalleryUtilities::putRequestVariable('form[error][webPage][nothingSelected]', 1);
	} else if (isset($form['action']['addFromWebPage'])) {
	    $platform =& $gallery->getPlatform();
	    /* Pass referer checking */
	    if (!empty($form['webPage'])) {
		$extraHeaders =
		    array('Referer' => str_replace('&amp;', '&', $form['webPage']));
	    }
	    foreach (array_keys($form['webPageUrls']) as $url) {
		/* Copy the file locally */
		$tmpDir = $gallery->getConfig('data.gallery.tmp');
		$tmpFile = $platform->tempnam($tmpDir, 'add');

		$successfullyCopied = false;
		GalleryUtilities::unsanitizeInputValues($url, false);
		if (empty($extraHeaders)) {
		    $extraHeaders = array('Referer' => str_replace('&amp;', '&', $url));
		}
		list ($successfullyCopied, $response, $headers) =
		    GalleryCoreApi::fetchWebFile($url, $tmpFile, $extraHeaders);
		if ($successfullyCopied) {
		    /* Add it */
		    list ($ret, $mimeType, $fileName) = $this->_getMimeType($url, $headers, true);
		    if ($ret) {
			return array($ret, null, null);
		    }

		    list ($base) = GalleryUtilities::getFileNameComponents($fileName);
		    $title = (isset($form['set']['title']) && $form['set']['title']) ? $base : '';
		    $summary = (isset($form['set']['summary'])
			     && $form['set']['summary']) ? $base : '';
		    $description = (isset($form['set']['description'])
				 && $form['set']['description']) ? $base : '';

		    list ($ret, $newItem) = GalleryCoreApi::addItemToAlbum($tmpFile,
									   $fileName,
									   $title,
									   $summary,
									   $description,
									   $mimeType,
									   $item->getId());
		    if ($ret) {
			return array($ret, null, null);
		    }

		    $status['addedFiles'][] = array('fileName' => $url,
						    'id' => $newItem->getId(),
						    'warnings' => array());
		}
		@$platform->unlink($tmpFile);
	    }
	}

	return array(null, $error, $status);
    }

    /**
     * @see ItemAdd:loadTemplate
     */
    function loadTemplate(&$template, &$form, $item) {
	global $gallery;

	if ($form['formName'] != 'ItemAddFromWeb') {
	    /* First time around, load the form with item data */
	    $form['webPage'] = '';
	    $form['formName'] = 'ItemAddFromWeb';
	}

	if (isset($form['action']['findFilesFromWebPage'])) {
	    /* Download the web page then parse it to get the file list */
	    if (empty($form['webPage'])) {
		$form['error']['webPage']['missing'] = 1;
	    }
	    if (empty($form['error'])) {
		$baseUrlComponents = parse_url($form['webPage']);
		if (empty($baseUrlComponents['scheme']) || $baseUrlComponents['scheme'] != 'http') {
		    $form['error']['webPage']['invalid'] = 1;
		}
	    }
	    if (empty($form['error'])) {
		list ($successful, $buffer, $response, $headers, $actualUrl) =
		    GalleryCoreApi::fetchWebPage($form['webPage']);
		if (empty($buffer) || !$successful) {
		    $form['error']['webPage']['unavailable'] = 1;
		}
	    }
	    if (empty($form['error'])) {
		if (isset($actualUrl) && $actualUrl != $form['webPage']) {
		    $form['webPage'] = str_replace('&', '&amp;', $actualUrl);
		    $baseUrlComponents = parse_url($form['webPage']);
		}

		/* Add path to the recent path list */
		$session =& $gallery->getSession();
		$recentUrls = $session->get('itemadd.view.ItemAddFromWeb.recentUrls');
		$recentUrls[$form['webPage']] = 1;
		$session->put('itemadd.view.ItemAddFromWeb.recentUrls', $recentUrls);

		$form['webPageUrls'] = array();

		if (isset($headers['Content-Type'])) {
		    $contentType = $headers['Content-Type'];
		} else if (isset($headers['Content-type'])) {
		    /*
		     * Grumble grumble.  Some servers (eg Sun-ONE-Web-Server/6.1)
		     * capitalize this header differently
		     */
		    $contentType = $headers['Content-type'];
		} else {
		    $contentType = '';
		}

		if (strncmp($contentType, 'text', 4)) {
		    /*
		     * If the buffer does not contain text(/html) then just offer
		     * to add this url, rather than parsing the contents.
		     */
		    list ($ret, $typeName) = $this->_getTypeName($form['webPage'], null, $headers);
		    if ($ret) {
			return array($ret, null, null);
		    }
		    if (!empty($typeName)) {
			$form['webPageUrls'][] = array('url' => $form['webPage'],
						       'itemType' => $typeName);
		    }
		} else {
		    /*
		     * Parse the buffer.  We match:
		     *  href="foo bar"    href='foo bar'   href=foo
		     *  src="foo bar"     src='foo bar'    src=foo
		     *  value="http:foo"  value='http:foo' value=http:foo (or https)
		     */
		    preg_match_all('/(src|href|value(?=\s*=\s*[\'"]?https?:))\s*=\s*'
			    . '(?:\"(.*?)\"|\'(.*?)\'|([^\'\"\> ]*))/i',
			    $buffer, $matches);

		    $seenBefore = array();
		    for ($i = 0; $i < count($matches[1]); $i++) {
			$url = !empty($matches[2][$i]) ? $matches[2][$i]
				: (!empty($matches[3][$i]) ? $matches[3][$i]
				: $matches[4][$i]);

			/* Avoid XSS by eliminating any HTML from the url */
			$url = str_replace(array('<', '>'), array('&lt;', '&gt;'), $url);

			if (empty($url) || isset($seenBefore[$url])) {
			    continue;
			}
			$seenBefore[$url] = 1;

			/*
			 * Some sites (slashdot) have images that start with //
			 * and this confuses Gallery.  Prepend the base scheme.
			 */
			if (!strncmp($url, '//', 2)) {
			    $url = $baseUrlComponents['scheme'] . ':' . $url;
			}

			/* Convert urls without scheme/host to full urls */
			if (!preg_match('/^\w+:/', $url)) {
			    $tmp = $baseUrlComponents['scheme'] . '://'
				 . $baseUrlComponents['host'];
			    if (!empty($baseUrlComponents['port'])) {
				$tmp .= ':' . $baseUrlComponents['port'];
			    }
			    if ($url[0] == '/') {
				/* Absolute path; just prepend scheme/host:port */
				$url = $tmp . $url;
			    } else {
				/*
				 * Relative path; the current url might be one of:
				 *   http://example.com/path/to/file.html
				 *   http://example.com/path/to/
				 *
				 * If it's a directory, it should have a trailing slash at
				 * this point.  Either way, we want the base path to be:
				 *   http://example.com/path/to/
				 */
				if (isset($baseUrlComponents['path'])) {
				    $basePath = $baseUrlComponents['path'];
				} else {
				    $basePath = '/';
				}
				if (!preg_match('/\/$/', $basePath)) {
				    $basePath = dirname($basePath);
				    if ($basePath != '/') {
					$basePath .= '/';
				    }
				}
				$tmp .= $basePath;
				$url = $tmp . $url;
			    }
			}

			list ($ret, $typeName) = $this->_getTypeName($url, $matches[1][$i]);
			if ($ret) {
			    return array($ret, null, null);
			}

			if (!empty($typeName)) {
			    $form['webPageUrls'][] = array('url' => $url, 'itemType' => $typeName);
			}
		    }
		}
		if (empty($form['webPageUrls'])) {
		    /* Didn't find any urls to add */
		    $form['error']['webPage']['noUrlsFound'] = 1;
		}
	    }
	}

	if (!isset($form['set'])) {
	    $form['set'] = array('title' => 1, 'summary' => 0, 'description' => 0);
	}

	$ItemAddFromWeb = array(
	    'webPageUrlCount' => isset($form['webPageUrls']) ? count($form['webPageUrls']) : 0);

	$session =& $gallery->getSession();
	$recentUrls = $session->get('itemadd.view.ItemAddFromWeb.recentUrls');
	if (!isset($recentUrls)) {
	    $recentUrls = array();
	}
	$ItemAddFromWeb['recentUrls'] = array_keys($recentUrls);

	$template->setVariable('ItemAddFromWeb', $ItemAddFromWeb);
	return array(null,
		     'modules/itemadd/templates/ItemAddFromWeb.tpl',
		     'modules_itemadd');
    }

    /**
     * Analyze url and available data to find mime type.  Check:
     *  1. Parse url for file extension and map this to a mime type.
     *  2. Check for Content-Disposition http header than includes
     *     a filename and map this extension to a mime type.
     *  3. Check for Content-Type http header and use that mime type.
     *
     * @param string $url url
     * @param array $headers (optional) http response headers
     * @param boolean $getFileName (optional) true to also figure out filename
     * @return array object GalleryStatus a status object
     *               string mime type
     *               string filename or null if not requested
     * @access private
     */
    function _getMimeType($url, $headers=null, $getFileName=false) {
	$urlComponents = parse_url($url);

	$fileName = null;
	if ($getFileName) {
	    if (!empty($headers['Content-Disposition'])
		    && preg_match('/filename="(.*?)"/', $headers['Content-Disposition'], $match)) {
		$fileName = $match[1];
	    } else if (!empty($urlComponents['path'])) {
		$fileName = basename($urlComponents['path']);
	    } else {
		$fileName = basename($url);
	    }
	}

	if (!empty($urlComponents['path'])) {
	    list ($ret, $mimeType) = GalleryCoreApi::getMimeType($urlComponents['path']);
	    if ($ret) {
		return array($ret, null, null);
	    }
	    if (!empty($mimeType) && $mimeType != 'application/unknown') {
		return array(null, $mimeType, $fileName);
	    }
	}

	if (!empty($urlComponents['query'])) {
	    /*
	     * Try again with end of the query string -- just in case.  Some sites, like
	     * Google's image search feature, put the file name at the end of the query string.
	     */
	    list ($ret, $mimeType) = GalleryCoreApi::getMimeType($urlComponents['query']);
	    if ($ret) {
		return array($ret, null, null);
	    }
	    if (!empty($mimeType) && $mimeType != 'application/unknown') {
		return array(null, $mimeType, $fileName);
	    }
	}

	if (!empty($headers['Content-Disposition'])
		&& preg_match('/filename="(.*?)"/', $headers['Content-Disposition'], $match)) {
	    list ($ret, $mimeType) = GalleryCoreApi::getMimeType($match[1]);
	    if ($ret) {
		return array($ret, null, null);
	    }
	    if (!empty($mimeType) && $mimeType != 'application/unknown') {
		return array(null, $mimeType, $fileName);
	    }
	}

	if (!empty($headers['Content-Type'])) {
	    return array(null, $headers['Content-Type'], $fileName);
	}

	return array(null, null, $fileName);
    }

    /**
     * Analyze url and available data to find item type.
     *
     * @param string $url url
     * @param string $htmlAttribute (optional) html attribute this url was parsed from
     * @param array $headers (optional) http response headers
     * @return array object GalleryStatus a status object
     *               string type name
     * @access private
     */
    function _getTypeName($url, $htmlAttribute=null, $headers=null) {
	if (isset($htmlAttribute) && strtolower($htmlAttribute) == 'src') {
	    /* For <img> src attribute just assume "Photo" and don't examine mime type */
	    list ($ret, $module) = GalleryCoreApi::loadPlugin('module', 'itemadd');
	    if ($ret) {
		return array($ret, null);
	    }
	    return array(null, $module->translate('Photo'));
	} else {
	    list ($ret, $mimeType) = $this->_getMimeType($url, $headers);
	    if ($ret) {
		return array($ret, null);
	    }
	    if (empty($mimeType)) {
		return array(null, null);
	    }

	    static $mimeTypeNameMap = array();
	    if (!isset($mimeTypeNameMap[$mimeType])) {
		list ($ret, $mimeTypeItem) = GalleryCoreApi::newItemByMimeType($mimeType);
		if ($ret) {
		    return array($ret, null);
		}
		$mimeTypeItem->setMimeType($mimeType);
		$mimeTypeNameMap[$mimeType] = $mimeTypeItem->itemTypeName();
	    }
	    return array(null, $mimeTypeNameMap[$mimeType][0]);
	}
    }

    /**
     * @see ItemAddPlugin::getTitle
     */
    function getTitle() {
	list ($ret, $module) = GalleryCoreApi::loadPlugin('module', 'itemadd');
	if ($ret) {
	    return array($ret, null);
	}

	return array(null, $module->translate('From Web Page'));
    }
}
?>
');
expand_a4483450cb($outputDir, 'ItemAddSiteAdmin.inc', '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');
expand_a4483450cb($outputDir, 'MANIFEST', 'IyAkUmV2aXNpb246IDE2MDQxICQKIyBGaWxlIGNyYzMyIGNyYzMyKGNybGYpIHNpemUgc2l6ZShjcmxmKSAgb3IgIFIgRmlsZQptb2R1bGVzL2l0ZW1hZGQvSXRlbUFkZEZyb21TZXJ2ZXIuaW5jCTE2NjE2NDQzNDkJMTQ2NDM2MzEwOQkxODQyNwkxODk4NAptb2R1bGVzL2l0ZW1hZGQvSXRlbUFkZEZyb21XZWIuaW5jCTE0ODk5ODA5NTQJMzk2NjM4MzgzNgkxMzQ0MQkxMzg1NQptb2R1bGVzL2l0ZW1hZGQvSXRlbUFkZFNpdGVBZG1pbi5pbmMJODA1NzA5ODE3CTMyODIzOTk2OTQJNTk4NAk2MTYyCm1vZHVsZXMvaXRlbWFkZC9tb2R1bGUuaW5jCTE3NTY3MzY0ODAJMTQxNzA1MDU1MAkyNzQ1CTI4MzcKbW9kdWxlcy9pdGVtYWRkL3RlbXBsYXRlcy9JdGVtQWRkRnJvbVNlcnZlci50cGwJMzczMjMxMjUzOQkzMDczNzExNzY5CTEwODIyCTExMTMzCm1vZHVsZXMvaXRlbWFkZC90ZW1wbGF0ZXMvSXRlbUFkZEZyb21XZWIudHBsCTI2NDk4MjYyNTUJMzY1MzEyMTk1Nwk1NDk2CTU2NjIKbW9kdWxlcy9pdGVtYWRkL3RlbXBsYXRlcy9JdGVtQWRkU2l0ZUFkbWluLnRwbAkxODY0NDg3NzM4CTk5MDc4MDg4Ngk0NDM3CTQ1NTQK');
expand_a4483450cb($outputDir, 'module.inc', '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');
expand_a4483450cb($outputDir, 'po/GNUmakefile', 'R0FMTEVSWURJUiA/PSAuLi8uLi8uLgpUT09MRElSID89ICQoR0FMTEVSWURJUikvbGliL3Rvb2xzCgppbmNsdWRlICQoVE9PTERJUikvcG8vR05VbWFrZWZpbGUuaW5jCgo=');
expand_a4483450cb($outputDir, 'po/strings.raw', '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');
expand_a4483450cb($outputDir, 'templates/ItemAddFromServer.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.
 *}
<script type="text/javascript">
  // <![CDATA[
{if !empty($form.localServerFiles)}
  var symState = false;
  {* Generate indexes of items that we know, which will correspond to checkbox ids, below *}
  {strip}
  var knownTypeCheckboxIds = new Array(
  {assign var="first" value="1"}
  {foreach name=fileIndex from=$form.localServerFiles item=file}
    {if ( ($file.type == 'file' ||
	   ($file.type == 'directory' && $file.fileName != '..' && $file.fileName != 'CVS')
	  ) && empty($file.unknown))}
      {if !$first},{else}{assign var="first" value="0"}{/if}
      "{$smarty.foreach.fileIndex.iteration}"
    {/if}
  {/foreach}
  );
  {/strip}

  {literal}
  function toggleSelections() {
    for (i = 0; i < knownTypeCheckboxIds.length; i++) {
      var cb = document.getElementById('cb_' + knownTypeCheckboxIds[i]);
      cb.checked = !cb.checked;
  {/literal}
      {if $ItemAddFromServer.showSymlink}toggleSymlinkEnabled(knownTypeCheckboxIds[i]);{/if}
  {literal}
    }
  }

  function toggleSymlinkEnabled(a) {
    var cbSymlink = document.getElementById('symlink_' + a );
    var cbSelected = document.getElementById('cb_' + a );
    if (cbSymlink) {
      cbSymlink.disabled = !cbSelected.checked;
    }
  }

  function invertSymlinkSelection() {
    symState = !symState;
    for (i = 0; i < knownTypeCheckboxIds.length; i++) {
      var cb = document.getElementById('cb_' + knownTypeCheckboxIds[i]);
      var cbSymlink = document.getElementById('symlink_' + knownTypeCheckboxIds[i]);
      if (cb.checked == true) {
	if (symState == false) {
	  cbSymlink.checked = false;
	} else {
	  cbSymlink.checked = true;
	}
      }
    }
  }
  {/literal}
{/if}

  function selectPath(path) {ldelim}
  document.getElementById('itemAdminForm').elements['{g->formVar
    var="form[localServerPath]"}'].value = path;
  {rdelim}
  // ]]>
</script>

<div class="gbBlock">
  <p class="giDescription">
    {g->text text="Transfer files that are already on your server into your Gallery.  The files must already have been uploaded to your server some other way (like FTP) and must be placed in a directory where they are accessibly by any element on the server.  If you're on Unix this means that the files and the directory the files are in should have modes of at least 755."}
  </p>

  {if empty($ItemAddFromServer.localServerDirList)}
  <div class="giWarning">
    {g->text text="For security purposes, you can't use this feature until the Gallery Site Administrator configures a set of legal upload directories."}
    {if $ItemAdd.isAdmin}
      <a href="{g->url arg1="view=core.SiteAdmin" arg2="subView=itemadd.ItemAddSiteAdmin"}">
	{g->text text="site admin"}
      </a>
    {/if}
  </div>
  {else}

  {if empty($form.localServerFiles)}
    <h4> {g->text text="Server Path"} </h4>

    <input type="text" size="80"
     name="{g->formVar var="form[localServerPath]"}" value="{$form.localServerPath}"/>

    {if isset($form.error.pathComponent.missing)}
    <div class="giError">
      {g->text text="You must enter a directory."}
    </div>
    {/if}
    {if isset($form.error.pathComponent.invalid)}
    <div class="giError">
      {g->text text="The directory you entered is invalid.  Make sure that the directory is readable by all users."}
    </div>
    {/if}
    {if isset($form.error.pathComponent.illegal)}
    <div class="giError">
      {g->text text="The directory you entered is illegal.  It must be a sub directory of one of the directories listed below."}
    </div>
    {/if}
    {if isset($form.error.pathComponent.collision)}
    <div class="giError">
      {g->text text="An item with the same name already exists."}
    </div>
    {/if}

    <br/>
    {g->text text="Legal Directories"}

    {if $ItemAdd.isAdmin}
    <a href="{g->url arg1="view=core.SiteAdmin" arg2="subView=itemadd.ItemAddSiteAdmin" arg3="return=true"}">
      {g->text text="modify"}
    </a>
    {/if}

    <ul style="list-style-type: none; margin-bottom: 1em">
      {foreach from=$ItemAddFromServer.localServerDirList item=dir}
	{capture name="escapedDir"}{$dir|escape|replace:"\\":"\\\\"}{/capture}
	<li>
	  <a href="javascript:selectPath('{$smarty.capture.escapedDir}')"> {$dir|escape} </a>
	</li>
      {/foreach}
    </ul>

    {if !empty($ItemAddFromServer.recentPaths)}
      {g->text text="Recent Directories"}

      <ul style="list-style-type: none">
	{foreach from=$ItemAddFromServer.recentPaths item=dir}
	  {capture name="escapedDir"}{$dir|escape|replace:"\\":"\\\\"}{/capture}
	  <li>
	  <a href="javascript:selectPath('{$smarty.capture.escapedDir}')"> {$dir|escape} </a>
	  </li>
	{/foreach}
      </ul>
    {/if}

    {capture name="submitLinks"}
      <input type="submit" class="inputTypeSubmit"
       name="{g->formVar var="form[action][findFilesFromLocalServer]"}"
       value="{g->text text="Find Files"}"/>
    {/capture}
  {else} {* {if empty($form.localServerFiles)} *}

    {capture name="path"}{strip}
      {foreach name="pathElements" from=$ItemAddFromServer.pathElements key=idx item=element}
	{if $idx>1}{$ItemAddFromServer.pathSeparator}{/if}
	{if ($element.legal && !$smarty.foreach.pathElements.last)}
	  <a href="{g->url arg1="controller=core.ItemAdd" arg2="addPlugin=ItemAddFromServer"
	   arg3="form[localServerPath]=`$element.path`" arg4="itemId=`$ItemAdmin.item.id`"
	   arg5="form[action][findFilesFromLocalServer]=1"
	   arg6="form[formName]=ItemAddFromServer"}">{$element.name|escape}</a>
	{else}
	  {$element.name|escape}
	{/if}
      {/foreach}
    {/strip}{/capture}
    <strong>
      {g->text text="Directory: %s" arg1=$smarty.capture.path}
    </strong>

    <input type="hidden"
     name="{g->formVar var="form[localServerPath]"}" value="{$form.localServerPath|escape}"/>
    <br/>

    <table class="gbDataTable"><tr>
      <th> </th>
      <th> {g->text text="File name"} </th>
      <th> {g->text text="Type"} </th>
      <th> {g->text text="Size"} </th>
      {if $ItemAddFromServer.showSymlink}
	<th> {g->text text="Use Symlink"} </th>
      {/if}
    </tr>
    {foreach name=fileIndex from=$form.localServerFiles item=file}
      {assign var=key value=$file.fileKey|escape}
      <tr class="{cycle values="gbEven,gbOdd"}">
      {if ($file.type == 'file')}
	<td style="text-align: center">
	  <input type="checkbox" id="cb_{$smarty.foreach.fileIndex.iteration}"
	   {if $ItemAddFromServer.showSymlink}
	     onclick="toggleSymlinkEnabled('{$smarty.foreach.fileIndex.iteration}')"
	   {/if}
	   name="{g->formVar var="form[localServerFiles][$key][selected]"}"/>
	</td><td>
	  <label for="cb_{$smarty.foreach.fileIndex.iteration}">
	    {$file.fileName|escape}
	  </label>
	</td><td>
	  {$file.itemType}
	</td><td>
	  {g->text one="%d byte" many="%d bytes" count=$file.stat.size arg1=$file.stat.size}
	</td>
	{if $ItemAddFromServer.showSymlink}
	  <td align="center">
	    <input type="checkbox" disabled="true"
	     id="symlink_{$smarty.foreach.fileIndex.iteration}"
	     name="{g->formVar var="form[localServerFiles][$key][useSymlink]"}"/>
	  </td>
	{/if}
      {else}
	<td>
	  <input type="checkbox" id="cb_{$smarty.foreach.fileIndex.iteration}"
	   {if $ItemAddFromServer.showSymlink}
	     onclick="toggleSymlinkEnabled('{$smarty.foreach.fileIndex.iteration}')"
	   {/if}
	   name="{g->formVar var="form[localServerDirectories][$key][selected]"}"
	   {if !$ItemAddFromServer.canAddAlbum}
	     disabled="true"
	   {/if}
	   />
	</td><td>
	  {if $file.legal}{strip}
	    <a href="{g->url arg1="controller=core.ItemAdd" arg2="addPlugin=ItemAddFromServer"
	     arg3="form[localServerPath]=`$file.filePath`" arg4="itemId=`$ItemAdmin.item.id`"
	     arg5="form[action][findFilesFromLocalServer]=1"
	     arg6="form[formName]=ItemAddFromServer"}">
	      {if $file.fileName == ".."}
		&laquo; {g->text text="Parent Directory"} &raquo;
	      {else}
		{$file.fileName|escape}
	      {/if}
	    </a>
	  {/strip}{else}
	    <i>{$file.fileName|escape}</i>
	  {/if}
	</td><td>
	  {g->text text="Directory"}
	</td><td>
	  &nbsp;
	</td>
	{if $ItemAddFromServer.showSymlink}
	<td style="text-align: center">
	  <input type="checkbox" disabled="true"
	   id="symlink_{$smarty.foreach.fileIndex.iteration}"
	   name="{g->formVar var="form[localServerDirectories][$key][useSymlink]"}"/>
	</td>
	{/if}
      {/if}
      </tr>
    {/foreach}
    <tr>
      <th>
	<input type="checkbox" id="cbSelectionToggle" onclick="toggleSelections()"/>
      </th>
      <th colspan="{if $ItemAddFromServer.showSymlink}2{else}3{/if}">
	<label for="cbSelectionToggle">
	  {g->text text="(Un)check all known types"}
	</label>
      </th>
      {if $ItemAddFromServer.showSymlink}
      <th>
	<label for="cbSymlinkToggle">
	  {g->text text="(Un)check symlinks"}<br/>{g->text text="for selected items"}
	</label>
      </th>
      <th style="text-align: center">
	<input type="checkbox" id="cbSymlinkToggle" onclick="invertSymlinkSelection()"/>
      </th>
      {/if}
    </tr></table>
  </div>

  <div class="gbBlock">
    <p class="giDescription">
      {g->text text="Copy base filenames to:"}
      <br/>
      <input type="checkbox" id="cbTitle"{if $form.set.title} checked="checked"{/if}
       name="{g->formVar var="form[set][title]"}"/>
      <label for="cbTitle"> {g->text text="Title"} </label>
      &nbsp;

      <input type="checkbox" id="cbSummary"{if $form.set.summary} checked="checked"{/if}
       name="{g->formVar var="form[set][summary]"}"/>
      <label for="cbSummary"> {g->text text="Summary"} </label>
      &nbsp;

      <input type="checkbox" id="cbDescription"{if $form.set.description} checked="checked"{/if}
       name="{g->formVar var="form[set][description]"}"/>
      <label for="cbDescription"> {g->text text="Description"} </label>
    </p>

    {capture name="submitLinks"}
      <input type="submit" class="inputTypeSubmit"
       name="{g->formVar var="form[action][addFromLocalServer]"}"
       value="{g->text text="Add Files"}"/>
      <input type="submit" class="inputTypeSubmit"
       name="{g->formVar var="form[action][startOver]"}" value="{g->text text="Start Over"}"/>
    {/capture}
    {assign var="showOptions" value="true"}
  {/if} {* {if !empty($form.localServerFiles)} *}
  {/if} {* {if empty($ItemAddFromServer.localServerDirList)} *}
</div>

{if isset($showOptions)}
  {* Include our extra ItemAddOptions *}
  {foreach from=$ItemAdd.options item=option}
    {include file="gallery:`$option.file`" l10Domain=$option.l10Domain}
  {/foreach}
{/if}

{if !empty($smarty.capture.submitLinks)}
<div class="gbBlock gcBackground1">
  {$smarty.capture.submitLinks}
</div>
{/if}
');
expand_a4483450cb($outputDir, 'templates/ItemAddFromWeb.tpl', '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');
expand_a4483450cb($outputDir, 'templates/ItemAddSiteAdmin.tpl', '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');
}
function expand_a4483450cb($outputDir, $relativePath, $data) {
$fd = fopen($outputDir . $relativePath, 'w');
fwrite($fd, base64_decode($data));
fclose($fd);
}
$unpackFunction = "unpack_a4483450cb";
?>

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