← Back to branch summary

~ubuntu-branches/ubuntu/quantal/openmotif/quantal

« back to all changes in this revision

Viewing changes to lib/Xm/TextFunc.c

  • Committer: Bazaar Package Importer
  • Author(s): Stefan Bauer
  • Date: 2010-06-23 12:12:31 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100623121231-u89gxdp51sg9wjj2
Tags: 2.3.0-1
http://bugs.debian.org/379258
http://bugs.debian.org/494375
http://bugs.debian.org/288537
* New Maintainer (Closes: #379258) 
* Acknowledge NMU changes
* New upstream release (Closes: #494375)
* Get rid of security patches as they are already part of new upstream
  release (00-xpmvuln.openmotif.patch, 342092-CVE-2005-3964.patch)
* Bump Standards to 3.8.4
* Added {misc:Depends} to make the package lintian cleaner
* Fix weak-library-dev-dependency by adding ${binary:Version}) for the
  -dev Package of openmotif
* Let package depend on autotools-dev to use newer autotools-helper-files
* Work around an autoconf-bug (Gentoo-Bug #1475)
* Added Client-side anti-aliased fonts support via XFT
* Added UTF-8 and UTF8_STRING atom support
* Ability to show text and pixmaps in Label, LabelGadget and all
  derived widgets
* Support of PNG/JPEG image formats in the same way as XPM is supported
* Increase FILE_OFFSET_BITS to 64 to show files >2GB in file-selector
  Idea taken from Magne Oestlyngen (Closes: #288537)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Xm/TextFunc.c
 
1
/* $XConsortium: TextFunc.c /main/16 1996/11/19 12:37:29 drk $ */
 
2
/*
 
3
 * @OPENGROUP_COPYRIGHT@
 
4
 * COPYRIGHT NOTICE
 
5
 * Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
 
6
 * Copyright (c) 1996, 1997, 1998, 1999, 2000 The Open Group
 
7
 * ALL RIGHTS RESERVED (MOTIF).  See the file named COPYRIGHT.MOTIF for
 
8
 * the full copyright text.
 
9
 * 
 
10
 * This software is subject to an open license. It may only be
 
11
 * used on, with or for operating systems which are themselves open
 
12
 * source systems. You must contact The Open Group for a license
 
13
 * allowing distribution and sublicensing of this software on, with,
 
14
 * or for operating systems which are not Open Source programs.
 
15
 * 
 
16
 * See http://www.opengroup.org/openmotif/license for full
 
17
 * details of the license agreement. Any use, reproduction, or
 
18
 * distribution of the program constitutes recipient's acceptance of
 
19
 * this agreement.
 
20
 * 
 
21
 * EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
 
22
 * PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 
23
 * KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
 
24
 * WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
 
25
 * OR FITNESS FOR A PARTICULAR PURPOSE
 
26
 * 
 
27
 * EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
 
28
 * NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT,
 
29
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
30
 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED
 
31
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
32
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 
33
 * ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
 
34
 * EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
 
35
 * POSSIBILITY OF SUCH DAMAGES.
 
36
 * 
 
37
 */
 
38
/*
 
39
 *  (c) Copyright 1995 FUJITSU LIMITED
 
40
 *  This is source code modified by FUJITSU LIMITED under the Joint
 
41
 *  Development Agreement for the CDEnext PST.
 
42
 *  This is unpublished proprietary source code of FUJITSU LIMITED
 
43
 */
 
44
 
 
45
#ifdef HAVE_CONFIG_H
 
46
#include <config.h>
 
47
#endif
 
48
 
 
49
 
 
50
#include <Xm/XmosP.h>
 
51
#include <Xm/TextStrSoP.h>
 
52
#include "XmI.h"
 
53
#include "TextFI.h"
 
54
#include "TextI.h"
 
55
#include "TextInI.h"
 
56
#include "TextStrSoI.h"
 
57
 
 
58
/****************************************************************
 
59
 *
 
60
 * Public definitions with TextField calls.
 
61
 *
 
62
 ****************************************************************/
 
63
 
 
64
XmTextPosition 
 
65
XmTextGetLastPosition(Widget widget)
 
66
{
 
67
  XmTextPosition ret_val;
 
68
  _XmWidgetToAppContext(widget);
 
69
 
 
70
  _XmAppLock(app);
 
71
  if (XmIsTextField(widget)){
 
72
    XmTextFieldWidget tf = (XmTextFieldWidget) widget;
 
73
 
 
74
    ret_val = tf->text.string_length;
 
75
  } else {
 
76
    XmTextSource source;
 
77
 
 
78
    source = GetSrc(widget);
 
79
    ret_val = (*source->Scan)(source, 0, XmSELECT_ALL, XmsdRight, 1, TRUE);
 
80
  }
 
81
  _XmAppUnlock(app);
 
82
  return ret_val;
 
83
}
 
84
 
 
85
void
 
86
_XmTextReplace(Widget widget,
 
87
               XmTextPosition frompos,
 
88
               XmTextPosition topos,
 
89
               char *value, 
 
90
#if NeedWidePrototypes
 
91
               int is_wchar)
 
92
#else
 
93
               Boolean is_wchar)
 
94
#endif /* NeedWidePrototypes */
 
95
{
 
96
  XmTextWidget tw = (XmTextWidget) widget;
 
97
  XmTextSource source;
 
98
  XmTextBlockRec block, newblock;
 
99
  Boolean editable, freeBlock;
 
100
  Boolean need_free = False;
 
101
  int max_length;
 
102
  int num_chars;
 
103
  wchar_t * tmp_wc;
 
104
  XmTextPosition selleft, selright, cursorPos;
 
105
  char * tmp_block = NULL;
 
106
  
 
107
  source = GetSrc(tw);
 
108
  
 
109
  (*tw->text.output->DrawInsertionPoint)(tw, tw->text.cursor_position, off);
 
110
  
 
111
  if ((*source->GetSelection)(tw->text.source, &selleft, &selright)) {
 
112
    if ((selleft > frompos && selleft < topos)  || 
 
113
        (selright >frompos && selright < topos) ||
 
114
        (selleft <= frompos && selright >= topos)) {
 
115
      (*source->SetSelection)(tw->text.source, tw->text.cursor_position,
 
116
                              tw->text.cursor_position,
 
117
                              XtLastTimestampProcessed(XtDisplay(widget)));
 
118
      if (tw->text.input->data->pendingdelete)
 
119
        tw->text.pendingoff = FALSE;
 
120
    }
 
121
  }
 
122
 
 
123
  block.format = XmFMT_8_BIT;
 
124
  if (!is_wchar) {
 
125
    if (value == NULL)
 
126
      block.length = 0;
 
127
    else
 
128
      block.length = strlen(value);
 
129
    block.ptr = value;
 
130
  } else { /* value is really a wchar_t ptr cast to char* */
 
131
    if (value == NULL) {
 
132
      block.length = 0;
 
133
    } else {
 
134
      for (tmp_wc = (wchar_t*)value, num_chars = 0; 
 
135
           *tmp_wc != (wchar_t)0L; 
 
136
           num_chars++) tmp_wc++;
 
137
      tmp_block = XtMalloc((unsigned) 
 
138
                           (num_chars + 1) * (int)tw->text.char_size);
 
139
      block.ptr = tmp_block;
 
140
      need_free = True;
 
141
      tmp_wc = (wchar_t *) value;
 
142
      /* if successful, wcstombs returns number of bytes, else -1 */
 
143
      block.length = wcstombs(block.ptr, tmp_wc, 
 
144
                              (num_chars + 1) * (int)tw->text.char_size);
 
145
      if (block.length == -1) {
 
146
        block.length = 0; /* if error, don't insert anything */
 
147
        block.ptr[0] = '\0'; /* use the empty string */
 
148
      }
 
149
    }
 
150
  }
 
151
  editable = _XmStringSourceGetEditable(source);
 
152
  max_length = _XmStringSourceGetMaxLength(source);
 
153
  
 
154
  _XmStringSourceSetEditable(source, TRUE);
 
155
  _XmStringSourceSetMaxLength(source, INT_MAX);
 
156
  if (_XmTextModifyVerify(tw, NULL, &frompos, &topos,
 
157
                          &cursorPos, &block, &newblock, &freeBlock)) {
 
158
    (*source->Replace)(tw, NULL, &frompos, &topos, &newblock, False);
 
159
    if (frompos == tw->text.cursor_position && frompos == topos) {
 
160
      _XmTextSetCursorPosition((Widget)tw, cursorPos);
 
161
    }
 
162
    _XmTextValueChanged(tw, NULL);
 
163
    if (UnderVerifyPreedit(tw))
 
164
      if (newblock.length != block.length ||
 
165
        strncmp(newblock.ptr, block.ptr, block.length) != 0) { 
 
166
        VerifyCommitNeeded(tw) = True;  
 
167
        PreEndTW(tw) += _XmTextCountCharacters(newblock.ptr, newblock.length)
 
168
                        - _XmTextCountCharacters(block.ptr, block.length);
 
169
      }
 
170
      
 
171
    if (freeBlock && newblock.ptr) XtFree(newblock.ptr);
 
172
  }
 
173
  else 
 
174
    if (UnderVerifyPreedit(tw)) {
 
175
      VerifyCommitNeeded(tw) = True;
 
176
      PreEndTW(tw) -= _XmTextCountCharacters(block.ptr, block.length);
 
177
    }
 
178
 
 
179
  if (need_free)
 
180
    XtFree(tmp_block); 
 
181
  _XmStringSourceSetEditable(source, editable);
 
182
  _XmStringSourceSetMaxLength(source, max_length);
 
183
  
 
184
  if (tw->text.input->data->has_destination)
 
185
    _XmTextSetDestinationSelection(widget, tw->text.cursor_position,
 
186
                           False, XtLastTimestampProcessed(XtDisplay(widget)));
 
187
  (*tw->text.output->DrawInsertionPoint)(tw, tw->text.cursor_position, on);
 
188
 
 
189
}
 
190
 
 
191
void
 
192
XmTextReplace(Widget widget,
 
193
              XmTextPosition frompos,
 
194
              XmTextPosition topos,
 
195
              char *value)
 
196
{
 
197
  if (XmIsTextField(widget))
 
198
    XmTextFieldReplace(widget, frompos, topos, value);
 
199
  else {
 
200
    _XmWidgetToAppContext(widget);
 
201
 
 
202
    _XmAppLock(app);
 
203
    _XmTextReplace(widget, frompos, topos, value, False);
 
204
    _XmAppUnlock(app);
 
205
  }
 
206
}
 
207
   
 
208
void
 
209
XmTextReplaceWcs(Widget widget,
 
210
                 XmTextPosition frompos,
 
211
                 XmTextPosition topos,
 
212
                 wchar_t *value)
 
213
{
 
214
  if (XmIsTextField(widget))
 
215
    XmTextFieldReplaceWcs(widget, frompos, topos, (wchar_t*) value);
 
216
  else {
 
217
    _XmWidgetToAppContext(widget);
 
218
 
 
219
    _XmAppLock(app);
 
220
    _XmTextReplace(widget, frompos, topos, (char*) value, True);
 
221
    _XmAppUnlock(app);
 
222
  }
 
223
}
 
224
 
 
225
void 
 
226
XmTextInsert(Widget widget,
 
227
             XmTextPosition position,
 
228
             char *value)
 
229
{
 
230
  XmTextReplace(widget, position, position, value);
 
231
}
 
232
 
 
233
   
 
234
void
 
235
XmTextInsertWcs(Widget widget,
 
236
                XmTextPosition position,
 
237
                wchar_t *wc_value)
 
238
{
 
239
  XmTextReplaceWcs(widget, position, position, wc_value);
 
240
}
 
241
 
 
242
 
 
243
void 
 
244
XmTextSetAddMode(Widget widget,
 
245
#if NeedWidePrototypes
 
246
                 int state)
 
247
#else
 
248
                 Boolean state)
 
249
#endif /* NeedWidePrototypes */
 
250
{
 
251
  if (XmIsTextField(widget))
 
252
    XmTextFieldSetAddMode(widget, state);
 
253
  else {
 
254
    XmTextWidget tw = (XmTextWidget) widget;
 
255
    _XmWidgetToAppContext(widget);
 
256
 
 
257
    _XmAppLock(app);
 
258
    if (tw->text.add_mode == state) {
 
259
        _XmAppUnlock(app);
 
260
        return;
 
261
    }
 
262
 
 
263
    (*tw->text.output->DrawInsertionPoint)(tw, tw->text.cursor_position, off);
 
264
    tw->text.add_mode = state;
 
265
    (*tw->text.output->DrawInsertionPoint)(tw, tw->text.cursor_position, on);
 
266
    _XmAppUnlock(app);
 
267
  }
 
268
}
 
269
 
 
270
Boolean 
 
271
XmTextGetAddMode(Widget widget)
 
272
{
 
273
  Boolean ret_val;
 
274
  _XmWidgetToAppContext(widget);
 
275
 
 
276
  _XmAppLock(app);
 
277
  if (XmIsTextField(widget)){
 
278
    XmTextFieldWidget tf = (XmTextFieldWidget) widget;
 
279
    ret_val = tf->text.add_mode;
 
280
  } else {
 
281
    XmTextWidget tw = (XmTextWidget) widget;
 
282
    ret_val = tw->text.add_mode;
 
283
  }
 
284
  _XmAppUnlock(app);
 
285
  return ret_val;
 
286
}
 
287
 
 
288
Boolean 
 
289
XmTextGetEditable(Widget widget)
 
290
{
 
291
  Boolean ret_val;
 
292
  _XmWidgetToAppContext(widget);
 
293
 
 
294
  _XmAppLock(app);
 
295
  if (XmIsTextField(widget))
 
296
    ret_val = TextF_Editable(widget);
 
297
  else
 
298
    ret_val = _XmStringSourceGetEditable(GetSrc(widget));
 
299
 
 
300
  _XmAppUnlock(app);
 
301
  return ret_val;
 
302
}
 
303
 
 
304
void 
 
305
XmTextSetEditable(Widget widget,
 
306
#if NeedWidePrototypes
 
307
                  int editable)
 
308
#else
 
309
                  Boolean editable)
 
