Source for file layout_profile.php

Documentation is available at layout_profile.php

  1. <?php
  2.     // This file is part of the Sloodle project (www.sloodle.org)
  3.     
  4.     /**
  5.     * This file defines structures for managing Sloodle layout profiles.
  6.     *
  7.     * @package sloodle
  8.     * @copyright Copyright (c) 2008 Sloodle (various contributors)
  9.     * @license http://www.gnu.org/licenses/gpl-3.0.html GNU GPL v3
  10.     *
  11.     * @contributor Peter R. Bloomfield
  12.     */
  13.     
  14.     class SloodleLayout
  15.     {
  16.         var $name;
  17.         var $id;
  18.         var $courseid;
  19.  
  20.         var $entries = array();
  21.         var $originalentryids = array();
  22.  
  23.         function SloodleLayout($r = null) {
  24.  
  25.             if ($r != null) {
  26.                 return $this->load_from_row($r);
  27.             }
  28.             return null;
  29.  
  30.         }
  31.  
  32.         function load_from_row($r) {
  33.  
  34.             if (!$r) return null;
  35.  
  36.             $this->name = $r->name;
  37.             $this->id = $r->id;
  38.             $this->courseid = $r->course;
  39.  
  40.             $this->originalentries = $this->get_entries($store = false);
  41.  
  42.             return true;
  43.  
  44.         }
  45.  
  46.         function load($id) {
  47.  
  48.             $rec = get_record('sloodle_layout','id',$id); 
  49.             if (!$rec) return null;
  50.             $loaded = $this->load_from_row($rec);
  51.  
  52.         }
  53.  
  54.     function populate_entries_from_active_objects() {
  55.            $entries = $this->entries;     
  56.            $ok = true;
  57.        for ($i=0; $i<count($entries); $i++) {
  58.               $entry = $entries[$i];
  59.               if ( ($entry->objectuuid != null) && ($entry->objectuuid != '') ) {
  60.                  $entry->populate_from_active_object();
  61.               }
  62.        }
  63.            return $ok;
  64.     }
  65.  
  66.         function get_sloodle_course() {
  67.  
  68.             $course = new SloodleCourse();
  69.             if ($course->load($this->courseid)) {
  70.                 return $course;
  71.             }
  72.             return null;
  73.  
  74.         }
  75.  
  76.         function get_course() {
  77.  
  78.             return get_record('course','id',$this->courseid);
  79.  
  80.         }
  81.  
  82.         // return a set of SloodleLayoutEntry objects for the layout.
  83.      // store parameter indicates whether they should be stored as instance variables.
  84.     // set $store=false if you're planning to update the object entries and you're only reading them in so the object will know what is already there and what to insert and delete.
  85.         function get_entries($store = true) {
  86.  
  87.             $rows = get_records('sloodle_layout_entry','layout',$this->id);
  88.             $entries = array();
  89.             if (count($rows) > 0) {
  90.                foreach($rows as $row) {
  91.                   $entries[] = new SloodleLayoutEntry($row);
  92.                }
  93.             }
  94.  
  95.             if ($store) {
  96.                $this->entries = $entries;
  97.             }
  98.  
  99. //print "<h4>layout.get_entries returning ".count($entries)."entries</h4>";
  100.             return $entries;
  101.  
  102.         }
  103.  
  104.         function add_entry($entry) {
  105.  
  106.            $entries = $this->entries;
  107.            $entries[] = $entry;
  108.            $this->entries = $entries;
  109.  
  110.         }
  111.  
  112.         function insert() {
  113.  
  114.             $this->id = insert_record('sloodle_layout', $this);
  115.             $this->save_entries();
  116.             return $this->id;
  117.  
  118.         }
  119.  
  120.         function update() {
  121.  
  122.             if (!update_record('sloodle_layout', $this)) {
  123.                return false;
  124.             }
  125.             return $this->save_entries();
  126.  
  127.         }
  128.  
  129.         function save_entries() {
  130.  
  131.             $neededids = array();
  132.             foreach($this->entries as $entry) {
  133.                $entry->layout = $this->id;
  134.                if (!$entry->id) {
  135.                   $entry->id = $entry->insert();
  136.                } else {
  137.                   $entry->update();
  138.                }
  139.                $neededids[] = $entry->id;
  140.             }
  141.  
  142.             foreach($this->originalentries as $entry) {
  143.                $entryid = $entry->id;
  144.                if (!in_array($entryid,$neededids)) {
  145.                   $entry->delete();
  146.                }
  147.             }
  148.  
  149.            return true;
  150.  
  151.         }
  152.  
  153.     }
  154.     
  155.     /**
  156.     * Stores data for a single entry in a layout profile.
  157.     * Used with {@link SloodleCourse}
  158.     * @package sloodle
  159.     */
  160.     class SloodleLayoutEntry
  161.     {
  162.     // DATA //
  163.     
  164.         /**
  165.         * The name of the object this entry represents.
  166.         * @var string 
  167.         * @access public
  168.         */
  169.         var $name = '';
  170.         
  171.         /**
  172.         * The position of the object, as a 3d vector, in string format "<x,y,z>"
  173.         * @var string 
  174.         * @access public
  175.         */
  176.         var $position = '<0.0,0.0,0.0>';
  177.         
  178.         /**
  179.         * The rotation of the object, as a 3d vector of Euler angles, in string format "<x,y,z>"
  180.         * @var string 
  181.         * @access public
  182.         */
  183.         var $rotation = '<0.0,0.0,0.0>';
  184.  
  185.         var $id;
  186.         var $layout;
  187.         var $configs;
  188.         var $originalconfigs;
  189.       
  190.         function SloodleLayoutEntry($r = null) {
  191.  
  192.              if ($r != null) {
  193.                 return $this->load_from_row($r);
  194.              }
  195.  
  196.              return true;
  197.  
  198.         }
  199.  
  200.         function load_from_row($r) {
  201.  
  202.             if (!$r) return null;
  203.  
  204.             $this->name = $r->name;
  205.             $this->position = $r->position;
  206.             $this->rotation = $r->rotation;
  207.             $this->id = $r->id;
  208.             $this->layout = $r->layout;
  209.             $this->objectuuid = $r->objectuuid; // not saved - just used to populate defaults
  210.  
  211.             $this->configs = $this->get_layout_entry_configs();
  212.             $this->originalconfigs = $this->configs; // save the original configs so we know what to delete, what to update and what to add
  213.  
  214.             return true;
  215.  
  216.         }
  217.  
  218.         function load($id) {
  219.  
  220.         $rec = get_record('sloodle_layout_entry', 'id', $id);
  221.             if (!$rec) return null;
  222.             return $this->load_from_row($rec);
  223.             
  224.         }
  225.  
  226.     function populate_from_active_object() {
  227.  
  228.            if (!$objectuuid = $this->objectuuid) {
  229.               return false;
  230.            }
  231.  
  232.            $object = get_record('sloodle_active_object','uuid',$this->objectuuid); 
  233.            $object_id = $object->id;
  234.            if (!$object_id) return false;
  235.  
  236.            $configs = get_records('sloodle_object_config','object',$object_id); 
  237.            foreach($configs as $config) {
  238.               $this->set_config($config->name,$config->value);
  239.            }
  240.  
  241.            return true;
  242.            
  243.            }
  244.  
  245.         function get_layout() {
  246.  
  247.             if ($this->layout != null) {
  248.  
  249.                $layout = new SloodleLayout();
  250.                if ( $layout->load($this->layout) ) {
  251.                    return $layout;
  252.                }
  253.  
  254.             }
  255.             return null;
  256.         }
  257.  
  258.     /**
  259.         * Return an array of layout_entry_config objects
  260.         * @param integer $layout_entry_id The ID of the layout entry
  261.         * @return array Array if successful (empty if there are no entries) , or null otherwise
  262.         */
  263.     function get_layout_entry_configs() {
  264.             
  265.         $recs = get_records('sloodle_layout_entry_config', 'layout_entry', $this->id);
  266.             if (!$recs) return null;
  267.             
  268.             // Construct the array of SloodleLayoutEntry objects
  269.             $entryconfigs = array();
  270.             foreach ($recs as $r) {
  271.                 $entryconfigs[] = new SloodleLayoutEntryConfig($r);
  272.             } 
  273.             return $entryconfigs;
  274.  
  275.     }
  276.  
  277.         function get_layout_entry_configs_as_hidden_fields($prefix, $suffix) {
  278.            
  279.            $str = '';
  280.            foreach($this->get_layout_entry_configs_as_name_value_hash() as $n=>$v) {
  281.               $fieldname = $prefix.$n.$suffix;
  282.               $str .= '<input type="hidden" name="'.$fieldname.'" value="'.$v.'" />';
  283.            }
  284.            return $str;
  285.  
  286.     }
  287.  
  288.      function get_layout_entry_configs_as_name_value_hash() {
  289.  
  290.         $objs = $this->get_layout_entry_configs();
  291.             $configs = array();
  292.             if (count($objs) > 0) {
  293.                foreach($objs as $obj) {
  294.                   $configs[$obj->name] = $obj->value;
  295.                }
  296.             }
  297.             return $configs;
  298.  
  299.     }
  300.  
  301.         /**
  302.         * Sets the position as separate X,Y,Z components
  303.         * @param float $x The X component to set
  304.         * @param float $y The Y component to set
  305.         * @param float $z The Z component to set
  306.         * @return void 
  307.         */
  308.         function set_position_xyz($x, $y, $z)
  309.         {
  310.             $this->position = "<$x,$y,$z>";
  311.         }
  312.         
  313.         /**
  314.         * Sets the rotation as separate X,Y,Z components
  315.         * @param float $x The X component to set
  316.         * @param float $y The Y component to set
  317.         * @param float $z The Z component to set
  318.         * @return void 
  319.         */
  320.         function set_rotation_xyz($x, $y, $z)
  321.         {
  322.             $this->rotation = "<$x,$y,$z>";
  323.         }
  324.         
  325.         function set_config($name, $value) { // add config with given name/value, overwriting if necessary
  326.             $configs = $this->configs;
  327.             $done = false;
  328.             if ( is_array($configs) ) {
  329.                 for( $i=0; $i<count($configs); $i++) {
  330.                     $config = $configs[$i];
  331.                     if ($config->name == $name) {
  332.                          $config->value = $value;
  333.                          $configs[$i] = $config;
  334.                          $done = true;
  335.                     }
  336.                 }  
  337.             } else {
  338.                 $configs = array();
  339.             }
  340.             if (!$done) {
  341.                 $config = new SloodleLayoutEntryConfig();
  342.                 $config->layout_entry = $this->id;
  343.                 $config->name = $name;
  344.                 $config->value = $value;
  345.                 $configs[] = $config;
  346.             }
  347.             $this->configs = $configs;
  348.  
  349.         }
  350.  
  351.         function insert() {
  352.  
  353.             $this->id = insert_record('sloodle_layout_entry', $this);
  354.             if (!$this->id) {
  355.                return false;
  356.             }
  357.             return $this->save_configs();
  358.  
  359.         }
  360.  
  361.         function update() {
  362.  
  363.             if (!update_record('sloodle_layout_entry', $this)) {
  364.                return false;
  365.             }
  366.             return $this->save_configs();
  367.  
  368.         }
  369.  
  370.         function delete() {
  371.  
  372.            if (!$this->id) return false;
  373.  
  374.            if (!$this->delete_configs()) {
  375.               return false;
  376.            }           
  377.  
  378.            $result = delete_records('sloodle_layout_entry', 'id', $this->id);
  379.            return $result;
  380.  
  381.         }
  382.  
  383.         function delete_configs() {
  384.  
  385.             return delete_records('sloodle_layout_entry_config', 'layout_entry', $this->id);
  386.  
  387.         }
  388.  
  389.         function save_configs() {
  390.  
  391.             foreach($this->configs as $config) {
  392.                $config->layout_entry = $this->id; 
  393.  
  394.                if (!$config->id) {
  395.                   $entry_id = $config->insert();
  396.                } else {
  397.                   $config->update();
  398.                }
  399.             }
  400.  
  401.         }
  402.  
  403.     }
  404.  
  405.     class SloodleLayoutEntryConfig
  406.     {
  407.  
  408.         var $id;
  409.         var $layout_entry;
  410.         var $name;
  411.         var $value;
  412.  
  413.         function SloodleLayoutEntryConfig($row = null) {
  414.  
  415.             if ($row != null) {
  416.                 return $this->load_from_row($row);
  417.             }
  418.  
  419.             return null;
  420.  
  421.         }
  422.  
  423.         function load_from_row($row) {
  424.  
  425.             if (!$row) return null;
  426.  
  427.             $this->id = $row->id;
  428.             $this->layout_entry = $row->layout_entry;
  429.             $this->name = $row->name;
  430.             $this->value = $row->value;
  431.  
  432.         }
  433.  
  434.         function load($id) {
  435.         $rec = get_record('sloodle_layout_entry_config', 'id', $id);
  436.             if (!$rec) return null;
  437.             return $this->load_from_row($rec);
  438.         }
  439.  
  440.         function insert() {
  441.  
  442.             return $this->id = insert_record('sloodle_layout_entry_config', $this);
  443.  
  444.         }
  445.  
  446.         function update() {
  447.  
  448.             return update_record('sloodle_layout_entry_config', $this);
  449.  
  450.         }
  451.  
  452.     }
  453. ?>

Documentation generated on Fri, 17 Jul 2009 11:01:32 +0100 by phpDocumentor 1.4.0