PHP AJXP_Node::getUrl方法代码示例

 /**
  * @param AJXP_Node $ajxpNode
  * @return null|string
  */
 protected function extractIndexableContent($ajxpNode)
 {
     $ext = strtolower(pathinfo($ajxpNode->getLabel(), PATHINFO_EXTENSION));
     if (in_array($ext, explode(",", $this->getFilteredOption("PARSE_CONTENT_TXT")))) {
         return file_get_contents($ajxpNode->getUrl());
     }
     $unoconv = $this->getFilteredOption("UNOCONV");
     $pipe = false;
     if (!empty($unoconv) && in_array($ext, array("doc", "odt", "xls", "ods"))) {
         $targetExt = "txt";
         if (in_array($ext, array("xls", "ods"))) {
             $targetExt = "csv";
         } else {
             if (in_array($ext, array("odp", "ppt"))) {
                 $targetExt = "pdf";
                 $pipe = true;
             }
         }
         $realFile = call_user_func(array($ajxpNode->wrapperClassName, "getRealFSReference"), $ajxpNode->getUrl());
         $unoconv = "HOME=" . AJXP_Utils::getAjxpTmpDir() . " " . $unoconv . " --stdout -f {$targetExt} " . escapeshellarg($realFile);
         if ($pipe) {
             $newTarget = str_replace(".{$ext}", ".pdf", $realFile);
             $unoconv .= " > {$newTarget}";
             register_shutdown_function("unlink", $newTarget);
         }
         $output = array();
         exec($unoconv, $output, $return);
         if (!$pipe) {
             $out = implode("\n", $output);
             $enc = 'ISO-8859-1';
             $asciiString = iconv($enc, 'ASCII//TRANSLIT//IGNORE', $out);
             return $asciiString;
         } else {
             $ext = "pdf";
         }
     }
     $pdftotext = $this->getFilteredOption("PDFTOTEXT");
     if (!empty($pdftotext) && in_array($ext, array("pdf"))) {
         $realFile = call_user_func(array($ajxpNode->wrapperClassName, "getRealFSReference"), $ajxpNode->getUrl());
         if ($pipe && isset($newTarget) && is_file($newTarget)) {
             $realFile = $newTarget;
         }
         $cmd = $pdftotext . " " . escapeshellarg($realFile) . " -";
         $output = array();
         exec($cmd, $output, $return);
         $out = implode("\n", $output);
         $enc = 'UTF8';
         $asciiString = iconv($enc, 'ASCII//TRANSLIT//IGNORE', $out);
         return $asciiString;
     }
     return null;
 }

 /**
  * @param AJXP_Node $node
  * @param string $cacheType
  * @param string $details
  * @return string
  */
 public static function computeIdForNode($node, $cacheType, $details = '')
 {
     $repo = $node->getRepository();
     if ($repo == null) {
         return "failed-id";
     }
     $scope = $repo->securityScope();
     $additional = "";
     if ($scope === "USER") {
         $additional = AuthService::getLoggedUser()->getId() . "@";
     } else {
         if ($scope == "GROUP") {
             $additional = ltrim(str_replace("/", "__", AuthService::getLoggedUser()->getGroupPath()), "__") . "@";
         }
     }
     $scheme = parse_url($node->getUrl(), PHP_URL_SCHEME);
     return str_replace($scheme . "://", $cacheType . "://" . $additional, $node->getUrl()) . ($details ? "##" . $details : "");
 }

 /**
  * 
  * @param AJXP_Node $ajxpNode
  */
 public function extractMeta(&$ajxpNode, $contextNode = false, $details = false)
 {
     $currentFile = $ajxpNode->getUrl();
     $metadata = $this->metaStore->retrieveMetadata($ajxpNode, "users_meta", false, AJXP_METADATA_SCOPE_GLOBAL);
     if (count($metadata)) {
         // @todo : Should be UTF8-IZED at output only !!??
         // array_map(array("SystemTextEncoding", "toUTF8"), $metadata);
     }
     $metadata["meta_fields"] = $this->options["meta_fields"];
     $metadata["meta_labels"] = $this->options["meta_labels"];
     $ajxpNode->mergeMetadata($metadata);
 }

 /**
  * @param AJXP_Node $ajxpNode
  */
 public function videoAlternateVersions(&$ajxpNode)
 {
     if (!preg_match('/\\.mpg$|\\.mp4$|\\.ogv$|\\.webm$/i', $ajxpNode->getLabel())) {
         return;
     }
     if (file_exists(str_replace(".mpg", "_PREVIEW.mp4", $ajxpNode->getUrl()))) {
         $ajxpNode->mergeMetadata(array("video_altversion_mp4" => str_replace(".mpg", "_PREVIEW.mp4", $ajxpNode->getPath())));
     }
     $rotating = array("mp4", "ogv", "webm");
     foreach ($rotating as $ext) {
         if (preg_match('/\\.' . $ext . '$/i', $ajxpNode->getLabel())) {
             foreach ($rotating as $other) {
                 if ($other == $ext) {
                     continue;
                 }
                 if (file_exists(str_replace($ext, $other, $ajxpNode->getUrl()))) {
                     $ajxpNode->mergeMetadata(array("video_altversion_" . $other => str_replace($ext, $other, $ajxpNode->getPath())));
                 }
             }
         }
     }
 }

 /**
  * @param AJXP_Node $ajxpNode
  */
 public function detectDLParts(&$ajxpNode)
 {
     if (!preg_match("/\\.dlpart\$/i", $ajxpNode->getUrl())) {
         return;
     }
     $basename = basename($ajxpNode->getUrl());
     $newName = "__" . str_replace(".dlpart", ".ser", $basename);
     $hidFile = str_replace($basename, $newName, $ajxpNode->getUrl());
     if (is_file($hidFile)) {
         $data = unserialize(file_get_contents($hidFile));
         if ($data["totalSize"] != -1) {
             $ajxpNode->target_bytesize = $data["totalSize"];
             $ajxpNode->target_filesize = AJXP_Utils::roundSize($data["totalSize"]);
             $ajxpNode->process_stoppable = isset($data["pid"]) ? "true" : "false";
         }
     }
 }

 public function switchAction($action, $httpVars, $filesVars)
 {
     $repository = ConfService::getRepository();
     if (!$repository->detectStreamWrapper(true)) {
         return false;
     }
     $selection = new UserSelection($repository, $httpVars);
     $selectedNode = $selection->getUniqueNode();
     $selectedNodeUrl = $selectedNode->getUrl();
     if ($action == "post_to_server") {
         // Backward compat
         if (strpos($httpVars["file"], "base64encoded:") !== 0) {
             $legacyFilePath = AJXP_Utils::decodeSecureMagic(base64_decode($httpVars["file"]));
             $selectedNode = new AJXP_Node($selection->currentBaseUrl() . $legacyFilePath);
             $selectedNodeUrl = $selectedNode->getUrl();
         }
         $target = rtrim(base64_decode($httpVars["parent_url"]), '/') . "/plugins/editor.pixlr";
         $tmp = AJXP_MetaStreamWrapper::getRealFSReference($selectedNodeUrl);
         $tmp = SystemTextEncoding::fromUTF8($tmp);
         $this->logInfo('Preview', 'Sending content of ' . $selectedNodeUrl . ' to Pixlr server.', array("files" => $selectedNodeUrl));
         AJXP_Controller::applyHook("node.read", array($selectedNode));
         $saveTarget = $target . "/fake_save_pixlr.php";
         if ($this->getFilteredOption("CHECK_SECURITY_TOKEN", $repository->getId())) {
             $saveTarget = $target . "/fake_save_pixlr_" . md5($httpVars["secure_token"]) . ".php";
         }
         $params = array("referrer" => "Pydio", "method" => "get", "loc" => ConfService::getLanguage(), "target" => $saveTarget, "exit" => $target . "/fake_close_pixlr.php", "title" => urlencode(basename($selectedNodeUrl)), "locktarget" => "false", "locktitle" => "true", "locktype" => "source");
         require_once AJXP_BIN_FOLDER . "/http_class/http_class.php";
         $arguments = array();
         $httpClient = new http_class();
         $httpClient->request_method = "POST";
         $httpClient->GetRequestArguments("https://pixlr.com/editor/", $arguments);
         $arguments["PostValues"] = $params;
         $arguments["PostFiles"] = array("image" => array("FileName" => $tmp, "Content-Type" => "automatic/name"));
         $err = $httpClient->Open($arguments);
         if (empty($err)) {
             $err = $httpClient->SendRequest($arguments);
             if (empty($err)) {
                 $response = "";
                 while (true) {
                     $header = array();
                     $error = $httpClient->ReadReplyHeaders($header, 1000);
                     if ($error != "" || $header != null) {
                         break;
                     }
                     $response .= $header;
                 }
             }
         }
         header("Location: {$header['location']}");
         //$response");
     } else {
         if ($action == "retrieve_pixlr_image") {
             $file = AJXP_Utils::decodeSecureMagic($httpVars["original_file"]);
             $selectedNode = new AJXP_Node($selection->currentBaseUrl() . $file);
             $selectedNode->loadNodeInfo();
             $this->logInfo('Edit', 'Retrieving content of ' . $file . ' from Pixlr server.', array("files" => $file));
             AJXP_Controller::applyHook("node.before_change", array(&$selectedNode));
             $url = $httpVars["new_url"];
             $urlParts = parse_url($url);
             $query = $urlParts["query"];
             if ($this->getFilteredOption("CHECK_SECURITY_TOKEN", $repository->getId())) {
                 $scriptName = basename($urlParts["path"]);
                 $token = str_replace(array("fake_save_pixlr_", ".php"), "", $scriptName);
                 if ($token != md5($httpVars["secure_token"])) {
                     throw new AJXP_Exception("Invalid Token, this could mean some security problem!");
                 }
             }
             $params = array();
             parse_str($query, $params);
             $image = $params['image'];
             $headers = get_headers($image, 1);
             $content_type = explode("/", $headers['Content-Type']);
             if ($content_type[0] != "image") {
                 throw new AJXP_Exception("Invalid File Type");
             }
             $content_length = intval($headers["Content-Length"]);
             if ($content_length != 0) {
                 AJXP_Controller::applyHook("node.before_change", array(&$selectedNode, $content_length));
             }
             $orig = fopen($image, "r");
             $target = fopen($selectedNode->getUrl(), "w");
             if (is_resource($orig) && is_resource($target)) {
                 while (!feof($orig)) {
                     fwrite($target, fread($orig, 4096));
                 }
                 fclose($orig);
                 fclose($target);
             }
             clearstatcache(true, $selectedNode->getUrl());
             $selectedNode->loadNodeInfo(true);
             AJXP_Controller::applyHook("node.change", array(&$selectedNode, &$selectedNode));
         }
     }
 }

 /**
  * @param AJXP_Node $ajxpNode
  */
 public function extractMeta(&$ajxpNode)
 {
     $currentFile = $ajxpNode->getUrl();
     if (!$ajxpNode->isLeaf() || preg_match("/\\.zip\\//", $currentFile)) {
         return;
     }
     if (!preg_match("/\\.jpg\$|\\.jpeg\$|\\.tif\$|\\.tiff\$/i", $currentFile)) {
         return;
     }
     $definitions = $this->getMetaDefinition();
     if (!count($definitions)) {
         return;
     }
     if (!function_exists("exif_read_data")) {
         return;
     }
     //if(!exif_imagetype($currentFile)) return ;
     $realFile = $ajxpNode->getRealFile();
     $exif = @exif_read_data($realFile, 0, TRUE);
     $iptc = $this->extractIPTC($realFile);
     if ($exif === false) {
         return;
     }
     $additionalMeta = array();
     foreach ($definitions as $def => $label) {
         list($exifSection, $exifName) = explode("-", $def);
         if ($exifSection == "COMPUTED_GPS" && !isset($exif["COMPUTED_GPS"])) {
             $exif['COMPUTED_GPS'] = $this->convertGPSData($exif);
         }
         if (isset($exif[$exifSection]) && isset($exif[$exifSection][$exifName])) {
             $additionalMeta[$def] = $exif[$exifSection][$exifName];
         }
         if ($exifSection == "IPTC" && isset($iptc[$exifName])) {
             $additionalMeta[$def] = $iptc[$exifName];
         }
     }
     $ajxpNode->mergeMetadata($additionalMeta);
 }

 /**
  *
  * @param AJXP_Node $ajxpNode
  */
 public function enrichMetadata(&$ajxpNode)
 {
     $currentNode = $ajxpNode->getUrl();
     $metadata = $ajxpNode->metadata;
     $parsed = parse_url($currentNode);
     if (isset($parsed["fragment"]) && strpos($parsed["fragment"], "attachments") === 0) {
         list(, $attachmentId) = explode("/", $parsed["fragment"]);
         $meta = imapAccessWrapper::getCurrentAttachmentsMetadata();
         if ($meta != null) {
             foreach ($meta as $attach) {
                 if ($attach["x-attachment-id"] == $attachmentId) {
                     $metadata["text"] = $attach["filename"];
                     $metadata["icon"] = AJXP_Utils::mimetype($attach["filename"], "image", false);
                     $metadata["mimestring"] = AJXP_Utils::mimetype($attach["filename"], "text", false);
                 }
             }
         }
     }
     if (!$metadata["is_file"] && $currentNode != "") {
         $metadata["icon"] = "imap_images/ICON_SIZE/mail_folder_sent.png";
     }
     if (basename($currentNode) == "INBOX") {
         $metadata["text"] = "Incoming Mails";
     }
     if (strstr($currentNode, "__delim__") !== false) {
         $parts = explode("/", $currentNode);
         $metadata["text"] = str_replace("__delim__", "/", array_pop($parts));
     }
     $ajxpNode->metadata = $metadata;
 }

 /**
  *
  * @param AJXP_Node $node
  * @param int $depth
  * @throws Exception
  */
 public function recursiveIndexation($node, $depth = 0)
 {
     $repository = $node->getRepository();
     $user = $node->getUser();
     $messages = ConfService::getMessages();
     if ($user == null && AuthService::usersEnabled()) {
         $user = AuthService::getLoggedUser();
     }
     if ($depth == 0) {
         $this->logDebug("Starting indexation - node.index.recursive.start  - " . memory_get_usage(true) . "  - " . $node->getUrl());
         $this->setIndexStatus("RUNNING", str_replace("%s", $node->getPath(), $messages["core.index.8"]), $repository, $user);
         AJXP_Controller::applyHook("node.index.recursive.start", array($node));
     } else {
         if ($this->isInterruptRequired($repository, $user)) {
             $this->logDebug("Interrupting indexation! - node.index.recursive.end - " . $node->getUrl());
             AJXP_Controller::applyHook("node.index.recursive.end", array($node));
             $this->releaseStatus($repository, $user);
             throw new Exception("User interrupted");
         }
     }
     if (!ConfService::currentContextIsCommandLine()) {
         @set_time_limit(120);
     }
     $url = $node->getUrl();
     $this->logDebug("Indexing Node parent node " . $url);
     $this->setIndexStatus("RUNNING", str_replace("%s", $node->getPath(), $messages["core.index.8"]), $repository, $user);
     try {
         AJXP_Controller::applyHook("node.index", array($node));
     } catch (Exception $e) {
         $this->logDebug("Error Indexing Node " . $url . " (" . $e->getMessage() . ")");
     }
     $handle = opendir($url);
     if ($handle !== false) {
         while (($child = readdir($handle)) != false) {
             if ($child[0] == ".") {
                 continue;
             }
             $childNode = new AJXP_Node(rtrim($url, "/") . "/" . $child);
             $childUrl = $childNode->getUrl();
             if (is_dir($childUrl)) {
                 $this->logDebug("Entering recursive indexation for " . $childUrl);
                 $this->recursiveIndexation($childNode, $depth + 1);
             } else {
                 try {
                     $this->logDebug("Indexing Node " . $childUrl);
                     AJXP_Controller::applyHook("node.index", array($childNode));
                 } catch (Exception $e) {
                     $this->logDebug("Error Indexing Node " . $childUrl . " (" . $e->getMessage() . ")");
                 }
             }
         }
         closedir($handle);
     } else {
         $this->logDebug("Cannot open {$url}!!");
     }
     if ($depth == 0) {
         $this->logDebug("End indexation - node.index.recursive.end - " . memory_get_usage(true) . "  -  " . $node->getUrl());
         $this->setIndexStatus("RUNNING", "Indexation finished, cleaning...", $repository, $user);
         AJXP_Controller::applyHook("node.index.recursive.end", array($node));
         $this->releaseStatus($repository, $user);
         $this->logDebug("End indexation - After node.index.recursive.end - " . memory_get_usage(true) . "  -  " . $node->getUrl());
     }
 }

 /**
  * @param  Zend_Search_Lucene_Interface $index
  * @param AJXP_Node $ajxpNode
  * @return Number
  */
 public function getIndexedDocumentId($index, $ajxpNode)
 {
     $term = new Zend_Search_Lucene_Index_Term(SystemTextEncoding::toUTF8($ajxpNode->getUrl()), "node_url");
     $docIds = $index->termDocs($term);
     if (!count($docIds)) {
         return null;
     }
     return $docIds[0];
 }

 public function extractArchiveItemPreCallback($status, $data)
 {
     $fullname = $data['filename'];
     $size = $data['size'];
     $realBase = call_user_func(array($this->wrapperClassName, "getRealFSReference"), $this->urlBase);
     $repoName = $this->urlBase . str_replace($realBase, "", $fullname);
     $toNode = new AJXP_Node($repoName);
     $toNode->setLeaf($data['folder'] ? false : true);
     if (file_exists($toNode->getUrl())) {
         AJXP_Controller::applyHook("node.before_change", array($toNode, $size));
     } else {
         AJXP_Controller::applyHook("node.before_create", array($toNode, $size));
     }
     return 1;
 }

 /**
  * @param AJXP_Node $oldNode
  * @param AJXP_Node $newNode
  * @param bool $copy
  * @param string $targetNotif
  * @return AJXP_Notification
  */
 public function generateNotificationFromChangeHook(AJXP_Node $oldNode = null, AJXP_Node $newNode = null, $copy = false, $targetNotif = "new")
 {
     $type = "";
     $primaryNode = null;
     $secondNode = null;
     $notif = new AJXP_Notification();
     if ($oldNode == null) {
         if ($targetNotif == "old") {
             return false;
         }
         $type = AJXP_NOTIF_NODE_ADD;
         $primaryNode = $newNode;
     } else {
         if ($newNode == null) {
             if ($targetNotif == "new") {
                 return false;
             }
             $type = AJXP_NOTIF_NODE_DEL;
             $primaryNode = $oldNode;
         } else {
             if ($oldNode->getUrl() == $newNode->getUrl()) {
                 $type = AJXP_NOTIF_NODE_CHANGE;
                 $primaryNode = $newNode;
             } else {
                 if (dirname($oldNode->getPath()) == dirname($newNode->getPath())) {
                     $type = AJXP_NOTIF_NODE_RENAME;
                     $primaryNode = $newNode;
                     $secondNode = $oldNode;
                 } else {
                     if ($targetNotif == "new") {
                         $type = $copy ? AJXP_NOTIF_NODE_COPY_FROM : AJXP_NOTIF_NODE_MOVE_FROM;
                         $primaryNode = $newNode;
                         $secondNode = $oldNode;
                     } else {
                         if ($targetNotif == "old") {
                             $type = $copy ? AJXP_NOTIF_NODE_COPY_TO : AJXP_NOTIF_NODE_MOVE_TO;
                             $primaryNode = $oldNode;
                             $secondNode = $newNode;
                         } else {
                             if ($targetNotif == "unify") {
                                 $type = $copy ? AJXP_NOTIF_NODE_COPY : AJXP_NOTIF_NODE_MOVE;
                                 $primaryNode = $newNode;
                                 $secondNode = $oldNode;
                             }
                         }
                     }
                 }
             }
         }
     }
     $notif->setNode($primaryNode);
     $notif->setAction($type);
     if ($secondNode != null) {
         $notif->setSecondaryNode($secondNode);
     }
     return $notif;
 }

 /**
  * @param AJXP_Node $ajxpNode
  * @param String $scope
  * @param String $userId
  */
 protected function saveMetaFileData($ajxpNode, $scope, $userId)
 {
     $currentFile = $ajxpNode->getUrl();
     $repositoryId = $ajxpNode->getRepositoryId();
     $fileKey = $ajxpNode->getPath();
     if (isset($this->options["METADATA_FILE_LOCATION"]) && $this->options["METADATA_FILE_LOCATION"] == "outside") {
         // Force scope
         $scope = AJXP_METADATA_SCOPE_REPOSITORY;
     }
     if ($scope == AJXP_METADATA_SCOPE_GLOBAL) {
         $metaFile = dirname($currentFile) . "/" . $this->options["METADATA_FILE"];
         $fileKey = basename($fileKey);
     } else {
         if (!is_dir(dirname($this->globalMetaFile))) {
             mkdir(dirname($this->globalMetaFile), 0755, true);
         }
         $metaFile = $this->globalMetaFile . "_" . $repositoryId;
         $metaFile = $this->updateSecurityScope($metaFile, $ajxpNode->getRepositoryId(), $ajxpNode->getUser());
     }
     if ($scope == AJXP_METADATA_SCOPE_REPOSITORY || @is_file($metaFile) && call_user_func(array($this->accessDriver, "isWriteable"), $metaFile) || call_user_func(array($this->accessDriver, "isWriteable"), dirname($metaFile))) {
         if (is_array(self::$metaCache) && count(self::$metaCache)) {
             if (!isset(self::$fullMetaCache[$metaFile])) {
                 self::$fullMetaCache[$metaFile] = array();
             }
             if (!isset(self::$fullMetaCache[$metaFile][$fileKey])) {
                 self::$fullMetaCache[$metaFile][$fileKey] = array();
             }
             if (!isset(self::$fullMetaCache[$metaFile][$fileKey][$userId])) {
                 self::$fullMetaCache[$metaFile][$fileKey][$userId] = array();
             }
             self::$fullMetaCache[$metaFile][$fileKey][$userId] = self::$metaCache;
         } else {
             // CLEAN
             if (isset(self::$fullMetaCache[$metaFile][$fileKey][$userId])) {
                 unset(self::$fullMetaCache[$metaFile][$fileKey][$userId]);
             }
             if (isset(self::$fullMetaCache[$metaFile][$fileKey]) && !count(self::$fullMetaCache[$metaFile][$fileKey])) {
                 unset(self::$fullMetaCache[$metaFile][$fileKey]);
             }
         }
         $fp = @fopen($metaFile, "w");
         if ($fp !== false) {
             @fwrite($fp, serialize(self::$fullMetaCache[$metaFile]), strlen(serialize(self::$fullMetaCache[$metaFile])));
             @fclose($fp);
         } else {
             $this->logError(__FUNCTION__, "Error while trying to open the meta file, maybe a permission problem?");
         }
         if ($scope == AJXP_METADATA_SCOPE_GLOBAL) {
             AJXP_Controller::applyHook("version.commit_file", array($metaFile, $ajxpNode));
         }
     }
 }

 /**
  * Apply specific operation to set a node as hidden.
  * Can be overwritten, or will probably do nothing.
  * @param AJXP_Node $node
  */
 public function setHiddenAttribute($node)
 {
     if (AJXP_MetaStreamWrapper::actualRepositoryWrapperClass($node->getRepositoryId()) == "fsAccessWrapper" && strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
         $realPath = AJXP_MetaStreamWrapper::getRealFSReference($node->getUrl());
         @shell_exec("attrib +H " . escapeshellarg($realPath));
     }
 }

 /**
  * Enrich node metadata
  * @param AJXP_Node $ajxpNode
  */
 public function extractImageMetadata(&$ajxpNode)
 {
     $currentPath = $ajxpNode->getUrl();
     $wrapperClassName = $ajxpNode->wrapperClassName;
     $isImage = AJXP_Utils::is_image($currentPath);
     $ajxpNode->is_image = $isImage;
     if (!$isImage) {
         return;
     }
     $setRemote = false;
     $remoteWrappers = $this->getFilteredOption("META_EXTRACTION_REMOTEWRAPPERS");
     if (is_string($remoteWrappers)) {
         $remoteWrappers = explode(",", $remoteWrappers);
     }
     $remoteThreshold = $this->getFilteredOption("META_EXTRACTION_THRESHOLD");
     if (in_array($wrapperClassName, $remoteWrappers)) {
         if ($remoteThreshold != 0 && isset($ajxpNode->bytesize)) {
             $setRemote = $ajxpNode->bytesize > $remoteThreshold;
         } else {
             $setRemote = true;
         }
     }
     if ($isImage) {
         if ($setRemote) {
             $ajxpNode->image_type = "N/A";
             $ajxpNode->image_width = "N/A";
             $ajxpNode->image_height = "N/A";
             $ajxpNode->readable_dimension = "";
         } else {
             $realFile = $ajxpNode->getRealFile();
             list($width, $height, $type, $attr) = @getimagesize($realFile);
             if ($this->getFilteredOption("EXIF_ROTATION")) {
                 require_once AJXP_INSTALL_PATH . "/plugins/editor.diaporama/PThumb.lib.php";
                 $pThumb = new PThumb($this->getFilteredOption["THUMBNAIL_QUALITY"], $this->getFilteredOption("EXIF_ROTATION"));
                 $orientation = $pThumb->exiforientation($realFile, false);
                 if ($pThumb->rotationsupported($orientation)) {
                     $ajxpNode->image_exif_orientation = $orientation;
                     if ($orientation > 4) {
                         $tmp = $height;
                         $height = $width;
                         $width = $tmp;
                     }
                 }
             }
             $ajxpNode->image_type = image_type_to_mime_type($type);
             $ajxpNode->image_width = $width;
             $ajxpNode->image_height = $height;
             $ajxpNode->readable_dimension = $width . "px X " . $height . "px";
         }
     }
     //$this->logDebug("CURRENT NODE IN EXTRACT IMAGE METADATA ", $ajxpNode);
 }