310
#endif /* NeedWidePrototypes */
 
311
{
 
312
  if (XmIsTextField(widget))
 
313
    XmTextFieldSetEditable(widget, editable);
 
314
  else {
 
315
    _XmWidgetToAppContext(widget);
 
316
 
 
317
    _XmAppLock(app);
 
318
    _XmTextSetEditable(widget, editable);
 
319
    _XmAppUnlock(app);
 
320
  }
 
321
}
 
322
 
 
323
int 
 
324
XmTextGetMaxLength(Widget widget)
 
325
{
 
326
  int ret_val;
 
327
  _XmWidgetToAppContext(widget);
 
328
 
 
329
  _XmAppLock(app);
 
330
  if (XmIsTextField(widget))
 
331
    ret_val = TextF_MaxLength(widget);
 
332
  else
 
333
    ret_val = _XmStringSourceGetMaxLength(GetSrc(widget));
 
334
 
 
335
  _XmAppUnlock(app);
 
336
  return ret_val;
 
337
}
 
338
 
 
339
void 
 
340
XmTextSetMaxLength(Widget widget,
 
341
                   int max_length)
 
342
{
 
343
  _XmWidgetToAppContext(widget);
 
344
 
 
345
  _XmAppLock(app);
 
346
  if (XmIsTextField(widget))
 
347
    TextF_MaxLength(widget) = max_length;
 
348
  else {
 
349
    XmTextWidget tw = (XmTextWidget) widget;
 
350
    
 
351
    tw->text.max_length = max_length;
 
352
    _XmStringSourceSetMaxLength(GetSrc(tw), max_length);
 
353
  }
 
354
  _XmAppUnlock(app);
 
355
}
 
