modules/flickrup/flickrup.module

<?php
/**
 * @file
 * Flickr Uploading module
 * 
 * Notes:
 * - Requires phpFlickr package, http://phpflickr.com/. Using v2.1.0
 * - To get the Flickr auth token, you can use http://phpflickr.com/tools/auth/
 *   and follow the steps there (you'll need a key with 'write' permissions).
 * 
 * Developed by Jose A. Reyero
 * Development Seed, http://www.developmentseed.org
 **/

/**
 * Implementation of hook_help()
 */
function flickrup_help($section) {
  switch ($section) {
    case 'admin/help#flickrup':
      $output = '<p>'.t('Flickr Upload module features:').'</p><ul>';
      $output .= '<li>'.t('Allows uploading images to Flickr from your site.').'</li>';
      $output .= '<li>'.t('Images can be linked to nodes using per content type settings.').'</li>';
      $ouptut .= '<li>'.t('Tags can be configured globally or using node parameters.').'</li>';
      $output .= '</ul>';
      $output .= '<p>'.t('The images are uploaded first to the web server, then from there to your Flickr account. This may have some important performance impact on the web server, so please review carefully the module settings for production servers.').'</p>';
      $output .= '<p><small>'.t('This module uses <a href="http://phpflickr.com/">phpFlickr</a> to interact with the Flickr API.').'</small></p>';
      return $output;
    case 'admin/settings/flickrup':
      $output = '<p>'.t('In adition to your normal flickr settings this module needs a Flickr authentication token with write permissions for your account. If you don\'t know how to get one, <a href="http://phpflickr.com/tools/auth/" >follow the steps here</a>.').'</p>';
      return $output;
  }

}

/**
 * Implementation of hook_menu().
 */
function flickrup_menu($may_cache) {
  global $user;
  
  $items = array();
  if ($may_cache) {
    $items[] = array(
      'path' => 'admin/settings/flickrup', 'title' => t('Flickr Uploading'),
      'callback' => 'drupal_get_form',
      'callback arguments' => array('flickrup_admin_settings'),
      'access' => user_access('administer site configuration'),
      'type' => MENU_NORMAL_ITEM,
      'description' => t('Change settings for the flickr upload module.')
    );
    $items[] = array(
      'path' => 'flickrup/js',
      'callback' => 'flickrup_js',
      'access' => user_access('upload photos to all nodes') || user_access('upload photos to own nodes'),
      'type' => MENU_CALLBACK,
    );
    
    // Testing
    /*
    $items[] = array(
      'path' => 'flickr/upload',
      'title' => t('Upload to Flickr'),
      'callback' => 'flickrup_page_upload',
      'access' => user_access('upload photos to nodes'),
    );
    */
  } else {
    // Upload to nodes
    if (arg(0) == 'node' && is_numeric(arg(1)) && ($node = node_load(arg(1))) && variable_get('flickr_upload_type_'.$node->type, 0)) {
      $items[] = array('path' => 'node/'. arg(1) .'/flickr', 'title' => t('Upload photos'),
        'callback' => 'flickrup_page_node_upload',
        'callback arguments' => array($node),
        'access' => user_access('upload photos to all nodes') || ($node->uid == $user->uid && user_access('upload photos to own nodes')),
        'weight' => 4,
        'type' => MENU_LOCAL_TASK
      );
      if (variable_get('flickr_node_view', 'tab') == 'tab') {
        $items[] = array('path' => 'node/'. arg(1) .'/photos', 'title' => t('Photos'),
          'callback' => 'flickrup_page_node_view',
          'callback arguments' => array($node),
          'access' => user_access('access content'),
          'weight' => 2,
          'type' => MENU_LOCAL_TASK
        );
      }
    }
  }
  return $items;
}

/**
 * Menu/form callback. Settings form
 */
