/* $XConsortium: MultiSrc.c,v 1.5 94/03/30 21:28:36 kaleb Exp $ */ /* * Copyright 1991 by OMRON Corporation * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name OMRON not be used in * advertising or publicity pertaining to distribution of the software without * specific, written prior permission. OMRON makes no representations * about the suitability of this software for any purpose. It is provided * "as is" without express or implied warranty. * * OMRON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL OMRON BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTUOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. * * Authors: Chris Peterson MIT X Consortium * Li Yuhong OMRON Corporation * Frank Sheeran OMRON Corporation * * Much code taken from X11R3 String and Disk Sources. */ /* Copyright (c) 1991, 1994 X Consortium Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of the X Consortium shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from the X Consortium. */ /* * MultiSrc.c - MultiSrc object. (For use with the text widget). * */ #include #include #include #include #include #include #include #include #include #include #include #include "XawI18n.h" #include /**************************************************************** * * Full class record constant * ****************************************************************/ /* Private Data */ static int magic_value = MAGIC_VALUE; #define offset(field) XtOffsetOf(MultiSrcRec, multi_src.field) static XtResource resources[] = { {XtNstring, XtCString, XtRString, sizeof (XtPointer), offset(string), XtRPointer, NULL}, {XtNtype, XtCType, XtRMultiType, sizeof (XawAsciiType), offset(type), XtRImmediate, (XtPointer)XawAsciiString}, /* not used. */ {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}, }; #undef offset static XawTextPosition Scan(), Search(), ReadText(); static int ReplaceText(); static MultiPiece * FindPiece(), * AllocNewPiece(); static FILE * InitStringOrFile(); static void FreeAllPieces(), RemovePiece(), BreakPiece(), LoadPieces(); static void RemoveOldStringOrFile(), CvtStringToMultiType(); static void ClassInitialize(), Initialize(), Destroy(), GetValuesHook(); static String StorePiecesInString(); static Boolean SetValues(), WriteToFile(); #define MyWStrncpy( t,s,wcnt ) (void) memmove( (t), (s), (wcnt)*sizeof(wchar_t)) #ifndef MyWStrncpy static void (MyWStrncpy)(); #endif extern char *tmpnam(); #ifdef X_NOT_STDC_ENV extern int errno; #endif #if !defined(WIN32) && (defined(X_NOT_STDC_ENV) || (defined(sun) && !defined(SVR4))) extern int sys_nerr; extern char* sys_errlist[]; #endif #ifdef X_NOT_POSIX #define Off_t long #define Size_t unsigned int #else #define Off_t off_t #define Size_t size_t #endif extern wchar_t* _XawTextMBToWC(); extern char *_XawTextWCToMB(); #define superclass (&textSrcClassRec) MultiSrcClassRec multiSrcClassRec = { { /* object_class fields */ /* superclass */ (WidgetClass) superclass, /* class_name */ "MultiSrc", /* widget_size */ sizeof(MultiSrcRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* pad */ NULL, /* pad */ NULL, /* pad */ 0, /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* pad */ FALSE, /* pad */ FALSE, /* pad */ FALSE, /* pad */ FALSE, /* destroy */ Destroy, /* pad */ NULL, /* pad */ NULL, /* set_values */ SetValues, /* set_values_hook */ NULL, /* pad */ NULL, /* get_values_hook */ GetValuesHook, /* pad */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* pad */ NULL, /* pad */ NULL, /* pad */ NULL, /* extension */ NULL }, { /* textSrc_class fields */ /* Read */ ReadText, /* Replace */ ReplaceText, /* Scan */ Scan, /* Search */ Search, /* SetSelection */ XtInheritSetSelection, /* ConvertSelection */ XtInheritConvertSelection }, { /* multiSrc_class fields */ /* Keep the compiler happy */ '\0' } }; WidgetClass multiSrcObjectClass = (WidgetClass)&multiSrcClassRec; /************************************************************ * * Semi-Public Interfaces. * ************************************************************/ /* Function Name: ClassInitialize * Description: Class Initialize routine, called only once. * Arguments: none. * Returns: none. */ static void ClassInitialize() { XawInitializeWidgetSet(); XtAddConverter( XtRString, XtRMultiType, CvtStringToMultiType, NULL, (Cardinal) 0); } /* Function Name: Initialize * Description: Initializes the simple menu widget * Arguments: request - the widget requested by the argument list. * new - the new widget with both resource and non * resource values. * Returns: none. */ /* ARGSUSED */ static void Initialize(request, new, args, num_args) Widget request, new; ArgList args; Cardinal* num_args; { 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; } /* Function Name: ReadText * Description: This function reads the source. * Arguments: w - the MultiSource widget. * pos - position of the text to retreive. * RETURNED text - text block that will contain returned text. * length - maximum number of characters to read. * Returns: The number of characters read into the buffer. */ static XawTextPosition ReadText(w, pos, text, length) Widget w; XawTextPosition pos; XawTextBlock* text; int length; { 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); } /* Function Name: ReplaceText. * Description: Replaces a block of text with new text. * Arguments: w - the MultiSource widget. * startPos, endPos - ends of text that will be removed. * text - new text to be inserted into buffer at startPos. * Returns: XawEditError or XawEditDone. */ /*ARGSUSED*/ static int ReplaceText( w, startPos, endPos, u_text_p) Widget w; XawTextPosition startPos, endPos; XawTextBlock* u_text_p; { 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. */ XtFree( 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); } /* Function Name: Scan * Description: Scans the text source for the number and type * of item specified. * Arguments: w - the MultiSource widget. * position - the position to start scanning. * type - type of thing to scan for. * dir - direction to scan. * count - which occurance if this thing to search for. * include - whether or not to include the character found in * the position that is returned. * Returns: the position of the item found. * * Note: While there are only 'n' characters in the file there are n+1 * possible cursor positions (one before the first character and * one after the last character. */ static XawTextPosition Scan( w, position, type, dir, count, include ) Widget w; XawTextPosition position; XawTextScanType type; XawTextScanDirection dir; int count; Boolean include; { MultiSrcObject src = (MultiSrcObject) w; int inc; MultiPiece * piece; XawTextPosition first, first_eol_position; 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 */ } if ( dir == XawsdLeft ) position++; if (position >= src->multi_src.length) return(src->multi_src.length); if (position < 0) return(0); return(position); } /* Function Name: Search * Description: Searchs the text source for the text block passed * Arguments: w - the MultiSource Widget. * position - the position to start scanning. * dir - direction to scan. * text - the text block to search for. * Returns: the position of the item found. */ static XawTextPosition Search(w, position, dir, text ) Widget w; XawTextPosition position; XawTextScanDirection dir; XawTextBlock* text; { 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 ) ); } /* Function Name: SetValues * Description: Sets the values for the MultiSource. * Arguments: current - current state of the widget. * request - what was requested. * new - what the widget will become. * Returns: True if redisplay is needed. */ /* ARGSUSED */ static Boolean SetValues(current, request, new, args, num_args) Widget current, request, new; ArgList args; Cardinal* num_args; { 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); } /* Function Name: GetValuesHook * Description: This is a get values hook routine that sets the * values specific to the multi source. * Arguments: w - the MultiSource Widget. * args - the argument list. * num_args - the number of args. * Returns: none. */ static void GetValuesHook(w, args, num_args) Widget w; ArgList args; Cardinal* num_args; { 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; } } } /* Function Name: Destroy * Description: Destroys an multi source (frees all data) * Arguments: src - the Multi source Widget to free. * Returns: none. */ static void Destroy (w) Widget w; { RemoveOldStringOrFile((MultiSrcObject) w, True); } /************************************************************ * * Public routines * ************************************************************/ /* Function Name: XawMultiSourceFreeString * Description: Frees the string returned by a get values call * on the string when the source is of type string. * Arguments: w - the MultiSrc widget. * Returns: none. * * The public interface is XawAsciiSourceFreeString! */ void #if NeedFunctionPrototypes _XawMultiSourceFreeString( Widget w) #else _XawMultiSourceFreeString(w) Widget w; #endif { 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; } } /* Function Name: _XawMultiSave * Description: Saves all the pieces into a file or string as required. * Arguments: w - the multiSrc Widget. * Returns: TRUE if the save was successful. * * The public interface is XawAsciiSave(w)! */ Boolean #if NeedFunctionPrototypes _XawMultiSave( Widget w) #else _XawMultiSave(w) Widget w; #endif { 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); } /* Function Name: XawMultiSaveAsFile * Description: Save the current buffer as a file. * Arguments: w - the MultiSrc widget. * name - name of the file to save this file into. * Returns: True if the save was sucessful. * * The public interface is XawAsciiSaveAsFile! */ Boolean #if NeedFunctionPrototypes _XawMultiSaveAsFile( Widget w, _Xconst char* name) #else _XawMultiSaveAsFile(w, name) Widget w; String name; #endif { 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 ); } /************************************************************ * * Private Functions. * ************************************************************/ static void RemoveOldStringOrFile(src, checkString) MultiSrcObject src; Boolean checkString; { 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; } } /* Function Name: WriteToFile * Description: Write the string specified to the begining of the file * specified. * Arguments: string - string to write. * name - the name of the file * Returns: returns TRUE if sucessful, FALSE otherwise. */ static Boolean WriteToFile(string, name) String string, name; { 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); } /* Function Name: StorePiecesInString * Description: store the pieces in memory into a char string. * Arguments: src - the multiSrc to gather data from * Returns: char *mb_string. Caller must free. * or 0: conversion error. Caller must panic! */ static String StorePiecesInString(src) MultiSrcObject src; { 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 ); } /* Function Name: InitStringOrFile. * Description: Initializes the string or file. * Arguments: src - the MultiSource. * Returns: none - May exit though. */ static FILE * InitStringOrFile(src, newString) MultiSrcObject src; Boolean newString; { char * open_mode; 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 ) XtFree( src->multi_src.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; char msg[11]; params[0] = src->multi_src.string; #if defined(X_NOT_STDC_ENV) || (defined(sun) && !defined(SVR4)) if (errno <= sys_nerr) params[1] = sys_errlist[errno]; else { sprintf(msg, "errno=%.4d", errno); params[1] = msg; } #else params[1] = msg; #endif 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 } /* LoadPieces: This routine takes either the MB contents of open file `file' or the MB contents of string or the MB contents of src->multi_src.string and places them in Pieces in WC format. CAUTION: You must have src->multi_src.length set to file length bytes when src->multi_src.type == XawAsciiFile. src->multi_src.length must be the length of the parameter string if string is non-NULL. */ static void LoadPieces(src, file, string) MultiSrcObject src; FILE* file; char* string; { 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 ); } /* Function Name: AllocNewPiece * Description: Allocates a new piece of memory. * Arguments: src - The MultiSrc Widget. * prev - the piece just before this one, or NULL. * Returns: the allocated piece. */ static MultiPiece * AllocNewPiece(src, prev) MultiSrcObject src; 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); } /* Function Name: FreeAllPieces * Description: Frees all the pieces * Arguments: src - The MultiSrc Widget. * Returns: none. */ static void FreeAllPieces(src) MultiSrcObject src; { 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); } } /* Function Name: RemovePiece * Description: Removes a piece from the list. * Arguments: * piece - the piece to remove. * Returns: none. */ static void RemovePiece(src, piece) MultiSrcObject src; MultiPiece* piece; { 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); } /* Function Name: FindPiece * Description: Finds the piece containing the position indicated. * Arguments: src - The MultiSrc Widget. * position - the position that we are searching for. * RETURNED first - the position of the first character in this piece. * Returns: piece - the piece that contains this position. */ static MultiPiece * FindPiece(src, position, first) MultiSrcObject src; XawTextPosition position, *first; { MultiPiece * old_piece, * 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 */ } /* Function Name: BreakPiece * Description: Breaks a full piece into two new pieces. * Arguments: src - The MultiSrc Widget. * piece - the piece to break. * Returns: none. */ #define HALF_PIECE (src->multi_src.piece_size/2) static void BreakPiece(src, piece) MultiSrcObject src; MultiPiece* piece; { 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; } /* Convert string "XawAsciiString" and "XawAsciiFile" to quarks. */ /* ARGSUSED */ static void CvtStringToMultiType(args, num_args, fromVal, toVal) XrmValuePtr args; /* unused */ Cardinal* num_args; /* unused */ XrmValuePtr fromVal; XrmValuePtr toVal; { static XawAsciiType type; static XrmQuark XtQEstring = NULLQUARK; static XrmQuark XtQEfile; XrmQuark q; char lowerName[BUFSIZ]; if (XtQEstring == NULLQUARK) { XtQEstring = XrmPermStringToQuark(XtEstring); XtQEfile = XrmPermStringToQuark(XtEfile); } XmuCopyISOLatin1Lowered(lowerName, (char *) fromVal->addr); q = XrmStringToQuark(lowerName); if (q == XtQEstring) type = XawAsciiString; if (q == XtQEfile) type = XawAsciiFile; (*toVal).size = sizeof(XawAsciiType); (*toVal).addr = (XPointer) &type; return; }