356
 
 
357
 
 
358
XmTextPosition 
 
359
XmTextGetInsertionPosition(Widget widget)
 
360
{
 
361
  XmTextPosition ret_val;
 
362
  _XmWidgetToAppContext(widget);
 
363
 
 
364
  _XmAppLock(app);
 
365
  if (XmIsTextField(widget))
 
366
    ret_val = TextF_CursorPosition(widget);
 
367
  else {
 
368
    XmTextWidget tw = (XmTextWidget) widget;
 
369
    
 
370
    ret_val = tw->text.cursor_position;
 
371
  }
 
372
  _XmAppUnlock(app);
 
373
  return ret_val;
 
374
}
 
375
 
 
376
void 
 
377
XmTextSetInsertionPosition(Widget widget,
 
378
                           XmTextPosition position)
 
379
{
 
380
  XmTextWidget tw = (XmTextWidget) widget;
 
381
  
 
382
  if (XmIsTextField(widget))
 
383
    XmTextFieldSetInsertionPosition(widget, position);
 
384
  else {
 
385
    _XmWidgetToAppContext(widget);
 
386
 
 
387
    _XmAppLock(app);
 
388
    _XmTextResetIC(widget);
 
389
    _XmTextSetCursorPosition(widget, position);
 
390
    
 
391
    _XmTextSetDestinationSelection(widget, tw->text.cursor_position,
 
392
                False, XtLastTimestampProcessed(XtDisplay(widget)));
 
393
    _XmAppUnlock(app);
 
394
  }
 
395
}
 