function flickrup_admin_settings() {
  $form['flickr_api_token'] = array(
    '#type' => 'textfield',
    '#title' => t('API Auth token'),
    '#required' => TRUE,
    '#default_value' => variable_get('flickr_api_token', ''),
    '#description' => t('API Auth Token from Flickr with \'write\' permission'),
  );    
  $form['flickr_global_tag'] = array(
    '#type' => 'textfield',
    '#title' => t('Global Flickr tags'),
    '#required' => TRUE,
    '#default_value' => variable_get('flickr_global_tag', ''),
    '#description' => t('Enter space separated global tags to apply to all the uploads from this site.'),
  );
  $form['flickrup_remove'] = array(
    '#type' => 'checkbox',
    '#title' => t('Delete photos from Flickr when they are removed from a node'),
    '#default_value' => variable_get('flickrup_remove', ''),
  );
  
  // Upload options
  $form['upload'] = array('#type' => 'fieldset', '#title' => t('Upload options'));
  $form['upload']['flickr_upload_fields'] = array(
    '#type' => 'textfield',
    '#title' => t('Number of upload fields'),
    '#default_value' => variable_get('flickr_upload_fields', 1),
    '#description' => t('Enter the number of image fields for the upload form. Be warned that this may have an important impact on server performance. The minimum number is 1'),
  );
  $form['upload']['flickr_upload_public'] = array(
    '#type' => 'radios',
    '#title' => t('Upload mode'),
    '#options' => array(t('Private'), t('Public')),
    '#default_value' => variable_get('flickr_upload_public', 1),
    '#description' => t('Select whether you want your uploaded images to be private or public'),
  );
  $form['upload']['flickr_upload_async'] = array(
    '#type' => 'checkbox',
    '#title' => t('Asynchronous uploading'),
    '#default_value' => variable_get('flickr_upload_async', 0),
    '#description' => t('Enable asynchronous uploading to Flickr to speed up the page request. This should be faster but we won\'t be able to control whether the Flickr upload has worked or not.'),
  );
  $form['upload']['flickr_upload_delete'] = array(
    '#type' => 'checkbox',
    '#title' => t('Delete images from server'),
    '#default_value' => variable_get('flickr_upload_delete', 0),
    '#description' => t('Delete images from the web server after uploading them to Flickr. This is currently not compatible with asynchronous uploading.'),
  );
  // Check whether the picture directory exists:
  $picture_path = file_create_path(variable_get('flickr_picture_path', 'flickr'));
  file_check_directory($picture_path, 1, 'flickr_picture_path');
  
  // Image file settings
  $form['pictures'] = array('#type' => 'fieldset', '#title' => t('Pictures'));
  $form['pictures']['flickr_picture_path'] = array('#type' => 'textfield', '#title' => t('Picture image path'), '#default_value' => variable_get('flickr_picture_path', 'flickr'), '#size' => 30, '#maxlength' => 255, '#description' => t('Subdirectory in the directory %dir where pictures will be stored.', array('%dir' => file_directory_path() .'/')));
  $form['pictures']['flickr_picture_dimensions'] = array('#type' => 'textfield', '#title' => t('Picture maximum dimensions'), '#default_value' => variable_get('flickr_picture_dimensions', '800x600'), '#size' => 15, '#maxlength' => 10, '#description' => t('Maximum dimensions for pictures, in pixels.'));
  $form['pictures']['flickr_picture_file_size'] = array('#type' => 'textfield', '#title' => t('Picture maximum file size'), '#default_value' => variable_get('flickr_picture_file_size', '1000'), '#size' => 15, '#maxlength' => 10, '#description' => t('Maximum file size for pictures, in kB.'));
 
  $form['flickr_node_view'] = array(
    '#type' => 'radios',
    '#title' => t('Show images for nodes'),
    '#options' => array(
      'none' => t('Do not show'), 
      'body' => t('Show in the node body'), 
      'tab' => t('Show in a different tab')
     ),
    '#default_value' => variable_get('flickr_node_view', 'tab'),
    '#description' => t('Select whether you want to display images with the content they were uploaded for.'),
  );
  return system_settings_form($form);  
}
/**
 * Implementation of hook_perms()
 */
function flickrup_perm() {
  return array('upload photos to all nodes', 'upload photos to own nodes');
}

/**
 * Implementation of hook_form_alter()
 */
function flickrup_form_alter($form_id, &$form) {
  if (isset($form['type'])) {
    if ($form['type']['#value'] .'_node_form' == $form_id) {
      $type = content_types($form['type']['#value']);
      foreach ($type['fields'] as $name => $field) {
        if ($field['type'] == 'flickrfield' && $field['widget']['type'] == 'flickrup') {
          drupal_add_js('misc/progress.js');
          drupal_add_js('misc/upload.js');
          $form['#attributes']['enctype'] = 'multipart/form-data';
        }
      }    
    }
  }
  
  if ($form_id == 'node_type_form' && isset($form['identity']['type'])) {
    $type = $form['#node_type']->type;
    
    $description = '<p>' . t('Some variables you can use in your tags are:').'</p>';
    foreach (flickrup_node_variables('list', $type) as $key => $name) {
      $items[] = '<strong>'.$key.'</strong> - '.$name;
    }   
    $description .= theme('item_list', $items);    
    $form['workflow']['flickr'] = array(
      '#type' => 'fieldset',
      '#title' => t('Flickr settings'),
      '#description' => $description,
    );
    $form['workflow']['flickr']['flickr_upload_type'] = array(
      '#type' => 'radios',
      '#title' => t('Enable Flickr upload'),
      '#default_value' => variable_get('flickr_upload_type_'.$type, 0),
      '#options' => array(t('Disabled'), t('Enabled')),
      '#description' => t('Upload photos to Flickr for this content.'),
    );
    $form['workflow']['flickr']['flickr_upload_tag'] = array(
      '#type' => 'textfield',
      '#title' => t('Automatic Upload tags'),
      '#default_value' => variable_get('flickr_upload_tag_'.$type, ''),
      '#description' => t('Tags for this content type separated by spaces') ,
    );
    $form['workflow']['flickr']['flickr_display_tag'] = array(
      '#type' => 'textfield',
      '#title' => t('Tags for display'),
      '#default_value' => variable_get('flickr_display_tag_'.$type, variable_get('flickr_upload_tag_'.$type, '')),
      '#description' => t('Tags that will be used for node display. They will default to upload tags.') ,
    );
  }  
}

