1 /* 2 * Copyright 1991 by OMRON Corporation 3 * 4 * Permission to use, copy, modify, distribute, and sell this software and its 5 * documentation for any purpose is hereby granted without fee, provided that 6 * the above copyright notice appear in all copies and that both that 7 * copyright notice and this permission notice appear in supporting 8 * documentation, and that the name OMRON not be used in 9 * advertising or publicity pertaining to distribution of the software without 10 * specific, written prior permission. OMRON makes no representations 11 * about the suitability of this software for any purpose. It is provided 12 * "as is" without express or implied warranty. 13 * 14 * OMRON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 16 * EVENT SHALL OMRON BE LIABLE FOR ANY SPECIAL, INDIRECT OR 17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 19 * TORTUOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 20 * PERFORMANCE OF THIS SOFTWARE. 21 * 22 * Authors: Chris Peterson MIT X Consortium 23 * Li Yuhong OMRON Corporation 24 * Frank Sheeran OMRON Corporation 25 * 26 * Much code taken from X11R3 String and Disk Sources. 27 */ 28 29 /* 30 31 Copyright 1991, 1994, 1998 The Open Group 32 33 Permission to use, copy, modify, distribute, and sell this software and its 34 documentation for any purpose is hereby granted without fee, provided that 35 the above copyright notice appear in all copies and that both that 36 copyright notice and this permission notice appear in supporting 37 documentation. 38 39 The above copyright notice and this permission notice shall be included in 40 all copies or substantial portions of the Software. 41 42 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 43 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 44 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 45 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 46 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 47 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 48 49 Except as contained in this notice, the name of The Open Group shall not be 50 used in advertising or otherwise to promote the sale, use or other dealings 51 in this Software without prior written authorization from The Open Group. 52 53 */ 54 55 #ifdef HAVE_CONFIG_H 56 #include <config.h> 57 #endif 58 #include <stdio.h> 59 #include <stdlib.h> 60 #include <ctype.h> 61 #include <errno.h> 62 #include <X11/IntrinsicP.h> 63 #include <X11/StringDefs.h> 64 #include <X11/Xfuncs.h> 65 #include <X11/Xos.h> 66 #include <X11/Xmu/CharSet.h> 67 #include <X11/Xmu/Misc.h> 68 #include <X11/Xaw/XawInit.h> 69 #include <X11/Xaw/MultiSrcP.h> 70 #include <X11/Xaw/XawImP.h> 71 #include "XawI18n.h" 72 #include "Private.h" 73 74 #include <sys/types.h> 75 #include <sys/stat.h> 76 #include <fcntl.h> 77 78 #ifndef O_CLOEXEC 79 #define O_CLOEXEC 0 80 #endif 81 82 #define MAGIC_VALUE ((XawTextPosition)-1) 83 #define streq(a, b) (strcmp((a), (b)) == 0) 84 85 86 /* 87 * Class Methods 88 */ 89 static XawTextPosition ReadText(Widget, XawTextPosition, XawTextBlock*, int); 90 static int ReplaceText(Widget, XawTextPosition, XawTextPosition, 91 XawTextBlock*); 92 static XawTextPosition Scan(Widget, XawTextPosition, XawTextScanType, 93 XawTextScanDirection, int, Bool); 94 static XawTextPosition Search(Widget, XawTextPosition, XawTextScanDirection, 95 XawTextBlock*); 96 static void XawMultiSrcClassInitialize(void); 97 static void XawMultiSrcDestroy(Widget); 98 static void XawMultiSrcInitialize(Widget, Widget, ArgList, Cardinal*); 99 static Boolean XawMultiSrcSetValues(Widget, Widget, Widget, 100 ArgList, Cardinal*); 101 static void XawMultiSrcGetValuesHook(Widget, ArgList, Cardinal*); 102 103 /* 104 * Prototypes 105 */ 106 static MultiPiece *AllocNewPiece(MultiSrcObject, MultiPiece*); 107 static void BreakPiece(MultiSrcObject, MultiPiece*); 108 static Boolean CvtMultiTypeToString(Display*, XrmValuePtr, Cardinal*, 109 XrmValuePtr, XrmValuePtr, XtPointer*); 110 static void CvtStringToMultiType(XrmValuePtr, Cardinal*, 111 XrmValuePtr, XrmValuePtr); 112 static MultiPiece *FindPiece(MultiSrcObject, XawTextPosition, 113 XawTextPosition*); 114 static void FreeAllPieces(MultiSrcObject); 115 static FILE *InitStringOrFile(MultiSrcObject, Bool); 116 static void LoadPieces(MultiSrcObject, FILE*, char*); 117 static void RemovePiece(MultiSrcObject, MultiPiece*); 118 static void RemoveOldStringOrFile(MultiSrcObject, Bool); 119 static char * StorePiecesInString(MultiSrcObject); 120 static Bool WriteToFile(String, String); 121 static void GetDefaultPieceSize(Widget, int, XrmValue*); 122 123 /* 124 * Initialization 125 */ 126 #define offset(field) XtOffsetOf(MultiSrcRec, multi_src.field) 127 static XtResource resources[] = { 128 { 129 XtNstring, 130 XtCString, 131 XtRString, 132 sizeof(XtPointer), 133 offset(string), 134 XtRPointer, 135 NULL 136 }, 137 { 138 XtNtype, 139 XtCType, 140 XtRMultiType, 141 sizeof(XawAsciiType), 142 offset(type), 143 XtRImmediate, 144 (XtPointer)XawAsciiString 145 }, 146 { 147 XtNdataCompression, 148 XtCDataCompression, 149 XtRBoolean, 150 sizeof(Boolean), 151 offset(data_compression), 152 XtRImmediate, 153 (XtPointer)False 154 }, 155 { 156 XtNpieceSize, 157 XtCPieceSize, 158 XtRInt, 159 sizeof(XawTextPosition), 160 offset(piece_size), 161 XtRCallProc, 162 (XtPointer)GetDefaultPieceSize 163 }, 164 #ifdef OLDXAW 165 { 166 XtNcallback, 167 XtCCallback, 168 XtRCallback, 169 sizeof(XtPointer), 170 offset(callback), 171 XtRCallback, 172 (XtPointer)NULL 173 }, 174 #endif 175 { 176 XtNuseStringInPlace, 177 XtCUseStringInPlace, 178 XtRBoolean, 179 sizeof(Boolean), 180 offset(use_string_in_place), 181 XtRImmediate, 182 (XtPointer)False 183 }, 184 { 185 XtNlength, 186 XtCLength, 187 XtRInt, 188 sizeof(int), 189 offset(multi_length), 190 XtRImmediate, 191 (XtPointer)MAGIC_VALUE 192 }, 193 }; 194 #undef offset 195 196 #define superclass (&textSrcClassRec) 197 MultiSrcClassRec multiSrcClassRec = { 198 /* object */ 199 { 200 (WidgetClass)superclass, /* superclass */ 201 "MultiSrc", /* class_name */ 202 sizeof(MultiSrcRec), /* widget_size */ 203 XawMultiSrcClassInitialize, /* class_initialize */ 204 NULL, /* class_part_initialize */ 205 False, /* class_inited */ 206 XawMultiSrcInitialize, /* initialize */ 207 NULL, /* initialize_hook */ 208 NULL, /* obj1 */ 209 NULL, /* obj2 */ 210 0, /* obj3 */ 211 resources, /* resources */ 212 XtNumber(resources), /* num_resources */ 213 NULLQUARK, /* xrm_class */ 214 False, /* obj4 */ 215 False, /* obj5 */ 216 False, /* obj6 */ 217 False, /* obj7 */ 218 XawMultiSrcDestroy, /* destroy */ 219 NULL, /* obj8 */ 220 NULL, /* obj9 */ 221 XawMultiSrcSetValues, /* set_values */ 222 NULL, /* set_values_hook */ 223 NULL, /* obj10 */ 224 XawMultiSrcGetValuesHook, /* get_values_hook */ 225 NULL, /* obj11 */ 226 XtVersion, /* version */ 227 NULL, /* callback_private */ 228 NULL, /* obj12 */ 229 NULL, /* obj13 */ 230 NULL, /* obj14 */ 231 NULL, /* extension */ 232 }, 233 /* text_src */ 234 { 235 ReadText, /* Read */ 236 ReplaceText, /* Replace */ 237 Scan, /* Scan */ 238 Search, /* Search */ 239 XtInheritSetSelection, /* SetSelection */ 240 XtInheritConvertSelection, /* ConvertSelection */ 241 #ifndef OLDXAW 242 NULL 243 #endif 244 }, 245 /* multi_src */ 246 { 247 NULL, /* extension */ 248 }, 249 }; 250 251 WidgetClass multiSrcObjectClass = (WidgetClass)&multiSrcClassRec; 252 253 static XrmQuark Qstring, Qfile; 254 255 /* 256 * Implementation 257 */ 258 static void 259 XawMultiSrcClassInitialize(void) 260 { 261 XawInitializeWidgetSet(); 262 Qstring = XrmPermStringToQuark(XtEstring); 263 Qfile = XrmPermStringToQuark(XtEfile); 264 XtAddConverter(XtRString, XtRMultiType, CvtStringToMultiType, NULL, 0); 265 XtSetTypeConverter(XtRMultiType, XtRString, CvtMultiTypeToString, NULL, 0, 266 XtCacheNone, NULL); 267 } 268 269 /* 270 * Function: 271 * XawMultiSrcInitialize 272 * 273 * Parameters: 274 * request - widget requested by the argument list 275 * cnew - the new widget with both resource and non resource values 276 * args - (unused) 277 * num_args - (unused) 278 * 279 * Description: 280 * Initializes the multi src object 281 */ 282 /*ARGSUSED*/ 283 static void 284 XawMultiSrcInitialize(Widget request _X_UNUSED, Widget cnew, 285 ArgList args _X_UNUSED, Cardinal *num_args _X_UNUSED) 286 { 287 MultiSrcObject src = (MultiSrcObject)cnew; 288 FILE *file; 289 290 /* 291 * Set correct flags (override resources) depending upon widget class 292 */ 293 #ifdef OLDXAW 294 src->multi_src.changes = False; 295 #else 296 src->text_src.changed = False; 297 #endif 298 src->multi_src.allocated_string = False; 299 300 if (src->multi_src.use_string_in_place && src->multi_src.string == NULL) 301 src->multi_src.use_string_in_place = False; 302 303 file = InitStringOrFile(src, src->multi_src.type == XawAsciiFile); 304 LoadPieces(src, file, NULL); 305 306 if (file != NULL) 307 fclose(file); 308 src->text_src.text_format = (XrmQuark)XawFmtWide; 309 } 310 311 /* 312 * Function: 313 * ReadText 314 * 315 * Parameters: 316 * w - MultiSource object 317 * pos - position of the text to retrieve 318 * text - text block that will contain returned text 319 * length - maximum number of characters to read 320 * 321 * Description: 322 * This function reads the source. 323 * 324 * Returns: 325 * The character position following the retrieved text. 326 */ 327 static XawTextPosition 328 ReadText(Widget w, XawTextPosition pos, XawTextBlock *text, int length) 329 { 330 MultiSrcObject src = (MultiSrcObject)w; 331 XawTextPosition count, start; 332 MultiPiece *piece = FindPiece(src, pos, &start); 333 334 text->format = XawFmtWide; 335 text->firstPos = (int)pos; 336 text->ptr = (char *)(piece->text + (pos - start)); 337 count = piece->used - (pos - start); 338 text->length = (int)(Max(0, (length > count) ? count : length)); 339 340 return (pos + text->length); 341 } 342 343 /* 344 * Function: 345 * ReplaceText 346 * 347 * Parameters: 348 * w - MultiSource object 349 * startPos - ends of text that will be removed 350 * endPos - "" 351 * text - new text to be inserted into buffer at startPos 352 * 353 * Description: 354 * Replaces a block of text with new text. 355 * 356 * Returns: 357 * XawEditDone on success, XawEditError otherwise 358 */ 359 /*ARGSUSED*/ 360 static int 361 ReplaceText(Widget w, XawTextPosition startPos, XawTextPosition endPos, 362 XawTextBlock *u_text_p) 363 { 364 MultiSrcObject src = (MultiSrcObject)w; 365 MultiPiece *start_piece, *end_piece, *temp_piece; 366 XawTextPosition start_first, end_first; 367 int length, firstPos; 368 wchar_t *wptr; 369 Bool local_artificial_block = False; 370 XawTextBlock text; 371 372 /* STEP 1: The user handed me a text block called `u_text' that may be 373 * in either FMTWIDE or FMT8BIT (ie MB.) Later code needs the block 374 * `text' to hold FMTWIDE. So, this copies `u_text' to `text', and if 375 * `u_text' was MB, I knock it up to WIDE 376 */ 377 if (u_text_p->length == 0) /* if so, the block contents never ref'd */ 378 text.length = 0; 379 380 else if (u_text_p->format == XawFmtWide) { 381 local_artificial_block = False; /* don't have to free it ourselves */ 382 text.firstPos = u_text_p->firstPos; 383 text.length = u_text_p->length; 384 text.ptr = u_text_p->ptr; 385 } 386 else { 387 /* 388 * WARNING! u_text->firstPos and length are in units of CHAR, 389 * not CHARACTERS! 390 */ 391 local_artificial_block = True; /* have to free it ourselves */ 392 text.firstPos = 0; 393 text.length = u_text_p->length; /* _XawTextMBToWC converts this 394 * to wchar len 395 */ 396 397 text.ptr = (char*)_XawTextMBToWC(XtDisplay(XtParent(w)), 398 &u_text_p->ptr[u_text_p->firstPos], 399 &text.length); 400 401 /* I assert the following assignment is not needed - since Step 4 402 depends on length, it has no need of a terminating NULL. I think 403 the ASCII-version has the same needless NULL. */ 404 /*((wchar_t*)text.ptr)[ text.length ] = NULL;*/ 405 } 406 407 /* STEP 2: some initialization... */ 408 if (src->text_src.edit_mode == XawtextRead) 409 return (XawEditError); 410 411 if ((start_piece = FindPiece(src, startPos, &start_first)) == NULL) 412 return XawEditError; 413 if ((end_piece = FindPiece(src, endPos, &end_first)) == NULL) 414 return XawEditError; 415 416 /* STEP 3: remove the empty pieces... */ 417 if (start_piece != end_piece) { 418 if ((temp_piece = start_piece->next) == NULL) 419 return XawEditError; 420 421 /* If empty and not the only piece then remove it */ 422 if (((start_piece->used = startPos - start_first) == 0) 423 && !(start_piece->next == NULL && start_piece->prev == NULL)) 424 RemovePiece(src, start_piece); 425 426 while (temp_piece != end_piece) { 427 temp_piece = temp_piece->next; 428 RemovePiece(src, temp_piece->prev); 429 } 430 end_piece->used -= endPos - end_first; 431 if (end_piece->used != 0) 432 memmove(end_piece->text, end_piece->text + endPos - end_first, 433 (size_t)end_piece->used * sizeof(wchar_t)); 434 } 435 else { /* We are fully in one piece */ 436 if ((start_piece->used -= endPos - startPos) == 0) { 437 if (!(start_piece->next == NULL && start_piece->prev == NULL)) 438 RemovePiece(src, start_piece); 439 } 440 else { 441 memmove(start_piece->text + (startPos - start_first), 442 start_piece->text + (endPos - start_first), 443 (size_t)(start_piece->used - (startPos - start_first)) * 444 sizeof(wchar_t)); 445 if (src->multi_src.use_string_in_place && 446 ((src->multi_src.length - (endPos - startPos)) 447 < src->multi_src.piece_size - 1)) 448 start_piece->text[src->multi_src.length - (endPos - startPos)] = 449 (wchar_t)0; 450 } 451 } 452 453 src->multi_src.length += text.length -(endPos - startPos); 454 455 /* STEP 4: insert the new stuff */ 456 if ( text.length != 0) { 457 start_piece = FindPiece(src, startPos, &start_first); 458 length = text.length; 459 firstPos = text.firstPos; 460 461 while (length > 0) { 462 wchar_t *ptr; 463 int fill; 464 465 if (src->multi_src.use_string_in_place) { 466 if (start_piece->used == src->multi_src.piece_size - 1) { 467 468 /* 469 * The string is used in place, then the string 470 * is not allowed to grow 471 */ 472 start_piece->used = src->multi_src.length = 473 src->multi_src.piece_size - 1; 474 475 start_piece->text[src->multi_src.length] = (wchar_t)0; 476 return (XawEditError); 477 } 478 } 479 480 if (start_piece->used == src->multi_src.piece_size) { 481 BreakPiece(src, start_piece); 482 start_piece = FindPiece(src, startPos, &start_first); 483 } 484 485 fill = Min((int)(src->multi_src.piece_size - start_piece->used), length); 486 487 ptr = start_piece->text + (startPos - start_first); 488 memmove(ptr + fill, ptr, (size_t)(start_piece->used - 489 (startPos - start_first)) * sizeof(wchar_t)); 490 wptr =(wchar_t *)text.ptr; 491 (void)wcsncpy(ptr, wptr + firstPos, (size_t)fill); 492 493 startPos += fill; 494 firstPos += fill; 495 start_piece->used += fill; 496 length -= fill; 497 } 498 } 499 500 if (local_artificial_block == True) 501 /* In other words, text is not the u_text that the user handed me but 502 one I made myself. I only care, because I need to free the string */ 503 XtFree(text.ptr); 504 505 if (src->multi_src.use_string_in_place) 506 start_piece->text[start_piece->used] = (wchar_t)0; 507 508 #ifdef OLDXAW 509 src->multi_src.changes = True; 510 XtCallCallbacks(w, XtNcallback, NULL); 511 #endif 512 513 return (XawEditDone); 514 } 515 516 /* 517 * Function: 518 * Scan 519 * 520 * Parameters: 521 * w - MultiSource widget 522 * position - position to start scanning 523 * type - type of thing to scan for 524 * dir - direction to scan 525 * count - which occurrence of this thing to search for 526 * include - whether or not to include the character found in 527 * the position that is returned 528 * 529 * Description: 530 * Scans the text source for the number and type of item specified. 531 * 532 * Returns: 533 * The position of the item found 534 * 535 * Note: 536 * While there are only 'n' characters in the file there are n+1 537 * possible cursor positions (one before the first character and 538 * one after the last character 539 */ 540 static XawTextPosition 541 Scan(Widget w, register XawTextPosition position, XawTextScanType type, 542 XawTextScanDirection dir, int count, Bool include) 543 { 544 MultiSrcObject src = (MultiSrcObject)w; 545 register char inc; 546 MultiPiece *piece; 547 XawTextPosition first, first_eol_position = position; 548 register wchar_t *ptr; 549 int cnt = count; 550 551 if (type == XawstAll) { 552 if (dir == XawsdRight) 553 return (src->multi_src.length); 554 return (0); 555 } 556 557 /* STEP 1: basic sanity checks */ 558 if (position > src->multi_src.length) 559 position = src->multi_src.length; 560 561 if (dir == XawsdRight) { 562 if (position == src->multi_src.length) 563 return (src->multi_src.length); 564 inc = 1; 565 } 566 else { 567 if (position == 0) 568 return (0); 569 inc = -1; 570 position--; 571 } 572 573 piece = FindPiece(src, position, &first); 574 575 if (piece->used == 0) 576 return (0); 577 578 ptr = (position - first) + piece->text; 579 580 switch (type) { 581 case XawstEOL: 582 case XawstParagraph: 583 case XawstWhiteSpace: 584 case XawstAlphaNumeric: 585 for (; cnt > 0 ; cnt--) { 586 Bool non_space = False, first_eol = True; 587 588 /*CONSTCOND*/ 589 while (True) { 590 register wchar_t c; 591 592 if (ptr < piece->text) { 593 piece = piece->prev; 594 if (piece == NULL) /* Beginning of text */ 595 return (0); 596 ptr = piece->text + piece->used - 1; 597 } 598 else if (ptr >= piece->text + piece->used) { 599 piece = piece->next; 600 if (piece == NULL) /* End of text */ 601 return (src->multi_src.length); 602 ptr = piece->text; 603 } 604 605 c = *ptr; 606 ptr += inc; 607 position += inc; 608 609 if (type == XawstAlphaNumeric) { 610 if (!iswalnum((wint_t)c)) { 611 if (non_space) 612 break; 613 } 614 else 615 non_space = True; 616 } 617 else if (type == XawstWhiteSpace) { 618 if (iswspace(c)) { 619 if (non_space) 620 break; 621 } 622 else 623 non_space = True; 624 } 625 else if (type == XawstEOL) { 626 if (c == _Xaw_atowc(XawLF)) 627 break; 628 } 629 else { /* XawstParagraph */ 630 if (first_eol) { 631 if (c == _Xaw_atowc(XawLF)) { 632 first_eol_position = position; 633 first_eol = False; 634 } 635 } 636 else 637 if (c == _Xaw_atowc(XawLF)) 638 break; 639 else if (!iswspace(c)) 640 first_eol = True; 641 } 642 } 643 } 644 if (!include) { 645 if (type == XawstParagraph) 646 position = first_eol_position; 647 if (count) 648 position -= inc; 649 } 650 break; 651 case XawstPositions: 652 position += count * inc; 653 break; 654 default: 655 break; 656 } 657 658 if (dir == XawsdLeft) 659 position++; 660 661 if (position >= src->multi_src.length) 662 return (src->multi_src.length); 663 if (position < 0) 664 return (0); 665 666 return (position); 667 } 668 669 /* 670 * Function: 671 * Search 672 * 673 * Parameters: 674 * w - MultiSource objecy 675 * position - position to start scanning 676 * dir - direction to scan 677 * text - text block to search for 678 * 679 * Description: 680 * Searches the text source for the text block passed. 681 * 682 * Returns: 683 * The position of the item found 684 */ 685 static XawTextPosition 686 Search(Widget w, register XawTextPosition position, XawTextScanDirection dir, 687 XawTextBlock *text) 688 { 689 MultiSrcObject src = (MultiSrcObject)w; 690 register int count = 0; 691 wchar_t *ptr; 692 wchar_t *wtarget; 693 int wtarget_len; 694 Display *d = XtDisplay(XtParent(w)); 695 MultiPiece *piece; 696 wchar_t *buf; 697 XawTextPosition first; 698 register char inc; 699 int cnt; 700 701 /* STEP 1: First, a brief sanity check */ 702 if (dir == XawsdRight) 703 inc = 1; 704 else { 705 inc = -1; 706 if (position == 0) 707 return (XawTextSearchError); 708 position--; 709 } 710 711 /* STEP 2: Ensure I have a local wide string.. */ 712 713 /* Since this widget stores 32bit chars, I check here to see if 714 I'm being passed a string claiming to be 8bit chars (ie, MB text.) 715 If that is the case, naturally I convert to 32bit format */ 716 717 /*if the block was FMT8BIT, length will convert to REAL wchar count below */ 718 wtarget_len = text->length; 719 720 if (text->format == XawFmtWide) 721 wtarget = &(((wchar_t*)text->ptr) [text->firstPos]); 722 else { 723 /* The following converts wtarget_len from byte len to wchar count */ 724 wtarget = _XawTextMBToWC(d, &text->ptr[text->firstPos], &wtarget_len); 725 } 726 727 /* OK, I can now assert that wtarget holds wide characters, wtarget_len 728 holds an accurate count of those characters, and that firstPos has been 729 effectively factored out of the following computations */ 730 731 /* STEP 3: SEARCH! */ 732 buf = (wchar_t *)XtMalloc((Cardinal)(sizeof(wchar_t) * (size_t)wtarget_len)); 733 (void)wcsncpy(buf, wtarget, (size_t)wtarget_len); 734 piece = FindPiece(src, position, &first); 735 ptr = (position - first) + piece->text; 736 737 /*CONSTCOND*/ 738 while (True) { 739 if (*ptr == (dir == XawsdRight ? *(buf + count) 740 : *(buf + wtarget_len - count - 1))) { 741 if (count == text->length - 1) 742 break; 743 else 744 count++; 745 } 746 else { 747 if (count != 0) { 748 position -=inc * count; 749 ptr -= inc * count; 750 } 751 count = 0; 752 } 753 754 ptr += inc; 755 position += inc; 756 757 while (ptr < piece->text) { 758 cnt = (int)(piece->text - ptr); 759 760 piece = piece->prev; 761 if (piece == NULL) { /* Beginning of text */ 762 XtFree((char *)buf); 763 return (XawTextSearchError); 764 } 765 ptr = piece->text + piece->used - cnt; 766 } 767 768 while (ptr >= piece->text + piece->used) { 769 cnt = (int)(ptr - (piece->text + piece->used)); 770 771 piece = piece->next; 772 if (piece == NULL) { /* End of text */ 773 XtFree((char *)buf); 774 return (XawTextSearchError); 775 } 776 ptr = piece->text + cnt; 777 } 778 } 779 780 XtFree((char *)buf); 781 if (dir == XawsdLeft) 782 return(position); 783 784 return(position - (wtarget_len - 1)); 785 } 786 787 /* 788 * Function: 789 * XawMultiSrcSetValues 790 * 791 * Parameters: 792 * current - current state of the widget 793 * request - what was requested 794 * cnew - what the widget will become 795 * args - representation of resources that have changed 796 * num_args - number of changed resources 797 * 798 * Description: 799 * Sets the values for the MultiSource. 800 * 801 * Returns: 802 * True if redisplay is needed 803 */ 804 static Boolean 805 XawMultiSrcSetValues(Widget current, Widget request _X_UNUSED, Widget cnew, 806 ArgList args, Cardinal *num_args) 807 { 808 MultiSrcObject src = (MultiSrcObject)cnew; 809 MultiSrcObject old_src = (MultiSrcObject)current; 810 XtAppContext app_con = XtWidgetToApplicationContext(cnew); 811 Bool total_reset = False, string_set = False; 812 FILE *file; 813 unsigned int i; 814 815 if (old_src->multi_src.use_string_in_place 816 != src->multi_src.use_string_in_place) { 817 XtAppWarning(app_con, 818 "MultiSrc: The XtNuseStringInPlace resources " 819 "may not be changed."); 820 src->multi_src.use_string_in_place = 821 old_src->multi_src.use_string_in_place; 822 } 823 824 for (i = 0; i < *num_args ; i++) 825 if (streq(args[i].name, XtNstring)) { 826 string_set = True; 827 break; 828 } 829 830 if (string_set || old_src->multi_src.type != src->multi_src.type) { 831 RemoveOldStringOrFile(old_src, string_set); 832 src->multi_src.allocated_string = old_src->multi_src.allocated_string; 833 file = InitStringOrFile(src, string_set); 834 835 LoadPieces(src, file, NULL); 836 if (file != NULL) 837 fclose(file); 838 #ifndef OLDXAW 839 for (i = 0; i < src->text_src.num_text; i++) 840 /* Tell text widget what happened */ 841 XawTextSetSource(src->text_src.text[i], cnew, 0); 842 #else 843 XawTextSetSource(XtParent(cnew), cnew, 0); 844 #endif 845 total_reset = True; 846 } 847 848 if (old_src->multi_src.multi_length != src->multi_src.multi_length) 849 src->multi_src.piece_size = src->multi_src.multi_length + 1; 850 851 if ( !total_reset && old_src->multi_src.piece_size 852 != src->multi_src.piece_size) { 853 char * mb_string = StorePiecesInString(old_src); 854 855 if (mb_string != 0) { 856 FreeAllPieces(old_src); 857 LoadPieces(src, NULL, mb_string); 858 XtFree(mb_string); 859 } 860 else { 861 /* If the buffer holds bad chars, don't touch it... */ 862 XtAppWarningMsg(app_con, 863 "convertError", "multiSource", "XawError", 864 XtName(XtParent((Widget)old_src)), NULL, NULL); 865 XtAppWarningMsg(app_con, 866 "convertError", "multiSource", "XawError", 867 "Non-character code(s) in buffer.", NULL, NULL); 868 } 869 } 870 871 return (False); 872 } 873 874 static void 875 XawMultiSrcGetValuesHook(Widget w, ArgList args, Cardinal *num_args) 876 { 877 MultiSrcObject src = (MultiSrcObject)w; 878 Cardinal i; 879 880 if (src->multi_src.type == XawAsciiString) { 881 for (i = 0; i < *num_args ; i++) { 882 if (streq(args[i].name, XtNstring)) { 883 if (src->multi_src.use_string_in_place) 884 *((char **)args[i].value) = (char *) 885 src->multi_src.first_piece->text; 886 else if (_XawMultiSave(w)) /* If save successful */ 887 *((char **)args[i].value) = (char *)src->multi_src.string; 888 break; 889 } 890 } 891 } 892 } 893 894 static void 895 XawMultiSrcDestroy(Widget w) 896 { 897 RemoveOldStringOrFile((MultiSrcObject) w, True); 898 } 899 900 /* 901 * Public routines 902 */ 903 /* 904 * Function: 905 * XawMultiSourceFreeString 906 * 907 * Parameters: 908 * w - MultiSrc widget 909 * 910 * Description: 911 * Frees the string returned by a get values call 912 * on the string when the source is of type string. 913 * 914 * Note: 915 * The public interface is XawAsciiSourceFreeString! 916 */ 917 void 918 _XawMultiSourceFreeString(Widget w) 919 { 920 MultiSrcObject src = (MultiSrcObject)w; 921 922 if (src->multi_src.allocated_string) { 923 XtFree((char *)src->multi_src.string); 924 src->multi_src.allocated_string = False; 925 src->multi_src.string = NULL; 926 } 927 } 928 929 /* 930 * Function: 931 * _XawMultiSave 932 * 933 * Parameters: 934 * w - multiSrc Widget 935 * 936 * Description: 937 * Saves all the pieces into a file or string as required. 938 * 939 * Returns: 940 * True if the save was successful 941 * 942 * Note: 943 * The public interface is XawAsciiSave(w)! 944 */ 945 Bool 946 _XawMultiSave(Widget w) 947 { 948 MultiSrcObject src = (MultiSrcObject)w; 949 XtAppContext app_con = XtWidgetToApplicationContext(w); 950 char *mb_string; 951 952 /* 953 * If using the string in place then there is no need to play games 954 * to get the internal info into a readable string 955 */ 956 if (src->multi_src.use_string_in_place) 957 return (True); 958 959 if (src->multi_src.type == XawAsciiFile) { 960 #ifdef OLDXAW 961 if (!src->multi_src.changes) 962 #else 963 if (!src->text_src.changed) /* No changes to save */ 964 #endif 965 return (True); 966 967 mb_string = StorePiecesInString(src); 968 969 if (mb_string != 0) { 970 if (WriteToFile(mb_string, (String)src->multi_src.string) == False) { 971 XtFree(mb_string); 972 return (False); 973 } 974 XtFree(mb_string); 975 #ifndef OLDXAW 976 src->text_src.changed = False; 977 #else 978 src->multi_src.changes = False; 979 #endif 980 return (True); 981 } 982 else { 983 /* If the buffer holds bad chars, don't touch it... */ 984 XtAppWarningMsg(app_con, 985 "convertError", "multiSource", "XawError", 986 "Due to illegal characters, file not saved.", 987 NULL, NULL); 988 return (False); 989 } 990 } 991 else { 992 /* THIS FUNCTIONALITY IS UNDOCUMENTED, probably UNNEEDED? The manual 993 says this routine's only function is to save files to 994 disk. -Sheeran */ 995 mb_string = StorePiecesInString(src); 996 997 if (mb_string == 0) { 998 /* If the buffer holds bad chars, don't touch it... */ 999 XtAppWarningMsg(app_con, 1000 "convertError", "multiSource", "XawError", 1001 XtName(XtParent((Widget)src)), NULL, NULL); 1002 return (False); 1003 } 1004 1005 /* assert: mb_string holds good characters so the buffer is fine */ 1006 if (src->multi_src.allocated_string == True) 1007 XtFree((char *)src->multi_src.string); 1008 else 1009 src->multi_src.allocated_string = True; 1010 1011 src->multi_src.string = mb_string; 1012 } 1013 #ifdef OLDXAW 1014 src->multi_src.changes = False; 1015 #else 1016 src->text_src.changed = False; 1017 #endif 1018 1019 return (True); 1020 } 1021 1022 /* 1023 * Function: 1024 * XawMultiSaveAsFile 1025 * 1026 * Parameters: 1027 * w - MultiSrc widget 1028 * name - name of the file to save this file into 1029 * 1030 * Description: 1031 * Save the current buffer as a file. 1032 * 1033 * Returns: 1034 * True if the save was successful 1035 * 1036 * Note: 1037 * The public interface is XawAsciiSaveAsFile! 1038 */ 1039 Bool 1040 _XawMultiSaveAsFile(Widget w, _Xconst char* name) 1041 { 1042 MultiSrcObject src = (MultiSrcObject)w; 1043 char *mb_string = StorePiecesInString(src); 1044 1045 if (mb_string != 0) { 1046 Bool ret = WriteToFile(mb_string, (String)name); 1047 XtFree(mb_string); 1048 1049 return (ret); 1050 } 1051 1052 /* otherwise there was a conversion error. So print widget name too */ 1053 XtAppWarningMsg(XtWidgetToApplicationContext(w), 1054 "convertError", "multiSource", "XawError", 1055 XtName(XtParent(w)), NULL, NULL); 1056 1057 return (False); 1058 } 1059 1060 /* 1061 * Private Functions 1062 */ 1063 static void 1064 RemoveOldStringOrFile(MultiSrcObject src, Bool checkString) 1065 { 1066 FreeAllPieces(src); 1067 1068 if (checkString && src->multi_src.allocated_string) { 1069 XtFree((char *)src->multi_src.string); 1070 src->multi_src.allocated_string = False; 1071 src->multi_src.string = NULL; 1072 } 1073 } 1074 1075 /* 1076 * Function: 1077 * WriteToFile 1078 * 1079 * Parameters: 1080 * string - string to write 1081 * name - name of the file 1082 * 1083 * Description: 1084 * Write the string specified to the beginning of the file specified. 1085 * 1086 * Returns: 1087 * Returns True if successful, False otherwise 1088 */ 1089 static Bool 1090 WriteToFile(String string, String name) 1091 { 1092 int fd; 1093 Bool result = True; 1094 1095 if ((fd = open(name, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0666)) == -1) 1096 return (False); 1097 1098 if (write(fd, string, strlen(string)) == -1) 1099 result = False; 1100 1101 if (close(fd) == -1) 1102 return (False); 1103 1104 return (result); 1105 } 1106 1107 1108 /* 1109 * Function: 1110 * StorePiecesInString 1111 * 1112 * Parameters: 1113 * src - the multiSrc object to gather data from 1114 * 1115 * Description: 1116 * Store the pieces in memory into a char string. 1117 * 1118 * Returns: 1119 * mb_string: Caller must free 1120 * (or) 1121 * NULL: conversion error 1122 */ 1123 static char * 1124 StorePiecesInString(MultiSrcObject src) 1125 { 1126 wchar_t *wc_string; 1127 char *mb_string; 1128 int char_count = (int)src->multi_src.length; 1129 XawTextPosition first; 1130 MultiPiece *piece; 1131 1132 /* I believe the char_count + 1 and the NULL termination are unneeded! FS */ 1133 wc_string = (wchar_t*)XtMalloc((Cardinal)((size_t)(char_count + 1) * sizeof(wchar_t))); 1134 1135 for (first = 0, piece = src->multi_src.first_piece ; piece != NULL; 1136 first += piece->used, piece = piece->next) 1137 (void)wcsncpy(wc_string + first, piece->text, (size_t)piece->used); 1138 1139 wc_string[char_count] = 0; 1140 1141 /* This will refill all pieces to capacity */ 1142 if (src->multi_src.data_compression) { 1143 FreeAllPieces(src); 1144 LoadPieces(src, NULL, (char *)wc_string); 1145 } 1146 1147 /* Lastly, convert it to a MB format and send it back */ 1148 mb_string = _XawTextWCToMB(XtDisplayOfObject((Widget)src), 1149 wc_string, &char_count); 1150 1151 /* NOTE THAT mb_string MAY BE ZERO IF THE CONVERSION FAILED */ 1152 XtFree((char*)wc_string); 1153 1154 return (mb_string); 1155 } 1156 1157 /* 1158 * Function: 1159 * InitStringOrFile 1160 * 1161 * Parameters: 1162 * src - MultiSource 1163 * 1164 * Description: 1165 * Initializes the string or file. 1166 */ 1167 static FILE * 1168 InitStringOrFile(MultiSrcObject src, Bool newString) 1169 { 1170 mode_t open_mode = 0; 1171 const char *fdopen_mode = NULL; 1172 int fd; 1173 FILE *file; 1174 Display *d = XtDisplayOfObject((Widget)src); 1175 1176 if (src->multi_src.type == XawAsciiString) { 1177 if (src->multi_src.string == NULL) 1178 src->multi_src.length = 0; 1179 1180 else if (!src->multi_src.use_string_in_place) { 1181 int length; 1182 char * temp = XtNewString((char *)src->multi_src.string); 1183 1184 if (src->multi_src.allocated_string) 1185 XtFree((char *)src->multi_src.string); 1186 src->multi_src.allocated_string = True; 1187 src->multi_src.string = temp; 1188 1189 length = (int)strlen((char *)src->multi_src.string); 1190 1191 /* Wasteful, throwing away the WC string, but need side effect! */ 1192 (void)_XawTextMBToWC(d, (char *)src->multi_src.string, &length); 1193 src->multi_src.length = (XawTextPosition)length; 1194 } 1195 else { 1196 src->multi_src.length = (XawTextPosition)strlen((char *)src->multi_src.string); 1197 /* In case the length resource is incorrectly set */ 1198 if (src->multi_src.length > src->multi_src.multi_length) 1199 src->multi_src.multi_length = (int)src->multi_src.length; 1200 1201 if (src->multi_src.multi_length == MAGIC_VALUE) 1202 src->multi_src.piece_size = src->multi_src.length; 1203 else 1204 src->multi_src.piece_size = src->multi_src.multi_length + 1; 1205 } 1206 1207 return (NULL); 1208 } 1209 1210 /* 1211 * type is XawAsciiFile 1212 */ 1213 src->multi_src.is_tempfile = False; 1214 1215 switch (src->text_src.edit_mode) { 1216 case XawtextRead: 1217 if (src->multi_src.string == NULL) 1218 XtErrorMsg("NoFile", "multiSourceCreate", "XawError", 1219 "Creating a read only disk widget and no file specified.", 1220 NULL, 0); 1221 open_mode = O_RDONLY | O_CLOEXEC; 1222 fdopen_mode = "r"; 1223 break; 1224 case XawtextAppend: 1225 case XawtextEdit: 1226 if (src->multi_src.string == NULL) { 1227 src->multi_src.string = (char *)"*multi-src*"; 1228 src->multi_src.is_tempfile = True; 1229 } 1230 else { 1231 /* O_NOFOLLOW was a FreeBSD & Linux extension, now adopted by POSIX */ 1232 #ifdef O_NOFOLLOW 1233 open_mode = O_RDWR | O_NOFOLLOW | O_CLOEXEC; 1234 #else 1235 open_mode = O_RDWR; /* unsafe; subject to race conditions */ 1236 #endif 1237 fdopen_mode = "r+"; 1238 } 1239 break; 1240 default: 1241 XtErrorMsg("badMode", "multiSourceCreate", "XawError", 1242 "Bad editMode for multi source; must be " 1243 "Read, Append or Edit.", NULL, NULL); 1244 } 1245 1246 /* If is_tempfile, allocate a private copy of the text 1247 * Unlikely to be changed, just to set allocated_string */ 1248 if (newString || src->multi_src.is_tempfile) { 1249 char * temp = XtNewString((char *)src->multi_src.string); 1250 1251 if (src->multi_src.allocated_string) 1252 XtFree((char *)src->multi_src.string); 1253 src->multi_src.string = temp; 1254 src->multi_src.allocated_string = True; 1255 } 1256 1257 if (!src->multi_src.is_tempfile) { 1258 if ((fd = open((char *)src->multi_src.string, (int)open_mode, 0666)) != -1) { 1259 if ((file = fdopen(fd, fdopen_mode)) != NULL) { 1260 (void)fseek(file, 0, SEEK_END); 1261 src->multi_src.length = (XawTextPosition)ftell(file); 1262 return(file); 1263 } 1264 else 1265 close(fd); 1266 } 1267 { 1268 String params[2]; 1269 Cardinal num_params = 2; 1270 1271 params[0] = (String)src->multi_src.string; 1272 params[1] = strerror(errno); 1273 XtAppWarningMsg(XtWidgetToApplicationContext((Widget)src), 1274 "openError", "multiSourceCreate", "XawWarning", 1275 "Cannot open file %s; %s", params, &num_params); 1276 } 1277 } 1278 src->multi_src.length = 0; 1279 return (NULL); 1280 } 1281 1282 /* LoadPieces: This routine takes either the MB contents of open file 1283 `file' or the MB contents of string or the MB contents of 1284 src->multi_src.string and places them in Pieces in WC format. 1285 1286 CAUTION: You must have src->multi_src.length set to file length bytes 1287 when src->multi_src.type == XawAsciiFile. src->multi_src.length must be 1288 the length of the parameter string if string is non-NULL 1289 */ 1290 static void 1291 LoadPieces(MultiSrcObject src, FILE *file, char *string) 1292 { 1293 Display *d = XtDisplayOfObject((Widget)src); 1294 wchar_t* local_str, *ptr; 1295 MultiPiece* piece = NULL; 1296 XawTextPosition left; 1297 int bytes = sizeof(wchar_t); 1298 char* temp_mb_holder = NULL; 1299 1300 /* 1301 * This is tricky - the _XawTextMBtoWC converter uses its 3rd arg 1302 * in as MB length, out as WC length. We want local_length to be 1303 * WC count. 1304 */ 1305 int local_length = (int)src->multi_src.length; 1306 1307 if (string != NULL) { 1308 /* 1309 * ASSERT: IF our caller passed a non-null string, THEN 1310 * src->multi_src.length is currently string's * byte count, 1311 * AND string is in a MB format 1312 */ 1313 local_str = _XawTextMBToWC(d, (char *)string, &local_length); 1314 src->multi_src.length = (XawTextPosition) local_length; 1315 } 1316 else if (src->multi_src.type != XawAsciiFile) { 1317 /* 1318 * here, we are not changing the contents, just reloading, 1319 * so don't change len... 1320 */ 1321 local_length = (int)(src->multi_src.string ? 1322 strlen((char *)src->multi_src.string) : 0); 1323 local_str = _XawTextMBToWC(d, (char *)src->multi_src.string, 1324 &local_length); 1325 } 1326 else { 1327 if (src->multi_src.length != 0) { 1328 temp_mb_holder = 1329 XtMalloc((Cardinal)((size_t)(src->multi_src.length + 1) * sizeof(unsigned char))); 1330 fseek(file, 0, SEEK_SET); 1331 src->multi_src.length = (XawTextPosition)fread(temp_mb_holder, 1332 sizeof(unsigned char), 1333 (size_t)src->multi_src.length, file); 1334 if (src->multi_src.length <= 0) 1335 XtAppErrorMsg(XtWidgetToApplicationContext ((Widget) src), 1336 "readError", "multiSource", "XawError", 1337 "fread returned error.", NULL, NULL); 1338 local_length = (int)src->multi_src.length; 1339 local_str = _XawTextMBToWC(d, temp_mb_holder, &local_length); 1340 src->multi_src.length = local_length; 1341 1342 if (local_str == 0) { 1343 String params[2]; 1344 Cardinal num_params; 1345 static char err_text[] = 1346 "<<< FILE CONTENTS NOT REPRESENTABLE IN THIS LOCALE >>>"; 1347 1348 params[0] = XtName(XtParent((Widget)src)); 1349 params[1] = src->multi_src.string; 1350 num_params = 2; 1351 1352 XtAppWarningMsg(XtWidgetToApplicationContext((Widget)src), 1353 "readLocaleError", "multiSource", "XawError", 1354 "%s: The file `%s' contains characters " 1355 "not representable in this locale.", 1356 params, &num_params); 1357 src->multi_src.length = sizeof err_text; 1358 local_length = (int)src->multi_src.length; 1359 local_str = _XawTextMBToWC(d, err_text, &local_length); 1360 src->multi_src.length = local_length; 1361 } 1362 } 1363 else 1364 /* ASSERT that since following while loop looks at local_length 1365 this isn't needed. Sheeran, Omron KK, 1993/07/15 1366 temp_mb_holder[src->multi_src.length] = '\0'; */ 1367 local_str = (wchar_t*)temp_mb_holder; 1368 } 1369 1370 if (src->multi_src.use_string_in_place) { 1371 piece = AllocNewPiece(src, piece); 1372 piece->used = Min(src->multi_src.length, src->multi_src.piece_size); 1373 piece->text = (wchar_t*)src->multi_src.string; 1374 return; 1375 } 1376 1377 ptr = local_str; 1378 left = local_length; 1379 1380 do { 1381 piece = AllocNewPiece(src, piece); 1382 1383 piece->text = (wchar_t*)XtMalloc((unsigned)(src->multi_src.piece_size 1384 * bytes)); 1385 piece->used = Min(left, src->multi_src.piece_size); 1386 if (piece->used != 0) 1387 (void)wcsncpy(piece->text, ptr, (size_t)piece->used); 1388 1389 left -= piece->used; 1390 ptr += piece->used; 1391 } while (left > 0); 1392 1393 if (temp_mb_holder) 1394 XtFree((char*)temp_mb_holder); 1395 } 1396 1397 /* 1398 * Function: 1399 * AllocNewPiece 1400 * 1401 * Parameters: 1402 * src - MultiSrc Widget 1403 * prev - the piece just before this one, or NULL 1404 * 1405 * Description: 1406 * Allocates a new piece of memory. 1407 * 1408 * Returns: 1409 * The allocated piece 1410 */ 1411 static MultiPiece * 1412 AllocNewPiece(MultiSrcObject src, MultiPiece *prev) 1413 { 1414 MultiPiece *piece = XtNew(MultiPiece); 1415 1416 if (prev == NULL) { 1417 src->multi_src.first_piece = piece; 1418 piece->next = NULL; 1419 } 1420 else { 1421 if (prev->next != NULL) 1422 (prev->next)->prev = piece; 1423 piece->next = prev->next; 1424 prev->next = piece; 1425 } 1426 1427 piece->prev = prev; 1428 1429 return (piece); 1430 } 1431 1432 /* 1433 * Function: 1434 * FreeAllPieces 1435 * 1436 * Parameters: 1437 * src - MultiSrc Widget 1438 * 1439 * Description: 1440 * Frees all the pieces 1441 */ 1442 static void 1443 FreeAllPieces(MultiSrcObject src) 1444 { 1445 MultiPiece *next, *first = src->multi_src.first_piece; 1446 1447 #ifdef DEBUG 1448 if (first->prev != NULL) 1449 printf("Xaw MultiSrc Object: possible memory leak in FreeAllPieces().\n"); 1450 #endif 1451 1452 for (; first != NULL ; first = next) { 1453 next = first->next; 1454 RemovePiece(src, first); 1455 } 1456 } 1457 1458 /* 1459 * Function: 1460 * RemovePiece 1461 * 1462 * Parameters: 1463 * piece - piece to remove 1464 * 1465 * Description: 1466 * Removes a piece from the list. 1467 */ 1468 static void 1469 RemovePiece(MultiSrcObject src, MultiPiece *piece) 1470 { 1471 if (piece->prev == NULL) 1472 src->multi_src.first_piece = piece->next; 1473 else 1474 piece->prev->next = piece->next; 1475 1476 if (piece->next != NULL) 1477 piece->next->prev = piece->prev; 1478 1479 if (!src->multi_src.use_string_in_place) 1480 XtFree((char *)piece->text); 1481 1482 XtFree((char *)piece); 1483 } 1484 1485 /* 1486 * Function: 1487 * FindPiece 1488 * 1489 * Parameters: 1490 * src - MultiSrc Widget 1491 * position - position that we are searching for 1492 * first - position of the first character in this piece (return) 1493 * 1494 * Description: 1495 * Finds the piece containing the position indicated. 1496 * 1497 * Returns: 1498 * Piece that contains this position 1499 */ 1500 static MultiPiece * 1501 FindPiece(MultiSrcObject src, XawTextPosition position, XawTextPosition *first) 1502 { 1503 MultiPiece *old_piece, *piece; 1504 XawTextPosition temp; 1505 1506 for (old_piece = NULL, piece = src->multi_src.first_piece, temp = 0; 1507 piece; old_piece = piece, piece = piece->next) 1508 if ((temp += piece->used) > position) { 1509 *first = temp - piece->used; 1510 return (piece); 1511 } 1512 1513 *first = temp - (old_piece ? old_piece->used : 0); 1514 1515 return (old_piece); /* if we run off the end the return the last piece */ 1516 } 1517 1518 /* 1519 * Function: 1520 * BreakPiece 1521 * 1522 * Parameters: 1523 * src - MultiSrc Widget 1524 * piece - piece to break 1525 * 1526 * Description: 1527 * Breaks a full piece into two new pieces. 1528 */ 1529 #define HALF_PIECE (src->multi_src.piece_size >> 1) 1530 static void 1531 BreakPiece(MultiSrcObject src, MultiPiece *piece) 1532 { 1533 MultiPiece *cnew = AllocNewPiece(src, piece); 1534 1535 cnew->text = (wchar_t *) 1536 XtMalloc((Cardinal)((size_t)src->multi_src.piece_size * sizeof(wchar_t))); 1537 (void)wcsncpy(cnew->text, piece->text + HALF_PIECE, 1538 (size_t)(src->multi_src.piece_size - HALF_PIECE)); 1539 piece->used = HALF_PIECE; 1540 cnew->used = src->multi_src.piece_size - HALF_PIECE; 1541 } 1542 1543 /*ARGSUSED*/ 1544 static void 1545 CvtStringToMultiType(XrmValuePtr args _X_UNUSED, Cardinal *num_args _X_UNUSED, 1546 XrmValuePtr fromVal, XrmValuePtr toVal) 1547 { 1548 static XawAsciiType type = XawAsciiString; 1549 XrmQuark q; 1550 char name[7]; 1551 1552 XmuNCopyISOLatin1Lowered(name, (char *)fromVal->addr, sizeof(name)); 1553 q = XrmStringToQuark(name); 1554 1555 if (q == Qstring) 1556 type = XawAsciiString; 1557 if (q == Qfile) 1558 type = XawAsciiFile; 1559 else { 1560 toVal->size = 0; 1561 toVal->addr = NULL; 1562 XtStringConversionWarning((char *)fromVal->addr, XtRAsciiType); 1563 } 1564 1565 toVal->size = sizeof(XawAsciiType); 1566 toVal->addr = (XPointer)&type; 1567 } 1568 1569 /*ARGSUSED*/ 1570 static Boolean 1571 CvtMultiTypeToString(Display *dpy, XrmValuePtr args _X_UNUSED, Cardinal *num_args _X_UNUSED, 1572 XrmValuePtr fromVal, XrmValuePtr toVal, 1573 XtPointer *data _X_UNUSED) 1574 { 1575 static String buffer; 1576 Cardinal size; 1577 1578 switch (*(XawAsciiType *)fromVal->addr) { 1579 case XawAsciiFile: 1580 buffer = XtEfile; 1581 break; 1582 case XawAsciiString: 1583 buffer = XtEstring; 1584 break; 1585 default: 1586 XawTypeToStringWarning(dpy, XtRAsciiType); 1587 toVal->addr = NULL; 1588 toVal->size = 0; 1589 return (False); 1590 } 1591 1592 size = (Cardinal)strlen(buffer) + 1; 1593 if (toVal->addr != NULL) { 1594 if (toVal->size < size) { 1595 toVal->size = size; 1596 return (False); 1597 } 1598 strcpy((char *)toVal->addr, buffer); 1599 } 1600 else 1601 toVal->addr = (XPointer)buffer; 1602 toVal->size = sizeof(String); 1603 1604 return (True); 1605 } 1606 1607 /*ARGSUSED*/ 1608 static void 1609 GetDefaultPieceSize(Widget w _X_UNUSED, int offset _X_UNUSED, XrmValue *value) 1610 { 1611 static XPointer pagesize; 1612 1613 if (pagesize == 0) { 1614 pagesize = (XPointer)((long)_XawGetPageSize()); 1615 if (pagesize < (XPointer)BUFSIZ) 1616 pagesize = (XPointer)BUFSIZ; 1617 } 1618 1619 value->addr = (XPointer)&pagesize; 1620 } 1621
Indexes created Fri Jul 03 00:25:33 UTC 2026