396
 
 
397
 
 
398
Boolean 
 
399
XmTextRemove(Widget widget)
 
400
{
 
401
  if (XmIsTextField(widget))
 
402
    return(XmTextFieldRemove(widget));
 
403
  else {
 
404
    XmTextWidget tw = (XmTextWidget) widget;
 
405
    XmTextSource source;
 
406
    XmTextPosition left, right;
 
407
    _XmWidgetToAppContext(widget);
 
408
 
 
409
    _XmAppLock(app);
 
410
    if (tw->text.editable == False) {
 
411
      _XmAppUnlock(app);
 
412
      return False; 
 
413
    }
 
414
 
 
415
    source = tw->text.source;
 
416
    _XmTextResetIC(widget);
 
417
    if (!(*source->GetSelection)(source, &left, &right) ||
 
418
        left == right) {
 
419
      tw->text.input->data->anchor = tw->text.cursor_position;
 
420
      _XmAppUnlock(app);
 
421
      return False;
 
422
    }
 
423
 
 
424
    XmTextReplace(widget, left, right, NULL);
 
425
 
 
426
    if (tw->text.cursor_position > left)
 
427
      _XmTextSetCursorPosition(widget, left);
 
428
 
 
429
    tw->text.input->data->anchor = tw->text.cursor_position;
 
430
 
 
431
    _XmAppUnlock(app);
 
432
    return True;
 
433
  }
 
434
}
 
435
 
 
436
Boolean 
 
437
XmTextCopy(Widget widget,
 
438
           Time copy_time)
 
