diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..dbf1b472 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.DS_Store +tmp +*~ +*.swp diff --git a/client/Java/Demo.class b/client/Java/Demo.class new file mode 100644 index 00000000..ffed26e2 Binary files /dev/null and b/client/Java/Demo.class differ diff --git a/client/Java/Demo.java b/client/Java/Demo.java new file mode 100644 index 00000000..9dee0fcf --- /dev/null +++ b/client/Java/Demo.java @@ -0,0 +1,50 @@ + +import java.util.ArrayList; +import java.util.List; +import java.io.BufferedReader; +import java.io.InputStreamReader; + +import com.google.gson.Gson; + +import org.apache.http.HttpEntity; +import org.apache.http.HttpResponse; +import org.apache.http.NameValuePair; +import org.apache.http.client.entity.UrlEncodedFormEntity; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.cookie.Cookie; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.message.BasicNameValuePair; +import org.apache.http.protocol.HTTP; + +public class Demo { + public static final String BASE_URL = "http://example.com/gallery3/index.php"; + public static final String USERNAME = "admin"; + public static final String PASSWORD = "admin"; + + public static void main(String[] argv) throws java.io.UnsupportedEncodingException, java.io.IOException { + DefaultHttpClient httpclient = new DefaultHttpClient(); + HttpResponse response; + Gson gson = new Gson(); + + // Get the REST API key + HttpPost post = new HttpPost(BASE_URL + "/rest"); + ArrayList nvps = new ArrayList (); + nvps.add(new BasicNameValuePair("user", USERNAME)); + nvps.add(new BasicNameValuePair("password", USERNAME)); + post.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8)); + response = httpclient.execute(post); + String api_key = gson.fromJson(new BufferedReader( + new InputStreamReader(response.getEntity().getContent())).readLine(), String.class); + System.out.println("API Key:" + api_key); + + // Get the JSON representation of the root album, which we know has id 1 + HttpGet get = new HttpGet(BASE_URL + "/rest/item/1"); + get.setHeader("X-Gallery-Request-Method", "GET"); + get.setHeader("X-Gallery-Request-Key", api_key); + response = httpclient.execute(get); + + System.out.println( + "Response: " + new BufferedReader(new InputStreamReader(response.getEntity().getContent())).readLine()); + } +} diff --git a/client/Java/README b/client/Java/README new file mode 100644 index 00000000..2a11795f --- /dev/null +++ b/client/Java/README @@ -0,0 +1,10 @@ +This is very, very rough sample code for how to do some Java REST +requests. To run this code: + +1) Edit Demo.java and set the BASE_URL to your Gallery3 install. +2) Edit USERNAME and PASSWORD as appropriate +3) In a shell, do "sh build.sh" +4) In a shell, do "sh run.sh" + +Note that there is NO error checking, so if something goes wrong +you'll have to debug it. diff --git a/client/Java/build.sh b/client/Java/build.sh new file mode 100644 index 00000000..146932bd --- /dev/null +++ b/client/Java/build.sh @@ -0,0 +1 @@ +javac -classpath lib/httpclient-4.0.1.jar:lib/httpcore-4.0.1.jar:lib/gson-1.4.jar Demo.java diff --git a/client/Java/lib/commons-logging-api-1.1.1.jar b/client/Java/lib/commons-logging-api-1.1.1.jar new file mode 100644 index 00000000..bd451168 Binary files /dev/null and b/client/Java/lib/commons-logging-api-1.1.1.jar differ diff --git a/client/Java/lib/gson-1.4.jar b/client/Java/lib/gson-1.4.jar new file mode 100644 index 00000000..b9c33d03 Binary files /dev/null and b/client/Java/lib/gson-1.4.jar differ diff --git a/client/Java/lib/httpclient-4.0.1.jar b/client/Java/lib/httpclient-4.0.1.jar new file mode 100644 index 00000000..e9c961f1 Binary files /dev/null and b/client/Java/lib/httpclient-4.0.1.jar differ diff --git a/client/Java/lib/httpcore-4.0.1.jar b/client/Java/lib/httpcore-4.0.1.jar new file mode 100644 index 00000000..4638daa5 Binary files /dev/null and b/client/Java/lib/httpcore-4.0.1.jar differ diff --git a/client/Java/run.sh b/client/Java/run.sh new file mode 100644 index 00000000..94ccb6e6 --- /dev/null +++ b/client/Java/run.sh @@ -0,0 +1 @@ +java -classpath lib/httpclient-4.0.1.jar:lib/httpcore-4.0.1.jar:lib/commons-logging-api-1.1.1.jar:lib/gson-1.4.jar:. Demo diff --git a/client/PHP/Gallery3.php b/client/PHP/Gallery3.php new file mode 100644 index 00000000..83ed7b2d --- /dev/null +++ b/client/PHP/Gallery3.php @@ -0,0 +1,205 @@ + $user, "password" => $pass)); + return $response; + } + + /** + * Construct a new Gallery3 instance associated with a remote resource + * @param string remote url + * @param string authentication token + * @return object Gallery3 + */ + static function factory($url=null, $token=null) { + $obj = new Gallery3(); + $obj->token = $token; + $obj->url = $url; + if ($url && $token) { + $obj->load(); + } + return $obj; + } + + /** + * Constructor. + */ + public function __construct() { + $this->data = new stdClass(); + $this->token = null; + $this->url = null; + } + + /** + * Set a value on the remote resource's entity. You must call save for it to take effect. + * + * @param string key + * @param string value + * @return object Gallery3 + * @chainable + */ + public function set($key, $value) { + $this->data->entity->$key = $value; + return $this; + } + + /** + * Replace the members for the remote resource + * + * @param array members + * @return object Gallery3 + * @chainable + */ + public function set_members($members) { + $this->data->members = $members; + return $this; + } + + /** + * Attach a file to the remote resource. + * + * @param string path to a local file (eg: /tmp/foo.jpg) + * @return object Gallery3 + */ + public function set_file($file) { + $this->file = $file; + return $this; + } + + /** + * Save any local changes made to this resource. If this is an existing resource, we'll return + * the resource itself. If we're creating a new resource, return the newly created resource. + * + * @return object Gallery3 + */ + public function create($url, $token) { + if (!is_string($url)) { + throw new Gallery3_Exception("Invalid url: " . var_export($url)); + } + + $response = Gallery3_Helper::request( + "post", $url, $token, array("entity" => $this->data->entity), $this->file); + $this->url = $response->url; + $this->token = $token; + return $this->load(); + } + + /** + * Save any local changes made to this resource. If this is an existing resource, we'll return + * the resource itself. If we're creating a new resource, return the newly created resource. + * + * @return object Gallery3 + */ + public function save() { + $data = array(); + $data["entity"] = array_diff((array)$this->data->entity, $this->original_entity); + if (isset($this->data->members)) { + $data["members"] = $this->data->members; + } + if ($this->file) { + $response = Gallery3_Helper::request("put", $this->url, $this->token, $data, $this->file); + } else { + $response = Gallery3_Helper::request("put", $this->url, $this->token, $data); + } + return $this->load(); + } + + /** + * Delete the remote resource. + * + * @return object Gallery3 + */ + public function delete() { + Gallery3_Helper::request("delete", $this->url, $this->token); + $this->data = array(); + $this->url = null; + return $this; + } + + /** + * Reload the resource from a given url. This is useful after the remote resource has been + * modified. + * + * @return object Gallery3 + */ + public function load() { + $response = Gallery3_Helper::request("get", $this->url, $this->token); + $this->data = $response; + $this->original_entity = isset($response->entity) ? (array)$response->entity : null; + return $this; + } +} + +class Gallery3_Helper { + static function request($method, $url, $token=null, $params=array(), $file=null) { + $req = new HTTP_Request($url); + $req->setMethod($method == "get" ? HTTP_REQUEST_METHOD_GET : HTTP_REQUEST_METHOD_POST); + $req->addHeader("X-Gallery-Request-Method", $method); + if ($token) { + $req->addHeader("X-Gallery-Request-Key", $token); + } + foreach ($params as $key => $value) { + $req->addPostData($key, is_string($value) ? $value : json_encode($value)); + } + if ($file) { + $req->addFile("file", $file, mime_content_type($file)); + } + $req->sendRequest(); + + switch ($req->getResponseCode()) { + case 200: + case 201: + return json_decode($req->getResponseBody()); + + case 403: + throw new Gallery3_Forbidden_Exception($req->getResponseBody()); + + default: + throw new Gallery3_Exception($req->getResponseBody()); + } + } +} + +class Gallery3_Exception extends Exception { +} + +class Gallery3_Forbidden_Exception extends Gallery3_Exception { +} \ No newline at end of file diff --git a/client/PHP/example.php b/client/PHP/example.php new file mode 100644 index 00000000..5bfc49a2 --- /dev/null +++ b/client/PHP/example.php @@ -0,0 +1,112 @@ +set("name", "My Tag") + ->create($tags->url, $auth); +alert("Created tag: {$tag->url}"); + +$album = Gallery3::factory() + ->set("type", "album") + ->set("name", "Sample Album") + ->set("title", "This is my Sample Album") + ->create($root->url, $auth); +alert("Created album: {$album->url} {$album->data->entity->title}"); + + +alert("Modify the album"); +$album + ->set("title", "This is the new title") + ->save(); +alert("New title: {$album->data->entity->title}"); + +for ($i = 0; $i < 2; $i++) { + $photo = Gallery3::factory() + ->set("type", "photo") + ->set("name", "Sample Photo.png") + ->set("title", "Sample Photo") + ->set_file("test1.png") + ->create($album->url, $auth); + alert("Uploaded photo: {$photo->url}"); +} +$album->load(); +alert("Album members: " . join(", ", $album->data->members) . ""); + + +alert("Replace the data file"); +$photo->set_file("test2.png") + ->save(); + + +$comment = Gallery3::factory() + ->set("item", $album->data->members[0]) + ->set("type", "comment") + ->set("text", "This is a random comment-- whee!") + ->create($comments->url, $auth); +alert("Comment: {$comment->url}"); + +alert("Reorder the album"); +$album + ->set_members(array($album->data->members[1], $album->data->members[0])) + ->set("sort_column", "weight") + ->save(); +alert("New order: " . join(", ", $album->data->members) . ""); + +alert("Search for the photo"); +$photos = Gallery3::factory($root->url, $auth) + ->set("name", "Sample") + ->load(); +alert("Found: {$photos->data->members[0]}"); + + +alert("Grab a random photo"); +$photos = Gallery3::factory("{$root->url}?random=true", $auth) + ->load(); +alert("Found: {$photos->data->members[0]}"); + + +alert("Tag the album (using the album's relationships: {$album->data->relationships->tags->url})"); +$tag_relationship1 = Gallery3::factory() + ->set("tag", $tag->url) + ->set("item", $root->url) + ->create($album->data->relationships->tags->url, $auth); +alert("Tag: {$tag_relationship1->url}"); + + +alert("Tag the photo (using the tag's relationships: {$tag->data->relationships->items->url})"); +$tag_relationship2 = Gallery3::factory() + ->set("tag", $tag->url) + ->set("item", $photo->url) + ->create($tag->data->relationships->items->url, $auth); +alert("Tag: {$tag_relationship2->url}"); + +alert("Un-tag the photo"); +$tag_relationship2->delete(); +$tag->load(); +alert("1 remaining tag: {$tag->data->relationships->items->members[0]}"); + +alert("Delete the album and tag"); +$album->delete(); +$tag->delete(); + +alert("Done!"); + +function alert($msg) { + print "$msg
\n"; + flush(); +} +?> \ No newline at end of file diff --git a/client/PHP/test1.png b/client/PHP/test1.png new file mode 100644 index 00000000..ca8e0e95 Binary files /dev/null and b/client/PHP/test1.png differ diff --git a/client/PHP/test2.png b/client/PHP/test2.png new file mode 100644 index 00000000..fdc97779 Binary files /dev/null and b/client/PHP/test2.png differ diff --git a/modules/adsense/controllers/admin_adsense.php b/modules/adsense/controllers/admin_adsense.php new file mode 100644 index 00000000..13be83d8 --- /dev/null +++ b/modules/adsense/controllers/admin_adsense.php @@ -0,0 +1,57 @@ +page_title = t("Adsense settings"); + $view->content = new View("admin_adsense.html"); + $view->content->form = $this->_get_admin_form(); + print $view; + } + + public function save() { + access::verify_csrf(); + $form = $this->_get_admin_form(); + if ($form->validate()) { + module::set_var("adsense", "code", $form->adsense->code->value); + module::set_var("adsense", "location", $form->adsense->location->value); + message::success(t("Adsense settings updated")); + url::redirect("admin/adsense"); + } else { + print $form; + } + } + + private function _get_admin_form() { + $form = new Forge("admin/adsense/save", "", "post", array("id" => "g-adsense-admin-form")); + $adsense_settings = $form->group("adsense")->label(t("Adsense settings")); + $adsense_settings->textarea("code")->label(t("Adsense code")) + ->value(module::get_var("adsense", "code")); + $adsense_settings->dropdown("location") + ->label(t("Where should the ads be displayed?")) + ->options(array("header" => t("In the header"), + "sidebar" => t("In the sidebar"), + "footer" => t("In the footer"))) + ->selected(module::get_var("adsense", "location")); + $adsense_settings->submit("save")->value(t("Save")); + return $form; + } +} + diff --git a/modules/adsense/helpers/adsense_block.php b/modules/adsense/helpers/adsense_block.php new file mode 100644 index 00000000..7c00cb45 --- /dev/null +++ b/modules/adsense/helpers/adsense_block.php @@ -0,0 +1,39 @@ + t("Adsense")); + } + + static function get($block_id, $theme) { + $block = ""; + switch ($block_id) { + case "adsense": + if (module::get_var("adsense", "location") == "sidebar") { + $block = new Block(); + $block->css_id = "g-adsense"; + $block->title = t("Adsense"); + $block->content = new View("adsense_block.html"); + } + break; + } + return $block; + } +} \ No newline at end of file diff --git a/modules/adsense/helpers/adsense_event.php b/modules/adsense/helpers/adsense_event.php new file mode 100644 index 00000000..6611ebb1 --- /dev/null +++ b/modules/adsense/helpers/adsense_event.php @@ -0,0 +1,28 @@ +get("settings_menu") + ->append(Menu::factory("link") + ->id("adsense_menu") + ->label(t("Adsense")) + ->url(url::site("admin/adsense"))); + } +} diff --git a/modules/adsense/helpers/adsense_theme.php b/modules/adsense/helpers/adsense_theme.php new file mode 100644 index 00000000..97293992 --- /dev/null +++ b/modules/adsense/helpers/adsense_theme.php @@ -0,0 +1,54 @@ +' . $code . ' + '; + + return $google_code; + } + } + + static function footer($theme) { + if(module::get_var("adsense","location") == "footer") { + $code = module::get_var("adsense", "code"); + if (!$code) { + return; + } + $google_code = ' + + '; + + return $google_code; + } + } +} diff --git a/modules/adsense/module.info b/modules/adsense/module.info new file mode 100644 index 00000000..41cc63b2 --- /dev/null +++ b/modules/adsense/module.info @@ -0,0 +1,3 @@ +name = "Adsense" +description = "Display Google Adsense ads" +version = 1 diff --git a/modules/adsense/views/admin_adsense.html.php b/modules/adsense/views/admin_adsense.html.php new file mode 100644 index 00000000..f994fae5 --- /dev/null +++ b/modules/adsense/views/admin_adsense.html.php @@ -0,0 +1,7 @@ + +
+

+
+ +
+
diff --git a/modules/adsense/views/adsense_block.html.php b/modules/adsense/views/adsense_block.html.php new file mode 100644 index 00000000..53f8b20a --- /dev/null +++ b/modules/adsense/views/adsense_block.html.php @@ -0,0 +1,17 @@ +' . $code . ' + '; + + echo $google_code; +} +?> + diff --git a/modules/atom/libraries/Atom_Entry.php b/modules/atom/libraries/Atom_Entry.php index 70bc6e3a..ceb5738e 100644 --- a/modules/atom/libraries/Atom_Entry.php +++ b/modules/atom/libraries/Atom_Entry.php @@ -36,7 +36,7 @@ class Atom_Entry_Core extends Atom_Base { } public function content($text, $type="html") { - $content = $this->dom->createElement("content", html::specialchars($text)); + $content = $this->dom->createElement("content", html::chars($text)); $content->setAttribute("type", $type); $this->element->appendChild($content); return $this; diff --git a/modules/atom/libraries/Gallery_Atom_Entry.php b/modules/atom/libraries/Gallery_Atom_Entry.php index ee5abd07..ab6e655c 100644 --- a/modules/atom/libraries/Gallery_Atom_Entry.php +++ b/modules/atom/libraries/Gallery_Atom_Entry.php @@ -27,7 +27,7 @@ class Gallery_Atom_Entry_Core extends Atom_Entry { parent::__construct("entry"); /* Set feed ID and self link. */ - $this->id(html::specialchars(url::abs_current())); + $this->id(html::chars(url::abs_current())); $this->link() ->rel("self") ->href(url::abs_current()); diff --git a/modules/atom/libraries/Gallery_Atom_Feed.php b/modules/atom/libraries/Gallery_Atom_Feed.php index ba44f15a..138421a2 100644 --- a/modules/atom/libraries/Gallery_Atom_Feed.php +++ b/modules/atom/libraries/Gallery_Atom_Feed.php @@ -27,7 +27,7 @@ class Gallery_Atom_Feed_Core extends Atom_Feed { parent::__construct("feed"); /* Set feed ID and self link. */ - $this->id(html::specialchars(url::abs_current())); + $this->id(html::chars(url::abs_current())); $this->link() ->rel("self") ->href(url::abs_current()); diff --git a/modules/autorotate/helpers/autorotate.php b/modules/autorotate/helpers/autorotate.php new file mode 100644 index 00000000..5bfe1afe --- /dev/null +++ b/modules/autorotate/helpers/autorotate.php @@ -0,0 +1,68 @@ +is_photo() && $item->mime_type == "image/jpeg") { + require_once(MODPATH . "exif/lib/exif.php"); + $exif_raw = read_exif_data_raw($item->file_path(), false); + if (isset($exif_raw['ValidEXIFData'])) { + $orientation = $exif_raw["IFD0"]["Orientation"]; + $degrees = 0; + if ($orientation == '3: Upside-down') { + $degrees = 180; + } + else if ($orientation == '8: 90 deg CW') { + $degrees = -90; + } + else if ($orientation == '6: 90 deg CCW') { + $degrees = 90; + } + if($degrees) { + $tmpfile = tempnam(TMPPATH, "rotate"); + gallery_graphics::rotate($item->file_path(), $tmpfile, array("degrees" => $degrees)); + // Update EXIF info + $data = new PelDataWindow(file_get_contents($tmpfile)); + if (PelJpeg::isValid($data)) { + $jpeg = $file = new PelJpeg(); + $jpeg->load($data); + $exif = $jpeg->getExif(); + if($exif !== null) { + $tiff = $exif->getTiff(); + $ifd0 = $tiff->getIfd(); + $orientation = $ifd0->getEntry(PelTag::ORIENTATION); + $orientation->setValue(1); + file_put_contents($tmpfile, $file->getBytes()); + } + } + $item->set_data_file($tmpfile); + $item->save(); + unlink($tmpfile); + } + } + } + return; + } +} \ No newline at end of file diff --git a/modules/autorotate/helpers/autorotate_event.php b/modules/autorotate/helpers/autorotate_event.php new file mode 100644 index 00000000..f8307215 --- /dev/null +++ b/modules/autorotate/helpers/autorotate_event.php @@ -0,0 +1,32 @@ +getMessage() . "\n" . $e->getTraceAsString()); + } + } +} \ No newline at end of file diff --git a/modules/autorotate/helpers/autorotate_installer.php b/modules/autorotate/helpers/autorotate_installer.php new file mode 100644 index 00000000..8ae94fda --- /dev/null +++ b/modules/autorotate/helpers/autorotate_installer.php @@ -0,0 +1,42 @@ + + * @version $Revision: 463 $ + * @date $Date: 2006-11-18 23:25:24 +0100 (Sat, 18 Nov 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + + +/* Initialize Gettext, if available. This must be done before any + * part of PEL calls Pel::tra() or Pel::fmt() --- this is ensured if + * every piece of code using those two functions require() this file. + * + * If Gettext is not available, wrapper functions will be created, + * allowing PEL to function, but without any translations. + * + * The PEL translations are stored in './locale'. It is important to + * use an absolute path here because the lookups will be relative to + * the current directory. */ + +if (function_exists('dgettext')) { + bindtextdomain('pel', dirname(__FILE__) . '/locale'); +} else { + + /** + * Pretend to lookup a message in a specific domain. + * + * This is just a stub which will return the original message + * untranslated. The function will only be defined if the Gettext + * extension has not already defined it. + * + * @param string $domain the domain. + * + * @param string $str the message to be translated. + * + * @return string the original, untranslated message. + */ + function dgettext($domain, $str) { + return $str; + } +} + + +/** + * Class with miscellaneous static methods. + * + * This class will contain various methods that govern the overall + * behavior of PEL. + * + * Debugging output from PEL can be turned on and off by assigning + * true or false to {@link Pel::$debug}. + * + * @author Martin Geisler + * @package PEL + */ +class Pel { + + /** + * Flag for controlling debug information. + * + * The methods producing debug information ({@link debug()} and + * {@link warning()}) will only output something if this variable is + * set to true. + * + * @var boolean + */ + private static $debug = false; + + /** + * Flag for strictness of parsing. + * + * If this variable is set to true, then most errors while loading + * images will result in exceptions being thrown. Otherwise a + * warning will be emitted (using {@link Pel::warning}) and the + * exceptions will be appended to {@link Pel::$exceptions}. + * + * Some errors will still be fatal and result in thrown exceptions, + * but an effort will be made to skip over as much garbage as + * possible. + * + * @var boolean + */ + private static $strict = false; + + /** + * Stored exceptions. + * + * When {@link Pel::$strict} is set to false exceptions will be + * accumulated here instead of being thrown. + */ + private static $exceptions = array(); + + + /** + * Return list of stored exceptions. + * + * When PEL is parsing in non-strict mode, it will store most + * exceptions instead of throwing them. Use this method to get hold + * of them when a call returns. + * + * Code for using this could look like this: + * + * + * Pel::setStrictParsing(true); + * Pel::clearExceptions(); + * + * $jpeg = new PelJpeg($file); + * + * // Check for exceptions. + * foreach (Pel::getExceptions() as $e) { + * printf("Exception: %s\n", $e->getMessage()); + * if ($e instanceof PelEntryException) { + * // Warn about entries that couldn't be loaded. + * printf("Warning: Problem with %s.\n", + * PelTag::getName($e->getType(), $e->getTag())); + * } + * } + * + * + * This gives applications total control over the amount of error + * messages shown and (hopefully) provides the necessary information + * for proper error recovery. + * + * @return array the exceptions. + */ + static function getExceptions() { + return self::$exceptions; + } + + + /** + * Clear list of stored exceptions. + * + * Use this function before a call to some method if you intend to + * check for exceptions afterwards. + */ + static function clearExceptions() { + self::$exceptions = array(); + } + + + /** + * Conditionally throw an exception. + * + * This method will throw the passed exception when strict parsing + * in effect (see {@link setStrictParsing()}). Otherwise the + * exception is stored (it can be accessed with {@link + * getExceptions()}) and a warning is issued (with {@link + * Pel::warning}). + * + * @param PelException $e the exceptions. + */ + static function maybeThrow(PelException $e) { + if (self::$strict) { + throw $e; + } else { + self::$exceptions[] = $e; + self::warning('%s (%s:%s)', $e->getMessage(), + basename($e->getFile()), $e->getLine()); + } + } + + + /** + * Enable/disable strict parsing. + * + * If strict parsing is enabled, then most errors while loading + * images will result in exceptions being thrown. Otherwise a + * warning will be emitted (using {@link Pel::warning}) and the + * exceptions will be stored for later use via {@link + * getExceptions()}. + * + * Some errors will still be fatal and result in thrown exceptions, + * but an effort will be made to skip over as much garbage as + * possible. + * + * @param boolean $flag use true to enable strict parsing, false to + * diable. + */ + function setStrictParsing($flag) { + self::$strict = $flag; + } + + + /** + * Get current setting for strict parsing. + * + * @return boolean true if strict parsing is in effect, false + * otherwise. + */ + function getStrictParsing() { + return self::$strict; + } + + + /** + * Enable/disable debugging output. + * + * @param boolean $flag use true to enable debug output, false to + * diable. + */ + function setDebug($flag) { + self::$debug = $flag; + } + + + /** + * Get current setting for debug output. + * + * @return boolean true if debug is enabled, false otherwise. + */ + function getDebug() { + return self::$debug; + } + + + /** + * Conditionally output debug information. + * + * This method works just like printf() except that it always + * terminates the output with a newline, and that it only outputs + * something if the {@link Pel::$debug} is true. + * + * @param string $format the format string. + * + * @param mixed $args,... any number of arguments can be given. The + * arguments will be available for the format string as usual with + * sprintf(). + */ + static function debug() { + if (self::$debug) { + $args = func_get_args(); + $str = array_shift($args); + vprintf($str . "\n", $args); + } + } + + + /** + * Conditionally output a warning. + * + * This method works just like printf() except that it prepends the + * output with the string 'Warning: ', terminates the output with a + * newline, and that it only outputs something if the PEL_DEBUG + * defined to some true value. + * + * @param string $format the format string. + * + * @param mixed $args,... any number of arguments can be given. The + * arguments will be available for the format string as usual with + * sprintf(). + */ + static function warning() { + if (self::$debug) { + $args = func_get_args(); + $str = array_shift($args); + vprintf('Warning: ' . $str . "\n", $args); + } + } + + + /** + * Translate a string. + * + * This static function will use Gettext to translate a string. By + * always using this function for static string one is assured that + * the translation will be taken from the correct text domain. + * Dynamic strings should be passed to {@link fmt} instead. + * + * @param string the string that should be translated. + * + * @return string the translated string, or the original string if + * no translation could be found. + */ + static function tra($str) { + return dgettext('pel', $str); + } + + + /** + * Translate and format a string. + * + * This static function will first use Gettext to translate a format + * string, which will then have access to any extra arguments. By + * always using this function for dynamic string one is assured that + * the translation will be taken from the correct text domain. If + * the string is static, use {@link tra} instead as it will be + * faster. + * + * @param string $format the format string. This will be translated + * before being used as a format string. + * + * @param mixed $args,... any number of arguments can be given. The + * arguments will be available for the format string as usual with + * sprintf(). + * + * @return string the translated string, or the original string if + * no translation could be found. + */ + static function fmt() { + $args = func_get_args(); + $str = array_shift($args); + return vsprintf(dgettext('pel', $str), $args); + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelConvert.php b/modules/autorotate/lib/pel/PelConvert.php new file mode 100644 index 00000000..31c4b2a6 --- /dev/null +++ b/modules/autorotate/lib/pel/PelConvert.php @@ -0,0 +1,397 @@ + + * @version $Revision: 387 $ + * @date $Date: 2005-10-05 13:02:52 +0200 (Wed, 05 Oct 2005) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/** + * Conversion functions to and from bytes and integers. + * + * The functions found in this class are used to convert bytes into + * integers of several sizes ({@link bytesToShort}, {@link + * bytesToLong}, and {@link bytesToRational}) and convert integers of + * several sizes into bytes ({@link shortToBytes} and {@link + * longToBytes}). + * + * All the methods are static and they all rely on an argument that + * specifies the byte order to be used, this must be one of the class + * constants {@link LITTLE_ENDIAN} or {@link BIG_ENDIAN}. These + * constants will be referred to as the pseudo type PelByteOrder + * throughout the documentation. + * + * @author Martin Geisler + * @package PEL + */ +class PelConvert { + + /** + * Little-endian (Intel) byte order. + * + * Data stored in little-endian byte order store the least + * significant byte first, so the number 0x12345678 becomes 0x78 + * 0x56 0x34 0x12 when stored with little-endian byte order. + */ + const LITTLE_ENDIAN = true; + + /** + * Big-endian (Motorola) byte order. + * + * Data stored in big-endian byte order store the most significant + * byte first, so the number 0x12345678 becomes 0x12 0x34 0x56 0x78 + * when stored with big-endian byte order. + */ + const BIG_ENDIAN = false; + + + /** + * Convert an unsigned short into two bytes. + * + * @param int the unsigned short that will be converted. The lower + * two bytes will be extracted regardless of the actual size passed. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + * + * @return string the bytes representing the unsigned short. + */ + static function shortToBytes($value, $endian) { + if ($endian == self::LITTLE_ENDIAN) + return chr($value) . chr($value >> 8); + else + return chr($value >> 8) . chr($value); + } + + + /** + * Convert a signed short into two bytes. + * + * @param int the signed short that will be converted. The lower + * two bytes will be extracted regardless of the actual size passed. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + * + * @return string the bytes representing the signed short. + */ + static function sShortToBytes($value, $endian) { + /* We can just use shortToBytes, since signed shorts fits well + * within the 32 bit signed integers used in PHP. */ + return self::shortToBytes($value, $endian); + } + + + /** + * Convert an unsigned long into four bytes. + * + * Because PHP limits the size of integers to 32 bit signed, one + * cannot really have an unsigned integer in PHP. But integers + * larger than 2^31-1 will be promoted to 64 bit signed floating + * point numbers, and so such large numbers can be handled too. + * + * @param int the unsigned long that will be converted. The + * argument will be treated as an unsigned 32 bit integer and the + * lower four bytes will be extracted. Treating the argument as an + * unsigned integer means that the absolute value will be used. Use + * {@link sLongToBytes} to convert signed integers. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + * + * @return string the bytes representing the unsigned long. + */ + static function longToBytes($value, $endian) { + /* We cannot convert the number to bytes in the normal way (using + * shifts and modulo calculations) because the PHP operator >> and + * function chr() clip their arguments to 2^31-1, which is the + * largest signed integer known to PHP. But luckily base_convert + * handles such big numbers. */ + $hex = str_pad(base_convert($value, 10, 16), 8, '0', STR_PAD_LEFT); + if ($endian == self::LITTLE_ENDIAN) + return (chr(hexdec($hex{6} . $hex{7})) . + chr(hexdec($hex{4} . $hex{5})) . + chr(hexdec($hex{2} . $hex{3})) . + chr(hexdec($hex{0} . $hex{1}))); + else + return (chr(hexdec($hex{0} . $hex{1})) . + chr(hexdec($hex{2} . $hex{3})) . + chr(hexdec($hex{4} . $hex{5})) . + chr(hexdec($hex{6} . $hex{7}))); + } + + + /** + * Convert a signed long into four bytes. + * + * @param int the signed long that will be converted. The argument + * will be treated as a signed 32 bit integer, from which the lower + * four bytes will be extracted. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + * + * @return string the bytes representing the signed long. + */ + static function sLongToBytes($value, $endian) { + /* We can convert the number into bytes in the normal way using + * shifts and modulo calculations here (in contrast with + * longToBytes) because PHP automatically handles 32 bit signed + * integers for us. */ + if ($endian == self::LITTLE_ENDIAN) + return (chr($value) . + chr($value >> 8) . + chr($value >> 16) . + chr($value >> 24)); + else + return (chr($value >> 24) . + chr($value >> 16) . + chr($value >> 8) . + chr($value)); + } + + + /** + * Extract an unsigned byte from a string of bytes. + * + * @param string the bytes. + * + * @param int the offset. The byte found at the offset will be + * returned as an integer. The must be at least one byte available + * at offset. + * + * @return int the unsigned byte found at offset, e.g., an integer + * in the range 0 to 255. + */ + static function bytesToByte($bytes, $offset) { + return ord($bytes{$offset}); + } + + + /** + * Extract a signed byte from bytes. + * + * @param string the bytes. + * + * @param int the offset. The byte found at the offset will be + * returned as an integer. The must be at least one byte available + * at offset. + * + * @return int the signed byte found at offset, e.g., an integer in + * the range -128 to 127. + */ + static function bytesToSByte($bytes, $offset) { + $n = self::bytesToByte($bytes, $offset); + if ($n > 127) + return $n - 256; + else + return $n; + } + + + /** + * Extract an unsigned short from bytes. + * + * @param string the bytes. + * + * @param int the offset. The short found at the offset will be + * returned as an integer. There must be at least two bytes + * available beginning at the offset given. + * + * @return int the unsigned short found at offset, e.g., an integer + * in the range 0 to 65535. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + */ + static function bytesToShort($bytes, $offset, $endian) { + if ($endian == self::LITTLE_ENDIAN) + return (ord($bytes{$offset+1}) * 256 + + ord($bytes{$offset})); + else + return (ord($bytes{$offset}) * 256 + + ord($bytes{$offset+1})); + } + + + /** + * Extract a signed short from bytes. + * + * @param string the bytes. + * + * @param int the offset. The short found at offset will be returned + * as an integer. There must be at least two bytes available + * beginning at the offset given. + * + * @return int the signed byte found at offset, e.g., an integer in + * the range -32768 to 32767. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + */ + static function bytesToSShort($bytes, $offset, $endian) { + $n = self::bytesToShort($bytes, $offset, $endian); + if ($n > 32767) + return $n - 65536; + else + return $n; + } + + + /** + * Extract an unsigned long from bytes. + * + * @param string the bytes. + * + * @param int the offset. The long found at offset will be returned + * as an integer. There must be at least four bytes available + * beginning at the offset given. + * + * @return int the unsigned long found at offset, e.g., an integer + * in the range 0 to 4294967295. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + */ + static function bytesToLong($bytes, $offset, $endian) { + if ($endian == self::LITTLE_ENDIAN) + return (ord($bytes{$offset+3}) * 16777216 + + ord($bytes{$offset+2}) * 65536 + + ord($bytes{$offset+1}) * 256 + + ord($bytes{$offset})); + else + return (ord($bytes{$offset}) * 16777216 + + ord($bytes{$offset+1}) * 65536 + + ord($bytes{$offset+2}) * 256 + + ord($bytes{$offset+3})); + } + + + /** + * Extract a signed long from bytes. + * + * @param string the bytes. + * + * @param int the offset. The long found at offset will be returned + * as an integer. There must be at least four bytes available + * beginning at the offset given. + * + * @return int the signed long found at offset, e.g., an integer in + * the range -2147483648 to 2147483647. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + */ + static function bytesToSLong($bytes, $offset, $endian) { + $n = self::bytesToLong($bytes, $offset, $endian); + if ($n > 2147483647) + return $n - 4294967296; + else + return $n; + } + + + /** + * Extract an unsigned rational from bytes. + * + * @param string the bytes. + * + * @param int the offset. The rational found at offset will be + * returned as an array. There must be at least eight bytes + * available beginning at the offset given. + * + * @return array the unsigned rational found at offset, e.g., an + * array with two integers in the range 0 to 4294967295. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + */ + static function bytesToRational($bytes, $offset, $endian) { + return array(self::bytesToLong($bytes, $offset, $endian), + self::bytesToLong($bytes, $offset+4, $endian)); + } + + + /** + * Extract a signed rational from bytes. + * + * @param string the bytes. + * + * @param int the offset. The rational found at offset will be + * returned as an array. There must be at least eight bytes + * available beginning at the offset given. + * + * @return array the signed rational found at offset, e.g., an array + * with two integers in the range -2147483648 to 2147483647. + * + * @param PelByteOrder one of {@link LITTLE_ENDIAN} and {@link + * BIG_ENDIAN}. + */ + static function bytesToSRational($bytes, $offset, $endian) { + return array(self::bytesToSLong($bytes, $offset, $endian), + self::bytesToSLong($bytes, $offset+4, $endian)); + } + + + /** + * Format bytes for dumping. + * + * This method is for debug output, it will format a string as a + * hexadecimal dump suitable for display on a terminal. The output + * is printed directly to standard out. + * + * @param string the bytes that will be dumped. + * + * @param int the maximum number of bytes to dump. If this is left + * out (or left to the default of 0), then the entire string will be + * dumped. + */ + static function bytesToDump($bytes, $max = 0) { + $s = strlen($bytes); + + if ($max > 0) + $s = min($max, $s); + + $line = 24; + + for ($i = 0; $i < $s; $i++) { + printf('%02X ', ord($bytes{$i})); + + if (($i+1) % $line == 0) + print("\n"); + } + print("\n"); + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelDataWindow.php b/modules/autorotate/lib/pel/PelDataWindow.php new file mode 100644 index 00000000..523f8277 --- /dev/null +++ b/modules/autorotate/lib/pel/PelDataWindow.php @@ -0,0 +1,525 @@ + + * @version $Revision: 387 $ + * @date $Date: 2005-10-05 13:02:52 +0200 (Wed, 05 Oct 2005) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelException.php'); +require_once('PelConvert.php'); +/**#@-*/ + + +/** + * An exception thrown when an invalid offset is encountered. + * + * @package PEL + * @subpackage Exception + */ +class PelDataWindowOffsetException extends PelException {} + +/** + * An exception thrown when an invalid window is encountered. + * + * @package PEL + * @subpackage Exception + */ +class PelDataWindowWindowException extends PelException {} + +/** + * The window. + * + * @package PEL + */ +class PelDataWindow { + + /** + * The data held by this window. + * + * The string can contain any kind of data, including binary data. + * + * @var string + */ + private $data = ''; + + /** + * The byte order currently in use. + * + * This will be the byte order used when data is read using the for + * example the {@link getShort} function. It must be one of {@link + * PelConvert::LITTLE_ENDIAN} and {@link PelConvert::BIG_ENDIAN}. + * + * @var PelByteOrder + * @see setByteOrder, getByteOrder + */ + private $order; + + /** + * The start of the current window. + * + * All offsets used for access into the data will count from this + * offset, effectively limiting access to a window starting at this + * byte. + * + * @var int + * @see setWindowStart + */ + private $start = 0; + + /** + * The size of the current window. + * + * All offsets used for access into the data will be limited by this + * variable. A valid offset must be strictly less than this + * variable. + * + * @var int + * @see setWindowSize + */ + private $size = 0; + + + /** + * Construct a new data window with the data supplied. + * + * @param string the data that this window will contain. The data + * will be copied into the new data window. + * + * @param boolean the initial byte order of the window. This must + * be either {@link PelConvert::LITTLE_ENDIAN} or {@link + * PelConvert::BIG_ENDIAN}. This will be used when integers are + * read from the data, and it can be changed later with {@link + * setByteOrder()}. + */ + function __construct($d = '', $e = PelConvert::LITTLE_ENDIAN) { + $this->data = $d; + $this->order = $e; + $this->size = strlen($d); + } + + + /** + * Get the size of the data window. + * + * @return int the number of bytes covered by the window. The + * allowed offsets go from 0 up to this number minus one. + * + * @see getBytes() + */ + function getSize() { + return $this->size; + } + + + /** + * Change the byte order of the data. + * + * @param PelByteOrder the new byte order. This must be either + * {@link PelConvert::LITTLE_ENDIAN} or {@link + * PelConvert::BIG_ENDIAN}. + */ + function setByteOrder($o) { + $this->order = $o; + } + + + /** + * Get the currently used byte order. + * + * @return PelByteOrder this will be either {@link + * PelConvert::LITTLE_ENDIAN} or {@link PelConvert::BIG_ENDIAN}. + */ + function getByteOrder() { + return $this->order; + } + + + /* Move the start of the window forward. + * + * @param int the new start of the window. All new offsets will be + * calculated from this new start offset, and the size of the window + * will shrink to keep the end of the window in place. + */ + function setWindowStart($start) { + if ($start < 0 || $start > $this->size) + throw new PelDataWindowWindowException('Window [%d, %d] does ' . + 'not fit in window [0, %d]', + $start, $this->size, $this->size); + + $this->start += $start; + $this->size -= $start; + } + + + /** + * Adjust the size of the window. + * + * The size can only be made smaller. + * + * @param int the desired size of the window. If the argument is + * negative, the window will be shrunk by the argument. + */ + function setWindowSize($size) { + if ($size < 0) + $size += $this->size; + + if ($size < 0 || $size > $this->size) + throw new PelDataWindowWindowException('Window [0, %d] ' . + 'does not fit in window [0, %d]', + $size, $this->size); + $this->size = $size; + } + + + /** + * Make a new data window with the same data as the this window. + * + * @param mixed if an integer is supplied, then it will be the start + * of the window in the clone. If left unspecified, then the clone + * will inherit the start from this object. + * + * @param mixed if an integer is supplied, then it will be the size + * of the window in the clone. If left unspecified, then the clone + * will inherit the size from this object. + * + * @return PelDataWindow a new window that operates on the same data + * as this window, but (optionally) with a smaller window size. + */ + function getClone($start = false, $size = false) { + $c = clone $this; + + if (is_int($start)) + $c->setWindowStart($start); + + if (is_int($size)) + $c->setWindowSize($size); + + return $c; + } + + + /** + * Validate an offset against the current window. + * + * @param int the offset to be validated. If the offset is negative + * or if it is greater than or equal to the current window size, + * then a {@link PelDataWindowOffsetException} is thrown. + * + * @return void if the offset is valid nothing is returned, if it is + * invalid a new {@link PelDataWindowOffsetException} is thrown. + */ + private function validateOffset($o) { + if ($o < 0 || $o >= $this->size) + throw new PelDataWindowOffsetException('Offset %d not within [%d, %d]', + $o, 0, $this->size-1); + } + + + /** + * Return some or all bytes visible in the window. + * + * This method works just like the standard {@link substr()} + * function in PHP with the exception that it works within the + * window of accessible bytes and does strict range checking. + * + * @param int the offset to the first byte returned. If a negative + * number is given, then the counting will be from the end of the + * window. Invalid offsets will result in a {@link + * PelDataWindowOffsetException} being thrown. + * + * @param int the size of the sub-window. If a negative number is + * given, then that many bytes will be omitted from the result. + * + * @return string a subset of the bytes in the window. This will + * always return no more than {@link getSize()} bytes. + */ + function getBytes($start = false, $size = false) { + if (is_int($start)) { + if ($start < 0) + $start += $this->size; + + $this->validateOffset($start); + } else { + $start = 0; + } + + if (is_int($size)) { + if ($size <= 0) + $size += $this->size - $start; + + $this->validateOffset($start+$size); + } else { + $size = $this->size - $start; + } + + return substr($this->data, $this->start + $start, $size); + } + + + /** + * Return an unsigned byte from the data. + * + * @param int the offset into the data. An offset of zero will + * return the first byte in the current allowed window. The last + * valid offset is equal to {@link getSize()}-1. Invalid offsets + * will result in a {@link PelDataWindowOffsetException} being + * thrown. + * + * @return int the unsigned byte found at offset. + */ + function getByte($o = 0) { + /* Validate the offset --- this throws an exception if offset is + * out of range. */ + $this->validateOffset($o); + + /* Translate the offset into an offset into the data. */ + $o += $this->start; + + /* Return an unsigned byte. */ + return PelConvert::bytesToByte($this->data, $o); + } + + + /** + * Return a signed byte from the data. + * + * @param int the offset into the data. An offset of zero will + * return the first byte in the current allowed window. The last + * valid offset is equal to {@link getSize()}-1. Invalid offsets + * will result in a {@link PelDataWindowOffsetException} being + * thrown. + * + * @return int the signed byte found at offset. + */ + function getSByte($o = 0) { + /* Validate the offset --- this throws an exception if offset is + * out of range. */ + $this->validateOffset($o); + + /* Translate the offset into an offset into the data. */ + $o += $this->start; + + /* Return a signed byte. */ + return PelConvert::bytesToSByte($this->data, $o); + } + + + /** + * Return an unsigned short read from the data. + * + * @param int the offset into the data. An offset of zero will + * return the first short available in the current allowed window. + * The last valid offset is equal to {@link getSize()}-2. Invalid + * offsets will result in a {@link PelDataWindowOffsetException} + * being thrown. + * + * @return int the unsigned short found at offset. + */ + function getShort($o = 0) { + /* Validate the offset+1 to see if we can safely get two bytes --- + * this throws an exception if offset is out of range. */ + $this->validateOffset($o); + $this->validateOffset($o+1); + + /* Translate the offset into an offset into the data. */ + $o += $this->start; + + /* Return an unsigned short. */ + return PelConvert::bytesToShort($this->data, $o, $this->order); + } + + + /** + * Return a signed short read from the data. + * + * @param int the offset into the data. An offset of zero will + * return the first short available in the current allowed window. + * The last valid offset is equal to {@link getSize()}-2. Invalid + * offsets will result in a {@link PelDataWindowOffsetException} + * being thrown. + * + * @return int the signed short found at offset. + */ + function getSShort($o = 0) { + /* Validate the offset+1 to see if we can safely get two bytes --- + * this throws an exception if offset is out of range. */ + $this->validateOffset($o); + $this->validateOffset($o+1); + + /* Translate the offset into an offset into the data. */ + $o += $this->start; + + /* Return a signed short. */ + return PelConvert::bytesToSShort($this->data, $o, $this->order); + } + + + /** + * Return an unsigned long read from the data. + * + * @param int the offset into the data. An offset of zero will + * return the first long available in the current allowed window. + * The last valid offset is equal to {@link getSize()}-4. Invalid + * offsets will result in a {@link PelDataWindowOffsetException} + * being thrown. + * + * @return int the unsigned long found at offset. + */ + function getLong($o = 0) { + /* Validate the offset+3 to see if we can safely get four bytes + * --- this throws an exception if offset is out of range. */ + $this->validateOffset($o); + $this->validateOffset($o+3); + + /* Translate the offset into an offset into the data. */ + $o += $this->start; + + /* Return an unsigned long. */ + return PelConvert::bytesToLong($this->data, $o, $this->order); + } + + + /** + * Return a signed long read from the data. + * + * @param int the offset into the data. An offset of zero will + * return the first long available in the current allowed window. + * The last valid offset is equal to {@link getSize()}-4. Invalid + * offsets will result in a {@link PelDataWindowOffsetException} + * being thrown. + * + * @return int the signed long found at offset. + */ + function getSLong($o = 0) { + /* Validate the offset+3 to see if we can safely get four bytes + * --- this throws an exception if offset is out of range. */ + $this->validateOffset($o); + $this->validateOffset($o+3); + + /* Translate the offset into an offset into the data. */ + $o += $this->start; + + /* Return a signed long. */ + return PelConvert::bytesToSLong($this->data, $o, $this->order); + } + + + /** + * Return an unsigned rational read from the data. + * + * @param int the offset into the data. An offset of zero will + * return the first rational available in the current allowed + * window. The last valid offset is equal to {@link getSize()}-8. + * Invalid offsets will result in a {@link + * PelDataWindowOffsetException} being thrown. + * + * @return array the unsigned rational found at offset. A rational + * number is represented as an array of two numbers: the enumerator + * and denominator. Both of these numbers will be unsigned longs. + */ + function getRational($o = 0) { + return array($this->getLong($o), $this->getLong($o+4)); + } + + + /** + * Return a signed rational read from the data. + * + * @param int the offset into the data. An offset of zero will + * return the first rational available in the current allowed + * window. The last valid offset is equal to {@link getSize()}-8. + * Invalid offsets will result in a {@link + * PelDataWindowOffsetException} being thrown. + * + * @return array the signed rational found at offset. A rational + * number is represented as an array of two numbers: the enumerator + * and denominator. Both of these numbers will be signed longs. + */ + function getSRational($o = 0) { + return array($this->getSLong($o), $this->getSLong($o+4)); + } + + + /** + * String comparison on substrings. + * + * @param int the offset into the data. An offset of zero will make + * the comparison start with the very first byte available in the + * window. The last valid offset is equal to {@link getSize()} + * minus the length of the string. If the string is too long, then + * a {@link PelDataWindowOffsetException} will be thrown. + * + * @param string the string to compare with. + * + * @return boolean true if the string given matches the data in the + * window, at the specified offset, false otherwise. The comparison + * will stop as soon as a mismatch if found. + */ + function strcmp($o, $str) { + /* Validate the offset of the final character we might have to + * check. */ + $s = strlen($str); + $this->validateOffset($o); + $this->validateOffset($o + $s - 1); + + /* Translate the offset into an offset into the data. */ + $o += $this->start; + + /* Check each character, return as soon as the answer is known. */ + for ($i = 0; $i < $s; $i++) { + if ($this->data{$o + $i} != $str{$i}) + return false; + } + + /* All characters matches each other, return true. */ + return true; + } + + + /** + * Return a string representation of the data window. + * + * @return string a description of the window with information about + * the number of bytes accessible, the total number of bytes, and + * the window start and stop. + */ + function __toString() { + return Pel::fmt('DataWindow: %d bytes in [%d, %d] of %d bytes', + $this->size, + $this->start, $this->start + $this->size, + strlen($this->data)); + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelEntry.php b/modules/autorotate/lib/pel/PelEntry.php new file mode 100644 index 00000000..b3c1d15c --- /dev/null +++ b/modules/autorotate/lib/pel/PelEntry.php @@ -0,0 +1,382 @@ + + * @version $Revision: 442 $ + * @date $Date: 2006-09-17 14:45:10 +0200 (Sun, 17 Sep 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelException.php'); +require_once('PelFormat.php'); +require_once('PelTag.php'); +require_once('Pel.php'); +/**#@-*/ + + +/** + * Exception indicating a problem with an entry. + * + * @author Martin Geisler + * @package PEL + * @subpackage Exception + */ +class PelEntryException extends PelException { + + /** + * The IFD type (if known). + * + * @var int + */ + protected $type; + + /** + * The tag of the entry (if known). + * + * @var PelTag + */ + protected $tag; + + /** + * Get the IFD type associated with the exception. + * + * @return int one of {@link PelIfd::IFD0}, {@link PelIfd::IFD1}, + * {@link PelIfd::EXIF}, {@link PelIfd::GPS}, or {@link + * PelIfd::INTEROPERABILITY}. If no type is set, null is returned. + */ + function getIfdType() { + return $this->type; + } + + + /** + * Get the tag associated with the exception. + * + * @return PelTag the tag. If no tag is set, null is returned. + */ + function getTag() { + return $this->tag; + } + +} + + +/** + * Exception indicating that an unexpected format was found. + * + * The documentation for each tag in {@link PelTag} will detail any + * constrains. + * + * @author Martin Geisler + * @package PEL + * @subpackage Exception + */ +class PelUnexpectedFormatException extends PelEntryException { + + /** + * Construct a new exception indicating an invalid format. + * + * @param int the type of IFD. + * + * @param PelTag the tag for which the violation was found. + * + * @param PelFormat the format found. + * + * @param PelFormat the expected format. + */ + function __construct($type, $tag, $found, $expected) { + parent::__construct('Unexpected format found for %s tag: PelFormat::%s. ' . + 'Expected PelFormat::%s instead.', + PelTag::getName($type, $tag), + strtoupper(PelFormat::getName($found)), + strtoupper(PelFormat::getName($expected))); + $this->tag = $tag; + $this->type = $type; + } +} + + +/** + * Exception indicating that an unexpected number of components was + * found. + * + * Some tags have strict limits as to the allowed number of + * components, and this exception is thrown if the data violates such + * a constraint. The documentation for each tag in {@link PelTag} + * explains the expected number of components. + * + * @author Martin Geisler + * @package PEL + * @subpackage Exception + */ +class PelWrongComponentCountException extends PelEntryException { + + /** + * Construct a new exception indicating a wrong number of + * components. + * + * @param int the type of IFD. + * + * @param PelTag the tag for which the violation was found. + * + * @param int the number of components found. + * + * @param int the expected number of components. + */ + function __construct($type, $tag, $found, $expected) { + parent::__construct('Wrong number of components found for %s tag: %d. ' . + 'Expected %d.', + PelTag::getName($type, $tag), $found, $expected); + $this->tag = $tag; + $this->type = $type; + } +} + + +/** + * Common ancestor class of all {@link PelIfd} entries. + * + * As this class is abstract you cannot instantiate objects from it. + * It only serves as a common ancestor to define the methods common to + * all entries. The most important methods are {@link getValue()} and + * {@link setValue()}, both of which is abstract in this class. The + * descendants will give concrete implementations for them. + * + * If you have some data coming from an image (some raw bytes), then + * the static method {@link newFromData()} is helpful --- it will look + * at the data and give you a proper decendent of {@link PelEntry} + * back. + * + * If you instead want to have an entry for some data which take the + * form of an integer, a string, a byte, or some other PHP type, then + * don't use this class. You should instead create an object of the + * right subclass ({@link PelEntryShort} for short integers, {@link + * PelEntryAscii} for strings, and so on) directly. + * + * @author Martin Geisler + * @package PEL + */ +abstract class PelEntry { + + /** + * Type of IFD containing this tag. + * + * This must be one of the constants defined in {@link PelIfd}: + * {@link PelIfd::IFD0} for the main image IFD, {@link PelIfd::IFD1} + * for the thumbnail image IFD, {@link PelIfd::EXIF} for the Exif + * sub-IFD, {@link PelIfd::GPS} for the GPS sub-IFD, or {@link + * PelIfd::INTEROPERABILITY} for the interoperability sub-IFD. + * + * @var int + */ + protected $ifd_type; + + /** + * The bytes representing this entry. + * + * Subclasses must either override {@link getBytes()} or, if + * possible, maintain this property so that it always contains a + * true representation of the entry. + * + * @var string + */ + protected $bytes = ''; + + /** + * The {@link PelTag} of this entry. + * + * @var PelTag + */ + protected $tag; + + /** + * The {@link PelFormat} of this entry. + * + * @var PelFormat + */ + protected $format; + + /** + * The number of components of this entry. + * + * @var int + */ + protected $components; + + + /** + * Return the tag of this entry. + * + * @return PelTag the tag of this entry. + */ + function getTag() { + return $this->tag; + } + + + /** + * Return the type of IFD which holds this entry. + * + * @return int one of the constants defined in {@link PelIfd}: + * {@link PelIfd::IFD0} for the main image IFD, {@link PelIfd::IFD1} + * for the thumbnail image IFD, {@link PelIfd::EXIF} for the Exif + * sub-IFD, {@link PelIfd::GPS} for the GPS sub-IFD, or {@link + * PelIfd::INTEROPERABILITY} for the interoperability sub-IFD. + */ + function getIfdType() { + return $this->ifd_type; + } + + + /** + * Update the IFD type. + * + * @param int must be one of the constants defined in {@link + * PelIfd}: {@link PelIfd::IFD0} for the main image IFD, {@link + * PelIfd::IFD1} for the thumbnail image IFD, {@link PelIfd::EXIF} + * for the Exif sub-IFD, {@link PelIfd::GPS} for the GPS sub-IFD, or + * {@link PelIfd::INTEROPERABILITY} for the interoperability + * sub-IFD. + */ + function setIfdType($type) { + $this->ifd_type = $type; + } + + + /** + * Return the format of this entry. + * + * @return PelFormat the format of this entry. + */ + function getFormat() { + return $this->format; + } + + + /** + * Return the number of components of this entry. + * + * @return int the number of components of this entry. + */ + function getComponents() { + return $this->components; + } + + + /** + * Turn this entry into bytes. + * + * @param PelByteOrder the desired byte order, which must be either + * {@link Convert::LITTLE_ENDIAN} or {@link Convert::BIG_ENDIAN}. + * + * @return string bytes representing this entry. + */ + function getBytes($o) { + return $this->bytes; + } + + + /** + * Get the value of this entry as text. + * + * The value will be returned in a format suitable for presentation, + * e.g., rationals will be returned as 'x/y', ASCII strings will be + * returned as themselves etc. + * + * @param boolean some values can be returned in a long or more + * brief form, and this parameter controls that. + * + * @return string the value as text. + */ + abstract function getText($brief = false); + + + /** + * Get the value of this entry. + * + * The value returned will generally be the same as the one supplied + * to the constructor or with {@link setValue()}. For a formatted + * version of the value, one should use {@link getText()} instead. + * + * @return mixed the unformatted value. + */ + abstract function getValue(); + + + /** + * Set the value of this entry. + * + * The value should be in the same format as for the constructor. + * + * @param mixed the new value. + * + * @abstract + */ + function setValue($value) { + /* This (fake) abstract method is here to make it possible for the + * documentation to refer to PelEntry::setValue(). + * + * It cannot declared abstract in the proper PHP way, for then PHP + * wont allow subclasses to define it with two arguments (which is + * what PelEntryCopyright does). + */ + throw new PelException('setValue() is abstract.'); + } + + + /** + * Turn this entry into a string. + * + * @return string a string representation of this entry. This is + * mostly for debugging. + */ + function __toString() { + $str = Pel::fmt(" Tag: 0x%04X (%s)\n", + $this->tag, PelTag::getName($this->ifd_type, $this->tag)); + $str .= Pel::fmt(" Format : %d (%s)\n", + $this->format, PelFormat::getName($this->format)); + $str .= Pel::fmt(" Components: %d\n", $this->components); + if ($this->getTag() != PelTag::MAKER_NOTE && + $this->getTag() != PelTag::PRINT_IM) + $str .= Pel::fmt(" Value : %s\n", print_r($this->getValue(), true)); + $str .= Pel::fmt(" Text : %s\n", $this->getText()); + return $str; + } +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelEntryAscii.php b/modules/autorotate/lib/pel/PelEntryAscii.php new file mode 100644 index 00000000..bdffe4bb --- /dev/null +++ b/modules/autorotate/lib/pel/PelEntryAscii.php @@ -0,0 +1,482 @@ + + * @version $Revision: 443 $ + * @date $Date: 2006-09-17 20:32:04 +0200 (Sun, 17 Sep 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelEntry.php'); +/**#@-*/ + + +/** + * Class for holding a plain ASCII string. + * + * This class can hold a single ASCII string, and it will be used as in + * + * $entry = $ifd->getEntry(PelTag::IMAGE_DESCRIPTION); + * print($entry->getValue()); + * $entry->setValue('This is my image. I like it.'); + * + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryAscii extends PelEntry { + + /** + * The string hold by this entry. + * + * This is the string that was given to the {@link __construct + * constructor} or later to {@link setValue}, without any final NULL + * character. + * + * @var string + */ + private $str; + + + /** + * Make a new PelEntry that can hold an ASCII string. + * + * @param int the tag which this entry represents. This should be + * one of the constants defined in {@link PelTag}, e.g., {@link + * PelTag::IMAGE_DESCRIPTION}, {@link PelTag::MODEL}, or any other + * tag with format {@link PelFormat::ASCII}. + * + * @param string the string that this entry will represent. The + * string must obey the same rules as the string argument to {@link + * setValue}, namely that it should be given without any trailing + * NULL character and that it must be plain 7-bit ASCII. + */ + function __construct($tag, $str = '') { + $this->tag = $tag; + $this->format = PelFormat::ASCII; + $this->setValue($str); + } + + + /** + * Give the entry a new ASCII value. + * + * This will overwrite the previous value. The value can be + * retrieved later with the {@link getValue} method. + * + * @param string the new value of the entry. This should be given + * without any trailing NULL character. The string must be plain + * 7-bit ASCII, the string should contain no high bytes. + * + * @todo Implement check for high bytes? + */ + function setValue($str) { + $this->components = strlen($str)+1; + $this->str = $str; + $this->bytes = $str . chr(0x00); + } + + + /** + * Return the ASCII string of the entry. + * + * @return string the string held, without any final NULL character. + * The string will be the same as the one given to {@link setValue} + * or to the {@link __construct constructor}. + */ + function getValue() { + return $this->str; + } + + + /** + * Return the ASCII string of the entry. + * + * This methods returns the same as {@link getValue}. + * + * @param boolean not used with ASCII entries. + * + * @return string the string held, without any final NULL character. + * The string will be the same as the one given to {@link setValue} + * or to the {@link __construct constructor}. + */ + function getText($brief = false) { + return $this->str; + } + +} + + +/** + * Class for holding a date and time. + * + * This class can hold a timestamp, and it will be used as + * in this example where the time is advanced by one week: + * + * $entry = $ifd->getEntry(PelTag::DATE_TIME_ORIGINAL); + * $time = $entry->getValue(); + * print('The image was taken on the ' . date($time, 'jS')); + * $entry->setValue($time + 7 * 24 * 3600); + * + * + * The example used a standard UNIX timestamp, which is the default + * for this class. + * + * But the Exif format defines dates outside the range of a UNIX + * timestamp (about 1970 to 2038) and so you can also get access to + * the timestamp in two other formats: a simple string or a Julian Day + * Count. Please see the Calendar extension in the PHP Manual for more + * information about the Julian Day Count. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryTime extends PelEntryAscii { + + /** + * Constant denoting a UNIX timestamp. + */ + const UNIX_TIMESTAMP = 1; + /** + * Constant denoting a Exif string. + */ + const EXIF_STRING = 2; + /** + * Constant denoting a Julian Day Count. + */ + const JULIAN_DAY_COUNT = 3; + + /** + * The Julian Day Count of the timestamp held by this entry. + * + * This is an integer counting the number of whole days since + * January 1st, 4713 B.C. The fractional part of the timestamp held + * by this entry is stored in {@link $seconds}. + * + * @var int + */ + private $day_count; + + /** + * The number of seconds into the day of the timestamp held by this + * entry. + * + * The number of whole days is stored in {@link $day_count} and the + * number of seconds left-over is stored here. + * + * @var int + */ + private $seconds; + + + /** + * Make a new entry for holding a timestamp. + * + * @param int the Exif tag which this entry represents. There are + * only three standard tags which hold timestamp, so this should be + * one of the constants {@link PelTag::DATE_TIME}, {@link + * PelTag::DATE_TIME_ORIGINAL}, or {@link + * PelTag::DATE_TIME_DIGITIZED}. + * + * @param int the timestamp held by this entry in the correct form + * as indicated by the third argument. For {@link UNIX_TIMESTAMP} + * this is an integer counting the number of seconds since January + * 1st 1970, for {@link EXIF_STRING} this is a string of the form + * 'YYYY:MM:DD hh:mm:ss', and for {@link JULIAN_DAY_COUNT} this is a + * floating point number where the integer part denotes the day + * count and the fractional part denotes the time of day (0.25 means + * 6:00, 0.75 means 18:00). + * + * @param int the type of the timestamp. This must be one of + * {@link UNIX_TIMESTAMP}, {@link EXIF_STRING}, or + * {@link JULIAN_DAY_COUNT}. + */ + function __construct($tag, $timestamp, $type = self::UNIX_TIMESTAMP) { + parent::__construct($tag); + $this->setValue($timestamp, $type); + } + + + /** + * Return the timestamp of the entry. + * + * The timestamp held by this entry is returned in one of three + * formats: as a standard UNIX timestamp (default), as a fractional + * Julian Day Count, or as a string. + * + * @param int the type of the timestamp. This must be one of + * {@link UNIX_TIMESTAMP}, {@link EXIF_STRING}, or + * {@link JULIAN_DAY_COUNT}. + * + * @return int the timestamp held by this entry in the correct form + * as indicated by the type argument. For {@link UNIX_TIMESTAMP} + * this is an integer counting the number of seconds since January + * 1st 1970, for {@link EXIF_STRING} this is a string of the form + * 'YYYY:MM:DD hh:mm:ss', and for {@link JULIAN_DAY_COUNT} this is a + * floating point number where the integer part denotes the day + * count and the fractional part denotes the time of day (0.25 means + * 6:00, 0.75 means 18:00). + */ + function getValue($type = self::UNIX_TIMESTAMP) { + switch ($type) { + case self::UNIX_TIMESTAMP: + $seconds = jdtounix($this->day_count); + if ($seconds === false) + /* jdtounix() return false if the Julian Day Count is outside + * the range of a UNIX timestamp. */ + return false; + else + return $seconds + $this->seconds; + + case self::EXIF_STRING: + list($month, $day, $year) = explode('/', jdtogregorian($this->day_count)); + $hours = (int)($this->seconds / 3600); + $minutes = (int)($this->seconds % 3600 / 60); + $seconds = $this->seconds % 60; + return sprintf('%04d:%02d:%02d %02d:%02d:%02d', + $year, $month, $day, $hours, $minutes, $seconds); + case self::JULIAN_DAY_COUNT: + return $this->day_count + $this->seconds / 86400; + default: + throw new PelInvalidArgumentException('Expected UNIX_TIMESTAMP (%d), ' . + 'EXIF_STRING (%d), or ' . + 'JULIAN_DAY_COUNT (%d) for $type, '. + 'got %d.', + self::UNIX_TIMESTAMP, + self::EXIF_STRING, + self::JULIAN_DAY_COUNT, + $type); + } + } + + + /** + * Update the timestamp held by this entry. + * + * @param int the timestamp held by this entry in the correct form + * as indicated by the third argument. For {@link UNIX_TIMESTAMP} + * this is an integer counting the number of seconds since January + * 1st 1970, for {@link EXIF_STRING} this is a string of the form + * 'YYYY:MM:DD hh:mm:ss', and for {@link JULIAN_DAY_COUNT} this is a + * floating point number where the integer part denotes the day + * count and the fractional part denotes the time of day (0.25 means + * 6:00, 0.75 means 18:00). + * + * @param int the type of the timestamp. This must be one of + * {@link UNIX_TIMESTAMP}, {@link EXIF_STRING}, or + * {@link JULIAN_DAY_COUNT}. + * + * @todo How to deal with timezones? Use the TimeZoneOffset tag + * 0x882A? + */ + function setValue($timestamp, $type = self::UNIX_TIMESTAMP) { + switch ($type) { + case self::UNIX_TIMESTAMP: + $this->day_count = unixtojd($timestamp); + $this->seconds = $timestamp % 86400; + break; + + case self::EXIF_STRING: + /* Clean the timestamp: some timestamps are broken other + * separators than ':' and ' '. */ + $d = split('[^0-9]+', $timestamp); + $this->day_count = gregoriantojd($d[1], $d[2], $d[0]); + $this->seconds = $d[3]*3600 + $d[4]*60 + $d[5]; + break; + + case self::JULIAN_DAY_COUNT: + $this->day_count = (int)floor($timestamp); + $this->seconds = (int)(86400 * ($timestamp - floor($timestamp))); + break; + + default: + throw new PelInvalidArgumentException('Expected UNIX_TIMESTAMP (%d), ' . + 'EXIF_STRING (%d), or ' . + 'JULIAN_DAY_COUNT (%d) for $type, '. + 'got %d.', + self::UNIX_TIMESTAMP, + self::EXIF_STRING, + self::JULIAN_DAY_COUNT, + $type); + } + + /* Now finally update the string which will be used when this is + * turned into bytes. */ + parent::setValue($this->getValue(self::EXIF_STRING)); + } +} + + +/** + * Class for holding copyright information. + * + * The Exif standard specifies a certain format for copyright + * information where the one {@link PelTag::COPYRIGHT copyright + * tag} holds both the photographer and editor copyrights, separated + * by a NULL character. + * + * This class is used to manipulate that tag so that the format is + * kept to the standard. A common use would be to add a new copyright + * tag to an image, since most cameras do not add this tag themselves. + * This would be done like this: + * + * + * $entry = new PelEntryCopyright('Copyright, Martin Geisler, 2004'); + * $ifd0->addEntry($entry); + * + * + * Here we only set the photographer copyright, use the optional + * second argument to specify the editor copyright. If there is only + * an editor copyright, then let the first argument be the empty + * string. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryCopyright extends PelEntryAscii { + + /** + * The photographer copyright. + * + * @var string + */ + private $photographer; + + /** + * The editor copyright. + * + * @var string + */ + private $editor; + + + /** + * Make a new entry for holding copyright information. + * + * @param string the photographer copyright. Use the empty string + * if there is no photographer copyright. + * + * @param string the editor copyright. Use the empty string if + * there is no editor copyright. + */ + function __construct($photographer = '', $editor = '') { + parent::__construct(PelTag::COPYRIGHT); + $this->setValue($photographer, $editor); + } + + + /** + * Update the copyright information. + * + * @param string the photographer copyright. Use the empty string + * if there is no photographer copyright. + * + * @param string the editor copyright. Use the empty string if + * there is no editor copyright. + */ + function setValue($photographer = '', $editor = '') { + $this->photographer = $photographer; + $this->editor = $editor; + + if ($photographer == '' && $editor != '') + $photographer = ' '; + + if ($editor == '') + parent::setValue($photographer); + else + parent::setValue($photographer . chr(0x00) . $editor); + } + + + /** + * Retrive the copyright information. + * + * The strings returned will be the same as the one used previously + * with either {@link __construct the constructor} or with {@link + * setValue}. + * + * @return array an array with two strings, the photographer and + * editor copyrights. The two fields will be returned in that + * order, so that the first array index will be the photographer + * copyright, and the second will be the editor copyright. + */ + function getValue() { + return array($this->photographer, $this->editor); + } + + + /** + * Return a text string with the copyright information. + * + * The photographer and editor copyright fields will be returned + * with a '-' in between if both copyright fields are present, + * otherwise only one of them will be returned. + * + * @param boolean if false, then the strings '(Photographer)' and + * '(Editor)' will be appended to the photographer and editor + * copyright fields (if present), otherwise the fields will be + * returned as is. + * + * @return string the copyright information in a string. + */ + function getText($brief = false) { + if ($brief) { + $p = ''; + $e = ''; + } else { + $p = ' ' . Pel::tra('(Photographer)'); + $e = ' ' . Pel::tra('(Editor)'); + } + + if ($this->photographer != '' && $this->editor != '') + return $this->photographer . $p . ' - ' . $this->editor . $e; + + if ($this->photographer != '') + return $this->photographer . $p; + + if ($this->editor != '') + return $this->editor . $e; + + return ''; + } +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelEntryByte.php b/modules/autorotate/lib/pel/PelEntryByte.php new file mode 100644 index 00000000..f6482d0c --- /dev/null +++ b/modules/autorotate/lib/pel/PelEntryByte.php @@ -0,0 +1,275 @@ + + * @version $Revision: 419 $ + * @date $Date: 2006-02-20 17:22:36 +0100 (Mon, 20 Feb 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelEntryNumber.php'); +/**#@-*/ + + +/** + * Class for holding unsigned bytes. + * + * This class can hold bytes, either just a single byte or an array of + * bytes. The class will be used to manipulate any of the Exif tags + * which has format {@link PelFormat::BYTE}. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryByte extends PelEntryNumber { + + /** + * Make a new entry that can hold an unsigned byte. + * + * The method accept several integer arguments. The {@link + * getValue} method will always return an array except for when a + * single integer argument is given here. + * + * @param PelTag the tag which this entry represents. This + * should be one of the constants defined in {@link PelTag} + * which has format {@link PelFormat::BYTE}. + * + * @param int $value... the byte(s) that this entry will represent. + * The argument passed must obey the same rules as the argument to + * {@link setValue}, namely that it should be within range of an + * unsigned byte, that is between 0 and 255 (inclusive). If not, + * then a {@link PelOverflowException} will be thrown. + */ + function __construct($tag /* $value... */) { + $this->tag = $tag; + $this->min = 0; + $this->max = 255; + $this->format = PelFormat::BYTE; + + $value = func_get_args(); + array_shift($value); + $this->setValueArray($value); + } + + + /** + * Convert a number into bytes. + * + * @param int the number that should be converted. + * + * @param PelByteOrder one of {@link PelConvert::LITTLE_ENDIAN} and + * {@link PelConvert::BIG_ENDIAN}, specifying the target byte order. + * + * @return string bytes representing the number given. + */ + function numberToBytes($number, $order) { + return chr($number); + } + +} + + +/** + * Class for holding signed bytes. + * + * This class can hold bytes, either just a single byte or an array of + * bytes. The class will be used to manipulate any of the Exif tags + * which has format {@link PelFormat::BYTE}. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntrySByte extends PelEntryNumber { + + /** + * Make a new entry that can hold a signed byte. + * + * The method accept several integer arguments. The {@link getValue} + * method will always return an array except for when a single + * integer argument is given here. + * + * @param PelTag the tag which this entry represents. This + * should be one of the constants defined in {@link PelTag} + * which has format {@link PelFormat::BYTE}. + * + * @param int $value... the byte(s) that this entry will represent. + * The argument passed must obey the same rules as the argument to + * {@link setValue}, namely that it should be within range of a + * signed byte, that is between -128 and 127 (inclusive). If not, + * then a {@link PelOverflowException} will be thrown. + */ + function __construct($tag /* $value... */) { + $this->tag = $tag; + $this->min = -128; + $this->max = 127; + $this->format = PelFormat::SBYTE; + + $value = func_get_args(); + array_shift($value); + $this->setValueArray($value); + } + + + /** + * Convert a number into bytes. + * + * @param int the number that should be converted. + * + * @param PelByteOrder one of {@link PelConvert::LITTLE_ENDIAN} and + * {@link PelConvert::BIG_ENDIAN}, specifying the target byte order. + * + * @return string bytes representing the number given. + */ + function numberToBytes($number, $order) { + return chr($number); + } + +} + + +/** + * Class used to manipulate strings in the format Windows XP uses. + * + * When examining the file properties of an image in Windows XP one + * can fill in title, comment, author, keyword, and subject fields. + * Filling those fields and pressing OK will result in the data being + * written into the Exif data in the image. + * + * The data is written in a non-standard format and can thus not be + * loaded directly --- this class is needed to translate it into + * normal strings. + * + * It is important that entries from this class are only created with + * the {@link PelTag::XP_TITLE}, {@link PelTag::XP_COMMENT}, {@link + * PelTag::XP_AUTHOR}, {@link PelTag::XP_KEYWORD}, and {@link + * PelTag::XP_SUBJECT} tags. If another tag is used the data will no + * longer be correctly decoded when reloaded with PEL. (The data will + * be loaded as an {@link PelEntryByte} entry, which isn't as useful.) + * + * This class is to be used as in + * + * $entry = $ifd->getEntry(PelTag::XP_TITLE); + * print($entry->getValue()); + * $entry->setValue('My favorite cat'); + * + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryWindowsString extends PelEntry { + + /** + * The string hold by this entry. + * + * This is the string that was given to the {@link __construct + * constructor} or later to {@link setValue}, without any extra NULL + * characters or any such nonsense. + * + * @var string + */ + private $str; + + + /** + * Make a new PelEntry that can hold a Windows XP specific string. + * + * @param int the tag which this entry represents. This should be + * one of {@link PelTag::XP_TITLE}, {@link PelTag::XP_COMMENT}, + * {@link PelTag::XP_AUTHOR}, {@link PelTag::XP_KEYWORD}, and {@link + * PelTag::XP_SUBJECT} tags. If another tag is used, then this + * entry will be incorrectly reloaded as a {@link PelEntryByte}. + * + * @param string the string that this entry will represent. It will + * be passed to {@link setValue} and thus has to obey its + * requirements. + */ + function __construct($tag, $str = '') { + $this->tag = $tag; + $this->format = PelFormat::BYTE; + $this->setValue($str); + } + + + /** + * Give the entry a new value. + * + * This will overwrite the previous value. The value can be + * retrieved later with the {@link getValue} method. + * + * @param string the new value of the entry. This should be use the + * Latin-1 encoding and be given without any extra NULL characters. + */ + function setValue($str) { + $l = strlen($str); + + $this->components = 2 * ($l + 1); + $this->str = $str; + $this->bytes = ''; + for ($i = 0; $i < $l; $i++) + $this->bytes .= $str{$i} . chr(0x00); + + $this->bytes .= chr(0x00) . chr(0x00); + } + + + /** + * Return the string of the entry. + * + * @return string the string held, without any extra NULL + * characters. The string will be the same as the one given to + * {@link setValue} or to the {@link __construct constructor}. + */ + function getValue() { + return $this->str; + } + + + /** + * Return the string of the entry. + * + * This methods returns the same as {@link getValue}. + * + * @param boolean not used. + * + * @return string the string held, without any extra NULL + * characters. The string will be the same as the one given to + * {@link setValue} or to the {@link __construct constructor}. + */ + function getText($brief = false) { + return $this->str; + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelEntryLong.php b/modules/autorotate/lib/pel/PelEntryLong.php new file mode 100644 index 00000000..1ae4b30b --- /dev/null +++ b/modules/autorotate/lib/pel/PelEntryLong.php @@ -0,0 +1,182 @@ + + * @version $Revision: 419 $ + * @date $Date: 2006-02-20 17:22:36 +0100 (Mon, 20 Feb 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelEntryNumber.php'); +/**#@-*/ + + +/** + * Class for holding unsigned longs. + * + * This class can hold longs, either just a single long or an array of + * longs. The class will be used to manipulate any of the Exif tags + * which can have format {@link PelFormat::LONG} like in this + * example: + * + * $w = $ifd->getEntry(PelTag::EXIF_IMAGE_WIDTH); + * $w->setValue($w->getValue() / 2); + * $h = $ifd->getEntry(PelTag::EXIF_IMAGE_HEIGHT); + * $h->setValue($h->getValue() / 2); + * + * Here the width and height is updated to 50% of their original + * values. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryLong extends PelEntryNumber { + + /** + * Make a new entry that can hold an unsigned long. + * + * The method accept its arguments in two forms: several integer + * arguments or a single array argument. The {@link getValue} + * method will always return an array except for when a single + * integer argument is given here, or when an array with just a + * single integer is given. + * + * This means that one can conveniently use objects like this: + * + * $a = new PelEntryLong(PelTag::EXIF_IMAGE_WIDTH, 123456); + * $b = $a->getValue() - 654321; + * + * where the call to {@link getValue} will return an integer instead + * of an array with one integer element, which would then have to be + * extracted. + * + * @param PelTag the tag which this entry represents. This + * should be one of the constants defined in {@link PelTag}, + * e.g., {@link PelTag::IMAGE_WIDTH}, or any other tag which can + * have format {@link PelFormat::LONG}. + * + * @param int $value... the long(s) that this entry will + * represent or an array of longs. The argument passed must obey + * the same rules as the argument to {@link setValue}, namely that + * it should be within range of an unsigned long (32 bit), that is + * between 0 and 4294967295 (inclusive). If not, then a {@link + * PelExifOverflowException} will be thrown. + */ + function __construct($tag /* $value... */) { + $this->tag = $tag; + $this->min = 0; + $this->max = 4294967295; + $this->format = PelFormat::LONG; + + $value = func_get_args(); + array_shift($value); + $this->setValueArray($value); + } + + + /** + * Convert a number into bytes. + * + * @param int the number that should be converted. + * + * @param PelByteOrder one of {@link PelConvert::LITTLE_ENDIAN} and + * {@link PelConvert::BIG_ENDIAN}, specifying the target byte order. + * + * @return string bytes representing the number given. + */ + function numberToBytes($number, $order) { + return PelConvert::longToBytes($number, $order); + } +} + + +/** + * Class for holding signed longs. + * + * This class can hold longs, either just a single long or an array of + * longs. The class will be used to manipulate any of the Exif tags + * which can have format {@link PelFormat::SLONG}. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntrySLong extends PelEntryNumber { + + /** + * Make a new entry that can hold a signed long. + * + * The method accept its arguments in two forms: several integer + * arguments or a single array argument. The {@link getValue} + * method will always return an array except for when a single + * integer argument is given here, or when an array with just a + * single integer is given. + * + * @param PelTag the tag which this entry represents. This + * should be one of the constants defined in {@link PelTag} + * which have format {@link PelFormat::SLONG}. + * + * @param int $value... the long(s) that this entry will represent + * or an array of longs. The argument passed must obey the same + * rules as the argument to {@link setValue}, namely that it should + * be within range of a signed long (32 bit), that is between + * -2147483648 and 2147483647 (inclusive). If not, then a {@link + * PelOverflowException} will be thrown. + */ + function __construct($tag /* $value... */) { + $this->tag = $tag; + $this->min = -2147483648; + $this->max = 2147483647; + $this->format = PelFormat::SLONG; + + $value = func_get_args(); + array_shift($value); + $this->setValueArray($value); + } + + + /** + * Convert a number into bytes. + * + * @param int the number that should be converted. + * + * @param PelByteOrder one of {@link PelConvert::LITTLE_ENDIAN} and + * {@link PelConvert::BIG_ENDIAN}, specifying the target byte order. + * + * @return string bytes representing the number given. + */ + function numberToBytes($number, $order) { + return PelConvert::sLongToBytes($number, $order); + } +} + + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelEntryNumber.php b/modules/autorotate/lib/pel/PelEntryNumber.php new file mode 100644 index 00000000..2301bb62 --- /dev/null +++ b/modules/autorotate/lib/pel/PelEntryNumber.php @@ -0,0 +1,309 @@ + + * @version $Revision: 419 $ + * @date $Date: 2006-02-20 17:22:36 +0100 (Mon, 20 Feb 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelException.php'); +require_once('PelEntry.php'); +/**#@-*/ + + +/** + * Exception cast when numbers overflow. + * + * @author Martin Geisler + * @package PEL + * @subpackage Exception + */ +class PelOverflowException extends PelException { + + /** + * Construct a new overflow exception. + * + * @param int the value that is out of range. + * + * @param int the minimum allowed value. + * + * @param int the maximum allowed value. + */ + function __construct($v, $min, $max) { + parent::__construct('Value %.0f out of range [%.0f, %.0f]', + $v, $min, $max); + } +} + + +/** + * Class for holding numbers. + * + * This class can hold numbers, with range checks. + * + * @author Martin Geisler + * @package PEL + */ +abstract class PelEntryNumber extends PelEntry { + + /** + * The value held by this entry. + * + * @var array + */ + protected $value = array(); + + /** + * The minimum allowed value. + * + * Any attempt to change the value below this variable will result + * in a {@link PelOverflowException} being thrown. + * + * @var int + */ + protected $min; + + /** + * The maximum allowed value. + * + * Any attempt to change the value over this variable will result in + * a {@link PelOverflowException} being thrown. + * + * @var int + */ + protected $max; + + /** + * The dimension of the number held. + * + * Normal numbers have a dimension of one, pairs have a dimension of + * two, etc. + * + * @var int + */ + protected $dimension = 1; + + + /** + * Change the value. + * + * This method can change both the number of components and the + * value of the components. Range checks will be made on the new + * value, and a {@link PelOverflowException} will be thrown if the + * value is found to be outside the legal range. + * + * The method accept several number arguments. The {@link getValue} + * method will always return an array except for when a single + * number is given here. + * + * @param int|array $value... the new value(s). This can be zero or + * more numbers, that is, either integers or arrays. The input will + * be checked to ensure that the numbers are within the valid range. + * If not, then a {@link PelOverflowException} will be thrown. + * + * @see getValue + */ + function setValue(/* $value... */) { + $value = func_get_args(); + $this->setValueArray($value); + } + + + /** + * Change the value. + * + * This method can change both the number of components and the + * value of the components. Range checks will be made on the new + * value, and a {@link PelOverflowException} will be thrown if the + * value is found to be outside the legal range. + * + * @param array the new values. The array must contain the new + * numbers. + * + * @see getValue + */ + function setValueArray($value) { + foreach ($value as $v) + $this->validateNumber($v); + + $this->components = count($value); + $this->value = $value; + } + + + /** + * Return the numeric value held. + * + * @return int|array this will either be a single number if there is + * only one component, or an array of numbers otherwise. + */ + function getValue() { + if ($this->components == 1) + return $this->value[0]; + else + return $this->value; + } + + + /** + * Validate a number. + * + * This method will check that the number given is within the range + * given my {@link getMin()} and {@link getMax()}, inclusive. If + * not, then a {@link PelOverflowException} is thrown. + * + * @param int|array the number in question. + * + * @return void nothing, but will throw a {@link + * PelOverflowException} if the number is found to be outside the + * legal range and {@link Pel::$strict} is true. + */ + function validateNumber($n) { + if ($this->dimension == 1) { + if ($n < $this->min || $n > $this->max) + Pel::maybeThrow(new PelOverflowException($n, + $this->min, + $this->max)); + } else { + for ($i = 0; $i < $this->dimension; $i++) + if ($n[$i] < $this->min || $n[$i] > $this->max) + Pel::maybeThrow(new PelOverflowException($n[$i], + $this->min, + $this->max)); + } + } + + + /** + * Add a number. + * + * This appends a number to the numbers already held by this entry, + * thereby increasing the number of components by one. + * + * @param int|array the number to be added. + */ + function addNumber($n) { + $this->validateNumber($n); + $this->value[] = $n; + $this->components++; + } + + + /** + * Convert a number into bytes. + * + * The concrete subclasses will have to implement this method so + * that the numbers represented can be turned into bytes. + * + * The method will be called once for each number held by the entry. + * + * @param int the number that should be converted. + * + * @param PelByteOrder one of {@link PelConvert::LITTLE_ENDIAN} and + * {@link PelConvert::BIG_ENDIAN}, specifying the target byte order. + * + * @return string bytes representing the number given. + */ + abstract function numberToBytes($number, $order); + + + /** + * Turn this entry into bytes. + * + * @param PelByteOrder the desired byte order, which must be either + * {@link PelConvert::LITTLE_ENDIAN} or {@link + * PelConvert::BIG_ENDIAN}. + * + * @return string bytes representing this entry. + */ + function getBytes($o) { + $bytes = ''; + for ($i = 0; $i < $this->components; $i++) { + if ($this->dimension == 1) { + $bytes .= $this->numberToBytes($this->value[$i], $o); + } else { + for ($j = 0; $j < $this->dimension; $j++) { + $bytes .= $this->numberToBytes($this->value[$i][$j], $o); + } + } + } + return $bytes; + } + + + /** + * Format a number. + * + * This method is called by {@link getText} to format numbers. + * Subclasses should override this method if they need more + * sophisticated behavior than the default, which is to just return + * the number as is. + * + * @param int the number which will be formatted. + * + * @param boolean it could be that there is both a verbose and a + * brief formatting available, and this argument controls that. + * + * @return string the number formatted as a string suitable for + * display. + */ + function formatNumber($number, $brief = false) { + return $number; + } + + + /** + * Get the numeric value of this entry as text. + * + * @param boolean use brief output? The numbers will be separated + * by a single space if brief output is requested, otherwise a space + * and a comma will be used. + * + * @return string the numbers(s) held by this entry. + */ + function getText($brief = false) { + if ($this->components == 0) + return ''; + + $str = $this->formatNumber($this->value[0]); + for ($i = 1; $i < $this->components; $i++) { + $str .= ($brief ? ' ' : ', '); + $str .= $this->formatNumber($this->value[$i]); + } + + return $str; + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelEntryRational.php b/modules/autorotate/lib/pel/PelEntryRational.php new file mode 100644 index 00000000..3dd503c8 --- /dev/null +++ b/modules/autorotate/lib/pel/PelEntryRational.php @@ -0,0 +1,290 @@ + + * @version $Revision: 419 $ + * @date $Date: 2006-02-20 17:22:36 +0100 (Mon, 20 Feb 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelEntryLong.php'); +/**#@-*/ + + +/** + * Class for holding unsigned rational numbers. + * + * This class can hold rational numbers, consisting of a numerator and + * denominator both of which are of type unsigned long. Each rational + * is represented by an array with just two entries: the numerator and + * the denominator, in that order. + * + * The class can hold either just a single rational or an array of + * rationals. The class will be used to manipulate any of the Exif + * tags which can have format {@link PelFormat::RATIONAL} like in this + * example: + * + * + * $resolution = $ifd->getEntry(PelTag::X_RESOLUTION); + * $resolution->setValue(array(1, 300)); + * + * + * Here the x-resolution is adjusted to 1/300, which will be 300 DPI, + * unless the {@link PelTag::RESOLUTION_UNIT resolution unit} is set + * to something different than 2 which means inches. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryRational extends PelEntryLong { + + /** + * Make a new entry that can hold an unsigned rational. + * + * @param PelTag the tag which this entry represents. This should + * be one of the constants defined in {@link PelTag}, e.g., {@link + * PelTag::X_RESOLUTION}, or any other tag which can have format + * {@link PelFormat::RATIONAL}. + * + * @param array $value... the rational(s) that this entry will + * represent. The arguments passed must obey the same rules as the + * argument to {@link setValue}, namely that each argument should be + * an array with two entries, both of which must be within range of + * an unsigned long (32 bit), that is between 0 and 4294967295 + * (inclusive). If not, then a {@link PelOverflowException} will be + * thrown. + */ + function __construct($tag /* $value... */) { + $this->tag = $tag; + $this->format = PelFormat::RATIONAL; + $this->dimension = 2; + $this->min = 0; + $this->max = 4294967295; + + $value = func_get_args(); + array_shift($value); + $this->setValueArray($value); + } + + + /** + * Format a rational number. + * + * The rational will be returned as a string with a slash '/' + * between the numerator and denominator. + * + * @param array the rational which will be formatted. + * + * @param boolean not used. + * + * @return string the rational formatted as a string suitable for + * display. + */ + function formatNumber($number, $brief = false) { + return $number[0] . '/' . $number[1]; + } + + + /** + * Get the value of an entry as text. + * + * The value will be returned in a format suitable for presentation, + * e.g., rationals will be returned as 'x/y', ASCII strings will be + * returned as themselves etc. + * + * @param boolean some values can be returned in a long or more + * brief form, and this parameter controls that. + * + * @return string the value as text. + */ + function getText($brief = false) { + if (isset($this->value[0])) + $v = $this->value[0]; + + switch ($this->tag) { + case PelTag::FNUMBER: + //CC (e->components, 1, v); + return Pel::fmt('f/%.01f', $v[0]/$v[1]); + + case PelTag::APERTURE_VALUE: + //CC (e->components, 1, v); + //if (!v_rat.denominator) return (NULL); + return Pel::fmt('f/%.01f', pow(2, $v[0]/$v[1]/2)); + + case PelTag::FOCAL_LENGTH: + //CC (e->components, 1, v); + //if (!v_rat.denominator) return (NULL); + return Pel::fmt('%.1f mm', $v[0]/$v[1]); + + case PelTag::SUBJECT_DISTANCE: + //CC (e->components, 1, v); + //if (!v_rat.denominator) return (NULL); + return Pel::fmt('%.1f m', $v[0]/$v[1]); + + case PelTag::EXPOSURE_TIME: + //CC (e->components, 1, v); + //if (!v_rat.denominator) return (NULL); + if ($v[0]/$v[1] < 1) + return Pel::fmt('1/%d sec.', $v[1]/$v[0]); + else + return Pel::fmt('%d sec.', $v[0]/$v[1]); + + case PelTag::GPS_LATITUDE: + case PelTag::GPS_LONGITUDE: + $degrees = $this->value[0][0]/$this->value[0][1]; + $minutes = $this->value[1][0]/$this->value[1][1]; + $seconds = $this->value[2][0]/$this->value[2][1]; + + return sprintf('%s° %s\' %s" (%.2f°)', + $degrees, $minutes, $seconds, + $degrees + $minutes/60 + $seconds/3600); + + default: + return parent::getText($brief); + } + } +} + + +/** + * Class for holding signed rational numbers. + * + * This class can hold rational numbers, consisting of a numerator and + * denominator both of which are of type unsigned long. Each rational + * is represented by an array with just two entries: the numerator and + * the denominator, in that order. + * + * The class can hold either just a single rational or an array of + * rationals. The class will be used to manipulate any of the Exif + * tags which can have format {@link PelFormat::SRATIONAL}. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntrySRational extends PelEntrySLong { + + /** + * Make a new entry that can hold a signed rational. + * + * @param PelTag the tag which this entry represents. This should + * be one of the constants defined in {@link PelTag}, e.g., {@link + * PelTag::SHUTTER_SPEED_VALUE}, or any other tag which can have + * format {@link PelFormat::SRATIONAL}. + * + * @param array $value... the rational(s) that this entry will + * represent. The arguments passed must obey the same rules as the + * argument to {@link setValue}, namely that each argument should be + * an array with two entries, both of which must be within range of + * a signed long (32 bit), that is between -2147483648 and + * 2147483647 (inclusive). If not, then a {@link + * PelOverflowException} will be thrown. + */ + function __construct($tag /* $value... */) { + $this->tag = $tag; + $this->format = PelFormat::SRATIONAL; + $this->dimension = 2; + $this->min = -2147483648; + $this->max = 2147483647; + + $value = func_get_args(); + array_shift($value); + $this->setValueArray($value); + } + + + /** + * Format a rational number. + * + * The rational will be returned as a string with a slash '/' + * between the numerator and denominator. Care is taken to display + * '-1/2' instead of the ugly but mathematically equivalent '1/-2'. + * + * @param array the rational which will be formatted. + * + * @param boolean not used. + * + * @return string the rational formatted as a string suitable for + * display. + */ + function formatNumber($number, $brief = false) { + if ($number[1] < 0) + /* Turn output like 1/-2 into -1/2. */ + return (-$number[0]) . '/' . (-$number[1]); + else + return $number[0] . '/' . $number[1]; + } + + + /** + * Get the value of an entry as text. + * + * The value will be returned in a format suitable for presentation, + * e.g., rationals will be returned as 'x/y', ASCII strings will be + * returned as themselves etc. + * + * @param boolean some values can be returned in a long or more + * brief form, and this parameter controls that. + * + * @return string the value as text. + */ + function getText($brief = false) { + if (isset($this->value[0])) + $v = $this->value[0]; + + switch ($this->tag) { + case PelTag::SHUTTER_SPEED_VALUE: + //CC (e->components, 1, v); + //if (!v_srat.denominator) return (NULL); + return Pel::fmt('%.0f/%.0f sec. (APEX: %d)', + $v[0], $v[1], pow(sqrt(2), $v[0]/$v[1])); + + case PelTag::BRIGHTNESS_VALUE: + //CC (e->components, 1, v); + // + // TODO: figure out the APEX thing, or remove this so that it is + // handled by the default clause at the bottom. + return sprintf('%d/%d', $v[0], $v[1]); + //FIXME: How do I calculate the APEX value? + + case PelTag::EXPOSURE_BIAS_VALUE: + //CC (e->components, 1, v); + //if (!v_srat.denominator) return (NULL); + return sprintf('%s%.01f', $v[0]*$v[1] > 0 ? '+' : '', $v[0]/$v[1]); + + default: + return parent::getText($brief); + } + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelEntryShort.php b/modules/autorotate/lib/pel/PelEntryShort.php new file mode 100644 index 00000000..72e499d7 --- /dev/null +++ b/modules/autorotate/lib/pel/PelEntryShort.php @@ -0,0 +1,599 @@ + + * @version $Revision: 419 $ + * @date $Date: 2006-02-20 17:22:36 +0100 (Mon, 20 Feb 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelEntryNumber.php'); +require_once('PelConvert.php'); +require_once('Pel.php'); +/**#@-*/ + + +/** + * Class for holding signed shorts. + * + * This class can hold shorts, either just a single short or an array + * of shorts. The class will be used to manipulate any of the Exif + * tags which has format {@link PelFormat::SHORT} like in this + * example: + * + * + * $w = $ifd->getEntry(PelTag::EXIF_IMAGE_WIDTH); + * $w->setValue($w->getValue() / 2); + * $h = $ifd->getEntry(PelTag::EXIF_IMAGE_HEIGHT); + * $h->setValue($h->getValue() / 2); + * + * + * Here the width and height is updated to 50% of their original + * values. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryShort extends PelEntryNumber { + + /** + * Make a new entry that can hold an unsigned short. + * + * The method accept several integer arguments. The {@link + * getValue} method will always return an array except for when a + * single integer argument is given here. + * + * This means that one can conveniently use objects like this: + * + * $a = new PelEntryShort(PelTag::EXIF_IMAGE_HEIGHT, 42); + * $b = $a->getValue() + 314; + * + * where the call to {@link getValue} will return an integer + * instead of an array with one integer element, which would then + * have to be extracted. + * + * @param PelTag the tag which this entry represents. This should be + * one of the constants defined in {@link PelTag}, e.g., {@link + * PelTag::IMAGE_WIDTH}, {@link PelTag::ISO_SPEED_RATINGS}, + * or any other tag with format {@link PelFormat::SHORT}. + * + * @param int $value... the short(s) that this entry will + * represent. The argument passed must obey the same rules as the + * argument to {@link setValue}, namely that it should be within + * range of an unsigned short, that is between 0 and 65535 + * (inclusive). If not, then a {@link PelOverFlowException} will be + * thrown. + */ + function __construct($tag /* $value... */) { + $this->tag = $tag; + $this->min = 0; + $this->max = 65535; + $this->format = PelFormat::SHORT; + + $value = func_get_args(); + array_shift($value); + $this->setValueArray($value); + } + + + /** + * Convert a number into bytes. + * + * @param int the number that should be converted. + * + * @param PelByteOrder one of {@link PelConvert::LITTLE_ENDIAN} and + * {@link PelConvert::BIG_ENDIAN}, specifying the target byte order. + * + * @return string bytes representing the number given. + */ + function numberToBytes($number, $order) { + return PelConvert::shortToBytes($number, $order); + } + + + /** + * Get the value of an entry as text. + * + * The value will be returned in a format suitable for presentation, + * e.g., instead of returning '2' for a {@link + * PelTag::METERING_MODE} tag, 'Center-Weighted Average' is + * returned. + * + * @param boolean some values can be returned in a long or more + * brief form, and this parameter controls that. + * + * @return string the value as text. + */ + function getText($brief = false) { + switch ($this->tag) { + case PelTag::METERING_MODE: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Unknown'); + case 1: + return Pel::tra('Average'); + case 2: + return Pel::tra('Center-Weighted Average'); + case 3: + return Pel::tra('Spot'); + case 4: + return Pel::tra('Multi Spot'); + case 5: + return Pel::tra('Pattern'); + case 6: + return Pel::tra('Partial'); + case 255: + return Pel::tra('Other'); + default: + return $this->value[0]; + } + + case PelTag::COMPRESSION: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 1: + return Pel::tra('Uncompressed'); + case 6: + return Pel::tra('JPEG compression'); + default: + return $this->value[0]; + + } + + case PelTag::PLANAR_CONFIGURATION: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 1: + return Pel::tra('chunky format'); + case 2: + return Pel::tra('planar format'); + default: + return $this->value[0]; + } + + case PelTag::SENSING_METHOD: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 1: + return Pel::tra('Not defined'); + case 2: + return Pel::tra('One-chip color area sensor'); + case 3: + return Pel::tra('Two-chip color area sensor'); + case 4: + return Pel::tra('Three-chip color area sensor'); + case 5: + return Pel::tra('Color sequential area sensor'); + case 7: + return Pel::tra('Trilinear sensor'); + case 8: + return Pel::tra('Color sequential linear sensor'); + default: + return $this->value[0]; + } + + case PelTag::LIGHT_SOURCE: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Unknown'); + case 1: + return Pel::tra('Daylight'); + case 2: + return Pel::tra('Fluorescent'); + case 3: + return Pel::tra('Tungsten (incandescent light)'); + case 4: + return Pel::tra('Flash'); + case 9: + return Pel::tra('Fine weather'); + case 10: + return Pel::tra('Cloudy weather'); + case 11: + return Pel::tra('Shade'); + case 12: + return Pel::tra('Daylight fluorescent'); + case 13: + return Pel::tra('Day white fluorescent'); + case 14: + return Pel::tra('Cool white fluorescent'); + case 15: + return Pel::tra('White fluorescent'); + case 17: + return Pel::tra('Standard light A'); + case 18: + return Pel::tra('Standard light B'); + case 19: + return Pel::tra('Standard light C'); + case 20: + return Pel::tra('D55'); + case 21: + return Pel::tra('D65'); + case 22: + return Pel::tra('D75'); + case 24: + return Pel::tra('ISO studio tungsten'); + case 255: + return Pel::tra('Other'); + default: + return $this->value[0]; + } + + case PelTag::FOCAL_PLANE_RESOLUTION_UNIT: + case PelTag::RESOLUTION_UNIT: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 2: + return Pel::tra('Inch'); + case 3: + return Pel::tra('Centimeter'); + default: + return $this->value[0]; + } + + case PelTag::EXPOSURE_PROGRAM: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Not defined'); + case 1: + return Pel::tra('Manual'); + case 2: + return Pel::tra('Normal program'); + case 3: + return Pel::tra('Aperture priority'); + case 4: + return Pel::tra('Shutter priority'); + case 5: + return Pel::tra('Creative program (biased toward depth of field)'); + case 6: + return Pel::tra('Action program (biased toward fast shutter speed)'); + case 7: + return Pel::tra('Portrait mode (for closeup photos with the background out of focus'); + case 8: + return Pel::tra('Landscape mode (for landscape photos with the background in focus'); + default: + return $this->value[0]; + } + + case PelTag::ORIENTATION: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 1: + return Pel::tra('top - left'); + case 2: + return Pel::tra('top - right'); + case 3: + return Pel::tra('bottom - right'); + case 4: + return Pel::tra('bottom - left'); + case 5: + return Pel::tra('left - top'); + case 6: + return Pel::tra('right - top'); + case 7: + return Pel::tra('right - bottom'); + case 8: + return Pel::tra('left - bottom'); + default: + return $this->value[0]; + } + + case PelTag::YCBCR_POSITIONING: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 1: + return Pel::tra('centered'); + case 2: + return Pel::tra('co-sited'); + default: + return $this->value[0]; + } + + case PelTag::YCBCR_SUB_SAMPLING: + //CC (e->components, 2, v); + if ($this->value[0] == 2 && $this->value[1] == 1) + return 'YCbCr4:2:2'; + if ($this->value[0] == 2 && $this->value[1] == 2) + return 'YCbCr4:2:0'; + + return $this->value[0] . ', ' . $this->value[1]; + + case PelTag::PHOTOMETRIC_INTERPRETATION: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 2: + return 'RGB'; + case 6: + return 'YCbCr'; + default: + return $this->value[0]; + } + + case PelTag::COLOR_SPACE: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 1: + return 'sRGB'; + case 2: + return 'Adobe RGB'; + case 0xffff: + return Pel::tra('Uncalibrated'); + default: + return $this->value[0]; + } + + case PelTag::FLASH: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0x0000: + return Pel::tra('Flash did not fire.'); + case 0x0001: + return Pel::tra('Flash fired.'); + case 0x0005: + return Pel::tra('Strobe return light not detected.'); + case 0x0007: + return Pel::tra('Strobe return light detected.'); + case 0x0009: + return Pel::tra('Flash fired, compulsory flash mode.'); + case 0x000d: + return Pel::tra('Flash fired, compulsory flash mode, return light not detected.'); + case 0x000f: + return Pel::tra('Flash fired, compulsory flash mode, return light detected.'); + case 0x0010: + return Pel::tra('Flash did not fire, compulsory flash mode.'); + case 0x0018: + return Pel::tra('Flash did not fire, auto mode.'); + case 0x0019: + return Pel::tra('Flash fired, auto mode.'); + case 0x001d: + return Pel::tra('Flash fired, auto mode, return light not detected.'); + case 0x001f: + return Pel::tra('Flash fired, auto mode, return light detected.'); + case 0x0020: + return Pel::tra('No flash function.'); + case 0x0041: + return Pel::tra('Flash fired, red-eye reduction mode.'); + case 0x0045: + return Pel::tra('Flash fired, red-eye reduction mode, return light not detected.'); + case 0x0047: + return Pel::tra('Flash fired, red-eye reduction mode, return light detected.'); + case 0x0049: + return Pel::tra('Flash fired, compulsory flash mode, red-eye reduction mode.'); + case 0x004d: + return Pel::tra('Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected.'); + case 0x004f: + return Pel::tra('Flash fired, compulsory flash mode, red-eye reduction mode, return light detected.'); + case 0x0058: + return Pel::tra('Flash did not fire, auto mode, red-eye reduction mode.'); + case 0x0059: + return Pel::tra('Flash fired, auto mode, red-eye reduction mode.'); + case 0x005d: + return Pel::tra('Flash fired, auto mode, return light not detected, red-eye reduction mode.'); + case 0x005f: + return Pel::tra('Flash fired, auto mode, return light detected, red-eye reduction mode.'); + default: + return $this->value[0]; + } + + case PelTag::CUSTOM_RENDERED: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Normal process'); + case 1: + return Pel::tra('Custom process'); + default: + return $this->value[0]; + } + + case PelTag::EXPOSURE_MODE: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Auto exposure'); + case 1: + return Pel::tra('Manual exposure'); + case 2: + return Pel::tra('Auto bracket'); + default: + return $this->value[0]; + } + + case PelTag::WHITE_BALANCE: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Auto white balance'); + case 1: + return Pel::tra('Manual white balance'); + default: + return $this->value[0]; + } + + case PelTag::SCENE_CAPTURE_TYPE: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Standard'); + case 1: + return Pel::tra('Landscape'); + case 2: + return Pel::tra('Portrait'); + case 3: + return Pel::tra('Night scene'); + default: + return $this->value[0]; + } + + case PelTag::GAIN_CONTROL: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Normal'); + case 1: + return Pel::tra('Low gain up'); + case 2: + return Pel::tra('High gain up'); + case 3: + return Pel::tra('Low gain down'); + case 4: + return Pel::tra('High gain down'); + default: + return $this->value[0]; + } + + case PelTag::SATURATION: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Normal'); + case 1: + return Pel::tra('Low saturation'); + case 2: + return Pel::tra('High saturation'); + default: + return $this->value[0]; + } + + case PelTag::CONTRAST: + case PelTag::SHARPNESS: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Normal'); + case 1: + return Pel::tra('Soft'); + case 2: + return Pel::tra('Hard'); + default: + return $this->value[0]; + } + + case PelTag::SUBJECT_DISTANCE_RANGE: + //CC (e->components, 1, v); + switch ($this->value[0]) { + case 0: + return Pel::tra('Unknown'); + case 1: + return Pel::tra('Macro'); + case 2: + return Pel::tra('Close view'); + case 3: + return Pel::tra('Distant view'); + default: + return $this->value[0]; + } + + case PelTag::SUBJECT_AREA: + switch ($this->components) { + case 2: + return Pel::fmt('(x,y) = (%d,%d)', $this->value[0], $this->value[1]); + case 3: + return Pel::fmt('Within distance %d of (x,y) = (%d,%d)', + $this->value[0], $this->value[1], $this->value[2]); + case 4: + return Pel::fmt('Within rectangle (width %d, height %d) around (x,y) = (%d,%d)', + $this->value[0], $this->value[1], + $this->value[2], $this->value[3]); + + default: + return Pel::fmt('Unexpected number of components (%d, expected 2, 3, or 4).', $this->components); + } + + default: + return parent::getText($brief); + } + } +} + + +/** + * Class for holding signed shorts. + * + * This class can hold shorts, either just a single short or an array + * of shorts. The class will be used to manipulate any of the Exif + * tags which has format {@link PelFormat::SSHORT}. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntrySShort extends PelEntryNumber { + + /** + * Make a new entry that can hold a signed short. + * + * The method accept several integer arguments. The {@link + * getValue} method will always return an array except for when a + * single integer argument is given here. + * + * @param PelTag the tag which this entry represents. This + * should be one of the constants defined in {@link PelTag} + * which has format {@link PelFormat::SSHORT}. + * + * @param int $value... the signed short(s) that this entry will + * represent. The argument passed must obey the same rules as the + * argument to {@link setValue}, namely that it should be within + * range of a signed short, that is between -32768 to 32767 + * (inclusive). If not, then a {@link PelOverFlowException} will be + * thrown. + */ + function __construct($tag /* $value... */) { + $this->tag = $tag; + $this->min = -32768; + $this->max = 32767; + $this->format = PelFormat::SSHORT; + + $value = func_get_args(); + array_shift($value); + $this->setValueArray($value); + } + + + /** + * Convert a number into bytes. + * + * @param int the number that should be converted. + * + * @param PelByteOrder one of {@link PelConvert::LITTLE_ENDIAN} and + * {@link PelConvert::BIG_ENDIAN}, specifying the target byte order. + * + * @return string bytes representing the number given. + */ + function numberToBytes($number, $order) { + return PelConvert::sShortToBytes($number, $order); + } +} + + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelEntryUndefined.php b/modules/autorotate/lib/pel/PelEntryUndefined.php new file mode 100644 index 00000000..8ee8df34 --- /dev/null +++ b/modules/autorotate/lib/pel/PelEntryUndefined.php @@ -0,0 +1,416 @@ + + * @version $Revision: 380 $ + * @date $Date: 2005-10-03 14:01:28 +0200 (Mon, 03 Oct 2005) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelEntry.php'); +/**#@-*/ + + +/** + * Class for holding data of any kind. + * + * This class can hold bytes of undefined format. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryUndefined extends PelEntry { + + /** + * Make a new PelEntry that can hold undefined data. + * + * @param PelTag the tag which this entry represents. This + * should be one of the constants defined in {@link PelTag}, + * e.g., {@link PelTag::SCENE_TYPE}, {@link + * PelTag::MAKER_NOTE} or any other tag with format {@link + * PelFormat::UNDEFINED}. + * + * @param string the data that this entry will be holding. Since + * the format is undefined, no checking will be done on the data. + */ + function __construct($tag, $data = '') { + $this->tag = $tag; + $this->format = PelFormat::UNDEFINED; + $this->setValue($data); + } + + + /** + * Set the data of this undefined entry. + * + * @param string the data that this entry will be holding. Since + * the format is undefined, no checking will be done on the data. + */ + function setValue($data) { + $this->components = strlen($data); + $this->bytes = $data; + } + + + /** + * Get the data of this undefined entry. + * + * @return string the data that this entry is holding. + */ + function getValue() { + return $this->bytes; + } + + + /** + * Get the value of this entry as text. + * + * The value will be returned in a format suitable for presentation. + * + * @param boolean some values can be returned in a long or more + * brief form, and this parameter controls that. + * + * @return string the value as text. + */ + function getText($brief = false) { + switch ($this->tag) { + case PelTag::FILE_SOURCE: + //CC (e->components, 1, v); + switch (ord($this->bytes{0})) { + case 0x03: + return 'DSC'; + default: + return sprintf('0x%02X', ord($this->bytes{0})); + } + + case PelTag::SCENE_TYPE: + //CC (e->components, 1, v); + switch (ord($this->bytes{0})) { + case 0x01: + return 'Directly photographed'; + default: + return sprintf('0x%02X', ord($this->bytes{0})); + } + + case PelTag::COMPONENTS_CONFIGURATION: + //CC (e->components, 4, v); + $v = ''; + for ($i = 0; $i < 4; $i++) { + switch (ord($this->bytes{$i})) { + case 0: + $v .= '-'; + break; + case 1: + $v .= 'Y'; + break; + case 2: + $v .= 'Cb'; + break; + case 3: + $v .= 'Cr'; + break; + case 4: + $v .= 'R'; + break; + case 5: + $v .= 'G'; + break; + case 6: + $v .= 'B'; + break; + default: + $v .= 'reserved'; + break; + } + if ($i < 3) $v .= ' '; + } + return $v; + + case PelTag::MAKER_NOTE: + // TODO: handle maker notes. + return $this->components . ' bytes unknown MakerNote data'; + + default: + return '(undefined)'; + } + } + +} + + +/** + * Class for a user comment. + * + * This class is used to hold user comments, which can come in several + * different character encodings. The Exif standard specifies a + * certain format of the {@link PelTag::USER_COMMENT user comment + * tag}, and this class will make sure that the format is kept. + * + * The most basic use of this class simply stores an ASCII encoded + * string for later retrieval using {@link getValue}: + * + * + * $entry = new PelEntryUserComment('An ASCII string'); + * echo $entry->getValue(); + * + * + * The string can be encoded with a different encoding, and if so, the + * encoding must be given using the second argument. The Exif + * standard specifies three known encodings: 'ASCII', 'JIS', and + * 'Unicode'. If the user comment is encoded using a character + * encoding different from the tree known encodings, then the empty + * string should be passed as encoding, thereby specifying that the + * encoding is undefined. + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryUserComment extends PelEntryUndefined { + + /** + * The user comment. + * + * @var string + */ + private $comment; + + /** + * The encoding. + * + * This should be one of 'ASCII', 'JIS', 'Unicode', or ''. + * + * @var string + */ + private $encoding; + + /** + * Make a new entry for holding a user comment. + * + * @param string the new user comment. + * + * @param string the encoding of the comment. This should be either + * 'ASCII', 'JIS', 'Unicode', or the empty string specifying an + * undefined encoding. + */ + function __construct($comment = '', $encoding = 'ASCII') { + parent::__construct(PelTag::USER_COMMENT); + $this->setValue($comment, $encoding); + } + + + /** + * Set the user comment. + * + * @param string the new user comment. + * + * @param string the encoding of the comment. This should be either + * 'ASCII', 'JIS', 'Unicode', or the empty string specifying an + * unknown encoding. + */ + function setValue($comment = '', $encoding = 'ASCII') { + $this->comment = $comment; + $this->encoding = $encoding; + parent::setValue(str_pad($encoding, 8, chr(0)) . $comment); + } + + + /** + * Returns the user comment. + * + * The comment is returned with the same character encoding as when + * it was set using {@link setValue} or {@link __construct the + * constructor}. + * + * @return string the user comment. + */ + function getValue() { + return $this->comment; + } + + + /** + * Returns the encoding. + * + * @return string the encoding of the user comment. + */ + function getEncoding() { + return $this->encoding; + } + + + /** + * Returns the user comment. + * + * @return string the user comment. + */ + function getText($brief = false) { + return $this->comment; + } + +} + + +/** + * Class to hold version information. + * + * There are three Exif entries that hold version information: the + * {@link PelTag::EXIF_VERSION}, {@link + * PelTag::FLASH_PIX_VERSION}, and {@link + * PelTag::INTEROPERABILITY_VERSION} tags. This class manages + * those tags. + * + * The class is used in a very straight-forward way: + * + * $entry = new PelEntryVersion(PelTag::EXIF_VERSION, 2.2); + * + * This creates an entry for an file complying to the Exif 2.2 + * standard. It is easy to test for standards level of an unknown + * entry: + * + * if ($entry->getTag() == PelTag::EXIF_VERSION && + * $entry->getValue() > 2.0) { + * echo 'Recent Exif version.'; + * } + * + * + * @author Martin Geisler + * @package PEL + */ +class PelEntryVersion extends PelEntryUndefined { + + /** + * The version held by this entry. + * + * @var float + */ + private $version; + + + /** + * Make a new entry for holding a version. + * + * @param PelTag the tag. This should be one of {@link + * PelTag::EXIF_VERSION}, {@link PelTag::FLASH_PIX_VERSION}, + * or {@link PelTag::INTEROPERABILITY_VERSION}. + * + * @param float the version. The size of the entries leave room for + * exactly four digits: two digits on either side of the decimal + * point. + */ + function __construct($tag, $version = 0.0) { + parent::__construct($tag); + $this->setValue($version); + } + + + /** + * Set the version held by this entry. + * + * @param float the version. The size of the entries leave room for + * exactly four digits: two digits on either side of the decimal + * point. + */ + function setValue($version = 0.0) { + $this->version = $version; + $major = floor($version); + $minor = ($version - $major)*100; + parent::setValue(sprintf('%02.0f%02.0f', $major, $minor)); + } + + + /** + * Return the version held by this entry. + * + * @return float the version. This will be the same as the value + * given to {@link setValue} or {@link __construct the + * constructor}. + */ + function getValue() { + return $this->version; + } + + + /** + * Return a text string with the version. + * + * @param boolean controls if the output should be brief. Brief + * output omits the word 'Version' so the result is just 'Exif x.y' + * instead of 'Exif Version x.y' if the entry holds information + * about the Exif version --- the output for FlashPix is similar. + * + * @return string the version number with the type of the tag, + * either 'Exif' or 'FlashPix'. + */ + function getText($brief = false) { + $v = $this->version; + + /* Versions numbers like 2.0 would be output as just 2 if we don't + * add the '.0' ourselves. */ + if (floor($this->version) == $this->version) + $v .= '.0'; + + switch ($this->tag) { + case PelTag::EXIF_VERSION: + if ($brief) + return Pel::fmt('Exif %s', $v); + else + return Pel::fmt('Exif Version %s', $v); + + case PelTag::FLASH_PIX_VERSION: + if ($brief) + return Pel::fmt('FlashPix %s', $v); + else + return Pel::fmt('FlashPix Version %s', $v); + + case PelTag::INTEROPERABILITY_VERSION: + if ($brief) + return Pel::fmt('Interoperability %s', $v); + else + return Pel::fmt('Interoperability Version %s', $v); + } + + if ($brief) + return $v; + else + return Pel::fmt('Version %s', $v); + + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelException.php b/modules/autorotate/lib/pel/PelException.php new file mode 100644 index 00000000..b090fd0e --- /dev/null +++ b/modules/autorotate/lib/pel/PelException.php @@ -0,0 +1,87 @@ + + * @version $Revision: 396 $ + * @date $Date: 2005-10-24 00:36:10 +0200 (Mon, 24 Oct 2005) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/** + * A printf() capable exception. + * + * This class is a simple extension of the standard Exception class in + * PHP, and all the methods defined there retain their original + * meaning. + * + * @package PEL + * @subpackage Exception + */ +class PelException extends Exception { + + /** + * Construct a new PEL exception. + * + * @param string $fmt an optional format string can be given. It + * will be used as a format string for vprintf(). The remaining + * arguments will be available for the format string as usual with + * vprintf(). + * + * @param mixed $args,... any number of arguments to be used with + * the format string. + */ + function __construct(/* fmt, args... */) { + $args = func_get_args(); + $fmt = array_shift($args); + parent::__construct(vsprintf($fmt, $args)); + } +} + + +/** + * Exception throw if invalid data is found. + * + * @author Martin Geisler + * @package PEL + * @subpackage Exception + */ +class PelInvalidDataException extends PelException {} + +/** + * Exception throw if an invalid argument is passed. + * + * @author Martin Geisler + * @package PEL + * @subpackage Exception + */ +class PelInvalidArgumentException extends PelException {} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelExif.php b/modules/autorotate/lib/pel/PelExif.php new file mode 100644 index 00000000..6f85d695 --- /dev/null +++ b/modules/autorotate/lib/pel/PelExif.php @@ -0,0 +1,175 @@ + + * @version $Revision: 380 $ + * @date $Date: 2005-10-03 14:01:28 +0200 (Mon, 03 Oct 2005) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelJpegContent.php'); +require_once('PelException.php'); +require_once('PelFormat.php'); +require_once('PelEntry.php'); +require_once('PelTiff.php'); +require_once('PelIfd.php'); +require_once('PelTag.php'); +require_once('Pel.php'); +/**#@-*/ + + +/** + * Class representing Exif data. + * + * Exif data resides as {@link PelJpegContent data} and consists of a + * header followed by a number of {@link PelJpegIfd IFDs}. + * + * The interesting method in this class is {@link getTiff()} which + * will return the {@link PelTiff} object which really holds the data + * which one normally think of when talking about Exif data. This is + * because Exif data is stored as an extension of the TIFF file + * format. + * + * @author Martin Geisler + * @package PEL + */ +class PelExif extends PelJpegContent { + + /** + * Exif header. + * + * The Exif data must start with these six bytes to be considered + * valid. + */ + const EXIF_HEADER = "Exif\0\0"; + + /** + * The PelTiff object contained within. + * + * @var PelTiff + */ + private $tiff = null; + + + /** + * Construct a new Exif object. + * + * The new object will be empty --- use the {@link load()} method to + * load Exif data from a {@link PelDataWindow} object, or use the + * {@link setTiff()} to change the {@link PelTiff} object, which is + * the true holder of the Exif {@link PelEntry entries}. + */ + function __construct() { + + } + + + /** + * Load and parse Exif data. + * + * This will populate the object with Exif data, contained as a + * {@link PelTiff} object. This TIFF object can be accessed with + * the {@link getTiff()} method. + */ + function load(PelDataWindow $d) { + Pel::debug('Parsing %d bytes of Exif data...', $d->getSize()); + + /* There must be at least 6 bytes for the Exif header. */ + if ($d->getSize() < 6) + throw new PelInvalidDataException('Expected at least 6 bytes of Exif ' . + 'data, found just %d bytes.', + $d->getSize()); + + /* Verify the Exif header */ + if ($d->strcmp(0, self::EXIF_HEADER)) { + $d->setWindowStart(strlen(self::EXIF_HEADER)); + } else { + throw new PelInvalidDataException('Exif header not found.'); + } + + /* The rest of the data is TIFF data. */ + $this->tiff = new PelTiff(); + $this->tiff->load($d); + } + + + /** + * Change the TIFF information. + * + * Exif data is really stored as TIFF data, and this method can be + * used to change this data from one {@link PelTiff} object to + * another. + * + * @param PelTiff the new TIFF object. + */ + function setTiff(PelTiff $tiff) { + $this->tiff = $tiff; + } + + + /** + * Get the underlying TIFF object. + * + * The actual Exif data is stored in a {@link PelTiff} object, and + * this method provides access to it. + * + * @return PelTiff the TIFF object with the Exif data. + */ + function getTiff() { + return $this->tiff; + } + + + /** + * Produce bytes for the Exif data. + * + * @return string bytes representing this object. + */ + function getBytes() { + return self::EXIF_HEADER . $this->tiff->getBytes(); + } + + + /** + * Return a string representation of this object. + * + * @return string a string describing this object. This is mostly + * useful for debugging. + */ + function __toString() { + return Pel::tra("Dumping Exif data...\n") . + $this->tiff->__toString(); + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelFormat.php b/modules/autorotate/lib/pel/PelFormat.php new file mode 100644 index 00000000..4b2badcd --- /dev/null +++ b/modules/autorotate/lib/pel/PelFormat.php @@ -0,0 +1,225 @@ + + * @version $Revision: 380 $ + * @date $Date: 2005-10-03 14:01:28 +0200 (Mon, 03 Oct 2005) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/** + * Namespace for functions operating on Exif formats. + * + * This class defines the constants that are to be used whenever one + * has to refer to the format of an Exif tag. They will be + * collectively denoted by the pseudo-type PelFormat throughout the + * documentation. + * + * All the methods defined here are static, and they all operate on a + * single argument which should be one of the class constants. + * + * @author Martin Geisler + * @package PEL + */ +class PelFormat { + + /** + * Unsigned byte. + * + * Each component will be an unsigned 8-bit integer with a value + * between 0 and 255. + * + * Modelled with the {@link PelEntryByte} class. + */ + const BYTE = 1; + + /** + * ASCII string. + * + * Each component will be an ASCII character. + * + * Modelled with the {@link PelEntryAscii} class. + */ + const ASCII = 2; + + /** + * Unsigned short. + * + * Each component will be an unsigned 16-bit integer with a value + * between 0 and 65535. + * + * Modelled with the {@link PelEntryShort} class. + */ + const SHORT = 3; + + /** + * Unsigned long. + * + * Each component will be an unsigned 32-bit integer with a value + * between 0 and 4294967295. + * + * Modelled with the {@link PelEntryLong} class. + */ + const LONG = 4; + + /** + * Unsigned rational number. + * + * Each component will consist of two unsigned 32-bit integers + * denoting the enumerator and denominator. Each integer will have + * a value between 0 and 4294967295. + * + * Modelled with the {@link PelEntryRational} class. + */ + const RATIONAL = 5; + + /** + * Signed byte. + * + * Each component will be a signed 8-bit integer with a value + * between -128 and 127. + * + * Modelled with the {@link PelEntrySByte} class. + */ + const SBYTE = 6; + + /** + * Undefined byte. + * + * Each component will be a byte with no associated interpretation. + * + * Modelled with the {@link PelEntryUndefined} class. + */ + const UNDEFINED = 7; + + /** + * Signed short. + * + * Each component will be a signed 16-bit integer with a value + * between -32768 and 32767. + * + * Modelled with the {@link PelEntrySShort} class. + */ + const SSHORT = 8; + + /** + * Signed long. + * + * Each component will be a signed 32-bit integer with a value + * between -2147483648 and 2147483647. + * + * Modelled with the {@link PelEntrySLong} class. + */ + const SLONG = 9; + + /** + * Signed rational number. + * + * Each component will consist of two signed 32-bit integers + * denoting the enumerator and denominator. Each integer will have + * a value between -2147483648 and 2147483647. + * + * Modelled with the {@link PelEntrySRational} class. + */ + const SRATIONAL = 10; + + /** + * Floating point number. + * + * Entries with this format are not currently implemented. + */ + const FLOAT = 11; + + /** + * Double precision floating point number. + * + * Entries with this format are not currently implemented. + */ + const DOUBLE = 12; + + + /** + * Returns the name of a format. + * + * @param PelFormat the format. + * + * @return string the name of the format, e.g., 'Ascii' for the + * {@link ASCII} format etc. + */ + static function getName($type) { + switch ($type) { + case self::ASCII: return 'Ascii'; + case self::BYTE: return 'Byte'; + case self::SHORT: return 'Short'; + case self::LONG: return 'Long'; + case self::RATIONAL: return 'Rational'; + case self::SBYTE: return 'SByte'; + case self::SSHORT: return 'SShort'; + case self::SLONG: return 'SLong'; + case self::SRATIONAL: return 'SRational'; + case self::FLOAT: return 'Float'; + case self::DOUBLE: return 'Double'; + case self::UNDEFINED: return 'Undefined'; + default: + return Pel::fmt('Unknown format: 0x%X', $type); + } + } + + + /** + * Return the size of components in a given format. + * + * @param PelFormat the format. + * + * @return the size in bytes needed to store one component with the + * given format. + */ + static function getSize($type) { + switch ($type) { + case self::ASCII: return 1; + case self::BYTE: return 1; + case self::SHORT: return 2; + case self::LONG: return 4; + case self::RATIONAL: return 8; + case self::SBYTE: return 1; + case self::SSHORT: return 2; + case self::SLONG: return 4; + case self::SRATIONAL: return 8; + case self::FLOAT: return 4; + case self::DOUBLE: return 8; + case self::UNDEFINED: return 1; + default: + return Pel::fmt('Unknown format: 0x%X', $type); + } + } + +} +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelIfd.php b/modules/autorotate/lib/pel/PelIfd.php new file mode 100644 index 00000000..86c7fad1 --- /dev/null +++ b/modules/autorotate/lib/pel/PelIfd.php @@ -0,0 +1,1200 @@ + + * @version $Revision: 443 $ + * @date $Date: 2006-09-17 20:32:04 +0200 (Sun, 17 Sep 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelEntryUndefined.php'); +require_once('PelEntryRational.php'); +require_once('PelDataWindow.php'); +require_once('PelEntryAscii.php'); +require_once('PelEntryShort.php'); +require_once('PelEntryByte.php'); +require_once('PelEntryLong.php'); +require_once('PelException.php'); +require_once('PelFormat.php'); +require_once('PelEntry.php'); +require_once('PelTag.php'); +require_once('Pel.php'); +/**#@-*/ + + +/** + * Exception indicating a general problem with the IFD. + * + * @author Martin Geisler + * @package PEL + * @subpackage Exception + */ +class PelIfdException extends PelException {} + +/** + * Class representing an Image File Directory (IFD). + * + * {@link PelTiff TIFF data} is structured as a number of Image File + * Directories, IFDs for short. Each IFD contains a number of {@link + * PelEntry entries}, some data and finally a link to the next IFD. + * + * @author Martin Geisler + * @package PEL + */ +class PelIfd implements IteratorAggregate, ArrayAccess { + + /** + * Main image IFD. + * + * Pass this to the constructor when creating an IFD which will be + * the IFD of the main image. + */ + const IFD0 = 0; + + /** + * Thumbnail image IFD. + * + * Pass this to the constructor when creating an IFD which will be + * the IFD of the thumbnail image. + */ + const IFD1 = 1; + + /** + * Exif IFD. + * + * Pass this to the constructor when creating an IFD which will be + * the Exif sub-IFD. + */ + const EXIF = 2; + + /** + * GPS IFD. + * + * Pass this to the constructor when creating an IFD which will be + * the GPS sub-IFD. + */ + const GPS = 3; + + /** + * Interoperability IFD. + * + * Pass this to the constructor when creating an IFD which will be + * the interoperability sub-IFD. + */ + const INTEROPERABILITY = 4; + + /** + * The entries held by this directory. + * + * Each tag in the directory is represented by a {@link PelEntry} + * object in this array. + * + * @var array + */ + private $entries = array(); + + /** + * The type of this directory. + * + * Initialized in the constructor. Must be one of {@link IFD0}, + * {@link IFD1}, {@link EXIF}, {@link GPS}, or {@link + * INTEROPERABILITY}. + * + * @var int + */ + private $type; + + /** + * The next directory. + * + * This will be initialized in the constructor, or be left as null + * if this is the last directory. + * + * @var PelIfd + */ + private $next = null; + + /** + * Sub-directories pointed to by this directory. + * + * This will be an array of ({@link PelTag}, {@link PelIfd}) pairs. + * + * @var array + */ + private $sub = array(); + + /** + * The thumbnail data. + * + * This will be initialized in the constructor, or be left as null + * if there are no thumbnail as part of this directory. + * + * @var PelDataWindow + */ + private $thumb_data = null; + // TODO: use this format to choose between the + // JPEG_INTERCHANGE_FORMAT and STRIP_OFFSETS tags. + // private $thumb_format; + + + /** + * Construct a new Image File Directory (IFD). + * + * The IFD will be empty, use the {@link addEntry()} method to add + * an {@link PelEntry}. Use the {@link setNext()} method to link + * this IFD to another. + * + * @param int type the type of this IFD. Must be one of {@link + * IFD0}, {@link IFD1}, {@link EXIF}, {@link GPS}, or {@link + * INTEROPERABILITY}. An {@link PelIfdException} will be thrown + * otherwise. + */ + function __construct($type) { + if ($type != PelIfd::IFD0 && $type != PelIfd::IFD1 && + $type != PelIfd::EXIF && $type != PelIfd::GPS && + $type != PelIfd::INTEROPERABILITY) + throw new PelIfdException('Unknown IFD type: %d', $type); + + $this->type = $type; + } + + + /** + * Load data into a Image File Directory (IFD). + * + * @param PelDataWindow the data window that will provide the data. + * + * @param int the offset within the window where the directory will + * be found. + */ + function load(PelDataWindow $d, $offset) { + $thumb_offset = 0; + $thumb_length = 0; + + Pel::debug('Constructing IFD at offset %d from %d bytes...', + $offset, $d->getSize()); + + /* Read the number of entries */ + $n = $d->getShort($offset); + Pel::debug('Loading %d entries...', $n); + + $offset += 2; + + /* Check if we have enough data. */ + if ($offset + 12 * $n > $d->getSize()) { + $n = floor(($offset - $d->getSize()) / 12); + Pel::maybeThrow(new PelIfdException('Adjusted to: %d.', $n)); + } + + for ($i = 0; $i < $n; $i++) { + // TODO: increment window start instead of using offsets. + $tag = $d->getShort($offset + 12 * $i); + Pel::debug('Loading entry with tag 0x%04X: %s (%d of %d)...', + $tag, PelTag::getName($this->type, $tag), $i + 1, $n); + + switch ($tag) { + case PelTag::EXIF_IFD_POINTER: + case PelTag::GPS_INFO_IFD_POINTER: + case PelTag::INTEROPERABILITY_IFD_POINTER: + $o = $d->getLong($offset + 12 * $i + 8); + Pel::debug('Found sub IFD at offset %d', $o); + + /* Map tag to IFD type. */ + if ($tag == PelTag::EXIF_IFD_POINTER) + $type = PelIfd::EXIF; + elseif ($tag == PelTag::GPS_INFO_IFD_POINTER) + $type = PelIfd::GPS; + elseif ($tag == PelTag::INTEROPERABILITY_IFD_POINTER) + $type = PelIfd::INTEROPERABILITY; + + $this->sub[$type] = new PelIfd($type); + $this->sub[$type]->load($d, $o); + break; + case PelTag::JPEG_INTERCHANGE_FORMAT: + $thumb_offset = $d->getLong($offset + 12 * $i + 8); + $this->safeSetThumbnail($d, $thumb_offset, $thumb_length); + break; + case PelTag::JPEG_INTERCHANGE_FORMAT_LENGTH: + $thumb_length = $d->getLong($offset + 12 * $i + 8); + $this->safeSetThumbnail($d, $thumb_offset, $thumb_length); + break; + default: + $format = $d->getShort($offset + 12 * $i + 2); + $components = $d->getLong($offset + 12 * $i + 4); + + /* The data size. If bigger than 4 bytes, the actual data is + * not in the entry but somewhere else, with the offset stored + * in the entry. + */ + $s = PelFormat::getSize($format) * $components; + if ($s > 0) { + $doff = $offset + 12 * $i + 8; + if ($s > 4) + $doff = $d->getLong($doff); + + $data = $d->getClone($doff, $s); + } else { + $data = new PelDataWindow(); + } + + try { + $entry = $this->newEntryFromData($tag, $format, $components, $data); + + if ($this->isValidTag($tag)) { + $entry->setIfdType($this->type); + $this->entries[$tag] = $entry; + } else { + Pel::maybeThrow(new PelInvalidDataException("IFD %s cannot hold\n%s", + $this->getName(), + $entry->__toString())); + } + } catch (PelException $e) { + /* Throw the exception when running in strict mode, store + * otherwise. */ + Pel::maybeThrow($e); + } + + /* The format of the thumbnail is stored in this tag. */ +// TODO: handle TIFF thumbnail. +// if ($tag == PelTag::COMPRESSION) { +// $this->thumb_format = $data->getShort(); +// } + break; + } + } + + /* Offset to next IFD */ + $o = $d->getLong($offset + 12 * $n); + Pel::debug('Current offset is %d, link at %d points to %d.', + $offset, $offset + 12 * $n, $o); + + if ($o > 0) { + /* Sanity check: we need 6 bytes */ + if ($o > $d->getSize() - 6) { + Pel::maybeThrow(new PelIfdException('Bogus offset to next IFD: ' . + '%d > %d!', + $o, $d->getSize() - 6)); + } else { + if ($this->type == PelIfd::IFD1) // IFD1 shouldn't link further... + Pel::maybeThrow(new PelIfdException('IFD1 links to another IFD!')); + + $this->next = new PelIfd(PelIfd::IFD1); + $this->next->load($d, $o); + } + } else { + Pel::debug('Last IFD.'); + } + } + + + /** + * Make a new entry from a bunch of bytes. + * + * This method will create the proper subclass of {@link PelEntry} + * corresponding to the {@link PelTag} and {@link PelFormat} given. + * The entry will be initialized with the data given. + * + * Please note that the data you pass to this method should come + * from an image, that is, it should be raw bytes. If instead you + * want to create an entry for holding, say, an short integer, then + * create a {@link PelEntryShort} object directly and load the data + * into it. + * + * A {@link PelUnexpectedFormatException} is thrown if a mismatch is + * discovered between the tag and format, and likewise a {@link + * PelWrongComponentCountException} is thrown if the number of + * components does not match the requirements of the tag. The + * requirements for a given tag (if any) can be found in the + * documentation for {@link PelTag}. + * + * @param PelTag the tag of the entry. + * + * @param PelFormat the format of the entry. + * + * @param int the components in the entry. + * + * @param PelDataWindow the data which will be used to construct the + * entry. + * + * @return PelEntry a newly created entry, holding the data given. + */ + function newEntryFromData($tag, $format, $components, PelDataWindow $data) { + + /* First handle tags for which we have a specific PelEntryXXX + * class. */ + + switch ($this->type) { + + case self::IFD0: + case self::IFD1: + case self::EXIF: + case self::INTEROPERABILITY: + + switch ($tag) { + case PelTag::DATE_TIME: + case PelTag::DATE_TIME_ORIGINAL: + case PelTag::DATE_TIME_DIGITIZED: + if ($format != PelFormat::ASCII) + throw new PelUnexpectedFormatException($this->type, $tag, $format, + PelFormat::ASCII); + + if ($components != 20) + throw new PelWrongComponentCountException($this->type, $tag, $components, 20); + + // TODO: handle timezones. + return new PelEntryTime($tag, $data->getBytes(0, -1), PelEntryTime::EXIF_STRING); + + case PelTag::COPYRIGHT: + if ($format != PelFormat::ASCII) + throw new PelUnexpectedFormatException($this->type, $tag, $format, + PelFormat::ASCII); + + $v = explode("\0", trim($data->getBytes(), ' ')); + return new PelEntryCopyright($v[0], $v[1]); + + case PelTag::EXIF_VERSION: + case PelTag::FLASH_PIX_VERSION: + case PelTag::INTEROPERABILITY_VERSION: + if ($format != PelFormat::UNDEFINED) + throw new PelUnexpectedFormatException($this->type, $tag, $format, + PelFormat::UNDEFINED); + + return new PelEntryVersion($tag, $data->getBytes() / 100); + + case PelTag::USER_COMMENT: + if ($format != PelFormat::UNDEFINED) + throw new PelUnexpectedFormatException($this->type, $tag, $format, + PelFormat::UNDEFINED); + if ($data->getSize() < 8) { + return new PelEntryUserComment(); + } else { + return new PelEntryUserComment($data->getBytes(8), + rtrim($data->getBytes(0, 8))); + } + + case PelTag::XP_TITLE: + case PelTag::XP_COMMENT: + case PelTag::XP_AUTHOR: + case PelTag::XP_KEYWORDS: + case PelTag::XP_SUBJECT: + if ($format != PelFormat::BYTE) + throw new PelUnexpectedFormatException($this->type, $tag, $format, + PelFormat::BYTE); + + $v = ''; + for ($i = 0; $i < $components; $i++) { + $b = $data->getByte($i); + /* Convert the byte to a character if it is non-null --- + * information about the character encoding of these entries + * would be very nice to have! So far my tests have shown + * that characters in the Latin-1 character set are stored in + * a single byte followed by a NULL byte. */ + if ($b != 0) + $v .= chr($b); + } + + return new PelEntryWindowsString($tag, $v); + } + + case self::GPS: + + default: + /* Then handle the basic formats. */ + switch ($format) { + case PelFormat::BYTE: + $v = new PelEntryByte($tag); + for ($i = 0; $i < $components; $i++) + $v->addNumber($data->getByte($i)); + return $v; + + case PelFormat::SBYTE: + $v = new PelEntrySByte($tag); + for ($i = 0; $i < $components; $i++) + $v->addNumber($data->getSByte($i)); + return $v; + + case PelFormat::ASCII: + return new PelEntryAscii($tag, $data->getBytes(0, -1)); + + case PelFormat::SHORT: + $v = new PelEntryShort($tag); + for ($i = 0; $i < $components; $i++) + $v->addNumber($data->getShort($i*2)); + return $v; + + case PelFormat::SSHORT: + $v = new PelEntrySShort($tag); + for ($i = 0; $i < $components; $i++) + $v->addNumber($data->getSShort($i*2)); + return $v; + + case PelFormat::LONG: + $v = new PelEntryLong($tag); + for ($i = 0; $i < $components; $i++) + $v->addNumber($data->getLong($i*4)); + return $v; + + case PelFormat::SLONG: + $v = new PelEntrySLong($tag); + for ($i = 0; $i < $components; $i++) + $v->addNumber($data->getSLong($i*4)); + return $v; + + case PelFormat::RATIONAL: + $v = new PelEntryRational($tag); + for ($i = 0; $i < $components; $i++) + $v->addNumber($data->getRational($i*8)); + return $v; + + case PelFormat::SRATIONAL: + $v = new PelEntrySRational($tag); + for ($i = 0; $i < $components; $i++) + $v->addNumber($data->getSRational($i*8)); + return $v; + + case PelFormat::UNDEFINED: + return new PelEntryUndefined($tag, $data->getBytes()); + + default: + throw new PelException('Unsupported format: %s', + PelFormat::getName($format)); + } + } + } + + + + + /** + * Extract thumbnail data safely. + * + * It is safe to call this method repeatedly with either the offset + * or the length set to zero, since it requires both of these + * arguments to be positive before the thumbnail is extracted. + * + * When both parameters are set it will check the length against the + * available data and adjust as necessary. Only then is the + * thumbnail data loaded. + * + * @param PelDataWindow the data from which the thumbnail will be + * extracted. + * + * @param int the offset into the data. + * + * @param int the length of the thumbnail. + */ + private function safeSetThumbnail(PelDataWindow $d, $offset, $length) { + /* Load the thumbnail if both the offset and the length is + * available. */ + if ($offset > 0 && $length > 0) { + /* Some images have a broken length, so we try to carefully + * check the length before we store the thumbnail. */ + if ($offset + $length > $d->getSize()) { + Pel::maybeThrow(new PelIfdException('Thumbnail length %d bytes ' . + 'adjusted to %d bytes.', + $length, + $d->getSize() - $offset)); + $length = $d->getSize() - $offset; + } + + /* Now set the thumbnail normally. */ + $this->setThumbnail($d->getClone($offset, $length)); + } + } + + + /** + * Set thumbnail data. + * + * Use this to embed an arbitrary JPEG image within this IFD. The + * data will be checked to ensure that it has a proper {@link + * PelJpegMarker::EOI} at the end. If not, then the length is + * adjusted until one if found. An {@link PelIfdException} might be + * thrown (depending on {@link Pel::$strict}) this case. + * + * @param PelDataWindow the thumbnail data. + */ + function setThumbnail(PelDataWindow $d) { + $size = $d->getSize(); + /* Now move backwards until we find the EOI JPEG marker. */ + while ($d->getByte($size - 2) != 0xFF || + $d->getByte($size - 1) != PelJpegMarker::EOI) { + $size--; + } + + if ($size != $d->getSize()) + Pel::maybeThrow(new PelIfdException('Decrementing thumbnail size ' . + 'to %d bytes', $size)); + + $this->thumb_data = $d->getClone(0, $size); + } + + + /** + * Get the type of this directory. + * + * @return int of {@link PelIfd::IFD0}, {@link PelIfd::IFD1}, {@link + * PelIfd::EXIF}, {@link PelIfd::GPS}, or {@link + * PelIfd::INTEROPERABILITY}. + */ + function getType() { + return $this->type; + } + + + /** + * Is a given tag valid for this IFD? + * + * Different types of IFDs can contain different kinds of tags --- + * the {@link IFD0} type, for example, cannot contain a {@link + * PelTag::GPS_LONGITUDE} tag. + * + * A special exception is tags with values above 0xF000. They are + * treated as private tags and will be allowed everywhere (use this + * for testing or for implementing your own types of tags). + * + * @param PelTag the tag. + * + * @return boolean true if the tag is considered valid in this IFD, + * false otherwise. + * + * @see getValidTags() + */ + function isValidTag($tag) { + return $tag > 0xF000 || in_array($tag, $this->getValidTags()); + } + + + /** + * Returns a list of valid tags for this IFD. + * + * @return array an array of {@link PelTag}s which are valid for + * this IFD. + */ + function getValidTags() { + switch ($this->type) { + case PelIfd::IFD0: + case PelIfd::IFD1: + return array(PelTag::IMAGE_WIDTH, + PelTag::IMAGE_LENGTH, + PelTag::BITS_PER_SAMPLE, + PelTag::COMPRESSION, + PelTag::PHOTOMETRIC_INTERPRETATION, + PelTag::IMAGE_DESCRIPTION, + PelTag::MAKE, + PelTag::MODEL, + PelTag::STRIP_OFFSETS, + PelTag::ORIENTATION, + PelTag::SAMPLES_PER_PIXEL, + PelTag::ROWS_PER_STRIP, + PelTag::STRIP_BYTE_COUNTS, + PelTag::X_RESOLUTION, + PelTag::Y_RESOLUTION, + PelTag::PLANAR_CONFIGURATION, + PelTag::RESOLUTION_UNIT, + PelTag::TRANSFER_FUNCTION, + PelTag::SOFTWARE, + PelTag::DATE_TIME, + PelTag::ARTIST, + PelTag::WHITE_POINT, + PelTag::PRIMARY_CHROMATICITIES, + PelTag::JPEG_INTERCHANGE_FORMAT, + PelTag::JPEG_INTERCHANGE_FORMAT_LENGTH, + PelTag::YCBCR_COEFFICIENTS, + PelTag::YCBCR_SUB_SAMPLING, + PelTag::YCBCR_POSITIONING, + PelTag::REFERENCE_BLACK_WHITE, + PelTag::COPYRIGHT, + PelTag::EXIF_IFD_POINTER, + PelTag::GPS_INFO_IFD_POINTER, + PelTag::PRINT_IM); + + case PelIfd::EXIF: + return array(PelTag::EXPOSURE_TIME, + PelTag::FNUMBER, + PelTag::EXPOSURE_PROGRAM, + PelTag::SPECTRAL_SENSITIVITY, + PelTag::ISO_SPEED_RATINGS, + PelTag::OECF, + PelTag::EXIF_VERSION, + PelTag::DATE_TIME_ORIGINAL, + PelTag::DATE_TIME_DIGITIZED, + PelTag::COMPONENTS_CONFIGURATION, + PelTag::COMPRESSED_BITS_PER_PIXEL, + PelTag::SHUTTER_SPEED_VALUE, + PelTag::APERTURE_VALUE, + PelTag::BRIGHTNESS_VALUE, + PelTag::EXPOSURE_BIAS_VALUE, + PelTag::MAX_APERTURE_VALUE, + PelTag::SUBJECT_DISTANCE, + PelTag::METERING_MODE, + PelTag::LIGHT_SOURCE, + PelTag::FLASH, + PelTag::FOCAL_LENGTH, + PelTag::MAKER_NOTE, + PelTag::USER_COMMENT, + PelTag::SUB_SEC_TIME, + PelTag::SUB_SEC_TIME_ORIGINAL, + PelTag::SUB_SEC_TIME_DIGITIZED, + PelTag::XP_TITLE, + PelTag::XP_COMMENT, + PelTag::XP_AUTHOR, + PelTag::XP_KEYWORDS, + PelTag::XP_SUBJECT, + PelTag::FLASH_PIX_VERSION, + PelTag::COLOR_SPACE, + PelTag::PIXEL_X_DIMENSION, + PelTag::PIXEL_Y_DIMENSION, + PelTag::RELATED_SOUND_FILE, + PelTag::FLASH_ENERGY, + PelTag::SPATIAL_FREQUENCY_RESPONSE, + PelTag::FOCAL_PLANE_X_RESOLUTION, + PelTag::FOCAL_PLANE_Y_RESOLUTION, + PelTag::FOCAL_PLANE_RESOLUTION_UNIT, + PelTag::SUBJECT_LOCATION, + PelTag::EXPOSURE_INDEX, + PelTag::SENSING_METHOD, + PelTag::FILE_SOURCE, + PelTag::SCENE_TYPE, + PelTag::CFA_PATTERN, + PelTag::CUSTOM_RENDERED, + PelTag::EXPOSURE_MODE, + PelTag::WHITE_BALANCE, + PelTag::DIGITAL_ZOOM_RATIO, + PelTag::FOCAL_LENGTH_IN_35MM_FILM, + PelTag::SCENE_CAPTURE_TYPE, + PelTag::GAIN_CONTROL, + PelTag::CONTRAST, + PelTag::SATURATION, + PelTag::SHARPNESS, + PelTag::DEVICE_SETTING_DESCRIPTION, + PelTag::SUBJECT_DISTANCE_RANGE, + PelTag::IMAGE_UNIQUE_ID, + PelTag::INTEROPERABILITY_IFD_POINTER, + PelTag::GAMMA); + + case PelIfd::GPS: + return array(PelTag::GPS_VERSION_ID, + PelTag::GPS_LATITUDE_REF, + PelTag::GPS_LATITUDE, + PelTag::GPS_LONGITUDE_REF, + PelTag::GPS_LONGITUDE, + PelTag::GPS_ALTITUDE_REF, + PelTag::GPS_ALTITUDE, + PelTag::GPS_TIME_STAMP, + PelTag::GPS_SATELLITES, + PelTag::GPS_STATUS, + PelTag::GPS_MEASURE_MODE, + PelTag::GPS_DOP, + PelTag::GPS_SPEED_REF, + PelTag::GPS_SPEED, + PelTag::GPS_TRACK_REF, + PelTag::GPS_TRACK, + PelTag::GPS_IMG_DIRECTION_REF, + PelTag::GPS_IMG_DIRECTION, + PelTag::GPS_MAP_DATUM, + PelTag::GPS_DEST_LATITUDE_REF, + PelTag::GPS_DEST_LATITUDE, + PelTag::GPS_DEST_LONGITUDE_REF, + PelTag::GPS_DEST_LONGITUDE, + PelTag::GPS_DEST_BEARING_REF, + PelTag::GPS_DEST_BEARING, + PelTag::GPS_DEST_DISTANCE_REF, + PelTag::GPS_DEST_DISTANCE, + PelTag::GPS_PROCESSING_METHOD, + PelTag::GPS_AREA_INFORMATION, + PelTag::GPS_DATE_STAMP, + PelTag::GPS_DIFFERENTIAL); + + case PelIfd::INTEROPERABILITY: + return array(PelTag::INTEROPERABILITY_INDEX, + PelTag::INTEROPERABILITY_VERSION, + PelTag::RELATED_IMAGE_FILE_FORMAT, + PelTag::RELATED_IMAGE_WIDTH, + PelTag::RELATED_IMAGE_LENGTH); + + /* TODO: Where do these tags belong? +PelTag::FILL_ORDER, +PelTag::DOCUMENT_NAME, +PelTag::TRANSFER_RANGE, +PelTag::JPEG_PROC, +PelTag::BATTERY_LEVEL, +PelTag::IPTC_NAA, +PelTag::INTER_COLOR_PROFILE, +PelTag::CFA_REPEAT_PATTERN_DIM, + */ + } + } + + + /** + * Get the name of an IFD type. + * + * @param int one of {@link PelIfd::IFD0}, {@link PelIfd::IFD1}, + * {@link PelIfd::EXIF}, {@link PelIfd::GPS}, or {@link + * PelIfd::INTEROPERABILITY}. + * + * @return string the name of type. + */ + static function getTypeName($type) { + switch ($type) { + case self::IFD0: + return '0'; + case self::IFD1: + return '1'; + case self::EXIF: + return 'Exif'; + case self::GPS: + return 'GPS'; + case self::INTEROPERABILITY: + return 'Interoperability'; + default: + throw new PelIfdException('Unknown IFD type: %d', $type); + } + } + + + /** + * Get the name of this directory. + * + * @return string the name of this directory. + */ + function getName() { + return $this->getTypeName($this->type); + } + + + /** + * Adds an entry to the directory. + * + * @param PelEntry the entry that will be added. + * + * @todo The entry will be identified with its tag, so each + * directory can only contain one entry with each tag. Is this a + * bug? + */ + function addEntry(PelEntry $e) { + $this->entries[$e->getTag()] = $e; + } + + + /** + * Does a given tag exist in this IFD? + * + * This methods is part of the ArrayAccess SPL interface for + * overriding array access of objects, it allows you to check for + * existance of an entry in the IFD: + * + * + * if (isset($ifd[PelTag::FNUMBER])) + * // ... do something with the F-number. + * + * + * @param PelTag the offset to check. + * + * @return boolean whether the tag exists. + */ + function offsetExists($tag) { + return isset($this->entries[$tag]); + } + + + /** + * Retrieve a given tag from this IFD. + * + * This methods is part of the ArrayAccess SPL interface for + * overriding array access of objects, it allows you to read entries + * from the IFD the same was as for an array: + * + * + * $entry = $ifd[PelTag::FNUMBER]; + * + * + * @param PelTag the tag to return. It is an error to ask for a tag + * which is not in the IFD, just like asking for a non-existant + * array entry. + * + * @return PelEntry the entry. + */ + function offsetGet($tag) { + return $this->entries[$tag]; + } + + + /** + * Set or update a given tag in this IFD. + * + * This methods is part of the ArrayAccess SPL interface for + * overriding array access of objects, it allows you to add new + * entries or replace esisting entries by doing: + * + * + * $ifd[PelTag::EXPOSURE_BIAS_VALUE] = $entry; + * + * + * Note that the actual array index passed is ignored! Instead the + * {@link PelTag} from the entry is used. + * + * @param PelTag the offset to update. + * + * @param PelEntry the new value. + */ + function offsetSet($tag, $e) { + if ($e instanceof PelEntry) { + $tag = $e->getTag(); + $this->entries[$tag] = $e; + } else { + throw new PelInvalidArgumentException('Argument "%s" must be a PelEntry.', $e); + } + } + + + /** + * Unset a given tag in this IFD. + * + * This methods is part of the ArrayAccess SPL interface for + * overriding array access of objects, it allows you to delete + * entries in the IFD by doing: + * + * + * unset($ifd[PelTag::EXPOSURE_BIAS_VALUE]) + * + * + * @param PelTag the offset to delete. + */ + function offsetUnset($tag) { + unset($this->entries[$tag]); + } + + + /** + * Retrieve an entry. + * + * @param PelTag the tag identifying the entry. + * + * @return PelEntry the entry associated with the tag, or null if no + * such entry exists. + */ + function getEntry($tag) { + if (isset($this->entries[$tag])) + return $this->entries[$tag]; + else + return null; + } + + + /** + * Returns all entries contained in this IFD. + * + * @return array an array of {@link PelEntry} objects, or rather + * descendant classes. The array has {@link PelTag}s as keys + * and the entries as values. + * + * @see getEntry + * @see getIterator + */ + function getEntries() { + return $this->entries; + } + + + /** + * Return an iterator for all entries contained in this IFD. + * + * Used with foreach as in + * + * + * foreach ($ifd as $tag => $entry) { + * // $tag is now a PelTag and $entry is a PelEntry object. + * } + * + * + * @return Iterator an iterator using the {@link PelTag tags} as + * keys and the entries as values. + */ + function getIterator() { + return new ArrayIterator($this->entries); + } + + + /** + * Returns available thumbnail data. + * + * @return string the bytes in the thumbnail, if any. If the IFD + * does not contain any thumbnail data, the empty string is + * returned. + * + * @todo Throw an exception instead when no data is available? + * + * @todo Return the $this->thumb_data object instead of the bytes? + */ + function getThumbnailData() { + if ($this->thumb_data != null) + return $this->thumb_data->getBytes(); + else + return ''; + } + + + /** + * Make this directory point to a new directory. + * + * @param PelIfd the IFD that this directory will point to. + */ + function setNextIfd(PelIfd $i) { + $this->next = $i; + } + + + /** + * Return the IFD pointed to by this directory. + * + * @return PelIfd the next IFD, following this IFD. If this is the + * last IFD, null is returned. + */ + function getNextIfd() { + return $this->next; + } + + + /** + * Check if this is the last IFD. + * + * @return boolean true if there are no following IFD, false + * otherwise. + */ + function isLastIfd() { + return $this->next == null; + } + + + /** + * Add a sub-IFD. + * + * Any previous sub-IFD of the same type will be overwritten. + * + * @param PelIfd the sub IFD. The type of must be one of {@link + * PelIfd::EXIF}, {@link PelIfd::GPS}, or {@link + * PelIfd::INTEROPERABILITY}. + */ + function addSubIfd(PelIfd $sub) { + $this->sub[$sub->type] = $sub; + } + + + /** + * Return a sub IFD. + * + * @param int the type of the sub IFD. This must be one of {@link + * PelIfd::EXIF}, {@link PelIfd::GPS}, or {@link + * PelIfd::INTEROPERABILITY}. + * + * @return PelIfd the IFD associated with the type, or null if that + * sub IFD does not exist. + */ + function getSubIfd($type) { + if (isset($this->sub[$type])) + return $this->sub[$type]; + else + return null; + } + + + /** + * Get all sub IFDs. + * + * @return array an associative array with (IFD-type, {@link + * PelIfd}) pairs. + */ + function getSubIfds() { + return $this->sub; + } + + + /** + * Turn this directory into bytes. + * + * This directory will be turned into a byte string, with the + * specified byte order. The offsets will be calculated from the + * offset given. + * + * @param int the offset of the first byte of this directory. + * + * @param PelByteOrder the byte order that should be used when + * turning integers into bytes. This should be one of {@link + * PelConvert::LITTLE_ENDIAN} and {@link PelConvert::BIG_ENDIAN}. + */ + function getBytes($offset, $order) { + $bytes = ''; + $extra_bytes = ''; + + Pel::debug('Bytes from IDF will start at offset %d within Exif data', + $offset); + + $n = count($this->entries) + count($this->sub); + if ($this->thumb_data != null) { + /* We need two extra entries for the thumbnail offset and + * length. */ + $n += 2; + } + + $bytes .= PelConvert::shortToBytes($n, $order); + + /* Initialize offset of extra data. This included the bytes + * preceding this IFD, the bytes needed for the count of entries, + * the entries themselves (and sub entries), the extra data in the + * entries, and the IFD link. + */ + $end = $offset + 2 + 12 * $n + 4; + + foreach ($this->entries as $tag => $entry) { + /* Each entry is 12 bytes long. */ + $bytes .= PelConvert::shortToBytes($entry->getTag(), $order); + $bytes .= PelConvert::shortToBytes($entry->getFormat(), $order); + $bytes .= PelConvert::longToBytes($entry->getComponents(), $order); + + /* + * Size? If bigger than 4 bytes, the actual data is not in + * the entry but somewhere else. + */ + $data = $entry->getBytes($order); + $s = strlen($data); + if ($s > 4) { + Pel::debug('Data size %d too big, storing at offset %d instead.', + $s, $end); + $bytes .= PelConvert::longToBytes($end, $order); + $extra_bytes .= $data; + $end += $s; + } else { + Pel::debug('Data size %d fits.', $s); + /* Copy data directly, pad with NULL bytes as necessary to + * fill out the four bytes available.*/ + $bytes .= $data . str_repeat(chr(0), 4 - $s); + } + } + + if ($this->thumb_data != null) { + Pel::debug('Appending %d bytes of thumbnail data at %d', + $this->thumb_data->getSize(), $end); + // TODO: make PelEntry a class that can be constructed with + // arguments corresponding to the newt four lines. + $bytes .= PelConvert::shortToBytes(PelTag::JPEG_INTERCHANGE_FORMAT_LENGTH, + $order); + $bytes .= PelConvert::shortToBytes(PelFormat::LONG, $order); + $bytes .= PelConvert::longToBytes(1, $order); + $bytes .= PelConvert::longToBytes($this->thumb_data->getSize(), + $order); + + $bytes .= PelConvert::shortToBytes(PelTag::JPEG_INTERCHANGE_FORMAT, + $order); + $bytes .= PelConvert::shortToBytes(PelFormat::LONG, $order); + $bytes .= PelConvert::longToBytes(1, $order); + $bytes .= PelConvert::longToBytes($end, $order); + + $extra_bytes .= $this->thumb_data->getBytes(); + $end += $this->thumb_data->getSize(); + } + + + /* Find bytes from sub IFDs. */ + $sub_bytes = ''; + foreach ($this->sub as $type => $sub) { + if ($type == PelIfd::EXIF) + $tag = PelTag::EXIF_IFD_POINTER; + elseif ($type == PelIfd::GPS) + $tag = PelTag::GPS_INFO_IFD_POINTER; + elseif ($type == PelIfd::INTEROPERABILITY) + $tag = PelTag::INTEROPERABILITY_IFD_POINTER; + + /* Make an aditional entry with the pointer. */ + $bytes .= PelConvert::shortToBytes($tag, $order); + /* Next the format, which is always unsigned long. */ + $bytes .= PelConvert::shortToBytes(PelFormat::LONG, $order); + /* There is only one component. */ + $bytes .= PelConvert::longToBytes(1, $order); + + $data = $sub->getBytes($end, $order); + $s = strlen($data); + $sub_bytes .= $data; + + $bytes .= PelConvert::longToBytes($end, $order); + $end += $s; + } + + /* Make link to next IFD, if any*/ + if ($this->isLastIFD()) { + $link = 0; + } else { + $link = $end; + } + + Pel::debug('Link to next IFD: %d', $link); + + $bytes .= PelConvert::longtoBytes($link, $order); + + $bytes .= $extra_bytes . $sub_bytes; + + if (!$this->isLastIfd()) + $bytes .= $this->next->getBytes($end, $order); + + return $bytes; + } + + + /** + * Turn this directory into text. + * + * @return string information about the directory, mainly for + * debugging. + */ + function __toString() { + $str = Pel::fmt("Dumping IFD %s with %d entries...\n", + $this->getName(), count($this->entries)); + + foreach ($this->entries as $entry) + $str .= $entry->__toString(); + + $str .= Pel::fmt("Dumping %d sub IFDs...\n", count($this->sub)); + + foreach ($this->sub as $type => $ifd) + $str .= $ifd->__toString(); + + if ($this->next != null) + $str .= $this->next->__toString(); + + return $str; + } + + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelJpeg.php b/modules/autorotate/lib/pel/PelJpeg.php new file mode 100644 index 00000000..f1fb0a7c --- /dev/null +++ b/modules/autorotate/lib/pel/PelJpeg.php @@ -0,0 +1,599 @@ + + * @version $Revision: 473 $ + * @date $Date: 2006-11-24 00:12:21 +0100 (Fri, 24 Nov 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelJpegComment.php'); +require_once('PelJpegContent.php'); +require_once('PelDataWindow.php'); +require_once('PelJpegMarker.php'); +require_once('PelException.php'); +require_once('PelExif.php'); +require_once('Pel.php'); +/**#@-*/ + + +/** + * Exception thrown when an invalid marker is found. + * + * This exception is thrown when PEL expects to find a {@link + * PelJpegMarker} and instead finds a byte that isn't a known marker. + * + * @author Martin Geisler + * @package PEL + * @subpackage Exception + */ +class PelJpegInvalidMarkerException extends PelException { + + /** + * Construct a new invalid marker exception. + * + * The exception will contain a message describing the error, + * including the byte found and the offset of the offending byte. + * + * @param int the byte found. + * + * @param int the offset in the data. + */ + function __construct($marker, $offset) { + parent::__construct('Invalid marker found at offset %d: 0x%2X', + $offset, $marker); + } +} + +/** + * Class for handling JPEG data. + * + * The {@link PelJpeg} class defined here provides an abstraction for + * dealing with a JPEG file. The file will be contain a number of + * sections containing some {@link PelJpegContent content} identified + * by a {@link PelJpegMarker marker}. + * + * The {@link getExif()} method is used get hold of the {@link + * PelJpegMarker::APP1 APP1} section which stores Exif data. So if + * the name of the JPEG file is stored in $filename, then one would + * get hold of the Exif data by saying: + * + * + * $jpeg = new PelJpeg($filename); + * $exif = $jpeg->getExif(); + * $tiff = $exif->getTiff(); + * $ifd0 = $tiff->getIfd(); + * $exif = $ifd0->getSubIfd(PelIfd::EXIF); + * $ifd1 = $ifd0->getNextIfd(); + * + * + * The $idf0 and $ifd1 variables will then be two {@link PelTiff TIFF} + * {@link PelIfd Image File Directories}, in which the data is stored + * under the keys found in {@link PelTag}. + * + * Should one have some image data (in the form of a {@link + * PelDataWindow}) of an unknown type, then the {@link + * PelJpeg::isValid()} function is handy: it will quickly test if the + * data could be valid JPEG data. The {@link PelTiff::isValid()} + * function does the same for TIFF images. + * + * @author Martin Geisler + * @package PEL + */ +class PelJpeg { + + /** + * The sections in the JPEG data. + * + * A JPEG file is built up as a sequence of sections, each section + * is identified with a {@link PelJpegMarker}. Some sections can + * occur more than once in the JPEG stream (the {@link + * PelJpegMarker::DQT DQT} and {@link PelJpegMarker::DHT DTH} + * markers for example) and so this is an array of ({@link + * PelJpegMarker}, {@link PelJpegContent}) pairs. + * + * The content can be either generic {@link PelJpegContent JPEG + * content} or {@link PelExif Exif data}. + * + * @var array + */ + private $sections = array(); + + /** + * The JPEG image data. + * + * @var PelDataWindow + */ + private $jpeg_data = null; + + /** + * Construct a new JPEG object. + * + * The new object will be empty unless an argument is given from + * which it can initialize itself. This can either be the filename + * of a JPEG image, a {@link PelDataWindow} object or a PHP image + * resource handle. + * + * New Exif data (in the form of a {@link PelExif} object) can be + * inserted with the {@link setExif()} method: + * + * + * $jpeg = new PelJpeg($data); + * // Create container for the Exif information: + * $exif = new PelExif(); + * // Now Add a PelTiff object with a PelIfd object with one or more + * // PelEntry objects to $exif... Finally add $exif to $jpeg: + * $jpeg->setExif($exif); + * + */ + function __construct($data = false) { + if ($data === false) + return; + + if (is_string($data)) { + Pel::debug('Initializing PelJpeg object from %s', $data); + $this->loadFile($data); + } elseif ($data instanceof PelDataWindow) { + Pel::debug('Initializing PelJpeg object from PelDataWindow.'); + $this->load($data); + } elseif (is_resource($data) && get_resource_type($data) == 'gd') { + Pel::debug('Initializing PelJpeg object from image resource.'); + /* The ImageJpeg() function insists on printing the bytes + * instead of returning them in a more civil way as a string, so + * we have to buffer the output... */ + ob_start(); + ImageJpeg($data); + $bytes = ob_get_clean(); + $this->load(new PelDataWindow($bytes)); + } else { + throw new PelInvalidArgumentException('Bad type for $data: %s', + gettype($data)); + } + } + + /** + * Load data into a JPEG object. + * + * The data supplied will be parsed and turned into an object + * structure representing the image. This structure can then be + * manipulated and later turned back into an string of bytes. + * + * This methods can be called at any time after a JPEG object has + * been constructed, also after the {@link appendSection()} has been + * called to append custom sections. Loading several JPEG images + * into one object will accumulate the sections, but there will only + * be one {@link PelJpegMarker::SOS} section at any given time. + * + * @param PelDataWindow the data that will be turned into JPEG + * sections. + */ + function load(PelDataWindow $d) { + + Pel::debug('Parsing %d bytes...', $d->getSize()); + + /* JPEG data is stored in big-endian format. */ + $d->setByteOrder(PelConvert::BIG_ENDIAN); + + /* Run through the data to read the sections in the image. After + * each section is read, the start of the data window will be + * moved forward, and after the last section we'll terminate with + * no data left in the window. */ + while ($d->getSize() > 0) { + /* JPEG sections start with 0xFF. The first byte that is not + * 0xFF is a marker (hopefully). + */ + for ($i = 0; $i < 7; $i++) + if ($d->getByte($i) != 0xFF) + break; + + $marker = $d->getByte($i); + + if (!PelJpegMarker::isValid($marker)) + throw new PelJpegInvalidMarkerException($marker, $i); + + /* Move window so first byte becomes first byte in this + * section. */ + $d->setWindowStart($i+1); + + if ($marker == PelJpegMarker::SOI || $marker == PelJpegMarker::EOI) { + $content = new PelJpegContent(new PelDataWindow()); + $this->appendSection($marker, $content); + } else { + /* Read the length of the section. The length includes the + * two bytes used to store the length. */ + $len = $d->getShort(0) - 2; + + Pel::debug('Found %s section of length %d', + PelJpegMarker::getName($marker), $len); + + /* Skip past the length. */ + $d->setWindowStart(2); + + if ($marker == PelJpegMarker::APP1) { + + try { + $content = new PelExif(); + $content->load($d->getClone(0, $len)); + } catch (PelInvalidDataException $e) { + /* We store the data as normal JPEG content if it could + * not be parsed as Exif data. */ + $content = new PelJpegContent($d->getClone(0, $len)); + } + + $this->appendSection($marker, $content); + /* Skip past the data. */ + $d->setWindowStart($len); + + } elseif ($marker == PelJpegMarker::COM) { + + $content = new PelJpegComment(); + $content->load($d->getClone(0, $len)); + $this->appendSection($marker, $content); + $d->setWindowStart($len); + + } else { + + $content = new PelJpegContent($d->getClone(0, $len)); + $this->appendSection($marker, $content); + /* Skip past the data. */ + $d->setWindowStart($len); + + /* In case of SOS, image data will follow. */ + if ($marker == PelJpegMarker::SOS) { + /* Some images have some trailing (garbage?) following the + * EOI marker. To handle this we seek backwards until we + * find the EOI marker. Any trailing content is stored as + * a PelJpegContent object. */ + + $length = $d->getSize(); + while ($d->getByte($length-2) != 0xFF || + $d->getByte($length-1) != PelJpegMarker::EOI) { + $length--; + } + + $this->jpeg_data = $d->getClone(0, $length-2); + Pel::debug('JPEG data: ' . $this->jpeg_data->__toString()); + + /* Append the EOI. */ + $this->appendSection(PelJpegMarker::EOI, + new PelJpegContent(new PelDataWindow())); + + /* Now check to see if there are any trailing data. */ + if ($length != $d->getSize()) { + Pel::maybeThrow(new PelException('Found trailing content ' . + 'after EOI: %d bytes', + $d->getSize() - $length)); + $content = new PelJpegContent($d->getClone($length)); + /* We don't have a proper JPEG marker for trailing + * garbage, so we just use 0x00... */ + $this->appendSection(0x00, $content); + } + + /* Done with the loop. */ + break; + } + } + } + } /* while ($d->getSize() > 0) */ + } + + + /** + * Load data from a file into a JPEG object. + * + * @param string the filename. This must be a readable file. + */ + function loadFile($filename) { + $this->load(new PelDataWindow(file_get_contents($filename))); + } + + + /** + * Set Exif data. + * + * Use this to set the Exif data in the image. This will overwrite + * any old Exif information in the image. + * + * @param PelExif the Exif data. + */ + function setExif(PelExif $exif) { + $app0_offset = 1; + $app1_offset = -1; + + /* Search through all sections looking for APP0 or APP1. */ + for ($i = 0; $i < count($this->sections); $i++) { + if ($this->sections[$i][0] == PelJpegMarker::APP0) { + $app0_offset = $i; + } elseif ($this->sections[$i][0] == PelJpegMarker::APP1) { + $app1_offset = $i; + break; + } + } + + /* Store the Exif data at the appropriate place, either where the + * old Exif data was stored ($app1_offset) or right after APP0 + * ($app0_offset+1). */ + if ($app1_offset > 0) + $this->sections[$app1_offset][1] = $exif; + else + $this->insertSection(PelJpegMarker::APP1, $exif, $app0_offset+1); + } + + + /** + * Get Exif data. + * + * Use this to get the @{link PelExif Exif data} stored. + * + * @return PelExif the Exif data found or null if the image has no + * Exif data. + */ + function getExif() { + $exif = $this->getSection(PelJpegMarker::APP1); + if ($exif instanceof PelExif) + return $exif; + else + return null; + } + + + /** + * Clear any Exif data. + * + * This method will only clear the first @{link PelJpegMarker::APP1} + * section found (there should normally be just one). + */ + function clearExif() { + for ($i = 0; $i < count($this->sections); $i++) { + if ($this->sections[$i][0] == PelJpegMarker::APP1) { + unset($this->sections[$i]); + return; + } + } + } + + + /** + * Append a new section. + * + * Used only when loading an image. If it used again later, then the + * section will end up after the @{link PelJpegMarker::EOI EOI + * marker} and will probably not be useful. + * + * Please use @{link setExif()} instead if you intend to add Exif + * information to an image as that function will know the right + * place to insert the data. + * + * @param PelJpegMarker the marker identifying the new section. + * + * @param PelJpegContent the content of the new section. + */ + function appendSection($marker, PelJpegContent $content) { + $this->sections[] = array($marker, $content); + } + + + /** + * Insert a new section. + * + * Please use @{link setExif()} instead if you intend to add Exif + * information to an image as that function will know the right + * place to insert the data. + * + * @param PelJpegMarker the marker for the new section. + * + * @param PelJpegContent the content of the new section. + * + * @param int the offset where the new section will be inserted --- + * use 0 to insert it at the very beginning, use 1 to insert it + * between sections 1 and 2, etc. + */ + function insertSection($marker, PelJpegContent $content, $offset) { + array_splice($this->sections, $offset, 0, array(array($marker, $content))); + } + + + /** + * Get a section corresponding to a particular marker. + * + * Please use the {@link getExif()} if you just need the Exif data. + * + * This will search through the sections of this JPEG object, + * looking for a section identified with the specified {@link + * PelJpegMarker marker}. The {@link PelJpegContent content} will + * then be returned. The optional argument can be used to skip over + * some of the sections. So if one is looking for the, say, third + * {@link PelJpegMarker::DHT DHT} section one would do: + * + * + * $dht3 = $jpeg->getSection(PelJpegMarker::DHT, 2); + * + * + * @param PelJpegMarker the marker identifying the section. + * + * @param int the number of sections to be skipped. This must be a + * non-negative integer. + * + * @return PelJpegContent the content found, or null if there is no + * content available. + */ + function getSection($marker, $skip = 0) { + foreach ($this->sections as $s) { + if ($s[0] == $marker) + if ($skip > 0) + $skip--; + else + return $s[1]; + } + + return null; + } + + + /** + * Get all sections. + * + * @return array an array of ({@link PelJpegMarker}, {@link + * PelJpegContent}) pairs. Each pair is an array with the {@link + * PelJpegMarker} as the first element and the {@link + * PelJpegContent} as the second element, so the return type is an + * array of arrays. + * + * So to loop through all the sections in a given JPEG image do + * this: + * + * + * foreach ($jpeg->getSections() as $section) { + * $marker = $section[0]; + * $content = $section[1]; + * // Use $marker and $content here. + * } + * + * + * instead of this: + * + * + * foreach ($jpeg->getSections() as $marker => $content) { + * // Does not work the way you would think... + * } + * + * + * The problem is that there could be several sections with the same + * marker, and thus a simple associative array does not suffice. + */ + function getSections() { + return $this->sections; + } + + + /** + * Turn this JPEG object into bytes. + * + * The bytes returned by this method is ready to be stored in a file + * as a valid JPEG image. + * + * @return string bytes representing this JPEG object, including all + * its sections and their associated data. + */ + function getBytes() { + $bytes = ''; + + foreach ($this->sections as $section) { + $m = $section[0]; + $c = $section[1]; + + /* Write the marker */ + $bytes .= "\xFF" . PelJpegMarker::getBytes($m); + /* Skip over empty markers. */ + if ($m == PelJpegMarker::SOI || $m == PelJpegMarker::EOI) + continue; + + $data = $c->getBytes(); + $size = strlen($data) + 2; + + $bytes .= PelConvert::shortToBytes($size, PelConvert::BIG_ENDIAN); + $bytes .= $data; + + /* In case of SOS, we need to write the JPEG data. */ + if ($m == PelJpegMarker::SOS) + $bytes .= $this->jpeg_data->getBytes(); + } + + return $bytes; + + } + + + /** + * Make a string representation of this JPEG object. + * + * This is mainly usefull for debugging. It will show the structure + * of the image, and its sections. + * + * @return string debugging information about this JPEG object. + */ + function __toString() { + $str = Pel::tra("Dumping JPEG data...\n"); + for ($i = 0; $i < count($this->sections); $i++) { + $m = $this->sections[$i][0]; + $c = $this->sections[$i][1]; + $str .= Pel::fmt("Section %d (marker 0x%02X - %s):\n", + $i, $m, PelJpegMarker::getName($m)); + $str .= Pel::fmt(" Description: %s\n", + PelJpegMarker::getDescription($m)); + + if ($m == PelJpegMarker::SOI || + $m == PelJpegMarker::EOI) + continue; + + if ($c instanceof PelExif) { + $str .= Pel::tra(" Content : Exif data\n"); + $str .= $c->__toString() . "\n"; + } elseif ($c instanceof PelJpegComment) { + $str .= Pel::fmt(" Content : %s\n", $c->getValue()); + } else { + $str .= Pel::tra(" Content : Unknown\n"); + } + } + + return $str; + } + + + /** + * Test data to see if it could be a valid JPEG image. + * + * The function will only look at the first few bytes of the data, + * and try to determine if it could be a valid JPEG image based on + * those bytes. This means that the check is more like a heuristic + * than a rigorous check. + * + * @param PelDataWindow the bytes that will be checked. + * + * @return boolean true if the bytes look like the beginning of a + * JPEG image, false otherwise. + * + * @see PelTiff::isValid() + */ + static function isValid(PelDataWindow $d) { + /* JPEG data is stored in big-endian format. */ + $d->setByteOrder(PelConvert::BIG_ENDIAN); + + for ($i = 0; $i < 7; $i++) + if ($d->getByte($i) != 0xFF) + break; + + return $d->getByte($i) == PelJpegMarker::SOI; + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelJpegComment.php b/modules/autorotate/lib/pel/PelJpegComment.php new file mode 100644 index 00000000..feb62c30 --- /dev/null +++ b/modules/autorotate/lib/pel/PelJpegComment.php @@ -0,0 +1,121 @@ + + * @version $Revision: 397 $ + * @date $Date: 2005-10-24 00:40:26 +0200 (Mon, 24 Oct 2005) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelJpegContent.php'); +/**#@-*/ + + +/** + * Class representing JPEG comments. + * + * @author Martin Geisler + * @package PEL + */ +class PelJpegComment extends PelJpegContent { + + /** + * The comment. + * + * @var string + */ + private $comment = ''; + + /** + * Construct a new JPEG comment. + * + * The new comment will contain the string given. + */ + function __construct($comment = '') { + $this->comment = $comment; + } + + + /** + * Load and parse data. + * + * This will load the comment from the data window passed. + */ + function load(PelDataWindow $d) { + $this->comment = $d->getBytes(); + } + + + /** + * Update the value with a new comment. + * + * Any old comment will be overwritten. + * + * @param string the new comment. + */ + function setValue($comment) { + $this->comment = $comment; + } + + + /** + * Get the comment. + * + * @return string the comment. + */ + function getValue() { + return $this->comment; + } + + + /** + * Turn this comment into bytes. + * + * @return string bytes representing this comment. + */ + function getBytes() { + $this->comment; + } + + + /** + * Return a string representation of this object. + * + * @return string the same as {@link getValue()}. + */ + function __toString() { + return $this->getValue(); + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelJpegContent.php b/modules/autorotate/lib/pel/PelJpegContent.php new file mode 100644 index 00000000..93eea2ae --- /dev/null +++ b/modules/autorotate/lib/pel/PelJpegContent.php @@ -0,0 +1,82 @@ + + * @version $Revision: 380 $ + * @date $Date: 2005-10-03 14:01:28 +0200 (Mon, 03 Oct 2005) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelDataWindow.php'); +/**#@-*/ + + +/** + * Class representing content in a JPEG file. + * + * A JPEG file consists of a sequence of each of which has an + * associated {@link PelJpegMarker marker} and some content. This + * class represents the content, and this basic type is just a simple + * holder of such content, represented by a {@link PelDataWindow} + * object. The {@link PelExif} class is an example of more + * specialized JPEG content. + * + * @author Martin Geisler + * @package PEL + */ +class PelJpegContent { + private $data = null; + + /** + * Make a new piece of JPEG content. + * + * @param PelDataWindow the content. + */ + function __construct(PelDataWindow $data) { + $this->data = $data; + } + + + /** + * Return the bytes of the content. + * + * @return string bytes representing this JPEG content. These bytes + * will match the bytes given to {@link __construct the + * constructor}. + */ + function getBytes() { + return $this->data->getBytes(); + } + +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelJpegMarker.php b/modules/autorotate/lib/pel/PelJpegMarker.php new file mode 100644 index 00000000..377b279b --- /dev/null +++ b/modules/autorotate/lib/pel/PelJpegMarker.php @@ -0,0 +1,435 @@ + + * @version $Revision: 432 $ + * @date $Date: 2006-09-06 00:13:00 +0200 (Wed, 06 Sep 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('Pel.php'); +/**#@-*/ + + +/** + * Class with static methods for JPEG markers. + * + * This class defines the constants to be used whenever one refers to + * a JPEG marker. All the methods defined are static, and they all + * operate on one argument which should be one of the class constants. + * They will all be denoted by PelJpegMarker in the documentation. + * + * @author Martin Geisler + * @package PEL + */ +class PelJpegMarker { + + /** Encoding (baseline) */ + const SOF0 = 0xC0; + /** Encoding (extended sequential) */ + const SOF1 = 0xC1; + /** Encoding (progressive) */ + const SOF2 = 0xC2; + /** Encoding (lossless) */ + const SOF3 = 0xC3; + /** Define Huffman table */ + const DHT = 0xC4; + /** Encoding (differential sequential) */ + const SOF5 = 0xC5; + /** Encoding (differential progressive) */ + const SOF6 = 0xC6; + /** Encoding (differential lossless) */ + const SOF7 = 0xC7; + /** Extension */ + const JPG = 0xC8; + /** Encoding (extended sequential, arithmetic) */ + const SOF9 = 0xC9; + /** Encoding (progressive, arithmetic) */ + const SOF10 = 0xCA; + /** Encoding (lossless, arithmetic) */ + const SOF11 = 0xCB; + /** Define arithmetic coding conditioning */ + const DAC = 0xCC; + /** Encoding (differential sequential, arithmetic) */ + const SOF13 = 0xCD; + /** Encoding (differential progressive, arithmetic) */ + const SOF14 = 0xCE; + /** Encoding (differential lossless, arithmetic) */ + const SOF15 = 0xCF; + /** Restart 0 */ + const RST0 = 0xD0; + /** Restart 1 */ + const RST1 = 0xD1; + /** Restart 2 */ + const RST2 = 0xD2; + /** Restart 3 */ + const RST3 = 0xD3; + /** Restart 4 */ + const RST4 = 0xD4; + /** Restart 5 */ + const RST5 = 0xD5; + /** Restart 6 */ + const RST6 = 0xD6; + /** Restart 7 */ + const RST7 = 0xD7; + /** Start of image */ + const SOI = 0xD8; + /** End of image */ + const EOI = 0xD9; + /** Start of scan */ + const SOS = 0xDA; + /** Define quantization table */ + const DQT = 0xDB; + /** Define number of lines */ + const DNL = 0xDC; + /** Define restart interval */ + const DRI = 0xDD; + /** Define hierarchical progression */ + const DHP = 0xDE; + /** Expand reference component */ + const EXP = 0xDF; + /** Application segment 0 */ + const APP0 = 0xE0; + /** + * Application segment 1 + * + * When a JPEG image contains Exif data, the data will normally be + * stored in this section and a call to {@link PelJpeg::getExif()} + * will return a {@link PelExif} object representing it. + */ + const APP1 = 0xE1; + /** Application segment 2 */ + const APP2 = 0xE2; + /** Application segment 3 */ + const APP3 = 0xE3; + /** Application segment 4 */ + const APP4 = 0xE4; + /** Application segment 5 */ + const APP5 = 0xE5; + /** Application segment 6 */ + const APP6 = 0xE6; + /** Application segment 7 */ + const APP7 = 0xE7; + /** Application segment 8 */ + const APP8 = 0xE8; + /** Application segment 9 */ + const APP9 = 0xE9; + /** Application segment 10 */ + const APP10 = 0xEA; + /** Application segment 11 */ + const APP11 = 0xEB; + /** Application segment 12 */ + const APP12 = 0xEC; + /** Application segment 13 */ + const APP13 = 0xED; + /** Application segment 14 */ + const APP14 = 0xEE; + /** Application segment 15 */ + const APP15 = 0xEF; + /** Extension 0 */ + const JPG0 = 0xF0; + /** Extension 1 */ + const JPG1 = 0xF1; + /** Extension 2 */ + const JPG2 = 0xF2; + /** Extension 3 */ + const JPG3 = 0xF3; + /** Extension 4 */ + const JPG4 = 0xF4; + /** Extension 5 */ + const JPG5 = 0xF5; + /** Extension 6 */ + const JPG6 = 0xF6; + /** Extension 7 */ + const JPG7 = 0xF7; + /** Extension 8 */ + const JPG8 = 0xF8; + /** Extension 9 */ + const JPG9 = 0xF9; + /** Extension 10 */ + const JPG10 = 0xFA; + /** Extension 11 */ + const JPG11 = 0xFB; + /** Extension 12 */ + const JPG12 = 0xFC; + /** Extension 13 */ + const JPG13 = 0xFD; + /** Comment */ + const COM = 0xFE; + + /** + * Check if a byte is a valid JPEG marker. + * + * @param PelJpegMarker the byte that will be checked. + * + * @return boolean if the byte is recognized true is returned, + * otherwise false will be returned. + */ + static function isValid($m) { + return ($m >= self::SOF0 && $m <= self::COM); + } + + /** + * Turn a JPEG marker into bytes. + * + * @param PelJpegMarker the marker. + * + * @return string the marker as a string. This will be a string + * with just a single byte since all JPEG markers are simply single + * bytes. + */ + static function getBytes($m) { + return chr($m); + } + + /** + * Return the short name for a marker. + * + * @param PelJpegMarker the marker. + * + * @return string the name of the marker, e.g., 'SOI' for the Start + * of Image marker. + */ + static function getName($m) { + switch ($m) { + case self::SOF0: return 'SOF0'; + case self::SOF1: return 'SOF1'; + case self::SOF2: return 'SOF2'; + case self::SOF3: return 'SOF3'; + case self::SOF5: return 'SOF5'; + case self::SOF6: return 'SOF6'; + case self::SOF7: return 'SOF7'; + case self::SOF9: return 'SOF9'; + case self::SOF10: return 'SOF10'; + case self::SOF11: return 'SOF11'; + case self::SOF13: return 'SOF13'; + case self::SOF14: return 'SOF14'; + case self::SOF15: return 'SOF15'; + case self::SOI: return 'SOI'; + case self::EOI: return 'EOI'; + case self::SOS: return 'SOS'; + case self::COM: return 'COM'; + case self::DHT: return 'DHT'; + case self::JPG: return 'JPG'; + case self::DAC: return 'DAC'; + case self::RST0: return 'RST0'; + case self::RST1: return 'RST1'; + case self::RST2: return 'RST2'; + case self::RST3: return 'RST3'; + case self::RST4: return 'RST4'; + case self::RST5: return 'RST5'; + case self::RST6: return 'RST6'; + case self::RST7: return 'RST7'; + case self::DQT: return 'DQT'; + case self::DNL: return 'DNL'; + case self::DRI: return 'DRI'; + case self::DHP: return 'DHP'; + case self::EXP: return 'EXP'; + case self::APP0: return 'APP0'; + case self::APP1: return 'APP1'; + case self::APP2: return 'APP2'; + case self::APP3: return 'APP3'; + case self::APP4: return 'APP4'; + case self::APP5: return 'APP5'; + case self::APP6: return 'APP6'; + case self::APP7: return 'APP7'; + case self::APP8: return 'APP8'; + case self::APP9: return 'APP9'; + case self::APP10: return 'APP10'; + case self::APP11: return 'APP11'; + case self::APP12: return 'APP12'; + case self::APP13: return 'APP13'; + case self::APP14: return 'APP14'; + case self::APP15: return 'APP15'; + case self::JPG0: return 'JPG0'; + case self::JPG1: return 'JPG1'; + case self::JPG2: return 'JPG2'; + case self::JPG3: return 'JPG3'; + case self::JPG4: return 'JPG4'; + case self::JPG5: return 'JPG5'; + case self::JPG6: return 'JPG6'; + case self::JPG7: return 'JPG7'; + case self::JPG8: return 'JPG8'; + case self::JPG9: return 'JPG9'; + case self::JPG10: return 'JPG10'; + case self::JPG11: return 'JPG11'; + case self::JPG12: return 'JPG12'; + case self::JPG13: return 'JPG13'; + case self::COM: return 'COM'; + default: return Pel::fmt('Unknown marker: 0x%02X', $m); + } + } + + /** + * Returns a description of a JPEG marker. + * + * @param PelJpegMarker the marker. + * + * @return string the description of the marker. + */ + static function getDescription($m) { + switch ($m) { + case self::SOF0: + return Pel::tra('Encoding (baseline)'); + case self::SOF1: + return Pel::tra('Encoding (extended sequential)'); + case self::SOF2: + return Pel::tra('Encoding (progressive)'); + case self::SOF3: + return Pel::tra('Encoding (lossless)'); + case self::SOF5: + return Pel::tra('Encoding (differential sequential)'); + case self::SOF6: + return Pel::tra('Encoding (differential progressive)'); + case self::SOF7: + return Pel::tra('Encoding (differential lossless)'); + case self::SOF9: + return Pel::tra('Encoding (extended sequential, arithmetic)'); + case self::SOF10: + return Pel::tra('Encoding (progressive, arithmetic)'); + case self::SOF11: + return Pel::tra('Encoding (lossless, arithmetic)'); + case self::SOF13: + return Pel::tra('Encoding (differential sequential, arithmetic)'); + case self::SOF14: + return Pel::tra('Encoding (differential progressive, arithmetic)'); + case self::SOF15: + return Pel::tra('Encoding (differential lossless, arithmetic)'); + case self::SOI: + return Pel::tra('Start of image'); + case self::EOI: + return Pel::tra('End of image'); + case self::SOS: + return Pel::tra('Start of scan'); + case self::COM: + return Pel::tra('Comment'); + case self::DHT: + return Pel::tra('Define Huffman table'); + case self::JPG: + return Pel::tra('Extension'); + case self::DAC: + return Pel::tra('Define arithmetic coding conditioning'); + case self::RST0: + return Pel::fmt('Restart %d', 0); + case self::RST1: + return Pel::fmt('Restart %d', 1); + case self::RST2: + return Pel::fmt('Restart %d', 2); + case self::RST3: + return Pel::fmt('Restart %d', 3); + case self::RST4: + return Pel::fmt('Restart %d', 4); + case self::RST5: + return Pel::fmt('Restart %d', 5); + case self::RST6: + return Pel::fmt('Restart %d', 6); + case self::RST7: + return Pel::fmt('Restart %d', 7); + case self::DQT: + return Pel::tra('Define quantization table'); + case self::DNL: + return Pel::tra('Define number of lines'); + case self::DRI: + return Pel::tra('Define restart interval'); + case self::DHP: + return Pel::tra('Define hierarchical progression'); + case self::EXP: + return Pel::tra('Expand reference component'); + case self::APP0: + return Pel::fmt('Application segment %d', 0); + case self::APP1: + return Pel::fmt('Application segment %d', 1); + case self::APP2: + return Pel::fmt('Application segment %d', 2); + case self::APP3: + return Pel::fmt('Application segment %d', 3); + case self::APP4: + return Pel::fmt('Application segment %d', 4); + case self::APP5: + return Pel::fmt('Application segment %d', 5); + case self::APP6: + return Pel::fmt('Application segment %d', 6); + case self::APP7: + return Pel::fmt('Application segment %d', 7); + case self::APP8: + return Pel::fmt('Application segment %d', 8); + case self::APP9: + return Pel::fmt('Application segment %d', 9); + case self::APP10: + return Pel::fmt('Application segment %d', 10); + case self::APP11: + return Pel::fmt('Application segment %d', 11); + case self::APP12: + return Pel::fmt('Application segment %d', 12); + case self::APP13: + return Pel::fmt('Application segment %d', 13); + case self::APP14: + return Pel::fmt('Application segment %d', 14); + case self::APP15: + return Pel::fmt('Application segment %d', 15); + case self::JPG0: + return Pel::fmt('Extension %d', 0); + case self::JPG1: + return Pel::fmt('Extension %d', 1); + case self::JPG2: + return Pel::fmt('Extension %d', 2); + case self::JPG3: + return Pel::fmt('Extension %d', 3); + case self::JPG4: + return Pel::fmt('Extension %d', 4); + case self::JPG5: + return Pel::fmt('Extension %d', 5); + case self::JPG6: + return Pel::fmt('Extension %d', 6); + case self::JPG7: + return Pel::fmt('Extension %d', 7); + case self::JPG8: + return Pel::fmt('Extension %d', 8); + case self::JPG9: + return Pel::fmt('Extension %d', 9); + case self::JPG10: + return Pel::fmt('Extension %d', 10); + case self::JPG11: + return Pel::fmt('Extension %d', 11); + case self::JPG12: + return Pel::fmt('Extension %d', 12); + case self::JPG13: + return Pel::fmt('Extension %d', 13); + case self::COM: + return Pel::tra('Comment'); + default: + return Pel::fmt('Unknown marker: 0x%02X', $m); + } + } +} + +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelTag.php b/modules/autorotate/lib/pel/PelTag.php new file mode 100644 index 00000000..5000811e --- /dev/null +++ b/modules/autorotate/lib/pel/PelTag.php @@ -0,0 +1,1969 @@ + + * @version $Revision: 472 $ + * @date $Date: 2006-11-19 21:29:14 +0100 (Sun, 19 Nov 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('Pel.php'); +require_once('PelIfd.php'); +/**#@-*/ + + +/** + * Class with static methods for Exif tags. + * + * This class defines the constants that represents the Exif tags + * known to PEL. They are supposed to be used whenever one needs to + * specify an Exif tag, and they will be denoted by the pseudo-type + * {@link PelTag} throughout the documentation. + * + * Please note that the constrains on the format and number of + * components given here are advisory only. To follow the Exif + * specification one should obey them, but there is nothing that + * prevents you from creating an {@link IMAGE_LENGTH} entry with two + * or more components, even though the standard says that there should + * be exactly one component. + * + * All the methods in this class are static and should be called with + * the Exif tag on which they should operate. + * + * @author Martin Geisler + * @package PEL + */ +class PelTag { + + /** + * Interoperability index. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 4. + */ + const INTEROPERABILITY_INDEX = 0x0001; + + /** + * Interoperability version. + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: 4. + */ + const INTEROPERABILITY_VERSION = 0x0002; + + /** + * Image width. + * + * Format: {@link PelFormat::SHORT} or {@link PelFormat::LONG}. + * + * Components: 1. + */ + const IMAGE_WIDTH = 0x0100; + + /** + * Image length. + * + * Format: {@link PelFormat::SHORT} or {@link PelFormat::LONG}. + * + * Components: 1. + */ + const IMAGE_LENGTH = 0x0101; + + /** + * Number of bits per component. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 3. + */ + const BITS_PER_SAMPLE = 0x0102; + + /** + * Compression scheme. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const COMPRESSION = 0x0103; + + /** + * Pixel composition. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const PHOTOMETRIC_INTERPRETATION = 0x0106; + + /** + * Fill Orde + * + * Format: Unknown. + * + * Components: Unknown. + */ + const FILL_ORDER = 0x010A; + + /** + * Document Name + * + * Format: Unknown. + * + * Components: Unknown. + */ + const DOCUMENT_NAME = 0x010D; + + /** + * Image Description + * + * Format: {@link PelEntryAscii}. + * + * Components: any number. + */ + const IMAGE_DESCRIPTION = 0x010E; + + /** + * Manufacturer + * + * Format: {@link PelEntryAscii}. + * + * Components: any number. + */ + const MAKE = 0x010F; + + /** + * Model + * + * Format: {@link PelFormat::ASCII}. + * + * Components: any number. + */ + const MODEL = 0x0110; + + /** + * Strip Offsets + * + * Format: {@link PelFormat::SHORT} or {@link PelFormat::LONG}. + * + * Components: any number. + */ + const STRIP_OFFSETS = 0x0111; + + /** + * Orientation of image. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const ORIENTATION = 0x0112; + + /** + * Number of components. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const SAMPLES_PER_PIXEL = 0x0115; + + /** + * Rows per Strip + * + * Format: {@link PelFormat::SHORT} or {@link PelFormat::LONG}. + * + * Components: 1. + */ + const ROWS_PER_STRIP = 0x0116; + + /** + * Strip Byte Count + * + * Format: {@link PelFormat::SHORT} or {@link PelFormat::LONG}. + * + * Components: any number. + */ + const STRIP_BYTE_COUNTS = 0x0117; + + /** + * Image resolution in width direction. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const X_RESOLUTION = 0x011A; + + /** + * Image resolution in height direction. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const Y_RESOLUTION = 0x011B; + + /** + * Image data arrangement. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const PLANAR_CONFIGURATION = 0x011C; + + /** + * Unit of X and Y resolution. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const RESOLUTION_UNIT = 0x0128; + + /** + * Transfer function. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 3. + */ + const TRANSFER_FUNCTION = 0x012D; + + /** + * Software used. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: any number. + */ + const SOFTWARE = 0x0131; + + /** + * File change date and time. + * + * Format: {@link PelFormat::ASCII}, modelled by the {@link + * PelEntryTime} class. + * + * Components: 20. + */ + const DATE_TIME = 0x0132; + + /** + * Person who created the image. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: any number. + */ + const ARTIST = 0x013B; + + /** + * White point chromaticity. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 2. + */ + const WHITE_POINT = 0x013E; + + /** + * Chromaticities of primaries. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 6. + */ + const PRIMARY_CHROMATICITIES = 0x013F; + + /** + * Transfer Range + * + * Format: Unknown. + * + * Components: Unknown. + */ + const TRANSFER_RANGE = 0x0156; + + /** + * JPEGProc + * + * Format: Unknown. + * + * Components: Unknown. + */ + const JPEG_PROC = 0x0200; + + /** + * Offset to JPEG SOI. + * + * Format: {@link PelFormat::LONG}. + * + * Components: 1. + */ + const JPEG_INTERCHANGE_FORMAT = 0x0201; + + /** + * Bytes of JPEG data. + * + * Format: {@link PelFormat::LONG}. + * + * Components: 1. + */ + const JPEG_INTERCHANGE_FORMAT_LENGTH = 0x0202; + + /** + * Color space transformation matrix coefficients. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 3. + */ + const YCBCR_COEFFICIENTS = 0x0211; + + /** + * Subsampling ratio of Y to C. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 2. + */ + const YCBCR_SUB_SAMPLING = 0x0212; + + /** + * Y and C positioning. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const YCBCR_POSITIONING = 0x0213; + + /** + * Pair of black and white reference values. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 6. + */ + const REFERENCE_BLACK_WHITE = 0x0214; + + /** + * Related Image File Format + * + * Format: Unknown. + * + * Components: Unknown. + */ + const RELATED_IMAGE_FILE_FORMAT = 0x1000; + + /** + * Related Image Width + * + * Format: Unknown, probably {@link PelFormat::SHORT}? + * + * Components: Unknown, probably 1. + */ + const RELATED_IMAGE_WIDTH = 0x1001; + + /** Related Image Length + * + * Format: Unknown, probably {@link PelFormat::SHORT}? + * + * Components: Unknown, probably 1. + */ + const RELATED_IMAGE_LENGTH = 0x1002; + + /** + * CFA Repeat Pattern Dim. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 2. + */ + const CFA_REPEAT_PATTERN_DIM = 0x828D; + + /** + * Battery level. + * + * Format: Unknown. + * + * Components: Unknown. + */ + const BATTERY_LEVEL = 0x828F; + + /** + * Copyright holder. + * + * Format: {@link PelFormat::ASCII}, modelled by the {@link + * PelEntryCopyright} class. + * + * Components: any number. + */ + const COPYRIGHT = 0x8298; + + /** + * Exposure Time + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const EXPOSURE_TIME = 0x829A; + + /** + * FNumber + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const FNUMBER = 0x829D; + + /** + * IPTC/NAA + * + * Format: {@link PelFormat::LONG}. + * + * Components: any number. + */ + const IPTC_NAA = 0x83BB; + + /** + * Exif IFD Pointer + * + * Format: {@link PelFormat::LONG}. + * + * Components: 1. + */ + const EXIF_IFD_POINTER = 0x8769; + + /** + * Inter Color Profile + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: any number. + */ + const INTER_COLOR_PROFILE = 0x8773; + + /** + * Exposure Program + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const EXPOSURE_PROGRAM = 0x8822; + + /** + * Spectral Sensitivity + * + * Format: {@link PelFormat::ASCII}. + * + * Components: any number. + */ + const SPECTRAL_SENSITIVITY = 0x8824; + + /** + * GPS Info IFD Pointer + * + * Format: {@link PelFormat::LONG}. + * + * Components: 1. + */ + const GPS_INFO_IFD_POINTER = 0x8825; + + /** + * ISO Speed Ratings + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 2. + */ + const ISO_SPEED_RATINGS = 0x8827; + + /** + * OECF + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: any number. + */ + const OECF = 0x8828; + + /** + * Exif version. + * + * Format: {@link PelFormat::UNDEFINED}, modelled by the {@link + * PelEntryVersion} class. + * + * Components: 4. + */ + const EXIF_VERSION = 0x9000; + + /** + * Date and time of original data generation. + * + * Format: {@link PelFormat::ASCII}, modelled by the {@link + * PelEntryTime} class. + * + * Components: 20. + */ + const DATE_TIME_ORIGINAL = 0x9003; + + /** + * Date and time of digital data generation. + * + * Format: {@link PelFormat::ASCII}, modelled by the {@link + * PelEntryTime} class. + * + * Components: 20. + */ + const DATE_TIME_DIGITIZED = 0x9004; + + /** + * Meaning of each component. + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: 4. + */ + const COMPONENTS_CONFIGURATION = 0x9101; + + /** + * Image compression mode. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const COMPRESSED_BITS_PER_PIXEL = 0x9102; + + /** + * Shutter speed + * + * Format: {@link PelFormat::SRATIONAL}. + * + * Components: 1. + */ + const SHUTTER_SPEED_VALUE = 0x9201; + + /** + * Aperture + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const APERTURE_VALUE = 0x9202; + + /** + * Brightness + * + * Format: {@link PelFormat::SRATIONAL}. + * + * Components: 1. + */ + const BRIGHTNESS_VALUE = 0x9203; + + /** + * Exposure Bias + * + * Format: {@link PelFormat::SRATIONAL}. + * + * Components: 1. + */ + const EXPOSURE_BIAS_VALUE = 0x9204; + + /** + * Max Aperture Value + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const MAX_APERTURE_VALUE = 0x9205; + + /** + * Subject Distance + * + * Format: {@link PelFormat::SRATIONAL}. + * + * Components: 1. + */ + const SUBJECT_DISTANCE = 0x9206; + + /** + * Metering Mode + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const METERING_MODE = 0x9207; + + /** + * Light Source + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const LIGHT_SOURCE = 0x9208; + + /** + * Flash + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const FLASH = 0x9209; + + /** + * Focal Length + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const FOCAL_LENGTH = 0x920A; + + /** + * Subject Area + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 4. + */ + const SUBJECT_AREA = 0x9214; + + /** + * Maker Note + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: any number. + */ + const MAKER_NOTE = 0x927C; + + /** + * User Comment + * + * Format: {@link PelFormat::UNDEFINED}, modelled by the {@link + * PelEntryUserComment} class. + * + * Components: any number. + */ + const USER_COMMENT = 0x9286; + + /** + * SubSec Time + * + * Format: {@link PelFormat::ASCII}. + * + * Components: any number. + */ + const SUB_SEC_TIME = 0x9290; + + /** + * SubSec Time Original + * + * Format: {@link PelFormat::ASCII}. + * + * Components: any number. + */ + const SUB_SEC_TIME_ORIGINAL = 0x9291; + + /** + * SubSec Time Digitized + * + * Format: {@link PelFormat::ASCII}. + * + * Components: any number. + */ + const SUB_SEC_TIME_DIGITIZED = 0x9292; + + /** + * Windows XP Title + * + * Format: {@link PelFormat::BYTE}. + * + * Components: any number. + */ + const XP_TITLE = 0x9C9B; + + + /** + * Windows XP Comment + * + * Format: {@link PelFormat::BYTE}. + * + * Components: any number. + */ + const XP_COMMENT = 0x9C9C; + + + /** + * Windows XP Author + * + * Format: {@link PelFormat::BYTE}. + * + * Components: any number. + */ + const XP_AUTHOR = 0x9C9D; + + + /** + * Windows XP Keywords + * + * Format: {@link PelFormat::BYTE}. + * + * Components: any number. + */ + const XP_KEYWORDS = 0x9C9E; + + + /** + * Windows XP Subject + * + * Format: {@link PelFormat::BYTE}. + * + * Components: any number. + */ + const XP_SUBJECT = 0x9C9F; + + + /** + * Supported Flashpix version + * + * Format: {@link PelFormat::UNDEFINED}, modelled by the {@link + * PelEntryVersion} class. + * + * Components: 4. + */ + const FLASH_PIX_VERSION = 0xA000; + + /** + * Color space information. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const COLOR_SPACE = 0xA001; + + /** + * Valid image width. + * + * Format: {@link PelFormat::SHORT} or {@link PelFormat::LONG}. + * + * Components: 1. + */ + const PIXEL_X_DIMENSION = 0xA002; + + /** + * Valid image height. + * + * Format: {@link PelFormat::SHORT} or {@link PelFormat::LONG}. + * + * Components: 1. + */ + const PIXEL_Y_DIMENSION = 0xA003; + + /** + * Related audio file. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: any number. + */ + const RELATED_SOUND_FILE = 0xA004; + + /** + * Interoperability IFD Pointer + * + * Format: {@link PelFormat::LONG}. + * + * Components: 1. + */ + const INTEROPERABILITY_IFD_POINTER = 0xA005; + + /** + * Flash energy. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const FLASH_ENERGY = 0xA20B; + + /** + * Spatial frequency response. + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: any number. + */ + const SPATIAL_FREQUENCY_RESPONSE = 0xA20C; + + /** + * Focal plane X resolution. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const FOCAL_PLANE_X_RESOLUTION = 0xA20E; + + /** + * Focal plane Y resolution. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const FOCAL_PLANE_Y_RESOLUTION = 0xA20F; + + /** + * Focal plane resolution unit. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const FOCAL_PLANE_RESOLUTION_UNIT = 0xA210; + + /** + * Subject location. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const SUBJECT_LOCATION = 0xA214; + + /** + * Exposure index. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const EXPOSURE_INDEX = 0xA215; + + /** + * Sensing method. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const SENSING_METHOD = 0xA217; + + /** + * File source. + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: 1. + */ + const FILE_SOURCE = 0xA300; + + /** + * Scene type. + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: 1. + */ + const SCENE_TYPE = 0xA301; + + /** + * CFA pattern. + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: any number. + */ + const CFA_PATTERN = 0xA302; + + /** + * Custom image processing. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const CUSTOM_RENDERED = 0xA401; + + /** + * Exposure mode. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const EXPOSURE_MODE = 0xA402; + + /** + * White balance. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const WHITE_BALANCE = 0xA403; + + /** + * Digital zoom ratio. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const DIGITAL_ZOOM_RATIO = 0xA404; + + /** + * Focal length in 35mm film. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const FOCAL_LENGTH_IN_35MM_FILM = 0xA405; + + /** + * Scene capture type. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const SCENE_CAPTURE_TYPE = 0xA406; + + /** + * Gain control. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const GAIN_CONTROL = 0xA407; + + /** + * Contrast. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const CONTRAST = 0xA408; + + /** + * Saturation. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const SATURATION = 0xA409; + + /** + * Sharpness. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const SHARPNESS = 0xA40A; + + /** + * Device settings description. + * + * This tag indicates information on the picture-taking conditions + * of a particular camera model. The tag is used only to indicate + * the picture-taking conditions in the reader. + */ + const DEVICE_SETTING_DESCRIPTION = 0xA40B; + + /** + * Subject distance range. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const SUBJECT_DISTANCE_RANGE = 0xA40C; + + /** + * Image unique ID. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 32. + */ + const IMAGE_UNIQUE_ID = 0xA420; + + /** + * Gamma. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const GAMMA = 0xA500; + + /** + * PrintIM + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: unknown. + */ + const PRINT_IM = 0xC4A5; + + /** + * GPS tag version. + * + * Format: {@link PelFormat::BYTE}. + * + * Components: 4. + */ + const GPS_VERSION_ID = 0x0000; + + /** + * North or South Latitude. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_LATITUDE_REF = 0x0001; + + /** + * Latitude. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 3. + */ + const GPS_LATITUDE = 0x0002; + + /** + * East or West Longitude. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_LONGITUDE_REF = 0x0003; + + /** + * Longitude. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 3. + */ + const GPS_LONGITUDE = 0x0004; + + /** + * Altitude reference. + * + * Format: {@link PelFormat::BYTE}. + * + * Components: 1. + */ + const GPS_ALTITUDE_REF = 0x0005; + + /** + * Altitude. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const GPS_ALTITUDE = 0x0006; + + /** + * GPS time (atomic clock). + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 3. + */ + const GPS_TIME_STAMP = 0x0007; + + /** + * GPS satellites used for measurement. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: Any. + */ + const GPS_SATELLITES = 0x0008; + + /** + * GPS receiver status. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_STATUS = 0x0009; + + /** + * GPS measurement mode. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_MEASURE_MODE = 0x000A; + + /** + * Measurement precision. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const GPS_DOP = 0x000B; + + /** + * Speed unit. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_SPEED_REF = 0x000C; + + /** + * Speed of GPS receiver. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const GPS_SPEED = 0x000D; + + /** + * Reference for direction of movement. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_TRACK_REF = 0x000E; + + /** + * Direction of movement. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const GPS_TRACK = 0x000F; + + /** + * Reference for direction of image. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_IMG_DIRECTION_REF = 0x0010; + + /** + * Direction of image. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const GPS_IMG_DIRECTION = 0x0011; + + /** + * Geodetic survey data used. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: Any. + */ + const GPS_MAP_DATUM = 0x0012; + + /** + * Reference for latitude of destination. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_DEST_LATITUDE_REF = 0x0013; + + /** + * Latitude of destination. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 3. + */ + const GPS_DEST_LATITUDE = 0x0014; + + /** + * Reference for longitude of destination. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_DEST_LONGITUDE_REF = 0x0015; + + /** + * Longitude of destination. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 3. + */ + const GPS_DEST_LONGITUDE = 0x0016; + + /** + * Reference for bearing of destination. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_DEST_BEARING_REF = 0x0017; + + /** + * Bearing of destination. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const GPS_DEST_BEARING = 0x0018; + + /** + * Reference for distance to destination. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 2. + */ + const GPS_DEST_DISTANCE_REF = 0x0019; + + /** + * Distance to destination. + * + * Format: {@link PelFormat::RATIONAL}. + * + * Components: 1. + */ + const GPS_DEST_DISTANCE = 0x001A; + + /** + * Name of GPS processing method. + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: Any. + */ + const GPS_PROCESSING_METHOD = 0x001B; + + /** + * Name of GPS area. + * + * Format: {@link PelFormat::UNDEFINED}. + * + * Components: Any. + */ + const GPS_AREA_INFORMATION = 0x001C; + + /** + * GPS date. + * + * Format: {@link PelFormat::ASCII}. + * + * Components: 11. + */ + const GPS_DATE_STAMP = 0x001D; + + /** + * GPS differential correction. + * + * Format: {@link PelFormat::SHORT}. + * + * Components: 1. + */ + const GPS_DIFFERENTIAL = 0x001E; + + + /** + * Returns a short name for an Exif tag. + * + * @param int the IFD type of the tag, one of {@link PelIfd::IFD0}, + * {@link PelIfd::IFD1}, {@link PelIfd::EXIF}, {@link PelIfd::GPS}, + * or {@link PelIfd::INTEROPERABILITY}. + * + * @param PelTag the tag. + * + * @return string the short name of the tag, e.g., 'ImageWidth' for + * the {@link IMAGE_WIDTH} tag. If the tag is not known, the string + * 'Unknown:0xTTTT' will be returned where 'TTTT' is the hexadecimal + * representation of the tag. + */ + static function getName($type, $tag) { + + switch ($type) { + case PelIfd::IFD0: + case PelIfd::IFD1: + case PelIfd::EXIF: + case PelIfd::INTEROPERABILITY: + + switch ($tag) { + case self::INTEROPERABILITY_INDEX: + return 'InteroperabilityIndex'; + case self::INTEROPERABILITY_VERSION: + return 'InteroperabilityVersion'; + case self::IMAGE_WIDTH: + return 'ImageWidth'; + case self::IMAGE_LENGTH: + return 'ImageLength'; + case self::BITS_PER_SAMPLE: + return 'BitsPerSample'; + case self::COMPRESSION: + return 'Compression'; + case self::PHOTOMETRIC_INTERPRETATION: + return 'PhotometricInterpretation'; + case self::FILL_ORDER: + return 'FillOrder'; + case self::DOCUMENT_NAME: + return 'DocumentName'; + case self::IMAGE_DESCRIPTION: + return 'ImageDescription'; + case self::MAKE: + return 'Make'; + case self::MODEL: + return 'Model'; + case self::STRIP_OFFSETS: + return 'StripOffsets'; + case self::ORIENTATION: + return 'Orientation'; + case self::SAMPLES_PER_PIXEL: + return 'SamplesPerPixel'; + case self::ROWS_PER_STRIP: + return 'RowsPerStrip'; + case self::STRIP_BYTE_COUNTS: + return 'StripByteCounts'; + case self::X_RESOLUTION: + return 'XResolution'; + case self::Y_RESOLUTION: + return 'YResolution'; + case self::PLANAR_CONFIGURATION: + return 'PlanarConfiguration'; + case self::RESOLUTION_UNIT: + return 'ResolutionUnit'; + case self::TRANSFER_FUNCTION: + return 'TransferFunction'; + case self::SOFTWARE: + return 'Software'; + case self::DATE_TIME: + return 'DateTime'; + case self::ARTIST: + return 'Artist'; + case self::WHITE_POINT: + return 'WhitePoint'; + case self::PRIMARY_CHROMATICITIES: + return 'PrimaryChromaticities'; + case self::TRANSFER_RANGE: + return 'TransferRange'; + case self::JPEG_PROC: + return 'JPEGProc'; + case self::JPEG_INTERCHANGE_FORMAT: + return 'JPEGInterchangeFormat'; + case self::JPEG_INTERCHANGE_FORMAT_LENGTH: + return 'JPEGInterchangeFormatLength'; + case self::YCBCR_COEFFICIENTS: + return 'YCbCrCoefficients'; + case self::YCBCR_SUB_SAMPLING: + return 'YCbCrSubSampling'; + case self::YCBCR_POSITIONING: + return 'YCbCrPositioning'; + case self::REFERENCE_BLACK_WHITE: + return 'ReferenceBlackWhite'; + case self::RELATED_IMAGE_FILE_FORMAT: + return 'RelatedImageFileFormat'; + case self::RELATED_IMAGE_WIDTH: + return 'RelatedImageWidth'; + case self::RELATED_IMAGE_LENGTH: + return 'RelatedImageLength'; + case self::CFA_REPEAT_PATTERN_DIM: + return 'CFARepeatPatternDim'; + case self::CFA_PATTERN: + return 'CFAPattern'; + case self::BATTERY_LEVEL: + return 'BatteryLevel'; + case self::COPYRIGHT: + return 'Copyright'; + case self::EXPOSURE_TIME: + return 'ExposureTime'; + case self::FNUMBER: + return 'FNumber'; + case self::IPTC_NAA: + return 'IPTC/NAA'; + case self::EXIF_IFD_POINTER: + return 'ExifIFDPointer'; + case self::INTER_COLOR_PROFILE: + return 'InterColorProfile'; + case self::EXPOSURE_PROGRAM: + return 'ExposureProgram'; + case self::SPECTRAL_SENSITIVITY: + return 'SpectralSensitivity'; + case self::GPS_INFO_IFD_POINTER: + return 'GPSInfoIFDPointer'; + case self::ISO_SPEED_RATINGS: + return 'ISOSpeedRatings'; + case self::OECF: + return 'OECF'; + case self::EXIF_VERSION: + return 'ExifVersion'; + case self::DATE_TIME_ORIGINAL: + return 'DateTimeOriginal'; + case self::DATE_TIME_DIGITIZED: + return 'DateTimeDigitized'; + case self::COMPONENTS_CONFIGURATION: + return 'ComponentsConfiguration'; + case self::COMPRESSED_BITS_PER_PIXEL: + return 'CompressedBitsPerPixel'; + case self::SHUTTER_SPEED_VALUE: + return 'ShutterSpeedValue'; + case self::APERTURE_VALUE: + return 'ApertureValue'; + case self::BRIGHTNESS_VALUE: + return 'BrightnessValue'; + case self::EXPOSURE_BIAS_VALUE: + return 'ExposureBiasValue'; + case self::MAX_APERTURE_VALUE: + return 'MaxApertureValue'; + case self::SUBJECT_DISTANCE: + return 'SubjectDistance'; + case self::METERING_MODE: + return 'MeteringMode'; + case self::LIGHT_SOURCE: + return 'LightSource'; + case self::FLASH: + return 'Flash'; + case self::FOCAL_LENGTH: + return 'FocalLength'; + case self::MAKER_NOTE: + return 'MakerNote'; + case self::USER_COMMENT: + return 'UserComment'; + case self::SUB_SEC_TIME: + return 'SubSecTime'; + case self::SUB_SEC_TIME_ORIGINAL: + return 'SubSecTimeOriginal'; + case self::SUB_SEC_TIME_DIGITIZED: + return 'SubSecTimeDigitized'; + case self::XP_TITLE: + return 'WindowsXPTitle'; + case self::XP_COMMENT: + return 'WindowsXPComment'; + case self::XP_AUTHOR: + return 'WindowsXPAuthor'; + case self::XP_KEYWORDS: + return 'WindowsXPKeywords'; + case self::XP_SUBJECT: + return 'WindowsXPSubject'; + case self::FLASH_PIX_VERSION: + return 'FlashPixVersion'; + case self::COLOR_SPACE: + return 'ColorSpace'; + case self::PIXEL_X_DIMENSION: + return 'PixelXDimension'; + case self::PIXEL_Y_DIMENSION: + return 'PixelYDimension'; + case self::RELATED_SOUND_FILE: + return 'RelatedSoundFile'; + case self::INTEROPERABILITY_IFD_POINTER: + return 'InteroperabilityIFDPointer'; + case self::FLASH_ENERGY: + return 'FlashEnergy'; + case self::SPATIAL_FREQUENCY_RESPONSE: + return 'SpatialFrequencyResponse'; + case self::FOCAL_PLANE_X_RESOLUTION: + return 'FocalPlaneXResolution'; + case self::FOCAL_PLANE_Y_RESOLUTION: + return 'FocalPlaneYResolution'; + case self::FOCAL_PLANE_RESOLUTION_UNIT: + return 'FocalPlaneResolutionUnit'; + case self::SUBJECT_LOCATION: + return 'SubjectLocation'; + case self::EXPOSURE_INDEX: + return 'ExposureIndex'; + case self::SENSING_METHOD: + return 'SensingMethod'; + case self::FILE_SOURCE: + return 'FileSource'; + case self::SCENE_TYPE: + return 'SceneType'; + case self::SUBJECT_AREA: + return 'SubjectArea'; + case self::CUSTOM_RENDERED: + return 'CustomRendered'; + case self::EXPOSURE_MODE: + return 'ExposureMode'; + case self::WHITE_BALANCE: + return 'WhiteBalance'; + case self::DIGITAL_ZOOM_RATIO: + return 'DigitalZoomRatio'; + case self::FOCAL_LENGTH_IN_35MM_FILM: + return 'FocalLengthIn35mmFilm'; + case self::SCENE_CAPTURE_TYPE: + return 'SceneCaptureType'; + case self::GAIN_CONTROL: + return 'GainControl'; + case self::CONTRAST: + return 'Contrast'; + case self::SATURATION: + return 'Saturation'; + case self::SHARPNESS: + return 'Sharpness'; + case self::DEVICE_SETTING_DESCRIPTION: + return 'DeviceSettingDescription'; + case self::SUBJECT_DISTANCE_RANGE: + return 'SubjectDistanceRange'; + case self::IMAGE_UNIQUE_ID: + return 'ImageUniqueID'; + case self::GAMMA: + return 'Gamma'; + case self::PRINT_IM: + return 'PrintIM'; + } + + case PelIfd::GPS: + switch ($tag) { + case self::GPS_VERSION_ID: + return 'GPSVersionID'; + case self::GPS_LATITUDE_REF: + return 'GPSLatitudeRef'; + case self::GPS_LATITUDE: + return 'GPSLatitude'; + case self::GPS_LONGITUDE_REF: + return 'GPSLongitudeRef'; + case self::GPS_LONGITUDE: + return 'GPSLongitude'; + case self::GPS_ALTITUDE_REF: + return 'GPSAltitudeRef'; + case self::GPS_ALTITUDE: + return 'GPSAltitude'; + case self::GPS_TIME_STAMP: + return 'GPSTimeStamp'; + case self::GPS_SATELLITES: + return 'GPSSatellites'; + case self::GPS_STATUS: + return 'GPSStatus'; + case self::GPS_MEASURE_MODE: + return 'GPSMeasureMode'; + case self::GPS_DOP: + return 'GPSDOP'; + case self::GPS_SPEED_REF: + return 'GPSSpeedRef'; + case self::GPS_SPEED: + return 'GPSSpeed'; + case self::GPS_TRACK_REF: + return 'GPSTrackRef'; + case self::GPS_TRACK: + return 'GPSTrack'; + case self::GPS_IMG_DIRECTION_REF: + return 'GPSImgDirectionRef'; + case self::GPS_IMG_DIRECTION: + return 'GPSImgDirection'; + case self::GPS_MAP_DATUM: + return 'GPSMapDatum'; + case self::GPS_DEST_LATITUDE_REF: + return 'GPSDestLatitudeRef'; + case self::GPS_DEST_LATITUDE: + return 'GPSDestLatitude'; + case self::GPS_DEST_LONGITUDE_REF: + return 'GPSDestLongitudeRef'; + case self::GPS_DEST_LONGITUDE: + return 'GPSDestLongitude'; + case self::GPS_DEST_BEARING_REF: + return 'GPSDestBearingRef'; + case self::GPS_DEST_BEARING: + return 'GPSDestBearing'; + case self::GPS_DEST_DISTANCE_REF: + return 'GPSDestDistanceRef'; + case self::GPS_DEST_DISTANCE: + return 'GPSDestDistance'; + case self::GPS_PROCESSING_METHOD: + return 'GPSProcessingMethod'; + case self::GPS_AREA_INFORMATION: + return 'GPSAreaInformation'; + case self::GPS_DATE_STAMP: + return 'GPSDateStamp'; + case self::GPS_DIFFERENTIAL: + return 'GPSDifferential'; + } + + default: + return Pel::fmt('Unknown: 0x%04X', $tag); + } + } + + + /** + * Returns a title for an Exif tag. + * + * @param int the IFD type of the tag, one of {@link PelIfd::IFD0}, + * {@link PelIfd::IFD1}, {@link PelIfd::EXIF}, {@link PelIfd::GPS}, + * or {@link PelIfd::INTEROPERABILITY}. + * + * @param PelTag the tag. + * + * @return string the title of the tag, e.g., 'Image Width' for the + * {@link IMAGE_WIDTH} tag. If the tag isn't known, the string + * 'Unknown Tag: 0xTT' will be returned where 'TT' is the + * hexadecimal representation of the tag. + */ + function getTitle($type, $tag) { + + switch ($type) { + case PelIfd::IFD0: + case PelIfd::IFD1: + case PelIfd::EXIF: + case PelIfd::INTEROPERABILITY: + + switch ($tag) { + case self::INTEROPERABILITY_INDEX: + return Pel::tra('Interoperability Index'); + case self::INTEROPERABILITY_VERSION: + return Pel::tra('Interoperability Version'); + case self::IMAGE_WIDTH: + return Pel::tra('Image Width'); + case self::IMAGE_LENGTH: + return Pel::tra('Image Length'); + case self::BITS_PER_SAMPLE: + return Pel::tra('Bits per Sample'); + case self::COMPRESSION: + return Pel::tra('Compression'); + case self::PHOTOMETRIC_INTERPRETATION: + return Pel::tra('Photometric Interpretation'); + case self::FILL_ORDER: + return Pel::tra('Fill Order'); + case self::DOCUMENT_NAME: + return Pel::tra('Document Name'); + case self::IMAGE_DESCRIPTION: + return Pel::tra('Image Description'); + case self::MAKE: + return Pel::tra('Manufacturer'); + case self::MODEL: + return Pel::tra('Model'); + case self::STRIP_OFFSETS: + return Pel::tra('Strip Offsets'); + case self::ORIENTATION: + return Pel::tra('Orientation'); + case self::SAMPLES_PER_PIXEL: + return Pel::tra('Samples per Pixel'); + case self::ROWS_PER_STRIP: + return Pel::tra('Rows per Strip'); + case self::STRIP_BYTE_COUNTS: + return Pel::tra('Strip Byte Count'); + case self::X_RESOLUTION: + return Pel::tra('x-Resolution'); + case self::Y_RESOLUTION: + return Pel::tra('y-Resolution'); + case self::PLANAR_CONFIGURATION: + return Pel::tra('Planar Configuration'); + case self::RESOLUTION_UNIT: + return Pel::tra('Resolution Unit'); + case self::TRANSFER_FUNCTION: + return Pel::tra('Transfer Function'); + case self::SOFTWARE: + return Pel::tra('Software'); + case self::DATE_TIME: + return Pel::tra('Date and Time'); + case self::ARTIST: + return Pel::tra('Artist'); + case self::WHITE_POINT: + return Pel::tra('White Point'); + case self::PRIMARY_CHROMATICITIES: + return Pel::tra('Primary Chromaticities'); + case self::TRANSFER_RANGE: + return Pel::tra('Transfer Range'); + case self::JPEG_PROC: + return Pel::tra('JPEG Process'); + case self::JPEG_INTERCHANGE_FORMAT: + return Pel::tra('JPEG Interchange Format'); + case self::JPEG_INTERCHANGE_FORMAT_LENGTH: + return Pel::tra('JPEG Interchange Format Length'); + case self::YCBCR_COEFFICIENTS: + return Pel::tra('YCbCr Coefficients'); + case self::YCBCR_SUB_SAMPLING: + return Pel::tra('YCbCr Sub-Sampling'); + case self::YCBCR_POSITIONING: + return Pel::tra('YCbCr Positioning'); + case self::REFERENCE_BLACK_WHITE: + return Pel::tra('Reference Black/White'); + case self::RELATED_IMAGE_FILE_FORMAT: + return Pel::tra('Related Image File Format'); + case self::RELATED_IMAGE_WIDTH: + return Pel::tra('Related Image Width'); + case self::RELATED_IMAGE_LENGTH: + return Pel::tra('Related Image Length'); + case self::CFA_REPEAT_PATTERN_DIM: + return Pel::tra('CFA Repeat Pattern Dim'); + case self::CFA_PATTERN: + return Pel::tra('CFA Pattern'); + case self::BATTERY_LEVEL: + return Pel::tra('Battery Level'); + case self::COPYRIGHT: + return Pel::tra('Copyright'); + case self::EXPOSURE_TIME: + return Pel::tra('Exposure Time'); + case self::FNUMBER: + return Pel::tra('FNumber'); + case self::IPTC_NAA: + return Pel::tra('IPTC/NAA'); + case self::EXIF_IFD_POINTER: + return Pel::tra('Exif IFD Pointer'); + case self::INTER_COLOR_PROFILE: + return Pel::tra('Inter Color Profile'); + case self::EXPOSURE_PROGRAM: + return Pel::tra('Exposure Program'); + case self::SPECTRAL_SENSITIVITY: + return Pel::tra('Spectral Sensitivity'); + case self::GPS_INFO_IFD_POINTER: + return Pel::tra('GPS Info IFD Pointer'); + case self::ISO_SPEED_RATINGS: + return Pel::tra('ISO Speed Ratings'); + case self::OECF: + return Pel::tra('OECF'); + case self::EXIF_VERSION: + return Pel::tra('Exif Version'); + case self::DATE_TIME_ORIGINAL: + return Pel::tra('Date and Time (original)'); + case self::DATE_TIME_DIGITIZED: + return Pel::tra('Date and Time (digitized)'); + case self::COMPONENTS_CONFIGURATION: + return Pel::tra('Components Configuration'); + case self::COMPRESSED_BITS_PER_PIXEL: + return Pel::tra('Compressed Bits per Pixel'); + case self::SHUTTER_SPEED_VALUE: + return Pel::tra('Shutter speed'); + case self::APERTURE_VALUE: + return Pel::tra('Aperture'); + case self::BRIGHTNESS_VALUE: + return Pel::tra('Brightness'); + case self::EXPOSURE_BIAS_VALUE: + return Pel::tra('Exposure Bias'); + case self::MAX_APERTURE_VALUE: + return Pel::tra('Max Aperture Value'); + case self::SUBJECT_DISTANCE: + return Pel::tra('Subject Distance'); + case self::METERING_MODE: + return Pel::tra('Metering Mode'); + case self::LIGHT_SOURCE: + return Pel::tra('Light Source'); + case self::FLASH: + return Pel::tra('Flash'); + case self::FOCAL_LENGTH: + return Pel::tra('Focal Length'); + case self::MAKER_NOTE: + return Pel::tra('Maker Note'); + case self::USER_COMMENT: + return Pel::tra('User Comment'); + case self::SUB_SEC_TIME: + return Pel::tra('SubSec Time'); + case self::SUB_SEC_TIME_ORIGINAL: + return Pel::tra('SubSec Time Original'); + case self::SUB_SEC_TIME_DIGITIZED: + return Pel::tra('SubSec Time Digitized'); + case self::XP_TITLE: + return 'Windows XP Title'; + case self::XP_COMMENT: + return 'Windows XP Comment'; + case self::XP_AUTHOR: + return 'Windows XP Author'; + case self::XP_KEYWORDS: + return 'Windows XP Keywords'; + case self::XP_SUBJECT: + return 'Windows XP Subject'; + case self::FLASH_PIX_VERSION: + return Pel::tra('FlashPix Version'); + case self::COLOR_SPACE: + return Pel::tra('Color Space'); + case self::PIXEL_X_DIMENSION: + return Pel::tra('Pixel x-Dimension'); + case self::PIXEL_Y_DIMENSION: + return Pel::tra('Pixel y-Dimension'); + case self::RELATED_SOUND_FILE: + return Pel::tra('Related Sound File'); + case self::INTEROPERABILITY_IFD_POINTER: + return Pel::tra('Interoperability IFD Pointer'); + case self::FLASH_ENERGY: + return Pel::tra('Flash Energy'); + case self::SPATIAL_FREQUENCY_RESPONSE: + return Pel::tra('Spatial Frequency Response'); + case self::FOCAL_PLANE_X_RESOLUTION: + return Pel::tra('Focal Plane x-Resolution'); + case self::FOCAL_PLANE_Y_RESOLUTION: + return Pel::tra('Focal Plane y-Resolution'); + case self::FOCAL_PLANE_RESOLUTION_UNIT: + return Pel::tra('Focal Plane Resolution Unit'); + case self::SUBJECT_LOCATION: + return Pel::tra('Subject Location'); + case self::EXPOSURE_INDEX: + return Pel::tra('Exposure index'); + case self::SENSING_METHOD: + return Pel::tra('Sensing Method'); + case self::FILE_SOURCE: + return Pel::tra('File Source'); + case self::SCENE_TYPE: + return Pel::tra('Scene Type'); + case self::SUBJECT_AREA: + return Pel::tra('Subject Area'); + case self::CUSTOM_RENDERED: + return Pel::tra('Custom Rendered'); + case self::EXPOSURE_MODE: + return Pel::tra('Exposure Mode'); + case self::WHITE_BALANCE: + return Pel::tra('White Balance'); + case self::DIGITAL_ZOOM_RATIO: + return Pel::tra('Digital Zoom Ratio'); + case self::FOCAL_LENGTH_IN_35MM_FILM: + return Pel::tra('Focal Length In 35mm Film'); + case self::SCENE_CAPTURE_TYPE: + return Pel::tra('Scene Capture Type'); + case self::GAIN_CONTROL: + return Pel::tra('Gain Control'); + case self::CONTRAST: + return Pel::tra('Contrast'); + case self::SATURATION: + return Pel::tra('Saturation'); + case self::SHARPNESS: + return Pel::tra('Sharpness'); + case self::DEVICE_SETTING_DESCRIPTION: + return Pel::tra('Device Setting Description'); + case self::SUBJECT_DISTANCE_RANGE: + return Pel::tra('Subject Distance Range'); + case self::IMAGE_UNIQUE_ID: + return Pel::tra('Image Unique ID'); + case self::GAMMA: + return Pel::tra('Gamma'); + case self::PRINT_IM: + return Pel::tra('Print IM'); + } + + case PelIfd::GPS: + switch ($tag) { + case self::GPS_VERSION_ID: + return 'GPSVersionID'; + case self::GPS_LATITUDE_REF: + return 'GPSLatitudeRef'; + case self::GPS_LATITUDE: + return 'GPSLatitude'; + case self::GPS_LONGITUDE_REF: + return 'GPSLongitudeRef'; + case self::GPS_LONGITUDE: + return 'GPSLongitude'; + case self::GPS_ALTITUDE_REF: + return 'GPSAltitudeRef'; + case self::GPS_ALTITUDE: + return 'GPSAltitude'; + case self::GPS_TIME_STAMP: + return 'GPSTimeStamp'; + case self::GPS_SATELLITES: + return 'GPSSatellites'; + case self::GPS_STATUS: + return 'GPSStatus'; + case self::GPS_MEASURE_MODE: + return 'GPSMeasureMode'; + case self::GPS_DOP: + return 'GPSDOP'; + case self::GPS_SPEED_REF: + return 'GPSSpeedRef'; + case self::GPS_SPEED: + return 'GPSSpeed'; + case self::GPS_TRACK_REF: + return 'GPSTrackRef'; + case self::GPS_TRACK: + return 'GPSTrack'; + case self::GPS_IMG_DIRECTION_REF: + return 'GPSImgDirectionRef'; + case self::GPS_IMG_DIRECTION: + return 'GPSImgDirection'; + case self::GPS_MAP_DATUM: + return 'GPSMapDatum'; + case self::GPS_DEST_LATITUDE_REF: + return 'GPSDestLatitudeRef'; + case self::GPS_DEST_LATITUDE: + return 'GPSDestLatitude'; + case self::GPS_DEST_LONGITUDE_REF: + return 'GPSDestLongitudeRef'; + case self::GPS_DEST_LONGITUDE: + return 'GPSDestLongitude'; + case self::GPS_DEST_BEARING_REF: + return 'GPSDestBearingRef'; + case self::GPS_DEST_BEARING: + return 'GPSDestBearing'; + case self::GPS_DEST_DISTANCE_REF: + return 'GPSDestDistanceRef'; + case self::GPS_DEST_DISTANCE: + return 'GPSDestDistance'; + case self::GPS_PROCESSING_METHOD: + return 'GPSProcessingMethod'; + case self::GPS_AREA_INFORMATION: + return 'GPSAreaInformation'; + case self::GPS_DATE_STAMP: + return 'GPSDateStamp'; + case self::GPS_DIFFERENTIAL: + return 'GPSDifferential'; + } + + default: + return Pel::fmt('Unknown Tag: 0x%04X', $tag); + } + } + +} +?> \ No newline at end of file diff --git a/modules/autorotate/lib/pel/PelTiff.php b/modules/autorotate/lib/pel/PelTiff.php new file mode 100644 index 00000000..0146c9e2 --- /dev/null +++ b/modules/autorotate/lib/pel/PelTiff.php @@ -0,0 +1,296 @@ + + * @version $Revision: 458 $ + * @date $Date: 2006-11-18 22:22:58 +0100 (Sat, 18 Nov 2006) $ + * @license http://www.gnu.org/licenses/gpl.html GNU General Public + * License (GPL) + * @package PEL + */ + +/**#@+ Required class definitions. */ +require_once('PelDataWindow.php'); +require_once('PelIfd.php'); +require_once('Pel.php'); +/**#@-*/ + + +/** + * Class for handling TIFF data. + * + * Exif data is actually an extension of the TIFF file format. TIFF + * images consist of a number of {@link PelIfd Image File Directories} + * (IFDs), each containing a number of {@link PelEntry entries}. The + * IFDs are linked to each other --- one can get hold of the first one + * with the {@link getIfd()} method. + * + * To parse a TIFF image for Exif data one would do: + * + * + * $tiff = new PelTiff($data); + * $ifd0 = $tiff->getIfd(); + * $exif = $ifd0->getSubIfd(PelIfd::EXIF); + * $ifd1 = $ifd0->getNextIfd(); + * + * + * Should one have some image data of an unknown type, then the {@link + * PelTiff::isValid()} function is handy: it will quickly test if the + * data could be valid TIFF data. The {@link PelJpeg::isValid()} + * function does the same for JPEG images. + * + * @author Martin Geisler + * @package PEL + */ +class PelTiff { + + /** + * TIFF header. + * + * This must follow after the two bytes indicating the byte order. + */ + const TIFF_HEADER = 0x002A; + + /** + * The first Image File Directory, if any. + * + * If set, then the type of the IFD must be {@link PelIfd::IFD0}. + * + * @var PelIfd + */ + private $ifd = null; + + + /** + * Construct a new object for holding TIFF data. + * + * The new object will be empty (with no {@link PelIfd}) unless an + * argument is given from which it can initialize itself. This can + * either be the filename of a TIFF image or a {@link PelDataWindow} + * object. + * + * Use {@link setIfd()} to explicitly set the IFD. + */ + function __construct($data = false) { + if ($data === false) + return; + + if (is_string($data)) { + Pel::debug('Initializing PelTiff object from %s', $data); + $this->loadFile($data); + } elseif ($data instanceof PelDataWindow) { + Pel::debug('Initializing PelTiff object from PelDataWindow.'); + $this->load($data); + } else { + throw new PelInvalidArgumentException('Bad type for $data: %s', + gettype($data)); + } + } + + + /** + * Load TIFF data. + * + * The data given will be parsed and an internal tree representation + * will be built. If the data cannot be parsed correctly, a {@link + * PelInvalidDataException} is thrown, explaining the problem. + * + * @param PelDataWindow the data from which the object will be + * constructed. This should be valid TIFF data, coming either + * directly from a TIFF image or from the Exif data in a JPEG image. + */ + function load(PelDataWindow $d) { + Pel::debug('Parsing %d bytes of TIFF data...', $d->getSize()); + + /* There must be at least 8 bytes available: 2 bytes for the byte + * order, 2 bytes for the TIFF header, and 4 bytes for the offset + * to the first IFD. */ + if ($d->getSize() < 8) + throw new PelInvalidDataException('Expected at least 8 bytes of TIFF ' . + 'data, found just %d bytes.', + $d->getSize()); + + /* Byte order */ + if ($d->strcmp(0, 'II')) { + Pel::debug('Found Intel byte order'); + $d->setByteOrder(PelConvert::LITTLE_ENDIAN); + } elseif ($d->strcmp(0, 'MM')) { + Pel::debug('Found Motorola byte order'); + $d->setByteOrder(PelConvert::BIG_ENDIAN); + } else { + throw new PelInvalidDataException('Unknown byte order found in TIFF ' . + 'data: 0x%2X%2X', + $d->getByte(0), $d->getByte(1)); + } + + /* Verify the TIFF header */ + if ($d->getShort(2) != self::TIFF_HEADER) + throw new PelInvalidDataException('Missing TIFF magic value.'); + + /* IFD 0 offset */ + $offset = $d->getLong(4); + Pel::debug('First IFD at offset %d.', $offset); + + if ($offset > 0) { + /* Parse the first IFD, this will automatically parse the + * following IFDs and any sub IFDs. */ + $this->ifd = new PelIfd(PelIfd::IFD0); + $this->ifd->load($d, $offset); + } + } + + + /** + * Load data from a file into a TIFF object. + * + * @param string the filename. This must be a readable file. + */ + function loadFile($filename) { + $this->load(new PelDataWindow(file_get_contents($filename))); + } + + + /** + * Set the first IFD. + * + * @param PelIfd the new first IFD, which must be of type {@link + * PelIfd::IFD0}. + */ + function setIfd(PelIfd $ifd) { + if ($ifd->getType() != PelIfd::IFD0) + throw new PelInvalidDataException('Invalid type of IFD: %d, expected %d.', + $ifd->getType(), PelIfd::IFD0); + + $this->ifd = $ifd; + } + + + /** + * Return the first IFD. + * + * @return PelIfd the first IFD contained in the TIFF data, if any. + * If there is no IFD null will be returned. + */ + function getIfd() { + return $this->ifd; + } + + + /** + * Turn this object into bytes. + * + * TIFF images can have {@link PelConvert::LITTLE_ENDIAN + * little-endian} or {@link PelConvert::BIG_ENDIAN big-endian} byte + * order, and so this method takes an argument specifying that. + * + * @param PelByteOrder the desired byte order of the TIFF data. + * This should be one of {@link PelConvert::LITTLE_ENDIAN} or {@link + * PelConvert::BIG_ENDIAN}. + * + * @return string the bytes representing this object. + */ + function getBytes($order = PelConvert::LITTLE_ENDIAN) { + if ($order == PelConvert::LITTLE_ENDIAN) + $bytes = 'II'; + else + $bytes = 'MM'; + + /* TIFF magic number --- fixed value. */ + $bytes .= PelConvert::shortToBytes(self::TIFF_HEADER, $order); + + if ($this->ifd != null) { + /* IFD 0 offset. We will always start IDF 0 at an offset of 8 + * bytes (2 bytes for byte order, another 2 bytes for the TIFF + * header, and 4 bytes for the IFD 0 offset make 8 bytes + * together). + */ + $bytes .= PelConvert::longToBytes(8, $order); + + /* The argument specifies the offset of this IFD. The IFD will + * use this to calculate offsets from the entries to their data, + * all those offsets are absolute offsets counted from the + * beginning of the data. */ + $bytes .= $this->ifd->getBytes(8, $order); + } else { + $bytes .= PelConvert::longToBytes(0, $order); + } + + return $bytes; + } + + + /** + * Return a string representation of this object. + * + * @return string a string describing this object. This is mostly useful + * for debugging. + */ + function __toString() { + $str = Pel::fmt("Dumping TIFF data...\n"); + if ($this->ifd != null) + $str .= $this->ifd->__toString(); + + return $str; + } + + + /** + * Check if data is valid TIFF data. + * + * This will read just enough data from the data window to determine + * if the data could be a valid TIFF data. This means that the + * check is more like a heuristic than a rigorous check. + * + * @param PelDataWindow the bytes that will be examined. + * + * @return boolean true if the data looks like valid TIFF data, + * false otherwise. + * + * @see PelJpeg::isValid() + */ + static function isValid(PelDataWindow $d) { + /* First check that we have enough data. */ + if ($d->getSize() < 8) + return false; + + /* Byte order */ + if ($d->strcmp(0, 'II')) { + $d->setByteOrder(PelConvert::LITTLE_ENDIAN); + } elseif ($d->strcmp(0, 'MM')) { + Pel::debug('Found Motorola byte order'); + $d->setByteOrder(PelConvert::BIG_ENDIAN); + } else { + return false; + } + + /* Verify the TIFF header */ + return $d->getShort(2) == self::TIFF_HEADER; + } + +} \ No newline at end of file diff --git a/modules/autorotate/module.info b/modules/autorotate/module.info new file mode 100644 index 00000000..17c62229 --- /dev/null +++ b/modules/autorotate/module.info @@ -0,0 +1,3 @@ +name = "Autorotate" +description = "Rotate an image automatically on upload based on EXIF data" +version = 1 \ No newline at end of file diff --git a/modules/batchtag/controllers/batchtag.php b/modules/batchtag/controllers/batchtag.php index fc17f594..ec012719 100644 --- a/modules/batchtag/controllers/batchtag.php +++ b/modules/batchtag/controllers/batchtag.php @@ -1,7 +1,7 @@ where("parent_id", $this->input->post("item_id")) - ->where("type !=", "album") - ->find_all(); + $input = Input::instance(); + // Figure out if the contents of sub-albums should also be tagged + $str_tag_subitems = $input->post("tag_subitems"); + + $children = ""; + if ($str_tag_subitems == false) { + // Generate an array of all non-album items in the current album. + $children = ORM::factory("item") + ->where("parent_id", "=", $input->post("item_id")) + ->where("type", "!=", "album") + ->find_all(); + } else { + // Generate an array of all non-album items in the current album + // and any sub albums. + $item = ORM::factory("item", $input->post("item_id")); + $children = $item->descendants(); + } // Loop through each item in the album and make sure the user has // access to view and edit it. foreach ($children as $child) { - if (access::can("view", $child) && access::can("edit", $child)) { + if (access::can("view", $child) && access::can("edit", $child) && !$child->is_album()) { // Assuming the user can view/edit the current item, loop // through each tag that was submitted and apply it to // the current item. - foreach (split(",", $this->input->post("name")) as $tag_name) { + foreach (explode(",", $input->post("name")) as $tag_name) { $tag_name = trim($tag_name); if ($tag_name) { tag::add($child, $tag_name); @@ -48,7 +60,7 @@ class BatchTag_Controller extends Controller { } // Redirect back to the album. - $item = ORM::factory("item", $this->input->post("item_id")); + $item = ORM::factory("item", $input->post("item_id")); url::redirect(url::abs_site("{$item->type}s/{$item->id}")); } } diff --git a/modules/batchtag/helpers/batchtag_theme.php b/modules/batchtag/helpers/batchtag_block.php similarity index 66% rename from modules/batchtag/helpers/batchtag_theme.php rename to modules/batchtag/helpers/batchtag_block.php index 3a6fe70a..f1be1387 100644 --- a/modules/batchtag/helpers/batchtag_theme.php +++ b/modules/batchtag/helpers/batchtag_block.php @@ -1,7 +1,7 @@ t("Batch Tag")); + } + static function get($block_id, $theme) { + $block = ""; + + // Only display on album pages that the user can edit. $item = $theme->item(); - - // Only display the form in albums that the user has edit permission in. - if ($item->is_album() && access::can("edit", $item)) { + if (!$item || !$item->is_album() || !access::can("edit", $item)) { + return; + } + switch ($block_id) { + case "batch_tag": // Make a new sidebar block. $block = new Block(); - $block->css_id = "gBatchTag"; + $block->css_id = "g-batch-tag"; $block->title = t("Batch Tag"); $block->content = new View("batchtag_block.html"); // Make a new form to place in the sidebar block. $form = new Forge("batchtag/tagitems", "", "post", - array("id" => "gBatchTagForm")); + array("id" => "g-batch-tag-form")); $label = t("Tag everything in this album:"); $group = $form->group("add_tag")->label("Add Tag"); $group->input("name")->label($label)->rules("required|length[1,64]"); + $group->checkbox("tag_subitems") + ->label(t("Include sub-albums?")) + ->value(true) + ->checked(false); + $group->hidden("item_id")->value($item->id); $group->submit("")->value(t("Add Tag")); - $block->content->form = $form; + $block->content->batch_tag_form = $form; - // Display the block. - return $block; - } + break; + } + return $block; } -} \ No newline at end of file +} diff --git a/modules/batchtag/helpers/batchtag_event.php b/modules/batchtag/helpers/batchtag_event.php new file mode 100644 index 00000000..ba4454a4 --- /dev/null +++ b/modules/batchtag/helpers/batchtag_event.php @@ -0,0 +1,34 @@ +deactivate)) { + site_status::warning( + t("The BatchTag module requires the Tags module. " . + "Activate the Tags module now", + array("url" => url::site("admin/modules"))), + "batchtag_needs_tag"); + } else { + site_status::clear("batchtag_needs_tag"); + } + } +} diff --git a/modules/batchtag/helpers/batchtag_installer.php b/modules/batchtag/helpers/batchtag_installer.php index 0a24b58c..bdf64d5a 100644 --- a/modules/batchtag/helpers/batchtag_installer.php +++ b/modules/batchtag/helpers/batchtag_installer.php @@ -1,6 +1,7 @@ - - \ No newline at end of file + \ No newline at end of file diff --git a/modules/calendarview/controllers/calendarview.php b/modules/calendarview/controllers/calendarview.php new file mode 100644 index 00000000..d5d23943 --- /dev/null +++ b/modules/calendarview/controllers/calendarview.php @@ -0,0 +1,270 @@ +css("calendarview_calendar.css"); + $template->set_global("calendar_user", $display_user); + $template->page_title = t("Gallery :: Calendar"); + $template->content = new View("calendarview_year.html"); + $template->content->calendar_year = $display_year; + $template->content->calendar_user = $display_user; + $template->content->calendar_user_year_form = $this->_get_calenderprefs_form($display_year, $display_user); + $template->content->title = t("Calendar") . ": " . $display_year; + // Set up breadcrumbs + $calendar_breadcrumbs[0] = new Calendar_Breadcrumb(item::root()->title, item::root()->url()); + $calendar_breadcrumbs[1] = new Calendar_Breadcrumb($display_year, ""); + $template->set_global("breadcrumbs", $calendar_breadcrumbs); + print $template; + } + + public function day($display_year, $display_user, $display_month, $display_day) { + // Display all images for the specified day. + + // Figure out the total number of photos to display. + $day_count = 0; + if ($display_user == "-1") { + $day_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $display_month, $display_day, $display_year)) + ->where("captured", "<", mktime(0, 0, 0, $display_month, ($display_day + 1), $display_year)) + ->find_all() + ->count(); + } else { + $day_count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $display_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $display_month, $display_day, $display_year)) + ->where("captured", "<", mktime(0, 0, 0, $display_month, ($display_day + 1), $display_year)) + ->find_all() + ->count(); + } + + // Figure out paging stuff. + $page_size = module::get_var("gallery", "page_size", 9); + $page = (int) Input::instance()->get("page", "1"); + $offset = ($page-1) * $page_size; + $max_pages = max(ceil($day_count / $page_size), 1); + + // Make sure that the page references a valid offset + if (($page < 1) || ($page > $max_pages)) { + throw new Kohana_404_Exception(); + } + + // Set up the page. + $template = new Theme_View("calpage.html", "collection", "CalendarDayView"); + $template->set_global("page", $page); + $template->set_global("max_pages", $max_pages); + $template->set_global("page_size", $page_size); + $template->page_title = t("Gallery :: Calendar"); + + // Figure out which photos go on this page. + if ($display_user == "-1") { + $template->set_global("children", ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $display_month, $display_day, $display_year)) + ->where("captured", "<", mktime(0, 0, 0, $display_month, ($display_day + 1), $display_year)) + ->order_by("captured", "ASC") + ->find_all($page_size, $offset)); + } else { + $template->set_global("children", ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $display_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $display_month, $display_day, $display_year)) + ->where("captured", "<", mktime(0, 0, 0, $display_month, ($display_day + 1), $display_year)) + ->order_by("captured", "ASC") + ->find_all($page_size, $offset)); + } + + // Set up breadcrumbs + $calendar_breadcrumbs[0] = new Calendar_Breadcrumb(item::root()->title, item::root()->url()); + $calendar_breadcrumbs[1] = new Calendar_Breadcrumb($display_year, url::site("calendarview/calendar/" . $display_year . "/" . $display_user)); + $calendar_breadcrumbs[2] = new Calendar_Breadcrumb(t(date("F", mktime(0, 0, 0, $display_month, $display_day, $display_year))), url::site("calendarview/month/" . $display_year . "/" . $display_user . "/" . $display_month)); + $calendar_breadcrumbs[3] = new Calendar_Breadcrumb($display_day, ""); + $template->set_global("breadcrumbs", $calendar_breadcrumbs); + + // Finish setting up and then display the page. + $template->set_global("children_count", $day_count); + $template->content = new View("dynamic.html"); + $template->content->title = t("Photos From ") . date("d", mktime(0, 0, 0, $display_month, $display_day, $display_year)) . " " . t(date("F", mktime(0, 0, 0, $display_month, $display_day, $display_year))) . " " . date("Y", mktime(0, 0, 0, $display_month, $display_day, $display_year)); + print $template; + } + + public function month($display_year, $display_user, $display_month) { + // Display all images for the specified month. + + // Figure out the total number of photos to display. + $day_count = 0; + if ($display_user == "-1") { + $day_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $display_month, 1, $display_year)) + ->where("captured", "<", mktime(0, 0, 0, $display_month+1, 1, $display_year)) + ->find_all() + ->count(); + } else { + $day_count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $display_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $display_month, 1, $display_year)) + ->where("captured", "<", mktime(0, 0, 0, $display_month+1, 1, $display_year)) + ->find_all() + ->count(); + } + + // Figure out paging stuff. + $page_size = module::get_var("gallery", "page_size", 9); + $page = (int) Input::instance()->get("page", "1"); + $offset = ($page-1) * $page_size; + $max_pages = max(ceil($day_count / $page_size), 1); + + // Make sure that the page references a valid offset + if (($page < 1) || ($page > $max_pages)) { + throw new Kohana_404_Exception(); + } + + // Set up the page. + $template = new Theme_View("calpage.html", "collection", "CalendarMonthView"); + $template->set_global("page", $page); + $template->set_global("max_pages", $max_pages); + $template->set_global("page_size", $page_size); + $template->page_title = t("Gallery :: Calendar"); + + // Figure out which photos go on this page. + if ($display_user == "-1") { + $template->set_global("children", ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $display_month, 1, $display_year)) + ->where("captured", "<", mktime(0, 0, 0, $display_month+1, 1, $display_year)) + ->order_by("captured", "ASC") + ->find_all($page_size, $offset)); + } else { + $template->set_global("children", ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $display_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $display_month, 1, $display_year)) + ->where("captured", "<", mktime(0, 0, 0, $display_month+1, 1, $display_year)) + ->order_by("captured", "ASC") + ->find_all($page_size, $offset)); + } + + // Set up breadcrumbs + $calendar_breadcrumbs[0] = new Calendar_Breadcrumb(item::root()->title, item::root()->url()); + $calendar_breadcrumbs[1] = new Calendar_Breadcrumb($display_year, url::site("calendarview/calendar/" . $display_year . "/" . $display_user)); + $calendar_breadcrumbs[2] = new Calendar_Breadcrumb(t(date("F", mktime(0, 0, 0, $display_month, 1, $display_year))), ""); + $template->set_global("breadcrumbs", $calendar_breadcrumbs); + + // Finish setting up and then display the page. + $template->set_global("children_count", $day_count); + $template->content = new View("dynamic.html"); + $template->content->title = t("Photos From ") . t(date("F", mktime(0, 0, 0, $display_month, 1, $display_year))) . " " . date("Y", mktime(0, 0, 0, $display_month, 1, $display_year)); + print $template; + } + + private function _get_calenderprefs_form($display_year, $display_user) { + // Generate a form to allow the visitor to select a year and a gallery photo owner. + $calendar_group = new Forge("calendarview/setprefs", "", "post", + array("id" => "g-view-calendar-form")); + + // Generate a list of all Gallery users who have uploaded photos. + $valid_users[-1] = "(All Users)"; + $gallery_users = ORM::factory("user")->find_all(); + foreach ($gallery_users as $one_user) { + $count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $one_user->id) + ->where("type", "!=", "album") + ->where("captured", "!=", "") + ->find_all() + ->count(); + if ($count > 0) { + $valid_users[$one_user->id] = $one_user->full_name; + } + } + + // Generate a list of years, starting with the year the earliest photo was + // taken, and ending with the year of the most recent photo. + $valid_years = Array(); + $all_photos = ORM::factory("item") + ->viewable() + //->where("owner_id", "=", $one_user->id) + ->where("type", "!=", "album") + ->where("captured", "!=", "") + ->order_by("captured", "DESC") + ->find_all(); + $counter = date('Y', $all_photos[count($all_photos)-1]->captured); + while ($counter <= date('Y', $all_photos[0]->captured)) { + $valid_years[$counter] = $counter; + $counter++; + } + + // Create the form. + $calendar_group->dropdown('cal_user') + ->label(t("Display Photos From User: ")) + ->id('cal_user') + ->options($valid_users) + ->selected($display_user); + $calendar_group->dropdown('cal_year') + ->label(t("For Year: ")) + ->id('cal_year') + ->options($valid_years) + ->selected($display_year); + + // Add a save button to the form. + $calendar_group->submit("SaveSettings")->value(t("Go"))->id('cal_go'); + + // Return the newly generated form. + return $calendar_group; + } + + public function setprefs() { + // Change the calendar year and / or user. + + // Prevent Cross Site Request Forgery + access::verify_csrf(); + + // Get user specified settings. + $str_user_id = Input::instance()->post("cal_user"); + $str_year_id = Input::instance()->post("cal_year"); + + // redirect to the currect page. + url::redirect(url::site("calendarview/calendar/" . $str_year_id . "/" . $str_user_id, request::protocol())); + } +} \ No newline at end of file diff --git a/modules/calendarview/css/calendarview_calendar.css b/modules/calendarview/css/calendarview_calendar.css new file mode 100644 index 00000000..53807042 --- /dev/null +++ b/modules/calendarview/css/calendarview_calendar.css @@ -0,0 +1,50 @@ +/* Grid view ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ +#g-calendar-grid { + position: relative; + align: center; + float: left; + width: 200px; + height: 220px; + margin: 10px 10px 10px 10px; +} + +/* Search form ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ +#cal_user { + top: 0px; + left: 60px; + display: inline; +} +#cal_year { + top: 0px; + left: 240px; + display: inline; +} +#cal_go { + top: 0px; + left: 328px; + display: inline; +} + +/* Content ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ +table.calendar { + text-align: center; +} + +table.calendar caption { + font-size: 1.5em; + padding: 0.2em; +} + +table.calendar th, table.calendar td { + padding: 0.2em; + border: 0px; +} + +table.calendar td:hover { + background: #ddf; +} + +/* For RTL Languages ~~~~~~~~~~~~~~~~~~~~~~~ */ +.rtl #g-calendar-grid { + float: right; +} diff --git a/modules/calendarview/css/calendarview_menu.css b/modules/calendarview/css/calendarview_menu.css new file mode 100644 index 00000000..600cc151 --- /dev/null +++ b/modules/calendarview/css/calendarview_menu.css @@ -0,0 +1,3 @@ +#g-view-menu #g-calendarview-link { + background-image: url('../images/ico-view-calendarview.png'); +} diff --git a/modules/calendarview/helpers/calendarview_block.php b/modules/calendarview/helpers/calendarview_block.php new file mode 100644 index 00000000..1037ecaa --- /dev/null +++ b/modules/calendarview/helpers/calendarview_block.php @@ -0,0 +1,72 @@ + t("More Photos From This Date")); + } + + static function get($block_id, $theme) { + $block = ""; + + // Make sure the current page belongs to an item. + if (!$theme->item()) { + return; + } + $item = $theme->item; + + $display_date = ""; + if (isset($item->captured)) { + $display_date = $item->captured; + }elseif (isset($item->created)) { + $display_date = $item->created; + } + + // Make sure there are photo's to display. + $day_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, date("n", $display_date), date("j", $display_date), date("Y", $display_date))) + ->where("captured", "<", mktime(0, 0, 0, date("n", $display_date), date("j", $display_date)+1, date("Y", $display_date))) + ->find_all() + ->count(); + $month_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, date("n", $display_date), 1, date("Y", $display_date))) + ->where("captured", "<", mktime(0, 0, 0, date("n", $display_date)+1, 1, date("Y", $display_date))) + ->find_all() + ->count(); + + switch ($block_id) { + case "calendarview_photo": + if ( ($display_date != "") && (($day_count > 0) || ($month_count > 0)) ) { + $block = new Block(); + $block->css_id = "g-calendarview-sidebar"; + $block->title = t("Calendar"); + $block->content = new View("calendarview_sidebar.html"); + $block->content->date = $display_date; + $block->content->day_count = $day_count; + $block->content->month_count = $month_count; + } + break; + } + return $block; + } +} diff --git a/modules/calendarview/helpers/calendarview_event.php b/modules/calendarview/helpers/calendarview_event.php new file mode 100644 index 00000000..4564b500 --- /dev/null +++ b/modules/calendarview/helpers/calendarview_event.php @@ -0,0 +1,72 @@ +append(Menu::factory("link") + ->id("calendarview") + ->label(t("View Calendar")) + ->url(url::site("calendarview/calendar/")) + ->css_id("g-calendarview-link")); + } + + static function movie_menu($menu, $theme) { + $menu->append(Menu::factory("link") + ->id("calendarview") + ->label(t("View Calendar")) + ->url(url::site("calendarview/calendar/")) + ->css_id("g-calendarview-link")); + } + + static function album_menu($menu, $theme) { + $menu->append(Menu::factory("link") + ->id("calendarview") + ->label(t("View Calendar")) + ->url(url::site("calendarview/calendar/")) + ->css_id("g-calendarview-link")); + } + + static function tag_menu($menu, $theme) { + $menu->append(Menu::factory("link") + ->id("calendarview") + ->label(t("View Calendar")) + ->url(url::site("calendarview/calendar/")) + ->css_id("g-calendarview-link")); + } + + static function pre_deactivate($data) { + // If the admin is about to deactivate EXIF, warn them that this module requires it. + if ($data->module == "exif") { + $data->messages["warn"][] = t("The CalendarView module requires the EXIF module."); + } + } + + static function module_change($changes) { + // If EXIF is deactivated, display a warning that it is required for this module to function properly. + if (!module::is_active("exif") || in_array("exif", $changes->deactivate)) { + site_status::warning( + t("The CalendarView module requires the EXIF module. " . + "Activate the EXIF module now", + array("url" => html::mark_clean(url::site("admin/modules")))), + "calendarview_needs_exif"); + } else { + site_status::clear("calendarview_needs_exif"); + } + } +} \ No newline at end of file diff --git a/modules/google_analytics/helpers/google_analytics_installer.php b/modules/calendarview/helpers/calendarview_installer.php similarity index 82% rename from modules/google_analytics/helpers/google_analytics_installer.php rename to modules/calendarview/helpers/calendarview_installer.php index 54d5b8e2..11ab23bb 100644 --- a/modules/google_analytics/helpers/google_analytics_installer.php +++ b/modules/calendarview/helpers/calendarview_installer.php @@ -17,13 +17,16 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ -class google_analytics_installer { +class calendarview_installer { static function install() { - module::set_var("google_analytics", "code", ""); - module::set_version("google_analytics", 2); + module::set_version("calendarview", 1); + } + + static function deactivate() { + site_status::clear("calendarview_needs_exif"); } static function uninstall() { - module::clear_var("google_analytics", "code"); + module::delete("calendarview"); } } diff --git a/modules/calendarview/helpers/calendarview_theme.php b/modules/calendarview/helpers/calendarview_theme.php new file mode 100644 index 00000000..4342b11f --- /dev/null +++ b/modules/calendarview/helpers/calendarview_theme.php @@ -0,0 +1,25 @@ +css("calendarview_menu.css"); + } +} diff --git a/modules/calendarview/images/ico-view-calendarview.png b/modules/calendarview/images/ico-view-calendarview.png new file mode 100644 index 00000000..5e564b8d Binary files /dev/null and b/modules/calendarview/images/ico-view-calendarview.png differ diff --git a/modules/calendarview/libraries/Calendar_Breadcrumb.php b/modules/calendarview/libraries/Calendar_Breadcrumb.php new file mode 100644 index 00000000..60502667 --- /dev/null +++ b/modules/calendarview/libraries/Calendar_Breadcrumb.php @@ -0,0 +1,31 @@ +title = $new_title; + $this->url = $new_url; + } +} diff --git a/modules/calendarview/libraries/PHPCalendar.php b/modules/calendarview/libraries/PHPCalendar.php new file mode 100644 index 00000000..2d1df2b4 --- /dev/null +++ b/modules/calendarview/libraries/PHPCalendar.php @@ -0,0 +1,87 @@ +month = (int) $month; + $this->year = (int) $year; + $this->month_url = $url; + } + + public function event($day_of_the_week, $event_url = NULL, $css_id = NULL, $custom_text = NULL) + { + $this->event_data += Array($day_of_the_week => Array($event_url, $css_id, $custom_text)); + } + + public function render() + { + return $this->generate_calendar($this->year, $this->month, $this->event_data, 2, $this->month_url, $this->week_start, NULL); + } + + # PHP Calendar (version 2.3), written by Keith Devens + # http://keithdevens.com/software/php_calendar + # see example at http://keithdevens.com/weblog + # License: http://keithdevens.com/software/license + function generate_calendar($year, $month, $days = array(), $day_name_length = 3, $month_href = NULL, $first_day = 0, $pn = array()) + { + $first_of_month = gmmktime(0,0,0,$month,1,$year); + #remember that mktime will automatically correct if invalid dates are entered + # for instance, mktime(0,0,0,12,32,1997) will be the date for Jan 1, 1998 + # this provides a built in "rounding" feature to generate_calendar() + + if ($first_day == 0) $day_names = array("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"); + if ($first_day == 1) $day_names = array("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"); + + list($month, $year, $month_name, $weekday) = explode(',',gmstrftime('%m,%Y,%B,%w',$first_of_month)); + $weekday = ($weekday + 7 - $first_day) % 7; #adjust for $first_day + $title = t(date("F", mktime(0, 0, 0, $month, 1, $year))) . ' ' . $year; + + #Begin calendar. Uses a real . See http://diveintomark.org/archives/2002/07/03 + @list($p, $pl) = each($pn); @list($n, $nl) = each($pn); #previous and next links, if applicable + if($p) $p = ''.($pl ? ''.$p.'' : $p).' '; + if($n) $n = ' '.($nl ? ''.$n.'' : $n).''; + $calendar = ''."\n". + '\n"; + + if($day_name_length){ #if the day names should be shown ($day_name_length > 0) + #if day_name_length is >3, the full name of the day will be printed + foreach($day_names as $d) + $calendar .= ''; + $calendar .= "\n"; + } + + if($weekday > 0) $calendar .= ''; #initial 'empty' days + for($day=1,$days_in_month=gmdate('t',$first_of_month); $day<=$days_in_month; $day++,$weekday++){ + if($weekday == 7){ + $weekday = 0; #start a new week + $calendar .= "\n"; + } + if(isset($days[$day]) and is_array($days[$day])){ + @list($link, $classes, $content) = $days[$day]; + if(is_null($content)) $content = $day; + $calendar .= '' : '>'). + ($link ? ''.$content.'' : $content).''; + } + else $calendar .= ""; + } + if($weekday != 7) $calendar .= ''; #remaining "empty" days + + return $calendar."\n
'.$p.($month_href ? ''.$title.'' : $title).$n."
'.t($day_name_length < 4 ? substr($d,0,$day_name_length) : $d) . '
 
$day 
\n"; + } +} +?> \ No newline at end of file diff --git a/modules/calendarview/module.info b/modules/calendarview/module.info new file mode 100644 index 00000000..e70ff69f --- /dev/null +++ b/modules/calendarview/module.info @@ -0,0 +1,3 @@ +name = "CalendarView" +description = "View your photos by the date they were taken." +version = 1 \ No newline at end of file diff --git a/modules/calendarview/views/calendarview_sidebar.html.php b/modules/calendarview/views/calendarview_sidebar.html.php new file mode 100644 index 00000000..b4f1f6fe --- /dev/null +++ b/modules/calendarview/views/calendarview_sidebar.html.php @@ -0,0 +1,9 @@ + +
    + 0): ?> +
  • ">
    • + + 0): ?> +
  • ">
    • + +
\ No newline at end of file diff --git a/modules/calendarview/views/calendarview_year.html.php b/modules/calendarview/views/calendarview_year.html.php new file mode 100644 index 00000000..be739c79 --- /dev/null +++ b/modules/calendarview/views/calendarview_year.html.php @@ -0,0 +1,178 @@ + +
+
+ dynamic_top() ?> +
+

+
+ +


+ +"; + + // Figure out if any photos were taken for the current month. + if ($calendar_user == "-1") { + $month_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, 1, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, $counter_months+1, 1, $calendar_year)) + ->find_all() + ->count(); + } else { + $month_count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $calendar_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, 1, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, $counter_months+1, 1, $calendar_year)) + ->find_all() + ->count(); + } + if ($month_count > 0) { + $month_url = url::site("calendarview/month/" . $calendar_year . "/" . $calendar_user . "/" . $counter_months . "/"); + } else { + $month_url = ""; + } + $calendar = new PHPCalendar($counter_months, $calendar_year, $month_url); + + // If there are photos, loop through each day in the month and display links on the correct dates. + if ($month_count > 0) { + $curr_day = 1; + $MAX_DAYS = date('t', mktime(00, 00, 00, $counter_months, 1, $calendar_year)); + while ($curr_day < $MAX_DAYS) { + if ($calendar_user == "-1") { + $day_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, $curr_day, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, $counter_months, ($curr_day + 1), $calendar_year)) + ->find_all() + ->count(); + } else { + $day_count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $calendar_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, $curr_day, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, $counter_months, ($curr_day + 1), $calendar_year)) + ->find_all() + ->count(); + } + if ($day_count > 0) { + $calendar->event($curr_day, url::site("calendarview/day/" . $calendar_year . "/" . $calendar_user . "/" . $counter_months . "/" . $curr_day)); + } + $curr_day++; + } + + // Do the last day of the month seperately, because the mktime code is different. + if ($calendar_user == "-1") { + $day_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, $MAX_DAYS, $calendar_year)) + ->where("captured", "<",mktime(0, 0, 0, ($counter_months + 1), 1, $calendar_year)) + ->find_all() + ->count(); + } else { + $day_count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $calendar_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, $MAX_DAYS, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, ($counter_months + 1), 1, $calendar_year)) + ->find_all() + ->count(); + } + if ($day_count > 0) { + $calendar->event($MAX_DAYS, url::site("calendarview/day/" . $calendar_year . "/" . $calendar_user . "/" . $counter_months . "/" . $MAX_DAYS)); + } + } + echo $calendar->render(); + print ""; + $counter_months++; + } + + // Do December seperately, because the mktime code is different. + print "
"; + if ($calendar_user == "-1") { + $month_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, 1, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, 1, 1, ($calendar_year + 1))) + ->find_all() + ->count(); + } else { + $month_count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $calendar_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, 1, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, 1, 1, ($calendar_year + 1))) + ->find_all() + ->count(); + } + if ($month_count > 0) { + $month_url = url::site("calendarview/month/" . $calendar_year . "/" . $calendar_user . "/" . $counter_months . "/"); + } else { + $month_url = ""; + } + $calendar = new PHPCalendar($counter_months, $calendar_year, $month_url); + if ($month_count > 0) { + $curr_day = 1; + $MAX_DAYS = date('t', mktime(00, 00, 00, $counter_months, 1, $calendar_year)); + while ($curr_day < $MAX_DAYS) { + if ($calendar_user == "-1") { + $day_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, $curr_day, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, $counter_months, ($curr_day + 1), $calendar_year)) + ->find_all() + ->count(); + } else { + $day_count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $calendar_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, $curr_day, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, $counter_months, ($curr_day + 1), $calendar_year)) + ->find_all() + ->count(); + } + if ($day_count > 0) { + $calendar->event($curr_day, url::site("calendarview/day/" . $calendar_year . "/" . $calendar_user . "/" . $counter_months . "/" . $curr_day)); + } + $curr_day++; + } + if ($calendar_user == "-1") { + $day_count = ORM::factory("item") + ->viewable() + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, $MAX_DAYS, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, 1, 1, $calendar_year+1)) + ->find_all() + ->count(); + } else { + $day_count = ORM::factory("item") + ->viewable() + ->where("owner_id", "=", $calendar_user) + ->where("type", "!=", "album") + ->where("captured", ">=", mktime(0, 0, 0, $counter_months, $MAX_DAYS, $calendar_year)) + ->where("captured", "<", mktime(0, 0, 0, 1, 1, $calendar_year+1)) + ->find_all() + ->count(); + } + if ($day_count > 0) { + $calendar->event($MAX_DAYS, url::site("calendarview/day/" . $calendar_year . "/" . $calendar_user . "/" . $counter_months . "/" . $MAX_DAYS)); + } + } + $counter_months++; + echo $calendar->render(); + print "
"; +?> \ No newline at end of file diff --git a/modules/calendarview/views/calpage.html.php b/modules/calendarview/views/calpage.html.php new file mode 100644 index 00000000..f98352b9 --- /dev/null +++ b/modules/calendarview/views/calpage.html.php @@ -0,0 +1,154 @@ + + + + + + + <? if ($page_title): ?> + <?= $page_title ?> + <? else: ?> + <? if ($theme->item()): ?> + <? if ($theme->item()->is_album()): ?> + <?= t("Browse Album :: %album_title", array("album_title" => $theme->item()->title)) ?> + <? elseif ($theme->item()->is_photo()): ?> + <?= t("Photo :: %photo_title", array("photo_title" => $theme->item()->title)) ?> + <? else: ?> + <?= t("Movie :: %movie_title", array("movie_title" => $theme->item()->title)) ?> + <? endif ?> + <? elseif ($theme->tag()): ?> + <?= t("Browse Tag :: %tag_title", array("tag_title" => $theme->tag()->name)) ?> + <? else: /* Not an item, not a tag, no page_title specified. Help! */ ?> + <?= t("Gallery") ?> + <? endif ?> + <? endif ?> + + " type="image/x-icon" /> + css("yui/reset-fonts-grids.css") ?> + css("superfish/css/superfish.css") ?> + css("themeroller/ui.base.css") ?> + css("gallery.common.css") ?> + css("screen.css") ?> + + page_type == "collection"): ?> + + + + + + + script("jquery.js") ?> + script("jquery.form.js") ?> + script("jquery-ui.js") ?> + script("gallery.common.js") ?> + + + script("gallery.ajax.js") ?> + script("gallery.dialog.js") ?> + script("superfish/js/superfish.js") ?> + script("jquery.localscroll.js") ?> + script("ui.init.js") ?> + + head() they get combined */ ?> + page_subtype == "photo"): ?> + script("jquery.scrollTo.js") ?> + script("gallery.show_full_size.js") ?> + page_subtype == "movie"): ?> + script("flowplayer.js") ?> + + + head() ?> + + + body_attributes() ?>> + page_top() ?> +
+ site_status() ?> +
+
+ + + + + + user_menu() ?> + header_top() ?> + + + + + + header_bottom() ?> +
+ + + +
    + + + > + + url) : ?> + title) ?> + + title) ?> + + + + +
