external/cde
1
0
Fork 0
mirror of git://git.code.sf.net/p/cdesktopenv/code synced 2025-03-09 15:50:02 +00:00
Code Issues Releases Wiki Activity
cde/cde/lib/DtWidget/Editor.c
Peter Howkins 37e03a1820 libdtwidget: resolve uninitialized warnings
2021-12-24 10:50:27 -07:00

8286 lines
229 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/* $TOG: Editor.c /main/24 1999/10/14 16:38:25 mgreess $
**********************************<+>*************************************
***************************************************************************
**
** File: Editor.c
**
** Project: Text Editor widget
**
** Description:
** -----------
** This is the main source file for the Text Editor widget.
**
*******************************************************************
* (c) Copyright 1996 Digital Equipment Corporation.
* (c) Copyright 1993, 1994, 1996 Hewlett-Packard Company.
* (c) Copyright 1993, 1994, 1996 International Business Machines Corp.
* (c) Copyright 1993, 1994, 1996 Sun Microsystems, Inc.
* (c) Copyright 1996 Novell, Inc.
* (c) Copyright 1996 FUJITSU LIMITED.
* (c) Copyright 1996 Hitachi.
* (c) Copyright 1993, 1994 Unix System Labs, Inc., a subsidiary of Novell, Inc.
********************************************************************
**
**************************************************************************
**********************************<+>*************************************/
/*-------------------------------------------------------------
** Include Files
*/
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600
#endif
#include <ctype.h>
#include <stdlib.h>
#if defined(__hpux)
# include <wchar.h>
#elif defined(sun)
# if (_XOPEN_VERSION==3)
# include <wctype.h>
# else
# include <wchar.h>
# endif
# include <libintl.h>
#elif defined(__linux__) || defined(CSRG_BASED)
# include <wctype.h>
# include <wchar.h>
#endif /* linux || CSRG_BASED */
#include <sys/wait.h>
#include "signal.h"
#include <string.h>
#include <limits.h> /* For LINE_MAX definition */
#include <sys/errno.h> /* For Error handling */
#include "EditorP.h"
#include <Dt/Dnd.h>
#include "X11/Xutil.h"
#include <X11/StringDefs.h>
#include <X11/keysymdef.h>
#include <Xm/Form.h>
#include <Xm/MessageB.h>
#include <Xm/MwmUtil.h>
#include <Xm/TextF.h>
#include <Xm/LabelG.h>
#include <Xm/SeparatoG.h>
#include <Xm/PushBG.h>
#include <Xm/ToggleBG.h>
#include <Xm/RowColumn.h>
/* Need the following for _DtOkString */
#include <Dt/DtP.h>
#include <Dt/DtMsgsP.h>
#include <Dt/HourGlass.h>
#include "DtWidgetI.h"
/*
* Private functions borrowed from Motif.
*/
extern XmTextLineTable _XmTextGetLineTable(Widget widget, int *total_lines);
extern char * _XmStringSourceGetString(XmTextWidget tw,
XmTextPosition from,
XmTextPosition to,
#if NeedWidePrototypes
int want_wchar);
#else
Boolean want_wchar);
#endif /* NeedWidePrototypes */
/*-------------------------------------------------------------
** Public Interface
**-------------------------------------------------------------
*/
/******** Public Function Declarations ********/
/******** End Public Function Declarations ********/
/*-------------------------------------------------------------
** Forward Declarations
**-------------------------------------------------------------
*/
/******** Static Function Declarations ********/
static void ClassInitialize(void);
static void Initialize(
Widget rw,
Widget nw,
ArgList al,
Cardinal *num_args) ;
static void VariableInitialize(
DtEditorWidget new);
static void ValidateResources(
DtEditorWidget new,
DtEditorWidget request);
static Widget CreateText(
DtEditorWidget parent);
static void extractFontMetrics(
DtEditorWidget w,
XmFontList fontlist,
int *height,
int *width);
static void getFontMetrics(
DtEditorWidget w);
static void Destroy(
Widget widget);
static void SetStatusLine(
DtEditorWidget ew,
Boolean statusLineOn);
static Widget CreateStatusLine(
DtEditorWidget parent);
static Boolean SetValues(
Widget cw,
Widget rw,
Widget nw);
static void _DtEditorGetCenterToggleLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetChangeAllButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetChangeButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetChangeFieldLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetColumns(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetCurrentLineLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetCursorPosition(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetFindButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetFindFieldLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetFormatAllButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetFormatParagraphButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetJustifyToggleLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetLeftAlignToggleLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetLeftMarginFieldLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetMaxLength(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetMisspelledListLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetRightAlignToggleLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetRightMarginFieldLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetRows(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetScrollLeftSide(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetScrollTopSide(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetTextBackground(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetTextForeground(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetTopCharacter(
Widget wid,
int resource_offset,
XtArgVal *value );
static void _DtEditorGetLineCountLabel(
Widget wid,
int resource_offset,
XtArgVal *value );
static void FixWordWrap( /* XXX Word Wrap workaround */
Widget w, /* XXX Word Wrap workaround */
Boolean wrapOn); /* XXX Word Wrap workaround */
static void BackwardChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void BackwardPara(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void BackwardWord(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void BeginningOfFile(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void BeginningOfLine(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ClearSelection(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void CopyClipboard(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void CutClipboard(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void DeleteNextChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void DeleteNextWord(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void DeletePrevChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void DeletePrevWord(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void DeleteToEOL(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void DeleteToSOL(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void DeselectAll(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void EndOfFile(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void EndOfLine(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ForwardChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ForwardPara(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ForwardWord(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void GoToLine(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void GoToLine_I(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void Help(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void InsertString(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void KeySelect(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void NewlineAndBackup(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void NewlineAndIndent(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void NextPage(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void PageLeft(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void PageRight(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void PasteClipboard(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void PreviousPage(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ProcessCancel(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ProcessDown(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ProcessShiftDown(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ProcessShiftUp(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ProcessUp(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void QuoteNextChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void QuoteNextChar_I(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void SelectAll(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ToggleInsertMode(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void ToggleInsertMode_I(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void UndoEdit(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void UndoEdit_I(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params);
static void Call_TextSelectCallback(
DtEditorWidget editor);
static void Call_TextDeselectCallback(
DtEditorWidget editor);
static void Editor_SetSelectionProc(
XmTextSource source,
XmTextPosition left,
XmTextPosition right,
Time set_time );
static void CallHelpCallback(
DtEditorWidget editor,
int reason);
static void HelpEditWindowCB(
Widget w,
caddr_t client_data,
caddr_t call_data );
static void HelpStatusCurrentLineCB(
Widget w,
caddr_t client_data,
caddr_t call_data );
static void HelpStatusTotalLinesCB(
Widget w,
caddr_t client_data,
caddr_t call_data );
static void HelpStatusMessageCB(
Widget w,
caddr_t client_data,
caddr_t call_data );
static void HelpStatusOverstrikeCB(
Widget w,
caddr_t client_data,
caddr_t call_data );
static void RegisterDropZone(
DtEditorWidget w );
static void UnregisterDropZone(
DtEditorWidget w );
static void SetInfoDialogTitle(
DtEditorWidget editor );
static int FormatText (
AdjRecPtr pAdjRec );
static void AdjustParaCB(
Widget w,
caddr_t client_data,
caddr_t call_data );
static void AdjustAllCB(
Widget w,
caddr_t client_data,
caddr_t call_data );
static DtEditorErrorCode DoAdjust(
DtEditorWidget editor,
int leftMargin,
int rightMargin,
unsigned int alignment,
XmTextPosition start,
XmTextPosition end);
static void SetFormatDialogTitle(
DtEditorWidget editor);
static void ResetFormatDialog(
DtEditorWidget editor);
static void CreateFormatDialog(
DtEditorWidget editor);
static void GetAdjustSettings(
DtEditorWidget pPad,
DtEditorFormatSettings *formatSettings);
static void UpdateOverstrikeIndicator(
DtEditorWidget widget,
Boolean overstrikeOn );
/******** End Static Function Declarations ********/
/****************************************************************
*
* Compatability routines
*
****************************************************************/
#if defined(NO_putwc)
static wint_t putwc(wint_t wc, FILE *stream)
{
int rc = putc((int) wc, stream);
return (wint_t) rc;
}
static wint_t getwc(FILE *stream)
{
int rc = getc(stream);
return (wint_t) rc;
}
#endif /* NO_putwc */
/****************************************************************
*
* Translations and Actions
*
****************************************************************/
/*
* The following are the translations which DtEditor places (overrides)
* on the scrolled text widget. If the DtNtextTranslations resource is
* set, it will also be added (in override mode) to the text widget.
*/
static char EditorTranslationTable[] = "\
~s ~c ~m ~a <Key>Return: newline-and-indent()\n\
~s m<Key>osfBackSpace: I-undo-edit()\n\
~s c<Key>osfBackSpace: delete-previous-word()\n\
s<Key>osfBackSpace: delete-to-start-of-line()\n\
~s ~c <Key>osfInsert: I-toggle-insert-mode()\n\
<Key>osfUndo: I-undo-edit()\n\
c<Key>g: I-go-to-line()\n\
c<Key>q: I-quote-next-character()\n\
c<Key>z: I-undo-edit()";
/*
* The following are DtEditor's actions. A few are internal only (_I
* suffix) and will be called by the default translations DtEditor places
* on the text widget (see previous comment). The rest will only be called
* from an application with XtCallActionProc(). The main difference is
* the internal ones will be passed a text widget ID, while the public
* ones will be passed a DtEditor ID.
*/
static XtActionsRec EditorActionTable[] = {
{"I-go-to-line", (XtActionProc)GoToLine_I},
{"I-toggle-insert-mode", (XtActionProc)ToggleInsertMode_I},
{"I-undo-edit", (XtActionProc)UndoEdit_I},
{"I-quote-next-character", (XtActionProc)QuoteNextChar_I},
{"backward-character", (XtActionProc)BackwardChar},
{"backward-paragraph", (XtActionProc)BackwardPara},
{"backward-word", (XtActionProc)BackwardWord},
{"beginning-of-file", (XtActionProc)BeginningOfFile},
{"beginning-of-line", (XtActionProc)BeginningOfLine},
{"clear-selection", (XtActionProc)ClearSelection},
{"copy-clipboard", (XtActionProc)CopyClipboard},
{"cut-clipboard", (XtActionProc)CutClipboard},
{"delete-next-character", (XtActionProc)DeleteNextChar},
{"delete-next-word", (XtActionProc)DeleteNextWord},
{"delete-previous-character", (XtActionProc)DeletePrevChar},
{"delete-previous-word", (XtActionProc)DeletePrevWord},
{"delete-to-end-of-line", (XtActionProc)DeleteToEOL},
{"delete-to-start-of-line", (XtActionProc)DeleteToSOL},
{"deselect-all", (XtActionProc)DeselectAll},
{"end-of-file", (XtActionProc)EndOfFile},
{"end-of-line", (XtActionProc)EndOfLine},
{"forward-character", (XtActionProc)ForwardChar},
{"forward-paragraph", (XtActionProc)ForwardPara},
{"forward-word", (XtActionProc)ForwardWord},
{"go-to-line", (XtActionProc)GoToLine},
{"Help", (XtActionProc)Help},
{"insert-string", (XtActionProc)InsertString},
{"key-select", (XtActionProc)KeySelect},
{"newline-and-backup", (XtActionProc)NewlineAndBackup},
{"newline-and-indent", (XtActionProc)NewlineAndIndent},
{"next-page", (XtActionProc)NextPage},
{"page-left", (XtActionProc)PageLeft},
{"page-right", (XtActionProc)PageRight},
{"paste-clipboard", (XtActionProc)PasteClipboard},
{"previous-page", (XtActionProc)PreviousPage},
{"process-cancel", (XtActionProc)ProcessCancel},
{"process-down", (XtActionProc)ProcessDown},
{"process-shift-down", (XtActionProc)ProcessShiftDown},
{"process-shift-up", (XtActionProc)ProcessShiftUp},
{"process-up", (XtActionProc)ProcessUp},
{"quote-next-character", (XtActionProc)QuoteNextChar},
{"select-all", (XtActionProc)SelectAll},
{"toggle-insert-mode", (XtActionProc)ToggleInsertMode},
{"undo-edit", (XtActionProc)UndoEdit},
};
/****************************************************************
*
* Defines
*
****************************************************************/
#define NL_SETN 1
#ifdef _AIX
#define iswctype(a,b) is_wctype(a,b)
#define wctype(a) get_wctype(a)
#endif /* _AIX */
#if !(defined(sun) && (_XOPEN_VERSION==3))
#if !(defined(__FreeBSD__))
# define iswblank(wc) iswctype((wc),blnkclass)
# undef getwc /* Use the libc function */
#endif
#if defined(_AIX) /* _AIX */
/* IBM defines wctype to get_wctype above - don't use const. */
static char *blankString = "space";
#else /* _AIX */
static const char *blankString = "space";
#endif /* _AIX */
static wctype_t _DtEditor_blankClass;
#else
# define wctype_t int
# define iswblank(a) iswspace(a)
# define iswctype(a,b) _iswctype(a,b)
# define wcwidth(a) sun_wcwidth(a)
#endif /* not sun */
#define MAXTABSIZE 100 /* max legal tabsize */
/****************************************************************
*
* Define misc data structures
*
****************************************************************/
static wctype_t ekinclass = 0; /* Prop value for "ekinsoku" class */
static wctype_t bekinclass = 0; /* Prop value for "bekinsoku" class */
static wctype_t blnkclass = 0; /* Prop value for "Blank" Class */
/****************************************************************
*
* Resource List
*
****************************************************************/
static XmSyntheticResource syn_resources[] =
{
{
DtNcolumns, sizeof(short),
XtOffset (DtEditorWidget, editor.editStuff.columns),
_DtEditorGetColumns, NULL
},
{
DtNcenterToggleLabel, sizeof (XmString),
XtOffset (DtEditorWidget, editor.formatStuff.centerToggleLabel),
_DtEditorGetCenterToggleLabel, NULL
},
{
DtNchangeAllButtonLabel, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.searchStuff.changeAllButtonLabel),
_DtEditorGetChangeAllButtonLabel, NULL
},
{
DtNchangeButtonLabel, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.changeButtonLabel),
_DtEditorGetChangeButtonLabel, NULL
},
{
DtNchangeFieldLabel, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.changeFieldLabel),
_DtEditorGetChangeFieldLabel, NULL
},
{
DtNcurrentLineLabel, sizeof (XmString),
XtOffset(DtEditorWidget, editor.statusStuff.currentLineLabel),
_DtEditorGetCurrentLineLabel, NULL
},
{
DtNcursorPosition, sizeof (XmTextPosition),
XtOffset(DtEditorWidget, editor.editStuff.cursorPos),
_DtEditorGetCursorPosition, NULL
},
{
DtNfindButtonLabel, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.findButtonLabel),
_DtEditorGetFindButtonLabel, NULL
},
{
DtNfindFieldLabel, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.findFieldLabel),
_DtEditorGetFindFieldLabel, NULL
},
{
DtNformatAllButtonLabel, sizeof (XmString),
XtOffset(DtEditorWidget,
editor.formatStuff.formatAllButtonLabel),
_DtEditorGetFormatAllButtonLabel, NULL
},
{
DtNformatParagraphButtonLabel, sizeof (XmString),
XtOffset(DtEditorWidget,
editor.formatStuff.formatParaButtonLabel),
_DtEditorGetFormatParagraphButtonLabel, NULL
},
{
DtNjustifyToggleLabel, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.formatStuff.justifyToggleLabel),
_DtEditorGetJustifyToggleLabel, NULL
},
{
DtNleftAlignToggleLabel, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.formatStuff.leftAlignToggleLabel),
_DtEditorGetLeftAlignToggleLabel, NULL
},
{
DtNleftMarginFieldLabel, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.formatStuff.leftMarginFieldLabel),
_DtEditorGetLeftMarginFieldLabel, NULL
},
{
DtNmaxLength, sizeof(int),
XtOffset(DtEditorWidget, editor.editStuff.maxLength),
_DtEditorGetMaxLength, NULL
},
{
DtNmisspelledListLabel, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.searchStuff.misspelledListLabel),
_DtEditorGetMisspelledListLabel, NULL
},
{
DtNrightAlignToggleLabel, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.formatStuff.rightAlignToggleLabel),
_DtEditorGetRightAlignToggleLabel, NULL
},
{
DtNrightMarginFieldLabel, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.formatStuff.rightMarginFieldLabel),
_DtEditorGetRightMarginFieldLabel, NULL
},
{
DtNrows, sizeof(short),
XtOffset (DtEditorWidget, editor.editStuff.rows),
_DtEditorGetRows, NULL
},
{
DtNscrollLeftSide, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.editStuff.scrollLeft),
_DtEditorGetScrollLeftSide, NULL
},
{
DtNscrollTopSide, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.editStuff.scrollTop),
_DtEditorGetScrollTopSide, NULL
},
{
DtNtextBackground, sizeof(Pixel),
XtOffset (DtEditorWidget, editor.editStuff.background),
_DtEditorGetTextBackground, NULL
},
{
DtNtextForeground, sizeof(Pixel),
XtOffset (DtEditorWidget, editor.editStuff.foreground),
_DtEditorGetTextForeground, NULL
},
{
DtNtopCharacter, sizeof(XmTextPosition),
XtOffset (DtEditorWidget, editor.editStuff.topCharacter),
_DtEditorGetTopCharacter, NULL
},
{
DtNtotalLineCountLabel, sizeof (XmString),
XtOffset (DtEditorWidget, editor.statusStuff.totalLineLabel),
_DtEditorGetLineCountLabel, NULL
},
};
static XtResource resources[] =
{
{
DtNautoShowCursorPosition,
DtCAutoShowCursorPosition, XmRBoolean, sizeof (Boolean),
XtOffset(DtEditorWidget,
editor.editStuff.autoShowCursorPos),
XmRImmediate, (XtPointer) True
},
{
DtNbuttonFontList, DtCFontList, XmRFontList, sizeof(XmFontList),
XtOffsetOf(struct _XmBulletinBoardRec,
bulletin_board.button_font_list),
XmRFontList, (XtPointer) NULL
},
{
DtNblinkRate, DtCBlinkRate, XmRInt, sizeof(int),
XtOffset(DtEditorWidget, editor.editStuff.blinkRate),
XmRImmediate, (XtPointer) 500
},
{
DtNcenterToggleLabel, DtCCenterToggleLabel,
XmRXmString, sizeof (XmString),
XtOffset (DtEditorWidget, editor.formatStuff.centerToggleLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNchangeAllButtonLabel, DtCChangeAllButtonLabel,
XmRXmString, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.searchStuff.changeAllButtonLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNchangeButtonLabel, DtCChangeButtonLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.changeButtonLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNchangeFieldLabel, DtCChangeFieldLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.changeFieldLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNcolumns, DtCColumns, XmRShort, sizeof(short),
XtOffset (DtEditorWidget, editor.editStuff.columns),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNcurrentLineLabel, DtCCurrentLineLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.statusStuff.currentLineLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNcursorPosition, DtCCursorPosition, XmRTextPosition,
sizeof (XmTextPosition),
XtOffset(DtEditorWidget, editor.editStuff.cursorPos),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNcursorPositionVisible, DtCCursorPositionVisible,
XmRBoolean, sizeof (Boolean),
XtOffset(DtEditorWidget,
editor.editStuff.cursorPosVisible),
XmRImmediate, (XtPointer) True
},
{
DtNdialogTitle, DtCDialogTitle, XmRXmString, sizeof (XmString),
XtOffsetOf(struct _XmBulletinBoardRec,
bulletin_board.dialog_title),
XmRString, (XtPointer) NULL
},
{
DtNeditable, DtCEditable, XmRBoolean, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.editStuff.editable),
XmRImmediate, (XtPointer) True
},
{
DtNfindButtonLabel, DtCFindButtonLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.findButtonLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNfindChangeDialogTitle, DtCFindChangeDialogTitle,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.fndChngTitle),
XmRString, (XtPointer) NULL
},
{
DtNfindFieldLabel, DtCFindFieldLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.findFieldLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNformatAllButtonLabel, DtCFormatAllButtonLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget,
editor.formatStuff.formatAllButtonLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNformatParagraphButtonLabel, DtCFormatParagraphButtonLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget,
editor.formatStuff.formatParaButtonLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNformatSettingsDialogTitle, DtCFormatSettingsDialogTitle,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.formatStuff.formatDialogTitle),
XmRString, (XtPointer) NULL
},
{
DtNinformationDialogTitle, DtCInformationDialogTitle,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.warningStuff.infoDialogTitle),
XmRString, (XtPointer) NULL
},
{
DtNinsertLabel, DtCInsertLabel, XmRXmString, sizeof (XmString),
XtOffset (DtEditorWidget, editor.statusStuff.ins),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNjustifyToggleLabel, DtCJustifyToggleLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.formatStuff.justifyToggleLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNlabelFontList, DtCFontList, XmRFontList, sizeof(XmFontList),
XtOffsetOf(struct _XmBulletinBoardRec,
bulletin_board.label_font_list),
XmRFontList, (XtPointer) NULL
},
{
DtNleftAlignToggleLabel, DtCLeftAlignToggleLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget,
editor.formatStuff.leftAlignToggleLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNleftMarginFieldLabel, DtCLeftMarginFieldLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget,
editor.formatStuff.leftMarginFieldLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNmaxLength, DtCMaxLength, XmRInt, sizeof(int),
XtOffset(DtEditorWidget, editor.editStuff.maxLength),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNmisspelledListLabel, DtCMisspelledListLabel,
XmRXmString, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.searchStuff.misspelledListLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNoverstrike, DtCOverstrike, XmRBoolean, sizeof (Boolean),
XtOffset(DtEditorWidget, editor.editStuff.overstrikeMode),
XmRImmediate, (XtPointer) False
},
{
DtNoverstrikeLabel, DtCOverstrikeLabel,
XmRXmString, sizeof (XmString),
XtOffset (DtEditorWidget, editor.statusStuff.ovr),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNrightAlignToggleLabel, DtCRightAlignToggleLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget,
editor.formatStuff.rightAlignToggleLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNrightMarginFieldLabel, DtCRightMarginFieldLabel,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget,
editor.formatStuff.rightMarginFieldLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNrows, DtCRows, XmRShort, sizeof(short),
XtOffset (DtEditorWidget, editor.editStuff.rows),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNscrollHorizontal, DtCScroll, XmRBoolean, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.editStuff.scrollHorizontal),
XmRImmediate, (XtPointer) True
},
{
DtNscrollLeftSide, DtCScrollSide, XmRBoolean, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.editStuff.scrollLeft),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNscrollTopSide, DtCScrollSide, XmRBoolean, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.editStuff.scrollTop),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNscrollVertical, DtCScroll, XmRBoolean, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.editStuff.scrollVertical),
XmRImmediate, (XtPointer) True
},
{
DtNshowStatusLine,
DtCShowStatusLine, XmRBoolean, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.statusStuff.showStatusLine),
XmRImmediate, (XtPointer) False
},
{
DtNspellDialogTitle, DtCSpellDialogTitle,
XmRXmString, sizeof (XmString),
XtOffset(DtEditorWidget, editor.searchStuff.spellTitle),
XmRString, (XtPointer) NULL
},
{
DtNspellFilter, DtCSpellFilter, XmRString, sizeof(XmRString),
XtOffset (DtEditorWidget, editor.searchStuff.spellFilter),
XmRString, "spell"
},
{
DtNtextBackground, DtCBackground,
XmRPixel, sizeof(Pixel),
XtOffset (DtEditorWidget, editor.editStuff.background),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNtextDeselectCallback,
DtCCallback, XtRCallback, sizeof (XtCallbackList),
XtOffset (DtEditorWidget, editor.textDeselect),
XtRCallback, (XtPointer) NULL
},
{
DtNtextForeground, DtCForeground,
XmRPixel, sizeof(Pixel),
XtOffset (DtEditorWidget, editor.editStuff.foreground),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNtextFontList, DtCFontList, XmRFontList, sizeof(XmFontList),
XtOffsetOf(struct _XmBulletinBoardRec,
bulletin_board.text_font_list),
XmRFontList, (XtPointer) NULL
},
{
DtNtextSelectCallback,
DtCCallback, XtRCallback, sizeof (XtCallbackList),
XtOffset (DtEditorWidget, editor.textSelect),
XtRCallback, (XtPointer) NULL
},
{
DtNtextTranslations, DtCTranslations,
XmRTranslationTable, sizeof (XtTranslations),
XtOffsetOf(struct _XmBulletinBoardRec,
bulletin_board.text_translations),
XmRImmediate, (XtPointer) NULL
},
{
DtNtopCharacter, DtCTopCharacter,
XmRTextPosition, sizeof(XmTextPosition),
XtOffset (DtEditorWidget, editor.editStuff.topCharacter),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNtotalLineCountLabel, DtCTotalLineCountLabel,
XmRXmString, sizeof (XmString),
XtOffset (DtEditorWidget,
editor.statusStuff.totalLineLabel),
XmRImmediate, (XtPointer) DtUNSPECIFIED
},
{
DtNwordWrap,
DtCWordWrap, XmRBoolean, sizeof (Boolean),
XtOffset (DtEditorWidget, editor.editStuff.wordWrap),
XmRImmediate, (XtPointer) False
},
};
/****************************************************************
*
* Public Function Declarations
*
****************************************************************/
/****************************************************************
*
* Class Record
*
****************************************************************/
externaldef( dteditorclassrec ) DtEditorClassRec
dtEditorClassRec =
{
/* Core Part
*/
{
(WidgetClass) &xmFormClassRec, /* superclass */
"DtEditor", /* class_name */
sizeof (DtEditorRec), /* widget_size */
ClassInitialize, /* class_initialize */
NULL, /* class_part_initialize*/
False, /* class_inited */
(XtInitProc) Initialize, /* initialize */
NULL, /* initialize_hook */
XtInheritRealize, /* realize */
(XtActionList)EditorActionTable,/* actions */
(Cardinal)XtNumber(EditorActionTable), /* num_actions */
resources, /* resources */
XtNumber (resources), /* num_resources */
NULLQUARK, /* xrm_class */
True, /* compress_motion */
XtExposeCompressMaximal, /* compress_exposure */
False, /* compress_enterleave */
False, /* visible_interest */
(XtWidgetProc) Destroy, /* destroy */
XtInheritResize, /* resize */
XtInheritExpose, /* expose */
(XtSetValuesFunc) SetValues, /* set_values */
NULL, /* set_values_hook */
XtInheritSetValuesAlmost, /* set_values_almost */
NULL, /* get_values_hook */
XtInheritAcceptFocus, /* accept_focus */
XtVersion, /* version */
NULL, /* callback private */
XtInheritTranslations, /* tm_table */
XtInheritQueryGeometry, /* query_geometry */
(XtStringProc)NULL, /* display_accelerator */
NULL, /* extension */
},
/* Composite Part
*/
{
XtInheritGeometryManager, /* geometry_manager */
XtInheritChangeManaged, /* change_managed */
XtInheritInsertChild, /* insert_child */
XtInheritDeleteChild, /* delete_child */
NULL, /* extension */
},
/* Constraint Part
*/
{
NULL, /* constraint_resources */
0, /* num_constraint_resource */
sizeof(XmFormConstraintRec), /* size of constraint */
NULL, /* initialization */
NULL, /* constraint_destroy */
NULL, /* constraint_set_values */
NULL, /* extension */
},
/* XmManager Part
*/
{
XmInheritTranslations, /* default_translations */
syn_resources, /* syn_resources */
XtNumber(syn_resources), /* num_syn_resources */
NULL, /* syn_cont_resources */
0, /* num_syn_cont_resources */
XmInheritParentProcess, /* parent_process */
NULL, /* extension */
},
/* XmbulletinBoard Part
*/
{
FALSE, /* always_install_accelerators */
(XmGeoCreateProc)NULL, /* geo_matrix_create */
XmInheritFocusMovedProc, /* focus_moved_proc */
NULL, /* extension */
},
/* XmForm Part
*/
{
NULL, /* extension */
},
/* DtEditor Part
*/
{
0, /* extension */
}
};
WidgetClass dtEditorWidgetClass = (WidgetClass) &dtEditorClassRec;
/*-------------------------------------------------------------
** Editor Procs
**-------------------------------------------------------------
*/
/****************************************************************
*
* Private Procs
*
****************************************************************/
/*-------------------------------------------------------------
** Function: static void ClassInitialize (void);
**
** Parameters:
**
** Purpose: This is the Editor class initializzation routine.
** It is called once, before the first instance
** is created.
*/
static void
ClassInitialize(void)
{
#if !(defined(sun) && (_XOPEN_VERSION==3))
_DtEditor_blankClass = wctype(blankString);
/*
** These calls determine if the particular value is True for
** the current locale. A value of -1 is returned if the locale
** does not support the charclass. If the locale supports the
** charclass, the return value is passed as a parameter to the
** iswctype call.
*/
ekinclass = wctype("ekinsoku");
bekinclass = wctype("bkinsoku");
blnkclass = wctype("blank");
#endif /* end not Sun */
}
/*-------------------------------------------------------------
** Function: static void Initialize (
** Widget rw,
** Widget nw,
** ArgList arg_list,
** Cardinal *num_args)
**
** Parameters:
**
** Purpose: This is the Editor widget initialize routine.
** It is responsible for the following:
** 1) Validate all resources the user passed in,
** 2) Override any invalid resources,
** 3) Initialize the internal data structures,
** 4) Create the edit area widget
** 5) Create the status area widget, if requested
** 6) Add any callbacks and actions
*/
static void
Initialize(
Widget rw,
Widget nw,
ArgList arg_list,
Cardinal *num_args)
{
DtEditorWidget request = (DtEditorWidget) rw,
new = (DtEditorWidget) nw;
/* Initialize non-resource portion of the instance structure */
VariableInitialize (new);
/* Validate the incoming arguments to make sure they are OK */
ValidateResources (new, request);
/*
* Create & customize the scrolled text widget
*/
M_text(new) = CreateText (new);
XtManageChild( M_text(new)) ;
/*
* If the widget is not "read only" then register it as a drop zone
*/
if ( M_editable(new) == True )
RegisterDropZone( new );
/*
* Compute the width & height of the scrolled text's font. These values
* will be used when formatting and in calculating the window manager
* hints.
*/
getFontMetrics(new);
/*
* Create the status line
*/
SetStatusLine( new, M_status_showStatusLine(request) );
} /* end Initialize */
/*-------------------------------------------------------------
** Function: static void VariableInitialize (
** DtEditorWidget new )
**
** Parameters: The Editor widget being created
**
** Purpose: This routine:
** 1) Initializes the widget's instance structure
*/
static void
VariableInitialize(
DtEditorWidget new)
{
Widget thisParent;
/*
* Initialize the non-resource instance fields
*/
M_display(new) = XtDisplayOfObject( (Widget)new->core.parent );
M_app_context(new) = XtDisplayToApplicationContext(M_display(new));
/*
* Empty 'for' walks up the widget tree to find a shell.
*/
for (thisParent = new->core.parent;
thisParent != (Widget)NULL && XtIsShell(thisParent) == False;
thisParent = XtParent(thisParent));
M_topLevelShell(new) = thisParent;
/* Initialize edit area fields */
M_loadingAllNewData(new) = False;
M_unreadChanges(new) = False; /* There have not been any changes since */
/* the app requested the data */
M_deletionStart(new) = NO_DELETION_IN_PROGRESS;
M_deletedText(new) = (char *)NULL;
M_insertStart(new) = 0;
M_insertionLength(new) = 0;
M_textSelectCbCalled(new) = False;
M_fontWidth(new) = -1;
/* Initialize status line fields */
M_status_statusArea(new) = (Widget)NULL;
M_status_messageText(new) = (Widget)NULL;
M_status_currentLine(new) = -1;
M_status_lastLine(new) = -1;
/* Initialize search function data */
M_search_dialog(new) = (Widget) NULL;
M_search_dialogMode(new) = SPELL;
M_search_string(new) = (char *)NULL;
M_replace_string(new) = (char *)NULL;
M_misspelled_string(new) = (char *)NULL;
M_misspelled_found(new) = False;
/* Initialize format function data */
M_format_dialog(new) = (Widget)NULL;
/* Initialize warning dialogs data */
M_gen_warning(new) = (Widget)NULL;
} /* end VariableInitialize */
/*-------------------------------------------------------------
** Function: static void ValidateResources (
** DtEditorWidget new,
** DtEditorWidget request )
**
** Parameters: The Editor widget being created & its requested
** resource values
**
** Purpose: This routine:
** 1) Validates the widget's requested resources
*/
static void
ValidateResources(
DtEditorWidget new,
DtEditorWidget request)
{
/*
* Validate the requested values for the editor's resources
*/
/*
* Make local copies of all resource strings assigned by the application.
*/
if (M_spellFilter(request) != (char *) NULL)
M_spellFilter(new) = XtNewString( M_spellFilter(request) );
/*
* Copy the dialog titles if the application set them, otherwise,
* get their values from the message catalog.
*/
if (M_spellTitle(request) != (XmString) NULL)
M_spellTitle(new) = XmStringCopy( M_spellTitle(request) );
else
M_spellTitle(new) = XmStringCreateLocalized(SPELL_TITLE);
if (M_fndChngTitle(request) != (XmString) NULL)
M_fndChngTitle(new) = XmStringCopy( M_fndChngTitle(request) );
else
M_fndChngTitle(new) = XmStringCreateLocalized(FIND_TITLE);
if (E_format_dialogTitle(request) != (XmString) NULL)
E_format_dialogTitle(new) = XmStringCopy( E_format_dialogTitle(request) );
else
E_format_dialogTitle(new) = XmStringCreateLocalized(FORMAT_SETTINGS);
if (E_infoDialogTitle(request) != (XmString) NULL)
E_infoDialogTitle(new) = XmStringCopy( E_infoDialogTitle(request) );
else
E_infoDialogTitle(new) = XmStringCreateLocalized(INFO_TITLE);
/*
* Copy the insert & overstrike label indicators if the appli-
* cation set them, otherwise, get their value from the message
* catalog.
* Check for DtUNSPECIFIED because NULL is a valid value.
*/
if (M_status_insertLabel(request) != (XmString) DtUNSPECIFIED)
M_status_insertLabel(new) =
XmStringCopy( M_status_insertLabel(request) );
else
M_status_insertLabel(new) = XmStringCreateLocalized(INS);
if (M_status_overstrikeLabel(request) != (XmString) DtUNSPECIFIED)
M_status_overstrikeLabel(new) =
XmStringCopy( M_status_overstrikeLabel(request) );
else
M_status_overstrikeLabel(new) = XmStringCreateLocalized(OVR);
} /* end ValidateResources */
/*-------------------------------------------------------------
** Function: static Widget CreateText (
** DtEditorWidget parent)
**
** Parameters: The parent of the text widget
**
** Purpose: This routine creates the scrolled text widget which
** lives inside the editor widget.
** It is responsible for the following:
** 1) Creating the scrolled text widget,
** 2) Adding specific translations,
** 3) Adding our own callbacks,
** 4) Substituting our own set selection routine.
*/
static Widget
CreateText(
DtEditorWidget parent)
{
int ac; /* arg count */
Arg al[21]; /* arg list */
Widget text;
/*
* First, set up the hardwired scrolled text widget resource values.
* (Change these and you die! Aha! Ha! Ha! Ha! [evil laugh])
*/
ac = 0;
XtSetArg (al[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNpendingDelete, True); ac++;
/*
* Now, set up the resource values which can vary (passed in from
* application or default values).
*
* If a synthetic resource is DtUNSPECIFIED don't set it, but let
* it default to the scrolled text default value.
* If it is specified, clear the data field after setting the
* resource because the value in the field will be out of sync
* with the real value.
*/
XtSetArg(al[ac], XmNautoShowCursorPosition, M_autoShowCursorPos(parent));
ac++;
XtSetArg(al[ac], XmNblinkRate, M_blinkRate(parent)); ac++;
if ( M_columns(parent) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNcolumns, M_columns(parent) ); ac++;
M_columns(parent) = (short) DtUNSPECIFIED;
}
if ( M_cursorPos(parent) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNcursorPosition, M_cursorPos(parent)); ac++;
M_cursorPos(parent) = (XmTextPosition) DtUNSPECIFIED;
}
XtSetArg(al[ac], XmNcursorPositionVisible, M_cursorPosVisible(parent));
ac++;
XtSetArg(al[ac], XmNeditable, M_editable(parent)); ac++;
if ( E_textFontList(parent) != (XmFontList) NULL) {
XtSetArg (al[ac], XmNfontList, E_textFontList(parent)); ac++;
}
if ( M_maxLength(parent) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNmaxLength, M_maxLength(parent) ); ac++;
M_maxLength(parent) = (int) DtUNSPECIFIED;
}
if ( M_rows(parent) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNrows, M_rows(parent) ); ac++;
M_rows(parent) = (short) DtUNSPECIFIED;
}
XtSetArg (al[ac], XmNscrollHorizontal, M_scrollHorizontal(parent) ); ac++;
if ( M_scrollLeftSide(parent) != (Boolean)DtUNSPECIFIED) {
XtSetArg (al[ac], XmNscrollLeftSide, M_scrollLeftSide(parent) ); ac++;
M_scrollLeftSide(parent) = (Boolean)DtUNSPECIFIED;
}
if ( M_scrollTopSide(parent) != (Boolean)DtUNSPECIFIED) {
XtSetArg (al[ac], XmNscrollTopSide, M_scrollTopSide(parent) ); ac++;
M_scrollTopSide(parent) = (Boolean)DtUNSPECIFIED;
}
XtSetArg (al[ac], XmNscrollVertical, M_scrollVertical(parent) ); ac++;
if ( M_topCharacter(parent) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNtopCharacter, M_topCharacter(parent) ); ac++;
M_topCharacter(parent) = (XmTextPosition) DtUNSPECIFIED;
}
XtSetArg (al[ac], XmNwordWrap, M_wordWrap(parent) ); ac++;
/* Create text widget */
text = XmCreateScrolledText ( (Widget) parent, "text", al, ac );
/*
* Now, set the foreground & background of the text widget. Could not
* set it at create time because the scrolled window would have
* picked it up, too.
*/
ac=0;
if ( M_textBackground(parent) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNbackground, M_textBackground(parent) ); ac++;
M_textBackground(parent) = (Pixel) DtUNSPECIFIED;
}
if ( M_textForeground(parent) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNforeground, M_textForeground(parent) ); ac++;
M_textForeground(parent) = (Pixel) DtUNSPECIFIED;
}
if (ac)
XtSetValues( text, al, ac);
/* XXX Word Wrap workaround. See comments for FixWordWrap() */
if ( M_scrollHorizontal(parent) ) /* XXX Word Wrap workaround */
FixWordWrap(text, M_wordWrap(parent)); /* XXX Word Wrap workaround */
/* Put the editor-specific translation routines in place. */
XtOverrideTranslations(text,
XtParseTranslationTable(EditorTranslationTable));
/* Add any translations set by the application. */
if ( E_textTranslations(parent) != (XtTranslations)NULL ) {
XtOverrideTranslations(text, E_textTranslations(parent));
}
/*
* Add modify verify callback
*/
XtAddCallback(text, XmNmodifyVerifyCallback,
(XtCallbackProc) _DtEditorModifyVerifyCB,
(XtPointer) parent);
/*
* Add the Help callback
*/
XtAddCallback( text, XmNhelpCallback, (XtCallbackProc) HelpEditWindowCB,
(XtPointer) parent );
/*
* Substitute our own Set Selection routine which can
* call the textSelect and textDeselect callback procs
*/
if(((XmTextWidget)(text))->text.source->SetSelection !=
Editor_SetSelectionProc) {
M_setSelection(parent) =
((XmTextWidget)(text))->text.source->SetSelection;
((XmTextWidget)(text))->text.source->SetSelection =
Editor_SetSelectionProc;
}
XtSetSensitive (text, True);
return(text);
} /* end CreateText */
/*-------------------------------------------------------------
** Function: static int extractFontMetrics (
** XmFontList fontlist )
**
** Purpose: Given a font list, determine the width & height
** of the characters.
**
** This routine is lifted almost straight out of
** lib/Xm/TextOut.c (see LoadFontMetrics() ) so the editor will
** select the same font the text widget is working with.
*/
static void
extractFontMetrics(
DtEditorWidget w,
XmFontList fontlist,
int *height,
int *width)
{
XmFontContext context;
XmFontListEntry next_entry;
XmFontType type_return = XmFONT_IS_FONT;
XtPointer tmp_font;
XFontStruct *font = NULL;
Boolean have_font_struct = False;
Boolean have_font_set = False;
Boolean use_font_set = False;
XFontSetExtents *fs_extents;
unsigned long tmp_width = 0;
int font_descent, font_ascent;
char* font_tag = NULL;
*width = *height = 0;
if (XmFontListInitFontContext(&context, fontlist)) {
/*
* Look through the font list for a fontset with the default tag.
* If we do not find it, use the first font set we came to, otherwise,
* use the first font struct we came to.
*/
do {
Boolean do_break = False;
next_entry = XmFontListNextEntry(context);
if (next_entry) {
tmp_font = XmFontListEntryGetFont(next_entry, &type_return);
if (type_return == XmFONT_IS_FONTSET) {
/*
* Have a font set
*/
font_tag = XmFontListEntryGetTag(next_entry);
if (!have_font_set){
/*
* Save the first fontset found in case we don't find
* a default tag font set.
*/
have_font_set = True; /* we have a font set. */
use_font_set = True;
font = (XFontStruct *)tmp_font;
/*
* We have a font set, so no need to consider future font
* structs
*/
have_font_struct = True;
/*
* If this is the default font set break out, we've
* found the one we want.
*/
if (!strcmp(XmFONTLIST_DEFAULT_TAG, font_tag))
do_break = True;
}
else if (!strcmp(XmFONTLIST_DEFAULT_TAG, font_tag)) {
/*
* If this is the default font set save it & break out,
* we've found the one we want.
*/
font = (XFontStruct *)tmp_font;
have_font_set = True;
do_break = True;
}
if (NULL != font_tag)
XtFree(font_tag);
if (do_break)
break;
}
else if (!have_font_struct){
/*
* Have a font
*/
use_font_set = False;
/*
* Save the first one in case no font set is found
*/
font = (XFontStruct *)tmp_font;
use_font_set = False;
have_font_struct = True;
}
}
} while (next_entry != NULL);
XmFontListFreeFontContext(context);
/*
* Now, extract the font metrics from the font set or font that
* we chose.
*/
if (use_font_set) {
/*
* Chose a font set
*/
fs_extents = XExtentsOfFontSet((XFontSet)font);
if (XmDirectionMatch(w->manager.string_direction,
XmTOP_TO_BOTTOM_RIGHT_TO_LEFT)) {
tmp_width = (unsigned long)fs_extents->max_ink_extent.width;
} else {
tmp_width = (unsigned long)fs_extents->max_logical_extent.width;
}
/* max_logical_extent.y is number of pixels from origin to top of
* rectangle (i.e. y is negative) */
font_ascent = -fs_extents->max_logical_extent.y;
font_descent = fs_extents->max_logical_extent.height +
fs_extents->max_logical_extent.y;
}
else {
/*
* Chose a font struct
*/
font_ascent = font->max_bounds.ascent;
font_descent = font->max_bounds.descent;
if ( (!XGetFontProperty(font, XA_QUAD_WIDTH, &tmp_width)) ||
tmp_width == 0 )
{
if ( font->per_char && font->min_char_or_byte2 <= '0' &&
font->max_char_or_byte2 >= '0' )
tmp_width = font->per_char['0' - font->min_char_or_byte2].width;
else
tmp_width = font->max_bounds.width;
}
}
if (tmp_width <= 0) tmp_width = 1;
*width = (int)tmp_width; /* This assumes there will be no truncation */
*height = font_descent + font_ascent;
}
} /* end extractFontMetrics */
/*-------------------------------------------------------------
** Function: static void getFontMetrics (
** DtEditorWidget w )
**
** Parameters: An Editor widget
**
** Purpose: Determine the height & width of the scrolled text
** widget's font
**
*/
static void
getFontMetrics(
DtEditorWidget w)
{
Arg al[10]; /* arg list */
XmFontList fontlist;
int width, height;
/*
* Get the text widget's font list
*
* Note, have to retrieve the fontList from the text widget rather
* than use the DtNtextFontList resource because the text widget may
* have rejected the font specified with DtNtextFontList. This way
* we will get the fontList actually used by the text widget.
*/
XtSetArg(al[0], XmNfontList, &fontlist);
XtGetValues(M_text(w), al, 1);
/*
* Now, extract the height and width
*/
extractFontMetrics( w, fontlist, &height, &width );
M_fontWidth(w) = width;
M_fontHeight(w) = height;
} /* end getFontMetrics */
/*-------------------------------------------------------------
** Destroy
** Release resources allocated for a widget instance.
*/
static void
Destroy(
Widget widget )
{
DtEditorWidget editor = (DtEditorWidget) widget;
/*
* Cleanup the edit window
*/
/*
* (Nothing to be done. Unregistering it as a drop site is handled
* automatically by the DnD library.)
*/
/*
* Cleanup the status line
*/
if (M_status_insertLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(M_status_insertLabel(editor));
if (M_status_overstrikeLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(M_status_overstrikeLabel(editor));
if (E_status_currentLineLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_status_currentLineLabel(editor));
if (E_status_totalLineCountLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_status_totalLineCountLabel(editor));
/*
* Cleanup the Find/Change & Spell dialogs
*/
if (M_search_string(editor))
XtFree(M_search_string(editor));
if (M_replace_string(editor))
XtFree(M_replace_string(editor));
if (M_misspelled_string(editor))
XtFree(M_misspelled_string(editor));
if (M_spellFilter(editor))
XtFree(M_spellFilter(editor));
if (M_spellTitle(editor) != (XmString)NULL)
XmStringFree(M_spellTitle(editor));
if (E_misspelledListLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_misspelledListLabel(editor));
if (M_fndChngTitle(editor) != (XmString)NULL)
XmStringFree(M_fndChngTitle(editor));
if (E_findFieldLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_findFieldLabel(editor));
if (E_changeFieldLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_changeFieldLabel(editor));
if (E_findButtonLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_findButtonLabel(editor));
if (E_changeButtonLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_changeButtonLabel(editor));
if (E_changeAllButtonLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_changeAllButtonLabel(editor));
/*
* Cleanup the Format Settings dialog
*/
if (E_format_dialogTitle(editor) != (XmString)NULL)
XmStringFree(E_format_dialogTitle(editor));
if (E_format_leftMarginFieldLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_format_leftMarginFieldLabel(editor));
if (E_format_rightMarginFieldLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_format_rightMarginFieldLabel(editor));
if (E_format_leftAlignToggleLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_format_leftAlignToggleLabel(editor));
if (E_format_rightAlignToggleLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_format_rightAlignToggleLabel(editor));
if (E_format_justifyToggleLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_format_justifyToggleLabel(editor));
if (E_format_centerToggleLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_format_centerToggleLabel(editor));
if (E_format_formatAllButtonLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_format_formatAllButtonLabel(editor));
if (E_format_formatParagraphButtonLabel(editor) != (XmString)DtUNSPECIFIED)
XmStringFree(E_format_formatParagraphButtonLabel(editor));
/*
* Cleanup the Information dialog
*/
if (E_infoDialogTitle(editor) != (XmString)NULL)
XmStringFree(E_infoDialogTitle(editor));
/*
* Cleanup the Undo deletion context
*/
_DtEditorResetUndo(editor);
} /* end Destroy */
/*-------------------------------------------------------------
** SetValues
** Handle changes in resource data.
*/
static Boolean
SetValues(
Widget cw,
Widget rw,
Widget nw )
{
Boolean redisplay_flag = False;
Arg al[15]; /* arg list */
int ac; /* arg count */
Boolean resetSpellTitle = False,
resetFormatTitle = False,
resetInfoTitle = False,
newButtonFontList = False,
newLabelFontList = False,
newTextFontList = False,
NeedToFixWordWrap = False; /* XXX Word Wrap workaround*/
DtEditorWidget current = (DtEditorWidget) cw;
DtEditorWidget request = (DtEditorWidget) rw;
DtEditorWidget new = (DtEditorWidget) nw;
/*
* XXX Need to propagate changes to Core resources, like XmNbackground,
* to the children.
*/
/*
* If a synthetic resource is specified, clear the data field
* after setting the resource because the value in the field
* will be out of sync with the real value (contained in the
* child widget).
*/
/*
* General changes, not directly affecting a child
*/
/* Check for a new spell filter */
if ( strcmp(M_spellFilter(request), M_spellFilter(current)) != 0 )
{
XtFree( M_spellFilter(current) );
M_spellFilter(new) = XtNewString( M_spellFilter(request) );
}
/* Check for new font lists */
if ( E_buttonFontList(request) != E_buttonFontList(current) )
newButtonFontList = True;
if ( E_labelFontList(request) != E_labelFontList(current) )
newLabelFontList = True;
if ( E_textFontList(request) != E_textFontList(current) )
newTextFontList = True;
/*
* Check for any changes which affect the dialog titles
*/
if (XmStringCompare(E_dialogTitle(request),E_dialogTitle(current)) == False) {
resetSpellTitle = resetFormatTitle = resetInfoTitle = True;
}
if (XmStringCompare(M_spellTitle(request),M_spellTitle(current)) == False) {
XmStringFree( M_spellTitle(current) );
M_spellTitle(new) = XmStringCopy( M_spellTitle(request) );
resetSpellTitle = True;
}
if (XmStringCompare(M_fndChngTitle(request),M_fndChngTitle(current)) == False)
{
XmStringFree( M_fndChngTitle(current) );
M_fndChngTitle(new) = XmStringCopy( M_fndChngTitle(request) );
resetSpellTitle = True;
}
if (XmStringCompare(E_format_dialogTitle(request),
E_format_dialogTitle(current) ) == False)
{
XmStringFree( E_format_dialogTitle(current) );
E_format_dialogTitle(new) = XmStringCopy( E_format_dialogTitle(request) );
resetFormatTitle = True;
}
if (XmStringCompare(E_infoDialogTitle(request),
E_infoDialogTitle(current) ) == False)
{
XmStringFree( E_infoDialogTitle(current) );
E_infoDialogTitle(new) = XmStringCopy( E_infoDialogTitle(request) );
resetInfoTitle = True;
}
/*
* Calculate new titles for the dialogs depending upon which resources
* changed.
*/
if ( resetSpellTitle == True ) {
/*
* No need to do anything because the Spell and Find/Change dialog
* titles are recomputed every time.
*/
redisplay_flag = True;
}
if ( resetFormatTitle == True ) {
SetFormatDialogTitle( new );
redisplay_flag = True;
}
if ( resetInfoTitle == True ) {
SetInfoDialogTitle( new );
redisplay_flag = True;
}
/*
* Check for any changes which affect the status line
*/
if (M_status_showStatusLine(request) != M_status_showStatusLine(current)) {
SetStatusLine( new, M_status_showStatusLine(request) );
redisplay_flag = True;
}
if ( M_overstrikeMode(request) != M_overstrikeMode(current) ) {
UpdateOverstrikeIndicator( new, M_overstrikeMode(request) );
XtCallActionProc( (Widget) M_text(current), "toggle-overstrike",
(XEvent *)NULL, (String *)NULL, 0 );
redisplay_flag = True;
}
if ( M_status_statusArea(current) != (Widget)NULL ) {
if (newLabelFontList == True) {
XtSetArg (al[0], XmNfontList, E_labelFontList(request) );
XtSetValues( (Widget) M_status_lineLabel(current), al, 1);
XtSetValues( (Widget) M_status_totalLabel(current), al, 1);
XtSetValues( (Widget) M_status_totalText(current), al, 1);
XtSetValues( (Widget) M_status_overstrikeWidget(current), al, 1);
}
ac=0;
if (newTextFontList == True) {
XtSetArg( al[ac], XmNfontList, E_textFontList(request) ); ac++;
}
if ( M_textBackground(request) != DtUNSPECIFIED) {
XtSetArg( al[ac], XmNbackground, M_textBackground(request) ); ac++;
}
if ( M_textForeground(request) != DtUNSPECIFIED) {
XtSetArg( al[ac], XmNforeground, M_textForeground(request) ); ac++;
}
if ( ac ) {
XtSetValues( (Widget) M_status_lineText(current), al, ac);
XtSetValues( (Widget) M_status_messageText(current), al, ac);
}
}
/*
* Check for any changes which affect the dialog boxes
*/
/* Information dialog */
if ( M_gen_warning(current) != (Widget)NULL ) {
if ( newButtonFontList == True ) {
XtSetArg (al[0], XmNfontList, E_buttonFontList(request) );
XtSetValues(
XmMessageBoxGetChild(M_gen_warning(current), XmDIALOG_OK_BUTTON),
al, 1 );
}
if ( newLabelFontList == True ) {
XtSetArg (al[0], XmNfontList, E_labelFontList(request) );
XtSetValues(
XmMessageBoxGetChild(M_gen_warning(current), XmDIALOG_MESSAGE_LABEL),
al, 1 );
}
}
/* Find/Change dialog */
if ( M_search_dialog(current) != (Widget)NULL )
{
if ( newButtonFontList == True ) {
XtSetArg (al[0], XmNfontList, E_buttonFontList(request));
XtSetValues( (Widget)M_search_findBtn(current), al, 1 );
XtSetValues( (Widget)M_search_replaceBtn(current), al, 1 );
XtSetValues( (Widget)M_search_replaceAllBtn(current), al, 1 );
XtSetValues( (Widget)M_search_closeBtn(current), al, 1 );
XtSetValues( (Widget)M_search_helpBtn(current), al, 1 );
}
if ( newLabelFontList == True ) {
XtSetArg (al[0], XmNfontList, E_labelFontList(request) );
XtSetValues( (Widget)M_search_listLbl(current), al, 1 );
XtSetValues( (Widget)M_search_findLbl(current), al, 1 );
XtSetValues( (Widget)M_search_replaceLbl(current), al, 1);
}
if ( newTextFontList == True ) {
XtSetArg (al[0], XmNfontList, E_textFontList(request) );
XtSetValues( (Widget)M_search_spellList(current), al, 1);
XtSetValues( (Widget)M_findText(current), al, 1 );
XtSetValues( (Widget)M_replaceText(current), al, 1 );
}
ac=0;
if ( M_textBackground(request) != DtUNSPECIFIED) {
XtSetArg( al[ac], XmNbackground, M_textBackground(request) ); ac++;
}
if ( M_textForeground(request) != DtUNSPECIFIED) {
XtSetArg( al[ac], XmNforeground, M_textForeground(request) ); ac++;
}
if ( ac ) {
XtSetValues( (Widget) M_findText(current), al, ac);
XtSetValues( (Widget) M_replaceText(current), al, ac);
}
}
/* Format Settings dialog */
if ( M_format_dialog(current) != (Widget)NULL )
{
if ( newButtonFontList == True ) {
XtSetArg (al[0], XmNfontList, E_buttonFontList(request));
XtSetValues( (Widget)M_format_leftJust(current), al, 1 );
XtSetValues( (Widget)M_format_rightJust(current), al, 1);
XtSetValues( (Widget)M_format_bothJust(current), al, 1 );
XtSetValues( (Widget)M_format_center(current), al, 1 );
XtSetValues( (Widget)M_format_paragraph(current), al, 1);
XtSetValues( (Widget)M_format_all(current), al, 1 );
XtSetValues( (Widget)M_format_close(current), al, 1 );
XtSetValues( (Widget)M_format_help(current), al, 1 );
}
if ( newLabelFontList == True ) {
XtSetArg (al[0], XmNfontList, E_labelFontList(request) );
XtSetValues( (Widget)M_format_leftLabel(current), al, 1 );
XtSetValues( (Widget)M_format_rightLabel(current), al, 1);
}
if ( newTextFontList == True ) {
XtSetArg (al[0], XmNfontList, E_textFontList(request) );
XtSetValues( (Widget)M_format_leftMarginField(current), al, 1 );
XtSetValues( (Widget)M_format_rightMarginField(current), al, 1);
}
ac=0;
if ( M_textBackground(request) != DtUNSPECIFIED) {
XtSetArg( al[ac], XmNbackground, M_textBackground(request) ); ac++;
}
if ( M_textForeground(request) != DtUNSPECIFIED) {
XtSetArg( al[ac], XmNforeground, M_textForeground(request) ); ac++;
}
if ( ac ) {
XtSetValues( (Widget) M_format_leftMarginField(current), al, ac);
XtSetValues( (Widget) M_format_rightMarginField(current), al, ac);
}
}
/*
* Check for any changes which affect the edit area (scrolled text widget)
*/
ac=0;
if ( M_autoShowCursorPos(request) != M_autoShowCursorPos(current) ) {
XtSetArg( al[ac], XmNautoShowCursorPosition, M_autoShowCursorPos(request));
ac++;
}
if ( M_blinkRate(request) != M_blinkRate(current) ) {
XtSetArg( al[ac], XmNblinkRate, M_blinkRate(request)); ac++;
}
if ( M_columns(request) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNcolumns, M_columns(request) ); ac++;
M_columns(new) = (short) DtUNSPECIFIED;
redisplay_flag = True;
}
/* PERF - disable redisplay for all SetValues */
if ( M_cursorPos(request) != DtUNSPECIFIED) {
XmTextSetCursorPosition( M_text(new), M_topCharacter(request) );
M_cursorPos(new) = (XmTextPosition) DtUNSPECIFIED;
}
if ( M_cursorPosVisible(request) != M_cursorPosVisible(current) ) {
XtSetArg( al[ac], XmNcursorPositionVisible, M_cursorPosVisible(request));
ac++;
}
if ( M_editable(request) != M_editable(current) ) {
XtSetArg( al[ac], XmNeditable, M_editable(request)); ac++;
if( M_editable(request) ) {
/*
* If the widget is becoming editable, register it as a
* drop site and...
*/
RegisterDropZone( new );
/*
* ...turn back on the Change To field in the Find/Change dialog
*/
if ( M_search_dialog(current) != (Widget)NULL ) {
XtSetSensitive(M_search_replaceLbl(current), True);
XtSetSensitive(M_replaceText(current), True);
}
}
else
/*
* It's no longer available as a drop site.
*/
UnregisterDropZone( current );
}
if ( M_maxLength(request) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNmaxLength, M_maxLength(request) ); ac++;
M_maxLength(new) = (int) DtUNSPECIFIED;
}
if ( M_rows(request) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNrows, M_rows(request) ); ac++;
M_rows(new) = (short) DtUNSPECIFIED;
redisplay_flag = True;
}
if ( M_textBackground(request) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNbackground, M_textBackground(request) ); ac++;
M_textBackground(new) = (XmTextPosition) DtUNSPECIFIED;
redisplay_flag = True;
}
if ( newTextFontList == True ) {
XtSetArg (al[ac], XmNfontList, E_textFontList(request) ); ac++;
redisplay_flag = True;
}
if ( M_textForeground(request) != DtUNSPECIFIED) {
XtSetArg (al[ac], XmNforeground, M_textForeground(request) ); ac++;
M_textForeground(new) = (XmTextPosition) DtUNSPECIFIED;
redisplay_flag = True;
}
/* PERF - disable redisplay for all SetValues */
if ( M_topCharacter(request) != DtUNSPECIFIED) {
XmTextSetTopCharacter( M_text(new), M_topCharacter(request) );
M_topCharacter(new) = (XmTextPosition) DtUNSPECIFIED;
}
if ( M_wordWrap(request) != M_wordWrap(current) ) {
XtSetArg( al[ac], XmNwordWrap, M_wordWrap(request)); ac++;
NeedToFixWordWrap=M_scrollHorizontal(current);/*XXX Word Wrap workaround*/
}
if ( NeedToFixWordWrap ) /*XXX Word Wrap workaround*/
FixWordWrap(M_text(new), M_wordWrap(request));/*XXX Word Wrap workaround*/
if ( ac )
XtSetValues( (Widget) M_text(new), al, ac);
if ( E_textTranslations(request) != E_textTranslations(current) ) {
XtOverrideTranslations(M_text(new), E_textTranslations(request));
}
if ( newTextFontList == True ) {
getFontMetrics(new);
}
return (redisplay_flag);
} /* end Set values */
/**************************************************************
**
** Get values routines for synthetic resources
**
**/
static void
_DtEditorGetCenterToggleLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_format_centerToggleLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_format_centerToggleLabel(editor) );
else if (M_format_dialog(editor) != (Widget)NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_format_center(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(CENTER);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetCenterToggleLabel */
static void
_DtEditorGetChangeAllButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_changeAllButtonLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_changeAllButtonLabel(editor) );
else if (M_search_dialog(editor) != (Widget) NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_search_replaceAllBtn(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(CHNG_ALL_BUTTON);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetChangeAllButtonLabel */
static void
_DtEditorGetChangeButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_changeButtonLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_changeButtonLabel(editor) );
else if (M_search_dialog(editor) != (Widget) NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_search_replaceBtn(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(CHANGE_BUTTON);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetChangeButtonLabel */
static void
_DtEditorGetChangeFieldLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_changeFieldLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_changeFieldLabel(editor) );
else if (M_search_dialog(editor) != (Widget) NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_search_replaceLbl(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(CHANGE_LABEL);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetChangeFieldLabel */
static void
_DtEditorGetColumns(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
short data;
Arg al[1];
XtSetArg( al[0], XmNcolumns, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetColumns */
static void
_DtEditorGetCurrentLineLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_status_currentLineLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_status_currentLineLabel(editor) );
else if (M_status_statusArea(editor) != (Widget) NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_status_lineLabel(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(LINE);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetCurrentLineLabel */
static void
_DtEditorGetCursorPosition(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmTextPosition data;
Arg al[1];
XtSetArg( al[0], XmNcursorPosition, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetCursorPosition */
static void
_DtEditorGetFindButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_findButtonLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_findButtonLabel(editor) );
else if (M_search_dialog(editor) != (Widget) NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_search_findBtn(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(FIND_BUTTON);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetFindButtonLabel */
static void
_DtEditorGetFindFieldLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_findFieldLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_findFieldLabel(editor) );
else if (M_search_dialog(editor) != (Widget) NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_search_findLbl(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(FIND_LABEL);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetFindFieldLabel */
static void
_DtEditorGetFormatAllButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_format_formatAllButtonLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_format_formatAllButtonLabel(editor) );
else if (M_format_dialog(editor) != (Widget)NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_format_all(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(ALL);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetFormatAllButtonLabel */
static void
_DtEditorGetFormatParagraphButtonLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if(E_format_formatParagraphButtonLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_format_formatParagraphButtonLabel(editor) );
else if (M_format_dialog(editor) != (Widget)NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_format_paragraph(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(PARAGRAPH);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetFormatParagraphButtonLabel */
static void
_DtEditorGetJustifyToggleLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_format_justifyToggleLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_format_justifyToggleLabel(editor) );
else if (M_format_dialog(editor) != (Widget)NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_format_bothJust(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(JUSTIFY);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetJustifyToggleLabel */
static void
_DtEditorGetLeftAlignToggleLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_format_leftAlignToggleLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_format_leftAlignToggleLabel(editor) );
else if (M_format_dialog(editor) != (Widget)NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_format_leftJust(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(LEFT_ALIGN);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetLeftAlignToggleLabel */
static void
_DtEditorGetLeftMarginFieldLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_format_leftMarginFieldLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_format_leftMarginFieldLabel(editor) );
else if (M_format_dialog(editor) != (Widget)NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_format_leftLabel(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(LEFT_MARGIN);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetLeftMarginFieldLabel */
static void
_DtEditorGetMaxLength(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
int data;
Arg al[1];
XtSetArg( al[0], XmNmaxLength, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetMaxLength */
static void
_DtEditorGetMisspelledListLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_misspelledListLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_misspelledListLabel(editor) );
else if (M_search_dialog(editor) != (Widget) NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_search_listLbl(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(MISSPELLED);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetMisspelledListLabel */
static void
_DtEditorGetRightAlignToggleLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_format_rightAlignToggleLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_format_rightAlignToggleLabel(editor) );
else if (M_format_dialog(editor) != (Widget)NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_format_rightJust(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(RIGHT_ALIGN);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetRightAlignToggleLabel */
static void
_DtEditorGetRightMarginFieldLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_format_rightMarginFieldLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_format_rightMarginFieldLabel(editor) );
else if (M_format_dialog(editor) != (Widget)NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_format_rightLabel(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(RIGHT_MARGIN);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetRightMarginFieldLabel */
static void
_DtEditorGetRows(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
short data;
Arg al[1];
XtSetArg( al[0], XmNrows, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetRows */
static void
_DtEditorGetScrollLeftSide(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
Boolean data;
Arg al[1];
XtSetArg( al[0], XmNscrollLeftSide, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetScrollLeftSide */
static void
_DtEditorGetScrollTopSide(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
Boolean data;
Arg al[1];
XtSetArg( al[0], XmNscrollTopSide, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetScrollTopSide */
static void
_DtEditorGetTextBackground(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
Pixel data;
Arg al[1];
XtSetArg( al[0], XmNbackground, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetTextBackground */
static void
_DtEditorGetTextForeground(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
Pixel data;
Arg al[1];
XtSetArg( al[0], XmNforeground, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetTextForeground */
static void
_DtEditorGetTopCharacter(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmTextPosition data;
Arg al[1];
XtSetArg( al[0], XmNtopCharacter, &data) ;
XtGetValues( (Widget) M_text(editor), al, 1) ;
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetTopCharacter */
static void
_DtEditorGetLineCountLabel(
Widget wid,
int resource_offset,
XtArgVal *value )
{
DtEditorWidget editor = (DtEditorWidget) wid;
XmString data;
Arg al[1];
/*
* Get the value directly from the field in the instance structure.
* If it is DtUNSPECIFIED then either:
* 1) the value has been assigned to the widget (so get it from
* there), or
* 2) the value has never been set (so return the default value).
*/
if (E_status_totalLineCountLabel(editor) != (XmString) DtUNSPECIFIED)
data = XmStringCopy( E_status_totalLineCountLabel(editor) );
else if (M_status_statusArea(editor) != (Widget) NULL)
{
XtSetArg( al[0], XmNlabelString, &data) ;
XtGetValues( (Widget) M_status_totalLabel(editor), al, 1) ;
}
else
data = XmStringCreateLocalized(TOTAL);
*value = (XtArgVal) data ;
return;
} /* end _DtEditorGetLineCountLabel */
/**************************************************************
**
** Action Procedures
**
**/
/*
* The following are DtEditor's actions. A few are internal only (_I
* suffix) and will be called by the default translations DtEditor places
* on the text widget. The rest will be called from an application with
* XtCallActionProc(). The main difference is the internal ones will be
* passed a text widget ID, while the public ones will be passed a DtEditor ID.
*/
static void
BackwardChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "backward-character", event,
params, *num_params );
}
static void
BackwardPara(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "backward-paragraph", event,
params, *num_params );
}
static void
BackwardWord(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "backward-word", event,
params, *num_params );
}
static void
BeginningOfFile(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "beginning-of-file", event,
params, *num_params );
}
static void
BeginningOfLine(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "beginning-of-line", event,
params, *num_params );
}
static void
ClearSelection(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "clear-selection", event,
params, *num_params );
/*
* Clearing selected text also deselects the selection, but for some
* reason the selection proc (Editor_SetSelectionProc) does not get
* called, therefore, we need to call the DtNtextDeselectCallback
* from here.
*/
Call_TextDeselectCallback(editor);
}
static void
CopyClipboard(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "copy-clipboard", event,
params, *num_params );
}
static void
CutClipboard(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "cut-clipboard", event,
params, *num_params );
}
static void
DeleteNextChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "delete-next-character", event,
params, *num_params );
}
static void
DeleteNextWord(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "delete-next-word", event,
params, *num_params );
}
static void
DeletePrevChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "delete-previous-character", event,
params, *num_params );
}
static void
DeletePrevWord(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "delete-previous-word", event,
params, *num_params );
}
static void
DeleteToEOL(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "delete-to-end-of-line", event,
params, *num_params );
}
static void
DeleteToSOL(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "delete-to-start-of-line", event,
params, *num_params );
}
static void
DeselectAll(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "deselect-all", event,
params, *num_params );
}
static void
EndOfFile(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "end-of-file", event,
params, *num_params );
}
static void
EndOfLine(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "end-of-line", event,
params, *num_params );
}
static void
ForwardChar(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "forward-character", event,
params, *num_params );
}
static void
ForwardPara(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "forward-paragraph", event,
params, *num_params );
}
static void
ForwardWord(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "forward-word", event,
params, *num_params );
}
static void
GoToLine(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
if( M_status_statusArea(editor) != (Widget)NULL &&
XtIsManaged(M_status_statusArea(editor)) == True )
{
/*
* Set the input focus to the "Line" text field.
*/
XmProcessTraversal(M_status_lineText(editor), XmTRAVERSE_CURRENT);
/*
* Select the current contents to allow easy modification.
*/
XtCallActionProc( (Widget)M_status_lineText(editor), "select-all",
event, (String *)NULL, 0 );
}
} /* end GoToLine */
/*
* Internal action called only from the scrolled text widget
*/
static void
GoToLine_I(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
XmTextWidget tw = (XmTextWidget)w;
DtEditorWidget editor = (DtEditorWidget)M_editor(tw);
GoToLine( (Widget)editor, event, params, num_params );
} /* end GoToLine_I */
static void
Help(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
CallHelpCallback((DtEditorWidget)w, DtEDITOR_HELP_EDIT_WINDOW);
}
static void
InsertString(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "insert-string", event,
params, *num_params );
}
static void
KeySelect(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "key-select", event,
params, *num_params );
}
static void
NewlineAndBackup(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "newline-and-backup", event,
params, *num_params );
}
static void
NewlineAndIndent(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "newline-and-indent", event,
params, *num_params );
}
static void
NextPage(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "next-page", event,
params, *num_params );
}
static void
PageLeft(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "page-left", event,
params, *num_params );
}
static void
PageRight(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "page-right", event,
params, *num_params );
}
static void
PasteClipboard(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "paste-clipboard", event,
params, *num_params );
}
static void
PreviousPage(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "previous-page", event,
params, *num_params );
}
static void
ProcessCancel(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "process-cancel", event,
params, *num_params );
}
static void
ProcessDown(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "process-down", event,
params, *num_params );
}
static void
ProcessShiftDown(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "process-shift-down", event,
params, *num_params );
}
static void
ProcessShiftUp(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "process-shift-up", event,
params, *num_params );
}
static void
ProcessUp(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "process-up", event,
params, *num_params );
}
/************************************************************************
* GetModeSwitchModifier
* Find if any Mod<n> modifier is acting as the Group modifier - you
* can't assume Mod1Mask is always it.
* Returns the mask of the modifier key to which the Mode_switch
* keysym is attached.
*
************************************************************************/
/* ARGSUSED */
static unsigned int
GetModeSwitchModifier(
Display *dpy)
{
XModifierKeymap *pMap;
int mapIndex, keyCol, mapSize;
KeySym keySym;
unsigned int modeSwitchModMask = 0;
pMap = XGetModifierMapping(dpy);
mapSize = 8*pMap->max_keypermod;
for (mapIndex = 3*pMap->max_keypermod; mapIndex < mapSize; mapIndex++) {
/* look only at the first 4 columns of key map */
for (keyCol = 0; keyCol < 4; keyCol++) {
keySym = XKeycodeToKeysym(dpy, pMap->modifiermap[mapIndex], keyCol);
if (keySym == XK_Mode_switch)
modeSwitchModMask |= 1 << (mapIndex / pMap->max_keypermod);
}
}
XFreeModifiermap(pMap);
return modeSwitchModMask;
}
/************************************************************************
*
* DtEditorQuoteNextChar
* This action routine circumvents the normal XtDispatchEvent
* mechanism, inserting the next control or extended character
* directly into text without processed by event handlers or the
* translation manager. This means, for
* example, that the next control or extended character will be
* inserted into text without being intrepreted as a Motif menu
* or text widget accelerator.
*
************************************************************************/
/* ARGSUSED */
static void
QuoteNextChar(
Widget widget,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)widget;
static unsigned int ExtendcharMask = 0;
/* NOTE: ExtendcharMask could be a global set via a MappingNotify
* event handler. But it isn't...
*/
if (! ExtendcharMask)
{
_DtProcessLock();
if (! ExtendcharMask)
ExtendcharMask = GetModeSwitchModifier( M_display(editor) );
_DtProcessUnlock();
}
for (;;)
{
XEvent next;
#ifdef XTHREADS
/*
* We cannot let XtAppNextEvent bloc, because the intrinsics
* will release locks and some other thread might dispatch
* the event we want to trap.
*/
XtInputMask mask;
XtAppContext app = XtWidgetToApplicationContext(widget);
while ((mask = XtAppPending(app)) == 0)
{
if (XtAppGetExitFlag(app))
return;
}
if (mask & XtIMXEvent)
{
#endif
XtAppNextEvent(M_app_context(editor), &next);
if ((next.type == KeyPress) &&
(! IsModifierKey(XLookupKeysym((XKeyEvent *) &next, 0))) )
{
if (next.xkey.state & (ControlMask|ExtendcharMask))
XtCallActionProc(M_text(editor), "self-insert", &next, NULL, 0);
else
XtDispatchEvent(&next);
break;
}
else
XtDispatchEvent(&next);
#ifdef XTHREADS
}
else
{
/* Some (non-X) event is pending, so this should not block. */
XtAppProcessEvent(app, mask);
}
#endif
}
} /* end QuoteNextChar */
/*
* Internal action called only from the scrolled text widget
*/
static void
QuoteNextChar_I(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
XmTextWidget tw = (XmTextWidget)w;
DtEditorWidget editor = (DtEditorWidget) M_editor(tw);
QuoteNextChar( (Widget)editor, event, params, num_params );
} /* end QuoteNextChar_I */
static void
SelectAll(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
XtCallActionProc( M_text(editor), "select-all", event,
params, *num_params );
}
static void
ToggleInsertMode(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorWidget editor = (DtEditorWidget)w;
/*
* Toggle the state of the DtNoverstrike resource
*/
XtVaSetValues(w, DtNoverstrike, !M_overstrikeMode(editor), NULL);
} /* end ToggleInsertMode */
static void
ToggleInsertMode_I(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
XmTextWidget tw = (XmTextWidget)w;
DtEditorWidget editor = (DtEditorWidget)M_editor(tw);
ToggleInsertMode( (Widget)editor, event, params, num_params );
} /* end ToggleInsertMode_I */
static void
UndoEdit(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
DtEditorUndoEdit(w);
} /* end UndoEdit */
static void
UndoEdit_I(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params)
{
XmTextWidget tw = (XmTextWidget)w;
UndoEdit( (Widget)M_editor(tw), event, params, num_params );
} /* end UndoEdit_I */
/*
* XXX All lines in this file marked "XXX Word Wrap workaround"
* XXX are related to a Motif 1.2 Text widget design defect regarding
* XXX word wrap. For Motif 1.2, the Text widget was designed so word
* XXX wrap will not function if the scrolled text widget has a
* XXX horizontal scroll bar ("a hscrollbar means the paper is infinite
* XXX so there is no edge to wrap at"). This change was made in
* XXX Xm/TextOut.c RCS version 1.71 checked in July, 1991. A
* XXX CMVC report was filed 9/8/94 & assigned number 4772.
*/
#include <Xm/TextOutP.h> /* XXX Word Wrap workaround */
static void /* XXX Word Wrap workaround */
FixWordWrap( /* XXX Word Wrap workaround */
Widget w, /* XXX Word Wrap workaround */
Boolean wrapOn) /* XXX Word Wrap workaround */
{ /* XXX Word Wrap workaround */
XmTextWidget tw = (XmTextWidget)w; /* XXX Word Wrap workaround */
OutputData data = tw->text.output->data; /* XXX Word Wrap workaround */
data->scrollhorizontal = !wrapOn; /* XXX Word Wrap workaround */
} /* XXX Word Wrap workaround */
static void
Call_TextSelectCallback(
DtEditorWidget editor)
{
DtEditorSelectCallbackStruct select_cb;
/*
* Call the Editor widget's DtNtextSelectCallback proc
* if it hasn't been called since the last select.
*/
if ( !M_textSelectCbCalled(editor) ) {
M_textSelectCbCalled(editor) = True;
select_cb.reason = DtEDITOR_TEXT_SELECT;
select_cb.event = (XEvent *)NULL;
XtCallCallbackList ((Widget)editor, M_textSelect(editor),
(XtPointer) &select_cb);
}
} /* end Call_TextSelectCallback */
static void
Call_TextDeselectCallback(
DtEditorWidget editor)
{
DtEditorSelectCallbackStruct select_cb;
/*
* Call the Editor widget's DtNtextDeselectCallback proc
* if it hasn't been called since the last deselect.
*/
if ( M_textSelectCbCalled(editor) ) {
M_textSelectCbCalled(editor) = False;
select_cb.reason = DtEDITOR_TEXT_DESELECT;
select_cb.event = (XEvent *)NULL;
XtCallCallbackList ((Widget)editor, M_textDeselect(editor),
(XtPointer) &select_cb);
}
} /* end Call_TextDeselectCallback */
/*
* Editor_SetSelectionProc
* is put into the widget->text.source->SetSelection.
* Used to call the DtEditor's select/unselect callbacks
*/
static void
Editor_SetSelectionProc(
XmTextSource source,
XmTextPosition left,
XmTextPosition right,
Time set_time )
{
XmSourceData data = source->data;
Widget widget;
XmTextWidget tw;
DtEditorWidget editor;
/*
* Sanity check
*/
if (!XtIsRealized((Widget)data->widgets[0]) ||
data->numwidgets <= 0)
return;
if (left < 0) left = right = 0;
widget = (Widget) data->widgets[0];
tw = (XmTextWidget)widget;
editor = M_editor(tw);
if (!editor->core.being_destroyed) {
if (left < right) {
/*
* There is a selected area if left < right so call the
* DtNtextSelectCallback.
*/
Call_TextSelectCallback( editor );
}
else {
/*
* Left = Right so nothing is selected; call the
* DtNtextDeselectCallback.
*/
Call_TextDeselectCallback( editor );
}
}
/*
* Now, call the text widget's real Set Selection proc
*/
(*M_setSelection(editor))(source, left, right, set_time);
} /* end Editor_SetSelectionProc */
/**************************************************************
**
** Drag and drop routines
**
**/
/*
* Handles drops of a file into the text editor, after validation in the
* transfer callback. Files are handled by reading their contents.
* Text is handled by Motif.
*
* Changing the contents of the text widget occurs here, rather than in
* the transfer callback, because of the visual changes which occur when
* changing the text widget.
*/
static void
AnimateCallback(
Widget w,
XtPointer client_data,
XtPointer call_data )
{
int numItems, ii;
DtEditorErrorCode error;
DtDndDropAnimateCallbackStruct *animateInfo =
(DtDndDropAnimateCallbackStruct *) call_data;
DtEditorWidget editor = (DtEditorWidget) client_data;
/*
* XXX Only really needed if # of items is > 1
*/
_DtTurnOnHourGlass( M_topLevelShell(editor) );
/*
* How many items are being dropped on us?
*/
numItems = animateInfo->dropData->numItems;
switch (animateInfo->dropData->protocol)
{
case DtDND_FILENAME_TRANSFER:
{
/*
* OK, insert each file we are given
*/
for (ii = 0; ii < numItems; ii++)
{
error = DtEditorInsertFromFile( (Widget)editor,
animateInfo->dropData->data.files[ii] );
/*
* If the file was not inserted successfully, then quit
* (don't care if the file is read only or if it contained
* nulls that were stripped out).
*/
if( error != DtEDITOR_NO_ERRORS &&
error != DtEDITOR_READ_ONLY_FILE &&
error != DtEDITOR_NULLS_REMOVED )
{
ii = numItems; /* break out of loop */
}
} /* end for */
break;
} /* end file transfer case */
case DtDND_BUFFER_TRANSFER:
{
/*
* OK, insert each buffer we are given
*/
DtDndBuffer *buffers = animateInfo->dropData->data.buffers;
DtEditorContentRec cr;
cr.type = DtEDITOR_DATA;
for (ii = 0; ii < numItems; ii++)
{
cr.value.data.buf = buffers[ii].bp;
cr.value.data.length = buffers[ii].size;
error = DtEditorInsert( (Widget)editor, &cr );
/*
* If the buffer was not inserted successfully, then quit
* (don't care if the file contained nulls that were stripped out).
*/
if( error != DtEDITOR_NO_ERRORS && error != DtEDITOR_NULLS_REMOVED )
{
ii = numItems; /* break out of loop */
}
} /* end for */
break;
} /* end buffer transfer case */
case DtDND_TEXT_TRANSFER:
{
/*
* Receiving a text drop.
*
* Text drag and drop is handled by Motif so this switch
* will never be called.
*
*/
break;
} /* end text transfer case */
default:
{
}
} /* end switch */
/*
* XXX Only really needed if # of items is > 1
*/
_DtTurnOffHourGlass( M_topLevelShell(editor) );
} /* end AnimateCallback */
/*
* Validates a drop of a file into the text widget.
*
* Changing the contents of the text widget occurs in the animate
* callback, rather than here, because of the visual changes which
* occur when changing the text widget.
*/
/* ARGSUSED */
static void
TransferCallback(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
int numItems, ii;
DtEditorErrorCode error;
DtDndTransferCallbackStruct *transferInfo =
(DtDndTransferCallbackStruct *) call_data;
transferInfo->status = DtDND_SUCCESS;
/*
* How many items are being dropped on us?
*/
numItems = transferInfo->dropData->numItems;
switch (transferInfo->dropData->protocol)
{
case DtDND_FILENAME_TRANSFER:
{
/*
* Check to see if we can read each file we are given
*/
for (ii = 0; ii < numItems; ii++)
{
error = _DtEditorValidateFileAccess(
transferInfo->dropData->data.files[ii],
READ_ACCESS);
/*
* Can't access it for reading so reject drop
*/
if ( error != DtEDITOR_NO_ERRORS ) {
transferInfo->status = DtDND_FAILURE;
ii = numItems; /* break out of loop */
}
} /* end for each file */
break;
} /* end file transfer case */
case DtDND_BUFFER_TRANSFER:
{
/*
* Receiving a buffer drop.
* -- do nothing in transfer
*/
break;
} /* end buffer transfer case */
case DtDND_TEXT_TRANSFER:
{
/*
* Receiving a text drop.
*
* Text drag and drop is handled by Motif so this switch
* will never be called.
*
*/
break;
} /* end text transfer case */
default:
{
transferInfo->status = DtDND_FAILURE;
break;
}
} /* end switch */
} /* end TransferCallback */
/*-------------------------------------------------------------
** Function: static void RegisterDropZone (
** DtEditorWidget w)
**
** Parameters: A DtEditor widget
**
** Purpose: This routine registers the edit window's text widget
** as a drop site for file & buffer drops. Because it
** is a text widget it will automatically accept text
** drops.
*/
static void
RegisterDropZone(
DtEditorWidget w)
{
int ac;
Arg al[2];
XtCallbackRec transferCB[] = { {TransferCallback, NULL}, {NULL, NULL} };
XtCallbackRec animateCB[] = { {AnimateCallback, NULL}, {NULL, NULL} };
transferCB[0].closure = (XtPointer) w;
animateCB[0].closure = (XtPointer) w;
/*
* Register file & buffer transfers... let Motif handle text DnD
*/
ac=0;
XtSetArg( al[ac], DtNdropAnimateCallback, animateCB ); ac++;
DtDndDropRegister( M_text(w),
DtDND_FILENAME_TRANSFER|DtDND_BUFFER_TRANSFER,
XmDROP_COPY, transferCB, al, ac );
} /* end RegisterDropZone */
/*-------------------------------------------------------------
** Function: static void UnregisterDropZone (
** DtEditorWidget w)
**
** Parameters: A DtEditor widget
**
** Purpose: This routine unregisters the edit window
*/
static void
UnregisterDropZone(
DtEditorWidget w)
{
DtDndDropUnregister( M_text(w) );
} /* end UnregisterDropZone */
/************************************************************************
*
* SetInfoDialogTitle - Change the title for the Information dialog
*
************************************************************************/
static void
SetInfoDialogTitle(
DtEditorWidget editor)
{
Arg al[2];
/*
* If the Information dialog has been created, change its title
*/
if( M_gen_warning(editor) != (Widget)NULL )
{
/*
* Prepend the DialogTitle resource, if it has been set
*/
if( E_dialogTitle(editor) != (XmString)NULL ) {
XmString titleStr;
/*
* Add the "functional title" to the DialogTitle
*/
titleStr = XmStringConcat( E_dialogTitle(editor),
E_infoDialogTitle(editor) );
XtSetArg( al[0], XmNdialogTitle, titleStr );
XtSetValues(M_gen_warning(editor), al, 1);
XmStringFree( titleStr );
}
else {
XtSetArg( al[0], XmNdialogTitle, E_infoDialogTitle(editor) );
XtSetValues(M_gen_warning(editor), al, 1);
}
}
} /* end SetInfoDialogTitle */
/************************************************************************
*
* _DtEditorWarning - get a message to the user
*
************************************************************************/
void
_DtEditorWarning(
DtEditorWidget editor,
char *mess,
unsigned char dialogType)
{
Arg al[10];
int ac;
char *tmpMess;
XmString tmpStr;
tmpMess = strdup(mess);
/* create the dialog if it is the first time */
if(M_gen_warning(editor) == (Widget) NULL)
{
XmString titleStr = (XmString) NULL;
XmString okStr;
ac = 0;
/*
* First, create the dialog's title, prepending the
* DtNdialogTitle resource, if it is set
*/
if( E_dialogTitle(editor) != (XmString)NULL ) {
/*
* Add the "functional title" to the DialogTitle
*/
titleStr = XmStringConcat( E_dialogTitle(editor),
E_infoDialogTitle(editor) );
XtSetArg (al[ac], XmNdialogTitle, titleStr ); ac++;
}
else {
XtSetArg (al[ac], XmNdialogTitle, E_infoDialogTitle(editor)); ac++;
}
okStr = XmStringCreateLocalized((char*) _DtOkString);
XtSetArg (al[ac], XmNokLabelString, okStr); ac++;
M_gen_warning(editor) = (Widget) XmCreateMessageDialog(
M_topLevelShell(editor), "Warn",
al, ac);
if (titleStr != (XmString) NULL)
XmStringFree( titleStr );
XmStringFree(okStr);
/* Set the correct font lists for the message & OK button. */
XtSetArg (al[0], XmNfontList, E_buttonFontList(editor));
XtSetValues(
XmMessageBoxGetChild(M_gen_warning(editor), XmDIALOG_OK_BUTTON),
al, 1) ;
XtSetArg (al[0], XmNfontList, E_labelFontList(editor));
XtSetValues(
XmMessageBoxGetChild(M_gen_warning(editor), XmDIALOG_MESSAGE_LABEL),
al, 1) ;
/* Unmanage unneeded children. */
XtUnmanageChild ( XmMessageBoxGetChild(M_gen_warning(editor),
XmDIALOG_CANCEL_BUTTON) );
XtUnmanageChild ( XmMessageBoxGetChild(M_gen_warning(editor),
XmDIALOG_HELP_BUTTON) );
XtRealizeWidget (M_gen_warning(editor));
ac=0;
XtSetArg(al[ac], XmNmwmInputMode,
MWM_INPUT_PRIMARY_APPLICATION_MODAL);ac++;
XtSetValues(XtParent(M_gen_warning(editor)), al, ac);
}
tmpStr = XmStringCreateLocalized(tmpMess);
ac = 0;
XtSetArg(al[ac], XmNdialogType, dialogType); ac++;
XtSetArg(al[ac], XmNmessageString, tmpStr); ac++;
XtSetValues(M_gen_warning(editor), al, ac);
XmStringFree(tmpStr);
XtFree( (char *) tmpMess );
XtManageChild (M_gen_warning(editor));
} /* end _DtEditorWarning */
/*********************************************************************
*
* The following section contains the procedures related to the staus
* line
*
*********************************************************************/
#define FORCE True
#define DONT_FORCE False
/*
* PositionActivateCB is invoked when the user presses [Return] after
* (presumably) modifying the current line text field. It retrieves
* the user specified line number and calls DtEditorGoToLine().
*/
/* ARGSUSED */
static void
PositionActivateCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
DtEditorWidget editor = (DtEditorWidget)client_data;
char *lineStr = XmTextFieldGetString(M_status_lineText(editor));
int newLineNum = atoi(lineStr);
XtFree(lineStr);
DtEditorGoToLine ((Widget)editor, newLineNum);
XmProcessTraversal(M_text(editor), XmTRAVERSE_CURRENT);
} /* PositionActivateCB */
/*
* _DtEditorUpdateLineDisplay updates the current & total line displays
* in the status line, if needed. Normally, the displays are not changed
* if the correct numbers are (supposedly) displayed. Setting forceUpdate
* will cause the numbers to be updated anyways. This is primarily used
* when the user enters a number into the current line display to force
* display of the correct number.
*/
void
_DtEditorUpdateLineDisplay(
DtEditorWidget editor,
int currentLine,
Boolean forceUpdate )
{
XmTextWidget tw = (XmTextWidget) M_text(editor);
Arg al[10];
char tmpChars[8];
int lastLine;
XmString tmpXmStr;
/*
* Only change the current & total lines displays if the status
* line is visible
*/
if ( M_status_showStatusLine(editor) == True )
{
/*
* Current line
*/
if (M_status_currentLine(editor) != currentLine || forceUpdate)
{
sprintf(tmpChars, "%d", currentLine);
XmTextFieldSetString(M_status_lineText(editor), tmpChars);
M_status_currentLine(editor) = currentLine;
}
/*
* Total lines
*/
lastLine = tw->text.total_lines;
if(M_status_lastLine(editor) != lastLine )
{
sprintf(tmpChars, "%d", lastLine);
tmpXmStr = XmStringCreateLocalized(tmpChars);
XtSetArg(al[0], XmNlabelString, tmpXmStr);
XtSetValues( M_status_totalText(editor), al, 1 );
XmStringFree(tmpXmStr);
M_status_lastLine(editor) = lastLine;
}
}
} /* end _DtEditorUpdateLineDisplay */
static void
UpdateOverstrikeIndicator(
DtEditorWidget widget,
Boolean overstrikeOn )
{
Arg al[10];
int ac;
DtEditorWidget ew = (DtEditorWidget) widget;
/*
* Only change the overstrike indicator if the status line is visible
*/
if ( M_status_showStatusLine(ew) == True &&
M_status_overstrikeWidget(ew) != (Widget) NULL )
{
ac=0;
if ( overstrikeOn == True ) {
XtSetArg(al[ac], XmNlabelString, M_status_overstrikeLabel(ew)); ac++;
}
else {
XtSetArg(al[ac], XmNlabelString, M_status_insertLabel(ew)); ac++;
}
XtSetValues( M_status_overstrikeWidget(ew), al, ac );
}
} /* end UpdateOverstrikeIndicator */
int
_DtEditorGetLineIndex(
XmTextWidget tw,
XmTextPosition pos)
{
int startLine, lastLine, middleLine;
XmTextLineTable lineTab = tw->text.line_table;
startLine = 0;
lastLine = tw->text.total_lines - 1;
while(startLine != lastLine)
{
middleLine = (startLine + lastLine)/2;
if(middleLine == startLine || middleLine == lastLine)
{
/*
* We're down to 2 lines. It's gotta be on one of these
* two lines.
*/
if(pos < (XmTextPosition) lineTab[lastLine].start_pos)
lastLine = startLine;
else
startLine = lastLine;
}
else
{
if (pos < (XmTextPosition) lineTab[middleLine].start_pos)
lastLine = middleLine;
else
startLine = middleLine;
}
}
return startLine;
} /* end _DtEditorGetLineIndex */
/*
* SetCursorPosStatus is called as an XmNmotionVerifyCallback on the
* text widget when the statusLine is turned on. It computes and
* displays the new line of the insert cursor.
*/
static void
SetCursorPosStatus(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
DtEditorWidget editor = (DtEditorWidget)client_data;
XmTextWidget tw = (XmTextWidget)w;
XmTextVerifyCallbackStruct * cb = (XmTextVerifyCallbackStruct *) call_data;
int startLine;
startLine = _DtEditorGetLineIndex(tw, cb->newInsert) + 1;
_DtEditorUpdateLineDisplay( editor, startLine, FORCE );
} /* end SetCursorPosStatus */
static void
SetStatusLine(
DtEditorWidget ew,
Boolean statusLineOn)
{
Arg al[10];
int ac;
int currentLine;
XmTextPosition cursorPos;
M_status_showStatusLine(ew) = statusLineOn;
if( statusLineOn == True )
{
if( M_status_statusArea(ew) == (Widget)NULL )
M_status_statusArea(ew) = CreateStatusLine( ew );
/*
* Update the line counts
*/
cursorPos = (XmTextPosition)DtEditorGetInsertionPosition( (Widget)ew );
currentLine = _DtEditorGetLineIndex( (XmTextWidget) M_text(ew),
cursorPos ) + 1;
_DtEditorUpdateLineDisplay( ew, currentLine, DONT_FORCE );
/*
* Update the overstrike indicator
*/
UpdateOverstrikeIndicator( ew, M_overstrikeMode(ew) );
/*
* Show the status line
*/
XtManageChild( M_status_statusArea(ew) );
/*
* Hook the scrolled text widget to the status line
*/
ac = 0;
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_WIDGET ); ac++;
XtSetArg( al[ac], XmNbottomWidget, M_status_statusArea(ew) ); ac++;
XtSetValues( XtParent(M_text(ew)), al, ac );
XtAddCallback( M_text(ew), XmNmotionVerifyCallback,
(XtCallbackProc) SetCursorPosStatus, (XtPointer)ew);
}
else
{
/*
* Hook the scrolled text widget to the bottom of the form
*/
ac = 0;
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_FORM ); ac++;
XtSetValues( XtParent(M_text(ew)), al, ac );
XtRemoveCallback( M_text(ew), XmNmotionVerifyCallback,
(XtCallbackProc) SetCursorPosStatus, (XtPointer)ew);
/*
* Hide the status line
*/
if( M_status_statusArea(ew) != (Widget)NULL )
XtUnmanageChild( M_status_statusArea(ew) );
}
} /* SetStatusLine */
/************************************************************************
*
* CreateStatusLine - Creates the status line
*
************************************************************************/
static Widget
CreateStatusLine(
DtEditorWidget parent)
{
Arg al[20];
int ac;
Widget container;
XmString tmpStr;
Pixel background, foreground;
/*
* Match the background & foreground colors of the edit window
* Don't use DtNtextBackground/Foreground directly because they
* will be DtUNSPECIFIED.
*/
ac = 0;
XtSetArg(al[ac], XmNforeground, &foreground); ac++;
XtSetArg(al[ac], XmNbackground, &background); ac++;
XtGetValues(M_text(parent), al, ac);
/*
* Create the status line container
*/
ac = 0;
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNleftAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNrightAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNverticalSpacing, 3 ); ac++;
XtSetArg( al[ac], XmNhorizontalSpacing, 3 ); ac++;
container = (Widget) XmCreateForm( (Widget)parent, "statusLine",
al, ac );
/*
* Create the current line label and text field
*/
ac = 0;
if (E_status_currentLineLabel(parent) != (XmString)DtUNSPECIFIED)
{
/*
* Use the resource value & clear it (to save space).
*/
tmpStr = XmStringCopy(E_status_currentLineLabel(parent));
E_status_currentLineLabel(parent) = (XmString)DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tmpStr = XmStringCreateLocalized(LINE);
}
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNtopAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNleftAttachment, XmATTACH_FORM ); ac++;
XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
XtSetArg(al[ac], XmNfontList, E_labelFontList(parent) ); ac++;
M_status_lineLabel(parent) = (Widget) XmCreateLabelGadget( container,
"lineLabel", al, ac);
XtManageChild(M_status_lineLabel(parent));
XtAddCallback(M_status_lineLabel(parent), XmNhelpCallback,
(XtCallbackProc)HelpStatusCurrentLineCB, parent);
XmStringFree(tmpStr);
ac = 0;
XtSetArg(al[ac], XmNcolumns, 6); ac++;
XtSetArg(al[ac], XmNforeground, foreground); ac++;
XtSetArg(al[ac], XmNbackground, background); ac++;
XtSetArg( al[ac], XmNfontList, E_textFontList(parent)); ac++;
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNtopAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNleftAttachment, XmATTACH_WIDGET ); ac++;
XtSetArg( al[ac], XmNleftWidget, M_status_lineLabel(parent) ); ac++;
M_status_lineText(parent) = XmCreateTextField( container, "lineText",
al, ac );
XtManageChild(M_status_lineText(parent));
XtAddCallback(M_status_lineText(parent), XmNactivateCallback,
(XtCallbackProc)PositionActivateCB, parent);
XtAddCallback(M_status_lineText(parent), XmNhelpCallback,
(XtCallbackProc)HelpStatusCurrentLineCB, parent);
/*
* Create the total lines labels
*/
ac = 0;
if (E_status_totalLineCountLabel(parent) != (XmString)DtUNSPECIFIED)
{
/*
* Use the resource value & clear it (to save space).
*/
tmpStr = XmStringCopy(E_status_totalLineCountLabel(parent));
E_status_totalLineCountLabel(parent) = (XmString)DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tmpStr = XmStringCreateLocalized(TOTAL);
}
XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
XtSetArg(al[ac], XmNfontList, E_labelFontList(parent) ); ac++;
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNtopAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNleftAttachment, XmATTACH_WIDGET ); ac++;
XtSetArg( al[ac], XmNleftWidget, M_status_lineText(parent) ); ac++;
M_status_totalLabel(parent) = (Widget) XmCreateLabelGadget( container,
"totalLabel", al, ac);
XtManageChild(M_status_totalLabel(parent));
XtAddCallback(M_status_totalLabel(parent), XmNhelpCallback,
(XtCallbackProc)HelpStatusTotalLinesCB, parent);
XmStringFree(tmpStr);
ac = 0;
XtSetArg(al[ac], XmNfontList, E_labelFontList(parent) ); ac++;
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNtopAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNleftAttachment, XmATTACH_WIDGET ); ac++;
XtSetArg( al[ac], XmNleftWidget, M_status_totalLabel(parent) ); ac++;
M_status_totalText(parent) = (Widget) XmCreateLabelGadget( container,
"totalText", al, ac);
XtManageChild(M_status_totalText(parent));
XtAddCallback(M_status_totalText(parent), XmNhelpCallback,
(XtCallbackProc)HelpStatusTotalLinesCB, parent);
/*
* Create the overstrike indicator
*/
ac = 0;
/*
XtSetArg(al[ac], XmNrecomputeSize, False); ac++;
*/
XtSetArg(al[ac], XmNmarginLeft, 0); ac++;
XtSetArg(al[ac], XmNmarginRight, 0); ac++;
XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
XtSetArg( al[ac], XmNrightOffset, 3 ); ac++;
XtSetArg(al[ac], XmNfontList, E_labelFontList(parent) ); ac++;
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNtopAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNrightAttachment, XmATTACH_FORM ); ac++;
M_status_overstrikeWidget(parent) =
(Widget) XmCreateLabelGadget( container, "overstrikeLabel", al, ac);
XtManageChild(M_status_overstrikeWidget(parent));
XtAddCallback(M_status_overstrikeWidget(parent), XmNhelpCallback,
(XtCallbackProc)HelpStatusOverstrikeCB, parent);
/*
* Create the application message area
*/
ac = 0;
XtSetArg(al[ac], XmNbackground, parent->core.background_pixel); ac++;
XtSetArg(al[ac], XmNforeground, foreground); ac++;
XtSetArg( al[ac], XmNfontList, E_textFontList(parent)); ac++;
XtSetArg(al[ac], XmNeditable, False); ac++;
XtSetArg(al[ac], XmNcursorPositionVisible, False); ac++;
XtSetArg(al[ac], XmNtraversalOn, False); ac++;
XtSetArg( al[ac], XmNbottomAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNtopAttachment, XmATTACH_FORM ); ac++;
XtSetArg( al[ac], XmNleftAttachment, XmATTACH_WIDGET ); ac++;
XtSetArg( al[ac], XmNleftWidget, M_status_totalText(parent) ); ac++;
XtSetArg( al[ac], XmNleftOffset, 17 ); ac++;
XtSetArg( al[ac], XmNrightAttachment, XmATTACH_WIDGET ); ac++;
XtSetArg(al[ac], XmNrightWidget, M_status_overstrikeWidget(parent)); ac++;
M_status_messageText(parent) =
XmCreateTextField( container, "messageText", al, ac );
XtManageChild(M_status_messageText(parent));
XtAddCallback(M_status_messageText(parent), XmNhelpCallback,
(XtCallbackProc)HelpStatusMessageCB, parent);
return( container );
} /* end CreateStatusLine */
/*********************************************************************
*
* The following section contains the procedures related to help
*
*********************************************************************/
static void
CallHelpCallback(
DtEditorWidget editor,
int reason)
{
DtEditorHelpCallbackStruct help_cb;
help_cb.reason = reason;
help_cb.event = (XEvent *) NULL;
XtCallCallbackList( (Widget)editor, M_HelpCB(editor),
(XtPointer) &help_cb );
} /* end CallHelpCallback */
/****
* Edit window help callbacks
*/
/* ARGSUSED */
static void
HelpEditWindowCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback((DtEditorWidget)client_data, DtEDITOR_HELP_EDIT_WINDOW);
}
/****
* Status Line help callbacks
*/
/* XXX
* Who uses this??
*/
/* ARGSUSED */
static void
HelpStatusLineCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback((DtEditorWidget)client_data, DtEDITOR_HELP_STATUS_LINE);
}
/* ARGSUSED */
static void
HelpStatusCurrentLineCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_STATUS_CURRENT_LINE );
}
/* ARGSUSED */
static void
HelpStatusTotalLinesCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_STATUS_TOTAL_LINES );
}
/* ARGSUSED */
static void
HelpStatusMessageCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_STATUS_MESSAGE );
}
/* ARGSUSED */
static void
HelpStatusOverstrikeCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_STATUS_OVERSTRIKE );
}
/****
* Format Settings dialog help callbacks
*/
/* ARGSUSED */
static void
HelpFormatDialogCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback((DtEditorWidget)client_data, DtEDITOR_HELP_FORMAT_DIALOG);
}
/* ARGSUSED */
static void
HelpFormatRightMarginCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_FORMAT_RIGHT_MARGIN);
}
/* ARGSUSED */
static void
HelpFormatLeftMarginCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_FORMAT_LEFT_MARGIN);
}
/* ARGSUSED */
static void
HelpFormatJustifyButtonsCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_FORMAT_ALIGNMENT);
}
/****
* Find/Change & Spell dialogs help callbacks
*/
/* ARGSUSED */
void
_DtEditorHelpSearchCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
DtEditorWidget editor = (DtEditorWidget)client_data;
switch (M_search_dialogMode(editor))
{
case SPELL:
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_SPELL_DIALOG);
break;
case REPLACE:
default:
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_CHANGE_DIALOG);
break;
}
} /* _DtEditorHelpSearchCB */
/* ARGSUSED */
void
_DtEditorHelpSearchFindCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_CHANGE_FIND);
}
/* ARGSUSED */
void
_DtEditorHelpSearchChangeCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
DtEditorWidget editor = (DtEditorWidget)client_data;
switch (M_search_dialogMode(editor))
{
case SPELL:
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_SPELL_CHANGE);
break;
case REPLACE:
default:
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_CHANGE_CHANGE);
break;
}
} /* _DtEditorHelpSearchChangeCB */
/* ARGSUSED */
void
_DtEditorHelpSearchSpellCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
CallHelpCallback( (DtEditorWidget)client_data,
DtEDITOR_HELP_SPELL_MISSPELLED_WORDS);
}
/*********************************************************************
*
* The following section contains the procedures related to formating
* text and the Format Settings dialog.
*
*********************************************************************/
/*
* Do simple formatting of paragraphs of text.
* Designed for speed, at some cost in complexity and redundancy.
*
* There is a minor undocumented bug in Dump(). It calls Justify() in the
* case where the last word of the last line of a paragraph is an end-of-
* sentence word (typical) and ends just one blank before the margin
* (rare). This results in one blank being inserted in the line when it's
* not necessary. It happens because the two trailing blanks after the
* word cause an "ordinary" line dump before Fill() sees the next line and
* knows it has an end of paragraph. WARNING: The situation would be
* aggravated if FillWord() ever set blanks to an even larger number.
*/
/*
** This section contains changes for EUC_4B compatibility.
** WPI interface is used.
*/
/* Global Variables and extern declarations */
typedef struct _WORD{ /* describe one word */
wint_t *cp; /* word location in buffer */
int inlinenum; /* word start line in input */
int incolumn; /* word start column in input */
int length; /* size of word */
int score; /* word + next for jflag */
int blanks; /* output trailing blanks need */
int wclen; /* Length of wide character word */
} WORD;
typedef struct {
wchar_t Blank;
AdjRecPtr pAdj;
/* FORMATTING CONTROL */
int m0flag;
long fillmargin;
long centermiddle;
int tabsize; /* tab size in use */
int centerstartpara; /* expect para. start? in "Center" */
/* Global/static vars used in "Fill" */
wint_t *wordbuf; /* see comments for "Fill" for discussion */
wint_t *wordcp;
wint_t *wordcpwrap;
WORD *word;
WORD *wordbase;
WORD *wordlimit;
WORD *wordfirst;
WORD *wordat;
WORD *wordnext;
int inlinenum;
int incolumn;
int outlinenum;
int pendchars;
int indent1, indent2;
} FormatData;
#define isekinsoku(wc) iswctype((wc),ekinclass)
#define isbekinsoku(wc) iswctype((wc),bekinclass)
#define LINESIZE BUFSIZ /* how big a line can be */
#define WORDMAX LINESIZE /* see above for discussion */
#define WORDNEXT(d,at) { if (++at == d->wordlimit) at = d->wordbase; } /* statement */
#define WORDPREV(d,at) (((at == d->wordbase) ? d->wordlimit : at) - 1) /* function */
#include <locale.h>
extern int _nl_space_alt;
/*
* Forward declarations
*/
static int DoLine (FormatData *data, FILE *filep);
static void Center (FormatData *data,
wint_t *in_line, wint_t *inlinelim);
static void Fill (FormatData *data, wint_t *in_line, wint_t *inlinelim);
static void FillWord (FormatData *data);
static void Dump (FormatData *data, int endpara);
static void PrintIndent (FormatData *data, int indent);
static void PrintTag (FormatData *data, WORD *wordpast);
static void PrintWords (FormatData *data, WORD *wordpast);
static void Justify (FormatData *data, int blanks, WORD *wordpast);
static int CompareWords (const void *, const void *);
static int EkinBekinProc(FormatData *data, WORD **wordpast);
static void postEkinBekinProc(FormatData *data, int *poutchars, WORD *wordpast);
#if defined(sun)
/*
* A small workaround for systems that don't have wcwidth...
*/
static int
sun_wcwidth(
const wchar_t wc)
{
int status;
char mbstr[MB_LEN_MAX + 1];
status = wctomb(mbstr, wc);
if (status > 0)
return(euccol(mbstr));
else
return(status);
}
#endif /* sun */
/*
* The following utilities: lineBlank, findNonBlank, and countBlanks all
* require the lineLen parameter to specify the number of characters, not
* bytes, in the line.
*/
static Boolean
lineBlank(
char *pLine,
int lineLen)
{
int byteNum, charNum;
wchar_t wc;
size_t mbCurMax = MB_CUR_MAX;
for(byteNum = charNum = 0; charNum < lineLen;
byteNum += mblen(&pLine[byteNum], mbCurMax), charNum++)
{
(void) mbtowc(&wc, &pLine[byteNum], mbCurMax);
#if !(defined(sun) && (_XOPEN_VERSION==3))
if( !iswctype(wc, _DtEditor_blankClass) )
return False;
#else
if( !iswblank(wc) )
return False;
#endif /* not sun */
}
return True;
}
static char *
findNonBlank(
char *pLine,
int lineLen)
{
int byteNum, charNum;
wchar_t wc;
size_t mbCurMax = MB_CUR_MAX;
for(byteNum = charNum = 0; charNum < lineLen;
byteNum += mblen(&pLine[byteNum], mbCurMax), charNum++)
{
(void) mbtowc(&wc, &pLine[byteNum], mbCurMax);
#if !(defined(sun) && (_XOPEN_VERSION==3))
if( !iswctype(wc, _DtEditor_blankClass) )
return &pLine[byteNum];
#else
if(! iswblank(wc) )
return &pLine[byteNum];
#endif /* not sun */
}
return &pLine[byteNum];
}
static int
countBlanks(
char *pLine,
int lineLen)
{
int byteNum, charNum, count;
wchar_t wc;
size_t mbCurMax = MB_CUR_MAX;
for(byteNum = charNum = 0, count = 0; charNum < lineLen;
byteNum += mblen(&pLine[byteNum], mbCurMax), charNum++)
{
(void) mbtowc(&wc, &pLine[byteNum], mbCurMax);
if(iswcntrl(wc))
{
if(mblen(&pLine[byteNum], mbCurMax) == 1)
{
switch((int) pLine[byteNum])
{
/*
* I don't really know what to do with weird embedded chars.
* This is just a guess. In non-ascii locales this could
* screw up, but I don't know how else to deal with
* weird embedded control characters.
*/
case '\n': /* newline */
case '\f': /* form feed */
count++;
continue;
case '\t': /* horizontal tab */
count += 8;
continue;
case '\b': /* backspace */
count--;
continue;
case '\r': /* carriage return */
count = 0;
continue;
default:
return count;
}
}
else
count++; /* multibyte control chars??? */
continue;
}
#if !(defined(sun) && (_XOPEN_VERSION==3))
if(!iswctype(wc, _DtEditor_blankClass))
return count;
#else
if(! iswblank(wc) )
return count;
#endif /* not sun */
count++;
}
return count;
}
/*
* fixLeftMarginAndNewlines - writes out a substring from the text widget,
* inserting leading blanks as needed to set the left margin, and adding
* newlines at all "virtual" (i.e. word-wrapped) lines. It assumes that the
* specified substring is an integer number of lines - i.e. the substring
* cannot begin or end in the middle of a line. Non-complying substrings
* are expanded to encompass whole lines.
*/
static void
fixLeftMarginAndNewlines(
DtEditorWidget editor,
FILE *fp,
int leftMargin,
int rightMargin,
int startPos,
int endPos)
{
Widget widget = M_text(editor);
XmTextLineTable lineTable;
int i;
int lineIndex, lineLen, nextLen, lineIndent, lastIndex,
lineByteLen, total_lines;
Boolean newPara = True;
char *pLine, *pNext, *pFirstNonBlank, *pLastChar;
size_t mbCurMax = MB_CUR_MAX;
lineTable = _XmTextGetLineTable(widget, &total_lines);
if (leftMargin > rightMargin || leftMargin < 0)
leftMargin = 0;
lineIndent = leftMargin;
/*
* calculate the starting line number and ending line number
* for the [sub]string we're operating upon.
*/
lineIndex = _DtEditorGetLineIndex((XmTextWidget)M_text(editor), startPos);
lastIndex = _DtEditorGetLineIndex((XmTextWidget)M_text(editor), endPos);
/*
* This loop terminates with one line unwritten. This is correct
* if we're not formatting the last line of the file, as that means
* that we must be formatting a paragraph, and the paragraph adjust
* code has trouble locating the end of a paragraph (as opposed to the
* beginning of the next paragraph. If the last line of the text is
* to be formatted, it is handled after this loop terminates.
*/
for(; lineIndex < lastIndex; lineIndex++)
{
/*
* if the current line was word-wrapped, put out a nl.
*/
if(lineTable[lineIndex].virt_line)
fwrite("\n", sizeof(char), 1, fp);
lineLen = lineTable[lineIndex + 1].start_pos -
lineTable[lineIndex].start_pos;
pLine = _XmStringSourceGetString((XmTextWidget)M_text(editor),
lineTable[lineIndex].start_pos,
lineTable[lineIndex + 1].start_pos, False);
pLastChar = _DtEditorGetPointer(pLine, lineLen - 1);
lineByteLen = pLastChar - pLine + mblen(pLastChar, mbCurMax);
if(lineBlank(pLine, lineLen))
{
/*
* Blank lines indicate the start of a new paragraph.
* They also don't require any indent adjustment so are
* quick/easy to write out.
*/
fwrite( pLine, sizeof(char),
_DtEditorGetPointer(pLine, lineLen) - pLine, fp );
newPara = True;
XtFree(pLine);
continue;
}
if(newPara == True)
{
int firstIndent;
/*
* Calc the proper indent for the first line, and
* the indent for the rest of the lines
* in the paragraph. If there's only one line in the
* paragraph, then the proper indent is adjustStuff.left_margin.
*/
/*
* Get the next line.
*/
if((total_lines - lineIndex) > 2)
nextLen = lineTable[lineIndex + 2].start_pos -
lineTable[lineIndex + 1].start_pos;
else
nextLen = XmTextGetLastPosition(widget) -
lineTable[lineIndex + 1].start_pos;
pNext = _XmStringSourceGetString((XmTextWidget)M_text(editor),
lineTable[lineIndex + 1].start_pos,
lineTable[lineIndex + 1].start_pos + nextLen, False);
if(lineBlank(pNext, nextLen)) /* single line paragraph */
firstIndent = lineIndent = leftMargin;
else
{
int curFirstIndent, curSecondIndent, offset;
curFirstIndent = countBlanks(pLine, lineLen);
curSecondIndent = countBlanks(pNext, nextLen);
offset = curFirstIndent - curSecondIndent;
if(offset >= 0)
{
/* second line is closer to the left margin */
/*
* Note, the first line will still be indented even
* if the remaining words in the paragraph can
* all fit on the first line. The end result is a
* one line indented paragraph. I am mentioning
* this because some may think this is a defect.
*/
firstIndent = leftMargin + offset;
lineIndent = leftMargin;
}
else
{
firstIndent = leftMargin;
lineIndent = leftMargin - offset;
}
}
for(i = firstIndent; i-- > 0;)
fwrite(" ", sizeof(char), 1, fp); /* that's a _space_ */
pFirstNonBlank = findNonBlank(pLine, lineLen);
fwrite(pFirstNonBlank, sizeof(char), lineByteLen -
(pFirstNonBlank - pLine), fp);
newPara = False;
XtFree(pLine);
continue;
}
for(i = lineIndent; i-- > 0;)
fwrite(" ", sizeof(char), 1, fp); /* that's a _space_ */
pFirstNonBlank = findNonBlank(pLine, lineLen);
fwrite(pFirstNonBlank, sizeof(char), lineByteLen -
(pFirstNonBlank - pLine), fp);
XtFree(pLine);
}
if((total_lines - lineIndex) == 1)
{
/*
* Now we have to handle the last line.
*/
if(lineTable[lineIndex].virt_line)
fwrite("\n", sizeof(char), 1, fp);
if((total_lines - lineIndex) > 2)
lineLen = lineTable[lineIndex + 1].start_pos -
lineTable[lineIndex].start_pos;
else
lineLen = XmTextGetLastPosition(widget) -
lineTable[lineIndex].start_pos;
if(lineLen > 0)
{
for(i = lineIndent; i-- > 0;)
fwrite(" ", sizeof(char), 1, fp); /* that's a _space_ */
pLine = _XmStringSourceGetString((XmTextWidget)M_text(editor),
lineTable[lineIndex].start_pos,
lineTable[lineIndex].start_pos + lineLen, False);
pLastChar = _DtEditorGetPointer(pLine, lineLen - 1);
lineByteLen = pLastChar - pLine + mblen(pLastChar, mbCurMax);
if(lineBlank(pLine, lineLen))
{
fwrite(pLine, sizeof(char), lineByteLen, fp);
}
else
{
pFirstNonBlank = findNonBlank(pLine, lineLen);
fwrite(pFirstNonBlank, sizeof(char), lineByteLen -
(pFirstNonBlank - pLine), fp);
}
XtFree(pLine);
}
}
XtFree((XtPointer)lineTable);
}
/************************************************************************
* FormatText -
*
* Initialize, check arguments embedded in AdjRec, open and read files,
* and pass a series of lines to lower-level routines.
*/
static int
FormatText (
AdjRecPtr
pAdjRec)
{
long maxmargin; /* max allowed */
FILE *filep; /* file to read */
int retVal;
FormatData data;
/*
* INITIALIZE FOR NLS
*/
mbtowc(&data.Blank," ",1);
/*
* Initialize global/statics.
*/
if((data.wordbuf = malloc(sizeof(wint_t) * LINESIZE * 3)) == (wint_t *)NULL)
return 0;
if((data.word = malloc(sizeof(WORD) * WORDMAX)) == (WORD *)NULL)
{
retVal = 0;
goto CleanUp;
}
data.tabsize = 8; /* default tab size */
data.centerstartpara = True;
data.fillmargin = data.centermiddle = pAdjRec->margin;
data.m0flag = (data.fillmargin == 0L);
/*
* Initialize global/statics for "Fill".
*/
data.wordcp = data.wordbuf;
data.wordcpwrap = data.wordbuf + (LINESIZE * 2);
data.wordbase = & data.word [0];
data.wordlimit = & data.word [WORDMAX];
data.wordfirst = & data.word [0];
data.wordnext = & data.word [0];
data.inlinenum = 0;
data.outlinenum = 1;
data.pendchars = 0;
/*
* CHECK ARGUMENTS:
*/
if (pAdjRec->cflag + pAdjRec->jflag + pAdjRec->rflag > 1)
{
retVal = 0;
goto CleanUp;
}
maxmargin = pAdjRec->cflag? (LINESIZE / 2) : LINESIZE;
if ((data.fillmargin < 0L) || (data.fillmargin > maxmargin))
{
retVal = 0;
goto CleanUp;
}
if ((pAdjRec->tabsize > 0) && (pAdjRec->tabsize <= MAXTABSIZE))
data.tabsize = pAdjRec->tabsize;
/*
* OPEN AND READ INPUT FILE:
*/
filep = pAdjRec->infp;
data.pAdj = pAdjRec; /* set (file) global var to passed in rec */
while (DoLine (&data, filep))
;
/*
* DUMP LAST LINE AND EXIT:
*/
if (! data.pAdj->cflag) /* not centering */
{
Dump (&data, True); /* force end paragraph */
}
retVal = 1;
CleanUp:
if(data.wordbuf != (wint_t *)NULL)
{
free(data.wordbuf);
}
if(data.word != (WORD *)NULL)
{
free(data.word);
}
return retVal;
}
/************************************************************************
* D O L I N E
*
* Read one input line and do generic processing (read chars from input
* to in_line, crunching backspaces). Return True if successful, else
* false at end of input file. This must be done before expanding tabs;
* pass half-processed line to Center() or Fill() for more work.
*
* Assumes getc() is efficient.
* in_line[] is static so it is only allocated once.
*/
static int
DoLine (FormatData *data,
FILE *filep) /* open file to read */
{
wint_t in_line [LINESIZE]; /* after reading in */
wint_t *incp = in_line; /* place in in_line */
wint_t *incplim = in_line + LINESIZE; /* limit of in_line */
wint_t c;
/*
* READ LINE WITH BACKSPACE CRUNCHING:
*/
while (incp < incplim) /* buffer not full */
{
c = getwc (filep); /* get and save wide char */
switch(c)
{
case WEOF:
if (incp == in_line) /* nothing read yet */
return (False);
case L'\0': /* fall through */
case L'\n': /* end of line */
incplim = incp; /* set limit (quit loop) */
break;
case L'\b': /* backspace */
if (incp > in_line) /* not at start */
incp--; /* just back up */
break;
default: /* any other char */
*incp++ = c;
break;
}
}
/* now incplim is correctly set to last char + 1 */
/*
* PASS LINE ON FOR MORE WORK:
*/
if (data->pAdj->cflag) Center (data, in_line, incplim);
else Fill (data, in_line, incplim);
return (True); /* maybe more to read */
} /* DoLine */
/************************************************************************
* C E N T E R
*
* Center text (starting at in_line, ending before inlinelim). First copy
* chars from in_line to outline skipping nonprintables and expanding tabs.
* For efficiency (at the cost of simplicity), note and skip indentation
* at the same time. Then, print outline with indentation to center it.
*
* outline[] is static so it is only allocated once; startpara so it is
* used for successive lines.
*/
static void
Center (FormatData *data,
wint_t *in_line, /* start of input line */
wint_t *inlinelim) /* end of line + 1 */
{
wint_t *incp; /* pointer in in_line */
wint_t outline [LINESIZE + MAXTABSIZE]; /* after generic work */
wint_t *outcp = outline; /* place in outline */
wint_t *outlinelim = outline + LINESIZE; /* limit of outline*/
int haveword = False; /* hit word in in_line? */
wint_t ch; /* current working char */
int needsp; /* spaces need for tab */
int indent = 0; /* size of indentation */
int textwidth; /* size of text part */
int extwidth = 0; /* additional width for MBCS */
/*
* SCAN INPUT LINE:
*/
for (incp = in_line; (incp < inlinelim) && (outcp < outlinelim); incp++)
{
ch = *incp;
/*
* SKIP WHITE SPACE:
*/
if (iswspace(ch))
{
needsp = ((ch != L'\t') && (iswblank(ch))) ?
1 : data->tabsize - ((indent + outcp - outline) % data->tabsize);
if (! haveword) /* indentation */
indent += needsp;
else /* past text */
for ( ; needsp > 0; needsp--)
*outcp++ = data->Blank;
}
/*
* CARRY OVER PRINTABLE CHARS AND NOTE INDENTATION:
*/
else if (iswprint (ch)) /* note: ch != ' ' */
{
*outcp++ = ch; /* just copy it over */
haveword = True;
if(MB_CUR_MAX > 1 && wcwidth(ch) > 1)
extwidth += wcwidth(ch) - 1;
}
/* else do nothing, which tosses other chars */
} /* end for */
/* Now outcp is the new outlinelim */
/*
* HANDLE BLANK LINE (no text):
*/
if (! haveword)
{
putc ('\n', data->pAdj->outfp); /* "eat" any whitespace */
data->centerstartpara = True; /* expect new paragraph */
}
/*
* EAT TRAILING BLANKS, SET TEXTWIDTH:
*/
else
{
/* note that outcp > outline */
while ((outcp[-1] != L'\t') && iswblank(outcp [-1]))
outcp--;
textwidth = (outcp - outline); /* thus textwidth > 0 */
/*
* SET AUTOMARGIN AND PRINT CENTERED LINE:
*
* The equations used depend on truncating division:
*
* eqn. 1 eqn. 2
* Margin Middle Width Results
* odd exact odd exact centering
* odd exact even extra char to right
* even left odd extra char to left
* even left even exact centering (due to "extra" char to right)
*
* When centermiddle is default or given by user, it is the same as the
* first two lines above (middle exactly specified).
*/
if (data->centerstartpara) /* start of paragraph */
{
data->centerstartpara = False;
if (data->m0flag) /* set automargin */
/* 1 */ data->centermiddle = (indent + textwidth + extwidth + 1) / 2;
}
/* 2 */ PrintIndent (data, data->centermiddle - ((textwidth + extwidth + 1) / 2));
{
int i;
for(i = 0; i < textwidth; i++)
{
putwc(outline[i], data->pAdj->outfp);
}
putc('\n', data->pAdj->outfp);
}
} /* else */
} /* Center */
/************************************************************************
* WORD DATA STRUCTURES USED TO TRACK WORDS WHILE FILLING:
*
* This complicated scheme is used to minimize the actual data moving
* and manipulation needed to do the job.
*
* Words are kept in wordbuf[] without trailing nulls. It is large enough
* to accommodate two lines' worth of words plus wrap around to start a new
* word (which might be as big as a line) without overwriting old words
* not yet dumped. wordcp -> next free location in wordbuf[];
* wordcpwrap -> last place a new word is allowed to start.
*
* Words are pointed to and described by word[] structures. The array is
* big enough to accommodate two lines' worth of words, assuming each word
* takes at least two characters (including separator). wordbase and
* wordlimit are the bounds of the array. wordfirst remembers the first
* word in the array not yet printed. wordat is the word being worked on
* after wordnext is advanced (and maybe wrapped around). New elements
* are "allocated" using wordnext, a pointer that is wrapped around as
* needed.
*
* inlinenum and incolumn track the current input line and column per
* paragraph. outlinenum tracks the next line to print. All are base 1,
* but inlinenum is preset to zero at the start of each paragraph.
*
* pendchars tracks the number of dumpable characters accrued so far, to
* trigger dumping. indent1 and indent2 remember the indentations seen
* for the first two lines of each paragraph.
*/
/************************************************************************
* F I L L
*
* Parse an input line (in_line to inlinelim) into words and trigger
* FillWord() as needed to finish each word, which in turn can call
* Dump() to dump output lines. This routine sacrifices simplicity and
* clarity for efficiency. It uses shared global word data except
* outlinenum and pendchars.
*/
static void
Fill (FormatData *data,
wint_t *in_line, /* start of input line */
wint_t *inlinelim) /* end of line + 1 */
{
wint_t *incp; /* place in in_line */
wint_t ch; /* current working char */
int haveword = False; /* hit word in in_line? */
int inword = False; /* currently in a word? */
/*
* SCAN INPUT LINE:
*/
data->inlinenum++;
data->incolumn = 1; /* starting a line */
for (incp = in_line; incp < inlinelim; incp++)
{
ch = *incp;
/*
* AT WHITE SPACE; FINISH PREVIOUS WORD if any, then skip white space:
*/
if (iswspace(ch))
{
if (inword) /* was skipping a word */
{
inword = False;
FillWord(data);
}
data->incolumn += ((ch != L'\t') && (iswblank(ch))) ?
1 : data->tabsize - ((data->incolumn - 1) % data->tabsize);
}
/*
* AT PART OF WORD; START NEW ONE IF NEEDED:
*/
else if (iswprint (ch))
{
if (! inword) /* start new word */
{
inword = True;
if (data->wordcp > data->wordcpwrap)/* past wrap point */
data->wordcp = data->wordbuf;/* wraparound buffer */
data->wordat = data->wordnext;
WORDNEXT (data,data->wordnext);
data->wordat->cp = data->wordcp; /* note start of word */
data->wordat->inlinenum = data->inlinenum; /* note input line */
data->wordat->incolumn = data->incolumn; /* note input column */
data->wordat->wclen = 0;
if (! haveword)
{
haveword = True;
switch (data->inlinenum)/* note indentations */
{
case 1:
data->indent1 = data->incolumn - 1;
break;
case 2:
data->indent2 = data->incolumn - 1;
break;
}
}
}
/*
* SAVE ONE CHAR OF WORD:
*/
*(data->wordcp++) = ch;
{
int n = wcwidth(ch);
if (n > 0)
{ /* == 0 for a null char */
data->incolumn += n;
data->wordat->wclen++;
}
}
} /* else */
/* else skip other chars by doing nothing */
} /* for */
/*
* END OF LINE; HANDLE BLANK LINE, OR FINISH WORD AND AUTOMARGIN:
*/
if (! haveword) /* no text on line */
{
data->inlinenum--; /* don't count empty lines */
Dump (data, True); /* force end paragraph */
fputc ('\n', data->pAdj->outfp); /* put this empty line */
data->inlinenum = 0; /* start new paragraph */
}
else /* have text on line */
{
if (inword) /* line ends in word */
FillWord(data);
if (data->pendchars > data->fillmargin)
{ /* time to dump line */
Dump (data, False); /* not end of paragraph */
}
if (data->m0flag && (data->inlinenum == 1)) /* need to note right margin */
data->fillmargin = data->wordat->incolumn + data->wordat->length - 1;
}
} /* Fill */
/************************************************************************
* F I L L W O R D
*
* Save values for the word just finished and dump the output line if
* needed. Uses shared global word values, but does not touch outlinenum,
* and only increments pendchars.
*
* Trailing blanks (1 or 2) needed after a word are figured here.
* wordlen is the total length (nonzero) and wordcp points to the char
* past the end of the word. Two blanks are needed after words ending in:
*
* <terminal>[<quote>][<close>]
*
* where <terminal> is any of . : ? !
* <quote> is any of ' "
* <close> is any of ) ] }
*
* For efficiency, this routine avoids calling others to do character
* matching; it does them in line.
*/
static void
FillWord (FormatData *data)
{
int wordlen; /* length of word to fill */
int blanks = 1; /* trailing blanks needed */
wint_t ch1, ch2, ch3; /* last chars of word */
data->wordat->length = (data->incolumn - data->wordat->incolumn);
wordlen = data->wordat->wclen;
/*
* CHECK FOR SPECIAL END OF WORD:
*/
ch3 = data->wordcp [-1];
if ((ch3 == L'.') || (ch3 == L':') || (ch3 == L'?') || (ch3 ==L'!'))
{
blanks = 2; /* <terminal> */
}
else if (wordlen >= 2)
{
ch2 = data->wordcp [-2];
if( ((ch2 == L'.') || (ch2 == L':') || (ch2 ==L'?') || (ch2 == L'!')) &&
((ch3 == L'\'') || (ch3 == L'"') || (ch3 ==L')') || (ch3 == L']')
|| (ch3 == L'}'))
)
{
blanks = 2; /* <terminal><quote or close> */
}
else if (wordlen >= 3)
{
ch1 = data->wordcp [-3];
if( ((ch1 == L'.') || (ch1 == L':') || (ch1 == L'?') || (ch1 == L'!'))
&& ((ch2 == L'\'') || (ch2 == L'"'))
&& ((ch3 == L')') || (ch3 == L']') || (ch3 == L'}')) )
{
blanks = 2; /* <terminal><quote><close> */
}
}
} /* else */
/*
* SAVE VALUES
*/
data->pendchars += wordlen + (data->wordat->blanks = blanks);
} /* FillWord */
/************************************************************************
* D U M P
*
* Print output line(s), with all necessary indentation and formatting,
* if required (at end of paragraph) or if permissible. If required,
* indent1 is used if indent2 is not set yet (not on second line of
* input). Otherwise, if not at end of paragraph, dumping is only
* permissible after beginning the second input line, so fillmargin and
* indent2 are known, so tagged paragraphs are done right.
*
* Whenever dumping, all "full" lines are dumped, which means more than
* just one may be printed per call. jflag or rflag formatting is
* applied to all lines, except that jflag is ignored for the last line
* of each paragraph.
*
* Uses shared global word data, but does not touch inlinenum, incolumn,
* indent1, or indent2.
*/
static void
Dump (FormatData *data,
int endpara) /* end of paragraph? */
{
int haveindent2 = (data->inlinenum >= 2); /* indent2 known? */
int startpara; /* start of paragraph? */
int normal; /* non-tagged line? */
WORD *wordpast = data->wordfirst; /* past last to dump */
int wordlen; /* length of one word */
int indent; /* local value */
int outneed; /* chars need to dump */
int outchars; /* chars found to dump */
/*
* IF DUMPING NEEDED, DUMP LINES TILL DONE:
*/
if (! (endpara || haveindent2)) /* not time to dump */
return;
while ( (data->pendchars > data->fillmargin) /* line is full */
|| (endpara && (data->wordfirst != data->wordnext)) ) /* more to dump */
{
startpara = (data->outlinenum < 2);
indent = (startpara || (! haveindent2)) ? data->indent1 : data->indent2;
/*
* CHECK FOR TAGGED PARAGRAPH if needed:
*/
normal = True; /* default == no tag */
if (startpara && haveindent2 && (data->indent1 < data->indent2))
{
int incol2 = data->indent2 + 1; /* column needed */
while ( (wordpast != data->wordnext) /* more words */
&& (wordpast->inlinenum == 1)) /* from line 1 */
{
if (wordpast->incolumn == incol2) /* bingo */
{
normal = False;
break;
}
WORDNEXT (data,wordpast);
}
if (normal)
wordpast = data->wordfirst; /* reset value */
/*
* PRINT TAG PART OF TAGGED PARAGRAPH:
*/
else
{
WORD *wordat = data->wordfirst; /* local value */
while (wordat != wordpast) /* decrement pendchars */
{
data->pendchars -= wordat->length + wordat->blanks;
WORDNEXT (data,wordat);
}
PrintIndent (data, indent);
PrintTag (data, wordpast); /* preceding words */
data->wordfirst = wordpast; /* do rest of line */
indent = data->indent2; /* as if second line */
}
} /* if */
/*
* FIND WORDS WHICH FIT ON [REST OF] LINE:
*/
if (indent >= data->fillmargin) /* don't over indent */
indent = data->fillmargin - 1;
outneed = data->fillmargin - indent; /* always greater than zero */
outchars = 0;
wordlen = wordpast->length;
do { /* always consume one */
outchars += wordlen + wordpast->blanks;
WORDNEXT (data,wordpast);
} while ( (wordpast != data->wordnext) /* not last word */
&& (outchars + (wordlen = wordpast->length) <= outneed)
);
/* next will fit */
/*
** BEKINSOKU/EKINSOKU PROCESSING
*/
if( EkinBekinProc(data, &wordpast) )
postEkinBekinProc(data, &outchars,wordpast);
data->pendchars -= outchars; /* pendchars to consume */
/* from now on, don't include trailing blanks on last word */
outchars -= (WORDPREV (data,wordpast) -> blanks);
/* now wordfirst and wordpast specify the words to dump */
/*
* PRINT INDENTATION AND PREPARE JUSTIFICATION:
*/
if (data->pAdj->rflag) /* right-justify only */
{
if (normal) /* nothing printed yet */
PrintIndent (data, data->fillmargin - outchars);
else /* indent + tag printed */
{
int blanks = data->fillmargin - outchars - indent;
while (blanks-- > 0) /* can't use PrintIndent()*/
putwc(data->Blank, data->pAdj->outfp);
}
}
else
{
if (normal) /* not already done */
PrintIndent (data, indent);
if (data->pAdj->jflag && ! (endpara && (wordpast == data->wordnext)))
Justify (data, outneed - outchars, wordpast);
}
/*
* PRINT REST OF LINE:
*/
PrintWords (data, wordpast);
putwc('\n', data->pAdj->outfp);
data->wordfirst = wordpast;
data->outlinenum++; /* affects startpara */
} /* while */
if (endpara)
data->outlinenum = 1;
} /* Dump */
/************************************************************************
* P R I N T I N D E N T
*
* Print line indentation (if > 0), optionally using tabs where possible.
* Does not print a newline.
*/
static void
PrintIndent (FormatData *data,
int indent) /* leading indentation */
{
if (indent > 0) /* indentation needed */
{
if (! data->pAdj->bflag) /* unexpand leading blanks */
{
while (indent >= data->tabsize)
{
putc ('\t', data->pAdj->outfp);
indent -= data->tabsize;
}
}
fprintf (data->pAdj->outfp, "%*s", indent, "");/*[remaining] blanks */
}
} /* PrintIndent */
/************************************************************************
* P R I N T T A G
*
* Print paragraph tag words from word[] array beginning with (global)
* wordfirst and ending before (parameter) wordpast, using input column
* positions in each word's data. Assumes indentation of indent1 was
* already printed on the line. Assumes *wordpast is the next word on
* the line and its column position is valid, and appends spaces up to
* the start of that word. Doesn't print a newline.
*
* Line indentation must already be done, as this routine doesn't know
* how to print leading tabs, only blanks.
*/
static void
PrintTag (FormatData *data,
WORD *wordpast) /* past last to print */
{
WORD *wordat = data->wordfirst; /* local value */
int outcol = data->indent1 + 1; /* next column */
int wordcol; /* desired column */
wint_t *wordcp; /* place in word */
wint_t *wordcplim; /* limit of word */
while (True) /* till break */
{
wordcol = wordat->incolumn;
while (outcol < wordcol)/* space over to word */
{
putwc(data->Blank, data->pAdj->outfp);
outcol++;
}
if (wordat == wordpast) /* past last word */
break; /* quit the loop */
wordcp = wordat->cp;
wordcplim = wordcp + wordat->wclen;
while (wordcp < wordcplim) /* print word */
putwc(*wordcp++, data->pAdj->outfp);
outcol += wordat->length;
WORDNEXT (data,wordat);
}
} /* PrintTag */
/************************************************************************
* P R I N T W O R D S
*
* Print words from word[] array beginning with (global) wordfirst and
* ending before (parameter) wordpast, using word sizes and trailing
* blanks (except for last word on line). Doesn't print a newline.
*/
static void
PrintWords (FormatData *data,
WORD *wordpast) /* past last to print */
{
WORD *wordat = data->wordfirst; /* local value */
wint_t *wordcp; /* place in word */
wint_t *wordcplim; /* limit of word */
int blanks; /* after a word */
while (True) /* till break */
{
wordcp = wordat->cp;
wordcplim = wordcp + wordat->wclen;
blanks = wordat->blanks; /* set before do WORDNEXT() */
while (wordcp < wordcplim) /* print word */
{
putwc(*wordcp++, data->pAdj->outfp);
}
wordat->wclen = 0;
WORDNEXT (data,wordat);
if (wordat == wordpast) /* just did last word */
break;
while (blanks-- > 0) /* print trailing blanks */
putwc(data->Blank, data->pAdj->outfp);
}
} /* PrintWords */
/************************************************************************
* J U S T I F Y
*
* Do left/right justification of [part of] a line in the word[] array
* beginning with (global) wordfirst and ending before (parameter)
* wordpast, by figuring where to insert blanks.
*
* Gives each word (except the last on the line) a score based on its
* size plus the size of the next word. Quicksorts word indices into
* order of current trailing blanks (least first), then score (most
* first). Cycles through this list adding trailing blanks to word[]
* entries such that words will space out nicely when printed.
*/
static void
Justify (FormatData *data,
int blanks, /* blanks to insert */
WORD *wordpast) /* past last to print */
{
WORD *wordat; /* local value */
int sortat; /* place in sort[] */
int wordlen; /* size of this word */
int nextlen; /* size of next word */
int level; /* current blanks level */
WORD *sort [WORDMAX]; /* sorted pointers */
int words; /* words in sort[] */
wordat = WORDPREV (data,wordpast); /* last word on line */
if ((blanks < 1) || (wordat == data->wordfirst))
return; /* can't do anything */
/*
* COMPUTE SCORES FOR WORDS AND SORT INDICES:
*
* March backwards through the words on line, starting with next to last.
*/
words = 0;
nextlen = wordat->length; /* length of last word */
do { /* always at least one */
wordat = WORDPREV (data,wordat);
wordlen = wordat->length;
wordat->score = wordlen + nextlen; /* this plus next */
nextlen = wordlen;
sort [words++] = wordat; /* prepare for sorting */
} while (wordat != data->wordfirst);
qsort ((wint_t *) sort, words, sizeof (WORD *), CompareWords);
/*
* ADD TRAILING BLANKS TO PAD OUT WORDS:
*
* Each pass through the sorted list adds one trailing blank to each word
* not already past the current level. Thus all one-blank words are brought
* up to two; then all twos up to three; etc.
*/
level = 0;
while (True) /* till return */
{
level++;
for (sortat = 0; sortat < words; sortat++)
{
wordat = sort [sortat];
if (wordat->blanks > level) /* end of this level */
break; /* start next level */
wordat->blanks++;
if (--blanks <= 0) /* no more needed */
return;
}
}
} /* Justify */
/************************************************************************
* C O M P A R E W O R D S
*
* Compare two word[] entries based on pointers to (WORD *), as called
* from qsort(3). Tell which entry has priority for receiving inserted
* blanks (least trailing blanks first, then highest scores), by returning
* -1 for the first entry, +1 for second entry, or 0 if no difference.
* (-1 literally means first entry < second entry, so it sorts first.)
*/
static int
CompareWords (const void *p1, const void *p2)
{
WORD *word1 = *((WORD **)p1); /* (WORD *) pointers */
WORD *word2 = *((WORD **)p2);
int blanks1 = word1->blanks; /* trailing blanks */
int blanks2 = word2->blanks;
if (blanks1 == blanks2) /* commonest case */
{
int score1 = word1->score; /* word scores */
int score2 = word2->score;
if (score1 > score2) return (-1); /* word1 has priority */
else if (score1 < score2) return ( 1);
else return (0);
}
else if (blanks1 < blanks2) return (-1); /* word1 has priority */
else return ( 1);
} /* CompareWords */
/*
** BKINSOKU and EKINSOKU processing for Japanese text
**
** The function scans the wordlist that are ready for printing
** and updates the "wordpast" pointer based on the rules of
** BKINSOKU and EKINSOKU characters.
**
** The code does not split a line just after a "gyomatu kinsoku"
** character and just before a "gyoto kinsoku" character.
** "Gyomatsu kinsoku" (e-kinsoku) are characters which cannot be
** placed at the end of a line. "Gyoto kinsoku" (b-kinsoku) are
** characters which can not be placed at the top of a line.
**
** Global variables used:
** wordfirst - beginning the word list (buffer of pending lines)
** wordnext - next available spot in the pending buffer (i.e.
** end of the buffer).
**
** Global variables modified:
** None.
**
** Return Values:
** 0 - No Post processing is required.
** 1 - Post processing is required
*/
#if !(defined(sun) && (_XOPEN_VERSION==3))
static int
EkinBekinProc(FormatData *data,
WORD **wordpast)
{
WORD *curword,*compword,*prevword;
int ekinflag = False, margin;
/*
* curword points to the last word of the first line.
* compword points to the first word of the next line or to the next
* available spot if there is no next line.
*/
compword = *wordpast;
curword = WORDPREV(data,compword);
/*
* If the length of the current word is > fillmargin
* or it is the only word then return.
*/
if (curword->length > data->fillmargin || (curword == data->wordfirst))
return False;
/*
* EKINSOKU processing
* If this character set supports ekinclass (can't end a line) char,
* start at the end of the line and search back until
* 1) we find a non-ekinsoku character, or
* 2) come to the beginning of the pending buffer.
*/
if (ekinclass)
{
while (isekinsoku(*(curword->cp+curword->wclen-1)))
{
ekinflag = True;
if (curword == data->wordfirst) /* Boundary Condition */
break;
curword = WORDPREV(data,curword);
}
/*
* Post EKIN processing (i.e. we found an ekinsoku character in
* the line before finding an non-ekinsoku).
*/
if (ekinflag) {
if (curword != data->wordfirst) {
/*
* We found a non-ekinsoku after we found the ekinsoku.
* Move the end of line to just after the non-ekinsoku.
*/
WORDNEXT(data,curword);
*wordpast = curword;
return True;
}
else { /* Boundary condition */
/*
* Reached the beginning of the buffer without finding a
* non-ekinsoku. If the last word in the line can begin
* a line (i.e. non-bkinsoku) make it the first word of
* the next line.
*/
curword = WORDPREV(data,compword);
if (!isbekinsoku(*curword->cp)) {
*wordpast = curword;
return True;
}
return False;
}
}
}
/*
* If we reached this point then:
* 1) the character set does not support ekinclass characters, or
* 2) the last character in the line is non-ekinsoku.
* Now, need to see if we can begin the next line with the first
* character on that line.
*/
/*
* BEKINSOKU processing
* If this character set supports bekinclass (can't begin a line) char,
* search forward from the begining of the next line (curword) to the
* end of the buffer (wordnext) until:
* 1) A non-bekinsoku word is found,
* 2) if the line limit exceeds the set value, or
* 3) we reach the end of the buffer.
*/
if (bekinclass)
{
/*
* compword points to the first word of the next line.
*/
curword = compword;
margin = data->indent2;
while (curword != data->wordnext)
{
if (!isbekinsoku(*curword->cp))
break;
margin += (curword->length + curword->blanks);
if (margin >= data->fillmargin)
return False;
WORDNEXT(data,curword);
}
if (curword != data->wordnext && curword != compword)
{
/*
* The first word of the second line is bekinsoku so search
* backwards from end of first line until we are:
* 1) not at the first word of the buffer, and
* 2) not in between either an ekinsoku or bekinsoku character.
*/
/*
* compword points to the first word of the next line.
* curword points to the last word of the first line.
*/
curword = WORDPREV(data,compword);
prevword = WORDPREV(data,curword);
while ( (curword != data->wordfirst) &&
(isbekinsoku(*curword->cp) ||
isekinsoku(*(prevword->cp+prevword->wclen-1)))
)
{
margin += curword->length + curword->blanks;
if (margin >= data->fillmargin)
return False;
curword = prevword;
prevword = WORDPREV(data,curword);
}
if (curword != data->wordfirst) {
/*
* Did not reach the beginning of the buffer so we are between
* two non-ekinsoku & non-bekinsoku characters. Move the end
* of the first line here.
*/
*wordpast = curword;
return True;
}
}
return False;
}
return False;
} /* end EkinBekinProc */
#else
static int
EkinBekinProc(FormatData *data,
WORD **wordpast)
{
WORD *curword,*compword,*prevword,*nextword;
int margin = data->indent2;
/*
* prevword points to the last word of the first line.
* compword & curword point to the first word of the next line or
* to the next available spot in the buffer if there is no next line.
*/
compword = *wordpast;
curword = compword;
prevword = WORDPREV(data,curword);
/*
* If the length of the previous word is > fillmargin
* or it is the only word in the line then return.
* wordfirst points to the beginning of the buffer of pending lines.
*/
if (prevword->length > data->fillmargin || (prevword == data->wordfirst))
return False;
/*
* Starting at the beginning of the next line, search backwards
* until:
* 1) we find two words we can split between lines, or
* 2) we reach the beginning of the buffer.
*
* If there is no next line start with the last two words of this line
* (wordnext points to the next available space in the buffer (i.e
* the end of the buffer).
*/
if (curword == data->wordnext) {
curword = prevword;
prevword = WORDPREV(data,curword);
}
while ( (curword != data->wordfirst) &&
(wdbindf(*(prevword->cp+prevword->wclen-1), *curword->cp, 1) >4)
)
{
curword = prevword;
prevword = WORDPREV(data,curword);
}
if (curword != data->wordfirst) {
/*
* Did not reach the beginning of the buffer so we are between
* two non-ekinsoku & non-bekinsoku characters. Move the end
* of the first line here.
*/
*wordpast = curword;
return True;
}
else {
/*
* Reached the beginning of the buffer so search forward
* from the beginning of the second line until:
* 1) we find two words we can split between lines,
* 2) we reach the end of the buffer, or
* 3) the line becomes too long.
*
* If there is no next line then just exit.
*/
/*
* compword points to the first word of the next line or to the
* next available spot in the buffer if there is no next line.
* nextword points to the second word of the next line.
* wordnext points to the next available space in the buffer (i.e
* the end of the buffer)
*/
curword = compword;
nextword = compword;
WORDNEXT(data,nextword);
if (curword == data->wordnext)
return False;
while (nextword != data->wordnext)
{
if (wdbindf(*(curword->cp+curword->wclen-1), *nextword->cp, 1) < 5)
break;
margin += (curword->length + curword->blanks);
if (margin >= data->fillmargin)
return False;
curword = nextword;
WORDNEXT(data,nextword);
}
if (nextword != data->wordnext) {
/*
* Did not reach the end of the buffer so we are between
* two non-ekinsoku & non-bekinsoku characters. Move the end
* of the first line here.
*/
*wordpast = nextword;
return True;
}
return False;
}
} /* end EkinBekinProc */
#endif /* not sun */
static void
postEkinBekinProc(FormatData *data,
int *poutchars,
WORD *wordpast)
{
WORD *curword;
int colvalue,curlineno;
/*
* Recompute the value of *poutchars
*/
(*poutchars) = 0;
curword = data->wordfirst;
while (curword != wordpast)
{
(*poutchars) += curword->length + curword->blanks;
WORDNEXT(data,curword);
}
/*
** Adjust the word parameters -
** inlinenum,incolumn of all the words
** from 'curword' till 'wordnext'
*/
curword = wordpast;
curlineno = curword->inlinenum+1;
colvalue = data->indent2;
while (curword != data->wordnext)
{
curword->inlinenum = curlineno;
curword->incolumn = colvalue;
colvalue += curword->length + curword->blanks;
if (colvalue > data->fillmargin)
{
colvalue = data->indent2;
curlineno++;
}
WORDNEXT(data,curword);
}
data->incolumn = colvalue;
data->inlinenum = curlineno;
}
#ifdef DEBUG
static
prnword(pword)
WORD *pword;
{
int i = 0;
if (pword == NULL)
return;
for (i=0; i < pword->wclen; i++)
fprintf(stderr,(const char *)"%c",(char)*(pword->cp+i));
fprintf(stderr,"Word Length :%d\n",pword->wclen);
}
#endif /* DEBUG */
/* ARGSUSED */
static void
AdjustParaCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
DtEditorFormat( (Widget)client_data, (DtEditorFormatSettings *)NULL,
DtEDITOR_FORMAT_PARAGRAPH );
} /* AdjustParaCB */
/* ARGSUSED */
static void
AdjustAllCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
DtEditorFormat( (Widget)client_data, (DtEditorFormatSettings *)NULL,
DtEDITOR_FORMAT_ALL );
} /* AdjustAllCB */
/*********
*
* DoAdjust - given left & right margin values & an alignment style, formats
* the text from one specified text position to another.
*
* Returns:
* DtEDITOR_NO_ERRORS if the text was formatted successfully.
* DtEDITOR_ILLEGAL_SIZE if the left & right margins don't make
* sense.
* DtEDITOR_NO_TMP_FILE if the 2 temporary files cannot be
* created.
* DtEDITOR_INVALID_TYPE if specified alignment is
* unrecognized
*
*/
static DtEditorErrorCode
DoAdjust(
DtEditorWidget editor,
int leftMargin,
int rightMargin,
unsigned int alignment,
XmTextPosition start,
XmTextPosition end)
{
char tempName1[L_tmpnam], tempName2[L_tmpnam];
DtEditorErrorCode returnVal;
AdjRec adjRec;
/*
* Check that valid margin values were passed in
*/
if( leftMargin >= 0 &&
rightMargin > 0 &&
rightMargin < 1025 &&
leftMargin <= rightMargin )
{
/*
* Set up
*/
_DtTurnOnHourGlass(M_topLevelShell(editor));
if (M_format_dialog(editor) != (Widget)NULL)
_DtTurnOnHourGlass(M_format_dialog(editor));
memset(&adjRec, 0, sizeof(AdjRec));
/* The adjust text formatting code works with a data
representation to the screen of 1 byte per column for
multibyte environment. The Motif text Widget has a data
representation of 2 bytes per column in multibyte, so we must
fool the adjust code into thinking the margins are twice the
size in a multibyte environment.
*/
if (MB_CUR_MAX > 1)
{
rightMargin = rightMargin * 2;
leftMargin = leftMargin * 2;
}
switch (alignment)
{
case DtEDITOR_ALIGN_CENTER:
{
adjRec.cflag = 1;
adjRec.margin = (rightMargin + leftMargin) / 2;
break;
}
case DtEDITOR_ALIGN_JUSTIFY:
{
adjRec.jflag = 1;
adjRec.margin = rightMargin;
break;
}
case DtEDITOR_ALIGN_RIGHT:
{
adjRec.rflag = 1;
adjRec.margin = rightMargin;
break;
}
case DtEDITOR_ALIGN_LEFT:
{
adjRec.margin = rightMargin;
break;
}
default:
{
returnVal = DtEDITOR_INVALID_TYPE;
}
} /* end switch */
/*
* Turn off converting leading spaces into tabs if we are
* working in a multi-byte locale. This is necessary
* because a tab may not equal (be as wide as) 8 spaces in
* a multi-byte locale.
*/
adjRec.tabsize = 8;
if (MB_CUR_MAX > 1)
adjRec.bflag = True;
else
adjRec.bflag = False;
/*
* Create the two temp files
*/
(void)tmpnam(tempName1);
(void)tmpnam(tempName2);
if ((adjRec.infp = fopen(tempName1, "w+")) != (FILE *)NULL) {
/*
* Successfully opened the first temporary file
*/
if((adjRec.outfp = fopen(tempName2, "w")) != (FILE *)NULL) {
/*
* Successfully opened the second temporary file, so do the
* formatting.
*/
returnVal = DtEDITOR_NO_ERRORS;
fixLeftMarginAndNewlines( editor, adjRec.infp, leftMargin,
rightMargin, (int)start, (int)end );
fflush(adjRec.infp);
rewind(adjRec.infp);
FormatText(&adjRec);
fclose(adjRec.infp);
unlink(tempName1);
fclose(adjRec.outfp);
returnVal =
DtEditorReplaceFromFile( (Widget)editor, start, end, tempName2 );
unlink(tempName2);
}
else {
/*
* Could not open second temporary file, so clean up first one
*/
fclose(adjRec.infp);
unlink(tempName1);
returnVal = DtEDITOR_NO_TMP_FILE;
}
} /* end creating temporary files */
else
returnVal = DtEDITOR_NO_TMP_FILE;
/*
* Clean up
*/
_DtTurnOffHourGlass(M_topLevelShell(editor));
if (M_format_dialog(editor) != (Widget)NULL)
_DtTurnOffHourGlass(M_format_dialog(editor));
} /* end check for valid margins */
else
returnVal = DtEDITOR_ILLEGAL_SIZE;
return (returnVal);
}
/* ARGSUSED */
static void
AdjustCloseCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
DtEditorWidget editor = (DtEditorWidget )client_data;
XtUnmanageChild (M_format_dialog(editor));
}
/* ARGSUSED */
static int
ComputeRightMargin(
DtEditorWidget editor)
{
Dimension text_width, highlight_thickness, shadow_thickness,
margin_width;
int rightMargin;
Arg al[5]; /* arg list */
int ac; /* arg count */
ac=0;
XtSetArg(al[ac], XmNwidth, &text_width); ac++;
XtSetArg(al[ac], XmNhighlightThickness, &highlight_thickness); ac++;
XtSetArg(al[ac], XmNshadowThickness, &shadow_thickness); ac++;
XtSetArg(al[ac], XmNmarginWidth, &margin_width); ac++;
XtGetValues(M_text(editor), al, ac);
if (M_fontWidth(editor) != 0)
rightMargin = ( (int)text_width -
(2 * ((int)highlight_thickness +
(int)shadow_thickness + (int)margin_width))
) / M_fontWidth(editor);
else
rightMargin = (int)text_width -
(2 * ((int)highlight_thickness +
(int)shadow_thickness + (int)margin_width));
return( rightMargin );
} /* end ComputeRightMargin */
/* ARGSUSED */
static void
UpdateAdjust(
Widget widget,
XtPointer *client_data,
XConfigureEvent *event )
{
Dimension width;
DtEditorWidget editor = (DtEditorWidget) client_data;
char orgnum[20]; /* original margin size string */
Arg al[2];
XtSetArg(al[0], XmNwidth, &width);
XtGetValues(M_text(editor), al, 1);
if (width == M_textWidth(editor))
return;
M_textWidth(editor) = width;
sprintf( orgnum, "%d", ComputeRightMargin(editor) );
XmTextFieldSetString(M_format_rightMarginField(editor), orgnum);
}
/************************************************************************
*
* SetFormatDialogTitle - Change the title for the Format Settings dialog
*
************************************************************************/
static void
SetFormatDialogTitle(
DtEditorWidget editor)
{
Arg al[2];
/*
* If the Format Settings dialog has been created, change its title
*/
if( M_format_dialog(editor) != (Widget)NULL )
{
/*
* Prepend the DialogTitle resource, if it has been set
*/
if( E_dialogTitle(editor) != (XmString)NULL ) {
XmString titleStr;
/*
* Add the "functional title" to the DialogTitle
*/
titleStr = XmStringConcat( E_dialogTitle(editor),
E_format_dialogTitle(editor) );
XtSetArg( al[0], XmNdialogTitle, titleStr );
XtSetValues(M_format_dialog(editor), al, 1);
XmStringFree( titleStr );
}
else {
XtSetArg( al[0], XmNdialogTitle, E_format_dialogTitle(editor) );
XtSetValues(M_format_dialog(editor), al, 1);
}
}
} /* end SetFormatDialogTitle */
/************************************************************************
*
* ResetFormatDialog - Reset margins & alignment of the Format Settings
* dialog
*
************************************************************************/
static void
ResetFormatDialog(
DtEditorWidget editor)
{
char orgnum[20]; /* original margin size string */
/*
* Reset the margins to default values
*/
/* Right margin default value */
sprintf( orgnum, "%d", ComputeRightMargin(editor) );
XmTextFieldSetString(M_format_rightMarginField(editor), orgnum);
/* Left margin default value */
sprintf(orgnum, "%d", 0);
XmTextFieldSetString(M_format_leftMarginField(editor), orgnum);
/*
* Reset the alignment style to default value
*/
XmToggleButtonGadgetSetState(M_format_leftJust(editor), True, True);
} /* end ResetFormatDialog */
/************************************************************************
*
* CreateFormatDialog - Create & initialize the Format Settings dialog
*
************************************************************************/
static void
CreateFormatDialog(
DtEditorWidget editor)
{
Arg al[15]; /* arg list */
int ac; /* arg count */
Pixel textBackground, textForeground;
XmString tempString = (XmString)NULL;
/*
* Match the background & foreground colors of the edit window
* Don't use DtNtextBackground/Foreground directly because they
* will be DtUNSPECIFIED.
*/
ac = 0;
XtSetArg(al[ac], XmNforeground, &textForeground); ac++;
XtSetArg(al[ac], XmNbackground, &textBackground); ac++;
XtGetValues(M_text(editor), al, ac);
ac = 0;
/*
* First, create the dialog's title, prepending the
* DtNdialogTitle resource, if it is set
*/
if( E_dialogTitle(editor) != (XmString)NULL ) {
/*
* Add the "functional title" to the DialogTitle
*/
tempString = XmStringConcat( E_dialogTitle(editor),
E_format_dialogTitle(editor) );
XtSetArg (al[ac], XmNdialogTitle, tempString ); ac++;
}
else {
XtSetArg(al[ac], XmNdialogTitle, E_format_dialogTitle(editor)); ac++;
}
XtSetArg (al[ac], XmNautoUnmanage, False); ac++;
XtSetArg (al[ac], XmNmarginWidth, 5); ac++;
XtSetArg (al[ac], XmNmarginHeight, 5); ac++;
XtSetArg (al[ac], XmNshadowThickness, 1); ac++;
XtSetArg (al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
XtSetArg (al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
M_format_dialog(editor) = XmCreateFormDialog(
M_topLevelShell(editor), "ad_dial", al, ac);
if (tempString != (XmString)NULL)
XmStringFree( tempString );
XtAddCallback(M_format_dialog(editor), XmNhelpCallback,
(XtCallbackProc)HelpFormatDialogCB, (XtPointer)editor);
/*
* When creating the fields & buttons use the appropriate label
* resource (e.g. DtNcenterToggleLabel), if it has been set, then
* clear the resource to save space. The field or button widget
* will contain the actual value & it can be gotten from there,
* if it is needed.
*
* If the appropriate resource has not been set, use its default
* value from the message catalog.
*/
/*
* create the left margin label and text field
*/
ac = 0;
if (E_format_leftMarginFieldLabel(editor) != (XmString) DtUNSPECIFIED) {
/*
* Use the resource value & clear it (to save space).
*/
tempString = XmStringCopy(E_format_leftMarginFieldLabel(editor));
E_format_leftMarginFieldLabel(editor) = (XmString) DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tempString = XmStringCreateLocalized(LEFT_MARGIN);
}
XtSetArg(al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNleftPosition, 2); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNtopOffset, 10); ac++;
XtSetArg (al[ac], XmNfontList, E_labelFontList(editor)); ac++;
M_format_leftLabel(editor) = (Widget) XmCreateLabelGadget (
M_format_dialog(editor), "left_label", al, ac);
XtManageChild (M_format_leftLabel(editor));
XmStringFree (tempString);
XtAddCallback(M_format_leftLabel(editor), XmNhelpCallback,
(XtCallbackProc)HelpFormatLeftMarginCB, (XtPointer)editor);
ac = 0;
XtSetArg (al[ac], XmNbackground, textBackground); ac++;
XtSetArg (al[ac], XmNforeground, textForeground); ac++;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg (al[ac], XmNleftWidget, M_format_leftLabel(editor)); ac++;
XtSetArg (al[ac], XmNleftOffset, 3); ac++;
XtSetArg (al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNrightPosition, 45); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNtopOffset, 5); ac++;
XtSetArg (al[ac], XmNtraversalOn, True); ac++;
XtSetArg (al[ac], XmNcolumns, 3); ac++;
XtSetArg (al[ac], XmNfontList, E_textFontList(editor)); ac++;
M_format_leftMarginField(editor) = (Widget) XmCreateTextField (
M_format_dialog(editor), "left_text", al, ac);
XtManageChild (M_format_leftMarginField(editor));
XtAddCallback(M_format_leftMarginField(editor), XmNhelpCallback,
(XtCallbackProc)HelpFormatLeftMarginCB, (XtPointer)editor);
/*
* create the right margin label and text field
*/
ac = 0;
if (E_format_rightMarginFieldLabel(editor) != (XmString) DtUNSPECIFIED)
{
/*
* Use the resource value & clear it (to save space).
*/
tempString = XmStringCopy(E_format_rightMarginFieldLabel(editor));
E_format_rightMarginFieldLabel(editor) = (XmString) DtUNSPECIFIED;
}
else
{
/*
* The resource has not been set so use its default value
*/
tempString = XmStringCreateLocalized(RIGHT_MARGIN);
}
XtSetArg(al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNleftPosition, 55); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNtopOffset, 10); ac++;
XtSetArg (al[ac], XmNfontList, E_labelFontList(editor)); ac++;
M_format_rightLabel(editor)= (Widget) XmCreateLabelGadget (
M_format_dialog(editor), "right_label", al, ac);
XtManageChild (M_format_rightLabel(editor));
XmStringFree (tempString);
XtAddCallback(M_format_rightLabel(editor), XmNhelpCallback,
(XtCallbackProc)HelpFormatRightMarginCB,
(XtPointer)editor);
ac = 0;
XtSetArg (al[ac], XmNbackground, textBackground); ac++;
XtSetArg (al[ac], XmNforeground, textForeground); ac++;
XtSetArg (al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNrightPosition, 98); ac++;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg (al[ac], XmNleftWidget, M_format_rightLabel(editor)); ac++;
XtSetArg (al[ac], XmNleftOffset, 3); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNtopOffset, 5); ac++;
XtSetArg (al[ac], XmNtraversalOn, True); ac++;
XtSetArg (al[ac], XmNcolumns, 3); ac++;
XtSetArg (al[ac], XmNfontList, E_textFontList(editor)); ac++;
M_format_rightMarginField(editor) = (Widget) XmCreateTextField (
M_format_dialog(editor),
"right_text", al, ac);
XtManageChild (M_format_rightMarginField(editor));
XtAddCallback(M_format_rightMarginField(editor), XmNhelpCallback,
(XtCallbackProc)HelpFormatRightMarginCB,
(XtPointer)editor);
/*
* create the radio box for justification choices
*/
ac = 0;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNleftOffset, 5); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg (al[ac], XmNtopWidget, M_format_leftMarginField(editor)); ac++;
XtSetArg (al[ac], XmNtopOffset, 5); ac++;
XtSetArg (al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNrightOffset, 5); ac++;
XtSetArg (al[ac], XmNtraversalOn, True); ac++;
M_format_radioBox(editor) = (Widget) XmCreateRadioBox(
M_format_dialog(editor), "radioBox", al, ac);
XtAddCallback(M_format_radioBox(editor), XmNhelpCallback,
(XtCallbackProc)HelpFormatJustifyButtonsCB,
(XtPointer)editor);
XtManageChild(M_format_radioBox(editor));
/* Create Left Align toggle */
ac = 0;
if (E_format_leftAlignToggleLabel(editor) != (XmString) DtUNSPECIFIED) {
/*
* Use the resource value & clear it (to save space).
*/
tempString = XmStringCopy(E_format_leftAlignToggleLabel(editor));
E_format_leftAlignToggleLabel(editor) = (XmString) DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tempString = XmStringCreateLocalized(LEFT_ALIGN);
}
XtSetArg(al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNfontList, E_buttonFontList(editor)); ac++;
M_format_leftJust(editor) = (Widget) XmCreateToggleButtonGadget(
M_format_radioBox(editor), "left_just", al, ac);
XmStringFree (tempString);
XtManageChild(M_format_leftJust(editor));
/* Create Right Align toggle */
ac = 0;
if(E_format_rightAlignToggleLabel(editor) != (XmString)DtUNSPECIFIED) {
/*
* Use the resource value & clear it (to save space).
*/
tempString = XmStringCopy(E_format_rightAlignToggleLabel(editor));
E_format_rightAlignToggleLabel(editor) = (XmString) DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tempString = XmStringCreateLocalized(RIGHT_ALIGN);
}
XtSetArg(al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNfontList, E_buttonFontList(editor)); ac++;
M_format_rightJust(editor) = (Widget) XmCreateToggleButtonGadget(
M_format_radioBox(editor), "right_just", al, ac);
XmStringFree (tempString);
XtManageChild(M_format_rightJust(editor));
/* Create Justify toggle */
ac = 0;
if (E_format_justifyToggleLabel(editor) != (XmString) DtUNSPECIFIED) {
/*
* Use the resource value & clear it (to save space).
*/
tempString = XmStringCopy(E_format_justifyToggleLabel(editor));
E_format_justifyToggleLabel(editor) = (XmString) DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tempString = XmStringCreateLocalized( JUSTIFY );
}
XtSetArg(al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNfontList, E_buttonFontList(editor)); ac++;
M_format_bothJust(editor) = (Widget) XmCreateToggleButtonGadget(
M_format_radioBox(editor), "both_just", al, ac);
XmStringFree (tempString);
XtManageChild(M_format_bothJust(editor));
/* Create Center align toggle */
ac = 0;
if (E_format_centerToggleLabel(editor) != (XmString) DtUNSPECIFIED) {
/*
* Use the resource value & clear it (to save space).
*/
tempString = XmStringCopy(E_format_centerToggleLabel(editor));
E_format_centerToggleLabel(editor) = (XmString) DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tempString = XmStringCreateLocalized(CENTER);
}
XtSetArg(al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNfontList, E_buttonFontList(editor)); ac++;
M_format_center(editor) = (Widget) XmCreateToggleButtonGadget(
M_format_radioBox(editor), "center", al, ac);
XmStringFree(tempString);
XtManageChild(M_format_center(editor));
/* Create a separator between the radio box and buttons */
ac = 0;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg (al[ac], XmNtopWidget, M_format_radioBox(editor)); ac++;
XtSetArg (al[ac], XmNtopOffset, 15); ac++;
M_format_separator(editor) = (Widget) XmCreateSeparatorGadget (
M_format_dialog(editor), "separator", al, ac);
XtManageChild (M_format_separator(editor));
/* Create Format Paragraph button */
ac = 0;
if ( E_format_formatParagraphButtonLabel(editor) !=
(XmString) DtUNSPECIFIED ) {
/*
* Use the resource value & clear it (to save space).
*/
tempString = XmStringCopy(E_format_formatParagraphButtonLabel(editor));
E_format_formatParagraphButtonLabel(editor) = (XmString) DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tempString = XmStringCreateLocalized(PARAGRAPH);
}
XtSetArg(al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNleftPosition, 2); ac++;
XtSetArg (al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNrightPosition, 25); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg (al[ac], XmNtopWidget, M_format_separator(editor)); ac++;
XtSetArg (al[ac], XmNtopOffset, 5); ac++;
XtSetArg (al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNbottomOffset, 5); ac++;
XtSetArg (al[ac], XmNmarginWidth, 4); ac++;
XtSetArg (al[ac], XmNmarginHeight, 4); ac++;
XtSetArg (al[ac], XmNfontList, E_buttonFontList(editor)); ac++;
M_format_paragraph(editor) = (Widget) XmCreatePushButtonGadget (
M_format_dialog(editor), "para", al, ac);
XtManageChild (M_format_paragraph(editor));
XmStringFree (tempString);
XtAddCallback (M_format_paragraph(editor), XmNactivateCallback,
(XtCallbackProc) AdjustParaCB, (XtPointer) editor);
/* Create Format All button */
ac = 0;
if (E_format_formatAllButtonLabel(editor) != (XmString)DtUNSPECIFIED) {
/*
* Use the resource value & clear it (to save space).
*/
tempString = XmStringCopy(E_format_formatAllButtonLabel(editor));
E_format_formatAllButtonLabel(editor) = (XmString) DtUNSPECIFIED;
}
else {
/*
* The resource has not been set so use its default value
*/
tempString = XmStringCreateLocalized(ALL);
}
XtSetArg(al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNleftPosition, 27); ac++;
XtSetArg (al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNrightPosition, 49); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg (al[ac], XmNtopWidget, M_format_separator(editor)); ac++;
XtSetArg (al[ac], XmNtopOffset, 5); ac++;
XtSetArg (al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNbottomOffset, 5); ac++;
XtSetArg (al[ac], XmNmarginWidth, 4); ac++;
XtSetArg (al[ac], XmNmarginHeight, 4); ac++;
XtSetArg (al[ac], XmNfontList, E_buttonFontList(editor)); ac++;
M_format_all(editor) = (Widget) XmCreatePushButtonGadget(
M_format_dialog(editor), "all", al, ac);
XtManageChild (M_format_all(editor));
XmStringFree (tempString);
XtAddCallback (M_format_all(editor), XmNactivateCallback,
(XtCallbackProc) AdjustAllCB, (XtPointer) editor);
/* Create Close button */
tempString = XmStringCreateLocalized(CLOSE_BUTTON);
ac = 0;
XtSetArg (al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNleftPosition, 51); ac++;
XtSetArg (al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNrightPosition, 73); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg (al[ac], XmNtopWidget, M_format_separator(editor)); ac++;
XtSetArg (al[ac], XmNtopOffset, 5); ac++;
XtSetArg (al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNbottomOffset, 5); ac++;
XtSetArg (al[ac], XmNmarginWidth, 4); ac++;
XtSetArg (al[ac], XmNmarginHeight, 4); ac++;
XtSetArg (al[ac], XmNfontList, E_buttonFontList(editor)); ac++;
M_format_close(editor) = (Widget) XmCreatePushButtonGadget (
M_format_dialog(editor), "close", al, ac);
XtManageChild (M_format_close(editor));
XmStringFree (tempString);
XtAddCallback (M_format_close(editor), XmNactivateCallback,
(XtCallbackProc) AdjustCloseCB, (XtPointer) editor);
tempString = XmStringCreateLocalized(HELP_BUTTON);
ac = 0;
XtSetArg (al[ac], XmNlabelString, tempString); ac++;
XtSetArg (al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNleftPosition, 75); ac++;
XtSetArg (al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg (al[ac], XmNrightPosition, 98); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg (al[ac], XmNtopWidget, M_format_separator(editor)); ac++;
XtSetArg (al[ac], XmNtopOffset, 5); ac++;
XtSetArg (al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNbottomOffset, 5); ac++;
XtSetArg (al[ac], XmNmarginWidth, 4); ac++;
XtSetArg (al[ac], XmNmarginHeight, 4); ac++;
XtSetArg (al[ac], XmNfontList, E_buttonFontList(editor)); ac++;
M_format_help(editor) = (Widget) XmCreatePushButtonGadget(
M_format_dialog(editor), "help", al, ac);
XtManageChild (M_format_help(editor));
XmStringFree (tempString);
XtAddCallback( M_format_help(editor), XmNactivateCallback,
(XtCallbackProc) HelpFormatDialogCB, (XtPointer) editor);
/*
* set the default/activation button.
*/
XtSetArg(al[0], XmNdefaultButton, M_format_close(editor));
XtSetValues(M_format_dialog(editor), al, 1);
XtRealizeWidget (M_format_dialog(editor));
/*
* Initialize the margins & alignment toggles
*/
ResetFormatDialog(editor);
XtSetArg(al[0], XmNwidth, &(M_textWidth(editor)));
XtGetValues(M_text(editor), al, 1);
XtAddEventHandler(M_text(editor), StructureNotifyMask, False,
(XtEventHandler) UpdateAdjust, (XtPointer) editor);
} /* end CreateFormatDialog */
/************************************************************************
*
* GetAdjustSettings - Read the alignment settings from the Format
* Settings dialog.
*
************************************************************************/
static void
GetAdjustSettings(
DtEditorWidget editor,
DtEditorFormatSettings *formatSettings)
{
if( M_format_dialog(editor)!= (Widget)NULL ) {
/*
* Read the current alignment settings from the Format Settings
* dialog.
*/
char *num;
/*
* Get current type of alignment
*/
if (XmToggleButtonGadgetGetState(M_format_leftJust(editor)))
formatSettings->alignment = DtEDITOR_ALIGN_LEFT;
else if (XmToggleButtonGadgetGetState(M_format_rightJust(editor)))
formatSettings->alignment = DtEDITOR_ALIGN_RIGHT;
else if (XmToggleButtonGadgetGetState(M_format_bothJust(editor)))
formatSettings->alignment = DtEDITOR_ALIGN_JUSTIFY;
else
formatSettings->alignment = DtEDITOR_ALIGN_CENTER;
/*
* Get current margin settings
*/
num = (char *) XmTextFieldGetString(
(Widget)M_format_rightMarginField(editor) );
formatSettings->rightMargin = atoi(num);
XtFree(num);
num = (char *) XmTextFieldGetString(
(Widget)M_format_leftMarginField(editor) );
formatSettings->leftMargin = atoi(num);
XtFree(num);
}
else {
/*
* The Format Settings dialog box has not been created so use the
* default values.
*/
formatSettings->leftMargin = 0;
formatSettings->rightMargin = ComputeRightMargin(editor);
formatSettings->alignment = DtEDITOR_ALIGN_LEFT;
}
}
/****************************************************************
*
* Public Procs
*
****************************************************************/
/*********************************************************
*
* DtCreateEditor
* Create an instance of an editor and return the widget id.
*/
Widget
DtCreateEditor(
Widget parent,
char *name,
ArgList arglist,
Cardinal argcount )
{
return( XtCreateWidget(name,dtEditorWidgetClass,parent,arglist,argcount) );
}
Boolean
DtEditorCheckForUnsavedChanges(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
Boolean result;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
result = M_unreadChanges( editor );
_DtAppUnlock(app);
return result;
} /* end DtEditorCheckForUnsavedChanges */
Boolean
DtEditorDeleteSelection(
Widget widget)
{
XmTextPosition first, last;
DtEditorWidget editor = (DtEditorWidget) widget;
Boolean result;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Check for a non-null selection
*/
if ( XmTextGetSelectionPosition(M_text(editor), &first, &last) &&
first != last )
{
XmTextRemove(M_text(editor));
result = True;
}
else
result = False;
_DtAppUnlock(app);
return result;
} /* end DtEditorDeleteSelection */
/*
* DtEditorClearSelection replaces the currently selected text with
* spaces. It requires an event because the underlying text widget
* routines require one to look at the time stamp within.
*/
Boolean
DtEditorClearSelection(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
char *params=(char *)NULL;
Cardinal num_params = 0;
XEvent event;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Create an event with a correct timestamp
*/
event.xkey.time = XtLastTimestampProcessed( M_display(editor) );
/*
* Call routine to clear primary selection
*/
ClearSelection( widget, &event, &params, &num_params );
_DtAppUnlock(app);
return(True);
} /* end DtEditorClearSelection */
/*
*
* DtEditorDeselect - Unselects any selected text of an Editor widget
*
*/
Boolean
DtEditorDeselect(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
char *params=(char *)NULL;
Cardinal num_params = 0;
XEvent event;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Create an event with a correct timestamp
*/
event.xkey.time = XtLastTimestampProcessed( M_display(editor) );
DeselectAll( widget, &event, &params, &num_params );
_DtAppUnlock(app);
return(True);
} /* end DtEditorDeselect */
/*
*
* DtEditorDisableRedisplay - Temporarily prevent visual update of a
* Editor widget
*
*/
void
DtEditorDisableRedisplay(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
XmTextDisableRedisplay( M_text(editor) );
_DtAppUnlock(app);
} /* end DtEditorDisableRedisplay */
/*
*
* DtEditorEnableRedisplay - Force visual update of an Editor widget
*
*/
void
DtEditorEnableRedisplay(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
XmTextEnableRedisplay( M_text(editor) );
_DtAppUnlock(app);
} /* end DtEditorEnableRedisplay */
/*********
*
* DtEditorFormat
* Given left & right margin values & an alignment style,
* formats either the current paragraph or the entire document,
* as specified. If margin values & alignment style are not
* provided, DtEditorFormat will use the current values from
* the Format Settings dialog.
*
* Returns:
* DtEDITOR_NO_ERRORS if the text was formatted successfully.
* DtEDITOR_NO_TMP_FILE if the 2 temporary files cannot be
* created.
* DtEDITOR_ILLEGAL_SIZE if the left & right margins don't make
* sense.
* DtEDITOR_INVALID_RANGE if specified amount to format is
* unrecognized
* DtEDITOR_INVALID_TYPE if specified alignment is
* unrecognized
*
*/
DtEditorErrorCode
DtEditorFormat(
Widget widget,
DtEditorFormatSettings *formatSettings,
unsigned int amountToFormat )
{
DtEditorWidget editor = (DtEditorWidget) widget;
DtEditorErrorCode error;
int leftMargin, rightMargin, alignment;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Check to see if we should use the format settings from the
* Format Settings dialog.
*/
if( formatSettings == (DtEditorFormatSettings *) NULL )
{
DtEditorFormatSettings tmpFormatSettings;
/*
* Get the format settings from the Format Settings dialog
*/
GetAdjustSettings(editor, &tmpFormatSettings);
/*
* Set up the correct format settings
*/
leftMargin = tmpFormatSettings.leftMargin;
rightMargin = tmpFormatSettings.rightMargin;
alignment = tmpFormatSettings.alignment;
}
else {
leftMargin = formatSettings->leftMargin;
rightMargin = formatSettings->rightMargin;
alignment = formatSettings->alignment;
}
/*
* Now, do the formatting
*/
switch (amountToFormat)
{
case DtEDITOR_FORMAT_ALL:
{
error = DoAdjust( editor, leftMargin, rightMargin, alignment,
0, XmTextGetLastPosition(M_text(editor)) );
break;
}
case DtEDITOR_FORMAT_PARAGRAPH:
{
XmTextPosition start, end;
char *params=(char *)NULL;
Cardinal num_params = 0;
/*
* Create an event with a correct timestamp
*/
XEvent event;
event.xkey.time = XtLastTimestampProcessed( M_display(editor) );
/*
* Get the beginning & ending positions of the current paragraph
*/
ForwardPara( widget, &event, &params, &num_params );
end = XmTextGetInsertionPosition(M_text(editor));
if( end != XmTextGetLastPosition(M_text(editor)) ) {
/*
* If we're not at the end, then we need to back up to the
* start of this line, otherwise we'll disturb the first line
* of the following paragraph. If we are at the end, then "end"
* must point to the end of the line, or we'll leave the last
* line along with the formatted text.
*/
BeginningOfLine( widget, &event, &params, &num_params );
end = XmTextGetInsertionPosition(M_text(editor));
}
BackwardPara( widget, &event, &params, &num_params );
BeginningOfLine( widget, &event, &params, &num_params );
start = XmTextGetInsertionPosition(M_text(editor));
/*
* Pass in beginning & ending positions to adjust the current
* paragraph
*/
error = DoAdjust( editor, leftMargin, rightMargin, alignment,
start, end );
break;
}
default: {
error = DtEDITOR_INVALID_RANGE;
}
} /* end switch */
_DtAppUnlock(app);
return( error );
} /* DtEditorFormat */
/*
*
* DtEditorGetMessageTextFieldID - Returns the widget ID of the Text
* Field used to display application status messages.
*
*/
Widget
DtEditorGetMessageTextFieldID(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
Widget result;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Create the status line if is does not exist
*/
if( M_status_statusArea(editor) == (Widget) NULL )
M_status_statusArea(editor) = CreateStatusLine( editor );
result = M_status_messageText(editor);
_DtAppUnlock(app);
return result;
} /* end DtEditorGetMessageTextFieldID */
/*
* DtEditorGoToLine moves the insert cursor to the beginning of the
* line specified by lineNumber. It figures out the text character
* position corresponding to the specified line and sets the text
* widget's insertionPosition to that location. If this new
* insertionPosition is not currently on-screen, then the
* text widget's contents are scrolled to display the new position.
*
* The cursor can be moved to last line by specifying DtEDITOR_LAST_LINE
* as the line number.
* If lineNumber is less than one, the insert cursor will be placed
* at the beginning of the first line. If it is greater than the total
* number of lines, the cursor will be placed at the last line of text.
*/
/* ARGSUSED */
void DtEditorGoToLine(
Widget widget,
int lineNumber)
{
DtEditorWidget editor = (DtEditorWidget)widget;
XmTextWidget tw;
XmTextLineTable lineTab;
XmTextPosition newPos;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
tw = (XmTextWidget)M_text(editor);
lineTab = tw->text.line_table;
/*
* Validate the specified line number, check it is in range.
* If we adjust the line number, then update the current line display
* in the status line so it reflects where we are really going. This
* is only a problem if lineNumber is less/greater than the first/last
* line becausee we won't be moving the cursor so the status line will
* not be updated.
*/
if (lineNumber > tw->text.total_lines || lineNumber == DtEDITOR_LAST_LINE)
{
lineNumber = tw->text.total_lines;
_DtEditorUpdateLineDisplay( editor, lineNumber, FORCE );
}
else if(lineNumber < 1)
{
lineNumber = 1;
_DtEditorUpdateLineDisplay( editor, lineNumber, FORCE );
}
/*
* Move the insertion cursor
*/
newPos = lineTab[lineNumber - 1].start_pos;
XmTextSetInsertionPosition(M_text(editor), newPos);
/*
* Scroll the widget, if necessary
*/
if (newPos < tw->text.top_character || newPos >= tw->text.bottom_position)
{
Arg al[5];
int ac;
Dimension height;
short rows;
Position x, y;
ac = 0;
XtSetArg(al[ac], XmNheight, &height); ac++;
XtSetArg(al[ac], XmNrows, &rows); ac++;
XtGetValues(M_text(editor), al, ac);
if(XmTextPosToXY(M_text(editor), newPos, &x, &y) == True)
{
int offset = (y - height/2) * rows;
XmTextScroll(M_text(editor), offset/(int) height);
}
}
_DtAppUnlock(app);
} /* end DtEditorGoToLine */
/*
* DtEditorGetEditorSizeHints - Set the resize increment, minimum window
* size, and base dimension properties in the supplied XSizeHints
* struct for the editor as a whole.
*
* NOTE: This routine returns data in the struct pointed to by pHints.
*
*/
void
DtEditorGetSizeHints(
Widget widget,
XSizeHints *pHints) /* Return */
{
Arg al[10]; /* arg list */
int ac; /* arg count */
Dimension FormWidth, FormHeight,
Twidth, Theight, statusHeight,
highlightThickness, shadowThickness,
marginWidth, marginHeight,
textRegionWidth, textRegionHeight;
DtEditorWidget editor = (DtEditorWidget) widget;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Window manager should resize in increments of a character or line.
*/
pHints->width_inc = M_fontWidth(editor);
pHints->height_inc = M_fontHeight(editor);
/*
* Size of the Editor (Form)
*/
FormWidth = editor->core.width + (2 * editor->core.border_width);
FormHeight = editor->core.height + (2 * editor->core.border_width);
/*
* Size of the Edit window (text widget)
*/
ac=0;
XtSetArg(al[ac], XmNwidth, &Twidth); ac++;
XtSetArg(al[ac], XmNheight, &Theight); ac++;
XtSetArg(al[ac], XmNhighlightThickness, &highlightThickness); ac++;
XtSetArg(al[ac], XmNshadowThickness, &shadowThickness); ac++;
XtSetArg(al[ac], XmNmarginWidth, &marginWidth); ac++;
XtSetArg(al[ac], XmNmarginHeight, &marginHeight); ac++;
XtGetValues(M_text(editor), al, ac);
/*
* Calculate the width & height of the area within the text widget
* which can actually display characters.
*/
textRegionWidth = (int)Twidth -
(2 * ((int)highlightThickness +
(int)shadowThickness + (int)marginWidth));
textRegionHeight = (int)Theight -
(2 * ((int)highlightThickness +
(int)shadowThickness + (int)marginHeight));
/*
* Set the base width/height to the size of the area which will not
* display characters.
*
* The base width/height is used by the window manager in concert
* with the height & width increments to display the current size
* (rows & columns) of edit window (text widget) while resizing the
* editor.
*/
pHints->base_width = FormWidth - textRegionWidth;
pHints->base_height = FormHeight - textRegionHeight;
/*
* Get the height of the status line, if it is turned on.
* Remember, the border width is not included in the height of the
* status line so add it in to account for the border between the
* edit window (text widget) and the status line.
*/
/* XXX Actually, the statusHeight should already be included in the
* FormHeight, so it should not be necessary to add it in again.
* However, the numbers don't come out right otherwise. Hmmm? */
if( M_status_showStatusLine(editor) == True )
{
XtSetArg( al[0], XmNheight, &statusHeight );
XtGetValues( M_status_statusArea(editor), al, 1 );
statusHeight = statusHeight + editor->core.border_width;
}
else
statusHeight = 0;
/*
* What is being returned here is the minimum width & height of the
* editor. Leave room for the scrollbars, shadows, etc., plus one
* character.
*/
pHints->min_width = pHints->base_width + pHints->width_inc;
pHints->min_height = pHints->base_width + pHints->height_inc +
statusHeight;
pHints->flags = PMinSize | PResizeInc | PBaseSize;
_DtAppUnlock(app);
} /* end DtEditorGetSizeHints */
void
DtEditorInvokeFormatDialog(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Create the dialog if it is the first time
*/
if (M_format_dialog(editor) == (Widget)NULL)
CreateFormatDialog( editor );
/*
* Post the dialog
*/
XtUnmanageChild (M_format_dialog(editor));
XtManageChild (M_format_dialog(editor));
XmProcessTraversal(M_format_paragraph(editor), XmTRAVERSE_CURRENT);
_DtAppUnlock(app);
} /* DtEditorInvokeFormatDialog */
void
DtEditorReset(
Widget widget)
{
DtEditorContentRec cr;
DtEditorWidget editor = (DtEditorWidget) widget;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Reset the edit window (includes the Undo context)
*/
cr.type = DtEDITOR_TEXT;
cr.value.string = "";
DtEditorSetContents( widget, &cr );
/*
* Reset the status line
* Note, the current & total line displays are reset by DtEditorSetContents()
*/
if( M_status_statusArea(editor) != (Widget) NULL ) {
XmTextFieldSetString( M_status_messageText(editor), "" );
}
/*
* Reset the Find/Change & Spell dialogs
*/
if ( M_search_string(editor) )
XtFree(M_search_string(editor));
M_search_string(editor) = (char *)NULL;
if ( M_replace_string(editor) )
XtFree(M_replace_string(editor));
M_replace_string(editor) = (char *)NULL;
if (M_misspelled_string(editor))
XtFree(M_misspelled_string(editor));
M_misspelled_string(editor) = (char *)NULL;
/*
* Reset the Format Settings dialog
*/
if (M_format_dialog(editor) != (Widget)NULL)
ResetFormatDialog(editor);
_DtAppUnlock(app);
} /* end DtEditorReset */
/*
*
* DtEditorSelectAll - Selects the contents of an Editor widget
*
*/
Boolean
DtEditorSelectAll(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
char *params=(char *)NULL;
Cardinal num_params = 0;
XEvent event;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
/*
* Create an event with a correct timestamp
*/
event.xkey.time = XtLastTimestampProcessed( M_display(editor) );
SelectAll( widget, &event, &params, &num_params );
_DtAppUnlock(app);
return(True);
} /* end DtEditorSelectAll */
void
DtEditorTraverseToEditor(
Widget widget)
{
DtEditorWidget editor = (DtEditorWidget) widget;
_DtWidgetToAppContext(widget);
_DtAppLock(app);
XmProcessTraversal(M_text(editor), XmTRAVERSE_CURRENT);
_DtAppUnlock(app);
} /* end DtEditorTraverseToEditor */
Reference in a new issue View git blame Copy permalink