439
{
 
440
  Boolean result = False;
 
441
  XmTextPosition left, right;
 
442
  _XmWidgetToAppContext(widget);
 
443
 
 
444
  _XmAppLock(app);
 
445
  if (XmTextGetSelectionPosition(widget, &left, &right) && right != left)
 
446
    /* start copy to clipboard */
 
447
    result = XmeClipboardSource(widget, XmCOPY, copy_time);
 
448
  _XmAppUnlock(app);
 
449
 
 
450
  return result;
 
451
}
 
452
 
 
453
Boolean 
 
454
XmTextCopyLink(Widget widget,
 
455
               Time copy_time)
 
456
{
 
457
  Boolean result = False;
 
458
  XmTextPosition left, right;
 
459
  _XmWidgetToAppContext(widget);
 
460
 
 
461
  _XmAppLock(app);
 
462
  if (XmTextGetSelectionPosition(widget, &left, &right) && right != left)
 
463
    /* start copy to clipboard */
 
464
    result = XmeClipboardSource(widget, XmLINK, copy_time);
 
465
  _XmAppUnlock(app);
 
466
 
 
467
  return result;
 
468
}
 
469
 
 
470
Boolean 
 
471
XmTextCut(Widget widget,
 
472
          Time cut_time)
 
473
{
 
474
  Boolean result = False;
 
475
  XmTextPosition left, right;
 
476
  _XmWidgetToAppContext(widget);
 
477
 
 
478
  _XmAppLock(app);
 
479
  /* can't cut if you can't edit */
 
480
  if (XmTextGetEditable(widget) &&
 
481
      XmTextGetSelectionPosition(widget, &left, &right) && 
 
482
      (right != left))
 
483
    /* start copy to clipboard */
 
484
    result = XmeClipboardSource(widget, XmMOVE, cut_time);
 
485
  _XmAppUnlock(app);
 
486
 
 
487
  return result;
 
488
}
 
489
 
 
490
 
 
491
/*
 
492
 * Retrieves the current data from the clipboard
 
493
 * and paste it at the current cursor position
 
494
 */
 
495
Boolean 
 
496
XmTextPaste(Widget widget)
 
497
{
 
498
  Boolean status;
 
499
  InputData data;
 
500
  _XmWidgetToAppContext(widget);
 
501
 
 
502
  _XmAppLock(app);
 
503
  _XmTextResetIC(widget);
 
504
  data = ((XmTextWidget) widget)->text.input->data;
 
505
  
 
506
  data->selectionMove = FALSE;
 
507
  data->selectionLink = FALSE;
 
508
  status = XmeClipboardSink(widget, XmCOPY, NULL);
 
509
  _XmAppUnlock(app); 
 
510
  return(status);
 
511
}
 
512
 
 
513
/*
 
514
 * Retrieves the current data from the clipboard
 
515
 * and paste it at the current cursor position
 
516
 */
 
517
Boolean 
 
518
XmTextPasteLink(Widget widget)
 
519
{
 
520
  Boolean status;
 
521
  
 
522
  InputData data;
 
523
  _XmWidgetToAppContext(widget);
 
524
 
 
525
  _XmAppLock(app);
 
526
  data = ((XmTextWidget) widget)->text.input->data;
 
527
  
 
528
  data->selectionMove = FALSE;
 
529
  data->selectionLink = True;
 
530
  status = XmeClipboardSink(widget, XmLINK, NULL);
 
531
  _XmAppUnlock(app); 
 
532
  return(status);
 
533
}
 
534
 
 
535
char * 
 
536
XmTextGetSelection(Widget widget)
 
537
{
 
538
  if (XmIsTextField(widget))
 
539
    return(XmTextFieldGetSelection(widget));
 
540
  else {
 
541
    XmTextSource source;
 
542
    XmTextPosition left, right;
 
543
    char *ret_val;
 
544
    _XmWidgetToAppContext(widget);
 
545
    
 
546
    _XmAppLock(app);
 
547
    source = GetSrc(widget);
 
548
    if ((!(*source->GetSelection)(source, &left, &right)) || right == left)
 
549
    {
 
550
        _XmAppUnlock(app);
 
551
        return NULL;
 
552
    }
 
553
 
 
554
    ret_val = _XmStringSourceGetString((XmTextWidget)widget, left, 
 
555
                                    right, False);
 
556
    _XmAppUnlock(app);
 
557
    return ret_val;
 
558
  }
 
559
}
 
560
 
 
561
wchar_t *
 
562
XmTextGetSelectionWcs(Widget widget)
 
563
{
 
564
  if (XmIsTextField(widget))
 
565
    return(XmTextFieldGetSelectionWcs(widget)); 
 
566
  else {
 
567
    XmTextSource source;
 
568
    XmTextPosition left, right;
 
569
    wchar_t *ret_val;
 
570
    _XmWidgetToAppContext(widget);
 
571
 
 
572
    _XmAppLock(app);
 
573
    source = GetSrc(widget);
 
574
    if (!(*source->GetSelection)(source, &left, &right)) {
 
575
      _XmAppUnlock(app);
 
576
      return NULL;
 
577
    }
 
578
 
 
579
    ret_val = (wchar_t *)_XmStringSourceGetString((XmTextWidget)widget,
 
580
                left, right, True);
 
581
    _XmAppUnlock(app); 
 
582
    return ret_val;
 
583
  }
 
584
}
 
