~ubuntu-branches/ubuntu/trusty/rasmol/trusty : revision 21

1

/***************************************************************************

2

* RasMol 2.7.5 *

3

* *

4

* RasMol *

5

* Molecular Graphics Visualisation Tool *

6

* 13 June 2009 *

7

* *

8

* Based on RasMol 2.6 by Roger Sayle *

9

* Biomolecular Structures Group, Glaxo Wellcome Research & Development, *

10

* Stevenage, Hertfordshire, UK *

11

* Version 2.6, August 1995, Version 2.6.4, December 1998 *

12

* Copyright (C) Roger Sayle 1992-1999 *

13

* *

14

* and Based on Mods by *

15

*Author Version, Date Copyright *

16

*Arne Mueller RasMol 2.6x1 May 98 (C) Arne Mueller 1998 *

17

*Gary Grossman and RasMol 2.5-ucb Nov 95 (C) UC Regents/ModularCHEM *

18

*Marco Molinaro RasMol 2.6-ucb Nov 96 Consortium 1995, 1996 *

19

* *

20

*Philippe Valadon RasTop 1.3 Aug 00 (C) Philippe Valadon 2000 *

21

* *

22

*Herbert J. RasMol 2.7.0 Mar 99 (C) Herbert J. Bernstein *

23

*Bernstein RasMol 2.7.1 Jun 99 1998-2008 *

24

* RasMol 2.7.1.1 Jan 01 *

25

* RasMol 2.7.2 Aug 00 *

26

* RasMol 2.7.2.1 Apr 01 *

27

* RasMol 2.7.2.1.1 Jan 04 *

28

* RasMol 2.7.3 Feb 05 *

29

* RasMol 2.7.3.1 Apr 06 *

30

* RasMol 2.7.4 Nov 07 *

31

* RasMol 2.7.4.1 Jan 08 *

32

* RasMol 2.7.4.2 Mar 08 *

33

* RasMol 2.7.5 May 09 *

34

* *

35

* RasMol 2.7.5 incorporates changes by T. Ikonen, G. McQuillan, N. Darakev*

36

* and L. Andrews (via the neartree package). Work on RasMol 2.7.5 *

37

* supported in part by grant 1R15GM078077-01 from the National Institute *

38

* of General Medical Sciences (NIGMS), U.S. National Institutes of Health *

39

* and by grant ER63601-1021466-0009501 from the Office of Biological & *

40

* Environmental Research (BER), Office of Science, U. S. Department of *

41

* Energy. RasMol 2.7.4 incorporated changes by G. Todorov, Nan Jia, *

42

* N. Darakev, P. Kamburov, G. McQuillan, and J. Jemilawon. Work on RasMol *

43

* 2.7.4 supported in part by grant 1R15GM078077-01 from the NIGMS/NIH and *

44

* grant ER63601-1021466-0009501 from BER/DOE. RasMol 2.7.3 incorporates *

45

* changes by Clarice Chigbo, Ricky Chachra, and Mamoru Yamanishi. Work *

46

* on RasMol 2.7.3 supported in part by grants DBI-0203064, DBI-0315281 *

47

* and EF-0312612 from the U.S. National Science Foundation and grant *

48

* DE-FG02-03ER63601 from BER/DOE. The content is solely the responsibility*

49

* of the authors and does not necessarily represent the official views of *

50

* the funding organizations. *

51

* *

52

* The code for use of RasMol under GTK in RasMol 2.7.4.2 and 2.7.5 was *

53

* written by Teemu Ikonen. *

54

* *

55

* and Incorporating Translations by *

56

* Author Item Language *

57

* Isabel Servan Martinez, *

58

* Jose Miguel Fernandez Fernandez 2.6 Manual Spanish *

59

* Jose Miguel Fernandez Fernandez 2.7.1 Manual Spanish *

60

* Fernando Gabriel Ranea 2.7.1 menus and messages Spanish *

61

* Jean-Pierre Demailly 2.7.1 menus and messages French *

62

* Giuseppe Martini, Giovanni Paolella, 2.7.1 menus and messages *

63

* A. Davassi, M. Masullo, C. Liotto 2.7.1 help file Italian *

64

* G. Pozhvanov 2.7.3 menus and messages Russian *

65

* G. Todorov 2.7.3 menus and messages Bulgarian*

66

* Nan Jia, G. Todorov 2.7.3 menus and messages Chinese *

67

* Mamoru Yamanishi, Katajima Hajime 2.7.3 menus and messages Japanese *

68

* *

69

* This Release by *

70

* Herbert J. Bernstein, Bernstein + Sons, 5 Brewster Ln, Bellport, NY, USA*

71

* yaya@bernstein-plus-sons.com *

72

* Copyright(C) Herbert J. Bernstein 1998-2008 *

73

* *

74

* READ THE FILE NOTICE FOR RASMOL LICENSES *

75

*Please read the file NOTICE for important notices which apply to this *

76

*package and for license terms (GPL or RASLIC). *

77

***************************************************************************/

78

/* command.c

79

*/

80

81

/* With post-2.7.2.1-release mod,

82

Update for inline script loading in UCB multiple

83

molecule environment. HJB, 18 April 2001 */

84

/* With post-2.7.2.1-release mod,

85

Disable STRICT checking in ExecuteLoadCommand

86

To fix load inline for Windows. HJB 19 April 2001 */

87

/* With post-2.7.2.1-release mod,

88

Correct logic for inline load of new molecule

89

from data file treated as a script. HJB 29 June 2001 */

90

91

#include "rasmol.h"

92

93

#ifdef IBMPC

94

#include <windows.h>

95

#include <shellapi.h>

96

#include <malloc.h>

97

#endif

98

#ifdef APPLEMAC

99

#include <Types.h>

100

#include <Errors.h>

101

#ifdef __CONDITIONALMACROS__

102

#include <Printing.h>

103

#else

104

#include <PrintTraps.h>

105

#endif

106

#endif

107

#ifndef sun386

108

#include <stdlib.h>

109

#endif

110

111

#include <string.h>

112

#if defined(IBMPC) || defined(VMS) || defined(APPLEMAC)

113

#include "string_case.h"

114

#else

115

#include <strings.h>

116

#endif

117

#include <ctype.h>

118

#include <stdio.h>

119

#include <time.h>

120

121

122

#if !defined(IBMPC) && !defined(VMS) && !defined(APPLEMAC)

123

#include <pwd.h>

124

#endif

125

126

#define COMMAND

127

#include "command.h"

128

#include "tokens.h"

129

#include "molecule.h"

130

#include "infile.h"

131

#include "abstree.h"

132

#include "transfor.h"

133

#include "cmndline.h"

134

#include "render.h"

135

#include "repres.h"

136

#include "graphics.h"

137

#include "pixutils.h"

138

#include "outfile.h"

139

#include "script.h"

140

#include "multiple.h" /* [GSG 11/9/95] */

141

/* #include "toolbar.h" */ /* [GSG 11/11/95] */

142

#include "vector.h"

143

#include "wbrotate.h"

144

#include "langsel.h"

145

#include "maps.h"

146

147

#include <math.h>

148

#include <CVector.h>

149

#ifndef CVECTOR_FAR

150

#define CVECTOR_FAR

151

#endif

152

153

154

#if defined(__sun) && !defined(_XOPEN_SOURCE)

155

/* SUN doesn't always define popen in stdio! */

156

extern FILE *popen( const char*, const char* );

157

#endif

158

159

/* Macros for commonly used loops */

160

#define ForEachAtom for(chain=Database->clist;chain;chain=chain->cnext) \

161

for(group=chain->glist;group;group=group->gnext) \

162

for(ptr=group->alist;ptr;ptr=ptr->anext)

163

#define ForEachBond for(bptr=Database->blist;bptr;bptr=bptr->bnext)

164

#define ForEachSurfBond for(sbptr=Database->sblist;sbptr;sbptr=sbptr->sbnext)

165

166

167

#define IsIdentChar(x) ((isalnum(x))||((x)=='_')||((x)=='$'))

168

169

#ifdef INVERT

170

#define InvertY(y) (y)

171

#else

172

#define InvertY(y) (-(y))

173

#endif

174

175

#define Round(x) ((int)rint(x))

176

177

178

179

#ifndef VMS

180

#ifdef IBMPC

181

#define DirChar '\\'

182

#else

183

#define DirChar '/'

184

#endif

185

#endif

186

187

188

189

typedef struct {

190

Byte red;

191

Byte grn;

192

Byte blu;

193

} RGBStruct;

194

195

static RGBStruct ColourTable[34] = {

196

{ 0, 0, 0 }, /* Black */

197

{ 0, 0, 255 }, /* Blue */

198

{ 175, 214, 255 }, /* BlueTint */

199

{ 175, 117, 89 }, /* Brown */

200

{ 0, 255, 255 }, /* Cyan */

201

{ 255, 156, 0 }, /* Gold */

202

{ 125, 125, 125 }, /* Gray */

203

{ 0, 255, 0 }, /* Green */

204

{ 46, 139, 87 }, /* GreenBlue */

205

{ 152, 255, 179 }, /* GreenTint */

206

{ 255, 0, 101 }, /* HotPink */

207

{ 255, 0, 255 }, /* Magenta */

208

{ 255, 165, 0 }, /* Orange */

209

{ 255, 101, 117 }, /* Pink */

210

{ 255, 171, 187 }, /* PinkTint */

211

{ 160, 32, 240 }, /* Purple */

212

{ 255, 0, 0 }, /* Red */

213

{ 255, 69, 0 }, /* RedOrange */

214

{ 0, 250, 109 }, /* SeaGreen */

215

{ 58, 144, 255 }, /* SkyBlue */

216

{ 238, 130, 238 }, /* Violet */

217

{ 255, 255, 255 }, /* White */

218

{ 255, 255, 0 }, /* Yellow */

219

{ 246, 246, 117 } /* YellowTint */

220

};

221

222

223

typedef struct _HlpEntry {

224

struct _HlpEntry __far *next;

225

struct _HlpEntry __far *info;

226

char __far *keyword;

227

long fpos;

228

} HlpEntry;

229

230

#define HelpPool 16

231

static char *HelpFileName;

232

static char HelpFileBuf[80];

233

static HlpEntry __far *FreeInfo;

234

static HlpEntry __far *HelpInfo;

235

236

237

static char ResidueChar[29] = {

238

'A', 'G', 'L', 'S', 'V', 'T', 'K', 'D', 'I', 'N',

239

'E', 'P', 'R', 'F', 'Q', 'Y', 'H', 'C', 'M', 'W',

240

'B', 'Z', '*', 'P',

241

'A', 'C', 'G', 'T',

242

'U'

243

};

244

245

246

#define STACKSIZE 32

247

static char *NameStack[STACKSIZE];

248

static FILE *FileStack[STACKSIZE];

249

static int LineStack[STACKSIZE];

250

static char AcceptData[STACKSIZE];

251

252

static int TokenLength;

253

static Long TokenValue;

254

static char TokenIdent[128];

255

static char *TokenStart;

256

static char *TokenPtr;

257

static int CurToken;

258

259

260

static int RVal, GVal, BVal;

261

static int SeqFormat;

262

263

264

/*=======================*/

265

/* Function Prototypes */

266

/*=======================*/

267

268

int ExecuteCommand( void );

269

int ExecuteIPCCommand( char __huge* );

270

static int PrefixString( char __far*, char __far* );

271

static char __far * xfgets( char __far*, int, FILE __far *);

272

static int FetchToken( void );

273

void WriteImageFile( char *, int, int );

274

275

void CommandError( char *error )

276

{

277

register char *ptr;

278

char buffer[40];

279

280

if( TokenPtr )

281

{ if( FileDepth > -1 )

282

{ InvalidateCmndLine();

283

WriteString(CurLine);

284

WriteChar('\n');

285

} else WriteString(" ");

286

287

for( ptr=CurLine; ptr<TokenStart; ptr++ )

288

WriteChar(' ');

289

WriteString("^\n");

290

}

291

292

if( FileDepth > -1 )

293

{ if( LineStack[FileDepth] )

294

{ if( NameStack[FileDepth] )

295

{ WriteChar('"');

296

ptr = NameStack[FileDepth];

297

while( *ptr ) ptr++;

298

while( *ptr != '\\' && ptr != NameStack[FileDepth] ) ptr--;

299

if( *ptr == '\\' ) ptr++;

300

WriteString(ptr);

301

WriteString("\", ");

302

}

303

sprintf(buffer,"line %d: ",LineStack[FileDepth]);

304

WriteString(buffer);

305

} else

306

{ WriteString(NameStack[FileDepth]);

307

WriteString(": ");

308

}

309

}

310

311

if( error )

312

{ WriteString(error);

313

if (strlen(error)>(size_t)0 && !(error[strlen(error)-(size_t)1]=='\n')) {

314

WriteString("\n");

315

}

316

}

317

CommandActive = False;

318

CurToken = 0;

319

}

320

321

322

323

/*==========================*/

324

/* File Handling Services */

325

/*==========================*/

326

327

#ifdef IBMPC

328

static char *ProcessFileName( char *name )

329

{

330

register char *ptr;

331

332

while( *name==' ' )

333

name++;

334

335

ptr = DataFileName;

336

while( *name )

337

{ *ptr++ = ToUpper(*name);

338

name++;

339

}

340

341

/* Strip trailing spaces! */

342

while( (ptr!=DataFileName) && (ptr[-1]==' ') )

343

ptr--;

344

*ptr = '\0';

345

return ptr;

346

}

347

#endif

348

349

#ifdef APPLEMAC

350

static char *ProcessFileName( char *name )

351

{

352

register char *ptr;

353

354

while( *name==' ' )

355

name++;

356

357

ptr = DataFileName;

358

while( *name )

359

*ptr++ = *name++;

360

361

/* Strip trailing spaces! */

362

while( (ptr!=DataFileName) && (ptr[-1]==' ') )

363

ptr--;

364

*ptr = '\0';

365

return ptr;

366

}

367

#endif

368

369

#ifdef VMS

370

static char *ProcessFileName( char *name )

371

{

372

register char *ptr;

373

374

while( *name==' ' )

375

name++;

376

377

ptr = DataFileName;

378

while( *name && (*name!=' ') )

379

{ *ptr++ = ToUpper(*name);

380

name++;

381

}

382

*ptr = '\0';

383

return ptr;

384

}

385

#endif

386

387

388

#if !defined(IBMPC) && !defined(APPLEMAC) && !defined(VMS)

389

static int IsSecure( int ch )

390

{

391

switch( ch )

392

{ /* Dangerous characters in UNIX "popen"! */

393

case('<'): case('>'): case('('): case(')'):

394

case('{'): case('}'): case('['): case(']'):

395

case('\''): case(';'): case('|'): case('&'):

396

return False;

397

}

398

return True;

399

}

400

401

402

static char *ProcessFileName( char *name )

403

{

404

register struct passwd *entry;

405

register char *temp;

406

register char *ptr;

407

char username[64];

408

409

while( *name==' ' )

410

name++;

411

412

/* Perform filename globbing */

413

if( *name=='~' )

414

{ ptr = username; name++;

415

while( *name && (*name!=' ') && (*name!='/') )

416

*ptr++ = *name++;

417

*ptr = '\0';

418

419

ptr = DataFileName;

420

if( *username )

421

{ if( (entry=getpwnam(username)) )

422

{ temp = entry->pw_dir;

423

endpwent();

424

} else /* Unknown user! */

425

{ temp = username;

426

*ptr++ = '~';

427

}

428

429

} else if( !(temp=(char*)getenv("HOME")) )

430

temp = ".";

431

432

while( *temp )

433

*ptr++ = *temp++;

434

} else ptr = DataFileName;

435

436

/* Strip dubious characters! */

437

while( *name && (*name!=' ') )

438

if( IsSecure(*name) )

439

{ *ptr++ = *name++;

440

} else name++;

441

*ptr = '\0';

442

return ptr;

443

}

444

#endif

445

446

447

#ifdef UNIX

448

449

#define MaxFileExt 4

450

/* UNIX Compressed Filename extensions! */

451

static char *FileExt[MaxFileExt] = { "", ".Z", ".gz", ".z" };

452

453

static FILE *OpenDataFile( char *begin, char *end )

454

{

455

register char *src, *dst;

456

register FILE *fp;

457

register int i;

458

459

for( i=0; i<MaxFileExt; i++ )

460

{ dst = end; src = FileExt[i];

461

while( (*dst++ = *src++) );

462

if( (fp=fopen(begin,"rb")) ) {

463

*end = '\0';

464

return fp;

465

}

466

}

467

fp = fopen(begin,"rb");

468

*end = '\0';

469

return fp;

470

}

471

#else /* !defined(UNIX) */

472

473

static FILE *OpenDataFile( char *begin, char *end )

474

{

475

register FILE *fp;

476

477

fp = fopen(begin,"rb");

478

return fp;

479

}

480

#endif

481

482

483

int ProcessFile( int format, int info, FILE *fp )

484

{

485

register int done;

486

char __far *temp;

487

488

temp = getenv("RASMOLCIF");

489

if (temp) {

490

UseCIF = 0;

491

if (!strncasecmp(temp,"cif",3)) UseCIF = 1;

492

}

493

DataFileFormat = 0;

494

switch( format )

495

{ case(FormatPDB): done = LoadPDBMolecule(fp,False); break;

496

case(FormatNMRPDB): done = LoadPDBMolecule(fp,True); break;

497

case(FormatMacroMod): done = LoadMacroModelMolecule(fp); break;

498

case(FormatAlchemy): done = LoadAlchemyMolecule(fp); break;

499

case(FormatCharmm): done = LoadCharmmMolecule(fp); break;

500

case(FormatBiosym): done = LoadBiosymMolecule(fp); break;

501

case(FormatMOPAC): done = LoadMOPACMolecule(fp); break;

502

case(FormatSHELX): done = LoadSHELXMolecule(fp); break;

503

case(FormatMol2): done = LoadMol2Molecule(fp); break;

504

case(FormatFDAT): done = LoadFDATMolecule(fp); break;

505

case(FormatMDL): done = LoadMDLMolecule(fp); break;

506

case(FormatXYZ): done = LoadXYZMolecule(fp); break;

507

case(FormatCIF): done = LoadCIFMolecule(fp); break;

508

#ifdef CEXIOLIB

509

case(FormatCEX): done = LoadCEXMolecule(fp); break;

510

#endif

511

default: done = False;

512

}

513

514

if( !done )

515

{ return False;

516

} else if( !Database )

517

return True;

518

if (Interactive) ReviseTitle();

519

if( info )

520

DescribeMolecule();

521

if (!DataFileFormat) DataFileFormat = format;

522

AdviseUpdate(AdvName);

523

AdviseUpdate(AdvClass);

524

AdviseUpdate(AdvIdent);

525

526

#ifdef X11WIN

527

if( Interactive )

528

FetchEvent(False);

529

#endif

530

531

ReDrawFlag |= RFInitial;

532

if( CalcBondsFlag )

533

{ if( Info.bondcount < (MainAtomCount+HetaAtomCount)-Info.chaincount )

534

{ if( MainAtomCount+HetaAtomCount > 255 )

535

{ CreateMoleculeBonds(info,False,False);

536

} else CreateMoleculeBonds(info,True,False);

537

}

538

}

539

if( CalcSurfFlag ) CreateSurfaceBonds();

540

541

/* Explicit Hydrogen Bonds! */

542

if( Info.hbondcount > 0 )

543

SetHBondStatus(True,True,0,0);

544

545

/* Explicit SSbonds! */

546

if (Info.ssbondcount > 0 ) {

547

SetHBondStatus(False,True,0,0);

548

SSBondMode = True;

549

}

550

551

InitialTransform();

552

553

VoxelsClean = False;

554

ApplyTransform();

555

return True;

556

}

557

558

559

static int FetchFileOne( int format, int info, char *name )

560

{

561

#ifndef APPLEMAC

562

#ifdef UNIX

563

register int comp;

564

#endif /* UNIX */

565

register char *src,*dst;

566

register char *tmp;

567

char buffer[128];

568

#endif /* APPLEMAC */

569

570

register int done = 0;

571

register FILE *fp;

572

573

DataFileFormat = 0;

574

name = ProcessFileName(name);

575

fp = OpenDataFile(DataFileName,name);

576

577

#ifndef APPLEMAC

578

/* Search for directory specification! */

579

#ifndef VMS

580

if( !fp )

581

{ src = DataFileName;

582

while( *src && (*src!=DirChar) )

583

src++;

584

done = !(*src);

585

}

586

#else

587

done = True;

588

#endif

589

590

/* Try using a default file path! */

591

if( !fp && done )

592

{ char* datadir;

593

datadir = "";

594

switch( format )

595

{ case(FormatNMRPDB):

596

case(FormatPDB): src = (char*)getenv("RASMOLPDBPATH"); break;

597

case(FormatMol2): src = (char*)getenv("RASMOLMOL2PATH"); break;

598

case(FormatMMDB): src = (char*)getenv("RASMOLMMDBPATH"); break;

599

case(FormatAlchemy): src = (char*)getenv("RASMOLMOLPATH"); break;

600

case(FormatMDL): src = (char*)getenv("RASMOLMDLPATH"); break;

601

case(FormatXYZ): src = (char*)getenv("RASMOLXYZPATH"); break;

602

case(FormatCIF): src = (char*)getenv("RASMOLCIFPATH"); break;

603

default: src = NULL;

604

}

605

if (!src || !*src) {

606

src = (char*)getenv("RASMOLPATH");

607

datadir = "Data";

608

}

609

if( src && *src ) {

610

#ifdef VMS

611

dst = buffer;

612

while( *src ) *dst++ = *src++;

613

614

tmp = DataFileName;

615

while( *dst = *tmp++ ) dst++;

616

if( fp = OpenDataFile(buffer,dst) )

617

strcpy(DataFileName,buffer);

618

#else

619

while( *src )

620

{ dst = buffer;

621

while( *src && (*src!=':') )

622

*dst++ = *src++;

623

if( *src == ':' )

624

src++;

625

626

if( dst != buffer )

627

{ if( *(dst-1) != DirChar )

628

*dst++ = DirChar;

629

if (strcmp(datadir,"")) {

630

tmp = datadir;

631

while( (*dst = *tmp++)) dst++;

632

if( *(dst-1) != DirChar )

633

*dst++ = DirChar;

634

}

635

tmp = DataFileName;

636

while( (*dst = *tmp++) ) dst++;

637

if( (fp = OpenDataFile(buffer,dst)) )

638

{ strcpy(DataFileName,buffer);

639

break;

640

}

641

}

642

}

643

#endif

644

}

645

}

646

#endif /* APPLEMAC */

647

648

649

#ifdef CEXIOLIB

650

if( !fp && (format==FormatCEX) )

651

{ if( ProcessFile(format,info,fp) )

652

return True;

653

}

654

#endif

655

656

if( !fp )

657

{ *name = '\0';

658

InvalidateCmndLine();

659

WriteString(MsgStrs[StrErrFile]);

660

WriteString(DataFileName);

661

WriteString(MsgStrs[StrNotFnd]);

662

CommandActive=False;

663

return False;

664

}

665

666

#ifdef UNIX

667

done = getc(fp);

668

if( done == 0x1f )

669

{ done = getc(fp);

670

fclose(fp);

671

672

if( done == 0x9d )

673

{ /* Should #include <signal.h> and trap "" SIGPIPE */

674

sprintf(buffer,"trap \"\" 13; uncompress -c '%s' 2> /dev/null\n",

675

DataFileName);

676

} else if( done == 0x8b )

677

{ /* Should #include <signal.h> and trap "" SIGPIPE */

678

sprintf(buffer,"trap \"\" 13; gzip -cdq '%s' 2> /dev/null\n",

679

DataFileName);

680

} else /* bad magic number! */

681

{ InvalidateCmndLine();

682

WriteString(MsgStrs[StrCFmt]);

683

return False;

684

}

685

686

comp = True;

687

fp = popen(buffer,"r");

688

if( !fp )

689

{ InvalidateCmndLine();

690

WriteString(MsgStrs[StrDcmp]);

691

return False;

692

}

693

} else /* Uncompressed! */

694

{ ungetc(done,fp);

695

comp = False;

696

}

697

#endif

698

699

done = ProcessFile(format,info,fp);

700

701

#ifdef UNIX

702

if( comp )

703

{ if( pclose(fp) )

704

{ InvalidateCmndLine();

705

WriteString(MsgStrs[StrDcmp]);

706

return False;

707

}

708

} else fclose(fp);

709

#else /* !defined(UNIX) */

710

fclose(fp);

711

#endif

712

return done;

713

}

714

715

/* [GSG 11/9/95] Multiple Molecule Support */

716

int FetchFile( int format, int info, char *name )

717

{

718

int SaveMolecule = MoleculeIndex;

719

int result;

720

721

if (NumMolecules >= MAX_MOLECULES) {

722

return 0;

723

}

724

SwitchMolecule(NumMolecules);

725

result = FetchFileOne( format, info, name );

726

if (result && Database) {

727

NumMolecules++;

728

DrawMoleculeList();

729

} else {

730

SwitchMolecule(SaveMolecule);

731

}

732

return result;

733

}

734

735

int FetchStdin( int format )

736

{

737

int SaveMolecule = MoleculeIndex;

738

int result;

739

740

if (NumMolecules >= MAX_MOLECULES) {

741

return 0;

742

}

743

SwitchMolecule(NumMolecules);

744

result = ProcessFile( format, True, stdin );

745

if (result && Database) {

746

NumMolecules++;

747

DrawMoleculeList();

748

} else {

749

SwitchMolecule(SaveMolecule);

750

}

751

return result;

752

}

753

754

static int SetNewMolecule( void )

755

{

756

if (NumMolecules >= MAX_MOLECULES) {

757

return False;

758

}

759

SwitchMolecule(NumMolecules);

760

NumMolecules++;

761

return True;

762

}

763

764

int DivertToData( int format, int info )

765

{

766

register int ch,len,done;

767

register long pos;

768

FILE *fp;

769

770

fp = FileStack[FileDepth];

771

pos = ftell(fp);

772

do

773

{ len = 0;

774

ch = getc(fp);

775

while( (ch!='\n') && (ch!='\r') && (ch!=EOF) )

776

{ if( len<MAXBUFFLEN )

777

CurLine[len++] = ch;

778

ch = getc(fp);

779

}

780

781

if( ch == '\r' )

782

{ ch = getc(fp);

783

if( ch != '\n' )

784

ungetc(ch,fp);

785

}

786

787

if( len<MAXBUFFLEN )

788

{ CurLine[len] = '\0';

789

TokenPtr = CurLine;

790

if( FetchToken() ) {

791

if ( CurToken == QuitTok || CurToken == ExitTok )

792

{ if ( SetNewMolecule()) {

793

done = ProcessFile( format, info, fp );

794

fseek(fp,pos,SEEK_SET);

795

strcpy (Info.filename,"inline");

796

return done;

797

} else {

798

CommandError(MsgStrs[ErrBadLoad]);

799

return False;

800

}

801

} else {

802

if ( CurToken == HeaderTok || CurToken == CIFDataTok )

803

{

804

Recycle = &CurLine[0];

805

AcceptData[FileDepth] = 'N';

806

if ( SetNewMolecule()) {

807

done = ProcessFile( format, info, fp );

808

fseek(fp,pos,SEEK_SET);

809

strcpy (Info.filename,"inline");

810

return done;

811

} else {

812

CommandError(MsgStrs[ErrBadLoad]);

813

return False;

814

}

815

}

816

}

817

}

818

} else CommandError(MsgStrs[StrSLong]);

819

} while( ch!=EOF );

820

821

if( SetNewMolecule() )

822

{ fseek(fp,0,SEEK_SET);

823

AcceptData[FileDepth] = 'N';

824

done = ProcessFile( format, info, fp );

825

fseek(fp,pos,SEEK_SET);

826

return done;

827

} else {

828

CommandError(MsgStrs[ErrBadLoad]);

829

}

830

831

return False;

832

}

833

834

835

void LoadScriptFile( FILE *fp, char *name )

836

{

837

register char *ptr;

838

register int ch;

839

register size_t len;

840

register int stat;

841

842

if( fp )

843

{ FileDepth++;

844

len = strlen(name)+1;

845

ptr = (char*)_fmalloc(len);

846

memcpy(ptr,name,len);

847

NameStack[FileDepth] = ptr;

848

FileStack[FileDepth] = fp;

849

LineStack[FileDepth] = 0;

850

AcceptData[FileDepth] = 'Y';

851

852

do {

853

len = 0;

854

ch = getc(fp);

855

while( (ch!='\n') && (ch!='\r') && (ch!=EOF) )

856

{ if( len<(size_t)MAXBUFFLEN )

857

CurLine[len++] = ch;

858

ch = getc(fp);

859

}

860

861

if( ch == '\r' )

862

{ ch = getc(fp);

863

if( ch != '\n' )

864

ungetc(ch,fp);

865

}

866

867

LineStack[FileDepth]++;

868

if( len<(size_t)MAXBUFFLEN )

869

{ CurLine[len] = '\0';

870

stat = ExecuteCommand();

871

if( stat )

872

{ if( stat == QuitTok )

873

{ while( FileDepth >= 0 )

874

{ fclose(FileStack[FileDepth]);

875

_ffree(NameStack[FileDepth]);

876

FileDepth--;

877

}

878

RasMolExit();

879

} else /* ExitTok */

880

break;

881

} else if( IsPaused )

882

return;

883

884

} else CommandError(MsgStrs[StrSLong]);

885

} while( ch!=EOF );

886

_ffree(NameStack[FileDepth]);

887

fclose( fp );

888

FileDepth--;

889

} else

890

{ CommandError( (char*)NULL );

891

WriteString(MsgStrs[StrSFile]);

892

WriteString(name); WriteString("'\n");

893

}

894

*CurLine = '\0';

895

}

896

897

/*============================*/

898

/* Deferred Command Support */

899

/*============================*/

900

901

902

static int Define_Symbol(const char __far * string, const char __far * definition) {

903

904

int clead, is;

905

Symbol __far * symbol;

906

Symbol __far * prevsymbol;

907

908

clead = string[0];

909

clead &= 0xFF;

910

symbol = Defer_Symbols[clead];

911

prevsymbol = NULL;

912

while (symbol) {

913

if (!strcasecmp(string,symbol->string)) {

914

if (symbol->definition_capacity < strlen(definition)+1) {

915

_ffree((void *)symbol->definition);

916

symbol->definition = (const char __far *)_fmalloc(strlen(definition)+1);

917

if (!symbol->definition)return -1;

918

symbol->definition_capacity = symbol->definition_size = strlen(definition)+1;

919

}

920

strcpy((char *)(symbol->definition),definition);

921

922

return 0;

923

}

924

prevsymbol = symbol;

925

symbol = symbol->Symbol_Next;

926

}

927

if (!FreeSymbol) {

928

symbol = (Symbol __far *)_fmalloc(SymbolPool*sizeof(Symbol));

929

if (!symbol)return -1;

930

for (is = 0; is < SymbolPool-1; is++) {

931

(symbol[is]).Symbol_Next= &(symbol[is+1]);

932

}

933

symbol[SymbolPool-1].Symbol_Next = NULL;

934

for (is = 0; is < SymbolPool; is ++) {

935

(symbol[is]).string = NULL;

936

(symbol[is]).definition = NULL;

937

(symbol[is]).definition_size=0;

938

(symbol[is]).definition_capacity=0;

939

}

940

FreeSymbol = symbol;

941

}

942

symbol = FreeSymbol;

943

FreeSymbol = symbol->Symbol_Next;

944

symbol->string = (const char __far *)_fmalloc(strlen(string)+1);

945

if (!symbol->string) return -1;

946

strcpy((char *)(symbol->string),string);

947

symbol->definition = (const char __far *)_fmalloc(strlen(definition)+1);

948

if (!symbol->definition)

949

{

950

_ffree((void *)symbol->string);

951

return -1;

952

}

953

symbol->definition_capacity = symbol->definition_size = strlen(definition)+1;

954

strcpy((char *)(symbol->definition),definition);

955

if (prevsymbol) {

956

prevsymbol->Symbol_Next = symbol;

957

} else {

958

Defer_Symbols[clead] = symbol;

959

}

960

symbol->Symbol_Next = NULL;

961

return 0;

962

}

963

964

965

static int Append_Symbol_Definition(const char __far * string, const char __far * definition, int bylines) {

966

967

int clead, is, il;

968

Symbol __far * symbol;

969

Symbol __far * prevsymbol;

970

971

size_t xsize;

972

il = bylines?1:0;

973

clead = string[0];

974

clead &= 0xFF;

975

symbol = Defer_Symbols[clead];

976

prevsymbol = NULL;

977

while (symbol) {

978

if (!strcasecmp(string,symbol->string)) {

979

xsize = strlen(symbol->definition)+strlen(definition)+il+1;

980

if (symbol->definition_capacity < xsize) {

981

const char * old_definition;

982

old_definition = symbol->definition;

983

symbol->definition = (const char __far *)_fmalloc(xsize);

984

if (!symbol->definition)return -1;

985

strcpy((char *)symbol->definition,old_definition);

986

symbol->definition_size = strlen(old_definition+1);

987

symbol->definition_capacity = xsize;

988

_ffree((void *)old_definition);

989

}

990

if (bylines) strcat((char *)(symbol->definition),"\n");

991

strcat((char *)(symbol->definition),definition);

992

993

return 0;

994

}

995

prevsymbol = symbol;

996

symbol = symbol->Symbol_Next;

997

}

998

if (!FreeSymbol) {

999

symbol = (Symbol __far *)_fmalloc(SymbolPool*sizeof(Symbol));

1000

if (!symbol)return -1;

1001

for (is = 0; is < SymbolPool-1; is++) {

1002

(symbol[is]).Symbol_Next= &(symbol[is+1]);

1003

}

1004

symbol[SymbolPool-1].Symbol_Next = NULL;

1005

for (is = 0; is < SymbolPool; is ++) {

1006

(symbol[is]).string = NULL;

1007

(symbol[is]).definition = NULL;

1008

(symbol[is]).definition_size=0;

1009

(symbol[is]).definition_capacity=0;

1010

}

1011

FreeSymbol = symbol;

1012

}

1013

symbol = FreeSymbol;

1014

FreeSymbol = symbol->Symbol_Next;

1015

symbol->string = (const char __far *)_fmalloc(strlen(string)+1);

1016

if (!symbol->string) return -1;

1017

strcpy((char *)(symbol->string),string);

1018

symbol->definition = (const char __far *)_fmalloc(strlen(definition)+1);

1019

if (!symbol->definition)

1020

{

1021

_ffree((void *)(symbol->string));

1022

return -1;

1023

}

1024

symbol->definition_capacity = symbol->definition_size = strlen(definition)+1;

1025

strcpy((char *)(symbol->definition),definition);

1026

if (prevsymbol) {

1027

prevsymbol->Symbol_Next = symbol;

1028

} else {

1029

Defer_Symbols[clead] = symbol;

1030

}

1031

symbol->Symbol_Next = NULL;

1032

return 0;

1033

}

1034

1035

static int Free_Symbol(const char __far * string) {

1036

1037

int clead;

1038

Symbol __far * symbol;

1039

Symbol __far * prevsymbol;

1040

1041

clead = string[0];

1042

clead &= 0xFF;

1043

symbol = Defer_Symbols[clead];

1044

prevsymbol = NULL;

1045

while (symbol) {

1046

if (!strcasecmp(string,symbol->string)) {

1047

_ffree((void *)(symbol->definition));

1048

_ffree((void *)(symbol->string));

1049

symbol->string = NULL;

1050

symbol->definition = NULL;

1051

symbol->definition_size=0;

1052

symbol->definition_capacity=0;

1053

if (prevsymbol) {

1054

prevsymbol->Symbol_Next = symbol->Symbol_Next;

1055

} else {

1056

Defer_Symbols[clead] = symbol->Symbol_Next;

1057

}

1058

symbol->Symbol_Next = FreeSymbol;

1059

FreeSymbol = symbol;

1060

return 0;

1061

}

1062

prevsymbol = symbol;

1063

symbol = symbol->Symbol_Next;

1064

}

1065

return 1;

1066

}

1067

1068

static int Find_Symbol_Definition(const char __far * string, const char __far * __far * definition) {

1069

1070

int clead;

1071

Symbol __far * symbol;

1072

Symbol __far * prevsymbol;

1073

1074

clead = string[0];

1075

clead &= 0xFF;

1076

symbol = Defer_Symbols[clead];

1077

prevsymbol = NULL;

1078

while (symbol) {

1079

if (!strcasecmp(string,symbol->string)) {

1080

*definition = symbol->definition;

1081

return 0;

1082

}

1083

prevsymbol = symbol;

1084

symbol = symbol->Symbol_Next;

1085

}

1086

return 1;

1087

}

1088

1089

