PageRenderTime 35ms CodeModel.GetById 33ms RepoModel.GetById 0ms app.codeStats 1ms

/class.xfiledef.inc

https://github.com/jcplat/console-seolan
PHP | 1560 lines | 1383 code | 74 blank | 103 comment | 291 complexity | b6c21925187ad431547e037c84508d23 MD5 | raw file
Possible License(s): LGPL-2.0, LGPL-2.1, GPL-3.0, Apache-2.0, BSD-3-Clause 
    

  1. <?php
    2. 

  2. /// Gestion d'un champ fichier, y compris images et videos
    3. 

  3. class XFileDef extends XFieldDef {
    4. 

  4.   public $maxlength='';
    5. 

  5.   public $usealt=true;
    6. 

  6.   public $accept='.*';
    7. 

  7.   public $secured=false;
    8. 

  8.   public $crypt=false;
    9. 

  9.   public $sourcemodule=NULL;
    10. 

  10.   public $nocopydup=false;
    11. 

  11.   public $image_crop_ration='';
    12. 

  12.   public $image_geometry='640x480%3E';
    13. 

  13.   public $image_max_geometry=null;
    14. 

  14.   public $video_geometry='320x240%3E';
    15. 

  15.   public $video_bitrate='512';
    16. 

  16.   public $audio_geometry='300x30';
    17. 

  17.   public $audio_bitrate='128';
    18. 

  18.   public $autoplay=false;
    19. 

  19.   public $usemimehtml=false;
    20. 

  20.   public $viewlink=true;
    21. 

  21.   public $gzipped=false;
    22. 

  22.   public $indexable=true;
    23. 

  23.   public $auto_write_meta=false;
    24. 

  24.   static $html5_video_format = array(
    25. 

  25.     'webm' => array('ffmpeg_opts' => FFMPEG_WEBM_OPTS),
    26. 

  26.     'ogg'  => array('ffmpeg_opts' => FFMPEG_OGG_OPTS),
    27. 

  27.     'mp4'  => array('ffmpeg_opts' => FFMPEG_MP4_OPTS),
    28. 

  28.   );
    29. 

  29. 

  30.   function __construct($obj=NULL) {
    31. 

  31.     parent::__construct($obj);
    32. 

  32.     $this->thumb_geometry = TZR_THUMB_SIZE.'x'.TZR_THUMB_SIZE;
    33. 

  33.     $this->multivalued=false;
    34. 

  34.     if(empty($this->image_max_geometry) && defined('XFILEDEF_IMAGE_MAX_GEOMETRY')) $this->image_max_geometry=XFILEDEF_IMAGE_MAX_GEOMETRY;
    35. 

  35.   }
    36. 

  36. 

  37.   /// Retourne l'extention d'un type mime
    38. 

  38.   static function mime2extension($mime) {
    39. 

  39.     $mimeClasse=XMimeTypes::getInstance();
    40. 

  40.     return $mimeClasse->get_extension($mime);
    41. 

  41.   }
    42. 

  42.   /// Retourne vrai si le type mime représente une image
    43. 

  43.   static public function isImage($mime){
    44. 

  44.     $mimeClasse=XMimeTypes::getInstance();
    45. 

  45.     return $mimeClasse->isImage($mime);
    46. 

  46.   }
    47. 

  47.   /// Retourne vrai si le type mime représente une vidéo
    48. 

  48.   static public function isVideo($mime){
    49. 

  49.     $mimeClasse=XMimeTypes::getInstance();
    50. 

  50.     return $mimeClasse->isVideo($mime);
    51. 

  51.   }
    52. 

  52.   /// Retourne vrai si le type mime représente un fichier audio
    53. 

  53.   static public function isAudio($mime){
    54. 

  54.     $mimeClasse = XMimeTypes::getInstance();
    55. 

  55.     return $mimeClasse->isAudio($mime);
    56. 

  56.   }
    57. 

  57.   /**
    58. 

  58.    * Function isEmpty
    59. 

  59.    * @return true si le champ n'est pas remplit
    60. 

  60.    */
    61. 

  61.   public function isEmpty($r) {
    62. 

  62.     if (property_exists($r, 'filename'))
    63. 

  63.       return empty($r->filename) && empty($r->externalUrl);
    64. 

  64.     else return true;
    65. 

  65.   }
    66. 

  66. 

  67.   static function mkfilename($str, $mime) {
    68. 

  68.     $s=preg_replace('@([^\/0-9a-zA-Z_-]+)@','',$str);
    69. 

  69.     $mimeClasse = XMimeTypes::getInstance();
    70. 

  70.     $ext=$mimeClasse->get_extension($mime);
    71. 

  71.     return $s.'.'.$ext;
    72. 

  72.   }
    73. 

  73.   public function hasExternals() {
    74. 

  74.     return true;
    75. 

  75.   }
    76. 

  76.   /// Retourne le nom du fichier
    77. 

  77.   public function externals($value) {
    78. 

  78.     list($file,$mime,$originalname,$title)=explode(';',$value);
    79. 

  79.     $files=$this->filename($file,false,true);
    80. 

  80.     if(!empty($files)) return array($files);
    81. 

  81.     else return NULL;
    82. 

  82.   }
    83. 

  83.   /// Copie le fichier d'une fiche vers une autre fiche
    84. 

  84.   public function copyExternalsTo($value,$oidsrc,$oiddst,$upd=NULL) {
    85. 

  85.     if(empty($value) || empty($oiddst)) return NULL;
    86. 

  86.     if($value==TZR_UNCHANGED) return $value;
    87. 

  87.     @list($file,$mime,$originalname,$title) = explode(';',$value);
    88. 

  88.     if(strpos($file,'.')) list($lang)=explode('.',$file);
    89. 

  89.     $files=$this->filename($file,false,true);
    90. 

  90.     if(!empty($files) && file_exists($GLOBALS['DATA_DIR'].$files)) {
    91. 

  91.       list($table,$idd) = explode(':',$oiddst);
    92. 

  92.       if(!empty($lang)) $idd=$lang.'.'.$idd;
    93. 

  93.       // 1er appel : creation de l'arbo / 2eme appel : recupereation du nom du fichier
    94. 

  94.       $nfiles=$this->filename($idd,true,false,$upd);
    95. 

  95.       $nfiles=$this->filename($idd,false,false,$upd);
    96. 

  96.       copy($GLOBALS['DATA_DIR'].$files,$GLOBALS['DATA_DIR'].$nfiles);
    97. 

  97.       return $idd.';'.$mime.';'.$originalname.';'.$title;
    98. 

  98.     }else{
    99. 

  99.       return TZR_UNCHANGED;
    100. 

  100.     }
    101. 

  101.   }
    102. 

  102. 

  103.   function initOptions() {
    104. 

  104.     parent::initOptions();
    105. 

  105.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','xfileviewlink'), 'viewlink','boolean');
    106. 

  106.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','usemimehtml'), 'usemimehtml','boolean');
    107. 

  107.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','maxlength'), 'maxlength', 'text');
    108. 

  108.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','usealt'), 'usealt', 'boolean');
    109. 

  109.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','accept'), 'accept', 'text');
    110. 

  110.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','browsemods'), 'browsemods', 'boolean');
    111. 

  111.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','sourcemodule'), 'sourcemodule', 'module');
    112. 

  112.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','secured'), 'secured', 'boolean');
    113. 

  113.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','crypt'), 'crypt', 'boolean');
    114. 

  114.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','image_crop_ratio'), 'image_crop_ratio', 'text');
    115. 

  115.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','image_geometry'), 'image_geometry', 'text');
    116. 

  116.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','image_max_geometry'), 'image_max_geometry', 'text');
    117. 

  117.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','video_geometry'), 'video_geometry', 'text');
    118. 

  118.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','video_bitrate'), 'video_bitrate', 'text');
    119. 

  119.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','audio_bitrate'), 'audio_bitrate', 'text');
    120. 

  120.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','autoplay'), 'autoplay', 'boolean');
    121. 

  121.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','gzipped'), 'gzipped', 'boolean');
    122. 

  122.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','allow_externalfile'), 'allow_externalfile', 'boolean');
    123. 

  123.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','xfiledef_autowritemeta'),'auto_write_meta','boolean');
    124. 

  124. 

  125.     $querygroup=XLabels::getSysLabel('general','query','text');
    126. 

  126.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef.indexable'), 'indexable', 'boolean', NULL, true, $querygroup);
    127. 

  127.   }
    128. 

  128. 

  129.   // Verification que les repertoires qui contiennent les fichiers n'existent pas,  sinon on les cree
    130. 

  130.   function _checkDir() {
    131. 

  131.     global $DATA_DIR;
    132. 

  132.     umask(0000);
    133. 

  133.     $root=$DATA_DIR.$this->table.'/'.$this->field;
    134. 

  134.     if(!is_dir($root)) {
    135. 

  135.       if(!is_dir($DATA_DIR.$this->table)) {
    136. 

  136. 	@mkdir($DATA_DIR.$this->table,0777);
    137. 

  137.       }
    138. 

  138.       if(!is_dir($DATA_DIR.$this->table.'/'.$this->field)) {
    139. 

  139. 	@mkdir($DATA_DIR.$this->table.'/'.$this->field,0777);
    140. 

  140.       }
    141. 

  141.     }
    142. 

  142.   }
    143. 

  143. 

  144.   /// Suppression du champ, i.e. suppression du repertoire et des donnees incluses dans ce repertoire
    145. 

  145.   function delfield() {
    146. 

  146.     global $DATA_DIR;
    147. 

  147.     XDir::unlink($DATA_DIR.$this->table.'/'.$this->field);
    148. 

  148.   }
    149. 

  149. 

  150.   /// Ecriture dans un fichier excel
    151. 

  151.   function writeXLS(&$xl,$i,$j,&$value,$format=0,&$ss=NULL) {
    152. 

  152.     if(!empty($value->url)){
    153. 

  153.       $lab=$value->text;
    154. 

  154.       if(empty($lab)) $lab='Link';
    155. 

  155.       convert_charset($lab,TZR_INTERNAL_CHARSET,'UTF-8');
    156. 

  156.       $xl->setCellValueByColumnAndRow($j,$i,$lab);
    157. 

  157.       $xl->getCellByColumnAndRow($j,$i)->getHyperlink()->setUrl($GLOBALS['HOME_ROOT_URL'].$value->url);
    158. 

  158.       if(is_array($format)) $xl->getStyleByColumnAndRow($j,$i)->applyFromArray($format);
    159. 

  159.     }
    160. 

  160.   }
    161. 

  161. 

  162.   /// Ecriture dans un csv
    163. 

  163.   function writeCSV(&$o,$textsep){
    164. 

  164.     return $textsep.$o->originalname.$textsep;
    165. 

  165.   }
    166. 

  166. 

  167.   /// Affiche dans le mode parcourir
    168. 

  168.   function my_browse(&$value,&$options) {
    169. 

  169.     $r=&$this->my_display($value,$options);
    170. 

  170.     if($this->usemimehtml && !empty($options['admin'])) {
    171. 

  171.       $r->html=$r->html_preview;
    172. 

  172.     }
    173. 

  173.     return $r;
    174. 

  174.   }
    175. 

  175. 

  176.   /// Retourne la taille du fichier
    177. 

  177.   function getFileSize($r){
    178. 

  178.     if(empty($r->filesize)) $r->filesize=filesize($r->filename);
    179. 

  179.     return $r->filesize;
    180. 

  180.   }
    181. 

  181. 

  182.   /// Affichage du champ
    183. 

  183.   function my_display($value,&$options) {
    184. 

  184.     global $DATA_DIR;
    185. 

  185.     $langdata = XShell::getLangData();
    186. 

  186.     $resizer=TZR_RESIZER;
    187. 

  187.     $r=$this->_newXFieldVal($options, true);
    188. 

  188.     $r->type = NULL;
    189. 

  189.     $r->resizer = NULL;
    190. 

  190.     $r->mime = NULL;
    191. 

  191.     $r->isImage = false;
    192. 

  192.     $r->isVideo = false;
    193. 

  193.     if($value=='' || $value==TZR_UNCHANGED)
    194. 

  194.       return $r;
    195. 

  195. 

  196.     @list($file,$mime,$originalname,$title) = explode(';',$value);
    197. 

  197.     if (strpos($file, ':') !== false)
    198. 

  198.       return $this->displayExternal($r, $file, $value, $options);
    199. 

  199.     if(empty($originalname)) {
    200. 

  200.       $originalname = 'download';
    201. 

  201.       $mimeClasse = XMimeTypes::getInstance();
    202. 

  202.       $originalname .= '.'.$mimeClasse->get_extension($mime);
    203. 

  203.     }
    204. 

  204.     $files=$this->filename($file,false,false,@$options['_archive']);
    205. 

  205.     if(!$files) return $r;
    206. 

  206.     $filename=$DATA_DIR.$files;
    207. 

  207.     $originalname_corrected=preg_replace('@([^\._a-zA-Z0-9-]+)@','_',$originalname);
    208. 

  208.     $downloader=$this->getDownloader($files, $mime, $originalname_corrected, $title, @$options['fmoid']);
    209. 

  209.     $r->filename=$filename;
    210. 

  210.     $r->shortfilename=$files;
    211. 

  211.     $r->mime=$mime;
    212. 

  212.     $r->title=$title;
    213. 

  213.     $r->originalname=$originalname;
    214. 

  214.     $r->raw=$value;
    215. 

  215.     $r->url=$downloader[0];
    216. 

  216.     $r->text=$r->title?$r->title:$r->originalname;
    217. 

  217.     $r->mimepicto=XLabels::getSysLabel('mime',$mime, 'both', 'mime', 'unknown/unknown');	
    218. 

  218.     $r->html_default='<a bt-xpath="'.TZR_AJAX8.'?class=xfiledef&function=xfiledef_getfilesize&file='.$files.'&_='.XShell::uniqid().'" class="tzr-hottip-c tzr-file" href="'.$r->url.'" target="_self">'.$r->mimepicto.(empty($title)?$originalname:$title).'</a>';
    219. 

  219.     $r->html_preview=$r->html_default;
    220. 

  220.     $r->html=$r->html_default;
    221. 

  221. 

  222.     if(XFileDef::isVideo($mime)) $this->displayVideo($r,$value,$options);
    223. 

  223.     elseif(XFileDef::isImage($mime)) $this->displayImage($r,$value,$options);
    224. 

  224.     elseif($mime=='application/pdf') $this->displayPDF($r,$value,$options);
    225. 

  225.     elseif(XFileDef::isAudio($mime)) $this->displayAudio($r,$value,$options);
    226. 

  226. 

  227.     return $r;
    228. 

  228.   }
    229. 

  229. 

  230.   /// Affichage d'un fichier externe
    231. 

  231.   function displayExternal(&$r, $file, $value, $options) {
    232. 

  232.     $r->file = $file;
    233. 

  233.     $r->raw = $value;
    234. 

  234.     list($r->type, $r->id) = explode(':', $file, 2);
    235. 

  235.     $r->isExternal = true;
    236. 

  236.     $displayFunction = 'display'.$r->type;
    237. 

  237.     if (method_exists($this, $displayFunction))
    238. 

  238.       return $this->$displayFunction($r, $options);
    239. 

  239.     $r->externalUrl = $r->id;
    240. 

  240.     return $r;
    241. 

  241.   }
    242. 

  242.   
    243. 

  243.   /* Image */
    244. 

  244.   /// Complete l'objet d'affichage dans le cas d'une image
    245. 

  245.   function displayImage(&$r,&$value,$options){
    246. 

  246.     $resizer=$this->getResizer($r->shortfilename,$r->mime,$r->originalname);
    247. 

  247.     if(!empty($resizer) && !empty($resizer['resizer'])) {
    248. 

  248.       $r->resizer=$resizer['resizer'];
    249. 

  249.       $r->weresizer=$resizer['weresizer'];
    250. 

  250.     }
    251. 

  251.     $r->isImage=true;
    252. 

  252.     if($this->usemimehtml){
    253. 

  253.       $r->html = '<img class="tzr-image" src="'.$r->resizer.'&geometry='.$this->image_geometry.'" alt="'.$r->title.'" title="'.$r->title.'">';
    254. 

  254.       if ($this->viewlink) $r->html.='<br>'.$r->html_default;
    255. 

  255.     }
    256. 

  256.     $r->html_preview = '<img class="tzr-image" src="'.$r->resizer.'&geometry='.TZR_THUMB_SIZE.'x'.TZR_THUMB_SIZE.'%3E" alt="'.$r->title.'" title="'.$r->title.'">';
    257. 

  257.     if ($this->viewlink) $r->html_preview.='<br>'.$r->html_default;
    258. 

  258.   }
    259. 

  259.   
    260. 

  260.   /// Retourne le code html du preview d'une image
    261. 

  261.   function html_previewImage($r, $options=array()) {
    262. 

  262.     $options = array_merge(array('title' => $r->title, 'geometry' => $this->thumb_geometry), $options);
    263. 

  263.     return $this->htmlImage($r, $options);
    264. 

  264.   }
    265. 

  265.   
    266. 

  266.   /// Retourne le code html d'une image
    267. 

  267.   function htmlImage($r, $options=array()) {
    268. 

  268.     $options = array_merge(array('title' => $r->title, 'geometry' => $this->image_geometry), $options);
    269. 

  269.     $geometry = $options['geometry'];
    270. 

  270.     $this->getImageSize($r);
    271. 

  271.     list($w, $h) = explode('x', str_replace('>', '', $geometry));
    272. 

  272.     $w = (integer)$w;
    273. 

  273.     $h = (integer)$h;
    274. 

  274.     $ratio = $r->fullheight / $r->fullwidth;
    275. 

  275.     if (isset($options['gravity'])) { // on peux croper
    276. 

  276.       $geometry = (integer)($ratio * $r->fullwidth).'x'.(integer)($ratio * $r->fullheight);
    277. 

  277.       $crop = '&amp;crop='.$w.'x'.$h.'&amp;gravity='.$options['gravity'];
    278. 

  278.     } else {
    279. 

  279.       if ($w < $r->fullwidth || $h < $r->fullheight) {
    280. 

  280.         if ($ratio < 1)
    281. 

  281.           $h = (integer)($w*$ratio);
    282. 

  282.         else
    283. 

  283.           $w = (integer)($h/$ratio);
    284. 

  284.       } else {
    285. 

  285.         $w = $r->fullwidth;
    286. 

  286.         $h = $r->fullheight;
    287. 

  287.       }
    288. 

  288.       $geometry = $w.'x'.$h;
    289. 

  289.     }
    290. 

  290.     return '<img class="tzr-image" src="'.$r->resizer.'&amp;geometry='.$geometry.@$crop.'" '.(isset($options['title']) ? ' alt="'.@$options['title'].'" title="'.@$options['title'].'"':'').(isset($w)?' width="'.$w.'" height="'.$h.'"':'').'>';
    291. 

  291.   }
    292. 

  292. 

  293.   /// Retourne le code html 
    294. 

  294.   function completeHTML($r, $options=array(), $alt){
    295. 

  295.     if (empty($r) || $r->raw == '')
    296. 

  296.       return '';
    297. 

  297.     if (is_string($options)) { // from template
    298. 

  298.       parse_str($options, $options);
    299. 

  299.     }
    300. 

  300.     if (count($options)==1 && current($options) == '') // compatibilité
    301. 

  301.       $options = array('geometry' => key($options));
    302. 

  302.     if ($r->isExternal) {
    303. 

  303.       $htmlFunction = 'html'.$r->type;
    304. 

  304.       if (method_exists($this, $htmlFunction))
    305. 

  305.         $html = $this->$htmlFunction($r, $options);
    306. 

  306.     }
    307. 

  307.     elseif ($r->isImage || $r->isPDF)
    308. 

  308.       $html = $this->htmlImage($r, $options);
    309. 

  309.    elseif ($r->isVideo)
    310. 

  310.       $html = $this->htmlVideo($r, $options);
    311. 

  311.     elseif ($r->isAudio)
    312. 

  312.       $html = $this->htmlAudio($r, $options, $alt);
    313. 

  313.     else
    314. 

  314.       $html = $r->html_default;
    315. 

  315. 

  316.     return $html;
    317. 

  317.   }
    318. 

  318.   
    319. 

  319.   /// Retourne l'url des reiszer
    320. 

  320.   protected function getResizer($filename,$mime="null/null",$originalname=NULL){
    321. 

  321.     $mimedst=$mime;
    322. 

  322.     if($mime=='image/x-png') $mime=$mimedst='image/png';
    323. 

  323.     if(($mime!='image/gif') && ($mime!='image/png')) $mimedst='image/jpeg';
    324. 

  324.     $mimedst=rawurlencode($mimedst);
    325. 

  325.     $fmime = '';
    326. 

  326.     $mimeClasse=XMimeTypes::getInstance();
    327. 

  327.     if($mime=='application/pdf'){
    328. 

  328.       $fmime=$mime;
    329. 

  329.     }elseif($mimeClasse->isImage($mime)) {
    330. 

  330.       $fmime=$mimedst;
    331. 

  331.     }
    332. 

  332.     if(!empty($fmime)){
    333. 

  333.       $str = '?filename='.$filename.'&amp;mime='.$fmime.'&amp;';
    334. 

  334.       if($originalname) $str .= '&amp;originalname='.rawurlencode($originalname);
    335. 

  335.       $resizer=TZR_RESIZER.$str;
    336. 

  336.       $weresizer=TZR_WERESIZER.$str;
    337. 

  337.     }else{
    338. 

  338.       $resizer=$weresizer='';
    339. 

  339.     }
    340. 

  340.     return array('resizer'=>$resizer,'weresizer'=>$weresizer);
    341. 

  341.   }
    342. 

  342.   
    343. 

  343.   /// Retourne la taille en px d'une image
    344. 

  344.   function getImageSize($r,$dim=NULL){
    345. 

  345.     if(!isset($r->fullwidth)){
    346. 

  346.       if($r->isImage) $t=getimagesize($r->filename);
    347. 

  347.       elseif($r->isVideo) $t=getimagesize($r->filename.'-fullsizeimage');
    348. 

  348.       elseif($r->isPDF) {
    349. 

  349.         if (!file_exists($r->filename.'-fullsizeimage'))
    350. 

  350.           exec(TZR_MOGRIFY_RESIZER . ' ' . $r->filename . '[0] jpeg:' . $r->filename . '-fullsizeimage');
    351. 

  351.         $t=getimagesize($r->filename.'-fullsizeimage');
    352. 

  352.       }
    353. 

  353.       else $t=array(0,0);
    354. 

  354.       $r->fullwidth=$t[0];
    355. 

  355.       $r->fullheight=$t[1];
    356. 

  356.     }
    357. 

  357.     if($dim) return $r->$dim;
    358. 

  358.   }
    359. 

  359.   
    360. 

  360.   /// Recupere la largeur ou la hauteur finale d'une image en fonction d'une géométrie passée au resizer
    361. 

  361.   function getImageResize($r,$geometry,$dim){
    362. 

  362.     if(empty($r->_cache['size'][$geometry])){
    363. 

  363.       $this->getImageSize($r);
    364. 

  364.       $t=array($r->fullwidth,$r->fullheight);
    365. 

  365.       $oratio=$t[0]/$t[1];
    366. 

  366.       $size=explode('x',$geometry);
    367. 

  367.       if(!is_numeric($size[0])) $size[0]=0;
    368. 

  368.       if(empty($size[1]) || !is_numeric($size[1])) $size[1]=0;
    369. 

  369.       $ratio=$size[0]/$size[1];
    370. 

  370. 

  371.       if(!empty($size[0]) && ($oratio>$ratio || empty($size[1]))){
    372. 

  372. 	$w=$size[0];
    373. 

  373. 	$h=round($t[1]*$size[0]/$t[0]);
    374. 

  374.       }else{
    375. 

  375. 	$w=round($t[0]*$size[1]/$t[1]);
    376. 

  376. 	$h=$size[1];
    377. 

  377.       }
    378. 

  378.      $r->_cache['size'][$geometry]=array('width'=>$w,'height'=>$h);
    379. 

  379.     }
    380. 

  380.     return $r->_cache['size'][$geometry][$dim];
    381. 

  381.   }
    382. 

  382.   /// Retourne une propriété iptc ou l'objet iptc de l'image
    383. 

  383.   function getIPTC($r,$prop=NULL){
    384. 

  384.     if($r->mime=='image/jpeg'){
    385. 

  385.       if(empty($r->meta_data)) $r->meta_data=XFileDef::loadMeta($r->filename);
    386. 

  386.       if(!$prop) return $r->meta_data;
    387. 

  387.       else return $r->meta_data->getIPTCProperty($prop);
    388. 

  388.     }
    389. 

  389.     return NULL;
    390. 

  390.   }
    391. 

  391.   /// Retourne une propriété exif ou l'objet exif de l'image
    392. 

  392.   function getEXIF($r,$prop=NULL){
    393. 

  393.     if($r->mime=='image/jpeg'){
    394. 

  394.       if(empty($r->exif_data)) $r->exif_data=exif_read_data($r->filename);
    395. 

  395.       if(!$prop) return $r->exif_data;
    396. 

  396.       else return $r->exif_data[$prop];
    397. 

  397.     }
    398. 

  398.     return NULL;
    399. 

  399.   }
    400. 

  400.   /// Retourne une propriété XMP ou l'objet XMP de l'image
    401. 

  401.   function getXMP($r,$prop=NULL){
    402. 

  402.     if($r->mime=='image/jpeg'){
    403. 

  403.       if(empty($r->meta_data)) $r->meta_data=XFileDef::loadMeta($r->filename);
    404. 

  404.       if(!$prop) return $r->meta_data;
    405. 

  405.       else return $r->meta_data->getXMPProperty($prop,array('Alt'=>array('lang'=>array(XShell::getLangData(),'x-default'))));
    406. 

  406.     }
    407. 

  407.     return NULL;
    408. 

  408.   }
    409. 

  409.   /// Charge l'objet meta du fichier
    410. 

  410.   static function loadMeta($file){
    411. 

  411.     return new MetaAnalyser($file);
    412. 

  412.   }
    413. 

  413. 

  414.   /// Redimensione une image
    415. 

  415.   function resizeImage($file,$geo=null){
    416. 

  416.     if(!$geo) return false;
    417. 

  417.     // Verifie si l'image est plus grande qua la taille max ou pas
    418. 

  418.     $s=getimagesize($file);
    419. 

  419.     list($w,$h)=explode('x',$geo);
    420. 

  420.     if(!is_numeric($w)) $w=99999;
    421. 

  421.     if(empty($h) || !is_numeric($h)) $h=99999;
    422. 

  422.     if($s[0]<$w && $s[1]<$h) return false;
    423. 

  423.     // Redimensionne l'image
    424. 

  424.     $geo=rawurldecode($geo);
    425. 

  425.     exec(TZR_MOGRIFY_RESIZER.' -resize "'.$geo.'" '.$file.' '.$file);
    426. 

  426.     return true;
    427. 

  427.   }
    428. 

  428. 

  429.   /// Applique rotate et flip à un fichier selon son orientation exif
    430. 

  430.   function rotateAndFlip($filename,$mime){
    431. 

  431.     $r=(object)array('filename'=>$filename,'mime'=>$mime);
    432. 

  432.     $o=$this->getExif($r,'Orientation');
    433. 

  433.     if(!empty($o) && $o!=1){
    434. 

  434.       switch ($o){
    435. 

  435.       case 2:
    436. 

  436. 	$opt='-flop';
    437. 

  437. 	break;
    438. 

  438.       case 3:
    439. 

  439. 	$opt='-rotate 180';
    440. 

  440. 	break;
    441. 

  441.       case 4:
    442. 

  442. 	$opt='-flip';
    443. 

  443. 	break;
    444. 

  444.       case 5:
    445. 

  445. 	$opt='-flip -rotate "90"';
    446. 

  446. 	break;
    447. 

  447.       case 6:
    448. 

  448. 	$opt='-rotate "90"';
    449. 

  449. 	break;
    450. 

  450.       case 7:
    451. 

  451. 	$opt='-flop -rotate "90"';
    452. 

  452. 	break;
    453. 

  453.       case 8:
    454. 

  454. 	$opt='-rotate "-90"';
    455. 

  455. 	break;
    456. 

  456.       }
    457. 

  457.       exec(TZR_MOGRIFY_RESIZER.' '.$opt.' '.$filename.' '.$filename);
    458. 

  458.     }
    459. 

  459.   }
    460. 

  460. 

  461.   /* Video */
    462. 

  462.   /// Complete l'objet d'affichage dans le cas d'une video
    463. 

  463.   function displayVideo(&$r,&$value,&$options){
    464. 

  464.     $r->isVideo=true;
    465. 

  465.     $r->resizer=TZR_VIDEOCONVERT.'?filename='.$r->shortfilename;
    466. 

  466.     $r->preview=TZR_VIDEOCONVERT.'?preview=true&filename='.$r->shortfilename;
    467. 

  467.     if ($this->usemimehtml) {
    468. 

  468.       $r->html_preview = $this->html_previewVideo($r, $options);
    469. 

  469.       $r->html = $this->htmlVideo($r, $options);
    470. 

  470.       if ($this->viewlink) {
    471. 

  471.         $r->html .= '<br>'.$r->html_default;
    472. 

  472.         $r->html_preview .= '<br>'.$r->html_default;
    473. 

  473.       }
    474. 

  474.     } else
    475. 

  475.       $r->html = $r->html_preview;
    476. 

  476.   }
    477. 

  477.   /// Code html du preview d'une vidéo
    478. 

  478.   function html_previewVideo($r, $options=array()) {
    479. 

  479.     $options = array_merge(array('title' => $r->title, 'geometry' => $this->thumb_geometry), $options);
    480. 

  480.     $geometry = XFileDef::videoGetGeometry($r->filename, $options['geometry']);
    481. 

  481.     list($width, $height) = explode('x', $geometry);
    482. 

  482.     return '<img class="tzr-image" src="'.$r->preview.'&geometry='.$geometry.'" alt="'.$options['title'].'" title="'.$options['title'].'" width="'.$width.'" height="'.$height.'">';
    483. 

  483.   }
    484. 

  484.   /// Code html de l'affichage d'une vidéo
    485. 

  485.   function htmlVideo(&$r, $options=array(1=>1)) {
    486. 

  486.     global $DATA_URL;
    487. 

  487.     $options = array_merge(array('title' => $r->title, 'geometry' => $this->video_geometry, 'video_bitrate' => $this->video_bitrate, 'autoplay' => $this->autoplay, 'fullscreen' => 1), $options);
    488. 

  488.     $geometry = XFileDef::videoGetGeometry($r->filename, $options['geometry']);
    489. 

  489.     list($width, $height) = explode('x', $geometry);
    490. 

  490.     $r->video_bitrate = $options['video_bitrate'];
    491. 

  491.     if ($this->videoReady($r, $geometry, true, $options['video_bitrate'])) {
    492. 

  492.       if (defined('HTML5MEDIA')) {
    493. 

  493.         $html = '
    494. 

  494.         <div class="tzr-video-div">
    495. 

  495.           <video id="'.$r->varid.'" class="tzr-video" '.($options['autoplay'] ? ' autoplay="autoplay"' : '').' width="'.$width.'" height="'.$height.'" controls poster="'.$r->preview.'&geometry='.$geometry.'" preload="none">';
    496. 

  496.         foreach (XFileDef::$html5_video_format as $format => $opts) {
    497. 

  497.           $html .= '
    498. 

  498.           <source src="'.$r->resizer.'&geometry='.$geometry.'&bitrate='.$options['video_bitrate'].'&format='.$format.'&type=.'.$format.'"  type="video/'.$format.'"/>';
    499. 

  499.         }
    500. 

  500.         $html .= '
    501. 

  501.           </video>
    502. 

  502.           <script type="text/javascript">
    503. 

  503.             jQuery("#'.$r->varid.'").mediaelementplayer({pluginPath: "'.TZR_SHARE_URL.'js/jmediaelement/"});
    504. 

  504.           </script>
    505. 

  505.         </div>';
    506. 

  506.       } else {
    507. 

  507.         $html = '<div style="width='.$width.'px;height:'.$height.'px"><div id="'.$r->varid.'"></div></div><script type="text/javascript">swfobject.embedSWF("'.TZR_SHARE_URL.'flash/player_flv_maxi.swf","'.$r->varid.'","'.$width.'","'.$height.'","8","",{flv:"'.urlencode($r->resizer.'&geometry='.$geometry.'&bitrate='.$options['video_bitrate']).'",startimage:"'.urlencode($r->preview.'&geometry='.$geometry).'",autoplay:'.($options['autoplay']?'1':'0').',showfullscreen:'.($options['fullscreen']?'1':'0').',margin:0,showstop:1,showvolume:1,showtime:1,ondoubleclick:"fullscreen"},{allowFullScreen:true, wmode:"transparent"});</script>';
    508. 

  508.       }
    509. 

  509.     }
    510. 

  510.     else {
    511. 

  511.       $html = '<img src="'.$r->preview.'&geometry='.$geometry.'" alt="'.$title.'" title="'.$title.'" width="'.$width.'" height="'.$height.'">';
    512. 

  512.     }
    513. 

  513.     return $html;
    514. 

  514.   }
    515. 

  515. 

  516.   /// Determine si le fichier est directement disponible dans le format.
    517. 

  517.   /// Si 'force' a true et fichier non disponible, lance la tache de conversion.
    518. 

  518.   function videoReady($r,$geometry,$forceConvert=true) {
    519. 

  519.     if(!XFileDef::isVideo($r->mime))
    520. 

  520.       return false;
    521. 

  521.     $geometry=XFileDef::videoGetGeometry($r->filename,$geometry);
    522. 

  522.     $ready = true;
    523. 

  523.     $ffmpeg = '';
    524. 

  524.     if (defined('HTML5MEDIA')) {  // html5 video tag
    525. 

  525.       foreach (XFileDef::$html5_video_format as $format => $opts) {
    526. 

  526.         $hash = md5($geometry.$r->video_bitrate.'video/'.$format);
    527. 

  527.         $filename_cache = $r->filename.'-'.$hash.'-cache';
    528. 

  528.         if (!file_exists($filename_cache) || (filemtime($filename)>filemtime($filename_cache))) {
    529. 

  529.           $ready = false;
    530. 

  530.           if ($forceConvert) {
    531. 

  531.             $ffmpeg .= FFMPEG." -y -i {$r->filename} {$opts['ffmpeg_opts']} -vb {$r->video_bitrate}k -s $geometry $filename_cache ;\n";
    532. 

  532.           }
    533. 

  533.         }
    534. 

  534.       }
    535. 

  535.     }
    536. 

  536.     else {
    537. 

  537.       $hash = md5($geometry.$r->video_bitrate.'video/x-flv');
    538. 

  538.       $filename_cache=$r->filename.'-'.$hash.'-cache';
    539. 

  539.       if (!file_exists($filename_cache) || (filemtime($filename)>filemtime($filename_cache))) {
    540. 

  540.         $ready = false;
    541. 

  541.         if ($forceConvert) {
    542. 

  542.           $ffmpeg .= FFMPEG." -y -i {$r->filename} -ab 64k -ar 22050 -f flv -vb {$r->video_bitrate}k -s $geometry $filename_cache ";
    543. 

  543.         }
    544. 

  544.       }
    545. 

  545.     }
    546. 

  546.     if ($ffmpeg) {
    547. 

  547.       $s=new XModScheduler(array('tplentry'=>TZR_RETURN_DATA));
    548. 

  548.       $s->createIdleShellJob(md5($ffmpeg),'Video encoding',$ffmpeg,'');
    549. 

  549.     }
    550. 

  550.     return $ready;
    551. 

  551.   }
    552. 

  552.   /// Affichage d'une video youtube
    553. 

  553.   function displayYoutube(&$r, $value, $options) {
    554. 

  554.     require_once 'Zend/Loader.php'; // the Zend dir must be in your include_path
    555. 

  555.     Zend_Loader::loadClass('Zend_Gdata_YouTube');
    556. 

  556.     $r->videoid = $r->id;
    557. 

  557.     $r->videourl = 'http://www.youtube.com/watch?v='.$r->videoid;
    558. 

  558.     $r->isVideo = true;
    559. 

  559.     $r->videoReady = true;
    560. 

  560.     $r->resizer = '';
    561. 

  561.     $yt = new Zend_Gdata_YouTube();
    562. 

  562.     $yt->setMajorProtocolVersion(2);
    563. 

  563.     try {
    564. 

  564.       $videoEntry = $yt->getVideoEntry($r->videoid);
    565. 

  565.       $r->externalUrl = $videoEntry->getVideoWatchPageUrl();
    566. 

  566.       $r->embedUrl = 'http://www.youtube.com/embed/' . $r->videoid;
    567. 

  567.       $thumbnails = $videoEntry->getVideoThumbnails();
    568. 

  568.       $r->flashplayer = $videoEntry->getFlashPlayerUrl();
    569. 

  569.       $r->preview = $thumbnails[0]; /// TODO: choose best size
    570. 

  570.       $r->title = $videoEntry->getVideoTitle();
    571. 

  571.       $r->text = $r->title;
    572. 

  572.       $r->error = false;
    573. 

  573.     } catch(Zend_Gdata_App_HttpException $e) {
    574. 

  574.       $r->error = true;
    575. 

  575.       XLogs::notice('XFileDef::displayYoutube', "Error : " . $e->getMessage());
    576. 

  576.     }
    577. 

  577.     $r->fullwidth = 1600;
    578. 

  578.     $r->fullheight = 900;
    579. 

  579.     $r->html_preview = $this->html_previewYoutube($r, $options);
    580. 

  580.     if ($this->usemimehtml)
    581. 

  581.       $r->html = $this->htmlYoutube($r, $options);
    582. 

  582.     else
    583. 

  583.       $r->html = $r->html_preview;
    584. 

  584.     return $r;
    585. 

  585.   }
    586. 

  586. 

  587.   /// html du preview d'une video youtube
    588. 

  588.   function html_previewYoutube($r, $options=array()) {
    589. 

  589.     if ($r->error)
    590. 

  590.       return '';
    591. 

  591.     if (isset($options['geometry']))
    592. 

  592.       list($width, $height) = explode('x', str_replace('>', '', $options['geometry']));
    593. 

  593.     else
    594. 

  594.       $width = $height = TZR_THUMB_SIZE;
    595. 

  595.     $margin = (int) -($width * $r->preview['height']/$r->preview['width'] - $height) /2;
    596. 

  596.     return '<div style="width:'.$width.'px;height:'.$height.'px;overflow:hidden;display:inline"><img src="'.$r->preview['url'].'" alt="'.$r->title.'" width="'.$width.'" class="tzr-externalfile" rel="'.$r->file.'"'.($margin<0?'style="margin-top:'.$margin.'px"':'').'></div>';
    597. 

  597.   }
    598. 

  598.   /// html d'une video youtube
    599. 

  599.   function htmlYoutube($r, $options=array()) {
    600. 

  600.     if ($r->error)
    601. 

  601.       return '';
    602. 

  602.     $options = array_merge(array('autoplay' => $this->autoplay, 'geometry' => $this->video_geometry), $options);
    603. 

  603.     list($width, $height) = explode('x', str_replace('>', '', rawurldecode($options['geometry'])));
    604. 

  604.     return '<iframe id="'.$r->varid.'" width="'.$width.'" height="'.$height.'" style="width:'.$width.'px;height:'.$height.'px" src="'.$r->embedUrl.'?enablejsapi=1&origin='.$GLOBALS['TZR_SESSION_MANAGER']::makeDomainName().'&wmode=transparent'.($options['autoplay']?'&autoplay=1':'').'"></iframe>';
    605. 

  605.   }
    606. 

  606. 

  607.   /// Affichage d'une video Daily Motion
    608. 

  608.   function displayDailyMotion(&$r, $file, $value, $options) {
    609. 

  609.     $videoid = substr($file, 12);
    610. 

  610.     $r->videoid = $r->id;
    611. 

  611.     $r->videourl = 'http://www.dailymotion.com/video/'.$r->videoid;
    612. 

  612.     $r->isVideo = true;
    613. 

  613.     $r->videoReady = true;
    614. 

  614.     $r->resizer = '';
    615. 

  615.     if (!$videoEntry = file_get_contents('https://api.dailymotion.com/video/'.$r->videoid.'?fields=allow_embed,url,embed_url,thumbnail_medium_url,title')) {
    616. 

  616.       XLogs::notice('XFileDef::displayDailyMotion', "Error : cannot retreive video information ");
    617. 

  617.       $r->error = true;
    618. 

  618.       return $r;
    619. 

  619.     }
    620. 

  620.     $videoEntry = json_decode($videoEntry);
    621. 

  621.     if ($videoEntry->error) {
    622. 

  622.       XLogs::notice('XFileDef::displayDailyMotion', "Error : " . $videoEntry->error->message);
    623. 

  623.       $r->error = true;
    624. 

  624.       return $r;
    625. 

  625.     }
    626. 

  626.    if (!$videoEntry->allow_embed) {
    627. 

  627.       XLogs::notice('XFileDef::displayDailyMotion', "Error : {$r->videoid} embed not allowed");
    628. 

  628.       return $r;
    629. 

  629.     }
    630. 

  630.     $r->preview = array(
    631. 

  631.       'url' => $videoEntry->thumbnail_medium_url,
    632. 

  632.       'width' => 160,
    633. 

  633.       'height' => 120
    634. 

  634.     );
    635. 

  635.     $r->title = $videoEntry->title;
    636. 

  636.     $r->externalUrl = $videoEntry->url;
    637. 

  637.     $r->embedUrl = $videoEntry->embed_url;
    638. 

  638.     $r->html_preview = $this->html_previewDailyMotion($r, $options);
    639. 

  639.     if ($this->usemimehtml)
    640. 

  640.       $r->html = $this->htmlDailyMotion($r, $options);
    641. 

  641.     else
    642. 

  642.       $r->html = $r->html_preview;
    643. 

  643.     return $r;
    644. 

  644.   }
    645. 

  645.   /// html du preview d'une video Daily Motion
    646. 

  646.   function html_previewDailyMotion($r, $options=array()) {
    647. 

  647.     return $this->html_previewYoutube($r, $options=array());
    648. 

  648.   }
    649. 

  649.   /// html d'une video Daily Motion
    650. 

  650.   function htmlDailyMotion($r, $options=array()) {
    651. 

  651.     return $this->htmlYoutube($r, $options=array());
    652. 

  652.   }
    653. 

  653. 

  654.   /// Gestion de la geometrie d'une video
    655. 

  655.   static function videoGetGeometry($filename,$geometry){
    656. 

  656.     if(strpos($filename,$GLOBALS['DATA_DIR'])===false)  $filename=$GLOBALS['DATA_DIR'].$filename;
    657. 

  657.     $geometry=rawurldecode($geometry);
    658. 

  658.     if(substr($geometry,-1)=='>')
    659. 

  659.       $geometry=substr($geometry,0,-1);
    660. 

  660.     $filefullsizeimage=$filename.'-fullsizeimage';
    661. 

  661.     if(!($t=@getimagesize($filefullsizeimage))){
    662. 

  662.       exec(FFMPEG.' -y -i "'.$filename.'" -f image2 -vcodec mjpeg -vframes 1 -an "'.$filefullsizeimage.'"');
    663. 

  663.       $t=@getimagesize($filefullsizeimage);
    664. 

  664.     }
    665. 

  665.     $oratio=$t[0]/$t[1];
    666. 

  666.     $size=explode('x',$geometry);
    667. 

  667.     $ratio=$size[0]/$size[1];
    668. 

  668.     if (!$size[0] || !$size[1])
    669. 

  669.       XLogs::critical('videoGetGeometry geometry imcomplete definition: '.$size[0].'x'.$size[1], '', true);
    670. 

  670.     if($oratio>$ratio){
    671. 

  671.       $w=$size[0];
    672. 

  672.       $h=round($t[1]*$size[0]/$t[0]);
    673. 

  673.     }else{
    674. 

  674.       $w=round($t[0]*$size[1]/$t[1]);
    675. 

  675.       $h=$size[1];
    676. 

  676.     }
    677. 

  677.     if($w%2) $w--;
    678. 

  678.     if($h%2) $h--;
    679. 

  679.     $geometry=$w.'x'.$h;
    680. 

  680.     return $geometry;
    681. 

  681.   }
    682. 

  682. 

  683.   /* Audio */
    684. 

  684.   /// Complete l'objet d'affichage dans le cas d'un fichier audio
    685. 

  685.   function displayAudio(&$r,&$value,&$options){
    686. 

  686.     global $DATA_URL;
    687. 

  687.     $r->isAudio=true;
    688. 

  688.     $r->audio_bitrate = $this->audio_bitrate;
    689. 

  689.     $r->prehear = TZR_AUDIOCONVERT.'?prehear=true&filename='.$r->shortfilename.'&type=.mp3';
    690. 

  690.     $r->fullaudio = TZR_AUDIOCONVERT.'?filename='.$r->shortfilename.'&type=.mp3';
    691. 

  691.     if (defined('HTML5MEDIA')) {
    692. 

  692.       $r->prehear_ogg = TZR_AUDIOCONVERT.'?mime=audio/ogg&prehear=true&filename='.$r->shortfilename.'&type=.ogg';
    693. 

  693.       $r->fullaudio_ogg = TZR_AUDIOCONVERT.'?mime=audio/ogg&filename='.$r->shortfilename.'&type=.ogg';
    694. 

  694.     }
    695. 

  695.     if ($this->usemimehtml) {
    696. 

  696.       $r->html_preview = $this->html_previewAudio($r, $options);
    697. 

  697.       $r->html = $this->htmlAudio($r, $options);
    698. 

  698.       if ($this->viewlink) {
    699. 

  699.         $r->html .= '<br>'.$r->html_default;
    700. 

  700.         $r->html_preview .= '<br>'.$r->html_default;
    701. 

  701.       }
    702. 

  702.     } else
    703. 

  703.       $r->html = $r->html_preview;
    704. 

  704.     return $r;
    705. 

  705.   }
    706. 

  706. 

  707.   /// html preview audio, $alt est un media alternatif (image)
    708. 

  708.   function html_previewAudio($r, $options=array(), $alt) {
    709. 

  709.     $options = array_merge(array('title' => $r->title, 'geometry' => $this->thumb_geometry, 'img' => TZR_SHARE_URL.'ico/mime/big-mp3.gif'), $options);
    710. 

  710.     if ($alt && is_object($alt) && $alt->raw)
    711. 

  711.       return $this->html_previewImage($alt, $options);
    712. 

  712.     $html = '<img src="'.$options['img'].'" alt="'.$r->title.'">';
    713. 

  713.     return $html;
    714. 

  714.   }
    715. 

  715.   /// html audio, $alt est un media alternatif (image)
    716. 

  716.   function htmlAudio(&$r, $options=array(), $alt) {
    717. 

  717.     $options = array_merge(array('audio_bitrate' => $this->audio_bitrate, 'audio_geometry' => $this->audio_geometry, 'geometry' => $this->geometry, 'autoplay' => $this->autoplay), $options);
    718. 

  718.     list($width, $height) = explode('x', str_replace('>', '', $options['audio_geometry']));
    719. 

  719.     list($altwidth, $altheight) = explode('x', str_replace('>', '', $options['geometry']));
    720. 

  720.     if ($options['audio_bitrate'] != $this->audio_bitrate) {
    721. 

  721.       $r->audio_bitrate = $options['audio_bitrate'];
    722. 

  722.       $this->displayAudio($r);
    723. 

  723.     }
    724. 

  724.     if ($alt && is_object($alt) && $alt->raw) {
    725. 

  725.       $options['geometry'] = $altwidth.'x'.($altheight-$height);
    726. 

  726.       $img = '<div class="tzr-audio-alt">' . $this->htmlImage($alt, $options) . '</div>';
    727. 

  727.     }
    728. 

  728.     if (defined('HTML5MEDIA')) {
    729. 

  729.       if ($this->audioReady($r, true))
    730. 

  730.         $audio = '
    731. 

  731.           <audio id="'.$r->varid.'" class="tzr-audio" '.($options['autoplay'] ? ' autoplay="autoplay"' : '').' controls="controls" height="'.$height.'" width="'.$width.'" style="height:'.$height.'px;width:'.$width.'px" preload="none">
    732. 

  732.             <source src="'.$r->fullaudio_ogg.'" type="audio/ogg" />
    733. 

  733.             <source src="'.$r->fullaudio.'" type="audio/mp3" />
    734. 

  734.           </audio>';
    735. 

  735.       else
    736. 

  736.         $audio = '
    737. 

  737.           <audio id="'.$r->varid.'" class="tzr-audio" '.($options['autoplay'] ? ' autoplay="autoplay"' : '').' controls="controls" height="'.$height.'" width="'.$width.'" style="height:'.$height.'px;width:'.$width.'px">
    738. 

  738.             <source src="'.$r->prehear_ogg.'" type="audio/ogg" />
    739. 

  739.             <source src="'.$r->prehear.'" type="audio/mp3" />
    740. 

  740.           </audio>';
    741. 

  741.       $html = '
    742. 

  742.         <div class="tzr-audio-div">
    743. 

  743.           '.@$img.$audio.'
    744. 

  744.           <script type="text/javascript">
    745. 

  745.             jQuery("#'.$r->varid.'").mediaelementplayer({pluginPath: "'.TZR_SHARE_URL.'js/jmediaelement/build/"});
    746. 

  746.           </script>
    747. 

  747.         </div>';
    748. 

  748.     }
    749. 

  749.     else
    750. 

  750.       $html = @$img.'<div style="height:27px;width:'.$width.'px;"><div id="'.$r->varid.'"></div></div><script type="text/javascript">swfobject.embedSWF("'.TZR_SHARE_URL.'flash/mpw_player.swf","'.$r->varid.'","'.$width.'","27","8","",{mp3:"'.urlencode(($this->audioReady($r,true)?$r->fullaudio:$r->prehear.'&bitrate='.$r->audio_bitrate)).'",autoplay:'.($options['autoplay']?'1':'0').'},{bgcolor:"000000"});</script>';
    751. 

  751.     return $html;
    752. 

  752.   }
    753. 

  753.   /// Determine si le fichier est directement disponible dans la format. Si 'force' a true et fichier non disponible, lance la tache
    754. 

  754.   function audioReady($r, $forceConvert=true){
    755. 

  755.     if(!XFileDef::isAudio($r->mime))
    756. 

  756.       return false;
    757. 

  757.     $ready = true;
    758. 

  758.     $filename_cache = $r->filename.'-'.md5($r->audio_bitrate.'audio/mpeg').'-cache';
    759. 

  759.     if(!file_exists($filename_cache) || (filemtime($r->filename)>filemtime($filename_cache))){
    760. 

  760.       $ready = false;
    761. 

  761.       if($forceConvert){
    762. 

  762.         $ffmpeg = FFMPEG.' -y -i '.$r->filename.' -ab '.$r->audio_bitrate.'k -ar 44100 -f mp3 '.$filename_cache.';';
    763. 

  763.       }
    764. 

  764.     }
    765. 

  765.     if (defined('HTML5MEDIA')) {
    766. 

  766.       $filename_cache=$r->filename.'-'.md5($r->audio_bitrate.'audio/ogg').'-cache';
    767. 

  767.       if(!file_exists($filename_cache) || (filemtime($r->filename)>filemtime($filename_cache))){
    768. 

  768.         $ready = false;
    769. 

  769.         if($forceConvert){
    770. 

  770.           $ffmpeg .= FFMPEG.' -y-i '.$r->filename.' -ab '.$r->audio_bitrate.'k  -acodec libvorbis -f ogg '.$filename_cache;
    771. 

  771.         }
    772. 

  772.       }
    773. 

  773.     }
    774. 

  774.     if ($ffmpeg) {
    775. 

  775.       $s=new XModScheduler(array('tplentry'=>TZR_RETURN_DATA));
    776. 

  776.       $s->createIdleShellJob(md5($ffmpeg),'Audio encoding',$ffmpeg,'');
    777. 

  777.     }
    778. 

  778.     return $ready;
    779. 

  779.   }
    780. 

  780.   /// Renvoie la duree d'une video ou d'un audio en secondes
    781. 

  781.   function getDuration($file,$mime){
    782. 

  782.     if(!$file || !file_exists($file)) return 0;
    783. 

  783.     elseif(XFileDef::isVideo($mime) || XFileDef::isAudio($mime)){
    784. 

  784.       $ffmpeg=exec(FFMPEG.' -i '.$file.' 2>&1|grep "Duration"|sed \'s/^.*Duration: \(.*\)\.[0-9],.*$/\1/\'');
    785. 

  785.       if(!empty($ffmpeg)) list($h,$m,$s)=explode(':',$ffmpeg);
    786. 

  786.       else return 0;
    787. 

  787.       if($h && $m && $s) return intval($h)*3600+intval($m)*60+intval($s);
    788. 

  788.     }
    789. 

  789.     return 0;
    790. 

  790.   }
    791. 

  791.   
    792. 

  792.   /* PDF */
    793. 

  793.   /// Complete l'objet d'affichage dans le cas d'une image
    794. 

  794.   function displayPDF(&$r,&$value,&$options){
    795. 

  795.     $resizer=$this->getResizer($r->shortfilename,$r->mime,$r->originalname);
    796. 

  796.     if(!empty($resizer) && !empty($resizer['resizer'])) {
    797. 

  797.       $r->resizer=$resizer['resizer'];
    798. 

  798.       $r->weresizer=$resizer['weresizer'];
    799. 

  799.     }
    800. 

  800.     $r->isPDF = true;
    801. 

  801.     $r->html = $r->html_default;
    802. 

  802.     return $r;
    803. 

  803.   }
    804. 

  804. 

  805.   /// Affichage d'un pdf Calaméo
    806. 

  806.   function displayCalameo(&$r, $value, $options) {
    807. 

  807.     $book_id = substr($r->file, 8);
    808. 

  808.     $params = array(
    809. 

  809.       'action' => 'API.getBookInfos',
    810. 

  810.       'apikey' => CALAMEO_PUBLIC_KEY, // a définir dans le local.inc
    811. 

  811.       'book_id' => $book_id,
    812. 

  812.       'output' => 'PHP'
    813. 

  813.     );
    814. 

  814.     $url = 'http://api.calameo.com/1.0?';
    815. 

  815.     $signature = CALAMEO_SECRET_KEY; // a définir dans le local.inc
    816. 

  816.     foreach ($params as $key => $value) {
    817. 

  817.       $url .= "$key=$value&";
    818. 

  818.       $signature .= "$key$value";
    819. 

  819.     }
    820. 

  820.     $url .= 'signature=' . md5($signature);
    821. 

  821.     $response = unserialize(file_get_contents($url));
    822. 

  822.     $response = $response['response'];
    823. 

  823.     if ($response['status'] == 'error') {
    824. 

  824.       XLogs::notice(__CLASS__.'::'.__FUNCTION__, "error code {$response['error']['code']}, {$response['error']['message']}");
    825. 

  825.       $r->error = true;
    826. 

  826.       return $r;
    827. 

  827.     }
    828. 

  828.     $r->error = false;
    829. 

  829.     $r->isCalameo = true;
    830. 

  830.     $r->mime = 'application/pdf';
    831. 

  831.     $r->resizer = '';
    832. 

  832.     $r->preview = $response['content']['ThumbUrl'];
    833. 

  833.     $r->title = $response['content']['Name'];
    834. 

  834.     $r->text = $r->title;
    835. 

  835.     $r->externalUrl = $response['content']['ViewUrl'];
    836. 

  836.     $r->downloadUrl = str_replace('read', 'download', $response['content']['ViewUrl']);
    837. 

  837.     $r->fullwidth = $response['content']['Width'];
    838. 

  838.     $r->fullheight = $response['content']['Height'];
    839. 

  839.     $r->dltarget = 'calameo'; // target pour le lien download, si pdf non dispo
    840. 

  840.     $r->html_preview = $this->html_previewCalameo($r, $options);
    841. 

  841.     if ($this->usemimehtml)
    842. 

  842.       $r->html = $this->htmlCalameo($r, $options);
    843. 

  843.     else
    844. 

  844.       $r->html = $r->html_preview;
    845. 

  845.     return $r;
    846. 

  846.   }
    847. 

  847. 

  848.   /// html preview calaméo
    849. 

  849.   function html_previewCalameo($r, $options=array()) {
    850. 

  850.     if ($r->error)
    851. 

  851.       return '';
    852. 

  852.     if (isset($options['geometry'])) {
    853. 

  853.       list($width, $height) = explode('x', str_replace('>', '', $options['geometry']));
    854. 

  854.       $width = (integer)$width;
    855. 

  855.       $height = (integer)$height;
    856. 

  856.       $ratio = min($width / $r->fullwidth, $height / $r->fullheight);
    857. 

  857.       $width = (integer)($ratio * $r->fullwidth);
    858. 

  858.       $height = (integer)($ratio * $r->fullwidth);
    859. 

  859.     } else {
    860. 

  860.       $width = TZR_THUMB_SIZE;
    861. 

  861.       $height = TZR_THUMB_SIZE;
    862. 

  862.     }
    863. 

  863.     return '<img src="'.$r->preview.'" width="'.$width.'" height="'.$height.'" alt="'.$r->title.'" class="tzr-externalfile" rel="'.$r->file.'">';
    864. 

  864.   }
    865. 

  865. 

  866.   /// html calaméo
    867. 

  867.   function htmlCalameo($r, $options=array()) {
    868. 

  868.     if ($r->error)
    869. 

  869.       return '';
    870. 

  870.     $geometry = @$options['geometry'] ? $options['geometry'] : $this->image_geometry;
    871. 

  871.     list($width, $height) = explode('x', $geometry);
    872. 

  872.     $width = (integer)$width;
    873. 

  873.     $height = (integer)$height;
    874. 

  874.     return '<iframe id="'.$r->varid.'" src="'.$r->externalUrl.'" wmode="transparent" style="width:'.$width.'px;height:'.$height.'px"></iframe>';
    875. 

  875.   }
    876. 

  876. 

  877.   /// Tag les valeurs IPTC/XMP d'un fichier via un tableau de donnée
    878. 

  878.   static function setFileMetaWithArray($data,$file,$tmpfile=NULL,$clean=false){
    879. 

  879.     if(empty($file)) return false;
    880. 

  880.     if($tmpfile=='auto'){
    881. 

  881.       $infos=pathinfo($file);
    882. 

  882.       $tmpfile=TZR_TMP_DIR.uniqid('metafile').'.'.$infos['extension'];
    883. 

  883.       copy($file,$tmpfile);
    884. 

  884.     }elseif($tmpfile){
    885. 

  885.       copy($file,$tmpfile);
    886. 

  886.     }else{
    887. 

  887.       $tmpfile=$file;
    888. 

  888.     }
    889. 

  889. 

  890.     if($clean) XFileDef::cleanFileMeta($tmpfile);
    891. 

  891.     
    892. 

  892.     $mimeClasse=XMimeTypes::getInstance();
    893. 

  893.     $mime=$mimeClasse->getValidMime(NULL,$tmpfile,NULL);
    894. 

  894.     if($mime=='image/jpeg'){
    895. 

  895.       $meta=XFileDef::loadMeta($tmpfile);
    896. 

  896.       if(!empty($data['IPTC'])){
    897. 

  897. 	foreach($data['IPTC'] as $tag=>$value){
    898. 

  898. 	  $meta->setIPTCProperty($tag,$value);
    899. 

  899. 	}
    900. 

  900.       }
    901. 

  901.       if(!empty($data['XMP'])){
    902. 

  902. 	foreach($data['XMP'] as $tag=>$value){
    903. 

  903. 	  $meta->setXMPProperty($tag,$value);
    904. 

  904. 	}
    905. 

  905.       }
    906. 

  906.       $meta->save();
    907. 

  907.     }
    908. 

  908.     return $tmpfile;
    909. 

  909.   }
    910. 

  910.   
    911. 

  911.   /// Tag les valeurs IPTC/XMP d'un fichier via un template
    912. 

  912.   static function setFileMetaWithTemplate($tpl,$file,$tmpfile=NULL,$standards=array('IPTC','XMP'),$clean=false){
    913. 

  913.     if(empty($file)) return false;
    914. 

  914.     if($tmpfile=='auto'){
    915. 

  915.       $infos=pathinfo($file);
    916. 

  916.       $tmpfile=TZR_TMP_DIR.uniqid('metafile').'.'.$infos['extension'];
    917. 

  917.       copy($file,$tmpfile);
    918. 

  918.     }elseif($tmpfile){
    919. 

  919.       copy($file,$tmpfile);
    920. 

  920.     }else{
    921. 

  921.       $tmpfile=$file;
    922. 

  922.     }
    923. 

  923. 

  924.     if($clean) XFileDef::cleanFileMeta($tmpfile);
    925. 

  925. 

  926.     $mimeClasse=XMimeTypes::getInstance();
    927. 

  927.     $mime=$mimeClasse->getValidMime(NULL,$tmpfile,NULL);
    928. 

  928.     if($mime=='image/jpeg' && !empty($standards)){
    929. 

  929.       $tplmeta=XFileDef::loadMeta($tpl);
    930. 

  930.       $meta=XFileDef::loadMeta($tmpfile);
    931. 

  931.       // Traitement des tags IPTC
    932. 

  932.       if(in_array('IPTC',$standards)){
    933. 

  933. 	$tags=$tplmeta->getIPTCAll();
    934. 

  934. 	foreach($tags as $tag=>$value){
    935. 

  935. 	  $meta->setIPTCProperty($value['IPTC_Type'],$value['RecData']);
    936. 

  936. 	}
    937. 

  937.       }
    938. 

  938.       
    939. 

  939.       // Traitement des tags XMP
    940. 

  940.       if(in_array('XMP',$standards)){
    941. 

  941. 	$tags=$tplmeta->xmp_xpath->query($tplmeta->xmp_descr_path.'/'.$tplmeta->xmp_descr_node.'/*');
    942. 

  942. 	foreach($tags as $tag){
    943. 

  943. 	  list($prefix,$foo)=explode(':',$tag->nodeName);
    944. 

  944. 	  if($prefix!='dc') continue;
    945. 

  945. 	  $n=$meta->xmp_xpath->query($meta->xmp_descr_path.'/'.$meta->xmp_descr_node.'/'.$tag->nodeName);
    946. 

  946. 	  if($n->length){
    947. 

  947. 	    $p=$n->parentNode;
    948. 

  948. 	    $p->removeChild($n);
    949. 

  949. 	  }else{
    950. 

  950. 	    $d=$meta->getXMPDescriptionFromPrefix($prefix);
    951. 

  951. 	    if(empty($d)) $d=$meta->addXMPDescription($prefix,$tag->parentNode->lookupNamespaceURI($prefix));
    952. 

  952. 	    $p=$d;
    953. 

  953. 	  }
    954. 

  954. 	  $p->appendChild($meta->xmp_dom->importNode($tag,true));
    955. 

  955. 	}
    956. 

  956.       }
    957. 

  957.       $meta->save();
    958. 

  958.     }
    959. 

  959.     return $tmpfile;
    960. 

  960.   }
    961. 

  961. 

  962.   /// Tag les valeurs IPTC/XMP d'un fichier via un display
    963. 

  963.   static function setFileMetaWithDisplay($d,$file,$tmpfile=NULL,$standards=array('IPTC','XMP'),$clean=false){ 
    964. 

  964.     if(empty($file)) return false;
    965. 

  965.     if($tmpfile=='auto'){
    966. 

  966.       $infos=pathinfo($file);
    967. 

  967.       $tmpfile=TZR_TMP_DIR.uniqid('metafile').'.'.$infos['extension'];
    968. 

  968.       copy($file,$tmpfile);
    969. 

  969.     }elseif($tmpfile){
    970. 

  970.       copy($file,$tmpfile);
    971. 

  971.     }else{
    972. 

  972.       $tmpfile=$file;
    973. 

  973.     }
    974. 

  974. 

  975.     if($clean) XFileDef::cleanFileMeta($tmpfile);
    976. 

  976. 

  977.     $mimeClasse=XMimeTypes::getInstance();
    978. 

  978.     $mime=$mimeClasse->getValidMime(NULL,$file,NULL);
    979. 

  979.     if($mime=='image/jpeg' && !empty($standards)){
    980. 

  980.       $meta=XFileDef::loadMeta($tmpfile);
    981. 

  981.       if(!isset($d['fields_object'])){
    982. 

  982. 	foreach($d as $i=>&$dd){
    983. 

  983. 	  foreach($dd['fields_object'] as $i=>&$f){
    984. 

  984. 	    $fdef=&$f->fielddef;
    985. 

  985. 	    $fdef->setMetaFromValue($meta,$dd['o'.$fdef->field],$standards);
    986. 

  986. 	  }
    987. 

  987. 	}
    988. 

  988.       }else{
    989. 

  989. 	foreach($d['fields_object'] as $i=>&$f){
    990. 

  990. 	  $fdef=&$f->fielddef;
    991. 

  991. 	  $fdef->setMetaFromValue($meta,$d['o'.$fdef->field],$standards);
    992. 

  992. 	}
    993. 

  993.       }
    994. 

  994.       $meta->save();
    995. 

  995.     }
    996. 

  996.     return $tmpfile;
    997. 

  997.   }
    998. 

  998. 

  999.   /// Nettoie tous les metas d'un fichier
    1000. 

  1000.   static function cleanFileMeta($file){
    1001. 

  1001.     $mimeClasse=XMimeTypes::getInstance();
    1002. 

  1002.     $mime=$mimeClasse->getValidMime(NULL,$file,NULL);
    1003. 

  1003.     if($mime=='image/jpeg'){
    1004. 

  1004.       system(TZR_MOGRIFY_RESIZER.' +profile "*" '.$file.' '.$file.';'. TZR_MOGRIFY_RESIZER.' +profile "*" '.$file.'_ld '.$file.'_ld');
    1005. 

  1005.     }
    1006. 

  1006.   }
    1007. 

  1007. 

  1008.   // generation du nom du fichier
    1009. 

  1009.   //
    1010. 

  1010.   function filename($value,$test=false,$testfinal=false,$secondaryroot=NULL) {
    1011. 

  1011.     global $DATA_DIR;
    1012. 

  1012.     $ar=NULL;
    1013. 

  1013.     if($value=='') return NULL;
    1014. 

  1014.     if($value==TZR_UNCHANGED) return NULL;
    1015. 

  1015.     $langdata = XShell::getLangData();
    1016. 

  1016.     @list($file,$mime,$originalname) = @explode(';',$value);
    1017. 

  1017.     if($file=='') return NULL;
    1018. 

  1018.     if($test) $this->_checkDir();
    1019. 

  1019.     umask(0000);
    1020. 

  1020.     $root=$this->table;
    1021. 

  1021.     if(!empty($secondaryroot)) {
    1022. 

  1022.       $root='A_'.$this->table.'/'.$secondaryroot;
    1023. 

  1023.     }
    1024. 

  1024.     $root.='/'.$this->field;
    1025. 

  1025.     $subdir=md5($file);
    1026. 

  1026.     while(strlen($subdir)>=16) {
    1027. 

  1027.       $tmp=substr($subdir,0,2);
    1028. 

  1028.       $root.='/'.$tmp;
    1029. 

  1029.       $subdir=substr($subdir,16);
    1030. 

  1030.     }
    1031. 

  1031.     if($test) XDir::mkdir($DATA_DIR.$root, false);
    1032. 

  1032.     $filename=$root.'/'.$file;
    1033. 

  1033.     if($test || $testfinal) {
    1034. 

  1034.       if(file_exists($DATA_DIR.$filename)) {
    1035. 

  1035.         $ar=$filename;
    1036. 

  1036.       } elseif($test) {
    1037. 

  1037.         $ar=NULL;
    1038. 

  1038.       }
    1039. 

  1039.     } else {
    1040. 

  1040.       $ar=$filename;
    1041. 

  1041.     }
    1042. 

  1042.     return $ar;
    1043. 

  1043.   }
    1044. 

  1044. 

  1045.   /// Generation du champ pour modification du fichier
    1046. 

  1046.   function my_edit(&$value,&$options) {
    1047. 

  1047.     $lang = XShell::getLangUser();
    1048. 

  1048.     $r=$this->_newXFieldVal($options,true);
    1049. 

  1049.     if(isset($options['intable'])) {
    1050. 

  1050.       return $r;
    1051. 

  1051.       $o = $options['intable'];
    1052. 

  1052.       $fname=$this->field.'['.$o.']';
    1053. 

  1053.       $hiddenname=$this->field.'_HID['.$o.']';
    1054. 

  1054.     } elseif(!empty($options['fieldname'])) {
    1055. 

  1055.       $fname=$options['fieldname'];
    1056. 

  1056.       $hiddenname=$options['fieldname'].'_HID';
    1057. 

  1057.     } else {
    1058. 

  1058.       $fname=$this->field;
    1059. 

  1059.       $hiddenname=$this->field.'_HID';
    1060. 

  1060.     }
    1061. 

  1061.     $r->raw=$value;
    1062. 

  1062.     $this->_checkDir();
    1063. 

  1063.     $varid=$r->varid;
    1064. 

  1064.     $disp=$this->my_display($value,$options);
    1065. 

  1065.     // Titre à part
    1066. 

  1066.     $txt='<table class="tzr-xfiledef"><tr>';
    1067. 

  1067.     if($this->usealt)
    1068. 

  1068.       $txt.='<td><label>'.XLabels::getSysLabel('general','title','text').'</label></td><td id="'.$varid.'-tdtitle"><input type="text" name="'.$fname.'_title" value="'.$disp->title.'"/></td></tr><tr><td><label>'.XLabels::getSysLabel('xfielddef','xfiledef','text').'</label></td>';
    1069. 

  1069.     // Input fichier + bouton parcourir console
    1070. 

  1070.     $txt.='<td id="'.$varid.'-tdfile"'.($disp->isExternal?' style="display:none"':'').'><input type="file" name="'.$fname.'" accept="'.$this->accept.'"'.(!empty($this->maxlength)?' maxlength="'.$this->maxlength.'"':'').' id="'.$varid.'"><br/>';
    1071. 

  1071.     if(XShell::admini_mode() && $this->browsemods) {
    1072. 

  1072.       $url=$GLOBALS['TZR_SESSION_MANAGER']::complete_self().'moid='.XModule::getMoid(XMODADMIN_TOID).'&function=modulesList&tplentry=br&_nonav=1&_nohistory=1&template=basic/source-file.html'.
    1073. 

  1073.       '&skip=1&ajaxurl='.rawurlencode($GLOBALS['TZR_SESSION_MANAGER']::complete_self().'&function=browseFiles&tplentry=br&template=basic/source-file-ajax.html'.
    1074. 

  1074.                                       '&pagesize=20&skip=1&recipientid='.$varid.'&_nonav=1&_nohistory=1&selectedprops[published]=1'.
    1075. 

  1075.                                       '&selectedtypes[]=XFileDef&selectedtypes[]=XFolderDef&selectedop=OR');
    1076. 

  1076.       if($this->sourcemodule) $url.='&toid=xx&ajaxmoid='.$this->sourcemodule;
    1077. 

  1077.       else $url.='&toid[]=25&toid[]=8001';
    1078. 

  1078.       $txt.='<input type="button" value="'.XLabels::getSysLabel('xmodule','browsemods','text').'" onclick="window.open(\''.$url.'\',\'\',\'width=655,height=550,menubar=0,resizable=1,scrollbars=1\');">';
    1079. 

  1079.     }
    1080. 

  1080.     // Fichier externe
    1081. 

  1081.     if ($this->allow_externalfile) {
    1082. 

  1082.       $txt .= '<input type="button" value="'.XLabels::getSysLabel('xfielddef','externalfile').'" onclick="jQuery(\'#'.$r->varid.'-tdfile, #'.$r->varid.'-tdexternal, #'.$r->varid.'-trcancel\').toggle()">';
    1083. 

  1083.     }
    1084. 

  1084.     $txt.='</td>';
    1085. 

  1085.     if (XShell::admini_mode() && $this->browsemods) {
    1086. 

  1086.       $txt .= '<td id="'.$r->varid.'-tdbrowsemods"></td>';
    1087. 

  1087.     }
    1088. 

  1088.     if ($this->allow_externalfile) {
    1089. 

  1089.       $txt .= '<td id="'.$r->varid.'-tdexternal"'.($disp->isExternal?'':' style="display:none"').'>'.XLabels::getSysLabel('xfielddef','externalfile').' : <input type="text" id="'.$r->varid.'-external" value="'.$disp->externalUrl.'" name="'.$hiddenname.'[external]" size="50" maxsize="200"/></td>';
    1090. 

  1090.     }
    1091. 

  1091.     $txt.='</tr>';
    1092. 

  1092.     if (XShell::admini_mode() && $this->browsemods || $this->allow_externalfile) {
    1093. 

  1093.       $txt.='<tr '.($disp->isExternal?'':' style="display:none"').' id="'.$r->varid.'-trcancel"><td colspan="4"><input type="button" value="'.XLabels::getSysLabel('general','cancel').'" onclick="jQuery(\'#'.$r->varid.'-tdexternal,#'.$r->varid.'-trcancel\').hide();jQuery(\'#'.$r->varid.'-tdbrowsemods\').html(\'\').hide();jQuery(\'#'.$r->varid.'-tdfile\').show();jQuery(\'#'.$r->varid.'-from, #'.$r->varid.'-external\').val(\'\')"></td></tr>';
    1094. 

  1094.     }
    1095. 

  1095.     $txt.='</tr></table>';
    1096. 

  1096.     $txt.='<input type="hidden" id="'.$r->varid.'-old" name="'.$hiddenname.'[old]" value="'.$value.'"/>';
    1097. 

  1097.     $txt.='<input id="'.$varid.'-from" type="hidden" name="'.$hiddenname.'[from]" value=""/>';
    1098. 

  1098.     // Bouton de supression
    1099. 

  1099.     if($disp->html!='' && !$this->compulsory)
    1100. 

  1100.       $txt.=' '.XLabels::getSysLabel('xfielddef','detach_file').' : <input type="checkbox" name="'.$fname.'_del" class="checkbox"/><br/>';
    1101. 

  1101.     if ($this->compulsory) {
    1102. 

  1102.       $txt .= '<script type="text/javascript">TZR.addValidator(["'.$r->varid.'","","'.addslashes($this->label).'","'.XIni::get('error_color').'","XFileDef","","'.$this->browsemods.'","'.$this->allow_externalfile.'"]);</script>';
    1103. 

  1103.     }
    1104. 

  1104.     $r->html=$txt;
    1105. 

  1105.     $r->originalname=$disp->originalname;
    1106. 

  1106.     $r->filename=$disp->filename;
    1107. 

  1107.     $r->mime=$disp->mime;
    1108. 

  1108. 

  1109.     if(XFileDef::isImage($r->mime) || get_class($this)=='XImageDef') 
    1110. 

  1110.       $this->editImage($r,$value,$options,$disp,$fname,$hiddenname);
    1111. 

  1111.     elseif($disp->mime=='text/html' || $disp->mime=='text/plain') 
    1112. 

  1112.       $this->editHTML($r,$value,$options,$disp,$fname,$hiddenname);
    1113. 

  1113.     else 
    1114. 

  1114.       $r->html .= $disp->html_preview;
    1115. 

  1115.     return $r;
    1116. 

  1116.   }
    1117. 

  1117. 

  1118.   /// Complete l'objet d'edition dans le cas d'une image
    1119. 

  1119.   function editImage(&$r,&$value,&$options,&$disp,$fname,$hiddenname){
    1120. 

  1120.     $r->isImage=true;
    1121. 

  1121.     if(!empty($this->image_crop_ratio)){
    1122. 

  1122.       $r->html.='<div id="'.$r->varid.'-cropinfo" class="tzr-xfiledef-cropinfo"><a href="#" onclick="return false;">'.XLabels::getSysLabel('xfielddef','image_crop').'</a></div>';
    1123. 

  1123.       $r->html.='<script type="text/javascript">TZR.Image.activeCrop(\''.$r->varid.'\',\''.$this->image_crop_ratio.'\');</script>';
    1124. 

  1124.     }
    1125. 

  1125.     if($disp->html){
    1126. 

  1126.       $px=' '.XLabels::getSysLabel('general','pixels','text');
    1127. 

  1127.       $r->html='<table><tr><td colspan="2">'.$r->html.'</td></tr><tr><td><img src="'.$disp->resizer.'&geometry='.TZR_THUMB_SIZE.'x'.TZR_THUMB_SIZE.'%3E"></td><td>'.
    1128. 

  1128. 	$disp->html_default.'<br>'.
    1129. 

  1129. 	XLabels::getSysLabel('xfielddef','file_size').' : '.round($this->getFileSize($r)/1024).' Ko<br>'.
    1130. 

  1130. 	XLabels::getSysLabel('general','width','text').' : '.$this->getImageSize($r,'fullwidth').$px.'<br>'.
    1131. 

  1131. 	XLabels::getSysLabel('general','height','text').' : '.$this->getImageSize($r,'fullheight').$px.
    1132. 

  1132. 	'</td></tr></table>';
    1133. 

  1133.     }
    1134. 

  1134.   }
    1135. 

  1135. 

  1136.   /// Complete l'objet d'édition dans le cas d'un fichier HTML
    1137. 

  1137.   function editHTML(&$r,&$value,&$options,&$disp,$fname,$hiddenname){
    1138. 

  1138.     if($options['fmoid']){
    1139. 

  1139.       $edition='';
    1140. 

  1140.       $tmpname=md5(session_id().$disp->table.$disp->field.$options['oid']);
    1141. 

  1141.       copy($disp->filename, TZR_TMP_DIR.$tmpname);
    1142. 

  1142.       $dla=$this->getDownloader($tmpname, $disp->mime, $disp->originalname, $disp->originalname, $options['fmoid']);
    1143. 

  1143.       $dl=$dla[0].'&tmp=1&disp=inline';
    1144. 

  1144.       $url=$GLOBALS['TZR_SESSION_MANAGER']::complete_self(true,true).'&function=edit&selectedfields[]='.$this->field.'&moid='.$options['fmoid'].'&template=popfileedit.html&field='.$this->field.'&tplentry=br&oid='.$options['oid'];
    1145. 

  1145.       $upl=TZR_FILE_EDITOR_UPLOADER.'?moid='.$options['fmoid'].'&table='.$disp->table.'&field='.$disp->field.'&oid='.$options['oid'].'&moid='.$options['fmoid'];
    1146. 

  1146.       $edition.='<input type="hidden" name="'.$hiddenname.'[editflag]" value="no"/>';
    1147. 

  1147.       $edition.=' <a href="#" onclick="TZR.openhtmlfileeditor({uniqid:\''.XShell::uniqid().'\',url:\''.$url.'\',uploader:\''.$upl.'\', editflag:\''.$hiddenname.'[editflag]\'}); return false;">'.XLabels::getSysLabel('general','edit','text').'</a>';
    1148. 

  1148.       $r->html.=$disp->html.$edition;
    1149. 

  1149.     }else{
    1150. 

  1150.       $r->html.=$disp->html;
    1151. 

  1151.     }
    1152. 

  1152.   }
    1153. 

  1153. 

  1154.   function sqltype() {
    1155. 

  1155.     return 'varchar(200)';
    1156. 

  1156.   }
    1157. 

  1157. 

  1158.   /// Suppression de la donnee
    1159. 

  1159.   function delete($value, $oid) {
    1160. 

  1160.     global $DATA_DIR;
    1161. 

  1161.     $langdata = XShell::getLangData();
    1162. 

  1162. 

  1163.     // calcul du nom du fichier associe
    1164. 

  1164.     $filename= $this->filename($value,true);
    1165. 

  1165.     if($filename) {
    1166. 

  1166.       if(file_exists($DATA_DIR.$filename)) {
    1167. 

  1167. 	XLogs::debug('[XFileDef::delete]unlink('.$DATA_DIR.$filename.')');
    1168. 

  1168. 	@unlink($DATA_DIR.$filename);
    1169. 

  1169.       }
    1170. 

  1170.     }
    1171. 

  1171.     return 1;
    1172. 

  1172.   }
    1173. 

  1173. 

  1174.   function post_edit($value,$options) {
    1175. 

  1175.     global $DATA_DIR;
    1176. 

  1176.     $p=new XParam($options,array('del'=>true));
    1177. 

  1177.     $r=$this->_newXFieldVal($options);
    1178. 

  1178.     $langdata=XShell::getLangData();
    1179. 

  1179.     $hidden=$options[$this->field.'_HID'];
    1180. 

  1180.     $del=$p->get('del');
    1181. 

  1181.     $mimeClasse=XMimeTypes::getInstance();
    1182. 

  1182. 

  1183.     // Verification que les repertoires existent
    1184. 

  1184.     $oid=$p->get('oid');
    1185. 

  1185.     // Calcul du nom du fichier associe
    1186. 

  1186.     list($t,$f)=explode(':',$oid);
    1187. 

  1187.     if($this->translatable) $retval=$langdata.'.'.$f;
    1188. 

  1188.     else $retval=$f;
    1189. 

  1189.     $oldfile=$this->filename($retval,true);
    1190. 

  1190.     $file=$this->filename($retval,false);
    1191. 

  1191.     if($file) $filename=$DATA_DIR.$file;
    1192. 

  1192.     $oldfilename='';
    1193. 

  1193.     if($oldfile) $oldfilename=$DATA_DIR.$oldfile;
    1194. 

  1194.     $from=$hidden['from'];
    1195. 

  1195.     $link=(@$hidden['link']?true:false);
    1196. 

  1196.     if(!empty($from)) {
    1197. 

  1197.       // Le fichier est déjà sur le serveur et doit etre dupliqué
    1198. 

  1198.       @list($url,$mime,$name)=@explode(';',$from);
    1199. 

  1199.       parse_str($url,$infos);
    1200. 

  1200.       $infos=pathinfo($url);
    1201. 

  1201.       if(empty($mime)) $mime=@$infos['mime'];
    1202. 

  1202.       if(substr($url,0,1)!='/') $url=TZR_WWW_DIR.$url;
    1203. 

  1203.       if($link) $tmp_name=$from;
    1204. 

  1204.       else {
    1205. 

  1205.       	$tmp_name=TZR_TMP_DIR.uniqid();
    1206. 

  1206.       	copy($url,$tmp_name);
    1207. 

  1207.       }
    1208. 

  1208.       $upload_type=$mime;
    1209. 

  1209.       $upload_filename=$tmp_name;
    1210. 

  1210.       if(!empty($name)){
    1211. 

  1211.       	$upload_name=$name;
    1212. 

  1212.       	$upload_type=$mimeClasse->getValidMime(NULL,$upload_filename,NULL);
    1213. 

  1213.       }elseif(!empty($infos['extension'])){
    1214. 

  1214.       	$upload_name=$infos['basename'];
    1215. 

  1215.       	$upload_type='';
    1216. 

  1216.       }else{
    1217. 

  1217.       	$upload_type=$mimeClasse->getValidMime(NULL,$upload_filename,NULL);
    1218. 

  1218.       	$upload_name=$infos['basename'].'.'.$mimeClasse->get_extension($upload_type);
    1219. 

  1219.       }
    1220. 

  1220.       $upload_filename_del='off';
    1221. 

  1221.       $upload_title=$p->get($this->field.'_title');
    1222. 

  1222.       $upload_size=@filesize($tmp_name);
    1223. 

  1223.     } elseif(is_string($value) && substr($value,0,7)=='http://') {
    1224. 

  1224.       // Le fichier est une url
    1225. 

  1225.       $tmp_name=TZR_TMP_DIR.uniqid();
    1226. 

  1226.       $content=file_get_contents($value);
    1227. 

  1227.       file_put_contents($tmp_name,$content);
    1228. 

  1228.       $upload_filename=$tmp_name;
    1229. 

  1229.       $infos=parse_url($value);
    1230. 

  1230.       $infos=pathinfo($infos['path']);
    1231. 

  1231.       $headers = get_headers($value,1);
    1232. 

  1232.       if($headers && $headers['Content-disposition'] && preg_match('/filename=(.*)$/',$headers['Content-disposition'],$eregs) && $eregs[1]){
    1233. 

  1233. 	$upload_name = $eregs[1];
    1234. 

  1234. 	$upload_type = $mimeClasse->getValidMime($headers['Content-Type'],$upload_filename,$upload_name);
    1235. 

  1235.       }elseif($infos['extension']){
    1236. 

  1236. 	$upload_name = $infos['basename'];
    1237. 

  1237. 	$upload_type = '';
    1238. 

  1238.       }else{
    1239. 

  1239. 	$upload_type = $mimeClasse->getValidMime(NULL,$upload_filename,NULL);
    1240. 

  1240. 	$upload_name = $infos['basename'].'.'.$mimeClasse->get_extension($upload_type);
    1241. 

  1241.       }
    1242. 

  1242.       $upload_filename_del='off';
    1243. 

  1243.       $upload_title=NULL;
    1244. 

  1244.       $upload_size=@filesize($tmp_name);
    1245. 

  1245.     } elseif(is_string($value) && file_exists($value)) {
    1246. 

  1246.       // Le fichier est un chemin sur le serveur
    1247. 

  1247.       $infos=pathinfo($value);
    1248. 

  1248.       $upload_filename=$value;
    1249. 

  1249.       if($infos['extension']){
    1250. 

  1250. 	$upload_name=$infos['basename'];
    1251. 

  1251. 	$upload_type='';
    1252. 

  1252.       }else{
    1253. 

  1253. 	$upload_type=$mimeClasse->getValidMime(NULL,$upload_filename,NULL);
    1254. 

  1254. 	$upload_name=$infos['basename'].'.'.$mimeClasse->get_extension($upload_type);
    1255. 

  1255.       }
    1256. 

  1256.       $upload_filename_del='off';
    1257. 

  1257.       $upload_title=NULL;
    1258. 

  1258.       $upload_size=@filesize($value);
    1259. 

  1259.     } elseif(is_array($value)) {
    1260. 

  1260.       $upload_filename=$value['tmp_name'];
    1261. 

  1261.       $upload_type=$value['type'];
    1262. 

  1262.       $upload_name=$value['name'];
    1263. 

  1263.       $upload_filename_del='off';
    1264. 

  1264.       $upload_title=$value['title'];
    1265. 

  1265.       $upload_size=$value['size'];
    1266. 

  1266.     } elseif(isset($hidden['editflag']) && $hidden['editflag']=='yes'){
    1267. 

  1267.       // cas d'un fichier édité (dans l'admin)
    1268. 

  1268.       $tmpfile=TZR_TMP_DIR.md5(session_id().$this->table.$this->field.$options['oid']);
    1269. 

  1269.       $upload_filename=$tmpfile;
    1270. 

  1270.       list($void, $upload_type , $upload_name) = explode(';', $hidden['old']);
    1271. 

  1271.       $upload_filename_del='off';
    1272. 

  1272.       $upload_title=NULL;
    1273. 

  1273.       $upload_size=@filesize($tmpfile);
    1274. 

  1274.     } elseif($hidden['external']){
    1275. 

  1275.       return $this->post_editExternal($value,$options);
    1276. 

  1276.     } else {
    1277. 

  1277.       // Fichier uploadé via formulaire
    1278. 

  1278.       $upload_filename=@$_FILES[$this->field]['tmp_name'];
    1279. 

  1279.       $upload_type=@$_FILES[$this->field]['type'];
    1280. 

  1280.       $upload_name=@$_FILES[$this->field]['name'];
    1281. 

  1281.       $upload_size=@$_FILES[$this->field]['size'];
    1282. 

  1282.       $upload_filename_del=$p->get($this->field.'_del');
    1283. 

  1283.       $upload_title=$p->get($this->field.'_title');
    1284. 

  1284.     }
    1285. 

  1285.     // Recupere un type mime fiable
    1286. 

  1286.     $upload_type=$mimeClasse->getValidMime($upload_type,$upload_filename,$upload_name);
    1287. 

  1287.     XLogs::debug('[XFileDef::post_edit] '.$upload_type);
    1288. 

  1288.     // Renseigne la taille si non renseigné
    1289. 

  1289.     if(empty($upload_size)) $upload_size=@filesize($upload_filename);
    1290. 

  1290.     // On verifie qu'on est dans les types acceptés
    1291. 

  1291.     $ok = ($upload_filename!='none' && !empty($upload_filename)) && ($mimeClasse->isAccepted($upload_type,$this->accept));
    1292. 

  1292. 

  1293.     // Verification de la taille du fichier
    1294. 

  1294.     $maxlength=trim($this->maxlength);
    1295. 

  1295.     if(!empty($maxlength) && ($upload_size > $maxlength)) $ok=false;
    1296. 

  1296.     if($upload_filename_del=='on') {
    1297. 

  1297.       if(isset($GLOBALS['XREPLI'])) $GLOBALS['XREPLI']->journalize('del',$oldfilename);
    1298. 

  1298.       XLogs::debug('[XFileDef::post_edit]unlink('.$oldfilename.')');
    1299. 

  1299.       $this->trace($options['old'],$r, '[-]file deleted');
    1300. 

  1300.       @unlink($oldfilename);
    1301. 

  1301.       $retval='';
    1302. 

  1302.     }else{
    1303. 

  1303.       if(XFileDef::isImage($upload_type) && !$link){
    1304. 

  1304. 	$this->rotateAndFlip($upload_filename,$upload_type);
    1305. 

  1305. 	$this->resizeImage($upload_filename,$this->image_max_geometry);
    1306. 

  1306.       }
    1307. 

  1307.       if($ok && ($upload_filename!='none') && !empty($upload_filename)){
    1308. 

  1308. 	if(!empty($oldfilename) && file_exists($oldfilename)) {
    1309. 

  1309. 	  XLogs::debug('[XFileDef::post_edit]unlink('.$oldfilename.')');
    1310. 

  1310. 	  unlink($oldfilename);
    1311. 

  1311. 	}
    1312. 

  1312. 	if(file_exists($filename)) {
    1313. 

  1313. 	  XLogs::debug('[XFileDef::post_edit]unlink('.$filename.')');
    1314. 

  1314. 	  unlink($filename);
    1315. 

  1315. 	}
    1316. 

  1316. 	if(!empty($hidden['crop'])){
    1317. 

  1317. 	  $upload_filename_crop=$upload_filename.'_crop';
    1318. 

  1318. 	  exec(TZR_MOGRIFY_RESIZER.' +profile "*" -crop "'.$hidden['crop']['w'].'x'.$hidden['crop']['h'].'+'.$hidden['crop']['x'].'+'.$hidden['crop']['y'].'" "'.
    1319. 

  1319. 	       $upload_filename.'" "'.$upload_filename_crop.'" 2>&1  > /dev/null');
    1320. 

  1320. 	  $upload_filename=$upload_filename_crop;
    1321. 

  1321. 	}
    1322. 

  1322. 	// Cryptage/Signature des fichiers
    1323. 

  1323. 	if($this->crypt) cryptAndSignFile($upload_filename);
    1324. 

  1324.         // gzip
    1325. 

  1325.         if ($this->gzipped == 1) {
    1326. 

  1326.           $content = file_get_contents($upload_filename);
    1327. 

  1327.           $fh = gzopen($filename, 'w');
    1328. 

  1328.           gzwrite($fh, $content);
    1329. 

  1329.           gzclose($fh);
    1330. 

  1330.         } elseif($link) {
    1331. 

  1331. 	  link($upload_filename,$filename);
    1332. 

  1332. 	} else
    1333. 

  1333.           copy($upload_filename, $filename);
    1334. 

  1334.         // calcul de l'image réduite de reference pour le jpeg
    1335. 

  1335.         if ($upload_type == 'image/jpeg') {
    1336. 

  1336.           exec(TZR_MOGRIFY_RESIZER.' -resize "'.TZR_LD_IMAGE_SIZE.'>" -density 72x72 '.$filename.' '.$filename.'_ld 2>&1  > /dev/null');
    1337. 

  1337.         }
    1338. 

  1338. 

  1339. 	$this->trace(@$options['old'],$r, (!empty($upload_name)?$upload_name:'file changed'));
    1340. 

  1340. 	$r->filename=$filename;
    1341. 

  1341. 	$r->mime=$upload_type;
    1342. 

  1342. 	if(isset($GLOBALS['XREPLI'])) $GLOBALS['XREPLI']->journalize('upd',$filename);
    1343. 

  1343.         $retval=$retval.';'.$upload_type.';'.$upload_name.';'.$upload_title;
    1344. 

  1344. 	if(!$link && $del && empty($options['editbatch'])){
    1345. 

  1345. 	  XLogs::debug('[XFileDef::post_edit]unlink('.$upload_filename.')');
    1346. 

  1346. 	  @unlink($upload_filename);
    1347. 

  1347. 	}
    1348. 

  1348. 	if(!empty($upload_filename_crop)) @unlink($upload_filename_crop);
    1349. 

  1349.       }else{
    1350. 

  1350. 	// Modification du libellé seulement
    1351. 

  1351. 	$oldvalue=rawurldecode($hidden['old']);
    1352. 

  1352. 	$values=explode(';',$oldvalue);
    1353. 

  1353. 	if($values[3]!=$upload_title) {
    1354. 

  1354. 	  $values[3]=$upload_title;
    1355. 

  1355. 	  $retval=implode(';',$values);
    1356. 

  1356. 	  $this->trace($options['old'],$r, 'file label changed -> '.$upload_title);
    1357. 

  1357. 	} else {
    1358. 

  1358. 	  $retval = TZR_UNCHANGED;
    1359. 

  1359. 	}
    1360. 

  1360.       }
    1361. 

  1361.     }
    1362. 

  1362.     $r->raw=$retval;
    1363. 

  1363.     return $r;
    1364. 

  1364.   }
    1365. 

  1365. 

  1366.   /// traitement apres saisie en duplication
    1367. 

  1367.   function post_editExternal($value,$options) {
    1368. 

  1368.     $r = $this->_newXFieldVal($options);
    1369. 

  1369.     $hidden = $options[$this->field.'_HID'];
    1370. 

  1370.     $url = preg_replace('@^http(s)?://@', '', $hidden['external']);
    1371. 

  1371.     $upload_filename_del='off';
    1372. 

  1372.     if (preg_match('@^(www.youtube.com/watch\?v=|www.youtube.com/embed/|youtu.be/|www.youtube.com/v/|youtube:)([A-Za-z0-9_-]{11})@', $url, $matches)) {
    1373. 

  1373.       $videoid = $matches[2];
    1374. 

  1374.       $r->raw = 'youtube:'.$videoid.';video/x-flv;;';
    1375. 

  1375.       return $r;
    1376. 

  1376.     }
    1377. 

  1377.     if (preg_match('@(calameo.com/[^\/]*/|calameo:)([0-9a-z]*)@', $url, $matches)) {
    1378. 

  1378.       $book_id = $matches[2];
    1379. 

  1379.       $r->raw = 'calameo:'.$book_id.';application/pdf;;';
    1380. 

  1380.       return $r;
    1381. 

  1381.     }
    1382. 

  1382.     if (preg_match('@(www.dailymotion.com/video/|dailymotion:)([0-9a-z]*)@', $url, $matches)) {
    1383. 

  1383.       $videoid = $matches[2];
    1384. 

  1384.       $r->raw = 'dailymotion:'.$videoid.';video/x-flv;;';
    1385. 

  1385.       return $r;
    1386. 

  1386.     }
    1387. 

  1387.     return $r;
    1388. 

  1388.   }
    1389. 

  1389.   
    1390. 

  1390.   /// traitement apres saisie en duplication
    1391. 

  1391.   function post_edit_dup($value,$options) {
    1392. 

  1392.     global $DATA_DIR;
    1393. 

  1393. 

  1394.     $p = new XParam($options,array());
    1395. 

  1395.     $langdata = XShell::getLangData();
    1396. 

  1396.     $oidsrc=$p->get('oidsrc');
    1397. 

  1397.     $oiddst=$p->get('oiddst');
    1398. 

  1398. 

  1399.     // Si on a renseigné le champ pour un nouveau fichier
    1400. 

  1400.     if(!empty($_FILES[$this->field]['tmp_name']) || $p->get('filepub_del')){
    1401. 

  1401.       $options['oid' ]=$oiddst;
    1402. 

  1402.       $r=$this->post_edit($value,$options,NULL);
    1403. 

  1403.       return $r->raw;
    1404. 

  1404.     }elseif(!$this->nocopydup){
    1405. 

  1405.       $oldvalue=$p->get($this->field.'_HID');
    1406. 

  1406.       return $this->copyExternalsTo($oldvalue['old'],$oidsrc,$oiddst);
    1407. 

  1407.     }
    1408. 

  1408.   }
    1409. 

  1409. 

  1410.   /// nettoyage des repertoires de données
    1411. 

  1411.   function chk(&$messages) {
    1412. 

  1412.     // verification que les images renseignees en base existent sur le disque
    1413. 

  1413.     $rs=selectQuery('SELECT KOID,'.$this->field.',LANG FROM '.$this->table. ' WHERE '.$this->field.'!="'.TZR_UNCHANGED.'"');
    1414. 

  1414.     while($rs && ($ors=$rs->fetch())) {
    1415. 

  1415.       $opts=array();
    1416. 

  1416.       $val=$this->my_display($ors[$this->field],$opts);
    1417. 

  1417.       if(!$val->isExternal && !file_exists($val->filename)) {
    1418. 

  1418. 	updateQuery('UPDATE '.$this->table.' SET UPD=UPD,'.$this->field.'="'.TZR_UNCHANGED.'" WHERE KOID="'.$ors['KOID'].'" AND LANG="'.$ors['LANG'].'"');
    1419. 

  1419.       }
    1420. 

  1420.       unset($val);
    1421. 

  1421.     }
    1422. 

  1422. 

  1423.     // verification de x000 images au hasard que les images sur le disque sont rattachees en base
    1424. 

  1424.     $root=$GLOBALS['DATA_DIR'].$this->table.'/'.$this->field;
    1425. 

  1425.     $files1 = XDir::scan($root);
    1426. 

  1426.     if(!empty($files1)) {
    1427. 

  1427.       $files = array_rand($files1, min(10000,count($files1)));
    1428. 

  1428.       // dans le cas ou il n'y a qu'un element dans $files1, array_rand ne rend pas un tableau
    1429. 

  1429.       if(!is_array($files)) { $f1=$files;unset($files);$files=array($f1);}
    1430. 

  1430.       $list=$listtodelete=array();
    1431. 

  1431.       foreach($files as $i => $file1) {
    1432. 

  1432. 	$file=$files1[$file1];
    1433. 

  1433. 	$names=explode('/',$file);
    1434. 

  1434. 	$names=array_reverse($names);
    1435. 

  1435. 	$idx=$names[0];
    1436. 

  1436. 	if(preg_match("@cache([\.a-z0-9]+)-([a-z0-9]+)@i",$names[0],$eregs)) {
    1437. 

  1437. 	  $idx=$eregs[1];
    1438. 

  1438. 	}
    1439. 

  1439. 	if(preg_match("@([\.a-z0-9_]+)-(([a-z0-9]+)-cache|fullsizeimage)@i",$names[0],$eregs)) {
    1440. 

  1440. 	  $idx=$eregs[1];
    1441. 

  1441. 	}
    1442. 

  1442. 	$idf=$idx;
    1443. 

  1443. 	if(preg_match('@([a-z]+)\.([a-z0-9]+)@i',$idx,$eregs)) {
    1444. 

  1444. 	  $idx=$eregs[2];
    1445. 

  1445. 	}
    1446. 

  1446. 	$list[]=array($idx, $file,$idf);
    1447. 

  1447.       }
    1448. 

  1448.       foreach($list as $i => $o) {
    1449. 

  1449. 	$fname=$o[0];
    1450. 

  1450. 	$filename=$o[1];
    1451. 

  1451. 	$o2=$o[2];
    1452. 

  1452. 	$cnt=countSelectQuery('SELECT COUNT(KOID) FROM '.$this->table.' WHERE '.$this->field.' like \''.$o2.'%\' LIMIT 1');
    1453. 

  1453. 	if($cnt<=0) {
    1454. 

  1454. 	  $listtodelete[]=$filename;
    1455. 

  1455. 	}
    1456. 

  1456.       }
    1457. 

  1457.       foreach($listtodelete as $filename) {
    1458. 

  1458. 	$flag=@unlink($filename);
    1459. 

  1459. 	XLogs::notice('XFileDef::chk','unlinking '.$filename);
    1460. 

  1460. 	if(!$flag) $messages.='unlinking '.$filename.':nok'."\n";
    1461. 

  1461.       }
    1462. 

  1462.       $dirs=XDir::scan($root, true, false, true);
    1463. 

  1463.       $do=true;
    1464. 

  1464.       while($do) {
    1465. 

  1465. 	$do=false;
    1466. 

  1466. 	foreach($dirs as $i=>$dirname) {
    1467. 

  1467. 	  if(@rmdir($dirname)) {
    1468. 

  1468. 	    unset($dirs[$i]);
    1469. 

  1469. 	    $do=true;
    1470. 

  1470. 	  }
    1471. 

  1471. 	}
    1472. 

  1472.       }
    1473. 

  1473.     }
    1474. 

  1474.   }
    1475. 

  1475. 

  1476.   /// Prepare la recherche rapide sur le champ
    1477. 

  1477.   function my_quickquery($value,$options=NULL) {
    1478. 

  1478.     $r=$this->my_query($value,$options);
    1479. 

  1479.     $r->html.='<input type="hidden" value="'.$this->field.'" name="_FIELDS['.$this->field.']">';
    1480. 

  1480.     return $r;
    1481. 

  1481.   }
    1482. 

  1482. 

  1483.   /// Prepare la recherche sur le champ
    1484. 

  1484.   function my_query($value,$options=NULL) {
    1485. 

  1485.     if(is_array($value)){
    1486. 

  1486.       $v=$value['name'];
    1487. 

  1487.       $mime=$value['mime'];
    1488. 

  1488.     }else{
    1489. 

  1489.       $v=$value;
    1490. 

  1490.       $mime='';
    1491. 

  1491.     }
    1492. 

  1492.     $v=htmlspecialchars($v);
    1493. 

  1493.     $labelin=@$options['labelin'];
    1494. 

  1494.     $r=$this->_newXFieldVal($options,true);
    1495. 

  1495.     $fname=(isset($options['fieldname'])?$options['fieldname']:$this->field);
    1496. 

  1496.     $varid=$r->varid;
    1497. 

  1497.     $t='<input type="text" id="'.$fname.$varid.'" name="'.$fname.'[name]" size="'.($this->fcount>30?30:$this->fcount).'" value="'.$v.'"/>';
    1498. 

  1498.     $t.='<select name="'.$fname.'[mime]">';
    1499. 

  1499.     $t.='<option value="">---</option>';
    1500. 

  1500.     $t.='<option value="image/*"'.($mime=='image/*'?' selected':'').'>'.XLabels::getSysLabel('mime','image/*','text').'</option>';
    1501. 

  1501.     $t.='<option value="*video*"'.($mime=='*video*'?' selected':'').'>'.XLabels::getSysLabel('mime','video/*','text').'</option>';
    1502. 

  1502.     $t.='<option value="*audio*"'.($mime=='*audio*'?' selected':'').'>'.XLabels::getSysLabel('mime','audio/*','text').'</option>';
    1503. 

  1503.     $t.='<option value="text/html"'.($mime=='text/html'?' selected':'').'>'.XLabels::getSysLabel('mime','text/html','text').'</option>';
    1504. 

  1504.     $t.='<option value="application/pdf"'.($mime=='application/pdf'?' selected':'').'>'.XLabels::getSysLabel('mime','application/pdf','text').'</option>';
    1505. 

  1505.     $t.='</select>';
    1506. 

  1506.     if(!empty($labelin)) $t.='<script type="text/javascript">inputInit("'.$fname.$varid.'","'.addslashes($this->label).'");</script>';
    1507. 

  1507.     $r->varid=$varid;
    1508. 

  1508.     $r->html=$t;
    1509. 

  1509.     $r->raw=$value;
    1510. 

  1510.     return $r;
    1511. 

  1511.   }
    1512. 

  1512. 

  1513.   function post_query($o,$ar){
    1514. 

  1514.     if(is_array($o->value)){
    1515. 

  1515.       $v=addslashes($o->value['name']);
    1516. 

  1516.       $mime=str_replace('*','.*',addslashes($o->value['mime']));
    1517. 

  1517.       if(!empty($v) || !empty($mime)){
    1518. 

  1518. 	if(empty($mime)) $mime='.+';
    1519. 

  1519. 	$sql='^(.+;'.$mime.';.*'.$v.'.*;.*)|(.+;'.$mime.';.+;.*'.$v.'.*)$';
    1520. 

  1520. 	$o->op='regexp';
    1521. 

  1521. 	$o->value=$sql;
    1522. 

  1522.       }else{
    1523. 

  1523. 	$o->value='';
    1524. 

  1524.       }
    1525. 

  1525.     }
    1526. 

  1526.     return parent::post_query($o,$ar);
    1527. 

  1527.   }
    1528. 

  1528. 

  1529.   /// Recupere le type du champ dans un webservice (name : type xml, descr : description du type pour l'ajour d'une type complexe)
    1530. 

  1530.   function getSoapType(){
    1531. 

  1531.     return array('name'=>'tns:file','descr'=>array('file'=>array(array('name'=>'mime','minOccurs'=>0,'maxOccurs'=>1,'type'=>'xsd:string'),
    1532. 

  1532. 								 array('name'=>'url','minOccurs'=>1,'maxOccurs'=>1,'type'=>'xsd:string'),
    1533. 

  1533. 								 array('name'=>'originalname','minOccurs'=>1,'maxOccurs'=>1,'type'=>'xsd:string'))));
    1534. 

  1534.   }
    1535. 

  1535.   /// Recupere la valeur formattée pour le service SOAP
    1536. 

  1536.   function getSoapValue($r){
    1537. 

  1537.     if($r->url) return array('mime'=>$r->mime,'url'=>$GLOBALS['TZR_SESSION_MANAGER']::makeDomainName().$r->url,'originalname'=>$r->originalname);
    1538. 

  1538.     else return;
    1539. 

  1539.   }
    1540. 

  1540. }
    1541. 

  1541. 

  1542. function xfiledef_getfilesize(){
    1543. 

  1543.   $file=$_REQUEST['file'];
    1544. 

  1544.   $s=filesize($GLOBALS['DATA_DIR'].$file);
    1545. 

  1545.   echo XLabels::getSysLabel('xfielddef','file_size').' : '.getStringBytes($s);
    1546. 

  1546. }
    1547. 

  1547. 

  1548. function xfiledef_uploadfiletopreview(){
    1549. 

  1549.   $keys=array_keys($_FILES);
    1550. 

  1550.   $new=uniqid('file_');
    1551. 

  1551.   move_uploaded_file($_FILES[$keys[0]]['tmp_name'],TZR_TMP_DIR.$new);
    1552. 

  1552.   $s=getimagesize(TZR_TMP_DIR.$new);
    1553. 

  1553.   echo json_encode(array('file'=>$new,'w'=>$s[0],'h'=>$s[1],'r'=>$s[0]/$s[1]));
    1554. 

  1554. }
    1555. 

  1555. 

  1556. function xfiledef_preview(){
    1557. 

  1557.   $file=str_replace('..','',$_REQUEST['file']);
    1558. 

  1558.   echo file_get_contents(TZR_TMP_DIR.$file);
    1559. 

  1559. }
    1560. 

  1560. ?>
    1561. 

  1561.