585
 
 
586
 
 
587
 
 
588
void 
 
589
XmTextSetSelection(Widget widget,
 
590
                   XmTextPosition first,
 
591
                   XmTextPosition last,
 
592
                   Time set_time)
 
593
{
 
594
  if (XmIsTextField(widget))
 
595
    XmTextFieldSetSelection(widget, first, last, set_time);
 
596
  else {
 
597
    XmTextSource source;
 
598
    XmTextWidget tw = (XmTextWidget) widget;
 
599
    _XmWidgetToAppContext(widget);
 
600
 
 
601
    _XmAppLock(app);
 
602
    _XmTextResetIC(widget);
 
603
    if (first < 0 || last > tw->text.last_position) {
 
604
        _XmAppUnlock(app);
 
605
        return;
 
606
    }
 
607
    
 
608
    source = GetSrc(widget);
 
609
    source->data->take_selection = True;
 
610
    (*source->SetSelection)(source, first, last, set_time);
 
611
    tw->text.pendingoff = FALSE;
 
612
    _XmTextSetCursorPosition(widget, last);
 
613
    _XmTextSetDestinationSelection(widget, tw->text.cursor_position, False,
 
614
                                   set_time);
 
615
    _XmAppUnlock(app);
 
616
  }
 
617
}
 
618
 
 
619
void 
 
620
XmTextClearSelection(Widget widget,
 
621
                     Time clear_time)
 
622
{
 
623
  if (XmIsTextField(widget))
 
624
    XmTextFieldClearSelection(widget, clear_time);
 
625
  else {
 
626
    XmTextWidget tw = (XmTextWidget) widget;
 
627
    XmTextSource source = GetSrc(widget);
 
628
    _XmWidgetToAppContext(widget);
 
629
 
 
630
    _XmAppLock(app);
 
631
    (*source->SetSelection)(source, 1, -999, source->data->prim_time);
 
632
    if (tw->text.input->data->pendingdelete) {
 
633
      tw->text.pendingoff = FALSE;
 
634
    }
 
635
    _XmAppUnlock(app);
 
636
  }
 
637
}
 
638
 
 
639
Boolean 
 
640
XmTextGetSelectionPosition(Widget widget,
 
641
                           XmTextPosition *left,
 
642
                           XmTextPosition *right)
 
643
{
 
644
  Boolean ret_val;
 
645
  _XmWidgetToAppContext(widget);
 
646
 
 
647
  _XmAppLock(app);
 
648
  if (XmIsTextField(widget)) {
 
649
    XmTextFieldWidget tf = (XmTextFieldWidget) widget;
 
650
    
 
651
    if (!tf->text.has_primary) {
 
652
      ret_val = False;
 
653
    } else {
 
654
      *left = tf->text.prim_pos_left;
 
655
      *right = tf->text.prim_pos_right;
 
656
      ret_val = True;
 
657
    }
 
658
  } else {
 
659
    XmTextWidget tw = (XmTextWidget) widget;
 
660
    ret_val = (*tw->text.source->GetSelection)(tw->text.source, left, right);
 
661
  }
 
662
  _XmAppUnlock(app);
 
663
 
 
664
  return ret_val;
 
665
}
 
666
 
 
667
XmTextPosition 
 
668
XmTextXYToPos(Widget widget,
 
669
#if NeedWidePrototypes
 
670
              int x,
 
671
              int y)
 
672
#else
 
673
              Position x,
 
674
              Position y)
 
675
#endif /* NeedWidePrototypes */
 
676
{
 
677
  if (XmIsTextField(widget))
 
678
    return(XmTextFieldXYToPos(widget, x, y));
 
679
  else {
 
680
    XmTextWidget tw = (XmTextWidget) widget;
 
681
    XmTextPosition ret_val;
 
682
    _XmWidgetToAppContext(widget);
 
683
 
 
684
    _XmAppLock(app);
 
685
    ret_val = (*tw->text.output->XYToPos)(tw, x, y);
 
686
    _XmAppUnlock(app);
 
687
    return ret_val;
 
688
  }
 
689
}
 
690
 
 
691
Boolean 
 
692
XmTextPosToXY(Widget widget,
 
693
              XmTextPosition position,
 
694
              Position *x,
 
695
              Position *y)
 