void ExecuteDeferCommand( void ) {

1090

const char * strptr;

1091

char ch;

1092

1093

FetchToken();

1094

if (CurToken == ZapTok) {

1095

Free_Symbol("");

1096

return;

1097

}

1098

if (CurToken == '(') {

1099

if (Append_Symbol_Definition("", TokenStart, True)==-1) {

1100

InvalidateCmndLine();

1101

RasMolFatalExit(MsgStrs[StrMalloc]);

1102

}

1103

return;

1104

}

1105

if( !CurToken ){

1106

CommandError(MsgStrs[ErrSyntax]);

1107

return;

1108

}

1109

strptr = TokenIdent;

1110

CurToken = 0;

1111

ch = *TokenPtr++;

1112

while( ch && (ch!='#') ){

1113

if( isspace(ch) ){

1114

ch = *TokenPtr++;

1115

continue;

1116

}

1117

TokenPtr--;

1118

break;

1119

}

1120

if (!strncasecmp("zap",TokenPtr,3) && (!(*(TokenPtr+3)) ||isspace(*(TokenPtr+3)))){

1121

Free_Symbol(strptr);

1122

} else {

1123

if (Append_Symbol_Definition(strptr, TokenPtr, True)==-1) {

1124

InvalidateCmndLine();

1125

RasMolFatalExit(MsgStrs[StrMalloc]);

1126

}

1127

}

1128

return;

1129

}

1130

1131

1132

void ShowDeferCommand( void ) {

1133

const char * definition;

1134

FetchToken();

1135

if( !CurToken ){

1136

CommandError(MsgStrs[ErrSyntax]);

1137

return;

1138

}

1139

if (!Find_Symbol_Definition(TokenIdent,&definition)) {

1140

WriteString((char *)definition);

1141

} else {

1142

WriteString("'");

1143

WriteString(TokenIdent);

1144

WriteString(MsgStrs[StrNotFnd]);

1145

return;

1146

}

1147

WriteString("\n=================\n");

1148

return;

1149

}

1150

1151

void ExecuteExecuteCommand( void ) {

1152

const char * definition;

1153

register int ch;

1154

register size_t len;

1155

int stat;

1156

int save_Interactive;

1157

int save_molecule, save_num_molecules;

1158

int im;

1159

double * dialsave_old;

1160

double * dialsave_new;

1161

int RDF;

1162

1163

1164

FetchToken();

1165

if( !CurToken ){

1166

CommandError(MsgStrs[ErrSyntax]);

1167

return;

1168

}

1169

if (!Find_Symbol_Definition(TokenIdent,&definition))

1170

{

1171

save_Interactive = Interactive;

1172

1173

dialsave_old = (double *)_fmalloc(sizeof(double)*11*NumMolecules);

1174

if (!dialsave_old) {

1175

RasMolFatalExit(MsgStrs[StrMalloc]);

1176

}

1177

save_molecule = MoleculeIndex;

1178

save_num_molecules = NumMolecules;

1179

1180

for (im=0; im<NumMolecules; im++) {

1181

SwitchMolecule(im);

1182

memmove((char *)(dialsave_old+im*11),(char *)DialValue,11*sizeof(double));

1183

}

1184

SwitchMolecule(save_molecule);

1185

1186

Interactive=False; /* Supress all screen activity while

1187

executing the commands first time around */

1188

do {

1189

len = 0;

1190

ch = *definition++;

1191

while( ch && (ch!='\n') && (ch!='\r') ){

1192

if( len<(size_t)MAXBUFFLEN )

1193

CurLine[len++] = ch;

1194

ch = *definition++;

1195

}

1196

if( ch == '\r' )

1197

{ ch = *definition++;

1198

if( ch != '\n' )

1199

definition--;

1200

}

1201

if( len<(size_t)MAXBUFFLEN )

1202

{ CurLine[len] = '\0';

1203

stat = ExecuteCommand();

1204

if( stat )

1205

{ if( stat == QuitTok ) {

1206

Interactive = save_Interactive;

1207

RasMolExit();

1208

} else /* ExitTok */

1209

break;

1210

}

1211

} else CommandError(MsgStrs[StrSLong]);

1212

} while( ch );

1213

1214

dialsave_new = (double *)_fmalloc(sizeof(double)*11*NumMolecules);

1215

if (!dialsave_new) {

1216

_ffree(dialsave_old);

1217

RasMolFatalExit(MsgStrs[StrMalloc]);

1218

}

1219

save_molecule = MoleculeIndex;

1220

1221

for (im=0; im<NumMolecules; im++) {

1222

SwitchMolecule(im);

1223

memmove((char *)(dialsave_new+im*11),(char *)DialValue,11*sizeof(double));

1224

if (im<save_num_molecules)

1225

{

1226

memmove((char *)DialValue,(char *)(dialsave_old+im*11),11*sizeof(double));

1227

}

1228

}

1229

1230

SwitchMolecule(save_molecule);

1231

1232

RDF = ReDrawFlag;

1233

1234

RefreshScreen();

1235

1236

ReDrawFlag |= RDF;

1237

1238

Interactive = save_Interactive;

1239

1240

for (im=0; im<NumMolecules; im++) {

1241

SwitchMolecule(im);

1242

memmove((char *)DialValue,(char *)(dialsave_new+im*11),11*sizeof(double));

1243

}

1244

1245

SwitchMolecule(save_molecule);

1246

1247

1248

}

1249

return;

1250

}

1251

1252

1253

/*===========================*/

1254

/* Movie Support Utilities */

1255

/*===========================*/

1256

1257

1258

1259

void ShowRecordCommand( void ) {

1260

int millisec;

1261

char param[1024];

1262

millisec = RecordFrom + 1000.*((double)record_frame[0])/record_fps;

1263

if (RecordPause

1264

|| RecordTemplate[0] == '\0'

1265

|| (millisec > RecordMaxMS && RecordMaxMS > 1.)

1266

|| (RecordUntil >= RecordFrom

1267

&& millisec > RecordUntil + 1000.*((double)record_frame[0])/record_fps)) {

1268

WriteString("record off\n");

1269

} else {

1270

sprintf(param,"record from %g until %g\n",RecordFrom/1000., RecordUntil/1000.);

1271

WriteString(param);

1272

if (record_fps > 0.) {

1273

sprintf(param,"set record.fps %g\n",record_fps);

1274

WriteString(param);

1275

}

1276

if (record_aps > 0.) {

1277

sprintf(param,"set record.aps %g\n",record_aps);

1278

WriteString(param);

1279

}

1280

if (record_dwell > 0.) {

1281

sprintf(param,"set record.dwell %g\n",record_dwell);

1282

WriteString(param);

1283

}

1284

if (record_on[0]) WriteString("record motion on\n");

1285

else WriteString("record motion off\n");

1286

if (record_on[1]) WriteString("record appearance on\n");

1287

else WriteString("record apperance off\n");

1288

if (RecordMaxMS == 1.) {

1289

sprintf(param,RecordTemplate);

1290

} else{

1291

sprintf(param,RecordTemplate,millisec<0?0:millisec);

1292

}

1293

WriteString("record on ");

1294

switch(RecordOption) {

1295

1296

case (0):

1297

#ifdef EIGHTBIT

1298

WriteString("GIF "); break;

1299

#else

1300

WriteString("PPM "); break;

1301

#endif

1302

case(NMRPDBTok):

1303

case(PDBTok):

1304

WriteString("PDB "); break;

1305

case(MDLTok):

1306

WriteString("MDL "); break;

1307

case(XYZTok):

1308

WriteString("XYZ "); break;

1309

case(CIFTok):

1310

WriteString("CIF "); break;

1311

case(AlchemyTok):

1312

WriteString("ALCHEMY "); break;

1313

case(GIFTok):

1314

WriteString("GIF "); break;

1315

case(BMPTok):

1316

WriteString("BMP "); break;

1317

case(PPMTok):

1318

WriteString("PPM "); break;

1319

case(SUNTok):

1320

WriteString("SUN "); break;

1321

case(SUNRLETok):

1322

WriteString("SUNRLE "); break;

1323

case(PICTTok):

1324

WriteString("PICT "); break;

1325

case(IRISTok):

1326

WriteString("IRIS "); break;

1327

case(EPSFTok):

1328

WriteString("EPSF "); break;

1329

case(MonoPSTok):

1330

WriteString("MONOPS "); break;

1331

case(VectPSTok):

1332

WriteString("VECTPS "); break;

1333

case(Raster3DTok):

1334

WriteString("R3D "); break;

1335

1336

case(RasMolTok):

1337

case(ScriptTok):

1338

WriteString("SCRIPT "); break;

1339

case(KinemageTok):

1340

WriteString("KINEMAGE "); break;

1341

case(MolScriptTok):

1342

WriteString("MOLSCRIPT "); break;

1343

case(POVRayTok):

1344

WriteString("POVRAY "); break;

1345

case(POVRay3Tok):

1346

WriteString("POVRAY3 "); break;

1347

case(PhiPsiTok):

1348

WriteString("PHIPSI "); break;

1349

case(RamachanTok):

1350

WriteString("RAMACHAN "); break;

1351

case(RamPrintTok):

1352

WriteString("RPP "); break;

1353

case(VRMLTok):

1354

WriteString("VRML ");

1355

if (RecordSubOption == MirrorTok) WriteString("MIRROR ");

1356

if (RecordSubOption == RotateTok) WriteString("ROTATE ");

1357

break;

1358

1359

}

1360

WriteString(param);

1361

WriteString("\n");

1362

}

1363

return;

1364

}

1365

1366

void ShowPlayCommand( void ) {

1367

int millisec;

1368

char param[1024];

1369

millisec = PlayFrom + 1000.*((double)play_frame[0])/play_fps;

1370

if (PlayPause

1371

|| PlayTemplate[0] == '\0'

1372

|| (millisec > PlayMaxMS && PlayMaxMS > 1.)

1373

|| (PlayUntil >= PlayFrom

1374

&& millisec > PlayUntil + 1000.*((double)play_frame[0])/play_fps)) {

1375

WriteString("play off\n");

1376

} else {

1377

sprintf(param,"play from %g until %g\n",PlayFrom/1000., PlayUntil/1000.);

1378

WriteString(param);

1379

if (play_fps > 0.) {

1380

sprintf(param,"set play.fps %g\n",record_fps);

1381

WriteString(param);

1382

}

1383

if (PlayMaxMS == 1.) {

1384

sprintf(param,PlayTemplate);

1385

} else{

1386

sprintf(param,PlayTemplate,millisec<0?0:millisec);

1387

}

1388

WriteString("play on ");

1389

switch(PlayOption) {

1390

1391

case (0):

1392

#ifdef EIGHTBIT

1393

WriteString("GIF "); break;

1394

#else

1395

WriteString("PPM "); break;

1396

#endif

1397

case(NMRPDBTok):

1398

case(PDBTok):

1399

WriteString("PDB "); break;

1400

case(MDLTok):

1401

WriteString("MDL "); break;

1402

case(XYZTok):

1403

WriteString("XYZ "); break;

1404

case(CIFTok):

1405

WriteString("CIF "); break;

1406

case(AlchemyTok):

1407

WriteString("ALCHEMY "); break;

1408

case(GIFTok):

1409

WriteString("GIF "); break;

1410

case(BMPTok):

1411

WriteString("BMP "); break;

1412

case(PPMTok):

1413

WriteString("PPM "); break;

1414

case(SUNTok):

1415

WriteString("SUN "); break;

1416

case(SUNRLETok):

1417

WriteString("SUNRLE "); break;

1418

case(PICTTok):

1419

WriteString("PICT "); break;

1420

case(IRISTok):

1421

WriteString("IRIS "); break;

1422

case(EPSFTok):

1423

WriteString("EPSF "); break;

1424

case(MonoPSTok):

1425

WriteString("MONOPS "); break;

1426

case(VectPSTok):

1427

WriteString("VECTPS "); break;

1428

case(Raster3DTok):

1429

WriteString("R3D "); break;

1430

1431

case(RasMolTok):

1432

case(ScriptTok):

1433

WriteString("SCRIPT "); break;

1434

case(KinemageTok):

1435

WriteString("KINEMAGE "); break;

1436

case(MolScriptTok):

1437

WriteString("MOLSCRIPT "); break;

1438

case(POVRayTok):

1439

WriteString("POVRAY "); break;

1440

case(POVRay3Tok):

1441

WriteString("POVRAY3 "); break;

1442

case(PhiPsiTok):

1443

WriteString("PHIPSI "); break;

1444

case(RamachanTok):

1445

WriteString("RAMACHAN "); break;

1446

case(RamPrintTok):

1447

WriteString("RPP "); break;

1448

case(VRMLTok):

1449

WriteString("VRML ");

1450

if (PlaySubOption == MirrorTok) WriteString("MIRROR ");

1451

if (PlaySubOption == RotateTok) WriteString("ROTATE ");

1452

break;

1453

1454

}

1455

WriteString(param);

1456

WriteString("\n");

1457

}

1458

return;

1459

}

1460

1461

void WriteMovieFrame( void ) {

1462

int millisec;

1463

char param[1024];

1464

millisec = RecordFrom + 1000.*((double)record_frame[0])/record_fps;

1465

if (RecordTemplate[0] == '\0'

1466

|| (millisec > RecordMaxMS && RecordMaxMS > 1.)

1467

|| (RecordUntil >= RecordFrom

1468

&& millisec > RecordUntil)) {

1469

RecordPause = True;

1470

} else {

1471

if (RecordMaxMS == 1.) {

1472

sprintf(param,RecordTemplate);

1473

} else{

1474

sprintf(param,RecordTemplate,millisec);

1475

}

1476

if (!IsMoleculeToken(RecordOption)) {

1477

WriteImageFile( param, RecordOption, RecordSubOption );

1478

} else switch(RecordOption) {

1479

case(NMRPDBTok):

1480

case(PDBTok): SavePDBMolecule(param); break;

1481

case(MDLTok): SaveMDLMolecule(param); break;

1482

case(XYZTok): SaveXYZMolecule(param); break;

1483

case(CIFTok): SaveCIFMolecule(param); break;

1484

case(AlchemyTok): SaveAlchemyMolecule(param);

1485

break;

1486

}

1487

}

1488

return;

1489

}

1490

1491

static int PlayMovieFrame( void ) {

1492

int millisec;

1493

int checkfile;

1494

char param[1024];

1495

FILE * moviefp;

1496

millisec = PlayFrom + 1000.*((double)play_frame[0])/play_fps;

1497

if (PlayTemplate[0] == '\0'

1498

|| (millisec > PlayMaxMS && PlayMaxMS > 1.)

1499

|| (PlayUntil >= PlayFrom

1500

&& millisec > PlayUntil)) {

1501

PlayPause = True;

1502

return 1;

1503

} else {

1504

checkfile = False;

1505

for (play_frame[1] = 0;play_frame[1]<=millisec; play_frame[1]++)

1506

{

1507

if (RecordMaxMS == 1.) {

1508

sprintf(param,PlayTemplate);

1509

} else{

1510

sprintf(param,PlayTemplate,millisec-play_frame[1]);

1511

}

1512

ProcessFileName(param);

1513

moviefp = fopen(DataFileName,"rb");

1514

if (moviefp) {

1515

if (PlayOption == ScriptTok) {

1516

LoadScriptFile(moviefp,DataFileName);

1517

return 0;

1518

}

1519

ZapDatabase();

1520

SwitchMolecule(NumMolecules);

1521

if (!ProcessFile(Tok2Format(PlayOption),False,moviefp)) return -1;

1522

if (Database) {

1523

NumMolecules++;

1524

DrawMoleculeList();

1525

DefaultRepresentation();

1526

}

1527

return 0;

1528

}

1529

}

1530

return -1;

1531

}

1532

}

1533

1534

static void PlayMovie( void ) {

1535

int interactive_save;

1536

int SaveMolecule = MoleculeIndex;

1537

int status;

1538

if ((!IsMoleculeToken(PlayOption) && PlayOption != ScriptTok)

1539

|| NumMolecules >= MAX_MOLECULES ){

1540

CommandError(MsgStrs[ErrBadLoad]);

1541

return;

1542

}

1543

if (FileDepth == -1) ShowPlayCommand();

1544

interactive_save = Interactive;

1545

if (IsMoleculeToken(PlayOption)) {

1546

SwitchMolecule(NumMolecules);

1547

}

1548

while (!PlayPause && PlayTemplate[0]) {

1549

Interactive = False;

1550

status = PlayMovieFrame();

1551

Interactive = interactive_save;

1552

ReDrawFlag |= RFRefresh;

1553

RefreshScreen();

1554

if (status) break;

1555

play_frame[0]++;

1556

}

1557

if (IsMoleculeToken(PlayOption)) {

1558

SwitchMolecule(SaveMolecule);

1559

}

1560

1561

return;

1562

}

1563

1564

1565

/* Convert a Play/Record file name template

1566

The first string of s...s (case insensitive s's or digits) is changed to %.nd where

1567

n is the number of s's. An s in the template can be protected

1568

from this conversion with a backslash. Each % is converted to %%.

1569

1570

*** Warning: if the length of param is K, then the size of the

1571

template must be at least max(1+2*K,3+K)

1572

1573

The result is a conversion string for sprintf */

1574

1575

static int ConvPRTemplate(char * template, const char * param, size_t limit, double *numfiles) {

1576

char c;

1577

int swid;

1578

int cwid;

1579

int ii;

1580

int escape;

1581

char * torig;

1582

1583

torig = template;

1584

escape = 0;

1585

*numfiles = 1.;

1586

while ((c=*param++)) {

1587

if (!escape && c=='\\') {

1588

escape++;

1589

continue;

1590

}

1591

if (escape || (c != 's' && c != 'S' && !(isdigit(c)))){

1592

*template++ = c;

1593

if ( template-torig >= limit ) return -1;

1594

if (c=='%') *template++ = c;

1595

if ( template-torig >= limit ) return -1;

1596

escape = 0;

1597

continue;

1598

}

1599

break;

1600

}

1601

if (c) {

1602

swid = 1;

1603

*numfiles = 10.;

1604

while ((c=*param++)) {

1605

if (c != 's' && c != 'S' && !(isdigit(c))) break;

1606

swid++;

1607

*numfiles *= 10.;

1608

}

1609

*template++='%';

1610

if ( template-torig >= limit ) return -1;

1611

*template++='.';

1612

if ( template-torig >= limit ) return -1;

1613

1614

cwid = 1;

1615

do {

1616

*template = (swid%10)+'0';

1617

swid /= 10;

1618

if (swid) {

1619

if ( template+cwid-torig >= limit ) return -1;

1620

for (ii=0; ii<cwid; ii++) {

1621

template[cwid-ii]=template[cwid-ii-1];

1622

}

1623

cwid++;

1624

}

1625

1626

} while (swid);

1627

template += cwid;

1628

*template++ = 'd';

1629

if ( template-torig >= limit ) return -1;

1630

1631

}

1632

escape=0;

1633

if (c) {

1634

param--;

1635

while ((c=*param++)) {

1636

if (!escape && c=='\\') {

1637

escape++;

1638

continue;

1639

}

1640

escape = 0;

1641

*template++ = c;

1642

if ( template-torig >= limit ) return -1;

1643

if (c=='%') *template++ = c;

1644

if ( template-torig >= limit ) return -1;

1645

}

1646

}

1647

*template++ = '\0';

1648

return 0;

1649

}

1650

1651

1652

/*====================================*/

1653

/* Command Line On-Line Help System */

1654

/*====================================*/

1655

1656

static int PrefixString( char __far *str1, char __far *str2 )

1657

{

1658

while( *str1 )

1659

if( *str1++ != *str2++ )

1660

return False;

1661

return True;

1662

}

1663

1664

static char __far *xfgets( char __far* s, int n, FILE __far *fp )

1665

{

1666

register int i;

1667

register int c;

1668

register char __far *cs;

1669

cs = s;

1670

c = '\0';

1671

for (i = 0; i < n-1; i++)

1672

{

1673

if ((c = fgetc(fp)) == EOF)

1674

{

1675

*cs++ = '\0';

1676

return NULL;

1677

}

1678

if (c == '\r' || c == '\n' || c == '\0') break;

1679

*cs++ = c;

1680

}

1681

if (c == '\r') {

1682

c = getc(fp);

1683

if ( c != '\n' ) ungetc(c,fp);

1684

}

1685

*cs++ = '\n';

1686

*cs++ = '\0';

1687

return s;

1688

}

1689

1690

1691

1692

static HlpEntry __far *EnterHelpInfo( char *text )

1693

{

1694

register HlpEntry __far * __far *tmp;

1695

register HlpEntry __far *ptr;

1696

register int res,len,i;

1697

register char ch;

1698

char keyword[32];

1699

1700

ptr = (void __far*)0;

1701

while( *text && (*text!='\n') )

1702

{ while( *text && (*text!='\n') && (*text==' ') )

1703

text++;

1704

1705

len = 0;

1706

while( *text && (*text!='\n') && (*text!=' ') )

1707

if( len<31 )

1708

{ ch = *text++;

1709

keyword[len++] = ToUpper(ch);

1710

} else text++;

1711

keyword[len]='\0';

1712

1713

if( ptr )

1714

{ tmp = &ptr->info;

1715

ptr = (void __far*)0;

1716

} else tmp = &HelpInfo;

1717

1718

while( *tmp )

1719

{ res = _fstrcmp(keyword,(*tmp)->keyword);

1720

if( res==0 ) /* Exact Match */

1721

{ ptr = *tmp;

1722

break;

1723

} else if( res<0 )

1724

break;

1725

tmp = &(*tmp)->next;

1726

}

1727

1728

if( !ptr )

1729

{ if( !FreeInfo )

1730

{ ptr = (HlpEntry __far*)_fmalloc(HelpPool*sizeof(HlpEntry));

1731

if( !ptr )

1732

RasMolFatalExit(MsgStrs[StrSMem]);

1733

for( i=1; i<HelpPool; i++ )

1734

{ ptr->next = FreeInfo;

1735

FreeInfo = ptr++;

1736

}

1737

} else

1738

{ ptr = FreeInfo;

1739

FreeInfo = ptr->next;

1740

}

1741

1742

ptr->keyword = (char __far*)_fmalloc(len+1);

1743

for( i=0; i<=len; i++ )

1744

ptr->keyword[i] = keyword[i];

1745

1746

ptr->info = (void __far*)0;

1747

ptr->next = *tmp;

1748

ptr->fpos = 0;

1749

*tmp = ptr;

1750

}

1751

}

1752

return ptr;

1753

}

1754

1755

1756

void InitHelpFile( void )

1757

{

1758

register char *src,*dst;

1759

register HlpEntry __far *fix;

1760

register HlpEntry __far *ptr;

1761

register FILE *fp;

1762

register long pos;

1763

char buffer[82];

1764

1765

HelpFileName = "rasmol.hlp";

1766

fp=fopen(HelpFileName,"rb");

1767

1768

if( !fp )

1769

{ src = (char*)getenv("RASMOLPATH");

1770

if( src )

1771

{ HelpFileName = dst = HelpFileBuf;

1772

while( *src )

1773

*dst++ = *src++;

1774

#ifndef VMS

1775

if( (dst!=HelpFileBuf) && (*(dst-1)!=DirChar) )

1776

*dst++ = DirChar;

1777

#endif

1778

1779

strcpy(dst,"rasmol.hlp");

1780

fp = fopen(HelpFileName,"rb");

1781

}

1782

}

1783

1784

#ifdef RASMOLDIR

1785

if( !fp )

1786

{ src = RASMOLDIR;

1787

HelpFileName = dst = HelpFileBuf;

1788

while( *src )

1789

*dst++ = *src++;

1790

#ifndef VMS

1791

if( (dst!=HelpFileBuf) && (*(dst-1)!=DirChar) )

1792

*dst++ = DirChar;

1793

#endif

1794

1795

src = "rasmol.hlp";

1796

while( (*dst++ = *src++) );

1797

fp = fopen(HelpFileName,"rb");

1798

}

1799

#endif

1800

1801

if( !fp )

1802

{ InvalidateCmndLine();

1803

WriteString(MsgStrs[StrHFil]);

1804

HelpFileName = NULL;

1805

return;

1806

}

1807

1808

pos = 0;

1809

xfgets(buffer,80,fp);

1810

while( !feof(fp) )

1811

{ fix = (void __far*)0;

1812

while( *buffer=='?' )

1813

{ ptr = EnterHelpInfo(buffer+1);

1814

if( ptr )

1815

{ ptr->info = fix;

1816

fix = ptr;

1817

}

1818

1819

pos = ftell(fp);

1820

if( !xfgets(buffer,80,fp) )

1821

break;

1822

}

1823

1824

while( fix )

1825

{ ptr = fix->info;

1826

fix->info = (void __far*)0;

1827

fix->fpos = pos;

1828

fix = ptr;

1829

}

1830

1831

while( xfgets(buffer,80,fp) )

1832

if( *buffer=='?' )

1833

break;

1834

}

1835

fclose(fp);

1836

}

1837

1838

1839

static void FindHelpInfo( void )

1840

{

1841

register HlpEntry __far * __far *tmp;

1842

register HlpEntry __far *ptr;

1843

register int res,len;

1844

register long pos;

1845

register FILE *fp;

1846

register char ch;

1847

char keyword[32];

1848

char buffer[82];

1849

1850

while( *TokenPtr && (*TokenPtr==' ') )

1851

TokenPtr++;

1852

1853

if( *TokenPtr )

1854

{ ptr = NULL;

1855

do {

1856

len = 0;

1857

while( *TokenPtr && (*TokenPtr!=' ') )

1858

if( len<31 )

1859

{ ch = *TokenPtr++;

1860

keyword[len++] = ToUpper(ch);

1861

} else TokenPtr++;

1862

keyword[len]='\0';

1863

1864

if( ptr )

1865

{ tmp = &ptr->info;

1866

ptr = (void __far*)0;

1867

} else tmp = &HelpInfo;

1868

1869

while( *tmp )

1870

{ res = _fstrcmp(keyword,(*tmp)->keyword);

1871

if( res<0 )

1872

{ if( PrefixString(keyword,(*tmp)->keyword) )

1873

{ ptr = *tmp;

1874

if( ptr->next &&

1875

PrefixString(keyword,ptr->next->keyword) )

1876

{ InvalidateCmndLine();

1877

WriteString(MsgStrs[StrHTop]);

1878

return;

1879

} else break;

1880

} else break;

1881

} else if( res==0 )

1882

{ ptr = *tmp;

1883

break;

1884

}

1885

tmp = &(*tmp)->next;

1886

}

1887

1888

while( *TokenPtr && (*TokenPtr==' ') )

1889

TokenPtr++;

1890

} while( *TokenPtr && ptr );

1891

1892

if( !ptr || !ptr->fpos )

1893

{ InvalidateCmndLine();

1894

WriteString(MsgStrs[StrHNone]);

1895

return;

1896

} else pos=ptr->fpos;

1897

} else pos=0;

1898

1899

1900

if( !(fp=fopen(HelpFileName,"rb")) )

1901

RasMolFatalExit(MsgStrs[StrHROpn]);

1902

1903

InvalidateCmndLine();

1904

1905

fseek(fp,pos,SEEK_SET);

1906

while( xfgets(buffer,80,fp) )

1907

if( *buffer!='?' )

1908

{ WriteString(buffer);

1909

} else break;

1910

fclose(fp);

1911

}

1912

1913

1914

1915

/*=================================*/

1916

/* Command Line Lexical Analysis */

1917

/*=================================*/

1918

1919

static int FetchToken( void )

1920

{

1921

register char ch;

1922

1923

CurToken = 0;

1924

ch = *TokenPtr++;

1925

while( ch && (ch!='#') )

1926

{ if( isspace(ch) )

1927

{ ch = *TokenPtr++;

1928

continue;

1929

}

1930

1931

TokenStart = TokenPtr-1;

1932

if( isalpha(ch) )

1933

{ TokenLength = 1;

1934

*TokenIdent = ToUpper(ch);

1935

while( IsIdentChar(*TokenPtr) && (TokenLength<32) )

1936

{ ch = *TokenPtr++;

1937

TokenIdent[TokenLength++] = ToUpper(ch);

1938

}

1939

if( TokenLength==32 )

1940

{ CommandError(MsgStrs[StrILong]);

1941

return(0);

1942

} else TokenIdent[TokenLength] = '\0';

1943

return( CurToken = LookUpKeyword(TokenIdent) );

1944

1945

} else if( isdigit(ch) )

1946

{ TokenValue = ch-'0';

1947

while( isdigit(*TokenPtr) )

1948

TokenValue = 10*TokenValue + (*TokenPtr++)-'0';

1949

return( CurToken = NumberTok );

1950

1951

} else if( (ch=='\'') || (ch=='\"') || (ch=='`') )

1952

{ TokenLength = 0;

1953

while( *TokenPtr && (TokenLength<128) && (*TokenPtr!=ch) )

1954

TokenIdent[TokenLength++] = *TokenPtr++;

1955

1956

if( ch != *TokenPtr )

1957

{ if( *TokenPtr )

1958

{ CommandError(MsgStrs[StrCTerm]);

1959

} else CommandError(MsgStrs[StrCLong]);

1960

return( 0 );

1961

} else TokenPtr++;

1962

1963

TokenIdent[TokenLength]='\0';

1964

return( CurToken = StringTok );

1965

} else if( ispunct(ch) )

1966

return( CurToken = ch );

1967

1968

ch = *TokenPtr++;

1969

}

1970

TokenPtr--;

1971

return 0;

1972

}

1973

1974

1975

static int NextIf( int tok, int err )

1976

{

1977

if( FetchToken() != tok )

1978

{ CommandError(MsgStrs[err]);

1979

return True;

1980

} else return False;

1981

}

1982

1983

1984

static void FetchFloat( Long value, int scale )

1985

{

1986

register int count;

1987

register int mant;

1988

1989

if( !value && !isdigit(*TokenPtr) )

1990

{ CommandError(MsgStrs[StrFNum]);

1991

TokenValue = 0;

1992

return;

1993

}

1994

1995

mant = 0;

1996

count = 1;

1997

while( isdigit(*TokenPtr) )

1998

{ if( count < scale )

1999

{ mant = 10*mant + (*TokenPtr-'0');

2000

count *= 10;

2001

}

2002

TokenPtr++;

2003

}

2004

2005

mant = (scale*mant)/count;

2006

TokenValue = value*scale + mant;

2007

}

2008

2009

static void FetchBracketedTriple(Long Triple[3]) {

2010

int index, neg;

2011

for (index = 0; index < 3; index++) {

2012

FetchToken();

2013

Triple[index] = 0;

2014

if (CurToken == '-') {

2015

FetchToken();

2016

neg = True;

2017

} else {

2018

neg = False;

2019

}

2020

if (CurToken == NumberTok) {

2021

if (*TokenPtr=='.') {

2022

TokenPtr++;

2023

FetchFloat(TokenValue,250);

2024

}

2025

} else if( CurToken=='.' ) {

2026

FetchFloat(0,250);

2027

} else CommandError(MsgStrs[ErrNotNum]);

2028

Triple[index] = neg?(-TokenValue):TokenValue;

2029

FetchToken();

2030

if( !(CurToken == ',' && index < 2) &&

2031

!(CurToken == ']' && index == 2 )) {

2032

CommandError(MsgStrs[ErrSyntax]);

2033

return;

2034

}

2035

}

2036

return;

2037

}

2038

2039

2040

static int ParseColour( void )

2041

{

2042

register RGBStruct *rgb;

2043

2044

if( IsColourToken(CurToken) )

2045

{ rgb = ColourTable + Token2Colour(CurToken);

2046

RVal = rgb->red;

2047

GVal = rgb->grn;

2048

BVal = rgb->blu;

2049

return True;

2050

2051

} else if( CurToken == '[' )

2052

{ RVal = GVal = BVal = 0;

2053

2054

if( NextIf(NumberTok,ErrNotNum) )

2055

{ return False;

2056

} else if( TokenValue>255 )

2057

{ CommandError(MsgStrs[ErrBigNum]);

2058

return False;

2059

} else RVal = (int)TokenValue;

2060

2061

if( NextIf(',',ErrNotSep) )

2062

return False;

2063

2064

if( NextIf(NumberTok,ErrNotNum) )

2065

{ return False;

2066

} else if( TokenValue>255 )

2067

{ CommandError(MsgStrs[ErrBigNum]);

2068

return False;

2069

} else GVal = (int)TokenValue;

2070

2071

if( NextIf(',',ErrNotSep) )

2072

return False;

2073

2074

if( NextIf(NumberTok,ErrNotNum) )

2075

{ return False;

2076

} else if( TokenValue>255 )

2077

{ CommandError(MsgStrs[ErrBigNum]);

2078

return False;

2079

} else BVal = (int)TokenValue;

2080

2081

return !NextIf(']',ErrNotBrac);

2082

2083

} else if( !CurToken && (*TokenPtr=='#') )

2084

{ RVal = 0;

2085

GVal = 0;

2086

BVal = 0;

2087

2088

} else if( CurToken == IdentTok )

2089

if( Interactive )

2090

return LookUpColour(TokenIdent,&RVal,&GVal,&BVal);

2091

2092

return False;

2093

}

2094

2095

2096

static Expr *ParseRange( int neg )

2097

{

2098

register Expr *tmp1,*tmp2;

2099

register char ch;

2100

2101

tmp1 = AllocateNode();

2102

tmp1->type = OpLftProp|OpRgtVal;

2103

tmp1->rgt.val = neg? -(int)TokenValue : (int)TokenValue;

2104

tmp1->lft.val = PropResId;

2105

2106

if( *TokenPtr == '-' )

2107

{ TokenPtr++;

2108

neg = (*TokenPtr=='-');

2109

if( neg ) TokenPtr++;

2110

FetchToken();

2111

2112

if( CurToken != NumberTok )

2113

{ CommandError(MsgStrs[ErrNotNum]);

2114

DeAllocateExpr( tmp1 );

2115

return( (Expr*)NULL );

2116

}

2117

2118

tmp1->type |= OpMoreEq;

2119

tmp2 = AllocateNode();

2120

tmp2->rgt.ptr = tmp1;

2121

tmp2->type = OpAnd;

2122

2123

tmp1 = AllocateNode();

2124

tmp1->type = OpLftProp|OpRgtVal|OpLessEq;

2125

tmp1->rgt.val = neg? -(int)TokenValue : (int)TokenValue;

2126

tmp1->lft.val = PropResId;

2127

tmp2->lft.ptr = tmp1;

2128

tmp1 = tmp2;

2129

} else tmp1->type |= OpEqual;

2130

2131

if( *TokenPtr == ':' )

2132

TokenPtr++;

2133

2134

ch = *TokenPtr;

2135

if( isalnum(ch) )

2136

{ ch = ToUpper(ch);

2137

TokenPtr++;

2138

2139

tmp2 = AllocateNode();

2140

tmp2->type = OpAnd;

2141

tmp2->rgt.ptr = tmp1;

2142

2143

tmp1 = AllocateNode();

2144

tmp1->type = OpEqual | OpLftProp | OpRgtVal;

2145

tmp1->lft.val = PropChain;

2146

tmp1->rgt.val = ch;

2147

2148

tmp2->lft.ptr = tmp1;

2149

tmp1 = tmp2;

2150

} else if( (ch=='?') || (ch=='%') || (ch=='*') )

2151

TokenPtr++;

2152

2153

FetchToken();

2154

return tmp1;

2155

}

2156

2157

2158

static Expr *ParseExpression( int level )

2159

