imce_watermark.module in IMCE Watermark 6.2

Adding watermar for IMCE uploaded images.

File

imce_watermark.module

<?php

/**
 * @file 
 * 
 * Adding watermar for IMCE uploaded images.
 * 
 */

/**
 * Implementation of hook_perm().
 */
function imce_watermark_perm() {
  return array(
    'imce watermark control',
  );
}

/**
 * Implementation of hook_menu().
 */
function imce_watermark_menu() {
  $items['admin/settings/imce/imce'] = array(
    'title' => 'IMCE',
    'type' => MENU_DEFAULT_LOCAL_TASK,
  );
  $items['admin/settings/imce/imce_watermark'] = array(
    'title' => 'Imce watermark settings',
    'description' => 'Control how to apply watermark.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'imce_watermark_settings',
    ),
    'access arguments' => array(
      'administer site configuration',
    ),
    'type' => MENU_LOCAL_TASK,
  );
  return $items;
}

/**
 * imce_watermark settings form.
 */
function imce_watermark_settings() {
  drupal_add_js('
$(document).ready(function() {
  $("select#edit-imce-watermark-imagecache-preset").change(function() {
    if ($(this).val() == "-2") {
      if ($("#edit-imce-watermark-custom").is(".collapsed")) {
        $("#edit-imce-watermark-custom").removeClass("collapsed");
      }
    }
    else {
      if (!$("#edit-imce-watermark-custom").is(".collapsed")) {
        $("#edit-imce-watermark-custom").addClass("collapsed");
      }
    }
  }).trigger("change");
});', 'inline');
  $presets[-1] = ' - ' . t('Watermark disabled') . ' - ';
  $presets[-2] = ' - ' . t('Manual script watermark') . ' - ';
  if (module_exists('imagecache_canvasactions')) {
    $presets[t('Imagecache presets')] = array();
    $all_presets = imagecache_presets();
    foreach ($all_presets as $preset) {
      if (isset($preset['actions'])) {
        foreach ($preset['actions'] as $action) {
          if ($action['action'] == 'canvasactions_file2canvas') {
            $presets[t('Imagecache presets')][$preset['presetname']] = $preset['presetname'];
            break;
          }
        }
      }
    }
  }
  $form['imce_watermark_imagecache_preset'] = array(
    '#type' => 'select',
    '#title' => t('Imagecache watermark action'),
    '#options' => $presets,
    '#required' => TRUE,
    '#description' => t('Set "Watermark disabled" for turning off watermark on IMCE.<br/>
      Select "Manual script watermark" for adding watermark with custom script (warning: it\'s slow).<br/>
      Select imagecache preset names, that have effect "Overlay (watermark)" for using imagecache_canvasactions module.'),
    '#default_value' => variable_get('imce_watermark_imagecache_preset', -1),
  );
  $form['imce_watermark_custom'] = array(
    '#type' => 'fieldset',
    '#title' => t('Manual script watermark settings'),
    '#collapsed' => variable_get('imce_watermark_imagecache_preset', -1) == -2 ? FALSE : TRUE,
    '#collapsible' => TRUE,
    '#attributes' => array(
      'id' => 'edit-imce-watermark-custom',
    ),
  );
  $watermark_filepath = db_result(db_query('
    SELECT filepath FROM {files} WHERE fid = %d', variable_get('imce_watermark_file', 0)));
  $form['imce_watermark_custom']['filepath'] = array(
    '#type' => 'item',
    '#title' => t('Current selected image'),
    '#value' => theme('image', $watermark_filepath, t('Watermark image')) . '<br/>' . $watermark_filepath,
  );
  $form['imce_watermark_custom']['file'] = array(
    '#type' => 'file',
    '#title' => !$watermark_filepath ? t('Watermark image') : t('Choose file to change image'),
    '#size' => 50,
  );
  $form['imce_watermark_custom']['imce_watermark_horizontal_position'] = array(
    '#type' => 'select',
    '#title' => t('Horizontal position of watermark'),
    '#options' => array(
      0 => t('left'),
      1 => t('middle'),
      2 => t('right'),
    ),
    '#default_value' => variable_get('imce_watermark_horizontal_position', 0),
  );
  $form['imce_watermark_custom']['imce_watermark_vertical_position'] = array(
    '#type' => 'select',
    '#title' => t('Vertical position of watermark'),
    '#options' => array(
      0 => t('top'),
      1 => t('center'),
      2 => t('bottom'),
    ),
    '#default_value' => variable_get('imce_watermark_vertical_position', 0),
  );
  $form['imce_watermark_custom']['imce_watermark_horizontal_margin'] = array(
    '#type' => 'textfield',
    '#title' => t('Horizontal margin, px'),
    '#default_value' => variable_get('imce_watermark_horizontal_margin', 0),
    '#description' => t('Set minus or plus signed value for moving watermark to left or right from defined position.'),
  );
  $form['imce_watermark_custom']['imce_watermark_vertical_margin'] = array(
    '#type' => 'textfield',
    '#title' => t('Vertical margin, px'),
    '#default_value' => variable_get('imce_watermark_vertical_margin', 0),
    '#description' => t('Set minus or plus signed value for moving watermark to higher or lower from defined position.'),
  );
  $form['imce_watermark_custom']['imce_watermark_alpha'] = array(
    '#type' => 'textfield',
    '#title' => t('Alpha level value'),
    '#default_value' => variable_get('imce_watermark_alpha', 90),
  );
  $form['#attributes']['enctype'] = 'multipart/form-data';
  $form['#submit'][] = 'imce_watermark_settings_submit';
  return system_settings_form($form);
}

/**
 * Submit watermark settings.
 */
function imce_watermark_settings_submit($form, &$form_state) {
  if ($form_state['values']['imce_watermark_imagecache_preset'] == -2) {
    $file = file_save_upload('file', array(), file_directory_path());
    if ($file) {
      variable_set('imce_watermark_file', $file->fid);
      file_set_status($file, FILE_STATUS_PERMANENT);
    }
    else {
      $watermark_filepath = db_result(db_query('
        SELECT filepath FROM {files} WHERE fid = %d', variable_get('imce_watermark_file', 0)));
      if (!$watermark_filepath) {
        drupal_set_message(t('Please upload file for "Manual script watermark settings".'), 'error');
      }
    }
  }
}

/**
 * Implementation of hook_form_alter().
 * @param array $form
 * @param array $form_state
 * @param string $form_id 
 */
function imce_watermark_form_alter(&$form, $form_state, $form_id) {
  if ($form_id == 'imce_upload_form' && variable_get('imce_watermark_imagecache_preset', -1) != -1) {
    if (user_access('imce watermark control')) {
      $form['fset_upload']['upload']['#weight'] = 10;
      $form['fset_upload']['thumbnails']['#weight'] = 5;
      $form['fset_upload']['watermark'] = array(
        '#type' => 'checkbox',
        '#title' => t('Watermark'),
        '#default_value' => TRUE,
      );
    }
    else {
      $form['watermark'] = array(
        '#type' => 'value',
        '#value' => TRUE,
      );
    }
    $form['fset_upload']['upload']['#submit'][] = 'imce_watermark_upload_submit';
  }
}

/**
 * Adding watermark with using imagecache_canvasactions
 * @param array $form
 * @param array $form_state
 */
function imce_watermark_upload_submit($form, &$form_state) {
  if (!$form_state['values']['watermark']) {
    return;
  }
  $presetname = variable_get('imce_watermark_imagecache_preset', -1);
  if ($presetname == -1) {
    return;
  }
  $imce =& $form['#parameters'][2]['imce'];
  $dirpath = file_directory_path() . ($imce['dir'] == '.' ? '' : '/' . $imce['dir']);
  if (!isset($imce['added']['0']['name'])) {
    return;
  }
  $filename = $imce['added']['0']['name'];
  if ($presetname == -2) {

    // Custom script watermarking
    $watermark_filepath = db_result(db_query('
      SELECT filepath FROM {files} WHERE fid = %d', variable_get('imce_watermark_file', 0)));
    if (!$watermark_filepath || !file_exists($watermark_filepath)) {
      return;
    }
    $watermark = new _imce_watermark();
    $img = imagecreatefromjpeg($dirpath . '/' . $filename);
    $watermark_img = imagecreatefrompng($watermark_filepath);
    $im = $watermark
      ->create_watermark($img, $watermark_img, variable_get('imce_watermark_alpha', 90));
    imagejpeg($im, $dirpath . '/' . $filename);
  }
  else {

    // Watermarking by imagecache actions
    $preset = imagecache_preset_by_name($presetname);
    if (!$preset) {
      return;
    }
    $src = $dirpath . '/' . $filename;
    imagecache_build_derivative($preset['actions'], $src, $src);
  }
}

/*
 * This class taken from: http://www.devshed.com/c/a/PHP/Dynamic-Watermarking-with-PHP/
 */
class _imce_watermark {

  # given two images, return a blended watermarked image
  function create_watermark($main_img_obj, $watermark_img_obj, $alpha_level = 100) {
    $alpha_level /= 100;

    # convert 0-100 (%) alpha to decimal

    # calculate our images dimensions
    $main_img_obj_w = imagesx($main_img_obj);
    $main_img_obj_h = imagesy($main_img_obj);
    $watermark_img_obj_w = imagesx($watermark_img_obj);
    $watermark_img_obj_h = imagesy($watermark_img_obj);
    $vm = variable_get('imce_watermark_vertical_margin', 0);
    $hm = variable_get('imce_watermark_horizontal_margin', 0);
    switch (variable_get('imce_watermark_horizontal_position', 0)) {
      case 0:
        $main_img_obj_min_x = $hm;
        $main_img_obj_max_x = $watermark_img_obj_w + $hm;
        break;
      case 1:

        # determine center position coordinates
        $main_img_obj_min_x = floor($main_img_obj_w / 2 - $watermark_img_obj_w / 2) + $hm;
        $main_img_obj_max_x = ceil($main_img_obj_w / 2 + $watermark_img_obj_w / 2) + $hm;
        break;
      case 2:
        $main_img_obj_min_x = $main_img_obj_w - $watermark_img_obj_w + $hm;
        $main_img_obj_max_x = $main_img_obj_w + $hm;
        break;
    }
    switch (variable_get('imce_watermark_vertical_position', 0)) {
      case 0:
        $main_img_obj_min_y = $vm;
        $main_img_obj_max_y = $watermark_img_obj_h + $hm;
        break;
      case 1:
        $main_img_obj_min_y = floor($main_img_obj_h / 2 - $watermark_img_obj_h / 2) + $hm;
        $main_img_obj_max_y = ceil($main_img_obj_h / 2 + $watermark_img_obj_h / 2) + $hm;
        break;
      case 2:
        $main_img_obj_min_y = $main_img_obj_h - $watermark_img_obj_h + $vm;
        $main_img_obj_max_y = $main_img_obj_h + $hm;
        break;
    }

    # create new image to hold merged changes
    $return_img = imagecreatetruecolor($main_img_obj_w, $main_img_obj_h);

    # walk through main image
    for ($y = 0; $y < $main_img_obj_h; $y++) {
      for ($x = 0; $x < $main_img_obj_w; $x++) {
        $return_color = NULL;

        # determine the correct pixel location within our watermark
        $watermark_x = $x - $main_img_obj_min_x;
        $watermark_y = $y - $main_img_obj_min_y;

        # fetch color information for both of our images
        $main_rgb = imagecolorsforindex($main_img_obj, imagecolorat($main_img_obj, $x, $y));

        # if our watermark has a non-transparent value at this pixel intersection

        # and we're still within the bounds of the watermark image
        if ($watermark_x >= 0 && $watermark_x < $watermark_img_obj_w && $watermark_y >= 0 && $watermark_y < $watermark_img_obj_h) {
          $watermark_rbg = imagecolorsforindex($watermark_img_obj, imagecolorat($watermark_img_obj, $watermark_x, $watermark_y));

          # using image alpha, and user specified alpha, calculate average
          $watermark_alpha = round((127 - $watermark_rbg['alpha']) / 127, 2);
          $watermark_alpha = $watermark_alpha * $alpha_level;

          # calculate the color 'average' between the two - taking into account the specified alpha level
          $avg_red = $this
            ->_get_ave_color($main_rgb['red'], $watermark_rbg['red'], $watermark_alpha);
          $avg_green = $this
            ->_get_ave_color($main_rgb['green'], $watermark_rbg['green'], $watermark_alpha);
          $avg_blue = $this
            ->_get_ave_color($main_rgb['blue'], $watermark_rbg['blue'], $watermark_alpha);

          # calculate a color index value using the average RGB values we've determined
          $return_color = $this
            ->_get_image_color($return_img, $avg_red, $avg_green, $avg_blue);

          # if we're not dealing with an average color here, then let's just copy over the main color
        }
        else {
          $return_color = imagecolorat($main_img_obj, $x, $y);
        }

        # END if watermark

        # draw the appropriate color onto the return image
        imagesetpixel($return_img, $x, $y, $return_color);
      }

      # END for each X pixel
    }

    # END for each Y pixel

    # return the resulting, watermarked image for display
    return $return_img;
  }

  # END create_watermark()

  # average two colors given an alpha
  function _get_ave_color($color_a, $color_b, $alpha_level) {
    return round($color_a * (1 - $alpha_level) + $color_b * $alpha_level);
  }

  # END _get_ave_color()

  # return closest pallette-color match for RGB values
  function _get_image_color($im, $r, $g, $b) {
    $c = imagecolorexact($im, $r, $g, $b);
    if ($c != -1) {
      return $c;
    }
    $c = imagecolorallocate($im, $r, $g, $b);
    if ($c != -1) {
      return $c;
    }
    return imagecolorclosest($im, $r, $g, $b);
  }

}

# END watermark API

Functions

Name	Description
imce_watermark_form_alter	Implementation of hook_form_alter().
imce_watermark_menu	Implementation of hook_menu().
imce_watermark_perm	Implementation of hook_perm().
imce_watermark_settings	imce_watermark settings form.
imce_watermark_settings_submit	Submit watermark settings.
imce_watermark_upload_submit	Adding watermark with using imagecache_canvasactions

Classes

Name	Description
_imce_watermark