696
{
 
697
  if (XmIsTextField(widget))
 
698
    return(XmTextFieldPosToXY(widget, position, x, y));
 
699
  else {
 
700
    XmTextWidget tw = (XmTextWidget) widget;
 
701
    Boolean ret_val;
 
702
    _XmWidgetToAppContext(widget);
 
703
 
 
704
    _XmAppLock(app);
 
705
    ret_val = (*tw->text.output->PosToXY)(tw, position, x, y);
 
706
    _XmAppUnlock(app);
 
707
    return ret_val;
 
708
  }
 
709
}
 
710
 
 
711
/*
 
712
 * Force the given position to be displayed.  If position < 0, then don't force
 
713
 * any position to be displayed.
 
714
 */
 
715
/* ARGSUSED */
 
716
void 
 
717
XmTextShowPosition(Widget widget,
 
718
                   XmTextPosition position)
 
719
{
 
720
  if (XmIsTextField(widget))
 
721
    XmTextFieldShowPosition(widget, position);
 
722
  else {
 
723
    _XmWidgetToAppContext(widget);
 
724
 
 
725
    _XmAppLock(app);
 
726
    _XmTextShowPosition(widget, position);
 
727
    _XmAppUnlock(app);
 
728
  }
 
729
}
 
730
 
 
731
int 
 
732
XmTextGetBaseline(Widget widget)
 
733
{
 
734
  _XmWidgetToAppContext(widget);
 
735
 
 
736
  _XmAppLock(app);
 
737
  if (XmIsTextField(widget)) {
 
738
    XmTextFieldWidget tf = (XmTextFieldWidget) widget;
 
739
    Dimension margin_top;
 
740
    int ret_val;
 
741
 
 
742
    if(XmDirectionMatch(XmPrim_layout_direction(tf),
 
743
                        XmTOP_TO_BOTTOM_RIGHT_TO_LEFT)) {
 
744
      _XmAppUnlock(app);
 
745
      return(0);
 
746
    }
 
747
    
 
748
    margin_top = tf->text.margin_top +
 
749
        tf->primitive.shadow_thickness +
 
750
        tf->primitive.highlight_thickness;
 
751
 
 
752
    ret_val = (int) margin_top + (int) TextF_FontAscent(tf);
 
753
    _XmAppUnlock(app);
 
754
    return ret_val;
 
755
  } else {
 
756
    Dimension *baselines;
 
757
    int temp_bl;
 
758
    int line_count;
 
759
    XmPrimitiveClassExt           *wcePtr;
 
760
    XmTextWidget tw = (XmTextWidget) widget;
 
761
 
 
762
    if(XmDirectionMatch(XmPrim_layout_direction(tw),
 
763
                        XmTOP_TO_BOTTOM_RIGHT_TO_LEFT)) {
 
764
      _XmAppUnlock(app);
 
765
      return(0);
 
766
    }
 
767
    
 
768
    wcePtr = _XmGetPrimitiveClassExtPtr(XtClass(widget), NULLQUARK);
 
769
    
 
770
    if (*wcePtr && (*wcePtr)->widget_baseline)
 
771
      (void) (*(*wcePtr)->widget_baseline)(widget, &baselines, &line_count);
 
772
    
 
773
    if (line_count)
 
774
      temp_bl = (int) baselines[0];
 
775
    else
 
776
      temp_bl = 0;
 
777
    
 
778
    XtFree((char *) baselines);
 
779
    _XmAppUnlock(app);
 
780
    return (temp_bl);
 
781
  }
 
782
}
 
783
 
 
784
int 
 
785
XmTextGetCenterline(Widget widget)
 
786
{
 
787
  Dimension *baselines;
 
788
  int temp_bl;
 
789
  int line_count;
 
790
  XmPrimitiveClassExt           *wcePtr;
 
791
  XmTextWidget tw = (XmTextWidget) widget;
 
792
 
 
793
  _XmWidgetToAppContext(widget);
 
794
 
 
795
  _XmAppLock(app);
 
796
    
 
797
  if (!XmDirectionMatch(XmPrim_layout_direction(tw),
 
798
                        XmTOP_TO_BOTTOM_RIGHT_TO_LEFT)) {
 
799
    _XmAppUnlock(app);
 
800
    return(0);
 
801
  }
 
802
 
 
803
  wcePtr = _XmGetPrimitiveClassExtPtr(XtClass(widget), NULLQUARK);
 
804
    
 
805
  if (*wcePtr && (*wcePtr)->widget_baseline)
 
806
    (void) (*(*wcePtr)->widget_baseline)(widget, &baselines, &line_count);
 
807
    
 
808
  if (line_count)
 
809
    temp_bl = (int) baselines[0];
 
810
  else
 
811
    temp_bl = 0;
 
812
    
 
813
  XtFree((char *) baselines);
 
814
  _XmAppUnlock(app);
 
815
  return (temp_bl);
 
816
}
 
817
 
 
818
void 
 
819
XmTextSetHighlight(Widget w,
 
820
                   XmTextPosition left,
 
821
                   XmTextPosition right,
 
822
                   XmHighlightMode mode)
 