{

2160

register Expr *tmp1,*tmp2;

2161

register int done, pred = 0;

2162

register int neg;

2163

2164

switch( level )

2165

{ case(0): /* Disjunctions */

2166

tmp1 = ParseExpression(1);

2167

while( (CurToken==OrTok) || (CurToken=='|') ||

2168

(CurToken==',') )

2169

{ if( CurToken=='|' )

2170

{ if( FetchToken()=='|' )

2171

FetchToken();

2172

} else FetchToken();

2173

2174

tmp2 = AllocateNode();

2175

tmp2->type = OpOr;

2176

tmp2->lft.ptr = tmp1;

2177

tmp2->rgt.ptr = NULL;

2178

if( !(tmp1=ParseExpression(1)) )

2179

{ DeAllocateExpr(tmp2);

2180

return( tmp1 );

2181

}

2182

tmp2->rgt.ptr = tmp1;

2183

tmp1 = tmp2;

2184

}

2185

return( tmp1 );

2186

2187

case(1): /* Conjunctions */

2188

tmp1 = ParseExpression(2);

2189

while( (CurToken==AndTok) || (CurToken==YTok) || (CurToken=='&') )

2190

{ if( CurToken=='&' )

2191

{ if( FetchToken()=='&' )

2192

FetchToken();

2193

} else FetchToken();

2194

2195

tmp2 = AllocateNode();

2196

tmp2->type = OpAnd;

2197

tmp2->lft.ptr = tmp1;

2198

tmp2->rgt.ptr = NULL;

2199

if( !(tmp1=ParseExpression(2)) )

2200

{ DeAllocateExpr(tmp2);

2201

return( tmp1 );

2202

}

2203

tmp2->rgt.ptr = tmp1;

2204

tmp1 = tmp2;

2205

}

2206

return( tmp1 );

2207

2208

case(2): /* Primitives */

2209

if( IsPredTok(CurToken) || (CurToken==BackboneTok) )

2210

{ switch( CurToken )

2211

{ case(HelixTok): if( Info.helixcount < 0 )

2212

DetermineStructure(False);

2213

pred = PredHelix;

2214

break;

2215

case(SheetTok): if( Info.laddercount < 0 )

2216

DetermineStructure(False);

2217

pred = PredSheet;

2218

break;

2219

case(TurnTok): if( Info.turncount < 0 )

2220

DetermineStructure(False);

2221

pred = PredTurn;

2222

break;

2223

case(CystineTok): if( Info.ssbondcount < 0 )

2224

FindDisulphideBridges();

2225

pred = PredCystine;

2226

break;

2227

case(CisBondedTok):if( Info.cisbondcount<0 )

2228

FindCisBonds();

2229

pred = PredCisBond;

2230

break;

2231

case(BackboneTok): pred = PredMainChain; break;

2232

case(SelectedTok): pred = PropSelect; break;

2233

default: pred = PredAbsChr(PredTokOrd(CurToken));

2234

}

2235

2236

tmp1 = AllocateNode();

2237

tmp1->type = OpConst|OpLftProp|OpRgtVal;

2238

tmp1->lft.val = pred;

2239

FetchToken();

2240

return( tmp1 );

2241

2242

} else if( IsPropTok(CurToken) )

2243

{ tmp1 = AllocateNode();

2244

tmp1->type = OpLftProp|OpRgtVal;

2245

switch( CurToken )

2246

{ case(TemperatureTok): pred = PropTemp; break;

2247

case(RadiusTok): pred = PropRad; break;

2248

case(AtomNoTok): pred = PropIdent; break;

2249

case(ElemNoTok): pred = PropElemNo; break;

2250

case(ResNoTok): pred = PropResId; break;

2251

case(ModelTok): pred = PropModel; break;

2252

case(AltlTok): pred = PropAltl; break;

2253

}

2254

tmp1->lft.val = pred;

2255

2256

FetchToken();

2257

if( CurToken=='=' )

2258

{ tmp1->type |= OpEqual;

2259

if( FetchToken()=='=' )

2260

FetchToken();

2261

} else if( CurToken=='<' )

2262

{ FetchToken();

2263

if( CurToken=='>' )

2264

{ tmp1->type |= OpNotEq;

2265

FetchToken();

2266

} else if( CurToken=='=' )

2267

{ tmp1->type |= OpLessEq;

2268

FetchToken();

2269

} else tmp1->type |= OpLess;

2270

} else if( CurToken=='>' )

2271

{ if( FetchToken()=='=' )

2272

{ tmp1->type |= OpMoreEq;

2273

FetchToken();

2274

} else tmp1->type |= OpMore;

2275

} else if( (CurToken=='!') || (CurToken=='/') )

2276

{ if( NextIf('=',ErrBadExpr) )

2277

{ DeAllocateExpr( tmp1 );

2278

return( (Expr*)NULL );

2279

} else tmp1->type |= OpNotEq;

2280

FetchToken();

2281

} else

2282

{ CommandError(MsgStrs[ErrBadExpr]);

2283

DeAllocateExpr( tmp1 );

2284

return( (Expr*)NULL );

2285

}

2286

2287

2288

if( CurToken == '-' )

2289

{ FetchToken();

2290

neg = True;

2291

} else neg = False;

2292

2293

if( CurToken!=NumberTok )

2294

{ CommandError(MsgStrs[ErrNotNum]);

2295

DeAllocateExpr( tmp1 );

2296

return( (Expr*)NULL );

2297

}

2298

2299

if( neg )

2300

{ tmp1->rgt.val = -(int)TokenValue;

2301

} else tmp1->rgt.val = (int)TokenValue;

2302

FetchToken();

2303

return( tmp1 );

2304

2305

} else switch( CurToken )

2306

{ case('('): FetchToken();

2307

if( !(tmp1=ParseExpression(0)) )

2308

return( (Expr*)NULL );

2309

2310

if( CurToken!=')' )

2311

{ CommandError(MsgStrs[ErrParen]);

2312

DeAllocateExpr( tmp1 );

2313

return( (Expr*)NULL );

2314

}

2315

FetchToken();

2316

return(tmp1);

2317

2318

case('!'): case('~'):

2319

case(NotTok): FetchToken();

2320

if( !(tmp1=ParseExpression(2)) )

2321

return( (Expr*)NULL );

2322

2323

tmp2 = AllocateNode();

2324

tmp2->type = OpNot | OpRgtVal;

2325

tmp2->lft.ptr = tmp1;

2326

return( tmp2 );

2327

2328

case('-'): if( NextIf(NumberTok,ErrNotNum) )

2329

return( (Expr*)NULL );

2330

return( ParseRange(True) );

2331

2332

case(NumberTok):

2333

return( ParseRange(False) );

2334

2335

case(WithinTok):

2336

if( NextIf('(',ErrFunc) )

2337

return( (Expr*)NULL );

2338

2339

FetchToken();

2340

if( CurToken==NumberTok )

2341

{ if( *TokenPtr=='.' )

2342

{ TokenPtr++;

2343

FetchFloat(TokenValue,250);

2344

}

2345

} else if( CurToken!='.' )

2346

{ CommandError(MsgStrs[ErrNotNum]);

2347

return( (Expr*)NULL );

2348

} else FetchFloat(0,250);

2349

2350

if( TokenValue>10000 )

2351

{ CommandError(MsgStrs[ErrBigNum]);

2352

return( (Expr*)NULL );

2353

} else pred = (int)TokenValue;

2354

if( NextIf(',',ErrNotSep) )

2355

return( (Expr*)NULL );

2356

2357

FetchToken();

2358

if( !(tmp1=ParseExpression(0)) )

2359

return( (Expr*)NULL );

2360

2361

if( CurToken!=')' )

2362

{ CommandError(MsgStrs[ErrParen]);

2363

DeAllocateExpr( tmp1 );

2364

return( (Expr*)NULL );

2365

}

2366

2367

FetchToken();

2368

if( !pred )

2369

return( tmp1 );

2370

2371

tmp2 = AllocateNode();

2372

tmp2->type = OpWithin;

2373

tmp2->lft.limit = (Long)pred*pred;

2374

tmp2->rgt.set = BuildAtomSet(tmp1);

2375

DeAllocateExpr(tmp1);

2376

return( tmp2 );

2377

2378

default: if( CurToken==IdentTok )

2379

{ tmp1 = LookUpSetExpr(TokenIdent);

2380

if( !tmp1 )

2381

tmp1 = LookUpElement(TokenIdent);

2382

2383

if( tmp1 )

2384

{ FetchToken();

2385

return(tmp1);

2386

}

2387

}

2388

2389

TokenPtr = TokenStart;

2390

done = ParsePrimitiveExpr(&TokenPtr);

2391

FetchToken();

2392

2393

if( !done )

2394

{ CommandError(MsgStrs[ErrBadExpr]);

2395

DeAllocateExpr( QueryExpr );

2396

return( (Expr*)NULL );

2397

} else return( QueryExpr );

2398

}

2399

}

2400

return (Expr*)NULL;

2401

}

2402

2403

2404

2405

/*======================================*/

2406

/* RasMol Command Parsing & Execution */

2407

/* Commands listed alphabetically */

2408

/*======================================*/

2409

2410

static void ExecuteAxesCommand( void )

2411

{

2412

FetchToken();

2413

if( !CurToken || (CurToken==FalseTok) )

2414

{ ReDrawFlag |= RFRefresh;

2415

DrawAxes = False;

2416

} else if( CurToken == TrueTok )

2417

{ ReDrawFlag |= RFRefresh;

2418

DrawAxes = True;

2419

} else CommandError(MsgStrs[ErrBadOpt]);

2420

}

2421

2422

2423

static void ExecuteBoundBoxCommand( void )

2424

{

2425

FetchToken();

2426

if( !CurToken || (CurToken==FalseTok) )

2427

{ ReDrawFlag |= RFRefresh;

2428

DrawBoundBox = False;

2429

} else if( CurToken == TrueTok )

2430

{ ReDrawFlag |= RFRefresh;

2431

DrawBoundBox = True;

2432

} else CommandError(MsgStrs[ErrBadOpt]);

2433

}

2434

2435

2436

static void ExecuteCentreCommand( void )

2437

{

2438

register Real x, y, z;

2439

register Long count;

2440

int xlatecen;

2441

2442

xlatecen = XlateCen;

2443

2444

FetchToken();

2445

if( !CurToken || (CurToken==AllTok) )

2446

{ CentreTransform(0,0,0,xlatecen);

2447

return;

2448

}

2449

2450

if( (CurToken==CentreTok) || (CurToken==TranslateTok) ) {

2451

xlatecen = XlateCen = (CurToken==TranslateTok)?True:False;

2452

FetchToken();

2453

if ( !CurToken ) return;

2454

if ( CurToken==AllTok ) {

2455

CentreTransform(0,0,0,xlatecen);

2456

return;

2457

}

2458

}

2459

2460

2461

/* Check for Centre [CenX, CenY, CenZ] syntax */

2462

2463

if ( CurToken == '[' )

2464

{ Long CenV[3];

2465

2466

2467

/* int icen, negcen;

2468

2469

for (icen = 0; icen < 3; icen++)

2470

{ FetchToken();

2471

CenV[icen] = 0;

2472

if( CurToken == '-' )

2473

{ FetchToken();

2474

negcen = True;

2475

} else negcen = False;

2476

if( CurToken == NumberTok )

2477

{ if (negcen )

2478

{ CenV[icen] = -TokenValue;

2479

} else CenV[icen] = TokenValue;

2480

FetchToken();

2481

}

2482

if( !(CurToken == ',' && icen < 2) &&

2483

!(CurToken == ']' && icen == 2 ))

2484

{ CommandError(MsgStrs[ErrSyntax]);

2485

return;

2486

}

2487

}

2488

*/

2489

2490

FetchBracketedTriple(CenV);

2491

2492

#ifdef INVERT

2493

CenV[1] = -CenV[1];

2494

#endif

2495

FetchToken();

2496

if( CurToken ) {

2497

if ( (CurToken==CentreTok) || (CurToken==TranslateTok) ) {

2498

xlatecen = (CurToken==TranslateTok)?True:False;

2499

} else {

2500

CommandError(MsgStrs[ErrSyntax]);

2501

return;

2502

}

2503

}

2504

CentreTransform(CenV[0],CenV[1],-CenV[2],xlatecen);

2505

return;

2506

}

2507

2508

QueryExpr = ParseExpression(0);

2509

if( !QueryExpr ) return;

2510

2511

if( CurToken )

2512

{ CommandError(MsgStrs[ErrSyntax]);

2513

DeAllocateExpr(QueryExpr);

2514

return;

2515

}

2516

2517

/* CentreZoneExpr(QueryExpr); */

2518

if( !Database ) return;

2519

2520

count = 0;

2521

x = y = z = 0.0;

2522

for( QChain=Database->clist; QChain; QChain=QChain->cnext )

2523

for( QGroup=QChain->glist; QGroup; QGroup=QGroup->gnext )

2524

for( QAtom=QGroup->alist; QAtom; QAtom=QAtom->anext )

2525

if( EvaluateExpr(QueryExpr) )

2526

{ x += (Real)(QAtom->xorg+QAtom->fxorg);

2527

y += (Real)(QAtom->yorg+QAtom->fyorg);

2528

z += (Real)(QAtom->zorg+QAtom->fzorg);

2529

count++;

2530

}

2531

2532

if( count )

2533

{ FetchToken();

2534

if( CurToken ) {

2535

if ( (CurToken==CentreTok) || (CurToken==TranslateTok) ) {

2536

xlatecen = (CurToken==TranslateTok)?True:False;

2537

} else {

2538

CommandError(MsgStrs[ErrSyntax]);

2539

return;

2540

}

2541

}

2542

CentreTransform((Long)(x/count),(Long)(y/count),(Long)(z/count),xlatecen);

2543

} else

2544

{ InvalidateCmndLine();

2545

WriteString(MsgStrs[StrCent]);

2546

}

2547

DeAllocateExpr(QueryExpr);

2548

}

2549

2550

2551

static void ExecuteClipboardCommand( void )

2552

{

2553

if( !ClipboardImage() )

2554

{ InvalidateCmndLine();

2555

WriteString(MsgStrs[StrCClip]);

2556

}

2557

}

2558

2559

2560

static void ExecuteLoadCommand( void )

2561

{

2562

register int format;

2563

register int info;

2564

register FILE *fp;

2565

int checkfile = False;

2566

2567

FetchToken();

2568

format = FormatPDB;

2569

if( !*TokenPtr || *TokenPtr==' ' )

2570

{ if( IsMoleculeToken(CurToken) )

2571

{ format = Tok2Format(CurToken);

2572

FetchToken();

2573

} else if( CurToken == DotsTok )

2574

{ format = FormatDots;

2575

FetchToken();

2576

} else if (CurToken == MapTok)

2577

{ format = FormatMap;

2578

if (!Database){

2579

CommandError(MsgStrs[ErrBadMolDB]);

2580

return;

2581

}

2582

FetchToken();

2583

}

2584

}

2585

2586

if( !CurToken )

2587

{ CommandError(MsgStrs[ErrFilNam]);

2588

return;

2589

}

2590

/*

2591

#ifdef STRICT

2592

if( (CurToken!=StringTok) && (CurToken!=IdentTok) )

2593

{ CommandError(MsgStrs[ErrFilNam]);

2594

return;

2595

}

2596

#endif

2597

*/

2598

info = (FileDepth == -1);

2599

if( IsMoleculeFormat(format) )

2600

{ if( NumMolecules >= MAX_MOLECULES )

2601

{ CommandError(MsgStrs[ErrBadLoad]);

2602

return;

2603

}

2604

2605

if( CurToken==InLineTok )

2606

{ if( (FileDepth!=-1) && LineStack[FileDepth] )

2607

{ DivertToData( format, info );

2608

} else CommandError(MsgStrs[ErrOutScrpt]);

2609

} else if( CurToken==StringTok )

2610

{ checkfile = FetchFile(format,info,TokenIdent);

2611

} else checkfile = FetchFile(format,info,TokenStart);

2612

2613

/* don't color the molecule unless it's actually loaded! */

2614

if (checkfile == True)

2615

DefaultRepresentation();

2616

} else /* format == FormatDots || format == FormatMap */

2617

{ if( !Database )

2618

{ CommandError(MsgStrs[ErrBadMolDB]);

2619

return;

2620

}

2621

2622

if( CurToken==StringTok )

2623

{ ProcessFileName(TokenIdent);

2624

} else ProcessFileName(TokenStart);

2625

2626

if( !(fp=fopen(DataFileName,"rb")) )

2627

{ CommandError( (char*)NULL );

2628

WriteString(MsgStrs[StrDFile]);

2629

WriteString(DataFileName);

2630

WriteString("'!\n");

2631

return;

2632

} else if (format == FormatDots) {

2633

LoadDotsFile(fp,info);

2634

fclose(fp);

2635

}

2636

#ifdef USE_CBFLIB

2637

else { /* format == FormatMap */

2638

if(LoadCCP4MapFile(fp,info, -1)) {

2639

if( !(fp=fopen(DataFileName,"rb")) ) {

2640

CommandError( (char*)NULL );

2641

WriteString(MsgStrs[StrDFile]);

2642

WriteString(DataFileName);

2643

WriteString("'!\n");

2644

return;

2645

} else if (LoadCBFMapFile(fp,info,-1)) {

2646

CommandError( (char*)NULL );

2647

WriteString(MsgStrs[StrErrFile]);

2648

WriteString(DataFileName);

2649

WriteString("'!\n");

2650

return;

2651

}

2652

}

2653

ReDrawFlag |= RFInitial|RFColour;

2654

}

2655

#endif

2656

}

2657

CurToken = 0;

2658

}

2659

2660

2661

static void ExecutePauseCommand( void )

2662

{

2663

if( FileDepth == -1 )

2664

{ CommandError(MsgStrs[ErrOutScrpt]);

2665

return;

2666

}

2667

2668

/* Ignore Pause Commands via IPC! */

2669

if( LineStack[FileDepth] )

2670

{ CommandActive = True;

2671

IsPaused = True;

2672

2673

#ifdef MSWIN

2674

/* Disable Drag & Drop! */

2675

DragAcceptFiles(CanvWin,FALSE);

2676

#endif

2677

}

2678

2679

ReDrawFlag |= RFRefresh;

2680

}

2681

2682

2683

static void ExecutePickingCommand( void )

2684

{

2685

switch( FetchToken() )

2686

{ case(TrueTok): case(0):

2687

case(IdentifyTok): SetPickMode(PickIdent); break;

2688

case(FalseTok):

2689

case(NoneTok): SetPickMode(PickNone); break;

2690

case(LabelTok): SetPickMode(PickLabel); break;

2691

case(DistanceTok): SetPickMode(PickDist); break;

2692

case(AngleTok): SetPickMode(PickAngle); break;

2693

case(TorsionTok): SetPickMode(PickTorsn); break;

2694

case(MonitorTok): SetPickMode(PickMonit); break;

2695

case(CentreTok): SetPickMode(PickCentr); break;

2696

case(OriginTok): SetPickMode(PickOrign); break;

2697

case(CoordTok): SetPickMode(PickCoord); break;

2698

case(AtomTok): SetPickMode(PickAtom); break;

2699

case(GroupTok): SetPickMode(PickGroup); break;

2700

case(ChainTok): SetPickMode(PickChain); break;

2701

case(BondTok): SetPickMode(PickBond); break;

2702

default: CommandError(MsgStrs[ErrBadOpt]);

2703

}

2704

}

2705

2706

2707

static void ExecutePrintCommand( void )

2708

{

2709

if( !PrintImage() )

2710

{ InvalidateCmndLine();

2711

WriteString(MsgStrs[StrNPrint]);

2712

}

2713

}

2714

2715

2716

static void ExecuteTitleCommand( void )

2717

{

2718

FetchToken();

2719

if( !CurToken )

2720

{ char VersionStr[50];

2721

2722

sprintf (VersionStr,"RasMol Version %s", VERSION);

2723

SetCanvasTitle(VersionStr);

2724

} else if( CurToken == StringTok )

2725

{ SetCanvasTitle(TokenIdent);

2726

} else SetCanvasTitle(TokenStart);

2727

CurToken = 0;

2728

}

2729

2730

2731

static void ExecuteUnitCellCommand( void )

2732

{

2733

FetchToken();

2734

if( !CurToken || (CurToken==FalseTok) )

2735

{ ReDrawFlag |= RFRefresh;

2736

DrawUnitCell = False;

2737

} else if( CurToken == TrueTok )

2738

{ ReDrawFlag |= RFRefresh;

2739

DrawUnitCell = True;

2740

} else CommandError(MsgStrs[ErrBadOpt]);

2741

}

2742

2743

2744

2745

/*=======================================*/

2746

/* Generic Command Parsing & Execution */

2747

/*=======================================*/

2748

2749

static void ExecuteSetCommand( void )

2750

{

2751

register int option;

2752

char buffer[50];

2753

2754

switch( FetchToken() )

2755

{ case(SlabTok):

2756

case(SlabModeTok):

2757

option = -1;

2758

FetchToken();

2759

if( CurToken==RejectTok )

2760

{ option = SlabReject;

2761

} else if( CurToken==HalfTok )

2762

{ option = SlabHalf;

2763

} else if( CurToken==HollowTok )

2764

{ option = SlabHollow;

2765

} else if( CurToken==SolidTok )

2766

{ option = SlabClose;

2767

} else if( CurToken==SectionTok )

2768

option = SlabSection;

2769

2770

if( option != -1 )

2771

{ if( UseSlabPlane && (SlabMode!=option) )

2772

ReDrawFlag |= RFRefresh;

2773

SlabMode = option;

2774

} else CommandError(MsgStrs[ErrBadOpt]);

2775

break;

2776

2777

case(ShadowTok):

2778

FetchToken();

2779

if( CurToken==TrueTok )

2780

{ UseShadow = True;

2781

ReviseInvMatrix();

2782

VoxelsClean = False;

2783

UseSlabPlane = False;

2784

UseDepthPlane = False;

2785

ReDrawFlag |= RFRefresh;

2786

ReAllocBuffers();

2787

} else if( CurToken==FalseTok )

2788

{ ReDrawFlag |= RFRefresh;

2789

UseShadow = False;

2790

} else CommandError(MsgStrs[ErrBadOpt]);

2791

break;

2792

2793

case(SpecularTok):

2794

FetchToken();

2795

if( CurToken==TrueTok )

2796

{ FakeSpecular = True;

2797

ReDrawFlag |= RFColour;

2798

} else if( CurToken==FalseTok )

2799

{ FakeSpecular = False;

2800

ReDrawFlag |= RFColour;

2801

} else CommandError(MsgStrs[ErrBadOpt]);

2802

break;

2803

2804

case(SpecPowerTok):

2805

FetchToken();

2806

if( !CurToken )

2807

{ SpecPower = 8;

2808

ReDrawFlag |= RFColour;

2809

} else if( CurToken==NumberTok )

2810

{ if( TokenValue<=100 )

2811

{ ReDrawFlag |= RFColour;

2812

SpecPower = (int)TokenValue;

2813

} else

2814

CommandError(MsgStrs[ErrBigNum]);

2815

} else CommandError(MsgStrs[ErrNotNum]);

2816

break;

2817

2818

2819

case(ShadePowerTok):

2820

FetchToken();

2821

if( !CurToken )

2822

{ ShadePower = 0;

2823

ReDrawFlag |= RFColour;

2824

} else if( CurToken==NumberTok )

2825

{ if( TokenValue<=100 )

2826

{ ReDrawFlag |= RFColour;

2827

ShadePower = (int)((TokenValue-50)*0.4);

2828

} else

2829

CommandError(MsgStrs[ErrBigNum]);

2830

} else CommandError(MsgStrs[ErrNotNum]);

2831

break;

2832

2833

case(AmbientTok):

2834

FetchToken();

2835

if( !CurToken )

2836

{ ReDrawFlag |= RFColour;

2837

Ambient = DefaultAmbient;

2838

} else if( CurToken==NumberTok )

2839

{ if( TokenValue<=100 )

2840

{ Ambient = TokenValue/100.0;

2841

ReDrawFlag |= RFColour;

2842

} else

2843

CommandError(MsgStrs[ErrBigNum]);

2844

} else CommandError(MsgStrs[ErrNotNum]);

2845

break;

2846

2847

case(HeteroTok):

2848

FetchToken();

2849

if( CurToken==TrueTok )

2850

{ HetaGroups = True;

2851

} else if( CurToken==FalseTok )

2852

{ HetaGroups = False;

2853

} else CommandError(MsgStrs[ErrBadOpt]);

2854

break;

2855

2856

case(HydrogenTok):

2857

FetchToken();

2858

if( CurToken==TrueTok )

2859

{ Hydrogens = True;

2860

} else if( CurToken==FalseTok )

2861

{ Hydrogens = False;

2862

} else CommandError(MsgStrs[ErrBadOpt]);

2863

break;

2864

2865

2866

case(BackgroundTok):

2867

FetchToken();

2868

if( CurToken == TransparentTok )

2869

{ UseTransparent = True;

2870

} else if( CurToken == NormalTok )

2871

{ UseTransparent = False;

2872

} else if( ParseColour() )

2873

{ ReDrawFlag |= RFColour;

2874

BackR = RVal;

2875

BackG = GVal;

2876

BackB = BVal;

2877

DefaultBackground = False; /* [GSG 11/29/95] */

2878

#ifndef IBMPC

2879

FBClear = False;

2880

#endif

2881

} else if( CurToken )

2882

{ CommandError(MsgStrs[ErrColour]);

2883

} else CommandError(MsgStrs[ErrNoCol]);

2884

break;

2885

2886

case(BondModeTok):

2887

FetchToken();

2888

if( !CurToken || (CurToken==AndTok) )

2889

{ ZoneBoth = True;

2890

} else if( CurToken==OrTok )

2891

{ ZoneBoth = False;

2892

} else if( CurToken==AllTok )

2893

{ MarkAtoms = AllAtomFlag;

2894

} else if( CurToken==NoneTok)

2895

{ MarkAtoms = 0;

2896

} else if( CurToken==NotTok )

2897

{ FetchToken();

2898

if( !CurToken || (CurToken==BondedTok) )

2899

{ MarkAtoms = NonBondFlag;

2900

} else CommandError(MsgStrs[ErrBadOpt]);

2901

} else CommandError(MsgStrs[ErrBadOpt]);

2902

break;

2903

2904

case(HBondTok):

2905

FetchToken();

2906

if( (CurToken==BackboneTok) || (CurToken==MainChainTok) )

2907

{ ReDrawFlag |= RFRefresh;

2908

HBondMode = True;

2909

} else if( !CurToken || (CurToken==SidechainTok) )

2910

{ ReDrawFlag |= RFRefresh;

2911

HBondMode = False;

2912

} else if( CurToken == ChainTok )

2913

{ FetchToken();

2914

if( !CurToken || (CurToken==TrueTok) )

2915

{ if( !HBondChainsFlag && (Info.hbondcount>=0) )

2916

{ ReDrawFlag |= RFRefresh;

2917

HBondChainsFlag = True;

2918

CalcHydrogenBonds();

2919

}

2920

} else if( CurToken == FalseTok )

2921

{ if( HBondChainsFlag && (Info.hbondcount>=0) )

2922

{ ReDrawFlag |= RFRefresh;

2923

HBondChainsFlag = False;

2924

CalcHydrogenBonds();

2925

}

2926

} else CommandError(MsgStrs[ErrBadOpt]);

2927

} else CommandError(MsgStrs[ErrBadOpt]);

2928

break;

2929

2930

case(SSBondTok):

2931

FetchToken();

2932

if( (CurToken==BackboneTok) || (CurToken==MainChainTok) )

2933

{ ReDrawFlag |= RFRefresh;

2934

SSBondMode = True;

2935

} else if( !CurToken || (CurToken==SidechainTok) )

2936

{ ReDrawFlag |= RFRefresh;

2937

SSBondMode = False;

2938

} else CommandError(MsgStrs[ErrBadOpt]);

2939

break;

2940

2941

case(HourGlassTok):

2942

FetchToken();

2943

if( CurToken==TrueTok )

2944

{ UseHourGlass = True;

2945

} else if( CurToken==FalseTok )

2946

{ UseHourGlass = False;

2947

} else CommandError(MsgStrs[ErrBadOpt]);

2948

break;

2949

2950

case(StrandsTok):

2951

FetchToken();

2952

if( !CurToken )

2953

{ ReDrawFlag |= RFRefresh;

2954

SplineCount = 5;

2955

} else if( CurToken==NumberTok )

2956

{ if( (TokenValue>0) && (TokenValue<=5) )

2957

{ SplineCount = (int)TokenValue;

2958

ReDrawFlag |= RFRefresh;

2959

} else if( TokenValue==9 )

2960

{ ReDrawFlag |= RFRefresh;

2961

SplineCount = 9;

2962

} else CommandError(MsgStrs[ErrBadOpt]);

2963

} else CommandError(MsgStrs[ErrNotNum]);

2964

break;

2965

2966

case(MouseTok):

2967

FetchToken();

2968

if( !CurToken || (CurToken==RasMolTok) || (CurToken==NewTok) || (CurToken==OldTok) )

2969

{ if( Interactive ) {

2970

if (CurToken == RasMolTok) {

2971

FetchToken();

2972

if (!CurToken || CurToken==NewTok) {

2973

SetMouseMode( MMRasMol );

2974

} else if (CurToken==OldTok) {

2975

SetMouseMode( MMRasOld );

2976

} else CommandError(MsgStrs[ErrBadOpt]);

2977

break;

2978

}

2979

if (CurToken == NewTok) {

2980

FetchToken();

2981

if (!CurToken || CurToken==RasMolTok) {

2982

SetMouseMode( MMRasMol );

2983

} else CommandError(MsgStrs[ErrBadOpt]);

2984

break;

2985

}

2986

if (CurToken == OldTok) {

2987

FetchToken();

2988

if (!CurToken || CurToken==RasMolTok) {

2989

SetMouseMode( MMRasOld );

2990

} else CommandError(MsgStrs[ErrBadOpt]);

2991

break;

2992

}

2993

SetMouseMode( MMRasMol );

2994

}

2995

} else if( CurToken==InsightTok )

2996

{ if( Interactive )

2997

SetMouseMode( MMInsight );

2998

} else if( CurToken==QuantaTok )

2999

{ if( Interactive )

3000

SetMouseMode( MMQuanta );

3001

} else if( CurToken==SybylTok )

3002

{ if( Interactive )

3003

SetMouseMode( MMSybyl );

3004

} else CommandError(MsgStrs[ErrBadOpt]);

3005

break;

3006

3007

case(DisplayTok):

3008

FetchToken();

3009

/* Affect StereoMode Parameters?? */

3010

if( !CurToken || (CurToken==NormalTok) )

3011

{ ReDrawFlag |= RFRefresh | RFColour;

3012

DisplayMode = 0;

3013

} else if( CurToken==SelectedTok )

3014

{ ReDrawFlag |= RFRefresh | RFColour;

3015

DisplayMode = 1;

3016

} else CommandError(MsgStrs[ErrBadOpt]);

3017

break;

3018

3019

case(VectPSTok):

3020

FetchToken();

3021

if( !CurToken || (CurToken==FalseTok) )

3022

{ UseOutLine = False;

3023

} else if( CurToken == TrueTok )

3024

{ UseOutLine = True;

3025

} else CommandError(MsgStrs[ErrBadOpt]);

3026

break;

3027

3028

case(Raster3DTok):

3029

FetchToken();

3030

if( !CurToken || (CurToken==FalseTok) )

3031

{ UseOutLine = False;

3032

} else if( CurToken == TrueTok )

3033

{ UseOutLine = True;

3034

} else CommandError(MsgStrs[ErrBadOpt]);

3035

break;

3036

3037

case(KinemageTok):

3038

FetchToken();

3039

if( !CurToken || (CurToken==FalseTok) )

3040

{ KinemageFlag = False;

3041

} else if( CurToken == TrueTok )

3042

{ KinemageFlag = True;

3043

} else CommandError(MsgStrs[ErrBadOpt]);

3044

break;

3045

3046

case(MenusTok):

3047

FetchToken();

3048

if( !CurToken || (CurToken==TrueTok) )

3049

{ EnableMenus(True);

3050

} else if( CurToken == FalseTok )

3051

{ EnableMenus(False);

3052

} else CommandError(MsgStrs[ErrBadOpt]);

3053

break;

3054

3055

case(RadiusTok):

3056

FetchToken();

3057

if( !CurToken )

3058

{ ProbeRadius = SolventDots? 300 : 0;

3059

} else if( CurToken==NumberTok )

3060

{ if( *TokenPtr=='.' )

3061

{ TokenPtr++;

3062

FetchFloat(TokenValue,250);

3063

}

3064

3065

if( TokenValue>1500 )

3066

{ CommandError(MsgStrs[ErrBigNum]);

3067

} else ProbeRadius = (int)TokenValue;

3068

} else if( CurToken=='.' )

3069

{ FetchFloat(0,250);

3070

if( TokenValue>1500 )

3071

{ CommandError(MsgStrs[ErrBigNum]);

3072

} else ProbeRadius = (int)TokenValue;

3073

3074

} else CommandError(MsgStrs[ErrNotNum]);

3075

iProbeRad = (int)(Scale*(Real)ProbeRadius);

3076

ReDrawFlag |= RFRefresh;

3077

break;

3078

3079

case(SolventTok):

3080

FetchToken();

3081

if( !CurToken || (CurToken==FalseTok) )

3082

{ SolventDots = False;

3083

ProbeRadius = 0;

3084

} else if( CurToken == TrueTok )

3085

{ SolventDots = True;

3086

ProbeRadius = 300;

3087

} else CommandError(MsgStrs[ErrBadOpt]);

3088

iProbeRad = (int)(Scale*(Real)ProbeRadius);

3089

ReDrawFlag |= RFRefresh;

3090

break;

3091

3092

case(FontSizeTok):

3093

FetchToken();

3094

if( CurToken==NumberTok )

3095

{ if( TokenValue<=48 )

3096

{ int fsize;

3097

3098

fsize = (int)TokenValue;

3099

FetchToken();

3100

if ( !CurToken || CurToken==FSTok )

3101

{ SetFontSize(fsize);

3102

} else if ( CurToken ==PSTok )

3103

{ SetFontSize(-fsize);

3104

} else CommandError(MsgStrs[ErrBadOpt]);

3105

} else CommandError(MsgStrs[ErrBigNum]);

3106

} else if( !CurToken )

3107

{ SetFontSize(8);

3108

} else if (CurToken == FSTok)

3109

{ SetFontSize(abs(FontSize));

3110

} else if (CurToken == PSTok)

3111

{ SetFontSize(-abs(FontSize));

3112

} else CommandError(MsgStrs[ErrBadOpt]);

3113

break;

3114

3115

case(FontStrokeTok):

3116

FetchToken();

3117

if( CurToken==NumberTok )

3118

{ if( TokenValue<=8 )

3119

{ if( LabelList || (MonitList && DrawMonitDistance) )

3120

ReDrawFlag |= RFRefresh;

3121

SetFontStroke((int)TokenValue);

3122

} else CommandError(MsgStrs[ErrBigNum]);

3123

} else if( !CurToken )

3124

{ if( LabelList )

3125

ReDrawFlag |= RFRefresh;

3126

SetFontStroke(0);

3127

} else CommandError(MsgStrs[ErrBadOpt]);

3128

break;

3129

3130

case(WriteTok):

3131

FetchToken();

3132

if( !CurToken || (CurToken==FalseTok) )

3133

{ AllowWrite = False;

3134

} else if( CurToken == TrueTok )

3135

{ if( (FileDepth!=-1) && LineStack[FileDepth] )

3136

{ CommandError(MsgStrs[ErrInScrpt]);

3137

} else AllowWrite = True;

3138

} else CommandError(MsgStrs[ErrBadOpt]);

3139

break;

3140

3141

case(StereoTok):

3142

FetchToken();

3143

if( !CurToken )

3144

{ if (UseStereo) {

3145

StereoAngle = -StereoAngle;

3146

if (StereoAngle < 0.0 ) {

3147

SetStereoMode(True);

3148

} else {

3149

SetStereoMode(False);

3150

}

3151

} else SetStereoMode(True);

3152

} else if( CurToken==TrueTok )

3153

{ SetStereoMode(True);

3154

} else if( CurToken==FalseTok )

3155

{ SetStereoMode(False);

3156

} else if( CurToken == '-' )

3157

{ if( !NextIf(NumberTok,ErrNotNum) )

3158

{ StereoAngle = -TokenValue;

3159

SetStereoMode(True);

3160

}

3161

} else if( CurToken == '+' )

3162

{ if( !NextIf(NumberTok,ErrNotNum) )

3163

{ StereoAngle = TokenValue;

3164

SetStereoMode(True);

3165

}

3166

} else if( CurToken==NumberTok )

3167

{ StereoAngle = TokenValue;

3168

SetStereoMode(True);

3169

} else {

3170

CommandError(MsgStrs[ErrSyntax]);

3171

break;

3172

}

3173

if (StereoAngle > 60.) {

3174

StereoAngle = 6.;

3175

CommandError(MsgStrs[ErrBigNum]);

3176

break;

3177

}

3178

if (StereoAngle < -60.) {

3179

StereoAngle = -6.;

3180

CommandError(MsgStrs[ErrBigNum]);

3181

break;

3182

}

3183

break;

3184

3185

case(BondTok):

3186

FetchToken();

3187

if( !CurToken || (CurToken==FalseTok) )

3188

{ ReDrawFlag |= RFRefresh;

3189

DrawDoubleBonds = False;

3190

} else if( CurToken == TrueTok )

3191

{ ReDrawFlag |= RFRefresh;

3192

DrawDoubleBonds = True;

3193

} else CommandError(MsgStrs[ErrBadOpt]);

3194

break;

3195

3196

case(MonitorTok):

3197

FetchToken();

3198

if( !CurToken || (CurToken==TrueTok) )

3199

{ ReDrawFlag |= RFRefresh;

3200

DrawMonitDistance = True;

3201

} else if( CurToken == FalseTok )

3202

{ ReDrawFlag |= RFRefresh;

3203

DrawMonitDistance = False;

3204

} else CommandError(MsgStrs[ErrBadOpt]);

3205

break;

3206

3207

case(CartoonTok):

3208

FetchToken();

3209

if( !CurToken )

3210

{ ReDrawFlag |= RFRefresh;

3211

DrawBetaArrows = True;

3212

CartoonHeight = 120;

3213

} else if( CurToken==TrueTok )

3214

{ ReDrawFlag |= RFRefresh;

3215

DrawBetaArrows = True;

3216

} else if( CurToken==FalseTok )

3217

{ ReDrawFlag |= RFRefresh;

3218

DrawBetaArrows = False;

3219

} else if( CurToken==NumberTok )

3220

{ if( *TokenPtr=='.' )

3221

{ TokenPtr++;

3222

FetchFloat(TokenValue,250);

3223

}

3224

3225

if( TokenValue <= 500 )

3226

{ CartoonHeight = (int)TokenValue;

3227

ReDrawFlag |= RFRefresh;

3228

} else CommandError(MsgStrs[ErrBigNum]);

3229

} else if( CurToken=='.' )

3230

{ FetchFloat(0,250);

3231

if( TokenValue <= 500 )

3232

{ CartoonHeight = (int)TokenValue;

3233

ReDrawFlag |= RFRefresh;

3234

} else CommandError(MsgStrs[ErrBigNum]);

3235

3236

} else CommandError(MsgStrs[ErrBadOpt]);

3237

break;

3238

3239

case(BackFadeTok):

3240

FetchToken();

3241

if( !CurToken || (CurToken==FalseTok) )

3242

{ ReDrawFlag |= RFColour;

3243

UseBackFade = False;

3244

} else if( CurToken == TrueTok )

3245

{ ReDrawFlag |= RFColour;

3246

UseBackFade = True;

3247

} else CommandError(MsgStrs[ErrBadOpt]);

3248

break;

3249

3250

case(TransparentTok):

3251

FetchToken();

3252

if( !CurToken || (CurToken==FalseTok) )

3253

{ UseTransparent = False;

3254

} else if( CurToken == TrueTok )

3255

{ UseTransparent = True;

3256

} else CommandError(MsgStrs[ErrBadOpt]);

3257

break;

3258

3259

case(DepthCueTok):

3260

FetchToken();

3261

if( !CurToken || (CurToken==FalseTok) )

3262

{ ReDrawFlag |= RFColour;

3263

UseDepthCue = False;

3264

} else if( CurToken == TrueTok )

3265

{ ReDrawFlag |= RFColour;

3266

UseDepthCue = True;

3267

} else CommandError(MsgStrs[ErrBadOpt]);

3268

break;

3269

3270

case(CisAngleTok):

3271

FetchToken();

3272

if( !CurToken )

3273

{ CisBondCutOff = CIS;

3274

} else {

3275

if( CurToken==NumberTok )

3276

{ if( TokenValue<=180 )

3277

{ CisBondCutOff = TokenValue;

3278

Info.cisbondcount = -1; /* to recalculate peptide bonds */

3279

} else {

3280

CommandError(MsgStrs[ErrBigNum]);

3281

}

3282

} else {

3283

CommandError(MsgStrs[ErrNotNum]);

3284

}

3285

}

3286

sprintf(buffer,"CisBondCutOff = %d\n", CisBondCutOff);

3287

WriteString( buffer );

3288

break;

3289

3290

case(SequenceTok):

3291

FetchToken();

3292

if( !CurToken || (CurToken==FalseTok) )

3293

{ SeqFormat = False;

3294

} else if( CurToken == TrueTok )

3295

{ SeqFormat = True;

3296

} else CommandError(MsgStrs[ErrBadOpt]);

3297

break;

3298

3299

case(ConnectTok):

3300

FetchToken();

3301

if( !CurToken || (CurToken==TrueTok) )

3302

{ CalcBondsFlag = True;

3303

} else if( CurToken == FalseTok )

3304

{ CalcBondsFlag = False;

3305

} else CommandError(MsgStrs[ErrBadOpt]);

3306

break;

3307

3308

case(AxesTok): ExecuteAxesCommand(); break;

3309

case(BoundBoxTok): ExecuteBoundBoxCommand(); break;

3310

case(PickingTok): ExecutePickingCommand(); break;

3311

case(TitleTok): ExecuteTitleCommand(); break;

3312

case(UnitCellTok): ExecuteUnitCellCommand(); break;

3313

3314

case(DotsTok):

3315

FetchToken();

3316

if( !CurToken )

3317

{ SurfaceChainsFlag = False;

3318

SolventDots = False;

3319

ProbeRadius = 0;

3320

} else if( CurToken == SolventTok )

3321

{ FetchToken();

3322

if( !CurToken || (CurToken==FalseTok) )

3323

{ SolventDots = False;

3324

ProbeRadius = 0;

3325

} else if( CurToken == TrueTok )

3326

{ SolventDots = True;

3327

ProbeRadius = 300;

3328

} else CommandError(MsgStrs[ErrBadOpt]);

3329

} else if( CurToken == ChainTok )

3330

{ FetchToken();

3331

if( !CurToken || (CurToken==TrueTok) )

3332

{ SurfaceChainsFlag = True;

3333

} else if( CurToken == FalseTok )

3334

{ SurfaceChainsFlag = False;

3335

} else CommandError(MsgStrs[ErrBadOpt]);

3336

} else if( CurToken == NumberTok )

3337

{ if( TokenValue<=20 )

3338

{ if( TokenValue )

3339

{ DotSize = TokenValue;

3340

ReDrawFlag |= RFRefresh;

3341

}

3342

} else CommandError(MsgStrs[ErrBigNum]);

3343

} else CommandError(MsgStrs[ErrBadOpt]);

3344

iProbeRad = (int)(Scale*(Real)ProbeRadius);

3345

ReDrawFlag |= RFRefresh;

3346

break;

3347

3348

/* set notoggle command - gm */

3349

case (NoToggleTok):

3350

FetchToken();

3351

if (!CurToken || CurToken == TrueTok)

3352

{

3353

NoToggle = 1;

3354

WriteString(MsgStrs[StrNoTogOn]);

3355

}

3356

else if (CurToken == FalseTok)

3357

{

3358

NoToggle = 0;

3359

WriteString(MsgStrs[StrNoTogOff]);

3360

}

3361

break;

3362

3363

/* set play.fps command */

3364

case (PlayTok):

3365

{ int errorcode = 0;

3366

3367

FetchToken();

3368

if (CurToken == '.') {

3369

FetchToken();

3370

if(CurToken == FPSTok) {

3371

FetchToken();

3372

if (CurToken == NumberTok ) {

3373

play_fps = (double)TokenValue;

3374

if( *TokenPtr=='.') {

3375

TokenPtr++;

3376

FetchFloat(TokenValue,1000);

3377

play_fps = (double)TokenValue/1000.;

3378

}

3379

} else if (CurToken=='.') {

3380

FetchFloat(0,1000);

3381

play_fps = (double)TokenValue/1000.;

3382

} else {

3383

if (!CurToken) {

3384

play_fps = 24.;

3385

} else errorcode++;

3386

}

3387

} else errorcode++;

3388

}

3389

if (errorcode) CommandError(MsgStrs[ErrBadArg]);

3390

break;

3391

}

3392

3393

/* set record.fps <n> command

3394

set record.aps <n> command

3395

set record.dwell <n> <what> command

3396

3397

handling of <what> deferred */

3398

case (RecordTok):

3399

{ int errorcode = 0;

3400

double __far * settarget;

3401

double targetdefault = 24.;

3402

3403

FetchToken();

3404

if (CurToken == '.') {

3405

FetchToken();

3406

switch (CurToken) {

3407

case FPSTok: settarget = &record_fps; break;

3408

case APSTok: settarget = &record_aps; targetdefault = 10.;break;

3409

case DwellTok: settarget = &record_dwell; targetdefault = 0.5; break;

3410

default: settarget = (double __far *)NULL;

3411

}

3412

if(settarget) {

3413

FetchToken();

3414

if (CurToken == NumberTok ) {

3415

*settarget = (double)TokenValue;

3416

if( *TokenPtr=='.') {

3417

TokenPtr++;

3418

FetchFloat(TokenValue,1000);

3419

*settarget = (double)TokenValue/1000.;

3420

}

3421

} else if (CurToken=='.') {

3422

FetchFloat(0,1000);

3423

*settarget = (double)TokenValue/1000.;

3424

} else {

3425

if (!CurToken) {

3426

*settarget = targetdefault;

3427

} else errorcode++;

3428

}

3429

} else errorcode++;

3430

}

3431

if (errorcode) CommandError(MsgStrs[ErrBadArg]);

3432

break;

3433

}

3434

3435

3436

default:

3437

CommandError(MsgStrs[ErrParam]);

3438

}

3439

}

