---

Bitmap.c

Go to the documentation of this file.

/*
 *    gui - [gega user interface] the flexible solution for user interface problems
 *    Copyright (C) 2002  Gergely Gati
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; version 2 of the License.
 *
 *    This program 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 General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *    Gergely Gati
 *      email:           g.gati@freemail.hu
 *      AIM screenname:  GatiGergely
 *      ICQ number:      93131690
 *
 */
#include <stdlib.h>
#include <string.h>

#include "macros.h"
#include "debug.h"
#include "Bases.h"
#include "Locale.h"
#include "Common.h"
#include "Memory.h"
#include "Gui.h"
#include "Window.h"
#include "Net.h"
#include "Bitmap.h"


static u32 (*call_vector[BITMAP_FUNC_DONE-BITMAP_FUNCBASE+1])(tag *);


struct Bitmap_s
{
  int width;
  int height;
  int size;
  int bytewidth;
  u8 *data;
  int locked;
};


u32 bitmap_Create(u32 firsttag, ...)
{
  return(bitmap_CreateTL((tag *)&firsttag));
}
u32 bitmap_CreateTL(tag *taglist)
{
  int width,height,inittype;
  u32 value;
  u8 *vector;

  Bitmap_t *ret=NULL;
  u8 val;

  debug_Begin();

  width=(int)tag_GetTagData(taglist,TAG_BMP_WIDTH,0L);
  height=(int)tag_GetTagData(taglist,TAG_BMP_HEIGHT,0L);
  inittype=(u8)tag_GetTagData(taglist,TAG_BMP_INITTYPE,0L);
  vector=(u8 *)tag_GetTagData(taglist,TAG_BMP_VECTOR,0L);
  value=(u32)tag_GetTagData(taglist,TAG_BMP_VALUE,0L);

  debug_Message("w:%d h:%d",width,height);

  val=(u8)value;
  if(width>0&&height>0)
  {
    if(NULL!=(ret=mem_malloc(sizeof(Bitmap_t))))
    {
      if(0!=(width%8)) ret->bytewidth=(width/8)+1;
      else ret->bytewidth=width/8;
      ret->size=ret->bytewidth*height;
      ret->locked=0;
      if(NULL!=(ret->data=mem_malloc(ret->size)))
      {
        ret->width=width;
        ret->height=height;
        memset(ret->data,0xff,ret->size);
        switch(inittype)
        {
          case BMP_ITY_BITMAP:
          {
            memcpy(ret->data,vector,ret->size);
            break;
          }
          case BMP_ITY_BYTES:
          {
            int x,y,b;
            u8 *p1,*p2,*src;
            for(src=vector,p1=ret->data,y=0;y<ret->height;y++)
            {
              p2=p1;
              for(x=0,b=7;x<ret->width;x++,b--)
              {
                if(b<0) { b=7; p2++; *p2=0; }
                *p2|=((!!*src++)<<b);
              }
              p1+=ret->bytewidth;
            }
            break;
          }
          case BMP_ITY_FILL:
          {
            bitmap_Fill(TAG_BMP_OBJECT,ret,TAG_BMP_VALUE,val,TAG_DONE);
            break;
          }
          case BMP_ITY_ALPHA:
          {
            debug_Error("BMP_ITY_ALPHA unimplemented yet");
            break;
          }
          case BMP_ITY_RGB:
          {
            int x,y,b;
            u8 *p1,*p2,*src;
            u32 curr;

            value&=0x00ffffff;
            for(src=vector,p1=ret->data,y=0;y<ret->height;y++)
            {
              p2=p1;
              for(x=0,b=7;x<ret->width;x++,b--)
              {
                if(b<0) { b=7; p2++; }
                curr=0L;
                src++;
                curr|=*src++;
                curr<<=8;
                curr|=*src++;
                curr<<=8;
                curr|=*src++;
                if(curr==value) *p2&=~(1<<b);
              }
              p1+=ret->bytewidth;
            }
            break;
          }
          default:
          {
            debug_Error("Bad inittype value");
            mem_free(ret);
            ret=NULL;
            break;
          }
        }
      }
      else
      {
        mem_free(ret);
        ret=NULL;
      }
    }
  }

//  bitmap_Print(ret,__FUNCTION__);

  debug_End();

  return((u32)ret);
}