+ + + +
+
+
+
+
+ messages() ?> + +
+
+
+
+ page_subtype != "login"): ?> + + +
+
+ +
+ page_bottom() ?> + + diff --git a/modules/contactowner/controllers/admin_contactowner.php b/modules/contactowner/controllers/admin_contactowner.php index f5972c09..73a82ee3 100644 --- a/modules/contactowner/controllers/admin_contactowner.php +++ b/modules/contactowner/controllers/admin_contactowner.php @@ -1,7 +1,7 @@ post("owner_button_text"); $str_contactemail = Input::instance()->post("owner_email"); $str_contactname = Input::instance()->post("owner_name"); + $str_messageheader = Input::instance()->post("message_header"); // Save Settings. module::set_var("contactowner", "contact_owner_link", $ownerLink); module::set_var("contactowner", "contact_user_link", $userLink); module::set_var("contactowner", "contact_button_text", $str_contactbutton); - module::set_var("contactowner", "contact_owner_email", $str_contactemail ); - module::set_var("contactowner", "contact_owner_name", $str_contactname ); + module::set_var("contactowner", "contact_owner_email", $str_contactemail); + module::set_var("contactowner", "contact_owner_name", $str_contactname); + module::set_var("contactowner", "contact_owner_header", $str_messageheader); message::success(t("Your Settings Have Been Saved.")); // Load Admin page. @@ -67,7 +69,7 @@ class Admin_ContactOwner_Controller extends Admin_Controller { private function _get_admin_form() { // Make a new Form. $form = new Forge("admin/contactowner/saveprefs", "", "post", - array("id" => "gContactOwnerAdminForm")); + array("id" => "g-contact-owner-adminForm")); // Make an array for the different types of link codes. $add_contactlinks = $form->group("contactOwnerLinks"); @@ -86,9 +88,12 @@ class Admin_ContactOwner_Controller extends Admin_Controller { $add_contacts->input("owner_button_text")->label(t("Contact Owner Link Text"))->value(module::get_var("contactowner", "contact_button_text")); $add_contacts->input("owner_email")->label(t("Owner Email Address"))->value(module::get_var("contactowner", "contact_owner_email")); $add_contacts->input("owner_name")->label(t("Owner Name"))->value(module::get_var("contactowner", "contact_owner_name")); - + + $message_prefs = $form->group("messagePrefs"); + $message_prefs->input("message_header")->label(t("Email Message Header"))->value(module::get_var("contactowner", "contact_owner_header")); + // Add a save button to the form. - $add_contacts->submit("SaveSettings")->value(t("Save")); + $form->submit("SaveSettings")->value(t("Save")); // Return the newly generated form. return $form; diff --git a/modules/contactowner/controllers/contactowner.php b/modules/contactowner/controllers/contactowner.php index 845454a5..2a760762 100644 --- a/modules/contactowner/controllers/contactowner.php +++ b/modules/contactowner/controllers/contactowner.php @@ -1,7 +1,7 @@ "gContactOwnerSendForm")); + array("id" => "g-contact-owner-send-form")); $sendmail_fields = $form->group("contactOwner"); $sendmail_fields->input("email_to")->label(t("To:"))->value(module::get_var("contactowner", "contact_owner_name")); - $sendmail_fields->input("email_from")->label(t("From:"))->value(user::active()->email); + $sendmail_fields->input("email_from")->label(t("From:"))->value(identity::active_user()->email); + $sendmail_fields->input("email_subject")->label(t("Subject:"))->value(""); $sendmail_fields->textarea("email_body")->label(t("Message:"))->value(""); $sendmail_fields->hidden("email_to_id")->value("-1"); @@ -40,7 +41,7 @@ class ContactOwner_Controller extends Controller { $sendmail_fields->submit("SendMessage")->value(t("Send")); // Set up and display the actual page. - $template = new Theme_View("page.html", "Contact"); + $template = new Theme_View("page.html", "other", "Contact"); $template->content = new View("contactowner_emailform.html"); $template->content->sendmail_form = $form; print $template; @@ -48,24 +49,24 @@ class ContactOwner_Controller extends Controller { public function emailid($user_id) { // Display a form that a vistor can use to contact a registered user. - + // If this page is disabled, show a 404 error. if (module::get_var("contactowner", "contact_user_link") != true) { - kohana::show_404(); + throw new Kohana_404_Exception(); } - + // Locate the record for the user specified by $user_id, // use this to determine the user's name. $userDetails = ORM::factory("user") - ->where("id", $user_id) + ->where("id", "=", $user_id) ->find_all(); // Make a new form with a couple of text boxes. $form = new Forge("contactowner/sendemail", "", "post", - array("id" => "gContactOwnerSendForm")); + array("id" => "g-contact-owner-send-form")); $sendmail_fields = $form->group("contactOwner"); $sendmail_fields->input("email_to")->label(t("To:"))->value($userDetails[0]->name); - $sendmail_fields->input("email_from")->label(t("From:"))->value(user::active()->email); + $sendmail_fields->input("email_from")->label(t("From:"))->value(identity::active_user()->email); $sendmail_fields->input("email_subject")->label(t("Subject:"))->value(""); $sendmail_fields->textarea("email_body")->label(t("Message:"))->value(""); $sendmail_fields->hidden("email_to_id")->value($user_id); @@ -74,7 +75,7 @@ class ContactOwner_Controller extends Controller { $sendmail_fields->submit("SendMessage")->value(t("Send")); // Set up and display the actual page. - $template = new Theme_View("page.html", "Contact"); + $template = new Theme_View("page.html", "other", "Contact"); $template->content = new View("contactowner_emailform.html"); $template->content->sendmail_form = $form; print $template; @@ -83,47 +84,71 @@ class ContactOwner_Controller extends Controller { public function sendemail() { // Process the data from the form into an email, // then send the email. - - // Copy the data from the email from into a couple of variables. - $str_emailsubject = Input::instance()->post("email_subject"); - $str_emailtoid = Input::instance()->post("email_to_id"); - $str_emailfrom = Input::instance()->post("email_from"); - $str_emailbody = Input::instance()->post("email_body"); - - // Add in some
tags to the message body where ever there are line breaks. - $str_emailbody = str_replace("\n", "\n
", $str_emailbody); - - // Gallery's Sendmail library doesn't allow for custom from addresses, - // so add the from email to the beginning of the message body instead. - $str_emailbody = "Message Sent From " . $str_emailfrom . "\r\n\r\n

" . $str_emailbody; - // Figure out where the email is going to. - $str_emailto = ""; - if ($str_emailtoid == -1) { - // If the email id is "-1" send the message to a pre-determined - // owner email address. - $str_emailto = module::get_var("contactowner", "contact_owner_email"); - } else { - // or else grab the email from the user table. - $userDetails = ORM::factory("user") - ->where("id", $str_emailtoid) - ->find_all(); - $str_emailto = $userDetails[0]->email; + // Make sure the form was submitted. + if ($_POST) { + // Set up some rules to validate the form against. + $post = new Validation($_POST); + $post->add_rules('email_from', 'required', 'valid::email'); + $post->add_rules('email_subject', 'required'); + $post->add_rules('email_body', 'required'); + + // If the form was filled out properly then... + if ($post->validate()) { + // Copy the data from the email form into a couple of variables. + $str_emailsubject = Input::instance()->post("email_subject"); + $str_emailtoid = Input::instance()->post("email_to_id"); + $str_emailfrom = Input::instance()->post("email_from"); + $str_emailbody = Input::instance()->post("email_body"); + + // Add in some
tags to the message body where ever there are line breaks. + $str_emailbody = str_replace("\n", "\n
", $str_emailbody); + + // Gallery's Sendmail library doesn't allow for custom from addresses, + // so add the from email to the beginning of the message body instead. + // Also add in the admin-defined message header. + $str_emailbody = module::get_var("contactowner", "contact_owner_header") . "
\r\n" . "Message Sent From " . $str_emailfrom . "
\r\n
\r\n" . $str_emailbody; + + // Figure out where the email is going to. + $str_emailto = ""; + if ($str_emailtoid == -1) { + // If the email id is "-1" send the message to a pre-determined + // owner email address. + $str_emailto = module::get_var("contactowner", "contact_owner_email"); + } else { + // or else grab the email from the user table. + $userDetails = ORM::factory("user") + ->where("id", "=", $str_emailtoid) + ->find_all(); + $str_emailto = $userDetails[0]->email; + } + + // Send the email message. + Sendmail::factory() + ->to($str_emailto) + ->subject($str_emailsubject) + ->header("Mime-Version", "1.0") + ->header("Content-type", "text/html; charset=utf-8") + ->message($str_emailbody) + ->send(); + + // Display a message telling the visitor that their email has been sent. + $template = new Theme_View("page.html", "other", "Contact"); + $template->content = new View("contactowner_emailform.html"); + $template->content->sendmail_form = t("Your Message Has Been Sent."); + print $template; + } else { + // Display a message telling the visitor that their email has been not been sent, + // along with the reason(s) why. + $template = new Theme_View("page.html", "other", "Contact"); + $template->content = new View("contactowner_emailform.html"); + $template->content->sendmail_form = t("Your Message Has Not Been Sent."); + $template->content->sendmail_form = $template->content->sendmail_form . "

" . t("Reason(s):") . "
"; + foreach($post->errors('form_error_messages') as $error) { + $template->content->sendmail_form = $template->content->sendmail_form . " - " . t($error) . "
"; + } + print $template; + } } - - // Send the email message. - Sendmail::factory() - ->to($str_emailto) - ->subject($str_emailsubject) - ->header("Mime-Version", "1.0") - ->header("Content-type", "text/html; charset=utf-8") - ->message($str_emailbody) - ->send(); - - // Display a message telling the visitor that their email has been sent. - $template = new Theme_View("page.html", "Contact"); - $template->content = new View("contactowner_emailform.html"); - $template->content->sendmail_form = t("Your Message Has Been Sent."); - print $template; } -} +} \ No newline at end of file diff --git a/modules/contactowner/helpers/contactowner_block.php b/modules/contactowner/helpers/contactowner_block.php new file mode 100644 index 00000000..b10252b3 --- /dev/null +++ b/modules/contactowner/helpers/contactowner_block.php @@ -0,0 +1,78 @@ + t("Contact Owner")); + } + + static function get($block_id, $theme) { + $block = ""; + + switch ($block_id) { + case "contact_owner": + + // Create a new block to display the links in. + $block = new Block(); + $block->css_id = "g-contact-owner"; + $block->title = t("Contact"); + $block->content = new View("contactowner_block.html"); + + // if $displayBlock is true, this block will be displayed, + // if there aren't any links to put in the block for whatever reason + // then $displayBlock will rename set to false and the + // block will not be displayed. + $displayBlock = false; + + if ($theme->item()) { + // Locate the record for the user that created the current item. + // Their name will be displayed as part of the contact link. + $userDetails = ORM::factory("user") + ->where("id", "=", $theme->item->owner_id) + ->find_all(); + + // Figure out if the contact item owner email link should be displayed. + // only display it if the current owner has an email address and + // the option for allowing item owners to be contacted is set to true. + if ((count($userDetails) > 0) && ($userDetails[0]->email != "") && + (module::get_var("contactowner", "contact_user_link") == true)) { + $block->content->userLink = "item->owner_id) . "\">" . t("Contact") . " " . + $userDetails[0]->name . ""; + $displayBlock = true; + } + } + + // Figure out if the contact site owner link should be displayed. + if (module::get_var("contactowner", "contact_owner_link")) { + $block->content->ownerLink = "" . t(module::get_var("contactowner", "contact_button_text")) . ""; + $displayBlock = true; + } + + break; + } + + if ($displayBlock) { + return $block; + } else { + return ""; + } + } +} diff --git a/modules/contactowner/helpers/contactowner_event.php b/modules/contactowner/helpers/contactowner_event.php index 6ebfccd9..5c8483d3 100644 --- a/modules/contactowner/helpers/contactowner_event.php +++ b/modules/contactowner/helpers/contactowner_event.php @@ -1,7 +1,7 @@ item()) { - return; - } - - // Locate the record for the user that created the current item. - // Their name will be displayed as part of the contact link. - $userDetails = ORM::factory("user") - ->where("id", $theme->item->owner_id) - ->find_all(); - - // Create a new block to display the links in. - $block = new Block(); - $block->css_id = "gContactOwner"; - $block->title = t("Contact:"); - $block->content = new View("contactowner_block.html"); - - // if $displayBlock is true, this block will be displayed, - // if there aren't any links to put in the block for whatever reason - // then $displayBlock will rename set to false and the - // block will not be displayed. - $displayBlock = false; - - // Figure out if the contact item owner email link should be displayed. - // only display it if the current owner has an email address and - // the option for allowing item owners to be contacted is set to true. - if ((count($userDetails) > 0) && ($userDetails[0]->email != "") && - (module::get_var("contactowner", "contact_user_link") == true)) { - $block->content->userLink = "item->owner_id) . "\">" . t("Contact") . " " . $userDetails[0]->name . ""; - $displayBlock = true; - } - - // Figure out if the contact site owner link should be displayed. - if (module::get_var("contactowner", "contact_owner_link")) { - $block->content->ownerLink = "" . t(module::get_var("contactowner", "contact_button_text")) . ""; - $displayBlock = true; - } - - if ($displayBlock) { - return $block; - } - } -} diff --git a/modules/contactowner/module.info b/modules/contactowner/module.info index 673023c3..e6995d27 100644 --- a/modules/contactowner/module.info +++ b/modules/contactowner/module.info @@ -1,3 +1,3 @@ -name = ContactOwner -description = Allows visitors to send the website owner an email. -version = 1 +name = "ContactOwner" +description = "Allows visitors to send the website owner an email." +version = 2 diff --git a/modules/contactowner/views/admin_contactowner.html.php b/modules/contactowner/views/admin_contactowner.html.php index 328e5820..08100e22 100644 --- a/modules/contactowner/views/admin_contactowner.html.php +++ b/modules/contactowner/views/admin_contactowner.html.php @@ -1,5 +1,5 @@ -
+

diff --git a/modules/contactowner/views/contactowner_block.html.php b/modules/contactowner/views/contactowner_block.html.php index c113564b..f593af5b 100644 --- a/modules/contactowner/views/contactowner_block.html.php +++ b/modules/contactowner/views/contactowner_block.html.php @@ -1,15 +1,15 @@ -