3440

3441

3442

static void OldExecuteColourCommand( void )

3443

{

3444

register int flag;

3445

3446

flag = 0;

3447

switch( FetchToken() )

3448

{ case(AtomTok):

3449

FetchToken();

3450

default:

3451

switch( CurToken )

3452

{ case(CPKTok): CPKColourAttrib();

3453

ReDrawFlag |= RFColour; break;

3454

3455

case(CpkNewTok): CpkNewColourAttrib();

3456

ReDrawFlag |= RFColour; break;

3457

3458

case(AminoTok): AminoColourAttrib();

3459

ReDrawFlag |= RFColour; break;

3460

3461

case(ShapelyTok): ShapelyColourAttrib();

3462

ReDrawFlag |= RFColour; break;

3463

3464

case(UserTok): UserMaskAttrib(MaskColourFlag);

3465

ReDrawFlag |= RFColour; break;

3466

3467

case(GroupTok): ScaleColourAttrib(GroupAttr);

3468

ReDrawFlag |= RFColour; break;

3469

3470

case(ChainTok): ScaleColourAttrib(ChainAttr);

3471

ReDrawFlag |= RFColour; break;

3472

3473

case(ModelTok): ScaleColourAttrib(ModelAttr);

3474

ReDrawFlag |= RFColour; break;

3475

3476

case(AltlTok): ScaleColourAttrib(AltAttr);

3477

ReDrawFlag |= RFColour; break;

3478

3479

case(ChargeTok): ScaleColourAttrib(ChargeAttr);

3480

ReDrawFlag |= RFColour; break;

3481

3482

case(TemperatureTok): ScaleColourAttrib(TempAttr);

3483

ReDrawFlag |= RFColour; break;

3484

3485

case(StructureTok): StructColourAttrib();

3486

ReDrawFlag |= RFColour; break;

3487

3488

default: if( ParseColour() )

3489

{ MonoColourAttrib(RVal,GVal,BVal);

3490

ReDrawFlag |= RFColour;

3491

} else if( CurToken )

3492

{ CommandError(MsgStrs[ErrColour]);

3493

} else CommandError(MsgStrs[ErrNoCol]);

3494

}

3495

break;

3496

3497

case(BondTok):

3498

case(DashTok):

3499

FetchToken();

3500

if( CurToken==NoneTok )

3501

{ ColourBondNone();

3502

ReDrawFlag |= RFColour;

3503

} else if( ParseColour() )

3504

{ ColourBondAttrib(RVal,GVal,BVal);

3505

ReDrawFlag |= RFColour;

3506

} else if( CurToken )

3507

{ CommandError(MsgStrs[ErrColour]);

3508

} else CommandError(MsgStrs[ErrNoCol]);

3509

break;

3510

3511

case(BackboneTok):

3512

FetchToken();

3513

if( CurToken==NoneTok )

3514

{ ColourBackNone();

3515

ReDrawFlag |= RFColour;

3516

} else if( ParseColour() )

3517

{ ColourBackAttrib(RVal,GVal,BVal);

3518

ReDrawFlag |= RFColour;

3519

} else if( CurToken )

3520

{ CommandError(MsgStrs[ErrColour]);

3521

} else CommandError(MsgStrs[ErrNoCol]);

3522

break;

3523

3524

case(SSBondTok):

3525

FetchToken();

3526

if( CurToken==NoneTok )

3527

{ ReDrawFlag |= RFColour;

3528

ColourHBondNone( False );

3529

} else if( ParseColour() )

3530

{ ReDrawFlag |= RFColour;

3531

ColourHBondAttrib(False,RVal,GVal,BVal);

3532

} else if( CurToken )

3533

{ CommandError(MsgStrs[ErrColour]);

3534

} else CommandError(MsgStrs[ErrNoCol]);

3535

break;

3536

3537

case(HBondTok):

3538

FetchToken();

3539

if( CurToken==NoneTok )

3540

{ ReDrawFlag |= RFColour;

3541

ColourHBondNone( True );

3542

} else if( CurToken==TypeTok )

3543

{ ReDrawFlag |= RFColour;

3544

ColourHBondType();

3545

} else if( ParseColour() )

3546

{ ReDrawFlag |= RFColour;

3547

ColourHBondAttrib(True,RVal,GVal,BVal);

3548

} else if( CurToken )

3549

{ CommandError(MsgStrs[ErrColour]);

3550

} else CommandError(MsgStrs[ErrNoCol]);

3551

break;

3552

3553

case(DotsTok):

3554

FetchToken();

3555

if( CurToken==PotentialTok )

3556

{ ReDrawFlag |= RFColour;

3557

ColourDotsPotential();

3558

} else if( ParseColour() )

3559

{ ReDrawFlag |= RFColour;

3560

ColourDotsAttrib(RVal,GVal,BVal);

3561

} else if( CurToken )

3562

{ CommandError(MsgStrs[ErrColour]);

3563

} else CommandError(MsgStrs[ErrNoCol]);

3564

break;

3565

3566

case(MapTok):

3567

FetchToken();

3568

if( CurToken==PotentialTok )

3569

{ ReDrawFlag |= RFColour;

3570

MapFlag |= MapColourPot;

3571

MapFlag &= ~MapColourAtom;

3572

ApplyMapColour();

3573

} else if( CurToken==AtomTok )

3574

{ ReDrawFlag |= RFColour;

3575

MapFlag |= MapColourAtom;

3576

MapFlag &= ~MapColourPot;

3577

ApplyMapColour();

3578

} else if( ParseColour() )

3579

{ ReDrawFlag |= RFColour;

3580

MapRGBCol[0] = RVal;

3581

MapRGBCol[1] = GVal;

3582

MapRGBCol[2] = BVal;

3583

MapFlag &= ~(MapColourPot|MapColourAtom);

3584

ApplyMapColour();

3585

} else if( CurToken )

3586

{ CommandError(MsgStrs[ErrColour]);

3587

} else CommandError(MsgStrs[ErrNoCol]);

3588

break;

3589

3590

3591

case(MonitorTok):

3592

FetchToken();

3593

if( CurToken == NoneTok )

3594

{ ColourMonitNone();

3595

} else if( ParseColour() )

3596

{ ReDrawFlag |= RFColour;

3597

ColourMonitAttrib(RVal,GVal,BVal);

3598

} else if( CurToken )

3599

{ CommandError(MsgStrs[ErrColour]);

3600

} else CommandError(MsgStrs[ErrNoCol]);

3601

break;

3602

3603

case(AxesTok):

3604

case(BoundBoxTok):

3605

case(UnitCellTok):

3606

FetchToken();

3607

if( ParseColour() )

3608

{ BoxR = RVal; BoxG = GVal; BoxB = BVal;

3609

ReDrawFlag |= RFColour;

3610

} else if( CurToken )

3611

{ CommandError(MsgStrs[ErrColour]);

3612

} else CommandError(MsgStrs[ErrNoCol]);

3613

break;

3614

3615

case(LabelTok):

3616

FetchToken();

3617

if( CurToken==NoneTok )

3618

{ ReDrawFlag |= RFColour;

3619

UseLabelCol = False;

3620

} else if( ParseColour() )

3621

{ LabR = RVal; LabG = GVal; LabB = BVal;

3622

ReDrawFlag |= RFColour;

3623

UseLabelCol = True;

3624

} else if( CurToken )

3625

{ CommandError(MsgStrs[ErrColour]);

3626

} else CommandError(MsgStrs[ErrNoCol]);

3627

break;

3628

3629

case(TraceTok):

3630

case(RibbonTok):

3631

case(StrandsTok):

3632

case(CartoonTok): flag = RibColBoth; break;

3633

case(Ribbon1Tok): flag = RibColInside; break;

3634

case(Ribbon2Tok): flag = RibColOutside; break;

3635

}

3636

3637

if( flag )

3638

{ FetchToken();

3639

if( CurToken==NoneTok )

3640

{ ReDrawFlag |= RFColour;

3641

ColourRibbonNone(flag);

3642

} else if( ParseColour() )

3643

{ ReDrawFlag |= RFColour;

3644

ColourRibbonAttrib(flag,RVal,GVal,BVal);

3645

} else if( CurToken )

3646

{ CommandError(MsgStrs[ErrColour]);

3647

} else CommandError(MsgStrs[ErrNoCol]);

3648

}

3649

}

3650

3651

static void ExecuteColourCommand( void )

3652

{

3653

/* The new ExecuteColorCommand - at present this is a copy of the

3654

* previous version */

3655

register int flag;

3656

3657

/* in case we want to use the old code... */

3658

if (UseOldColorCode)

3659

{

3660

/* ... use it ... */

3661

OldExecuteColourCommand();

3662

return;

3663

}

3664

3665

flag = 0;

3666

switch( FetchToken() )

3667

{ case(AtomTok):

3668

FetchToken();

3669

default:

3670

switch( CurToken )

3671

{ case(CPKTok): CPKColourAttrib();

3672

ReDrawFlag |= RFColour; break;

3673

3674

case(CpkNewTok): CpkNewColourAttrib();

3675

ReDrawFlag |= RFColour; break;

3676

3677

case(AminoTok): AminoColourAttrib();

3678

ReDrawFlag |= RFColour; break;

3679

3680

case(ShapelyTok): ShapelyColourAttrib();

3681

ReDrawFlag |= RFColour; break;

3682

3683

case(UserTok): UserMaskAttrib(MaskColourFlag);

3684

ReDrawFlag |= RFColour; break;

3685

3686

case(GroupTok): ScaleColourAttrib(GroupAttr);

3687

ReDrawFlag |= RFColour; break;

3688

3689

case(ChainTok): ScaleColourAttrib(ChainAttr);

3690

ReDrawFlag |= RFColour; break;

3691

3692

case(ModelTok): ScaleColourAttrib(ModelAttr);

3693

ReDrawFlag |= RFColour; break;

3694

3695

case(AltlTok): ScaleColourAttrib(AltAttr);

3696

ReDrawFlag |= RFColour; break;

3697

3698

case(ChargeTok): ScaleColourAttrib(ChargeAttr);

3699

ReDrawFlag |= RFColour; break;

3700

3701

case(TemperatureTok): ScaleColourAttrib(TempAttr);

3702

ReDrawFlag |= RFColour; break;

3703

3704

case(StructureTok): StructColourAttrib();

3705

ReDrawFlag |= RFColour; break;

3706

3707

default: if( ParseColour() )

3708

{ ColourBondNone();

3709

MonoColourAttrib(RVal,GVal,BVal);

3710

ReDrawFlag |= RFColour;

3711

} else if( CurToken )

3712

{ CommandError(MsgStrs[ErrColour]);

3713

} else CommandError(MsgStrs[ErrNoCol]);

3714

}

3715

break;

3716

3717

case(BondTok):

3718

case(DashTok):

3719

FetchToken();

3720

if( CurToken==NoneTok )

3721

{ ColourBondNone();

3722

ReDrawFlag |= RFColour;

3723

} else if( ParseColour() )

3724

{ ColourBondAttrib(RVal,GVal,BVal);

3725

ReDrawFlag |= RFColour;

3726

} else if( CurToken )

3727

{ CommandError(MsgStrs[ErrColour]);

3728

} else CommandError(MsgStrs[ErrNoCol]);

3729

break;

3730

3731

case(BackboneTok):

3732

FetchToken();

3733

if( CurToken==NoneTok )

3734

{ ColourBackNone();

3735

ReDrawFlag |= RFColour;

3736

} else if( ParseColour() )

3737

{ ColourBackAttrib(RVal,GVal,BVal);

3738

ReDrawFlag |= RFColour;

3739

} else if( CurToken )

3740

{ CommandError(MsgStrs[ErrColour]);

3741

} else CommandError(MsgStrs[ErrNoCol]);

3742

break;

3743

3744

case(SSBondTok):

3745

FetchToken();

3746

if( CurToken==NoneTok )

3747

{ ReDrawFlag |= RFColour;

3748

ColourHBondNone( False );

3749

} else if( ParseColour() )

3750

{ ReDrawFlag |= RFColour;

3751

ColourHBondAttrib(False,RVal,GVal,BVal);

3752

} else if( CurToken )

3753

{ CommandError(MsgStrs[ErrColour]);

3754

} else CommandError(MsgStrs[ErrNoCol]);

3755

break;

3756

3757

case(HBondTok):

3758

FetchToken();

3759

if( CurToken==NoneTok )

3760

{ ReDrawFlag |= RFColour;

3761

ColourHBondNone( True );

3762

} else if( CurToken==TypeTok )

3763

{ ReDrawFlag |= RFColour;

3764

ColourHBondType();

3765

} else if( ParseColour() )

3766

{ ReDrawFlag |= RFColour;

3767

ColourHBondAttrib(True,RVal,GVal,BVal);

3768

} else if( CurToken )

3769

{ CommandError(MsgStrs[ErrColour]);

3770

} else CommandError(MsgStrs[ErrNoCol]);

3771

break;

3772

3773

case(DotsTok):

3774

FetchToken();

3775

if( CurToken==PotentialTok )

3776

{ ReDrawFlag |= RFColour;

3777

ColourDotsPotential();

3778

} else if( ParseColour() )

3779

{ ReDrawFlag |= RFColour;

3780

ColourDotsAttrib(RVal,GVal,BVal);

3781

} else if( CurToken )

3782

{ CommandError(MsgStrs[ErrColour]);

3783

} else CommandError(MsgStrs[ErrNoCol]);

3784

break;

3785

3786

case(MapTok):

3787

FetchToken();

3788

if( CurToken==PotentialTok )

3789

{ ReDrawFlag |= RFColour;

3790

MapFlag |= MapColourPot;

3791

MapFlag &= ~MapColourAtom;

3792

ApplyMapColour();

3793

} else if( CurToken==AtomTok )

3794

{ ReDrawFlag |= RFColour;

3795

MapFlag |= MapColourAtom;

3796

MapFlag &= ~MapColourPot;

3797

ApplyMapColour();

3798

} else if( ParseColour() )

3799

{ ReDrawFlag |= RFColour;

3800

MapRGBCol[0] = RVal;

3801

MapRGBCol[1] = GVal;

3802

MapRGBCol[2] = BVal;

3803

MapFlag &= ~(MapColourPot|MapColourAtom);

3804

ApplyMapColour();

3805

} else if( CurToken )

3806

{ CommandError(MsgStrs[ErrColour]);

3807

} else CommandError(MsgStrs[ErrNoCol]);

3808

break;

3809

3810

3811

case(MonitorTok):

3812

FetchToken();

3813

if( CurToken == NoneTok )

3814

{ ColourMonitNone();

3815

} else if( ParseColour() )

3816

{ ReDrawFlag |= RFColour;

3817

ColourMonitAttrib(RVal,GVal,BVal);

3818

} else if( CurToken )

3819

{ CommandError(MsgStrs[ErrColour]);

3820

} else CommandError(MsgStrs[ErrNoCol]);

3821

break;

3822

3823

case(AxesTok):

3824

case(BoundBoxTok):

3825

case(UnitCellTok):

3826

FetchToken();

3827

if( ParseColour() )

3828

{ BoxR = RVal; BoxG = GVal; BoxB = BVal;

3829

ReDrawFlag |= RFColour;

3830

} else if( CurToken )

3831

{ CommandError(MsgStrs[ErrColour]);

3832

} else CommandError(MsgStrs[ErrNoCol]);

3833

break;

3834

3835

case(LabelTok):

3836

FetchToken();

3837

if( CurToken==NoneTok )

3838

{ ReDrawFlag |= RFColour;

3839

UseLabelCol = False;

3840

} else if( ParseColour() )

3841

{ LabR = RVal; LabG = GVal; LabB = BVal;

3842

ReDrawFlag |= RFColour;

3843

UseLabelCol = True;

3844

} else if( CurToken )

3845

{ CommandError(MsgStrs[ErrColour]);

3846

} else CommandError(MsgStrs[ErrNoCol]);

3847

break;

3848

3849

case(TraceTok):

3850

case(RibbonTok):

3851

case(StrandsTok):

3852

case(CartoonTok): flag = RibColBoth; break;

3853

case(Ribbon1Tok): flag = RibColInside; break;

3854

case(Ribbon2Tok): flag = RibColOutside; break;

3855

}

3856

3857

if( flag )

3858

{ FetchToken();

3859

if( CurToken==NoneTok )

3860

{ ReDrawFlag |= RFColour;

3861

ColourRibbonNone(flag);

3862

} else if( ParseColour() )

3863

{ ReDrawFlag |= RFColour;

3864

ColourRibbonAttrib(flag,RVal,GVal,BVal);

3865

} else if( CurToken )

3866

{ CommandError(MsgStrs[ErrColour]);

3867

} else CommandError(MsgStrs[ErrNoCol]);

3868

}

3869

}

3870

3871

3872

/* prints out information about all selected objects to terminal */

3873

/* example: Describe(ATM) could print output in terms of: */

3874

/* Chain: ? Group: ??? ?? Atom: ??? ???? */

3875

static void DescribeSelected( Selection type )

3876

{

3877

3878

register Chain __far *chain = (Chain __far*)NULL;

3879

register Group __far *group = (Group __far*)NULL;

3880

register RAtom __far *ptr = (RAtom __far*)NULL;

3881

AtomRef current;

3882

int touched ;

3883

int Aselect ;

3884

int Acount ;

3885

int Gselect ;

3886

int Gcount ;

3887

int model ;

3888

char buffer[40];

3889

3890

if(!Database)

3891

return;

3892

3893

model = -1;

3894

3895

for(chain=Database->clist;chain;chain=chain->cnext){

3896

Gselect = Gcount = 0;

3897

touched = False;

3898

current.chn = chain;

3899

for(group=chain->glist;group;group=group->gnext){

3900

Aselect = Acount = 0;

3901

current.grp = group;

3902

for(ptr=group->alist;ptr;ptr=ptr->anext) {

3903

current.atm = ptr;

3904

if( !(ptr->flag&HeteroFlag) || type != CHN) {

3905

if( ptr->flag&SelectFlag ) {

3906

Aselect++;

3907

touched = True;

3908

if( type == ATM || type == CRD){ /* Atom or Coordinates */

3909

WriteString(DescribeObj(&current, type));

3910

WriteChar('\n');

3911

}

3912

}

3913

Acount++;

3914

}

3915

}

3916

if( Acount == Aselect )

3917

Gselect++;

3918

Gcount++;

3919

if( Aselect && (type == GRP || type == CHN)) {

3920

if (!(model == group->model)) {

3921

model = group->model;

3922

if (model) {

3923

sprintf(buffer,"Model: %d\n",model);

3924

WriteString(buffer);

3925

}

3926

}

3927

}

3928

if( Aselect && type == GRP) { /* Group */

3929

WriteString(DescribeObj(&current, GRP));

3930

sprintf(buffer, "\t(%d/%d)\tatoms\n",Aselect, Acount);

3931

WriteString(buffer);

3932

}

3933

}

3934

if( touched && type == CHN ) { /* Chain */

3935

WriteString(DescribeObj(&current, CHN));

3936

if( Gselect > 0 ) {

3937

sprintf(buffer,"\t(%d/%d)\tgroups\n",Gselect, Gcount);

3938

WriteString(buffer);

3939

}

3940

else

3941

WriteString("\tno group completely selected\n");

3942

}

3943

}

3944

}

3945

3946

3947

/* Selection for printing selected atoms || groups || chains to terminal */

3948

static void ExecuteSelectedCommand()

3949

{

3950

3951

switch( FetchToken() )

3952

{

3953

case(AtomTok):

3954

DescribeSelected(ATM);

3955

break;

3956

case(CoordTok):

3957

DescribeSelected(CRD);

3958

break;

3959

case(GroupTok):

3960

DescribeSelected(GRP);

3961

break;

3962

case(ChainTok):

3963

DescribeSelected(CHN);

3964

break;

3965

case(0):

3966

DescribeSelected(GRP); /* default option for show selected is 'group' */

3967

break;

3968

default:

3969

CommandError(MsgStrs[ErrBadArg]);

3970

}

3971

}

3972

3973

3974

static void DescribeSequence( void )

3975

{

3976

register Chain __far *chn;

3977

register Group __far *grp;

3978

register int chain,count;

3979

register int subcount;

3980

register char *str;

3981

char buffer[40];

3982

int model;

3983

3984

InvalidateCmndLine();

3985

if( !Database )

3986

return;

3987

3988

model = -1;

3989

for( chn=Database->clist; chn; chn=chn->cnext )

3990

{ chain = (Info.chaincount<2); count = 0;

3991

subcount = -1;

3992

for( grp=chn->glist; grp; grp=grp->gnext )

3993

if( grp->alist && !(grp->alist->flag&HeteroFlag) )

3994

{ if( !chain )

3995

{ if (!(model==grp->model))

3996

{ model = grp->model;

3997

if (model)

3998

{ sprintf(buffer,"Model: %d ",model);

3999

WriteString(buffer);

4000

}

4001

}

4002

WriteString("Chain ");

4003

WriteChar(chn->ident);

4004

WriteString(":\n");

4005

chain = True;

4006

}

4007

4008

if( !SeqFormat )

4009

{ if( count == 10 )

4010

{ WriteChar('\n');

4011

count = 1;

4012

} else count++;

4013

4014

str = Residue[grp->refno];

4015

WriteChar(str[0]);

4016

WriteChar(str[1]);

4017

WriteChar(str[2]);

4018

4019

sprintf(buffer,"%-3d ",grp->serno);

4020

WriteString(buffer);

4021

} else

4022

{ if( count == 50 )

4023

{ WriteChar('\n');

4024

count = 1;

4025

subcount = 0;

4026

} else

4027

{ count++;

4028

subcount++;

4029

}

4030

4031

if( subcount == 10)

4032

{ WriteChar(' ');

4033

subcount = 0;

4034

}

4035

4036

if( grp->refno < 29 )

4037

{ WriteChar(ResidueChar[grp->refno]);

4038

} else WriteChar('*');

4039

}

4040

}

4041

WriteChar('\n');

4042

}

4043

WriteChar('\n');

4044

}

4045

4046

4047

static void ExecuteShowCommand( void )

4048

{

4049

register Real temp;

4050

char buffer[40];

4051

Real theta,phi,psi;

4052

4053

switch( FetchToken() )

4054

{ case(DeferTok):

4055

ShowDeferCommand();

4056

break;

4057

4058

case(InfoTok):

4059

DescribeMolecule();

4060

break;

4061

4062

case(PlayTok):

4063

ShowPlayCommand();

4064

break;

4065

4066

case(RecordTok):

4067

ShowRecordCommand();

4068

break;

4069

4070

case(MapTok):

4071

ApplyMapShow();

4072

break;

4073

4074

case(SequenceTok):

4075

DescribeSequence();

4076

break;

4077

4078

case(SelectedTok):

4079

ExecuteSelectedCommand();

4080

break;

4081

4082

case(PhiPsiTok):

4083

WritePhiPsiAngles(NULL, False); /* Writing to stderr/stdout */

4084

break;

4085

4086

case(RamPrintTok):

4087

WritePhiPsiAngles(NULL, -1); /* Writing to stderr/stdout */

4088

break;

4089

4090

case(SymmetryTok):

4091

InvalidateCmndLine();

4092

4093

if( *Info.spacegroup )

4094

{ sprintf(buffer,"%s ...... %s\n",MsgStrs[StrSGroup],Info.spacegroup);

4095

WriteString(buffer);

4096

4097

sprintf(buffer,"%s A ...... %g\n",MsgStrs[StrUCell],Info.cella);

4098

WriteString(buffer);

4099

sprintf(buffer,"%s B ...... %g\n",MsgStrs[StrUCell],Info.cellb);

4100

WriteString(buffer);

4101

sprintf(buffer,"%s C ...... %g\n",MsgStrs[StrUCell],Info.cellc);

4102

WriteString(buffer);

4103

4104

temp = Rad2Deg*Info.cellalpha;

4105

sprintf(buffer,"%s alpha .. %g\n",MsgStrs[StrUCell],temp);

4106

WriteString(buffer);

4107

temp = Rad2Deg*Info.cellbeta;

4108

sprintf(buffer,"%s beta ... %g\n",MsgStrs[StrUCell],temp);

4109

WriteString(buffer);

4110

temp = Rad2Deg*Info.cellgamma;

4111

sprintf(buffer,"%s gamma .. %g\n",MsgStrs[StrUCell],temp);

4112

WriteString(buffer);

4113

4114

} else WriteString(MsgStrs[StrSymm]);

4115

WriteChar('\n');

4116

break;

4117

4118

case(CentreTok):

4119

InvalidateCmndLine();

4120

if ( CenX || CenY || CenZ ) {

4121

#ifdef INVERT

4122

sprintf(buffer,"centre [%ld,%ld,%ld]\n", CenX, -CenY, -CenZ);

4123

#else

4124

sprintf(buffer,"centre [%ld,%ld,%ld]\n", CenX, CenY, -CenZ);

4125

#endif

4126

WriteString(buffer);

4127

}

4128

break;

4129

4130

case(RotateTok):

4131

InvalidateCmndLine();

4132

ReDrawFlag |= RFRotate;

4133

PrepareTransform();

4134

4135

/*

4136

phi = Round(Rad2Deg*asin(RotX[2]));

4137

if( phi == 90 )

4138

{ theta = -Round(Rad2Deg*atan2(RotY[0],RotY[1]));

4139

psi = 0;

4140

} else if( phi == -90 )

4141

{ theta = Round(Rad2Deg*atan2(RotY[0],RotY[1]));

4142

psi = 0;

4143

} else

4144

{ theta = Round(Rad2Deg*atan2(RotY[2],RotZ[2]));

4145

psi = Round(-Rad2Deg*atan2(RotX[1],RotX[0]));

4146

}

4147

*/

4148

4149

phi = psi = theta = 0.0;

4150

RMat2RV(&theta, &phi, &psi, RotX, RotY, RotZ);

4151

theta *= 180.;

4152

phi *= 180.;

4153

psi *= 180.;

4154

4155

4156

if( Round(theta) ) {

4157

sprintf(buffer,"rotate x %d\n",Round(InvertY(-theta)));

4158

WriteString(buffer);

4159

}

4160

if( Round(phi) ) {

4161

sprintf(buffer,"rotate y %d\n",Round(phi));

4162

WriteString(buffer);

4163

}

4164

if( Round(psi) ) {

4165

sprintf(buffer,"rotate z %d\n",Round(InvertY(-psi)));

4166

WriteString(buffer);

4167

}

4168

if (BondsSelected) {

4169

BondRot __far *brptr;

4170

4171

brptr = BondsSelected;

4172

while (brptr) {

4173

sprintf(buffer,"bond %ld %ld pick\n",

4174

(brptr->BSrcAtom)->serno, (brptr->BDstAtom)->serno);

4175

WriteString(buffer);

4176

if( brptr->BRotValue ) {

4177

sprintf(buffer,"rotate bond %d\n",

4178

Round((brptr->BRotValue)*180.));

4179

WriteString(buffer);

4180

}

4181

brptr = brptr->brnext;

4182

}

4183

}

4184

break;

4185

4186

case(TranslateTok):

4187

InvalidateCmndLine();

4188

/* temp = 100.0*DialValue[DialTX]; */

4189

temp = (int)(100.0*(Real)(XOffset-WRange)/((Real)XRange*Zoom));

4190

if( temp ) {

4191

sprintf(buffer,"translate x %.2f\n",temp);

4192

WriteString(buffer);

4193

}

4194

/* temp = 100.0*DialValue[DialTY]; */

4195

temp = (int)(100.0*(Real)(YOffset-HRange)/((Real)YRange*Zoom));

4196

if( temp ) {

4197

sprintf(buffer,"translate y %.2f\n",InvertY(-temp));

4198

WriteString(buffer);

4199

}

4200

/* temp = 100.0*DialValue[DialTZ]; */

4201

temp = (int)(100.0*(Real)(ZOffset-10000)/((Real)ZRange*Zoom));

4202

if( temp ) {

4203

sprintf(buffer,"translate z %.2f\n",temp);

4204

WriteString(buffer);

4205

}

4206

break;

4207

4208

case(ZoomTok):

4209

InvalidateCmndLine();

4210

if( DialValue[DialZoom] != 0.0 )

4211

{ if( DialValue[DialZoom]<0.0 )

4212

{ temp = 100.0*DialValue[DialZoom];

4213

} else temp = 100.0*MaxZoom*DialValue[DialZoom];

4214

sprintf(buffer,"zoom %d\n",(int)(temp+100));

4215

WriteString(buffer);

4216

}

4217

break;

4218

4219

case(FPSTok):

4220

InvalidateCmndLine();

4221

sprintf(buffer,"set play.fps %g\n",play_fps);

4222

WriteString(buffer);

4223

sprintf(buffer,"set record.fps %g\n",record_fps);

4224

WriteString(buffer);

4225

break;

4226

4227

case(APSTok):

4228

InvalidateCmndLine();

4229

sprintf(buffer,"set record.aps %g\n",record_aps);

4230

WriteString(buffer);

4231

break;

4232

4233

default:

4234

CommandError(MsgStrs[ErrBadArg]);

4235

}

4236

}

4237

4238

4239

4240

4241

/*Function call on "select <...<" , start and continue selection,

4242

* "select <...>" , start and stop selection,

4243

* or "select >...>" , continue and stop selection.

4244

* Escape the parser to make fast atom selection under the format:

4245

* "select (< or >) x1[-x2],...,xi[-x(i+1)](> or <)" where xi represent atomno.

4246

*/

4247

static void ReadAtomSelection( int start )

4248

