---

block.c

/*
GOCR Copyright (C) 2000  Joerg Schulenburg Joerg.Schulenburg@physik.uni-magdeburg.de 
GOCR API Copyright (C) 2001 Bruno Barberi Gnecco <brunobg@sourceforge.net>

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; either version 2
of the License, or (at your option) any later version.

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.

*/

#include "_gocr.h"
#include <string.h>

/* 
 * global variables 
 */
gocrBlock *currentblock = NULL;

/*
 * internal data
 */
List blocklist;
static HashTable blocktypelist;
static gocrblockType currentblocktype = 1; /* 1 because 0 would mistaken by NULL */

/*
 * _internal functions
 */
int _gocr_initBlock ( void ) { 
  char                  *basetypes[3] = { "TEXT", "PICTURE", "MATH_EXPRESSION" };
  int                   i;

  hash_init(&blocktypelist, 0xFF, NULL);
  
  for ( i = 0; i < sizeof(basetypes)/sizeof(char *); i++ )
    gocr_blockTypeRegister(basetypes[i]);

  return 0;
}

void _gocr_endBlock ( void ) { 

  hash_free(&blocktypelist, NULL);

}

/* 
 * API functions
 */

/* Block type functions
 */

gocrblockType gocr_blockTypeRegister ( char *name ) {
  _gocr_debug(3, fprintf(_data.error, "gocr_blockTypeRegister(%s): %d\n", name, currentblocktype);)

  if ( !name ) {
    _gocr_debug(1, fprintf(_data.error, "Error: gocr_blockTypeRegister(NULL).\n");)
    return -1;
  }

  /* insert */
  switch ( hash_insert(&blocktypelist, name, (void *)currentblocktype) ) {
    case -1:
      _gocr_debug(1, fprintf(_data.error, "Error: hash_insert returned -1.\n");)
      return -1;
    case -2:
      _gocr_debug(1, fprintf(_data.error, "Error: block already registered. Ignoring.\n");)
      return -1;
    default:
      break;
  }

  return currentblocktype++;
}

gocrblockType gocr_blockTypeGetByName ( char *name ) {
  void *ret;

  _gocr_debug(3, fprintf(_data.error, "gocr_blockTypeGetByName(%s): %d\n", name, 
      currentblocktype);)

  ret = hash_data(&blocktypelist, name);
  if ( ret == NULL )
    return -1;
  return (gocrblockType) ret;
}

char *gocr_blockTypeGetNameByType ( gocrblockType t ) {
  _gocr_debug(3, fprintf(_data.error, "gocr_blockTypeGetNameByType(%d)\n", t);)

  return hash_key(&blocktypelist, (void *)t);
}

int gocr_blockAdd ( gocrBlock *b ) { 
  int i, j;

  _gocr_debug(3, fprintf(_data.error, "gocr_blockAdd(%p)\n", b);)
  
  /* checks if blocktype is registered */
  if ( b->t >= currentblocktype ) {
    _gocr_debug(1, fprintf(_data.error, "Block type not registered, ignoring block\n");)
    return -1;
  }

  /* check boundaries */
  _gocr_fixParameters ( &b->x0, &b->y0, &b->x1, &b->y1 );
  if ( b->x0 < 0 || b->y0 < 0 || b->x1 >= currentimage->x || b->y1 >= currentimage->y ) {
    _gocr_debug(1, fprintf(_data.error, "Block is out of bounds\n");)
    return -1;
  }

  /* check for overlap */
  if ( _data.block_overlap == 0 ) {
    gocrBlock *t;
    int ret = 0;

    for_each_data(&blocklist) {
      t = (gocrBlock *)list_get_current(&blocklist);
      if ( t->x0 < b->x0 && t->x1 > b->x0 && t->y0 < b->y0 && t->y1 > b->y0 ) {
        ret = 1;
        break;
      }
      if ( t->x0 < b->x1 && t->x1 > b->x1 && t->y0 < b->y1 && t->y1 > b->y1 ) {
        ret = 1;
        break;
      }
    } end_for_each(&blocklist);
    if ( ret == 1 ) {
      _gocr_debug(2, fprintf(_data.error, "Block overlap\n");)
      return -2;
    }
  }

  /* set image */
  if ( _gocr_imageSharedCopy(currentimage, b->x0, b->x1, b->y0, b->y1, 
                &b->image) == -1 ) {
    _gocr_debug(2, fprintf(_data.error, "Image share error\n");)
    return -1;
  }

  /* fill the isblock field */
  for ( i = b->x0; i <= b->x1; i++ )  
    for ( j = b->x0; j <= b->x1; j++ )
      currentimage->data[i][j].isblock = 1;

  /* append to block list */
  if ( list_app(&blocklist, b) ) {
    _gocr_debug(2, fprintf(_data.error, "List error\n");)
    return -1;
  }

  return 0;
}

---