nggGallery

Main PHP class for the WordPress plugin NextGEN Gallery.

Defined (1)

The class is defined in the following location(s).

/lib/core.php  
  1. class nggGallery { 
  2.  
  3.     /** 
  4.     * Show a error messages 
  5.     */ 
  6.     static function show_error($message) { 
  7.         echo '<div class="error" id="error"><p>' . $message . '</p></div>'; 
  8.     } 
  9.  
  10.     /** 
  11.     * Show a system messages 
  12.     */ 
  13.     static function show_message($message) { 
  14.         echo '<div class="updated fade" id="message"><p>' . $message . '</p></div>'; 
  15.     } 
  16.  
  17.     /** 
  18.     * get the thumbnail url to the image 
  19.     */ 
  20.     static function get_thumbnail_url($imageID, $picturepath = '', $fileName = '') { 
  21.  
  22.         // get the complete url to the thumbnail 
  23.         global $wpdb; 
  24.  
  25.         // safety first 
  26.         $imageID = (int) $imageID; 
  27.  
  28.         // get gallery values 
  29.         if ( empty($fileName) ) { 
  30.             list($fileName, $picturepath ) = $wpdb->get_row("SELECT p.filename, g.path FROM $wpdb->nggpictures AS p INNER JOIN $wpdb->nggallery AS g ON (p.galleryid = g.gid) WHERE p.pid = '$imageID' ", ARRAY_N); 
  31.         } 
  32.  
  33.         if ( empty($picturepath) ) { 
  34.             $picturepath = $wpdb->get_var("SELECT g.path FROM $wpdb->nggpictures AS p INNER JOIN $wpdb->nggallery AS g ON (p.galleryid = g.gid) WHERE p.pid = '$imageID' "); 
  35.         } 
  36.  
  37.         // set gallery url 
  38.         $folder_url = site_url() . '/' . $picturepath.nggGallery::get_thumbnail_folder($picturepath, FALSE); 
  39.         $thumbnailURL = $folder_url . 'thumbs_' . $fileName; 
  40.  
  41.         return $thumbnailURL; 
  42.     } 
  43.  
  44.     /** 
  45.     * get the complete url to the image 
  46.     */ 
  47.     static function get_image_url($imageID, $picturepath = '', $fileName = '') { 
  48.         global $wpdb; 
  49.  
  50.         // safety first 
  51.         $imageID = (int) $imageID; 
  52.  
  53.         // get gallery values 
  54.         if (empty($fileName)) { 
  55.             list($fileName, $picturepath ) = $wpdb->get_row("SELECT p.filename, g.path FROM $wpdb->nggpictures AS p INNER JOIN $wpdb->nggallery AS g ON (p.galleryid = g.gid) WHERE p.pid = '$imageID' ", ARRAY_N); 
  56.         } 
  57.  
  58.         if (empty($picturepath)) { 
  59.             $picturepath = $wpdb->get_var("SELECT g.path FROM $wpdb->nggpictures AS p INNER JOIN $wpdb->nggallery AS g ON (p.galleryid = g.gid) WHERE p.pid = '$imageID' "); 
  60.         } 
  61.  
  62.         // set gallery url 
  63.         $imageURL = site_url() . '/' . $picturepath . '/' . $fileName; 
  64.  
  65.         return $imageURL; 
  66.     } 
  67.  
  68.     /** 
  69.     * nggGallery::get_thumbnail_folder() 
  70.     * 
  71.     * @param mixed $gallerypath 
  72.     * @param bool $include_Abspath 
  73.     * @return string $foldername 
  74.     */ 
  75.     static function create_thumbnail_folder($gallerypath, $include_Abspath = TRUE) { 
  76.         if (!$include_Abspath) { 
  77.             $gallerypath = WINABSPATH . $gallerypath; 
  78.         } 
  79.  
  80.         if (!file_exists($gallerypath)) { 
  81.             return FALSE; 
  82.         } 
  83.  
  84.         if (is_dir($gallerypath . '/thumbs/')) { 
  85.             return '/thumbs/'; 
  86.         } 
  87.  
  88.         if (is_admin()) { 
  89.             if (!is_dir($gallerypath . '/thumbs/')) { 
  90.                 if ( !wp_mkdir_p($gallerypath . '/thumbs/') ) { 
  91.                     if (SAFE_MODE) { 
  92.                         nggAdmin::check_safemode($gallerypath . '/thumbs/'); 
  93.                     } else { 
  94.                         nggGallery::show_error(__('Unable to create directory ', 'nggallery') . $gallerypath . '/thumbs !'); 
  95.                     } 
  96.                     return FALSE; 
  97.                 } 
  98.                 return '/thumbs/'; 
  99.             } 
  100.         } 
  101.  
  102.         return FALSE; 
  103.  
  104.     } 
  105.  
  106.     /** 
  107.     * nggGallery::get_thumbnail_folder() 
  108.     * 
  109.     * @param mixed $gallerypath 
  110.     * @param bool $include_Abspath 
  111.     * @deprecated use create_thumbnail_folder() if needed; 
  112.     * @return string $foldername 
  113.     */ 
  114.     static function get_thumbnail_folder($gallerypath, $include_Abspath = TRUE) { 
  115.         return nggGallery::create_thumbnail_folder($gallerypath, $include_Abspath); 
  116.     } 
  117.  
  118.     /** 
  119.     * nggGallery::get_thumbnail_prefix() - obsolete 
  120.     * 
  121.     * @param string $gallerypath 
  122.     * @param bool   $include_Abspath 
  123.     * @deprecated prefix is now fixed to "thumbs_"; 
  124.     * @return string  "thumbs_"; 
  125.     */ 
  126.     static function get_thumbnail_prefix($gallerypath, $include_Abspath = TRUE) { 
  127.         return 'thumbs_'; 
  128.     } 
  129.  
  130.     /** 
  131.     * nggGallery::get_option() - get the options and overwrite them with custom meta settings 
  132.     * 
  133.     * @param string $key 
  134.     * @return array $options 
  135.     */ 
  136.     static function get_option($key) { 
  137.         global $post; 
  138.  
  139.         // get first the options from the database 
  140.         $options = get_option($key); 
  141.  
  142.         if ( $post == null ) 
  143.             return $options; 
  144.  
  145.         // Get all key/value data for the current post. 
  146.         $meta_array = get_post_custom(); 
  147.  
  148.         // Ensure that this is a array 
  149.         if ( !is_array($meta_array) ) 
  150.             $meta_array = array($meta_array); 
  151.  
  152.         // assign meta key to db setting key 
  153.         $meta_tags = array( 
  154.             'string' => array( 
  155.                 'ngg_gal_ShowOrder' => 'galShowOrder',  
  156.                 'ngg_gal_Sort' => 'galSort',  
  157.                 'ngg_gal_SortDirection' => 'galSortDir',  
  158.                 'ngg_gal_ShowDescription' => 'galShowDesc',  
  159.                 'ngg_ir_Audio' => 'irAudio',  
  160.                 'ngg_ir_Overstretch' => 'irOverstretch',  
  161.                 'ngg_ir_Transition' => 'irTransition',  
  162.                 'ngg_ir_Backcolor' => 'irBackcolor',  
  163.                 'ngg_ir_Frontcolor' => 'irFrontcolor',  
  164.                 'ngg_ir_Lightcolor' => 'irLightcolor',  
  165.                 'ngg_slideshowFX' => 'slideFx',  
  166.  ),  
  167.  
  168.             'int' => array( 
  169.                 'ngg_gal_Images' => 'galImages',  
  170.                 'ngg_gal_Columns' => 'galColumns',  
  171.                 'ngg_paged_Galleries' => 'galPagedGalleries',  
  172.                 'ngg_ir_Width' => 'irWidth',  
  173.                 'ngg_ir_Height' => 'irHeight',  
  174.                 'ngg_ir_Rotatetime' => 'irRotatetime' 
  175.  ),  
  176.  
  177.             'bool' => array( 
  178.                 'ngg_gal_ShowSlide' => 'galShowSlide',  
  179.                 'ngg_gal_ShowPiclense' => 'usePicLens',  
  180.                 'ngg_gal_ImageBrowser' => 'galImgBrowser',  
  181.                 'ngg_gal_HideImages' => 'galHiddenImg',  
  182.                 'ngg_ir_Shuffle' => 'irShuffle',  
  183.                 'ngg_ir_LinkFromDisplay' => 'irLinkfromdisplay',  
  184.                 'ngg_ir_ShowNavigation' => 'irShownavigation',  
  185.                 'ngg_ir_ShowWatermark' => 'irWatermark',  
  186.                 'ngg_ir_Kenburns' => 'irKenburns' 
  187.  ) 
  188.  ); 
  189.  
  190.         foreach ($meta_tags as $typ => $meta_keys) { 
  191.             foreach ($meta_keys as $key => $db_value) { 
  192.                 // if the kex exist overwrite it with the custom field 
  193.                 if (array_key_exists($key, $meta_array)) { 
  194.                     switch ($typ) { 
  195.                     case 'string': 
  196.                         $options[$db_value] = (string) esc_attr($meta_array[$key][0]); 
  197.                         break; 
  198.                     case 'int': 
  199.                         $options[$db_value] = (int) $meta_array[$key][0]; 
  200.                         break; 
  201.                     case 'bool': 
  202.                         $options[$db_value] = (bool) $meta_array[$key][0]; 
  203.                         break; 
  204.                     } 
  205.                 } 
  206.             } 
  207.         } 
  208.  
  209.         return $options; 
  210.     } 
  211.  
  212.     /** 
  213.     * nggGallery::scale_image() - Scale down a image 
  214.     * 
  215.     * @param mixed $location (filename) 
  216.     * @param int $maxw - max width 
  217.     * @param int $maxh -  max height 
  218.     * @return array (width, heigth) 
  219.     */ 
  220.     static function scale_image($location, $maxw = 0, $maxh = 0) { 
  221.         $img = @getimagesize($location); 
  222.         if ($img) { 
  223.             $w = $img[0]; 
  224.             $h = $img[1]; 
  225.  
  226.             $dim = array('w', 'h'); 
  227.             foreach($dim AS $val) { 
  228.                 $max = "max{$val}"; 
  229.                 if(${$val} > ${$max} && ${$max}) { 
  230.                     $alt = ($val == 'w') ? 'h' : 'w'; 
  231.                     $ratio = ${$alt} / ${$val}; 
  232.                     ${$val} = ${$max}; 
  233.                     ${$alt} = ${$val} * $ratio; 
  234.                 } 
  235.             } 
  236.  
  237.             return array( $w, $h ); 
  238.         } 
  239.         return false; 
  240.     } 
  241.  
  242.     /** 
  243.     * Renders a section of user display code.  The code is first checked for in the current theme display directory 
  244.     * before defaulting to the plugin 
  245.     * Call the function :    nggGallery::render ('template_name', array ('var1' => $var1, 'var2' => $var2)); 
  246.     * 
  247.     * @autor John Godley 
  248.     * @param string $template_name Name of the template file (without extension) 
  249.     * @param string $vars Array of variable name=>value that is available to the display code (optional) 
  250.     * @param bool $callback In case we check we didn't find template we tested it one time more (optional) 
  251.     * @return void 
  252.     **/ 
  253.     static function render($template_name, $vars = array (), $callback = false) { 
  254.         foreach ($vars AS $key => $val) { 
  255.             $$key = $val; 
  256.         } 
  257.  
  258.         // hook into the render feature to allow other plugins to include templates 
  259.         $custom_template = apply_filters( 'ngg_render_template', false, $template_name ); 
  260.  
  261.         if ( ( $custom_template != false ) &&  file_exists ($custom_template) ) { 
  262.             include ( $custom_template ); 
  263.         //search in theme folder 
  264.         } elseif (file_exists (get_stylesheet_directory() . "/nggallery/$template_name.php")) { 
  265.             include (get_stylesheet_directory() . "/nggallery/$template_name.php"); 
  266.         //search in WP_CONTENT_DIR 
  267.         } elseif (file_exists (WP_CONTENT_DIR . "/ngg_styles/$template_name.php")) { 
  268.             include (WP_CONTENT_DIR . "/ngg_styles/$template_name.php"); 
  269.         //use defaults 
  270.         } elseif (file_exists (NGGALLERY_ABSPATH . "/view/$template_name.php")) { 
  271.             include (NGGALLERY_ABSPATH . "/view/$template_name.php"); 
  272.         } elseif ( $callback === true ) { 
  273.             echo "<p>Rendering of template $template_name.php failed</p>"; 
  274.         } else { 
  275.             //test without the "-template" name one time more 
  276.  
  277.             $explode = explode('-', $template_name, 2); 
  278.             $template_name = array_shift($explode); 
  279.             nggGallery::render ($template_name, $vars , true); 
  280.         } 
  281.     } 
  282.  
  283.     /** 
  284.     * Captures an section of user display code. 
  285.     * 
  286.     * @autor John Godley 
  287.     * @param string $template_name Name of the template file (without extension) 
  288.     * @param string $vars Array of variable name=>value that is available to the display code (optional) 
  289.     * @return string 
  290.     **/ 
  291.     static function capture ($template_name, $vars = array ()) { 
  292.         ob_start (); 
  293.         nggGallery::render ($template_name, $vars); 
  294.         $output = ob_get_contents (); 
  295.         ob_end_clean (); 
  296.  
  297.         return $output; 
  298.     } 
  299.  
  300.     /** 
  301.      * nggGallery::graphic_library() - switch between GD and ImageMagick 
  302.      * 
  303.      * @return path to the selected library 
  304.      */ 
  305.     static function graphic_library() { 
  306.  
  307.         $ngg_options = get_option('ngg_options'); 
  308.  
  309.         if ( $ngg_options['graphicLibrary'] == 'im') 
  310.             return NGGALLERY_ABSPATH . '/lib/imagemagick.inc.php'; 
  311.         else 
  312.             return NGGALLERY_ABSPATH . '/lib/gd.thumbnail.inc.php'; 
  313.  
  314.     } 
  315.  
  316.  
  317.     /** 
  318.      * Find where is the gallery stylesheet located. 
  319.      * 
  320.      * Combines several techniques to find out where is the current 
  321.      * gallery stylesheet located. 
  322.      * 20140924: Simplification & Documentation 
  323.      * 20140924: included 
  324.      * 
  325.      * @since 1.9.13 
  326.      * @access static 
  327.      * 
  328.      * @see (none) 
  329.      * @link Filter List http://wpgetready.com/wiki/nextcellent-plugin/nextcellent-filter-list/ 
  330.      * @global type $varname Short description. 
  331.      * 
  332.      * @param (none) 
  333.      * 
  334.      * @return bool|mixed|string|void 
  335.      */ 
  336.  
  337.     static function get_theme_css_file() { 
  338.           //Allow to include a custom stylesheet, return stylesheet uri 
  339.         $stylesheet = apply_filters( 'ngg_load_stylesheet', false ); 
  340.         //Is there a stylsheet customization? 
  341.         if ( $stylesheet !== false ) { 
  342.             return ($stylesheet); //Yes, return it 
  343.         } 
  344.         //No filter customization. Is the user putting a custom stylesheet on his/her theme? 
  345.         if ( file_exists (get_stylesheet_directory() . '/nggallery.css') ) { 
  346.             return get_stylesheet_directory_uri() . '/nggallery.css'; //Yes, return uri to the custom style 
  347.         } 
  348.         //No filter and no custom style. Bye bye 
  349.         return false; 
  350.     } 
  351.  
  352.     /** 
  353.      * Support for i18n with wpml, polyglot or qtrans 
  354.      * 
  355.      * @param string $in 
  356.      * @param string $name (optional) required for wpml to determine the type of translation 
  357.      * @return string $in localized 
  358.      */ 
  359.     static function i18n($in, $name = null) { 
  360.  
  361.         if ( function_exists( 'langswitch_filter_langs_with_message' ) ) 
  362.             $in = langswitch_filter_langs_with_message($in); 
  363.  
  364.         if ( function_exists( 'polyglot_filter' )) 
  365.             $in = polyglot_filter($in); 
  366.  
  367.         if ( function_exists( 'qtrans_useCurrentLanguageIfNotFoundUseDefaultLanguage' )) 
  368.             $in = qtrans_useCurrentLanguageIfNotFoundUseDefaultLanguage($in); 
  369.  
  370.         if (is_string($name) && !empty($name) && function_exists('icl_translate')) 
  371.             $in = icl_translate('plugin_ngg', $name, $in, true); 
  372.  
  373.         $in = apply_filters('localization', $in); 
  374.  
  375.         return $in; 
  376.     } 
  377.  
  378.     /** 
  379.      * This function register strings for the use with WPML plugin (see http://wpml.org/ ) 
  380.      * 
  381.      * @param object $image 
  382.      * @return void 
  383.      */ 
  384.     static function RegisterString($image) { 
  385.         if (function_exists('icl_register_string')) { 
  386.             global $wpdb; 
  387.             icl_register_string('plugin_ngg', 'pic_' . $image->pid . '_description', $image->description, TRUE); 
  388.             icl_register_string('plugin_ngg', 'pic_' . $image->pid . '_alttext', $image->alttext, TRUE); 
  389.         } 
  390.     } 
  391.  
  392.     /** 
  393.      * Check the memory_limit and calculate a recommended memory size 
  394.      * 
  395.      * @since V1.2.0 
  396.      * @return string message about recommended image size 
  397.      */ 
  398.     static function check_memory_limit() { 
  399.  
  400.         if ( (function_exists('memory_get_usage')) && (ini_get('memory_limit')) ) { 
  401.  
  402.             // get memory limit 
  403.             $memory_limit = ini_get('memory_limit'); 
  404.             if ($memory_limit != '') 
  405.                 $memory_limit = substr($memory_limit, 0, -1) * 1024 * 1024; 
  406.  
  407.             // calculate the free memory 
  408.             $freeMemory = $memory_limit - memory_get_usage(); 
  409.  
  410.             // build the test sizes 
  411.             $sizes = array(); 
  412.             $sizes[] = array ( 'width' => 800, 'height' => 600); 
  413.             $sizes[] = array ( 'width' => 1024, 'height' => 768); 
  414.             $sizes[] = array ( 'width' => 1280, 'height' => 960);  // 1MP 
  415.             $sizes[] = array ( 'width' => 1600, 'height' => 1200); // 2MP 
  416.             $sizes[] = array ( 'width' => 2016, 'height' => 1512); // 3MP 
  417.             $sizes[] = array ( 'width' => 2272, 'height' => 1704); // 4MP 
  418.             $sizes[] = array ( 'width' => 2560, 'height' => 1920); // 5MP 
  419.  
  420.             // test the classic sizes 
  421.             foreach ($sizes as $size) { 
  422.                 // very, very rough estimation 
  423.                 if ($freeMemory < round( $size['width'] * $size['height'] * 5.09 )) { 
  424.                     $result = sprintf(  __( 'Note : Based on your server memory limit you should not upload larger images then <strong>%d x %d</strong> pixel', 'nggallery' ), $size['width'], $size['height']); 
  425.                     return $result; 
  426.                 } 
  427.             } 
  428.         } 
  429.         return; 
  430.     } 
  431.  
  432.     /** 
  433.      * Slightly modfifed version of pathinfo(), clean up filename & rename jpeg to jpg 
  434.      * 
  435.      * @param string $name The name being checked. 
  436.      * @return array containing information about file 
  437.      */ 
  438.     static function fileinfo( $name ) { 
  439.  
  440.         //Sanitizes a filename replacing whitespace with dashes 
  441.         $name = sanitize_file_name($name); 
  442.  
  443.         //get the parts of the name 
  444.         $filepart = pathinfo ( strtolower($name) ); 
  445.  
  446.         if ( empty($filepart) ) 
  447.             return false; 
  448.  
  449.         // required until PHP 5.2.0 
  450.         if ( empty($filepart['filename']) ) 
  451.             $filepart['filename'] = substr($filepart['basename'], 0 , strlen($filepart['basename']) - (strlen($filepart['extension']) + 1) ); 
  452.  
  453.         $filepart['filename'] = sanitize_title_with_dashes( $filepart['filename'] ); 
  454.  
  455.         //extension jpeg will not be recognized by the slideshow, so we rename it 
  456.         $filepart['extension'] = ($filepart['extension'] == 'jpeg') ? 'jpg' : $filepart['extension']; 
  457.  
  458.         //combine the new file name 
  459.         $filepart['basename'] = $filepart['filename'] . '.' . $filepart['extension']; 
  460.  
  461.         return $filepart; 
  462.     } 
  463.  
  464.     /** 
  465.      * Check for extended capabilites. Must previously registers with add_ngg_capabilites() 
  466.      * 
  467.      * @since 1.5.0 
  468.      * @param string $capability 
  469.      * @return bool $result of capability check 
  470.      */ 
  471.     static function current_user_can( $capability ) { 
  472.  
  473.         global $_ngg_capabilites; 
  474.  
  475.         if ( is_array($_ngg_capabilites) ) 
  476.             if ( in_array($capability , $_ngg_capabilites) ) 
  477.                 return current_user_can( $capability ); 
  478.  
  479.         return true; 
  480.     } 
  481.  
  482.     /** 
  483.      * Check for extended capabilites and echo disabled="disabled" for input form 
  484.      * 
  485.      * @since 1.5.0 
  486.      * @param string $capability 
  487.      * @return void 
  488.      */ 
  489.     static function current_user_can_form( $capability ) { 
  490.  
  491.         if ( !nggGallery::current_user_can( $capability )) 
  492.             echo 'disabled="disabled"'; 
  493.     } 
  494.  
  495.     /** 
  496.      * Register more capabilities for custom use and add it to the administrator 
  497.      * 
  498.      * @since 1.5.0 
  499.      * @param string $capability 
  500.      * @param bool $register the new capability automatic to the admin role 
  501.      * @return void 
  502.      */ 
  503.     static function add_capabilites( $capability , $register = true ) { 
  504.         global $_ngg_capabilites; 
  505.  
  506.         if ( !is_array($_ngg_capabilites) ) 
  507.             $_ngg_capabilites = array(); 
  508.  
  509.         $_ngg_capabilites[] = $capability; 
  510.  
  511.         if ( $register ) { 
  512.             $role = get_role('administrator'); 
  513.             if ( !empty($role) ) 
  514.                 $role->add_cap( $capability ); 
  515.         } 
  516.  
  517.     } 
  518.  
  519.     /** 
  520.      * Check for mobile user agent 
  521.      * 
  522.      * @since 1.6.0 
  523.      * @author Part taken from WPtouch plugin (http://www.bravenewcode.com) 
  524.      * @return bool $result of  check 
  525.      */ 
  526.     static function detect_mobile_phone() { 
  527.  
  528.         $useragents = array(); 
  529.  
  530.         // Check if WPtouch is running 
  531.         if ( function_exists('bnc_wptouch_get_user_agents') ) 
  532.             $useragents = bnc_wptouch_get_user_agents(); 
  533.         else { 
  534.             $useragents = array( 
  535.                 "iPhone", // Apple iPhone 
  536.                 "iPod", // Apple iPod touch 
  537.                 "Android", // 1.5+ Android 
  538.                 "dream", // Pre 1.5 Android 
  539.                 "CUPCAKE", // 1.5+ Android 
  540.                 "blackberry9500", // Storm 
  541.                 "blackberry9530", // Storm 
  542.                 "blackberry9520", // Storm    v2 
  543.                 "blackberry9550", // Storm v2 
  544.                 "blackberry9800", // Torch 
  545.                 "webOS", // Palm Pre Experimental 
  546.                 "incognito", // Other iPhone browser 
  547.                 "webmate"              // Other iPhone browser 
  548.  ); 
  549.  
  550.             asort( $useragents ); 
  551.          } 
  552.  
  553.         // Godfather Steve says no to flash 
  554.         if ( is_array($useragents) ) 
  555.             $useragents[] = "iPad";  // Apple iPad; 
  556.  
  557.         // WPtouch User Agent Filter 
  558.         $useragents = apply_filters( 'wptouch_user_agents', $useragents ); 
  559.  
  560.          foreach ( $useragents as $useragent ) { 
  561.             if ( preg_match( "#$useragent#i", $_SERVER['HTTP_USER_AGENT'] ) ) 
  562.                 return true; 
  563.         } 
  564.  
  565.         return false; 
  566.     } 
  567.  
  568.     /** 
  569.      * get_memory_usage 
  570.      * 
  571.      * @access only for debug purpose 
  572.      * @since 1.8.3 
  573.      * @param string $text 
  574.      * @return void 
  575.      */ 
  576.     static function get_memory( $text = '' ) { 
  577.         global $memory; 
  578.  
  579.         $memory_peak = memory_get_usage(); 
  580.         $diff = 0; 
  581.  
  582.         if ( isset($memory) ) 
  583.             $diff = $memory_peak - $memory; 
  584.  
  585.         $exp = ($diff < 0) ? '-' : ''; 
  586.         $diff = ($exp == '-') ? 0 - $diff : $diff; 
  587.  
  588.         $memory = $memory_peak; 
  589.  
  590.         $unit = array('b', 'kb', 'mb', 'gb', 'tb', 'pb'); 
  591.         $rounded = @round($diff/pow(1024, ($i=floor(log($diff, 1024)))), 2).' '.$unit[$i]; 
  592.  
  593.         echo $text . ': ' . $exp . $rounded .'<br />'; 
  594.  
  595.     } 
  596.  
  597.     /** 
  598.      * Show NextGEN Version in header 
  599.      * @since 1.9.0 
  600.      * 
  601.      * @return void 
  602.      */ 
  603.     static function nextgen_version() { 
  604.         global $ngg; 
  605.         echo apply_filters('show_nextgen_version', '<!-- <meta name="NextGEN" version="'. $ngg->version . '" /> -->' . "\n"); 
  606.     } 
  607.  
  608.     /** 
  609.      * Prevents injection filtering HTML Code 
  610.      * 20140604: Improved based on suggestions of jayque9 
  611.      * http://wordpress.org/support/topic/prevent-removal-of-html-code-from-image-descriptions 
  612.      */ 
  613.     static function suppress_injection 
  614.     ($html_text) { 
  615.         global $allowedposttags; 
  616.         return wp_kses(stripslashes($html_text), $allowedposttags); 
  617.     } 
  618. }