falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/lib/DtTerm/TermPrim/TermPrimSelect.c

3080 lines
87 KiB
C
Raw Permalink Blame History

/*
* 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
*/
/* *
* (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 1993, 1994, 1996 Novell, Inc. *
* (c) Copyright 1995, 1996 Digital Equipment Corporation. *
* (c) Copyright 1996 FUJITSU LIMITED. *
* (c) Copyright 1996 Hitachi. *
*/
#include "TermHeader.h"
#include <X11/Xatom.h>
#include <Xm/Xm.h>
#include <Xm/AtomMgr.h>
#include <Xm/CutPaste.h>
#include <Xm/XmPrivate.h>
#include <Xm/ScrollBarP.h>
#include "TermPrimAction.h"
#include "TermPrimDebug.h"
#include "TermPrimP.h"
#include "TermPrimData.h"
#include "TermPrimRender.h"
#include "TermPrimSelectP.h"
#include "TermPrimBufferP.h"
#include <Xm/DropSMgr.h>
#include <Xm/DropTrans.h>
#include <ctype.h>
#include <wctype.h>
/* This is for Sun's two button mouse */
static char _DtTermEventBindingsCDE[] = "\
~c ~s ~m ~a <Btn1Down>:process-press(grab-focus,process-bdrag)\n\
~c s ~m ~a <Btn1Down>:process-press(extend-start,process-bdrag)\n\
~c ~m ~a <Btn1Motion>:select-adjust()\n\
~c ~m ~a <Btn1Up>:extend-end()";
static char _DtTermEventBindingsCDEBtn2[] = "\
<Btn2Down>:extend-start()\n\
<Btn2Motion>:select-adjust()\n\
<Btn2Up>:extend-end()";
static
XmTextScanType defaultScanArray[] =
{
XmSELECT_POSITION,
XmSELECT_WORD,
XmSELECT_LINE,
XmSELECT_ALL
};
static void RegisterDropSite( Widget w );
static void doExtendedSelection (Widget w,Time eventTime);
/*
** Get the current server time (I ripped this off from Xm/TextIn.c).
*/
static Time
getServerTime
(
Widget w
)
{
XEvent event;
EventMask shellMask;
while(!XtIsShell(w))
{
w = XtParent(w);
}
shellMask = XtBuildEventMask(w);
if (!(shellMask & PropertyChangeMask))
{
XSelectInput(XtDisplay(w), XtWindow(w), shellMask | PropertyChangeMask);
}
XChangeProperty(XtDisplay(w), XtWindow(w), XA_WM_HINTS, XA_WM_HINTS,
32, PropModeAppend, (unsigned char *)NULL, 0);
XWindowEvent(XtDisplay(w), XtWindow(w), PropertyChangeMask, &event);
if (!(shellMask & PropertyChangeMask))
{
XSelectInput(XtDisplay(w), XtWindow(w), shellMask);
}
return(event.xproperty.time);
}
static void
setScanType
(
Widget w,
XEvent *event
)
{
TermSelectInfo selectInfo =
((DtTermPrimitiveWidget)w)->term.tpd->selectInfo;
int multiClickTime;
int i;
multiClickTime = XtGetMultiClickTime(XtDisplay(w));
if (event->xbutton.time > selectInfo->lastTime &&
event->xbutton.time - selectInfo->lastTime <
(multiClickTime == 200 ? 500 : multiClickTime))
{
i = 0;
while (i < selectInfo->scanArraySize &&
selectInfo->scanArray[i] != selectInfo->scanType)
{
i++;
}
if (++i >= selectInfo->scanArraySize)
{
i = 0;
}
selectInfo->scanType = selectInfo->scanArray[i];
}
else
{
/* single-click event */
selectInfo->scanType = selectInfo->scanArray[0];
}
selectInfo->lastTime = event->xbutton.time;
}
/*
** convert a row,col pair into the equivalent XmTextPosition
**
** NOTE:
** this routine assumes that the calling routine as already checked
** row and col to insure that they are within the bounds of the terminal
** buffer (see _DtTermPrimSelectGrabFocus)
*/
XmTextPosition
rowColToPos
(
DtTermPrimitiveWidget tw,
short row,
short col
)
{
DtTermPrimData tpd = tw->term.tpd;
return(((tpd->selectInfo->columns + 1) *
(row + tpd->lastUsedHistoryRow)) + col);
}
/*
** getSelection
*/
Boolean
_DtTermPrimSelectGetSelection
(
Widget w,
XmTextPosition *begin,
XmTextPosition *end
)
{
TermSelectInfo selectInfo =
((DtTermPrimitiveWidget)w)->term.tpd->selectInfo;
if (selectInfo->ownPrimary &&
(selectInfo->begin <= selectInfo->end) &&
selectInfo->begin >= 0)
{
*begin = selectInfo->begin;
*end = selectInfo->end;
return(True);
}
else
{
*begin = 0;
*end = 0;
selectInfo->ownPrimary = False;
return(False);
}
}
/*
** convert an x,y pair into the appropriate text position
**
** Since positions count the number of inter-character spaces, there is
** one more x position on a line than columns on a line; xPos can be in
** the range (0, selectInfo->columns + 1). The same is true for yPos,
** it can be in the range (0, tpd->lastUsedRow - tpd->topRow - 1)
**
** In the case that we have a history buffer to deal with, text positions
** in the history buffer are forced to come before positions in the term
** buffer.
**
** NOTE:
** this routine assumes that the calling routine as already checked
** x and y to insure that they are within the bounds of the terminal
** window (see _DtTermPrimSelectGrabFocus)
** NOTE:
** I believe I'm now doing all checking in this routine for confining
** the x,y to the window. Disregard the previous note. TMH
*/
static
XmTextPosition
xyToPos
(
DtTermPrimitiveWidget tw,
int x, /* pixel */
int y /* pixel */
)
{
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
TermBuffer tb;
short row;
short yPos;
short xPos;
static short oldYPos = -1;
static short oldXPos = -1;
if ( x<0) x = 0;
if ( x > (int) tw->core.width) x = tw->core.width;
/*
** convert pixel units to character positions
*/
yPos = (MAX(0, y) - tpd->offsetY) / tpd->cellHeight;
/*
** yPos cannot exceed the buffer or screen
*/
yPos = MIN(yPos, MIN(tw->term.rows, tpd->lastUsedRow - tpd->topRow) - 1) +
tpd->topRow;
/*
** consider the possibility that we have a history buffer
*/
if (tpd->useHistoryBuffer)
{
if (yPos < 0)
{
/*
** yPos is not in the history buffer (order is important,
** step 2 must come before step 3):
** 1) point to history buffer
** 2) adjust yPos
** 3) decide which row of the buffer we are concerned
** with
*/
tb = tpd->historyBuffer;
yPos += tpd->lastUsedHistoryRow;
row = yPos;
}
else
{
/*
** yPos is not in the history buffer (order is important,
** step 2 must come before step 3):
** 1) point to term buffer
** 2) decide which row of the buffer we are concerned
** with
** 3) adjust yPos
*/
tb = tpd->termBuffer;
row = yPos;
yPos += tpd->lastUsedHistoryRow;
}
}
else
{
tb = tpd->termBuffer;
row = yPos;
}
xPos = (((x - tpd->offsetX) + (tpd->cellWidth / 2)) / tpd->cellWidth) ;
if ( MB_CUR_MAX > 1 ) /* check if xPos splits a 2 col char */
{
TermCharInfoRec charInfoRec ;
if (_DtTermPrimGetCharacterInfo(tb,row,xPos,&charInfoRec) )
{
if (charInfoRec.width == 2 && charInfoRec.startCol != xPos)
{
if (xPos*tpd->cellWidth < x - tpd->offsetX )
xPos++ ; /* set to right of char */
else
xPos-- ; /* set to left of char */
}
}
}
if ((yPos != oldYPos) || (xPos != oldXPos))
{
oldYPos = yPos;
oldXPos = xPos;
}
return (((selectInfo->columns + 1) * yPos) + xPos);
}
/*
* Takes a linear position and return buffer, row, and col.
* Since positions are between characters, this returns the col to
* right of the position.
*/
static void
posToBufferRowCol
(
DtTermPrimitiveWidget tw,
XmTextPosition pos,
TermBuffer *pb,
short *row,
short *col
)
{
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
short lrow, lcol;
lrow = pos / (selectInfo->columns + 1);
lcol = pos - (lrow * (selectInfo->columns + 1));
if ( tpd->useHistoryBuffer ) lrow -= tpd->lastUsedHistoryRow ;
if ( lrow < 0 ) { /* in history buffer */
*pb=tw->term.tpd->historyBuffer ;
lrow += tpd->lastUsedHistoryRow ;
}
else
{
*pb = tpd->termBuffer ;
}
*row = lrow ;
*col = lcol ;
}
/*
* Takes a buffer, row and column and returns the linear position.
*/
static XmTextPosition
bufferRowColToPos
(
DtTermPrimitiveWidget tw,
TermBuffer pb,
short row,
short col
)
{
DtTermPrimData tpd = tw->term.tpd;
short lrow, lcol;
XmTextPosition pos;
/* assume row, col in the history buffer or there is no history */
pos = (tpd->selectInfo->columns + 1) * row + col;
if ( tpd->useHistoryBuffer && pb == tpd->termBuffer)
pos += (tpd->selectInfo->columns + 1) * (tpd->lastUsedHistoryRow) ;
return(pos) ;
}
static XmTextPosition
scan
(
DtTermPrimitiveWidget tw,
XmTextPosition scanStart,
XmTextScanType scanType,
TermScanDirection scanDir,
int count,
Boolean inclusive
)
{
int i;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
XmTextPosition position = scanStart;
short row;
short col;
TermBuffer pb ;
switch(scanType)
{
case XmSELECT_POSITION:
posToBufferRowCol(tw, position, &pb, &row, &col) ;
if ( col > _DtTermPrimBufferGetLineWidth(pb, row) )
{
col = selectInfo->columns + 1;
position = bufferRowColToPos(tw,pb,row,col) ;
}
break;
case XmSELECT_WORD:
{
short width;
posToBufferRowCol(tw, position, &pb, &row, &col) ;
width = _DtTermPrimBufferGetLineWidth(pb,row);
if ( col > width ) break;
if ( MB_CUR_MAX > 1 )
{
TermCharInfoRec charInfoRec ;
_DtTermPrimGetCharacterInfo(pb,row,col,&charInfoRec);
col = charInfoRec.startCol ; /* align first */
switch(scanDir)
{
case scanLeft:
_DtTermPrimGetCharacterInfo(pb,row,col?--col:0,&charInfoRec);
while( !iswspace(*(wchar_t *)charInfoRec.u.pwc) &&
((col=charInfoRec.startCol-1)>=0) )
{
_DtTermPrimGetCharacterInfo(pb,row,col,&charInfoRec) ;
}
col ++ ;
break;
case scanRight:
_DtTermPrimGetCharacterInfo(pb,row,col,&charInfoRec);
while(++col<=width && !iswspace(*(wchar_t *)charInfoRec.u.pwc))
_DtTermPrimGetCharacterInfo(pb,row,col,&charInfoRec);
col--;
break;
}
}
else
{
char pbuf[10];
switch(scanDir)
{
case scanLeft:
_DtTermPrimBufferGetText(pb, row, col?--col:0, 1, pbuf, False);
while( !isspace(*pbuf) && --col >= 0)
_DtTermPrimBufferGetText(pb, row, col, 1, pbuf, False );
col++ ;
break;
case scanRight:
_DtTermPrimBufferGetText(pb, row, col, 1, pbuf, False);
while( ++col <= width && !isspace(*pbuf))
_DtTermPrimBufferGetText(pb, row, col, 1, pbuf, False );
col--;
break;
}
}
position = bufferRowColToPos(tw,pb,row,col) ;
}
break;
case XmSELECT_LINE:
{
posToBufferRowCol(tw, position, &pb, &row, &col) ;
col = 0;
switch(scanDir)
{
case scanLeft:
break;
case scanRight:
col = selectInfo->columns + 1;
break;
}
position = bufferRowColToPos(tw,pb,row,col) ;
}
break;
case XmSELECT_ALL:
switch(scanDir)
{
case scanLeft:
position = 0;
break;
case scanRight:
pb = tpd->termBuffer ;
row = tpd->lastUsedRow-1;
col = _DtTermPrimBufferGetLineWidth(pb,row) ;
position = bufferRowColToPos(tw,pb,row,col) ;
break;
}
break;
}
return(position);
}
/*
** refresh all text from start up to stop
**
** NOTE:
** We assume that start is always <= than stop
*/
void
_DtTermPrimRenderRefreshTextLinear
(
Widget w,
XmTextPosition start,
XmTextPosition stop
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
short startRow, startCol;
short stopRow , stopCol;
/*
** Turn XmTextPosition into a row and column
*/
startRow = start / (selectInfo->columns + 1);
startCol = start - (startRow * (selectInfo->columns + 1));
stopRow = stop / (selectInfo->columns + 1);
stopCol = stop - (stopRow * (selectInfo->columns + 1));
/*
** Accomodate the history buffer as necessary
*/
if (tpd->useHistoryBuffer)
{
startRow -= tpd->lastUsedHistoryRow;
stopRow -= tpd->lastUsedHistoryRow;
}
/*
** Now adjust for the top of the window
*/
startRow -= tpd->topRow;
stopRow -= tpd->topRow;
/*
** refresh the first (and possibly only) line
*/
if (startRow == stopRow)
{
_DtTermPrimRefreshText((Widget)tw, startCol, startRow,
stopCol, startRow);
return;
}
_DtTermPrimRefreshText((Widget)tw, startCol, startRow,
selectInfo->columns - 1, startRow);
/*
** refresh the middle block (if there is one)
*/
if (startRow++ < stopRow)
{
_DtTermPrimRefreshText((Widget)tw, 0, startRow,
selectInfo->columns - 1, stopRow - 1);
}
/*
** refresh the last line
*/
_DtTermPrimRefreshText((Widget)tw, 0, stopRow, stopCol, stopRow);
}
static void
setSelection
(
DtTermPrimitiveWidget tw,
XmTextPosition begin,
XmTextPosition end,
Time selectTime,
Boolean fromLoseSelection
)
{
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
XmTextPosition oldBegin, oldEnd;
Boolean disJoint; /* true if new and current are disjoint */
short selectLineBegin;
short selectColBegin;
short selectLineEnd;
short selectColEnd;
Debug('c', fprintf(stderr, ">>setSelection() starting\n"));
if (selectInfo->ownPrimary == False &&
begin > end)
{
Debug('c', fprintf(stderr, ">>setSelection() finishing a\n"));
return;
}
if (begin < 0)
{
begin = 0;
end = 0;
}
if (selectInfo->ownPrimary)
{
/*
** we own the selection see how much (if any) of the selected
** area needs to be unhighlighted...
*/
if (selectInfo->begin < selectInfo->end)
{
/*
** We own the selection, and its highlighted...
*/
if ((end <= selectInfo->begin) ||
(begin >= selectInfo->end))
{
/*
** The two areas don't intersect, simply clear the old
** area...
*/
Debug('c', fprintf(stderr, " new & old are disjoint\n"));
selectInfo->ownPrimary = False;
_DtTermPrimRenderRefreshTextLinear((Widget)tw,
selectInfo->begin,
selectInfo->end - 1);
selectInfo->ownPrimary = True;
disJoint = True;
}
else
{
/*
** There is some intersection, save the current begin
** and end so we can clean things up later.
*/
Debug('c', fprintf(stderr, " new & old intersect\n"));
oldBegin = selectInfo->begin;
oldEnd = selectInfo->end;
disJoint = False;
}
}
else
{
/*
** We own the selection, but nothing is highlighted...
*/
disJoint = True;
}
}
else
{
/*
** we don't own the selection (yet), come up with some reasonable
** defaults
*/
disJoint = True;
oldBegin = begin;
oldEnd = end;
}
selectInfo->begin = begin;
selectInfo->end = end;
if (begin <= end)
{
if (selectInfo->ownPrimary == False)
{
if (!XtOwnSelection((Widget)tw, XA_PRIMARY, selectTime,
_DtTermPrimSelectConvert,
_DtTermPrimSelectLoseSelection,
(XtSelectionDoneProc) NULL))
{
/*
** XtOwnSelection failed, make a dummy call to setSelection
** (with begin > end) to clear things up...
*/
setSelection(tw, 1, -99, selectTime, False);
}
else
{
selectInfo->ownPrimary = True;
selectInfo->primaryTime = selectTime;
}
}
/*
** now highlight the currently selected text...
*/
if (selectInfo->ownPrimary)
{
if (disJoint == True)
{
/*
** the selections are disjoint, simply draw the new one
*/
_DtTermPrimRenderRefreshTextLinear((Widget)tw, begin, end - 1);
}
else
{
if (begin != oldBegin)
{
if (begin < oldBegin)
{
/*
** refresh from the new beginning to the old
** beginning
*/
_DtTermPrimRenderRefreshTextLinear((Widget)tw, begin,
oldBegin - 1);
}
else if (oldBegin < begin)
{
/*
** refresh from the old beginning to the new
** beginning
**
** NOTE: in this case we want to unhighlight
** previously selected text, so we
** temporarily set ownPrimary to false
*/
selectInfo->ownPrimary = False;
_DtTermPrimRenderRefreshTextLinear((Widget)tw, oldBegin,
begin - 1);
selectInfo->ownPrimary = True;
}
}
if (end != oldEnd)
{
if (end < oldEnd)
{
/*
** refresh from the new end to the original end
**
** NOTE: in this case we want to unhighlight
** previously selected text, so we
** temporarily set ownPrimary to false
*/
selectInfo->ownPrimary = False;
_DtTermPrimRenderRefreshTextLinear((Widget)tw, end,
oldEnd - 1);
selectInfo->ownPrimary = True;
}
else if (oldEnd < end)
{
/*
** refresh from the old end to the new end.
*/
_DtTermPrimRenderRefreshTextLinear((Widget)tw, oldEnd,
end - 1);
}
}
}
}
}
else
{
if (!fromLoseSelection)
{
XtDisownSelection((Widget)tw, XA_PRIMARY, selectTime);
}
selectInfo->ownPrimary = False;
}
selectLineBegin = selectInfo->begin / (selectInfo->columns + 1);
selectColBegin = selectInfo->begin % (selectInfo->columns + 1);
selectLineEnd = (selectInfo->end - 1) / (selectInfo->columns + 1);
selectColEnd = (selectInfo->end - 1) % (selectInfo->columns + 1);
DebugF('c', 1,
fprintf(stderr, "set selection units: %ld-%ld lines: %d-%d\n",
selectInfo->begin, selectInfo->end,
selectLineBegin,
selectLineEnd));
if (tw->term.tpd->useHistoryBuffer && tw->term.tpd->lastUsedHistoryRow>0) {
if (selectLineEnd > tw->term.tpd->lastUsedHistoryRow) {
(void) _DtTermPrimBufferSetSelectLines(tw->term.tpd->historyBuffer,
selectLineBegin, selectColBegin,
tw->term.tpd->lastUsedHistoryRow - 1, selectInfo->columns);
} else {
(void) _DtTermPrimBufferSetSelectLines(tw->term.tpd->historyBuffer,
selectLineBegin, selectColBegin,
selectLineEnd, selectColEnd);
}
selectLineBegin -= tw->term.tpd->lastUsedHistoryRow;
if (selectLineBegin < 0) {
selectLineBegin = 0;
selectColBegin = 0;
}
selectLineEnd -= tw->term.tpd->lastUsedHistoryRow;
}
if (selectLineEnd > tw->term.tpd->lastUsedRow) {
(void) _DtTermPrimBufferSetSelectLines(tw->term.tpd->termBuffer,
selectLineBegin, selectColBegin,
tw->term.tpd->lastUsedRow, selectInfo->columns);
} else {
(void) _DtTermPrimBufferSetSelectLines(tw->term.tpd->termBuffer,
selectLineBegin, selectColBegin,
selectLineEnd, selectColEnd);
}
Debug('c', fprintf(stderr, ">>setSelection() finishing b\n"));
}
static void
handleSelection
(
DtTermPrimitiveWidget tw,
int x,
int y,
Time selectTime
)
{
XmTextPosition position;
XmTextPosition newBegin;
XmTextPosition newEnd;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
Debug('c', fprintf(stderr, ">>handleSelection() starting\n"));
position = xyToPos(tw, x, y);
newBegin = scan(tw, position, selectInfo->scanType, scanLeft,
1, False);
newEnd = scan(tw, position, selectInfo->scanType, scanRight,
1, selectInfo->scanType == XmSELECT_LINE);
setSelection(tw, newBegin, newEnd, selectTime, False);
if ((position - newBegin) <
(newEnd - position))
{
selectInfo->extendDir = scanLeft;
}
else
{
selectInfo->extendDir = scanRight;
}
selectInfo->origBegin = newBegin;
selectInfo->origEnd = newEnd;
}
/************************************************************************
* *
* browseScroll - timer proc that scrolls the list if the user has left *
* the window with the button down. If the button has been *
* released, call the standard click stuff. *
* *
************************************************************************/
/* ARGSUSED */
static void
browseScroll
(
XtPointer closure,
XtIntervalId *id
)
{
Widget w = (Widget) closure;
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo ;
XmScrollBarWidget vsb = (XmScrollBarWidget) tw->term.verticalScrollBar;
unsigned long interval;
if (selectInfo->cancel) {
selectInfo->selectID = 0;
return;
}
if (!selectInfo->selectID) return;
_DtTermPrimScrollComplete(w, True);
if ( selectInfo->isScrollUp ) {
if ( tpd->lastUsedRow-1 >= tpd->topRow + tw->term.rows)
_DtTermPrimScrollText(w, 1);
}
else
_DtTermPrimScrollText(w, -1);
_DtTermPrimScrollComplete(w, True);
if (selectInfo->extending)
doExtendedSelection(w, XtLastTimestampProcessed(XtDisplay(w)));
if (vsb)
interval = (unsigned long) vsb->scrollBar.repeat_delay;
else
interval = 100;
XSync (XtDisplay(w), False);
selectInfo->selectID = XtAppAddTimeOut(XtWidgetToApplicationContext(w),
interval, browseScroll, (XtPointer) w);
}
/* ARGSUSED */
static Boolean
CheckTimerScrolling
(
Widget w,
XEvent *event
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
XmScrollBarWidget vsb = (XmScrollBarWidget) tw->term.verticalScrollBar;
unsigned long interval;
selectInfo->extend.x = event->xmotion.x;
selectInfo->extend.y = event->xmotion.y;
if ( (event->xmotion.y > (int) tpd->offsetY) &&
(event->xmotion.y < (int) (tpd->offsetY + tw->term.rows *
tpd->cellHeight))) {
if (selectInfo->selectID) {
XtRemoveTimeOut(selectInfo->selectID);
selectInfo->selectID = 0;
}
} else {
/* above the text */
if (event->xmotion.y <= (int) tpd->offsetY) {
selectInfo->extend.x = 0;
selectInfo->extend.y = (int) (tpd->offsetY);
selectInfo->isScrollUp = False ;
/* below the text */
} else if (event->xmotion.y >= (int) (tpd->offsetY + tw->term.rows *
tpd->cellHeight)) {
selectInfo->extend.x = tw->core.width;
selectInfo->extend.y = (int) (tpd->offsetY + tw->term.rows *
tpd->cellHeight);
selectInfo->isScrollUp = True ;
}
if (vsb)
interval = (unsigned long) vsb->scrollBar.initial_delay;
else
interval = 200;
if (!selectInfo->selectID)
selectInfo->selectID = XtAppAddTimeOut(XtWidgetToApplicationContext(w),
interval, browseScroll, (XtPointer) w);
return True;
}
return False;
}
/*
** Create and initialize the selection specific information
*/
TermSelectInfo
_DtTermPrimSelectCreate
(
Widget w
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo;
int i;
selectInfo = (TermSelectInfo)XtMalloc(sizeof(TermSelectInfoRec));
selectInfo->begin = 0;
selectInfo->end = 0;
selectInfo->columns = tw->term.columns;
selectInfo->rows = tpd->bufferRows + tpd->historyBufferRows;
selectInfo->direction = (TermScanDirection) XmTEXT_FORWARD;
selectInfo->extend.x = 0;
selectInfo->extend.y = 0;
selectInfo->extending = False;
selectInfo->hint.x = 0;
selectInfo->hint.y = 0;
selectInfo->lastTime = 0;
selectInfo->origBegin = 0;
selectInfo->origEnd = 0;
selectInfo->ownPrimary = False;
selectInfo->threshold = 5;
selectInfo->selectID = 0;
selectInfo->selectType = TermSelect_NORMAL;
selectInfo->scanType = defaultScanArray[0];
selectInfo->scanArraySize = XtNumber(defaultScanArray);
selectInfo->scanArray = (XmTextScanType *)
XtMalloc(selectInfo->scanArraySize *
sizeof(XmTextScanType));
selectInfo->cancel = True; /* used by scroll selection */
selectInfo->anchor = -1; /* in case extend happens before set*/
selectInfo->sel_start = False;
for (i = 0; i < selectInfo->scanArraySize; i++)
{
selectInfo->scanArray[i] = defaultScanArray[i];
}
RegisterDropSite(w);
return(selectInfo);
}
void
_DtTermPrimSelectInitBtnEvents(Widget w)
{
Boolean btn1_transfer = False;
XtVaGetValues((Widget)XmGetXmDisplay(XtDisplay(w)), "enableBtn1Transfer",
&btn1_transfer, NULL);
if (btn1_transfer)
XtOverrideTranslations(w,
XtParseTranslationTable(_DtTermEventBindingsCDE));
if (btn1_transfer == True) /* for btn2 extend case */
XtOverrideTranslations(w,
XtParseTranslationTable(_DtTermEventBindingsCDEBtn2));
}
void
_DtTermPrimSelectDisown
(
Widget w
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
if (selectInfo->ownPrimary == True)
{
XtDisownSelection(w, XA_PRIMARY, getServerTime(w));
selectInfo->ownPrimary = False ;
}
}
void
_DtTermPrimSelectDestroy
(
Widget w,
TermSelectInfo selectInfo
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
if (selectInfo->ownPrimary == True)
{
XtDisownSelection(w, XA_PRIMARY, getServerTime(w));
}
selectInfo->ownPrimary = False ;
XtFree((char *) selectInfo->scanArray);
XtFree((char *) selectInfo);
tpd->selectInfo = NULL ;
}
/*
** determine how much (if any) of the text is selected
**
** NOTE:
** beginCol + width will never exceed the width of the terminal
** buffer
*/
Boolean
_DtTermPrimSelectIsInSelection
(
Widget w,
int row,
short startCol,
short width,
short *selWidth
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
Boolean inSelection = True;
XmTextPosition endPosition;
XmTextPosition position;
XmTextPosition begin;
XmTextPosition end;
short beginRow, beginCol;
short endRow , endCol;
position = rowColToPos(tw, row, startCol);
endPosition = position + width;
begin = selectInfo->begin;
end = selectInfo->end;
if ((begin >= endPosition) || (end <= position))
{
/*
** outside of selection range...
*/
inSelection = False;
}
else
{
/*
** we're in the selection range, clip endPosition as necessary...
*/
if (position < begin)
{
/*
** we start to the left of the selection...
*/
inSelection = False;
endPosition = MIN(endPosition, begin);
}
else
{
/*
** we must be in the selection, clip endPosition as
** necessary...
*/
endPosition = MIN(endPosition, end);
}
}
*selWidth = endPosition - position;
return(inSelection);
}
/*ARGSUSED*/
void
_DtTermPrimSelectDoSelection
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectDoSelection() starting\n"));
handleSelection(tw, event->xbutton.x, event->xbutton.y,
event->xbutton.time);
}
/*ARGSUSED*/
void
_DtTermPrimSelectSetHint
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
TermSelectInfo selectInfo =
((DtTermPrimitiveWidget)w)->term.tpd->selectInfo;
selectInfo->hint.x = event->xbutton.x;
selectInfo->hint.y = event->xbutton.y;
}
/*ARGSUSED*/
void
_DtTermPrimSelectStart
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
XButtonEvent *btnEvent = (XButtonEvent *) event;
XmTextPosition begin;
XmTextPosition end;
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectStart() starting\n"));
/*
** set the selection hints, and scan type
*/
_DtTermPrimSelectSetHint(w, event, params, paramCount);
setScanType(w, event);
/*
** Set the current anchor point
*/
selectInfo->anchor = xyToPos(tw, btnEvent->x, btnEvent->y);
if (selectInfo->scanType != XmSELECT_POSITION ||
(_DtTermPrimSelectGetSelection(w, &begin, &end) && begin != end)
)
{
_DtTermPrimSelectDoSelection(w, event, params, paramCount);
}
}
/*ARGSUSED*/
void
_DtTermPrimSelectGrabFocus
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
XButtonEvent *btnEvent = (XButtonEvent *) event;
/* setDebugFlags("c") ; */
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectGrabFocus() starting\n"));
/* turn off the cursor */
_DtTermPrimCursorOff(w);
selectInfo->cancel = False;
tw->term.allowOsfKeysyms = True; /* normal dtterm doesn't honor these*/
/*
** constrain the button event to the terminal's text area
*/
if (btnEvent->x <= (int) tpd->offsetX)
{
/* left */
btnEvent->x = (int)(tpd->offsetX + 1);
} else if (btnEvent->x >= (int)(tw->core.width - tpd->offsetX))
{
/* right */
btnEvent->x = (int)(tw->core.width - tpd->offsetX - 1);
}
if (btnEvent->y <= (int)tpd->offsetY)
{
/* above */
btnEvent->y = (int)(tpd->offsetY + 1);
}
else if (btnEvent->y - ((int)(tpd->offsetY +
((tpd->lastUsedRow - tpd->topRow) *
tpd->cellHeight))) >= selectInfo->threshold)
{
/* below */
btnEvent->y = (int)(tpd->offsetY + ((tpd->lastUsedRow - tpd->topRow) *
tpd->cellHeight) - 1);
}
if (_XmGetFocusPolicy(w) == XmEXPLICIT)
(void) XmProcessTraversal(w, XmTRAVERSE_CURRENT);
_DtTermPrimSelectStart(w, event, params, paramCount);
}
static
Boolean
dragged
(
TermSelectionHint hint,
XEvent *event,
int threshold
)
{
return ((abs(hint.x - event->xbutton.x) > threshold) ||
(abs(hint.y - event->xbutton.y) > threshold));
}
/* ARGSUSED */
static void
doExtendedSelection
(
Widget w,
Time eventTime
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
XmTextPosition position;
XmTextPosition begin;
XmTextPosition end;
XmTextPosition cursorPos;
float midPoint;
if (selectInfo->cancel) {
if (selectInfo->selectID) XtRemoveTimeOut(selectInfo->selectID);
selectInfo->selectID = 0;
return;
}
position = xyToPos(tw, selectInfo->extend.x, selectInfo->extend.y);
if (!(_DtTermPrimSelectGetSelection(w, &begin, &end)) ||
(begin == end))
{
begin = position;
end = position;
if ( selectInfo->anchor <0) selectInfo->anchor = position;
selectInfo->origBegin = selectInfo->anchor;
selectInfo->origEnd = selectInfo->anchor;
midPoint = (float)selectInfo->anchor;
}
else
{
midPoint = (float)
(((float)(selectInfo->origEnd -
selectInfo->origBegin) / 2.0) +
(float)selectInfo->origBegin);
}
/*
** shift anchor and direction to opposite end of the selection
*/
if ((float)(position) <= midPoint)
{
selectInfo->anchor = selectInfo->origEnd;
if (!selectInfo->extending)
{
selectInfo->extendDir = scanLeft;
}
}
else if ((float)(position) > midPoint)
{
selectInfo->anchor = selectInfo->origBegin;
if (!selectInfo->extending)
{
selectInfo->extendDir = scanRight;
}
}
selectInfo->extending = TRUE;
/*
** check for change in extend direction
*/
if ((selectInfo->extendDir == scanRight &&
position < selectInfo->anchor) ||
(selectInfo->extendDir == scanLeft &&
position > selectInfo->anchor))
{
selectInfo->extendDir = (selectInfo->extendDir == scanRight) ?
scanLeft : scanRight;
begin = selectInfo->begin;
end = selectInfo->end;
}
if (selectInfo->extendDir == scanRight)
{
cursorPos = scan(tw, position, selectInfo->scanType, scanRight, 1,
selectInfo->scanType == XmSELECT_LINE);
end = cursorPos;
begin = selectInfo->anchor;
}
else
{
cursorPos = scan(tw, position, selectInfo->scanType, scanLeft, 1,
FALSE);
begin = cursorPos;
end = selectInfo->anchor;
if (selectInfo->scanType == XmSELECT_WORD &&
(int)tw->term.tpd->cellWidth > 1)
{
if (position == scan (tw, begin, selectInfo->scanType, scanRight, 1,
FALSE))
{
begin = position;
}
}
}
setSelection(tw, begin, end, eventTime, False);
}
void
_DtTermPrimSelectExtendStart(
Widget w,
XEvent *event,
String *params,
Cardinal *num_params )
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
selectInfo->cancel = False;
tw->term.allowOsfKeysyms = True ;
_DtTermPrimSelectExtend(w, event, params, num_params);
}
/*ARGSUSED*/
void
_DtTermPrimSelectExtend
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectExtend() starting\n"));
/* turn off the cursor */
_DtTermPrimCursorOff(w);
if (_XmGetFocusPolicy(w) == XmEXPLICIT)
(void) XmProcessTraversal(w, XmTRAVERSE_CURRENT);
if (selectInfo->cancel) return ;
if ((selectInfo->hint.x > 0) || (selectInfo->hint.y > 0))
{
if (dragged(selectInfo->hint, event, selectInfo->threshold))
{
/*
** extend the selection
*/
handleSelection(tw,selectInfo->hint.x,selectInfo->hint.y,
event->xbutton.time);
selectInfo->hint.x = 0;
selectInfo->hint.y = 0;
selectInfo->extending = True;
}
else
{
/*
** do nothing
*/
return;
}
}
/*
** check for timer scrolling here
** NOTE: CheckTimerScrolling(w,event) will set extend.[x|y]
* selectInfo->extend.x = event->xbutton.x;
* selectInfo->extend.y = event->xbutton.y;
*/
if (!CheckTimerScrolling(w,event) )
doExtendedSelection(w, event->xbutton.time);
}
/*ARGSUSED*/
void
_DtTermPrimSelectExtendEnd
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectExtendEnd() starting\n"));
selectInfo->cancel = True; /* used by scroll selection */
tw->term.allowOsfKeysyms = False;
if (selectInfo->extending)
{
_DtTermPrimSelectGetSelection(w, &selectInfo->origBegin,
&selectInfo->origEnd);
setSelection(tw, selectInfo->origBegin, selectInfo->origEnd,
event->xbutton.time, False);
/* _DtTermPrimSelectExtend(w, event, params, paramCount);*/
}
if (selectInfo->selectID > 0)
{
XtRemoveTimeOut(selectInfo->selectID);
selectInfo->selectID = 0;
}
selectInfo->extend.x = 0;
selectInfo->extend.y = 0;
selectInfo->extending = False;
selectInfo->hint.x = 0;
selectInfo->hint.y = 0;
/* turn off the cursor */
_DtTermPrimCursorOn(w);
}
/*ARGSUSED*/
static void
doHandleTargets
(
Widget w,
XtPointer closure,
Atom *seltype,
Atom *type,
XtPointer value,
unsigned long *length,
int *format
)
{
_TermSelectPrimaryRec *primSelect = (_TermSelectPrimaryRec *) closure;
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
XTextProperty tmpProp;
XmTextBlockRec block;
int i, status;
char *pChar;
char *pCharEnd;
char *pCharFollow;
int malloc_size=0 , numVals ;
char *total_tmp_value ;
char **tmp_value ;
Debug('c', fprintf(stderr, ">>doHandleTargets() starting\n"));
if (_XmGetFocusPolicy(w) == XmEXPLICIT)
{
(void) XmProcessTraversal(w, XmTRAVERSE_CURRENT);
}
if (*type == XmInternAtom(XtDisplay(w), "COMPOUND_TEXT", False) ||
*type == XA_STRING)
{
tmpProp.value = (unsigned char *) value;
tmpProp.encoding = *type;
tmpProp.format = *format;
tmpProp.nitems = *length;
numVals = 0;
status = XmbTextPropertyToTextList(XtDisplay(w), &tmpProp,
&tmp_value, &numVals );
/*
** if no conversions, numVals doesn't change
*/
if (numVals && (status == Success || status > 0))
{
for (i = 0; i < numVals ; i++)
{
malloc_size += strlen(tmp_value[i]);
}
total_tmp_value = XtMalloc ((unsigned) malloc_size + 1);
total_tmp_value[0] = '\0';
for (i = 0; i < numVals ; i++)
{
strcat(total_tmp_value, tmp_value[i]);
}
block.ptr = total_tmp_value;
block.length = strlen(total_tmp_value);
block.format = XmFMT_8_BIT;
XFreeStringList(tmp_value);
}
else
{
malloc_size = 1; /* to force space to be freed */
total_tmp_value = XtMalloc ((unsigned)1);
*total_tmp_value = '\0';
block.ptr = total_tmp_value;
block.length = 0;
block.format = XmFMT_8_BIT;
}
} else {
block.ptr = (char*)value;
block.length = (int) *length; /* NOTE: this causes a truncation on
some architectures */
block.format = XmFMT_8_BIT;
}
pCharEnd = block.ptr + block.length;
pCharFollow = (char *)block.ptr;
for (pChar = (char *)block.ptr; pChar < pCharEnd; pChar++)
{
if (*pChar == '\n')
{
*pChar = '\r';
DtTermSubprocSend(w, (unsigned char *) pCharFollow,
pChar - pCharFollow + 1);
pCharFollow = pChar + 1;
}
}
if (pCharFollow < pCharEnd)
{
DtTermSubprocSend(w, (unsigned char *) pCharFollow,
pCharEnd - pCharFollow);
}
if (malloc_size != 0) XtFree(total_tmp_value);
XtFree((char *)value);
if (primSelect && (--primSelect->ref_count == 0))
{
XtFree((char *)primSelect);
}
value = NULL ;
}
/*
** Look at the target list and determine what target to place in the
** pair. it will then do any necessary conversions before "thrusting"
** the selection value onto the receiver. this will guarantee the
** best chance at a successful exchange.
*/
/*ARGSUSED*/
static void
handleTargets
(
Widget w,
XtPointer closure,
Atom *selType,
Atom *type,
XtPointer value,
unsigned long *length,
int *format
)
{
Atom CS_OF_LOCALE;
Atom COMPOUND_TEXT;
Boolean supportsLocaleData;
Boolean supportsCompoundText;
Atom *atomPtr;
_TermSelectRec *tmpAction;
_TermSelectPrimaryRec *primSelect;
char *abcString;
XTextProperty tmpProp;
int status;
XtPointer closures[2];
Atom targets[2];
int i;
/*
** make sure we have something to do...
*/
tmpAction = (_TermSelectRec *) closure;
if (!length || *length == 0) {
XtFree((char *)value);
value = NULL;
XtFree((char *)tmpAction->event);
XtFree((char *)tmpAction);
return;
}
COMPOUND_TEXT = XmInternAtom(XtDisplay(w),"COMPOUND_TEXT", False);
supportsLocaleData = False;
supportsCompoundText = False;
abcString = "ABC"; /* characters in XPCS, so... safe */
atomPtr = (Atom *)value;
tmpProp.value = NULL;
status = XmbTextListToTextProperty(XtDisplay(w), &abcString, 1,
(XICCEncodingStyle)XTextStyle, &tmpProp);
if (status == Success)
{
CS_OF_LOCALE = tmpProp.encoding;
}
else
{
/*
** Kludge for failure of XmbText... to
** handle XPCS characters. Should never
** happen, but this prevents a core dump
** if X11 is broken.
*/
CS_OF_LOCALE = (Atom)9999;
}
if (tmpProp.value != NULL)
{
XFree((char *)tmpProp.value);
}
for (i = 0; i < *length; i++, atomPtr++)
{
if (*atomPtr == CS_OF_LOCALE)
{
supportsLocaleData = True;
break;
}
if (*atomPtr == COMPOUND_TEXT)
{
supportsCompoundText = True;
}
}
primSelect = (_TermSelectPrimaryRec *)
XtMalloc((unsigned) sizeof(_TermSelectPrimaryRec));
/*
** If owner and I are using the same codeset, ask for it. If not,
** and if the owner supports compound text, ask for compound text.
** If not, fall back position is to ask for STRING and try to
** convert it locally.
*/
if (supportsLocaleData)
{
primSelect->target = targets[0] = CS_OF_LOCALE;
}
else if (supportsCompoundText)
{
primSelect->target = targets[0] = COMPOUND_TEXT;
}
else
{
primSelect->target = targets[0] = XA_STRING;
}
closures[0] = (char *)primSelect;
primSelect->ref_count = 1;
/*
** Make request to call doHandleTargets() with the primary selection.
*/
XtGetSelectionValue(w, XA_PRIMARY, targets[0], doHandleTargets,
(XtPointer)primSelect,
tmpAction->event->xbutton.time);
XtFree((char *)value);
value = NULL;
XtFree((char *)tmpAction->event);
XtFree((char *)tmpAction);
}
static char *
getString
(
Widget w,
XmTextPosition begin,
XmTextPosition end,
Boolean needWideChar
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
TermBuffer tb;
short beginRow,
beginCol;
short endRow,
endCol;
short thisRow;
short numRows;
char *buffer;
char *pBuf;
short len;
beginRow = begin / (selectInfo->columns + 1);
beginCol = begin - (beginRow * (selectInfo->columns + 1));
endRow = end / (selectInfo->columns + 1);
endCol = end - (endRow * (selectInfo->columns + 1));
numRows = endRow - beginRow + 1;
/*
** we need to store end - begin characters, a terminating byte, plus
** a new line for each line...
**
** NOTE: end - begin could result in a truncated long.
*/
buffer = XtMalloc(((int)(end - begin) + 1 + numRows) * sizeof(char)
* BYTES_PER_CHAR(tpd->termBuffer));
/*
** return a null string if there is nothing to do
*/
if (begin == end)
{
*buffer = 0x00;
return(buffer);
}
/*
** Accomodate the history buffer as necessary
*/
if (tpd->useHistoryBuffer)
{
beginRow -= tpd->lastUsedHistoryRow;
endRow -= tpd->lastUsedHistoryRow;
}
/*
** get the first (and possibly only) line of text
*/
pBuf = buffer;
if (beginRow == endRow)
{
if (beginRow < 0)
{
tb = tpd->historyBuffer;
thisRow = beginRow + tpd->lastUsedHistoryRow;
}
else
{
tb = tpd->termBuffer;
thisRow = beginRow;
}
len = _DtTermPrimBufferGetText(tb, thisRow, beginCol,
endCol - beginCol, pBuf, needWideChar);
pBuf += len;
}
else
{
if (beginRow < 0)
{
tb = tpd->historyBuffer;
thisRow = beginRow + tpd->lastUsedHistoryRow;
}
else
{
tb = tpd->termBuffer;
thisRow = beginRow;
}
len = _DtTermPrimBufferGetText(tb, thisRow, beginCol,
selectInfo->columns - beginCol, pBuf,
needWideChar);
pBuf += len;
if ( !_DtTermPrimBufferTestLineWrapFlag(tb,thisRow) ) {
*pBuf = '\n'; /* newline */
pBuf++;
}
/*
** get the middle block (if there is one)
*/
beginRow++;
while(beginRow < endRow)
{
if (beginRow < 0)
{
tb = tpd->historyBuffer;
thisRow = beginRow + tpd->lastUsedHistoryRow;
}
else
{
tb = tpd->termBuffer;
thisRow = beginRow;
}
len = _DtTermPrimBufferGetText(tb, thisRow, 0,
selectInfo->columns , pBuf,
needWideChar);
pBuf += len;
/* if (len != 0 && len < selectInfo->columns ) { */
if ( !_DtTermPrimBufferTestLineWrapFlag(tb,thisRow) ) {
*pBuf = '\n'; /* newline */
pBuf++;
}
beginRow++;
}
/*
** get the last line
*/
if (endRow < 0)
{
tb = tpd->historyBuffer;
thisRow = endRow + tpd->lastUsedHistoryRow;
}
else
{
tb = tpd->termBuffer;
thisRow = endRow;
}
len = _DtTermPrimBufferGetText(tb, thisRow, 0, endCol, pBuf,
needWideChar);
pBuf += len;
}
*pBuf = 0x00;
return(buffer);
}
/*
** Request targets from selection owner.
*/
static void
getTargets
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
_TermSelectRec *tmp;
tmp = (_TermSelectRec*)XtMalloc(sizeof(_TermSelectRec));
/*
** Request targets from the selection owner so you can decide what to
** request. The decision process and request for the selection is
** taken care of in handleTargets().
*/
tmp->event = (XEvent *) XtMalloc(sizeof(XEvent));
memcpy((void *)tmp->event, (void *)event, sizeof(XEvent));
tmp->params = params;
tmp->num_params = paramCount;
XtGetSelectionValue(w, XA_PRIMARY,
XmInternAtom(XtDisplay(w), "TARGETS", False),
handleTargets, (XtPointer)tmp, event->xbutton.time);
}
Boolean
_DtTermPrimSelectConvert
(
Widget w,
Atom *selection,
Atom *target,
Atom *type,
XtPointer *value,
unsigned long *length,
int *format
)
{
Atom TARGETS = XmInternAtom(XtDisplay(w), "TARGETS", False);
Atom CS_OF_LOCALE;
Atom COMPOUND_TEXT = XmInternAtom(XtDisplay(w), "COMPOUND_TEXT", False);
Atom TEXT = XmInternAtom(XtDisplay(w), "TEXT", False);
Atom MOTIF_DROP = XmInternAtom(XtDisplay(w), "_MOTIF_DROP", False);
int maxTargets = 10;
int targetCount;
int status;
Widget widget;
Boolean ownPrimary;
XmTextPosition begin;
XmTextPosition end;
char *tmpValue;
char *tmpString = "ABC"; /* characters in XPCS, so... safe */
XTextProperty tmpProp;
XtPointer c_ptr;
Arg args[1];
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectConvert() starting\n"));
if (*selection == MOTIF_DROP) {
XtSetArg(args[0], XmNclientData, &c_ptr);
XtGetValues(w, args, 1);
widget = (Widget)c_ptr;
} else
widget = w;
if (widget == NULL) return False;
tmpProp.value = NULL;
status = XmbTextListToTextProperty(XtDisplay(widget), &tmpString, 1,
(XICCEncodingStyle)XTextStyle, &tmpProp);
if (status == Success)
{
CS_OF_LOCALE = tmpProp.encoding;
}
else
{
/*
** XmbTextList... SHOULD never fail for
** XPCS character. But if it does, this
** prevents a core dump.
*/
CS_OF_LOCALE = (Atom) 9999;
}
if (tmpProp.value != NULL)
XFree((char *) tmpProp.value);
if (*selection == XA_PRIMARY || *selection == MOTIF_DROP)
{
ownPrimary = _DtTermPrimSelectGetSelection(widget, &begin, &end);
}
else
{
return(False);
}
if (*target == TARGETS)
{
Atom *targets = (Atom *)XtMalloc((unsigned)(maxTargets * sizeof(Atom)));
/*
** Xt should take care of TIME_STAMP for us.
*/
targetCount = 0;
*value = (XtPointer)targets;
*targets++ = TARGETS; targetCount++;
if (!isDebugFSet('s', 1)) {
*targets++ = COMPOUND_TEXT; targetCount++;
}
if (!isDebugFSet('s', 2)) {
*targets++ = CS_OF_LOCALE; targetCount++;
}
if (!isDebugFSet('s', 3)) {
*targets++ = TEXT; targetCount++;
}
if (!isDebugFSet('s', 4)) {
*targets++ = XA_STRING; targetCount++;
}
*type = XA_ATOM;
*length = (targetCount * sizeof(Atom)) >> 2; /* convert to work count */
*format = 32;
}
else if (!ownPrimary)
{
return(False);
}
else if ((*target == XA_STRING && !isDebugFSet('s', 4)) ||
(*target == COMPOUND_TEXT && !isDebugFSet('s', 1)))
{
tmpValue = getString(widget, begin, end, False);
tmpProp.value = NULL;
if ((*target == XA_STRING) && !isDebugFSet('s', 4)) {
*type = (Atom) XA_STRING;
*format = 8;
status = XmbTextListToTextProperty(XtDisplay(widget), &tmpValue, 1,
(XICCEncodingStyle)XStringStyle,
&tmpProp);
}
else if ((*target == COMPOUND_TEXT) && !isDebugFSet('s',1)) {
*type = COMPOUND_TEXT;
*format = 8;
status = XmbTextListToTextProperty(XtDisplay(widget), &tmpValue, 1,
(XICCEncodingStyle)XCompoundTextStyle,
&tmpProp);
}
XtFree(tmpValue);
if (status == Success || status > 0)
{
/*
** NOTE: casting tmpProp.nitems could result in a truncated long.
*/
if (tmpProp.nitems > 0)
*value = (XtPointer) XtMalloc((unsigned)tmpProp.nitems);
else
*value = (XtPointer) XtMalloc(1);
*length = tmpProp.nitems;
memcpy((void*)*value, (void*)tmpProp.value,
(unsigned)tmpProp.nitems);
if (tmpProp.value != NULL)
XFree((char*)tmpProp.value);
}
else
{
*value = NULL;
*length = 0;
if (tmpProp.value != NULL)
XFree((char*)tmpProp.value);
return(False);
}
}
else if (((*target == CS_OF_LOCALE) && !isDebugFSet('s', 2)) ||
(*target == TEXT && !isDebugFSet('s', 3)))
{
*type = CS_OF_LOCALE;
*format = 8;
*value = (XtPointer)getString(widget, begin, end, False);
*length = strlen((char*) *value);
}
else
{
*value = NULL;
*length = 0;
return(False);
}
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectConvert() exiting\n"));
return(True);
}
void
_DtTermPrimSelectLoseSelection
(
Widget w,
Atom *selection
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
Boolean restoreCursor = False;
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectLoseSelection() starting\n"));
if (*selection == XA_PRIMARY && selectInfo->ownPrimary)
{
/*
** We've lost the primary selection, make a dummy call to
** setSelection (with begin > end) to clear things up...
*/
/* turn off the cursor */
if (tw->term.tpd->cursorState != CURSORoff) {
_DtTermPrimCursorOff(w);
restoreCursor = True;
}
setSelection(tw, 1, -99, XtLastTimestampProcessed(XtDisplay(w)), True);
/* turn on the cursor */
if (restoreCursor) {
_DtTermPrimCursorOn(w);
}
}
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectLoseSelection() exiting\n"));
}
/*ARGSUSED*/
void
_DtTermPrimSelectBDragRelease
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
TermSelectInfo selectInfo =
((DtTermPrimitiveWidget)w)->term.tpd->selectInfo;
XButtonEvent *btnEvent = (XButtonEvent *) event;
Debug('c', fprintf(stderr, ">>_DtTermPrimSelectBDragRelease() starting\n"));
/* Work around for intrinsic bug. Remove once bug is fixed.
** this is for drag/drop
*/
XtUngrabPointer(w, btnEvent->time);
if ( selectInfo->sel_start ) getTargets(w, event, params, paramCount);
}
/*ARGSUSED*/
void
_DtTermPrimSelectInsert
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
if (!selectInfo->cancel)
_DtTermPrimSelectBDragRelease(w, event, params, paramCount);
selectInfo->cancel = True ;
/* turn on the cursor */
_DtTermPrimCursorOn(w);
}
Boolean
_DtTermPrimSelectIsAboveSelection
(
Widget w,
short row,
short col
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
XmTextPosition curPos, endPos;
endPos = selectInfo->end ;
curPos = rowColToPos(tw,row,col) ;
if ( curPos < endPos )
return(True) ;
else
return(False) ;
}
void
_DtTermPrimSelectResize
(
Widget w
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
_DtTermPrimSelectDisown(w) ;
selectInfo->columns = tw->term.columns ;
}
extern void
_DtTermPrimSelectMoveLines
(
Widget w,
short src,
short dest,
short len
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
short selectLineBegin;
short selectLineEnd;
TermBuffer pb;
short row,col;
posToBufferRowCol (tw, selectInfo->begin, &pb, &row, &col);
/* if there are no lines, etc. return... */
if ((len <= 0) || (src == dest) || !selectInfo->ownPrimary ||
pb == tw->term.tpd->historyBuffer ) {
return;
}
if (row >= src && row < (src + len)) {
selectInfo->begin -= (src - dest) * (selectInfo->columns + 1);
selectInfo->end -= (src - dest) * (selectInfo->columns + 1);
}
}
extern void
_DtTermPrimSelectDeleteLines
(
Widget w,
short src,
short len
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
short selectLineBegin;
short selectLineEnd;
TermBuffer pb;
short row,col;
posToBufferRowCol (tw, selectInfo->begin, &pb, &row, &col);
/* if there are no lines, etc. return... */
if ((len <= 0) || !selectInfo->ownPrimary ||
((tw->term.tpd->scrollLockTopRow > 0 ||
(tw->term.tpd->scrollLockBottomRow < tw->term.rows-1)) &&
row < tw->term.tpd->scrollLockTopRow)) {
return;
}
/* figure out what the begin line is... */
selectLineBegin = selectInfo->begin / (selectInfo->columns + 1);
/* if the beginning of the selection is after the source, we need to
* move the selection up...
*/
if (selectLineBegin > src) {
selectInfo->begin -= len * (selectInfo->columns + 1);
selectInfo->end -= len * (selectInfo->columns + 1);
if (selectInfo->begin < 0) {
(void) _DtTermPrimSelectDisown(w);
}
}
}
extern void
_DtTermPrimSelectInsertLines
(
Widget w,
short src,
short len
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
short selectLineBegin;
short selectLineEnd;
/* if there are no lines, return... */
if ((len <= 0) || !selectInfo->ownPrimary) {
return;
}
/* figure out what the begin line is... */
selectLineBegin = selectInfo->begin / (selectInfo->columns + 1);
/* if the beginning of the selection is at or after the source, we need to
* move the selection up...
*/
if (selectLineBegin >= src) {
selectInfo->begin += len * (selectInfo->columns + 1);
selectInfo->end += len * (selectInfo->columns + 1);
}
}
void
_DtTermPrimSelectAll
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
DtTermPrimData tpd = tw->term.tpd;
TermSelectInfo selectInfo = tpd->selectInfo;
XButtonEvent *btnEvent = (XButtonEvent *) event;
XmTextPosition begin;
XmTextPosition end;
/* position not used in XmSELECT_ALL case */
begin = scan(tw, (XmTextPosition) 0, XmSELECT_ALL, scanLeft,
1, False);
end = scan(tw, (XmTextPosition) 0, XmSELECT_ALL, scanRight,
1, selectInfo->scanType == XmSELECT_LINE);
/* turn off the cursor */
_DtTermPrimCursorOff(w);
setSelection(tw, begin, end, event->xbutton.time, False);
/* turn on the cursor */
_DtTermPrimCursorOn(w);
}
void
_DtTermPrimSelectPage
(
Widget w,
XEvent *event,
String *params,
Cardinal *paramCount
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
XButtonEvent *btnEvent = (XButtonEvent *) event;
XmTextPosition begin, end;
short lastRow, width;
TermBuffer pb;
begin = xyToPos(tw, 1, 1);
end = xyToPos(tw, tw->core.width-1, tw->core.height-1);
/* turn off the cursor */
_DtTermPrimCursorOff(w);
setSelection(tw, begin, end, event->xbutton.time, False);
/* turn on the cursor */
_DtTermPrimCursorOn(w);
}
/*
* DROP SITE code
*/
static XContext _DtTermDNDContext = 0;
static void
DropTransferCallback(
Widget w,
XtPointer closure,
Atom *seltype,
Atom *type,
XtPointer value,
unsigned long *length,
int *format )
{
_DtTermDropTransferRec *transfer_rec = (_DtTermDropTransferRec *) closure;
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)transfer_rec->widget;
/* When type = NULL, we are assuming a DELETE request has been requested */
if (*type == 0) {
if (value) {
XtFree((char *)value);
value = NULL;
}
return;
}
doHandleTargets((Widget)tw,NULL,seltype,type,value,length,format) ;
if (transfer_rec->move) {
XmDropTransferEntryRec transferEntries[1];
XmDropTransferEntryRec *transferList = NULL;
transferEntries[0].client_data = (XtPointer) transfer_rec;
transferEntries[0].target = XmInternAtom(XtDisplay(w),"DELETE",
False);
XmDropTransferAdd(w, transferEntries, 1);
}
}
static void
DeleteDropContext(
Widget w )
{
Display *display = XtDisplay(w);
Screen *screen = XtScreen(w);
XDeleteContext(display, (Window)screen, _DtTermDNDContext);
}
static void
SetDropContext(
Widget w )
{
Display *display = XtDisplay(w);
Screen *screen = XtScreen(w);
_DtTermProcessLock();
if (_DtTermDNDContext == 0)
_DtTermDNDContext = XUniqueContext();
_DtTermProcessUnlock();
XSaveContext(display, (Window)screen,
_DtTermDNDContext, (XPointer)w);
}
typedef struct _dropDestroyCBClientData {
_DtTermDropTransferRec *transfer_rec;
XtCallbackRec *dropDestroyCB; }
dropDestroyCBClientData;
/* ARGSUSED */
static void
DropDestroyCB(
Widget w,
XtPointer clientData,
XtPointer callData )
{
dropDestroyCBClientData *ptr = (dropDestroyCBClientData *) clientData;
DeleteDropContext(w);
if (ptr) {
if (ptr->transfer_rec) XtFree((char *) ptr->transfer_rec);
if (ptr->dropDestroyCB) XtFree((char *) ptr->dropDestroyCB);
XtFree((char *) ptr);
}
}
static void
HandleDrop( Widget w, XmDropProcCallbackStruct *cb )
{
Widget drag_cont, initiator;
/* XmTextWidget tw = (XmTextWidget) w; */
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
Cardinal numExportTargets, n;
Atom *exportTargets;
Arg args[10];
XmTextPosition insert_pos, left, right;
XtCallbackRec *dropDestroyCB, *dd_cb;
dropDestroyCBClientData *clientData;
clientData = (dropDestroyCBClientData *) XtMalloc(sizeof(dropDestroyCBClientData));
dropDestroyCB = dd_cb = (XtCallbackRec *) XtMalloc(2 * sizeof (XtCallbackRec));
clientData->dropDestroyCB = dropDestroyCB;
dd_cb->callback = DropDestroyCB;
dd_cb->closure = NULL;
dd_cb++;
dd_cb->callback = (XtCallbackProc) NULL;
dd_cb->closure = NULL;
drag_cont = cb->dragContext;
n = 0;
XtSetArg(args[n], XmNsourceWidget, &initiator); n++;
XtSetArg(args[n], XmNexportTargets, &exportTargets); n++;
XtSetArg(args[n], XmNnumExportTargets, &numExportTargets); n++;
XtGetValues((Widget) drag_cont, args, n);
{
XmDropTransferEntryRec transferEntries[2];
XmDropTransferEntryRec *transferList = NULL;
Atom TEXT = XmInternAtom(XtDisplay(w), "TEXT", False);
Atom COMPOUND_TEXT = XmInternAtom(XtDisplay(w), "COMPOUND_TEXT", False);
Atom CS_OF_LOCALE;
char * tmp_string = "ABC"; /* these are characters in XPCS, so... safe */
XTextProperty tmp_prop;
_DtTermDropTransferRec *transfer_rec;
Cardinal numTransfers = 0;
Boolean locale_found = False;
Boolean c_text_found = False;
Boolean string_found = False;
Boolean text_found = False;
int status;
tmp_prop.value = NULL;
status = XmbTextListToTextProperty(XtDisplay(w), &tmp_string, 1,
(XICCEncodingStyle)XTextStyle, &tmp_prop);
if (status == Success)
CS_OF_LOCALE = tmp_prop.encoding;
else
CS_OF_LOCALE = 99999; /* XmbTextList... should never fail for XPCS
* characters. But just in case someones
* Xlib is broken, this prevents a core dump.
*/
if (tmp_prop.value != NULL) XFree((char *)tmp_prop.value);
/* intialize data to send to drop transfer callback */
transfer_rec = (_DtTermDropTransferRec *)
XtMalloc(sizeof(_DtTermDropTransferRec));
clientData->transfer_rec = transfer_rec;
transfer_rec->widget = w;
/* don't actually need all of this for dtterm - it was from Text widget
*transfer_rec->insert_pos = insert_pos;
*transfer_rec->num_chars = 0;
*transfer_rec->timestamp = cb->timeStamp;
*
*/
if (cb->operation & XmDROP_MOVE) {
transfer_rec->move = True;
} else {
transfer_rec->move = False;
}
transferEntries[0].client_data = (XtPointer) transfer_rec;
transferList = transferEntries;
numTransfers = 1;
for (n = 0; n < numExportTargets; n++) {
if (exportTargets[n] == CS_OF_LOCALE) {
transferEntries[0].target = CS_OF_LOCALE;
locale_found = True;
break;
}
if (exportTargets[n] == COMPOUND_TEXT) c_text_found = True;
if (exportTargets[n] == XA_STRING) string_found = True;
if (exportTargets[n] == TEXT) text_found = True;
}
n = 0;
if (locale_found || c_text_found || string_found || text_found) {
if (!locale_found) {
if (c_text_found)
transferEntries[0].target = COMPOUND_TEXT;
else if (string_found)
transferEntries[0].target = XA_STRING;
else
transferEntries[0].target = TEXT;
}
if ( cb->operation & (XmDROP_COPY|XmDROP_MOVE) ) {
XtSetArg(args[n], XmNdropTransfers, transferList); n++;
XtSetArg(args[n], XmNnumDropTransfers, numTransfers); n++;
} else {
XtSetArg(args[n], XmNtransferStatus, XmTRANSFER_FAILURE); n++;
XtSetArg(args[n], XmNnumDropTransfers, 0); n++;
}
} else {
XtSetArg(args[n], XmNtransferStatus, XmTRANSFER_FAILURE); n++;
XtSetArg(args[n], XmNnumDropTransfers, 0); n++;
}
dropDestroyCB->closure = (XtPointer) clientData;
XtSetArg(args[n], XmNdestroyCallback, dropDestroyCB); n++;
XtSetArg(args[n], XmNtransferProc, DropTransferCallback); n++;
}
SetDropContext(w);
XmDropTransferStart(drag_cont, args, n);
}
/* ARGSUSED */
static void
DropProcCallback(
Widget w,
XtPointer client,
XtPointer call )
{
XmDropProcCallbackStruct *cb = (XmDropProcCallbackStruct *) call;
if (cb->dropAction != XmDROP_HELP) {
HandleDrop(w, cb);
} else {
Arg args[2];
XtSetArg(args[0], XmNtransferStatus, XmTRANSFER_FAILURE);
XtSetArg(args[1], XmNnumDropTransfers, 0);
XmDropTransferStart(cb->dragContext, args, 2);
}
}
static void
RegisterDropSite(
Widget w )
{
Atom targets[4];
Arg args[10];
int n;
char * tmp_string = "ABC"; /* these are characters in XPCS, so... safe */
XTextProperty tmp_prop;
int status = 0;
tmp_prop.value = NULL;
status = XmbTextListToTextProperty(XtDisplay(w), &tmp_string, 1,
(XICCEncodingStyle)XTextStyle, &tmp_prop);
if (status == Success)
targets[0] = tmp_prop.encoding;
else
targets[0] = 99999; /* XmbTextList... should never fail for XPCS
* characters. But just in case someones
* Xlib is broken, this prevents a core dump.
*/
if (tmp_prop.value != NULL) XFree((char *)tmp_prop.value);
targets[1] = XmInternAtom(XtDisplay(w), "COMPOUND_TEXT", False);
targets[2] = XA_STRING;
targets[3] = XmInternAtom(XtDisplay(w), "TEXT", False);
n = 0;
XtSetArg(args[n], XmNimportTargets, targets); n++;
XtSetArg(args[n], XmNnumImportTargets, 4); n++;
/* XtSetArg(args[n], XmNdragProc, DragProcCallback); n++; */
XtSetArg(args[n], XmNdropProc, DropProcCallback); n++;
XmDropSiteRegister(w, args, n);
}
/*
* DRAG SITE code
*/
/* ARGSUSED */
static void
StartDrag(
Widget w,
XEvent *event,
String *params,
Cardinal *num_params )
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
Atom targets[4];
char * tmp_string = "ABC"; /* these are characters in XPCS, so... safe */
XTextProperty tmp_prop;
int status = 0;
Cardinal num_targets = 0;
Widget drag_icon;
Arg args[10];
int n = 0;
tmp_prop.value = NULL;
status = XmbTextListToTextProperty(XtDisplay(w), &tmp_string, 1,
(XICCEncodingStyle)XTextStyle, &tmp_prop);
if (status == Success)
targets[num_targets++] = tmp_prop.encoding;
else
targets[num_targets++] = 99999; /* XmbTextList... should never fail
* for XPCS characters. But just in
* case someones Xlib is broken,
* this prevents a core dump.
*/
if (tmp_prop.value != NULL) XFree((char *)tmp_prop.value);
targets[num_targets++] = XmInternAtom(XtDisplay(w), "COMPOUND_TEXT", False);
targets[num_targets++] = XA_STRING;
targets[num_targets++] = XmInternAtom(XtDisplay(w), "TEXT", False);
drag_icon = (Widget) XmeGetTextualDragIcon(w);
n = 0;
XtSetArg(args[n], XmNcursorBackground, tw->core.background_pixel); n++;
XtSetArg(args[n], XmNcursorForeground, tw->primitive.foreground); n++;
XtSetArg(args[n], XmNsourceCursorIcon, drag_icon); n++;
XtSetArg(args[n], XmNexportTargets, targets); n++;
XtSetArg(args[n], XmNnumExportTargets, num_targets); n++;
XtSetArg(args[n], XmNconvertProc, _DtTermPrimSelectConvert); n++;
XtSetArg(args[n], XmNclientData, w); n++;
XtSetArg(args[n], XmNdragOperations, ( XmDROP_COPY)); n++;
(void) XmDragStart(w, event, args, n);
}
static Position
GetXFromPos(Widget w, XmTextPosition pos)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
DtTermPrimData tpd = tw->term.tpd;
TermBuffer pb;
short row,col;
TermCharInfoRec charInfoRec ;
posToBufferRowCol(tw,pos,&pb,&row,&col) ;
return(tpd->offsetX+col*tpd->cellWidth);
}
/* ARGSUSED */
void
_DtTermPrimSelectProcessBDrag(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params )
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
TermSelectInfo selectInfo =
((DtTermPrimitiveWidget)w)->term.tpd->selectInfo;
XmTextPosition position, left, right;
Position left_x, left_y, right_x, right_y;
/* InputData data = tw->text.input->data; */
selectInfo->cancel = False;
position = xyToPos(tw, event->xbutton.x, event->xbutton.y);
if (_DtTermPrimSelectGetSelection(w, &left, &right) &&
(right != left)) {
if ((position > left && position < right)
|| (position == left &&
event->xbutton.x > GetXFromPos(w, left))
|| (position == right &&
event->xbutton.x < GetXFromPos(w, right))) {
selectInfo->sel_start = False;
StartDrag(w, event, params, num_params);
}
else
{
selectInfo->sel_start = True ;
}
}
else selectInfo->sel_start = True ;
}
/* This is the menu interface for copy clipboard */
Boolean
_DtTermPrimSelectCopyClipboard
(
Widget w,
Time copy_time
)
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
XmTextPosition begin;
XmTextPosition end;
char *selected_string = NULL; /* text selection */
long item_id = 0L; /* clipboard item id */
long data_id = 0L; /* clipboard data id */
int status; /* clipboard status */
XmString clip_label;
XTextProperty tmp_prop;
Display *display = XtDisplay(w);
Window window = XtWindow(w);
char *atom_name;
if ( _DtTermPrimSelectGetSelection(w, &begin, &end) && begin != end ) {
selected_string = getString(w, begin, end, False);
}
/*
* Using the Xm clipboard facilities,
* copy the selected text to the clipboard
*/
tmp_prop.value = NULL;
if (selected_string != NULL) {
clip_label = XmStringCreateLocalized ("XM_TERM");
/* start copy to clipboard */
status = XmClipboardStartCopy(display, window, clip_label, copy_time,
w, NULL, &item_id);
if (status != ClipboardSuccess) {
XtFree(selected_string);
XmStringFree(clip_label);
return False;
}
status = XmbTextListToTextProperty(display, &selected_string, 1,
(XICCEncodingStyle)XStdICCTextStyle,
&tmp_prop);
if (status != Success && status <= 0) {
XmClipboardCancelCopy(display, window, item_id);
XtFree(selected_string);
XmStringFree(clip_label);
return False;
}
atom_name = XGetAtomName(display, tmp_prop.encoding);
/* move the data to the clipboard */
status = XmClipboardCopy(display, window, item_id, atom_name,
(XtPointer)tmp_prop.value, tmp_prop.nitems,
0, &data_id);
XtFree(atom_name);
if (status != ClipboardSuccess) {
XmClipboardCancelCopy(display, window, item_id);
XFree((char*)tmp_prop.value);
XmStringFree(clip_label);
return False;
}
/* end the copy to the clipboard */
status = XmClipboardEndCopy (display, window, item_id);
XtFree((char*)tmp_prop.value);
XmStringFree(clip_label);
if (status != ClipboardSuccess) return False;
} else
return False;
if (selected_string!=NULL)
XtFree(selected_string);
return True;
}
/* This is the event interface for copy clipboard */
void
_DtTermPrimSelectCopyClipboardEventIF
(
Widget w,
XEvent *event,
String *params,
Cardinal *num_params
)
{
_DtTermPrimSelectCopyClipboard(w,event->xkey.time) ;
}
/*
* Retrieves the current data from the clipboard
* and paste it at the current cursor position
*/
Boolean
_DtTermPrimSelectPasteClipboard
(
Widget w
)
{
XmTextPosition sel_left = 0;
XmTextPosition sel_right = 0;
XmTextPosition paste_pos_left, paste_pos_right, cursorPos;
int status; /* clipboard status */
char * buffer; /* temporary text buffer */
unsigned long length; /* length of buffer */
unsigned long outlength = 0L; /* length of bytes copied */
long private_id = 0L; /* id of item on clipboard */
Boolean dest_disjoint = True;
XmTextBlockRec block, newblock;
Display *display = XtDisplay(w);
Window window = XtWindow(w);
Boolean get_ct = False;
Boolean freeBlock;
XTextProperty tmp_prop;
int malloc_size = 0;
int num_vals;
char **tmp_value;
char * total_tmp_value = NULL;
int i;
status = XmClipboardInquireLength(display, window, "STRING", &length);
if (status == ClipboardNoData || length == 0) {
status = XmClipboardInquireLength(display, window, "COMPOUND_TEXT",
&length);
if (status == ClipboardNoData || length == 0) return False;
get_ct = True;
}
/* malloc length of clipboard data */
buffer = XtMalloc((unsigned) length);
if (!get_ct) {
status = XmClipboardRetrieve(display, window, "STRING", buffer,
length, &outlength, &private_id);
} else {
status = XmClipboardRetrieve(display, window, "COMPOUND_TEXT",
buffer, length, &outlength, &private_id);
}
if (status != ClipboardSuccess) {
XmClipboardEndRetrieve(display, window);
XtFree(buffer);
return False;
}
tmp_prop.value = (unsigned char *) buffer;
if (!get_ct)
tmp_prop.encoding = XA_STRING;
else
tmp_prop.encoding = XmInternAtom(display, "COMPOUND_TEXT", False);
tmp_prop.format = 8;
tmp_prop.nitems = outlength;
num_vals = 0;
status = XmbTextPropertyToTextList(display, &tmp_prop, &tmp_value,
&num_vals);
/* if no conversions, num_vals doesn't change */
if (num_vals && (status == Success || status > 0)) {
for (i = 0; i < num_vals ; i++)
malloc_size += strlen(tmp_value[i]);
total_tmp_value = XtMalloc ((unsigned) malloc_size + 1);
total_tmp_value[0] = '\0';
for (i = 0; i < num_vals ; i++)
strcat(total_tmp_value, tmp_value[i]);
block.ptr = total_tmp_value;
block.length = strlen(total_tmp_value);
block.format = XmFMT_8_BIT;
XFreeStringList(tmp_value);
} else {
malloc_size = 1; /* to force space to be freed */
total_tmp_value = XtMalloc ((unsigned)1);
*total_tmp_value = '\0';
block.ptr = total_tmp_value;
block.length = 0;
block.format = XmFMT_8_BIT;
}
/* add new text */
if ( block.length )
{
char *pChar, *pCharEnd, *pCharFollow;
pCharEnd = block.ptr + block.length;
pCharFollow = (char *)block.ptr;
for (pChar = (char *)block.ptr; pChar < pCharEnd; pChar++)
{
if (*pChar == '\n')
{
*pChar = '\r';
DtTermSubprocSend(w, (unsigned char *) pCharFollow,
pChar - pCharFollow + 1);
pCharFollow = pChar + 1;
}
}
if (pCharFollow < pCharEnd)
{
DtTermSubprocSend(w, (unsigned char *) pCharFollow,
pCharEnd - pCharFollow);
}
}
XtFree(buffer);
if (malloc_size != 0) XtFree(total_tmp_value);
(void) _DtTermPrimCursorOn(w);
return True;
}
/* This is the event interface for paste clipboard */
void
_DtTermPrimSelectPasteClipboardEventIF
(
Widget w,
XEvent *event,
String *params,
Cardinal *num_params
)
{
_DtTermPrimSelectPasteClipboard(w) ;
}
/*
* This is for the SUN two button mouse
*/
static Bool
LookForButton (
Display * display,
XEvent * event,
XPointer arg)
{
#define DAMPING 5
#define ABS_DELTA(x1, x2) (x1 < x2 ? x2 - x1 : x1 - x2)
if( event->type == MotionNotify) {
XEvent * press = (XEvent *) arg;
if (ABS_DELTA(press->xbutton.x_root, event->xmotion.x_root) > DAMPING ||
ABS_DELTA(press->xbutton.y_root, event->xmotion.y_root) > DAMPING)
return(True);
}
else if (event->type == ButtonRelease)
return(True);
return(False);
}
/* ARGSUSED */
static Boolean
XmTestInSelection(
Widget w,
XEvent *event )
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
XmTextPosition position, left, right;
Position left_x, right_x, dummy;
position = xyToPos(tw, event->xbutton.x, event->xbutton.y);
if ((!(_DtTermPrimSelectGetSelection(w, &left, &right) &&
(left != right && (position > left && position < right)))
|| (position == left &&
event->xbutton.x > GetXFromPos(w, left))
|| (position == right &&
event->xbutton.x < GetXFromPos(w, right)))
||
/* or if it is part of a multiclick sequence */
(event->xbutton.time > selectInfo->lastTime &&
event->xbutton.time - selectInfo->lastTime <
XtGetMultiClickTime(XtDisplay((Widget)w))) )
return(False);
else {
/* The determination of whether this is a transfer drag cannot be made
until a Motion event comes in. It is not a drag as soon as a
ButtonUp event happens or the MultiClickTimeout expires. */
XEvent new;
XPeekIfEvent(XtDisplay(w), &new, LookForButton, (XPointer)event);
switch (new.type) {
case MotionNotify:
return(True);
break;
case ButtonRelease:
return(False);
break;
}
return(False);
}
}
#define SELECTION_ACTION 0
#define TRANSFER_ACTION 1
/* ARGSUSED */
void
_DtTermPrimSelect2ButtonMouse(
Widget w,
XEvent *event,
char **params,
Cardinal *num_params )
{
/* This action happens when Button1 is pressed and the Selection
and Transfer are integrated on Button1. It is passed two
parameters: the action to call when the event is a selection,
and the action to call when the event is a transfer. */
if (*num_params != 2 /* || !XmIsTextField(w) */)
return;
if (XmTestInSelection(w, event))
XtCallActionProc(w, params[TRANSFER_ACTION], event, params, *num_params);
else
XtCallActionProc(w, params[SELECTION_ACTION], event, params, *num_params);
}
void
_DtTermPrimSelectProcessCancel(
Widget w,
XEvent *event,
String *params,
Cardinal *num_params )
{
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
TermSelectInfo selectInfo = tw->term.tpd->selectInfo;
XmTextPosition left_x, right_x;
XmParentInputActionRec p_event ;
if (!tw->term.allowOsfKeysyms) {
_DtTermPrimActionKeyInput(w,event,params,num_params);
return;
}
selectInfo->cancel = True ;
/* turn off the cursor */
_DtTermPrimCursorOff(w);
/* reset to origLeft and origRight */
setSelection (tw, selectInfo->origBegin, selectInfo->origEnd,
event->xkey.time, False) ;
/* turn on the cursor */
_DtTermPrimCursorOn(w);
if (selectInfo->selectID) {
XtRemoveTimeOut(selectInfo->selectID);
selectInfo->selectID = 0;
}
}
Reference in New Issue View Git Blame Copy Permalink