MultiSrc.c File Reference

#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/Xfuncs.h>
#include <X11/Xaw3d/XawInit.h>
#include <X11/Xaw3d/MultiSrcP.h>
#include <X11/Xaw3d/XawImP.h>
#include <X11/Xmu/Misc.h>
#include <X11/Xmu/CharSet.h>
#include "XawI18n.h"
#include <X11/Xos.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>

Include dependency graph for MultiSrc.c:

Go to the source code of this file.

Defines
#define	offset(field)   XtOffsetOf(MultiSrcRec, multi_src.field)
#define	MyWStrncpy(t, s, wcnt)   (void) memmove( (t), (s), (wcnt)*sizeof(wchar_t))
#define	Off_t   off_t
#define	Size_t   size_t
#define	superclass   (&textSrcClassRec)
#define	HALF_PIECE   (src->multi_src.piece_size/2)
Functions
static XawTextPosition	Scan ()
static XawTextPosition	Search ()
static XawTextPosition	ReadText ()
static int	ReplaceText ()
static MultiPiece *	FindPiece ()
static MultiPiece **	AllocNewPiece ()
static FILE *	InitStringOrFile ()
static void	FreeAllPieces ()
static void	RemovePiece ()
static void	BreakPiece ()
static void	LoadPieces ()
static void	RemoveOldStringOrFile ()
static void	CvtStringToMultiType ()
static void	ClassInitialize ()
static void	Initialize ()
static void	Destroy ()
static void	GetValuesHook ()
static String	StorePiecesInString ()
static Boolean	SetValues ()
static Boolean	WriteToFile ()
char *	tmpnam ()
wchar_t *	_XawTextMBToWC ()
char *	_XawTextWCToMB ()
static void	Initialize (Widget request, Widget new, ArgList args, Cardinal *num_args)
static XawTextPosition	ReadText (Widget w, XawTextPosition pos, XawTextBlock *text, int length)
static int	ReplaceText (Widget w, XawTextPosition startPos, XawTextPosition endPos, XawTextBlock *u_text_p)
static XawTextPosition	Scan (Widget w, XawTextPosition position, XawTextScanType type, XawTextScanDirection dir, int count, Boolean include)
static XawTextPosition	Search (Widget w, XawTextPosition position, XawTextScanDirection dir, XawTextBlock *text)
static Boolean	SetValues (Widget current, Widget request, Widget new, ArgList args, Cardinal *num_args)
static void	GetValuesHook (Widget w, ArgList args, Cardinal *num_args)
static void	Destroy (Widget w)
void	_XawMultiSourceFreeString (Widget w)
Boolean	_XawMultiSave (Widget w)
Boolean	_XawMultiSaveAsFile (Widget w, String name)
static void	RemoveOldStringOrFile (MultiSrcObject src, Boolean checkString)
static Boolean	WriteToFile (String string, String name)
static String	StorePiecesInString (MultiSrcObject src)
static FILE *	InitStringOrFile (MultiSrcObject src, Boolean newString)
static void	LoadPieces (MultiSrcObject src, FILE *file, char *string)
static MultiPiece *	AllocNewPiece (MultiSrcObject src, MultiPiece *prev)
static void	FreeAllPieces (MultiSrcObject src)
static void	RemovePiece (MultiSrcObject src, MultiPiece *piece)
static MultiPiece *	FindPiece (MultiSrcObject src, XawTextPosition position, XawTextPosition *first)
static void	BreakPiece (MultiSrcObject src, MultiPiece *piece)
static void	CvtStringToMultiType (XrmValuePtr args, Cardinal *num_args, XrmValuePtr fromVal, XrmValuePtr toVal)
Variables
static int	magic_value = MAGIC_VALUE
static XtResource	resources []
MultiSrcClassRec	multiSrcClassRec
WidgetClass	multiSrcObjectClass = (WidgetClass)&multiSrcClassRec

---

Define Documentation

#define HALF_PIECE   (src->multi_src.piece_size/2)

Definition at line 1406 of file MultiSrc.c.

#define MyWStrncpy	(	t,
		s,
		wcnt		)	(void) memmove( (t), (s), (wcnt)*sizeof(wchar_t))

Definition at line 119 of file MultiSrc.c.

Referenced by ReplaceText().

#define Off_t   off_t

Definition at line 134 of file MultiSrc.c.

#define offset

(

field

)

XtOffsetOf(MultiSrcRec, multi_src.field)

Definition at line 87 of file MultiSrc.c.

#define Size_t   size_t

Definition at line 135 of file MultiSrc.c.

#define superclass   (&textSrcClassRec)

Definition at line 141 of file MultiSrc.c.

---

Function Documentation

Boolean _XawMultiSave

(

Widget

w

)

Definition at line 871 of file MultiSrc.c.

References _MultiSrcPart::allocated_string, app_con, _MultiSrcPart::changes, FALSE, _MultiSrcRec::multi_src, StorePiecesInString(), _MultiSrcPart::string, TRUE, _MultiSrcPart::type, _MultiSrcPart::use_string_in_place, WriteToFile(), and XawAsciiFile.

Referenced by GetValuesHook(), and XawAsciiSave().

