banana/spool.inc.php

   1 <?php
   2 /********************************************************************************
   3 * include/spool.inc.php : spool subroutines
   4 * -----------------------
   5 *
   6 * This file is part of the banana distribution
   7 * Copyright: See COPYING files that comes with this distribution
   8 ********************************************************************************/
   9
  10 require_once dirname(__FILE__) . '/banana.inc.php';
  11
  12 define('BANANA_SPOOL_VERSION', '0.5.7');
  13
  14 /** Class spoolhead
  15  *  class used in thread overviews
  16  */
  17 class BananaSpoolHead
  18 {
  19     /** date (timestamp) */
  20     public $date;
  21     /** subject */
  22     public $subject;
  23     /** author */
  24     public $from;
  25     public $name;
  26     public $color;
  27     /** reference of parent */
  28     public $parent = null;
  29     /** paren is direct */
  30     public $parent_direct;
  31     /** array of children */
  32     public $children = Array();
  33     /** true if post is read */
  34     public $isread;
  35     /** number of posts deeper in this branch of tree */
  36     public $desc;
  37     /**  same as desc, but counts only unread posts */
  38     public $descunread;
  39
  40     /** storage data */
  41     public $storage = array();
  42
  43     /** constructor
  44      * @param $_date INTEGER timestamp of post
  45      * @param $_subject STRING subject of post
  46      * @param $_from STRING author of post
  47      * @param $_desc INTEGER desc value (1 for a new post)
  48      * @param $_read BOOLEAN true if read
  49      * @param $_descunread INTEGER descunread value (0 for a new post)
  50      */
  51     public function __construct(array &$message)
  52     {
  53         $this->date       = $message['date'];
  54         $this->subject    = $message['subject'];
  55         $this->from       = $message['from'];
  56         $this->color      = sprintf('#%06x', abs(crc32($this->from) % 0xffffff));
  57         $this->desc       = 1;
  58         $this->isread     = true;
  59         $this->descunread = 0;
  60         if (preg_match("/^([^ ]+@[^ ]+) \((.*)\)$/", $this->from, $regs)) {
  61             $this->name = $regs[2];
  62         }
  63         if (preg_match("/^\"?([^<>\"]+)\"? +<(.+@.+)>$/", $this->from, $regs)) {
  64             $this->name = preg_replace("/^'(.*)'$/", '\1', $regs[1]);
  65             $this->name = stripslashes($this->name);
  66         }
  67         if ($this->name) {
  68             $this->name =  preg_replace("/\\\(\(|\))/","\\1", $this->name);
  69         } else if (preg_match("/([^< ]+)@([^> ]+)/", $this->from, $regs)) {
  70             $this->name = $regs[1];
  71         } else {
  72             $this->name = 'Anonymous';
  73         }
  74     }
  75 }
  76
  77
  78 class BananaSpool
  79 {
  80     private $version;
  81     private $mode;
  82
  83     /**  group name */
  84     public $group;
  85     /**  spool */
  86     public $overview;
  87     /**  array msgid => msgnum */
  88     public $ids;
  89     /** thread starts */
  90     public $roots;
  91     /** thread trees (one tree per root node) */
  92     public $trees = array();
  93
  94     /** protocole specific data */
  95     public $storage = array();
  96
  97     private $unreadnb = 0;
  98
  99     /** constructor
 100      * @param $_group STRING group name
 101      * @param $_display INTEGER 1 => all posts, 2 => only threads with new posts
 102      * @param $_since INTEGER time stamp (used for read/unread)
 103      */
 104     protected function __construct($group)
 105     {
 106         $this->version    = BANANA_SPOOL_VERSION;
 107         $this->mode       = Banana::SPOOL_ALL;
 108         $this->group      = $group;
 109     }
 110
 111     public static function &getSpool($group, $since = 0, $clean = false)
 112     {
 113         if (!is_null(Banana::$spool) && Banana::$spool->group == $group) {
 114             $spool =& Banana::$spool;
 115         } else {
 116             $spool =& BananaSpool::readFromFile($group);
 117         }
 118         if (is_null($spool)) {
 119             $spool = new BananaSpool($group);
 120         }
 121         Banana::$spool =& $spool;
 122         $spool->build();
 123         if ($clean) {
 124             $spool->markAllAsRead();
 125         }
 126         $spool->updateUnread($since);
 127         return $spool;
 128     }
 129
 130     private static function spoolFilename($group)
 131     {
 132         $file = Banana::$spool_root . '/' . Banana::$protocole->name() . '/';
 133         if (!is_dir($file)) {
 134             mkdir($file);
 135         }
 136         return $file . Banana::$protocole->filename();
 137     }
 138
 139     private static function &readFromFile($group)
 140     {
 141         $spool = null;
 142         $file = BananaSpool::spoolFilename($group);
 143         if (!file_exists($file)) {
 144             return $spool;
 145         }
 146         $spool =  unserialize(file_get_contents($file));
 147         if ($spool->version != BANANA_SPOOL_VERSION || $spool->mode != Banana::SPOOL_ALL) {
 148             $spool = null;
 149             return $spool;
 150         }
 151         $spool->markAllAsRead();
 152         return $spool;
 153     }
 154
 155     private function compare($a, $b)
 156     {
 157         return ($this->overview[$b]->date >= $this->overview[$a]->date);
 158     }
 159
 160     private function saveToFile()
 161     {
 162         $file = BananaSpool::spoolFilename($this->group);
 163
 164         $this->roots = Array();
 165         foreach($this->overview as $id=>&$msg) {
 166             if (is_null($msg->parent)) {
 167                 $this->roots[] = $id;
 168             }
 169         }
 170         usort($this->roots, array($this, 'compare'));
 171
 172         if ($this->mode == Banana::SPOOL_ALL) {
 173             file_put_contents($file, serialize($this));
 174         }
 175     }
 176
 177     private function build()
 178     {
 179         $threshold = 0;
 180
 181         // Compute the range of indexes
 182         list($msgnum, $first, $last) = Banana::$protocole->getIndexes();
 183         if ($last < $first) {
 184             $threshold = $first + $msgnum - $last;
 185             $threshold = (int)(log($threshold)/log(2));
 186             $threshold = (2 ^ ($threshold + 1)) - 1;
 187         }
 188         if (Banana::$spool_max && Banana::$spool_max < $msgnum) {
 189             $first = $last - Banana::$spool_max;
 190             if ($first < 0) {
 191                 $first += $threshold;
 192             }
 193         }
 194         $clean  = $this->clean($first, $last, $msgnum);
 195         $update = $this->update($first, $last, $msgnum);
 196
 197         if ($clean || $update) {
 198             $this->saveToFile();
 199         }
 200     }
 201
 202     private function clean(&$first, &$last, $msgnum)
 203     {
 204         $do_save = false;
 205         if (is_array($this->overview)) {
 206             $mids = array_keys($this->overview);
 207             foreach ($mids as $id) {
 208                 if (($first <= $last && ($id < $first || $id > $last))
 209                         || ($first > $last && $id < $first && $id > $last)) {
 210                     $this->delid($id, false);
 211                     $do_save = true;
 212                 }
 213             }
 214             if (!empty($this->overview)) {
 215                 $first = max(array_keys($this->overview))+1;
 216             }
 217         }
 218         return $do_save;
 219     }
 220
 221     private function update(&$first, &$last, $msgnum)
 222     {
 223         if ($first > $last || !$msgnum) {
 224             return false;
 225         }
 226
 227         $messages =& Banana::$protocole->getMessageHeaders($first, $last,
 228             array('Date', 'Subject', 'From', 'Message-ID', 'References', 'In-Reply-To'));
 229
 230         if (!is_array($this->ids)) {
 231             $this->ids = array();
 232         }
 233         foreach ($messages as $id=>&$message) {
 234             $this->ids[$message['message-id']] = $id;
 235         }
 236
 237         if (!is_array($this->overview)) {
 238             $this->overview = array();
 239         }
 240         $updateTrees = array();
 241         foreach ($messages as $id=>&$message) {
 242             if (!isset($this->overview[$id])) {
 243                 $this->overview[$id] = new BananaSpoolHead($message);
 244             }
 245             $msg    =& $this->overview[$id];
 246             $msgrefs = BananaMessage::formatReferences($message);
 247             $parents = preg_grep('/^\d+$/', $msgrefs);
 248             $msg->parent = array_pop($parents);
 249             $msg->parent_direct = preg_match('/^\d+$/', array_pop($msgrefs));
 250
 251             if (!is_null($p = $msg->parent)) {
 252                 if (empty($this->overview[$p])) {
 253                     $this->overview[$p] = new BananaSpoolHead($messages[$p]);
 254                 }
 255                 $this->overview[$p]->children[] = $id;
 256                 while (!is_null($p)) {
 257                     $this->overview[$p]->desc += $msg->desc;
 258                     $prev = $p;
 259                     if ($p != $this->overview[$p]->parent) {
 260                         $p = $this->overview[$p]->parent;
 261                     } else {
 262                         $p = null;
 263                     }
 264                     if (is_null($p)) {
 265                         $updateTrees[$prev] = true;
 266                     }
 267                 }
 268             }
 269         }
 270         foreach ($updateTrees as $root=>$t) {
 271             $this->trees[$root] = $this->buildTree($root, true);
 272         }
 273         Banana::$protocole->updateSpool($messages);
 274         return true;
 275     }
 276
 277     public function updateUnread($since)
 278     {
 279         if (empty($since)) {
 280             return;
 281         }
 282
 283         $newpostsids = Banana::$protocole->getNewIndexes($since);
 284
 285         if (empty($newpostsids)) {
 286             return;
 287         }
 288
 289         if (!is_array($this->ids)) {
 290             $this->ids = array();
 291         }
 292         $newpostsids = array_intersect($newpostsids, array_keys($this->ids));
 293         foreach ($newpostsids as $mid) {
 294             $id = $this->ids[$mid];
 295             if ($this->overview[$id]->isread) {
 296                 $this->overview[$id]->isread = false;
 297                 $this->unreadnb++;
 298                 while (isset($id)) {
 299                     $this->overview[$id]->descunread++;
 300                     $id = $this->overview[$id]->parent;
 301                 }
 302             }
 303         }
 304     }
 305
 306     public function setMode($mode)
 307     {
 308         $this->mode = $mode;
 309         switch ($mode) {
 310           case Banana::SPOOL_UNREAD:
 311             $num = max(array_keys($this->overview));
 312             if ($this->overview[$num]->isread) {
 313                 break;
 314             }
 315             foreach ($this->roots as $k=>$i) {
 316                 if ($this->overview[$i]->descunread == 0) {
 317                     $this->killdesc($i);
 318                     unset($this->roots[$k]);
 319                 }
 320             }
 321             break;
 322         }
 323     }
 324
 325     /** Mark the given id as read
 326      * @param id MSGNUM of post
 327      */
 328     public function markAsRead($id)
 329     {
 330         if (!$this->overview[$id]->isread) {
 331             $this->overview[$id]->isread = true;
 332             $this->unreadnb--;
 333             while (isset($id)) {
 334                 $this->overview[$id]->descunread--;
 335                 $id = $this->overview[$id]->parent;
 336             }
 337         }
 338     }
 339
 340     /** Mark all unread messages as read
 341      */
 342     public function markAllAsRead(array &$array = null)
 343     {
 344         if (!$this->unreadnb) {
 345             return;
 346         }
 347         if (is_null($array) && is_array($this->roots)) {
 348             $array =& $this->roots;
 349         } elseif (is_null($array)) {
 350             return;
 351         }
 352         foreach ($array as $id) {
 353             if (!$this->overview[$id]->isread) {
 354                 $this->markAsRead($id);
 355                 if (!$this->unreadnb) {
 356                     return;
 357                 }
 358             }
 359             if ($this->overview[$id]->descunread) {
 360                 $this->markAllAsRead($this->overview[$id]->children);
 361             }
 362         }
 363     }
 364
 365     /** kill post and childrens
 366      * @param $_id MSGNUM of post
 367      */
 368     private function killdesc($_id)
 369     {
 370         if (sizeof($this->overview[$_id]->children)) {
 371             foreach ($this->overview[$_id]->children as $c) {
 372                 $this->killdesc($c);
 373             }
 374         }
 375         unset($this->overview[$_id]);
 376         if (($msgid = array_search($_id, $this->ids)) !== false) {
 377             unset($this->ids[$msgid]);
 378         }
 379     }
 380
 381     /** delete a post from overview
 382      * @param $_id MSGNUM of post
 383      */
 384     public function delid($_id, $write = true)
 385     {
 386         if (isset($this->overview[$_id])) {
 387             $overview =& $this->overview[$_id];
 388             if (!$overview->isread) {
 389                 $this->markAsRead($_id);
 390             }
 391             if ($overview->parent) {
 392                 $p      =  $overview->parent;
 393                 $parent =& $this->overview[$p];
 394                 $parent->children = array_diff($parent->children, array($_id));
 395                 if (sizeof($overview->children)) {
 396                     $parent->children = array_merge($parent->children, $overview->children);
 397                     foreach ($overview->children as $c) {
 398                         $this->overview[$c]->parent        = $p;
 399                         $this->overview[$c]->parent_direct = false;
 400                     }
 401                 }
 402                 while (isset($p)) {
 403                     $this->overview[$p]->desc--;
 404                     $p = $this->overview[$p]->parent;
 405                 }
 406             } elseif ($overview->children) {
 407                 foreach ($overview->children as $c) {
 408                     $this->overview[$c]->parent = null;
 409                 }
 410             }
 411             unset($overview);
 412             unset($this->overview[$_id]);
 413             unset($this->trees[$_id]);
 414             $msgid = array_search($_id, $this->ids);
 415             if ($msgid !== false) {
 416                 unset($this->ids[$msgid]);
 417             }
 418             $msgid = array_search($_id, $this->roots);
 419             if ($msgid !== false) {
 420                 unset($this->roots[$msgid]);
 421             }
 422
 423             if ($write) {
 424                 $this->saveToFile();
 425             }
 426         }
 427     }
 428
 429     public function formatDate($stamp)
 430     {
 431         $today  = intval(time() / (24*3600));
 432         $dday   = intval($stamp / (24*3600));
 433
 434         if ($today == $dday) {
 435             $format = "%H:%M";
 436         } elseif ($today == 1 + $dday) {
 437             $format = _b_('hier')." %H:%M";
 438         } elseif ($today < 7 + $dday) {
 439             $format = '%a %H:%M';
 440         } elseif ($today < 90 + $dday) {
 441             $format = '%a %e %b';
 442         } else {
 443             $format = '%a %e %b %Y';
 444         }
 445         return strftime($format, $stamp);
 446     }
 447
 448     public function formatSubject($id, $subject)
 449     {
 450         $subject = banana_html_entity_decode($subject);
 451         $popup = $subject;
 452         if (function_exists('hook_formatDisplayHeader')) {
 453             list($subject, $link) = hook_formatDisplayHeader('subject', $subject, true);
 454         } else {
 455             $subject = banana_catchFormats(banana_entities(stripslashes($subject)));
 456             $link = null;
 457         }
 458         if (empty($subject)) {
 459             $subject = _b_('(pas de sujet)');
 460         }
 461         if ($id != Banana::$artid) {
 462             $subject = Banana::$page->makeLink(Array('group' => $this->group, 'artid' => $id,
 463                                                      'text'  => $subject, 'popup' => $popup));
 464         }
 465         return $subject . $link;
 466     }
 467
 468     public function formatFrom($from)
 469     {
 470         $from = banana_html_entity_decode($from);
 471         return BananaMessage::formatFrom($from);
 472     }
 473
 474     public function start()
 475     {
 476         if (Banana::$first) {
 477             return Banana::$first;
 478         } else {
 479             $first = array_search(Banana::$artid, $this->roots);
 480             return max(0, $first - Banana::$spool_tbefore);
 481         }
 482     }
 483
 484     public function context()
 485     {
 486         return Banana::$first ? Banana::$spool_tmax : Banana::$spool_tcontext;
 487     }
 488
 489     /** displays children tree of a post
 490      * @param $_id INTEGER MSGNUM of post
 491      * @param $_index INTEGER linear number of post in the tree
 492      * @param $_first INTEGER linear number of first post displayed
 493      * @param $_last INTEGER linear number of last post displayed
 494      * @param $_ref STRING MSGNUM of current post
 495      * @param $_pfx_node STRING prefix used for current node
 496      * @param $_pfx_end STRING prefix used for children of current node
 497      * @param $_head BOOLEAN true if first post in thread
 498      *
 499      * If you want to analyse subject, you can define the function hook_formatDisplayHeader
 500      */
 501     private function _to_html($_id, $_index, $_first=0, $_last=0, $_ref="", $_pfx_node="", $_pfx_end="", $_head=true, $_pfx_id="")
 502     {
 503         static $spfx_f, $spfx_n, $spfx_Tnd, $spfx_Lnd, $spfx_snd, $spfx_T, $spfx_L, $spfx_s, $spfx_e, $spfx_I;
 504         if (!isset($spfx_f)) {
 505             $spfx_f   = Banana::$page->makeImg(Array('img' => 'k1',       'alt' => 'o', 'height' => 21,  'width' => 9));
 506             $spfx_n   = Banana::$page->makeImg(Array('img' => 'k2',       'alt' => '*', 'height' => 21,  'width' => 9));
 507             $spfx_Tnd = Banana::$page->makeImg(Array('img' => 'T-direct', 'alt' => '+', 'height' => 21, 'width' => 12));
 508             $spfx_Lnd = Banana::$page->makeImg(Array('img' => 'L-direct', 'alt' => '`', 'height' => 21, 'width' => 12));
 509             $spfx_snd = Banana::$page->makeImg(Array('img' => 's-direct', 'alt' => '-', 'height' => 21, 'width' => 5));
 510             $spfx_T   = Banana::$page->makeImg(Array('img' => 'T',        'alt' => '+', 'height' => 21, 'width' => 12));
 511             $spfx_L   = Banana::$page->makeImg(Array('img' => 'L',        'alt' => '`', 'height' => 21, 'width' => 12));
 512             $spfx_s   = Banana::$page->makeImg(Array('img' => 's',        'alt' => '-', 'height' => 21, 'width' => 5));
 513             $spfx_e   = Banana::$page->makeImg(Array('img' => 'e',   'alt' => '&nbsp;', 'height' => 21, 'width' => 12));
 514             $spfx_I   = Banana::$page->makeImg(Array('img' => 'I',        'alt' => '|', 'height' => 21, 'width' => 12));
 515         }
 516
 517         $overview =& $this->overview[$_id];
 518         if ($_index + $overview->desc < $_first || $_index > $_last) {
 519             return '';
 520         }
 521
 522         $res = '';
 523         if ($_index >= $_first) {
 524             $hc = empty($overview->children);
 525
 526             $res .= '<tr id="'.$_pfx_id.$_id.'" class="' . ($_index%2 ? 'pair' : 'impair') . ($overview->isread ? '' : ' new') . "\">\n";
 527             $res .= '<td class="date">' . $this->formatDate($overview->date) . " </td>\n";
 528             $res .= '<td class="subj' . ($_index == $_ref ? ' cur' : '') . '"><div class="tree">'
 529                 . $_pfx_node .($hc ? ($_head ? $spfx_f : ($overview->parent_direct ? $spfx_s : $spfx_snd)) : $spfx_n)
 530                 . '</div>';
 531             $popup = $subject = $overview->subject;
 532             if (function_exists('hook_formatDisplayHeader')) {
 533                 list($subject, $link) = hook_formatDisplayHeader('subject', $subject, true);
 534             } else {
 535                 $subject = banana_catchFormats(banana_entities(stripslashes($subject)));
 536                 $link = null;
 537             }
 538             if (empty($subject)) {
 539                 $subject = _b_('(pas de sujet)');
 540             }
 541             if ($_index != $_ref) {
 542                 $subject = Banana::$page->makeLink(Array('group' => $this->group, 'artid' => $_id,
 543                                                     'text'  => $subject, 'popup' => $popup));
 544             }
 545             $res .= '&nbsp;' . $subject . $link;
 546             $res .= "</td>\n<td class='from'>" . BananaMessage::formatFrom($overview->from) . "</td>\n</tr>";
 547
 548             if ($hc) {
 549                 return $res;
 550             }
 551         }
 552
 553         $_index ++;
 554         $children = $overview->children;
 555         while ($child = array_shift($children)) {
 556             $overview =& $this->overview[$child];
 557             if ($_index > $_last) {
 558                 return $res;
 559             }
 560             if ($_index + $overview->desc >= $_first) {
 561                 if (sizeof($children)) {
 562                     $res .= $this->_to_html($child, $_index, $_first, $_last, $_ref,
 563                             $_pfx_end . ($overview->parent_direct ? $spfx_T : $spfx_Tnd),
 564                             $_pfx_end . $spfx_I, false,$_id.'_');
 565                 } else {
 566                     $res .= $this->_to_html($child, $_index, $_first, $_last, $_ref,
 567                             $_pfx_end . ($overview->parent_direct ? $spfx_L : $spfx_Lnd),
 568                             $_pfx_end . $spfx_e, false,$_id.'_');
 569                 }
 570             }
 571             $_index += $overview->desc;
 572         }
 573
 574         return $res;
 575     }
 576
 577     /** Displays overview
 578      * @param $_first INTEGER MSGNUM of first post
 579      * @param $_last INTEGER MSGNUM of last post
 580      * @param $_ref STRING MSGNUM of current/selectionned post
 581      */
 582     public function toHtml($first = 0, $overview = false)
 583     {
 584         $res = Banana::$page->makeJs('jquery');
 585         $res .= Banana::$page->makeJs('spool_toggle');
 586
 587         if (!$overview) {
 588             $_first = $first;
 589             $_last  = $first + Banana::$spool_tmax - 1;
 590             $_ref   = null;
 591         } else {
 592             $_ref   = $this->getNdx($first);
 593             $_last  = $_ref + Banana::$spool_tafter;
 594             $_first = $_ref - Banana::$spool_tbefore;
 595             if ($_first < 0) {
 596                 $_last -= $_first;
 597             }
 598         }
 599         $index = 1;
 600         foreach ($this->roots as $id) {
 601             $res   .= $this->_to_html($id, $index, $_first, $_last, $_ref);
 602             $index += $this->overview[$id]->desc ;
 603             if ($index > $_last) {
 604                 break;
 605             }
 606         }
 607         return $res;
 608     }
 609
 610
 611     public function _buildTree($id, BananaSpoolHead &$head, $current) {
 612         static $t_e, $u_h, $u_ht, $u_vt, $u_l, $u_f, $r_h, $r_ht, $r_vt, $r_l, $r_f;
 613         if (!isset($spfx_f)) {
 614             $t_e   = Banana::$page->makeImg(Array('img' => 'e',  'alt' => '&nbsp;', 'height' => 18,  'width' => 14));
 615             $u_h   = Banana::$page->makeImg(Array('img' => 'h2', 'alt' => '-', 'height' => 18,  'width' => 14));
 616             $u_ht  = Banana::$page->makeImg(Array('img' => 'T2', 'alt' => '+', 'height' => 18, 'width' => 14));
 617             $u_vt  = Banana::$page->makeImg(Array('img' => 't2', 'alt' => '`', 'height' => 18, 'width' => 14));
 618             $u_l   = Banana::$page->makeImg(Array('img' => 'l2', 'alt' => '|', 'height' => 18, 'width' => 14));
 619             $u_f   = Banana::$page->makeImg(Array('img' => 'f2', 'alt' => 't', 'height' => 18, 'width' => 14));
 620             $r_h   = Banana::$page->makeImg(Array('img' => 'h2r', 'alt' => '-', 'height' => 18,  'width' => 14));
 621             $r_ht  = Banana::$page->makeImg(Array('img' => 'T2r', 'alt' => '+', 'height' => 18, 'width' => 14));
 622             $r_vt  = Banana::$page->makeImg(Array('img' => 't2r', 'alt' => '`', 'height' => 18, 'width' => 14));
 623             $r_l   = Banana::$page->makeImg(Array('img' => 'l2r', 'alt' => '|', 'height' => 18, 'width' => 14));
 624             $r_f   = Banana::$page->makeImg(Array('img' => 'f2r', 'alt' => 't', 'height' => 18, 'width' => 14));
 625         }
 626         $style = 'background-color:' . $head->color . '; text-decoration: none';
 627         $prof  = 1;
 628         $text = '<span style="' . $style . '" title="' . banana_entities($head->name . ', ' . $this->formatDate($head->date)) . '">' .
 629                 '<input type="radio" name="banana_tree" '. ($id == $current ? 'checked="checked" ' : ' ' ) .
 630                 (Banana::$msgshow_javascript ? 'onchange="window.location=\'' .
 631                     banana_entities(Banana::$page->makeURL(array('group' => $this->group, 'artid' => $id))) . '\'"'
 632                     : ' disabled="disabled"')
 633                 .' />' .
 634                 '</span>';
 635         $array = array($text);
 636         foreach ($head->children as $key=>&$child) {
 637             $msg =& $this->overview[$child];
 638             list($tpr, $tree) = $this->_buildTree($child, $msg, $current);
 639             $last = $key == count($head->children) - 1;
 640             foreach ($tree as $kt=>&$line) {
 641                 if ($kt == 0 && $key == 0 && !$last) {
 642                     $array[0] .= ($msg->isread ? $r_ht : $u_ht) . $line;
 643                 } else if($kt == 0 && $key == 0) {
 644                     $array[0] .= ($msg->isread ? $r_h : $u_h)  . $line;
 645                 } else if ($kt == 0 && $last) {
 646                     $array[] = $t_e . ($msg->isread ? $r_vt : $u_vt) . $line;
 647                 } else if ($kt == 0) {
 648                     $array[] = $t_e . ($msg->isread ? $r_f : $u_f) . $line;
 649                 } else if ($last) {
 650                     $array[] = $t_e . $t_e . $line;
 651                 } else {
 652                     $array[] = $t_e . ($msg->isread ? $r_l : $u_l) . $line;
 653                 }
 654             }
 655             unset($tree);
 656             if ($tpr > $prof) {
 657                 $prof = $tpr + 1;
 658             }
 659         }
 660         return array($prof, $array);
 661     }
 662
 663     /** build the spool tree associated with the given message
 664      */
 665     public function buildTree($id, $force = false) {
 666         $pos      =  $id;
 667         $overview =& $this->overview[$id];
 668         while (!is_null($overview->parent)) {
 669             $pos = $overview->parent;
 670             $overview =& $this->overview[$pos];
 671         }
 672         if (!$force && isset($this->trees[$pos])) {
 673             return $this->trees[$pos];
 674         } else {
 675             list(, $tree) = $this->_buildTree($pos, $overview, $force ? -1 : $id);
 676             return '<div style="height:18px">' . implode("</div>\n<div style=\"height:18px\">", $tree) . '</div>';
 677         }
 678     }
 679
 680     /** computes linear post index
 681      * @param $_id INTEGER MSGNUM of post
 682      * @return INTEGER linear index of post
 683      */
 684     public function getNdX($_id)
 685     {
 686         $ndx    = 1;
 687         $id_cur = $_id;
 688         while (true) {
 689             $id_parent = $this->overview[$id_cur]->parent;
 690             if (is_null($id_parent)) break;
 691             $pos       = array_search($id_cur, $this->overview[$id_parent]->children);
 692
 693             for ($i = 0; $i < $pos ; $i++) {
 694                 $ndx += $this->overview[$this->overview[$id_parent]->children[$i]]->desc;
 695             }
 696             $ndx++; //noeud père
 697
 698             $id_cur = $id_parent;
 699         }
 700
 701         foreach ($this->roots as $i) {
 702             if ($i==$id_cur) {
 703                 break;
 704             }
 705             $ndx += $this->overview[$i]->desc;
 706         }
 707         return $ndx;
 708     }
 709
 710     /** Return root message of the given thread
 711      * @param id INTEGER id of a message
 712      */
 713     public function root($id)
 714     {
 715         $id_cur = $id;
 716         while (true) {
 717             $id_parent = $this->overview[$id_cur]->parent;
 718             if (is_null($id_parent)) break;
 719             $id_cur = $id_parent;
 720         }
 721         return $id_cur;
 722     }
 723
 724     /** Return the last post id with the given subject
 725      * @param subject
 726      */
 727     public function getPostId($subject)
 728     {
 729         $subject = trim($subject);
 730         $id = max(array_keys($this->overview));
 731         while (isset($this->overview[$id])) {
 732             $test = $this->overview[$id]->subject;
 733             if (function_exists('hook_formatDisplayHeader')) {
 734                 $val = hook_formatDisplayHeader('subject', $test, true);
 735                 if (is_array($val)) {
 736                     $test = banana_html_entity_decode($val[0]);
 737                 } else {
 738                     $test = banana_html_entity_decode($val);
 739                 }
 740             }
 741             $test = trim($test);
 742             if ($test == $subject) {
 743                 return $id;
 744             }
 745             $id--;
 746         }
 747         return -1;
 748     }
 749
 750     /** Returns previous thread root index
 751      * @param id INTEGER message number
 752      */
 753     public function prevThread($id)
 754     {
 755         $root = $this->root($id);
 756         $last = null;
 757         foreach ($this->roots as $i) {
 758             if ($i == $root) {
 759                 return $last;
 760             }
 761             $last = $i;
 762         }
 763         return $last;
 764     }
 765
 766     /** Returns next thread root index
 767      * @param id INTEGER message number
 768      */
 769     public function nextThread($id)
 770     {
 771         $root = $this->root($id);
 772         $ok   = false;
 773         foreach ($this->roots as $i) {
 774             if ($ok) {
 775                 return $i;
 776             }
 777             if ($i == $root) {
 778                 $ok = true;
 779             }
 780         }
 781         return null;
 782     }
 783
 784     /** Return prev post in the thread
 785      * @param id INTEGER message number
 786      */
 787     public function prevPost($id)
 788     {
 789         $parent = $this->overview[$id]->parent;
 790         if (is_null($parent)) {
 791             return null;
 792         }
 793         $last = $parent;
 794         foreach ($this->overview[$parent]->children as $child) {
 795             if ($child == $id) {
 796                 return $last;
 797             }
 798             $last = $child;
 799         }
 800         return null;
 801     }
 802
 803     /** Return next post in the thread
 804      * @param id INTEGER message number
 805      */
 806     public function nextPost($id)
 807     {
 808         if (count($this->overview[$id]->children) != 0) {
 809             return $this->overview[$id]->children[0];
 810         }
 811
 812         $cur    = $id;
 813         while (true) {
 814             $parent = $this->overview[$cur]->parent;
 815             if (is_null($parent)) {
 816                 return null;
 817             }
 818             $ok = false;
 819             foreach ($this->overview[$parent]->children as $child) {
 820                 if ($ok) {
 821                     return $child;
 822                 }
 823                 if ($child == $cur) {
 824                     $ok = true;
 825                 }
 826             }
 827             $cur = $parent;
 828         }
 829         return null;
 830     }
 831
 832     /** Look for an unread message in the thread rooted by the message
 833      * @param id INTEGER message number
 834      */
 835     private function _nextUnread($id)
 836     {
 837         if (!$this->overview[$id]->isread) {
 838             return $id;
 839         }
 840         foreach ($this->overview[$id]->children as $child) {
 841             $unread = $this->_nextUnread($child);
 842             if (!is_null($unread)) {
 843                 return $unread;
 844             }
 845         }
 846         return null;
 847     }
 848
 849     /** Find next unread message
 850      * @param id INTEGER message number
 851      */
 852     public function nextUnread($id = null)
 853     {
 854         if (!$this->unreadnb) {
 855             return null;
 856         }
 857
 858         if (!is_null($id)) {
 859             // Look in message children
 860             foreach ($this->overview[$id]->children as $child) {
 861                 $next = $this->_nextUnread($child);
 862                 if (!is_null($next)) {
 863                     return $next;
 864                 }
 865             }
 866         }
 867
 868         // Look in current thread
 869         $cur = $id;
 870         do {
 871             $parent = is_null($cur) ? null : $this->overview[$cur]->parent;
 872             $ok     = is_null($cur) ? true : false;
 873             if (!is_null($parent)) {
 874                 $array = &$this->overview[$parent]->children;
 875             } else {
 876                 $array = &$this->roots;
 877             }
 878             foreach ($array as $child) {
 879                 if ($ok) {
 880                     $next = $this->_nextUnread($child);
 881                     if (!is_null($next)) {
 882                         return $next;
 883                     }
 884                 }
 885                 if ($child == $cur) {
 886                     $ok = true;
 887                 }
 888             }
 889             $cur = $parent;
 890         } while(!is_null($cur));
 891         return null;
 892     }
 893 }
 894
 895 // vim:set et sw=4 sts=4 ts=4 enc=utf-8:
 896 ?>