/**
 * Node variables
 */
 
function flickrup_node_variables($op, $param) {
  switch ($op) {
    case 'list': // Param is node type
      $variables = array(
        '[nid]' => t('The id number of the node.'),
        '[type]' => t('The node type (e.g., "page", "story", etc.).'),
        '[yyyy]' => t('The year the node was created.'),
      );
      break;
    case 'values': // Param is node object
      $variables = array(
        '[nid]' => $param->nid,
        '[type]' => $param->type,
        '[yyyy]' => date('Y', $param->created),     
      );
      
  }
  // Integration with location variables
  if (module_exists('location') ) {
    $variables += flickrup_node_variables_location($op, $param);
  }
  return $variables;
}

function flickrup_node_variables_location($op, $param) {
  $variables = array();
  switch ($op) {
    case 'list':
      if (variable_get('location_maxnum_'. $param, 0)) {
        $variables += array(
          '[city]' => t('City name'),
          '[state]' => t('State or province name'),
          '[country]' => t('Country name'),
        );
      }
      break;
    case 'values':
      // Empty values to be overriden
      $variables['[city]'] = '';
      $variables['[country]'] = '';
      $variables['[state]'] = '';

      if ($param->location) {
        $location = $param->location;
        //var_dump($location);
        if (!empty($location['city'])) {
          $variables['[city]'] = flickrup_cleanstring($location['city']);
        }
        if (!empty($location['country'])) {
          $countries = _location_get_iso3166_list();
          $variables['[country]'] = flickrup_cleanstring(t($countries[$location['country']]));
        }
        if (!empty($location['province'])) {
          $variables['[state]'] = flickrup_cleanstring($location['province']);
        }
      }
  }
  return $variables;
}

/**
 * Implementation of hook_nodeapi().
 * 
 * Show flickr images for this content
 */
function flickrup_nodeapi(&$node, $op, $teaser = NULL, $page = NULL) {
  switch ($op) {
    case 'view';
      if (variable_get('flickr_upload_type_'.$node->type, 0) && variable_get('flickr_node_view', 'tab') == 'body') {
        $node->content['photos'] = array(
          '#value' => theme('flickrup_node_photos', $node),
          '#weight' => 100,
        );
      }
      break;
  }  
}

/**
 * Quick node pictures presentation using the node tags
 */
function theme_flickrup_node_photos($node, $width = 480, $height = 480) {
  $output = '';
  if ($tags = flickrup_node_tags($node, TRUE)) {
    $tagstring = implode('%2C', $tags);
    $src = "http://www.flickr.com/slideShow/index.gne?user_id=&set_id=&tags=$tagstring&tag_mode=all&text=";
    $output .= "<iframe align=center src=\"$src\" frameBorder=0 width=$width scrolling=no height=$height></iframe>\n";
  }
  return $output;
}
/**
 * Menu callback. Upload photos to node
 */
function flickrup_page_node_upload($node) {
  drupal_set_title(t('Upload photos for %title', array('%title' => $node->title)));
  $output = '';
  // Get tags for this node type
  $tags = flickrup_node_tags($node);
  
  // Set default parameters
  $params['title'] = $node->title;
  $params['fixed_tags'] = implode(' ', $tags);
  $output .= drupal_get_form('flickrup_upload_form', $params);
  return $output;
}

/**
 * Menu callback. View pictures for a node
 */
function flickrup_page_node_view($node) {
  drupal_set_title(t('Photos for %title', array('%title' => $node->title)));
  $output = '';
  $output .= theme('flickrup_node_photos', $node);

  return $output;
}
/**
 * 
 * Menu callback: upload page and form
 * 
 * Arguments will be a list of tags
 */
function flickrup_page_upload($op = '') {
  $output = '';
  // Get tags
  $tags = func_get_args();
  array_shift($tags);
  
  switch ($op) {
    case 'done':
      $output .= flickrup_page_upload_done($tags);
      break;
    case 'tags':
    default;
      $output .= drupal_get_form('flickrup_upload_form', $tags);
      break;
  }
  return $output;
}