void bitmap_Print(Bitmap_t *bmp, char *msg)
{
  if(bmp!=NULL)
  {
    int x,y,b;
    u8 *p1,*p2;

    printf("BITMAP: %dx%d '%s'\n  ",bmp->width,bmp->height,msg);
    for(p1=bmp->data,y=0;y<bmp->height;y++)
    {
      p2=p1;
      for(x=0,b=7;x<bmp->width;x++,b--)
      {
         if(b<0) { b=7; p2++; }
         if(((((*p2)&(1<<b)))&0xff)==0) printf(".");
         else printf("x");
      }
      p1+=bmp->bytewidth;
      printf("\n  ");
    }
    printf("-----\n");
  }
}


u32 bitmap_Delete(u32 firsttag, ...)
{
  return(bitmap_DeleteTL((tag *)&firsttag));
}
u32 bitmap_DeleteTL(tag *taglist)
{
  Bitmap_t *bmp;

  u32 ret=~0L;

  debug_Begin();

  bmp=(Bitmap_t *)tag_GetTagData(taglist,TAG_BMP_OBJECT,0L);

  if(bmp!=NULL)
  {
    if(bmp->locked==0)
    {
      if(bmp->data!=NULL) mem_free(bmp->data);
      mem_free(bmp);
      ret=0L;
    }
    else debug_Error("Unable to delete, Bitmap locked!");
  }

  debug_End();

  return(ret);
}


u32 bitmap_Copy(u32 firsttag, ...)
{
  return(bitmap_CopyTL((tag *)&firsttag));
}
u32 bitmap_CopyTL(tag *taglist)
{
  Bitmap_t *bmp;
  int x;
  int y;
  Bitmap_t *source;

  u32 ret=~0L;

  debug_Begin();

  bmp=(Bitmap_t *)tag_GetTagData(taglist,TAG_BMP_OBJECT,0L);
  x=(int)tag_GetTagData(taglist,TAG_BMP_X,0L);
  y=(int)tag_GetTagData(taglist,TAG_BMP_Y,0L);
  source=(Bitmap_t *)tag_GetTagData(taglist,TAG_BMP_SOURCE,0L);

  if(bmp!=NULL&&source!=NULL&&x>=0&&y>=0&&x<bmp->width&&y<bmp->height)
  {
    int ymax,xmax,x1,y1,addr,bit,saddr,sbit;

    // source bitmap-et bemasolni a masikba, a megfelelo helyre
    ymax=min(source->height,(bmp->height-y));
    xmax=min(source->width,(bmp->width-x));

    debug_Message("src.width=%d src.height=%d x=%d y=%d dest.width=%d dest.height=%d xmax=%d ymax=%d",source->width,source->height,x,y,bmp->width,bmp->height,xmax,ymax);

    for(y1=0;y1<ymax;y1++)
    {
      for(x1=0;x1<xmax;x1++)
      {
        addr=(y1+y)*bmp->bytewidth+((x1+x)/8);
        bit=1<<(7-((x1+x)%8));
        bmp->data[addr]&=~bit;
        saddr=y1*source->bytewidth+(x1/8);
        sbit=1<<(7-(x1%8));
        if(((source->data[saddr]&sbit)&0xff)!=0) bmp->data[addr]|=bit;
      }
    }
    ret=0L;
  }

  debug_End();

  return(ret);
}


u32 bitmap_ObtainVector(u32 firsttag, ...)
{
  return(bitmap_ObtainVectorTL((tag *)&firsttag));
}
u32 bitmap_ObtainVectorTL(tag *taglist)
{
  Bitmap_t *bmp;
  u8 **vector;
  int *width,*height,*bytewidth;

  u32 ret=~0L;

  debug_Begin();

  bmp=(Bitmap_t *)tag_GetTagData(taglist,TAG_BMP_OBJECT,0L);
  vector=(u8 **)tag_GetTagData(taglist,TAG_BMP_VECTOR,0L);
  width=(int *)tag_GetTagData(taglist,TAG_BMP_WIDTH,0L);
  height=(int *)tag_GetTagData(taglist,TAG_BMP_HEIGHT,0L);
  bytewidth=(int *)tag_GetTagData(taglist,TAG_BMP_BYTEWIDTH,0L);

  if(bmp!=NULL&&vector!=NULL)
  {
    bmp->locked=1;
    if(vector!=NULL) *vector=bmp->data;
    if(width!=NULL) *width=bmp->width;
    if(height!=NULL) *height=bmp->height;
    if(bytewidth!=NULL) *bytewidth=bmp->bytewidth;
    ret=0L;
  }

  debug_End();

  return(ret);
}

