Пример #1
0
Cardinal 
Urm__SwapRGMCallbackDesc (RGMCallbackDescPtr	callb_desc,
			  RGMWidgetRecordPtr	widget_rec)
{
  Cardinal		ndx;	    /* inner loop index */
  RGMResourceDescPtr	res_desc;   /* resource description literal */
  char			err_msg[300];
    
  swapbytes( callb_desc->validation );
  swapbytes( callb_desc->count );
  swapbytes( callb_desc->annex );
  swapbytes( callb_desc->unres_ref_count );
  for (ndx=0 ; ndx < callb_desc->count ; ndx++)
    {
#ifdef WORD64
      swap4bytes( callb_desc->item[ndx].cb_item.routine );
      swap4bytes( callb_desc->item[ndx].cb_item.rep_type );
#else
      swap2bytes( callb_desc->item[ndx].cb_item.routine );
      swap2bytes( callb_desc->item[ndx].cb_item.rep_type );
#endif
      switch (callb_desc->item[ndx].cb_item.rep_type)
	{
	case MrmRtypeInteger:
	case MrmRtypeBoolean:
	  swapbytes( callb_desc->item[ndx].cb_item.datum.ival );
	  break;	
	case MrmRtypeSingleFloat:
	  swapbytes( callb_desc->item[ndx].cb_item.datum.ival );
	  _MrmOSIEEEFloatToHost((float *)
				&(callb_desc->item[ndx].cb_item.datum.ival));
	case MrmRtypeNull:
	  break;
	case MrmRtypeResource:
	  swapbytes( callb_desc->item[ndx].cb_item.datum.offset );
	  res_desc = (RGMResourceDesc *)
	    ((char *)widget_rec + callb_desc->item[ndx].cb_item.datum.offset);
	  Urm__SwapRGMResourceDesc( res_desc );
	  /* flag this resource as needing further byte swapping */
	  res_desc->cvt_type |= MrmResourceUnswapped;
	  break;
	default:
	  swapbytes( callb_desc->item[ndx].cb_item.datum.offset );
	  sprintf(err_msg, _MrmMMsg_0021,
		  callb_desc->item[ndx].cb_item.rep_type, ndx);
	  return Urm__UT_Error ("Urm__SwapRGMCallbackDesc",
				err_msg, NULL, NULL, MrmFAILURE) ;
	  break;
	}
    }
  return MrmSUCCESS;
}
Пример #2
0
Cardinal 
Urm__SwapRGMResourceDesc (RGMResourceDescPtr	res_desc)
{
  IDBridDesc  *idb_rid_ptr;

  swapbytes( res_desc->size );
  swapbytes( res_desc->annex1 );
  if ( res_desc->type == URMrRID ) 
    {
      idb_rid_ptr = (IDBridDesc *)&(res_desc->key.id);
#ifdef WORD64
      swap4bytes( idb_rid_ptr->internal_id.map_rec );
      swap4bytes( idb_rid_ptr->internal_id.res_index );
#else
      swap2bytes( idb_rid_ptr->internal_id.map_rec );
      swap2bytes( idb_rid_ptr->internal_id.res_index );
#endif
    }


  return MrmSUCCESS;
}
Пример #3
0
void DumpWORD(FILE *flp, short word)
{

	char byte;
	short wordswp;

	wordswp = swap2bytes(word);

	for (unsigned int i = 0; i < sizeof(WORD); i++)
	{
		memcpy(&byte, (char*)&wordswp + i, 1);	
		DumpByte(flp, &byte);
		fprintf(flp, " ");
	}
	

}
Пример #4
0
char *readTiff3DFile2Buffer ( void *fhandler, unsigned char *img, unsigned int img_width, unsigned int img_height, unsigned int first, unsigned int last, int b_swap ) {
	uint32 rps;
    uint16 spp, bpp, photo, comp, planar_config;
    int check, StripsPerImage,LastStripSize;

    TIFF *input = (TIFF *) fhandler;

	check=TIFFGetField(input, TIFFTAG_ROWSPERSTRIP, &rps);
	if (!check)
	{
		return ((char *) "Image length of undefined.");
	}	
	//rps=600;
    
	check=TIFFGetField(input, TIFFTAG_BITSPERSAMPLE, &bpp); 
	if (!check)
	{
		return ((char *) "Undefined bits per sample.");
	}

	check=TIFFGetField(input, TIFFTAG_SAMPLESPERPIXEL, &spp);
	if (!check)
	{
		return ((char *) "Undefined samples per pixel.");
	}

	check=TIFFGetField(input, TIFFTAG_PHOTOMETRIC, &photo);
	if (!check)
	{
		return ((char *) "Cannot determine photometric interpretation.");
	}

	check=TIFFGetField(input, TIFFTAG_COMPRESSION, &comp);
	if (!check)
	{
		return ((char *) "Cannot determine compression technique.");
	}

	check=TIFFGetField(input, TIFFTAG_PLANARCONFIG, &planar_config);
	if (!check)
	{
		return ((char *) "Cannot determine planar configuration.");
	}


	StripsPerImage =  (img_height + rps - 1) / rps;
	LastStripSize = img_height % rps;
	if (LastStripSize==0)
		LastStripSize=rps;

	check=TIFFSetDirectory(input, first);
	if (!check)
	{
		return ((char *) "Cannot open the requested first strip.");
	}

	unsigned char *buf = img;
	int page=0;
	do{

		for (int i=0; i < StripsPerImage-1; i++){
			if (comp==1) {
				TIFFReadRawStrip(input, i, buf, spp * rps * img_width * (bpp/8));
				buf = buf + spp * rps * img_width * (bpp/8);
			}
			else{
				TIFFReadEncodedStrip(input, i, buf, spp * rps * img_width * (bpp/8));
				buf = buf + spp * rps * img_width * (bpp/8);
			}
		}

		if (comp==1) {
			TIFFReadRawStrip(input, StripsPerImage-1, buf, spp * LastStripSize * img_width * (bpp/8));
		}
		else{
			TIFFReadEncodedStrip(input, StripsPerImage-1, buf, spp * LastStripSize * img_width * (bpp/8));
		}
		buf = buf + spp * LastStripSize * img_width * (bpp/8);

		page++;
	
	}while ( page < static_cast<int>(last-first+1) && TIFFReadDirectory(input));//while (TIFFReadDirectory(input));

	// input file is assumedo ti be already open and it is provided as an handler; the file should be closed by caller
	//TIFFClose(input);  

	if ( page < static_cast<int>(last-first+1) ){
		return ((char *) "Cannot read all the pages.");
	}

	// swap the data bytes if necessary 	
	if (b_swap)
	{
		int i;
		size_t total = img_width * img_height * spp * (last-first+1);
		if (bpp/8 == 2)
		{
			for (i=0;i<total; i++)
			{
				swap2bytes((void *)(img+2*i));
			}
		}
		else if (bpp/8 == 4)
		{
			for (i=0;i<total; i++)
			{
				swap4bytes((void *)(img+4*i));
			}
		}
	}

	return (char *) 0;
}
Пример #5
0
int loadRaw2Stack(char * filename, unsigned char ** img, long ** sz, int datatype) //this is the function of 4-byte raw format.
{
  /* This function reads 2-4D image stack from raw data generated by the program "saveStack2Raw.m". */
  /* The input parameters img, sz, and datatype should be empty, especially the pointers "img" and "sz". */

  int berror = 0;

  FILE * fid = fopen(filename, "rb");
  if (!fid)
    {
      printf("Fail to open file for reading.\n");
      berror = 1;
      return berror;
    }

  fseek (fid, 0, SEEK_END);
  long fileSize = ftell(fid);
  rewind(fid);

  /* Read header */

  char formatkey[] = "raw_image_stack_by_hpeng";
  long lenkey = strlen(formatkey);

  if (fileSize<lenkey+2+4*4+1) // datatype has 2 bytes, and sz has 4*4 bytes and endian flag has 1 byte. 
    {
      printf("The size of your input file is too small and is not correct, -- it is too small to contain the legal header.\n");
      printf("The fseek-ftell produces a file size = %ld.", fileSize);
      berror = 1;
      return berror;
    }

  char * keyread = (char*)Guarded_Malloc((lenkey+1)*sizeof(char), Program_Name());
  if (!keyread)
    {
      printf("Fail to allocate memory.\n");
      berror = 1;
      return berror;
    }
  long nread = fread(keyread, 1, lenkey, fid);
  if (nread!=lenkey)
    {
      printf("File unrecognized or corrupted file.\n");
      berror = 1;
      return berror;
    }
  keyread[lenkey] = '\0';

  long i;
  if (strcmp(formatkey, keyread)) /* is non-zero then the two strings are different */
    {
      printf("Unrecognized file format.\n");
      if (keyread) {free(keyread); keyread=0;}
      berror = 1;
      return berror;
    }

  char endianCodeData;
  fread(&endianCodeData, 1, 1, fid);
  if (endianCodeData!='B' && endianCodeData!='L')
    {
      printf("This program only supports big- or little- endian but not other format. Check your data endian.\n");
      berror = 1;
      if (keyread) {free(keyread); keyread=0;}
      return berror;
    }

  char endianCodeMachine;
  endianCodeMachine = checkMachineEndian();
  if (endianCodeMachine!='B' && endianCodeMachine!='L')
    {
      printf("This program only supports big- or little- endian but not other format. Check your data endian.\n");
      berror = 1;
      if (keyread) {free(keyread); keyread=0;}
      return berror;
    }

  int b_swap = (endianCodeMachine==endianCodeData)?0:1;
  printf("machine endian=[%c] data endian=[%c] b_swap=%d\n", endianCodeMachine, endianCodeData, b_swap);


  short int dcode = 0;
  fread(&dcode, 2, 1, fid); /* because I have already checked the file size to be bigger than the header, no need to check the number of actual bytes read. */
  if (b_swap)
    swap2bytes((void *)&dcode);

  switch (dcode)
    {
    case 1:
      datatype = 1; /* temporarily I use the same number, which indicates the number of bytes for each data point (pixel). This can be extended in the future. */
      break;

    case 2:
      datatype = 2;
      break;

    case 4:
      datatype = 4;
      break;

    default:
      printf("Unrecognized data type code [%d]. The file type is incorrect or this code is not supported in this version.\n", dcode);
      if (keyread) {free(keyread); keyread=0;}
      berror = 1;
      return berror;
    }

  long unitSize = datatype; // temporarily I use the same number, which indicates the number of bytes for each data point (pixel). This can be extended in the future. 

  printf("loadRaw2Stack unitSize=%d\n", unitSize);

  unsigned int mysz[4];
  mysz[0]=mysz[1]=mysz[2]=mysz[3]=0;
  int tmpn=fread(mysz, 4, 4, fid); // because I have already checked the file size to be bigger than the header, no need to check the number of actual bytes read. 
  if (tmpn!=4)
    {
      printf("This program only reads [%d] units.\n", tmpn);
      berror=1;
      return berror;
    }
  if (b_swap)
    {
      for (i=0;i<4;i++)
	{
	  //swap2bytes((void *)(mysz+i));
	  printf("mysz raw read unit[%ld]: [%d] ", i, mysz[i]);
	  swap4bytes((void *)(mysz+i));
	  printf("swap unit: [%d][%0x] \n", mysz[i], mysz[i]);
	}
    }

  if (*sz) {free(*sz); *sz=0;}
  *sz=(long*)Guarded_Malloc(4*sizeof(long), Program_Name());
  if (!(*sz))
    {
      printf("Fail to allocate memory.\n");
      if (keyread) {free(keyread); keyread=0;}
      berror = 1;
      return berror;
    }

  long totalUnit = 1;
  for (i=0;i<4;i++)
    {
      (*sz)[i] = (long)mysz[i];
      totalUnit *= (*sz)[i];
    }

  //mexPrintf("The input file has a size [%ld bytes], different from what specified in the header [%ld bytes]. Exit.\n", fileSize, totalUnit*unitSize+4*4+2+1+lenkey);
  //mexPrintf("The read sizes are: %ld %ld %ld %ld\n", sz[0], sz[1], sz[2], sz[3]);

  if ((totalUnit*unitSize+4*4+2+1+lenkey) != fileSize)
    {
      printf("The input file has a size [%ld bytes], different from what specified in the header [%ld bytes]. Exit.\n", fileSize, totalUnit*unitSize+4*4+2+1+lenkey);
      printf("The read sizes are: %ld %ld %ld %ld\n", (*sz)[0], (*sz)[1], (*sz)[2], (*sz)[3]);
      printf("The read sizes are: %d %d %d %d\n", mysz[0], mysz[1], mysz[2], mysz[3]);
      if (keyread) {free(keyread); keyread=0;}
      if (*sz) {free(*sz); *sz=0;}
      berror = 1;
      return berror;
    }

  if (*img) {free(*img); *img=0;}
  long totalBytes = unitSize*totalUnit;
  *img = (unsigned char *)Guarded_Malloc(totalBytes*sizeof(unsigned char), Program_Name());
  if (*img==0 || *img==NULL)
    {
      fprintf(stderr, "Fail to allocate memory in loadRaw2Stack().\n");
      if (keyread) {free(keyread); keyread=0;}
      if (*sz) {free(*sz); *sz=0;}
      berror = 1;
      return berror;
    }

  long remainingBytes = totalBytes;
  long nBytes2G = 1024L*1024L*1024L*2L;
  long cntBuf = 0;
  while (remainingBytes>0)
    {
      long curReadBytes = (remainingBytes<nBytes2G) ? remainingBytes : nBytes2G;
      long curReadUnits = curReadBytes/unitSize;
      nread = fread(*img+cntBuf*nBytes2G, unitSize, curReadUnits, fid);
      if (nread!=curReadUnits)
	{
	  printf("Something wrong in file reading. The program reads [%ld data points] but the file says there should be [%ld data points].\n", nread, totalUnit);
	  if (keyread) {free(keyread); keyread=0;}
	  if (*sz) {free(*sz); *sz=0;}
	  if (*img) {free(*img); *img=0;}
	  berror = 1;
	  return berror;
	}
      
      remainingBytes -= nBytes2G;
      cntBuf++;
    }

  // swap the data bytes if necessary 

  if (b_swap==1)
    {
      if (unitSize==2)
	{
	  for (i=0;i<totalUnit; i++)
	    {
	      swap2bytes((void *)(*img+i*unitSize));
	    }
	}
      else if (unitSize==4)
	{
	  for (i=0;i<totalUnit; i++)
	    {
	      swap4bytes((void *)(*img+i*unitSize));
	    }
	}
    }


  // clean and return 

  if (keyread) {free(keyread); keyread = 0;}
  fclose(fid); //bug fix on 060412

  double min=0.0, max=0.0;
  if (datatype==1) {
    findMinMax8bit(&min, &max, *img, totalUnit);
  } else if (datatype==2) {
    findMinMax16bit(&min, &max, *img, totalUnit);
  } else if (datatype==4) {
    findMinMaxFloat(&min, &max, *img, totalUnit);
  }
  printf("loadRaw2Stack() Min=%f Max=%f\n", min, max);

  return berror;
}
Пример #6
0
Cardinal 
Idb__BM_SwapRecordBytes (IDBRecordBufferPtr		buffer)
{
    
  /*
   *  Local variables
   */
  Cardinal		ndx;	    /* loop index */
  IDBDummyRecordPtr	idb_record; /* pointer to the generic IDB record */
  IDBRecordHeaderPtr	idb_header; /* pointer to hdr w/type and record # */
  IDBHeaderRecordPtr	header_rec; /* pointer to record type IDBrtHeader */
  IDBHeaderHdrPtr	header_hdr; /* pointer to the header in the header */
  IDBIndexLeafRecordPtr	leaf_rec;   /* pointer to record type IDBrtIndexLeaf */
  IDBIndexNodeRecordPtr node_rec;   /* pointer to record type IDBrtIndexNode */
  IDBridMapRecordPtr	ridmap_rec; /* pointer to record type IDBrtRIDMap */
  IDBDataRecordPtr	data_rec;   /* pointer to record type IDBrtData */
  char			err_msg[300] ;
    
  if ( ! Idb__BM_Valid(buffer) )
    return Urm__UT_Error("Idb__BM_MarkActivity", _MrmMMsg_0002,
			 NULL, NULL, MrmNOT_VALID) ;
    
  /* load pointers to the record and record header */
    
  idb_record = (IDBDummyRecordPtr) buffer->IDB_record ;
  idb_header = (IDBRecordHeaderPtr)&idb_record->header ;
    
    
  /* swap the remaining record entries in IDBRecordHeader */
  swapbytes( idb_header->record_type ) ;
  swapbytes( idb_header->record_num ) ;
    
  /*
   * Swap IDB record items based on record type
   */
    
  switch ( idb_header->record_type )
    {	
    case IDBrtHeader:
      header_rec = (IDBHeaderRecordPtr)buffer->IDB_record ;
      header_hdr = (IDBHeaderHdrPtr)&header_rec->header_hdr ;
	
      /* swap the HeaderHdr first */
      swapbytes( header_hdr->index_root );
      swapbytes( header_hdr->num_indexed );
      swapbytes( header_hdr->num_RID );
      /* VAR check */
#ifdef WORD64	
      swap4bytes( header_hdr->next_RID.internal_id.map_rec ); 
      swap4bytes( header_hdr->next_RID.internal_id.res_index ); 
#else
      swap2bytes( header_hdr->next_RID.internal_id.map_rec ); 
      swap2bytes( header_hdr->next_RID.internal_id.res_index ); 
#endif
      swapbytes( header_hdr->last_record );
      swapbytes( header_hdr->last_data_record );
      for( ndx=0 ; ndx < URMgVecSize ; ndx++)
	swapbytes(header_hdr->group_counts[ndx]);
      for( ndx=0 ; ndx < IDBrtVecSize ; ndx++)
	swapbytes(header_hdr->rt_counts[ndx]);
	
      /* now swap the rest of the header */
      /* VAR check */
      for( ndx=0 ; ndx < IDBHeaderRIDMax ; ndx++)
	{
	  swap2bytes(header_rec->RID_pointers[ndx].internal_id.rec_no);
	  swap2bytes(header_rec->RID_pointers[ndx].internal_id.item_offs);
	}
      swapbytes( header_rec->num_entry );
      swapbytes( header_rec->last_entry );
      swapbytes( header_rec->free_ptr );
      swapbytes( header_rec->free_count );
      break;
	
    case IDBrtIndexLeaf:
      leaf_rec = (IDBIndexLeafRecordPtr)buffer->IDB_record ;
      swapbytes( leaf_rec->leaf_header.parent );
      swapbytes( leaf_rec->leaf_header.index_count );
      swapbytes( leaf_rec->leaf_header.heap_start );
      swapbytes( leaf_rec->leaf_header.free_bytes );
      for( ndx=0 ; ndx < leaf_rec->leaf_header.index_count ; ndx++ ) 
	{
	  swapbytes( leaf_rec->index[ndx].index_stg );	
	  swap2bytes( leaf_rec->index[ndx].data.internal_id.rec_no );	
	  swap2bytes( leaf_rec->index[ndx].data.internal_id.item_offs );	
	}
      break;
	
    case IDBrtIndexNode:
      node_rec = (IDBIndexNodeRecordPtr)buffer->IDB_record ;
      swapbytes( node_rec->node_header.parent );
      swapbytes( node_rec->node_header.index_count );
      swapbytes( node_rec->node_header.heap_start );
      swapbytes( node_rec->node_header.free_bytes );
      for( ndx=0 ; ndx < node_rec->node_header.index_count ; ndx++ ) 
	{
	  swapbytes( node_rec->index[ndx].index_stg );	
	  swap2bytes( node_rec->index[ndx].data.internal_id.rec_no );	
	  swap2bytes( node_rec->index[ndx].data.internal_id.item_offs );	
	  swapbytes( node_rec->index[ndx].LT_record );	
	  swapbytes( node_rec->index[ndx].GT_record );	
	}
      break;
	
    case IDBrtRIDMap:
      ridmap_rec = (IDBridMapRecordPtr)buffer->IDB_record ;
      ndx = 0;
      while ( (ndx < IDBridPtrVecMax) && 
	      (ridmap_rec->pointers[ndx].internal_id.rec_no != 0) )
	{
	  swap2bytes( ridmap_rec->pointers[ndx].internal_id.rec_no );	
	  swap2bytes( ridmap_rec->pointers[ndx].internal_id.item_offs );
	  ndx++;
	}
      break;
	
    case IDBrtData:
      data_rec = (IDBDataRecordPtr)buffer->IDB_record ;
      swapbytes( data_rec->data_header.num_entry );
      swapbytes( data_rec->data_header.last_entry );
      swapbytes( data_rec->data_header.free_ptr );
      swapbytes( data_rec->data_header.free_count );
      break;
	
    default:
      sprintf(err_msg, _MrmMMsg_0020, idb_header->record_num,
	      idb_header->record_type);
      return Urm__UT_Error ("Idb__BM_SwapRecordBytes",
			    err_msg, NULL, NULL, MrmFAILURE) ;
    }
  return MrmSUCCESS ;
} 
Пример #7
0
Cardinal 
Urm__SwapRGMWidgetRecord(RGMWidgetRecordPtr	widget_rec)
{
    
  /*
   *  Local variables
   */
  RGMArgListDescPtr	arg_list;   	/* pointer to widget arglist */
  RGMChildrenDescPtr	child_list; 	/* pointer to the widgets children */
  RGMResourceDescPtr	res_desc;   	/* resource description literal */
  RGMCallbackDescPtr	callb_desc; 	/* pointer to a callback decriptor */
  Cardinal		ndx;	   	/* loop index */
  IDBridDesc	  	*idb_rid_ptr;
  void			*offset;     	/* generic offset pointer */
  char			err_msg[300];
    
  /* Swap the main part of the widget record */
    
  swapbytes( widget_rec->size );
  swapbytes( widget_rec->access );
  swapbytes( widget_rec->lock );
  swapbytes( widget_rec->type );
  swapbytes( widget_rec->name_offs );
  swapbytes( widget_rec->class_offs );
  swapbytes( widget_rec->arglist_offs );
  swapbytes( widget_rec->children_offs );
  swapbytes( widget_rec->comment_offs );
  swapbytes( widget_rec->creation_offs );
  swapbytes( widget_rec->variety );
  swapbytes( widget_rec->annex );
    
  /* handle the argument list */
    
  if (widget_rec->arglist_offs > 0)
    {	
      arg_list = (RGMArgListDesc *)
	((char *)widget_rec + widget_rec->arglist_offs);
      swapbytes( arg_list->count );
      swapbytes( arg_list->extra );
      for ( ndx=0 ; ndx<arg_list->count ; ndx++ )
	{
	  swapbytes( arg_list->args[ndx].tag_code );
	  swapbytes( arg_list->args[ndx].stg_or_relcode.tag_offs );
	  swapbytes( arg_list->args[ndx].arg_val.rep_type );
	    
	  switch( arg_list->args[ndx].arg_val.rep_type )
	    {
	    case MrmRtypeInteger:
	    case MrmRtypeBoolean:
	      swapbytes( arg_list->args[ndx].arg_val.datum.ival );
	      break;
	    case MrmRtypeSingleFloat:
	      swapbytes( arg_list->args[ndx].arg_val.datum.ival );
	      _MrmOSIEEEFloatToHost((float *)
				    &(arg_list->args[ndx].arg_val.datum.ival));
	    default:
	      swapbytes( arg_list->args[ndx].arg_val.datum.offset );
	      break;
	    }
	    
	  offset = ((char *)widget_rec+
		    arg_list->args[ndx].arg_val.datum.offset);
	    
	  switch( arg_list->args[ndx].arg_val.rep_type )
	    {	
	      /* these are immediate, do nothing special */
	    case MrmRtypeInteger:
	    case MrmRtypeBoolean:
	    case MrmRtypeSingleFloat:
	      break;
	      /* these are offsets into the file, handle them specially */
	    case MrmRtypeCallback:
	      callb_desc = (RGMCallbackDesc * )offset;
	      Urm__SwapRGMCallbackDesc( callb_desc, widget_rec );
	      break;
	    case MrmRtypeResource:
	      res_desc = (RGMResourceDesc *)offset;
	      Urm__SwapRGMResourceDesc( res_desc );
	      /* flag this resource as needing further byte swapping */
	      res_desc->cvt_type |= MrmResourceUnswapped;
	      break;
	    case MrmRtypeHorizontalInteger:
	    case MrmRtypeVerticalInteger:
	    case MrmRtypeHorizontalFloat:
	    case MrmRtypeVerticalFloat:
	    case MrmRtypeChar8:
	    case MrmRtypeChar8Vector:
	    case MrmRtypeCString:
	    case MrmRtypeCStringVector:
	    case MrmRtypeFloat:
	    case MrmRtypePixmapImage:
	    case MrmRtypePixmapDDIF:
	    case MrmRtypeNull:
	    case MrmRtypeAddrName:
	    case MrmRtypeIconImage:
	    case MrmRtypeFont:
	    case MrmRtypeFontList:
	    case MrmRtypeColor:
	    case MrmRtypeColorTable:
	    case MrmRtypeAny:
	    case MrmRtypeTransTable:
	    case MrmRtypeClassRecName:
	    case MrmRtypeIntegerVector:
	    case MrmRtypeXBitmapFile:
	    case MrmRtypeCountedVector:
	    case MrmRtypeKeysym:
	    case MrmRtypeWideCharacter:
	    case MrmRtypeFontSet:
	      sprintf(err_msg,_MrmMMsg_0022,
		      arg_list->args[ndx].arg_val.rep_type);
	      return Urm__UT_Error ("Urm__SwapRGMWidgetRecord",
				    err_msg, NULL, NULL, MrmFAILURE) ;
	      break;
	    }
	}
    }
    
  /* handle the child list */
    
  if (widget_rec->children_offs > 0)
    {
      child_list = (RGMChildrenDesc *)
	((char *)widget_rec + widget_rec->children_offs);
      swapbytes( child_list->count );
      swapbytes( child_list->unused1 );
      swapbytes( child_list->annex1 );
      for ( ndx=0 ; ndx<child_list->count ; ndx++ )
	{	
	  swapbytes( child_list->child[ndx].annex1 );
	  if (child_list->child[ndx].type ==  URMrRID ) 
	    {
	      idb_rid_ptr = (IDBridDesc *)&(child_list->child[ndx].key.id);
#ifdef WORD64
	      swap4bytes( idb_rid_ptr->internal_id.map_rec );
	      swap4bytes( idb_rid_ptr->internal_id.res_index );
#else
	      swap2bytes( idb_rid_ptr->internal_id.map_rec );
	      swap2bytes( idb_rid_ptr->internal_id.res_index );
#endif
	    }
	  else
	    swapbytes( child_list->child[ndx].key.index_offs );
	}
    }
    
  /* handle the creation callback, if any */
    
  if (widget_rec->creation_offs > 0)
    {
      callb_desc = (RGMCallbackDesc * )
	((char *)widget_rec + widget_rec->creation_offs);
      Urm__SwapRGMCallbackDesc( callb_desc, widget_rec );
    }
    
  return MrmSUCCESS ;
}