/**
  * Parses the nggMeta data only if needed
  * @param int $image path to a image
  * @param bool $onlyEXIF parse only exif if needed
  * @return
  */
 function __construct($image_or_id, $onlyEXIF = false)
 {
     if (is_int($image_or_id)) {
         //get the path and other data about the image
         $this->image = C_Image_Mapper::get_instance()->find($image_or_id);
     } else {
         $this->image = $image_or_id;
     }
     $imagePath = C_Gallery_Storage::get_instance()->get_image_abspath($this->image);
     if (!file_exists($imagePath)) {
         return false;
     }
     $this->size = @getimagesize($imagePath, $metadata);
     if ($this->size && is_array($metadata)) {
         // get exif - data
         if (is_callable('exif_read_data')) {
             $this->exif_data = @exif_read_data($imagePath, NULL, TRUE);
         }
         // stop here if we didn't need other meta data
         if ($onlyEXIF) {
             return true;
         }
         // get the iptc data - should be in APP13
         if (is_callable('iptcparse') && isset($metadata['APP13'])) {
             $this->iptc_data = @iptcparse($metadata['APP13']);
         }
         // get the xmp data in a XML format
         if (is_callable('xml_parser_create')) {
             $this->xmp_data = $this->extract_XMP($imagePath);
         }
         return true;
     }
     return false;
 }

 function index_action()
 {
     $this->enqueue_static_resources();
     $settings = C_NextGen_Settings::get_instance();
     $retval = $settings->proofing_user_confirmation_not_found;
     if ($proof = C_NextGen_Pro_Proofing_Mapper::get_instance()->find_by_hash($this->param('proof'), TRUE)) {
         $image_mapper = C_Image_Mapper::get_instance();
         $images = array();
         foreach ($proof->proofed_gallery['image_list'] as $image_id) {
             $images[] = $image_mapper->find($image_id);
         }
         $message = $settings->proofing_user_confirmation_template;
         if (preg_match_all('/%%(\\w+)%%/', $settings->proofing_user_confirmation_template, $matches, PREG_SET_ORDER) > 0) {
             foreach ($matches as $match) {
                 switch ($match[1]) {
                     case 'user_name':
                         $message = str_replace('%%user_name%%', $proof->customer_name, $message);
                         break;
                     case 'user_email':
                         $message = str_replace('%%user_email%%', $proof->email, $message);
                         break;
                     case 'proof_link':
                         $message = str_replace('%%proof_link%%', $proof->referer, $message);
                         break;
                     case 'proof_details':
                         $imagehtml = $this->object->render_partial('photocrati-nextgen_pro_proofing#confirmation', array('images' => $images, 'storage' => C_Gallery_Storage::get_instance()), TRUE);
                         $message = str_replace('%%proof_details%%', $imagehtml, $message);
                         break;
                 }
             }
             $retval = $message;
         }
     }
     return $retval;
 }

 /**
  * Gets all digital downloads for the pricelist
  * @param null $image_id
  * @return mixed
  */
 function get_digital_downloads($image_id = NULL)
 {
     // Find digital download items
     $mapper = C_Pricelist_Item_Mapper::get_instance();
     $conditions = array(array("pricelist_id = %d", $this->object->id()), array("source IN %s", array(NGG_PRO_DIGITAL_DOWNLOADS_SOURCE)));
     $items = $mapper->select()->where($conditions)->order_by('ID', 'ASC')->run_query();
     // Filter by image resolutions
     if ($image_id) {
         $image = is_object($image_id) ? $image_id : C_Image_Mapper::get_instance()->find($image_id);
         if ($image) {
             $retval = array();
             $storage = C_Gallery_Storage::get_instance();
             foreach ($items as $item) {
                 $source_width = $image->meta_data['width'];
                 $source_height = $image->meta_data['height'];
                 // the downloads themselves come from the backup as source so if possible only filter images
                 // whose backup file doesn't have sufficient dimensions
                 $backup_abspath = $storage->get_backup_abspath($image);
                 if (@file_exists($backup_abspath)) {
                     $dimensions = @getimagesize($backup_abspath);
                     $source_width = $dimensions[0];
                     $source_height = $dimensions[1];
                 }
                 if (isset($item->resolution) && $item->resolution >= 0 && ($source_height >= $item->resolution or $source_width >= $item->resolution)) {
                     $retval[] = $item;
                 }
             }
             $items = $retval;
         }
     }
     return $items;
 }