function flickrup_page_upload_done($tags) {
  $output = '';
  $output .= 'Not implemented';
  return $output;
}

/**
 * Upload form
 */
function flickrup_upload_form($params = array()) {
  $form['#attributes']['enctype'] = 'multipart/form-data';
  $form['title'] = array(
    '#type' => 'textfield',
    '#title' => t('Title'),
    '#default_value' => empty($params['title']) ? '' : $params['title'],
  );

  if (!empty($params['fixed_tags'])) {
    $form['fixed_tags'] = array(
      '#type' => 'value',
      '#value' => $params['fixed_tags'],
    );
    $form['info_tags'] = array(
      '#type' => 'item',
      '#title' => t('Predefined tags'),
      '#value' => $params['fixed_tags'],
    );
  }
  
  $form['custom_tags'] = array(
      '#type' => 'textfield',
      '#title' => t('Custom tags'),
      '#description' => t('Flickr tags separated by spaces. You can add your own tags here.'),
  );

  $form['images'] = array(
    '#type' => 'fieldset',
    '#title' => t('Upload pictures'), 
    '#description' => t('Maximum dimensions are %dimensions and the maximum size is %size kB.', array('%dimensions' => variable_get('flickr_picture_dimensions', '800x600'), '%size' => variable_get('flickr_picture_file_size', '1000')))
  );
  for($i=1; $i<= variable_get('flickr_upload_fields', 1); $i++) {
    $field = 'upload'.$i;
    // There may be uploaded images waiting in the session object. These will override
    // the upload fields using hook_after build
    $form['images'][$field] = array(
      '#title' => t('Image %number', array('%number' => $i)),
      '#type' => 'file', 
      '#size' => 48, 
    );
  }
  // Add preloaded images after the form has been built and validated
  //$form['#after_build'][] = 'flickrup_upload_form_previews';
  // We use form theming for that
  
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Upload'),
  );
  $form['reset'] = array(
    '#type' => 'submit',
    '#value' => t('Reset'),
  );
  return $form;
}

/**
 * Display image previews.
 * 
 * I didn't find a better place to do this, as images are added in session on 
 * form validation, after the form has been built, including after_build 
 */
function theme_flickrup_upload_form($form) {
  if (!empty($_SESSION['flickr_upload'])) {
    foreach ($_SESSION['flickr_upload'] as $field => $file) {
      // Cached image, just display
      $form['images'][$field]['#type'] = 'item';
      $form['images'][$field]['#value'] = theme('flickrup_image_preview', $file);      
    }
  } else {
    unset ($form['reset']);
  }
  
  return drupal_render($form);
}
/**
 * Preview image
 */
function theme_flickrup_image_preview($file, $width = 200, $height = 200) {
  $output = '<div class="flickr-image-preview" >';
  if ($info = image_get_info($file->filepath)) {
    // don't scale up
    if ($width >= $info['width'] && $height >= $info['height']) {
      return FALSE;
    }
  
    $aspect = $info['height'] / $info['width'];
    if ($aspect < $height / $width) {
      $width = (int)min($width, $info['width']);
      $height = (int)round($width * $aspect);
    }
    else {
      $height = (int)min($height, $info['height']);
      $width = (int)round($height / $aspect);
    }
    $src = file_create_url($file->filepath);
    $output .= "<img src=\"$src\"  width=$width height =$height />";

  } else {
    $output .= t('No image preview');
  }
  $output .= '</div>';
  return $output;
}
/**
 * Form callback. Validation
 */
function flickrup_upload_form_validate($form_id, $values) {
  global $form_values;

  // Check for uploaded images.
  $upload = FALSE;
  
  // Set previously uploaded files into form values
  if (!empty($_SESSION['flickr_upload'])) {
    $upload = TRUE;
    $form_values['files'] = $_SESSION['flickr_upload'];
  }

  for($i=1; $i<= variable_get('flickr_upload_fields', 1); $i++) {
    $field = 'upload'.$i;
    if ($file = file_check_upload($field)) {
      $upload = TRUE;
      flickrup_validate_picture($file, $field);
    }  
  }
  
  // Debug. Fire validation error
  // form_set_error('images', 'Testing validation error');
  
  // Final validation for files. If there are errors but also uploaded files,
  // they will be kept in the session object.
  if (!$upload) {
    form_set_error('images', t('No files to upload'));
  }
}

