<?php
// $Id: image.module,v 1.209.2.34 2007-07-01 22:00:44 drewish Exp $

define('IMAGE_ORIGINAL', '_original');
define('IMAGE_PREVIEW', 'preview');
define('IMAGE_THUMBNAIL', 'thumbnail');

define('IMAGE_LINK_HIDDEN', 0);
define('IMAGE_LINK_SHOWN', 1);
define('IMAGE_LINK_NEW', 2);

/**
 * Implementation of hook_help
 */
function image_help($section) {
  switch ($section) {
    case 'admin/help#image':
      $output = '<p>'. t('The image module is used to create and administer images for your site. Each image is stored as a post, with thumbnails of the original generated automatically. There are two default thumbnail sizes, thumbnail and preview. The thumbnail size is shown as the preview for image posts and when browsing image galleries. The preview is the default size when first displaying an image node.') .'</p>';
      $output .= '<p>'. t('Image administration allows the image directory and the image sizes to be set.</p><p>
Image galleries are used to organize and display images in galleries.   The list tab allows users to edit existing image gallery names, descriptions, parents and relative position, known as a weight.  The add galleries tab allows you to create a new image gallery defining name, description, parent and weight.') .'</p>';
      $output .= t('<p>You can</p>
<ul>
<li>view image handling messages in <a href="!admin-settings">administer &gt;&gt; settings</a>.</li>
<li>configure image sizes and file directories at <a href="!admin-settings-image">administer &gt;&gt; settings &gt;&gt; image</a>.</li>
<li>use the <a href="!external-http-drupal-org-project-img_assist">image assist module</a> to upload and insert images into posts.</li>
', array('!admin-settings' => url('admin/settings'), '!admin-image-galleries' => url('admin/image/galleries'), '!admin-settings-image' => url('admin/settings/image'), '!external-http-drupal-org-project-img_assist' => 'http://drupal.org/project/img_assist')) .'</ul>';
      $output .= '<p>'. t('For more information please read the configuration and customization handbook <a href="!image">Image page</a>.', array('!image' => 'http://www.drupal.org/handbook/modules/image/')) .'</p>';
      return $output;
  }
}

/**
 * Implementation of hook_node_info
 */
function image_node_info() {
  return array(
    'image' => array(
      'name' => t('Image'),
      'module' => 'image',
      'description' => t('An image (with thumbnail). This is ideal for publishing photographs or screenshots.'),
    )
  );
}

/**
 * Implementation of hook_perm
 */
function image_perm() {
  return array('create images', 'view original images', 'edit own images', 'edit images');
}

/**
 * Implementation of hook_access
 */
function image_access($op, $node) {
  global $user;

  if ($op == 'create' && user_access('create images')) {
    return TRUE;
  }

  if ($op == 'update' || $op == 'delete') {
    if (user_access('edit images')) {
      return TRUE;
    }
    if (user_access('edit own images') && ($user->uid == $node->uid)) {
      return TRUE;
    }
  }
}

/**
 * Admin settings callback.
 */
function image_admin_settings() {
  _image_check_settings();

  $form['#submit'] = array('image_settings_sizes_submit' => array());
  $form['image_updated'] = array(
    '#type' => 'hidden',
    '#value' => time(),
  );

  $form['paths'] = array(
    '#type' => 'fieldset',
    '#title' => t('File paths')
  );
  $form['paths']['image_default_path'] = array(
    '#type' => 'textfield',
    '#title' => t('Default image path'),
    '#default_value' => variable_get('image_default_path', 'images'),
    '#description' => t('Subdirectory in the directory "%dir" where pictures will be stored. Do not include trailing slash.', array('%dir' => variable_get('file_directory_path', 'files'))),
  );

  $form['image_max_upload_size'] = array(
    '#type' => 'textfield',
    '#title' => t('Maximum upload size'),
    '#default_value' => variable_get('image_max_upload_size', 800),
    '#field_suffix' => t('KB'),
    '#size' => 12,
    '#description' => t('Maximum file size for image uploads. When a maximum image dimensions is specified for original images the size is checked after resizing. '),
  );

  $form['image_sizes'] = array(
    '#type' => 'fieldset',
    '#title' => t('Image sizes'),
    '#tree' => TRUE,
    '#theme' => 'image_settings_sizes_form',
    '#description' => t('The dimensions on the "Original" image will be used to resize the images when they are first uploaded. If both dimensions are specified the image will be resized to fit with in that size. If only one dimension is specified the image will be resized to exactly that dimension with the other determined by the image aspect ratio.'),
    '#validate' => array('image_settings_sizes_validate' => array()),
  );

  $link_options = array(
    IMAGE_LINK_HIDDEN => t('Hidden'),
    IMAGE_LINK_SHOWN => t('Same window'),
    IMAGE_LINK_NEW => t('New window'),
  );
  
  $sizes = _image_get_sizes();
  // Add some empty rows for user defined sizes.
  for ($i = count($sizes); $i < 6; $i++) {
    $sizes['new'. $i] = array(
      'label' => '',
      'width' => '', 
      'height' => '', 
      'link' => IMAGE_LINK_SHOWN, 
      'new' => TRUE,
    );
  }

  foreach ($sizes as $key => $size) {
    $form['image_sizes'][$key]['label'] = array(
      '#type' => 'textfield',
      '#default_value' => $size['label'],
      '#size' => 25,
    );
    if (in_array($key, _image_required_sizes())) {
      $form['image_sizes'][$key]['label']['#attributes'] = array('disabled' => 'disabled');
      $form['image_sizes'][$key]['label']['#required'] = TRUE;
    }
    $form['image_sizes'][$key]['width'] = array(
      '#type' => 'textfield',
      '#default_value' => $size['width'],
      '#size' => 5,
      '#maxlength' => 5,
    );
    $form['image_sizes'][$key]['height'] = array(
      '#type' => 'textfield',
      '#default_value' => $size['height'],
      '#size' => 5,
      '#maxlength' => 5,
    );
    $form['image_sizes'][$key]['link'] = array(
      '#type' => 'select',
      '#default_value' => $size['link'],
      '#options' => $link_options,
    );
    $form['image_sizes'][$key]['new'] = array(
      '#type' => 'value',
      '#value' => isset($size['new']) ? $size['new'] : FALSE,
    );
  }

  return system_settings_form($form);
}

/**
 * Check that the sizes provided have the required amount of information.
 */
function image_settings_sizes_validate(&$form) {
  foreach (element_children($form) as $key) {
    if ($key != IMAGE_ORIGINAL && !empty($form[$key]['label']['#value'])) {
      if (empty($form[$key]['width']['#value']) && empty($form[$key]['height']['#value'])) {
        form_set_error("image_sizes][$key][width", t('Must specify a width or height.'));
      }
    }
  }
}

/**
 * Make changes to the settings before passing them off to
 * system_settings_form_submit(). Remove deleted sizes and use the label as
 * indexes for new sizes.
 */
function image_settings_sizes_submit($form_id, &$form_values) {
  foreach ($form_values['image_sizes'] as $key => $value) {
    if (empty($value['label'])) {
      unset($form_values['image_sizes'][$key]);
    }
    else if ($value['new']) {
      unset($form_values['image_sizes'][$key]);
      $form_values['image_sizes'][$value['label']] = $value;
    }
  }
  return system_settings_form_submit($form_id, $form_values);
}

function theme_image_settings_sizes_form(&$form) {
  $header = array(t('Label'), t('Width'), t('Height'), t('Link'));
  foreach (element_children($form) as $key) {
    $row = array();
    $row[] = drupal_render($form[$key]['label']);
    $row[] = drupal_render($form[$key]['width']);
    $row[] = drupal_render($form[$key]['height']);
    $row[] = drupal_render($form[$key]['link']);
    $rows[] = $row;
  }
  $output .= theme('table', $header, $rows);
  $output .= drupal_render($form);

  return $output;
}

/**
 * Implementation of hook_menu
 */
function image_menu($may_cache) {
  $items = array();

  if ($may_cache) {
    $items[] = array(
      'path' => 'node/add/image',
      'title' => t('Image'),
      'access' => user_access('create images'),
    );
    $items[] = array(
      'path' => 'image/view',
      'title' => t('image'),
      'access' => user_access('access content'),
      'type' => MENU_CALLBACK,
      'callback' => 'image_fetch',
    );
    $items[] = array(
      'path' => 'admin/settings/image',
      'title' => t('Image'),
      'callback' => 'drupal_get_form',
      'callback arguments' => array('image_admin_settings'),
      'access' => user_access('administer site configuration'),
      'type' => MENU_NORMAL_ITEM,
      'description' => t('Image module settings.'),
    );
  }

  return $items;
}

/**
 * Implements hook_cron. (deletes old temp images)
 */
function image_cron() {
  $path = variable_get('image_default_path', 'images') .'/temp';
  $files = file_scan_directory(file_create_path($path), '.*');
  foreach ($files as $file => $info) {
    if (time() - filemtime($file) > 60*60*6) {
      file_delete($file);
    }
  }
}

/**
 * Implementation of hook_node_operations().
 */
function image_node_operations() {
  $operations = array(
    'rebuild_thumbs' => array(
      'label' => t('Rebuild image thumbnails'),
      'callback' => 'image_operations_rebuild',
    ),
  );
  return $operations;
}

function image_operations_rebuild($nids) {
  foreach ($nids as $nid) {
    if ($node = node_load($nid)) {
      if ($node->type == 'image') {
        drupal_set_message(t("Rebuilding %node-title's resized images.", array('%node-title' => $node->title)));
        _image_remove_derivatives($node);
        _image_build_derivatives($node, FALSE);
        node_save($node);
      }
    }
  }
}

/**
 * Implementation of hook_prepare().
 */
function image_prepare(&$node, $field_name) {
  if (is_null($field_name)) {
    $field_name = 'image';
  }
  if ($file = file_check_upload($field_name)) {
    // Ensure the file is an image.
    $image_info = image_get_info($file->filepath);
    if (!$image_info || !isset($image_info['extension'])) {
      form_set_error($field_name, t('Uploaded file is not a valid image. Only JPG, PNG and GIF files are allowed.'));
      return;
    }
    // Save the file to the temp directory.
    $file = file_save_upload($field_name, _image_filename($file->filename, IMAGE_ORIGINAL, TRUE));
    if (!$file) {
      return;
    }
    // Resize the original.
    $original_size = _image_get_sizes(IMAGE_ORIGINAL);
    if (!empty($original_size['width']) && !empty($original_size['height'])) {
      $result = image_scale($file->filepath, $file->filepath, $original_size['width'], $original_size['height']);
      if ($result) {
        clearstatcache();
        $file->filesize = filesize($file->filepath);
        drupal_set_message(t('The original image was resized to fit within the maximum allowed resolution of %width x %height pixels.', array('%width' => $original_size['width'], '%height' => $original_size['height'])));
      }
    }
    // Check the file size limit.
    if ($file->filesize > variable_get('image_max_upload_size', 800) * 1024) {
      form_set_error($field_name, t('The image you uploaded was too big. You are only allowed upload files less than %max_size but your file was %file_size.', array('%max_size' => format_size(variable_get('image_max_upload_size', 800) * 1024), '%file_size' => format_size($file->filesize))));
      file_delete($file->filepath);
      return;
    }
    // We're good to go.
    $node->images[IMAGE_ORIGINAL] = $file->filepath;
    $node->new_file = TRUE;

    // Call hook to allow other modules to modify the original image.
    module_invoke_all('image_alter', $node, $file->filepath, IMAGE_ORIGINAL);
    _image_build_derivatives($node, TRUE);
  }
}

/**
 * implement hook_file_download
 */
function image_file_download($file) {
  $size = image_get_info(file_create_path($file));
  if ($size) {
    $headers = array('Content-Type: '. $size['mime_type']);
    return $headers;
  }
}

/**
 * Implementation of hook_link.
 */
function image_link($type, $node, $main = 0) {
  $links = array();

  if ($type == 'node' && $node->type == 'image' && !$main) {
    $request = ($_GET['size']) ? $_GET['size'] : IMAGE_PREVIEW;
    foreach (_image_get_sizes() as $key => $size) {
      if ($size['link']) {
        // For smaller images some derivative images may not have been created.
        // The thumbnail and preview images will be equal to the original images
        // but other sizes will not be set.
        if (isset($node->images[$key]) && $node->images[$key] != $node->images[$request]) {
          if ($size['link'] == IMAGE_LINK_NEW) {
            $links['image_size_'. $key] = array(
              'title' => $size['label'],
              'href' => "image/view/{$node->nid}/$key",
              'attributes' => array('target' => '_blank'),
            );
          }
          else {            
            $links['image_size_'. $key] = array(
              'title' => $size['label'],
              'href' => 'node/'. $node->nid, 
              'query' => 'size='. urlencode($key)
            );
          }
        }
      }
    }
    if (!user_access('view original images')) {
      unset($links['image_size_'. IMAGE_ORIGINAL]);
    }
  }

  return $links;
}

/**
 * Implementation of hook_block.
 *
 * Offers 2 blocks: latest image and random image
 */
function image_block($op = 'list', $delta = 0) {
  switch ($op) {
    case 'list':
      $block[0]['info'] = t('Latest image');
      $block[1]['info'] = t('Random image');

      return $block;
    case 'view':
      if (user_access('access content')) {
        switch ($delta) {
          case 0:
            $images = image_get_latest();
            $block['subject'] = t('Latest image');
            $block['content'] = l(image_display($images[0], IMAGE_THUMBNAIL), 'node/'. $images[0]->nid, array(), NULL, NULL, FALSE, TRUE);
            break;
          case 1:
            $images = image_get_random();
            $block['subject'] = t('Random image');
            $block['content'] = l(image_display($images[0], IMAGE_THUMBNAIL), 'node/'. $images[0]->nid, array(), NULL, NULL, FALSE, TRUE);
            break;
        }
      }
      return $block;
  }
}

function image_form_add_thumbnail($form_id, $edit) {
  if ($edit['images']['thumbnail']) {
    $node = (object)($edit);
    $form = array(
      '#type' => 'item',
      '#title' => t('Thumbnail'),
      '#value' => image_display($node, IMAGE_THUMBNAIL),
      '#weight' => -10,
    );
  }
  return $form;
}

/**
 * Implementation of hook_form
 */
function image_form(&$node, &$param) {
  _image_check_settings();

  $type = node_get_types('type', $node);

  $form['title'] = array(
    '#type' => 'textfield',
    '#title' => check_plain($type->title_label),
    '#size' => 60,
    '#maxlength' => 128,
    '#required' => TRUE,
    '#default_value' => $node->title
  );

  if ($node->new_file) {
    $form['new_file'] = array('#type' => 'value', '#value' => TRUE);
  }

  $form['images']['#tree'] = TRUE;
  foreach (_image_get_sizes() as $key => $size) {
    if ($node->new_file) {
      $form['images'][$key] = array(
        '#type' => 'hidden',
        '#value' => $node->images[$key]
      );
    }
    else {
      $form['images'][$key] = array(
        '#type' => 'hidden',
        '#default_value' => $node->images[$key]
      );
    }
  }

  $form['thumbnail']['#after_build'][] = 'image_form_add_thumbnail';

  $form['#attributes'] = array("enctype" => "multipart/form-data");
  $form['image'] = array(
    '#type' => 'file',
    '#title' => t('Image'),
    '#size' => 40,
    '#description' => t('Click "Browse..." to select an image to upload.'),
    '#weight' => -3,
  );
  if ($type->has_body) {
    $form['body_filter']['body'] = array(
      '#type' => 'textarea',
      '#title' => check_plain($type->body_label),
      '#required' => ($type->min_word_count > 0),
      '#default_value' => $node->body,
    );
    $form['body_filter']['format'] = filter_form($node->format);
  }

  return $form;
}

function image_validate($node) {
  if (empty($node->images[IMAGE_ORIGINAL])) {
    form_set_error('image', t('You must upload an image.'));
  }
}

function image_submit(&$node) {
  if ($node->new_file) {
    _image_remove_derivatives($node);
    _image_build_derivatives($node, FALSE);
  }
}

/**
 * Implementation of hook_view
 */
function image_view($node, $teaser = 0, $page = 0) {
  $request = ($_GET['size']) ? $_GET['size'] : IMAGE_PREVIEW;
  $request = check_plain($request);
  $node = node_prepare($node, $teaser);
  $node->content['image'] = array(
    '#value' => theme($teaser ? 'image_teaser' : 'image_body', $node, $request),
    '#weight' => 0,
  );
  return $node;
}

/**
 * Implementation of hook_load
 */
function image_load(&$node) {
  $result = db_query("SELECT filename, filepath FROM {files} WHERE nid=%d", $node->nid);
  $node->images = array();
  while ($file = db_fetch_object($result)) {
    $node->images[$file->filename] = $file->filepath;
  }
  // If the image is smaller than the thumbnail and prevew images, we just use
  // original image rather than creating new deriviatives.
  if (empty($node->images[IMAGE_THUMBNAIL])) {
    $node->images[IMAGE_THUMBNAIL] = $node->images[IMAGE_ORIGINAL];
  }
  if (empty($node->images[IMAGE_PREVIEW])) {
    $node->images[IMAGE_PREVIEW] = $node->images[IMAGE_ORIGINAL];
  }
}

/**
 * Implementation of hook_insert
 */
function image_insert($node) {
  foreach (_image_get_sizes() as $key => $size_info) {
    _image_insert($node, $key, $node->images[$key]);
  }
}

/**
 * Implementation of hook_update
 */
function image_update($node) {
  foreach (_image_get_sizes() as $key => $size) {
    $old_file = db_fetch_object(db_query("SELECT fid, filepath FROM {files} WHERE filename='%s' AND nid=%d", $key, $node->nid));

    // This is a new image.
    if (!isset($node->images[$key]) || $old_file->filepath != $node->images[$key]) {
      file_delete(file_create_path($old_file->filepath));
      db_query("DELETE FROM {files} WHERE fid = %d", $old_file->fid);
      db_query("DELETE FROM {file_revisions} WHERE fid = %d", $old_file->fid);
      _image_insert($node, $key, $node->images[$key]);
    }
  }
}

/**
 * Implementation of hook_delete.
 */
function image_delete($node) {
  $result = db_query('SELECT fid, filepath FROM {files} WHERE nid = %d', $node->nid);
  while ($file = db_fetch_object($result)) {
    file_delete(file_create_path($file->filepath));
    db_query("DELETE FROM {file_revisions} WHERE fid = %d", $file->fid);
  }
  db_query('DELETE FROM {files} WHERE nid = %d', $node->nid);
}

/**
 * Implementation of hook_views_tables()
 */
function image_views_tables() {
  $tables['image'] = array(
    'name' => 'node',
    'fields' => array(
      'nid' => array(
        'name' => t('Image: Display Image'),
        'handler' => array(
          'image_views_handler_image_img' => t('Image'),
          'image_views_handler_image_img_link' => t('Image with link'),
        ),
        'option' => array(
          '#type' => 'select',
          '#options' => 'image_views_handler_filter_image_size',
        ),
        'notafield' => true,
        'sortable' => false,
      ),
    ),
  );
  return $tables;
}

/**
 * Create an <img> tag for an image.
 */
function image_display(&$node, $label = IMAGE_PREVIEW, $attributes = array()) {
  // regenerate images?
  if ($node->images[$label] != $node->images[IMAGE_ORIGINAL] &&
      (!file_exists(file_create_path($node->images[$label])) ||
       filemtime(file_create_path($node->images[$label])) < variable_get('image_updated', 0))) 
  {
    _image_remove_derivatives($node);
    _image_build_derivatives($node);
    node_save($node);
    drupal_set_message(t('The image %title had missing derivative image which has been regenerated.', array('%title' => $node->title)));
  }

  if (empty($node->images[$label])) {
    return;
  }

  $info = image_get_info(file_create_path($node->images[$label]));
  $attributes['class'] = "image image-$label ". (isset($attributes['class']) ? $attributes['class'] : "");
  $attributes['width'] = $info['width'];
  $attributes['height'] = $info['height'];

  return theme('image_display', $node, $label, file_create_url($node->images[$label]), $attributes);
}

/**
 * Fetches an image file, allows "shorthand" image urls such of the form:
 * image/view/$nid/$label
 * (e.g. image/view/25/thumbnail or image/view/14)
 */
function image_fetch($nid = 0, $size = IMAGE_PREVIEW) {
  if ($size == IMAGE_ORIGINAL && !user_access('view original images')) {
    return drupal_access_denied();
  }

  if (isset($nid)) {
    $node = node_load(array('type' => 'image', 'nid' => $nid));
    if ($node) {
      if (!node_access('view', $node)) {
        return drupal_access_denied();
      }

      if (isset($node->images[$size])) {
        $file = $node->images[$size];
        $headers = image_file_download($file);
        file_transfer($file, $headers);
      }
    }
  }
  return drupal_not_found();
}

/**
 * Theme a teaser
 */
function theme_image_teaser($node) {
  return l(image_display($node, IMAGE_THUMBNAIL), 'node/'. $node->nid, array(), NULL, NULL, TRUE, TRUE);
}

/**
 * Theme a body
 */
function theme_image_body($node, $size) {
  return image_display($node, $size);
}

/**
 * Theme an img tag for displaying the image.
 */
function theme_image_display($node, $label, $url, $attributes) {
  return theme('image', $url, $node->title, $node->title, $attributes, FALSE);
}


/**
 * Fetch a random N image(s) - optionally from a given term.
 */
function image_get_random($count = 1, $tid = 0) {
  if ($tid != 0) {
    $result = db_query_range(db_rewrite_sql("SELECT n.nid FROM {term_node} tn LEFT JOIN {node} n ON n.nid=tn.nid WHERE n.type='image' AND n.status=1 AND tn.tid=%d ORDER BY RAND()"), $tid, 0, $count);
  }
  else {
    $result = db_query_range(db_rewrite_sql("SELECT n.nid FROM {node} n WHERE n.type='image' AND n.status=1 ORDER BY RAND()"), 0, $count);
  }
  $output = array();
  while ($nid = db_fetch_object($result)) {
    $output[] = node_load(array('nid' => $nid->nid));
  }
  return $output;
}

/**
 * Fetch the latest N image(s) - optionally from a given term.
 */
function image_get_latest($count = 1, $tid = 0) {
  if ($tid != 0) {
    $result = db_query_range(db_rewrite_sql("SELECT n.nid FROM {term_node} tn LEFT JOIN {node} n ON n.nid=tn.nid WHERE n.type='image' AND n.status=1 AND tn.tid=%d ORDER BY n.changed DESC"), $tid, 0, $count);
  }
  else {
    $result = db_query_range(db_rewrite_sql("SELECT n.nid FROM {node} n WHERE n.type='image' AND n.status=1 ORDER BY changed DESC"), 0, $count);
  }
  $output = array();
  while ($nid = db_fetch_object($result)) {
    $output[] = node_load(array('nid' => $nid->nid));
  }
  return $output;
}

/**
 * Views handler for displaying the image.
 */
function image_views_handler_image_img($fieldinfo, $fielddata, $value, $data) {
  $node = node_load($data->nid);
  return image_display($node, $fielddata['options']);
}

/**
 * Views handler for displaying the image in a link to the the image node
 */
function image_views_handler_image_img_link($fieldinfo, $fielddata, $value, $data) {
  $node = node_load($data->nid);
  return l(image_display($node, $fielddata['options']), "node/{$node->nid}", array(), NULL, NULL, FALSE, TRUE);
}

/**
 * Views - Generate a list of all the valid sizes that are available
 */
function image_views_handler_filter_image_size($op) {
  foreach (_image_get_sizes() as $key => $size) {
    $a[$key] = $size['label'];
  }
  return $a;
}

/**
 * Verify the image module and toolkit settings.
 */
function _image_check_settings() {
  // File paths
  $image_path = file_create_path(variable_get('image_default_path', 'images'));
  $temp_path = rtrim($image_path, '/') .'/temp';

  if (!file_check_directory($image_path, FILE_CREATE_DIRECTORY, 'image_default_path')) {
    return false;
  }
  if (!file_check_directory($temp_path, FILE_CREATE_DIRECTORY, 'image_default_path')) {
    return false;
  }

  // Sanity check : make sure we've got a working toolkit
  if (!image_get_toolkit()) {
    drupal_set_message(t('No image toolkit is currently enabled. Without one the image module will not be able to resize your images. You can select one from the <a href="!link">image toolkit settings page</a>.', array('!link' => url('admin/settings/image-toolkit'))), 'error');
    return false;
  }
  return true;
}

/**
 * Generate image derivatives.
 */
function _image_build_derivatives(&$node, $temp = FALSE) {
  // sanity check:
  if (!_image_check_settings()) {
    return FALSE;
  }
  $original_path = file_create_path($node->images[IMAGE_ORIGINAL]);
  $info = image_get_info($original_path);
  // If we can't find our original image, we can not proceed.
  if (!$info) {
    return FALSE;
  }

  foreach (_image_get_sizes() as $key => $size) {
    if (empty($size['width']) || empty($size['height'])) {
      $aspect = $info['height'] / $info['width'];
      if (empty($size['height']) && !empty($size['width'])) {
        $size['height'] = (int)round($size['width'] * $aspect);
      }
      elseif (empty($size['width']) && !empty($size['height'])) {
        $size['width'] = (int)round($size['height'] / $aspect);
      }
    }
    if (!empty($size['width']) && !empty($size['height'])) {
      $destination = _image_filename($original_path, $key, $temp);

      // Don't bother making a derivative image if the original is smaller than
      // the requested size.
      if ($info['width'] > $size['width'] || $info['height'] > $size['height']) {
        if (!image_scale($original_path, $destination, $size['width'], $size['height'])) {
          drupal_set_message(t('Unable to create scaled %label image', array('%label' => $size['label'])), 'error');
          return FALSE;
        }
        $node->images[$key] = $destination;
        module_invoke_all('image_alter', $node, $destination, $key);
      }
      else {
        unset($node->images[$key]);
      }
    }
  }
}

function _image_remove_derivatives($node) {
  $result = db_query("SELECT * FROM {files} WHERE nid=%d AND filename <> '%s'", $node->nid, IMAGE_ORIGINAL);
  while ($file = db_fetch_object($result)) {
    // Never delete the original!
    if ($file->filepath != $node->images[IMAGE_ORIGINAL]) {
      file_delete(file_create_path($file->filepath));
    }
  }
  $original_fid = db_result(db_query("SELECT fid FROM {files} WHERE nid=%d AND filename = '%s'", $node->nid, IMAGE_ORIGINAL));
  db_query("DELETE FROM {files} WHERE nid = %d AND filename <> '%s'", $node->nid, IMAGE_ORIGINAL);
  db_query("DELETE FROM {file_revisions} WHERE vid = %d AND fid <> %d", $node->vid, $original_fid);
}

/**
 * Creates an image filename.
 */
function _image_filename($filename, $label = IMAGE_ORIGINAL, $temp = FALSE) {
  $path = variable_get('image_default_path', 'images') .'/';
  if ($temp) {
    $path .= 'temp/';
  }

  $filename = basename($filename);

  // Insert the resized name in non-original images
  if ($label && ($label != IMAGE_ORIGINAL)) {
    $pos = strrpos($filename, '.');
    if ($pos === false) {
      // The file had no extension - which happens in really old image.module
      // versions, so figure out the extension.
      $info = image_get_info(file_create_path($path . $filename));
      $filename = $filename .'.'. $label .'.'. $info['extension'];
    }
    else {
      $filename = substr($filename, 0, $pos) .'.'. $label . substr($filename, $pos);
    }
  }

  return file_create_path($path . $filename);
}

/**
 * Helper function to return the defined sizes (or proper defaults).
 *
 * @param $size
 *   An optional string to return only the specific image size.
 * @return
 *   An associative array with width, height, and label fields for the size.
 */
function _image_get_sizes($size = NULL) {
  $defaults = array(
    IMAGE_ORIGINAL => array('width' => '', 'height' => '', 'label' => t('Original'), 'link' => IMAGE_LINK_SHOWN),
    IMAGE_THUMBNAIL => array('width' => 100, 'height' => 100, 'label' => t('Thumbnail'), 'link' => IMAGE_LINK_SHOWN),
    IMAGE_PREVIEW   => array('width' => 640, 'height' => 640, 'label' => t('Preview'), 'link' => IMAGE_LINK_SHOWN),
  );

  $sizes = array();
  foreach (variable_get('image_sizes', $defaults) as $key => $val) {
    if (!empty($val['label'])) {
      $sizes[$key] = $val;
    }
  }

  // If they requested a specific size return only that.
  if (isset($size)) {
    // Only return an array if it's available.
    return isset($sizes[$size]) ? $sizes[$size] : FALSE;
  }

  return $sizes;
}

function _image_required_sizes() {
  return array(IMAGE_THUMBNAIL, IMAGE_PREVIEW, IMAGE_ORIGINAL);
}

/**
 * Moves temporary (working) images to the final directory and stores
 * relevant information in the files table
 */
function _image_insert(&$node, $size, $image_path) {
  // Make sure there's an image.
  if (empty($image_path)) {
    return;
  }

  $original_path = $node->images[IMAGE_ORIGINAL];

  // Don't duplicate images when a derivative == _original
  if (($size != IMAGE_ORIGINAL) && (realpath($image_path) == realpath($original_path))) {
    return;
  }

  if (file_move($image_path, _image_filename($original_path, $size))) {
    // Update the node to reflect the actual filename, it may have been changed
    // if a file of the same name already existed.
    $node->images[$size] = $image_path;

    $info = image_get_info($image_path);
    $fid = db_next_id('{files}_fid');
    db_query("INSERT INTO {files} (fid, nid, filename, filepath, filemime, filesize) VALUES (%d, %d, '%s', '%s', '%s', '%s')",
             $fid, $node->nid, $size, $image_path, $info['mime_type'], $info['file_size']);
    db_query("INSERT INTO {file_revisions} (fid, vid, description, list) VALUES (%d, %d, '%s', %d)",
             $fid, $node->vid, '', 0);
  }
}