{ register Long ori=0, end=0;

4249

register int neg, bloc=0;

4250

register char ch;

4251

register Bond __far *bptr;

4252

register SurfBond __far *sbptr;

4253

4254

if( !Database )

4255

return;

4256

4257

/*Empty selection at start*/

4258

if( start )

4259

{ for( QChain=Database->clist; QChain; QChain=QChain->cnext )

4260

for( QGroup=QChain->glist; QGroup; QGroup=QGroup->gnext )

4261

for( QAtom=QGroup->alist; QAtom; QAtom=QAtom->anext )

4262

QAtom->flag &= ~SelectFlag;

4263

SelectCount = 0;

4264

}

4265

4266

NeedAtomTree = 1;

4267

4268

while( *TokenPtr )

4269

{ bloc = 0;

4270

neg = 0;

4271

ch = *TokenPtr++;

4272

4273

/*first number*/

4274

while( *TokenPtr && isspace(ch) )

4275

ch= *TokenPtr++;

4276

if( ch == '-' )

4277

neg = 1;

4278

else if( ch != '+' )

4279

*TokenPtr--;

4280

FetchToken();

4281

if( CurToken==NumberTok )

4282

{ ori = TokenValue;

4283

ch= *TokenPtr++;

4284

while( *TokenPtr && isspace(ch) )

4285

ch = *TokenPtr++;

4286

4287

/*second number*/

4288

if( ch=='-' )

4289

{ neg = 0;

4290

ch= *TokenPtr++;

4291

while( *TokenPtr && isspace(ch) )

4292

ch = *TokenPtr++;

4293

if( ch == '-' )

4294

neg = 1;

4295

else if( ch != '+' )

4296

*TokenPtr--;

4297

FetchToken();

4298

if( CurToken==NumberTok )

4299

{ end = TokenValue;

4300

if( neg )

4301

end = -end;

4302

ch = *TokenPtr++;

4303

while( *TokenPtr && isspace(ch) )

4304

ch = *TokenPtr++;

4305

if( ch==','||ch=='>'||ch=='<' )

4306

bloc = 1;

4307

}

4308

} else if( ch==','||ch=='>'||ch=='<' )

4309

{ end = ori;

4310

bloc = 1;

4311

}

4312

}

4313

4314

if( bloc==1 )

4315

{ for( QChain=Database->clist; QChain; QChain=QChain->cnext )

4316

for( QGroup=QChain->glist; QGroup; QGroup=QGroup->gnext )

4317

for( QAtom=QGroup->alist; QAtom; QAtom=QAtom->anext )

4318

if( QAtom->serno >= ori && QAtom->serno <= end )

4319

{ if( !(QAtom->flag&SelectFlag) )

4320

SelectCount++;

4321

QAtom->flag |= SelectFlag;

4322

}

4323

} else

4324

{ if( ch!=',' && ch!='<' && ch!='>' ) /*not empty bloc*/

4325

CommandError(MsgStrs[ErrBlocSel]);

4326

while( *TokenPtr && ch!=',' && ch!='<' && ch!='>' )

4327

ch = *TokenPtr++;

4328

}

4329

4330

if( ch==',' )

4331

continue;

4332

else if( ch=='<' )

4333

bloc = 0;

4334

else

4335

bloc = 1;

4336

while( *TokenPtr )

4337

*TokenPtr++;

4338

}

4339

4340

/*termination*/

4341

if( bloc!=0 )

4342

{ if( (FileDepth == -1) || !LineStack[FileDepth] )

4343

DisplaySelectCount( );

4344

4345

if( ZoneBoth )

4346

{ ForEachBond

4347

if( (bptr->srcatom->flag&bptr->dstatom->flag) & SelectFlag )

4348

{ bptr->flag |= SelectFlag;

4349

} else bptr->flag &= ~SelectFlag;

4350

ForEachSurfBond

4351

if( (sbptr->srcatom->flag&sbptr->dstatom->flag) & SelectFlag )

4352

{ sbptr->flag |= SelectFlag;

4353

} else sbptr->flag &= ~SelectFlag;

4354

} else

4355

{ ForEachBond

4356

if( (bptr->srcatom->flag|bptr->dstatom->flag) & SelectFlag )

4357

{ bptr->flag |= SelectFlag;

4358

} else bptr->flag &= ~SelectFlag;

4359

ForEachSurfBond

4360

if( (sbptr->srcatom->flag|sbptr->dstatom->flag) & SelectFlag )

4361

{ sbptr->flag |= SelectFlag;

4362

} else sbptr->flag &= ~SelectFlag;

4363

}

4364

}

4365

}

4366

4367

4368

4369

void ZapDatabase( void )

4370

{

4371

register int i;

4372

int s; /* 's' is for "shade" */

4373

4374

for( i=0; i<10; i++ )

4375

DialValue[i] = 0.0;

4376

CQRMSet(DialQRot,0.,0.,0.,0.);

4377

4378

SelectCount = 0;

4379

4380

DestroyDatabase();

4381

ResetSymbolTable();

4382

ResetTransform();

4383

ResetRenderer();

4384

ResetRepres();

4385

ResetBondsSel();

4386

DeleteMaps();

4387

4388

ZoneBoth = True;

4389

HetaGroups = True;

4390

Hydrogens = True;

4391

4392

for (s = 0; s < LastShade; s++)

4393

Shade[s].refcount = 0;

4394

4395

#if 0 /* [GSG 11/10/95] */

4396

BackR = BackG = BackB = 0;

4397

#endif

4398

#ifndef IBMPC

4399

FBClear = False;

4400

#endif

4401

4402

/* [11/10/95 GSG] Prevent colormap reset, refresh instead of clear */

4403

#if 0

4404

ResetColourMap();

4405

DefineColourMap();

4406

ClearBuffers();

4407

ReDrawFlag = 0;

4408

#else

4409

ReDrawFlag = RFRefresh;

4410

#endif

4411

4412

if( Interactive )

4413

{ UpdateScrollBars();

4414

/* ClearImage(); [GSG 11/10/95] */

4415

}

4416

AdviseUpdate(AdvName);

4417

AdviseUpdate(AdvClass);

4418

AdviseUpdate(AdvIdent);

4419

4420

/* [GSG 11/10/95] */

4421

ZapMolecule();

4422

ReRadius();

4423

}

4424

4425

4426

void WriteImageFile( char *name, int type, int subtype )

4427

{

4428

if( !type )

4429

#ifdef EIGHTBIT

4430

type = GIFTok;

4431

#else

4432

type = PPMTok;

4433

#endif

4434

4435

if ( (type != VRMLTok) && subtype ) {

4436

CommandError(MsgStrs[ErrSyntax]);

4437

}

4438

else

4439

4440

switch( type )

4441

{ case(GIFTok): WriteGIFFile(name); break;

4442

case(BMPTok): WriteBMPFile(name); break;

4443

case(PPMTok): WritePPMFile(name,True); break;

4444

case(SUNTok): WriteRastFile(name,False); break;

4445

case(SUNRLETok): WriteRastFile(name,True); break;

4446

case(PICTTok): WritePICTFile(name); break;

4447

case(IRISTok): WriteIRISFile(name); break;

4448

case(EPSFTok): WriteEPSFFile(name,True,True); break;

4449

case(MonoPSTok): WriteEPSFFile(name,False,True); break;

4450

case(VectPSTok): WriteVectPSFile(name); break;

4451

case(Raster3DTok): WriteR3DFile(name); break;

4452

4453

case(RasMolTok):

4454

case(ScriptTok): WriteScriptFile(name); break;

4455

case(KinemageTok): WriteKinemageFile(name); break;

4456

case(MolScriptTok): WriteMolScriptFile(name); break;

4457

case(POVRayTok): WritePOVRayFile(name); break;

4458

case(POVRay3Tok): WritePOVRay3File(name); break;

4459

case(PhiPsiTok): WritePhiPsiAngles(name, False); break;

4460

case(RamachanTok): WritePhiPsiAngles(name, 1); break;

4461

case(RamPrintTok): WritePhiPsiAngles(name, -1); break;

4462

case(VRMLTok): WriteVRMLFile(name, subtype); break;

4463

4464

}

4465

}

4466

4467

4468

void ResumePauseCommand( void )

4469

{

4470

register int ch,len;

4471

register FILE *fp;

4472

register int stat;

4473

4474

CommandActive = False;

4475

IsPaused = False;

4476

4477

#ifdef MSWIN

4478

/* Re-enable Drag & Drop! */

4479

DragAcceptFiles(CanvWin,TRUE);

4480

#endif

4481

4482

while( FileDepth >= 0 )

4483

{ fp = FileStack[FileDepth];

4484

do {

4485

len = 0;

4486

ch = getc(fp);

4487

while( (ch!='\n') && (ch!='\r') && (ch!=EOF) )

4488

{ if( len<MAXBUFFLEN )

4489

CurLine[len++] = ch;

4490

ch = getc(fp);

4491

}

4492

4493

LineStack[FileDepth]++;

4494

if( len<MAXBUFFLEN )

4495

{ CurLine[len] = '\0';

4496

stat = ExecuteCommand();

4497

if( stat )

4498

{ if( stat == QuitTok )

4499

{ while( FileDepth >= 0 )

4500

{ fclose(FileStack[FileDepth]);

4501

_ffree(NameStack[FileDepth]);

4502

FileDepth--;

4503

}

4504

RasMolExit();

4505

} else /* ExitTok */

4506

break;

4507

} else if( IsPaused )

4508

return;

4509

} else CommandError(MsgStrs[StrSLong]);

4510

} while( ch!=EOF );

4511

_ffree(NameStack[FileDepth]);

4512

fclose( fp );

4513

FileDepth--;

4514

}

4515

}

4516

4517

4518

void InterruptPauseCommand( void )

4519

{

4520

WriteString("*** RasMol script interrupted! ***\n\n");

4521

CommandActive = False;

4522

IsPaused = False;

4523

4524

#ifdef MSWIN

4525

/* Re-enable Drag & Drop! */

4526

DragAcceptFiles(CanvWin,TRUE);

4527

#endif

4528

4529

while( FileDepth >= 0 )

4530

{ fclose(FileStack[FileDepth]);

4531

_ffree(NameStack[FileDepth]);

4532

FileDepth--;

4533

}

4534

}

4535

4536

4537

static void ExecuteConnectCommand( void )

4538

{

4539

register Bond __far *bptr;

4540

register int info,flag;

4541

4542

FetchToken();

4543

if( !CurToken )

4544

{ flag = (MainAtomCount+HetaAtomCount<256);

4545

} else if( CurToken == TrueTok )

4546

{ flag = True;

4547

} else if( CurToken == FalseTok )

4548

{ flag = False;

4549

} else

4550

{ CommandError(MsgStrs[ErrSyntax]);

4551

return;

4552

}

4553

4554

if( Database )

4555

{ ForEachBond

4556

if( bptr->col )

4557

Shade[Colour2Shade(bptr->col)].refcount--;

4558

info = (FileDepth == -1);

4559

CreateMoleculeBonds(info,flag,True);

4560

ReDrawFlag |= RFRefresh|RFColour;

4561

EnableWireframe(WireFlag,0,0);

4562

}

4563

4564

CalcBondsFlag = True;

4565

}

4566

4567

4568

/* Select Maps

4569

4570

The format of a map command is

4571

map {<map_selector>} subcommand parameters

4572

4573

where the optional map_selector is one of the following:

4574

m -- a map number m indicating a particular map for the currently active molecule

4575

m1-m2 -- a range of map numbers indicating all maps for the current molecule

4576

with numbers between m1 and m2, inclusive. If m1 is blank, m1 is assumed

4577

to be the number of the first map. If m2 is blank, m2 is assumed to be the

4578

number of the last map.

4579

next -- the next map number after the highest number selected map in circular order.

4580

If all maps are already selected or no maps are selected, the result will be selection

4581

of the first map. If there are no maps, next has the same effect as new

4582

new (or none) -- no maps are selected, but if the subcommand changes any parameters

4583

or setting, they are changed for the next map to be created

4584

all -- all maps are selected

4585

a quoted string to be used as a map label, or one of the above followed by a

4586

quoted string to be used as a map label

4587

4588

SelectMaps parses map_selector tokens until it is positioned on the

4589

token after the last token of the map selector, setting the MapMarkedFlag

4590

for each selected map and, if it is to be applied to the next map,

4591

the global map flag. The MapSelectFlag is not changed at this stage.

4592

The transfer will be done in a call to ApplyMapSelection, to allow the

4593

processing to be aborted on errors in the subcommand or parameters

4594

4595

4596

*/

4597

4598

static void SelectMaps( void ) {

4599

4600

int lomap, himap, labfound, nextflag, newflag, j, nummaps;

4601

int nomapselected;

4602

int maxmapsel;

4603

MapInfo *mapinfo;

4604

4605

lomap = -1;

4606

himap = -1;

4607

labfound = 0;

4608

nextflag = 0;

4609

newflag = 0;

4610

nummaps = 0;

4611

nomapselected=1;

4612

4613

if (!MapInfoPtr) InitialiseMaps();

4614

4615

if (MapInfoPtr) nummaps = MapInfoPtr->size;

4616

FetchToken();

4617

if ( CurToken ) {

4618

if (CurToken == NewTok || CurToken == NoneTok) {

4619

nomapselected = 0;

4620

newflag = 1;

4621

FetchToken();

4622

if (CurToken == StringTok) labfound = 1;

4623

} else if (CurToken == NextTok) {

4624

nomapselected = 0;

4625

nextflag = 1;

4626

FetchToken();

4627

if (CurToken == StringTok) labfound = 1;

4628

} else if (CurToken == AllTok) {

4629

nomapselected = 0;

4630

lomap = 1;

4631

himap = nummaps;

4632

FetchToken();

4633

if (CurToken == StringTok) labfound = 1;

4634

} else if (CurToken == NumberTok) {

4635

nomapselected = 0;

4636

lomap = (int)TokenValue;

4637

himap = lomap;

4638

FetchToken();

4639

if (CurToken == '-') {

4640

himap = nummaps;

4641

FetchToken();

4642

if (CurToken == NumberTok) {

4643

himap = (int)TokenValue;

4644

} else {

4645

if (CurToken == StringTok) labfound = 1;

4646

}

4647

} else {

4648

if (CurToken == StringTok) labfound = 1;

4649

}

4650

4651

} else {

4652

lomap = 1;

4653

if (CurToken == '-') {

4654

nomapselected = 0;

4655

himap = nummaps;

4656

FetchToken();

4657

if (CurToken == NumberTok) {

4658

himap = (int)TokenValue;

4659

} else {

4660

if (CurToken == StringTok) labfound = 1;

4661

}

4662

} else {

4663

if (CurToken == StringTok) labfound = 1;

4664

}

4665

4666

}

4667

4668

}

4669

4670

if (labfound) {

4671

if (MapLabel) {

4672

_ffree(MapLabel);

4673

}

4674

MapLabel = _fmalloc(strlen(TokenIdent)+1);

4675

strcpy(MapLabel,TokenIdent);

4676

}

4677

4678

MapFlag &= ~(MapMarkedFlag|MapNoSelectFlag);

4679

if (nomapselected) MapFlag |= MapNoSelectFlag;

4680

if (MapInfoPtr) {

4681

maxmapsel = -1;

4682

for (j=0; j < MapInfoPtr->size; j++) {

4683

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4684

mapinfo->flag &= (~MapMarkedFlag);

4685

if (labfound){

4686

if (j+1 >= lomap && j+1 <=himap

4687

&& mapinfo->MapLabel

4688

&& !strcasecmp(mapinfo->MapLabel,MapLabel)) {

4689

maxmapsel = j;

4690

mapinfo->flag |= MapMarkedFlag;

4691

}

4692

} else {

4693

if (j+1 >= lomap && j+1 <=himap) {

4694

maxmapsel = j;

4695

mapinfo->flag |= MapMarkedFlag;

4696

}

4697

}

4698

}

4699

4700

if (nextflag) {

4701

maxmapsel++;

4702

if ( maxmapsel >= MapInfoPtr->size ) maxmapsel = 1;

4703

for (j=0; j < MapInfoPtr->size; j++) {

4704

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4705

if (j != maxmapsel) mapinfo->flag &= (~MapMarkedFlag);

4706

else mapinfo->flag |= MapMarkedFlag;

4707

}

4708

}

4709

4710

if (newflag) MapFlag |= MapMarkedFlag;

4711

4712

}

4713

4714

return;

4715

4716

}

4717

4718

static void ApplyMapSelection( void ) {

4719

int j;

4720

MapInfo *mapinfo;

4721

4722

if (MapFlag&MapNoSelectFlag) return;

4723

MapFlag &= (~MapSelectFlag);

4724

if (MapFlag&MapMarkedFlag) MapFlag |= MapSelectFlag;

4725

4726

if (MapInfoPtr) {

4727

for (j=0; j < MapInfoPtr->size; j++) {

4728

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4729

mapinfo->flag &= (~MapSelectFlag);

4730

if (mapinfo->flag&MapMarkedFlag) mapinfo->flag |= MapSelectFlag;

4731

}

4732

}

4733

return;

4734

}

4735

4736

/*

4737

ApplyMapAtomSelection

4738

4739

Searchs for atoms within the specified SearchRadius of the points of

4740

the currently selected maps. If clear is set, all selections are

4741

cleared prior to the search. If current is not set, all atoms are

4742

selected prior to the search.

4743

4744

*/

4745

4746

static void ApplyMapAtomSelection(int dontadd, int searchwithin, int SearchRadius) {

4747

int i, j;

4748

MapInfo *mapinfo;

4749

void CNEARTREE_FAR * objClosest;

4750

MapPointVec __far *MapPointsPtr;

4751

double coord[3];

4752

size_t visits;

4753

clock_t tc1,tc2;

4754

tc1 = clock();

4755

4756

/* First we need to set up the selection flags for CreateAtomTree

4757

4758

If we are adding to the selection (dontadd is false)

4759

we need to save the current selection using SaveFlag

4760

and restore those selections at the end.

4761

4762

If we are not searching within (searchwithin is false)

4763

we need to set all selection flags

4764

4765

*/

4766

4767

for( QChain=Database->clist; QChain; QChain=QChain->cnext )

4768

for( QGroup=QChain->glist; QGroup; QGroup=QGroup->gnext )

4769

for( QAtom=QGroup->alist; QAtom; QAtom=QAtom->anext ) {

4770

QAtom->flag &= ~SaveFlag;

4771

if (!dontadd && ((QAtom->flag)&SelectFlag)) QAtom->flag |= SaveFlag;

4772

if (searchwithin==False) QAtom->flag |= SelectFlag;

4773

}

4774

4775

if (!AtomTree || dontadd==True || searchwithin==False || NeedAtomTree) {

4776

if (CreateAtomTree()) {

4777

RasMolFatalExit(MsgStrs[StrMalloc]);

4778

}

4779

}

4780

#ifdef CNEARTREE_INSTRUMENTED

4781

visits = 0;

4782

CNearTreeSetNodeVisits(AtomTree,visits);

4783

#endif

4784

4785

/* Now, clear all selection flags */

4786

4787

for( QChain=Database->clist; QChain; QChain=QChain->cnext )

4788

for( QGroup=QChain->glist; QGroup; QGroup=QGroup->gnext )

4789

for( QAtom=QGroup->alist; QAtom; QAtom=QAtom->anext ) {

4790

QAtom->flag &= ~SelectFlag;

4791

}

4792

4793

4794

if (MapInfoPtr) {

4795

for (j=0; j < MapInfoPtr->size; j++) {

4796

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4797

if (mapinfo->flag&MapSelectFlag) {

4798

MapPointsPtr = mapinfo->MapPointsPtr;

4799

if (MapPointsPtr)

4800

for (i=0; i<MapPointsPtr->size; i++) {

4801

if (!(MapPointsPtr->array[i]).flag&SelectFlag) continue;

4802

coord[0] = (double)(MapPointsPtr->array[i]).xpos;

4803

coord[1] = (double)(MapPointsPtr->array[i]).ypos;

4804

coord[2] = (double)(MapPointsPtr->array[i]).zpos;

4805

4806

if (!CNearTreeNearestNeighbor(AtomTree,(double)(SearchRadius),NULL,&objClosest,coord)) {

4807

(*((RAtom __far * *)objClosest))->flag |= SelectFlag;

4808

}

4809

}

4810

4811

}

4812

}

4813

}

4814

4815

if (dontadd==False) {

4816

for( QChain=Database->clist; QChain; QChain=QChain->cnext )

4817

for( QGroup=QChain->glist; QGroup; QGroup=QGroup->gnext )

4818

for( QAtom=QGroup->alist; QAtom; QAtom=QAtom->anext ) {

4819

if ((QAtom->flag)&SaveFlag) {

4820

QAtom->flag |= SelectFlag;

4821

QAtom->flag &= ~SaveFlag;

4822

}

4823

}

4824

}

4825

4826

tc2 = clock();

4827

fprintf(stderr,"Map select time %g size %ld depth %ld\n",

4828

((double)(tc2-tc1))/CLOCKS_PER_SEC,

4829

(long)(AtomTree->m_szsize),(long)(AtomTree->m_szdepth));

4830

#ifdef CNEARTREE_INSTRUMENTED

4831

CNearTreeGetNodeVisits(AtomTree,&visits);

4832

fprintf(stderr,"Node visits %ld\n", (long)visits);

4833

#endif

4834

4835

NeedAtomTree = 1;

4836

4837

return;

4838

4839

4840

}

4841

4842

void ApplyMapColour( void ) {

4843

int i, j;

4844

MapInfo *mapinfo;

4845

4846

if (MapInfoPtr) {

4847

for (j=0; j < MapInfoPtr->size; j++) {

4848

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4849

if (mapinfo->flag&MapSelectFlag) {

4850

mapinfo->flag &= ~(MapColourPot|MapColourAtom);

4851

mapinfo->flag |= (MapFlag&(MapColourPot|MapColourAtom));

4852

for (i=0;i<3;i++) mapinfo->MapRGBCol[i]=MapRGBCol[i];

4853

if (mapinfo->flag&MapColourPot) ColourPointPotential(j);

4854

else if(mapinfo->flag&MapColourAtom) ColourPointAtom(j);

4855

else ColourPointAttrib(mapinfo->MapRGBCol[0],mapinfo->MapRGBCol[1],mapinfo->MapRGBCol[2],j);

4856

}

4857

}

4858

}

4859

return;

4860

}

4861

4862

4863

4864

static void ApplyMapFlag( void ) {

4865

int j, mapflag;

4866

MapInfo *mapinfo;

4867

4868

4869

mapflag = MapFlag&(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

4870

4871

if (MapInfoPtr) {

4872

for (j=0; j < MapInfoPtr->size; j++) {

4873

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4874

if (mapinfo->flag&MapSelectFlag) {

4875

mapinfo->flag |= mapflag;

4876

DeleteMap(j,True);

4877

if (mapinfo->MapPtr) {

4878

if (mapinfo->flag&(MapPointFlag|MapMeshFlag|MapSurfFlag)) {

4879

vector_create((GenericVec __far **)&mapinfo->MapPointsPtr,sizeof(MapPoint),1000);

4880

if (mapinfo->flag&(MapMeshFlag))

4881

vector_create((GenericVec __far **)&mapinfo->MapBondsPtr,sizeof(MapBond),1000);

4882

if (mapinfo->flag&(MapSurfFlag))

4883

vector_create((GenericVec __far **)&mapinfo->MapTanglePtr,sizeof(MapTangle),1000);

4884

map_points(mapinfo->MapPtr,

4885

mapinfo->MapLevel+((mapinfo->flag&MapMeanFlag)?mapinfo->MapPtr->mapdatamean:0.),

4886

mapinfo->MapSpacing, mapinfo->MapPointsPtr,mapinfo->MapBondsPtr,mapinfo->MapTanglePtr,

4887

mapinfo->MapMaskPtr, mapinfo->MapRGBCol );

4888

if (mapinfo->flag&MapColourPot) ColourPointPotential(j);

4889

if (mapinfo->flag&MapColourAtom) ColourPointAtom(j);

4890

}

4891

}

4892

}

4893

}

4894

}

4895

MapReRadius();

4896

ReRadius();

4897

ReDrawFlag |= RFInitial|RFColour;

4898

return;

4899

}

4900

4901

static void ApplyMapLevel( void ) {

4902

int j, mapflag;

4903

MapInfo *mapinfo;

4904

4905

mapflag = MapFlag&MapMeanFlag;

4906

4907

if (MapInfoPtr) {

4908

for (j=0; j < MapInfoPtr->size; j++) {

4909

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4910

if (mapinfo->flag&MapSelectFlag) {

4911

mapinfo->flag &= ~MapMeanFlag;

4912

mapinfo->flag |= mapflag;

4913

mapinfo->MapLevel = MapLevel;

4914

}

4915

}

4916

}

4917

return;

4918

}

4919

4920

4921

static void ApplyMapSpread( void ) {

4922

int j;

4923

MapInfo *mapinfo;

4924

4925

if (MapInfoPtr) {

4926

for (j=0; j < MapInfoPtr->size; j++) {

4927

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4928

if (mapinfo->flag&MapSelectFlag) {

4929

mapinfo->MapSpread = MapSpread;

4930

}

4931

}

4932

}

4933

return;

4934

}

4935

4936

4937

static void ApplyMapSpacing( void ) {

4938

int j;

4939

MapInfo *mapinfo;

4940

4941

if (MapInfoPtr) {

4942

for (j=0; j < MapInfoPtr->size; j++) {

4943

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4944

if (mapinfo->flag&MapSelectFlag) {

4945

mapinfo->MapSpacing = MapSpacing;

4946

}

4947

}

4948

}

4949

return;

4950

}

4951

4952

static void ApplyMapZap( void ) {

4953

int j;

4954

MapInfo *mapinfo;

4955

4956

if (MapInfoPtr) {

4957

for (j=0; j < MapInfoPtr->size; j++) {

4958

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4959

if (mapinfo->flag&MapSelectFlag) {

4960

DeleteMap(j,False);

4961

}

4962

}

4963

}

4964

return;

4965

}

4966

4967

static void ApplyMapRestriction( void ) {

4968

int j;

4969

MapInfo *mapinfo;

4970

4971

if (MapInfoPtr) {

4972

for (j=0; j < MapInfoPtr->size; j++) {

4973

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

4974

if (!mapinfo->flag&MapSelectFlag) {

4975

DeleteMap(j,True);

4976

}

4977

}

4978

}

4979

return;

4980

}

4981

4982

4983

/* Code for calculation of the distance from a point to the Lee-Richards

4984

Surface of a pair of atoms

4985

4986

x is the location of the test point

4987

a is the location of the first atom

4988

b is the location of the second atom

4989

ra, rb and rp are the radii of a, b and the probe */

4990

4991

#define vsub(result,src,dst) \

4992

result[0] = dst[0]-src[0]; result[1] = dst[1]-src[1]; result[2] = dst[2]-src[2];

4993

#define vadd(result,src,dst) \

4994

result[0] = dst[0]+src[0]; result[1] = dst[1]+src[1]; result[2] = dst[2]+src[2];

4995

#define vdot(u,v) \

4996

u[0]*v[0] + u[1]*v[1] + u[2]*v[2]

4997

#define vscale(result,scalar,vector) \

4998

result[0] = scalar*vector[0]; result[1] = scalar*vector[1]; result[2] = scalar*vector[2];

4999

5000

/*

5001

p

5002

_*_

5003

/|\

5004

/ | \

5005

/ | \

5006

/ | \

5007

/ | \

5008

rp / | \ rp

5009

/ | \

5010

/ | \

5011

/ rp| \

5012

/ | \ *x

5013

/ | \

5014

\/ | \/

5015

/| | |\

5016

/ | _| | \

5017

/ | | | \

5018

ra / | | | \ rb

5019

/ | | | \

5020

/ | | | \

5021

/ | dpc | \

5022

/ | | | \

5023

\ / | | | \ /

5024

*---------*-----------*-----------*---------*

5025

a e c f b

5026

|---dae---|-----dec---|---dfc-----|---dfb---|

5027

|---------dac---------|---------dbc---------|

5028

|--------------------dab--------------------|

5029

5030

*/

5031

5032

5033

5034

5035

5036

5037

#include <math.h>

5038

5039

5040

5041

double surfdist(double x[3], double a[3], double b[3],

5042

double ra, double rb, double rp) {

5043

5044

double dxas, dxbs; /* signed distances from x to vdw surfaces */

5045

double xa[3], xb[3]; /* vectors from x to a and b */

5046

double dab; /* distance from a to b */

5047

double dpc; /* distance from probe center, p, to c */

5048

double vab[3]; /* vector from a to b */

5049

double uab[3]; /* unit vector along a to b vector */

5050

double c[3]; /* break point between ends of the reentrant surface */

5051

double dac, dbc; /* distances from a to c and b to c */

5052

double xc[3]; /* x redone as vector from c to x */

5053

double xcaxial[3]; /* the axial vector component of xc */

5054

double dxcaxial; /* the axial coordinate of xcaxial */

5055

double xcperp[3]; /* the orthogonal vector component of xc */

5056

double dxcperp; /* the orthogonal coordinate of xc */

5057

double dpasq, dpbsq; /* squares of lengths from probe center to a and b */

5058

double dpxsq; /* square of length from probe center to x */

5059

double rtot; /* ra + rb + 2*rb */

5060

double vdwdist; /* the distance to the van der Waals surface */

5061

5062

vsub(xa,a,x)

5063

vsub(xb,b,x)

5064

dxas = sqrt(vdot(xa,xa)) -ra;

5065

dxbs = sqrt(vdot(xb,xb)) -rb;

5066

vsub(vab,a,b)

5067

dab = sqrt(vdot(vab,vab));

5068

rtot = ra+rb+rp+rp;

5069

if ((dxas * dxbs) >= 0. ) {

5070

5071

if (fabs(dxas)<fabs(dxbs)) {

5072

5073

vdwdist = dxas;

5074

5075

} else {

5076

5077

vdwdist = dxbs;

5078

5079

}

5080

5081

} else {

5082

5083

if ( dxas < dxbs ) {

5084

5085

vdwdist = dxas;

5086

5087

} else {

5088

5089

vdwdist = dxbs;

5090

5091

}

5092

}

5093

5094

/* if the distance is too large or too small ignore the reentrant surface */

5095

if (dab > rtot || dab < (ra+rb)/2.) {

5096

5097

return vdwdist;

5098

5099

} else {

5100

5101

vscale(uab,1./dab,vab)

5102

dac = .5*((rtot)*(ra-rb)/dab + dab);

5103

dbc = .5*((rtot)*(rb-ra)/dab + dab);

5104

vscale(c,dac,uab)

5105

vadd(c,a,c)

5106

vsub(xc,c,x)

5107

dxcaxial = vdot(xc,uab);

5108

vscale(xcaxial,dxcaxial,uab)

5109

vsub(xcperp,xcaxial,xc)

5110

dxcperp = sqrt(vdot(xcperp,xcperp));

5111

dpc = sqrt((rp+rb)*(rp+rb) - dbc*dbc);

5112

5113

/* If x is further from the axis than p

5114

just return the van der Waals distance

5115

otherwise we will need to check if the

5116

angle between x-p and c-p is less than

5117

the angle between a-p or b-p and c-p*/

5118

5119

if (dxcperp >= dpc || dpc < rp ) {

5120

5121

return vdwdist;

5122

5123

} else {

5124

5125

/* In the (axial, perp) coordinate frame centered on c:

5126

5127

x = (dxcaxial,dxcperp)

5128

p = (o,dpc)

5129

a = (-dac,0)

5130

b = (dbc,0)

5131

5132

5133

so (a-p).(c-p) = (-dac,-dpc).(0,-dpc) = dpc*dpc

5134

(b-p).(c-p) = dpc*dpc

5135

||a-p|| = sqrt(dac*dac+dpc*dpc)

5136

||b-p|| = sqrt(dbc*dbc+dpc*dpc)

5137

5138

We are inside a sector from p to the reentrant surface, on,

5139

say, the a side, if the cosine of the angle between a-p and

5140

c-p is larger than the cosine of the angle between x-p and c-p:

5141

5142

|(a-p).(c-p)|/(||a-p||.||c-p||) >= |(x-p).(c-p)|/(||x-p||.||c-p||)

5143

or

5144

||x-p||*|(a-p).(c-p)|>=||a-p||*|(x-p).(c-p)|

5145

or

5146

||x-p||*dpc*dpc >= sqrt(dac*dac+dpc*dpc)*|(dxcperp-dpc)*dpc|

5147

or

5148

||x-p||*dpc >= sqrt(dac*dac+dpc*dpc)*|(dxcperp-dpc)|

5149

5150

5151

*/

5152

5153

dpxsq = dxcaxial*dxcaxial + (dxcperp-dpc)*(dxcperp-dpc);

5154

5155

if (dxcaxial > 0.){

5156

/* x is on the b-side */

5157

5158

dpbsq = dbc*dbc + dpc*dpc;

5159

5160

if (dpc*dpc*dpxsq >= (dxcperp-dpc)*(dxcperp-dpc)*dpbsq) {

5161

5162

return vdwdist;

5163

5164

} else {

5165

5166

return rp - sqrt(dpxsq);

5167

5168

}

5169

5170

} else {

5171

5172

dpasq = dac*dac + dpc*dpc;

5173

5174

if (dpc*dpc*dpxsq >= (dxcperp-dpc)*(dxcperp-dpc)*dpasq) {

5175

5176

return vdwdist;

5177

5178

} else {

5179

5180

return rp - sqrt(dpxsq);

5181

5182

}

5183

5184

5185

}

5186

5187

}

5188

5189

}

5190

5191

}

5192

5193

5194

5195

5196

/*

5197

ApplyMapAtomShow

5198

5199

Searchs for atoms within the specified SearchRadius of the points of

5200

the currently selected maps. Show the statistics of the distances

5201

from the map points to the molecular surface of those atoms

5202

5203

*/

5204

5205

static void ApplyMapAtomShow(int SearchRadius) {

5206

int i, j;

5207

MapInfo *mapinfo;

5208

void CNEARTREE_FAR * objClosest;

5209

MapPointVec __far *MapPointsPtr;

5210

double coord[3], acoord[3], bcoord[3], arad, brad;

5211

CVectorHandle atomsclosest;

5212

double vdwdistmin, vdwdistmax, vdwdistmean, vdwvariance;

5213

double lrdistmin, lrdistmax, lrdistmean, lrvariance;

5214

double dtemp, vdwdtemp;

5215

int vdwpcount, vdwptotal, lrpcount, lrptotal;

5216

char buffer[133];

5217

5218

CVectorCreate(&atomsclosest,sizeof(void CVECTOR_FAR *),2);

5219

5220

vdwpcount = vdwptotal = 0;

5221

5222

vdwdistmean = 0.;

5223

vdwvariance = 0.;

5224

vdwdistmin = 1.e9;

5225

vdwdistmax = -1.e9;

5226

5227

lrpcount = lrptotal =0;

5228

5229

lrdistmean = 0.;

5230

lrvariance = 0;

5231

lrdistmin = 1.e9;

5232

lrdistmax = -1.e9;

5233

5234

5235

if (!AtomTree || NeedAtomTree ) {

5236

if (CreateAtomTree()) {

5237

RasMolFatalExit(MsgStrs[StrMalloc]);

5238

}

5239

}

5240

5241

if (MapInfoPtr) {

5242

for (j=0; j < MapInfoPtr->size; j++) {

5243

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

5244

if (mapinfo->flag&MapSelectFlag) {

5245

MapPointsPtr = mapinfo->MapPointsPtr;

5246

if (MapPointsPtr)

5247

for (i=0; i<MapPointsPtr->size; i++) {

5248

if (!(MapPointsPtr->array[i]).flag&SelectFlag) continue;

5249

coord[0] = (double)(MapPointsPtr->array[i]).xpos;

5250

coord[1] = (double)(MapPointsPtr->array[i]).ypos;

5251

coord[2] = (double)(MapPointsPtr->array[i]).zpos;

5252

vdwptotal ++;

5253

lrptotal ++;

5254

5255

if (!CNearTreeNearestNeighbor(AtomTree,(double)(SearchRadius),NULL,&objClosest,coord)) {

5256

acoord[0] = (double)(*((RAtom __far * *)objClosest))->xorg

5257

+ (double)(*((RAtom __far * *)objClosest))->fxorg

5258

+ ((double)(*((RAtom __far * *)objClosest))->xtrl)/40.;

5259

acoord[1] = (double)(*((RAtom __far * *)objClosest))->yorg

5260

+ (double)(*((RAtom __far * *)objClosest))->fyorg

5261

+ ((double)(*((RAtom __far * *)objClosest))->ytrl)/40.;

5262

acoord[2] = (double)(*((RAtom __far * *)objClosest))->zorg

5263

+ (double)(*((RAtom __far * *)objClosest))->fzorg

5264

+ ((double)(*((RAtom __far * *)objClosest))->ztrl)/40.;

5265

arad = (double)ElemVDWRadius((*((RAtom __far * *)objClosest))->elemno);

5266

vdwdtemp = sqrt((coord[0]-acoord[0])*(coord[0]-acoord[0]) +

5267

(coord[1]-acoord[1])*(coord[1]-acoord[1]) +

5268

(coord[2]-acoord[2])*(coord[2]-acoord[2]))-arad;

5269

if (fabs(vdwdtemp) <= SearchRadius-((ProbeRadius < 10)?350:ProbeRadius)) {

5270

vdwpcount++;

5271

if (vdwpcount == 1) {

5272

vdwdistmin = vdwdistmax = vdwdtemp;

5273

} else {

5274

if (vdwdtemp < vdwdistmin) vdwdistmin = vdwdtemp;

5275

if (vdwdtemp > vdwdistmax) vdwdistmax = vdwdtemp;

5276

}

5277

vdwdistmean += vdwdtemp;

5278

vdwvariance += vdwdtemp*vdwdtemp;

5279

}

5280

}

5281

5282

5283

if (!CNearTreeFindKNearest(AtomTree,2,(double)(SearchRadius),NULL,atomsclosest,coord,1)) {

5284

switch (CVectorSize(atomsclosest)) {

5285

case 0: break;

5286

case 1:

5287

objClosest = CVectorElementAt(atomsclosest,0);

5288

acoord[0] = (double)(**((RAtom __far * * *)objClosest))->xorg

5289

+ (double)(**((RAtom __far * * *)objClosest))->fxorg

5290

+ ((double)(**((RAtom __far * * *)objClosest))->xtrl)/40.;

5291

acoord[1] = (double)(**((RAtom __far * * *)objClosest))->yorg

5292

+ (double)(**((RAtom __far * * *)objClosest))->fyorg

5293

+ ((double)(**((RAtom __far * * *)objClosest))->ytrl)/40.;

5294

acoord[2] = (double)(**((RAtom __far * * *)objClosest))->zorg

5295

+ (double)(**((RAtom __far * * *)objClosest))->fzorg

5296

+ ((double)(**((RAtom __far * * *)objClosest))->ztrl)/40.;

5297

arad = (double)ElemVDWRadius((**((RAtom __far * * * )objClosest))->elemno);

5298

dtemp = sqrt((coord[0]-acoord[0])*(coord[0]-acoord[0]) +

5299

(coord[1]-acoord[1])*(coord[1]-acoord[1]) +

5300

(coord[2]-acoord[2])*(coord[2]-acoord[2]))-arad;

5301

if (fabs(dtemp) <= SearchRadius-((ProbeRadius < 10)?350:ProbeRadius)) {

5302

lrpcount++;

5303

if (lrpcount == 1) {

5304

lrdistmin = lrdistmax = dtemp;

5305

} else {

5306

if (dtemp < lrdistmin) lrdistmin = dtemp;

5307

if (dtemp > lrdistmax) lrdistmax = dtemp;

5308

}

5309

lrdistmean += dtemp;

5310

lrvariance += dtemp*dtemp;

5311

}

5312

break;

5313

case 2:

5314

objClosest = CVectorElementAt(atomsclosest,0);

5315

acoord[0] = (double)(**((RAtom __far * * *)objClosest))->xorg

5316

+ (double)(**((RAtom __far * * *)objClosest))->fxorg

5317

+ ((double)(**((RAtom __far * * *)objClosest))->xtrl)/40.;

5318

acoord[1] = (double)(**((RAtom __far * * *)objClosest))->yorg

5319

+ (double)(**((RAtom __far * * *)objClosest))->fyorg

5320

+ ((double)(**((RAtom __far * * *)objClosest))->ytrl)/40.;

5321

acoord[2] = (double)(**((RAtom __far * * *)objClosest))->zorg

5322

+ (double)(**((RAtom __far * * *)objClosest))->fzorg

5323

+ ((double)(**((RAtom __far * * *)objClosest))->ztrl)/40.;

5324

arad = (double)ElemVDWRadius((**((RAtom __far * * *)objClosest))->elemno);

5325

objClosest = CVectorElementAt(atomsclosest,1);

5326

bcoord[0] = (double)(**((RAtom __far * * *)objClosest))->xorg

5327

+ (double)(**((RAtom __far * * *)objClosest))->fxorg

5328

+ ((double)(**((RAtom __far * * *)objClosest))->xtrl)/40.;

5329

bcoord[1] = (double)(**((RAtom __far * * *)objClosest))->yorg

5330

+ (double)(**((RAtom __far * * *)objClosest))->fyorg

5331

+ ((double)(**((RAtom __far * * *)objClosest))->ytrl)/40.;

5332

bcoord[2] = (double)(**((RAtom __far * * *)objClosest))->zorg

5333

+ (double)(**((RAtom __far * * *)objClosest))->fzorg

5334

+ ((double)(**((RAtom __far * * *)objClosest))->ztrl)/40.;

5335

brad = (double)ElemVDWRadius((**((RAtom __far * * *)objClosest))->elemno);

5336

dtemp = surfdist(coord,acoord,bcoord,arad,brad,(double)((ProbeRadius < 10)?350:ProbeRadius));

5337

lrpcount++;

5338

if (lrpcount == 1) {

5339

lrdistmin = lrdistmax = dtemp;

5340

} else {

5341

if (dtemp < lrdistmin) lrdistmin = dtemp;

5342

if (dtemp > lrdistmax) lrdistmax = dtemp;

5343

}

5344

lrdistmean += dtemp;

5345

lrvariance += dtemp*dtemp;

5346

break;

5347

}

5348

5349

}

5350

}

5351

5352

5353

}

5354

}

5355

}

5356

5357

sprintf(buffer," points in mesh, points used in distances:\n total %d, used %d, within %g of surface\n",

5358

vdwptotal, vdwpcount, ((double)(SearchRadius-((ProbeRadius < 10)?350:ProbeRadius)))/250.);

5359

WriteString(buffer);

5360

if (vdwpcount > 0) {

5361

vdwdistmean /= (250.*(double)vdwpcount);

5362

vdwvariance /= (250.*250.*(double)vdwpcount)-vdwdistmean;

5363

vdwdistmin /= 250.;

5364

vdwdistmax /= 250.;

5365

sprintf(buffer," distance to selected van der Waals surface:\n mean %#g, min %#g, max %#g, esd %#g\n",

5366

vdwdistmean, vdwdistmin, vdwdistmax, sqrt(vdwvariance) );

5367

WriteString(buffer);

5368

}

5369

5370

if (lrpcount > 0) {

5371

lrdistmean /= (250.*(double)lrpcount);

5372

lrvariance /= (250.*250.*(double)lrpcount)-lrdistmean;

5373

lrdistmin /= 250.;

5374

lrdistmax /= 250.;

5375

sprintf(buffer," distance to selected Lee-Richards surface:\n mean %#g, min %#g, max %#g, esd %#g\n",

5376

lrdistmean, lrdistmin, lrdistmax, sqrt(lrvariance) );

5377

WriteString(buffer);

5378

}

5379

5380

CVectorFree(&atomsclosest);

5381

return;

5382

5383

5384

}

5385

5386

5387

void ApplyMapShow( void ) {

5388

int j;

5389

MapInfo *mapinfo;

5390

char buffer[1124];

5391

5392

InvalidateCmndLine();

5393

5394

if (MapFlag & MapSelectFlag) {

5395

sprintf(buffer,"map new %s %s %#lg spacing %#lg spread %#lg\n",

5396

MapFlag&MapSurfFlag?"surface":(MapFlag&MapMeshFlag?"mesh":(

5397

MapFlag&MapPointFlag?"dots":"unknown") ),

5398

MapFlag&MapMeanFlag?"level MEAN ":"level ",(double)MapLevel,

5399

(double)MapSpacing/250., (double)MapSpread);

5400

WriteString(buffer);

5401

if (MapMaskPtr) {

5402

sprintf(buffer,"mask: mean %#g, esd %#g, min %#g, max %#g\n",

5403

MapMaskPtr->mapdatamean,

5404

MapMaskPtr->mapdataesd,

5405

MapMaskPtr->mapdatamin,

5406

MapMaskPtr->mapdatamax );

5407

WriteString(buffer);

5408

}

5409

}

5410

5411

if (MapInfoPtr) {

5412

for (j=0; j < MapInfoPtr->size; j++) {

5413

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

5414

if (mapinfo->flag&MapSelectFlag) {

5415

sprintf(buffer,"map %d: %s %s %lg spacing %#lg spread %#lg %s %s\n",j+1,

5416

mapinfo->flag&MapSurfFlag?"surface":(mapinfo->flag&MapMeshFlag?"mesh":(

5417

mapinfo->flag&MapPointFlag?"dots":"unknown") ),

5418

mapinfo->flag&MapMeanFlag?"level MEAN ":"level ",(double)mapinfo->MapLevel,

5419

(double)mapinfo->MapSpacing/250., (double)mapinfo->MapSpread,

5420

mapinfo->MapFile?"file: ":"",

5421

mapinfo->MapFile?mapinfo->MapFile:"");

5422

WriteString(buffer);

5423

if (mapinfo->MapLabel) {

5424

WriteString("label: ");

5425

WriteString(mapinfo->MapLabel);

5426

WriteString("\n");

5427

}

5428

if (mapinfo->MapPtr) {

5429

sprintf(buffer,"map: mean %#g, esd %#g, min %#g, max %#g\n",

5430

mapinfo->MapPtr->mapdatamean,

5431

mapinfo->MapPtr->mapdataesd,

5432

mapinfo->MapPtr->mapdatamin,

5433

mapinfo->MapPtr->mapdatamax );

5434

WriteString(buffer);

5435

ApplyMapAtomShow( 1000 + ((ProbeRadius< 10)?350:ProbeRadius) );

5436

} else {

5437

WriteString("map: NONE\n");

5438

}

5439

if (mapinfo->MapMaskPtr) {

5440

sprintf(buffer,"mask: mean %#g, esd %#g, min %#g, max %#g\n",

5441

mapinfo->MapMaskPtr->mapdatamean,

5442

mapinfo->MapMaskPtr->mapdataesd,

5443

mapinfo->MapMaskPtr->mapdatamin,

5444

mapinfo->MapMaskPtr->mapdatamax );

5445

WriteString(buffer);

5446

}

5447

}

5448

}

5449

}

5450

return;

5451

}

5452

5453

5454

int ApplyMapMask(int mapno ) {

5455

int i,j;

5456

MapInfo *mapinfo, *omapinfo;

5457

MapStruct __far *mapmaskptr;

5458

MapAtmSelVec __far *mapmaskgensel;

5459

Long flag;

5460

5461

ApplyMapSelection();

5462

if (MapSpacing <= 0) MapSpacing = 250L;

5463

5464

if (MapInfoPtr) {

5465

if (mapno != -1 && mapno > MapInfoPtr->size) {

5466

CommandError(MsgStrs[ErrBadArg]);

5467

return 1;

5468

}

5469

if (mapno > 0) {

5470

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,mapno-1);

5471

if (!mapinfo || !mapinfo->MapPtr) {

5472

CommandError(MsgStrs[ErrBadArg]);

5473

return 1;

5474

}

5475

}

5476

for (j=-1; j==-1 || j < MapInfoPtr->size; j++) {

5477

mapmaskgensel = NULL;

5478

mapmaskptr = NULL;

5479

5480

if (j >=0 ) {

5481

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&mapinfo,j );

5482

flag = mapinfo->flag;

5483

} else {

5484

flag=MapFlag;

5485

}

5486

5487

if (flag&MapSelectFlag) {

5488

if (mapno == 0) {

5489

5490

if (MapSpread < 0.) MapSpread = 2.*(double)MapSpacing/750.;

5491

5492

if(generate_map(&mapmaskptr,MapSpacing,

5493

MapSpacing, MapSpacing, 0L, 0L, 0L,

5494

(Long)(250.*(1.+MapSpread)+MapSpacing),

5495

(MapSpread > 0.)?(1./MapSpread):0., (flag&MapScaleFlag)?1:0 )){

5496

CommandError(MsgStrs[StrMalloc]);

5497

return 1;

5498

}

5499

5500

vector_create((GenericVec __far **)&mapmaskgensel,sizeof(MapAtmSel),10);

5501

WriteMapAtoms(mapmaskgensel);

5502

} else if (mapno > 0) {

5503

if ( mapno <= MapInfoPtr->size ) {

5504

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&omapinfo,mapno-1 );

5505

if (omapinfo && omapinfo->MapPtr) {

5506

mapmaskptr = _fmalloc(sizeof(MapStruct));

5507

if(!mapmaskptr) {

5508

CommandError(MsgStrs[StrMalloc]);

5509

return 1;

5510

}

5511

mapmaskptr->mapdata = _fmalloc(omapinfo->MapPtr->elsize*

5512

((omapinfo->MapPtr)->xhigh-(omapinfo->MapPtr)->xlow+1)*

5513

((omapinfo->MapPtr)->yhigh-(omapinfo->MapPtr)->ylow+1)*

5514

((omapinfo->MapPtr)->zhigh-(omapinfo->MapPtr)->zlow+1));

5515

if(!mapmaskptr->mapdata) {

5516

_ffree(mapmaskptr);

5517

CommandError(MsgStrs[StrMalloc]);

5518

return 1;

5519

}

5520

mapmaskptr->elsize=omapinfo->MapPtr->elsize;

5521

mapmaskptr->eltype=omapinfo->MapPtr->eltype;

5522

mapmaskptr->maptype=omapinfo->MapPtr->maptype;

5523

mapmaskptr->adiv=omapinfo->MapPtr->adiv;

5524

mapmaskptr->bdiv=omapinfo->MapPtr->bdiv;

5525

mapmaskptr->cdiv=omapinfo->MapPtr->cdiv;

5526

mapmaskptr->xint=omapinfo->MapPtr->xint;

5527

mapmaskptr->yint=omapinfo->MapPtr->yint;

5528

mapmaskptr->zint=omapinfo->MapPtr->zint;

5529

mapmaskptr->xorig=omapinfo->MapPtr->xorig;

5530

mapmaskptr->yorig=omapinfo->MapPtr->yorig;

5531

mapmaskptr->zorig=omapinfo->MapPtr->zorig;

5532

mapmaskptr->xlow=omapinfo->MapPtr->xlow;

5533

mapmaskptr->ylow=omapinfo->MapPtr->ylow;

5534

mapmaskptr->zlow=omapinfo->MapPtr->zlow;

5535

mapmaskptr->xhigh=omapinfo->MapPtr->xhigh;

5536

mapmaskptr->yhigh=omapinfo->MapPtr->yhigh;

5537

mapmaskptr->zhigh=omapinfo->MapPtr->zhigh;

5538

mapmaskptr->mapdatamin=omapinfo->MapPtr->mapdatamin;

5539

mapmaskptr->mapdatamax=omapinfo->MapPtr->mapdatamax;

5540

mapmaskptr->mapdatamean=omapinfo->MapPtr->mapdatamean;

5541

mapmaskptr->mapdataesd=omapinfo->MapPtr->mapdataesd;

5542

for (i=0; i<9; i++) {

5543

mapmaskptr->mapm2r[i]=omapinfo->MapPtr->mapm2r[i];

5544

mapmaskptr->mapr2m[i]=omapinfo->MapPtr->mapr2m[i];

5545

}

5546

for (i=0; i<3; i++) {

5547

mapmaskptr->mapxlate[i]=omapinfo->MapPtr->mapxlate[i];

5548

}

5549

memmove(mapmaskptr->mapdata,omapinfo->MapPtr->mapdata,

5550

((mapmaskptr)->xhigh-(mapmaskptr)->xlow+1)

5551

*((mapmaskptr)->yhigh-(mapmaskptr)->ylow+1)

5552

*((mapmaskptr)->zhigh-(mapmaskptr)->zlow+1)

5553

*((mapmaskptr)->elsize));

5554

if (omapinfo->MapGenSel) {

5555

MapAtmSel *mapatmsel;

5556

vector_create((GenericVec __far **)&mapmaskgensel,sizeof(MapAtmSel),10);

5557

for (i = 0; i < omapinfo->MapGenSel->size; i++) {

5558

vector_get_elementptr((GenericVec __far *)omapinfo->MapGenSel,(void __far * __far *)&mapatmsel,i );

5559

vector_set_element((GenericVec __far *)mapmaskgensel,mapatmsel,i);

5560

}

5561

}

5562

}

5563

}

5564

}

5565

if (j < 0 ) {

5566

if (MapMaskPtr) {

5567

if (MapMaskPtr->mapdata)_ffree((void __far *)MapMaskPtr->mapdata);

5568

_ffree((void __far *)MapMaskPtr);

5569

}

5570

MapMaskPtr = mapmaskptr;

5571

} else {

5572

if (mapinfo->MapMaskPtr) {

5573

if (mapinfo->MapMaskPtr->mapdata)_ffree((void __far *)mapinfo->MapMaskPtr->mapdata);

5574

_ffree((void __far *)mapinfo->MapMaskPtr);

5575

}

5576

mapinfo->MapMaskPtr = mapmaskptr;

5577

}

5578

if (j < 0 ) {

5579

if (MapMaskGenSel) {

5580

vector_free((GenericVec __far * __far *)&(MapMaskGenSel ) );

5581

}

5582

MapMaskGenSel=mapmaskgensel;

5583

} else {

5584

if (mapinfo->MapMaskGenSel) {

5585

vector_free((GenericVec __far * __far *)&(mapinfo->MapMaskGenSel ) );

5586

}

5587

mapinfo->MapMaskGenSel=mapmaskgensel;

5588

}

5589

}

5590

}

