This commit was manufactured by cvs2svn to create branch 'branch-1.1'.

git-svn-id: file:///fltk/svn/fltk/branches/branch-1.1@1613 ea41ed52-d2ee-0310-a9c1-e6b18d33e121

1 files changed, 261 insertions, 0 deletions

diff --git a/src/Fl_Shared_Image.cxx b/src/Fl_Shared_Image.cxx
new file mode 100644
index 000000000..fffcb3ea0
--- /dev/null
+++ b/src/Fl_Shared_Image.cxx
@@ -0,0 +1,261 @@
+//
+// "$Id: Fl_Shared_Image.cxx,v 1.23 2001/09/10 01:16:17 spitzak Exp $"
+//
+// Image drawing code for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-1999 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems to "fltk-bugs@easysw.com".
+//
+
+// Draw an image that is stored compressed in a file or in memory. 
+// Keep uncompressed images in memory for later use. 
+
+#include <config.h>
+#include <fltk/Fl.h>
+#include <fltk/fl_draw.h>
+#include <fltk/Fl_Shared_Image.h>
+#include <fltk/Fl_Bitmap.h>
+#include <fltk/x.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+FL_IMAGES_API const char *Fl_Shared_Image::fl_shared_image_root=0;
+
+FL_IMAGES_API Fl_Shared_Image  *Fl_Shared_Image::first_image = 0;
+
+FL_IMAGES_API int Fl_Shared_Image::image_used=0;
+FL_IMAGES_API size_t Fl_Shared_Image::mem_usage_limit=0;
+
+FL_IMAGES_API size_t Fl_Shared_Image::mem_used=0;
+FL_IMAGES_API int Fl_Shared_Image::forbid_delete = 1;
+
+//     static size_t mem_used=0; (now moved to Fl.cxx !)
+// This contains the total number of pixmap pixels in the cache
+// WARNING : this is updated incrementally, so beware that it keeps balanced
+// when deleting or creating pixmaps !
+
+Fl_Shared_Image::~Fl_Shared_Image()
+{
+  if(forbid_delete)
+    fprintf(stderr, 
+      "FLTK user error : deleting an Fl_Shared_Image object is forbiden !\n");
+  if(id) mem_used -= w*h;
+}
+
+void Fl_Shared_Image::set_cache_size(size_t l)
+{
+  mem_usage_limit = l;
+}
+
+static Fl_Shared_Image *limage; // used to find the less used image
+void Fl_Shared_Image::find_less_used() {
+  if(l1) l1->find_less_used();
+  if(l2) l2->find_less_used();
+  if(id && (limage->id == 0 || used<limage->used)) limage=this;
+}
+void Fl_Shared_Image::check_mem_usage()
+{
+  if(mem_usage_limit==0 || first_image==NULL || mem_used < mem_usage_limit) 
+    return;
+
+  do {
+    limage=first_image;
+    first_image->find_less_used();
+    if(limage->id) {
+      mem_used -= limage->w*limage->h;
+      fl_delete_offscreen(Pixmap(limage->id));
+      limage->id=0;
+      if(limage->mask) {
+	fl_delete_bitmap(Pixmap(limage->mask));
+	limage->mask = 0;
+      }
+    } else return;
+  } while(mem_used >= mem_usage_limit);
+}
+
+
+class fl_shared_image_destructor_class {
+  int dummy;
+public:
+  fl_shared_image_destructor_class() { dummy = 0; }
+  ~fl_shared_image_destructor_class() {
+    if (Fl_Shared_Image::first_image) Fl_Shared_Image::first_image->clear_cache();
+  }
+};
+
+fl_shared_image_destructor_class fl_shared_image_destructor;
+
+void Fl_Shared_Image::clear_cache()
+{
+  if(id) {
+    mem_used -= w*h;
+    fl_delete_offscreen((Pixmap)id);
+    id=0;
+    if(mask) {
+      fl_delete_bitmap((Pixmap)mask);
+      mask = 0;
+    }
+  }
+  if (l1) l1->clear_cache();
+  if (l2) l2->clear_cache();
+}
+
+void Fl_Shared_Image::set_root_directory(const char *d) {
+  fl_shared_image_root = d;
+}
+
+void Fl_Shared_Image::insert(Fl_Shared_Image*& p, Fl_Shared_Image* image) {
+  if(p == 0)
+    p = image;
+  else {
+    int c = strcmp(image->name, p->name);
+    if(c<0) insert(p->l1, image);
+    else insert(p->l2, image);
+  }
+}
+
+Fl_Shared_Image* Fl_Shared_Image::find(Fl_Shared_Image* image, const char* name) {
+  if(image == 0) return 0;
+  int c = strcmp(name, image->name);
+  if(c == 0) return image;
+  else if(c<0) return find(image->l1, name);
+  else return find(image->l2, name);
+}
+
+
+const char* Fl_Shared_Image::get_filename() {
+  return get_filename(name);
+}
+
+const char* Fl_Shared_Image::get_filename(const char* name)
+{
+  if (name[0] == '/' || !fl_shared_image_root || !*fl_shared_image_root)
+    return name;
+  int m = strlen(fl_shared_image_root);
+  int n = strlen(name) + m + 2;
+  static char *s;
+  if (s) free(s);
+  s = (char*) malloc(n+1);
+  strcpy(s, fl_shared_image_root);
+  if (s[m-1] != '/') s[m++] = '/';
+  strcpy(s+m, name);
+  return s;
+}
+
+
+Fl_Shared_Image* Fl_Shared_Image::get(Fl_Shared_Image* (*create)(),
+				      const char* name, const uchar *datas)
+{
+  Fl_Shared_Image *image=Fl_Shared_Image::find(first_image, name);
+  if(!image)
+  {
+    image=create();
+    image->refcount = 1;
+    image->name = strdup(name);
+    image->datas=datas;
+    image->w = -1; // We mark the fact the it has never been measured yet
+    image->l1 = image->l2 = 0;
+    image->id=image->mask=0;
+    Fl_Shared_Image::insert(first_image, image);
+  } else {
+    if(image->datas==NULL) image->datas=datas;
+    image->refcount++;
+  }
+  image->used = image_used++;
+  return image;
+}
+
+void Fl_Shared_Image::reload(const uchar* pdatas)
+{
+  if (id) {
+    mem_used -= w*h;
+    fl_delete_offscreen((Pixmap)id);
+    id=0;
+    if (mask) {
+      fl_delete_bitmap((Pixmap)mask);
+      mask = 0;
+    }
+  }
+  if (pdatas) datas = pdatas;
+  measure(w, h);
+}
+void Fl_Shared_Image::reload(const char* name, const uchar* pdatas)
+{
+  Fl_Shared_Image *image=Fl_Shared_Image::find(first_image, name);
+  if (image) image->reload(pdatas);
+}
+
+void Fl_Shared_Image::remove_from_tree(Fl_Shared_Image*& p, Fl_Shared_Image* image) {
+  if (p) {
+    int c = strcmp(image->name, p->name);
+    if (c == 0) {
+      if (image->l1) {
+	p = image->l1;
+	if (image->l2) insert(first_image, image->l2);
+      } else
+	p = image->l2;
+    } else if (c<0) remove_from_tree(p->l1, image);
+    else remove_from_tree(p->l2, image);
+  }
+}
+
+int Fl_Shared_Image::remove()
+{
+  if (--refcount) return 0;
+  remove_from_tree(first_image, this);
+  forbid_delete = 0;
+  delete this;
+  forbid_delete = 1;
+  return 1;
+}
+int Fl_Shared_Image::remove(const char* name)
+{
+  Fl_Shared_Image *image=Fl_Shared_Image::find(first_image, name);
+  if (image) return image->remove();
+  else return 0;
+}
+
+void Fl_Shared_Image::draw(int X, int Y, Fl_Flags flags)
+{
+  if (w<0) measure(w, h);
+  if (w==0) return;
+  if (!id) // Need to uncompress the image ?
+  {
+    used = image_used++; // do this before check_mem_usage
+    mem_used += w*h;
+    check_mem_usage();
+
+    read();
+    if (!id) { // could not read the image for some reason ?
+      mem_used -= w*h;
+      w = 0; // Will never try again ...
+      return; 
+    }
+  }
+  else
+    used = image_used++;
+  _draw(X, Y, flags);
+}
+
+//
+// End of "$Id: Fl_Shared_Image.cxx,v 1.23 2001/09/10 01:16:17 spitzak Exp $"
+//