function flickrup_validate_picture($file, $field = 'upload') {
  global $form_values;

  // To check errors separately for each file
  $error = FALSE;
  
  // Check that uploaded file is an image, with a maximum file size
  // and maximum height/width.
  $info = image_get_info($file->filepath);
  //dsm($file);
  //dsm($info);
  list($maxwidth, $maxheight) = explode('x', variable_get('flickr_picture_dimensions', '800x600'));

  if (!$info || !$info['extension']) {
    $error = TRUE;
    form_set_error($field, t('The uploaded file was not an image.'));
  }
  else if (image_get_toolkit()) {
    image_scale($file->filepath, $file->filepath, $maxwidth, $maxheight);
  }
  else if (filesize($file->filepath) > (variable_get('user_picture_file_size', '1000') * 1000)) {
    $error = TRUE;
    form_set_error($field, t('The uploaded image is too large; the maximum file size is %size kB.', array('%size' => variable_get('user_picture_file_size', '30'))));
  }
  else if ($info['width'] > $maxwidth || $info['height'] > $maxheight) {
    $error = TRUE;
    form_set_error($field, t('The uploaded image is too large; the maximum dimensions are %dimensions pixels.', array('%dimensions' => variable_get('user_picture_dimensions', '85x85'))));
  }

  if (!$error) {
    if ($file = file_save_upload($file, variable_get('flickr_picture_path', 'flickr').'/'.$file->filename, FILE_EXISTS_RENAME)) {
      $form_values['files'][$field] = $file;
      // Store in session until it has been uploaded to flickr
      $_SESSION['flickr_upload'][$field] = $file;
    }
    else {
      form_set_error($field, t("Failed to upload the image file; the %directory directory doesn't exist or is not writable.", array('%directory' => variable_get('flickr_picture_path', 'flickr'))));
    }
  }
}
/**
 * Form callback. Upload to Flickr.
 */
function flickrup_upload_form_submit($form_id, $form_values) {
  $op = isset($_POST['op']) ? $_POST['op'] : '';
  $tags = array();

  // Reset option for deleting preloaded images
  if ($op == t('Reset')) {
    foreach($form_values['files'] as $index => $file) {
      file_delete($file->filepath);
    }
    unset($_SESSION['flickr_upload']);
    drupal_set_message(t('The saved images have been deleted.'));
  } else {
    // Image submission to Flickr
    foreach (array('fixed_tags', 'custom_tags') as $field) {
      if (!empty($form_values[$field])) {
        $tags[] = $form_values[$field];
      } 
    }
    if ($form_values['files']) {
      $uploads = $errors = 0;
      foreach ($form_values['files'] as $index => $file) {
        if (flickrup_upload($file->filepath, $form_values['title'], $tags)) {
          $uploads++;
          // Delete files that may be stored in session
          unset($_SESSION['flickr_upload'][$index]);
        } else {
          $errors++;
        }
      }
      if ($uploads) {
        drupal_set_message(t('Uploaded successfully %images.', array('%images' => format_plural($uploads, '@count image', '@count images'))));
      }
      if ($errors) {
        drupal_set_message(t('Flickr Upload error with %images. The images have been stored in our local server though so you won\'t need to upload them again.', array('%images' => format_plural($uploads, '@count image', '@count images'))));
      }
    } else {
      drupal_set_message(t('Drupal upload error. Please try again later or contact the site administrator.'), 'error');
    }
  }
}

/**
 * Get tags for a node
 * 
 * @param $node
 *   Node object to get the tags for
 * @param $display
 *   TRUE to get only display tags
 */
function flickrup_node_tags($node, $display = FALSE) {
  $tags = array();
  if ($tag = variable_get('flickr_global_tag', '')) {
    $tags = array_merge($tags, explode(' ', $tag));
  }
  // Node display/upload tags
  $tag = variable_get('flickr_upload_tag_'.$node->type, '');
  $tag = $display ? variable_get('flickr_display_tag_'.$node->type, $tag): $tag;
  if ($tag) {
    // Apply variables to placeholders
    if ($placeholders = flickrup_node_variables('values', $node)) {
      $tag = str_replace(array_keys($placeholders), $placeholders, $tag);
    }
    $tags = array_merge($tags, explode(' ', $tag));
  }

  // Filter and organize
  $tags = array_map('trim', $tags);
  return $tags;  
}

/**
 * Actually upload photo to flickr
 */