823
{
 
824
  if (XmIsTextField(w)) {
 
825
    XmTextFieldSetHighlight(w, left, right, mode);
 
826
  } else {
 
827
    _XmWidgetToAppContext(w);
 
828
 
 
829
    _XmAppLock(app);
 
830
    _XmTextSetHighlight(w, left, right, mode);
 
831
    _XmAppUnlock(app);
 
832
  }
 
833
}
 
834
 
 
835
static int
 
836
_XmTextGetSubstring(Widget widget,
 
837
                    XmTextPosition start,
 
838
                    int num_chars,
 
839
                    int buf_size,
 
840
                    char *buffer,
 
841
#if NeedWidePrototypes
 
842
                    int want_wchar)
 
843
#else
 
844
                    Boolean want_wchar)
 
845
#endif /* NeedWidePrototypes */
 
846
{
 
847
  XmTextWidget tw = (XmTextWidget) widget;
 
848
  XmTextBlockRec block;
 
849
  XmTextPosition pos, end;
 
850
  wchar_t * wc_buffer = (wchar_t*)buffer;
 
851
  int destpos = 0;
 
852
  
 
853
  end = start + num_chars;
 
854
  
 
855
  num_chars = 0; /* We're done with the value passed in, so let's
 
856
                  * re-use it when needed for the wchar functionality
 
857
                  * instead of creating a local automatic variable.
 
858
                  */
 
859
  
 
860
  for (pos = start; pos < end;) {
 
861
    pos = (*tw->text.source->ReadSource)(tw->text.source, pos, end,
 
862
                                         &block);
 
863
    if (block.length == 0) {
 
864
      if (!want_wchar)
 
865
        buffer[destpos] = '\0';
 
866
      else 
 
867
        wc_buffer[destpos] = (wchar_t)0L;
 
868
      return XmCOPY_TRUNCATED;
 
869
    }
 
870
    
 
871
    if (!want_wchar) {
 
872
      if (((destpos + block.length) * sizeof(char)) >= buf_size)
 
873
        return XmCOPY_FAILED;
 
874
    } else { /* Need number of characters for buffer comparison */
 
875
      num_chars = _XmTextCountCharacters(block.ptr, block.length);
 
876
      if (((destpos + num_chars) * sizeof(char)) >= buf_size)
 
877
        return XmCOPY_FAILED;
 
878
    }
 
879
    
 
880
    if (!want_wchar) {
 
881
      (void)memcpy((void*)&buffer[destpos], (void*)block.ptr, 
 
882
                   block.length);
 
883
      destpos += block.length;
 
884
    } else { /* want wchar_t* data */
 
885
      num_chars = mbstowcs(&wc_buffer[destpos], block.ptr, num_chars);
 
886
      if (num_chars < 0) num_chars = 0;
 
887
      destpos += num_chars;
 
888
    }
 
889
  }
 
890
  
 
891
  if (!want_wchar)
 
892
    buffer[destpos] = '\0';
 
893
  else
 
894
    wc_buffer[destpos] = (wchar_t)0L;
 
895
  
 
896
  return XmCOPY_SUCCEEDED;
 
897
}
 
898
 
 
899
int
 
900
XmTextGetSubstring(Widget widget,
 
901
                   XmTextPosition start,
 
902
                   int num_chars,
 
903
                   int buf_size,
 
904
                   char *buffer)
 
905
{
 
906
  if (XmIsTextField(widget)) 
 
907
    return (XmTextFieldGetSubstring(widget, start, num_chars, 
 
908
                                    buf_size, buffer));
 
909
  else {
 
910
    int ret_val;
 
911
    _XmWidgetToAppContext(widget);
 
912
 
 
913
    _XmAppLock(app);
 
914
    ret_val =_XmTextGetSubstring(widget, start, num_chars, buf_size,
 
915
                               buffer, False);
 
916
    _XmAppUnlock(app);
 
917
    return ret_val;
 
918
  }
 
919
}
 
920
 
 
921
int
 
922
XmTextGetSubstringWcs(Widget widget,
 
923
                      XmTextPosition start,
 
924
                      int num_chars,
 
925
                      int buf_size,
 
926
                      wchar_t *buffer)
 
927
{
 
928
  if (XmIsTextField(widget)) 
 
929
    return (XmTextFieldGetSubstringWcs(widget, start, num_chars, 
 
930
                                       buf_size, buffer));
 
931
  else {
 
932
    int ret_val;
 
933
    _XmWidgetToAppContext(widget);
 
934
 
 
935
    _XmAppLock(app);
 
936
    ret_val =_XmTextGetSubstring(widget, start, num_chars, buf_size,
 
937
                               (char*) buffer, True);
 
938
    _XmAppUnlock(app);
 
939
    return ret_val;
 
940
  }
 
941
}