{
  MultiSrcObject src = (MultiSrcObject) w;
  XtAppContext app_con = XtWidgetToApplicationContext(w);
  char * mb_string;

/*
 * If using the string in place then there is no need to play games
 * to get the internal info into a readable string.
 */

  if (src->multi_src.use_string_in_place) 
    return(TRUE);

  if (src->multi_src.type == XawAsciiFile) {

      if (!src->multi_src.changes)              /* No changes to save. */
          return(TRUE);

      mb_string = StorePiecesInString( src );

      if ( mb_string != 0 ) {
          if ( WriteToFile( mb_string, src->multi_src.string ) == FALSE ) {
              XtFree( mb_string );
              return( FALSE );
          }
          XtFree( mb_string );
          src->multi_src.changes = FALSE;
          return( TRUE );
      } else {
          /* If the buffer holds bad chars, don't touch it... */
          XtAppWarningMsg( app_con,
                "convertError", "multiSource", "XawError",
                "Due to illegal characters, file not saved.", NULL, NULL);
          return( FALSE );
      }
  }
  else {

  /* THIS FUNCTIONALITY IS UNDOCUMENTED, probably UNNEEDED?  The manual
  says this routine's only function is to save files to disk.  -Sheeran */

      mb_string = StorePiecesInString( src );

      if ( mb_string == 0 ) {
          /* If the buffer holds bad chars, don't touch it... */
          XtAppWarningMsg( app_con,
                "convertError", "multiSource", "XawError",
                 XtName( XtParent( (Widget) src ) ), NULL, NULL);
          return( FALSE );
      }

      /* assert: mb_string holds good characters so the buffer is fine */
      if (src->multi_src.allocated_string == TRUE) 
          XtFree(src->multi_src.string);
      else
          src->multi_src.allocated_string = TRUE;
    
      src->multi_src.string = mb_string;
  }
  src->multi_src.changes = FALSE;
  return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Boolean _XawMultiSaveAsFile	(	Widget	w,
		String	name
	)

Definition at line 952 of file MultiSrc.c.

References StorePiecesInString(), and WriteToFile().

Referenced by XawAsciiSaveAsFile().

{
  MultiSrcObject src = (MultiSrcObject) w;
  String mb_string;
  Boolean ret;

  mb_string = StorePiecesInString( src ); 

  if ( mb_string != 0 ) {
      ret = WriteToFile( mb_string, name );
      XtFree( mb_string );
      return( ret );
  }

  /* otherwise there was a conversion error.  So print widget name too. */
  XtAppWarningMsg( XtWidgetToApplicationContext(w),
                "convertError", "multiSource", "XawError",
                XtName( XtParent( (Widget) src ) ), NULL, NULL);
  return( False );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _XawMultiSourceFreeString

(

Widget

w

)

Definition at line 843 of file MultiSrc.c.

References _MultiSrcPart::allocated_string, FALSE, _MultiSrcRec::multi_src, and _MultiSrcPart::string.

Referenced by XawAsciiSourceFreeString().

{
  MultiSrcObject src = (MultiSrcObject) w;

/*if (src->multi_src.allocated_string&& src->multi_src.type != XawAsciiFile) {*/
  /* ASSERT: src->multi_src.allocated_string -> we MUST free .string! */
  if ( src->multi_src.allocated_string ) {
    XtFree(src->multi_src.string);
    src->multi_src.allocated_string = FALSE;
    src->multi_src.string = NULL;
  }
}

Here is the caller graph for this function:

wchar_t* _XawTextMBToWC

(

)

Referenced by InitStringOrFile(), InsertString(), LoadPieces(), ReplaceText(), and Search().

Here is the caller graph for this function:

char* _XawTextWCToMB

(

)

Referenced by InsertString(), and StorePiecesInString().

Here is the caller graph for this function:

static MultiPiece* AllocNewPiece	(	MultiSrcObject	src,
		MultiPiece *	prev
	)			[static]

Definition at line 1304 of file MultiSrc.c.

References _MultiPiece::next, and _MultiPiece::prev.

{
  MultiPiece * piece = XtNew(MultiPiece);

  if (prev == NULL) {
    src->multi_src.first_piece = piece;
    piece->next = NULL;
  }
  else {
    if (prev->next != NULL)
      (prev->next)->prev = piece;
    piece->next = prev->next;
    prev->next = piece;
  }
  
  piece->prev = prev;

  return(piece);
}

static MultiPiece* * AllocNewPiece

(

)

static void BreakPiece	(	MultiSrcObject	src,
		MultiPiece*	piece
	)			[static]

Definition at line 1409 of file MultiSrc.c.

References AllocNewPiece(), HALF_PIECE, _MultiPiece::text, _MultiPiece::used, and void().

{
  MultiPiece * new = AllocNewPiece(src, piece);
  
  new->text = (wchar_t*)XtMalloc(src->multi_src.piece_size * sizeof(wchar_t));
  (void) wcsncpy(new->text, piece->text + HALF_PIECE,
          src->multi_src.piece_size - HALF_PIECE);
  piece->used = HALF_PIECE;
  new->used = src->multi_src.piece_size - HALF_PIECE; 
}

Here is the call graph for this function:

static void BreakPiece

(

)

static void ClassInitialize

(

)

[static]

Definition at line 205 of file MultiSrc.c.

References XawInitializeWidgetSet().

{
  XawInitializeWidgetSet();
  XtAddConverter( XtRString, XtRMultiType, CvtStringToMultiType,
                 NULL, (Cardinal) 0);
}

Here is the call graph for this function:

static void CvtStringToMultiType	(	XrmValuePtr	args,
		Cardinal*	num_args,
		XrmValuePtr	fromVal,
		XrmValuePtr	toVal
	)			[static]

Definition at line 1426 of file MultiSrc.c.

References type, XawAsciiFile, XawAsciiString, XmuCopyISOLatin1Lowered(), XtEfile, and XtEstring.

{
  static XawAsciiType type;
  static XrmQuark  XtQEstring = NULLQUARK;
  static XrmQuark  XtQEfile;
  XrmQuark q;
  char lowerName[40];

  if (XtQEstring == NULLQUARK) {
    XtQEstring = XrmPermStringToQuark(XtEstring);
    XtQEfile   = XrmPermStringToQuark(XtEfile);
  }

  if (strlen ((char*) fromVal->addr) < sizeof lowerName) {
    XmuCopyISOLatin1Lowered(lowerName, (char *) fromVal->addr);
    q = XrmStringToQuark(lowerName);

    if (q == XtQEstring)     type = XawAsciiString;
    else if (q == XtQEfile)  type = XawAsciiFile;
    else {
      toVal->size = 0;
      toVal->addr = NULL;
      return;
    }
    toVal->size = sizeof type;
    toVal->addr = (XPointer) &type;
    return;
  }
  toVal->size = 0;
  toVal->addr = NULL;
}

Here is the call graph for this function:

static void CvtStringToMultiType

(

)

static void Destroy

(

Widget

w

)

[static]

Definition at line 817 of file MultiSrc.c.

References RemoveOldStringOrFile().

{
    RemoveOldStringOrFile((MultiSrcObject) w, True);
}

Here is the call graph for this function:

static void Destroy

(

)

static MultiPiece* FindPiece	(	MultiSrcObject	src,
		XawTextPosition	position,
		XawTextPosition *	first
	)			[static]

Definition at line 1382 of file MultiSrc.c.

{
  MultiPiece * old_piece = NULL, * piece = src->multi_src.first_piece;
  XawTextPosition temp;

  for ( temp = 0 ; piece != NULL ; temp += piece->used, piece = piece->next ) {
    *first = temp;
    old_piece = piece;

    if ((temp + piece->used) > position) 
      return(piece);
  }
  return(old_piece);      /* if we run off the end the return the last piece */
}

static MultiPiece* FindPiece

(

)

[static]

static void FreeAllPieces

(

MultiSrcObject

src

)

[static]

Definition at line 1333 of file MultiSrc.c.

References first, and RemovePiece().

{
  MultiPiece * next, * first = src->multi_src.first_piece;

  if (first->prev != NULL)
    printf("Xaw MultiSrc Object: possible memory leak in FreeAllPieces().\n");

  for ( ; first != NULL ; first = next ) {
    next = first->next;
    RemovePiece(src, first);
  }
}

Here is the call graph for this function:

static void FreeAllPieces

(

)

[static]

static void GetValuesHook	(	Widget	w,
		ArgList	args,
		Cardinal*	num_args
	)			[static]

Definition at line 786 of file MultiSrc.c.

References _XawMultiSave(), _MultiSrcPart::first_piece, i, _MultiSrcRec::multi_src, name, streq, _MultiSrcPart::string, _MultiPiece::text, _MultiSrcPart::type, _MultiSrcPart::use_string_in_place, value, and XawAsciiString.

{
  MultiSrcObject src = (MultiSrcObject) w;
  int i;

  if (src->multi_src.type == XawAsciiString) {
    for (i = 0; i < *num_args ; i++ ) 
      if (streq(args[i].name, XtNstring)) {
          if (src->multi_src.use_string_in_place) {
              *((char **) args[i].value) = (char *)
                                        src->multi_src.first_piece->text;
          }
          else {
              if (_XawMultiSave(w))     /* If save sucessful. */
                  *((char **) args[i].value) = src->multi_src.string;
          }
        break;
      }
  }
}    

Here is the call graph for this function:

static void GetValuesHook

(

)

static void Initialize	(	Widget	request,
		Widget	new,
		ArgList	args,
		Cardinal*	num_args
	)			[static]

Definition at line 222 of file MultiSrc.c.

References _MultiSrcPart::allocated_string, _MultiSrcPart::changes, FALSE, file, InitStringOrFile(), LoadPieces(), _MultiSrcRec::multi_src, TextSrcPart::text_format, _MultiSrcRec::text_src, _MultiSrcPart::type, XawAsciiFile, and XawFmtWide.

{
  MultiSrcObject src = (MultiSrcObject) new;
  FILE * file;

/*
 * Set correct flags (override resources) depending upon widget class.
 */

  src->multi_src.changes = FALSE;
  src->multi_src.allocated_string = FALSE;

  file = InitStringOrFile(src, src->multi_src.type == XawAsciiFile);
  LoadPieces(src, file, NULL);

  if (file != NULL) fclose(file);
  src->text_src.text_format = XawFmtWide;

}

Here is the call graph for this function:

static void Initialize

(

void

)

Initialisation of Scilab

static FILE* InitStringOrFile	(	MultiSrcObject	src,
		Boolean	newString
	)			[static]

Definition at line 1074 of file MultiSrc.c.

References _XawTextMBToWC(), FALSE, file, MAGIC_VALUE, Off_t, strerror(), tmpnam(), TMPSIZ, TRUE, void(), XawAsciiString, XawtextAppend, XawtextEdit, and XawtextRead.

{
    char * open_mode = NULL;
    FILE * file;
    char fileName[TMPSIZ];
    Display *d = XtDisplayOfObject((Widget)src);

    if (src->multi_src.type == XawAsciiString) {

        if (src->multi_src.string == NULL)
            src->multi_src.length = 0;

        else if (! src->multi_src.use_string_in_place) {
            int length;
            String temp = XtNewString(src->multi_src.string);
            if ( src->multi_src.allocated_string )
                XtFree( src->multi_src.string );
            src->multi_src.allocated_string = True;
            src->multi_src.string = temp;

            length = strlen(src->multi_src.string);

            /* Wasteful, throwing away the WC string, but need side effect! */
            (void) _XawTextMBToWC(d, src->multi_src.string, &length);
            src->multi_src.length = (XawTextPosition) length;
        } else {
            src->multi_src.length = strlen(src->multi_src.string);
            /* In case the length resource is incorrectly set */
            if (src->multi_src.length > src->multi_src.multi_length)
                src->multi_src.multi_length = src->multi_src.length;

            if (src->multi_src.multi_length == MAGIC_VALUE) 
                src->multi_src.piece_size = src->multi_src.length;
            else
                src->multi_src.piece_size = src->multi_src.multi_length + 1;
        }
                
       /*((TextWidget)src->object.parent)->text.lastPos = src->multi_src.length;*/
        return(NULL);
    }

/*
 * type is XawAsciiFile.
 */
    
    src->multi_src.is_tempfile = FALSE;

    switch (src->text_src.edit_mode) {
    case XawtextRead:
        if (src->multi_src.string == NULL)
            XtErrorMsg("NoFile", "multiSourceCreate", "XawError",
                     "Creating a read only disk widget and no file specified.",
                       NULL, 0);
        open_mode = "r";
        break;
    case XawtextAppend:
    case XawtextEdit:
        if (src->multi_src.string == NULL) {

            if ( src->multi_src.allocated_string )
                XtFree( src->multi_src.string );
            src->multi_src.allocated_string = False;
            src->multi_src.string = fileName;

            (void) tmpnam(src->multi_src.string);
            src->multi_src.is_tempfile = TRUE;
            open_mode = "w";
        } else
            open_mode = "r+";
        break;
    default:
        XtErrorMsg("badMode", "multiSourceCreate", "XawError",
                "Bad editMode for multi source; must be Read, Append or Edit.",
                   NULL, NULL);
    }

    /* Allocate new memory for the temp filename, because it is held in
     * a stack memory buffer.  We must verify that all routines that set
     * .string first check .allocated_string and free it - plumbing Sheeran.
     */
    if (newString || src->multi_src.is_tempfile) {
        if ( src->multi_src.allocated_string )
            src->multi_src.string = XtNewString(src->multi_src.string);
        src->multi_src.allocated_string = TRUE;
    }
    
    if (!src->multi_src.is_tempfile) {
        if ((file = fopen(src->multi_src.string, open_mode)) != 0) {
            (void) fseek(file, (Off_t)0, 2);
            src->multi_src.length = ftell (file);
            return file;
        } else {
            String params[2];
            Cardinal num_params = 2;
            
            params[0] = src->multi_src.string;
            params[1] = strerror(errno);
            XtAppWarningMsg(XtWidgetToApplicationContext((Widget)src),
                            "openError", "multiSourceCreate", "XawWarning",
                            "Cannot open file %s; %s", params, &num_params);
        }
    } 
    src->multi_src.length = 0;
    return((FILE *)NULL);
#undef StrLen
}

Here is the call graph for this function:

static FILE* InitStringOrFile

(

)

[static]

static void LoadPieces	(	MultiSrcObject	src,
		FILE*	file,
		char*	string
	)			[static]

Definition at line 1192 of file MultiSrc.c.

References _XawTextMBToWC(), AllocNewPiece(), left, Min, Off_t, Size_t, _MultiPiece::text, _MultiPiece::used, void(), and XawAsciiFile.

{
  Display *d = XtDisplayOfObject((Widget)src);
  wchar_t* local_str, *ptr;
  MultiPiece* piece = NULL;
  XawTextPosition left;
  int bytes = sizeof(wchar_t);
  char* temp_mb_holder = NULL;

  /* 
   * This is tricky - the _XawTextMBtoWC converter uses its 3rd arg 
   * in as MB length, out as WC length.  We want local_length to be 
   * WC count. 
   */
  int local_length = src->multi_src.length;

  if (string != NULL) {
    /* 
     * ASSERT: IF our caller passed a non-null string, THEN 
     * src->multi_src.length is currently string's * byte count, 
     * AND string is in a MB format.
     */
    local_str = _XawTextMBToWC(d, (char *)string, &local_length);
    src->multi_src.length = (XawTextPosition) local_length;
  } else if (src->multi_src.type != XawAsciiFile) {
    /* 
     * here, we are not changing the contents, just reloading, 
     * so don't change len...
     */
    local_length = src->multi_src.string ? 
                   strlen( src->multi_src.string ) : 0;
    local_str = _XawTextMBToWC( d, (char*)src->multi_src.string, &local_length );
  } else {
    if (src->multi_src.length != 0) {
      temp_mb_holder = 
        XtMalloc((unsigned)(src->multi_src.length + 1) * sizeof(unsigned char));
      fseek(file, (Off_t)0, 0);
      src->multi_src.length = fread (temp_mb_holder, 
                                     (Size_t)sizeof(unsigned char), 
                                     (Size_t)src->multi_src.length, file);
      if (src->multi_src.length <= 0) 
        XtAppErrorMsg( XtWidgetToApplicationContext ((Widget) src),
                       "readError", "multiSource", "XawError",
                       "fread returned error.", NULL, NULL);
      local_length = src->multi_src.length;
      local_str = _XawTextMBToWC(d, temp_mb_holder, &local_length);
      src->multi_src.length = local_length;

      if ( local_str == 0 ) {
        String params[2];
        Cardinal num_params;
        static char err_text[] = 
                "<<< FILE CONTENTS NOT REPRESENTABLE IN THIS LOCALE >>>";

        params[0] = XtName(XtParent((Widget)src));
        params[1] = src->multi_src.string;
        num_params = 2;

        XtAppWarningMsg( XtWidgetToApplicationContext((Widget)src),
                         "readLocaleError", "multiSource", "XawError",
    "%s: The file `%s' contains characters not representable in this locale.",
                         params, &num_params);
        src->multi_src.length = sizeof err_text;
        local_length = src->multi_src.length;
        local_str = _XawTextMBToWC(d, err_text, &local_length);
        src->multi_src.length = local_length;
      }
    } else { /*ASSERT that since following while loop looks at local_length
        this isn't needed.  Sheeran, Omron KK, 1993/07/15
        temp_mb_holder[src->multi_src.length] = '\0';*/
        local_str = (wchar_t*)temp_mb_holder;
    }
  }

  if (src->multi_src.use_string_in_place) {
      piece = AllocNewPiece(src, piece);
      piece->used = Min(src->multi_src.length, src->multi_src.piece_size);
      piece->text = (wchar_t*)src->multi_src.string;
      return;
  }

  ptr = local_str;
  left = local_length;

  do {
      piece = AllocNewPiece(src, piece);

      piece->text = (wchar_t*)XtMalloc(src->multi_src.piece_size * bytes);
      piece->used = Min(left, src->multi_src.piece_size);
      if (piece->used != 0)
          (void) wcsncpy(piece->text, ptr, piece->used);

      left -= piece->used;
      ptr += piece->used;
  } while (left > 0);

  if ( temp_mb_holder )
      XtFree( (char*) temp_mb_holder );
}

Here is the call graph for this function:

static void LoadPieces

(

)

static XawTextPosition ReadText	(	Widget	w,
		XawTextPosition	pos,
		XawTextBlock*	text,
		int	length
	)			[static]

Definition at line 255 of file MultiSrc.c.

References count, FindPiece(), XawTextBlock::firstPos, XawTextBlock::format, XawTextBlock::length, XawTextBlock::ptr, _MultiPiece::text, _MultiPiece::used, and XawFmtWide.

{
  MultiSrcObject src = (MultiSrcObject) w;
  XawTextPosition count, start;
  MultiPiece * piece = FindPiece(src, pos, &start);
    
  text->format = XawFmtWide;
  text->firstPos = pos;
  text->ptr = (char *)(piece->text + (pos - start));
  count = piece->used - (pos - start);
  text->length = (length > count) ? count : length;
  return(pos + text->length);
}

Here is the call graph for this function:

static XawTextPosition ReadText

(

)

static void RemoveOldStringOrFile	(	MultiSrcObject	src,
		Boolean	checkString
	)			[static]

Definition at line 983 of file MultiSrc.c.

References FreeAllPieces().

{
  FreeAllPieces(src);

  if (checkString && src->multi_src.allocated_string) {
    XtFree(src->multi_src.string);
    src->multi_src.allocated_string = False;
    src->multi_src.string = NULL;
  }
}

Here is the call graph for this function:

static void RemoveOldStringOrFile

(

)

[static]

static void RemovePiece	(	MultiSrcObject	src,
		MultiPiece*	piece
	)			[static]

Definition at line 1355 of file MultiSrc.c.

References _MultiPiece::next, _MultiPiece::prev, and _MultiPiece::text.

{
  if (piece->prev == NULL)
    src->multi_src.first_piece = piece->next;
  else
    (piece->prev)->next = piece->next;

  if (piece->next != NULL)
    (piece->next)->prev = piece->prev;

  if (!src->multi_src.use_string_in_place)
    XtFree((char *)piece->text);

  XtFree((char *)piece);
}

static void RemovePiece

(

)

static int ReplaceText	(	Widget	w,
		XawTextPosition	startPos,
		XawTextPosition	endPos,
		XawTextBlock*	u_text_p
	)			[static]

Definition at line 283 of file MultiSrc.c.

References _XawTextMBToWC(), BreakPiece(), _MultiSrcPart::changes, TextSrcPart::edit_mode, FindPiece(), XawTextBlock::firstPos, XawTextBlock::format, _MultiSrcPart::length, XawTextBlock::length, Min, _MultiSrcRec::multi_src, MyWStrncpy, _MultiPiece::next, _MultiSrcPart::piece_size, _MultiPiece::prev, XawTextBlock::ptr, RemovePiece(), _MultiPiece::text, _MultiSrcRec::text_src, TRUE, _MultiSrcPart::use_string_in_place, _MultiPiece::used, XawEditDone, XawEditError, XawFmtWide, and XawtextRead.

{
  MultiSrcObject src = (MultiSrcObject) w;
  MultiPiece *start_piece, *end_piece, *temp_piece;
  XawTextPosition start_first, end_first;
  int length, firstPos;
  wchar_t *wptr;
  Boolean local_artificial_block = False;
  XawTextBlock text;

  /* STEP 1: The user handed me a text block called `u_text' that may be 
   * in either FMTWIDE or FMT8BIT (ie MB.)  Later code needs the block 
   * `text' to hold FMTWIDE.  So, this copies `u_text' to `text', and if 
   * `u_text' was MB, I knock it up to WIDE. */

  if ( u_text_p->length == 0 )  /* if so, the block contents never ref'd. */
      text.length = 0;

  else if ( u_text_p->format == XawFmtWide) {
      local_artificial_block = False;           /* ie, don't have to free it ourselves*/
      text.firstPos = u_text_p->firstPos;
      text.length =   u_text_p->length;
      text.ptr =      u_text_p->ptr;
      /* text.format is unneeded */

  } else {
      /* WARNING! u_text->firstPos and length are in units of CHAR, not CHARACTERS! */

      local_artificial_block = True;    /* ie, have to free it ourselves */
      text.firstPos = 0;
      text.length = u_text_p->length; /* _XawTextMBToWC converts this to wchar len. */

      text.ptr = (char*)_XawTextMBToWC( XtDisplay(XtParent(w)),
                         &(u_text_p->ptr[u_text_p->firstPos]), &(text.length) );

      /* I assert the following assignment is not needed - since Step 4
      depends on length, it has no need of a terminating NULL.  I think
      the ASCII-version has the same needless NULL. */
      /*((wchar_t*)text.ptr)[ text.length ] = NULL;*/
  }


  /* STEP 2: some initialization... */

  if (src->text_src.edit_mode == XawtextRead) 
    return(XawEditError);

  start_piece = FindPiece(src, startPos, &start_first);
  end_piece = FindPiece(src, endPos, &end_first);


  /* STEP 3: remove the empty pieces... */

  if (start_piece != end_piece) {
    temp_piece = start_piece->next;

  /* If empty and not the only piece then remove it. */

    if ( ((start_piece->used = startPos - start_first) == 0) &&
         !((start_piece->next == NULL) && (start_piece->prev == NULL)) )
      RemovePiece(src, start_piece);

    while (temp_piece != end_piece) {
      temp_piece = temp_piece->next;
      RemovePiece(src, temp_piece->prev);
    }
    end_piece->used -= endPos - end_first;
    if (end_piece->used != 0)
      MyWStrncpy(end_piece->text, (end_piece->text + endPos - end_first),
                (int) end_piece->used);
  }
  else {                        /* We are fully in one piece. */
    if ( (start_piece->used -= endPos - startPos) == 0) {
      if ( !((start_piece->next == NULL) && (start_piece->prev == NULL)) )
        RemovePiece(src, start_piece);
    }
    else {
      MyWStrncpy(start_piece->text + (startPos - start_first),
                start_piece->text + (endPos - start_first),
                (int) (start_piece->used - (startPos - start_first)) );
      if ( src->multi_src.use_string_in_place && 
           ((src->multi_src.length - (endPos - startPos)) < 
            (src->multi_src.piece_size - 1)) ) 
        start_piece->text[src->multi_src.length - (endPos - startPos)] = (wchar_t)0;
    }
  }

  src->multi_src.length += text.length -(endPos - startPos);
  /*((TextWidget)src->object.parent)->text.lastPos = src->multi_src.length;*/



  /* STEP 4: insert the new stuff */

  if ( text.length != 0) {

    start_piece = FindPiece(src, startPos, &start_first);
    
    length = text.length;
    firstPos = text.firstPos;
    
    while (length > 0) {
      wchar_t* ptr;
      int fill;
      
      if (src->multi_src.use_string_in_place) {
        if (start_piece->used == (src->multi_src.piece_size - 1)) {
          /*
           * The string is used in place, then the string
           * is not allowed to grow.
           */
          start_piece->used = src->multi_src.length =
                                                 src->multi_src.piece_size - 1;
          /*((TextWidget)src->object.parent)->text.lastPos = src->multi_src.length;*/


          start_piece->text[src->multi_src.length] = (wchar_t)0;
          return(XawEditError);
        }
      }


      if (start_piece->used == src->multi_src.piece_size) {
        BreakPiece(src, start_piece);
        start_piece = FindPiece(src, startPos, &start_first);
      }

      fill = Min((int)(src->multi_src.piece_size - start_piece->used), length);
      
      ptr = start_piece->text + (startPos - start_first);
      MyWStrncpy(ptr + fill, ptr, 
                (int) start_piece->used - (startPos - start_first));
      wptr =(wchar_t *)text.ptr;
      (void)wcsncpy(ptr, wptr + firstPos, fill);
      
      startPos += fill;
      firstPos += fill;
      start_piece->used += fill;
      length -= fill;
    }
  }

  if ( local_artificial_block == True )

      /* In other words, text is not the u_text that the user handed me but
      one I made myself.  I only care, because I need to free the string. */

      XFree( text.ptr );

  if (src->multi_src.use_string_in_place)
    start_piece->text[start_piece->used] = (wchar_t)0;

  src->multi_src.changes = TRUE;

  XtCallCallbacks(w, XtNcallback, NULL);

  return(XawEditDone);
}

Here is the call graph for this function:

static int ReplaceText

(

)

[static]

static XawTextPosition Scan	(	Widget	w,
		XawTextPosition	position,
		XawTextScanType	type,
		XawTextScanDirection	dir,
		int	count,
		Boolean	include
	)			[static]

Definition at line 464 of file MultiSrc.c.

References _Xaw_atowc(), FALSE, FindPiece(), first, iswspace, _MultiSrcPart::length, _MultiSrcRec::multi_src, _MultiPiece::next, _MultiPiece::prev, _MultiPiece::text, TRUE, _MultiPiece::used, XawLF, XawsdRight, XawstAll, XawstEOL, XawstParagraph, XawstPositions, and XawstWhiteSpace.

{
  MultiSrcObject src = (MultiSrcObject) w;
  int inc;
  MultiPiece * piece;
  XawTextPosition first, first_eol_position = 0;
  wchar_t * ptr;

  if (type == XawstAll) {       /* Optimize this common case. */
    if (dir == XawsdRight)
      return(src->multi_src.length);
    return(0);                  /* else. */
  }


  /* STEP 1: basic sanity checks */

  if (position > src->multi_src.length)
    position = src->multi_src.length;


  if ( dir == XawsdRight ) {
    if (position == src->multi_src.length)
      return(src->multi_src.length);
    inc = 1;
  }
  else {
    if (position == 0)
      return(0);
    inc = -1;
    position--;
  }

  piece = FindPiece(src, position, &first);

  if ( piece->used == 0 ) return(0); /* i.e., buffer is empty. */

  ptr = (position - first) + piece->text;

  switch (type) {
  case XawstEOL: 
  case XawstParagraph: 
  case XawstWhiteSpace: 
    for ( ; count > 0 ; count-- ) {
      Boolean non_space = FALSE, first_eol = TRUE;
      /* CONSTCOND */
      while (TRUE) {
        wchar_t c = *ptr;

        ptr += inc;
        position += inc;
        
        if (type == XawstWhiteSpace) {
          if (iswspace(c)) {
            if (non_space) 
              break;
          }
          else
            non_space = TRUE;
        }
        else if (type == XawstEOL) {
          if (c == _Xaw_atowc(XawLF)) break;
        }
        else { /* XawstParagraph */
          if (first_eol) {
            if (c == _Xaw_atowc(XawLF)) {
              first_eol_position = position;
              first_eol = FALSE;
            }
          }
          else
            if ( c == _Xaw_atowc(XawLF))
              break;
            else if ( !iswspace(c) )
              first_eol = TRUE;
        }
              

        if ( ptr < piece->text ) {
          piece = piece->prev;
          if (piece == NULL)    /* Begining of text. */
            return(0);
          ptr = piece->text + piece->used - 1;
        }
        else if ( ptr >= (piece->text + piece->used) ) {
          piece = piece->next;
          if (piece == NULL)    /* End of text. */
            return(src->multi_src.length);
          ptr = piece->text;
        }
      }
    }
    if (!include) {
      if ( type == XawstParagraph)
        position = first_eol_position;
      position -= inc;
    }
    break;
  case XawstPositions: 
    position += count * inc;
    break;
  case XawstAll:                /* handled in special code above */
  default:
    break;
  }

  if ( dir == XawsdLeft )
    position++;

  if (position >= src->multi_src.length)
    return(src->multi_src.length);
  if (position < 0)
    return(0);

  return(position);
}

Here is the call graph for this function:

static XawTextPosition Scan

(

)

[static]

static XawTextPosition Search	(	Widget	w,
		XawTextPosition	position,
		XawTextScanDirection	dir,
		XawTextBlock*	text
	)			[static]

Definition at line 597 of file MultiSrc.c.

References _XawTextMBToWC(), buf, count, FindPiece(), first, XawTextBlock::firstPos, XawTextBlock::format, XawTextBlock::length, _MultiPiece::next, _MultiPiece::prev, XawTextBlock::ptr, _MultiPiece::text, TRUE, _MultiPiece::used, void(), XawFmtWide, XawsdLeft, XawsdRight, and XawTextSearchError.

{
  MultiSrcObject src = (MultiSrcObject) w;
  int inc, count = 0;
  wchar_t * ptr;
  wchar_t* wtarget;
  int wtarget_len;
  Display * d = XtDisplay(XtParent(w));
  MultiPiece * piece;
  wchar_t* buf;
  XawTextPosition first;


  /* STEP 1: First, a brief sanity check. */

  if ( dir == XawsdRight )
    inc = 1;
  else {
    inc = -1;
    if (position == 0)
      return(XawTextSearchError);       /* scanning left from 0??? */
    position--;
  }


  /* STEP 2: Ensure I have a local wide string.. */

  /* Since this widget stores 32bit chars, I check here to see if
  I'm being passed a string claiming to be 8bit chars (ie, MB text.)
  If that is the case, naturally I convert to 32bit format. */

  /*if the block was FMT8BIT, length will convert to REAL wchar count below */
  wtarget_len = text->length;

  if ( text->format == XawFmtWide )
      wtarget = &( ((wchar_t*)text->ptr) [text->firstPos] );
  else
  {
      /* The following converts wtarget_len from byte len to wchar count */
      wtarget = _XawTextMBToWC( d, &text->ptr[ text->firstPos ], &wtarget_len );
  }

  /* OK, I can now assert that wtarget holds wide characters, wtarget_len
  holds an accurate count of those characters, and that firstPos has been
  effectively factored out of the following computations. */


  /* STEP 3: SEARCH! */

  buf = (wchar_t *)XtMalloc((unsigned)sizeof(wchar_t) * wtarget_len );
  (void)wcsncpy(buf, wtarget, wtarget_len );
  piece = FindPiece(src, position, &first);
  ptr = (position - first) + piece->text;

  /* CONSTCOND */
  while (TRUE) {
    if (*ptr == ((dir == XawsdRight) ? *(buf + count) 
                                     : *(buf + wtarget_len - count - 1)) ) {
      if (count == (text->length - 1))
        break;
      else
        count++;
    }
    else {
      if (count != 0) {
        position -=inc * count;
        ptr -= inc * count;
      }
      count = 0;
    }

    ptr += inc;
    position += inc;
    
    while ( ptr < piece->text ) {
      piece = piece->prev;
      if (piece == NULL) {      /* Begining of text. */
        XtFree((char *)buf);
        return(XawTextSearchError);
      }
      ptr = piece->text + piece->used - 1;
    }
   
    while ( ptr >= (piece->text + piece->used) ) {
      piece = piece->next;
      if (piece == NULL) {      /* End of text. */
        XtFree((char *)buf);
        return(XawTextSearchError);
      }
      ptr = piece->text;
    }
  }

  XtFree( (char *) buf );
  if (dir == XawsdLeft)
    return( position );
  return( position - ( wtarget_len - 1 ) );
}

Here is the call graph for this function:

static XawTextPosition Search

(

)

static Boolean SetValues	(	Widget	current,
		Widget	request,
		Widget	new,
		ArgList	args,
		Cardinal*	num_args
	)			[static]

Definition at line 710 of file MultiSrc.c.

References app_con, FALSE, file, i, InitStringOrFile(), LoadPieces(), _MultiSrcRec::multi_src, name, RemoveOldStringOrFile(), streq, TRUE, _MultiSrcPart::type, _MultiSrcPart::use_string_in_place, and XawTextSetSource().

{
  MultiSrcObject src =      (MultiSrcObject) new;
  MultiSrcObject old_src = (MultiSrcObject) current;
  XtAppContext app_con = XtWidgetToApplicationContext(new);
  Boolean total_reset = FALSE, string_set = FALSE;
  FILE * file;
  int i;

  if ( old_src->multi_src.use_string_in_place != 
       src->multi_src.use_string_in_place ) {
      XtAppWarning( app_con,
           "MultiSrc: The XtNuseStringInPlace resources may not be changed.");
       src->multi_src.use_string_in_place = 
           old_src->multi_src.use_string_in_place;
  }

  for (i = 0; i < *num_args ; i++ ) 
      if (streq(args[i].name, XtNstring)) {
          string_set = TRUE;
          break;
      }
  
  if ( string_set || (old_src->multi_src.type != src->multi_src.type) ) {
    RemoveOldStringOrFile(old_src, string_set);
    file = InitStringOrFile(src, string_set);

    /* Load pieces does this logic for us, but it shouldn't.  Its messy.*/
    /*if (old_src->multi_src.type == XawAsciiString)
        LoadPieces(src, NULL, src->multi_src.string);
    else*/
        LoadPieces(src, file, NULL);
    if (file != NULL) fclose(file);
    XawTextSetSource( XtParent(new), new, 0);   /* Tell text widget
                                                   what happened. */
    total_reset = TRUE;
  }

  if ( old_src->multi_src.multi_length != src->multi_src.multi_length ) 
      src->multi_src.piece_size = src->multi_src.multi_length;

  if ( !total_reset && (old_src->multi_src.piece_size
                                        != src->multi_src.piece_size) ) {
      String mb_string = StorePiecesInString( old_src );

      if ( mb_string != 0 ) {
          FreeAllPieces( old_src );
          LoadPieces( src, NULL, mb_string );
          XtFree( mb_string );
      } else {
          /* If the buffer holds bad chars, don't touch it... */
          XtAppWarningMsg( app_con,
                "convertError", "multiSource", "XawError",
                 XtName( XtParent( (Widget) old_src ) ), NULL, NULL );
          XtAppWarningMsg( app_con,
                "convertError", "multiSource", "XawError",
                 "Non-character code(s) in buffer.", NULL, NULL );
      }
  }

  return(FALSE);
}

Here is the call graph for this function:

static Boolean SetValues

(

)

[static]

static String StorePiecesInString

(

MultiSrcObject

src

)

[static]

Definition at line 1029 of file MultiSrc.c.

References _XawTextWCToMB(), first, FreeAllPieces(), LoadPieces(), _MultiPiece::next, _MultiPiece::text, _MultiPiece::used, and void().

{
  wchar_t* wc_string;
  char *mb_string;
  int char_count = src->multi_src.length;
  XawTextPosition first;
  MultiPiece * piece;

  /* I believe the char_count + 1 and the NULL termination are unneeded! FS*/

  wc_string = (wchar_t*) XtMalloc((unsigned)(char_count + 1) * sizeof(wchar_t));

  for (first = 0, piece = src->multi_src.first_piece ; piece != NULL;
                                first += piece->used, piece = piece->next)
      (void) wcsncpy( wc_string + first, piece->text, piece->used );

  wc_string[ char_count ] = (wchar_t)0; /* NULL terminate this sucker. */


  /* This will refill all pieces to capacity. */

  if ( src->multi_src.data_compression ) {
    FreeAllPieces( src );
    LoadPieces( src, NULL, (char *)wc_string );
  }

  /* Lastly, convert it to a MB format and send it back. */

  mb_string = _XawTextWCToMB( XtDisplayOfObject( (Widget)src ),
                                                wc_string, &char_count );

  /* NOTE THAT mb_string MAY BE ZERO IF THE CONVERSION FAILED. */
  XtFree( (char*) wc_string );
  return( mb_string );
}

Here is the call graph for this function:

static String StorePiecesInString

(

)

[static]

char* tmpnam

(

)

Referenced by InitStringOrFile(), and set_tmp_names().

Here is the caller graph for this function:

static Boolean WriteToFile	(	String	string,
		String	name
	)			[static]

Definition at line 1005 of file MultiSrc.c.

References close(), FALSE, fd, TRUE, and write().

{
  int fd;
  
  if ( ((fd = creat(name, 0666)) == -1 ) ||
       (write(fd, string, sizeof(unsigned char) * strlen(string)) == -1) )
    return(FALSE);

  if ( close(fd) == -1 ) 
    return(FALSE);

  return(TRUE);
}

Here is the call graph for this function:

static Boolean WriteToFile

(

)

---

Variable Documentation

int magic_value = MAGIC_VALUE [static]

Definition at line 85 of file MultiSrc.c.

MultiSrcClassRec multiSrcClassRec

Definition at line 142 of file MultiSrc.c.

WidgetClass multiSrcObjectClass = (WidgetClass)&multiSrcClassRec

Definition at line 190 of file MultiSrc.c.

Referenced by Initialize(), InsertChar(), XawAsciiSave(), XawAsciiSaveAsFile(), XawAsciiSourceChanged(), and XawAsciiSourceFreeString().

XtResource resources[] [static]

Initial value:

 {
    {XtNstring, XtCString, XtRString, sizeof (XtPointer),
       offset(string), XtRPointer, NULL},
    {XtNtype, XtCType, XtRMultiType, sizeof (XawAsciiType),
       offset(type), XtRImmediate, (XtPointer)XawAsciiString},
    
    {XtNdataCompression, XtCDataCompression, XtRBoolean, sizeof (Boolean),
       offset(data_compression), XtRImmediate, (XtPointer) FALSE},
    {XtNpieceSize, XtCPieceSize, XtRInt, sizeof (XawTextPosition),
       offset(piece_size), XtRImmediate, (XtPointer) BUFSIZ},
    {XtNcallback, XtCCallback, XtRCallback, sizeof(XtPointer), 
       offset(callback), XtRCallback, (XtPointer)NULL},
    {XtNuseStringInPlace, XtCUseStringInPlace, XtRBoolean, sizeof (Boolean),
       offset(use_string_in_place), XtRImmediate, (XtPointer) FALSE},
    {XtNlength, XtCLength, XtRInt, sizeof (int),
       offset(multi_length), XtRInt, (XtPointer) &magic_value},

}

Definition at line 89 of file MultiSrc.c.

---