function flickrup_upload($path, $title = '', $tags = array(), $description = '') {
  static $flickr; // Static caching for the flickr object to support multiple uploads
  
  if (!isset($flickr)) {
    require_once drupal_get_path('module', 'flickrup').'/phpFlickr/phpFlickr.php';
    // Create the class with auth parameters
    $flickr = new phpFlickr(trim(variable_get('flickr_api_key', '')), trim(variable_get('flickr_api_secret', '')));
    $flickr->setToken(trim(variable_get('flickr_api_token', '')));
  }

  // Prepare tag string
  if (is_array($tags) && !empty($tags)) {
    $tagstring = implode(' ', $tags);
  }
  
  // Do sync or async uploading depending on options
  if ($async = variable_get('flickr_upload_async', 0)) {
    $result = $flickr->async_upload($path, $title, $description, $tagstring, variable_get('flickr_upload_public', 1), 0, 0);    
    // We asume success if no error code. The upload may still be going though
    $success = $flickr->getErrorCode() ? FALSE : TRUE;
  } else {
    $result = $flickr->sync_upload($path, $title, $description, $tagstring, variable_get('flickr_upload_public', 1), 0, 0);
    $success = $result;
  }
  // Log whatever has happened
  $variables = array(
    '%image-path' => $path,
    '%tagstring' => $tagstring,
    '%upload-mode' => ($async ? t('Asynchronous') : t('Synchronous')),
  );

  if ($success) { // Success
    watchdog('flickr upload', t('Flickr successful (%upload-mode) Upload for image %image-path with tags %tagstring', $variables));
    if (!$async && variable_get('flickr_upload_delete', 0)) {
      file_delete($path);
    }
  } else { // Failure
    $variables += array(
    '!error-code' => $flickr->getErrorCode(),
    '!error-message' => $flickr->getErrorMsg(),    
    );
    watchdog('flickr upload', t('Flickr (%upload-mode) Upload error (!error-code - !error-message) for image %image_path with tags %tagstring', $variables), WATCHDOG_ERROR);
  }
  return $success;
}

/**
 * Clean up a string value provided by a module, resulting in a
 * string containing only alphanumerics and separators
 * 
 * Code from pathauto_cleanstring() function, uses pathauto variables
 */ 
function flickrup_cleanstring($string) {
  // Default words to ignore
  $ignore_words = array(
    "a", "an", "as", "at", "before", "but", "by", "for", "from",
    "is", "in", "into", "like", "of", "off", "on", "onto", "per",
    "since", "than", "the", "this", "that", "to", "up", "via",
    "with"
  );

  static $i18n_loaded = false;
  static $translations = array();
  if (!$i18n_loaded) {
    $path = drupal_get_path('module', 'pathauto');
    if (is_file($path. '/i18n-ascii.txt')) {
      $translations = parse_ini_file($path. '/i18n-ascii.txt');
    }
    $i18n_loaded = true;
  }

  $output = strtr($output, $translations);

  // Replace or drop apostrophes based on user settings
  $separator = variable_get('pathauto_separator', '-');
  $quotes = variable_get('pathauto_quotes', 0);
  $output = str_replace("'", ($quotes ? $separator : ''), $string);
  
  // Convert accented characters to their ASCII counterparts...
/*  $output = strtr(utf8_decode($output),
       "\xA1\xAA\xBA\xBF".
       "\xC0\xC1\xC2\xC3\xC5\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF".
       "\xD0\xD1\xD2\xD3\xD4\xD5\xD8\xD9\xDA\xDB\xDD".
       "\xE0\xE1\xE2\xE3\xE5\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF".
       "\xF0\xF1\xF2\xF3\xF4\xF5\xF8\xF9\xFA\xFB\xFD\xFF",
       "!ao?AAAAACEEEEIIIIDNOOOOOUUUYaaaaaceeeeiiiidnooooouuuyy");
  // ...and ligatures too
  $output = utf8_encode(strtr($output, array("\xC4"=>"Ae", "\xC6"=>"AE", "\xD6"=>"Oe",
    "\xDC"=>"Ue", "\xDE"=>"TH", "\xDF"=>"ss", "\xE4"=>"ae", "\xE6"=>"ae",
    "\xF6"=>"oe", "\xFC"=>"ue", "\xFE"=>"th")));*/
  $output = strtr($output, $translations);

  // Get rid of words that are on the ignore list
  $ignore_re = "\b". preg_replace("/,/", "\b|\b", variable_get('pathauto_ignore_words', $ignore_words)) ."\b";
  $output = preg_replace("/$ignore_re/ie", "", $output);

  // Preserve alphanumerics, everything else becomes a separator
  $pattern = '/[^a-zA-Z0-9]+/ ';
  $output = preg_replace($pattern, $separator, $output);

  // Trim any leading or trailing separators (note the need to
  // escape the separator if and only if it is not alphanumeric)
  if ($separator) {
    if (ctype_alnum($separator)) {
      $seppattern = $separator;
    } 
    else {
      $seppattern = '\\'.$separator;
    }
    $output = preg_replace("/^$seppattern+|$seppattern+$/", "", $output);
  }

  // Enforce the maximum component length
  $maxlength = min(variable_get('pathauto_max_component_length', 100), 128);
  $output = drupal_substr($output, 0, $maxlength);

  return $output;
}

