lib/plugin/VisualWiki.php

   1 <?php // -*-php-*-
   2 rcs_id('$Id: VisualWiki.php,v 1.18 2004-12-17 16:49:52 rurban Exp $');
   3 /*
   4  Copyright (C) 2002 Johannes Große (Johannes Gro&szlig;e)
   5
   6  This file is part of PhpWiki.
   7
   8  PhpWiki is free software; you can redistribute it and/or modify
   9  it under the terms of the GNU General Public License as published by
  10  the Free Software Foundation; either version 2 of the License, or
  11  (at your option) any later version.
  12
  13  PhpWiki is distributed in the hope that it will be useful,
  14  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  GNU General Public License for more details.
  17
  18  You should have received a copy of the GNU General Public License
  19  along with PhpWiki; if not, write to the Free Software
  20  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 /**
  24  * Produces graphical site map of PhpWiki
  25  * Example for an image map creating plugin. It produces a graphical
  26  * sitemap of PhpWiki by calling the <code>dot</code> commandline tool
  27  * from graphviz (http://www.graphviz.org).
  28  * @author Johannes Große
  29  * @version 0.9
  30  */
  31 define('VISUALWIKI_ALLOWOPTIONS', true);
  32 if (!defined('VISUALWIKI_ALLOWOPTIONS'))
  33     define('VISUALWIKI_ALLOWOPTIONS', false);
  34
  35 require_once "lib/plugin/GraphViz.php";
  36
  37 class WikiPlugin_VisualWiki
  38 extends WikiPlugin_GraphViz
  39 {
  40     /**
  41      * Sets plugin type to map production
  42      */
  43     function getPluginType() {
  44         return ($GLOBALS['request']->getArg('debug')) ? PLUGIN_CACHED_IMG_ONDEMAND : PLUGIN_CACHED_MAP;
  45     }
  46
  47     /**
  48      * Sets the plugin's name to VisualWiki. It can be called by
  49      * <code>&lt;?plugin VisualWiki?&gt;</code>, now. This
  50      * name must correspond to the filename and the class name.
  51      */
  52     function getName() {
  53         return "VisualWiki";
  54     }
  55
  56     function getVersion() {
  57         return preg_replace("/[Revision: $]/", '',
  58                             "\$Revision: 1.18 $");
  59     }
  60
  61     /**
  62      * Sets textual description.
  63      */
  64     function getDescription() {
  65         return _("Visualizes the Wiki structure in a graph using the 'dot' commandline tool from graphviz.");
  66     }
  67
  68     /**
  69      * Returns default arguments. This is put into a separate
  70      * function to allow its usage by both <code>getDefaultArguments</code>
  71      * and <code>checkArguments</code>
  72      */
  73     function defaultarguments() {
  74         return array('imgtype'        => 'png',
  75                      'width'          => false, // was 5, scale it automatically
  76                      'height'         => false, // was 7, scale it automatically
  77                      'colorby'        => 'age', // sort by 'age' or 'revtime'
  78                      'fillnodes'      => 'off',
  79                      'label'          => 'name',
  80                      'shape'          => 'ellipse',
  81                      'large_nb'       => 5,
  82                      'recent_nb'      => 5,
  83                      'refined_nb'     => 15,
  84                      'backlink_nb'    => 5,
  85                      'neighbour_list' => '',
  86                      'exclude_list'   => '',
  87                      'include_list'   => '',
  88                      'fontsize'       => 9,
  89                      'debug'          => false,
  90                      'help'           => false );
  91     }
  92
  93     /**
  94      * Sets the default arguments. WikiPlugin also regards these as
  95      * the allowed arguments. Since WikiPluginCached stores an image
  96      * for each different set of parameters, there can be a lot of
  97      * these (large) graphs if you allow different parameters.
  98      * Set <code>VISUALWIKI_ALLOWOPTIONS</code> to <code>false</code>
  99      * to allow no options to be set and use only the default parameters.
 100      * This will need an disk space of about 20 Kbyte all the time.
 101      */
 102     function getDefaultArguments() {
 103         if (VISUALWIKI_ALLOWOPTIONS)
 104             return $this->defaultarguments();
 105         else
 106             return array();
 107     }
 108
 109     /**
 110      * Substitutes each forbidden parameter value by the default value
 111      * defined in <code>defaultarguments</code>.
 112      */
 113     function checkArguments(&$arg) {
 114         extract($arg);
 115         $def = $this->defaultarguments();
 116         if (($width < 3) || ($width > 15))
 117             $arg['width'] = $def['width'];
 118         if (($height < 3) || ($height > 20))
 119             $arg['height'] = $def['height'];
 120         if (($fontsize < 8) || ($fontsize > 24))
 121             $arg['fontsize'] = $def['fontsize'];
 122         if (!in_array($label, array('name', 'number')))
 123             $arg['label'] = $def['label'];
 124
 125         if (!in_array($shape, array('ellipse', 'box', 'point', 'circle',
 126                                     'plaintext')))
 127             $arg['shape'] = $def['shape'];
 128         if (!in_array($colorby, array('age', 'revtime')))
 129             $arg['colorby'] = $def['colorby'];
 130         if (!in_array($fillnodes, array('on', 'off')))
 131             $arg['fillnodes'] = $def['fillnodes'];
 132         if (($large_nb < 0) || ($large_nb > 50))
 133             $arg['large_nb'] = $def['large_nb'];
 134         if (($recent_nb < 0)  || ($recent_nb > 50))
 135             $arg['recent_nb'] = $def['recent_nb'];
 136         if (($refined_nb < 0 ) || ( $refined_nb > 50))
 137             $arg['refined_nb'] = $def['refined_nb'];
 138         if (($backlink_nb < 0) || ($backlink_nb > 50))
 139             $arg['backlink_nb'] = $def['backlink_nb'];
 140         // ToDo: check if "ImageCreateFrom$imgtype"() exists.
 141         if (!in_array($imgtype, $GLOBALS['PLUGIN_CACHED_IMGTYPES']))
 142             $arg['imgtype'] = $def['imgtype'];
 143         if (empty($fontname))
 144             $arg['fontname'] = VISUALWIKIFONT;
 145     }
 146
 147     /**
 148      * Checks options, creates help page if necessary, calls both
 149      * database access and image map production functions.
 150      * @return array($map,$html)
 151      */
 152     function getMap($dbi, $argarray, $request) {
 153         if (!VISUALWIKI_ALLOWOPTIONS)
 154             $argarray = $this->defaultarguments();
 155         $this->checkArguments($argarray);
 156         $request->setArg('debug',$argarray['debug']);
 157         //extract($argarray);
 158         if ($argarray['help'])
 159             return array($this->helpImage(), ' '); // FIXME
 160         $this->createColors();
 161         $this->extract_wikipages($dbi, $argarray);
 162         /* ($dbi,  $large, $recent, $refined, $backlink,
 163             $neighbour, $excludelist, $includelist, $color); */
 164         return $this->invokeDot($argarray);
 165         /* ($width, $height, $color, $shape, $text); */
 166     }
 167
 168     // ------------------------------------------------------------------------------------------
 169
 170     /**
 171      * Returns an image containing a usage description of the plugin.
 172      * @return string image handle
 173      */
 174     function helpImage() {
 175         $def = $this->defaultarguments();
 176         $other_imgtypes = $GLOBALS['PLUGIN_CACHED_IMGTYPES'];
 177         unset ($other_imgtypes[$def['imgtype']]);
 178         $helparr = array(
 179             '<?plugin '.$this->getName() .
 180             ' img'             => ' = "' . $def['imgtype'] . "(default)|" . join('|',$GLOBALS['PLUGIN_CACHED_IMGTYPES']).'"',
 181             'width'            => ' = "width in inches"',
 182             'height'           => ' = "height in inches"',
 183             'fontname'         => ' = "font family"',
 184             'fontsize'         => ' = "fontsize in points"',
 185             'colorby'          => ' = "age|revtime|none"',
 186             'fillnodes'        => ' = "on|off"',
 187             'shape'            => ' = "ellipse(default)|box|circle|point"',
 188             'label'            => ' = "name|number"',
 189             'large_nb'         => ' = "number of largest pages to be selected"',
 190             'recent_nb'        => ' = "number of youngest pages"',
 191             'refined_nb'       => ' = "#pages with smallest time between revisions"',
 192             'backlink_nb'      => ' = "number of pages with most backlinks"',
 193             'neighbour_list'   => ' = "find pages linked from and to these pages"',
 194             'exclude_list'     => ' = "colon separated list of pages to be excluded"',
 195             'include_list'     => ' = "colon separated list"     ?>'
 196             );
 197         $length = 0;
 198         foreach($helparr as $alignright => $alignleft) {
 199             $length = max($length, strlen($alignright));
 200         }
 201         $helptext ='';
 202         foreach($helparr as $alignright => $alignleft) {
 203             $helptext .= substr('                                                        '
 204                                 . $alignright, -$length).$alignleft."\n";
 205         }
 206         return $this->text2img($helptext, 4, array(1, 0, 0),
 207                                array(255, 255, 255));
 208     }
 209
 210
 211     /**
 212      * Selects the first (smallest or biggest) WikiPages in
 213      * a given category.
 214      *
 215      * @param  number   integer  number of page names to be found
 216      * @param  category string   attribute of the pages which is used
 217      *                           to compare them
 218      * @param  minimum  boolean  true finds smallest, false finds biggest
 219      * @return array             list of page names found to be the best
 220      */
 221     function findbest($number, $category, $minimum ) {
 222         // select the $number best in the category '$category'
 223         $pages = &$this->pages;
 224         $names = &$this->names;
 225
 226         $selected = array();
 227         $i = 0;
 228         foreach($names as $name) {
 229             if ($i++>=$number)
 230                 break;
 231             $selected[$name] = $pages[$name][$category];
 232         }
 233         //echo "<pre>$category "; var_dump($selected); "</pre>";
 234         $compareto = $minimum ? 0x79999999 : -0x79999999;
 235
 236         $i = 0;
 237         foreach ($names as $name) {
 238             if ($i++<$number)
 239                 continue;
 240             if ($minimum) {
 241                 if (($crit = $pages[$name][$category]) < $compareto) {
 242                     $selected[$name] = $crit;
 243                     asort($selected, SORT_NUMERIC);
 244                     array_pop($selected);
 245                     $compareto = end($selected);
 246                 }
 247             } elseif (($crit = $pages[$name][$category]) > $compareto)  {
 248                 $selected[$name] = $crit;
 249                 arsort($selected, SORT_NUMERIC);
 250                 array_pop($selected);
 251                 $compareto = end($selected);
 252             }
 253         }
 254         //echo "<pre>$category "; var_dump($selected); "</pre>";
 255
 256         return array_keys($selected);
 257     }
 258
 259
 260     /**
 261     * Extracts a subset of all pages from the wiki and find their
 262     * connections to other pages. Also collects some page features
 263     * like size, age, revision number which are used to find the
 264     * most attractive pages.
 265     *
 266     * @param  dbi         WikiDB   database handle to access all Wiki pages
 267     * @param  LARGE       integer  number of largest pages which should
 268     *                              be included
 269     * @param  RECENT      integer  number of the youngest pages to be included
 270     * @param  REFINED     integer  number of the pages with shortes revision
 271     *                              interval
 272     * @param  BACKLINK    integer  number of the pages with most backlinks
 273     * @param  EXCLUDELIST string   colon ':' separated list of page names which
 274     *                              should not be displayed (like PhpWiki, for
 275     *                              example)
 276     * @param  INCLUDELIST string   colon separated list of pages which are
 277     *                              allways included (for example your own
 278     *                              page :)
 279     * @param  COLOR       string   'age', 'revtime' or 'none'; Selects which
 280     *                              page feature is used to determine the
 281     *                              filling color of the nodes in the graph.
 282     * @return void
 283     */
 284     function extract_wikipages($dbi, $argarray) {
 285         // $LARGE, $RECENT, $REFINED, $BACKLINK, $NEIGHBOUR,
 286         // $EXCLUDELIST, $INCLUDELIST,$COLOR
 287         $now = time();
 288
 289         extract($argarray);
 290         // FIXME: gettextify?
 291         $exclude_list   = explode(':', $exclude_list);
 292         $include_list   = explode(':', $include_list);
 293         $neighbour_list = explode(':', $neighbour_list);
 294
 295         // FIXME remove INCLUDED from EXCLUDED
 296
 297         // collect all pages
 298         $allpages = $dbi->getAllPages();
 299         $pages = &$this->pages;
 300         $countpages = 0;
 301         while ($page = $allpages->next()) {
 302             $name = $page->getName();
 303
 304             // skip exluded pages
 305             if (in_array($name, $exclude_list)) {
 306                 $page->free();
 307                 continue;
 308             }
 309
 310             // false = get links from actual page
 311             // true  = get links to actual page ("backlinks")
 312             $backlinks = $page->getLinks(true);
 313             unset($bconnection);
 314             $bconnection = array();
 315             while ($blink = $backlinks->next()) {
 316                 array_push($bconnection, $blink->getName());
 317             }
 318             $backlinks->free();
 319             unset($backlinks);
 320
 321             // include all neighbours of pages listed in $NEIGHBOUR
 322             if (in_array($name, $neighbour_list)) {
 323                 $ln = $page->getLinks(false);
 324                 $con = array();
 325                 while ($link = $ln->next()) {
 326                     array_push($con, $link->getName());
 327                 }
 328                 $include_list = array_merge($include_list, $bconnection, $con);
 329                 $ln->free();
 330                 unset($l);
 331                 unset($con);
 332             }
 333
 334             unset($currev);
 335             $currev = $page->getCurrentRevision();
 336
 337             $pages[$name] = array(
 338                 'age'         => $now - $currev->get('mtime'),
 339                 'revnr'       => $currev->getVersion(),
 340                 'links'       => array(),
 341                 'backlink_nb' => count($bconnection),
 342                 'backlinks'   => $bconnection,
 343                 'size'        => 1000 // FIXME
 344                 );
 345             $pages[$name]['revtime'] = $pages[$name]['age'] / ($pages[$name]['revnr']);
 346
 347             unset($page);
 348         }
 349         $allpages->free();
 350         unset($allpages);
 351         $this->names = array_keys($pages);
 352
 353         $countpages = count($pages);
 354
 355         // now select each page matching to given parameters
 356         $all_selected = array_unique(array_merge(
 357             $this->findbest($recent_nb,   'age',         true),
 358             $this->findbest($refined_nb,  'revtime',     true),
 359             $x = $this->findbest($backlink_nb, 'backlink_nb', false),
 360 //          $this->findbest($large_nb,    'size',        false),
 361             $include_list));
 362
 363         foreach($all_selected as $name)
 364             if (isset($pages[$name]))
 365                 $newpages[$name] = $pages[$name];
 366         unset($this->names);
 367         unset($this->pages);
 368         $this->pages = $newpages;
 369         $pages = &$this->pages;
 370         $this->names = array_keys($pages);
 371         unset($newpages);
 372         unset($all_selected);
 373
 374         $countpages = count($pages);
 375
 376         // remove dead links and collect links
 377         reset($pages);
 378         while( list($name,$page) = each($pages) ) {
 379             if (is_array($page['backlinks'])) {
 380                 reset($page['backlinks']);
 381                 while ( list($index, $link) = each( $page['backlinks'] ) ) {
 382                     if ( !isset($pages[$link]) || $link == $name ) {
 383                         unset($pages[$name]['backlinks'][$index]);
 384                     } else {
 385                         array_push($pages[$link]['links'],$name);
 386                         //array_push($this->everylink, array($link,$name));
 387                     }
 388                 }
 389             }
 390         }
 391
 392         if ($colorby == 'none')
 393             return;
 394         list($oldestname) = $this->findbest(1, $colorby, false);
 395         $this->oldest = $pages[$oldestname][$colorby];
 396         foreach($this->names as $name)
 397             $pages[$name]['color'] = $this->getColor($pages[$name][$colorby] / $this->oldest);
 398     }
 399
 400     /**
 401      * Creates the text file description of the graph needed to invoke
 402      * <code>dot</code>.
 403      *
 404      * @param filename  string  name of the dot file to be created
 405      * @param width     float   width of the output graph in inches
 406      * @param height    float   height of the graph in inches
 407      * @param colorby   string  color sceme beeing used ('age', 'revtime',
 408      *                                                   'none')
 409      * @param shape     string  node shape; 'ellipse', 'box', 'circle', 'point'
 410      * @param label     string  'name': label by name,
 411      *                          'number': label by unique number
 412      * @return boolean          error status; true=ok; false=error
 413      */
 414     function createDotFile($filename, $argarray) {
 415         extract($argarray);
 416         if (!$fp = fopen($filename, 'w'))
 417             return false;
 418
 419         $fillstring = ($fillnodes == 'on') ? 'style=filled,' : '';
 420
 421         $ok = true;
 422         $names = &$this->names;
 423         $pages = &$this->pages;
 424         if ($names)
 425             $nametonumber = array_flip($names);
 426
 427         $dot = "digraph VisualWiki {\n" // }
 428             . (!empty($fontpath) ? "    fontpath=\"$fontpath\"\n" : "");
 429         if ($width and $height)
 430             $dot .= "    size=\"$width,$height\";\n    ";
 431
 432
 433         switch ($shape) {
 434         case 'point':
 435             $dot .= "edge [arrowhead=none];\nnode [shape=$shape,fontname=$fontname,width=0.15,height=0.15,fontsize=$fontsize];\n";
 436             break;
 437         case 'box':
 438             $dot .= "node [shape=$shape,fontname=$fontname,width=0.4,height=0.4,fontsize=$fontsize];\n";
 439             break;
 440         case 'circle':
 441             $dot .= "node [shape=$shape,fontname=$fontname,width=0.25,height=0.25,fontsize=$fontsize];\n";
 442             break;
 443         default :
 444             $dot .= "node [fontname=$fontname,shape=$shape,fontsize=$fontsize];\n" ;
 445         }
 446         $dot .= "\n";
 447         $i = 0;
 448         foreach ($names as $name) {
 449
 450             $url = rawurlencode($name);
 451             // patch to allow Page/SubPage
 452             $url = str_replace(urlencode(SUBPAGE_SEPARATOR), SUBPAGE_SEPARATOR, $url);
 453             $nodename = ($label != 'name' ? $nametonumber[$name] + 1 : $name);
 454
 455             $dot .= "    \"$nodename\" [URL=\"$url\"";
 456             if ($colorby != 'none') {
 457                 $col = $pages[$name]['color'];
 458                 $dot .= sprintf(',%scolor="#%02X%02X%02X"', $fillstring,
 459                                 $col[0], $col[1], $col[2]);
 460             }
 461             $dot .= "];\n";
 462
 463             if (!empty($pages[$name]['links'])) {
 464                 unset($linkarray);
 465                 if ($label != 'name')
 466                     foreach($pages[$name]['links'] as $linkname)
 467                         $linkarray[] = $nametonumber[$linkname] + 1;
 468                 else
 469                     $linkarray = $pages[$name]['links'];
 470                 $linkstring = join('"; "', $linkarray );
 471
 472                 $c = count($pages[$name]['links']);
 473                 $dot .= "        \"$nodename\" -> "
 474                      . ($c>1?'{':'')
 475                      . "\"$linkstring\";"
 476                      . ($c>1?'}':'')
 477                      . "\n";
 478             }
 479         }
 480         if ($colorby != 'none') {
 481             $dot .= "\n    subgraph cluster_legend {\n"
 482                  . "         node[fontname=$fontname,shape=box,width=0.4,height=0.4,fontsize=$fontsize];\n"
 483                  . "         fillcolor=lightgrey;\n"
 484                  . "         style=filled;\n"
 485                  . "         fontname=$fontname;\n"
 486                  . "         fontsize=$fontsize;\n"
 487                  . "         label=\"".gettext("Legend")."\";\n";
 488             $oldest= ceil($this->oldest / (24 * 3600));
 489             $max = 5;
 490             $legend = array();
 491             for($i = 0; $i < $max; $i++) {
 492                 $time = floor($i / $max * $oldest);
 493                 $name = '"' . $time .' '. _("days") .'"';
 494                 $col = $this->getColor($i/$max);
 495                 $dot .= sprintf('       %s [%scolor="#%02X%02X%02X"];',
 496                                 $name, $fillstring, $col[0], $col[1], $col[2])
 497                     . "\n";
 498                 $legend[] = $name;
 499             }
 500             $dot .= '        '. join(' -> ', $legend)
 501                  . ";\n    }\n";
 502
 503         }
 504
 505         // {
 506         $dot .= "}\n";
 507
 508         $ok = fwrite($fp, $dot);
 509         $ok = fclose($fp) && $ok;  // close anyway
 510
 511         return $ok;
 512     }
 513
 514
 515     /**
 516      * static workaround on broken Cache or broken dot executable,
 517      * called only if debug=static.
 518      *
 519      * @access private
 520      * @param  url      string  url pointing to the image part of the map
 521      * @param  map      string  &lt;area&gt; tags defining active
 522      *                          regions in the map
 523      * @param  dbi      WikiDB  database abstraction class
 524      * @param  argarray array   complete (!) arguments to produce
 525      *                          image. It is not necessary to call
 526      *                          WikiPlugin->getArgs anymore.
 527      * @param  request  Request ???
 528      * @return          string  html output
 529      */
 530     function embedImg($url,&$dbi,$argarray,&$request) {
 531         if (!VISUALWIKI_ALLOWOPTIONS)
 532             $argarray = $this->defaultarguments();
 533         $this->checkArguments($argarray);
 534         //extract($argarray);
 535         if ($argarray['help'])
 536             return array($this->helpImage(), ' '); // FIXME
 537         $this->createColors();
 538         $this->extract_wikipages($dbi, $argarray);
 539         list($imagehandle, $content['html']) = $this->invokeDot($argarray);
 540         // write to uploads and produce static url
 541         $file_dir = defined('PHPWIKI_DIR') ?
 542             PHPWIKI_DIR . "/uploads" : "uploads";
 543         $upload_dir = SERVER_URL . ((substr(DATA_PATH,0,1)=='/') ? '' : "/") . DATA_PATH . '/uploads/';
 544         $tmpfile = tempnam($file_dir,"VisualWiki").".".$argarray['imgtype'];
 545         WikiPluginCached::writeImage($argarray['imgtype'], $imagehandle, $tmpfile);
 546         ImageDestroy($imagehandle);
 547         return WikiPluginCached::embedMap(1,$upload_dir.basename($tmpfile),$content['html'],
 548                                           $dbi,$argarray,$request);
 549     }
 550
 551     /**
 552      * Prepares some rainbow colors for the nodes of the graph
 553      * and stores them in an array which may be accessed with
 554      * <code>getColor</code>.
 555      */
 556     function createColors() {
 557         $predefcolors = array(
 558              array('red' => 255, 'green' =>   0, 'blue' =>   0),
 559              array('red' => 255, 'green' => 255, 'blue' =>   0),
 560              array('red' =>   0, 'green' => 255, 'blue' =>   0),
 561              array('red' =>   0, 'green' => 255, 'blue' => 255),
 562              array('red' =>   0, 'green' =>   0, 'blue' => 255),
 563              array('red' => 100, 'green' => 100, 'blue' => 100)
 564              );
 565
 566         $steps = 2;
 567         $numberofcolors = count($predefcolors) * $steps;
 568
 569         $promille = -1;
 570         foreach($predefcolors as $color) {
 571             if ($promille < 0) {
 572                 $oldcolor = $color;
 573                 $promille = 0;
 574                 continue;
 575             }
 576             for ($i = 0; $i < $steps; $i++)
 577                 $this->ColorTab[++$promille / $numberofcolors * 1000] = array(
 578                     floor(interpolate( $oldcolor['red'],   $color['red'],   $i/$steps )),
 579                     floor(interpolate( $oldcolor['green'], $color['green'], $i/$steps )),
 580                     floor(interpolate( $oldcolor['blue'],  $color['blue'],  $i/$steps ))
 581                 );
 582             $oldcolor = $color;
 583         }
 584 //echo"<pre>";  var_dump($this->ColorTab); echo "</pre>";
 585     }
 586
 587     /**
 588      * Translates a value from 0.0 to 1.0 into rainbow color.
 589      * red -&gt; orange -&gt; green -&gt; blue -&gt; gray
 590      *
 591      * @param promille float value between 0.0 and 1.0
 592      * @return array(red,green,blue)
 593      */
 594     function getColor($promille) {
 595         foreach( $this->ColorTab as $pro => $col ) {
 596             if ($promille*1000 < $pro)
 597                 return $col;
 598         }
 599         $lastcol = end($this->ColorTab);
 600         return $lastcol;
 601     }
 602 }
 603
 604 /**
 605  * Linear interpolates a value between two point a and b
 606  * at a value pos.
 607  * @return float  interpolated value
 608  */
 609 function interpolate($a, $b, $pos) {
 610     return $a + ($b - $a) * $pos;
 611 }
 612
 613 // $Log: not supported by cvs2svn $
 614 // Revision 1.17  2004/10/14 19:19:34  rurban
 615 // loadsave: check if the dumped file will be accessible from outside.
 616 // and some other minor fixes. (cvsclient native not yet ready)
 617 //
 618 // Revision 1.16  2004/10/12 15:34:47  rurban
 619 // redirect stderr to display the failing msg
 620 //
 621 // Revision 1.15  2004/09/08 13:38:00  rurban
 622 // improve loadfile stability by using markup=2 as default for undefined markup-style.
 623 // use more refs for huge objects.
 624 // fix debug=static issue in WikiPluginCached
 625 //
 626 // Revision 1.14  2004/09/07 13:26:31  rurban
 627 // new WikiPluginCached option debug=static and some more sf.net defaults for VisualWiki
 628 //
 629 // Revision 1.13  2004/09/06 12:13:00  rurban
 630 // provide sf.net default dotbin
 631 //
 632 // Revision 1.12  2004/09/06 12:08:50  rurban
 633 // memory_limit on unix workaround
 634 // VisualWiki: default autosize image
 635 //
 636 // Revision 1.11  2004/09/06 10:10:27  rurban
 637 // fixed syntax error
 638 //
 639 // Revision 1.10  2004/06/19 10:06:38  rurban
 640 // Moved lib/plugincache-config.php to config/*.ini
 641 // use PLUGIN_CACHED_* constants instead of global $CacheParams
 642 //
 643 // Revision 1.9  2004/06/03 09:40:57  rurban
 644 // WikiPluginCache improvements
 645 //
 646 // Revision 1.8  2004/01/26 09:18:00  rurban
 647 // * changed stored pref representation as before.
 648 //   the array of objects is 1) bigger and 2)
 649 //   less portable. If we would import packed pref
 650 //   objects and the object definition was changed, PHP would fail.
 651 //   This doesn't happen with an simple array of non-default values.
 652 // * use $prefs->retrieve and $prefs->store methods, where retrieve
 653 //   understands the interim format of array of objects also.
 654 // * simplified $prefs->get() and fixed $prefs->set()
 655 // * added $user->_userid and class '_WikiUser' portability functions
 656 // * fixed $user object ->_level upgrading, mostly using sessions.
 657 //   this fixes yesterdays problems with loosing authorization level.
 658 // * fixed WikiUserNew::checkPass to return the _level
 659 // * fixed WikiUserNew::isSignedIn
 660 // * added explodePageList to class PageList, support sortby arg
 661 // * fixed UserPreferences for WikiUserNew
 662 // * fixed WikiPlugin for empty defaults array
 663 // * UnfoldSubpages: added pagename arg, renamed pages arg,
 664 //   removed sort arg, support sortby arg
 665 //
 666 // Revision 1.7  2003/03/03 13:57:31  carstenklapp
 667 // Added fontpath (see PhpWiki:VisualWiki), tries to be smart about which OS.
 668 // (This plugin still doesn't work for me on OS X, but at least image files
 669 // are actually being created now in '/tmp/cache'.)
 670 //
 671 // Revision 1.6  2003/01/18 22:11:45  carstenklapp
 672 // Code cleanup:
 673 // Reformatting & tabs to spaces;
 674 // Added copyleft, getVersion, getDescription, rcs_id.
 675 //
 676
 677 // Local Variables:
 678 // mode: php
 679 // tab-width: 8
 680 // c-basic-offset: 4
 681 // c-hanging-comment-ender-p: nil
 682 // indent-tabs-mode: nil
 683 // End:
 684 ?>