Rainer and Edzard,
thanx for the inspiration. I really prefer the XPM format. (expect the downside 
it is not compressed ;-( )

The best solution in my case was to combine both of your ideas.
So i expanded Fl_XPM_image and added the functionality to pass
a pointer for the XPM image data.

One easy step away by replacing fgets() with 'memgets()'.

Maybe its useful for 1.3 too.

mk

--- my_XPM_Image.h ---
//
// "$Id: my_XPM_Image.h,v 1.2 2012/02/08 22:14:56 mattes Exp $"
//
// XPM image header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2005 by Bill Spitzak and others.
// Copyright 2012      by mattes
//
// 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 on the following page:
//
//     http://www.fltk.org/str.php
//

#ifndef my_XPM_Image_H
#define my_XPM_Image_H
#  include "FL/Fl_Pixmap.H"

class FL_EXPORT my_XPM_Image : public Fl_Pixmap {

  public:

  my_XPM_Image(const char* filename, void *vxpm, int xlen );
};

#endif // !my_XPM_Image
-------------------------

--- my_XPM_Image.cpp ---


// "$Id: my_XPM_Image.cpp,v 1.3 2012/02/08 23:42:57 mattes Exp $"
//
// Fl_XPM_Image routines.
//
// Copyright 1997-2005 by Bill Spitzak and others.
// Copyright 2012      by mattes
//
// 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 on the following page:
//
//     http://www.fltk.org/str.php
//
// Contents:
//
//

//
// Include necessary header files...
//

#include <FL/Fl.H>
#include <FL/Fl_XPM_Image.H>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>     //isdigit
#include <string.h>    //memcpy

#include "my_XPM_Image.h"

//
// 'hexdigit()' - Convert a hex digit to an integer.
//

static int hexdigit(int x) {    // I - Hex digit...
  if (isdigit(x)) return x-'0';
  if (isupper(x)) return x-'A'+10;
  if (islower(x)) return x-'a'+10;
  return 20;
}


static char*
memgets( void **xptr,int *xlen, char *buf,int bufsize )
{
   // emulate fgets() func by reading the data from memory buffer
   //    return string by string
   //    xptr = filepointer to the next string
   //    xlen = remaing len of data in buffer

   char *mptr = (char *) *xptr;
   int mlen = *xlen;

   // find next '\n'
   const char *s = strchr(mptr, '\n');
   if ( s == NULL ) return NULL;

   int l = s - mptr +1;     //+1 for CR

   if ( l > bufsize-1 )
      l = bufsize-1;         // don't overrun buf (limit memcpy to bufsize)
   memcpy ( buf, mptr, l );
   buf[l] = '\0';            //terminate buffer

   // update xptr
   mptr += l;
   mlen -= l;
   *xptr = mptr;
   *xlen = mlen;

   return buf;
}

#define MAXSIZE 2048
#define INITIALLINES 256

my_XPM_Image::my_XPM_Image( const char *name, void *vxpm,int xlen) : 
Fl_Pixmap((char *const*)0 )
{
  FILE *f = NULL;
  void *xpmptr = vxpm;
  int   xpmlen = xlen;

  if ( vxpm == NULL || xlen <= 0) {
    if ((f = fopen(name, "rb")) == NULL) return;
  }

  // read all the c-strings out of the file:
  char** new_data = new char *[INITIALLINES];
  char** temp_data;
  int malloc_size = INITIALLINES;
  char buffer[MAXSIZE+20];
  int i = 0;
  int frsize = 0;
   //while (fgets(buffer,MAXSIZE+20,f)) {
   while ( 1 ) {
      char *cs = NULL;
      if ( vxpm == NULL || xlen <= 0) {
         cs = fgets(buffer,MAXSIZE+20,f);
      }
      else {
         cs = memgets( &xpmptr, &xpmlen, buffer, MAXSIZE+20 );
      }
      if ( cs == NULL ) break;
      frsize += strlen(buffer);
      if (buffer[0] != '\"') continue;
      char *myp = buffer;
      char *q = buffer+1;
      while (*q != '\"' && myp < buffer+MAXSIZE) {
         if (*q == '\\') switch (*++q) {
            case '\r':
            case '\n':
               if ( vxpm == NULL || xlen <= 0) {
                  fgets(buffer,MAXSIZE+20,f);
               }
               else {
                  memgets( &xpmptr, &xpmlen, buffer, MAXSIZE+20 );
               }
            case 0:
               break;
            case 'x': {
               q++;
               int n = 0;
               for (int x = 0; x < 3; x++) {
               int xd = hexdigit(*q);
               if (xd > 15) break;
               n = (n<<4)+xd;
               q++;
               }
               *myp++ = n;
               } break;
            default: {
               int c = *q++;
               if (c>='0' && c<='7') {
               c -= '0';
               for (int x=0; x<2; x++) {
                int xd = hexdigit(*q);
                if (xd>7) break;
                c = (c<<3)+xd;
                q++;
               }
               }
               *myp++ = c;
               } break;
         }
         else {
            *myp++ = *q++;
         }   // if(q
      }    //while(q

      *myp++ = 0;
      if (i >= malloc_size) {
         temp_data = new char *[malloc_size + INITIALLINES];
         memcpy(temp_data, new_data, sizeof(char *) * malloc_size);
         delete[] new_data;
         new_data = temp_data;
         malloc_size += INITIALLINES;
      }
      new_data[i] = new char[myp-buffer+1];
      memcpy(new_data[i], buffer,myp-buffer);
      new_data[i][myp-buffer] = 0;
      i++;
  }    //while fgets

  if ( f ) fclose(f);

  data((const char **)new_data, i);
  alloc_data = 1;

  measure();
}


_______________________________________________
fltk mailing list
[email protected]
http://lists.easysw.com/mailman/listinfo/fltk

Reply via email to