/**
 * Implementation of hook_widget_info().
 */
function flickrup_widget_info() {
  return array(
    'flickrup' => array(
      'label' => 'Flickr Upload',
      'field types' => array('flickrfield'),
    ),
  );
}

/**
 * Implementation of hook_widget().
 */
function flickrup_widget($op, &$node, $field, &$items) {
  static $submitted; // Work around for 'process form values' being called twice.

  switch ($op) {
    case 'prepare form values':
      _flickrup_prepare($node, $field, $items);
      break;
    case 'form':
      return _flickup_widget_form($node, $field, $items);
    case 'validate':
      break;
    case 'submit':
      $submitted = TRUE; // Work around for 'process form values' being called twice.
      break;
    case 'process form values':
      if ($submitted) {
        _flickrup_process($node, $field, $items);
      }
      break;
  }
}

/**
 * Implementation of hook_widget_settings().
 */
function flickrup_widget_settings($op, $widget) {
  switch ($op) {
    case 'form':
      $form['tags'] = array(
        '#type' => 'textfield',
        '#title' => t('Tags'),
        '#description' => t('These tags will be assigned to photos uploaded using this field. Separate by spaces. This will only apply to future uploads.'),
        '#size' => 40,
        '#maxlength' => 255,
        '#default_value' => $widget['tags'],
      );
      return $form;
    case 'save':
      return array('tags');
  }
}

function _flickup_widget_form($node, $field, $items) {
  require_once(drupal_get_path('module', 'flickr') .'/flickr.inc');
  $form['flickrup'] = array(
    '#type' => 'fieldset',
    '#title' => t('Flickr upload'),
    '#collapsible' => TRUE,
    '#description' => t('Changes are not permanent until you save this post. Maximum dimensions are %dimensions and the maximum size is %size kB.', array('%dimensions' => variable_get('flickr_picture_dimensions', '800x600'), '%size' => variable_get('flickr_picture_file_size', '1000')))
  );
  
  $form['flickrup']['fieldname'] = array(
    '#type' => 'hidden',
    '#value' => $field['field_name'],
    '#name' => 'flickrup-fieldname',
    '#id' => 'flickrup-fieldname',
  );
  
  // Wrapper for fieldset contents (used by upload JS).
  $form['flickrup']['wrapper'] = array(
    '#prefix' => '<div id="flickrup-wrapper">',
    '#suffix' => '</div>',
  );
  
  $form['flickrup']['wrapper'] += _flickrup_form($node, $field, $items);
  
  return $form;
}

function _flickrup_form($node, $field = NULL, $items = array()) {
  $form['#theme'] = 'flickrup_form_new';

  if (count($items)) {
    $form[$field['field_name']]['#theme'] = 'flickrup_form_current';
    $form[$field['field_name']]['#tree'] = TRUE;
    foreach ($items as $key => $item) {
      $preview = $title = '';
      if ($item['type'] == 'photo_id') {
        // Remove photos that weren't found on flickr
        if (!$photo = flickr_photo_get_info($item['id'])) {
          unset($items[$key]);
          break;
        }
        $item['title'] = $photo['title']['_content'];
        $item['preview'] = flickr_img($photo, 's');
        $form[$field['field_name']][$key]['flickr_photo'] = array('#type' => 'value', '#value' => $photo);
        $form[$field['field_name']][$key]['id'] = array('#type' => 'value', '#value' => $item['id']);
      }
      elseif (is_object($item['file'])) {
        $item['title'] = basename($item['file']->filename);
        $item['preview'] = theme('image', $item['file']->filepath, '', '', array('height' => 75, 'width' => 75), FALSE);
        $form[$field['field_name']][$key]['file'] = array('#type' => 'value', '#value' => $item['file']);
        
      }
      $form[$field['field_name']][$key]['type'] = array('#type' => 'value', '#value' => 'photo_id');
      $form[$field['field_name']][$key]['nsid'] = array('#type' => 'value', '#value' => variable_get('flickr_default_userid', ''));
      $form[$field['field_name']][$key]['preview'] = array(
        '#type' => 'item',
        '#value' => $item['preview'],
      );
      $form[$field['field_name']][$key]['remove'] = array(
        '#type' => 'checkbox',
        '#default_value' => $item['remove'],
      );
      
      $form[$field['field_name']][$key]['title'] = array(
        '#type' => 'textfield',
        '#description' => t('Link to flickr photo?'),
        '#size' => 40,
        '#maxlength' => 255,
        '#default_value' => $item['title'],
      );
    }
  }
  
  $form['new'] = array(
    '#prefix' => '<div id="flickrup-hide">',
    '#suffix' => '</div>',
  );
  $form['new']['flickrfile'] = array(
    '#title' => t('Upload new image'),
    '#type' => 'file', 
    '#size' => 48, 
  );
  $form['new']['flickrup'] = array(
    '#type' => 'button', 
    '#value' => t('Upload'),
    '#name' => 'flickrup',
    '#id' => 'flickrup-button',
  );
  
  $form['flickrup-url'] = array('#type' => 'hidden', '#value' => url('flickrup/js', NULL, NULL, TRUE), '#attributes' => array('class' => 'upload'));
  
  $form['current']['vid'] = array('#type' => 'hidden', '#value' => $node->vid);
  
  return $form;
}

