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 BitThemes1.php

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