Source for file calendar.php

Documentation is available at calendar.php

  1. <?php
  2. /**
  3. * Calendar object
  4. *
  5. * @author    Stuart Prescott
  6. * @copyright  Copyright Stuart Prescott
  7. * @license    http://opensource.org/licenses/gpl-license.php GNU Public License
  8. * @version    $Id$
  9. * @package    Bumblebee
  10. * @subpackage DBObjects
  11. *
  12. *  path (bumblebee root)/inc/bb/calendar.php
  13. */
  14.  
  15. /** Load ancillary functions */
  16. require_once 'inc/typeinfo.php';
  17. checkValidInclude();
  18.  
  19. /** date manipulation routines */
  20. require_once 'inc/date.php';
  21. /** Booking object */
  22. require_once 'inc/bookings/booking.php';
  23. /** Vacancy object */
  24. require_once 'inc/bookings/vacancy.php';
  25. /** Cell object */
  26. require_once 'inc/bookings/cell.php';
  27. /** BookingMatrix object */
  28. require_once 'inc/bookings/matrix.php';
  29. /** BookingData object (list of bookings) */
  30. require_once 'inc/bookings/bookingdata.php';
  31. /** TimeSlot and TimeSlotRule objects */
  32. require_once 'inc/bookings/timeslotrule.php';
  33.  
  34. /**
  35. * use start and end times from defined slots
  36. * @see Calender::_breakAccordingToList
  37. */
  38. define('CAL_TIME_SLOTRULE',    1);
  39. /**
  40. * use start and end times from the bookings
  41. * @see Calender::_breakAccordingToList
  42. */
  43. define('CAL_TIME_BOOKING',     2);
  44.  
  45. /**
  46. * Calendar object
  47. *
  48. * Retrives, sorts and displays bookings for an instrument over a given period of time
  49. *
  50. * @package    Bumblebee
  51. * @subpackage DBObjects
  52. * @todo //TODO: display bugs for off-slot bookings?
  53. * @todo //TODO: week-long / multi-day bookings
  54. */
  55. class Calendar {
  56.   /** @var SimpleDate  start date/time for the calendar    */
  57.   var $start;
  58.   /** @var SimpleDate  stop date/time for the calendar    */
  59.   var $stop;
  60.   /** @var integer     number of days in the calendar  */
  61.   var $numDays;
  62.   /** @var integer     instrument id number for which the calendar is being displayed    */
  63.   var $instrument;
  64.   /** @var array       list of instrument ids for which the calendar is being displayed    */
  65.   var $instrumentlist = null;
  66.   /** @var boolean     sql errors are fatal   */
  67.   var $fatal_sql = 1;
  68.   /** @var BookingData list of bookings  */
  69.   var $bookinglist;
  70.   /** @var string      prepended to all zoom hrefs generated by in the calendar    */
  71.   var $zoomhref = '';
  72.   /** @var string      callback function used to make URLs for booking hrefs in the calendar */
  73.   var $bookhrefCallback = '';
  74.   /** @var string      html/css class to be used for all table cells corresponding to a day    */
  75.   var $dayClass = '';
  76.   /** @var string      html/css class to be used for all table cells corresponding today    */
  77.   var $todayClass = '';
  78.   /** @var mixed       array or string. list of html/css class to be rotated through month by month for the time periods in the calendar   */
  79.   var $rotateDayClass = '';
  80.   /** @var mixed       array or string. list of html/css class to be rotated through month by month for the day header   */
  81.   var $rotateDayClassDatePart = '';
  82.   /** @var TimeSlotRule  time slots that govern this calendar    */
  83.   var $timeslots;
  84.   /** @var boolean     generate the calendar with an admin view (i.e. all times are bookable)  */
  85.   var $isAdminView = 0;
  86.   /** @var boolean    only show free/busy information and not the details of the bookings */
  87.   var $freeBusyOnly = false;
  88.   /** @var boolean    show a popup layer with extra details on it on the page */
  89.   var $showDetails = true;
  90.   /** @var integer    time after which the calendar should automatically reload itself (in milliseconds) */
  91.   var $reloadInterval = 300000;  //    5 * 60 * 1000
  92.  
  93.   
  94.   /** @var integer    debug level (0=off, 10=verbose)  */
  95.   var $DEBUG = 0;
  96.  
  97.   /**
  98.   * Create a calendar object, can display bookings in calendar format
  99.   *
  100.   * @param SimpleDate $start    start time to display bookings from
  101.   * @param SimpleDate $stop     stop time to display bookings until
  102.   * @param mixed      $instrument  what instrument number (or list of instrumets) to display bookings for
  103.   */
  104.   function Calendar($start, $stop, $instrument) {
  105.     $this->start = $start;
  106.     $this->stop  = $stop;
  107.     if (is_array($instrument)) {
  108.       $this->instrument = $instrument[0];
  109.       if (count($instrument) > 1) $this->instrumentlist = $instrument;
  110.     } else {
  111.       $this->instrument = $instrument;
  112.     }
  113.     $this->log('Creating calendar from '.$start->dateString().' to '.$stop->dateString(), 5);
  114.     $this->_fill();
  115.     $this->_insertVacancies();
  116.     //print $this->displayAsTable();
  117.   }
  118.  
  119.   /**
  120.   * set the CSS style names by which
  121.   *
  122.   * @param string $dayClass   class to use in every day header
  123.   * @param string $today      class to use on today's date
  124.   * @param mixed  $day        string for class on each day, or array to rotate through
  125.   * @param string $dayrotate  time-part ('m', 'd', 'y' etc) on which day CDD should be rotated
  126.   */
  127.   function setOutputStyles($dayClass, $today, $day, $dayrotate='m') {
  128.     $this->dayClass = $dayClass;
  129.     $this->todayClass = $today;
  130.     $this->rotateDayClass = is_array($day) ? $day : array($day);
  131.     $this->rotateDayClassDatePart = $dayrotate;
  132.   }
  133.  
  134.   /**
  135.    * set the time slot picture (passed straight to a TimeSlotRule object) to apply
  136.    *
  137.    * @param string $pic   timeslot picture for this instrument and this calendar
  138.    */
  139.   function setTimeSlotPicture($pic) {
  140.     $this->timeslots = new TimeSlotRule($pic);
  141.     //break bookings over the predefined pictures
  142.     $this->log('Breaking up bookings according to defined rules');
  143.     $this->_breakAccordingToList($this->timeslots, CAL_TIME_SLOTRULE, CAL_TIME_SLOTRULE);
  144.     //print $this->displayAsTable();
  145.   }
  146.  
  147.   /**
  148.   * Obtain the booking data for this time period
  149.   *
  150.   * @access private
  151.   */
  152.   function _fill() {
  153.     if ($this->instrumentlist !== null) {
  154.       $bookdata = $this->_getBookingData($this->instrumentlist);
  155.       $this->bookinglist = $this->_reduceList($bookdata->dataArray());
  156.     } else {
  157.       $bookdata = $this->_getBookingData($this->instrument);
  158.       $this->bookinglist = $bookdata->dataArray();
  159.     }
  160.     //preDump($this->bookinglist);
  161.   }
  162.  
  163.   function _getBookingData($instrument) {
  164.     $bookdata = new BookingData (
  165.         array(
  166.           'instrument' => $instrument,
  167.           'start'      => $this->start,
  168.           'stop'       => $this->stop
  169.               )
  170.       );
  171.     return $bookdata;
  172.   }
  173.  
  174.   function _reduceList($list) {
  175.     $cleandata = array();
  176.     $numBookings = count($list);
  177.     if ($numBookings <= 1) return $list;
  178.  
  179.     $cleandata[0] = $list[0];
  180.     $cleandata[0]->children[] = $list[0];
  181.     $now = clone($list[0]->start);
  182.     $idx=0;
  183.  
  184.     for ($i=1; $i < $numBookings; $i++) {
  185.       $booking = $list[$i];
  186.       #print "<br/>".$booking->generateBookingTitle()."<br />";
  187.  
  188.       // bookings are sorted by:
  189.       //   start (ascending) and then duration (descending)
  190.       if ($now->ticks == $booking->start->ticks) {
  191.         $cleandata[$idx]->children[] = $booking;
  192.         $this->log("ignored booking because starts match", 8);
  193.         continue;
  194.       }
  195.  
  196.       if ($cleandata[$idx]->stop->ticks <= $booking->start->ticks) {
  197.         $this->log("copied booking across", 8);
  198.         $idx++;
  199.         $cleandata[$idx] = $booking;
  200.         $cleandata[$idx]->children[] = $booking;
  201.         $now = clone($booking->start);
  202.         continue;
  203.       }
  204.  
  205.       if ($cleandata[$idx]->stop->ticks < $booking->stop->ticks) {
  206.         $this->log("adjusted previous booking because of overlap", 8);
  207.         $cleandata[$idx]->children[] = $booking;
  208.         $cleandata[$idx]->stop = $booking->stop;
  209.         continue;
  210.       }
  211.  
  212.       $cleandata[$idx]->children[] = $booking;
  213.       $this->log("did nothing with this booking", 8);
  214.     }
  215.     return $cleandata;
  216.   }
  217.  
  218.   /**
  219.   * Create pseudo-bookings for all vacancies between the start
  220.   * of this calendar and the end.
  221.   *
  222.   * For example, if we were constructing a calendar from 00:00 on 2004-01-01 to
  223.   *   23:59 on 2004-01-02, but there was only a booking from 10:00 to 11:00
  224.   *   on 2004-01-01, then we should create vacancy pseudo-bookings from:
  225.   *   - 2004-01-01-00:00 to 2004-01-01-10:00 and from
  226.   *   - 2004-01-01-11:00 to 2004-01-01-24:00 and from
  227.   *   - 2004-01-02-00:00 to 2004-01-02-24:00.
  228.   *
  229.   * Bookings are NOT restricted to remaining on one day (i.e. a booking from
  230.   * 20:00:00 until 10:00:00 the next day is OK.
  231.   *
  232.   */
  233.   function _insertVacancies() {
  234.     $this->numDays = $this->stop->partDaysBetween($this->start);
  235.     $this->log('Creating calendar for '.$this->numDays.' days', 5);
  236.     //blat over the booking list so we can create the normalised list
  237.     $bookings = $this->bookinglist;
  238.     $this->bookinglist = array();
  239.  
  240.     // put a vacancy at the end so we don't run off the end of the list.
  241.     $v = new Vacancy();
  242.     $v->setTimes(clone($this->stop),clone($this->stop));
  243.     $bookings[] = $v;
  244.  
  245.     //insert a vacancy between each non-consecutive booking
  246.     $bvlist = array();
  247.     $booking = 0;
  248.     $now = clone($this->start);
  249.     $this->log('Normalising bookings');
  250.     while ($now->ticks < $this->stop->ticks) {
  251.       if ($now->ticks < $bookings[$booking]->start->ticks) {
  252.         // then we should create a pseudobooking
  253.         $v = new Vacancy();
  254.         $stoptime = new SimpleDate($bookings[$booking]->start->ticks);
  255.         $v->setTimes(clone($now), clone($stoptime));
  256.         $bvlist[] = $v;
  257.         $now = $stoptime;
  258.         $this->log('Created vacancy: '.$v->start->dateTimeString()
  259.                   .' to '.$v->stop->dateTimeString(), 9);
  260.       } else {
  261.         // then this is the current timeslot
  262.         $bvlist[] = $bookings[$booking];
  263.         $now = $bookings[$booking]->stop;
  264.         $this->log('Included booking: '.
  265.                 $bookings[$booking]->start->dateTimeString() .' to '
  266.                .$bookings[$booking]->stop->dateTimeString(), 9);
  267.         $booking++;
  268.       }
  269.     }
  270.     $this->bookinglist = $bvlist;
  271.     $this->bookinglist[0]->arb_start = true;
  272.     $this->bookinglist[count($bvlist)-1]->arb_stop = true;
  273.   }
  274.  
  275.   /**
  276.   * Break up bookings that span days (for display purposes only)
  277.   *
  278.   * For example, if we had a vacancy pseudo-bookings from
  279.   * 2004-01-01-11:00 to 2004-01-02-24:00, then we would
  280.   * break it up into two bookings as follows:
  281.   *   -  2004-01-01-11:00 to 2004-01-01-24:00 and
  282.   *   -  2004-01-02-00:00 to 2004-01-02-24:00.
  283.   */
  284.   function _breakAcrossDays() {
  285.     $this->log('Breaking up bookings across days');
  286.     //break bookings over day boundaries
  287.     $daylist = new TimeSlotRule('[0-6]<00:00-24:00/*>');
  288.     $this->_breakAccordingToList($daylist, CAL_TIME_BOOKING, CAL_TIME_BOOKING);
  289.   }
  290.  
  291.   /**
  292.   * Break up bookings that span elements of a defined list (e.g. allowable times or
  293.   * days). A TimeSlotRule ($list) is used to define how the times should be broken up
  294.   *
  295.   * $keepTimes(Vacant|Book) are set to CAL_TIME_BOOKING, CAL_TIME_SLOTRULE
  296.   *
  297.   * CAL_TIME_BOOKING:
  298.   *   start|stop are set according to the timeslotrule and will be used to
  299.   *      display the timeslot in a graphica display (i.e. calculating height of boxes)
  300.   *    display(Start|Stop) are set to the values of the original vacancy or booking being examined.
  301.   *
  302.   * CAL_TIME_SLOTRULE:
  303.   *   display(Start|Stop) variables are set to the values of the timeslot rule that breaks up the slots
  304.   *      with the exception of slots that overlap a booking, where min() or max() is used
  305.   *   start|stop are set to the same as the start/stop vars
  306.   *   Note: vacancies that are at the start or end of the booking list are a corner case
  307.   *   that is handled respectively as: start = slotrule->stop and stop = slotrule->stop
  308.   *
  309.   * @param $list TimeSlotRule Object   set of rules used to break up booking stream
  310.   * @param $keepTimesVacant enum       how should the display(Start|Stop) and (start|stop)
  311.   * @param $keepTimesBook   enum       .. variables be set for Vacancy and Booking slots
  312.   */
  313.   function _breakAccordingToList($list, $keepTimesVacant, $keepTimesBook) {
  314.     $bl = $this->bookinglist;
  315.     $this->bookinglist = array();
  316.     $this->log('Breaking up bookings according to list');
  317.     $this->log($list->dump());
  318.     $booking=0;
  319.     for ($bv=0; $bv < count($bl); $bv++) {
  320. /*      $this->log('considering timeslot #'.$bv.': '
  321.                       .$bl[$bv]->start->dateTimeString().' - '.$bl[$bv]->stop->dateTimeString(), 8);*/
  322.       $cbook =& $bl[$bv];
  323.       $cbook->original = clone($cbook);
  324.       $isStart = START_BOOKING;
  325.       $slotrule = $list->findSlotFromWithin($bl[$bv]->start);
  326.       #$start = $list->findSlotStart($bl[$bv]->start);
  327.       if (!is_object($slotrule) && $slotrule == 0) {
  328.         // then the original start time must be outside the proper limits
  329.         $slotrule = $list->findNextSlot($bl[$bv]->start);
  330.       }
  331.       do {  //until the current booking has been broken up across list boundaries
  332.         //echo "memusage=".memory_get_usage()."<br />";
  333.         $this->slotlog('bookingo', $bl[$bv]);
  334.         $this->slotlog('timeslot', $slotrule);
  335.         // push the new booking onto the stack; record if it's the start of a booking or not
  336.         $this->bookinglist[$booking] = clone($cbook);
  337.         $realStart = isset($this->bookinglist[$booking]->displayStart) ? $this->bookinglist[$booking]->displayStart : $this->bookinglist[$booking]->start;
  338.         if ($isStart == MIDDLE_BOOKING && $slotrule->start->dow() != $realStart->dow()) {
  339.           $this->bookinglist[$booking]->isStart |= START_BOOKING_DAY;
  340.         }
  341.         $next_isStart = MIDDLE_BOOKING;
  342.  
  343.         $newstart = clone($this->bookinglist[$booking]->start);
  344.         $newstart->max($slotrule->start);
  345.         $newstop = clone($this->bookinglist[$booking]->stop);
  346.         $newstop->min($slotrule->stop);
  347.  
  348.         if (! $this->bookinglist[$booking]->isVacant) {
  349.           switch ($keepTimesBook) {
  350.             case CAL_TIME_SLOTRULE:   // for bookings
  351.               if ($this->bookinglist[$booking]->arb_start) {
  352.                 $newstart = clone($this->bookinglist[$booking]->start);
  353.               }
  354.               if ($this->bookinglist[$booking]->arb_stop) {
  355.                 $newstop = clone($this->bookinglist[$booking]->stop);
  356.               }
  357.               $this->bookinglist[$booking]->displayStart = $this->bookinglist[$booking]->original->start;
  358.               $this->bookinglist[$booking]->displayStop  = $this->bookinglist[$booking]->original->stop;
  359.               $this->bookinglist[$booking]->start = $newstart;
  360.               $this->bookinglist[$booking]->stop  = $newstop;
  361. /*              $this->bookinglist[$booking]->displayStart = $newstart;
  362.               $this->bookinglist[$booking]->displayStop  = $newstop;*/
  363.               $this->bookinglist[$booking]->slotRule = $slotrule;
  364.               $this->bookinglist[$booking]->isStart |= $isStart;
  365.               break;
  366.             case CAL_TIME_BOOKING:
  367.               $this->bookinglist[$booking]->start = $newstart;
  368.               $this->bookinglist[$booking]->stop  = $newstop;
  369. //               $this->bookinglist[$booking]->displayStart = $this->bookinglist[$booking]->original->start;
  370. //               $this->bookinglist[$booking]->displayStop  = $this->bookinglist[$booking]->original->stop;
  371.               break;
  372.           }
  373.         } else {
  374.           switch ($keepTimesVacant) {
  375.             case CAL_TIME_SLOTRULE:  // for vacancies
  376.               if ($this->bookinglist[$booking]->arb_start) {
  377.                 $newstart = clone($slotrule->start);
  378.               }
  379.               if ($this->bookinglist[$booking]->arb_stop) {
  380.                 $newstop = clone($slotrule->stop);
  381.               }
  382.               $this->bookinglist[$booking]->start = $newstart;
  383.               $this->bookinglist[$booking]->stop  = $newstop;
  384.               $this->bookinglist[$booking]->displayStart = $newstart;
  385.               $this->bookinglist[$booking]->displayStop  = $newstop;
  386.               $this->bookinglist[$booking]->isDisabled = ! $slotrule->isAvailable;
  387.               $this->bookinglist[$booking]->slotRule = $slotrule;
  388.               $this->bookinglist[$booking]->isStart |= $isStart;
  389.               break;
  390.             case CAL_TIME_BOOKING:
  391.               $this->bookinglist[$booking]->start = $newstart;
  392.               $this->bookinglist[$booking]->stop  = $newstop;
  393.               $this->bookinglist[$booking]->displayStart = $this->bookinglist[$booking]->original->start;
  394.               $this->bookinglist[$booking]->displayStop  = $this->bookinglist[$booking]->original->stop;
  395.               $this->bookinglist[$booking]->isStart |= $isStart;
  396.               break;
  397.           }
  398.         }
  399.  
  400.         // find the next TimeSlotRule to work out how to chop this booking up again (or how
  401.         // to chop up the next booking)
  402.         $nextslotrule = $list->findNextSlot($slotrule->start);
  403.         $isStart = $next_isStart;
  404.         $this->slotlog('displayv',$this->bookinglist[$booking], true);
  405.         $this->slotlog('realvalu',$this->bookinglist[$booking]);
  406.         $slotrule = $nextslotrule;
  407.         $booking++;
  408.         //$this->log('oticks='.$this->bookinglist[$booking-1]->original->stop->ticks
  409.         //           .'nticks='.$slotrule->start->ticks,10);
  410.         $this->timelog('nextstart=',$slotrule->start);
  411.         //var_dump($this->bookinglist[$booking-1]->original);
  412.         //$this->log('ost='.$this->bookinglist[$booking-1]->original->stop->ticks,10);
  413.         //$this->log('tst='.$slotrule->start->ticks,10);
  414.         $this->log('');
  415.       } while ($this->bookinglist[$booking-1]->original->stop->ticks > $slotrule->start->ticks);
  416.     }
  417.   }
  418.  
  419.   /**
  420.   * Generate a booking matrix for all the days we are interested in
  421.   */
  422.   function _collectMatrix($daystart, $daystop, $granularity) {
  423.     $matrixlist = array();
  424.     // matrix calculation object is shared from day to day which permits caching of data
  425.     $matrix = new BookingMatrix(clone($daystart), clone($daystop), $granularity, $this->bookinglist);
  426.     for ($day = 0; $day < $this->numDays; $day++) {
  427.       $today = clone($this->start);
  428.       $today->addDays($day);
  429.       $matrix->setDate($today);
  430.       $matrix->prepareMatrix();
  431.       $matrixlist[] = $matrix->getMatrix();
  432.     }
  433.     return $matrixlist;
  434.   }
  435.  
  436.   /**
  437.   * work out what html/css class this date should be rendered as
  438.   *
  439.   * @param SimpleDate $today  today's date
  440.   * @param SimpleDate $t      the date to check
  441.   * @return string  space-separated css class list for use in class=""
  442.   */
  443.   function _getDayClass($today, $t) {
  444.     $class = $this->dayClass;
  445.     $class .= ' '.$this->rotateDayClass[date($this->rotateDayClassDatePart, $t->ticks)
  446.                       % count($this->rotateDayClass)];
  447.     if ($today->dateString()==$t->dateString()) {
  448.       $class .= ' '.$this->todayClass;
  449.     }
  450.     return $class;
  451.   }
  452.  
  453.   /**
  454.   * Display the booking details in a list
  455.   */
  456.   function display() {
  457.     return $this->displayAsTable();
  458.   }
  459.  
  460.   /**
  461.   * Display the booking details in a list
  462.   */
  463.   function displayAsTable() {
  464.     $t = '<table class="tabularobject">';
  465.     foreach ($this->bookinglist as $v) {
  466.       #$t .= '<tr><td>'.$v[0].'</td><td>'.$v[1].'</td></tr>'."\n";
  467.       $t .= $v->displayShort();
  468.     }
  469.     $t .= '</table>';
  470.     return $t;
  471.   }
  472.  
  473.   /**
  474.   * Generate html for the booking details in a table with rowspan based on the duration of the booking
  475.   *
  476.   * @param SimpleTime $daystart    time from which bookings should be displayed
  477.   * @param SimpleTime $daystop     time up until which bookings should be displayed
  478.   * @param integer    $granularity seconds per row in display
  479.   * @param integer    $reportPeriod  seconds between reporting the time in a column down the side
  480.   * @return string   html representation of the calendar
  481.   */
  482.   function displayMonthAsTable($daystart, $daystop, $granularity,
  483.                                     $reportPeriod) {
  484.     $conf = ConfigReader::getInstance();
  485.     $this->_breakAcrossDays();
  486. //     echo $this->display();
  487.     $matrix = $this->_collectMatrix($daystart, $daystop, $granularity);
  488.     $numRowsPerDay =  $daystop->subtract($daystart) / $granularity;
  489.     $numRows = ceil($this->numDays/7) * $numRowsPerDay;
  490.  
  491.     #report the time in a time column on the LHS every nth row:
  492.     $timecolumn = array();
  493.     $time = clone($daystart);
  494.     for ($row=0; $row<$numRowsPerDay; $row++) {
  495.       $timecolumn[$row] = clone($time);
  496.       $time->addSecs($granularity);
  497.     }
  498.  
  499.     if (is_array($this->instrumentlist)) {
  500.       $this->freeBusyOnly = true;
  501.     }
  502.  
  503.     $today = new SimpleDate(time());
  504.  
  505.     $t = $this->_makeRefreshScript();
  506.  
  507.     $t .= '<table class="tabularobject calendar" summary="'
  508.                     .T_('Extended view of instrument bookings').'">';
  509.     $weekstart = clone($this->start);
  510.     $weekstart->addDays(-7);
  511.     $t .= '<tr><th colspan="2"></th>';
  512.     for ($day=0; $day<7; $day++) {
  513.       $current = clone($weekstart);
  514.       $current->addDays($day);
  515.       $t .= '<th class="caldow">'
  516.               .($conf->value('calendar', 'shortdaynames', true) ? $current->dowShortStr()
  517.                                                                 : $current->dowStr())
  518.               .'</th>';
  519.     }
  520.     $t .= '</tr>';
  521.  
  522.     // load up this translation once outside the main loop
  523.     $zoomStr = T_('Zoom in on %s');
  524.  
  525.     for ($row = 0; $row < $numRows; $row++) {
  526.       $dayRow = $row % $numRowsPerDay;
  527.       if ($dayRow == 0) {
  528.         $weekstart->addDays(7);
  529.         $t .= '<tr><td colspan="2"></td>';
  530.         for ($day=0; $day<7; $day++) {
  531.           $current = clone($weekstart);
  532.           $current->addDays($day);
  533.           $isodate = $current->dateString();
  534.           $class = $this->_getDayClass($today, $current);
  535.           $zoomwords = sprintf($zoomStr, $isodate);
  536.           $t .= '<td class="caldatecell '.$class.'">';
  537.           $t .= '<div style="float:right;"><a href="'.$this->zoomhref.'&amp;isodate='.$isodate.'" '
  538.                   .'class="but" title="'.$zoomwords .'">'
  539.                .'<img src="'.$conf->BasePath.'/theme/images/zoom.png" '
  540.                   .'alt="'.$zoomwords .'" class="calicon" /></a></div>'."\n";
  541.           $t .= '<div class="caldate">'
  542.                   .$current->getShortDateString()
  543.                 .'</div>';
  544.           $t .= '</td>';
  545.         }
  546.         $t .= '</tr>';
  547.       }
  548.       $t .= '<tr><td class="dummy"></td>';
  549.       //$t .= '<tr><td class="dummy"><img src="/1x1.png" height="5" width="1" alt="" /></td>';
  550.       if ($dayRow % $reportPeriod == 0) {
  551.         //$t .= '<td colspan="2" rowspan="'.$reportPeriod.'">';
  552.         $t .= '<td rowspan="'.$reportPeriod.'" class="timemark">';
  553.         $t .= $timecolumn[$dayRow]->getShortString();
  554.         $t .= '</td>';
  555.       }
  556.       for ($day=0; $day<7; $day++) {
  557.         $current = clone($weekstart);
  558.         $current->addDays($day);
  559.         #$currentidx = $current->dsDaysBetween($this->start);
  560.         // calculate the day number directly from the cell information rather than
  561.         // using date-time functions. (add a small qty to the value so that floor doesn't
  562.         // round down to the next integer below due to fp precision)
  563.         $currentidx = floor($row / $numRowsPerDay + 0.05) * 7 + $day;
  564.         if (isset($matrix[$currentidx][$dayRow])) {
  565.           #$t .= '<td>';
  566.           #preDump($matrix[$currentidx]->rows[$dayRow]);
  567.           $b =& $matrix[$currentidx][$dayRow];
  568.           $b->booking->freeBusyOnly = $this->freeBusyOnly;
  569.           $class = $this->_getDayClass($today, $b->booking->start);
  570.           $class .= ($b->booking->isDisabled ? ' disabled' : '');
  571.           //echo "$class <br />\n";
  572.           $t .= "\n\t".$b->display($class,
  573.                                     call_user_func($this->bookhrefCallback, $b->booking->start),
  574.                                     $this->showDetails,
  575.                                     $this->isAdminView)."\n";
  576.           #$t .= '</td>';
  577.         }
  578.       }
  579.       $t .= '</tr>';
  580.     }
  581.     $t .= '</table>';
  582.     return $t;
  583.   }
  584.  
  585.   /**
  586.   * Display the booking details in a table with rowspan based on the duration of the booking
  587.   *
  588.   * @param SimpleTime $daystart    time from which bookings should be displayed
  589.   * @param SimpleTime $daystop     time up until which bookings should be displayed
  590.   * @param integer    $granularity seconds per row in display
  591.   * @param integer    $reportPeriod  seconds between reporting the time in a column down the side
  592.   * @return string   html representation of the calendar
  593.   */
  594.   function displayDayAsTable($daystart, $daystop, $granularity,
  595.                                     $reportPeriod) {
  596.     $this->_breakAcrossDays();
  597. //     echo $this->display();
  598.     $matrix = $this->_collectMatrix($daystart, $daystop, $granularity);
  599.     $numRowsPerDay =  ceil($daystop->subtract($daystart) / $granularity);
  600.     $numRows = $numRowsPerDay;
  601.  
  602.     #report the time in a time column on the LHS every nth row:
  603.     $timecolumn = array();
  604.     $time = $daystart;
  605.     for ($row=0; $row<$numRowsPerDay; $row++) {
  606.       $timecolumn[$row] = clone($time);
  607.       $time->addSecs($granularity);
  608.     }
  609.  
  610.     if (is_array($this->instrumentlist)) {
  611.       $this->freeBusyOnly = true;
  612.     }
  613.  
  614.     $today = new SimpleDate(time());
  615.  
  616.     $t = $this->_makeRefreshScript();
  617.  
  618.     $t .= '<table class="tabularobject calendar" summary="'.T_('Day view of instrument bookings').'">';
  619.     $t .= '<tr><td class="dummy"></td><th></th>';
  620.     $t .= '<td class="caldayzoom">';
  621.     $t .= '<div class="caldate">'
  622.             .$this->start->getLongDateString()
  623.           .'</div>';
  624.     $t .= '</td>';
  625.     $t .= '</tr>';
  626.     for ($row = 0; $row < $numRows; $row++) {
  627.       $t .= '<tr><td class="dummy"></td>';
  628.       if ($row % $reportPeriod == 0) {
  629.         $t .= '<td rowspan="'.$reportPeriod.'">';
  630.         $t .= $timecolumn[$row]->timeString();
  631.         $t .= '</td>';
  632.       }
  633.       if (isset($matrix[0][$row])) {
  634.         #$t .= '<td>';
  635.         #preDump($matrix[$currentidx]->rows[$dayRow]);
  636.         $b =& $matrix[0][$row];
  637.         $b->booking->freeBusyOnly = $this->freeBusyOnly;
  638.         $class = $this->_getDayClass($today, $b->booking->start);
  639.         $t .= "\n\t".$b->display($class,
  640.                                     call_user_func($this->bookhrefCallback, $b->booking->start),
  641.                                     $this->showDetails,
  642.                                     $this->isAdminView)."\n";
  643.         #$t .= '</td>';
  644.       }
  645.       $t .= '</tr>';
  646.     }
  647.     $t .= '</table>';
  648.     return $t;
  649.   }
  650.  
  651.   function _makeRefreshScript() {
  652.     if ($this->reloadInterval <=0) return '';
  653.  
  654.     return "
  655.       <script type='text/javascript'>
  656.         function ReloadPageCalendar() {
  657.           location.reload();
  658.         }
  659.         setTimeout('ReloadPageCalendar()', {$this->reloadInterval});
  660.       </script>";
  661.   }
  662.  
  663.  
  664.   /**
  665.   * logging function -- logs debug info to stdout
  666.   *
  667.   * The higher $priority, the more verbose (in the debugging sense) the output.
  668.   *
  669.   * @param string $string  text to be logged
  670.   * @param integer $priority (optional, default value 10) debug level of the message
  671.   */
  672.   function log ($string, $priority=10) {
  673.     if ($priority <= $this->DEBUG) {
  674.       echo $string.'<br />'."\n";
  675.     }
  676.   }
  677.  
  678.   /**
  679.   * time logging function -- logs the start and stop time of a booking or slot
  680.   *
  681.   * @param string $string  prefix to text to be logged
  682.   * @param TimeSlot $slot    the slot whose start/stop is to be logged
  683.   * @param boolean $display (optional ) use the displayStart rather than the start data in  $slot
  684.   *
  685.   * The higher $prio, the more verbose (in the debugging sense) the output.
  686.   */
  687.   function slotlog ($string, $slot, $display=false) {
  688.     // Efficiency would suggest that &$slot would be better here, but bugs in PHP mean that we can't do that
  689.     // see http://bugs.php.net/bug.php?id=24485 and http://bugs.php.net/bug.php?id=30787
  691.     // short circuit the evaluation here -- if there's no logging going to be done then
  692.     // we don't want to make expensive dateTimeString() calls.
  693.     if ($this->DEBUG < 10) return;
  694.  
  695.     if ($display) {
  696.       $this->log($string.':start='.$slot->displayStart->dateTimeString()
  697.             .' '.$string.':stop='.$slot->displayStop->dateTimeString(), 10);
  698.     } else {
  699.       $this->log($string.':start='.$slot->start->dateTimeString()
  700.             .' '.$string.':stop='.$slot->stop->dateTimeString(), 10);
  701.     }
  702.   }
  703.  
  704.   /**
  705.   * time logging function
  706.   *
  707.   * @param string $string  prefix to text to be logged
  708.   * @param SimpleDate $slot    the time to be logged
  709.   *
  710.   * The higher $prio, the more verbose (in the debugging sense) the output.
  711.   */
  712.   function timelog ($string, $time) {
  713.     // Efficiency would suggest that &$time would be better here, but bugs in PHP mean that we can't do that
  714.     // see http://bugs.php.net/bug.php?id=24485 and http://bugs.php.net/bug.php?id=30787
  716.     // short circuit the evaluation here -- if there's no logging going to be done then
  717.     // we don't want to make expensive dateTimeString() calls.
  718.     if ($this->DEBUG < 10) return;
  719.  
  720.     $this->log($string.' '.$time->dateTimeString(), 10);
  721.   }
  722.  
  723.  

Documentation generated on Tue, 06 Mar 2007 10:00:58 +0000 by phpDocumentor 1.3.0