5591

}

5592

MapReRadius();

5593

ReRadius();

5594

ReDrawFlag |= RFInitial|RFColour;

5595

return 0;

5596

}

5597

5598

/* Generate a new map for the current molecule */

5599

5600

static int ExecuteGenerateCommand( int mapflags ) {

5601

int i, j;

5602

MapInfo mapinfo;

5603

MapInfo *omapinfo;

5604

MapStruct __far *mapmaskptr;

5605

MapAtmSelVec __far *mapmaskgensel;

5606

Long MapSpaceAdjust;

5607

int mapallocfailed;

5608

char buffer[60];

5609

5610

ApplyMapSelection();

5611

if (MapSpacing <= 0) MapSpacing = 250L;

5612

5613

/* Initialize a mapinfo struct */

5614

5615

mapinfo.MapLevel = MapLevel;

5616

mapinfo.MapSpacing = MapSpacing;

5617

if (mapinfo.MapSpacing < 25) mapinfo.MapSpacing = 25;

5618

if (MapSpread < 0.) MapSpread = 2.*((double)(MapSpacing))/750.;

5619

mapinfo.MapSpread = MapSpread;

5620

mapinfo.flag = SelectFlag|mapflags;

5621

if (mapinfo.flag&MapLRSurfFlag) {

5622

mapinfo.MapSpread = 0.;

5623

mapinfo.MapLevel = 1.;

5624

mapinfo.flag &= ~(MapMeanFlag|MapScaleFlag);

5625

}

5626

mapinfo.MapPointsPtr = NULL;

5627

mapinfo.MapBondsPtr = NULL;

5628

mapinfo.MapTanglePtr = NULL;

5629

mapinfo.MapPtr = NULL;

5630

mapinfo.MapMaskPtr = NULL;

5631

mapinfo.MapFile = NULL;

5632

mapinfo.MapGenSel = NULL;

5633

mapinfo.MapMaskGenSel = NULL;

5634

mapinfo.MapRGBCol[0] = MapRGBCol[0];

5635

mapinfo.MapRGBCol[1] = MapRGBCol[1];

5636

mapinfo.MapRGBCol[2] = MapRGBCol[2];

5637

mapinfo.MapMeshRad = MapMeshRad;

5638

mapinfo.MapPointRad = MapPointRad;

5639

mapinfo.MapLabel = MapLabel;

5640

MapLabel = NULL;

5641

if (MapMaskPtr) {

5642

mapmaskptr = _fmalloc(sizeof(MapStruct));

5643

if(!mapmaskptr) {

5644

CommandError(MsgStrs[StrMalloc]);

5645

return 1;

5646

}

5647

mapmaskptr->mapdata = _fmalloc(MapMaskPtr->elsize*

5648

((MapMaskPtr)->xhigh-(MapMaskPtr)->xlow+1)*

5649

((MapMaskPtr)->yhigh-(MapMaskPtr)->ylow+1)*

5650

((MapMaskPtr)->zhigh-(MapMaskPtr)->zlow+1));

5651

if(!mapmaskptr->mapdata) {

5652

_ffree(mapmaskptr);

5653

CommandError(MsgStrs[StrMalloc]);

5654

return 1;

5655

}

5656

mapmaskptr->elsize=MapMaskPtr->elsize;

5657

mapmaskptr->eltype=MapMaskPtr->eltype;

5658

mapmaskptr->maptype=MapMaskPtr->maptype;

5659

mapmaskptr->adiv=MapMaskPtr->adiv;

5660

mapmaskptr->bdiv=MapMaskPtr->bdiv;

5661

mapmaskptr->cdiv=MapMaskPtr->cdiv;

5662

mapmaskptr->xint=MapMaskPtr->xint;

5663

mapmaskptr->yint=MapMaskPtr->yint;

5664

mapmaskptr->zint=MapMaskPtr->zint;

5665

mapmaskptr->xorig=MapMaskPtr->xorig;

5666

mapmaskptr->yorig=MapMaskPtr->yorig;

5667

mapmaskptr->zorig=MapMaskPtr->zorig;

5668

mapmaskptr->xlow=MapMaskPtr->xlow;

5669

mapmaskptr->ylow=MapMaskPtr->ylow;

5670

mapmaskptr->zlow=MapMaskPtr->zlow;

5671

mapmaskptr->xhigh=MapMaskPtr->xhigh;

5672

mapmaskptr->yhigh=MapMaskPtr->yhigh;

5673

mapmaskptr->zhigh=MapMaskPtr->zhigh;

5674

mapmaskptr->mapdatamin=MapMaskPtr->mapdatamin;

5675

mapmaskptr->mapdatamax=MapMaskPtr->mapdatamax;

5676

mapmaskptr->mapdatamean=MapMaskPtr->mapdatamean;

5677

mapmaskptr->mapdataesd=MapMaskPtr->mapdataesd;

5678

for (i=0; i<9; i++) {

5679

mapmaskptr->mapm2r[i]=MapMaskPtr->mapm2r[i];

5680

mapmaskptr->mapr2m[i]=MapMaskPtr->mapr2m[i];

5681

}

5682

for (i=0; i<3; i++) {

5683

mapmaskptr->mapxlate[i]=MapMaskPtr->mapxlate[i];

5684

}

5685

memmove(mapmaskptr->mapdata,MapMaskPtr->mapdata,

5686

((mapmaskptr)->xhigh-(mapmaskptr)->xlow+1)

5687

*((mapmaskptr)->yhigh-(mapmaskptr)->ylow+1)

5688

*((mapmaskptr)->zhigh-(mapmaskptr)->zlow+1)

5689

*((mapmaskptr)->elsize));

5690

mapinfo.MapMaskPtr = mapmaskptr;

5691

}

5692

if (MapMaskGenSel) {

5693

MapAtmSel *mapatmsel;

5694

vector_create((GenericVec __far **)&mapmaskgensel,sizeof(MapAtmSel),10);

5695

for (i = 0; i < MapMaskGenSel->size; i++) {

5696

vector_get_elementptr((GenericVec __far *)MapMaskGenSel,(void __far * __far *)&mapatmsel,i );

5697

vector_set_element((GenericVec __far *)mapmaskgensel,mapatmsel,i);

5698

}

5699

mapinfo.MapMaskGenSel = mapmaskgensel;

5700

}

5701

5702

MapSpaceAdjust = 1.;

5703

5704

5705

do {

5706

mapallocfailed=

5707

generate_map(&mapinfo.MapPtr,mapinfo.MapSpacing*MapSpaceAdjust, mapinfo.MapSpacing*MapSpaceAdjust, mapinfo.MapSpacing*MapSpaceAdjust, 0L, 0L, 0L,

5708

(Long)(250.*(1.+mapinfo.MapSpread)+mapinfo.MapSpacing), (mapinfo.MapSpread>0.)?1./mapinfo.MapSpread:0.,

5709

(mapinfo.flag&MapScaleFlag)?1:0 );

5710

if (!mapallocfailed || MapSpaceAdjust >= 8) break;

5711

MapSpaceAdjust *= 2;

5712

sprintf(buffer," Trying coarser map spacing %g\n",((double)(mapinfo.MapSpacing*MapSpaceAdjust))/250.);

5713

WriteString(buffer);

5714

} while (True);

5715

5716

if (mapallocfailed) {

5717

CommandError(MsgStrs[StrMalloc]);

5718

if (mapinfo.MapMaskGenSel) vector_free((GenericVec __far * __far *)&(mapinfo.MapMaskGenSel));

5719

if (mapinfo.MapMaskPtr) {

5720

_ffree((void __far *)(mapinfo.MapMaskPtr)->mapdata);

5721

_ffree((void __far *)mapinfo.MapMaskPtr);

5722

}

5723

}

5724

5725

mapinfo.MapSpacing *= MapSpaceAdjust;

5726

vector_create((GenericVec __far **)&mapinfo.MapGenSel,sizeof(MapAtmSel),10);

5727

WriteMapAtoms(mapinfo.MapGenSel);

5728

5729

5730

if (mapinfo.flag&(MapPointFlag|MapMeshFlag|MapSurfFlag)) {

5731

vector_create((GenericVec __far **)&mapinfo.MapPointsPtr,sizeof(MapPoint),1000);

5732

if (mapinfo.flag&(MapMeshFlag))

5733

vector_create((GenericVec __far **)&mapinfo.MapBondsPtr,sizeof(MapBond),1000);

5734

if (mapinfo.flag&(MapSurfFlag))

5735

vector_create((GenericVec __far **)&mapinfo.MapTanglePtr,sizeof(MapTangle),1000);

5736

map_points(mapinfo.MapPtr,

5737

mapinfo.MapLevel+((mapinfo.flag&MapMeanFlag)?mapinfo.MapPtr->mapdatamean:0.),

5738

mapinfo.MapSpacing, mapinfo.MapPointsPtr,mapinfo.MapBondsPtr,mapinfo.MapTanglePtr,

5739

mapinfo.MapMaskPtr, mapinfo.MapRGBCol );

5740

5741

if (MapFlag&MapNoSelectFlag) {

5742

vector_add_element((GenericVec __far *)MapInfoPtr,(void __far *)&mapinfo);

5743

} else {

5744

if (MapFlag&MapSelectFlag) {

5745

vector_add_element((GenericVec __far *)MapInfoPtr,(void __far *)&mapinfo);

5746

} else {

5747

for (j=0; j < MapInfoPtr->size; j++) {

5748

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&omapinfo,j );

5749

if (omapinfo->flag&MapSelectFlag) {

5750

DeleteMap(j, False);

5751

vector_set_element((GenericVec __far *)MapInfoPtr,(void __far *)&mapinfo,j);

5752

break;

5753

}

5754

}

5755

5756

}

5757

5758

}

5759

5760

MapReRadius();

5761

ReRadius();

5762

ReDrawFlag |= RFInitial|RFColour;

5763

}

5764

return 0;

5765

}

5766

5767

/* Execute a command given as

5768

{(<selection>){.}}command

5769

if a selection is provided, it applies only during

5770

execution of this command, except for the following

5771

commands, the prior selection is not restored:

5772

5773

Select

5774

Restrict

5775

Script

5776

5777

*/

5778

5779

5780

int ExecuteCommandOne( int * );

5781

5782

int ExecuteCommand( void )

5783

{

5784

5785

int xret;

5786

int restore;

5787

5788

TokenPtr = CurLine;

5789

if( !FetchToken() )

5790

{ TokenPtr = NULL;

5791

return False;

5792

}

5793

5794

restore = 1;

5795

5796

if (CurToken == '(') {

5797

SaveAtomSelection();

5798

FetchToken();

5799

if( CurToken==AllTok )

5800

{ SelectZone(AllAtomFlag);

5801

} else if( CurToken==NoneTok )

5802

{ SelectZone(0x00);

5803

} else if( CurToken==ViewTok )

5804

{ SelectArea(False,True,1,1,XRange,YRange);

5805

} else if( CurToken=='<' )

5806

{ ReadAtomSelection(True);

5807

} else if( CurToken=='>' )

5808

{ ReadAtomSelection(False);

5809

} else if ( CurToken != ')')

5810

{ QueryExpr = ParseExpression(0);

5811

if( QueryExpr )

5812

{ if( CurToken == ')' )

5813

{ SelectZoneExpr(QueryExpr);

5814

FetchToken();

5815

xret=ExecuteCommandOne(&restore);

5816

if ( restore ) LoadAtomSelection();

5817

DeAllocateExpr(QueryExpr);

5818

return xret;

5819

} else CommandError(MsgStrs[ErrSyntax]);

5820

DeAllocateExpr(QueryExpr);

5821

}

5822

} else

5823

{ CommandError(MsgStrs[ErrSyntax]);

5824

return False;

5825

}

5826

NeedAtomTree = 1;

5827

FetchToken();

5828

if( CurToken == ')' ) {

5829

FetchToken();

5830

xret=ExecuteCommandOne(&restore);

5831

if ( restore ) {

5832

LoadAtomSelection();

5833

NeedAtomTree = 1;

5834

}

5835

return xret;

5836

}else

5837

{ CommandError(MsgStrs[ErrSyntax]);

5838

return False;

5839

}

5840

5841

}

5842

else return ExecuteCommandOne(&restore);

5843

}

5844

5845

5846

int ExecuteCommandOne( int * restore )

5847