/**
 * Image edit functions via AJAX
 *
 * @author Alex Rabe
 *
 *
 * @return void
 */
function ngg_ajax_operation()
{
    global $wpdb;
    // if nonce is not correct it returns -1
    check_ajax_referer("ngg-ajax");
    // check for correct capability
    if (!is_user_logged_in()) {
        die('-1');
    }
    // check for correct NextGEN capability
    if (!current_user_can('NextGEN Upload images') && !current_user_can('NextGEN Manage gallery')) {
        die('-1');
    }
    // include the ngg function
    include_once dirname(__FILE__) . '/functions.php';
    // Get the image id
    if (isset($_POST['image'])) {
        $id = (int) $_POST['image'];
        // let's get the image data
        $picture = nggdb::find_image($id);
        // what do you want to do ?
        switch ($_POST['operation']) {
            case 'create_thumbnail':
                $result = nggAdmin::create_thumbnail($picture);
                break;
            case 'resize_image':
                $result = nggAdmin::resize_image($picture);
                break;
            case 'rotate_cw':
                $result = nggAdmin::rotate_image($picture, 'CW');
                nggAdmin::create_thumbnail($picture);
                break;
            case 'rotate_ccw':
                $result = nggAdmin::rotate_image($picture, 'CCW');
                nggAdmin::create_thumbnail($picture);
                break;
            case 'set_watermark':
                $result = nggAdmin::set_watermark($picture);
                break;
            case 'recover_image':
                $result = nggAdmin::recover_image($id) ? '1' : '0';
                break;
            case 'import_metadata':
                $result = C_Image_Mapper::get_instance()->reimport_metadata($id) ? '1' : '0';
                break;
            case 'get_image_ids':
                $result = nggAdmin::get_image_ids($id);
                break;
            default:
                do_action('ngg_ajax_' . $_POST['operation']);
                die('-1');
                break;
        }
        // A success should return a '1'
        die($result);
    }
    // The script should never stop here
    die('0');
}

 function cheque_checkout_action()
 {
     $retval = array();
     $items = $this->param('items');
     if (!$items) {
         return array('error' => __('Your cart is empty', 'nggallery'));
     }
     $customer = array('name' => $this->param('customer_name'), 'email' => $this->param('customer_email'), 'address' => $this->param('customer_address'), 'city' => $this->param('customer_city'), 'state' => $this->param('customer_state'), 'postal' => $this->param('customer_postal'), 'country' => $this->param('customer_country'));
     $retval['customer'] = $customer;
     // Presently we only do basic field validation: ensure that each field is filled and that
     // the country selected exists in C_NextGen_Pro_Currencies::$countries
     foreach ($customer as $key => $val) {
         if (empty($val)) {
             $retval['error'] = __('Please fill all fields and try again', 'nggallery');
             break;
         }
     }
     // No error yet?
     if (!isset($retval['error'])) {
         if (empty(C_NextGen_Pro_Currencies::$countries[$customer['country']])) {
             return array('error' => __('Invalid country selected, please try again.', 'nggallery'));
         } else {
             $customer['country'] = C_NextGen_Pro_Currencies::$countries[$customer['country']]['name'];
         }
         $checkout = new C_NextGen_Pro_Checkout();
         $cart = new C_NextGen_Pro_Cart();
         $settings = C_NextGen_Settings::get_instance();
         $currency = C_NextGen_Pro_Currencies::$currencies[$settings->ecommerce_currency];
         foreach ($items as $image_id => $image_items) {
             if ($image = C_Image_Mapper::get_instance()->find($image_id)) {
                 $cart->add_image($image_id, $image);
                 foreach ($image_items as $item_id => $quantity) {
                     if ($item = C_Pricelist_Item_Mapper::get_instance()->find($item_id)) {
                         $item->quantity = $quantity;
                         $cart->add_item($image_id, $item_id, $item);
                     }
                 }
             }
         }
         // Calculate the total
         $use_home_country = intval($this->param('use_home_country'));
         $order_total = $cart->get_total($use_home_country);
         // Create the order
         if (!$cart->has_items()) {
             return array('error' => __('Your cart is empty', 'nggallery'));
         }
         $order = $checkout->create_order($cart->to_array(), $customer['name'], $customer['email'], $order_total, 'cheque', $customer['address'], $customer['city'], $customer['state'], $customer['postal'], $customer['country'], $use_home_country, 'unverified');
         $order->status = 'unverified';
         $order->gateway_admin_note = __('Payment was successfully made via Check. Once you have received payment, you can click “Verify” in the View Orders page and a confirmation email will be sent to the user.');
         C_Order_Mapper::get_instance()->save($order);
         $checkout->send_email_notification($order->hash);
         $retval['order'] = $order->hash;
         $retval['redirect'] = $checkout->get_thank_you_page_url($order->hash, TRUE);
     }
     return $retval;
 }

 function index_action()
 {
     wp_dequeue_script('photocrati_ajax');
     wp_dequeue_script('frame_event_publisher');
     wp_dequeue_script('jquery');
     wp_dequeue_style('nextgen_gallery_related_images');
     $img_mapper = C_Image_Mapper::get_instance();
     $image_id = $this->param('image_id');
     if ($image = $img_mapper->find($image_id)) {
         $displayed_gallery_id = $this->param('displayed_gallery_id');
         // Template parameters
         $params = array('img' => $image);
         // Get the url & dimensions
         $named_size = $this->param('named_size');
         $storage = C_Gallery_Storage::get_instance();
         $dimensions = $storage->get_image_dimensions($image, $named_size);
         $image->url = $storage->get_image_url($image, $named_size, TRUE);
         $image->width = $dimensions['width'];
         $image->height = $dimensions['height'];
         // Generate the lightbox url
         $router = $this->get_router();
         $lightboxes = C_Lightbox_Library_Manager::get_instance();
         $lightbox = $lightboxes->get(NGG_PRO_LIGHTBOX);
         $uri = urldecode($this->param('uri'));
         $lightbox_slug = $lightbox->values['nplModalSettings']['router_slug'];
         $qs = $this->get_querystring();
         if ($qs) {
             $lightbox_url = $router->get_url('/', FALSE, 'root');
             $lightbox_url .= "?" . $qs;
         } else {
             $lightbox_url = $router->get_url($uri, FALSE, 'root');
             $lightbox_url .= '/';
         }
         // widget galleries shouldn't have a url specific to one image
         if (FALSE !== strpos($displayed_gallery_id, 'widget-ngg-images-')) {
             $image_id = '!';
         }
         $params['lightbox_url'] = "{$lightbox_url}#{$lightbox_slug}/{$displayed_gallery_id}/{$image_id}";
         // Add the blog name
         $params['blog_name'] = get_bloginfo('name');
         if ($lightbox->values['nplModalSettings']['enable_twitter_cards']) {
             $params['enable_twitter_cards'] = $lightbox->values['nplModalSettings']['enable_twitter_cards'];
             $params['twitter_username'] = $lightbox->values['nplModalSettings']['twitter_username'];
         }
         // Add routed url
         $protocol = $router->is_https() ? 'https://' : 'http://';
         $params['routed_url'] = $protocol . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
         // Render the opengraph metadata
         $this->expires('+1 day');
         $this->render_view("photocrati-nextgen_pro_lightbox#opengraph", $params);
     } else {
         header(__('Status: 404 Image not found', 'nextgen-gallery-pro'));
         echo __('Image not found', 'nextgen-gallery-pro');
     }
 }

 function upload_images()
 {
     $storage = C_Gallery_Storage::get_instance();
     $image_mapper = C_Image_Mapper::get_instance();
     $gallery_mapper = C_Gallery_Mapper::get_instance();
     // Get Gallery ID
     $galleryID = absint($_POST['galleryselect']);
     if (0 == $galleryID) {
         $galleryID = get_option('npu_default_gallery');
         if (empty($galleryID)) {
             self::show_error(__('No gallery selected.', 'nextgen-public-uploader'));
             return;
         }
     }
     // Get the Gallery
     $gallery = $gallery_mapper->find($galleryID);
     if (!$gallery->path) {
         self::show_error(__('Failure in database, no gallery path set.', 'nextgen-public-uploader'));
         return;
     }
     // Read Image List
     foreach ($_FILES as $key => $value) {
         if (0 == $_FILES[$key]['error']) {
             try {
                 if ($storage->is_image_file($_FILES[$key]['tmp_name'])) {
                     $image = $storage->object->upload_base64_image($gallery, file_get_contents($_FILES[$key]['tmp_name']), $_FILES[$key]['name']);
                     if (get_option('npu_exclude_select')) {
                         $image->exclude = 1;
                         $image_mapper->save($image);
                     }
                     // Add to Image and Dir List
                     $this->arrImgNames[] = $image->filename;
                     $this->arrImageIds[] = $image->id();
                     $this->strGalleryPath = $gallery->path;
                 } else {
                     unlink($_FILES[$key]['tmp_name']);
                     $error_msg = sprintf(__('<strong>%s</strong> is not a valid file.', 'nextgen-public-uploader'), $_FILES[$key]['name']);
                     self::show_error($error_msg);
                     continue;
                 }
             } catch (E_NggErrorException $ex) {
                 self::show_error('<strong>' . $ex->getMessage() . '</strong>');
                 continue;
             } catch (Exception $ex) {
                 self::show_error('<strong>' . $ex->getMessage() . '</strong>');
                 continue;
             }
         }
     }
 }

 /**
  * Read an image file into memory and display it
  *
  * This is necessary for htaccess or server-side protection that blocks access to filenames ending with "_backup"
  * At the moment it only supports the backup or full size image.
  */
 function get_image_file_action()
 {
     $order_id = $this->param('order_id', FALSE);
     $image_id = $this->param('image_id', FALSE);
     $bail = FALSE;
     if (!$order_id || !$image_id) {
         $bail = TRUE;
     }
     $order = C_Order_Mapper::get_instance()->find_by_hash($order_id);
     if (!in_array($image_id, $order->cart['image_ids'])) {
         $bail = TRUE;
     }
     if ($order->status != 'verified') {
         $bail = TRUE;
     }
     if ($bail) {
         header('HTTP/1.1 404 Not found');
         exit;
     }
     $storage = C_Gallery_Storage::get_instance();
     if (version_compare(NGG_PLUGIN_VERSION, '2.0.66.99') <= 0) {
         // Pre 2.0.67 didn't fallback to the original path if the backup file didn't exist
         $imagemapper = C_Image_Mapper::get_instance();
         $fs = C_Fs::get_instance();
         $image = $imagemapper->find($image_id);
         $gallery_path = $storage->get_gallery_abspath($image->galleryid);
         $abspath = $fs->join_paths($gallery_path, $image->filename . '_backup');
         if (!@file_exists($abspath)) {
             $abspath = $storage->get_image_abspath($image_id, 'full');
         }
     } else {
         $abspath = $storage->get_image_abspath($image_id, 'backup');
     }
     $mimetype = 'application/octet';
     if (function_exists('finfo_buffer')) {
         $finfo = new finfo(FILEINFO_MIME);
         $mimetype = @$finfo->file($abspath);
     } elseif (function_exists('mime_content_type')) {
         $mimetype = @mime_content_type($abspath);
     }
     header('Content-Description: File Transfer');
     header('Content-Disposition: attachment; filename=' . basename($storage->get_image_abspath($image_id, 'full')));
     header("Content-type: " . $mimetype);
     header('Expires: 0');
     header('Cache-Control: must-revalidate');
     header('Pragma: public');
     header('Content-Length: ' . @filesize($abspath));
     readfile($abspath);
     exit;
 }

 function processor()
 {
     global $wpdb, $ngg, $nggdb;
     // Delete a picture
     if ($this->mode == 'delpic') {
         //TODO:Remove also Tag reference
         check_admin_referer('ngg_delpicture');
         $image = $nggdb->find_image($this->pid);
         if ($image) {
             if ($ngg->options['deleteImg']) {
                 @unlink($image->imagePath);
                 @unlink($image->thumbPath);
                 @unlink($image->imagePath . '_backup');
             }
             $mapper = C_Image_Mapper::get_instance();
             $result = $mapper->destroy($this->pid);
             do_action('ngg_delete_picture', $this->pid);
             if ($result) {
                 nggGallery::show_message(__('Picture', 'nggallery') . ' \'' . $this->pid . '\' ' . __('deleted successfully', 'nggallery'));
             }
         }
         $this->mode = 'edit';
         // show pictures
     }
     // Recover picture from backup
     if ($this->mode == 'recoverpic') {
         check_admin_referer('ngg_recoverpicture');
         $image = $nggdb->find_image($this->pid);
         // bring back the old image
         nggAdmin::recover_image($image);
         nggAdmin::create_thumbnail($image);
         nggGallery::show_message(__('Operation successful. Please clear your browser cache.', "nggallery"));
         $this->mode = 'edit';
         // show pictures
     }
     // will be called after a ajax operation
     if (isset($_POST['ajax_callback'])) {
         if ($_POST['ajax_callback'] == 1) {
             nggGallery::show_message(__('Operation successful. Please clear your browser cache.', "nggallery"));
         }
     }
     // show sort order
     if (isset($_POST['sortGallery'])) {
         $this->mode = 'sort';
     }
     if (isset($_GET['s'])) {
         $this->search_images();
     }
 }

 function set_custom_post_link($post_link, $post)
 {
     if (is_int($post)) {
         $post = get_post($post);
     }
     if ($post->post_type == 'photocrati-comments') {
         if (preg_match("/^http(s)?/", $post->post_excerpt)) {
             $post_link = $post->post_excerpt;
         } else {
             $image_id = intval(str_replace('nextgen-comment-link-image-', '', $post->post_name));
             if ($image = C_Image_Mapper::get_instance()->find($image_id)) {
                 $post_link = wp_nonce_url('admin.php?page=nggallery-manage-gallery&mode=edit&gid=' . $image->galleryid);
             }
         }
     }
     return $post_link;
 }

 function add_item($image_id, $item_id, $item_props = array())
 {
     // Treat an object as if it were an array
     if (is_object($item_props)) {
         $item_props = get_object_vars($item_props);
     }
     // Find the item
     $item = C_Pricelist_Item_Mapper::get_instance()->find($item_id);
     // Find the image
     if ($image = C_Image_Mapper::get_instance()->find($image_id) and $item) {
         // Ensure that the image has been added
         if (!isset($this->_state[$image_id])) {
             $image->items = array();
             $this->_state[$image_id] = $image;
         } else {
             $image = $this->_state[$image_id];
         }
         // Ensure that the image has an items array
         if (!isset($image->items)) {
             $image->items = array();
         }
         // Ensure that the items source key exists as an array
         if (!isset($image->items[$item->source])) {
             $image->items[$item->source] = array();
         }
         // Ensure that the item's pricelist id exists as a key in the array
         if (!isset($image->items[$item->source][$item->pricelist_id])) {
             $image->items[$item->source][$item->pricelist_id] = array();
         }
         // Has the item already been added? If so, increment it's quantity
         if (isset($image->items[$item->source][$item->pricelist_id][$item_id])) {
             $previous_quantity = intval($image->items[$item->source][$item->pricelist_id][$item_id]->quantity);
             $image->items[$item->source][$item->pricelist_id][$item_id]->quantity = $previous_quantity + intval($item_props['quantity']);
         } else {
             $item->quantity = isset($item_props['quantity']) ? intval($item_props['quantity']) : 1;
             $image->items[$item->source][$item->pricelist_id][$item_id] = $item;
         }
     } else {
         unset($this->_state[$image_id]);
     }
 }

 /**
  * Parse the gallery/imagebrowser/slideshow shortcode and return all images into an array
  *
  * @param string $atts
  * @return
  */
 function add_gallery($atts)
 {
     global $wpdb;
     extract(shortcode_atts(array('id' => 0), $atts));
     $gallery_mapper = C_Gallery_Mapper::get_instance();
     if (!is_numeric($id)) {
         if ($gallery = array_shift($gallery_mapper->select()->where(array('name = %s', $id))->limit(1)->run_query())) {
             $id = $gallery->{$gallery->id_field};
         } else {
             $id = NULL;
         }
     }
     if ($id) {
         $gallery_storage = C_Gallery_Storage::get_instance();
         $image_mapper = C_Image_Mapper::get_instance();
         foreach ($image_mapper->find_all_for_gallery($id) as $image) {
             $this->images[] = array('src' => $gallery_storage->get_image_url($image), 'title' => $image->title, 'alt' => $image->alttext);
         }
     }
     return '';
 }

 function paypal_standard_order_action()
 {
     $retval = array();
     if ($items = $this->param('items')) {
         $checkout = new C_NextGen_Pro_Checkout();
         $cart = new C_NextGen_Pro_Cart();
         $settings = C_NextGen_Settings::get_instance();
         $currency = C_NextGen_Pro_Currencies::$currencies[$settings->ecommerce_currency];
         foreach ($items as $image_id => $image_items) {
             if ($image = C_Image_Mapper::get_instance()->find($image_id)) {
                 $cart->add_image($image_id, $image);
                 foreach ($image_items as $item_id => $quantity) {
                     if ($item = C_Pricelist_Item_Mapper::get_instance()->find($item_id)) {
                         $item->quantity = $quantity;
                         $cart->add_item($image_id, $item_id, $item);
                     }
                 }
             }
         }
         // Calculate the total
         $use_home_country = intval($this->param('use_home_country'));
         $order_total = $cart->get_total($use_home_country);
         // Create the order
         if ($cart->has_items()) {
             $order = $checkout->create_order($cart->to_array(), __('PayPal Customer', 'nggallery'), 'Unknown', $order_total, 'paypal_standard');
             $order->status = 'unverified';
             $order->use_home_country = $use_home_country;
             $order->gateway_admin_note = __('Payment was successfully made via PayPal Standard, with no further payment action required.');
             C_Order_Mapper::get_instance()->save($order);
             $retval['order'] = $order->hash;
         } else {
             $retval['error'] = __('Your cart is empty', 'nggallery');
         }
     }
     return $retval;
 }

 function _prepare_entities($displayed_gallery, $thumbnail_size_name)
 {
     $current_url = $this->object->get_routed_url(TRUE);
     $storage = C_Gallery_Storage::get_instance();
     $mapper = C_Image_Mapper::get_instance();
     $entities = $displayed_gallery->get_included_entities();
     foreach ($entities as &$entity) {
         $entity_type = intval($entity->is_gallery) ? 'gallery' : 'album';
         // Is the gallery actually a link to a page? Stupid feature...
         if (isset($entity->pageid) && $entity->pageid > 0) {
             $entity->link = get_page_link($entity->pageid);
         } else {
             $page_url = $current_url;
             if (intval($entity->is_gallery) && !$this->param('album')) {
                 $page_url = $this->object->set_param_for($page_url, 'album', 'galleries');
             }
             $entity->link = $this->object->set_param_for($page_url, $entity_type, $entity->slug);
         }
         $preview_img = $mapper->find($entity->previewpic);
         $entity->thumb_size = $storage->get_image_dimensions($preview_img, $thumbnail_size_name);
         $entity->url = $storage->get_image_url($preview_img, $thumbnail_size_name, TRUE);
     }
     return $entities;
 }