/**
 * Theme the attachment form.
 * Note: required to output prefix/suffix.
 */
function theme_flickrup_form_new($form) {
  $output = drupal_render($form);
  return $output;
}

/**
 * Theme current photos.
 */
function theme_flickrup_form_current($form) {
  $header = array(t('Preview'), t('Remove'), t('Title'));
  
  foreach (element_children($form) as $key) {
    $row = array();
    $row[] = drupal_render($form[$key]['preview']);
    $row[] = drupal_render($form[$key]['remove']);
    $row[] = drupal_render($form[$key]['title']);
    $rows[] = $row;
  }
  $output = theme('table', $header, $rows);
  $output .= drupal_render($form);
  return $output;
}

/**
 * Save new uploads and attach them to the node object.
 * append flickrup_previews to the node object as well.
 */
function _flickrup_prepare(&$node, $field, &$items) {
  $fieldname = $field['field_name'];
  // Clear session variable and files that were leftover from previous uploading session
  if(count($_POST) == 0) {
    if (is_array($_SESSION['flickrup_previews']) && count($_SESSION['flickrup_previews'])) {
      foreach ($_SESSION['flickrup_previews'] as $file) {
        file_delete($file->filepath);
      }
      unset($_SESSION['flickrup_previews']);
    }
  }
  
  if (($file = file_check_upload('flickrfile')) && user_access('upload photos to all nodes')) {
    $key = 'flickrup_'. count($_SESSION['flickrup_previews']);
    $file->fid = $key;
    flickrup_validate_picture($file, 'flickrfile');
    $_SESSION['flickrup_previews'][$key] = $file;
  }
  
  // Attach previews to node
  if (is_array($_SESSION['flickrup_previews']) && count($_SESSION['flickrup_previews'])) {
    foreach ($_SESSION['flickrup_previews'] as $fid => $file) {
      $node->{$fieldname}[$fid] = $file;
      $items[]['file'] = $file;
    }
  }
}

function _flickrup_process(&$node, $field, &$items) {
  $fieldname = $field['field_name'];

  foreach ($items as $delta => $item) {
    
    // Remove empty items
    if ($item['remove'] || (!$item['id'] && !is_object($item['file']))) {
      if (variable_get('flickrup_remove', '')) {
        $flickr = flickrup_flickrapi();
        $flickr->photos_delete($item['id']);
      }
      unset($items[$delta]);
    }
    
    // Process new files
    if (is_object($item['file'])) {
      // Tags
      $global_tags = explode(' ', variable_get('flickr_global_tag', ''));
      $field_tags = explode(' ', $field['widget']['tags']);
      $tags = array_merge($global_tags, $field_tags);
      $result = flickrup_upload($item['file']->filepath, $item['title'], $tags);
      $items[$delta]['id'] = $result;
    }
    else {
      if ($item['title'] != $item['flickr_photo']['title']['_content']) {
        $flickr = flickrup_flickrapi();
        $flickr->photos_setMeta($item['id'], $item['title'], $item['flickr_photo']['description']['_content']);
      }
    }
  }
}

function flickrup_js() {
  $node = $_POST;
  $field = content_fields($node['flickrup-fieldname']);
  $fieldname = $field['field_name'];
  $node = (object)$node;
  
  // Load node to get existing photos
  $node = node_load(array('vid' => $node->vid));

  $items = $node->$fieldname;
  _flickrup_prepare($node, $field, $items);
  
  $form = _flickrup_form($node, $field, $items);
  $form = form_builder('flickrup_js', $form);
  $output .= theme('status_messages') . drupal_render($form);
  print drupal_to_js(array('status' => TRUE, 'data' => $output));
  exit;
}

function flickrup_flickrapi() {
  static $flickr;
  require_once drupal_get_path('module', 'flickrup').'/phpFlickr/phpFlickr.php';

  if (!$flickr) {
    $flickr = new phpFlickr(trim(variable_get('flickr_api_key', '')), trim(variable_get('flickr_api_secret', '')));
    $flickr->setToken(trim(variable_get('flickr_api_token', '')));
  }
  
  return $flickr;
}