falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/programs/dtudcfonted/ufont.c

2514 lines
62 KiB
C
Raw 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
*/
/* ufont.c 1.45 - Fujitsu source for CDEnext 96/12/03 18:34:11 */
/* $XConsortium: ufont.c /main/14 1996/12/17 19:30:16 cde-fuj $ */
/*
* (c) Copyright 1995 FUJITSU LIMITED
* This is source code modified by FUJITSU LIMITED under the Joint
* Development Agreement for the CDEnext PST.
* This is unpublished proprietary source code of FUJITSU LIMITED
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <X11/Intrinsic.h>
#include "xoakufont.h"
#include "util.h"
#define _CLIENT_CAT_NAME "dtudcfonted"
extern char *_DtGetMessage(char *filename, int set, int n, char *s);
#define GETMESSAGE(set, number, string) GetMessage(set, number, string)
static char *
GetMessage(int set, int number, char *string)
{
char *tmp, *ret;
tmp = _DtGetMessage(_CLIENT_CAT_NAME, set, number, string);
ret = malloc(strlen(tmp) + 1);
strcpy(ret, tmp);
return (ret);
}
/****************************************************************
* Widgets *
***************************************************************/
Widget toplevel;
Widget editPtnW;
Widget cpyPtnW;
Widget mngPtnW;
EditChar edg;
EditList edlist;
EditPane edpane;
XlibInf xl;
DelInf dn;
DelPtnInf dl[D_MAX] ;
DelPtnInf dl_glyph[EDLIST_MAX]; /* add dl_disp 1995.09.20 */
int sq_disp[EDLIST_MAX]; /* add sq_disp 1995.09.20 */
EditPtnInf em;
CopyPtnInf cpm;
static Widget dnPopW;
Widget wgeScro, editPopW;
static int select_x, select_y, select_w, select_h;
static int r1_x, r1_y, r2_x, r2_y, cut_w, cut_h;
extern Widget xlfdDialog, cpyDialog;
extern FalFontID font_id;
Pixmap arrow_pix=0;
static XtAppContext app; /* application context */
static int edpane_size=0;
static void OtherFontSelect(void);
void drawDelCode(int i);
void drawDelPtn(int i);
static void xeg_init(void);
static void dstrypaneEditPtn(void);
void chgEdCode(int code, char mode);
void chgEdList(int statloc, int slctloc, char mode);
static void chgEdPtn(int code);
static void DrawRectEdPn(int x1, int y1, int x2, int y2);
static void DrawBorderEdPn(int x1, int y1, int x2, int y2);
static void DrawPointEdPn(int x, int y, int mode);
static void DrawDpPn(void);
static void DrawPointDpPn(int x, int y, int mode);
static void musPoint(int evtype, int px, int py);
static void musLine(int evtype, int px, int py);
static void musCircle(int evtype, int px, int py);
static void musRect(int proc, int evtype, int px, int py);
static void musRegionProc(int proc, int evtype, int px, int py);
#ifdef __linux__
static void musPasteProc(Widget w, XtPointer client_data, XEvent *event, Boolean*);
#else
static void musPasteProc(Widget w, XtPointer client_data, XEvent *event);
#endif
static void rubLine(int x1, int y1, int x2, int y2);
static void rubBand(int x1, int y1, int x2, int y2);
static void rubCircle(int ox, int oy, int rx, int ry);
static void resetEditMode(unsigned int flag);
static void copyPatterns(FalFontData *fdata,
int s1_code,
int s2_code,
int d1_code,
int proc);
extern String MngCodeTfValue(void);
extern String CpySrcCodeTfValue(void);
extern String CpyDestCodeTfValue(void);
char *get_cmd_path(char *path, char *cmd);
extern FalFontData fullFontData;
extern FalFontData copyFontData;
extern void PopupSelectXLFD(Widget top);
extern void UpdateMessage(String str);
extern void DispMngErrorMessage(String msg);
extern void DispCpyErrorMessage(String msg);
static int setRealDelArea(int *s_ncode,
int *e_ncode,
int *sq_start,
int *sq_end);
/****************************************************************
* parameters *
***************************************************************/
static Arg arg[30];
static int n;
Resource resource;
/****************************************************************
* callback routines *
***************************************************************/
static void CancelCB(void);
static void
ExitCB(void)
{
exit(0);
}
int
efctPtnNum(void)
{
int no;
int sq;
int cnt;
for ( cnt = 0, sq = edlist.sqstart;
sq < (edlist.sqstart + edlist.nptn); sq++) {
no = ptnSqToNo(sq);
if (( no >= 0) && (codeCheck( noToCode( no)) == 0))
cnt++;
}
return( cnt);
}
void
Error_message(Widget widget, char *message)
{
static NoticeButton is_lock[] = {
NBTNARGS( ExitCB, NULL, 'E', True, False ),
NBTNARGS( CancelCB, NULL, 'C', True, True )
};
static NButton LockBTN = NBUTTONS( is_lock );
SetItemLabel(&LockBTN, 0, resource.l_exit);
SetItemLabel(&LockBTN, 1, resource.l_cancel);
PopupNotice( (widget), message,
D_ERROR,
&LockBTN,
True,
resource.l_question_title);
}
void
Error_message2(Widget widget, char *message)
{
static NoticeButton is_lock[] = {
NBTNARGS( CancelCB, NULL, 'C', True, True )
};
static NButton LockBTN = NBUTTONS( is_lock );
if (widget == NULL)
widget = toplevel;
SetItemLabel(&LockBTN, 0, resource.l_ok);
PopupNotice( (widget), message,
D_ERROR,
&LockBTN,
True,
resource.l_question_title);
}
/*
* contents : read a character pattern from SNF file
*/
/*ARGSUSED*/
static void
CBmOblB_edit( Widget widget, caddr_t clientData, caddr_t callData )
{
int ptn_n;
int ptn_w;
int ptn_h;
int code;
int i;
int ret;
char err[128];
extern int begin_code;
extern int ptnGetInfo();
extern void PopupEditPtn();
/* open font file and get informations of character to be edited */
ret = readSNF( &(edg.fdata), &(edg.width), &(edg.height), err);
if( ret == -1 ) {
Error_message(widget, err);
return;
}
dn.ptn_w = (Dimension) edg.width;
dn.ptn_h = (Dimension) edg.height;
if( xlfdDialog != NULL )
PopdownDialog(xlfdDialog);
ptnGetInfo( &ptn_n, &ptn_w, &ptn_h );
for( i=0 ; i<ptn_n ; i++ ) {
code = noToCode( ptnSqToNo(i) );
if( begin_code > code){
edlist.sqstart = i+1;
} else {
edlist.nptn++;
}
}
if( efctPtnNum() > 0) {
for ( i=edlist.sqstart; i<(edlist.sqstart+edlist.nptn); i++){
if ( codeCheck( noToCode( ptnSqToNo(i))) == 0)
break;
}
edg.ncode = ptnSqToNo( i );
edg.code = noToCode( edg.ncode );
ptnGet( edg.code, edg.ptn );
}
PopupEditPtn(toplevel);
}
void CBeOblB_aAdd(void);
static Boolean do_read = False;
static Boolean do_end = False;
static void CancelCB(void) { }
static void ContReadCB(Widget w)
{
FalCloseFont(font_id);
editPtnW = NULL;
OtherFontSelect();
PopupSelectXLFD(toplevel);
}
static void SaveReadCB(void)
{
CBeOblB_aAdd();
do_read = True;
PopupSelectXLFD(toplevel);
}
static void ContEndCB(void)
{
FalCloseFont(font_id);
exit(0);
}
static void SaveEndCB(void)
{
CBeOblB_aAdd();
do_end = True;
}
/*
* contents : quit editting
*/
/*ARGSUSED*/
static int
QuitEditPtn( Widget widget, caddr_t clientData, caddr_t callData )
{
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
if( edg.code != 0 ){
ptnAdd( edg.code, edg.ptn );
}
if( edg.flag == ON ){
return(0);
}
return(1);
}
void
OpenCB(Widget w, XtPointer client_data, XtPointer call_data)
{
static NoticeButton is_save_read_btn1[] = {
NBTNARGS( SaveReadCB, NULL, 'S', True, False ),
NBTNARGS( ContReadCB, NULL, 'O', True, False ),
NBTNARGS( CancelCB, NULL, 'C', True, True ),
};
static NoticeButton is_save_read_btn2[] = {
NBTNARGS( ContReadCB, NULL, 'O', True, False ),
NBTNARGS( CancelCB, NULL, 'C', True, True ),
};
static NButton SaveReadBTN1 = NBUTTONS( is_save_read_btn1 );
static NButton SaveReadBTN2 = NBUTTONS( is_save_read_btn2 );
if (QuitEditPtn((Widget)NULL, (caddr_t)NULL, (caddr_t)NULL)){
FalCloseFont(font_id);
editPtnW = NULL;
OtherFontSelect();
PopupSelectXLFD(toplevel);
}
else{
if (! fullFontData.prm) {
SetItemLabel(&SaveReadBTN1, 0, resource.l_do_save_exit);
SetItemLabel(&SaveReadBTN1, 1, resource.l_dont_save_exit);
SetItemLabel(&SaveReadBTN1, 2, resource.l_cancel);
PopupNotice( (w), resource.mn_saved_open ,
D_QUESTION,
&SaveReadBTN1,
True,
resource.l_question_title);
} else {
SetItemLabel(&SaveReadBTN2, 0, resource.l_dont_save_exit);
SetItemLabel(&SaveReadBTN2, 1, resource.l_cancel);
PopupNotice( (w), resource.mn_saved_open ,
D_QUESTION,
&SaveReadBTN2,
True,
resource.l_question_title);
}
}
}
void
ReadCB(Widget w, XtPointer client_data, XtPointer call_data)
{
if (fullFontData.xlfdname == NULL) {
return;
}
if (fullFontData.xlfdname == (char *) -1) {
Error_message(w, resource.mn_prop_font);
return;
}
CBmOblB_edit( w, client_data, call_data );
}
/****************************************************************
* callback routines and event handler *
***************************************************************/
/*
* contents : write character patterns to SNF file
*/
static Boolean
WPwriteSNF( int restart )
{
int rc, err;
char str[MG_MAXSIZE];
switch( rc = writeSNF( restart, &err ) ) {
case -1:
if (dnPopW)
XtSetSensitive( dnPopW, TRUE );
switch( err ) {
case 001:
sprintf(str, "%s(permission denied)", resource.me_write_snf);
break;
case 002:
sprintf(str, "%s(disk full)", resource.me_write_snf);
break;
case 101:
sprintf(str, "%s(pipe error)", resource.me_write_snf);
break;
case 102:
sprintf(str, "%s(fork error)", resource.me_write_snf);
break;
case 103:
sprintf(str, "%s(execv error)", resource.me_write_snf);
break;
case 104:
sprintf(str, "%s(data error)", resource.me_write_snf);
break;
default:
sprintf(str, "%s", resource.me_write_snf);
}
UpdateMessage( str );
return( TRUE );
case 0:
edg.flag = 0;
UpdateMessage( resource.mg_register );
sleep(1);
UpdateMessage("");
if (do_read){
do_read = False;
ContReadCB((Widget)NULL);
}
if (do_end){
do_read = False;
ContEndCB();
}
return(TRUE);
default:
if( rc == 1101 )
sprintf( str, "%s", resource.me_wait );
else
sprintf( str, "%s(%3d%%)", resource.mg_write_snf , rc-1000 );
UpdateMessage( str );
XtAppAddWorkProc( app, (XtWorkProc)WPwriteSNF, (XtPointer)ON );
if( rc == 1101 ){
XSync( xl.display,0 );
}
return( TRUE );
}
}
/*
* contents : write character patterns to SNF file
*/
void
CBeOblB_aAdd(void)
{
char str[MG_MAXSIZE];
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
UpdateMessage( resource.mg_write_snf );
if( edg.code != 0 )
ptnAdd( edg.code, edg.ptn );
if( edg.flag == ON ) {
sprintf( str, "%s", resource.mg_write_snf );
if (dnPopW)
XtSetSensitive( dnPopW, FALSE );
XtAppAddWorkProc( app, (XtWorkProc)WPwriteSNF, (XtPointer)OFF );
return;
}
else{
UpdateMessage( "" );
}
}
/*
* contents : destroy the editor window
*/
static void
OtherFontSelect(void)
{
dstrypaneEditPtn();
xeg_init();
}
/*
* contents : close dtudcfonted
*/
/*ARGSUSED*/
void
CBeOblB_aEnd( Widget widget, caddr_t clientData, caddr_t callData )
{
static NoticeButton is_save_exit_btn[] = {
NBTNARGS( SaveEndCB, NULL, 'S', True, False ),
NBTNARGS( ContEndCB, NULL, 'E', True, False ),
NBTNARGS( CancelCB, NULL, 'C', True, True ),
};
static NButton SaveEndBTN = NBUTTONS( is_save_exit_btn );
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
if( edg.code != 0 )
ptnAdd( edg.code, edg.ptn );
if( edg.flag == ON ) {
SetItemLabel(&SaveEndBTN, 0, resource.l_do_save);
SetItemLabel(&SaveEndBTN, 1, resource.l_dont_save);
SetItemLabel(&SaveEndBTN, 2, resource.l_cancel);
PopupNotice( widget, resource.mn_saved_exit, D_QUESTION,
&SaveEndBTN, True, resource.l_question_title);
return;
} else {
FalCloseFont(font_id);
}
exit(0);
}
/*ARGSUSED*/
void
CBeOblB_rCmd( Widget widget, int proc, caddr_t callData )
{
extern void SelectUnset();
extern void UndoSet();
if (!select_x && !select_y && !select_w && !select_h)
return;
em.rsv_f = ON;
bitPtnCopy( em.rsv_ptn, edg.ptn );
rubBand( r1_x, r1_y, r2_x, r2_y );
switch( proc ) {
case PROC_CLS:
bitDrawCls (edg.ptn, select_x, select_y, select_w, select_h );
break;
case PROC_SET:
bitDrawSet (edg.ptn, select_x, select_y, select_w, select_h );
break;
case PROC_REV:
bitDrawRev (edg.ptn, select_x, select_y, select_w, select_h );
break;
case PROC_ROLL:
bitDrawRoll(edg.ptn, select_x, select_y, select_w, select_h);
break;
case PROC_SYMV:
bitDrawSymV(edg.ptn, select_x, select_y, select_w, select_h );
break;
case PROC_SYMH:
bitDrawSymH(edg.ptn, select_x, select_y, select_w, select_h );
break;
}
edg.flag = ON;
DrawRectEdPn( 0, 0, edg.width - 1, edg.height - 1 );
DrawDpPn();
select_x = select_y = select_w = select_h = 0;
SelectUnset();
UndoSet();
}
/*ARGSUSED*/
void
CBeOblB_rCmdp( Widget widget, int proc, caddr_t callData )
{
extern Widget wgeBulB_edit;
extern void CopySet();
extern void UndoSet();
extern void SelectUnset();
switch( proc ) {
case PROC_CPY:
if (!select_x && !select_y && !select_w && !select_h)
return;
rubBand( r1_x, r1_y, r2_x, r2_y );
bitDrawCpy(edg.ptn, select_x, select_y, select_w, select_h, False);
cut_w = select_w;
cut_h = select_h;
select_x = select_y = select_w = select_h = 0;
CopySet();
SelectUnset();
break;
case PROC_CUT:
if (!select_x && !select_y && !select_w && !select_h)
return;
em.rsv_f = ON;
rubBand( r1_x, r1_y, r2_x, r2_y );
bitPtnCopy( em.rsv_ptn, edg.ptn );
bitDrawCpy(edg.ptn, select_x, select_y, select_w, select_h, True);
cut_w = select_w;
cut_h = select_h;
edg.flag = ON;
DrawRectEdPn( 0, 0, edg.width - 1, edg.height - 1 );
DrawDpPn();
select_x = select_y = select_w = select_h = 0;
CopySet();
UndoSet();
SelectUnset();
break;
case PROC_PASTE:
XtAddEventHandler(wgeBulB_edit,
ButtonReleaseMask|PointerMotionMask,
False, musPasteProc, NULL );
}
}
/*
* contents : cancel all editting
*/
/*ARGSUSED*/
void
CBeOblB_rCan( Widget widget, caddr_t clientData, caddr_t callData )
{
extern void UndoUnset();
resetEditMode( RES_MSG | RES_PROC | RES_SLCT );
if( em.rsv_f == ON ) {
bitPtnCopy( edg.ptn, em.rsv_ptn );
em.rsv_f = OFF;
DrawRectEdPn( 0, 0, edg.width - 1, edg.height - 1 );
DrawDpPn();
UndoUnset();
}
}
/*
*
* contents : get a sequential number of the editor
*/
int
RelToAbsSq( int from, int cnt)
{
int i;
int no;
if ( cnt >= 0) {
for ( i = -1; from < (edlist.sqstart + edlist.nptn) ; from++) {
no = ptnSqToNo(from);
if (( no >= 0) && ( noToCode( no) >= 0) ) {
i++;
if ( i >= cnt)
return( from);
}
}
} else {
cnt *= -1;
for ( i = -1; from >= edlist.sqstart; from--) {
no = ptnSqToNo(from);
if (( no >= 0) && ( noToCode( no) >= 0) ) {
i++;
if ( i >= cnt)
return(from);
}
}
}
return( -1);
}
/*
* contents : get a relative number of the system area
*/
int
AbsSqToRel( int from, int to)
{
int sq;
int cnt;
int sign = 1;
int no;
if ( from > to) {
sq = from;
from = to;
to = sq;
sign = -1;
}
for ( cnt = -1, sq = from; sq <= to; sq++) {
no = ptnSqToNo(sq);
if (( no >= 0) && (codeCheck( noToCode( no)) == 0))
cnt++;
}
if ( cnt < 0)
cnt = 0;
cnt *= sign;
return( cnt);
}
/*
* contents : be the character list selected
*/
/*ARGSUSED*/
void
EHeStaT_list( Widget widget, int select, XEvent *e )
{
int sq, no;
int code;
resetEditMode( RES_MSG|RES_PROC|RES_SLCT|RES_RSV );
if( (e->xbutton.button != 1) || (e->type != ButtonRelease) ||
(e->xbutton.x < 0) || ((int)edlist.elem_w < e->xbutton.x) ||
(e->xbutton.y < 0) || ((int)edlist.elem_h < e->xbutton.y)
)
return;
if( edlist.slctloc == select )
return;
sq = RelToAbsSq( edlist.sqstart + edlist.statloc, select);
if( (no = ptnSqToNo(sq)) == -1 )
return;
code = noToCode( no );
if( codeCheck( code ) == -1 )
return;
if( ptnSense( code) == 0 )
return ;
chgEdList( edlist.statloc, select, OFF );
if( ptnSense(edg.code) == 1 )
ptnAdd(edg.code, edg.ptn );
chgEdPtn( code );
}
/*
* contents : update the character list
*/
/*ARGSUSED*/
void
CBeScro( Widget widget, caddr_t clientData, caddr_t callData )
{
int newl;
int new_statloc;
int new_slct;
n = 0;
XtSetArg( arg[n], XmNvalue, (XtArgVal)&newl ); n++;
XtGetValues( wgeScro , arg, n );
if (( new_statloc = RelToAbsSq( edlist.sqstart, newl)) < 0) {
new_statloc = 0;
} else {
new_statloc -= edlist.sqstart;
}
/*
*/
new_slct = edlist.slctloc
- AbsSqToRel( edlist.sqstart + edlist.statloc,
edlist.sqstart + new_statloc);
chgEdList( new_statloc, new_slct, OFF);
}
/*
* contents : select the edit items by mouse
*/
/*ARGSUSED*/
void
EHeBulB_eMEv( Widget widget, caddr_t clientData, XEvent *e )
{
int px, py;
int downbutton;
if (edpane.pix_w * edpane.pix_h == 0 ) {
return;
}
if( e->type == ButtonPress ){
em.drag_f = ON;
}
if( (edg.code == 0) || (em.drag_f == OFF) )
return;
if( e->type == ButtonRelease ){
em.drag_f = OFF;
}
px = e->xbutton.x / edpane.pix_w;
py = e->xbutton.y / edpane.pix_h;
if (( e->type == ButtonPress) || (e->type == ButtonRelease)){
downbutton = e->xbutton.button;
}else if ( e->type == MotionNotify ){
if ( e->xmotion.state & Button1Mask ){
downbutton = 1; /* select button */
}else if ( e->xmotion.state & Button2Mask ){
downbutton = 2; /* adjust button */
} else {
downbutton = 0;
}
}
switch( downbutton ) {
case 1:
switch( em.proc ) {
case PROC_POINT:
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
musPoint( e->type, px, py );
break;
case PROC_LINE:
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
musLine( e->type, px, py );
break;
case PROC_CIRCLE:
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
musCircle( e->type, px, py );
break;
case PROC_RECT:
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
musRect( em.proc, e->type, px, py );
break;
case PROC_ERASE:
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
musPoint( e->type, px, py );
break;
case PROC_SELECT:
musRegionProc( em.proc, e->type, px, py );
break;
default:
break;
}
break;
case 2:
if( (0 <= px) && (px < edg.width) && (0 <= py) && (py < edg.height) ) {
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
switch( e->type ) {
case MotionNotify:
if( (em.adj_px == px) && (em.adj_py == py) )
return;
break;
case ButtonPress:
em.adj_px = px;
em.adj_py = py;
if( bitRead(edg.ptn, px, py) == 0 ) {
bitSet( edg.ptn, px, py );
DrawPointEdPn( px,py, 1 );
DrawPointDpPn( px,py, 1 );
}
else {
bitReset( edg.ptn, px, py );
DrawPointEdPn( px,py, 0 );
DrawPointDpPn( px,py, 0 );
}
edg.flag = ON;
break;
default:
return;
}
}
default:
break;
}
}
/*
* contents : restore the editting pane
*/
/*ARGSUSED*/
void
EHeBulB_eExp( Widget widget, caddr_t clientData, XEvent *e )
{
int x1, y1;
int x2, y2;
if (edpane.pix_w * edpane.pix_h == 0 ) {
return;
}
x1 = e->xexpose.x / edpane.pix_w;
y1 = e->xexpose.y / edpane.pix_h;
x2 = (e->xexpose.x + e->xexpose.width - 1) / edpane.pix_w;
y2 = (e->xexpose.y + e->xexpose.height - 1) / edpane.pix_h;
DrawRectEdPn( x1, y1, x2, y2 );
DrawBorderEdPn( x1, y1, x2, y2 );
}
/*
* contents : specifies the drawing operation (Pont/Line/Rectangle/Circle)
*/
/*ARGSUSED*/
void
CBeRecB_obj( Widget widget, int obj, XmToggleButtonCallbackStruct *call)
{
extern void SelectUnset();
if (call->set == False)
return;
resetEditMode( RES_MSG | RES_RSV | RES_SLCT );
if (obj == PROC_ERASE)
edpane.color = OFF;
else
edpane.color = ON;
edpane.obj = obj;
em.proc = obj;
if (obj != PROC_SELECT) {
if (select_x || select_y || select_w || select_h) {
rubBand( r1_x, r1_y, r2_x, r2_y );
select_x = select_y = select_w = select_h = 0;
SelectUnset();
}
}
}
/*
* contents : restore the displaying pane
*/
/*ARGSUSED*/
void
EHeBulB_dExp( Widget widget, caddr_t clientData )
{
if (xl.display == NULL ){
return;
}
DrawDpPn();
}
/*
* contents : set the range to be add or deleted
*/
static int
codeAreaSet(int *s_code, int *e_code)
{
char *str;
char delm;
str = MngCodeTfValue();
delm = '\0';
*s_code = 0;
*e_code = 0;
if (!str || !*str){
return(-1);
}
sscanf( str, "%x %c %x", s_code, &delm, e_code );
if (str) free( str );
switch( delm ) {
case '\0':
*e_code = *s_code;
break;
case '-':
break;
default:
return(-1);
}
if( codeCheck(*s_code) || codeCheck(*e_code) ||
(*s_code > *e_code) ) {
return(-1);
}
return(0);
}
/****************************************************************
* callback routines (character management window) *
***************************************************************/
Boolean
BeforeMngCheck(int *s_code, int *e_code)
{
if(codeAreaSet(s_code, e_code) == -1) {
DispMngErrorMessage( resource.me_illegal_code );
return(False);
}
return(True);
}
void
DoAddProc(int s_code, int e_code)
{
int code;
int s_ncode;
int e_ncode;
char ptn[MAXPTNBYTE];
char mode;
int i;
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
s_ncode = codeToNo( s_code );
e_ncode = codeToNo( e_code );
mode = OFF;
bitPtnClear( ptn );
for( i=s_ncode ; i <= e_ncode ; i++ ) {
code = noToCode(i);
if ( codeCheck( code))
continue;
if (ptnSense(code) == 0) {
if(ptnAdd(code, ptn) != 1) {
UpdateMessage( resource.me_non_memory );
return;
}
edg.flag = ON;
mode = ON;
edlist.nptn++;
}
}
if( ptnSense( edg.code ) == 1 ) {
ptnAdd( edg.code, edg.ptn );
}
if(mode == ON) {
chgEdCode( s_code, mode );
}
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
}
void PopupDelNotice();
Widget CreateDelNotice();
void
DoDelProc( int s_code, int e_code )
{
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
if( ptnSense( edg.code) == 1 )
ptnAdd( edg.code, edg.ptn );
dn.s_ncode = codeToNo( s_code );
dn.e_ncode = codeToNo( e_code );
if (setRealDelArea(&dn.s_ncode, &dn.e_ncode, &dn.sq_start, &dn.sq_end) == -1) {
DispMngErrorMessage( resource.me_nodelete_code );
return;
}
dn.sq_top = dn.sq_start;
dn.disp_num = AbsSqToRel( dn.sq_start, dn.sq_end) + 1;
dn.disp_num = (dn.disp_num <= D_MAX) ? dn.disp_num : D_MAX;
PopupDelNotice( mngPtnW );
}
/*
* contents : get the real range to be add or delete
*/
static int
setRealDelArea(int *s_ncode, int *e_ncode, int *sq_start, int *sq_end )
{
int ncode;
int flg;
int sq;
int i;
/* first code */
flg = 0;
ncode = *e_ncode;
for( i=*s_ncode ; i <= ncode ; i++ ) {
if (((sq = ptnNoToSq(i)) != -1) && (codeCheck( noToCode(i)) == 0)) {
flg = 1;
break;
}
}
if (flg == 1) {
*s_ncode = ptnSqToNo( sq );
*sq_start = sq;
} else {
return(-1);
}
/* last code */
flg = 0;
ncode = *s_ncode;
for( i=*e_ncode ; i >= ncode ; i-- ) {
if ((( sq = ptnNoToSq(i)) != -1) && (codeCheck( noToCode(i) ) == 0)) {
flg = 1;
break;
}
}
*e_ncode = ptnSqToNo( sq );
*sq_end = sq;
return(0);
}
/****************************************************************
* callback routines (Copy) *
****************************************************************/
static int
CpySrcCodeCheck(void)
{
char *str;
char delm;
str = CpySrcCodeTfValue();
if (!str)
return(-1);
if (!*str) {
free(str);
return(-1);
}
delm = '\0';
cpm.s1_code = 0;
cpm.s2_code = 0;
sscanf( str, "%x %c %x", &cpm.s1_code,&delm, &cpm.s2_code );
free( str );
switch( delm ) {
case '\0':
cpm.s2_code = cpm.s1_code;
break;
case '-':
break;
default:
return(-1);
}
if (cpm.s1_code > cpm.s2_code)
return(-1);
return(0);
}
static int
CpyDestCodeCheck(void)
{
char *str;
str = CpyDestCodeTfValue();
if (!str)
return(-1);
if (!*str){
free(str);
return(-1);
}
cpm.d1_code = 0;
sscanf( str, "%x", &cpm.d1_code );
free( str );
if( codeCheck(cpm.d1_code) ) {
return(-1);
}
return(0);
}
Boolean
BeforeCpyCheck( int proc )
{
int s_ncode, e_ncode;
int r1_code, r2_code;
int no;
int i;
char rstr[30];
extern void PopupCpyNotice();
if (copyFontData.xlfdname == NULL) {
DispCpyErrorMessage(resource.me_non_srcfile);
return(False);
}
if (CpySrcCodeCheck() == -1){
DispCpyErrorMessage( resource.me_illegal_srccode );
return(False);
}
if (CpyDestCodeCheck() == -1){
DispCpyErrorMessage( resource.me_illegal_destcode );
return(False);
}
s_ncode = codeToNo( cpm.d1_code );
e_ncode = codeToNo( cpm.d1_code + cpm.s2_code - cpm.s1_code);
r1_code = r2_code = 0;
for( i=s_ncode ; i <= e_ncode ; i++ ) {
no = ptnSqToNo(i);
if (( no >= 0) && (codeCheck( noToCode( no)) == 0)) {
if(r1_code == 0)
r1_code = noToCode(i);
r2_code = noToCode(i);
}
}
cpm.proc = proc;
if( r1_code != 0 ) {
if( r1_code == r2_code ) {
sprintf( rstr, "%s %x<><78>", resource.l_code, r1_code );
} else if ( codeCheck(r1_code) && codeCheck(r2_code)){
sprintf( rstr, " %x - %x", r1_code, r2_code );
} else {
sprintf( rstr, "%s %x - %x ", resource.l_code_range, r1_code, r2_code );
}
PopupCpyNotice(rstr);
return(False);
}
return(True);
}
void
DoCpyProc(void)
{
extern void PopdownCpyPtn();
PopdownCpyPtn();
resetEditMode( RES_MSG | RES_PROC | RES_SLCT | RES_RSV );
copyPatterns( cpm.fdata, cpm.s1_code, cpm.s2_code, cpm.d1_code, cpm.proc );
}
/****************************************************************
* main routine *
****************************************************************/
#define R(name, class, member,def) { \
name, \
class, \
XtRString, \
sizeof(char *), \
XtOffsetOf(Resource, member), \
XtRString, \
(XtPointer)def }
#define RBoolean(name, class, member,def) \
{ name, class, XtRBoolean, sizeof(XtRBoolean), \
XtOffsetOf(Resource, member), XtRString, (XtPointer)def }
#define RDimension(name, class, member,def) \
{ name, class, XtRDimension, sizeof(XtRDimension), \
XtOffsetOf(Resource, member), XtRString, (XtPointer)def }
#define Rint(name, class, member,def) \
{ name, class, XtRInt, sizeof(XtRInt), \
XtOffsetOf(Resource, member), XtRString, (XtPointer)def }
#define RPixel(name, class, member,def) \
{ name, class, XtRPixel, sizeof(XtRPixel), \
XtOffsetOf(Resource, member), XtRString, (XtPointer)def }
static XtResource app_resources[] = {
RBoolean("Codepoint", "codepoint", codepoint, "False"),
R( "lptog", "Lptog", l_ptog, DFLTPATH ),
R( "lptogCmd", "LptogCmd", l_ptog_cmd, DFLTCMD ),
/* CreateCaptionFrame() */
RBoolean( "captResize", "CaptResize", capt_resize, "True" ) ,
Rint( "captLftoff", "CaptLftoff", capt_lftoff, "2" ) ,
Rint( "captTopoff", "CaptTopoff", capt_topoff, "2" ) ,
Rint( "captRghoff", "CaptRghoff", capt_rghoff, "2" ) ,
RPixel( "paneBackground", "paneBackground", pane_background, "white" ),
RPixel( "paneForeground", "PaneForeground", pane_foreground, "black" ),
RPixel( "background", "Background", background, "white" ),
RPixel( "foreground", "Foreground", foreground, "black" ),
/* CreateMenuButtons() */
RDimension( "menuMargin", "MenuMargin", menu_margin, "0" ) ,
/* CreateDialogAndButtons() */
RBoolean( "diaTmAutomng", "DiaTmAutomng", dia_tm_automng, "False" ) ,
RDimension( "diaTmWidth", "DiaTmWidth", dia_tm_width, "4" ) ,
RDimension( "diaTmHeight", "DiaTmHeight", dia_tm_height, "4" ) ,
RBoolean( "diaTmResize", "DiaTmResize", dia_tm_resize, "True" ) ,
RBoolean( "diaTmMinimize", "DiaTmMinimize", dia_tm_minimize, "True" ) ,
RDimension( "diaRwWidth", "DiaRwWidth", dia_rw_width, "6" ) ,
RDimension( "diaRwHeight", "DiaRwHeight", dia_rw_height, "6" ) ,
RDimension( "diaRwSpacing", "DiaRwSpacing", dia_rw_spacing, "4" ) ,
/* CreateDrawingArea() */
RDimension( "drawBorder", "DrawBorder", draw_border, "1" ) ,
Rint( "drawTopoff", "DrawTopoff", draw_topoff, "2" ) ,
Rint( "drawLftoff", "DrawLftoff", draw_lftoff, "2" ) ,
/* PopupNotice() */
RBoolean( "popResize", "PopResize", pop_resize , "True" ) ,
RBoolean( "popMinimize", "PopMinimize", pop_minimize , "True" ) ,
/* CreateTemplateDialog() */
RBoolean( "tempResize", "TempResize", temp_resize, "True" ) ,
RBoolean( "tempMinimize", "TempMinimize", temp_minimize, "True" ) ,
RDimension( "tempWidth", "TempWidth", temp_width, "1" ) ,
RDimension( "tempHeight", "TempHeight", temp_height, "1" ) ,
/* CreateMenuBarAndFooterMessageForm() */
Rint( "edBarTopoff", "EdBarTopoff", ed_bar_topoff, "1" ) ,
Rint( "edBarLftoff", "EdBarLftoff", ed_bar_lftoff, "1" ) ,
Rint( "edBarRghoff", "EdBarRghoff", ed_bar_rghoff, "1" ) ,
Rint( "edFrmBtmoff", "EdFrmBtmoff", ed_frm_btmoff, "3" ) ,
Rint( "edFrmLftoff", "EdFrmLftoff", ed_frm_lftoff, "3" ) ,
Rint( "edFrmRghoff", "EdFrmRghoff", ed_frm_rghoff, "3" ) ,
RDimension( "edMsgMargintop", "EdMsgMargintop", ed_msg_margintop, "3" ) ,
RDimension( "edMsgMarginbtm", "EdMsgMarginbtm", ed_msg_marginbtm, "3" ) ,
RDimension( "edMesgMargintop", "EdMesgMargintop", ed_mesg_margintop, "3" ) ,
RDimension( "edMesgMarginbtm", "EdMesgMarginbtm", ed_mesg_marginbtm, "3" ) ,
Rint( "edSepBtmoff", "EdSepBtmoff", ed_sep_btmoff, "3" ) ,
Rint( "edSepLftoff", "EdSepLftoff", ed_sep_lftoff, "0" ) ,
Rint( "edSepRghoff", "EdSepRghoff", ed_sep_rghoff, "0" ) ,
RDimension( "edSepMargin", "EdSepMargin", ed_sep_margin, "0" ) ,
Rint( "edWgeTopoff", "EdWgeTopoff", ed_wge_topoff, "10" ) ,
Rint( "edWgeLftoff", "EdWgeLftoff", ed_wge_lftoff, "10" ) ,
Rint( "edWgeRghoff", "EdWgeRghoff", ed_wge_rghoff, "10" ) ,
Rint( "edWgeBtmoff", "EdWgeBtmoff", ed_wge_btmoff, "10" ) ,
/* CreateFrame() */
RBoolean( "frameResize", "FrameResize", frame_resize, "False" ) ,
/* CreateScrollBase() */
RDimension( "scllFrWidth", "ScllFrWidth", scll_fr_width, "500" ) ,
RDimension( "scllFrThick", "ScllFrThick", scll_fr_thick, "2" ) ,
Rint( "scllBarLftoff", "ScllBarLftoff", scll_bar_lftoff, "4" ) ,
};
#undef R
#undef RBoolean
#undef RDimension
#undef Rint
#undef RPixel
int CodePoint = False;
/*ARGSUSED*/
static void
xerror(Display *d, XErrorEvent *ev)
{
fprintf (stderr, "dtudcfonted: warning, error event receieved.\n");
exit(-1);
}
int
main(int argc, char *argv[])
{
static char class_name[] = "Dtudcfonted";
int i;
/* initialize GUI */
toplevel = GuiInitialize(&app, class_name, &argc, argv);
/* get application's resources */
XtGetApplicationResources( toplevel, &resource,
app_resources, XtNumber(app_resources), NULL, 0);
if (resource.codepoint)
CodePoint = True;
/* initialize the code range */
for( i=1 ; i < argc ; i++ ) {
if( !strcmp(argv[i],"-pane_size") ) {
i++;
edpane_size = atoi( argv[i] );
} else if( !strcmp(argv[i],"-codepoint") ) {
CodePoint = True;
}
}
resource.mg_write_snf = GETMESSAGE(2, 2, "Registration processing inside.");
resource.me_write_snf = GETMESSAGE(2, 4, "Failed in the registration of the character.");
resource.me_illegal_code = GETMESSAGE(2, 6, "Illegal code.");
resource.me_non_memory = GETMESSAGE(2, 8, "Because the memory allocation cannot be done, it is not possible to add.");
resource.mg_non_code = GETMESSAGE(2, 10, "There is no character of the specified code.");
resource.me_illegal_srccode = GETMESSAGE(2, 12, "The mistake is found in the specified copy origin code.");
resource.me_illegal_destcode = GETMESSAGE(2, 14, "The mistake is found in the specified copy target code.");
resource.me_nodelete_code = GETMESSAGE(2, 16, "There is no character in the specified area.");
resource.me_wait = GETMESSAGE(2, 18, "Please wait for a while.");
resource.me_non_srcfile = GETMESSAGE(2, 20, "No copy origin code file is specified.");
resource.mn_no_font = GETMESSAGE(2, 22, "Informations of user defined character cannot collect.\nThere is no font specified.");
resource.mn_plural_font = GETMESSAGE(2, 24, "Informations of user defined character cannot collect.\nThere are plural fonts specified.");
resource.mn_not_udc = GETMESSAGE(2, 26, "The specified font do not have any UDCs areas.");
resource.mn_no_mem = GETMESSAGE(2, 28, "There are no memories any more.");
resource.mn_illegal_area = GETMESSAGE(2, 30, "The information of UDCs area is illegal.");
resource.mn_no_read = GETMESSAGE(2, 32, "The font file cannot read.\nPattern area was broken.");
resource.mn_prop_font = GETMESSAGE(2, 34, "Dtudcfonted cannot edit proportional character font.");
resource.mn_saved_open = GETMESSAGE(2, 36, "There are unsaved edits.\nDo you want to save them before opening?");
resource.mn_saved_exit = GETMESSAGE(2, 38, "There are unsaved edits.\nDo you want to save them before exiting?");
resource.mn_cpy_lost = GETMESSAGE(2, 40, "When the copy processing is done, the glyph\nimage within the following ranges is changed.\nDo you want to do the copy processing?\n\n");
resource.mn_no_perm = GETMESSAGE(2, 42, "No write permission for this font. You should change the file access mode before saving.\n");
resource.l_selectitem = GETMESSAGE(2, 100, "Select Items"); /* font open */
resource.l_codeset = GETMESSAGE(2, 102, " CodeSet:");
resource.l_style = GETMESSAGE(2, 104, " Style:");
resource.l_width = GETMESSAGE(2, 106, " Width:");
resource.l_height = GETMESSAGE(2, 108, " Height:");
resource.exec_label = GETMESSAGE(2, 110, "Open");
resource.quit_label = GETMESSAGE(2, 112, "Quit");
resource.l_font = GETMESSAGE(2, 114, "Font"); /* menu bar */
resource.l_edit = GETMESSAGE(2, 116, "Edit");
resource.l_manage = GETMESSAGE(2, 118, "Character");
resource.l_info = GETMESSAGE(2, 120, "Information");
resource.l_open_w = GETMESSAGE(2, 122, "Open"); /* font menu */
resource.l_save = GETMESSAGE(2, 124, "Save");
resource.l_exit = GETMESSAGE(2, 126, "Exit");
resource.l_clear = GETMESSAGE(2, 128, "Clear"); /* edit menu */
resource.l_set = GETMESSAGE(2, 130, "Set");
resource.l_reverse = GETMESSAGE(2, 132, "Reverse");
resource.l_cut = GETMESSAGE(2, 134, "Cut");
resource.l_Copy = GETMESSAGE(2, 135, "Copy");
resource.l_paste = GETMESSAGE(2, 136, "Paste");
resource.l_roll = GETMESSAGE(2, 138, "Rotate");
resource.l_updown_roll = GETMESSAGE(2, 140, "Vertical Roll");
resource.l_leftright_roll = GETMESSAGE(2, 142, "Horizontal Roll");
resource.l_undo = GETMESSAGE(2, 144, "Undo");
resource.l_manage_w = GETMESSAGE(2, 146, "Add/Delete..."); /* character menu */
resource.l_copy_w = GETMESSAGE(2, 148, "Copy...");
resource.l_xlfd = GETMESSAGE(2, 150, "XLFD name..."); /* information menu */
resource.l_codearea = GETMESSAGE(2, 152, "Code Area...");
resource.l_add = GETMESSAGE(2, 154, "Add"); /* add/delete dialog */
resource.l_delete = GETMESSAGE(2, 156, "Delete");
resource.l_cancel = GETMESSAGE(2, 158, "Cancel");
resource.l_manage_code = GETMESSAGE(2, 160, "Code(hex):"); /* copy dialog */
resource.l_copy_src_code = GETMESSAGE(2, 162, " Copy origin code(hex):");
resource.l_copy_dest_code = GETMESSAGE(2, 164, "Copy target code(hex):");
resource.l_copy = GETMESSAGE(2, 166, "Copy");
resource.l_overlay = GETMESSAGE(2, 168, "Overlay");
resource.l_ok = GETMESSAGE(2, 170, "OK");
resource.l_do_save = GETMESSAGE(2, 172, "Save"); /* unsaved edits */
resource.l_dont_save = GETMESSAGE(2, 174, "Do not Save");
resource.l_do_save_exit = GETMESSAGE(2, 176, "Save and Exit");
resource.l_dont_save_exit = GETMESSAGE(2, 178, "Do not Save and Exit");
resource.mg_start_del_s = GETMESSAGE(2, 180, "The following character will be deleted."); /* delete notice dialog */
resource.mg_start_del_cs = GETMESSAGE(2, 182, "character");
resource.mg_start_del_m = GETMESSAGE(2, 184, "The following characters will be deleted.");
resource.mg_start_del_cm = GETMESSAGE(2, 186, "characters");
resource.mg_register = GETMESSAGE(2, 188, "Register completed");
resource.l_code = GETMESSAGE(2, 190, " Code : ");
resource.l_code_range = GETMESSAGE(2, 192, " Code range : ");
resource.message = GETMESSAGE(2, 194, "Message : ");
resource.code = GETMESSAGE(2, 196, "code..."); /* code dialog */
resource.previous = GETMESSAGE(2, 198, "Page up");
resource.next = GETMESSAGE(2, 200, "Page down");
resource.apply = GETMESSAGE(2, 202, "Apply");
resource.l_question_title = GETMESSAGE(2, 204, "dtudcfonted - Question");
resource.l_warning_title = GETMESSAGE(2, 206, "dtudcfonted - Warning");
resource.l_error_title = GETMESSAGE(2, 208, "dtudcfonted - Error");
resource.l_copy_title = GETMESSAGE(2, 210, "dtudcfonted - Copy");
resource.l_open_title = GETMESSAGE(2, 212, "dtudcfonted - Open");
resource.l_add_title = GETMESSAGE(2, 214, "dtudcfonted - Add/Delete");
resource.l_xlfd_title = GETMESSAGE(2, 216, "dtudcfonted - XLFD");
resource.l_codearea_title = GETMESSAGE(2, 218, "dtudcfonted - CodeArea");
resource.file_name = GETMESSAGE(2, 230, "File name");
resource.xlfd_name = GETMESSAGE(2, 232, "XLFD name");
resource.codearea = GETMESSAGE(2, 234, "Code area");
resource.falerrmsg[0] = GETMESSAGE(2, 300, "Fatal error occurred.");
resource.falerrmsg[1] = GETMESSAGE(2, 301, "Cannot open the font file.");
resource.falerrmsg[2] = GETMESSAGE(2, 302, "Cannot read the font file.");
resource.falerrmsg[3] = GETMESSAGE(2, 303, "There is no more memory.");
resource.falerrmsg[4] = GETMESSAGE(2, 304, "Fatal error occurred.");
resource.falerrmsg[5] = GETMESSAGE(2, 305, "The specified font file does not exist.");
resource.falerrmsg[6] = GETMESSAGE(2, 306, "This font is not a pcf or snf font.");
resource.falerrmsg[7] = GETMESSAGE(2, 307, "Cannot open fonts.list file.");
resource.falerrmsg[8] = GETMESSAGE(2, 308, "The format of fonts.list file is illegal.");
resource.falerrmsg[9] = GETMESSAGE(2, 309, "The descriptions of the fonts.list file are incorrect.");
resource.falerrmsg[10] = GETMESSAGE(2, 310, "The format of fonts.list file is illegal.");
resource.falerrmsg[11] = GETMESSAGE(2, 311, "Cannot open fonts.dir file.");
resource.falerrmsg[12] = GETMESSAGE(2, 312, "Cannot read fonts.dir file.");
resource.falerrmsg[13] = GETMESSAGE(2, 313, "Cannot read font properties.");
resource.falerrmsg[14] = GETMESSAGE(2, 314, "Cannot get FONT property.");
resource.falerrmsg[15] = GETMESSAGE(2, 315, "Cannot get FAMILY_NAME property.");
resource.falerrmsg[16] = GETMESSAGE(2, 316, "This font file is already opened by other application.");
resource.falerrmsg[17] = GETMESSAGE(2, 317, "Cannot lock font file.");
resource.falerrmsg[18] = GETMESSAGE(2, 318, "Cannot unlock font file.");
resource.falerrmsg[19] = GETMESSAGE(2, 319, "Cannot get lock information from the font file.");
resource.falerrmsg[20] = GETMESSAGE(2, 320, "Cannot find the specified font file.");
resource.falerrmsg[21] = GETMESSAGE(2, 321, "Cannot read NLS database.");
resource.falerrmsg[22] = GETMESSAGE(2, 322, "Cannot get charset names from NLS database.");
resource.falerrmsg[23] = GETMESSAGE(2, 323, "Charset name not defined in NLS database.");
resource.falerrmsg[24] = GETMESSAGE(2, 324, "The specified font has not been opened.");
resource.falerrmsg[25] = GETMESSAGE(2, 325, "Fatal error occurred.");
xlfdDialog = NULL ;
cpyDialog = NULL ;
/* initialize the global values and allocate the memories */
xeg_init();
/* displays the selection window */
PopupSelectXLFD(toplevel);
XSetErrorHandler((XErrorHandler)xerror);
XSetIOErrorHandler((XIOErrorHandler)xerror);
/* main loop */
XtAppMainLoop(app);
return(-1);
}
/*
* contents : initialize the global values
*/
static void
xeg_init(void)
{
int i;
edg.code = edg.ncode = 0;
bitPtnClear( edg.ptn );
edg.flag = (char)0;
edlist.nlist = EDLIST_MAX;
edlist.statloc = edlist.slctloc = 0;
edlist.nptn = 0;
edlist.sqstart = 0;
edlist.list_h = edlist.elem_w = edlist.elem_h = (Dimension)0;
edlist.back = resource.pane_background;
edlist.border = resource.pane_foreground;
if ( edpane_size ){
edpane.width = edpane_size;
edpane.height = edpane_size;
} else {
edpane.width = EDPANE_SIZE;
edpane.height = EDPANE_SIZE;
}
edpane.pix_w = edpane.pix_h = 0;
edpane.color = 0;
edpane.obj = 0;
edpane.back = resource.pane_background;
edpane.border = resource.pane_foreground;
xl.display = NULL;
xl.root_winID = xl.edit_winID = xl.disp_winID = xl.list_winID =
(Window)NULL;
xl.borderGC = xl.backGC = xl.rubGC = xl.dashGC = (GC)NULL;
xl.dispImage = NULL;
dn.elem_w = dn.elem_h = (Dimension)0;
dn.ptn_w = dn.ptn_h = (Dimension)0;
dn.list_h = (Dimension)0;
dn.s_ncode = dn.e_ncode = 0;
dn.sq_top = dn.sq_start = dn.sq_end = 0;
dn.disp_num = 0;
for ( i=0 ; i<D_MAX ; i++ ) {
dl[i].disp_winID = (Window)NULL;
dl[i].dispImage = NULL;
bitPtnClear( dl[i].ptn );
}
for ( i=0 ; i<EDLIST_MAX ; i++ ) {
dl_glyph[i].disp_winID = (Window)NULL;
dl_glyph[i].dispImage = NULL;
bitPtnClear( dl_glyph[i].ptn );
sq_disp[i] = 0 ;
}
em.drag_f = OFF;
em.adj_px = em.adj_py = 0;
em.proc = em.slct_f = 0;
em.src1_px = em.src1_py = 0;
em.src2_px = em.src2_py = 0;
em.dest_px = em.dest_py = 0;
em.rsv_f = (char)0;
bitPtnClear( em.rsv_ptn );
cpm.s1_code = cpm.s2_code = cpm.d1_code = 0;
cpm.proc = 0;
return;
}
/****************************************************************
* distroy the "User defined character editor" window *
****************************************************************/
/*
* contents : destroy the editting window
*/
static void
dstrypaneEditPtn(void)
{
int i ;
ptnClose();
XFree( (char *)xl.dispImage );
XFreeGC( xl.display, xl.borderGC );
XFreeGC( xl.display, xl.backGC );
XFreeGC( xl.display, xl.rubGC );
XFreeGC( xl.display, xl.dashGC );
for( i=0; i<EDLIST_MAX; i++ ){
if( dl_glyph[i].dispImage ){
XFree( (char *)dl_glyph[i].dispImage );
dl_glyph[i].dispImage = NULL ;
}
}
XtPopdown( editPopW );
XtDestroyWidget( editPopW );
return;
}
/****************************************************************
* update character list *
***************************************************************/
/*
* contents : add the specified code to the character list
*/
void
chgEdCode( int code, char mode )
{
int ncode;
int esq;
int statloc;
int slctloc;
int slimax;
if( code == 0 ) {
esq = -1;
} else {
ncode = codeToNo( code );
esq = ptnNoToSq( ncode ) - edlist.sqstart;
}
if( esq < 0 ) {
slctloc = -1;
statloc = 0;
} else if (efctPtnNum() <= edlist.nlist) {
statloc = 0;
slctloc = AbsSqToRel(edlist.sqstart, ptnNoToSq( ncode));
} else {
if ((esq >= edlist.statloc)
&& (esq <= (RelToAbsSq( edlist.sqstart + edlist.statloc,
edlist.nlist - 1) - edlist.sqstart))){
statloc = edlist.statloc;
slctloc = AbsSqToRel(edlist.sqstart+statloc,
edlist.sqstart + esq);
} else {
statloc = esq;
slctloc = 0;
}
while( RelToAbsSq(edlist.sqstart+statloc, edlist.nlist - 1) < 0)
statloc = RelToAbsSq( edlist.sqstart + statloc, -1)
- edlist.sqstart;
slctloc = AbsSqToRel( edlist.sqstart + statloc, edlist.sqstart + esq);
}
n = 0;
if (( slimax = efctPtnNum()) < edlist.nlist)
slimax = edlist.nlist;
XtSetArg( arg[n], XmNmaximum, (XtArgVal)slimax ); n++;
XtSetArg( arg[n], XmNvalue, (XtArgVal)AbsSqToRel( edlist.sqstart, edlist.sqstart + statloc) ); n++;
XtSetValues( wgeScro , arg, n );
chgEdList( statloc, slctloc, mode );
chgEdPtn( code );
}
/*
* contents : rewrite the character list
*/
void
chgEdList( int statloc, int slctloc, char mode )
{
int sq;
int i;
char str[6];
int no;
int code;
extern void ListSetLabelStr();
extern void ListSetGlyphImage();
extern void ListUnselectItem();
extern void ListSelectItem();
if((mode == ON) || (edlist.statloc != statloc)){
for (i=0, sq=edlist.sqstart+statloc; i < edlist.nlist; sq++){
no = ptnSqToNo(sq);
sq_disp[i] = sq ;
if ((no >= 0) && (code = noToCode(no)) >= 0 ){
sprintf(str, "%4x", code);
ListSetLabelStr(i, str);
ListSetGlyphImage(i) ;
if (i == 0)
edlist.statloc = sq - edlist.sqstart;
i++;
} else if (sq > ( edlist.sqstart + edlist.nptn - 1)){
strcpy(str, " ");
ListSetLabelStr(i, str);
ListSetGlyphImage(i) ;
i++;
}
}
}
if( (mode == ON) || (edlist.slctloc != slctloc) ) {
if((0 <= edlist.slctloc) && (edlist.slctloc < edlist.nlist)){
ListUnselectItem(edlist.slctloc);
}
if((0 <= slctloc) && (slctloc < edlist.nlist)){
ListSelectItem(slctloc);
}
edlist.slctloc = slctloc;
}
}
/*
* contents : rewrite the editting pane
*/
static void
chgEdPtn( int code )
{
extern void SetCodeString();
if (xl.display == NULL ){
return;
}
if( code == 0 ) {
XClearWindow( xl.display, xl.edit_winID );
DrawBorderEdPn( 0, 0, edg.width - 1, edg.height - 1 );
XClearWindow( xl.display, xl.disp_winID );
XClearWindow( xl.display, xl.list_winID );
bitPtnClear( edg.ptn );
edg.code = 0;
edg.ncode = 0;
SetCodeString(0);
}
if( ptnGet( code, edg.ptn) == 0 ) {
edg.code = code;
edg.ncode = codeToNo( code );
DrawRectEdPn( 0, 0, edg.width - 1, edg.height - 1 );
SetCodeString(code);
DrawDpPn();
}
}
/****************************************************************
* draw patterns to the editting pane *
***************************************************************/
/*
* contents : draw a rectangle
*
*/
static void
DrawRectEdPn( int x1, int y1, int x2, int y2 )
{
int i, j, wk;
short cx1, cy1, cx2, cy2;
XRectangle recOn[MAXPTNSIZE*MAXPTNSIZE];
XRectangle recOff[MAXPTNSIZE*MAXPTNSIZE];
int nron, nroff;
if (xl.display == NULL ){
return;
}
if( x2 < x1 ) {
wk = x2;
x2 = x1;
x1 = wk;
}
if( y2 < y1 ) {
wk = y2;
y2 = y1;
y1 = wk;
}
nron = nroff = 0;
for( j=y1 ; j <= y2 ; j++ ) {
for( i=x1 ; i <= x2 ; i++ ) {
cx1 = (short)(edpane.pix_w * i);
cy1 = (short)(edpane.pix_h * j);
cx2 = (short)(cx1 + edpane.pix_w - 1);
cy2 = (short)(cy1 + edpane.pix_h - 1);
if( bitRead( edg.ptn, i, j ) != 0 ) {
recOn[nron].x = cx1;
recOn[nron].y = cy1;
recOn[nron].width = (unsigned short)(cx2 - cx1);
recOn[nron].height = (unsigned short)(cy2 - cy1);
nron++;
}
else {
recOff[nroff].x = cx1;
recOff[nroff].y = cy1;
recOff[nroff].width = (unsigned short)(cx2 - cx1);
recOff[nroff].height = (unsigned short)(cy2 - cy1);
nroff++;
}
}
}
if( nron )
XFillRectangles( xl.display, xl.edit_winID, xl.borderGC, recOn, nron );
if( nroff )
XFillRectangles( xl.display, xl.edit_winID, xl.backGC, recOff, nroff );
}
/*
* contents : draw a lattice inside of the editting pane
*/
static void
DrawBorderEdPn( int x1, int y1, int x2, int y2 )
{
short cx1, cy1;
short cx2, cy2;
int ndseg;
int wk, i;
XSegment dseg[MAXPTNSIZE*2];
if (xl.display == NULL ){
return;
}
if( x2 < x1 ) {
wk = x2;
x2 = x1;
x1 = wk;
}
if( y2 < y1 ) {
wk = y2;
y2 = y1;
y1 = wk;
}
ndseg = 0;
cx1 = (short)(edpane.pix_w * x1);
cx2 = (short)(edpane.pix_w * x2 + edpane.pix_w - 1);
for( i=y1 ; i <= y2 ; i++ ) {
cy1 = (short)(edpane.pix_h * i + edpane.pix_h - 1);
dseg[ndseg].x1 = cx1;
dseg[ndseg].y1 = cy1;
dseg[ndseg].x2 = cx2;
dseg[ndseg].y2 = cy1;
ndseg++;
}
cy1 = (short)(edpane.pix_h * y1);
cy2 = (short)(edpane.pix_h * y2 + edpane.pix_h - 1);
for( i=x1 ; i <= x2 ; i++ ) {
cx1 = (short)(edpane.pix_w * i + edpane.pix_w - 1);
dseg[ndseg].x1 = cx1;
dseg[ndseg].y1 = cy1;
dseg[ndseg].x2 = cx1;
dseg[ndseg].y2 = cy2;
ndseg++;
}
if( ndseg ) {
XDrawSegments( xl.display, xl.edit_winID, xl.dashGC, dseg, ndseg);
}
}
/*
* contents : draw a dot
*/
static void
DrawPointEdPn( int x, int y, int mode )
{
int x1, y1;
int x2, y2;
if (xl.display == NULL ){
return;
}
x1 = edpane.pix_w * x;
y1 = edpane.pix_h * y;
x2 = x1 + edpane.pix_w - 1;
y2 = y1 + edpane.pix_h - 1;
if( mode != 0 ) {
XFillRectangle( xl.display, xl.edit_winID, xl.borderGC,
x1, y1, x2-x1, y2-y1 );
} else {
XFillRectangle( xl.display, xl.edit_winID, xl.backGC,
x1, y1, x2-x1, y2-y1 );
}
}
/*
* contents : draw a current character pattern to the display pane
*/
static void
DrawDpPn(void)
{
if (xl.display == NULL ){
return;
}
XPutImage( xl.display, xl.disp_winID, xl.borderGC, xl.dispImage,
0, 0, 0, 0, edg.width, edg.height );
if( xl.list_winID ) {
XPutImage( xl.display, xl.list_winID, xl.borderGC,
xl.dispImage, 0, 0, 0, 0, edg.width, edg.height );
}
}
/*
* contents : draw a dot
*/
static void
DrawPointDpPn( int x, int y, int mode )
{
if (xl.display == NULL ){
return;
}
if( mode != 0 ){
XDrawPoint( xl.display, xl.disp_winID, xl.borderGC, x, y );
if (xl.list_winID)
XDrawPoint( xl.display, xl.list_winID, xl.borderGC, x, y );
} else {
XDrawPoint( xl.display, xl.disp_winID, xl.backGC, x, y );
if (xl.list_winID)
XDrawPoint( xl.display, xl.list_winID, xl.backGC, x, y );
}
}
/****************************************************************
* draw patterns by mouse *
****************************************************************/
/*
* contents : draw a dot
*/
static void
musPoint( int evtype, int px, int py )
{
switch( evtype ) {
case MotionNotify:
if( (em.src1_px == px) && (em.src1_py == py) )
return;
break;
case ButtonPress:
em.src1_px = px;
em.src1_py = py;
break;
default:
return;
}
if( edpane.color == ON )
bitSet( edg.ptn, px, py );
else
bitReset( edg.ptn, px, py );
edg.flag = ON;
DrawPointEdPn( px, py, edpane.color );
DrawPointDpPn( px, py, edpane.color );
}
/*
* contents : draw a line
*/
static void
musLine( int evtype, int px, int py )
{
int r1_x, r1_y;
int r2_x, r2_y;
int rx, ry;
int harf_pix_w;
int harf_pix_h;
harf_pix_w = edpane.pix_w / 2;
harf_pix_h = edpane.pix_h / 2;
r1_x = em.src1_px * edpane.pix_w + harf_pix_w;
r1_y = em.src1_py * edpane.pix_h + harf_pix_h;
r2_x = em.src2_px * edpane.pix_w + harf_pix_w;
r2_y = em.src2_py * edpane.pix_h + harf_pix_h;
rx = px * edpane.pix_w + harf_pix_w;
ry = py * edpane.pix_h + harf_pix_h;
switch( evtype ) {
case MotionNotify:
if( (em.src2_px == px) && (em.src2_py == py) )
return;
rubLine( r1_x, r1_y, r2_x, r2_y );
rubLine( r1_x, r1_y, rx, ry );
em.src2_px = px;
em.src2_py = py;
return;
case ButtonPress:
em.src1_px = em.src2_px = px;
em.src1_py = em.src2_py = py;
return;
default:
if( (r1_x == r2_x) && (r1_y == r2_y) )
return;
rubLine( r1_x, r1_y, r2_x, r2_y );
if ((em.src2_px < 0) || (em.src2_py < 0) ||
(edg.width <= em.src2_px) || (edg.height <= em.src2_py))
return;
bitDrawLine( edg.ptn, em.src1_px, em.src1_py,
em.src2_px, em.src2_py, edpane.color );
edg.flag = ON;
DrawRectEdPn( em.src1_px, em.src1_py, em.src2_px, em.src2_py );
DrawDpPn();
}
}
/*
* contents : draw a circle
*/
static void
musCircle( int evtype, int px, int py )
{
int r1_x, r1_y;
int r2_x, r2_y;
int rx, ry;
int harf_pix_w;
int harf_pix_h;
extern int bitDrawCircle();
harf_pix_w = edpane.pix_w / 2;
harf_pix_h = edpane.pix_h / 2;
r1_x = em.src1_px * edpane.pix_w + harf_pix_w;
r1_y = em.src1_py * edpane.pix_h + harf_pix_h;
r2_x = em.src2_px * edpane.pix_w + harf_pix_w;
r2_y = em.src2_py * edpane.pix_h + harf_pix_h;
rx = px * edpane.pix_w + harf_pix_w;
ry = py * edpane.pix_h + harf_pix_h;
switch( evtype ) {
case MotionNotify:
if( (em.src2_px == px) && (em.src2_py == py) ) {
return;
}
rubCircle( r1_x, r1_y, r2_x, r2_y );
rubCircle( r1_x, r1_y, rx, ry );
em.src2_px = px;
em.src2_py = py;
return;
case ButtonPress:
em.src1_px = em.src2_px = px;
em.src1_py = em.src2_py = py;
return;
default:
if( (em.src1_px == px) && (em.src1_py == py) ) {
return;
}
rubCircle( r1_x, r1_y, r2_x, r2_y );
if( (px < 0) || (py < 0) || (edg.width <= px) || (edg.height <= py) ) {
return;
}
bitDrawCircle( edg.ptn, em.src1_px, em.src1_py, px, py, edpane.color);
edg.flag = ON;
DrawRectEdPn( 0, 0, edg.width -1, edg.height -1 );
DrawDpPn();
}
}
/*
* contents : draw a rectangle
*/
static void
musRect( int proc, int evtype, int px, int py )
{
int r1_x, r1_y;
int r2_x, r2_y;
int rx, ry;
int lux, luy;
int width, height;
int dpx, dpy, dp;
if( (proc == PROC_ROLL) && (evtype != ButtonPress) ) {
dpx = px - em.src1_px;
dpy = py - em.src1_py;
dp = (abs(dpx) > abs(dpy) ) ? abs(dpx) : abs(dpy);
if( dpx != 0 )
px = em.src1_px + dpx/abs(dpx) * dp;
if( dpy != 0 )
py = em.src1_py + dpy/abs(dpy) * dp;
}
r1_x = em.src1_px * edpane.pix_w + edpane.pix_w / 2;
r1_y = em.src1_py * edpane.pix_h + edpane.pix_h / 2;
r2_x = em.src2_px * edpane.pix_w + edpane.pix_w / 2;
r2_y = em.src2_py * edpane.pix_h + edpane.pix_h / 2;
rx = px * edpane.pix_w + edpane.pix_w / 2;
ry = py * edpane.pix_h + edpane.pix_h / 2;
switch( evtype ) {
case MotionNotify:
if( (em.src2_px == px) && (em.src2_py == py) )
return;
rubBand( r1_x, r1_y, r2_x, r2_y );
rubBand( r1_x, r1_y, rx, ry );
em.src2_px = px;
em.src2_py = py;
return;
case ButtonPress:
resetEditMode( RES_SLCT );
em.src1_px = em.src2_px = px;
em.src1_py = em.src2_py = py;
return;
default:
resetEditMode( RES_MSG | RES_PROC );
rubBand( r1_x, r1_y, r2_x, r2_y );
if( (r1_x == r2_x) || (r1_y == r2_y) )
return;
if( (em.src2_px < 0) || (em.src2_py < 0) ||
(edg.width <= em.src2_px) || (edg.height <= em.src2_py) )
return;
lux = (em.src1_px < em.src2_px ) ? em.src1_px : em.src2_px;
luy = (em.src1_py < em.src2_py ) ? em.src1_py : em.src2_py;
width = abs( em.src1_px - em.src2_px ) + 1;
height = abs( em.src1_py - em.src2_py ) + 1;
bitDrawRect(edg.ptn, lux, luy, width, height, edpane.color);
edg.flag = ON;
DrawRectEdPn( em.src1_px, em.src1_py, px, py );
DrawDpPn();
}
}
/*
* contents : edit inside of the specified area (clear, reverse, rotate,etc.)
*/
static void
musRegionProc( int proc, int evtype, int px, int py )
{
int rx, ry;
int dpx, dpy, dp;
extern void SelectSet();
if( (proc == PROC_ROLL) && (evtype != ButtonPress) ) {
dpx = px - em.src1_px;
dpy = py - em.src1_py;
dp = (abs(dpx) > abs(dpy) ) ? abs(dpx) : abs(dpy);
if( dpx != 0 )
px = em.src1_px + dpx/abs(dpx) * dp;
if( dpy != 0 )
py = em.src1_py + dpy/abs(dpy) * dp;
}
r1_x = em.src1_px * edpane.pix_w + edpane.pix_w / 2;
r1_y = em.src1_py * edpane.pix_h + edpane.pix_h / 2;
r2_x = em.src2_px * edpane.pix_w + edpane.pix_w / 2;
r2_y = em.src2_py * edpane.pix_h + edpane.pix_h / 2;
rx = px * edpane.pix_w + edpane.pix_w / 2;
ry = py * edpane.pix_h + edpane.pix_h / 2;
switch( evtype ) {
case MotionNotify:
if( (em.src2_px == px) && (em.src2_py == py) )
return;
rubBand( r1_x, r1_y, r2_x, r2_y );
rubBand( r1_x, r1_y, rx, ry );
em.src2_px = px;
em.src2_py = py;
return;
case ButtonPress:
if (select_x || select_y || select_w || select_h) {
rubBand( r1_x, r1_y, r2_x, r2_y );
}
resetEditMode( RES_SLCT );
em.src1_px = em.src2_px = px;
em.src1_py = em.src2_py = py;
return;
default:
resetEditMode( RES_MSG | RES_PROC );
select_x = select_y = select_w = select_h = 0;
if( (r1_x == r2_x) || (r1_y == r2_y) ) {
rubBand( r1_x, r1_y, r2_x, r2_y );
return;
}
if( (em.src2_px < 0) || (em.src2_py < 0) ||
(edg.width <= em.src2_px) || (edg.height <= em.src2_py) ) {
rubBand( r1_x, r1_y, r2_x, r2_y );
return;
}
select_x = (em.src1_px < em.src2_px ) ? em.src1_px : em.src2_px;
select_y = (em.src1_py < em.src2_py ) ? em.src1_py : em.src2_py;
select_w = abs( em.src1_px - em.src2_px ) + 1;
select_h = abs( em.src1_py - em.src2_py ) + 1;
SelectSet();
}
}
/*ARGSUSED*/
static void
#ifdef __linux__
musPasteProc(Widget w, XtPointer client_data, XEvent *event, Boolean* continue_to_dispatch)
#else
musPasteProc(Widget w, XtPointer client_data, XEvent *event)
#endif
{
static int ox=0, oy=0;
int rc, tx, ty;
extern void UndoSet();
extern Widget wgeBulB_edit;
extern int bitDrawPaste();
switch(event->type) {
case MotionNotify:
tx = (event->xmotion.x / edpane.pix_w) * edpane.pix_w + edpane.pix_w / 2;
ty = (event->xmotion.y / edpane.pix_h) * edpane.pix_h + edpane.pix_h / 2;
if (tx == ox && ty == oy)
return;
if(ox) {
rubBand(ox, oy, ox + cut_w * edpane.pix_w, oy + cut_h * edpane.pix_h);
}
ox = tx;
oy = ty;
rubBand(ox, oy, ox + cut_w * edpane.pix_w, oy + cut_h * edpane.pix_h);
break;
case ButtonRelease:
XtRemoveEventHandler(wgeBulB_edit,
ButtonReleaseMask|PointerMotionMask,
False, (XtEventHandler)musPasteProc, NULL );
rubBand(ox, oy, ox + cut_w * edpane.pix_w, oy + cut_h * edpane.pix_h);
ox = 0;
oy = 0;
bitPtnCopy( em.rsv_ptn, edg.ptn );
tx = event->xbutton.x / edpane.pix_w;
ty = event->xbutton.y / edpane.pix_h;
rc = bitDrawPaste(edg.ptn, tx, ty);
if( rc == -1 )
return;
edg.flag = ON;
em.rsv_f = ON;
DrawRectEdPn( 0, 0, edg.width - 1, edg.height - 1 );
DrawDpPn();
UndoSet();
break;
}
}
static void
rubLine( int x1, int y1, int x2, int y2 )
{
if( x1==x2 && y1==y2 ) return;
XDrawLine( xl.display, xl.edit_winID, xl.rubGC, x1,y1, x2,y2 );
}
static void
rubBand( int x1, int y1, int x2, int y2 )
{
if( x1==x2 && y1==y2 )
return;
XDrawLine( xl.display, xl.edit_winID, xl.rubGC, x1, y1, x2, y1 );
XDrawLine( xl.display, xl.edit_winID, xl.rubGC, x1, y1, x1, y2 );
XDrawLine( xl.display, xl.edit_winID, xl.rubGC, x2, y1, x2, y2 );
XDrawLine( xl.display, xl.edit_winID, xl.rubGC, x1, y2, x2, y2 );
}
static void
rubCircle( int ox, int oy, int rx, int ry )
{
unsigned int r;
int x, y;
if( ox==rx && oy==ry ) return;
x = rx - ox;
y = ry - oy;
r = (unsigned int)sqrt( (double)(x*x + y*y) );
if ( r == 0 ) return;
x = ox - (int)r;
y = oy - (int)r;
XDrawArc( xl.display, xl.edit_winID, xl.rubGC,
x, y, 2*r-1, 2*r-1,
0, 360*64
);
}
static void
resetEditMode( unsigned int flag )
{
int r1_x, r1_y;
int r2_x, r2_y;
if( flag & RES_MSG )
UpdateMessage( "" );
if( flag & RES_PROC )
em.proc = edpane.obj;
if( (flag & RES_SLCT) && (em.slct_f) ) {
r1_x = em.src1_px * edpane.pix_w + edpane.pix_w / 2;
r1_y = em.src1_py * edpane.pix_h + edpane.pix_h / 2;
r2_x = em.src2_px * edpane.pix_w + edpane.pix_w / 2;
r2_y = em.src2_py * edpane.pix_h + edpane.pix_h / 2;
rubBand( r1_x, r1_y, r2_x, r2_y );
em.slct_f = OFF;
}
if( flag & RES_RSV )
em.rsv_f = OFF;
}
/****************************************************************
* copy character pattern *
***************************************************************/
/*
* contents : copy or overlay the new character pattern to the current pattern
*/
/*ARGSUSED*/
static void
copyPatterns(
FalFontData *fdata,
int s1_code,
int s2_code,
int d1_code,
int proc)
{
int ret;
int d1_ncode, d2_ncode;
int code_d;
int code_disp;
char err[128];
int i_s, i_d;
int i;
char grc_d;
char **ptn;
char ptn2[MAXPTNBYTE];
int num;
extern int last_code;
ret = copySNF(s1_code, s2_code, &ptn, &num, err);
if( ret == -1 ) {
Error_message2((Widget)NULL, err);
return;
}
if (last_code < (d1_code + num))
last_code = d1_code + num;
if( ptnSense(edg.code) == 1 )
ptnAdd( edg.code, edg.ptn );
d1_ncode = codeToNo( d1_code );
for (i_d=d1_ncode, i_s=0; i_s < num; i_d++) {
if ( codeCheck( noToCode( i_d)))
continue;
bitPtnClear( ptn2 );
code_d = noToCode( i_d );
grc_d = ptnGet( code_d, ptn2 );
if (grc_d == 0) {
if( proc == CPY_OVERLAY ) {
for( i=0 ; i < edg.height*((edg.width+7)/8) ; i++ ) {
ptn[i_s][i] |= ptn2[i];
}
}
ptnAdd( code_d, ptn[i_s] );
edg.flag = ON;
} else {
if( ptnAdd( code_d, ptn[i_s] ) != 1 ) {
UpdateMessage( resource.me_non_memory );
break;
}
edlist.nptn++;
edg.flag = ON;
}
i_s ++;
}
d2_ncode = i_d - 1;
code_disp = 0;
for( i=d1_ncode ; i <= d2_ncode; i++ ) {
if ( codeCheck( noToCode(i) ) )
continue;
if( ptnSense( noToCode( i ) ) == 1 ) {
code_disp = noToCode( i );
break;
}
}
freeSNF(ptn, num);
if( (code_disp == 0) && (efctPtnNum() > 0))
code_disp = noToCode( ptnSqToNo(edlist.sqstart) );
chgEdCode( code_disp, ON );
resetEditMode( (unsigned int) (RES_MSG | RES_PROC | RES_SLCT | RES_RSV) );
}
Reference in New Issue View Git Blame Copy Permalink