{

5848

register char *param;

5849

register int option;

5850

register int i,done;

5851

register Long temp;

5852

int suboption;

5853

FILE *script;

5854

5855

if( !CurToken ) {

5856

TokenPtr = NULL;

5857

return False;

5858

}

5859

5860

if (CurToken=='.') {

5861

if( !FetchToken() ) {

5862

TokenPtr = NULL;

5863

return False;

5864

}

5865

}

5866

5867

*restore = 1;

5868

if (CurToken == SelectTok

5869

|| CurToken == RestrictTok

5870

|| CurToken == ScriptTok) *restore = 0;

5871

5872

switch( CurToken )

5873

{ case(AxesTok): ExecuteAxesCommand(); break;

5874

case(BoundBoxTok): ExecuteBoundBoxCommand(); break;

5875

case(BulgarianTok): SwitchLang(Bulgarian); break;

5876

case(CentreTok): ExecuteCentreCommand(); break;

5877

case(ChineseTok): SwitchLang(Chinese); break;

5878

case(ClipboardTok): ExecuteClipboardCommand(); break;

5879

case(ColourTok): ExecuteColourCommand(); break;

5880

case(ConnectTok): ExecuteConnectCommand(); break;

5881

case(DeferTok): ExecuteDeferCommand(); break;

5882

case(EnglishTok): SwitchLang(English); break;

5883

case(ExecuteTok): ExecuteExecuteCommand(); break;

5884

case(FrenchTok): SwitchLang(French); break;

5885

case(GenerateTok): ExecuteGenerateCommand(MapMeshFlag);

5886

break;

5887

case(ItalianTok): SwitchLang(Italian); break;

5888

case(JapaneseTok): SwitchLang(Japanese); break;

5889

case(LoadTok): ExecuteLoadCommand(); break;

5890

case(WaitTok): ExecutePauseCommand(); break;

5891

case(PickingTok): ExecutePickingCommand(); break;

5892

case(PrintTok): ExecutePrintCommand(); break;

5893

case(RussianTok): SwitchLang(Russian); break;

5894

case(SetTok): ExecuteSetCommand(); break;

5895

case(ShowTok): ExecuteShowCommand(); break;

5896

case(SpanishTok): SwitchLang(Spanish); break;

5897

case(TitleTok): ExecuteTitleCommand(); break;

5898

case(UnitCellTok): ExecuteUnitCellCommand(); break;

5899

5900

case(TimeTok):

5901

{ double prevtime;

5902

char buffer[40];

5903

prevtime = CommandTime;

5904

CommandTime = ((double)(clock()))/CLOCKS_PER_SEC;

5905

if (prevtime) {

5906

sprintf(buffer," Time: %g, Delta Time: %g\n", CommandTime, CommandTime-prevtime);

5907

} else {

5908

sprintf(buffer," Time: %g\n", CommandTime);

5909

}

5910

WriteString(buffer);

5911

}

5912

break;

5913

5914

case(RefreshTok): RefreshScreen();

5915

ReDrawFlag = NextReDrawFlag; break;

5916

5917

5918

case(ZapTok): FetchToken();

5919

if ( CurToken == MapTok ) {

5920

DeleteMaps(); break;

5921

} else if (!CurToken) {

5922

ZapDatabase(); break;

5923

} else CommandError(MsgStrs[ErrBadArg]);

5924

break;

5925

5926

case (ColourModeTok): /* gm */

5927

FetchToken();

5928

if (CurToken == TrueTok)

5929

{

5930

UseOldColorCode = 1;

5931

WriteString(MsgStrs[StrCCompOn]);

5932

}

5933

else if (CurToken == FalseTok)

5934

{

5935

UseOldColorCode = 0;

5936

WriteString(MsgStrs[StrCCompOff]);

5937

}

5938

else {

5939

if (!NoToggle) {

5940

if (UseOldColorCode)

5941

{

5942

UseOldColorCode = 0;

5943

WriteString(MsgStrs[StrCCompOff]);

5944

}

5945

else

5946

{

5947

UseOldColorCode = 1;

5948

WriteString(MsgStrs[StrCCompOn]);

5949

}

5950

}

5951

else

5952

{

5953

CommandError(MsgStrs[ErrNoToggle]);

5954

}

5955

}

5956

break;

5957

5958

case (NoToggleTok): /* gm */

5959

5960

FetchToken();

5961

if (CurToken == TrueTok)

5962

{

5963

NoToggle = 1;

5964

WriteString(MsgStrs[StrNoTogOn]);

5965

}

5966

else if (CurToken == FalseTok)

5967

{

5968

NoToggle = 0;

5969

WriteString(MsgStrs[StrNoTogOff]);

5970

}

5971

else {

5972

NoToggle = 1;

5973

WriteString(MsgStrs[StrNoTogOn]);

5974

}

5975

break;

5976

5977

5978

case(BondTok): FetchToken();

5979

if( CurToken == NumberTok )

5980

{ temp = TokenValue;

5981

FetchToken();

5982

if( CurToken == ',' )

5983

FetchToken();

5984

if( CurToken == NumberTok )

5985

{ Long temp2;

5986

5987

temp2 = TokenValue;

5988

FetchToken();

5989

if ( (!CurToken) || CurToken == '+' ) {

5990

CreateBondOrder(temp, temp2);

5991

ReDrawFlag |= RFInitial;

5992

} else if ( CurToken == PickingTok ) {

5993

CreateBondAxis(temp,TokenValue);

5994

ReDrawFlag |= RFInitial;

5995

} else CommandError(MsgStrs[ErrBadArg]);

5996

} else CommandError(MsgStrs[ErrNotNum]);

5997

} else if (CurToken==RotateTok)

5998

{ FetchToken();

5999

if(BondSelected &&

6000

(!CurToken || CurToken==TrueTok))

6001

{ RotMode = RotBond;

6002

ReDrawFlag |= RFRotBond;

6003

} else if(CurToken==FalseTok)

6004

{ if( RotMode == RotBond )

6005

{ RotMode = RotMol;

6006

ReDrawFlag |= RFRotate;

6007

}

6008

} else CommandError(MsgStrs[ErrBadArg]);

6009

} else CommandError(MsgStrs[ErrBadArg]);

6010

break;

6011

6012

case(UnBondTok): FetchToken();

6013

if( CurToken == NumberTok )

6014

{ temp = TokenValue;

6015

FetchToken();

6016

if( CurToken == ',' )

6017

FetchToken();

6018

if( CurToken == NumberTok )

6019

{ if (RemoveBond(temp,TokenValue)) {

6020

ReDrawFlag |= RFInitial;

6021

} else {

6022

CommandError(MsgStrs[ErrBadArg]);

6023

}

6024

} else CommandError(MsgStrs[ErrNotNum]);

6025

} else if( (!CurToken) && BondSelected )

6026

{ if (RemoveBond(BSrcAtom->serno,BDstAtom->serno)) {

6027

BSrcAtom = NULL; BDstAtom = NULL;

6028

ReDrawFlag |= RFRefresh;

6029

BondSelected = False;

6030

} else {

6031

CommandError(MsgStrs[ErrBadArg]);

6032

}

6033

} else CommandError(MsgStrs[ErrBadArg]);

6034

break;

6035

6036

case(MoleculeTok):

6037

FetchToken();

6038

if (CurToken != NumberTok) {

6039

CommandError(MsgStrs[ErrBadArg]);

6040

break;

6041

}

6042

if (TokenValue < 1 || TokenValue > NumMolecules) {

6043

CommandError(MsgStrs[ErrBadArg]);

6044

break;

6045

}

6046

SelectMolecule(TokenValue-1);

6047

break;

6048

6049

case(SelectTok): FetchToken();

6050

if( !CurToken )

6051

{ option = NormAtomFlag;

6052

if( HetaGroups ) option |= HeteroFlag;

6053

if( Hydrogens ) option |= HydrogenFlag;

6054

SelectZone(option);

6055

} else if( CurToken==AllTok )

6056

{ SelectZone(AllAtomFlag);

6057

} else if( CurToken==NoneTok )

6058

{ SelectZone(0x00);

6059

} else if( CurToken==ViewTok )

6060

{ SelectArea(False,True,1,1,XRange,YRange);

6061

} else if( CurToken=='<' )

6062

{ ReadAtomSelection(True);

6063

} else if( CurToken=='>' )

6064

{ ReadAtomSelection(False);

6065

} else

6066

{ QueryExpr = ParseExpression(0);

6067

if( QueryExpr )

6068

{ if( !CurToken )

6069

{ SelectZoneExpr(QueryExpr);

6070

} else CommandError(MsgStrs[ErrSyntax]);

6071

DeAllocateExpr(QueryExpr);

6072

}

6073

}

6074

NeedAtomTree = 1;

6075

break;

6076

6077

case(RestrictTok):

6078

FetchToken();

6079

if( !CurToken )

6080

{ option = NormAtomFlag;

6081

if( HetaGroups ) option |= HeteroFlag;

6082

if( Hydrogens ) option |= HydrogenFlag;

6083

RestrictZone(option);

6084

ReDrawFlag |= RFRefresh;

6085

} else if( CurToken==AllTok )

6086

{ RestrictZone(AllAtomFlag);

6087

ReDrawFlag |= RFRefresh;

6088

} else if( CurToken==NoneTok )

6089

{ RestrictZone(0x00);

6090

ReDrawFlag |= RFRefresh;

6091

} else

6092

{ QueryExpr = ParseExpression(0);

6093

if( QueryExpr )

6094

{ if( !CurToken )

6095

{ RestrictZoneExpr(QueryExpr);

6096

ReDrawFlag |= RFRefresh;

6097

} else CommandError(MsgStrs[ErrSyntax]);

6098

DeAllocateExpr(QueryExpr);

6099

}

6100

}

6101

NeedAtomTree = 1;

6102

break;

6103

6104

6105

case(MapTok):

6106

SelectMaps();

6107

if (CurToken) {

6108

switch (CurToken) {

6109

int mapflags, j;

6110

FILE *fp;

6111

6112

case(DotsTok):

6113

FetchToken();

6114

if (CurToken==FalseTok) {

6115

MapFlag &= ~MapPointFlag;

6116

} else if( (CurToken==TrueTok) || !CurToken ) {

6117

MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6118

MapFlag |= MapPointFlag;

6119

} else if( CurToken==NumberTok && TokenValue >=0)

6120

{ if( *TokenPtr=='.' )

6121

{ TokenPtr++;

6122

FetchFloat(TokenValue,250);

6123

}

6124

6125

if( TokenValue<=500 )

6126

{ if (TokenValue !=0) {

6127

MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6128

MapFlag |= MapPointFlag;

6129

MapPointRad = TokenValue;

6130

} else {

6131

MapFlag &= ~MapPointFlag;

6132

}

6133

} else { CommandError(MsgStrs[ErrBigNum]); break;}

6134

} else if( CurToken=='.' ) {

6135

FetchFloat(0,250);

6136

if( TokenValue<=500 ) {

6137

MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6138

MapFlag |= MapPointFlag;

6139

MapPointRad = TokenValue;

6140

} else { CommandError(MsgStrs[ErrBigNum]); break;}

6141

} else if (!CurToken) {

6142

MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6143

MapFlag |= MapPointFlag;

6144

MapPointRad = 0;

6145

} else { CommandError(MsgStrs[ErrBadArg]); break; }

6146

ApplyMapSelection();

6147

ApplyMapFlag();

6148

ReDrawFlag |= RFRefresh;

6149

break;

6150

6151

case(WireframeTok):

6152

FetchToken();

6153

if (CurToken==FalseTok) {

6154

MapFlag &= ~MapMeshDashFlag;

6155

} else if( (CurToken==TrueTok) || !CurToken ) {

6156

MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6157

MapFlag |= MapMeshFlag;

6158

} else if( CurToken==DashTok )

6159

{ MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6160

MapFlag |= MapMeshDashFlag;

6161

} else if( CurToken==NumberTok && TokenValue >=0)

6162

{ if( *TokenPtr=='.' )

6163

{ TokenPtr++;

6164

FetchFloat(TokenValue,250);

6165

}

6166

6167

if( TokenValue<=500 )

6168

{ MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6169

MapFlag |= MapMeshFlag;

6170

MapMeshRad = TokenValue;

6171

} else { CommandError(MsgStrs[ErrBigNum]); break;}

6172

} else if( CurToken=='.' ) {

6173

FetchFloat(0,250);

6174

if( TokenValue<=500 ) {

6175

MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6176

MapFlag |= MapMeshFlag;

6177

MapMeshRad = TokenValue;

6178

} else { CommandError(MsgStrs[ErrBigNum]); break;}

6179

} else if (!CurToken) {

6180

MapFlag &= ~(MapPointFlag|MapMeshDashFlag|MapSurfFlag);

6181

MapFlag |= MapMeshFlag;

6182

MapMeshRad = 0;

6183

} else { CommandError(MsgStrs[ErrBadArg]); break; }

6184

ApplyMapSelection();

6185

ApplyMapFlag();

6186

ReDrawFlag |= RFRefresh;

6187

break;

6188

6189

case(SurfaceTok):

6190

MapFlag &= ~(MapPointFlag|MapMeshFlag|MapSurfFlag);

6191

MapFlag |= MapSurfFlag;

6192

FetchToken();

6193

if (CurToken) CommandError(MsgStrs[ErrBadArg]);

6194

else {

6195

ApplyMapSelection();

6196

ApplyMapFlag();

6197

}

6198

ReDrawFlag |= RFRefresh;

6199

break;

6200

6201

case(ScaleTok):

6202

FetchToken();

6203

if (CurToken == TrueTok || CurToken==ZTok || !CurToken) {

6204

MapFlag |= MapScaleFlag;

6205

} else if (CurToken == NoneTok || CurToken == FalseTok) {

6206

MapFlag &= ~MapScaleFlag;

6207

} else { CommandError(MsgStrs[ErrBadArg]);

6208

break;

6209

}

6210

ApplyMapSelection();

6211

ReDrawFlag |= RFRefresh;

6212

break;

6213

ApplyMapFlag();

6214

6215

6216

case(GenerateTok):

6217

mapflags = MapFlag;

6218

FetchToken();

6219

if (CurToken==MolSurfTok) {

6220

mapflags |= MapLRSurfFlag;

6221

FetchToken();

6222

}

6223

if (CurToken==DotsTok) {

6224

mapflags &= ~(MapPointFlag|MapMeshFlag|MapSurfFlag);

6225

mapflags |= MapPointFlag;

6226

FetchToken();

6227

} else if (CurToken==WireframeTok) {

6228

mapflags &= ~(MapPointFlag|MapMeshFlag|MapSurfFlag);

6229

mapflags |= MapMeshFlag;

6230

FetchToken();

6231

} else if (CurToken==SurfaceTok) {

6232

mapflags &= ~(MapPointFlag|MapMeshFlag|MapSurfFlag);

6233

mapflags |= MapSurfFlag;

6234

FetchToken();

6235

}

6236

if (CurToken==MolSurfTok) {

6237

mapflags |= MapLRSurfFlag;

6238

FetchToken();

6239

} else if (CurToken) {

6240

CommandError(MsgStrs[ErrBadArg]);

6241

break;

6242

}

6243

if (!(mapflags &(MapPointFlag|MapMeshFlag|MapSurfFlag)))

6244

mapflags |= MapPointFlag;

6245

ExecuteGenerateCommand(mapflags);

6246

break;

6247

6248

case(LoadTok):

6249

FetchToken();

6250

if( !Database ) {

6251

CommandError(MsgStrs[ErrBadMolDB]);

6252

break;

6253

}

6254

6255

if( CurToken==StringTok ) {

6256

ProcessFileName(TokenIdent);

6257

} else ProcessFileName(TokenStart);

6258

6259

if( !(fp=fopen(DataFileName,"rb")) ) {

6260

CommandError( (char*)NULL );

6261

WriteString(MsgStrs[StrDFile]);

6262

WriteString(DataFileName);

6263

WriteString("'!\n");

6264

break;

6265

}

6266

#ifdef USE_CBFLIB

6267

else {

6268

int mapno=0;

6269

MapInfo *omapinfo;

6270

if (MapFlag&MapNoSelectFlag) mapno=-1;

6271

else {

6272

ApplyMapSelection();

6273

if (MapFlag&MapSelectFlag) {

6274

mapno = -1;

6275

} else {

6276

for (j=0; j < MapInfoPtr->size; j++) {

6277

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&omapinfo,j );

6278

if (omapinfo->flag&MapSelectFlag) {

6279

DeleteMap(j,False);

6280

mapno=j;

6281

break;

6282

}

6283

}

6284

}

6285

}

6286

if(LoadCCP4MapFile(fp,(FileDepth == -1),mapno)) {

6287

if( !(fp=fopen(DataFileName,"rb")) ) {

6288

CommandError( (char*)NULL );

6289

WriteString(MsgStrs[StrErrFile]);

6290

WriteString(DataFileName);

6291

WriteString("'!\n");

6292

break;

6293

} else if (LoadCBFMapFile(fp,(FileDepth == -1),mapno)) {

6294

CommandError( (char*)NULL );

6295

WriteString(MsgStrs[StrErrFile]);

6296

WriteString(DataFileName);

6297

WriteString("'!\n");

6298

break;

6299

}

6300

}

6301

CurToken = 0;

6302

ReDrawFlag |= RFInitial|RFColour;

6303

}

6304

#else

6305

CommandError(MsgStrs[ErrBadArg]);

6306

#endif

6307

break;

6308

6309

6310

case(LevelTok):

6311

{

6312

int neg;

6313

6314

FetchToken();

6315

MapFlag &= ~MapMeanFlag;

6316

MapLevel = 1.;

6317

neg = False;

6318

if ( CurToken==MeanTok) {

6319

MapFlag |= MapMeanFlag;

6320

FetchToken();

6321

MapLevel = 0.;

6322

}

6323

if ( CurToken == '-' ) {

6324

neg = True;

6325

MapLevel *= -1.;

6326

FetchToken();

6327

}

6328

if ( CurToken==NumberTok)

6329

{ if( *TokenPtr=='.' )

6330

{ TokenPtr++;

6331

FetchFloat(TokenValue,1000);

6332

} else {

6333

TokenValue *= 1000;

6334

}

6335

if( TokenValue<=50000 )

6336

{ if (TokenValue > 0 || MapFlag&MapMeanFlag) {

6337

MapLevel = ((Real)TokenValue)/1000.;

6338

if (neg) MapLevel *= -1.;

6339

ApplyMapSelection();

6340

ApplyMapLevel();

6341

ReDrawFlag |= RFRefresh;

6342

break;

6343

} else CommandError(MsgStrs[ErrBigNum]);

6344

} else CommandError(MsgStrs[ErrBigNum]);

6345

} else if( CurToken=='.' ) { FetchFloat(0,1000);

6346

if( TokenValue<=50000 )

6347

{ MapLevel = ((Real)TokenValue)/1000.;

6348

if (neg) MapLevel *= -1.;

6349

ApplyMapSelection();

6350

ApplyMapLevel();

6351

ReDrawFlag |= RFRefresh;

6352

break;

6353

} else CommandError(MsgStrs[ErrBigNum]);

6354

}

6355

if (!CurToken && (MapFlag&MapMeanFlag)) {

6356

ApplyMapSelection();

6357

ApplyMapLevel();

6358

break;

6359

} else CommandError(MsgStrs[ErrBadArg]);

6360

break;

6361

}

6362

6363

6364

case(SaveTok):

6365

case(WriteTok):

6366

if( !AllowWrite )

6367

if( (FileDepth!=-1) && LineStack[FileDepth] )

6368

{ CommandError(MsgStrs[ErrInScrpt]);

6369

break;

6370

}

6371

FetchToken();

6372

if( !Database ) {

6373

CommandError(MsgStrs[ErrBadMolDB]);

6374

break;

6375

}

6376

6377

6378

if( !CurToken ) {

6379

CommandError(MsgStrs[ErrFilNam]);

6380

break;

6381

} else if( CurToken==StringTok ) {

6382

ProcessFileName(TokenIdent);

6383

} else ProcessFileName(TokenStart);

6384

6385

param = DataFileName;

6386

CurToken = 0;

6387

6388

#ifdef USE_CBFLIB

6389

if( !(fp=fopen(DataFileName,"w+b")) ) {

6390

CommandError( (char*)NULL );

6391

FatalOutputError(DataFileName);

6392

break;

6393

}

6394

else {

6395

MapInfo *omapinfo;

6396

{

6397

ApplyMapSelection();

6398

if (MapFlag&MapSelectFlag) {

6399

CommandError(MsgStrs[ErrBadArg]);

6400

fclose(fp);

6401

break;

6402

} else {

6403

for (j=0; j < MapInfoPtr->size; j++) {

6404

vector_get_elementptr((GenericVec __far *)MapInfoPtr,(void __far * __far *)&omapinfo,j );

6405

if (omapinfo->flag&MapSelectFlag) {

6406

if(SaveMapFile(fp,(FileDepth == -1),j)) {

6407

CommandError( (char*)NULL );

6408

WriteString(MsgStrs[StrErrFile]);

6409

WriteString(DataFileName);

6410

WriteString("'!\n");

6411

break;

6412

}

6413

}

6414

}

6415

fclose(fp);

6416

}

6417

}

6418

CurToken = 0;

6419

}

6420

#else

6421

CommandError(MsgStrs[ErrBadArg]);

6422

#endif

6423

break;

6424

6425

6426

case(MaskTok):

6427

FetchToken();

6428

if (CurToken == SelectedTok) {

6429

ApplyMapMask(0);

6430

} else if (CurToken==NumberTok && TokenValue>0) {

6431

ApplyMapMask(TokenValue);

6432

} else if (CurToken==NoneTok) {

6433

ApplyMapMask(-1);

6434

}

6435

else CommandError(MsgStrs[ErrBadArg]);

6436

break;

6437

6438

case(ResolutionTok):

6439

FetchToken();

6440

if ( CurToken==NumberTok && TokenValue >=0)

6441

{ if( *TokenPtr=='.' )

6442

{ TokenPtr++;

6443

FetchFloat(TokenValue,1000);

6444

} else {

6445

TokenValue *= 1000;

6446

}

6447

if( TokenValue<=50000 )

6448

{ if (TokenValue !=0)

6449

MapSpacing = 250.*((Real)TokenValue)/1000.;

6450

MapSpread = .6667*((Real)TokenValue)/1000.;

6451

ApplyMapSelection();

6452

ApplyMapSpacing();

6453

ApplyMapSpread();

6454

ReDrawFlag |= RFRefresh;

6455

} else CommandError(MsgStrs[ErrBigNum]);

6456

} else if( CurToken=='.' )

6457

{ FetchFloat(0,1000);

6458

if( TokenValue<=50000 )

6459

{ MapSpacing = 250.*((Real)TokenValue)/1000.;

6460

MapSpread = .6667*((Real)TokenValue)/1000.;

6461

ApplyMapSelection();

6462

ApplyMapSpacing();

6463

ApplyMapSpread();

6464

ReDrawFlag |= RFRefresh;

6465

} else CommandError(MsgStrs[ErrBigNum]);

6466

} else CommandError(MsgStrs[ErrBadArg]);

6467

break;

6468

6469

6470

6471

case(SpreadTok):

6472

FetchToken();

6473

if ( CurToken==NumberTok && TokenValue >=0)

6474

{ if( *TokenPtr=='.' )

6475

{ TokenPtr++;

6476

FetchFloat(TokenValue,1000);

6477

} else {

6478

TokenValue *= 1000;

6479

}

6480

if( TokenValue<=50000 )

6481

{ MapSpread = ((Real)TokenValue)/1000.;

6482

ApplyMapSelection();

6483

ApplyMapSpread();

6484

ReDrawFlag |= RFRefresh;

6485

} else CommandError(MsgStrs[ErrBigNum]);

6486

} else if( CurToken=='.' )

6487

{ FetchFloat(0,1000);

6488

if( TokenValue<=50000 )

6489

{ MapSpread = ((Real)TokenValue)/1000.;

6490

ApplyMapSelection();

6491

ApplyMapSpread();

6492

ReDrawFlag |= RFRefresh;

6493

} else CommandError(MsgStrs[ErrBigNum]);

6494

} else CommandError(MsgStrs[ErrBadArg]);

6495

break;

6496

6497

case(SpacingTok):

6498

FetchToken();

6499

if ( CurToken==NumberTok && TokenValue >=0)

6500

{ if( *TokenPtr=='.' )

6501

{ TokenPtr++;

6502

FetchFloat(TokenValue,250);

6503

}

6504

if( TokenValue<=50000 )

6505

{ if (TokenValue !=0)

6506

MapSpacing = TokenValue;

6507

ApplyMapSelection();

6508

ApplyMapSpacing();

6509

ReDrawFlag |= RFRefresh;

6510

} else CommandError(MsgStrs[ErrBigNum]);

6511

} else if( CurToken=='.' )

6512

{ FetchFloat(0,250);

6513

if( TokenValue<=50000 )

6514

{ MapSpacing = TokenValue;

6515

ApplyMapSelection();

6516

ApplyMapSpacing();

6517

ReDrawFlag |= RFRefresh;

6518

} else CommandError(MsgStrs[ErrBigNum]);

6519

} else CommandError(MsgStrs[ErrBadArg]);

6520

break;

6521

6522

case(ColourTok):

6523

FetchToken();

6524

if( CurToken==PotentialTok )

6525

{ ReDrawFlag |= RFColour;

6526

MapFlag |= MapColourPot;

6527

MapFlag &= ~MapColourAtom;

6528

} else if( CurToken==AtomTok )

6529

{ ReDrawFlag |= RFColour;

6530

MapFlag |= MapColourAtom;

6531

MapFlag &= ~MapColourPot;

6532

} else if( ParseColour() )

6533

{ ReDrawFlag |= RFColour;

6534

MapRGBCol[0] = RVal;

6535

MapRGBCol[1] = GVal;

6536

MapRGBCol[2] = BVal;

6537

MapFlag &= ~(MapColourPot|MapColourAtom);

6538

} else if( CurToken )

6539

{ CommandError(MsgStrs[ErrColour]);

6540

} else CommandError(MsgStrs[ErrNoCol]);

6541

ApplyMapSelection();

6542

ApplyMapColour();

6543

break;

6544

6545

case(ZapTok):

6546

FetchToken();

6547

if (!CurToken) {

6548

ApplyMapSelection();

6549

ApplyMapZap();

6550

}

6551

else CommandError(MsgStrs[ErrSyntax]);

6552

break;

6553

6554

/* map {<mapselection>} select

6555

map {<mapselection>} select atom {SearchRadius} {+|add} {-|within}

6556

map {<mapselection>} restrict atom {SearchRadius} {+|add} {-|within}

6557

6558

The default SearchRadius is 6 Angstroms + probe radius

6559

The default is to discard all current selections first

6560

use '+' or 'add' to add to the current selections instead

6561

The default is to search through all atoms

6562

use '-' or 'within' to search through only currently selected atoms

6563

It is an error to use both add and within

6564

*/

6565

case(SelectTok):

6566

FetchToken();

6567

if (!CurToken) {

6568

ApplyMapSelection();

6569

} else if (CurToken == AtomTok){

6570

int dontadd, searchwithin, SearchRadius;

6571

SearchRadius = 1000+((ProbeRadius<10)?350:ProbeRadius);

6572

dontadd = True;

6573

searchwithin = False;

6574

while (FetchToken()) {

6575

if( CurToken==NumberTok ) {

6576

if( *TokenPtr=='.' ) {

6577

TokenPtr++;

6578

FetchFloat(TokenValue,250);

6579

}

6580

if( TokenValue>7500 ) {

6581

CommandError(MsgStrs[ErrBigNum]);

6582

break;

6583

} else SearchRadius = (int)TokenValue;

6584

continue;

6585

} else if( CurToken=='.' ) {

6586

FetchFloat(0,250);

6587

if( TokenValue>7500 ){

6588

CommandError(MsgStrs[ErrBigNum]);

6589

break;

6590

} else SearchRadius = (int)TokenValue;

6591

continue;

6592

} else if( CurToken == '+' || CurToken == AddTok ) {

6593

dontadd = False;

6594

continue;

6595

} else if( CurToken == '-' || CurToken == WithinTok) {

6596

searchwithin = True;

6597

continue;

6598

} else {

6599

CommandError(MsgStrs[ErrSyntax]);

6600

break;

6601

}

6602

}

6603

if (CurToken) {

6604

break;

6605

}

6606

ApplyMapAtomSelection(dontadd,searchwithin,SearchRadius);

6607

SelectZone(SelectFlag);

6608

NeedAtomTree = 1;

6609

ReDrawFlag |= RFRefresh;

6610

}

6611

else CommandError(MsgStrs[ErrSyntax]);

6612

break;

6613

6614

case(RestrictTok):

6615

FetchToken();

6616

if (!CurToken) {

6617

ApplyMapSelection();

6618

ApplyMapRestriction();

6619

} else if (CurToken == AtomTok){

6620

int dontadd, searchwithin, SearchRadius;

6621

SearchRadius = 1000+((ProbeRadius<10)?350:ProbeRadius);

6622

dontadd = True;

6623

searchwithin = False;

6624

while (FetchToken()) {

6625

if( CurToken==NumberTok ) {

6626

if( *TokenPtr=='.' ) {

6627

TokenPtr++;

6628

FetchFloat(TokenValue,250);

6629

}

6630

if( TokenValue>7500 ) {

6631

CommandError(MsgStrs[ErrBigNum]);

6632

break;

6633

} else SearchRadius = (int)TokenValue;

6634

continue;

6635

} else if( CurToken=='.' ) {

6636

FetchFloat(0,250);

6637

if( TokenValue>7500 ){

6638

CommandError(MsgStrs[ErrBigNum]);

6639

break;

6640

} else SearchRadius = (int)TokenValue;

6641

continue;

6642

} else if( CurToken == '+' || CurToken == AddTok) {

6643

dontadd = False;

6644

continue;

6645

} else if( CurToken == '-' || CurToken == WithinTok) {

6646

searchwithin = True;

6647

continue;

6648

} else {

6649

CommandError(MsgStrs[ErrSyntax]);

6650

break;

6651

}

6652

}

6653

if (CurToken) {

6654

break;

6655

}

6656

ApplyMapAtomSelection(dontadd,searchwithin,SearchRadius);

6657

RestrictZone(SelectFlag);

6658

NeedAtomTree = 1;

6659

ReDrawFlag |= RFRefresh;

6660

}

6661

else CommandError(MsgStrs[ErrSyntax]);

6662

break;

6663

6664

case(ShowTok):

6665

FetchToken();

6666

if (!CurToken) {

6667

ApplyMapSelection();

6668

ApplyMapShow();

6669

}

6670

else CommandError(MsgStrs[ErrSyntax]);

6671

break;

6672

6673

6674

default: CommandError(MsgStrs[ErrBadArg]); break;

6675

6676

}

6677

} else CommandError(MsgStrs[ErrSyntax]);

6678

break;

6679

6680

6681

6682

case(WireframeTok):

6683

FetchToken();

6684

if( CurToken==FalseTok )

6685

{ ReDrawFlag |= RFRefresh;

6686

DisableWireframe();

6687

} else if( (CurToken==TrueTok) || !CurToken )

6688

{ ReDrawFlag |= RFRefresh;

6689

EnableWireframe(WireFlag,0,0);

6690

} else if( CurToken==DashTok )

6691

{ ReDrawFlag |= RFRefresh;

6692

EnableWireframe(DashFlag,0,0);

6693

} else if( CurToken==NumberTok && TokenValue >=0)

6694

{ if( *TokenPtr=='.' )

6695

{ TokenPtr++;

6696

FetchFloat(TokenValue,250);

6697

}

6698

6699

if( TokenValue<=500 )

6700

{ if (TokenValue !=0)

6701

{ EnableWireframe(CylinderFlag,

6702

(int)TokenValue,

6703

(int)((TokenValue*4)/5));

6704

ReDrawFlag |= RFRefresh;

6705

} else

6706

{

6707

ReDrawFlag |= RFRefresh;

6708

DisableWireframe();

6709

}

6710

} else CommandError(MsgStrs[ErrBigNum]);

6711

} else if( CurToken=='.' )

6712

{ FetchFloat(0,250);

6713

if( TokenValue<=500 )

6714

{ EnableWireframe(CylinderFlag,

6715

(int)TokenValue,

6716

(int)((TokenValue*4)/5));

6717

ReDrawFlag |= RFRefresh;

6718

} else CommandError(MsgStrs[ErrBigNum]);

6719

} else CommandError(MsgStrs[ErrBadArg]);

6720

break;

6721

6722

case(BackboneTok):

6723

FetchToken();

6724

if( CurToken==FalseTok )

6725

{ ReDrawFlag |= RFRefresh;

6726

DisableBackbone();

6727

} else if( (CurToken==TrueTok) || !CurToken )

6728

{ ReDrawFlag |= RFRefresh;

6729

EnableBackbone(WireFlag,0,0);

6730

} else if( CurToken==DashTok )

6731

{ ReDrawFlag |= RFRefresh;

6732

EnableBackbone(DashFlag,0,0);

6733

} else if( CurToken==NumberTok && TokenValue>=0)

6734

{ if( *TokenPtr=='.' )

6735

{ TokenPtr++;

6736

FetchFloat(TokenValue,250);

6737

}

6738

6739

6740

if( TokenValue<=500 )

6741

{ if (TokenValue!=0) { EnableBackbone(CylinderFlag,

6742

(int)TokenValue,

6743

(int)((4*TokenValue)/5));

6744

ReDrawFlag |= RFRefresh; } else { ReDrawFlag |= RFRefresh; DisableBackbone(); } } else CommandError(MsgStrs[ErrBigNum]);

6745

} else if( CurToken=='.' )

6746

{ FetchFloat(0,250);

6747

if( TokenValue<=500 )

6748

{ EnableBackbone(CylinderFlag,

6749

(int)TokenValue,

6750

(int)((4*TokenValue)/5));

6751

ReDrawFlag |= RFRefresh;

6752

} else CommandError(MsgStrs[ErrBigNum]);

6753

} else CommandError(MsgStrs[ErrBadArg]);

6754

break;

6755

6756

case(CPKTok):

6757

case(SpacefillTok):

6758

FetchToken();

6759

if( CurToken==FalseTok )

6760

{ ReDrawFlag |= RFRefresh;

6761

DisableSpacefill();

6762

} else if( CurToken==NumberTok )

6763

{ if( *TokenPtr=='.' )

6764

{ TokenPtr++;

6765

FetchFloat(TokenValue,250);

6766

}

6767

6768

if( TokenValue<=3000 )

6769

{ SetRadiusValue(MaxFun((int)TokenValue,1),

6770

SphereFlag);

6771

DrawSurf = False;

6772

ReDrawFlag |= RFRefresh;

6773

} else CommandError(MsgStrs[ErrBigNum]);

6774

} else if( CurToken=='.' )

6775

{ FetchFloat(0,250);

6776

if( TokenValue<=3000 )

6777

{ SetRadiusValue(MaxFun((int)TokenValue,1),

6778

SphereFlag);

6779

DrawSurf = False;

6780

ReDrawFlag |= RFRefresh;

6781

} else CommandError(MsgStrs[ErrBigNum]);

6782

} else if( CurToken==UserTok )

6783

{ UserMaskAttrib(MaskRadiusFlag);

6784

DrawSurf = False;

6785

ReDrawFlag |= RFRefresh;

6786

} else if( CurToken==TemperatureTok )

6787

{ ReDrawFlag |= RFRefresh;

6788

DrawSurf = False;

6789

SetRadiusTemperature( SphereFlag );

6790

} else if( CurToken==SolventTok )

6791

{ ReDrawFlag |= RFRefresh;

6792

SetVanWaalRadius( SphereFlag | ExpandFlag );

6793

} else if( (CurToken==TrueTok) || !CurToken )

6794

{ ReDrawFlag |= RFRefresh;

6795

DrawSurf = False;

6796

SetVanWaalRadius( SphereFlag );

6797

} else CommandError(MsgStrs[ErrBadArg]);

6798

break;

6799

case(SurfaceTok):

6800

FetchToken();

6801

if( CurToken == SolventTok) {

6802

FetchToken();

6803

if( CurToken == DotsTok ) {

6804

} else if( CurToken == SolidTok ) {

6805

} else if( CurToken == NumberTok )

6806

{ if( *TokenPtr=='.' )

6807

{ TokenPtr++;

6808

FetchFloat(TokenValue,250);

6809

}

6810

if( TokenValue<=3000 )

6811

{ ProbeRadius = (int)TokenValue;

6812

DrawSurf = True;

6813

ReDrawFlag |= RFRefresh;

6814

SetVanWaalRadius( SphereFlag |

6815

ExpandFlag );

6816

} else CommandError(MsgStrs[ErrBigNum]);

6817

} else CommandError(MsgStrs[ErrBadArg]);

6818

6819

} else if( CurToken == MoleculeTok) {

6820

FetchToken();

6821

if( CurToken == DotsTok ) {

6822

} else if( CurToken == SolidTok ) {

6823

} else if( CurToken == NumberTok )

6824

{ if( *TokenPtr=='.' )

6825

{ TokenPtr++;

6826

FetchFloat(TokenValue,250);

6827

}

6828

if( TokenValue<=3000 )

6829

{ ProbeRadius = (int)TokenValue;

6830

DrawSurf = True;

6831

ReDrawFlag |= RFRefresh;

6832

FetchToken();

6833

if (!CurToken)

6834

SetVanWaalRadius( SphereFlag | TouchFlag );

6835

else if( CurToken==NumberTok ) {

6836

if( *TokenPtr=='.' ) {

6837

TokenPtr++;

6838

FetchFloat(TokenValue,250);

6839

}

6840

if( TokenValue<=3000 ) {

6841

SetRadiusValue(MaxFun((int)TokenValue,1),

6842

SphereFlag | TouchFlag);

6843

} else CommandError(MsgStrs[ErrBigNum]);

6844

} else if( CurToken=='.' ) {

6845

FetchFloat(0,250);

6846

if( TokenValue<=3000 ) {

6847

SetRadiusValue(MaxFun((int)TokenValue,1),

6848

SphereFlag | TouchFlag);

6849

} else CommandError(MsgStrs[ErrBigNum]);

6850

} else if( CurToken==UserTok ) {

6851

UserMaskAttrib(MaskRadiusFlag);

6852

} else if( CurToken==TemperatureTok ) {

6853

ReDrawFlag |= RFRefresh;

6854

} else CommandError(MsgStrs[ErrBadArg]);

6855

/* if( MainAtomCount+HetaAtomCount > 255 ) */

6856

CreateSurfaceBonds();

6857

} else CommandError(MsgStrs[ErrBigNum]);

6858

} else CommandError(MsgStrs[ErrBadArg]);

6859

} else CommandError(MsgStrs[ErrBadArg]);

6860

break;

6861

6862

case(MolSurfTok):

6863

FetchToken();

6864

if( CurToken==FalseTok )

6865

{ DrawSurf = False;

6866

ReDrawFlag |= RFRefresh;

6867

DisableSpacefill();

6868

} else if( CurToken==NumberTok )

6869

{ if( *TokenPtr=='.' )

6870

{ TokenPtr++;

6871

FetchFloat(TokenValue,250);

6872

}

6873

6874

if( TokenValue<=1500 )

6875

{ SetRadiusValue(MaxFun((int)TokenValue,1),

6876

SphereFlag);

6877

DrawSurf = True;

6878

ReDrawFlag |= RFRefresh;

6879

} else CommandError(MsgStrs[ErrBigNum]);

6880

} else if( CurToken=='.' )

6881

{ FetchFloat(0,250);

6882

if( TokenValue<=1500 )

6883

{ SetRadiusValue(MaxFun((int)TokenValue,1),

6884

SphereFlag);

6885

DrawSurf = True;

6886

ReDrawFlag |= RFRefresh;

6887

} else CommandError(MsgStrs[ErrBigNum]);

6888

} else if( CurToken==UserTok )

6889

{ UserMaskAttrib(MaskRadiusFlag);

6890

DrawSurf = True;

6891

ReDrawFlag |= RFRefresh;

6892

} else if( CurToken==TemperatureTok )

6893

{ DrawSurf = True;

6894

ReDrawFlag |= RFRefresh;

6895

SetRadiusTemperature( SphereFlag );

6896

} else if( (CurToken==TrueTok) || !CurToken )

6897

{ DrawSurf = True;

6898

ReDrawFlag |= RFRefresh;

6899

SetVanWaalRadius( SphereFlag );

6900

} else CommandError(MsgStrs[ErrBadArg]);

6901

break;

6902

6903

case(StarTok):

6904

FetchToken();

6905

if( CurToken==FalseTok )

6906

{ ReDrawFlag |= RFRefresh;

6907

DisableSpacefill();

6908

} else if( CurToken==NumberTok )

6909

{ if( *TokenPtr=='.' )

6910

{ TokenPtr++;

6911

FetchFloat(TokenValue,250);

6912

}

6913

if( TokenValue<=750 )

6914

{ SetRadiusValue(MaxFun((int)TokenValue,1),

6915

StarFlag);

6916

ReDrawFlag |= RFRefresh;

6917

} else CommandError(MsgStrs[ErrBigNum]);

6918

} else if( CurToken=='.' )

6919

{ FetchFloat(0,250);

6920

if( TokenValue<=750 )

6921

{ SetRadiusValue(MaxFun((int)TokenValue,1),

6922

StarFlag);

6923

ReDrawFlag |= RFRefresh;

6924

} else CommandError(MsgStrs[ErrBigNum]);

6925

} else if( CurToken==UserTok )

6926

{ UserMaskAttrib(MaskRadiusFlag);

6927

ReDrawFlag |= RFRefresh;

6928

} else if( CurToken==TemperatureTok )

6929

{ ReDrawFlag |= RFRefresh;

6930

SetRadiusTemperature( StarFlag );

6931

} else if( (CurToken==TrueTok) || !CurToken )

6932

{ ReDrawFlag |= RFRefresh;

6933

SetVanWaalRadius( StarFlag );

6934

} else CommandError(MsgStrs[ErrBadArg]);

6935

break;

6936

6937

case(DashTok): FetchToken();

6938

if( CurToken==FalseTok )

6939

{ ReDrawFlag |= RFRefresh;

6940

DisableWireframe();

6941

} else if( (CurToken==TrueTok) || !CurToken )

6942

{ ReDrawFlag |= RFRefresh;

6943

EnableWireframe(DashFlag,0,0);

6944

} else CommandError(MsgStrs[ErrBadArg]);

6945

break;

6946

6947

case(SSBondTok): FetchToken();

6948

if( CurToken==NumberTok )

6949

{ if( *TokenPtr=='.' )

6950

{ TokenPtr++;

6951

FetchFloat(TokenValue,250);

6952

}

6953

6954

if( TokenValue<=500 )

6955

{ SetHBondStatus(False,True,(int)TokenValue,

6956

(int)((4*TokenValue)/5));

6957

ReDrawFlag |= RFRefresh;

6958

} else CommandError(MsgStrs[ErrBigNum]);

6959

} else if( CurToken=='.' )

6960

{ FetchFloat(0,250);

6961

if( TokenValue<=500 )

6962

{ SetHBondStatus(False,True,(int)TokenValue,

6963

(int)((4*TokenValue)/5));

6964

ReDrawFlag |= RFRefresh;

6965

} else CommandError(MsgStrs[ErrBigNum]);

6966

} else if( CurToken==FalseTok )

6967

{ ReDrawFlag |= RFRefresh;

6968

SetHBondStatus(False,False,0,0);

6969

} else if( (CurToken==TrueTok) || !CurToken )

6970

{ ReDrawFlag |= RFRefresh;

6971

SetHBondStatus(False,True,0,0);

6972

} else CommandError(MsgStrs[ErrBadArg]);

6973

break;

6974

6975

case(HBondTok): FetchToken();

6976

if( CurToken==NumberTok )

6977

{ if( *TokenPtr=='.' )

6978

{ TokenPtr++;

6979

FetchFloat(TokenValue,250);

6980

}

6981

6982

if( TokenValue<=500 )

6983

{ SetHBondStatus(True,True,(int)TokenValue,

6984

(int)((4*TokenValue)/5));

6985

ReDrawFlag |= RFRefresh;

6986

} else CommandError(MsgStrs[ErrBigNum]);

6987

} else if( CurToken=='.' )

6988

{ FetchFloat(0,250);

6989

if( TokenValue<=500 )

6990

{ SetHBondStatus(True,True,(int)TokenValue,

6991

(int)((4*TokenValue)/5));

6992

ReDrawFlag |= RFRefresh;

6993

} else CommandError(MsgStrs[ErrBigNum]);

6994

} else if( CurToken==FalseTok )

6995

{ ReDrawFlag |= RFRefresh;

6996

SetHBondStatus(True,False,0,0);

6997

} else if( (CurToken==TrueTok) || !CurToken )

6998

{ ReDrawFlag |= RFRefresh;

6999

SetHBondStatus(True,True,0,0);

7000

} else CommandError(MsgStrs[ErrBadArg]);

7001

break;

7002

7003

case(RibbonTok): FetchToken();

7004

if( CurToken==NumberTok && TokenValue>=0)

7005

{ if( *TokenPtr=='.' )

7006

{ TokenPtr++;

7007

FetchFloat(TokenValue,250);

7008

}

7009

7010

if( TokenValue<=1000 )

7011

{ if (TokenValue !=0)

7012

{SetRibbonStatus(True,RibbonFlag,

7013

(int)TokenValue);

7014

ReDrawFlag |= RFRefresh;

7015

} else { ReDrawFlag |= RFRefresh;

7016

SetRibbonStatus(False, RibbonFlag,0);

7017

}

7018

} else CommandError(MsgStrs[ErrBigNum]);

7019

} else if( CurToken=='.' )

7020

{ FetchFloat(0,250);

7021

if( TokenValue<=1000 )

7022

{ SetRibbonStatus(True,RibbonFlag,

7023

(int)TokenValue);

7024

ReDrawFlag |= RFRefresh;

7025

} else CommandError(MsgStrs[ErrBigNum]);

7026

} else if( CurToken==FalseTok )

7027

{ ReDrawFlag |= RFRefresh;

7028

SetRibbonStatus(False,RibbonFlag,0);

7029

} else if( (CurToken==TrueTok) || !CurToken )

7030

{ ReDrawFlag |= RFRefresh;

7031

SetRibbonStatus(True,RibbonFlag,0);

7032

} else CommandError(MsgStrs[ErrBadArg]);

7033

break;

7034

7035

case(StrandsTok): FetchToken();

7036

if( CurToken == DashTok )

7037

{ option = DashStrandFlag;

7038

FetchToken();

7039

} else option = StrandFlag;

7040

7041

if( CurToken==NumberTok && TokenValue>=0)

7042

{ if( *TokenPtr=='.' )

7043

{ TokenPtr++;

7044

FetchFloat(TokenValue,250);

7045

}

7046

7047

if( TokenValue<=1000 )

7048

{ if (TokenValue !=0)

7049

{ SetRibbonStatus(True,option,(int)TokenValue);

7050

ReDrawFlag |= RFRefresh;

7051

} else {

7052

ReDrawFlag |= RFRefresh;

7053

SetRibbonStatus (False,option,0);

7054

}

7055

} else CommandError(MsgStrs[ErrBigNum]);

7056

} else if( CurToken=='.' )

7057

{ FetchFloat(0,250);

7058

if( TokenValue<=1000 )

7059

{ SetRibbonStatus(True,option,(int)TokenValue);

7060

ReDrawFlag |= RFRefresh;

7061

} else CommandError(MsgStrs[ErrBigNum]);

7062

} else if( CurToken==FalseTok )

7063

{ ReDrawFlag |= RFRefresh;

7064

SetRibbonStatus(False,option,0);

7065

} else if( (CurToken==TrueTok) || !CurToken )

7066

{ ReDrawFlag |= RFRefresh;

7067

SetRibbonStatus(True,option,0);

7068

} else CommandError(MsgStrs[ErrBadArg]);

7069

break;

7070

7071

case(TraceTok): FetchToken();

7072

if( CurToken==FalseTok )

7073

{ ReDrawFlag |= RFRefresh;

7074

SetRibbonStatus(False,TraceFlag,80);

7075

} else if( (CurToken==TrueTok) || !CurToken )

7076

{ ReDrawFlag |= RFRefresh;

7077

SetRibbonStatus(True,TraceFlag,80);

7078

} else if( CurToken==TemperatureTok )

7079

{ ReDrawFlag |= RFRefresh;

7080

SetTraceTemperature();

7081

} else if( CurToken==DotsTok )

7082

{ ReDrawFlag |= RFRefresh;

7083

SetRibbonStatus(True,DotsFlag,80);

7084

} else if( CurToken==NumberTok && TokenValue>=0)

7085

{ if( *TokenPtr=='.' )

7086

{ TokenPtr++;

7087

FetchFloat(TokenValue,250);

7088

}

7089

7090

if( TokenValue<=500)

7091

{ if (TokenValue !=0)

7092

{ SetRibbonStatus(True,TraceFlag,

7093

(int)TokenValue);

7094

ReDrawFlag |= RFRefresh;

7095

} else

7096

{

7097

ReDrawFlag |= RFRefresh;

7098

SetRibbonStatus(False,TraceFlag,80);

7099

}

7100

} else CommandError(MsgStrs[ErrBigNum]);

7101

} else if( CurToken=='.' )

7102

{ FetchFloat(0,250);

7103

if( TokenValue<=500 )

7104

{ SetRibbonStatus(True,TraceFlag,

7105

(int)TokenValue);

7106

ReDrawFlag |= RFRefresh;

7107

} else CommandError(MsgStrs[ErrBigNum]);

7108

} else CommandError(MsgStrs[ErrBadArg]);

7109

break;

7110

7111

case(CartoonTok): FetchToken();

7112

if( CurToken==NumberTok && TokenValue>=0)

7113

{ if( *TokenPtr=='.' )

7114

{ TokenPtr++;

7115

FetchFloat(TokenValue,250);

7116

}

7117

7118

if( TokenValue<=1000 )

7119

{ if (TokenValue !=0)

7120

{ SetRibbonStatus(True,CartoonFlag,

7121

(int)TokenValue);

7122

ReDrawFlag |= RFRefresh;

7123

} else

7124

{

7125

ReDrawFlag |= RFRefresh;

7126

SetRibbonStatus(False,CartoonFlag,0);

7127

}

7128

} else CommandError(MsgStrs[ErrBigNum]);

7129

} else if( CurToken=='.' )

7130

{ FetchFloat(0,250);

7131

if( TokenValue<=1000 )

7132

{ SetRibbonStatus(True,CartoonFlag,

7133

(int)TokenValue);

7134

ReDrawFlag |= RFRefresh;

7135

} else CommandError(MsgStrs[ErrBigNum]);

7136

} else if( CurToken==FalseTok )

7137

{ ReDrawFlag |= RFRefresh;

7138

SetRibbonStatus(False,CartoonFlag,0);

7139

} else if( (CurToken==TrueTok) || !CurToken )

7140

{ ReDrawFlag |= RFRefresh;

7141

SetRibbonStatus(True,CartoonFlag,0);

7142

} else CommandError(MsgStrs[ErrBadArg]);

7143

break;

7144

7145

case(DotsTok): FetchToken();

7146

if( CurToken==NumberTok )

7147

{ if( TokenValue<=1000 )

7148

{ if( TokenValue )

7149

{ CalculateSurface((int)TokenValue);

7150

} else CalculateSurface(1);

7151

ReDrawFlag |= RFRefresh;

7152

} else CommandError(MsgStrs[ErrBigNum]);

7153

} else if( CurToken==FalseTok )

7154

{ ReDrawFlag |= RFRefresh;

7155

DeleteSurface();

7156

DotCount = 0;

7157

} else if( (CurToken==TrueTok) || !CurToken )

7158

{ ReDrawFlag |= RFRefresh;

7159

CalculateSurface(100);

7160

} else CommandError(MsgStrs[ErrBadArg]);

7161

break;

7162

7163

case(MonitorTok): FetchToken();

7164

if( CurToken == NumberTok )

7165

{ temp = TokenValue;

7166

FetchToken();

7167

if( CurToken == ',' )

7168

FetchToken();

7169

7170

if( CurToken == NumberTok )

7171

{ CreateMonitor(temp,TokenValue);

7172

ReDrawFlag |= RFRefresh;

7173

} else CommandError(MsgStrs[ErrNotNum]);

7174

} else if( CurToken == FalseTok )

7175

{ ReDrawFlag |= RFRefresh;

7176

DeleteMonitors();

7177

} else if( !CurToken || CurToken == TrueTok )

7178

{ ReDrawFlag |= RFRefresh;

7179

DrawMonitDistance = True;

7180

}else CommandError(MsgStrs[ErrBadArg]);

7181

break;

7182

7183

case(SlabTok): FetchToken();

7184

if( (CurToken==NumberTok) || (CurToken=='.') )

7185

{ if( CurToken==NumberTok )

7186

{ if( *TokenPtr=='.' )

7187

{ TokenPtr++;

7188

FetchFloat(TokenValue,100);

7189

} else TokenValue *= 100;

7190

} else FetchFloat(0,100);

7191

7192

if( TokenValue<=10000 )

7193

{ DialValue[DialSlab] = (TokenValue-5000)/5000.0;

7194

/* UpdateScrollBars(); */

7195

ReDrawFlag |= RFSlab;

7196

UseSlabPlane = True;

7197

UseShadow = False;

7198

} else CommandError(MsgStrs[ErrBigNum]);

7199

7200

} else if( CurToken==FalseTok )

7201

{ if( UseSlabPlane )

7202

{ ReDrawFlag |= RFRefresh;

7203

UseSlabPlane = False;

7204

}

7205

} else if( !CurToken || (CurToken==TrueTok) )

7206

{ if( !UseSlabPlane )

7207

{ ReDrawFlag |= RFRefresh;

7208

UseSlabPlane = True;

7209

UseShadow = False;

7210

}

7211

} else CommandError(MsgStrs[ErrSyntax]);

7212

break;

7213

7214

case(DepthTok): FetchToken();

7215

if( (CurToken==NumberTok) || (CurToken=='.') )

7216

{ if( CurToken==NumberTok )

7217

{ if( *TokenPtr=='.' )

7218

{ TokenPtr++;

7219

FetchFloat(TokenValue,100);

7220

} else TokenValue *= 100;

7221

} else FetchFloat(0,100);

7222

7223

if( TokenValue<=10000 )

7224

{ DialValue[DialBClip] = (TokenValue-5000)/5000.0;

7225

/* UpdateScrollBars(); */

7226

ReDrawFlag |= RFRotate;

7227

UseDepthPlane = True;

7228

UseShadow = False;

7229

} else CommandError(MsgStrs[ErrBigNum]);

7230

7231

} else if( CurToken==FalseTok )

7232

{ if( UseDepthPlane )

7233

{ ReDrawFlag |= RFRotate;

7234

UseDepthPlane = False;

7235

}

7236

} else if( !CurToken || (CurToken==TrueTok) )

7237

{ if( !UseSlabPlane )

7238

{ ReDrawFlag |= RFRotate;

7239

UseDepthPlane = True;

7240

UseShadow = False;

7241

}

7242

} else CommandError(MsgStrs[ErrSyntax]);

7243

break;

7244

7245

case(ZoomTok): FetchToken();

7246

if( (CurToken==NumberTok) || (CurToken=='.') )

7247

{ if( CurToken==NumberTok )

7248

{ if( *TokenPtr=='.' )

7249

{ TokenPtr++;

7250

FetchFloat(TokenValue,100);

7251

} else TokenValue *= 100;

7252

} else FetchFloat(0,100);

7253

7254

if( TokenValue<=10000 )

7255

{ DialValue[DialZoom] = (TokenValue-10000)/10000.0;

7256

ReDrawFlag |= RFZoom;

7257

} else if( Database )

7258

{ /* Magnification */

7259

TokenValue -= 10000;

7260

temp = (Long)(MaxZoom*10000);

7261

if( TokenValue<=temp )

7262

{ DialValue[DialZoom] = (Real)TokenValue/temp;

7263

ReDrawFlag |= RFZoom;

7264

} else CommandError(MsgStrs[ErrBigNum]);

7265

}

7266

} else if( CurToken==TrueTok )

7267

{ ReDrawFlag |= RFZoom;

7268

DialValue[DialZoom] = 0.5;

7269

} else if( !CurToken || (CurToken==FalseTok) )

7270

{ ReDrawFlag |= RFZoom;

7271

DialValue[DialZoom] = 0.0;

7272

} else CommandError(MsgStrs[ErrSyntax]);

7273

/* UpdateScrollBars(); */

7274

break;

7275

7276

case(RotateTok): FetchToken();

7277

if( CurToken==XTok )

7278

{ option = 0;

7279

} else if( CurToken==YTok )

7280

{ option = 1;

7281

} else if( CurToken==ZTok )

7282

{ option = 2;

7283

} else if( CurToken==BondTok )

7284

{ if (!BondSelected) {

7285

CommandError(MsgStrs[ErrNoBond]);

7286

break;

7287

} else {

7288

option = -1;

7289

}

7290

} else if( CurToken==AllTok )

7291

{ option = -3;

7292

} else if( CurToken==MoleculeTok )

7293

{ option = -2;

7294

} else

7295

{ CommandError(MsgStrs[ErrSyntax]);

7296

break;

7297

}

7298

7299

FetchToken();

7300

if( option < 0 &&

7301

(!CurToken || CurToken==FalseTok ||

7302

CurToken==TrueTok))

7303

{ if( (option == -1 &&

7304

CurToken==FalseTok && RotMode==RotBond) ||

7305

(option == -2 &&

7306

(!CurToken || CurToken==TrueTok)) ||

7307

(option == -3 &&

7308

CurToken==FalseTok && RotMode==RotAll) )

7309

{ RotMode = RotMol;

7310

ReDrawFlag |= RFRotate;

7311

}

7312

if( option == -1 && CurToken==TrueTok )

7313

{ RotMode = RotBond;

7314

ReDrawFlag |= RFRotBond;

7315

}

7316

if( option == -3 &&

7317

(!CurToken || CurToken==TrueTok))

7318

{ RotMode = RotAll;

7319

ReDrawFlag |= RFRotate;

7320

}

7321

break;

7322

} else if( CurToken == '-' )

7323

{ FetchToken();

7324

done = True;

7325

} else done = False;

7326

#ifdef INVERT

7327

if( option != 1 )

7328

done = !done;

7329

#endif

7330

if( (CurToken==NumberTok) || (CurToken=='.') )

7331

{ if( CurToken==NumberTok )

7332

{ if( *TokenPtr=='.' )

7333

{ TokenPtr++;

7334

FetchFloat(TokenValue,100);

7335

} else TokenValue *= 100;

7336

} else FetchFloat(0,100);

7337

7338

if( TokenValue )

7339

{ if( ReDrawFlag & RFRotate )

7340

PrepareTransform();

7341

if( done ) TokenValue = -TokenValue;

7342

if (option == -1) {

7343

ReDrawFlag |= RFRotBond;

7344

BondSelected->BRotValue +=

7345

TokenValue/18000.0;

7346

while( BondSelected->BRotValue < -1.0 )

7347

BondSelected->BRotValue += 2.0;

7348

while( BondSelected->BRotValue > 1.0 )

7349

BondSelected->BRotValue -= 2.0;

7350

} else {

7351

double xtemp;

7352

7353

if (option < 0) {

7354

CommandError(MsgStrs[ErrSyntax]);

7355

break;

7356

}

7357

if (RotMode == RotAll) {

7358

xtemp = WorldDialValue[option];

7359

} else {

7360

xtemp = DialValue[option];

7361

}

7362

7363

ReDrawFlag |= (1<<option);

7364

7365

xtemp += TokenValue/18000.0;

7366

7367

while( xtemp<-1.0 )

7368

xtemp += 2.0;

7369

while( xtemp>1.0 )

7370

xtemp -= 2.0;

7371

7372

if (RotMode == RotAll) {

7373

WorldDialValue[option] = xtemp;

7374

} else {

7375

DialValue[option] = xtemp;

7376

}

7377

}

7378

if( Interactive )

7379

UpdateScrollBars();

7380

ReDrawFlag |= RFRefresh;

7381

}

7382

} else if (CurToken == ResetTok) {

7383

if (option == -1) {

7384

BondSelected->BRotValue = 0.0;

7385

ReDrawFlag |=RFRotBond;

7386

} else {

7387

ReDrawFlag |= (1<<option);

7388

if (RotMode == RotAll) {

7389

WorldDialValue[option] = 0.0;

7390

} else {

7391

DialValue[option] = 0.0;

7392

}

7393

}

7394

if( Interactive )

7395

UpdateScrollBars();

7396

ReDrawFlag |= RFRefresh;

7397

} else CommandError(MsgStrs[ErrNotNum]);

7398

break;

7399

7400

case(TranslateTok):

7401

FetchToken();

7402

if( CurToken==XTok )

7403

{ option = 4;

7404

} else if( CurToken==YTok )

7405

{ option = 5;

7406

} else if( CurToken==ZTok )

7407

{ option = 6;

7408

} else

7409

{ CommandError(MsgStrs[ErrSyntax]);

7410

break;

7411

}

7412

7413

FetchToken();

7414

if( CurToken == '-' )

7415

{ FetchToken();

7416

done = True;

7417

} else done = False;

7418

#ifdef INVERT

7419

if( option == 5 )

7420

done = !done;

7421

#endif

7422

7423

if( (CurToken==NumberTok) || (CurToken=='.') )

7424

{ if( CurToken==NumberTok )

7425

{ if( *TokenPtr=='.' )

7426

{ TokenPtr++;

7427

FetchFloat(TokenValue,100);

7428

} else TokenValue *= 100;

7429

} else FetchFloat(0,100);

7430

7431

if( TokenValue<=10000 )

7432

{ double wtemp;

7433

7434

ReDrawFlag |= RFTrans;

7435

if( done ) TokenValue = -TokenValue;

7436

wtemp = TokenValue/10000.0;

7437

if( RotMode == RotAll && option == 4 ) {

7438

WorldDialValue[DialTX] = wtemp;

7439

} else {

7440

if( RotMode == RotAll && option == 5 ) {

7441

WorldDialValue[DialTY] = wtemp;

7442

} else {

7443

if( RotMode == RotAll && option == 6 ) {

7444

WorldDialValue[DialTZ] = wtemp;

7445

} else {

7446

DialValue[option] = TokenValue/10000.0;

7447

}

7448

}

7449

}

7450

7451

/* UpdateScrollBars(); */

7452

} else CommandError(MsgStrs[ErrBigNum]);

7453

} else CommandError(MsgStrs[ErrNotNum]);

7454

break;

7455

7456

case(StereoTok): FetchToken();

7457

if( !CurToken || (CurToken==TrueTok) )

7458

{ SetStereoMode(True);

7459

} else if( CurToken==FalseTok )

7460

{ SetStereoMode(False);

7461

} else if( CurToken == '-' )

7462

{ if( !NextIf(NumberTok,ErrNotNum) )

7463

{ StereoAngle = -TokenValue;

7464

SetStereoMode(True);

7465

}

7466

} else if( CurToken==NumberTok )

7467

{ StereoAngle = TokenValue;

7468

SetStereoMode(True);

7469

} else {

7470

CommandError(MsgStrs[ErrSyntax]);

7471

break;

7472

}

7473

if (StereoAngle > 60.) {

7474

StereoAngle = 6.;

7475

CommandError(MsgStrs[ErrBigNum]);

7476

break;

7477

}

7478

if (StereoAngle < -60.) {

7479

StereoAngle = -6.;

7480

CommandError(MsgStrs[ErrBigNum]);

7481

break;

7482

}

7483

break;

7484

7485

case(ResizeTok): FetchToken();

7486

break;

7487

7488

case(ResetTok): for( i=0; i<10; i++ )

7489

DialValue[i] = 0.0;

7490

ReDrawFlag |= RFDials;

7491

ResetTransform();

7492

7493

/* ReDrawFlag |= RFRefresh|RFColour; */

7494

/* DisplayMode = 0; */

7495

7496

if( Interactive )

7497

UpdateScrollBars();

7498

break;

7499

7500

case('?'):

7501

case(HelpTok): if( !HelpFileName )

7502

InitHelpFile();

7503

if( HelpInfo )

7504

FindHelpInfo();

7505

CurToken=0;

7506

break;

7507

7508

case(LabelTok): FetchToken();

7509

if( !CurToken || (CurToken==TrueTok) )

7510

{ if( Info.chaincount>1 )

7511

{ DefineLabels("%n%r:%c.%a%A");

7512

} else if( MainGroupCount>1 )

7513

{ DefineLabels("%n%r.%a%A");

7514

} else DefineLabels("%e%i%A");

7515

} else if( CurToken==FalseTok )

7516

{ DeleteLabels();

7517

} else if( CurToken!=StringTok )

7518

{ DefineLabels(TokenStart);

7519

CurToken = 0;

7520

} else DefineLabels(TokenIdent);

7521

ReDrawFlag |= RFRefresh;

7522

break;

7523

7524

case(EchoTok): FetchToken();

7525

InvalidateCmndLine();

7526

if( CurToken==StringTok )

7527

{ WriteString(TokenIdent);

7528

} else if( CurToken )

7529

WriteString(TokenStart);

7530

WriteChar('\n');

7531

CurToken = 0;

7532

break;

7533

7534

case(DefineTok): FetchToken();

7535

if( CurToken != IdentTok )

7536

{ CommandError(MsgStrs[ErrSetName]);

7537

break;

7538

}

7539

7540

param = (char*)malloc(TokenLength+1);

7541

if( param )

7542

{ memcpy(param,TokenIdent,TokenLength+1);

7543

if( FetchToken() )

7544

{ QueryExpr = ParseExpression(0);

7545

if( QueryExpr )

7546

{ done = DefineSetExpr(param,QueryExpr);

7547

} else done = True;

7548

} else done = DefineSetExpr(param,(Expr*)NULL);

7549

} else done = False;

7550

7551

if( !done )

7552

CommandError(MsgStrs[ErrBadSet]);

7553

break;

7554

7555

case(BackgroundTok):

7556

FetchToken();

7557

if( CurToken == TransparentTok )

7558

{ UseTransparent = True;

7559

} else if( CurToken == NormalTok )

7560

{ UseTransparent = False;

7561

} else if( ParseColour() )

7562

{ ReDrawFlag |= RFColour;

7563

BackR = RVal;

7564

BackG = GVal;

7565

BackB = BVal;

7566

#ifndef IBMPC

7567

FBClear = False;

7568

#endif

7569

} else if( CurToken )

7570

{ CommandError(MsgStrs[ErrColour]);

7571

} else CommandError(MsgStrs[ErrNoCol]);

7572

break;

7573

7574

case(PlayTok):

7575

{

7576

int newPlayFrom, newPlayUntil;

7577

7578

newPlayFrom = PlayFrom;

7579

newPlayUntil = PlayUntil;

7580

if (PlayTemplate[0]==0){

7581

newPlayFrom = 0;

7582

newPlayUntil = -1;

7583

}

7584

FetchToken();

7585

do {

7586

if (CurToken == FromTok) {

7587

FetchToken();

7588

if( (CurToken==NumberTok) || (CurToken=='.') ) {

7589

if( CurToken==NumberTok ) {

7590

if( *TokenPtr=='.' ) {

7591

TokenPtr++;

7592

FetchFloat(TokenValue,1000);

7593

} else TokenValue *= 1000;

7594

} else FetchFloat(0,1000);

7595

newPlayFrom = (double)TokenValue;

7596

PlayFrom = newPlayFrom;

7597

} else {

7598

CommandError(MsgStrs[ErrSyntax]);

7599

break;

7600

}

7601

} else if (CurToken == UntilTok) {

7602

FetchToken();

7603

if( (CurToken==NumberTok) || (CurToken=='.') ) {

7604

if( CurToken==NumberTok ) {

7605

if( *TokenPtr=='.' ) {

7606

TokenPtr++;

7607

FetchFloat(TokenValue,1000);

7608

} else TokenValue *= 1000;

7609

} else FetchFloat(0,1000);

7610

newPlayUntil = (double)TokenValue;

7611

PlayUntil = newPlayUntil;

7612

} else {

7613

CommandError(MsgStrs[ErrSyntax]);

7614

break;

7615

}

7616

} else if (CurToken == OnTok){

7617

FetchToken();

7618

option = CurToken;

7619

suboption = 0;

7620

if( (option==RasMolTok) || (option==ScriptTok)

7621

|| (IsMoleculeToken(option))

7622

|| (IsImageToken(option)) )

7623

{ if( !*TokenPtr || *TokenPtr==' ' )

7624

suboption = FetchToken();

7625

if (suboption == MirrorTok || suboption == RotateTok)

7626

{ if (!*TokenPtr || *TokenPtr==' ')

7627

FetchToken();

7628

}

7629

else suboption = 0;

7630

} else option = 0;

7631

7632

if( !CurToken )

7633

{ CommandError(MsgStrs[ErrFilNam]);

7634

break;

7635

} else if( CurToken==StringTok )

7636

{ ProcessFileName(TokenIdent);

7637

} else {

7638

ProcessFileName(TokenStart);

7639

CurToken=0;

7640

}

7641

if (ConvPRTemplate(PlayTemplate,DataFileName,1024,&PlayMaxMS)) {

7642

CommandError(MsgStrs[StrCLong]);

7643

break;

7644

}

7645

PlayOption = option;

7646

PlaySubOption = suboption;

7647

PlayPause = 0;

7648

if (play_fps <= 0.) play_fps = 24.;

7649

play_frame[0] = play_frame[1] = 0;

7650

PlayFrom = newPlayFrom;

7651

PlayUntil = newPlayUntil;

7652

if (PlayUntil == 0) PlayUntil = PlayMaxMS-1.;

7653

if (PlayUntil > PlayMaxMS-1. && PlayMaxMS > 1.) PlayUntil = PlayMaxMS-1.;

7654

} else if (CurToken == OffTok ) {

7655

PlayPause = 1;

7656

FetchToken();

7657

if (!CurToken) break;

7658

PlayTemplate[0] = 0;

7659

} else {

7660

CommandError(MsgStrs[ErrSyntax]);

7661

break;

7662

}

7663

if (CurToken) FetchToken();

7664

} while (CurToken != 0);

7665

if (!PlayPause && PlayTemplate[0] != '\0') PlayMovie();

7666

break;

7667

}

7668

7669

case(RecordTok):

7670

{

7671

int newRecordFrom, newRecordUntil;

7672

7673

newRecordFrom = RecordFrom;

7674

newRecordUntil = RecordUntil;

7675

if (RecordTemplate[0]==0){

7676

newRecordFrom = 0;

7677

newRecordUntil = -1;

7678

}

7679

if( !AllowWrite )

7680

if( (FileDepth!=-1) && LineStack[FileDepth] )

7681

{ CommandError(MsgStrs[ErrInScrpt]);

7682

break;

7683

}

7684

if( !Database ) {

7685

CommandError(MsgStrs[ErrBadMolDB]);

7686

break;

7687

}

7688

FetchToken();

7689

do {

7690

if (CurToken == FromTok) {

7691

FetchToken();

7692

if( (CurToken==NumberTok) || (CurToken=='.') ) {

7693

if( CurToken==NumberTok ) {

7694

if( *TokenPtr=='.' ) {

7695

TokenPtr++;

7696

FetchFloat(TokenValue,1000);

7697

} else TokenValue *= 1000;

7698

} else FetchFloat(0,1000);

7699

newRecordFrom = (double)TokenValue;

7700

RecordFrom = newRecordFrom;

7701

} else {

7702

CommandError(MsgStrs[ErrSyntax]);

7703

break;

7704

}

7705

} else if (CurToken == UntilTok) {

7706

FetchToken();

7707

if( (CurToken==NumberTok) || (CurToken=='.') ) {

7708

if( CurToken==NumberTok ) {

7709

if( *TokenPtr=='.' ) {

7710

TokenPtr++;

7711

FetchFloat(TokenValue,1000);

7712

} else TokenValue *= 1000;

7713

} else FetchFloat(0,1000);

7714

newRecordUntil = (double)TokenValue;

7715

RecordUntil = newRecordUntil;

7716

} else {

7717

CommandError(MsgStrs[ErrSyntax]);

7718

break;

7719

}

7720

} else if (CurToken == OnTok){

7721

FetchToken();

7722

option = CurToken;

7723

suboption = 0;

7724

if( (option==RasMolTok) || (option==ScriptTok)

7725

|| (IsMoleculeToken(option))

7726

|| (IsImageToken(option)) )

7727

{ if( !*TokenPtr || *TokenPtr==' ' )

7728

suboption = FetchToken();

7729

if (suboption == MirrorTok || suboption == RotateTok)

7730

{ if (!*TokenPtr || *TokenPtr==' ')

7731

FetchToken();

7732

}

7733

else suboption = 0;

7734

} else option = 0;

7735

7736

if( !CurToken )

7737

{ CommandError(MsgStrs[ErrFilNam]);

7738

break;

7739

} else if( CurToken==StringTok )

7740

{ ProcessFileName(TokenIdent);

7741

} else {

7742

ProcessFileName(TokenStart);

7743

CurToken=0;

7744

}

7745

if (ConvPRTemplate(RecordTemplate,DataFileName,1024,&RecordMaxMS)) {

7746

CommandError(MsgStrs[StrCLong]);

7747

break;

7748

}

7749

RecordOption = option;

7750

RecordSubOption = suboption;

7751

RecordPause = 0;

7752

record_frame[0] = record_frame[1] = 0;

7753

if (record_fps <= 0.) record_fps = 24.;

7754

RecordFrom = newRecordFrom;

7755

RecordUntil = newRecordUntil;

7756

if (RecordUntil == 0) RecordUntil = RecordMaxMS-1.;

7757

if (RecordUntil > RecordMaxMS-1. && RecordMaxMS > 1.) RecordUntil = RecordMaxMS-1.;

7758

} else if (CurToken == OffTok ) {

7759

RecordPause = 1;

7760

FetchToken();

7761

if (!CurToken) break;

7762

RecordTemplate[0] = 0;

7763

} else if (CurToken == MotionTok || CurToken==MouseTok) {

7764

FetchToken();

7765

if (CurToken ==0 || CurToken == OnTok) {

7766

record_on[0] = True;

7767

} else if (CurToken == OffTok ){

7768

record_on[0] = False;

7769

}

7770

} else if (CurToken == AppearanceTok ) {

7771

FetchToken();

7772

if (CurToken ==0 || CurToken == OnTok) {

7773

record_on[1] = True;

7774

} else if (CurToken == OffTok ){

7775

record_on[1] = False;

7776

}

7777

7778

} else {

7779

CommandError(MsgStrs[ErrSyntax]);

7780

break;

7781

}

7782

if (CurToken) FetchToken();

7783

} while (CurToken != 0);

7784

break;

7785

}

7786

7787

7788

case(WriteTok):

7789

case(SaveTok): i = CurToken; /* Save keyword! */

7790

if( !AllowWrite )

7791

if( (FileDepth!=-1) && LineStack[FileDepth] )

7792

{ CommandError(MsgStrs[ErrInScrpt]);

7793

break;

7794

}

7795

if( !Database ) {

7796

CommandError(MsgStrs[ErrBadMolDB]);

7797

break;

7798

}

7799

7800

option = FetchToken();

7801

suboption = 0;

7802

if( (option==RasMolTok) || (option==ScriptTok)

7803

|| (IsMoleculeToken(option))

7804

|| (IsImageToken(option)) )

7805

{ if( !*TokenPtr || *TokenPtr==' ' )

7806

suboption = FetchToken();

7807

if (suboption == MirrorTok || suboption == RotateTok)

7808

{ if (!*TokenPtr || *TokenPtr==' ')

7809

FetchToken();

7810

}

7811

else suboption = 0;

7812

} else if( i==SaveTok )

7813

{ option = PDBTok;

7814

} else option = 0;

7815

7816

if( !CurToken )

7817

{ CommandError(MsgStrs[ErrFilNam]);

7818

break;

7819

} else if( CurToken==StringTok )

7820

{ ProcessFileName(TokenIdent);

7821

} else ProcessFileName(TokenStart);

7822

param = DataFileName;

7823

CurToken = 0;

7824

7825

if( !IsMoleculeToken(option) )

7826

{ if( ReDrawFlag ) {

7827

RefreshScreen();

7828

ReDrawFlag = NextReDrawFlag;

7829

}

7830

WriteImageFile( param, option, suboption );

7831

7832

} else switch(option)

7833

{ case(NMRPDBTok):

7834

case(PDBTok): SavePDBMolecule(param); break;

7835

case(MDLTok): SaveMDLMolecule(param); break;

7836

case(XYZTok): SaveXYZMolecule(param); break;

7837

case(CIFTok): SaveCIFMolecule(param); break;

7838

#ifdef CEXIOLIB

7839

case(CEXTok): SaveCEXMolecule(param); break;

7840

#endif

7841

case(AlchemyTok): SaveAlchemyMolecule(param);

7842

break;

7843

} break;

7844

7845

case(SourceTok):

7846

case(ScriptTok): FetchToken();

7847

if( FileDepth<STACKSIZE )

7848

{ if( !CurToken )

7849

{ CommandError(MsgStrs[ErrFilNam]);

7850

break;

7851

} else if( CurToken==StringTok )

7852

{ ProcessFileName(TokenIdent);

7853

} else ProcessFileName(TokenStart);

7854

CurToken = 0;

7855

7856

script = fopen(DataFileName,"rb");

7857

LoadScriptFile(script,DataFileName);

7858

} else CommandError(MsgStrs[ErrScript]);

7859

break;

7860

7861

case(RenumTok): FetchToken();

7862

if( CurToken )

7863

{ if( CurToken=='-' )

7864

{ FetchToken();

7865

done = True;

7866

} else done = False;

7867

7868

if( CurToken == NumberTok )

7869

{ if( done )

7870

{ RenumberMolecule(-(int)TokenValue);

7871

} else RenumberMolecule((int)TokenValue);

7872

} else CommandError(MsgStrs[ErrNotNum]);

7873

} else RenumberMolecule(1);

7874

break;

7875

7876

case(StructureTok):

7877

FetchToken();

7878

if( !CurToken || (CurToken==FalseTok) )

7879

{ DetermineStructure(False);

7880

} else if( CurToken==TrueTok )

7881

{ DetermineStructure(True);

7882

} else CommandError(MsgStrs[ErrSyntax]);

7883

break;

7884

7885

case(HeaderTok):

7886

case(CIFDataTok):

7887

if( AcceptData[FileDepth] == 'Y' ) {

7888

if( (FileDepth != -1) && LineStack[FileDepth] ) {

7889

Recycle = &CurLine[0];

7890

switch( CurToken )

7891

{ case(HeaderTok):

7892

if (SetNewMolecule()){

7893

ProcessFile(FormatPDB,False,

7894

FileStack[FileDepth]);

7895

} else {

7896

CommandError(MsgStrs[ErrBadLoad]);

7897

}

7898

break;

7899

7900

case(CIFDataTok):

7901

if (SetNewMolecule()){

7902

ProcessFile(FormatCIF,False,

7903

FileStack[FileDepth]);

7904

} else {

7905

CommandError(MsgStrs[ErrBadLoad]);

7906

}

7907

break;

7908

}

7909

DefaultRepresentation();

7910

} else {

7911

CommandError(MsgStrs[ErrOutScrpt]);

7912

}

7913

}

7914

CurToken = 0;

7915

return( ExitTok );

7916

7917

case(ExitTok): return( ExitTok );

7918

case(QuitTok): return( QuitTok );

7919

default: CommandError(MsgStrs[StrUnrec]);

7920

break;

7921

}

