{

//Note: values from 1 to 8 are upload errors

const NO_ERROR = 0;

const ILLEGAL_FILE_NAME = 101;

const FILE_NOT_EXIST = 102;

const ILLEGAL_PATH = 103;

const FILE_IN_BLACK_LIST = 104;

const FILE_NOT_IN_WHITE_LIST = 105;

const GENERAL_ERROR = 106;

const FILE_ALREADY_EXISTS = 107;

const DIRECTORY_ALREADY_EXISTS = 108;

const FILE_DELETED = 109;

const ERROR_CREATE_ZIP = 110;

const ERROR_OPEN_ZIP = 111;

const UNKNOWN_COMPRESSION = 112;

const DIRECTORY_NOT_EXIST = 113;

const NOT_LESSON_FILE = 114;

const UNAUTHORIZED_ACTION = 115;

const NOT_APPROPRIATE_TYPE = 116;

const ERROR_ZIP_PROCESSING = 117;

const CANNOT_CREATE_DIR = 118;

const NOT_WRITABLE_ERROR = 119;

const UNKNOWN_ERROR = 199;

const DATABASE_ERROR = 301;

{

/**

public static $mimeTypes = array (

'bmp' => 'image/bmp',

'cgm' => 'image/cgm',

'djv' => 'image/vnd.djvu',

'djvu' => 'image/vnd.djvu',

'flv' => 'application/flv',

'gif' => 'image/gif',

'ico' => 'image/x-icon',

'ief' => 'image/ief',

'jp2' => 'image/jp2',

'jpe' => 'image/jpeg',

'jpeg' => 'image/jpeg',

'jpg' => 'image/jpeg',

'mac' => 'image/x-macpaint',

'pbm' => 'image/x-portable-bitmap',

'pct' => 'image/pict',

'pgm' => 'image/x-portable-graymap',

'pic' => 'image/pict',

'pict' => 'image/pict',

'png' => 'image/png',

'pnm' => 'image/x-portable-anymap',

'pnt' => 'image/x-macpaint',

'pntg' => 'image/x-macpaint',

'ppm' => 'image/x-portable-pixmap',

'qti' => 'image/x-quicktime',

'qtif' => 'image/x-quicktime',

'ras' => 'image/x-cmu-raster',

'rgb' => 'image/x-rgb',

'svg' => 'image/svg+xml',

'tif' => 'image/tiff',

'tiff' => 'image/tiff',

'wbmp' => 'image/vnd.wap.wbmp',

'xbm' => 'image/x-xbitmap',

'xpm' => 'image/x-xpixmap',

'xwd' => 'image/x-xwindowdump',

'asc' => 'text/plain',

'css' => 'text/css',

'etx' => 'text/x-setext',

'htc' => 'text/x-component',

'htm' => 'text/html',

'html' => 'text/html',

'ics' => 'text/calendar',

'ifb' => 'text/calendar',

'rtf' => 'text/rtf',

'rtx' => 'text/richtext',

'sgm' => 'text/sgml',

'sgml' => 'text/sgml',

'tsv' => 'text/tab-separated-values',

'txt' => 'text/plain',

'wml' => 'text/vnd.wap.wml',

'wmls' => 'text/vnd.wap.wmlscript',

'kar' => 'audio/midi',

'm3u' => 'audio/x-mpegurl',

'm4a' => 'audio/mp4a-latm',

'm4b' => 'audio/mp4a-latm',

'm4p' => 'audio/mp4a-latm',

'mid' => 'audio/midi',

'midi' => 'audio/midi',

'mp2' => 'audio/mpeg',

'mp3' => 'audio/mpeg',

'mpga' => 'audio/mpeg',

'ra' => 'audio/x-pn-realaudio',

'ram' => 'audio/x-pn-realaudio',

'snd' => 'audio/basic',

'wav' => 'audio/x-wav',

'aif' => 'audio/x-aiff',

'aifc' => 'audio/x-aiff',

'aiff' => 'audio/x-aiff',

'au' => 'audio/basic',

'avi' => 'video/x-msvideo',

'mov' => 'video/quicktime',

'movie' => 'video/x-sgi-movie',

'mp4' => 'video/mp4',

'mpe' => 'video/mpeg',

'mpeg' => 'video/mpeg',

'mpg' => 'video/mpeg',

'm4u' => 'video/vnd.mpegurl',

'm4v' => 'video/x-m4v',

'dif' => 'video/x-dv',

'dv' => 'video/x-dv',

'mxu' => 'video/vnd.mpegurl',

'qt' => 'video/quicktime',

'wmv' => 'video/x-ms-wmv',

'iges' => 'model/iges',

'igs' => 'model/iges',

'mesh' => 'model/mesh',

'msh' => 'model/mesh',

'silo' => 'model/mesh',

'vrml' => 'model/vrml',

'wrl' => 'model/vrml',

'xyz' => 'chemical/x-xyz',

'pdb' => 'chemical/x-pdb',

'ice' => 'x-conference/x-cooltalk',

'ai' => 'application/postscript',

'atom' => 'application/atom+xml',

'bcpio' => 'application/x-bcpio',

'bin' => 'application/octet-stream',

'cdf' => 'application/x-netcdf',

'class' => 'application/octet-stream',

'cpio' => 'application/x-cpio',

'cpt' => 'application/mac-compactpro',

'csh' => 'application/x-csh',

'csv' => 'application/text',

'dcr' => 'application/x-director',

'dir' => 'application/x-director',

'dll' => 'application/octet-stream',

'dmg' => 'application/octet-stream',

'dms' => 'application/octet-stream',

'doc' => 'application/msword',

'dtd' => 'application/xml-dtd',

'dvi' => 'application/x-dvi',

'dxr' => 'application/x-director',

'eps' => 'application/postscript',

'exe' => 'application/octet-stream',

'ez' => 'application/andrew-inset',

'gram' => 'application/srgs',

'grxml' => 'application/srgs+xml',

'gtar' => 'application/x-gtar',

'hdf' => 'application/x-hdf',

'hqx' => 'application/mac-binhex40',

'jnlp' => 'application/x-java-jnlp-file',

'js' => 'application/x-javascript',

'latex' => 'application/x-latex',

'lha' => 'application/octet-stream',

'lzh' => 'application/octet-stream',

'man' => 'application/x-troff-man',

'mathml' => 'application/mathml+xml',

'me' => 'application/x-troff-me',

'mif' => 'application/vnd.mif',

'ms' => 'application/x-troff-ms',

'nc' => 'application/x-netcdf',

'oda' => 'application/oda',

'ogg' => 'application/ogg',

'pdf' => 'application/pdf',

'pgn' => 'application/x-chess-pgn',

'ppt' => 'application/vnd.ms-powerpoint',

'ps' => 'application/postscript',

'rdf' => 'application/rdf+xml',

'rm' => 'application/vnd.rn-realmedia',

'roff' => 'application/x-troff',

'sh' => 'application/x-sh',

'shar' => 'application/x-shar',

'sit' => 'application/x-stuffit',

'skd' => 'application/x-koan',

'skm' => 'application/x-koan',

'skp' => 'application/x-koan',

'skt' => 'application/x-koan',

'smi' => 'application/smil',

'smil' => 'application/smil',

'so' => 'application/octet-stream',

'spl' => 'application/x-futuresplash',

'src' => 'application/x-wais-source',

'sv4cpio' => 'application/x-sv4cpio',

'sv4crc' => 'application/x-sv4crc',

'swf' => 'application/x-shockwave-flash',

't' => 'application/x-troff',

'tar' => 'application/x-tar',

'tcl' => 'application/x-tcl',

'tex' => 'application/x-tex',

'texi' => 'application/x-texinfo',

'texinfo' => 'application/x-texinfo',

'tr' => 'application/x-troff',

'ustar' => 'application/x-ustar',

'vcd' => 'application/x-cdlink',

'vxml' => 'application/voicexml+xml',

'wbmxl' => 'application/vnd.wap.wbxml',

'wmlc' => 'application/vnd.wap.wmlc',

'wmlsc' => 'application/vnd.wap.wmlscriptc',

'xht' => 'application/xhtml+xml',

'xhtml' => 'application/xhtml+xml',

'xls' => 'application/vnd.ms-excel',

'xml' => 'application/xml',

'xsl' => 'application/xml',

'xslt' => 'application/xslt+xml',

'xul' => 'application/vnd.mozilla.xul+xml',

'zip' => 'application/zip');

/**

function __construct($file) {

if (is_array($file)) { //Instantiate object based on the given array

$file['path'] = EfrontDirectory :: normalize($file['path']);

if (strpos($file['path'], G_ROOTPATH) === false) {

$file['path'] = G_ROOTPATH.$file['path'];

}

$fileArray = $file;

} else {

if (eF_checkParameter($file, 'id')) { //Instantiate object based on id

$result = eF_getTableData("files", "*", "id=".$file, "id");

} elseif (eF_checkParameter($file, 'path')) { //id-based instantiation failed; Check if the full path is specified

$file = EfrontDirectory :: normalize($file);

$result = eF_getTableData("files", "*", "path='".str_replace(G_ROOTPATH, '', eF_addSlashes(EfrontDirectory :: normalize($file)))."'", "id"); //eF_addSlashes for files containing '

} else {

throw new EfrontFileException(_ILLEGALPATH.': '.$file, EfrontFileException :: ILLEGAL_PATH);

}

if (sizeof($result) > 0) {

if (sizeof($result) > 1) { //if for some reason there is more than 1 database entries for the same file, keep only the latest (based on id)

for ($i = 0; $i < sizeof($result) - 1; $i++) {

eF_deleteTableData("files", "id=".$result[$i]['id']);

EfrontSearch :: removeText('files', $result[$i]['id'], 'data');

//unlink($result[$i]['file']);

}

$fileArray = $result[$i];

} else {

$fileArray = $result[0];

}

$fileArray['path'] = G_ROOTPATH.$fileArray['path'];

} else {

if (is_file($file) && strpos($file, G_ROOTPATH) !== false) { //Create object without database information

$fileArray = array('id' => -1, //Set 'id' to -1, meaning this file has not a database representation

'path' => $file);

} else if (strpos($file, G_ROOTPATH) === false) {

throw new EfrontFileException(_ILLEGALPATH.': '.$file, EfrontFileException :: ILLEGAL_PATH);

} else {

throw new EfrontFileException(_FILEDOESNOTEXIST.': '.$file, EfrontFileException :: FILE_NOT_EXIST);

}

}

}

//Append extra useful (derived) information to the array: name, extension, size, mime type

$fileArray['name'] = EfrontFile :: decode(basename($fileArray['path']));

$fileArray['directory'] = dirname($fileArray['path']);

$fileArray['extension'] = pathinfo($fileArray['path'], PATHINFO_EXTENSION);

$fileArray['size'] = round(filesize($fileArray['path'])/1024, 2);

$fileArray['timestamp'] = filemtime($fileArray['path']);

$fileArray['type'] = 'file';

$fileArray['physical_name'] = basename($fileArray['path']);

foreach ($pathParts = explode("/", $fileArray['path']) as $key => $value) {

$pathParts[$key] = urlencode($value);

}

$fileArray['url_path'] = implode("/", $pathParts);

//$fileArray['original_name'] != $fileArray['physical_name'] ? $fileArray['renamed'] = true : $fileArray['renamed'] = false; //If the physical file name is different than the original name, it means that the file is renamed

isset(EfrontFile :: $mimeTypes[strtolower($fileArray['extension'])]) ? $fileArray['mime_type'] = EfrontFile :: $mimeTypes[strtolower($fileArray['extension'])] : $fileArray['mime_type'] = 'application/'.$fileArray['extension'];

parent :: __construct($fileArray); //Create an ArrayObject from the given array

if (!is_file($this['path'])) { //If the file does not actually exist, then delete it from database and issue exception

if ($this['id'] != -1) {

eF_deleteTableData("files", "id=".$this['id']);

EfrontSearch :: removeText('files', $this['id'], 'data');

}

throw new EfrontFileException(_FILEDOESNOTEXIST.': '.$this['path'], EfrontFileException :: FILE_DELETED);

} elseif ( strpos($this['path'], G_ROOTPATH) === false ) {

throw new EfrontFileException(_ILLEGALPATH.': '.$this['path'], EfrontFileException :: ILLEGAL_PATH); //The file must be inside root path, otherwise it is illegal

}

}

/**

public function delete() {

if (is_file($this['path']) && !unlink($this['path'])) { //If the file exists but could not be deleted, throw an exception. This way, even files that their equivalent physical file does not exist, may be deleted.

throw new EfrontFileException(_CANNOTDELETEFILE, EfrontFileException :: GENERAL_ERROR);

}

if ($this['id'] != -1) {

eF_deleteTableData("files", "path = '".str_replace(G_ROOTPATH, '', eF_addSlashes($this['path']))."' or id=".$this['id']); //Delete database representation of the file

EfrontSearch :: removeText('files', $this['id'], 'data');

}

return true;

}

/**

public function copy($destinationPath, $overwrite = true) {

$destinationPath = EfrontDirectory :: normalize($destinationPath);

$parentDirectory = new EfrontDirectory(dirname($destinationPath)); //This way we check integrity of destination

if (is_dir($destinationPath)) { //If $destinationPath is a directory, it means that the target file name was not specified, so append the current

$destinationPath = $destinationPath.'/'.$this['physical_name'];

}

if (!$overwrite && is_file($destinationPath)) {

throw new EfrontFileException(_CANNOTCOPYFILE.': '.$destinationPath.', '._FILEALREADYEXISTS, EfrontFileException :: FILE_ALREADY_EXISTS);//Use plain Exception rather than EfrontFileException, since the latter is caught right from the following catch block

}

if (copy($this['path'], $destinationPath)) {

if ($this['id'] != -1) {

$fields = array("path" => str_replace(G_ROOTPATH, '', $destinationPath), //Database entry for copied file

"users_LOGIN" => isset($_SESSION['s_login']) ? $_SESSION['s_login'] : $this['users_LOGIN'],

"timestamp" => time(),

"description" => $this['description'],

"groups_ID" => $this['groups_ID'],

"access" => $this['access'],

"metadata" => $this['metadata']);

$fileId = eF_insertTableData("files", $fields);

if ($fileId) {

$fileMetadataArray = unserialize($this['metadata']);

foreach ($fileMetadataArray as $key => $value) {

EfrontSearch :: insertText($value, $fileId, "files", "data");

}

}

}

$file = new EfrontFile($destinationPath);

return $file;

} else {

//eF_deleteTableData("files", "id=$fileid"); //If copy failed, delete empty table entry

throw new EfrontFileException(_CANNOTCOPYFILE, EfrontFileException :: UNKNOWN_ERROR);

}

}

/**

public function rename($destinationPath, $overwrite = false) {

if (eF_checkParameter($destinationPath, 'path') === false) {

throw new EfrontFileException(_ILLEGALFILENAME, EfrontFileException :: ILLEGAL_FILE_NAME);

}

$destinationPath = EfrontDirectory :: normalize($destinationPath);

$parentDirectory = new EfrontDirectory(dirname($destinationPath)); //This way we check integrity of destination

FileSystemTree::checkFile($destinationPath);

if (!$overwrite && (is_file($destinationPath))) {

throw new EfrontFileException(_CANNOTMOVEFILE.': '.$this['name'].', '._FILEALREADYEXISTS, EfrontFileException :: FILE_ALREADY_EXISTS);//Use plain Exception rather than EfrontFileException, since the latter is caught right from the following catch block

}

if ($this['path'] != $destinationPath) {

if (copy($this['path'], $destinationPath)) { //rename() acts as a move() function as well

unlink($this['path']);

$this['path'] = $destinationPath;

if ($this['id'] != -1) {

$this -> persist();

}

$this -> refresh();

} else {

throw new EfrontFileException(_CANNOTMOVEFILE, EfrontFileException :: UNKNOWN_ERROR);

}

}

}

/**

public function persist() {

$fields = array('path' => str_replace(G_ROOTPATH, '', $this['path']),

'description' => $this['description'],

'groups_ID' => $this['groups_ID'],

'access' => $this['access'],

'shared' => $this['shared'],

'metadata' => $this['metadata']);

$ok = eF_updateTableData("files", $fields, "id=".$this['id']);

EfrontSearch :: removeText('files', $this['id'], 'data');

$fileMetadataArray = unserialize($this['metadata']);

foreach ($fileMetadataArray as $key => $value) {

EfrontSearch :: insertText($value, $this['id'], "files", "data");

}

return $ok;

}

/**

public function refresh() {

if ($this['id'] != -1) {

$result = eF_getTableData("files", "*", "id=".$this['id']);

$this['path'] = G_ROOTPATH.$result[0]['path'];

$this['description'] = $result[0]['description'];

$this['groups_ID'] = $result[0]['groups_ID'];

$this['access'] = $result[0]['access'];

$this['shared'] = $result[0]['shared'];

$this['metadata'] = $result[0]['metadata'];

}

$this['name'] = EfrontFile :: decode(basename($this['path']));

$this['directory'] = dirname($this['path']);

$this['extension'] = pathinfo($this['path'], PATHINFO_EXTENSION);

$this['size'] = round(filesize($this['path'])/1024, 2);

$this['timestamp'] = filemtime($this['path']);

$this['type'] = 'file';

$this['physical_name'] = basename($this['path']);

foreach ($pathParts = explode("/", $this['path']) as $key => $value) {

$pathParts[$key] = urlencode($value);

}

$this['url_path'] = implode("/", $pathParts);

}

/**

public function compress($zipName = false, $decode = false) {

if (!$zipName) {

$zipName = $this['path'].'.zip';

} else {

$zipName = $this['directory'].'/'.(EfrontFile :: encode(basename($zipName)));

}

try { //This way we delete the file, if it already exists

$file = new EfrontFile($zipName);

$file -> delete();

} catch (Exception $e) {}

if ($GLOBALS['configuration']['zip_method'] == 'system') {

$dir = getcwd();

chdir($this['directory']);

$response = exec('zip -r "'.$zipName.'" '.$this['name'].' 2>&1', $output, $code);

chdir($dir);

if ($code != 0) {

throw new EfrontFileException(_COMMANDFAILEDWITHOUTPUT.': '.$response.". "._PERHAPSDONTSUPPORTZIP, EfrontFileException :: ERROR_ZIP_PROCESSING);

}

return new EfrontFile($zipName);

} else {

$zip = new ZipArchive;

if ($zip -> open($zipName, ZIPARCHIVE::CREATE ) === true) {

if ($decode) {

$zip -> addFile($this['path'], EfrontFile :: decode($this['name']));

} else {

$zip -> addFile($this['path'], $this['name']);

}

$zip -> close();

return new EfrontFile($zipName);

} else {

throw new EfrontFileException(_CANNOTOPENCOMPRESSEDFILE.': '.$this['path'], EfrontFileException :: ERROR_OPEN_ZIP);

}

}

}

/**

public function uncompress($addDB = true) {

if ($this['extension'] == 'zip') {

if ($GLOBALS['configuration']['zip_method'] == 'system') {

$blackList = explode(",", $GLOBALS['configuration']['file_black_list']);

$blackList[] = 'php';

$blackList[] = 'htaccess';

$blackList = '-x "*.'.implode('" "*.', $blackList).'"';

if ($GLOBALS['configuration']['file_white_list']) {

$whiteList = '"*.'.implode('" "*.', explode(",", $GLOBALS['configuration']['file_white_list'])).'"';

} else {

$whiteList = '';

}

if (defined("NO_CHECK_FILE_INTEGRITY") && NO_CHECK_FILE_INTEGRITY) {

$blackList = $whiteList = '';

}

$response = exec('unzip -qqο "'.$this['path'].'" '.$whiteList.' '.$blackList.' -d "'.$this['directory'].'" 2>&1', $output, $code);

if (stripos($response, 'caution') === false && stripos($response, 'warning') === false && $code != 0) {

throw new EfrontFileException(_COMMANDFAILEDWITHOUTPUT.': '.$response.". "._PERHAPSDONTSUPPORTZIP, EfrontFileException :: ERROR_ZIP_PROCESSING);

}

} else {

$zip = new ZipArchive;

if ($zip -> open($this['path']) === true && $zip -> extractTo($this['directory'])) {

for ($i = 0; $i < $zip -> numFiles; $i++) {

$file = $this['directory'].'/'.$zip -> getNameIndex($i);

try { //If the file is not allowed, then append to its extension '.ext'

FileSystemTree::checkFile($file);

} catch (EfrontFileException $e) {

$fileObj = new EfrontFile($file);

$fileObj -> rename($this['directory'].'/'.$zip -> getNameIndex($i).'.ext', true);

$file = $fileObj['path'];

}

$zipFiles[] = $file;

}

if ($this['id'] != -1 && $addDB) {

$importedFiles = FileSystemTree :: importFiles($zipFiles, $options);

return $importedFiles;

} else {

return $zipFiles;

}

} else {

throw new EfrontFileException(_CANNOTOPENCOMPRESSEDFILE.': '.$this['path'], EfrontFileException :: ERROR_OPEN_ZIP);

}

}

}

}

/**

public function listContents() {

if ($this['extension'] == 'zip') {

$zipFiles = array();

if ($GLOBALS['configuration']['zip_method'] == 'system') {

//@todo: Implement for system calls as well

$tempfile = tempnam(dirname($this['path']), time());

$response = exec('unzip -qql "'.$this['path'].'" | awk \'{print $4}\' > "'.$tempfile.'" 2>&1', $output, $code);

if ($code != 0) {

throw new EfrontFileException(_COMMANDFAILEDWITHOUTPUT.': '.$response.". "._PERHAPSDONTSUPPORTZIP, EfrontFileException :: ERROR_ZIP_PROCESSING);

}

foreach (file($tempfile) as $value) {

$zipFiles[] = trim($value);

}

unlink($tempfile);

return $zipFiles;

} else {

$zip = new ZipArchive;

if ($zip -> open($this['path'])) {

for ($i = 0; $i < $zip -> numFiles; $i++) {

$zipFiles[] = $zip -> getNameIndex($i);

}

return $zipFiles;

} else {

throw new EfrontFileException(_CANNOTOPENCOMPRESSEDFILE.': '.$this['path'], EfrontFileException :: ERROR_OPEN_ZIP);

}

}

} else {

throw new EFrontFileException(_UNSUPPORTEDFILETYPE.': '.$this['extension'], EfrontFileException :: UNKNOWN_COMPRESSION);

}

}

/**

public function getTypeImage() {

if (is_file(G_DEFAULTIMAGESPATH.'file_types/'.$this['extension'].'.png') || is_file(G_IMAGESPATH.'file_types/'.$this['extension'].'.png')) {

$image = 'images/file_types/'.$this['extension'].'.png';

} else {

$image = 'images/file_types/unknown.png';

}

return $image;

}

/**

public function share($lessonId = false) {

if (!$lessonId) {

$result = eF_getTableData("lessons", "share_folder", "id=".$_SESSION['s_lessons_ID']);

$lessonId = !$result[0]['share_folder'] ? $_SESSION['s_lessons_ID'] : $result[0]['share_folder'];

}

if ($lessonId) {

if ($this['id'] == -1) { //If the file does not have a database representation, create one for it

$newList = FileSystemTree :: importFiles($this['path']);

$this['id'] = key($newList);

$this -> refresh();

}

$this['shared'] = $lessonId;

$this -> persist();

} else {

throw new EfrontFileException(_CANNOTSHAREFILE.': '.$this['path'], EfrontFileException :: NOT_LESSON_FILE);

}

}

/**

public function unshare() {

$this['shared'] = 0;

$this -> persist();

}

/**

public function toHTMLTooltipLink($link, $preview = true, $tableId = 'filesTable') {

$classes[] = 'info'; //This array holds the link css classes

if (!$link) {

$link = 'javascript:void(0)';

$classes[] = 'inactiveLink';

}

$tooltipString =

<a href = "'.$link.'" class = "'.implode(" ", $classes).'" style = "vertical-align:middle;" '.($preview ? 'onclick = "eF_js_showDivPopup(event, \''._PREVIEW.'\', 2, \'preview_table_'.$tableId.'\')" target = "PREVIEW_FRAME"' : '').'>

'.$this -> offsetGet('name').

<span class = "tooltipSpan">';

foreach ($this as $key => $value) {

if ($value) {

switch ($key) {

//case 'path' : $tooltipString .= '<div style = "white-space:nowrap"><strong>'._PHYSICALNAME."</strong>: ".basename($value)."<br/></div>"; break;

case 'users_LOGIN' : $tooltipString .= '<strong>'._USER."</strong>: $value<br/>"; break;

case 'timestamp' : $tooltipString .= '<strong>'._LASTMODIFIED."</strong>: ".formatTimestamp($value, 'time_nosec')."<br/>"; break;

//case 'shared' : $tooltipString .= '<strong>'._SHARED."</strong>: $value<br/>"; break;

case 'mime_type' : $tooltipString .= '<strong>'._MIMETYPE."</strong>: $value<br/>"; break;

default: break;

}

}

}

$tooltipString .= '</span></a>';

return $tooltipString;

}

/**

public static function encode($name) {

$newName = $name;

if ($GLOBALS['configuration']['file_encoding']) {

if (in_array($GLOBALS['configuration']['file_encoding'], mb_list_encodings())) {

$newName = mb_convert_encoding($name, $GLOBALS['configuration']['file_encoding'], "UTF-8");

} else {

$newName = mb_convert_encoding($name, "UTF7-IMAP", "UTF-8");

}

}

return $newName;

}

/**

public static function decode($name) {

$newName = $name;

if ($GLOBALS['configuration']['file_encoding']) {

if (in_array($GLOBALS['configuration']['file_encoding'], mb_list_encodings())) {

$newName = mb_convert_encoding($name, "UTF-8", $GLOBALS['configuration']['file_encoding']);

} else {

$newName = mb_convert_encoding($name, "UTF-8", "UTF7-IMAP");

}

}

return $newName;

}

/**

public function sendFile($attachment = false) {

session_write_close(); //to allow the browser proceeding to other pages as well

if ($attachment) {

$browser = detectBrowser();

//because of #834

if ($browser != 'firefox') {

$this['name'] = urlencode(str_replace(" ", "_", $this['name']));

} else {

$this['name'] = str_replace(" ", "_", $this['name']);

}

header("Content-Description: File Transfer");

header("Content-Type: application/octet-stream");

header('Content-Disposition: attachment; filename="'.$this['name'].'"');

header("Content-Transfer-Encoding: binary");

header('Expires: 0');

header('Cache-Control: must-revalidate, post-check=0, pre-check=0');

header('Pragma: public');

header("Content-Type: application/force-download");

header("Content-Type: application/download");

if (defined('NO_OUTPUT_BUFFERING') || !$GLOBALS['configuration']['gz_handler']) {

//This does not cooperate well with gzhandler

header("Content-Length: ".filesize($this['path']));

}

} else {

header("Content-Description: File Transfer");

header("Content-Type: {$this['mime_type']}");

header('Content-Disposition: inline; filename="'.$this['name'].'"');

header("Content-Transfer-Encoding: binary");

header('Expires: 0');

header('Cache-Control: must-revalidate, post-check=0, pre-check=0');

header('Pragma: public');

}

$this -> readfileChunked($this['path']);

exit;

}

/**

private function readfileChunked($filename,$retbytes=true) {

$chunksize = 1*(1024*1024); // how many bytes per chunk

$buffer = '';

$cnt =0;

// $handle = fopen($filename, 'rb');

$handle = fopen($filename, 'rb');

if ($handle === false) {

return false;

}

while (!feof($handle)) {

$buffer = fread($handle, $chunksize);

echo $buffer;

ob_flush();

flush();

if ($retbytes) {

$cnt += strlen($buffer);

}

}

$status = fclose($handle);

if ($retbytes && $status) {

return $cnt; // return num. bytes delivered like readfile() does.

}

return $status;

}

{

/**