//.........这里部分代码省略.........
				<?php 
    }
    ?>
			</div>


        <?php 
    $ngg->manage_page->pagination('top', $_GET['paged'], $total_number_of_galleries, $items_per_page);
    ?>

		</div>
		<table class="wp-list-table widefat" cellspacing="0">
			<thead>
			<tr>
<?php 
    $wp_list_table->print_column_headers(true);
    ?>
			</tr>
			</thead>
			<tfoot>
			<tr>
<?php 
    $wp_list_table->print_column_headers(false);
    ?>
			</tr>
			</tfoot>
			<tbody id="the-list">
<?php 
    if ($gallerylist) {
        //get the columns
        $gallery_columns = $wp_list_table->get_columns();
        $hidden_columns = get_hidden_columns('nggallery-manage-gallery');
        $num_columns = count($gallery_columns) - count($hidden_columns);
        $image_mapper = C_Image_Mapper::get_instance();
        foreach ($gallerylist as $gallery) {
            $alternate = !isset($alternate) || $alternate == 'class="alternate"' ? '' : 'class="alternate"';
            $gid = $gallery->gid;
            $name = empty($gallery->title) ? $gallery->name : $gallery->title;
            $author_user = get_userdata((int) $gallery->author);
            ?>
		<tr id="gallery-<?php 
            echo $gid;
            ?>
" <?php 
            echo $alternate;
            ?>
 >
		<?php 
            foreach ($gallery_columns as $gallery_column_key => $column_display_name) {
                $class = "class=\"{$gallery_column_key} column-{$gallery_column_key}\"";
                $style = '';
                if (in_array($gallery_column_key, $hidden_columns)) {
                    $style = ' style="display:none;"';
                }
                $attributes = "{$class}{$style}";
                switch ($gallery_column_key) {
                    case 'cb':
                        ?>
        			<th scope="row" class="column-cb check-column">
        				<?php 
                        if (nggAdmin::can_manage_this_gallery($gallery->author)) {
                            ?>
        					<input name="doaction[]" type="checkbox" value="<?php 
                            echo $gid;
                            ?>
" />

 function update_pictures()
 {
     $updated = 0;
     if (!$this->can_user_manage_gallery()) {
         $updated;
     }
     if (isset($_POST['images']) && is_array($_POST['images'])) {
         $image_mapper = C_Image_Mapper::get_instance();
         foreach ($_POST['images'] as $pid => $data) {
             if (!isset($data['exclude'])) {
                 $data['exclude'] = 0;
             }
             if ($image = $image_mapper->find($pid)) {
                 // Strip slashes from title/description/alttext fields
                 if (isset($data['description'])) {
                     $data['description'] = stripslashes($data['description']);
                 }
                 if (isset($data['alttext'])) {
                     $data['alttext'] = stripslashes($data['alttext']);
                 }
                 if (isset($data['title'])) {
                     $data['title'] = stripslashes($data['title']);
                 }
                 // Generate new slug if the alttext has changed
                 if (isset($data['alttext']) && $image->alttext != $data['alttext']) {
                     $data['slug'] = NULL;
                     // will cause a new slug to be generated
                 }
                 // Update all fields
                 foreach ($data as $key => $value) {
                     $image->{$key} = $value;
                 }
                 if ($image_mapper->save($image)) {
                     $updated += 1;
                     // Update the tags for the image
                     if (isset($data['tags'])) {
                         $tags = $data['tags'];
                         if (!is_array($tags)) {
                             $tags = explode(',', $tags);
                         }
                         foreach ($tags as &$tag) {
                             $tag = trim($tag);
                         }
                         wp_set_object_terms($image->{$image->id_field}, $tags, 'ngg_tag');
                     }
                     // remove from cache
                     wp_cache_delete($image->pid, 'ngg_image');
                     // hook for other plugins after image is updated
                     do_action('ngg_image_updated', $image);
                 }
             }
         }
     }
     return $updated;
 }

 public function get_name_from_params($params, $only_size_name = false, $id_in_name = true)
 {
     $prefix_list = $this->object->_get_name_prefix_list();
     $id_prefix = $prefix_list['id'];
     $size_prefix = $prefix_list['size'];
     $flags_prefix = $prefix_list['flags'];
     $flags = $prefix_list['flag'];
     $max_value_length = $prefix_list['max_value_length'];
     $params = $this->object->_get_params_sanitized($params);
     $image = isset($params['image']) ? $params['image'] : null;
     $image_width = isset($params['width']) ? $params['width'] : null;
     $image_height = isset($params['height']) ? $params['height'] : null;
     $image_quality = isset($params['quality']) ? $params['quality'] : null;
     $extension = null;
     $name = null;
     // if $only_size_name is false then we include the file name and image id for the image
     if (!$only_size_name) {
         if (is_int($image)) {
             $imap = C_Image_Mapper::get_instance();
             $image = $imap->find($image);
         }
         if ($image != null) {
             // this is used to remove the extension and then add it back at the end of the name
             $extension = M_I18n::mb_pathinfo($image->filename, PATHINFO_EXTENSION);
             if ($extension != null) {
                 $extension = '.' . $extension;
             }
             $name .= M_I18n::mb_basename($image->filename, $extension);
             $name .= '-';
             if ($id_in_name) {
                 $image_id = strval($image->pid);
                 $id_len = min($max_value_length, strlen($image_id));
                 $id_len_hex = dechex($id_len);
                 // sanity check, should never occurr if $max_value_length is not messed up, ensure only 1 character is used to encode length or else skip parameter
                 if (strlen($id_len_hex) == 1) {
                     $name .= $id_prefix . $id_len . substr($image_id, 0, $id_len);
                     $name .= '-';
                 }
             }
         }
     }
     $name .= $size_prefix;
     $name .= strval($image_width) . 'x' . strval($image_height);
     if ($image_quality != null) {
         $name .= 'x' . $image_quality;
     }
     $name .= '-';
     $name .= $flags_prefix;
     foreach ($flags as $flag_prefix => $flag_name) {
         $flag_value = 0;
         if (isset($params[$flag_name])) {
             $flag_value = $params[$flag_name];
             if (!is_string($flag_value)) {
                 // only strings or ints allowed, sprintf is required because intval(0) returns '' and not '0'
                 $flag_value = intval($flag_value);
                 $flag_value = sprintf('%d', $flag_value);
             }
         }
         $flag_value = strval($flag_value);
         $flag_len = min($max_value_length, strlen($flag_value));
         $flag_len_hex = dechex($flag_len);
         // sanity check, should never occurr if $max_value_length is not messed up, ensure only 1 character is used to encode length or else skip parameter
         if (strlen($flag_len_hex) == 1) {
             $name .= $flag_prefix . $flag_len . substr($flag_value, 0, $flag_len);
         }
     }
     $name .= $extension;
     return $name;
 }

 /**
  * Renders the "Edit Proof" main content area
  *
  * @param null $post
  */
 function nextgen_proof_metabox($post = null)
 {
     if ($post != null) {
         $settings = C_NextGen_Settings::get_instance();
         $image_mapper = C_Image_Mapper::get_instance();
         $values = $image_mapper->unserialize($post->post_content);
         $proofed_gallery = $values['proofed_gallery'];
         $image_list = isset($proofed_gallery['image_list']) ? $proofed_gallery['image_list'] : null;
         $confirmation_param = array('proof' => $values['hash']);
         if (!empty($settings->proofing_page_confirmation)) {
             $confirmation_url = self::get_page_url($settings->proofing_page_confirmation, $confirmation_param);
         } else {
             $confirmation_url = self::add_to_querystring(site_url('/?ngg_pro_proofing_page=1'), $confirmation_param);
         }
         if ($image_list != null) {
             $storage = C_Gallery_Storage::get_instance();
             echo '<h4>';
             echo '<a target="_blank" href="' . $confirmation_url . '">' . __('User confirmation', 'nextgen-gallery-pro') . '</a>';
             echo ' | ';
             echo '<a target="_blank" href="' . $values['referer'] . '">' . __('Gallery source url', 'nextgen-gallery-pro') . '</a>';
             echo '</h4>';
             echo '<table style="width: 98%;">';
             echo '<tr><th style="width: 150px; text-align:left;">' . __('Thumbnail', 'nextgen-gallery-pro') . '</th><th style="text-align:left;">' . __('Title', 'nextgen-gallery-pro') . '</th><th style="width: 40%; text-align:left;">' . __('Filename', 'nextgen-gallery-pro') . '</th></tr>';
             foreach ($image_list as $image_id) {
                 $image = $image_mapper->find($image_id);
                 if (!$image) {
                     continue;
                 }
                 echo '<tr>';
                 echo '<td>' . $storage->get_image_html($image, 'thumb') . '</td>';
                 echo '<td>' . esc_html($image->alttext) . '</td>';
                 echo '<td>' . esc_html($image->filename) . '</td>';
                 echo '</tr>';
             }
             echo '</table>';
         }
     }
 }

 function _get_preview_image()
 {
     $registry = $this->object->get_registry();
     $storage = C_Gallery_Storage::get_instance();
     $image = C_Image_Mapper::get_instance()->find_first();
     $imagegen = C_Dynamic_Thumbnails_Manager::get_instance();
     $size = $imagegen->get_size_name(array('height' => 250, 'crop' => FALSE, 'watermark' => TRUE));
     $url = $image ? $storage->get_image_url($image, $size) : NULL;
     $abspath = $image ? $storage->get_image_abspath($image, $size) : NULL;
     return array('url' => $url, 'abspath' => $abspath);
 }