u32 bitmap_ReleaseVector(u32 firsttag, ...)
{
  return(bitmap_ReleaseVectorTL((tag *)&firsttag));
}
u32 bitmap_ReleaseVectorTL(tag *taglist)
{
  Bitmap_t *bmp;

  u32 ret=~0L;

  debug_Begin();

  bmp=(Bitmap_t *)tag_GetTagData(taglist,TAG_BMP_OBJECT,0L);

  if(bmp!=NULL)
  {
    bmp->locked=0;
    ret=0L;
  }

  debug_End();

  return(ret);
}


u32 bitmap_Fill(u32 firsttag, ...)
{
  return(bitmap_FillTL((tag *)&firsttag));
}
u32 bitmap_FillTL(tag *taglist)
{
  Bitmap_t *bmp;
  u8 value;

  u32 ret=~0L;

  debug_Begin();

  bmp=(Bitmap_t *)tag_GetTagData(taglist,TAG_BMP_OBJECT,0L);
  value=(u8)tag_GetTagData(taglist,TAG_BMP_VALUE,0L);

  if(bmp!=NULL)
  {
    int i;
    u8 mask=0,*p;

    if(value!=0) mask=0xff;
    for(p=bmp->data,i=0;i<bmp->size;i++) *p++=mask;
    ret=0L;
  }

  debug_End();

  return(ret);
}


u32 bitmap_IsSolid(u32 firsttag, ...)
{
  return(bitmap_IsSolidTL((tag *)&firsttag));
}
u32 bitmap_IsSolidTL(tag *taglist)
{
  Bitmap_t *bmp;
  u8 value;

  u32 ret=~0L;

  debug_Begin();

  bmp=(Bitmap_t *)tag_GetTagData(taglist,TAG_BMP_OBJECT,0L);
  value=(u8)tag_GetTagData(taglist,TAG_BMP_VALUE,0L);

  if(bmp!=NULL)
  {
    ret=0L;
  }

  debug_End();

  return(ret);
}




u32 bitmap_Call(int function, u32 firsttag, ...)
{
  return(bitmap_CallTL(function,(tag *)&firsttag));
}
u32 bitmap_CallTL(int function, tag *taglist)
{
  u32 ret=~0L;

  debug_Begin();

  debug_Message("function ID : %d",function-BITMAP_FUNCBASE);

  if(function>=BITMAP_FUNCBASE&&function<BITMAP_FUNC_DONE)
  {
    ret=call_vector[function-BITMAP_FUNCBASE](taglist);
  }
  else debug_Warning("%s(): Function code out of range! code=0x%04x",__FUNCTION__,function);

  debug_End();

  return(ret);
}


int bitmap_Init(void)
{
  int ret=-1;

  debug_Begin();

//Initialize call vector BEGIN - put this into the init function of this module
  call_vector[BITMAP_CREATE-BITMAP_FUNCBASE]=bitmap_CreateTL;
  call_vector[BITMAP_DELETE-BITMAP_FUNCBASE]=bitmap_DeleteTL;
  call_vector[BITMAP_COPY-BITMAP_FUNCBASE]=bitmap_CopyTL;
  call_vector[BITMAP_OBTAINVECTOR-BITMAP_FUNCBASE]=bitmap_ObtainVectorTL;
  call_vector[BITMAP_RELEASEVECTOR-BITMAP_FUNCBASE]=bitmap_ReleaseVectorTL;
  call_vector[BITMAP_FILL-BITMAP_FUNCBASE]=bitmap_FillTL;
  call_vector[BITMAP_ISSOLID-BITMAP_FUNCBASE]=bitmap_IsSolidTL;
//Initialize call vector END
  bases_modules.bitmap_Call=bitmap_Call;
  bases_modules.bitmap_CallTL=bitmap_CallTL;

  ret=0;

  debug_End();

  return(ret);
}


void bitmap_CleanUp(void)
{
  debug_Begin();
  debug_End();

  return;
}

---