7922

7923

if( CurToken )

7924

if( FetchToken() )

7925

CommandError(MsgStrs[StrIgnore]);

7926

TokenPtr = NULL;

7927

return False;

7928

}

7929

7930

7931

int ExecuteIPCCommand( char __huge *ptr )

7932

{

7933

auto char buffer[256];

7934

register int stat,result;

7935

register int len,depth;

7936

register char *dst;

7937

7938

/* Ignore IPC commands while paused! */

7939

if( IsPaused ) return 0;

7940

7941

FileDepth = 0;

7942

*LineStack = 0;

7943

result = IPC_Ok;

7944

*NameStack = "IPC Error";

7945

7946

/* Save command line */

7947

strcpy(buffer,CurLine);

7948

7949

while( *ptr && (*ptr==' ') )

7950

ptr++;

7951

7952

if( *ptr == '[' )

7953

{ while( *ptr++ == '[' )

7954

{ dst = CurLine;

7955

depth = 0;

7956

len = 0;

7957

7958

while( *ptr )

7959

{ if( *ptr == ']' )

7960

{ if( !depth )

7961

{ ptr++;

7962

break;

7963

} else depth--;

7964

} else if( *ptr=='[' )

7965

depth++;

7966

7967

if( len < MAXBUFFLEN-1 )

7968

{ *dst++ = *ptr++;

7969

len++;

7970

} else ptr++;

7971

}

7972

*dst = '\0';

7973

7974

if( len < MAXBUFFLEN-1 )

7975

{ stat = ExecuteCommand();

7976

if( stat == QuitTok )

7977

{ result = IPC_Quit;

7978

} else if( stat )

7979

result = IPC_Exit;

7980

} else

7981

{ InvalidateCmndLine();

7982

WriteString(MsgStrs[StrRCLong]);

7983

}

7984

7985

while( *ptr && ((*ptr==' ')||(*ptr==';')) )

7986

ptr++;

7987

}

7988

} else if( *ptr )

7989

{ dst = CurLine;

7990

len = 0;

7991

while( *ptr )

7992

{ if( len < MAXBUFFLEN-1 )

7993

{ *dst++ = *ptr++;

7994

len++;

7995

} else break;

7996

}

7997

*dst = '\0';

7998

7999

if( len < MAXBUFFLEN-1 )

8000

{ stat = ExecuteCommand();

8001

if( stat == QuitTok )

8002

{ result = IPC_Quit;

8003

} else if( stat )

8004

result = IPC_Exit;

8005

} else

8006

{ InvalidateCmndLine();

8007

WriteString(MsgStrs[StrRCLong]);

8008

}

8009

}

8010

8011

FileDepth = -1;

8012

if( CommandActive )

8013

{ strcpy(CurLine,buffer);

8014

if( !result ) result = IPC_Error;

8015

}

8016

return result;

8017

}

8018

8019

8020

void InitialiseCommand( void )

8021

{

8022

int ii;

8023

8024

for (ii=0; ii < 256; ii++) Defer_Symbols[ii] = (Symbol __far *)NULL;

8025

FreeSymbol = (Symbol __far *)NULL;

8026

HelpFileName = NULL;

8027

FreeInfo = (void __far*)0;

8028

HelpInfo = (void __far*)0;

8029

8030

SelectCount = 0;

8031

TokenPtr = NULL;

8032

FileDepth = -1;

8033

8034

SeqFormat = False;

8035

IsPaused = False;

8036

8037

/* Movie and animation intialization */

8038

8039

play_fps = record_fps = 24.; /* default to 24 fps */;

8040

record_aps = 10.; /* default to 10 Angstroms per second */

8041

record_on[0] = record_on[1] = False;

8042

/* default, not recording motion or appearance */

8043

record_frame[0] = record_frame[1] = 0;

8044

/* start the overall and dwell frame counts at 0 */

8045

play_frame[0] = play_frame[1] = 0;

8046

8047

record_dwell = 0.5; /* dwell half second per command (12 frames) */

8048

RecordTemplate[0] = 0; /* no initial recording */

8049

PlayTemplate[0] = 0; /* no initial playback */

8050

RecordCurrent = RecordFrom = RecordUntil

8051

= PlayCurrent = PlayFrom = PlayUntil = RecordMaxMS = PlayMaxMS = 0.;

8052

RecordPause = True;

8053

PlayPause = False;

8054

8055

}

8056