themes
[ class tree: themes ] [ index: themes ] [ all elements ]
Packages:
articles
blogs
boards
calendar
events
fisheye
install
kernel
languages
liberty
newsletters
protector
recess-http
search
sharethis
Smarty
stars
tags
themes
treasury
users
wiki

Source for file BitThemes.php

Documentation is available at BitThemes.php

  1. <?php
  2. /**
  3.  * @package themes
  4.  */
  5.  
  6. /**
  7.  * Set-up
  8.  */
  9. require_once( KERNEL_PKG_PATH.'BitCache.php' );
  10. /**
  11.  * BitThemes
  12.  *
  13.  * @package themes
  14.  * @uses BitBase
  15.  */
  16. class BitThemes extends BitSingleton {
  17.     // Array that contains a full description of the current layout
  18.     var $mLayout = array();
  19.  
  20.     // contains the currently active style
  21.     var $mStyle;
  22.  
  23.     // an array with style information
  24.     var $mStyles = array();
  25.  
  26.     // Ajax libraries needed by current Ajax framework (MochiKit libs, etc.)
  27.     var $mAjaxLibs = array();
  28.  
  29.     // Auxiliary Javascript and Css Files
  30.     var $mAuxFiles = array(
  31.         'js'  => array(),
  32.         'css' => array()
  33.     );
  34.  
  35.     // Raw Javascript and Css Files
  36.     var $mRawFiles = array(
  37.         'js'  => array(),
  38.         'css' => array()
  39.     );
  40.  
  41.     // Display Mode
  42.     var $mDisplayMode;
  43.  
  44.     // When all modules are loaded they are loaded here
  45.     var $mModules = array();
  46.  
  47.  
  48.     /**
  49.      * Initiate class
  50.      *
  51.      * @return void 
  52.      */
  53.     function __construct() {
  54.         parent::__construct();
  55.  
  56.         // start up caching engine
  57.         $this->mThemeCache = new BitCache( 'themes', TRUE );
  58.     }
  59.  
  60.     public static function isCacheableClass() {
  61.         return false;
  62.     }
  63.  
  64.     // {{{ =================== Styles ====================
  65.     /**
  66.      * load up style related information that must be
  67.      * loaded before template rendering begins
  68.      *
  69.      * @note this is a interim method as we continue sorting
  70.      *  out the optimal order of operations for rendering
  71.      *  pages. there was some conflict between rendering
  72.      *  module templates and loading styles, where some
  73.      *  style information needs to be loaded before the templates
  74.      *  are rendered, and some such as packing javascript and css
  75.      *  should happen after
  76.      *
  77.      * @see BitSystem::preDisplay
  78.      */
  79.     function preLoadStyle(){
  80.         // define style url and path
  81.         if( !defined( 'THEMES_STYLE_URL' ) ) {
  82.             define( 'THEMES_STYLE_URL', $this->getStyleUrl() );
  83.         }
  84.         if( !defined( 'THEMES_STYLE_PATH' ) ) {
  85.             define( 'THEMES_STYLE_PATH', $this->getStylePath() );
  86.         }
  87.     }
  88.  
  89.  
  90.     /*
  91.      * load up all style related information
  92.      * populates mStyle and mStyles
  93.      *
  94.      * @access public
  95.      * @return void
  96.      */
  97.     function loadStyle() {
  98.         global $gBitSystem;
  99.         // load default css files
  100.         if( empty( $this->mStyles['styleSheet'] )) {
  101.             $this->mStyles['styleSheet'] = $this->getStyleCssFile( NULL, TRUE );
  102.         }
  103.  
  104.         // load tpl files that need to be included
  105.         $this->loadTplFiles( "html_head_inc" );
  106.         $this->loadTplFiles( "footer_inc" );
  107.  
  108.         // join javascript files that have been loaded
  109.         $this->mStyles['joined_javascript'] = $this->joinAuxFiles( 'js' );
  110.  
  111.         // layout is called as the viry first, package css is around pos 300 and theme / browser are called last
  112.         // css inserted in <pkg>/html_head_inc.tpl is called before these files since these are inserted last
  113. //        $this->loadCss( $this->getLayoutCssFile(),       TRUE, 1,    TRUE, TRUE );
  114.         $this->loadCss( $this->getStyleCssFile(),        TRUE, 998,    TRUE, TRUE );
  115.         $this->loadCss( $this->getBrowserStyleCssFile(), TRUE, 999,    TRUE, TRUE );
  116.         // check for customized CSS file
  117.         if( file_exists( CONFIG_PKG_PATH.'css/config.css' ) ) {
  118.             $this->loadCss( CONFIG_PKG_PATH.'css/config.css' );
  119.         }
  120.         $this->mStyles['joined_css'] = $this->joinAuxFiles( 'css' );
  121.     }
  122.  
  123.     /**
  124.      * figure out the current style
  125.      *
  126.      * @param string $ pScanFile file to be looked for
  127.      * @return none 
  128.      * @access public
  129.      */
  130.     function getStyle() {
  131.         global $gBitSystem;
  132.         if( empty( $this->mStyle )) {
  133.             $this->mStyle = $gBitSystem->getConfig( 'style' );
  134.         }
  135.         return $this->mStyle;
  136.     }
  137.  
  138.     /**
  139.      * figure out the current style
  140.      *
  141.      * @param string $ pScanFile file to be looked for
  142.      * @return none 
  143.      * @access public
  144.      */
  145.     function setStyle( $pStyle ) {
  146.         global $gBitSmarty;
  147.         $this->mStyle = $pStyle;
  148.         $gBitSmarty->verifyCompileDir();
  149.     }
  150.  
  151.     /**
  152.      * figure out the current style
  153.      *
  154.      * @param string $ pScanFile file to be looked for
  155.      * @return none 
  156.      * @access public
  157.      */
  158.     function getStyleCssFile( $pStyle = NULL, $pUrl = FALSE ) {
  159.         global $gBitSystem;
  160.         if( empty( $pStyle )) {
  161.             $pStyle = $this->getStyle();
  162.         }
  163.         $ret = '';
  164.  
  165.         if( $pUrl ) {
  166.             $base = $this->getStyleUrl();
  167.         } else {
  168.             $base = $this->getStylePath();
  169.         }
  170.  
  171.         if( $gBitSystem->getConfig( 'style_variation' ) && is_readable( $this->getStylePath().'alternate/'.$gBitSystem->getConfig( 'style_variation' ).'.css' )) {
  172.             $ret = $base.'alternate/'.$gBitSystem->getConfig( 'style_variation' ).'.css';
  173.         } elseif( is_readable( $this->getStylePath().$pStyle.'.css' )) {
  174.             $ret = $base.$pStyle.'.css';
  175.         }
  176.         return $ret;
  177.     }
  178.  
  179.     /**
  180.      * get browser specific css file
  181.      *
  182.      * @param none 
  183.      * @return path to browser specific css file
  184.      * @access public
  185.      */
  186.     function getBrowserStyleCssFile( $pUrl = FALSE ) {
  187.         global $gSniffer;
  188.  
  189.         if( $pUrl ) {
  190.             $base = $this->getStyleUrl();
  191.         } else {
  192.             $base = $this->getStylePath();
  193.         }
  194.         $subpath = $this->getStyle().'_'.$gSniffer->property( 'browser' );
  195.  
  196.         // Allow us to split by major version with a fallback for others
  197.         if( file_exists( $this->getStylePath().$subpath.$gSniffer->property( 'maj_ver' ).'.css' )) {
  198.             $ret = $base.$subpath.$gSniffer->property( 'maj_ver' ).'.css';
  199.         } elseif( file_exists( $this->getStylePath().$subpath.'.css' )) {
  200.             $ret = $base.$subpath.'.css';
  201.         }
  202.         return !empty( $ret ) ? $ret : NULL;
  203.     }
  204.  
  205.     /**
  206.      * get browser specific css file
  207.      *
  208.      * @param none 
  209.      * @return path to browser specific css file
  210.      * @access public
  211.      */
  212.     function getLayoutCssFile() {
  213.         global $gBitSystem;
  214.         if( $gBitSystem->isFeatureActive( 'site_style_layout' )) {
  215.             $ret = realpath( THEMES_PKG_PATH."layouts/".$gBitSystem->getConfig( 'site_style_layout' ).".css" );
  216.         }
  217.         return !empty( $ret ) ? $ret : NULL;
  218.     }
  219.  
  220.     /**
  221.      * figure out the current style URL
  222.      *
  223.      * @param string $ pScanFile file to be looked for
  224.      * @return none 
  225.      * @access public
  226.      */
  227.     function getStyleUrl( $pStyle = NULL ) {
  228.         if( empty( $pStyle )) {
  229.             $pStyle = $this->getStyle();
  230.         }
  231.         return CONFIG_PKG_URL.'themes/'.$pStyle.'/';
  232.     }
  233.  
  234.     /**
  235.      * figure out the current style URL
  236.      *
  237.      * @param string $ pScanFile file to be looked for
  238.      * @return none 
  239.      * @access public
  240.      */
  241.     function getStylePath( $pStyle = NULL ) {
  242.         if( empty( $pStyle )) {
  243.             $pStyle = $this->getStyle();
  244.         }
  245.         return CONFIG_PKG_PATH.'themes/'.$pStyle.'/';
  246.     }
  247.  
  248.     /**
  249.      * getStyles
  250.      *
  251.      * @param array $pDir 
  252.      * @param array $pNullOption 
  253.      * @param array $bIncludeCustom 
  254.      * @access public
  255.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  256.      */
  257.     function getStyles( $pDir = NULL, $pNullOption = NULL, $bIncludeCustom = FALSE ) {
  258.         global $gBitSystem, $gBitUser;
  259.  
  260.         if( empty( $pDir )) {
  261.             $pDir = CONFIG_PKG_PATH.'themes/';
  262.         }
  263.         $ret = array();
  264.  
  265.         if( !empty( $pNullOption )) {
  266.             $ret[] = '';
  267.         }
  268.  
  269.         if( is_dir( $pDir )) {
  270.             $h = opendir( $pDir );
  271.             while( $file = readdir( $h )) {
  272.                 if ( is_dir( $pDir."$file" ) && ( $file != '.' && $file != '..' && $file != 'CVS' && $file != 'slideshows' && $file != 'blank' )) {
  273.                     $ret[] = $file;
  274.                 }
  275.             }
  276.             closedir( $h );
  277.         }
  278.  
  279.         if( $bIncludeCustom && $gBitSystem->getConfig( 'themes_edit_css' )) {
  280.             // Include the users custom css if they have created one
  281.             $customCSSPath = $gBitUser->getStoragePath( NULL,$gBitUser->mUserId );
  282.             $customCSSFile = $customCSSPath.'custom.css';
  283.  
  284.             if (file_exists($customCSSFile)) {
  285.                 $ret[] = 'custom';
  286.             }
  287.         }
  288.  
  289.         if( count( $ret )) {
  290.             sort( $ret );
  291.         }
  292.  
  293.         return $ret;
  294.     }
  295.  
  296.     /**
  297.      * getStyleLayouts
  298.      *
  299.      * @access public
  300.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  301.      */
  302.     function getStyleLayouts() {
  303.         $ret = array();
  304.  
  305.         if( is_dir( THEMES_PKG_PATH.'layouts/' )) {
  306.             $h = opendir( THEMES_PKG_PATH.'layouts/' );
  307.             // collect all layouts
  308.             while( FALSE !== ( $file = readdir( $h ))) {
  309.                 if ( !preg_match( "/^\./", $file )) {
  310.                     $ret[substr( $file, 0, ( strrpos( $file, '.' )))][substr( $file, ( strrpos( $file, '.' ) + 1 ))] = $file;
  311.                 }
  312.             }
  313.             closedir( $h );
  314.  
  315.             // weed out any files that don't have a css file associated with them
  316.             foreach( $ret as $key => $layout ) {
  317.                 if( empty( $layout['css'] )) {
  318.                     unset( $ret[$key] );
  319.                 }
  320.             }
  321.  
  322.             ksort( $ret );
  323.         }
  324.         return $ret;
  325.     }
  326.  
  327.     /**
  328.     * @param $pSubDirs a subdirectory to scan as well - you can pass in multiple dirs using an array
  329.      *
  330.      * @param array $pDir 
  331.      * @param array $pNullOption 
  332.      * @param array $pSubDirs 
  333.      * @access public
  334.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  335.      */
  336.     function getStylesList( $pDir = NULL, $pNullOption = NULL, $pSubDirs = NULL ) {
  337.         global $gBitSystem;
  338.  
  339.         $ret = array();
  340.  
  341.         if( empty( $pSubDirs )) {
  342.             $subDirs[] = array( '' );
  343.         } elseif( !is_array( $pSubDirs )) {
  344.             $subDirs[] = $pSubDirs;
  345.         } else {
  346.             $subDirs = $pSubDirs;
  347.         }
  348.  
  349.         if( empty( $pDir )) {
  350.             $pDir = CONFIG_PKG_PATH.'themes/';
  351.         }
  352.  
  353.         if( !empty( $pNullOption )) {
  354.             $ret[] = '';
  355.         }
  356.  
  357.         // open directories
  358.         if( is_dir( $pDir )) {
  359.             $h = opendir( $pDir );
  360.             // cycle through files / dirs
  361.             while( FALSE !== ( $file = readdir( $h ))) {
  362.                 if ( is_dir( $pDir.$file ) && ( $file != '.' && $file != '..' && $file != 'CVS' && $file != 'slideshows' && $file != 'blank' )) {
  363.                     $ret[$file]['style'] = $file;
  364.                     // check if we want to have a look in any subdirs
  365.                     foreach( $subDirs as $dir ) {
  366.                         if( is_dir( $infoDir = $pDir.$file.'/'.$dir.'/' )) {
  367.                             $dh = opendir( $infoDir );
  368.                             // cycle through files / dirs
  369.                             while( FALSE !== ( $f = readdir( $dh ))) {
  370.                                 if( is_readable( $infoDir.$f ) && ( $f != '.' &&  $f != '..' &&  $f != 'CVS' )) {
  371.                                     $ret[$file][$dir][preg_replace( "/\..*/", "", $f )] = CONFIG_PKG_URL.basename( dirname( dirname( $infoDir ))).'/'.$file.'/'.$dir.'/'.$f;
  372.  
  373.                                     if( preg_match( "/\.htm$/", $f )) {
  374.                                         $fh = fopen( $infoDir.$f, "r" );
  375.                                         $ret[$file][$dir][preg_replace( "/\.htm$/", "", $f )] = fread( $fh, filesize( $infoDir.$f ));
  376.                                         fclose( $fh );
  377.                                     }
  378.                                 }
  379.                             }
  380.                             // sort the returned items
  381.                             @ksort( $ret[$file][$dir] );
  382.                             closedir( $dh );
  383.                         }
  384.                     }
  385.                 }
  386.             }
  387.             closedir( $h );
  388.         }
  389.  
  390.         if( count( $ret )) {
  391.             ksort( $ret );
  392.         }
  393.  
  394.         return $ret;
  395.     }
  396.  
  397.     /**
  398.      * get the icon cache path
  399.      *
  400.      * @access public
  401.      * @return absolute path on where the system should store it's icons
  402.      */
  403.     function getIconCachePath() {
  404.         global $gSniffer, $gBitSystem, $gBitLanguage;
  405.  
  406.         // use bitweaver version as dir in case there has been changes since the last version
  407.         $version = $gBitSystem->getBitVersion( FALSE );
  408.  
  409.         // some browsers need special treatment due to different biticon feed.
  410.         if( $gSniffer->_browser_info['browser'] == 'ie' ) {
  411.             $browser = $gSniffer->_browser_info['browser'].$gSniffer->_browser_info['maj_ver'];
  412.         } else {
  413.             $browser = 'default';
  414.         }
  415.  
  416.         $cachedir = TEMP_PKG_PATH.'themes/biticon/'.$version.'/'.$gBitSystem->getConfig( 'site_icon_style', DEFAULT_ICON_STYLE ).'/'.$gBitLanguage->getLanguage().'/'.$browser.'/';
  417.         if( !is_dir( $cachedir )) {
  418.             mkdir_p( $cachedir );
  419.         }
  420.         return $cachedir;
  421.     }
  422.  
  423.  
  424.     // }}}
  425.     // {{{ =================== Layout ====================
  426.     /**
  427.      * load current layout into mLayout
  428.      *
  429.      * @param  $pParamHash 
  430.      * @return none 
  431.      * @access public
  432.      */
  433.     function loadLayout( $pParamHash = NULL ) {
  434.         global $gBitSystem;
  435.         if( empty( $this->mLayout ) || !count( $this->mLayout )){
  436.             $this->mLayout = $this->getLayout( $pParamHash );
  437.  
  438.             /**
  439.              * this needs to occur after loading the layout to ensure that we don't distrub the fallback process during layout loading
  440.              * we can disable clumns using various criteria:
  441.              *     <package>_hide_<area>_col
  442.              *     <display_mode>_hide_<area>_col
  443.              *     <package>_<display_mode>_hide_<area>_col
  444.              */
  445.             $areas = array( 't' => 'top', 'l' => 'left', 'r' => 'right', 'b' => 'bottom' );
  446.             foreach( $areas as $layout => $area ) {
  447.                 if(
  448.                     $gBitSystem->isFeatureActive( "{$this->mDisplayMode}_hide_{$area}_col" ) ||
  449.                     $gBitSystem->isFeatureActive( "{$gBitSystem->mActivePackage}_hide_{$area}_col" ) ||
  450.                     $gBitSystem->isFeatureActive( "{$gBitSystem->mActivePackage}_{$this->mDisplayMode}_hide_{$area}_col" )
  451.                 ) {
  452.                     unset( $this->mLayout[$layout] );
  453.                 }
  454.             }
  455.         }
  456.     }
  457.  
  458.     function hasColumnModules( $pColumn ) {
  459.         return count( $this->mLayout[$pColumn] );
  460.     }
  461.  
  462.     function displayLayoutColumn( $pColumn ) {
  463.         if( $colHtml = $this->fetchLayoutColumn( $pColumn ) ) {
  464.             print $colHtml;
  465.         }
  466.     }
  467.  
  468.     function fetchLayoutColumn( $pColumn ) {
  469.         global $gBitSmarty, $gBitSystem;
  470.         $ret = '';
  471.         if( !empty( $this->mLayout[$pColumn] ) ) {
  472.             for ($i = 0; $i < count( $this->mLayout[$pColumn] ); $i++) {
  473.                 $r = &$this->mLayout[$pColumn][$i];
  474.                 if( !empty( $r['visible'] )) {
  475.                     try {
  476.                         // @TODO MODULE UPGRADE under new module organization this is not reliable as tpls are in sub dir in modules/ change this when upgrade is complete
  477.                         list( $package, $template ) = explode(  '/', $r['module_rsrc'] );
  478.                         // deal with custom modules
  479.                         if( $package == '_custom:custom' ) {
  480.                             global $gBitLanguage;
  481.  
  482.                             // We're gonna run our own cache mechanism for user_modules
  483.                             // the cache is here to avoid calls to consumming queries,
  484.                             // each module is different for each language because of the strings
  485.                             $cacheDir = TEMP_PKG_PATH.'modules/cache/';
  486.                             if( !is_dir( $cacheDir )) {
  487.                                 mkdir_p( $cacheDir );
  488.                             }
  489.                             $cachefile = $cacheDir.'_custom.'.$gBitLanguage->mLanguage.'.'.$template.'.tpl.cache';
  490.  
  491.                             if( !empty( $r["cache_time"] ) && file_exists( $cachefile ) && !(( $gBitSystem->getUTCTime() - filemtime( $cachefile )) > $r["cache_time"] )) {
  492.                                 $fp = fopen( $cachefile, "r" );
  493.                                 $data = fread( $fp, filesize( $cachefile ));
  494.                                 fclose( $fp );
  495.                                 $r["data"] = $data;
  496.                             } else {
  497.                                 if( $moduleParams = $this->getCustomModule( $template )) {
  498.                                     $moduleParams = array_merge( $r, $moduleParams );
  499.                                     $gBitSmarty->assign_by_ref( 'moduleParams', $moduleParams );
  500.                                     $ret .= $gBitSmarty->fetch( 'bitpackage:themes/custom_module.tpl' );
  501.  
  502.                                     if( !empty( $r["cache_time"] ) ) {
  503.                                         // write to chache file
  504.                                         $fp = fopen( $cachefile, "w+" );
  505.                                         fwrite( $fp, $data, strlen( $data ));
  506.                                         fclose( $fp );
  507.                                     }
  508.                                     $r["data"] = $data;
  509.                                 }
  510.                             }
  511.                             unset( $data );
  512.                         } else {
  513.                             $explosion = explode( '/', $r['module_rsrc'] );
  514.                             $template = array_pop( $explosion );
  515.  
  516.                             // using $module_rows, $module_params and $module_title is deprecated. please use $moduleParams hash instead
  517.                             global $module_rows, $module_params, $module_title, $gBitLanguage;
  518.  
  519.                             $cacheDir = TEMP_PKG_PATH.'modules/cache/';
  520.                             if( !is_dir( $cacheDir )) {
  521.                                 mkdir_p( $cacheDir );
  522.                             }
  523.  
  524.                             // include tpl name and module id to uniquely identify
  525.                             $cachefile = $cacheDir.'_module_'.$r['module_id'].'.'.$gBitLanguage->mLanguage.'.'.$template.'.cache';
  526.  
  527.                             // if the time is right get the cache else get it fresh
  528.                             if( !empty( $r["cache_time"] ) && file_exists( $cachefile ) && filesize( $cachefile ) && !(( $gBitSystem->getUTCTime() - filemtime( $cachefile )) > $r["cache_time"] ) ) {
  529.                                 $fp = fopen( $cachefile, "r" );
  530.                                 $data = fread( $fp, filesize( $cachefile ));
  531.                                 fclose( $fp );
  532.                                 $r["data"] = $data;
  533.                             } else {
  534.                                 $module_params = $r['module_params']; // backwards compatability
  536.                                 if( !$r['module_rows'] ) {
  537.                                     $r['module_rows'] = 10;
  538.                                 }
  539.  
  540.                                 // if there's no custom title, get one from file name
  541.                                 if( !$r['title'] = ( isset( $r['title'] ) ? tra( $r['title'] ) : NULL )) {
  542.                                     $pattern[0] = "/.*\/mod_(.*)\.tpl/";
  543.                                     $replace[0] = "$1";
  544.                                     $pattern[1] = "/_/";
  545.                                     $replace[1] = " ";
  546.                                     $r['title'] = ( !empty( $r['title'] ) ? tra( $r['title'] ) : tra( ucwords( preg_replace( $pattern, $replace, $r['module_rsrc'] ))));
  547.                                 }
  548.  
  549.                                 // moduleParams are extracted in BitSmarty::getSiblingAttachments() and passed on the the module php file
  550.                                 $moduleParams = $r;
  551.                                 $gBitSmarty->assign_by_ref( 'moduleParams', $moduleParams );
  552.                                 // assign the custom module title
  553.                                 $ret .= $gBitSmarty->fetch( $r['module_rsrc'] );
  554.  
  555.                                 if( !empty( $r["cache_time"] ) ) {
  556.                                     // write to chache file
  557.                                     $fp = fopen( $cachefile, "w+" );
  558.                                     fwrite( $fp, $data, strlen( $data ));
  559.                                     fclose( $fp );
  560.                                 }
  561.                                 $r["data"] = $data;
  562.                             }
  563.  
  564.                             unset( $moduleParams );
  565.                         }
  566.                     } catch( Exception $e ) {
  567.                         print( '<div class="alert alert-warning">'.$e->getMessage() ).'</div>';
  568.                     }
  569.                     if( !empty( $ret ) && ($pColumn == 'l' || $pColumn == 'r') ) { 
  570.                         $ret = '<div class="panel-group col-xs-12">'.$ret.'</div>';
  571.                     }
  572.                 }
  573.             }
  574.         }
  575.         return $ret;
  576.     }
  577.  
  578.     /**
  579.      * get the current layout from the database, layouts are fetched in this order in this order until one is successfully loaded: 'layout', 'fallback_layout', ACTIVE_PACKGE, DEFAULT_PACKAGE"
  580.      *
  581.      * @param array $pParamHash
  582.      * @access public
  583.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  584.      */
  585.     function getLayout( $pParamHash = NULL ) {
  586.         global $gCenterPieces, $gBitUser, $gBitSystem, $gBitSmarty;
  587.         $ret = array( 'l' => NULL, 'c' => NULL, 'r' => NULL );
  588.  
  589.         $layouts =  array();
  590.         if( !empty( $pParamHash['layout'] )) {
  591.             $layouts[] = $pParamHash['layout'];
  592.         }
  593.         if( !empty( $pParamHash['fallback_layout'] )) {
  594.             $layouts[] = $pParamHash['fallback_layout'];
  595.         }
  596.         if( defined( 'ACTIVE_PACKAGE') ) {
  597.             $layouts[] = ACTIVE_PACKAGE;
  598.         }
  599.         $layouts[] = DEFAULT_PACKAGE;
  600.  
  601.         foreach( $layouts AS $l ) {
  602.             $query =   "SELECT tl.*
  603.                         FROM `".BIT_DB_PREFIX."themes_layouts` tl
  604.                         WHERE  tl.`layout`=? ORDER BY ".$this->mDb->convertSortmode( "pos_asc" );
  605.  
  606.             $result = $this->mDb->query( $query, array( $l ) );
  607.             if( $result && $result->RecordCount() ) {
  608.                 break;
  609.             }
  610.         }
  611.         if( !empty( $result ) && $result->RecordCount() ) {
  612.             $row = $result->fetchRow();
  613.             // Check to see if we have ACTIVE_PACKAGE modules at the top of the results
  614.             if( isset( $row['layout'] ) && ( $row['layout'] != DEFAULT_PACKAGE ) && ( ACTIVE_PACKAGE != DEFAULT_PACKAGE )) {
  615.                 $skipDefaults = TRUE;
  616.             } else {
  617.                 $skipDefaults = FALSE;
  618.             }
  619.  
  620.             if ( !is_array( $gCenterPieces ) ){
  621.                 $gCenterPieces = array();
  622.             }
  623.             while( $row ) {
  624.                 if( $skipDefaults && $row['layout'] == DEFAULT_PACKAGE ) {
  625.                     // we're done! we've got all the non-DEFAULT_PACKAGE modules
  626.                     break;
  627.                 }
  628.  
  629.                 if ( defined ('ROLE_MODEL') ) {
  630.                     // transform roles to managable array
  631.                     if( empty( $row["roles"] )) {
  632.                         // default is that module is visible at all times
  633.                         $row["visible"] = TRUE;
  634.                         $row["module_roles"] = array();
  635.                     } else {
  636.                         $row['module_roles'] = $this->parseRoles( $row['roles'] );
  637.  
  638.                         if( $gBitUser->isAdmin() ) {
  639.                             if ( $gBitSystem->isFeatureActive('site_mods_req_admn_grp') ) {
  640.                                 if( in_array(1, $row['module_roles']) ) {
  641.                                     $row['visible'] = TRUE;
  642.                                 }
  643.                             }
  644.                             else {
  645.                                 $row["visible"] = TRUE;
  646.                             }
  647.                         } else {
  648.                             // Check for the right roles
  649.                             foreach( $row["module_roles"] as $modRoleId ) {
  650.                                 if( $gBitUser->isInRole( $modRoleId )) {
  651.                                     $row["visible"] = TRUE;
  652.                                     break; // no need to continue looping
  653.                                 }
  654.                             }
  655.                         }
  656.                     }
  657.                 } else {
  658.                     // transform groups to managable array
  659.                     if( empty( $row["groups"] )) {
  660.                         // default is that module is visible at all times
  661.                         $row["visible"] = TRUE;
  662.                         $row["module_groups"] = array();
  663.                     } else {
  664.                         $row['module_groups'] = $this->parseGroups( $row['groups'] );
  665.  
  666.                         if( $gBitUser->isAdmin() ) {
  667.                             if ( $gBitSystem->isFeatureActive('site_mods_req_admn_grp') ) {
  668.                                 if( in_array(1, $row['module_groups']) ) {
  669.                                     $row['visible'] = TRUE;
  670.                                 }
  671.                             }
  672.                             else {
  673.                                 $row["visible"] = TRUE;
  674.                             }
  675.                         } else {
  676.                             // Check for the right groups
  677.                             foreach( $row["module_groups"] as $modGroupId ) {
  678.                                 if( $gBitUser->isInGroup( $modGroupId )) {
  679.                                     $row["visible"] = TRUE;
  680.                                     break; // no need to continue looping
  681.                                 }
  682.                             }
  683.                         }
  684.                     }
  685.                 }
  686.  
  687.                 if( empty( $ret[$row['layout_area']] )) {
  688.                     $ret[$row['layout_area']] = array();
  689.                 }
  690.  
  691.                 $row['module_params'] = $this->parseString( $row['params'] );
  692.  
  693.                 if( !empty( $pParamHash['load_config'] ) ) {
  694.                     global $moduleParams;
  695.                     $row['config'] = $gBitSmarty->getModuleConfig( $row['module_rsrc'] );
  696.                 }
  697.  
  698.                 if( $row['layout_area'] == CENTER_COLUMN ) {
  699.                     array_push( $gCenterPieces, $row );
  700.                 }
  701.  
  702.                 if( !empty( $row["visible"] )) {
  703.                     array_push( $ret[$row['layout_area']], $row );
  704.                 }
  705.  
  706.                 $row = $result->fetchRow();
  707.             }
  708.         }
  709.         return $ret;
  710.     }
  711.  
  712.     /**
  713.      * isModuleLoaded will check if a given modules is being used in the currently active layout
  714.      *
  715.      * @param string $pModuleResource the module resource
  716.      * @param string $pArea optionally specify the area the module should be found in
  717.      * @access public
  718.      * @return TRUE on success, FALSE on failure
  719.      */
  720.     function isModuleLoaded( $pModuleResource, $pArea = NULL ) {
  721.         // load the layout if it hasn't been done yet
  722.         $this->loadLayout();
  723.  
  724.         if( !$this->verifyArea( $pArea ) && !empty( $this->mLayout[$pArea] )) {
  725.             foreach( $this->mLayout[$pArea] as $module ) {
  726.                 if( $pModuleResource == $module['module_rsrc'] ) {
  727.                     return TRUE;
  728.                 }
  729.             }
  730.         } else {
  731.             foreach( array_keys( $this->mLayout ) as $area ) {
  732.                 if( !empty( $this->mLayout[$area] )) {
  733.                     foreach( $this->mLayout[$area] as $module ) {
  734.                         if( $pModuleResource == $module['module_rsrc'] ) {
  735.                             return TRUE;
  736.                         }
  737.                     }
  738.                 }
  739.             }
  740.         }
  741.         return FALSE;
  742.     }
  743.  
  744.     /**
  745.      * fix postional data in database using increments of 10 to make it easy for inserting new modules
  746.      *
  747.      * @access public
  748.      * @return void
  749.      */
  750.     function fixPositions( $pLayout = NULL ) {
  751.         $layouts = $this->getAllLayouts();
  752.  
  753.         // if we only want to fix the positions of a given layout, strip down the hash
  754.         if( !empty( $pLayout ) && !empty( $layouts[$pLayout] )) {
  755.             $layouts = array( $layouts[$pLayout] );
  756.         }
  757.  
  758.         foreach( $layouts as $layout ) {
  759.             foreach( $layout as $column ) {
  760.                 $i = 5;
  761.                 foreach( $column as $module ) {
  762.                     $this->mDb->query( "UPDATE `".BIT_DB_PREFIX."themes_layouts` SET pos=? WHERE `module_id`=?", array( $i, $module['module_id'] ));
  763.                     $i += 5;
  764.                 }
  765.             }
  766.         }
  767.     }
  768.  
  769.     /**
  770.      * get a brief summary of set layouts
  771.      *
  772.      * @access public
  773.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  774.      */
  775.     function getAllLayouts() {
  776.         $layouts = array();
  777.         $modules = $this->mDb->getAll( "SELECT tl.* FROM `".BIT_DB_PREFIX."themes_layouts` tl ORDER BY ".$this->mDb->convertSortmode( "pos_asc" ));
  778.         foreach( $modules as $module ) {
  779.             if( defined ( 'ROLE_MODEL') ) {
  780.                 $module['module_roles'] = $this->parseRoles( $module['roles'] );
  781.             } else {
  782.                 $module['module_groups'] = $this->parseGroups( $module['groups'] );
  783.             }
  784.             $layouts[$module['layout']][$module['layout_area']][] = $module;
  785.         }
  786.         ksort( $layouts );
  787.         // Take the default/kernel layout and make sure it is the first item in hash
  788.         if( ( count( $layouts ) > 1 ) && isset( $layouts['kernel'] ) ) {
  789.             $kernel_layout = $layouts['kernel'];
  790.             unset( $layouts['kernel'] );
  791.             $layouts = array('kernel' => $kernel_layout) + $layouts;
  792.         }
  793.         return $layouts;
  794.     }
  795.  
  796.     /**
  797.      * cloneLayout
  798.      *
  799.      * @param array $pFromLayout
  800.      * @param array $pToLayout
  801.      * @access public
  802.      * @return boolean TRUE
  803.      */
  804.     function cloneLayout( $pFromLayout, $pToLayout ) {
  805.         global $gBitSystem;
  806.         if( !empty( $pFromLayout ) && !empty( $pToLayout ) ) {
  807.             // nuke existing layout
  808.             $this->mDb->query( "DELETE FROM `".BIT_DB_PREFIX."themes_layouts` WHERE `layout`=?", array( $pToLayout ));
  809.             // get requested layout
  810.             $team = defined('ROLE_MODEL') ? 'roles' : 'groups';
  811.             $layout = $this->mDb->getAll( "
  812.                 SELECT `title`, `layout_area`, `module_rows`, `module_rsrc`, `params`, `cache_time`, `$team`, `pos`
  813.                 FROM `".BIT_DB_PREFIX."themes_layouts` WHERE `layout`=?", array( $pFromLayout ));
  814.             foreach( $layout as $module ) {
  815.                 $module['layout'] = $pToLayout;
  816.                 $this->storeModule( $module );
  817.             }
  818.         }
  819.         return TRUE;
  820.     }
  821.  
  822.     /**
  823.      * expungeLayout
  824.      *
  825.      * @param array $pLayout
  826.      * @access public
  827.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  828.      */
  829.     function expungeLayout( $pLayout = NULL ) {
  830.         $bindVars = array();
  831.         if( !empty( $pLayout )) {
  832.             $whereSql = "WHERE `layout`=?";
  833.             $bindVars[] = $pLayout;
  834.         }
  835.         $this->mDb->query( "DELETE FROM `".BIT_DB_PREFIX."themes_layouts` $whereSql", $bindVars );
  836.     }
  837.  
  838.     /**
  839.      * transform groups string to handy array
  840.      *
  841.      * @param array $pParseString either space separated list of groups or serialised array
  842.      * @access public
  843.      * @return array of groups
  844.      */
  845.     function parseGroups( $pParseString ) {
  846.         $ret = array();
  847.         // convert groups string to hash
  848.         if( preg_match( '/[A-Za-z]/', $pParseString )) {
  849.             // old style serialized group names
  850.             if( $grps = @unserialize( $pParseString )) {
  851.                 foreach( $grps as $grp ) {
  852.                     global $gBitUser;
  853.                     if( !( $groupId = array_search( $grp, $gBitUser->mGroups ))) {
  854.                         if( $gBitUser->isAdmin() ) {
  855.                             $ret[] = $gBitUser->groupExists( $grp, '*' );
  856.                         }
  857.                     }
  858.  
  859.                     if( @$this->verifyId( $groupId )) {
  860.                         $ret[] = $groupId;
  861.                     }
  862.                 }
  863.             }
  864.         } else {
  865.             // new imploded style
  866.             $ret = explode( ' ', $pParseString );
  867.         }
  868.         return $ret;
  869.     }
  870.  
  871.     /**
  872.      * transform roles string to handy array
  873.      *
  874.      * @param array $pParseString either space separated list of roles or serialised array
  875.      * @access public
  876.      * @return array of roles
  877.      */
  878.     function parseRoles( $pParseString ) {
  879.         $ret = array();
  880.         // convert role string to hash
  881.         if( preg_match( '/[A-Za-z]/', $pParseString )) {
  882.             // old style serialized role names
  883.             if( $grps = @unserialize( $pParseString )) {
  884.                 foreach( $grps as $grp ) {
  885.                     global $gBitUser;
  886.                     if( !( $roleId = array_search( $grp, $gBitUser->mRoles ))) {
  887.                         if( $gBitUser->isAdmin() ) {
  888.                             $ret[] = $gBitUser->rollExists( $grp, '*' );
  889.                         }
  890.                     }
  891.  
  892.                     if( @$this->verifyId( $roleId )) {
  893.                         $ret[] = $roleId;
  894.                     }
  895.                 }
  896.             }
  897.         } else {
  898.             // new imploded style
  899.             $ret = explode( ' ', $pParseString );
  900.         }
  901.         return $ret;
  902.     }
  903.  
  904.  
  905.     // }}}
  906.     // {{{ =================== Modules ====================
  907.     /**
  908.      * Verfiy module parameters when storing a new module
  909.      *
  910.      * @param array $pHash
  911.      * @access public
  912.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  913.      */
  914.     function verifyModuleParams( &$pHash ) {
  915.         // we need at least a module_id or a module_rsrc
  916.         if( empty( $pHash['module_id'] ) && empty( $pHash['module_rsrc'] )) {
  917.             $this->mErrors['module_rsrc'] = tra( 'No module id or module file given.' );
  918.         } elseif( !empty( $pHash['module_id'] )) {
  919.             $pHash['store']['module_id'] = $pHash['module_id'];
  920.         } elseif( !empty( $pHash['module_rsrc'] )) {
  921.             $pHash['store']['module_rsrc'] = $pHash['module_rsrc'];
  922.         }
  923.  
  924.         // if we don't have a valid area, we'll just shove it in the left column
  925.         if( $this->verifyArea( $pHash['layout_area'] )) {
  926.             $pHash['store']['layout_area'] = $pHash['layout_area'];
  927.         } else {
  928.             $pHash['store']['layout_area'] = 'l';
  929.         }
  930.  
  931.         $pHash['store']['title']         = ( !empty( $pHash['title'] )             ? $pHash['title']         : NULL );
  932.         $pHash['store']['params']        = ( !empty( $pHash['params'] )            ? $pHash['params']        : NULL );
  933.         $pHash['store']['layout']        = ( !empty( $pHash['layout'] )            ? $pHash['layout']        : DEFAULT_PACKAGE );
  934.         $pHash['store']['module_rows']   = ( @is_numeric( $pHash['module_rows'] )  ? $pHash['module_rows']   : NULL );
  935.         $pHash['store']['cache_time']    = ( @is_numeric( $pHash['cache_time'] )   ? $pHash['cache_time']    : NULL );
  936.         $pHash['store']['pos']           = ( @is_numeric( $pHash['pos'] )          ? $pHash['pos']           : 1 );
  937.  
  938.         if( !empty( $pHash['roles'] ) && is_array( $pHash['roles'] )) {
  939.             $pHash['store']['roles'] = implode( ' ', $pHash['roles'] );
  940.         } elseif( !empty( $pHash['groups'] ) && is_array( $pHash['groups'] )) {
  941.             $pHash['store']['groups'] = implode( ' ', $pHash['groups'] );
  942.         } elseif (defined('ROLE_MODEL') ) {
  943.             $pHash['store']['roles'] = NULL;
  944.         } else {
  945.             $pHash['store']['groups'] = NULL;
  946.         }
  947.  
  948.         if( !empty( $pHash['config'] ) ) {
  949.             $pHash['store']['params'] = '';
  950.             foreach( $pHash['config'] as $paramName=>$paramValue ) {
  951.                 $pHash['store']['params'] .= $paramName.'='.urlencode( $paramValue ).'&';
  952.             }
  953.         } else {
  954.             $pHash['store']['params']        = ( !empty( $pHash['params'] )            ? $pHash['params']        : NULL );
  955.         }
  956.  
  957.         return( count( $this->mErrors ) == 0 );
  958.     }
  959.  
  960.     /**
  961.      * storeModule
  962.      *
  963.      * @param array $pHash
  964.      * @access public
  965.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  966.      */
  967.     function storeModule( &$pHash ) {
  968.         if( $this->verifyModuleParams( $pHash )) {
  969.             $table = BIT_DB_PREFIX."themes_layouts";
  970.  
  971.             if( @BitBase::verifyId( $pHash['store']['module_id'] )) {
  972.                 // if we've been passed a module_id, we are updating an entry in the DB
  973.                 $result = $this->mDb->associateUpdate( $table, $pHash['store'], array( 'module_id' => $pHash['store']['module_id'] ));
  974.             } else {
  975.                 // no module_id yet - let's get one
  976.                 $pHash['store']['module_id'] = $this->mDb->GenID( 'themes_layouts_module_id_seq' );
  977.                 $result = $this->mDb->associateInsert( $table, $pHash['store'] );
  978.             }
  979.         }
  980.         return( count( $this->mErrors ) == 0 );
  981.     }
  982.  
  983.     /**
  984.      * getModuleData
  985.      *
  986.      * @param array $pModuleId
  987.      * @access public
  988.      * @return module details of the requested module id
  989.      */
  990.     function getModuleData( $pModuleId ) {
  991.         if( @BitBase::verifyId( $pModuleId )) {
  992.             $ret = $this->mDb->getRow( "SELECT tl.* FROM `".BIT_DB_PREFIX."themes_layouts` tl WHERE `module_id`=? ", array( $pModuleId ));
  993.             $ret['module_params'] = $this->parseString( $ret['params'] );
  994.             return $ret;
  995.         }
  996.     }
  997.  
  998.     /**
  999.      * moduleUp
  1000.      *
  1001.      * @param array $pModuleId
  1002.      * @access public
  1003.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1004.      */
  1005.     function moveModuleUp( $pModuleId ) {
  1006.         if( @BitBase::verifyId( $pModuleId )) {
  1007.             $this->moveModule( $pModuleId, 'up' );
  1008.         }
  1009.         return( count( $this->mErrors ) == 0 );
  1010.     }
  1011.  
  1012.     /**
  1013.      * moduleDown
  1014.      *
  1015.      * @param array $pModuleId
  1016.      * @access public
  1017.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1018.      */
  1019.     function moveModuleDown( $pModuleId ) {
  1020.         if( @BitBase::verifyId( $pModuleId )) {
  1021.             $this->moveModule( $pModuleId, 'down' );
  1022.         }
  1023.         return( count( $this->mErrors ) == 0 );
  1024.     }
  1025.  
  1026.     /**
  1027.      * generic function to move module up or down
  1028.      *
  1029.      * @param array $pModuleId
  1030.      * @param string $pOrientation
  1031.      * @access public
  1032.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1033.      */
  1034.     function moveModule( $pModuleId, $pDirection = 'down' ) {
  1035.         if( @BitBase::verifyId( $pModuleId )) {
  1036.             // first we get next module we want to swap with
  1037.             $moduleData = $this->getModuleData( $pModuleId );
  1038.             if( $pDirection == 'up' ) {
  1039.                 $pos_check = 'AND `pos`<=?';
  1040.                 $pos_set   = 'SET `pos`=`pos`-1';
  1041.                 $order     = 'ORDER BY pos DESC';
  1042.             } else {
  1043.                 $pos_check = 'AND `pos`>=?';
  1044.                 $pos_set   = 'SET `pos`=`pos`+1';
  1045.                 $order     = 'ORDER BY pos ASC';
  1046.             }
  1047.             $query  = "SELECT `module_id` FROM `".BIT_DB_PREFIX."themes_layouts` WHERE `layout`=? AND `layout_area`=? $pos_check AND `module_id` <> ? $order";
  1048.             $swapModuleId = $this->mDb->getOne( $query, array( $moduleData['layout'], $moduleData['layout_area'], $moduleData['pos'], $moduleData['module_id'] ));
  1049.             if( $moduleSwap = $this->getModuleData( $swapModuleId )) {
  1050.                 if( $moduleData['pos'] == $moduleSwap['pos'] ) {
  1051.                     $query = "UPDATE `".BIT_DB_PREFIX."themes_layouts` $pos_set WHERE `module_id`=?";
  1052.                     $result = $this->mDb->query( $query, array( $moduleData['module_id'] ));
  1053.                 } else {
  1054.                     $query = "UPDATE `".BIT_DB_PREFIX."themes_layouts` SET `pos`=? WHERE `module_id`=?";
  1055.                     $result = $this->mDb->query( $query, array( $moduleSwap['pos'], $moduleData['module_id'] ));
  1056.                     $result = $this->mDb->query( $query, array( $moduleData['pos'], $moduleSwap['module_id'] ));
  1057.                 }
  1058.             }
  1059.         }
  1060.         return( count( $this->mErrors ) == 0 );
  1061.     }
  1062.  
  1063.     /**
  1064.      * setModulePosition
  1065.      *
  1066.      * @param array $pModuleId
  1067.      * @param array $pPos
  1068.      * @access public
  1069.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1070.      */
  1071.     function setModulePosition( $pModuleId, $pPos, $pCol=NULL ) {
  1072.         if( @BitBase::verifyId( $pModuleId )) {
  1073.             $bindVars = array();
  1074.             $updateSql = '';
  1075.             if( !empty( $pCol ) ) {
  1076.                 $updateSql .= ' `layout_area`=?, ';
  1077.                 $bindVars[] = $pCol;
  1078.             }
  1079.             $bindVars[] = $pPos;
  1080.             $bindVars[] = $pModuleId;
  1081.             $query = "UPDATE `".BIT_DB_PREFIX."themes_layouts` SET ".$updateSql." `pos`=? WHERE `module_id`=?";
  1082.             $result = $this->mDb->query( $query, $bindVars );
  1083.         }
  1084.         return TRUE;
  1085.     }
  1086.  
  1087.     /**
  1088.      * moveModuleToArea
  1089.      *
  1090.      * @param array $pModuleId
  1091.      * @param array $pArea
  1092.      * @access public
  1093.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1094.      */
  1095.     function moveModuleToArea( $pModuleId, $pArea ) {
  1096.         if( !$this->verifyArea( $pArea )) {
  1097.             $pArea = 'l';
  1098.         }
  1099.  
  1100.         if( @BitBase::verifyId( $pModuleId )) {
  1101.             $query = "UPDATE `".BIT_DB_PREFIX."themes_layouts` SET `layout_area`=? WHERE `module_id`=?";
  1102.             $result = $this->mDb->query( $query, array( $pArea, $pModuleId ));
  1103.         }
  1104.         return TRUE;
  1105.     }
  1106.  
  1107.     /**
  1108.      * unassignModule
  1109.      *
  1110.      * @param array $pModuleId can be a module id or a resource path. if it is a resource path, all modules with that resource will be removed
  1111.      * @access public
  1112.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1113.      */
  1114.     function unassignModule( $pModuleMixed ) {
  1115.         $ret = FALSE;
  1116.         if( @BitBase::verifyId( $pModuleMixed )) {
  1117.             if( $this->mDb->query( "DELETE FROM `".BIT_DB_PREFIX."themes_layouts` WHERE `module_id`=?", array( $pModuleMixed ))) {
  1118.                 $ret = TRUE;
  1119.             }
  1120.         } elseif( !empty( $pModuleMixed )) {
  1121.             if( $this->mDb->query( "DELETE FROM `".BIT_DB_PREFIX."themes_layouts` WHERE `module_rsrc`=?", array( $pModuleMixed ))) {
  1122.                 $ret = TRUE;
  1123.             }
  1124.         }
  1125.         return $ret;
  1126.     }
  1127.  
  1128.     /**
  1129.      * if the specified area doesn't make any sense, we just dump it in the left column
  1130.      *
  1131.      * @param array $pArea l --> left       r --> right       c --> center       b --> bottom       t --> top
  1132.      * @access public
  1133.      * @return valid area
  1134.      */
  1135.     function verifyArea( &$pArea ) {
  1136.         return( !empty( $pArea ) && preg_match( '/^[lrctb]$/', $pArea ));
  1137.     }
  1138.  
  1139.     /**
  1140.      * generates module names on full hash by reference
  1141.      *
  1142.      * @param array $p2DHash layout hash
  1143.      * @access public
  1144.      * @return void
  1145.      */
  1146.     function generateModuleNames( &$p2DHash ) {
  1147.         if( is_array( $p2DHash )) {
  1148.             // Generate human friendly names
  1149.             foreach( array_keys( $p2DHash ) as $col ) {
  1150.                 if( count( $p2DHash[$col] )) {
  1151.                     foreach( array_keys( $p2DHash["$col"] ) as $mod ) {
  1152.                         list( $rsrc, $specifier ) = explode( ':', $p2DHash[$col][$mod]['module_rsrc'], 2 );
  1153.                         $specelems = explode( '/', $specifier );
  1154.                         $package = current( $specelems );
  1155.                         if( $package == 'temp' ) $package = next( $specelems );
  1156.                         // handle special case for custom modules
  1157.                         if( !isset( $package )) {
  1158.                             $package = $rsrc;
  1159.                         }
  1160.                         $file = end( $specelems );
  1161.                         $file = str_replace( 'mod_', '', $file );
  1162.                         $file = str_replace( '.tpl', '', $file );
  1163.                         $p2DHash[$col][$mod]['name'] = $package.' &raquo; '.str_replace( '_', ' ', $file );
  1164.                     }
  1165.                 }
  1166.             }
  1167.         }
  1168.     }
  1169.  
  1170.     /**
  1171.      * getAllModules
  1172.      *
  1173.      * @param string $pDir
  1174.      * @param string $pPrefix
  1175.      * @access public
  1176.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1177.      */
  1178.     function getAllModules( $pDir='modules', $pPrefix='mod_' ) {
  1179.         global $gBitSystem;
  1180.         // @TODO MODULE UPGRADE
  1181.         // hash for carrying references to modules:
  1182.         // $this->mModules[$pDir][$pPrefix]
  1183.         // this is ugly but is to smooth the transition until all modules are upgraded to directory and registration structure
  1184.         // it will be unncessary once all packages are caught up
  1186.         if(( $modules = $this->getCustomModuleList() ) && $pPrefix == 'mod_' ) {
  1187.             foreach( $modules as $m ) {
  1188.                 $this->mModules[$pDir][$pPrefix][tra( 'Custom Modules' )]['_custom:custom/'.$m["name"]] = array( 'title' => $m["name"] );
  1189.             }
  1190.             asort( $this->mModules[$pDir][$pPrefix][tra( 'Custom Modules' )] );
  1191.         }
  1192.  
  1193.         // iterate through all packages and look for all possible modules
  1194.         foreach( array_keys( $gBitSystem->mPackages ) as $key ) {
  1195.             if( $gBitSystem->isPackageActive( $key )) {
  1196.                 $loc = BIT_ROOT_PATH.$gBitSystem->mPackages[$key]['dir'].'/'.$pDir;
  1197.                 if( @is_dir( $loc )) {
  1198.                     $h = opendir( $loc );
  1199.                     if( $h ) {
  1200.                         while (($file = readdir($h)) !== false) {
  1201.                             // match on legacy module files which require a prefix
  1202.                             if ( preg_match( "/^$pPrefix(.*)\.tpl$/", $file, $match )) {
  1203.                                 $this->mModules[$pDir][$pPrefix][ucfirst( $key )]['bitpackage:'.$key.'/'.$file] = array( 'title' => str_replace( '_', ' ', $match[1] ),
  1204.                                                                                                                          'template' => $file,
  1205.                                                                                                                         );
  1206.                             }
  1207.                             // loop over nested directories which contain modern modules
  1208.                             // these modules are only accessible from gBitThemes
  1209.                             elseif ( !in_array( $file, array('.','..','CVS') ) && @is_dir( $loc.'/'.$file ) ){
  1210.                                 $conf_file = $loc.'/'.$file.'/config_inc.php';
  1211.                                 // we expect a configuration file
  1212.                                 if( @is_file( $conf_file ) ){
  1213.                                     require_once( $conf_file );
  1214.                                 }
  1215.                             }
  1216.                         }
  1217.                         closedir ($h);
  1218.                         if( !empty( $this->mModules[$pDir][$pPrefix][ucfirst( $key )] ) ) {
  1219.                             asort( $this->mModules[$pDir][$pPrefix][ucfirst( $key )] );
  1220.                         }
  1221.                     }
  1222.                 }
  1223.                 // we scan temp/<pkg>/modules for module files as well for on the fly generated modules (e.g. nexus)
  1224.                 if( $pDir == 'modules' ) {
  1225.                     $loc = TEMP_PKG_PATH.$gBitSystem->mPackages[$key]['name'].'/'.$pDir;
  1226.                     if( @is_dir( $loc )) {
  1227.                         $h = opendir( $loc );
  1228.                         if( $h ) {
  1229.                             while (($file = readdir($h)) !== false) {
  1230.                                 if ( preg_match( "/^$pPrefix(.*)\.tpl$/", $file, $match )) {
  1231.                                     $this->mModules[$pDir][$pPrefix][ucfirst( $key )]['bitpackage:temp/'.$key.'/'.$file] = array( 'title' => str_replace( '_', ' ', $match[1] ),
  1232.                                                                                                                                   'template' => $file,
  1233.                                                                                                                                 );
  1234.                                 }
  1235.                             }
  1236.                             closedir ($h);
  1237.                             if( !empty( $this->mModules[$pDir][$pPrefix][ucfirst($key)] ) ) {
  1238.                                 asort( $this->mModules[$pDir][$pPrefix][ucfirst($key)] );
  1239.                             }
  1240.                         }
  1241.                     }
  1242.                 }
  1243.             }
  1244.         }
  1245.         return $this->mModules[$pDir][$pPrefix];
  1246.     }
  1247.  
  1248.     function registerModule( $pMixed ){
  1249.         $pkg = $pMixed['package'];
  1250.         $dir = $pMixed['directory'];
  1251.         $tpl = $pMixed['template'];
  1252.         $legacy_dir = $pMixed['legacy_dir'];
  1253.         $legacy_prefix = $pMixed['legacy_prefix'];
  1254.         $this->mModules[$legacy_dir][$legacy_prefix][ucfirst( $pkg )]['bitpackage:'.$pkg.'/'.$dir.'/'.$tpl] = $pMixed;
  1255.     }
  1256.  
  1257.     // utility function for other packages when they upgrade their modules to the new module system
  1258.     // see themes/admin/upgrades/3.0.0.php for an example of usages
  1259.     function upgradeModulesPaths(){
  1260.         $this->getAllModules();
  1261.         $legacy_mods = array();
  1262.         $upgrade_mods = array();
  1263.  
  1264.         foreach( $this->mModules['modules']['mod_'] as $pkg => $modules ){
  1265.             foreach( $modules as $modulepath => $module ){
  1266.                 $parts =  explode( "/", $modulepath );
  1267.                 if( count( $parts ) > 2 ){
  1268.                     $upgrade_mods[array_pop( $parts )] = $modulepath;
  1269.                 }
  1270.             }
  1271.         }
  1272.  
  1273.         $sql1 = "SELECT DISTINCT `module_rsrc` FROM `".BIT_DB_PREFIX."themes_layouts`";
  1274.         $legacy_mods = $this->mDb->getArray( $sql1 );
  1275.  
  1276.         // fix everything
  1277.         // transaction will save us if something goes bad
  1278.         $this->mDb->StartTrans();
  1279.  
  1280.         foreach( $legacy_mods as $old ){
  1281.             $key =  array_pop( explode( "/", $old['module_rsrc'] ) );
  1282.             if( in_array( $key, array_keys($upgrade_mods) ) && $old['module_rsrc'] != $upgrade_mods[$key]){
  1283.                 $storeHash = array( 'module_rsrc' => $upgrade_mods[$key] );
  1284.                 $this->mDb->associateUpdate( BIT_DB_PREFIX."themes_layouts", $storeHash, array( 'module_rsrc' => $old['module_rsrc'] ));
  1285.             }
  1286.         }
  1287.  
  1288.         $this->mDb->CompleteTrans();
  1289.     }
  1290.  
  1291.     /**
  1292.      * get a module-specfic parameters
  1293.      *
  1294.      * @param array $pModuleId
  1295.      * @access public
  1296.      * @return array or parameters
  1297.      */
  1298.     function getModuleParameters( $pModuleId ) {
  1299.         $ret = array();
  1300.         if( @BitBase::verifyId( $pModuleId )) {
  1301.             $module = $this->getModuleData( $pModuleId );
  1302.             $ret = $module['module_params'];
  1303.         } else {
  1304.             deprecated( 'Please use the module parameters found in vd( $moduleParams[\'module_params\'] ); or pass in the module id for a database lookup.' );
  1305.         }
  1306.         return $ret;
  1307.     }
  1308.  
  1309.     /**
  1310.      * parse URL-like parameter string
  1311.      *
  1312.      * @param array $pParseString
  1313.      * @access public
  1314.      * @return array or parameters
  1315.      */
  1316.     function parseString( $pParseString ) {
  1317.         $ret = array();
  1318.         if( !empty( $pParseString )) {
  1319.             // only call crazy regex when params are too complex for parse_str()
  1320.             if( strpos( trim( $pParseString ), ' ' )) {
  1321.                 $ret = parse_xml_attributes( $pParseString );
  1322.             } else {
  1323.                 parse_str( $pParseString, $ret );
  1324.             }
  1325.         }
  1326.         return $ret;
  1327.     }
  1328.  
  1329.  
  1330.     // }}}
  1331.     // {{{ =================== Custom Modules ====================
  1332.     /**
  1333.      * verifyCustomModule
  1334.      *
  1335.      * @param array $pParamHash
  1336.      * @access public
  1337.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1338.      */
  1339.     function verifyCustomModule( &$pParamHash ) {
  1340.         if( !empty( $pParamHash['name'] ) && preg_match( "/[a-zA-Z]/", $pParamHash['name'] )) {
  1341.             $pParamHash['store']['name'] = substr( strtolower( preg_replace( "/[^\w]*/", "", $pParamHash['name'] )), 0, 40 );
  1342.         }
  1343.  
  1344.         if( empty( $pParamHash['store']['name'] )) {
  1345.             $this->mErrors[] = tra( 'You need to provide a name for your custom module. Only alphanumeric characters are allowed and you need to use at least one letter.' );
  1346.         }
  1347.  
  1348.         if( !empty( $pParamHash['title'] )) {
  1349.             $pParamHash['store']['title'] = substr( $pParamHash['title'], 0, 200 );
  1350.         }
  1351.  
  1352.         if( !empty( $pParamHash['data'] )) {
  1353.             $pParamHash['store']['data'] = $pParamHash['data'];
  1354.         }
  1355.  
  1356.         return( count( $this->mErrors ) == 0 );
  1357.     }
  1358.  
  1359.     /**
  1360.      * storeCustomModule
  1361.      *
  1362.      * @param array $pParamHash
  1363.      * @access public
  1364.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1365.      */
  1366.     function storeCustomModule( $pParamHash ) {
  1367.         if( $this->verifyCustomModule( $pParamHash )) {
  1368.             $table = "`".BIT_DB_PREFIX."themes_custom_modules`";
  1369.             $result = $this->mDb->query( "DELETE FROM $table WHERE `name`=?", array( $pParamHash['store']['name'] ));
  1370.             $result = $this->mDb->associateInsert( $table, $pParamHash['store'] );
  1371.         }
  1372.         return( count( $this->mErrors ) == 0 );
  1373.     }
  1374.  
  1375.     /**
  1376.      * getCustomModule
  1377.      *
  1378.      * @param array $pName
  1379.      * @access public
  1380.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1381.      */
  1382.     function getCustomModule( $pName ) {
  1383.         if( !empty( $pName )) {
  1384.             return $this->mDb->getRow( "SELECT * FROM `".BIT_DB_PREFIX."themes_custom_modules` WHERE `name`=?", array( $pName ));
  1385.         }
  1386.     }
  1387.  
  1388.     /**
  1389.      * getCustomModuleList
  1390.      *
  1391.      * @access public
  1392.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1393.      */
  1394.     function getCustomModuleList() {
  1395.         return( $this->mDb->getAll( "SELECT * FROM `".BIT_DB_PREFIX."themes_custom_modules`" ));
  1396.     }
  1397.  
  1398.     /**
  1399.      * expungeCustomModule
  1400.      *
  1401.      * @param array $pName
  1402.      * @access public
  1403.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1404.      */
  1405.     function expungeCustomModule( $pName ) {
  1406.         if( !empty( $pName )) {
  1407.             $this->unassignModule( '_custom:custom/'.$pName );
  1408.             $result = $this->mDb->query( "DELETE FROM `".BIT_DB_PREFIX."themes_custom_modules` WHERE `name`=?", array( $pName ));
  1409.         }
  1410.         return TRUE;
  1411.     }
  1412.  
  1413.     /**
  1414.      * isCustomModule
  1415.      *
  1416.      * @param array $pMixed either name of module or the rsrc of a module
  1417.      * @access public
  1418.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1419.      */
  1420.     function isCustomModule( $pMixed ) {
  1421.         if( strpos( $pMixed, "_custom:custom" ) !== FALSE ) {
  1422.             return TRUE;
  1423.         } elseif( strpos( $pMixed, "bitpackage:" ) !== FALSE ) {
  1424.             return FALSE;
  1425.         } else {
  1426.             $result = $this->mDb->getOne( "SELECT `name` FROM `".BIT_DB_PREFIX."themes_custom_modules` WHERE `name`=?", array( $pMixed ));
  1427.             return( !empty( $result ));
  1428.         }
  1429.     }
  1430.  
  1431.  
  1432.     // }}}
  1433.     // {{{ =================== Javascript and CSS related Methods ====================
  1434.     /**
  1435.      * Statically callable function to see if browser supports javascript
  1436.      * determined by cookie set in bitweaver.js
  1437.      * @access public
  1438.      */
  1439.     function isJavascriptEnabled() {
  1440.     //    return( !empty( $_COOKIE['javascript_enabled'] ) && $_COOKIE['javascript_enabled'] == 'y' );
  1441.         return TRUE; // This function is fuckt as cookie is empty for first query. And cookie privacy browsers are perfjects JS enabled
  1442.     }
  1443.  
  1444.     /**
  1445.      * Statically callable function to determine if the current call was made using Ajax
  1446.      *
  1447.      * @access public
  1448.      */
  1449.     function isAjaxRequest() {
  1450.         return(( !empty( $_SERVER['HTTP_X_REQUESTED_WITH'] ) && $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest' ) || !empty( $_REQUEST['ajax_xml'] ));
  1451.     }
  1452.  
  1453.     // {{{ Javascript and CSS load methods
  1454.     /**
  1455.      * Load Ajax libraries
  1456.      *
  1457.      * @param array $pAjaxLib Name of the library we want to use e.g.: prototype or mochikit
  1458.      * @param array $pLibHash Array of additional libraries we need to load
  1459.      * @param boolean $pPack Set to true if you want to pack the javascript file
  1460.      * @access public
  1461.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1462.      */
  1463.     function loadAjax( $pAjaxLib, $pLibHash=NULL, $pLibPath=NULL, $pPack = FALSE ) {
  1464.         global $gBitSystem, $gBitSmarty, $gSniffer;
  1465.         $ret = FALSE;
  1466.         $joined = TRUE;
  1467.         $ajaxLib = strtolower( $pAjaxLib );
  1468.         if( $this->isJavascriptEnabled() ) {
  1469.             // set the javascript lib path if not set yet
  1470.             if( empty( $pLibPath )) {
  1471.                 switch( $ajaxLib ) {
  1472.                     case 'mochikit':
  1473.                         $pLibPath = UTIL_PKG_PATH."javascript/MochiKit/";
  1474.                         $pos = 100;
  1475.                         break;
  1476.                     case 'yui':
  1477.                         $pLibPath = UTIL_PKG_PATH."javascript/yui/";
  1478.                         $pos = 100;
  1479.                         break;
  1480.                     case 'jquerylocal':
  1481.                         $pLibPath = UTIL_PKG_PATH."javascript/jquery/";
  1482.                         $pos = 100;
  1483.                         break;
  1484.                     default:
  1485.                         $pLibPath = UTIL_PKG_PATH."javascript/";
  1486.                         $pos = 200;
  1487.                         break;
  1488.                 }
  1489.             }
  1490.  
  1491.             if( !$this->isAjaxLib( $ajaxLib )) {
  1492.                 // load core javascript files for ajax libraries
  1493.                 $jqueryMin = $gBitSystem->isLive() ? '.min' : '';
  1494.                 $bootstrapSrc = CONFIG_PKG_PATH.'themes/bootstrap/js/bootstrap'.$jqueryMin.'.js';
  1495.                 switch( $ajaxLib ) {
  1496.                     case 'jquery':
  1497.                         $protocol = (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') ? 'https' : 'http';
  1498.                         $jqueryVersion = $gBitSystem->getConfig( 'jquery_version', '1.10.1' );
  1499.                         $jqueryUiVersion = $gBitSystem->getConfig( 'jquery_ui_version', '1.9.2' );
  1500.                         $jqueryTheme = $gBitSystem->getConfig( 'jquery_theme', 'base' );
  1501.                         $jquerySrc = $protocol.'://ajax.googleapis.com/ajax/libs/jquery/'.$jqueryVersion.'/jquery'.$jqueryMin.'.js';
  1502.                         $this->mRawFiles['js'][] = $jquerySrc;
  1503.                         $this->mRawFiles['js'][] = $protocol.'://ajax.googleapis.com/ajax/libs/jqueryui/'.$jqueryUiVersion.'/jquery-ui'.$jqueryMin.'.js';
  1504.                         $this->mRawFiles['css'][] = $protocol.'://ajax.googleapis.com/ajax/libs/jqueryui/'.$jqueryUiVersion.'/themes/'.$jqueryTheme.'/jquery-ui.css';
  1505.                         // bootstrap needs to load after jquery
  1506.                         if( file_exists( $bootstrapSrc ) ) {
  1507.                             $this->mRawFiles['js'][] = $bootstrapSrc;
  1508.                         }
  1509.  
  1510.                         $gBitSmarty->assign( 'jquerySrc', $jquerySrc );
  1511.                         break;
  1512.                     case 'jquerylocal':
  1513.                         $joined = FALSE;
  1514.                         $this->loadJavascript( THEMES_PKG_PATH.'js/jquery'.$jqueryMin.'.js', FALSE, $pos++, $joined );
  1515.                         $this->loadJavascript( THEMES_PKG_PATH.'js/jquery-ui-1.10.3.custom'.$jqueryMin.'.js', FALSE, $pos++, $joined );
  1516.                         $this->loadJavascript( THEMES_PKG_PATH.'bootstrap/js/bootstrap'.$jqueryMin.'.js', FALSE, $pos++, $joined );
  1517.                         $this->loadCss( THEMES_PKG_PATH.'bootstrap/colourstrap/colourstrap.css', FALSE, $pos++, $joined );
  1518.                         $this->loadCss( THEMES_PKG_PATH.'bootstrap/colourstrap/colourstrap-icons.css', FALSE, $pos++, $joined );
  1519.                         break;
  1520.                     case 'yui':
  1521.                         $this->loadJavascript( $pLibPath.'yuiloader-dom-event/yuiloader-dom-event.js', FALSE, $pos++ );
  1522.                         break;
  1523.                 }
  1524.                 $this->mAjaxLibs[$ajaxLib] = TRUE;
  1525.             }
  1526.  
  1527.             if( is_array( $pLibHash )) {
  1528.                 foreach( $pLibHash as $lib ) {
  1529.                     $fullLib = ($lib[0] == '/' ? '' : $pLibPath).$lib;
  1530.                     $this->loadJavascript( $fullLib, $pPack, $pos++, $joined );
  1531.                 }
  1532.             }
  1533.  
  1534.             $ret = TRUE;
  1535.         }
  1536.         return $ret;
  1537.     }
  1538.  
  1539.     /**
  1540.      * check to see if a given ajax library is loaded
  1541.      *
  1542.      * @param array $pAjaxLib
  1543.      * @access public
  1544.      * @return TRUE on success, FALSE on failure
  1545.      */
  1546.     function isAjaxLib( $pAjaxLib ) {
  1547.         if( !empty( $this->mAjaxLibs ) && !empty( $pAjaxLib )) {
  1548.             return in_array( strtolower( $pAjaxLib ), array_keys( $this->mAjaxLibs ));
  1549.         }
  1550.     }
  1551.  
  1552.     /**
  1553.      * scan packages for <pkg>/templates/html_head_inc.tpl or footer_inc.tpl files
  1554.      *
  1555.      * @param string $pFilename Name of template file we want to scan for and collect
  1556.      * @access private
  1557.      * @return void
  1558.      */
  1559.     function loadTplFiles( $pFilename ) {
  1560.         global $gBitSystem;
  1561.         // these package templates will be included last
  1562.         $prepend = array( 'kernel' );
  1563.         $append = array( 'themes' );
  1564.         $anti = $mid = $post = array();
  1565.         foreach( $gBitSystem->mPackages as $package => $info ) {
  1566.             if( !empty( $info['path'] )) {
  1567.                 $file = "{$info['path']}templates/{$pFilename}.tpl";
  1568.                 $out = "bitpackage:{$package}/{$pFilename}.tpl";
  1569.                 if( is_readable( $file )) {
  1570.                     if( in_array( $package, $prepend )) {
  1571.                         $anti[] = $out;
  1572.                     } elseif( in_array( $package, $append )) {
  1573.                         $post[] = $out;
  1574.                     } else {
  1575.                         $mid[] = $out;
  1576.                     }
  1577.                 }
  1578.             }
  1579.         }
  1580.         $this->mAuxFiles['templates'][$pFilename] = array_merge( $anti, $mid, $post );
  1581.     }
  1582.  
  1583.     /**
  1584.      * loadAuxFile will add a file to the mAuxFiles hash for later processing
  1585.      *
  1586.      * @param array $pFile Full path to the file in question
  1587.      * @param string $pType specifies what files to join. typical values include 'js', 'css'
  1588.      * @param numeric $pPosition Specify the position of the javascript file in the load process.
  1589.      *                           If the selected position is occupied, it will search for the next free position in the hash.
  1590.      * @access public
  1591.      * @return TRUE on success, FALSE on failure
  1592.      */
  1593.     function loadAuxFile( $pFile = NULL, $pType = NULL, $pPosition = 1, $pAuxFile = TRUE ) {
  1594.         if( !empty( $pFile ) && !empty( $pType )) {
  1595. //            if( $pFile = realpath( $pFile )) {
  1596.                 if( $pAuxFile ) {
  1597.                     $fileHash =& $this->mAuxFiles;
  1598.                 } else {
  1599.                     $fileHash =& $this->mRawFiles;
  1600.                 }
  1601.  
  1602.                 if( !$this->isAuxFile( $pFile, $pType, $pAuxFile )) {
  1603.                     // if the selected position is occupied, we'll try to load it in the next position
  1604.                     if( !empty( $fileHash[$pType][$pPosition] )) {
  1605.                         $this->loadAuxFile( $pFile, $pType, ++$pPosition, $pAuxFile );
  1606.                     } else {
  1607.                         $fileHash[$pType][$pPosition] = $pFile;
  1608.                         // ensure that hash is sorted correctly
  1609.                         ksort( $fileHash[$pType] );
  1610.  
  1611.                         return TRUE;
  1612.                     }
  1613.                 }
  1614. //            }
  1615.         }
  1616.         return FALSE;
  1617.     }
  1618.  
  1619.     /**
  1620.      * Load an addition javascript file
  1621.      *
  1622.      * @param string $pJavascriptFile Full path to javascript file
  1623.      * @param boolean $pPack Set to true if you want to pack the javascript file
  1624.      * @param numeric $pPosition Specify the position of the javascript file in the load process
  1625.      * @note
  1626.      *  - generic javascript libraries are loaded between 1 and 99
  1627.      *  - ajax javascript libraries use position numbers between 100 and 599
  1628.      *  - by default all loaded javascript files are after 600.
  1629.      * @access public
  1630.      * @return TRUE on success, FALSE on failure
  1631.      */
  1632.     function loadJavascript( $pJavascriptFile, $pPack = FALSE, $pPosition = 600, $pJoined = TRUE ) {
  1633.         global $gBitSystem;
  1634.         $ret = FALSE;
  1635.         if( !empty( $pJavascriptFile )) {
  1636.             if( $pPack && $gBitSystem->isFeatureActive( 'themes_packed_js_css' ) && function_exists( 'shell_exec' ) && shell_exec( 'which java' ) ) {
  1637.                 if( is_file( $pJavascriptFile )) {
  1638.                     // get a name for the cache file we're going to store
  1639.                     $cachefile = md5( $pJavascriptFile ).'.js';
  1640.  
  1641.                     // if the file hasn't been packed and cached yet, we do that now.
  1642.                     if( !$this->mThemeCache->isCached( $cachefile, filemtime( $pJavascriptFile ))) {
  1643.                         /* DEPRECATED in favor of better yui compressor
  1644.                         require_once( UTIL_PKG_PATH.'javascript/class.JavaScriptPacker.php' );
  1645.                         $packer = new JavaScriptPacker( file_get_contents( $pJavascriptFile ) );
  1646.                         $this->mThemeCache->writeCacheFile( $cachefile, $packer->pack() );
  1647.                         */
  1648.                         $cacheData = shell_exec( 'java -jar '.UTIL_PKG_PATH.'yui/yuicompressor-2.4.2.jar --type js '.$pJavascriptFile );
  1649.                         $this->mThemeCache->writeCacheFile( $cachefile, $cacheData );
  1650.                     }
  1651.  
  1652.                     // update javascript file with new path
  1653.                     $pJavascriptFile = $this->mThemeCache->getCacheFile( $cachefile );
  1654.                 }
  1655.             }
  1656.  
  1657.             $ret = $this->loadAuxFile( $pJavascriptFile, 'js', $pPosition, ( $pJoined && $gBitSystem->isFeatureActive( 'themes_joined_js_css' )));
  1658.         }
  1659.         return $ret;
  1660.     }
  1661.  
  1662.     /**
  1663.      * Load an additional CSS file
  1664.      *
  1665.      * @param array $pCssFile Full path to CSS file
  1666.      * @param numeric $pPosition Specify the position of the javascript file in the load process
  1667.      * @param boolean $pJoined Adds the file to the list of files to be concatenated into a single file
  1668.      * @param boolean $pForce Forces the css file to always be loaded, should only be used by active style
  1669.      * @access public
  1670.      * @return TRUE on success, FALSE on failure
  1671.      */
  1672.     function loadCss( $pCssFile, $pPack = TRUE, $pPosition = 300, $pJoined = TRUE, $pForce = FALSE ) {
  1673.         global $gBitSystem;
  1674.         $ret = FALSE;
  1675.         if( !empty( $pCssFile ) && ( !$gBitSystem->isFeatureActive( 'themes_disable_pkg_css' ) || $pForce )) {
  1676.             // only manipulate css file if we're joining or packing the files
  1677.             if(( $pJoined && $gBitSystem->isFeatureActive( 'themes_joined_js_css' )) || ( $pPack && $gBitSystem->isFeatureActive( 'themes_packed_js_css' ))) {
  1678.                 $pCssFile = $this->packCss( $pCssFile, ( $pPack && $gBitSystem->isFeatureActive( 'themes_packed_js_css' )));
  1679.             }
  1680.  
  1681.             $ret = $this->loadAuxFile( $pCssFile, 'css', $pPosition, ( $pJoined && $gBitSystem->isFeatureActive( 'themes_joined_js_css' )));
  1682.         }
  1683.         return $ret;
  1684.     }
  1685.  
  1686.     /**
  1687.      * simply pack css file by removing excess whitespace and comments
  1688.      *
  1689.      * @param array $pCssFile full path to css file
  1690.      * @access private
  1691.      * @return TRUE on success, FALSE on failure
  1692.      */
  1693.     function packCss( $pCssFile, $pPack = TRUE ) {
  1694.         $ret = FALSE;
  1695.         if( !empty( $pCssFile ) && is_readable( $pCssFile )) {
  1696.             $cachefile = md5( $pCssFile ).'.css';
  1697.  
  1698.             if( !$this->mThemeCache->isCached( $cachefile, filemtime( $pCssFile ))) {
  1699.                 $content = file_get_contents( $pCssFile )."\n";
  1700.  
  1701.                 // now that @import has been dealt with, there still might be some url()s in the file.
  1702.                 // if we have any url() in the CSS file, we need to fix the path to the file with an absolute URL
  1703.                 if( preg_match_all( "#\burl\s*\((.*?)\)#i", $content, $urls )) {
  1704.                     foreach( $urls[1] as $key => $url ) {
  1705.                         if( $url = $this->relativeToAbsolute( $url, $pCssFile )) {
  1706.                             $content = str_replace( $urls[1][$key], $url, $content );
  1707.                         }
  1708.                     }
  1709.                 }
  1710.  
  1711.                 // if we have an @import(), we fetch that file and insert it
  1712.                 if( preg_match_all( "#@import([^;]*);#", $content, $imports )) {
  1713.                     foreach( $imports[1] as $key => $import ) {
  1714.                         if( $file = $this->relativeToAbsolute( $import, $pCssFile, FALSE )) {
  1715.                             // since we're packing later on, we don't pack here, otherwise the same sections will be packed multiple times
  1716.                             $content = str_replace( $imports[0][$key], file_get_contents( $this->packCss( $file, FALSE )), $content );
  1717.                         }
  1718.                     }
  1719.                 }
  1720.  
  1721.                 // now pack the css file if wanted
  1722.                 if( $pPack ) {
  1723.                     $packer = array(
  1724. //                        "#/\*.*\*/#"           => "",       // one line comments -- disabled for now since it causes problems when someone has a multiline comment and closes it with /* */
  1725.                         "#\n\s*#s"             => "\n",     // leading whitespace
  1726.                         "#[\t ]+#"             => " ",      // reduce whitespace
  1727.                         "#,\s*#s"              => ",",      // whitespace after ,
  1728.                         "#[ \t]*([:;])[ \t]*#" => "$1",     // whitespace around : ;
  1729.                         "#;\n+#"               => ";",      // newlines after ;
  1730.                         "#\s*([\{\}])\s*#"     => "$1",     // whitespace around { }
  1731.                         "#\}#"                 => "}\n",    // insert newlines after } for readability
  1732.                         "#{([^\}]*){#"         => "{\n$1{", // insert newlines after { when there's a second { on that line ( e.g.: @media{body{...} )
  1733.                         "#.*{\s*\}#"           => '',       // remove empty definitions ( thanks to the ',' regex above, things like h1,h2,h3 {} should all be on one line )
  1734.                         "#\n+#"                => "\n",     // excess newlines
  1735.                     );
  1736.                     $content = preg_replace( array_keys( $packer ), array_values( $packer ), $content );
  1737.                 }
  1738.  
  1739.                 // css files have been compressed and url()s have been fixed
  1740.                 $this->mThemeCache->writeCacheFile( $cachefile, $content );
  1741.             }
  1742.             $ret = $this->mThemeCache->getCacheFile( $cachefile );
  1743.         }
  1744.         return $ret;
  1745.     }
  1746.  
  1747.     /**
  1748.      * relativeToAbsolute convert a relative or absolute URL to an absolute URL or path
  1749.      *
  1750.      * @param string $pUrl url() in the css file
  1751.      * @param string $pCssFile full path to the css file calling the url()
  1752.      * @param boolean $pReturnUrl return URL or path to file
  1753.      * @access private
  1754.      * @return URL/path on success, FALSE on failure
  1755.      */
  1756.     function relativeToAbsolute( $pUrl, $pCssFile, $pReturnUrl = TRUE ) {
  1757.         $ret = FALSE;
  1758.         if( !empty( $pUrl ) && !empty( $pCssFile )) {
  1759.             // clean up url
  1760.             if( preg_match( "#url\s*\(#", $pUrl )) {
  1761.                 $pUrl = trim( preg_replace( "#url\s*\(([^\)]*)\)#", "$1", $pUrl ));
  1762.             }
  1763.  
  1764.             $pUrl = trim( preg_replace( "#[\"']#", "", $pUrl ));
  1765.  
  1766.             if( strpos( $pUrl, "http" ) === 0 ) {
  1767.                 // don't do anything
  1768.             } elseif( strpos( $pUrl, "/" ) === 0 ) {
  1769.                 // if this is an absolute url, we check if the file exists
  1770.                 $ret = substr_replace( $pUrl, BIT_ROOT_PATH, 0, strlen( BIT_ROOT_URL ));
  1771.             } else {
  1772.                 // this url is relative to the original file
  1773.                 $ret = realpath( dirname( $pCssFile )."/".$pUrl );
  1774.             }
  1775.  
  1776.             if( $pReturnUrl ) {
  1777.                 if (is_windows() ) {
  1778.                     $ret = str_replace( '\\', '/',  $ret );
  1779.                     // Put first forward slash back
  1780.                     $ret = substr_replace($ret, '\\', 2, 1 );
  1781.                     $winBitRootPath = str_replace( '\\', '/',  BIT_ROOT_PATH );
  1782.                     // Put first forward slash back
  1783.                     $winBitRootPath = substr_replace($winBitRootPath, '\\', 2, 1 );
  1784.                     $ret = str_replace( $winBitRootPath, BIT_ROOT_URL, $ret );
  1785.                 } else {
  1786.                     $ret = str_replace( BIT_ROOT_PATH, BIT_ROOT_URL, $ret );
  1787.                 }
  1788.             } else if (is_windows() ) {
  1789.                 $ret = str_replace(  '/', '\\', $ret );
  1790.             }
  1791.         }
  1792.         return $ret;
  1793.     }
  1794.  
  1795.     /**
  1796.      * joinAuxFiles will join all files in mAuxFiles[hash] into one cached file. This helps keep our HTTP requests down to a minimum.
  1797.      *
  1798.      * @param string $pType specifies what files to join. typical values include 'js', 'css'
  1799.      * @access private
  1800.      * @return url to cached file
  1801.      */
  1802.     function joinAuxFiles( $pType ) {
  1803.         global $gBitSystem;
  1804.         $ret = FALSE;
  1805.  
  1806.         // remove conflicting aux files
  1807.         $this->cleanAuxFiles( $pType );
  1808.  
  1809.         if(( $pType == 'js' || $pType == 'css' ) && !$gBitSystem->isFeatureActive( 'themes_joined_js_css' )) {
  1810.             return $ret;
  1811.         }
  1812.  
  1813.         if( !empty( $pType ) && !empty( $this->mAuxFiles[$pType] ) && is_array( $this->mAuxFiles[$pType] )) {
  1814.             $cachestring = '';
  1815.             $lastmodified = 0;
  1816.             // get a unique cachefile name for this set of javascript files
  1817.             foreach( $this->mAuxFiles[$pType] as $file ) {
  1818.                 if( is_file( $file )) {
  1819.                     $cachestring .= '|'.$file;
  1820.                     $lastmodified = max( $lastmodified, filemtime( $file ));
  1821.                 }
  1822.             }
  1823.             $cachefile = md5( $cachestring ).'.'.$pType;
  1824.  
  1825.             if( !$this->mThemeCache->isCached( $cachefile, $lastmodified )) {
  1826.                 $contents = '';
  1827.                 foreach( $this->mAuxFiles[$pType] as $file ) {
  1828.                     // if we have an extension to check against, we'll do that
  1829.                     $chars = 0 - ( strlen( $pType ) + 1 );
  1830.                     if( !empty( $pType ) && substr( $file, $chars ) == '.'.$pType && is_readable( $file )) {
  1831.                         $contents .= file_get_contents( $file )."\n";
  1832.                     }
  1833.                 }
  1834.                 $this->mThemeCache->writeCacheFile( $cachefile, $contents );
  1835.             }
  1836.  
  1837.             $ret = $this->mThemeCache->getCacheUrl( $cachefile );
  1838.         }
  1839.         return $ret;
  1840.     }
  1841.  
  1842.     /**
  1843.      * cleanAuxFiles will remove unwanted aux files if conflicting files have been loaded
  1844.      *
  1845.      * @param string $pType specifies what files to clean up. typical values include 'js', 'css'
  1846.      * @access private
  1847.      * @return TRUE on success, FALSE on failure - mErrors will contain reason for failure
  1848.      * @note  It is regrettable that we have this method here but our previous
  1849.      *        use of prototype requires this cleanup and might be needed in the
  1850.      *        future as well
  1851.      */
  1852.     function cleanAuxFiles( $pType ) {
  1853.         // unload files that are not wanted by users
  1854.         if( !empty( $this->mUnloadFiles[$pType] )) {
  1855.             foreach( $this->mUnloadFiles[$pType] as $file ) {
  1856.                 if( !empty( $this->mAuxFiles[$pType] )) {
  1857.                     if( $key = array_search( $file, $this->mAuxFiles[$pType] )) {
  1858.                         unset( $this->mAuxFiles[$pType][$key] );
  1859.                     }
  1860.                 }
  1861.  
  1862.                 if( !empty( $this->mRawFiles[$pType] )) {
  1863.                     if( $key = array_search( $file, $this->mRawFiles[$pType] )) {
  1864.                         unset( $this->mRawFiles[$pType][$key] );
  1865.                     }
  1866.                 }
  1867.             }
  1868.         }
  1869.  
  1870.         // remove conflicting files
  1871.         if( !empty( $pType ) && !empty( $this->mAuxFiles[$pType] )) {
  1872.             if( $pType = 'js' ) {
  1873.                 // prototype is loaded for a reason. we'll remove mochikit
  1874.                 if( $this->isAjaxLib( 'prototype' ) && $this->isAjaxLib( 'mochikit' )) {
  1875.                     foreach( $this->mAuxFiles[$pType] as $key => $js ) {
  1876.                         if( strstr( $js, 'Mochi' )) {
  1877.                             unset( $this->mAuxFiles[$pType][$key] );
  1878.                         }
  1879.                     }
  1880.                 }
  1881.             }
  1882.         }
  1883.  
  1884.         // convert full file path to URL in mRawFiles hash
  1885.         if( !empty( $this->mRawFiles[$pType] )) {
  1886.             foreach( $this->mRawFiles[$pType] as $pos => $file ) {
  1887.                 if (is_windows() ) {
  1888.                     $file = str_replace( '\\', '/',  $file );
  1889.                     // Put first forward slash back
  1890.                     $file = substr_replace( $file, '\\', 2, 1 );
  1891.                     $winBitRootPath = str_replace( '\\', '/',  BIT_ROOT_PATH );
  1892.                     // Put first forward slash back
  1893.                     $winBitRootPath = substr_replace($winBitRootPath, '\\', 2, 1 );
  1894.                     if ( strpos( $file, $winBitRootPath ) !== FALSE ) {
  1895.                         $this->mRawFiles[$pType][$pos] = BIT_ROOT_URL.substr( $file, strlen( $winBitRootPath ));
  1896.                     }
  1897.                 } else if ( strpos( $file, BIT_ROOT_PATH ) !== FALSE ) {
  1898.                     $this->mRawFiles[$pType][$pos] = BIT_ROOT_URL.substr( $file, strlen( BIT_ROOT_PATH ));
  1899.                 }
  1900.             }
  1901.         }
  1902.     }
  1903.  
  1904.     // }}}
  1905.     // {{{ Javascript and CSS unload methods
  1906.     /**
  1907.      * unloadAuxFile
  1908.      *
  1909.      * @param string $pType specifies what files to clean up. typical values include 'js', 'css'
  1910.      * @param array $pFile Full path to the file in question
  1911.      * @access private
  1912.      * @return void
  1913.      */
  1914.     function unloadAuxFile( $pType, $pFile ) {
  1915.         if( !empty( $pType ) && !empty( $pFile ) && is_file( $pFile )) {
  1916.             $this->mUnloadFiles[$pType][] = $pFile;
  1917.         }
  1918.     }
  1919.  
  1920.     /**
  1921.      * unloadCss
  1922.      *
  1923.      * @param array $pFile Full path to the file in question
  1924.      * @access public
  1925.      * @return void
  1926.      */
  1927.     function unloadCss( $pFile ) {
  1928.         return $this->unloadAuxFile( 'css', $pFile );
  1929.     }
  1930.  
  1931.     /**
  1932.      * unloadJvascript
  1933.      *
  1934.      * @param array $pFile Full path to the file in question
  1935.      * @access public
  1936.      * @return void
  1937.      */
  1938.     function unloadJavascript( $pFile ) {
  1939.         return $this->unloadAuxFile( 'js', $pFile );
  1940.     }
  1941.  
  1942.     // }}}
  1943.     // {{{ Javascript and CSS override methods
  1944.     /**
  1945.      * overrideAuxFile Override an aux file
  1946.      *
  1947.      * @param string $pType specifies what files to clean up. typical values include 'js', 'css'
  1948.      * @param array $pOriginalFile Path to old file
  1949.      * @param array $pNewFile Path to new file
  1950.      * @access private
  1951.      * @return boolean TRUE on success, FALSE on failure
  1952.      * @note This can only be used after the original file has been loaded since we're swapping the original one with a new one
  1953.      */
  1954.     function overrideAuxFile( $pType, $pOriginalFile, $pNewFile ) {
  1955.         $ret = FALSE;
  1956.         if( is_file( $pNewFile )) {
  1957.             if( $key = array_search( $pOriginalFile, $this->mAuxFiles[$pType] )) {
  1958.                 $this->mAuxFiles[$pType][$key] = $pNewFile;
  1959.                 $ret = TRUE;
  1960.             }
  1961.  
  1962.             if( $key = array_search( $pOriginalFile, $this->mRawFiles[$pType] )) {
  1963.                 $this->mRawFiles[$pType][$key] = $pNewFile;
  1964.                 $ret = TRUE;
  1965.             }
  1966.         }
  1967.         return $ret;
  1968.     }
  1969.  
  1970.     /**
  1971.      * overrideCss
  1972.      *
  1973.      * @param array $pOriginalFile Path to old file
  1974.      * @param array $pNewFile Path to new file
  1975.      * @access public
  1976.      * @return boolean TRUE on success, FALSE on failure
  1977.      * @note See overrideAuxFile note
  1978.      */
  1979.     function overrideCss( $pOriginalFile, $pNewFile ) {
  1980.         return $this->overrideAuxFile( 'css', $pOriginalFile, $pNewFile );
  1981.     }
  1982.  
  1983.     /**
  1984.      * overrideJavascript
  1985.      *
  1986.      * @param array $pOriginalFile Path to old file
  1987.      * @param array $pNewFile Path to new file
  1988.      * @access public
  1989.      * @return boolean TRUE on success, FALSE on failure
  1990.      * @note See overrideAuxFile note
  1991.      */
  1992.     function overrideJavascript( $pOriginalFile, $pNewFile ) {
  1993.         return $this->overrideAuxFile( 'js', $pOriginalFile, $pNewFile );
  1994.     }
  1995.     // }}}
  1997.     /**
  1998.      * isAuxFile
  1999.      *
  2000.      * @param array $pFile Full path to file
  2001.      * @param string $pType specifies what files to check. typical values include 'js', 'css'
  2002.      * @access public
  2003.      * @return TRUE on success, FALSE on failure
  2004.      */
  2005.     function isAuxFile( $pFile = NULL, $pType = NULL, $pAuxFile = TRUE ) {
  2006.         if( $pAuxFile ) {
  2007.             $fileHash =& $this->mAuxFiles;
  2008.         } else {
  2009.             $fileHash =& $this->mRawFiles;
  2010.         }
  2011.  
  2012.         if( !empty( $pFile ) && !empty( $pType ) && !empty( $fileHash[$pType] )) {
  2013.             return( in_array( $pFile, $fileHash[$pType] ));
  2014.         }
  2015.     }
  2016.  
  2017.  
  2018.     // }}}
  2019.     // {{{ =================== Miscellaneous Stuff ====================
  2020.     /**
  2021.      * setDisplayMode
  2022.      *
  2023.      * @param string $pDisplayMode
  2024.      * @access public
  2025.      * @return void
  2026.      */
  2027.     function setDisplayMode( $pDisplayMode ) {
  2028.         if( !empty( $pDisplayMode )) {
  2029.             $this->mDisplayMode = $pDisplayMode;
  2030.         }
  2031.     }
  2032.  
  2033.     /**
  2034.      * Set the proper headers for requested output
  2035.      *
  2036.      * @param  $pFormat the output headers. Available options include: html, json, xml or none
  2037.      * @access public
  2038.      */
  2039.     function setFormatHeader( $pFormat = 'html' ) {
  2040.         // this will tell BitSystem::display what headers have been set in case it's been called independently
  2041.         $this->mFormatHeader = $pFormat;
  2042.  
  2043.         switch( $pFormat ) {
  2044.             case "xml" :
  2045.                 //since we are returning xml we must report so in the header
  2046.                 //we also need to tell the browser not to cache the page
  2047.                 //see: http://mapki.com/index.php?title=Dynamic_XML
  2048.                 // Date in the past
  2049.                 header( "Expires: Mon, 26 Jul 1997 05:00:00 GMT" );
  2050.                 // always modified
  2051.                 header( "Last-Modified: " . gmdate( "D, d M Y H:i:s" )." GMT" );
  2052.                 // HTTP/1.1
  2053.                 header( "Cache-Control: no-store, no-cache, must-revalidate" );
  2054.                 header( "Cache-Control: post-check=0, pre-check=0", FALSE );
  2055.                 // HTTP/1.0
  2056.                 header( "Pragma: no-cache" );
  2057.                 //XML Header
  2058.                 header( "Content-Type: text/xml" );
  2059.                 break;
  2060.  
  2061.             case "json" :
  2062.                 header( 'Content-type: application/json' );
  2063.                 break;
  2064.  
  2065.             case "none" :
  2066.             case "center_only" :
  2067.                 break;
  2068.  
  2069.             case "html" :
  2070.             default :
  2071.                 header( 'Content-Type: text/html; charset=utf-8' );
  2072.                 break;
  2073.         }
  2074.     }
  2075.  
  2076.     /**
  2077.      * getGraphvizGraphAttributes
  2078.      *
  2079.      * @param array $pParams Override any of the settings coming out of this function
  2080.      * @access public
  2081.      * @return array Hash of default values
  2082.      */
  2083.     function getGraphvizGraphAttributes( $pParams = array() ) {
  2084.         global $gBitSystem;
  2085.         $ret = array(
  2086.             'bgcolor'  => $gBitSystem->getConfig( 'graphviz_graph_bgcolor', 'transparent' ),
  2087.             'color'    => $gBitSystem->getConfig( 'graphviz_graph_color', '#000000' ),
  2088.             'fontname' => $gBitSystem->getConfig( 'graphviz_graph_fontname', 'Helvetica' ),
  2089.             'fontsize' => $gBitSystem->getConfig( 'graphviz_graph_fontsize', 10 ),
  2090.             'nodesep'  => $gBitSystem->getConfig( 'graphviz_graph_nodesep', '.1' ),
  2091.             'overlap'  => $gBitSystem->getConfig( 'graphviz_graph_overlap', 'scale' ),
  2092.             'rankdir'  => $gBitSystem->getConfig( 'graphviz_graph_rankdir', 'LR' ),
  2093.             'size'     => '',
  2094.         );
  2095.  
  2096.         foreach( $pParams as $key => $value ) {
  2097.             // any parameter can be prefixed that they can be passed in all at once
  2098.             if( empty( $value ) || preg_match( "@^(edge_|node_)@", $key )) {
  2099.                 unset( $pParams[$key] );
  2100.             } elseif( isset( $ret[preg_replace( '@^graph_@', '', $key )] )) {
  2101.                 $ret[preg_replace( '@^graph_@', '', $key )] = $value;
  2102.             }
  2103.         }
  2104.         return $ret;
  2105.     }
  2106.  
  2107.     /**
  2108.      * getGraphvizNodeAttributes
  2109.      *
  2110.      * @param array $pParams Override any of the settings coming out of this function
  2111.      * @access public
  2112.      * @return array Hash of default values
  2113.      */
  2114.     function getGraphvizNodeAttributes( $pParams = array() ) {
  2115.         global $gBitSystem;
  2116.         $ret = array(
  2117.             'color'     => $gBitSystem->getConfig( 'graphviz_node_color', '#aaaaaa' ),
  2118.             'fillcolor' => $gBitSystem->getConfig( 'graphviz_node_fillcolor', 'white' ),
  2119.             'fontname'  => $gBitSystem->getConfig( 'graphviz_node_fontname', 'Helvetica' ),
  2120.             'fontsize'  => $gBitSystem->getConfig( 'graphviz_node_fontsize', 10 ),
  2121.             'fontcolor' => $gBitSystem->getConfig( 'graphviz_node_fontcolor', 'black' ),
  2122.             'height'    => $gBitSystem->getConfig( 'graphviz_node_height', '.1' ),
  2123.             'overlap'   => $gBitSystem->getConfig( 'graphviz_node_overlap', 'scale' ),
  2124.             'penwidth'  => $gBitSystem->getConfig( 'graphviz_node_penwidth', '1' ),
  2125.             'shape'     => $gBitSystem->getConfig( 'graphviz_node_shape', 'box' ),
  2126.             'style'     => $gBitSystem->getConfig( 'graphviz_node_style', 'rounded,filled' ),
  2127.             'width'     => $gBitSystem->getConfig( 'graphviz_node_width', '.1' ),
  2128.         );
  2129.  
  2130.         foreach( $pParams as $key => $value ) {
  2131.             // any parameter can be prefixed that they can be passed in all at once
  2132.             if( empty( $value ) || preg_match( "@^(edge_|graph_)@", $key )) {
  2133.                 unset( $pParams[$key] );
  2134.             } elseif( isset( $ret[preg_replace( '@^node_@', '', $key )] )) {
  2135.                 $ret[preg_replace( '@^node_@', '', $key )] = $value;
  2136.             }
  2137.         }
  2138.         return $ret;
  2139.     }
  2140.  
  2141.     /**
  2142.      * getGraphvizEdgeAttributes
  2143.      *
  2144.      * @param array $pParams Override any of the settings coming out of this function
  2145.      * @access public
  2146.      * @return array Hash of default values
  2147.      */
  2148.     function getGraphvizEdgeAttributes( $pParams = array() ) {
  2149.         global $gBitSystem;
  2150.         $ret = array(
  2151.             'color'     => $gBitSystem->getConfig( 'graphviz_edge_color', '#888888' ),
  2152.             'fontcolor' => $gBitSystem->getConfig( 'graphviz_edge_fontcolor', 'black' ),
  2153.             'fontname'  => $gBitSystem->getConfig( 'graphviz_edge_fontname', 'Helvetica' ),
  2154.             'fontsize'  => $gBitSystem->getConfig( 'graphviz_edge_fontsize', 10 ),
  2155.             'style'     => $gBitSystem->getConfig( 'graphviz_edge_style', 'solid' ),
  2156.             'dir'       => '',
  2157.             'label'     => '',
  2158.         );
  2159.  
  2160.         foreach( $pParams as $key => $value ) {
  2161.             // any parameter can be prefixed that they can be passed in all at once
  2162.             if( empty( $value ) || preg_match( "@^(node_|graph_)@", $key )) {
  2163.                 unset( $pParams[$key] );
  2164.             } elseif( isset( $ret[preg_replace( '@^edge_@', '', $key )] )) {
  2165.                 $ret[preg_replace( '@^edge_@', '', $key )] = $value;
  2166.             }
  2167.         }
  2168.         return $ret;
  2169.     }
  2170.  
  2171.  
  2172.     // }}}
  2173.     // {{{ =================== Deprecated code ====================
  2174.     // deprecated stuff and temporary place holders
  2175.     //                                                                         --------------- all of these functions will be removed quite soon
  2176.     /**
  2177.      * @deprecated deprecated since version 2.0.0
  2178.      */
  2179.     function storeLayout() {
  2180.         deprecated( 'Please remove this function and use storeModule instead' );
  2181.     }
  2182.     /**
  2183.      * @deprecated deprecated since version 2.0.0
  2184.      */
  2185.     function storeModuleParameters($mod_rsrc, $user_id, $params) {
  2186.         deprecated( 'This method does not work as expected due to changes in the layout schema. we have not found a suitable replacement yet.' );
  2187.     }
  2188.     /**
  2189.      * @deprecated deprecated since version 2.0.0
  2190.      */
  2191.     function getModuleId($mod_rsrc) {
  2192.         deprecated( 'This method does not work as expected due to changes in the layout schema. we have not found a suitable replacement yet.' );
  2193.     }
  2194.     /**
  2195.      * @deprecated deprecated since version 2.0.0
  2196.      */
  2197.     function getStyleCss( $pStyle = NULL ) {
  2198.         deprecated( 'Please use: BitThemes::getStyleCssFile()' );
  2199.         return $this->getStyleCssFile( $pStyle, TRUE );
  2200.     }
  2201.     // }}}
  2202. }
  2203.  
  2204. function themes_feedback_to_html( $params ) {
  2205.  
  2206.     detoxify( $params );
  2207.     if( !empty( $params['hash'] ) ) {
  2208.         $hash = &$params['hash'];
  2209.     } else {
  2210.         // maybe params were passed in separately
  2211.         $hash = &$params;
  2212.     }
  2213.     $feedback = '';
  2214.     $i = 0;
  2215.     $color = isset( $hash['color'] )?$hash['color']:"000000";
  2216.     foreach( $hash as $key => $val ) {
  2217.         if( $val ) {
  2218.             $keys = array( 'warning', 'success', 'error', 'important', 'note' );
  2219.             if( in_array( $key, $keys )) {
  2220.                 switch( $key ) {
  2221.                     case 'success':
  2222.                         $alertClass = 'alert alert-success';
  2223.                         break;
  2224.                     case 'warning':
  2225.                         $alertClass = 'alert alert-warning';
  2226.                         break;
  2227.                     case 'error':
  2228.                         $alertClass = 'alert alert-danger';
  2229.                         break;
  2230.                     case 'note':
  2231.                     case 'important':
  2232.                     default:
  2233.                         $alertClass = 'alert alert-info';
  2234.                         break;
  2235.                 }
  2236.  
  2237.                 if( !is_array( $val ) ) {
  2238.                     $val = array( $val );
  2239.                 }
  2240.  
  2241.                 foreach( $val as $valText ) {
  2242.                     if( is_array( $valText ) ) {
  2243.                         foreach( $valText as $text ) {
  2244.                             $feedback .= '<span class="inline-block '.$alertClass.'">'.$text.'</span>';
  2245.                         }
  2246.                     } else {
  2247.                         $feedback .= '<span class="inline-block '.$alertClass.'">'.$valText.'</span>';
  2248.                     }
  2249.                 }
  2250.  
  2251.             } else {
  2252.                 /* unfortunately this plugin was written a little strictly and so it expects all params to be display text
  2253.                  * to allow setting of a background color we have to exclude that param when rendering out the html
  2254.                  * otherwise we'll render the color as text. -wjames5
  2255.                  */ 
  2256.                 if ( $key != 'color' ) {
  2257.                     if( is_array( $val ) ) {
  2258.                         foreach( $val as $text ) {
  2259.                             $feedback .= '<span class="'.$key.'">'.$text.'</span>';
  2260.                         }
  2261.                     } else {
  2262.                         $feedback .= '<span class="'.$key.'">'.$val.'</span>';
  2263.                     }
  2264.                 }
  2265.             }
  2266.         }
  2267.     }
  2268.  
  2269.     $html = '';
  2270.     if( !empty( $feedback ) ) {
  2271.         $html .= $feedback;
  2272.     }
  2273.     return $html;
  2274. }
  2275.  
  2276. /**
  2277.  * load content specific theme picked by user
  2278.  *
  2279.  * @param array $pContent
  2280.  * @access public
  2281.  * @return void
  2282.  */
  2283. function themes_content_display( $pContent ) {
  2284.     global $gBitSystem, $gBitSmarty, $gBitThemes, $gBitUser, $gQueryUser;
  2285.  
  2286.     // users_themes='u' is for all users content
  2287.     if( is_a( $pContent, 'LibertyContent' ) && $pContent->getPreference( 'style' ) ) {
  2288.         $theme = $pContent->getPreference( 'style' );
  2289.     } elseif( $gBitSystem->getConfig( 'users_themes' ) == 'u' ) {
  2290.         if( $gBitSystem->isFeatureActive( 'users_preferences' ) && is_object( $pContent ) && $pContent->isValid() ) {
  2291.             if( $pContent->getField( 'user_id' ) == $gBitUser->mUserId ) {
  2292.                 // small optimization to reduce checking when we are looking at our own content, which is frequent
  2293.                 if( $userStyle = $gBitUser->getPreference( 'theme' )) {
  2294.                     $theme = $userStyle;
  2295.                 }
  2296.             } else {
  2297.                 $theme = BitUser::getUserPreference( 'theme', NULL, $pContent->getField( 'user_id' ) );
  2298.             }
  2299.         }
  2300.     }
  2301.  
  2302.     if( !empty( $theme ) && $theme != DEFAULT_THEME ) {
  2303.         $gBitThemes->setStyle( $theme );
  2304.         if( !is_object( $gQueryUser ) ) {
  2305.             $userClass = $gBitSystem->getConfig( 'user_class', 'BitPermUser' );
  2306.             require_once( USERS_PKG_PATH . $userClass .'.php' );
  2307.             $gQueryUser = new $userClass( $pContent->getField( 'user_id' ) );
  2308.             $gQueryUser->load();
  2309.             $gBitSmarty->assign_by_ref( 'gQueryUser', $gQueryUser );
  2310.         }
  2311.     }
  2312. }
  2313.  
  2314. /**
  2315.  * themes_content_list
  2316.  *
  2317.  * @param array $pContent
  2318.  * @param array $pListHash
  2319.  * @access public
  2320.  * @return void
  2321.  */
  2322. function themes_content_list( $pContent, $pListHash ) {
  2323.     global $gBitSystem, $gBitSmarty, $gBitThemes, $gBitUser, $gQueryUser;
  2324.     // users_themes='u' is for all users content
  2325.     if( $gBitSystem->getConfig( 'users_themes' ) == 'u' ) {
  2326.         if( $gBitSystem->isFeatureActive( 'users_preferences' ) && !empty( $pListHash['user_id'] ) ) {
  2327.             if( $pListHash['user_id'] == $gBitUser->mUserId ) {
  2328.                 // small optimization to reduce checking when we are looking at our own content, which is frequent
  2329.                 if( $userStyle = $gBitUser->getPreference('theme') ) {
  2330.                     $theme = $userStyle;
  2331.                 }
  2332.             } else {
  2333.                 $theme = BitUser::getUserPreference( 'theme', NULL, $pListHash['user_id'] );
  2334.             }
  2335.         }
  2336.     }
  2337.     if( !empty( $theme ) && $theme != DEFAULT_THEME ) {
  2338.         $gBitThemes->setStyle( $theme );
  2339.         if( !is_object( $gQueryUser ) ) {
  2340.             $userClass = $gBitSystem->getConfig( 'user_class', 'BitPermUser' );
  2341.             require_once( USERS_PKG_PATH . $userClass .'.php' );
  2342.             $gQueryUser = new $userClass( $pListHash['user_id'] );
  2343.             $gQueryUser->load();
  2344.             $gBitSmarty->assign_by_ref( 'gQueryUser', $gQueryUser );
  2345.         }
  2346.     }
  2347. }
  2348.  
  2349. /* vim: :set fdm=marker : */
Documentation generated on Wed, 29 Jul 2015 13:56:05 +0000 by phpDocumentor 1.5.0-lsces