1 /* algorend.c
2 * ===========================================================================
3 *
4 * PUBLIC DOMAIN NOTICE
5 * National Center for Biotechnology Information (NCBI)
6 *
7 * This software/database is a "United States Government Work" under the
8 * terms of the United States Copyright Act. It was written as part of
9 * the author's official duties as a United States Government employee and
10 * thus cannot be copyrighted. This software/database is freely available
11 * to the public for use. The National Library of Medicine and the U.S.
12 * Government do not place any restriction on its use or reproduction.
13 * We would, however, appreciate having the NCBI and the author cited in
14 * any work or product based on this material
15 *
16 * Although all reasonable efforts have been taken to ensure the accuracy
17 * and reliability of the software and data, the NLM and the U.S.
18 * Government do not and cannot warrant the performance or results that
19 * may be obtained by using this software or data. The NLM and the U.S.
20 * Government disclaim all warranties, express or implied, including
21 * warranties of performance, merchantability or fitness for any particular
22 * purpose.
23 *
24 * ===========================================================================
25 *
26 * File Name: algorend.c
27 *
28 * Authors: Christopher Hogue, Lewis Geer, Yanli Wang
29 *
30 * Version Creation Date:
31 *
32 * File Description: Algorithmic rendering routines and Vibrant controls for Cn3d
33 *
34 * Modifications:
35 * --------------------------------------------------------------------------
36 * $Log: algorend.c,v $
37 * Revision 6.167 2001/04/27 19:53:36 juran
38 * Heed some warnings.
39 *
40 * Revision 6.166 2000/07/28 21:05:56 lewisg
41 * more c++ fixes
42 *
43 * Revision 6.165 2000/07/27 13:37:32 lewisg
44 * more c++ fixes
45 *
46 * Revision 6.164 2000/07/21 18:55:14 thiessen
47 * allow dynamic slave->master transformation
48 *
49 * Revision 6.163 2000/05/19 18:19:09 thiessen
50 * fix label bug on show/hide
51 *
52 * Revision 6.162 2000/05/04 19:00:05 thiessen
53 * fix to worm capping
54 *
55 * Revision 6.161 2000/05/01 12:20:11 thiessen
56 * persist animation speed
57 *
58 * Revision 6.160 2000/04/25 00:22:34 thiessen
59 * save quality settings in config
60 *
61 * Revision 6.159 2000/04/20 23:27:44 lewisg
62 * misc bug fixes
63 *
64 * Revision 6.158 2000/04/20 18:53:56 thiessen
65 * misc tweaks/fixes
66 *
67 * Revision 6.157 2000/04/19 17:56:47 thiessen
68 * added background color in OpenGL
69 *
70 * Revision 6.156 2000/04/17 23:49:44 thiessen
71 * fix #ifdef indentation typo
72 *
73 * Revision 6.155 2000/04/17 15:54:25 thiessen
74 * add cylinder arrows; misc graphics tweaks
75 *
76 * Revision 6.154 2000/04/11 20:05:39 lewisg
77 * fix freeing bug on bioseq import, misc. tweaks
78 *
79 * Revision 6.153 2000/04/08 00:37:31 lewisg
80 * multiple seqentries, NEWSEQ message, etc.
81 *
82 * Revision 6.152 2000/04/06 19:03:20 thiessen
83 * new BLOSUM62 conservation coloring
84 *
85 * Revision 6.151 2000/04/05 23:23:28 lewisg
86 * fix viewer3d type
87 *
88 * Revision 6.150 2000/04/05 23:11:27 lewisg
89 * get rid of double redraw for hide row
90 *
91 * Revision 6.149 2000/04/05 16:59:22 lewisg
92 * get rid of animation frame when row is hid
93 *
94 * Revision 6.148 2000/04/03 18:23:46 thiessen
95 * add arrowheads to strand bricks
96 *
97 * Revision 6.147 2000/03/23 18:27:24 thiessen
98 * show-by-selected now works for hets/ions/water
99 *
100 * Revision 6.146 2000/03/23 15:22:33 thiessen
101 * fix cycle object color for non-residues
102 *
103 * Revision 6.145 2000/03/23 14:53:03 thiessen
104 * fix bug in viewer3d camera; added conservation color algorithm to ARS
105 *
106 * Revision 6.144 2000/03/22 23:42:22 lewisg
107 * timing loop for animation
108 *
109 * Revision 6.143 2000/03/22 23:17:48 thiessen
110 * added ability to save ARS in ASN1
111 *
112 * Revision 6.142 2000/03/20 15:56:00 thiessen
113 * fixed residue coloring bug
114 *
115 * Revision 6.141 2000/03/17 22:48:58 thiessen
116 * fix for multi-chain / multi-model features ; added feature-move ; misc bug fixes
117 *
118 * Revision 6.140 2000/03/17 00:08:19 thiessen
119 * fixed coloring bug in unaligned sequences
120 *
121 * Revision 6.139 2000/03/16 20:31:44 thiessen
122 * fixes to color; new color-by-variety algorithm
123 *
124 * Revision 6.138 2000/03/15 18:49:06 thiessen
125 * fixed viewer3d color bug
126 *
127 * Revision 6.137 2000/03/15 16:59:54 thiessen
128 * fix highlighting, other minor bugs
129 *
130 * Revision 6.136 2000/03/15 04:43:54 thiessen
131 * various minor fixes
132 *
133 * Revision 6.135 2000/03/14 18:03:12 thiessen
134 * add target row to MMD; remove rowmgr
135 *
136 * Revision 6.134 2000/03/13 16:04:25 thiessen
137 * re-implementation of features
138 *
139 * Revision 6.133 2000/03/09 17:56:57 thiessen
140 * changes to palette handling, feature implementation, PARS storage
141 *
142 * Revision 6.132 2000/03/08 21:46:14 lewisg
143 * cn3d saves viewport, misc bugs
144 *
145 * Revision 6.131 2000/03/06 18:35:23 thiessen
146 * fixes for 8-bit color
147 *
148 * Revision 6.130 2000/03/06 15:33:53 lewisg
149 * add new hydrophobic palette, update visual c++ project to move seqcons
150 *
151 * Revision 6.129 2000/03/03 20:05:16 thiessen
152 * removal of palette-building pass if in 24-bit color
153 *
154 * Revision 6.128 2000/03/02 21:18:28 thiessen
155 * installed color-by-conservation on all alignment rows
156 *
157 * Revision 6.127 2000/03/01 21:03:00 thiessen
158 * fixed 'connection' display problem
159 *
160 * Revision 6.126 2000/03/01 16:17:54 thiessen
161 * improved handling of colors; many small fixes
162 *
163 * Revision 6.125 2000/02/26 13:53:00 thiessen
164 * fixed typecast error
165 *
166 * Revision 6.124 2000/02/26 13:30:40 thiessen
167 * capped cylinders and worms for visible ends
168 *
169 * Revision 6.123 2000/02/26 00:01:39 thiessen
170 * OpenGL improvements, progress on cleanup of Show/Hide
171 *
172 * Revision 6.122 2000/02/25 02:53:14 thiessen
173 * check AlignMgr rather than bAligned flag to see if a residue is aligned
174 *
175 * Revision 6.121 2000/02/23 20:09:22 thiessen
176 * fixed color-by-conservation
177 *
178 * Revision 6.120 2000/02/23 18:56:29 thiessen
179 * move to 1-based row numbers
180 *
181 * Revision 6.119 2000/02/19 21:25:56 thiessen
182 * split of cn3dmodl into cn3dmodl and cn3dstyl
183 *
184 * Revision 6.118 2000/02/19 01:23:58 lewisg
185 * use ibm, add row tracking code, various bug fixes
186 *
187 * Revision 6.117 2000/02/17 15:41:11 thiessen
188 * added CSC algorithm selection submenu
189 *
190 * Revision 6.116 2000/02/16 21:25:31 thiessen
191 * new row manager module; made Cn3D use row-wise color storage for aligned strucs
192 *
193 * Revision 6.115 2000/02/14 22:18:21 lewisg
194 * fix merge error
195 *
196 * Revision 6.114 2000/02/14 20:04:20 thiessen
197 * another fix for solvent; more filling in of seqcons
198 *
199 * Revision 6.113 2000/02/14 19:31:02 lewisg
200 * fix occupancy bug when temperature factors present
201 *
202 * Revision 6.112 2000/02/14 12:32:30 thiessen
203 * fix solvent identification; progress on seqcons module
204 *
205 * Revision 6.111 2000/02/11 15:52:28 thiessen
206 * transparent solvent if partial occupancy; move alt conf behaviour checkbox to Show/Hide panel
207 *
208 * Revision 6.110 2000/02/11 01:10:36 thiessen
209 * creating new module seqcons for sequence conservation coloring routines
210 *
211 * Revision 6.109 2000/02/10 19:04:25 thiessen
212 * added checkbox to change altConf behaviour
213 *
214 * Revision 6.108 2000/02/10 17:53:02 lewisg
215 * correct type bug
216 *
217 * Revision 6.107 2000/02/10 17:47:01 thiessen
218 * added: color-by-sequence-conservation menu item, zoom-out to OpenGL, misc fixes
219 *
220 * Revision 6.106 2000/02/10 15:51:58 lewisg
221 * cn3d responds and send correct update messages. many coloring bug fixes
222 *
223 * Revision 6.105 2000/02/07 20:17:37 lewisg
224 * minor bug fixes, use gui font for win32
225 *
226 * Revision 6.104 2000/02/03 15:07:44 thiessen
227 * more correct handling of worm bonds
228 *
229 * Revision 6.103 2000/01/25 22:58:12 thiessen
230 * added animation of conf-ensembles
231 *
232 * Revision 6.102 2000/01/14 21:40:40 lewisg
233 * add translucent spheres, ion labels, new cpk, fix misc bugs
234 *
235 * Revision 6.101 2000/01/11 01:16:46 lewisg
236 * fix color selection in Cn3D, other misc. bugs
237 *
238 * Revision 6.100 2000/01/06 00:04:42 lewisg
239 * selection bug fixes, update message outbound, animation APIs moved to vibrant
240 *
241 * Revision 6.99 1999/12/29 22:55:02 lewisg
242 * get rid of seqalign id
243 *
244 * Revision 6.98 1999/12/27 23:14:10 lewisg
245 * add colormgr show/hide in Cn3D
246 *
247 * Revision 6.97 1999/12/22 22:49:20 lewisg
248 * fix color bugs: no color in color by domain, selection overrides cpk and temperature
249 *
250 * Revision 6.96 1999/12/16 15:25:21 thiessen
251 * removed unused buttons/popups from OpenGL version
252 *
253 * Revision 6.95 1999/12/13 23:20:43 lewisg
254 * bug fixes: duplicate color structures eliminated, clear color doesn't clear case
255 *
256 * Revision 6.94 1999/12/11 01:30:34 lewisg
257 * fix bugs with sharing colors between ddv and cn3d
258 *
259 * Revision 6.93 1999/12/08 22:58:00 thiessen
260 * added quality settings for OpenGL rendering
261 *
262 * Revision 6.92 1999/12/07 15:45:54 thiessen
263 * fonts working in OpenGL on Mac
264 *
265 * Revision 6.91 1999/12/06 14:43:59 thiessen
266 * made OpenGL font selection work in X/Motif
267 *
268 * Revision 6.90 1999/12/03 15:54:47 thiessen
269 * added font styles and prettified OpenGL label panel
270 *
271 * Revision 6.89 1999/12/02 23:56:52 thiessen
272 * added font selection for OpenGL/Win32 labels
273 *
274 * Revision 6.88 1999/11/30 22:32:08 vakatov
275 * Changed "#if _OPENGL" to "#ifdef _OPENGL" to suit Borland 5.0 compiler
276 *
277 * Revision 6.87 1999/11/22 17:29:54 lewisg
278 * add back color selection dialogs, fix viewer3d half-selection bug
279 *
280 * Revision 6.86 1999/11/18 00:21:42 lewisg
281 * draw speedups and selection on mouseup
282 *
283 * Revision 6.85 1999/11/15 18:30:07 lewisg
284 * get rid of extra redraws when selecting
285 *
286 * Revision 6.84 1999/11/10 23:19:39 lewisg
287 * rewrite of selection code for ddv
288 *
289 * Revision 6.83 1999/11/08 19:44:35 thiessen
290 * fix for OpenGL cylinder transformation
291 *
292 * Revision 6.82 1999/11/08 16:37:54 thiessen
293 * use 3-d brick instead of quad (OpenGL)
294 *
295 * Revision 6.81 1999/11/04 13:24:47 thiessen
296 * fixed bad connection menu setting
297 *
298 * Revision 6.80 1999/11/03 16:59:16 thiessen
299 * added capped cylinders for 'helix' object
300 *
301 * Revision 6.79 1999/11/03 16:24:19 lewisg
302 * get rid of non-existing includes
303 *
304 * Revision 6.78 1999/11/01 22:10:26 lewisg
305 * add ability to call color functions by type, and add this to cn3d
306 *
307 * Revision 6.77 1999/11/01 14:03:07 thiessen
308 * fixed bug in viewer3d version of wire worm
309 *
310 * Revision 6.76 1999/10/31 22:37:35 thiessen
311 * added worm render type to UI
312 *
313 * Revision 6.75 1999/10/29 14:15:26 thiessen
314 * ran all Cn3D source through GNU Indent to prettify
315 *
316 * Revision 6.74 1999/10/26 13:38:15 thiessen
317 * minor fix to worm calculation
318 *
319 * Revision 6.73 1999/10/15 20:44:23 thiessen
320 * minor bug fix to worm display
321 *
322 * Revision 6.72 1999/10/15 18:27:22 thiessen
323 * put in splined 'worm' model for virtual BB
324 *
325 * Revision 6.71 1999/10/05 23:18:18 lewisg
326 * add ddv and udv to cn3d with memory management
327 *
328 * Revision 6.70 1999/09/21 18:09:16 lewisg
329 * binary search added to color manager, various bug fixes, etc.
330 *
331 * Revision 6.69 1999/09/21 13:59:21 thiessen
332 * port of Lewis's OpenGL code to X/Motif
333 *
334 * Revision 6.68 1999/05/11 17:54:17 ywang
335 * move Cn3d_AnyPrim out of OpenGL ifdef block in RenderAnAtom
336 *
337 * Revision 6.67 1999/05/05 21:12:57 ywang
338 * fix typing error bug in RenderGraph
339 *
340 * Revision 6.66 1999/04/14 16:40:00 ywang
341 * color objects by secondary structure for strucseqs
342 *
343 * Revision 6.65 1999/04/06 22:27:38 lewisg
344 * fix endless loop
345 *
346 * Revision 6.64 1999/04/06 16:06:10 coremake
347 * Fixes of typos
348 *
349 * Revision 6.63 1999/04/06 14:23:29 lewisg
350 * add opengl replacement for viewer3d
351 *
352 * Revision 6.62 1999/03/30 22:36:20 ywang
353 * add functions to color salsa for NcbiMimeAsn1_strucseqs & code reorganization
354 *
355 * Revision 6.61 1999/03/22 22:41:53 ywang
356 * redesign feature page, fix bugs
357 *
358 * Revision 6.60 1999/03/09 18:12:56 lewisg
359 * turn on termini labels
360 *
361 * Revision 6.59 1999/03/08 21:16:22 ywang
362 * initialize variables
363 *
364 * Revision 6.58 1999/03/01 20:21:31 ywang
365 * put in options for residue on/off control
366 *
367 * Revision 6.57 1999/02/24 23:06:37 ywang
368 * minor name change for MGD feature
369 *
370 * Revision 6.56 1999/02/10 23:49:41 lewisg
371 * use RGB values instead of indexed palette
372 *
373 * Revision 6.55 1999/01/27 21:51:51 ywang
374 * add label to 'Model' menu
375 *
376 * Revision 6.54 1999/01/26 17:14:35 ywang
377 * redesign Display menu and add 'display highlight residues only' function
378 *
379 * Revision 6.53 1999/01/20 22:57:24 ywang
380 * customize color for secondary structure & rearrange Option menu
381 *
382 * Revision 6.52 1998/12/23 19:40:56 ywang
383 * fix layer bug while drawing user-defined feature
384 *
385 * Revision 6.51 1998/12/16 19:44:00 kans
386 * improvements to labels - combine name, letter, pdb controls into single popup
387 *
388 * Revision 6.50 1998/12/16 01:32:08 kans
389 * first pass at improving label controls
390 *
391 * Revision 6.49 1998/12/14 18:39:55 kans
392 * enumerated alists to limit render and color choices
393 *
394 * Revision 6.48 1998/12/10 15:51:07 kans
395 * improved layout of render controls, safe set value/status to avoid flicker
396 *
397 * Revision 6.47 1998/12/10 01:32:06 kans
398 * first pass at improved render dialog
399 *
400 * Revision 6.46 1998/11/09 22:03:32 ywang
401 * fix bugs for modeling
402 *
403 * Revision 6.45 1998/11/06 23:01:06 ywang
404 * fix bugs for modeling
405 *
406 * Revision 6.44 1998/11/04 00:06:21 ywang
407 * add function for modeling: change render/color for special residue(s)
408 *
409 * Revision 6.43 1998/10/28 19:02:46 kans
410 * included salparam.h
411 *
412 * Revision 6.42 1998/10/27 15:56:55 ywang
413 * add functions for testing color by sequence conservation
414 *
415 * Revision 6.41 1998/10/21 21:18:00 ywang
416 * color salsa by cycle_molecule and by residue
417 *
418 * Revision 6.40 1998/10/21 15:51:28 ywang
419 * reset residue color for salsa before cn3d redraws so that residues shown in salsa will become black if they are not shown in cn3d window
420 *
421 * Revision 6.39 1998/10/01 21:55:40 ywang
422 * put function for object display control
423 *
424 * Revision 6.38 1998/09/30 22:10:47 ywang
425 * control display on three levels: structure, chain, domain
426 *
427 * Revision 6.37 1998/09/24 15:52:49 kans
428 * included cn3dmodl.h
429 *
430 * Revision 6.36 1998/09/23 22:04:04 ywang
431 * synchronize show/hide between cn3d and salsa when display complexity is changed
432 *
433 * Revision 6.35 1998/09/23 18:38:51 ywang
434 * add functions to control display on domain level
435 *
436 * Revision 6.34 1998/09/22 17:53:46 ywang
437 * add display control on MM level
438 *
439 * Revision 6.33 1998/09/17 20:53:51 ywang
440 * set default color display as by conservation for struc+align case and replace the 'magenta' color with 'red'
441 *
442 * Revision 6.32 1998/08/26 18:28:35 kans
443 * fixed -v -fd warnings
444 *
445 * Revision 6.31 1998/07/29 22:17:36 lewisg
446 * change color of 1st aligned structure
447 *
448 * Revision 6.30 1998/07/28 22:17:39 lewisg
449 * turned on messaging when apply button pressed in render pane
450 *
451 * Revision 6.29 1998/07/28 21:14:17 lewisg
452 * renamed some items in the color by dropdown
453 *
454 * Revision 6.28 1998/07/09 21:50:23 ywang
455 * get rid of printf
456 *
457 * Revision 6.26 1998/07/08 16:16:10 ywang
458 * fix rendering bug for P backbone only model
459 *
460 * Revision 6.25 1998/07/07 19:31:59 ywang
461 * fix rendering problem for model with Alpha Carbon onlyalgorend.c
462 *
463 * Revision 6.24 1998/07/02 15:05:17 lewisg
464 * fix bug with resetting presentation on null structure
465 *
466 * Revision 6.23 1998/06/16 18:00:23 lewisg
467 * moved rendering menus and created a reset presentation menu item
468 *
469 * Revision 6.22 1998/05/29 19:27:09 ywang
470 * fix potential bug
471 *
472 * Revision 6.19 1998/05/26 21:51:00 ywang
473 * limit color message
474 *
475 * Revision 6.18 1998/05/26 21:35:14 lewisg
476 * added defaults to render menu, got rid of mouse 3D actions menu item
477 *
478 * Revision 6.17 1998/05/22 22:23:21 lewisg
479 * always show heterogens
480 *
481 * Revision 6.16 1998/05/12 21:46:59 lewisg
482 * stricter conservation coloring
483 *
484 * Revision 6.15 1998/05/08 17:30:15 lewisg
485 * new conservation coloring
486 *
487 * Revision 6.14 1998/05/05 20:05:15 ywang
488 * add color by Protein to salsa
489 *
490 * Revision 6.12 1998/04/30 15:23:40 ywang
491 * call ColorSalsa from RenderGraph
492 *
493 * Revision 6.11 1998/04/28 22:47:16 lewisg
494 * master/slave color in sync
495 *
496 * Revision 6.10 1998/04/27 17:50:01 lewisg
497 * added color by conservation
498 *
499 * Revision 6.9 1998/04/21 23:00:51 lewisg
500 * added show aligned/unaligned
501 *
502 * Revision 6.8 1998/04/20 22:08:57 lewisg
503 * got rid of dead code
504 *
505 * Revision 6.7 1998/04/20 18:36:06 lewisg
506 * moved extern for Viewer3d to cn3dmain.h
507 *
508 * Revision 6.6 1998/04/18 00:33:46 lewisg
509 * added ability to turn slaves on/off
510 *
511 * Revision 6.5 1998/04/15 00:51:29 lewisg
512 * bug fixes for multiple alignment mode and alignment pane
513 *
514 * Revision 6.4 1998/04/06 04:25:20 lewisg
515 * added color by alignment
516 *
517 * Revision 6.3 1998/04/01 23:26:08 lewisg
518 * added new startup mode + fixed slave rendering
519 *
520 * Revision 6.2 1998/03/06 23:19:17 lewisg
521 * codewarrior fixes
522 *
523 * Revision 6.1 1998/03/06 01:16:43 lewisg
524 * merge
525 *
526 * Revision 6.0 1997/08/25 18:13:21 madden
527 * Revision changed to 6.0
528 *
529 * Revision 5.5 1996/08/19 21:04:29 vakatov
530 * Made functions of type "pNodeFunc" to be of that type(sharp)
531 * (and thus fixed fatal bug under Borland/WIN32); removed all
532 * castings to (pNodeFunc) -- to let compiler to check for such bugs
533 *
534 * Revision 5.4 1996/08/06 16:04:06 hogue
535 * Fixed a mistaken ==
536 *
537 * Revision 5.3 1996/07/31 18:35:50 hogue
538 * Selection and segment-grouping to atom nodes added.
539 *
540 * Revision 5.2 1996/07/22 00:24:10 hogue
541 * Added an origin 3D item for no-primitives condition and general use.
542 *
543 * Revision 5.1 1996/06/03 19:51:20 vakatov
544 * VIEWSCALE decreased (caused "long" overfloat in the 3D drawing functions)
545 *
546 * Revision 5.0 1996/05/28 14:05:44 ostell
547 * Set to revision 5.0
548 *
549 * Revision 1.13 1996/05/23 14:32:34 hogue
550 * Made RenderLabel static for Codewarrior
551 *
552 * Revision 1.12 1996/05/22 22:10:34 kans
553 * changed NULL to '\0'
554 *
555 * Revision 1.11 1996/05/22 21:46:25 hogue
556 * Added White button to label controls.
557 *
558 * Revision 1.10 1996/05/22 20:48:53 hogue
559 * Debugged the label controls, added some label features.
560 *
561 * Revision 1.9 1996/05/22 15:55:20 hogue
562 * Changed label control panel, many other changes to support label drawing.
563 * Also changed some FloatHi's to FloatLo's
564 *
565 * Revision 1.8 1996/05/14 15:19:41 hogue
566 * Added label contols - but are not hooked up yet.
567 *
568 * Revision 1.7 1996/05/09 15:40:40 hogue
569 * Domain rendering enabled.
570 *
571 * Revision 1.6 1996/04/26 21:44:48 vakatov
572 * just casting...
573 *
574 * Revision 1.5 1996/04/26 18:42:08 vakatov
575 * CN3D sources ported to MS-Windows;
576 * the portability errors and warnings fixed, etc.
577 *
578 *
579 * ==========================================================================
580 */
581 #ifdef _OPENGL
582 #include <shim3d.h>
583 #else
584 #include <viewer3d.h>
585 #endif
586 #include <cn3dmain.h>
587 #include <math.h>
588 #include <mmdbapi.h>
589 #include <algorend.h>
590 #include <cn3dmsg.h>
591 #include <saledit.h>
592 #include <salparam.h>
593 #include <cn3dshim.h>
594 #include <cn3dmesh.h>
595 #include <seqcons.h>
596 #include <cn3dmodl.h>
597 #include <cn3dstyl.h>
598 #include <alignmgr.h>
599
600
ENUM_ALIST(empty_alist)601 static ENUM_ALIST(empty_alist)
602 {" ", 1},
603 END_ENUM_ALIST
604
605 static ENUM_ALIST(all_render_alist)
606 {"Wireframe", 1},
607 {"Tubes", 2},
608 {"Ball & Stick", 3},
609 {"Fat Tubes", 4},
610 {"Space Fill ", 5},
611 END_ENUM_ALIST
612
613 static ENUM_ALIST(backbone_render_alist)
614 {"Wireframe", 1},
615 {"Tubes", 2},
616 {"Ball & Stick", 3},
617 {"Fat Tubes", 4},
618 {"Space Fill ", 5},
619 {"Wire Worm", 6}, /* leave worms at end of list - easier to test for */
620 #ifdef _OPENGL
621 {"Worm", 7},
622 {"Fat Worm", 8},
623 #endif
624 END_ENUM_ALIST
625
626 static ENUM_ALIST(ions_render_alist)
627 {"Fat Tubes", 4},
628 {"Space Fill ", 5},
629 END_ENUM_ALIST
630
631 static ENUM_ALIST(connections_render_alist)
632 {"Wireframe", 1},
633 {"Tubes", 2},
634 {"Ball & Stick", 3},
635 END_ENUM_ALIST
636
637 static ENUM_ALIST(solvents_render_alist)
638 {"Ball & Stick", 3},
639 {"Fat Tubes", 4},
640 {"Space Fill ", 5},
641 END_ENUM_ALIST
642
643 static ENUM_ALIST(object_arrow_alist)
644 {"No Arrows", 0},
645 {"Strand Arrows", ARROW_BRICK},
646 {"Helix Arrows", ARROW_CYL},
647 {"Arrows on Both", (ARROW_BRICK | ARROW_CYL)},
648 END_ENUM_ALIST
649
650
651 /* color popup names are now being set according to Cn3D_ColorList; for now
652 these will continue to define the list of appropriate color functions for
653 each object type */
654 static ENUM_ALIST(all_color_alist)
655 {"", C_BYOBJECT},
656 {"", C_BYCHAIN},
657 {"", C_BYDOMAIN},
658 {"", C_BYSECSTRUC},
659 {"", C_BYSTRUCALIGN},
660 {"", C_BYSEQCONS},
661 {"", C_BYRES},
662 {"", C_BYHYDRO},
663 {"", C_CPK},
664 {"", C_BYTEMP},
665 END_ENUM_ALIST
666
667 static ENUM_ALIST(objects_color_alist)
668 {"", C_BYSECSTRUC},
669 {"", C_BYOBJECT},
670 {"", C_BYCHAIN},
671 {"", C_BYDOMAIN},
672 END_ENUM_ALIST
673
674 static ENUM_ALIST(ions_color_alist)
675 {"", C_CPK},
676 {"", C_BYOBJECT},
677 {"", C_BYTEMP},
678 END_ENUM_ALIST
679
680 static ENUM_ALIST(solvents_color_alist)
681 {"", C_CPK},
682 {"", C_BYOBJECT},
683 {"", C_BYTEMP},
684 END_ENUM_ALIST
685
686 static ENUM_ALIST(nt_color_alist)
687 {"", C_BYOBJECT},
688 {"", C_BYCHAIN},
689 {"", C_CPK},
690 {"", C_BYTEMP},
691 END_ENUM_ALIST
692
693 static ENUM_ALIST(heterogen_color_alist)
694 {"", C_CPK},
695 {"", C_BYOBJECT},
696 {"", C_BYTEMP},
697 END_ENUM_ALIST
698
699 #ifdef _OPENGL
700 static ENUM_ALIST(bgColorAList)
701 {"Black", 1},
702 {"White", 2},
703 {"Select...", 3},
704 END_ENUM_ALIST
705 #endif
706
707 /*define DEBUG_N 1 */
708 #ifndef _OPENGL
709 static Picture3D pic = NULL;
710 #endif
711
712 static Int2 Cn3d_RenderNow = 0;
713 static Uint1 Cn3d_LabelNow = 1;
714 static Int2 Cn3d_ColorNow = 0;
715 static Int1 Cn3d_LayerNow = 0;
716 static Boolean Cn3d_DoHydrogens = FALSE;
717 static Boolean Cn3d_CopyToNode = FALSE;
718 static Boolean Cn3d_ColorPass = FALSE; /* gathering unique colors for palette */
719 static Boolean Cn3d_AnyPrim = FALSE;
720 static int Cn3d_lSlaveNum = 0; /* which slave being iterated over 0=master */
721
722 static PopuP Cn3D_pupPBB; /* protein backbone options and on/off */
723 static PopuP Cn3D_pupNABB; /* nucl. acid bb options and on/off */
724 static ButtoN Cn3D_lOnOffItem[10]; /* pieces parts to draw - first 2 empty */
725
726 static PopuP Cn3D_pupRenderStyle[10];
727 static PopuP Cn3D_pupColorStyle[10];
728
729 #ifdef _OPENGL
730 static PopuP Cn3D_pupBackgroundColor;
731 #endif
732
733 static EnumFieldAssocPtr renderAlist[10] = {
734 backbone_render_alist, backbone_render_alist,
735 all_render_alist, all_render_alist,
736 all_render_alist, ions_render_alist, connections_render_alist,
737 solvents_render_alist, object_arrow_alist, empty_alist
738 };
739 static EnumFieldAssocPtr colorAlist[10] = {
740 all_color_alist, nt_color_alist, all_color_alist, nt_color_alist,
741 heterogen_color_alist, ions_color_alist, empty_alist,
742 solvents_color_alist,
743 objects_color_alist, empty_alist
744 };
745 static Int2 renderDefaults[10] = { 1, 1, 1, 1, 1, 5, 1, 5, ARROW_BRICK, 1 };
746 static Int2 colorDefaults[10] = { C_BYOBJECT, C_BYOBJECT, C_BYOBJECT, C_BYOBJECT, C_BYOBJECT,
747 C_BYOBJECT, C_BYOBJECT, C_BYOBJECT, C_BYOBJECT, C_BYOBJECT };
748
749
750 static ButtoN Cn3D_bRedraw; /* the button to redraw */
751 static ButtoN Cn3D_immediateRedraw;
752
753 static ButtoN Cn3D_lOnOffLabel[4];
754 static PopuP Cn3D_pupLabelAA;
755 static PopuP Cn3D_pupLabelNT;
756 static PopuP Cn3D_pupLResName[2];
757 static ButtoN Cn3D_bLTermName[2];
758 static ButtoN Cn3D_bLNum[4];
759 static ButtoN Cn3D_bLWhite[4];
760
761 #ifndef _OPENGL
762 static ButtoN Cn3D_bLTop[4];
763 static PopuP Cn3D_pupLabelSize[4];
764 #else
765 static ButtoN Cn3D_bIonLabel;
766 static PopuP Cn3D_pupLabelFont;
767 static PopuP Cn3D_pupLabelPoints;
768 static ButtoN Cn3D_bLFontBold, Cn3D_bLFontItalic;
769 #ifndef WIN_MOTIF
770 static ButtoN Cn3D_bLFontUnderlined;
771 #endif
772
Nlm_GetCurrentOGLFontMenuSettings(Nlm_Int2 * font,Nlm_Int2 * size,Nlm_Boolean * isBold,Nlm_Boolean * isItalic,Nlm_Boolean * isUnderlined)773 static void Nlm_GetCurrentOGLFontMenuSettings(Nlm_Int2 *font, Nlm_Int2 *size,
774 Nlm_Boolean *isBold, Nlm_Boolean *isItalic, Nlm_Boolean *isUnderlined)
775 {
776 *font = GetValue(Cn3D_pupLabelFont);
777 *size = GetValue(Cn3D_pupLabelPoints);
778 *isBold = GetStatus(Cn3D_bLFontBold);
779 *isItalic = GetStatus(Cn3D_bLFontItalic);
780 #ifndef WIN_MOTIF
781 *isUnderlined = GetStatus(Cn3D_bLFontUnderlined);
782 #else
783 *isUnderlined = 0;
784 #endif
785 }
786
Cn3D_SetOGLFont(TOGL_Data * OGL_Data)787 static void Cn3D_SetOGLFont(TOGL_Data *OGL_Data)
788 {
789 static Nlm_Int2 currentIndex = -1, currentSize = -1;
790 static Nlm_Boolean currentBold = FALSE, currentItalic = FALSE,
791 currentUnderlined = FALSE;
792 Nlm_Int2 fontNameIndex, fontSize;
793 Nlm_Boolean isBold, isItalic, isUnderlined;
794
795 Nlm_GetCurrentOGLFontMenuSettings(&fontNameIndex, &fontSize, &isBold,
796 &isItalic, &isUnderlined);
797 SetOGLFont(OGL_Data, fontNameIndex, fontSize, isBold,
798 isItalic, isUnderlined);
799 }
800
801
802 #endif
803
804 static ButtoN Cn3D_bLRedraw;
805 static ButtoN Cn3D_LimmediateRedraw;
806
807 #ifdef _OPENGL
808 /* for Quality panel */
809 #define QUAL_SIZE_MIN 4
810 #define QUAL_SIZE_MAX 30
811 static PopuP Cn3D_pupQualBigCylSides;
812 static PopuP Cn3D_pupQualBondCylSides;
813 static PopuP Cn3D_pupQualSphSlices;
814 static PopuP Cn3D_pupQualSphStacks;
815 static PopuP Cn3D_pupQualWormSegments;
816 static PopuP Cn3D_pupQualWormSides;
817 static ButtoN Cn3D_bQualOverall[3];
818 static ButtoN Cn3D_bQRedraw;
819 static ButtoN Cn3D_QimmediateRedraw;
820 static PopuP Cn3D_pTick;
821 #endif
822
823 extern CharPtr NCBIstdaaUC;
824 extern CharPtr NCBI4naUC;
825 extern CharPtr NCBI4naLC;
826 extern CharPtr NCBIstdaaLC;
827
828 extern Int1 KinAAColor[];
829 extern Int2 KinNAColor[];
830 extern Int1 KinAtoms[];
831 extern Int1 ColorNumKinBB[];
832 extern Int1 ColorNumKinSC[];
833 extern Int1 ColorNumKinAC[];
834 extern CharPtr KineColors[];
835 extern Int1 ElementKinColors[];
836 extern Int1 ThermKine[];
837 extern Int4 TempsKine[];
838
839 static Uint1 Cn3D_UnalignedResidueColor[3] = { 175, 175, 175 };
840
841 /* the number of colors available to color aligned structures */
842 #define NUM_SLAVES 10
843 static Int1 bObjectColors[NUM_SLAVES] = /* object colors */
844 { C_magenta, C_blue, C_brown, C_sea, C_gray, C_gold, C_pink, C_green, C_cyan, C_yellowtint };
845
846 static Int1 PhobeAAColor[MAX_NCBIstdaa] = { 20, 37, 38, 39, 39, 40, 41,
847 39, 42, 43, 44, 45, 41, 53, 46, 47, 48, 49, 48, 50, 51, 20, 52, 40, 39, 20 };
848
849
850 /**************************************/
851 /* stuff for conf-ensemble separation */
852 /**************************************/
853
854 #define MAXALTCONF 40
855 static Nlm_Int2 Cn3d_nEnsembles = 0, Cn3d_currentEnsemble;
856 static Nlm_Char Cn3d_altConfIDs[MAXALTCONF][MAXALTCONF];
857
858 /* find the PALD structure with the current cAltConf, if ensembles are on */
GetAtomAltLocs(PMAD pmadThis,Nlm_Int2 iModel)859 static PALD GetAtomAltLocs(PMAD pmadThis, Nlm_Int2 iModel)
860 {
861 PALD pald, paldHead;
862 PMMD pmmdThis;
863
864 paldHead = pald = GetAtomLocs(pmadThis, iModel);
865 if (!paldHead) return NULL;
866 if (!Cn3d_nEnsembles) return pald;
867 while (pald) {
868 if (StrChr(Cn3d_altConfIDs[Cn3d_currentEnsemble], pald->cAltConf))
869 return pald;
870 pald = pald->next;
871 }
872 /* if not found, decide whether to return nothing, or just any 'ole PALD */
873 #define QUERY (pmmdThis->bWhat)
874 pmmdThis = GetParentMol((PFB) paldHead);
875 if ((QUERY & AM_SOL) || (QUERY & AM_WAT) ||
876 !allowAltConfIdOverlay())
877 return NULL;
878 else
879 return paldHead;
880 #undef QUERY
881 }
882
883 /* crudely ensures that the above function is always used as a replacement
884 for GetAtomLocs in this file, so alternate conformation models will
885 behave properly; generates a compiler error if GetAtomLocs is used */
886 #define GetAtomLocs DONT_USE_GetAtomLocs_USE_GetAtomAltLocs_IN_ALGOREND_C
887
888
889 /***********************************/
890
ColorFromSS(PMGD pmgdThis)891 static DDV_ColorCell *LIBCALL ColorFromSS(PMGD pmgdThis)
892 {
893 Int2 rsult = 0;
894
895 switch ((int) (pmgdThis->bNCBISecStru)) {
896 case SS_HELIX:
897 return DDV_SearchColorCellbyName(Cn3D_ColorData.pDDVColorGlobal->
898 pvnSpecialColors, "Helix");
899 case SS_SHEET:
900 case SS_STRAND:
901 return DDV_SearchColorCellbyName(Cn3D_ColorData.pDDVColorGlobal->
902 pvnSpecialColors, "Strand");
903 case SS_TURN:
904 return DDV_SearchColorCellbyName(Cn3D_ColorData.pDDVColorGlobal->
905 pvnSpecialColors, "Turn");
906 default:
907 return DDV_SearchColorCellbyName(Cn3D_ColorData.pDDVColorGlobal->
908 pvnSpecialColors, "Coil");
909 }
910 return NULL;
911
912 }
913
SetStructureRenderSettings(PARS pars)914 static void SetStructureRenderSettings(PARS pars)
915 {
916 if (!pars)
917 return;
918
919 pars->HydrogensOn = FALSE;
920
921 pars->PVirtualBBOn = TRUE;
922 pars->PPartialBBOn = FALSE;
923 pars->PCompleteBBOn = FALSE;
924 #ifdef _OPENGL
925 pars->PBBRender = R_WORMTHIN;
926 #else
927 pars->PBBRender = R_WORMWIRE;
928 #endif
929 pars->PResiduesOn = FALSE;
930 pars->PResRender = R_THICKWIRE;
931
932 pars->NTVirtualBBOn = TRUE;
933 pars->NTPartialBBOn = FALSE;
934 pars->NTCompleteBBOn = FALSE;
935 #ifdef _OPENGL
936 pars->NTBBRender = R_WORMFAT;
937 #else
938 pars->NTBBRender = R_THICKWIRE;
939 #endif
940 pars->NTResiduesOn = FALSE;
941 pars->NTResRender = R_WIRE;
942
943 pars->HeterogensOn = TRUE;
944 pars->HetRender = R_THICKWIRE;
945 pars->IonsOn = TRUE;
946 pars->IonRender = R_SPACE;
947 pars->ConnectOn = FALSE;
948 pars->ConnectRender = R_STICK;
949 pars->SolventOn = FALSE;
950 pars->SolventRender = R_BALLNSTICK;
951 pars->ObjectOn = TRUE;
952 pars->ObjectArrows = ARROW_BRICK;
953 }
954
SetStructureColorSettings(PARS pars)955 static void SetStructureColorSettings(PARS pars)
956 {
957 if (!pars)
958 return;
959
960 pars->PBBColor = C_BYSECSTRUC;
961 pars->PResColor = C_BYSECSTRUC;
962
963 pars->NTBBColor = C_CPK;
964 pars->NTResColor = C_CPK;
965
966 pars->HetColor = C_CPK;
967 pars->IonColor = C_CPK;
968 pars->ConnectColor = 9; /* all same color?? */
969 pars->SolventColor = C_CPK;
970 pars->ObjectColor = C_BYSECSTRUC;
971
972 pars->BGColRGB[0] = Cn3d_PaletteRGB[C_black][0];
973 pars->BGColRGB[1] = Cn3d_PaletteRGB[C_black][1];
974 pars->BGColRGB[2] = Cn3d_PaletteRGB[C_black][2];
975 }
976
SetStructureLabelSettings(PARS pars)977 static void SetStructureLabelSettings(PARS pars)
978 {
979 if (!pars)
980 return;
981
982 pars->PBBLabelInterval = 1;
983 pars->PBBLabelJust = (Uint1) (LA_CENTER);
984 pars->PBBLabelStyle = (Uint1) L_NAME | L_NUM | L_3LETR;
985 pars->PBBLabelScale = 2;
986
987 pars->PTermLabelOn = FALSE;
988 pars->PTermLabelJust = (Uint1) (LA_CENTER);
989 pars->PTermLabelStyle = (Uint1) L_NAME;
990 pars->PTermLabelScale = 4;
991
992 pars->IonLabelOn = TRUE;
993
994 pars->NTBBLabelInterval = 1;
995 pars->NTBBLabelJust = (Uint1) (LA_CENTER);
996 pars->NTBBLabelStyle = (Uint1) L_NAME | L_NUM | L_1LETR;
997 pars->NTBBLabelScale = 2;
998
999 pars->NTTermLabelOn = FALSE;
1000 pars->NTTermLabelJust = (Uint1) (LA_CENTER);
1001 pars->NTTermLabelStyle = (Uint1) L_NAME;
1002 pars->NTTermLabelScale = 4;
1003 }
1004
SetStructureAlgorRender(PARS pars)1005 void LIBCALL SetStructureAlgorRender(PARS pars)
1006 {
1007 if (!pars)
1008 return;
1009
1010 SetStructureRenderSettings(pars);
1011 SetStructureColorSettings(pars);
1012 SetStructureLabelSettings(pars);
1013 }
1014
SetAlignRenderSettings(PARS pars)1015 static void SetAlignRenderSettings(PARS pars)
1016 {
1017 if (!pars)
1018 return;
1019
1020 pars->HydrogensOn = FALSE;
1021
1022 pars->PVirtualBBOn = TRUE;
1023 pars->PPartialBBOn = FALSE;
1024 pars->PCompleteBBOn = FALSE;
1025 pars->PBBRender = R_THICKWIRE;
1026 pars->PResiduesOn = FALSE;
1027 pars->PResRender = R_WIRE;
1028
1029 pars->NTVirtualBBOn = FALSE;
1030 pars->NTPartialBBOn = FALSE;
1031 pars->NTCompleteBBOn = TRUE;
1032 pars->NTBBRender = R_WIRE;
1033 pars->NTResiduesOn = TRUE;
1034 pars->NTResRender = R_WIRE;
1035
1036 pars->HeterogensOn = TRUE;
1037 pars->HetRender = R_THICKWIRE;
1038 pars->IonsOn = TRUE;
1039 pars->IonRender = R_SPACE;
1040 pars->ConnectOn = FALSE;
1041 pars->ConnectRender = R_STICK;
1042 pars->SolventOn = FALSE;
1043 pars->SolventRender = R_BALLNSTICK;
1044 pars->ObjectOn = FALSE;
1045 pars->ObjectArrows = ARROW_BRICK;
1046 }
1047
SetAlignColorSettings(PARS pars)1048 static void SetAlignColorSettings(PARS pars)
1049 {
1050 if (!pars)
1051 return;
1052
1053 pars->PBBColor = C_BYSTRUCALIGN;
1054 pars->PResColor = C_BYSTRUCALIGN;
1055
1056 pars->NTBBColor = C_CPK;
1057 pars->NTResColor = C_CPK;
1058
1059 pars->HetColor = C_CPK;
1060 pars->IonColor = C_CPK;
1061 pars->ConnectColor = 9; /* all same color?? */
1062 pars->SolventColor = C_CPK;
1063 pars->ObjectColor = C_BYOBJECT;
1064
1065 pars->BGColRGB[0] = Cn3d_PaletteRGB[C_black][0];
1066 pars->BGColRGB[1] = Cn3d_PaletteRGB[C_black][1];
1067 pars->BGColRGB[2] = Cn3d_PaletteRGB[C_black][2];
1068 }
1069
SetAlignLabelSettings(PARS pars)1070 static void SetAlignLabelSettings(PARS pars)
1071 {
1072 if (!pars)
1073 return;
1074
1075 pars->PBBLabelInterval = 1;
1076 pars->PBBLabelJust = (Uint1) (LA_CENTER);
1077 pars->PBBLabelStyle = (Uint1) L_NAME | L_NUM | L_3LETR;
1078 pars->PBBLabelScale = 2;
1079
1080 pars->PTermLabelOn = FALSE;
1081 pars->PTermLabelJust = (Uint1) (LA_CENTER);
1082 pars->PTermLabelStyle = (Uint1) L_NAME;
1083 pars->PTermLabelScale = 4;
1084
1085 pars->IonLabelOn = TRUE;
1086
1087 pars->NTBBLabelInterval = 1;
1088 pars->NTBBLabelJust = (Uint1) (LA_CENTER);
1089 pars->NTBBLabelStyle = (Uint1) L_NAME | L_NUM | L_1LETR;
1090 pars->NTBBLabelScale = 2;
1091
1092 pars->NTTermLabelOn = FALSE;
1093 pars->NTTermLabelJust = (Uint1) (LA_CENTER);
1094 pars->NTTermLabelStyle = (Uint1) L_NAME;
1095 pars->NTTermLabelScale = 4;
1096 }
1097
SetAlignAlgorRender(PARS pars)1098 void LIBCALL SetAlignAlgorRender(PARS pars)
1099 {
1100 if (!pars)
1101 return;
1102
1103 SetAlignRenderSettings(pars);
1104 SetAlignColorSettings(pars);
1105 SetAlignLabelSettings(pars);
1106 }
1107
1108
NewStructureRenderSet(void)1109 PARS LIBCALL NewStructureRenderSet(void)
1110 {
1111 PARS par = NULL;
1112 par = (PARS) MemNew((size_t) (sizeof(ARS)));
1113 if (!par)
1114 return NULL;
1115 SetStructureAlgorRender(par);
1116 return par;
1117 }
1118
NewAlignRenderSet(void)1119 PARS LIBCALL NewAlignRenderSet(void)
1120 {
1121 PARS par = NULL;
1122 par = (PARS) MemNew((size_t) (sizeof(ARS)));
1123 if (!par)
1124 return NULL;
1125 SetAlignAlgorRender(par);
1126 return par;
1127 }
1128
FreeAlgorRenderSet(PARS pars)1129 void LIBCALL FreeAlgorRenderSet(PARS pars)
1130 {
1131 MemFree(pars);
1132 }
1133
1134
1135
MasterChangeRenderProc(PopuP p)1136 static void MasterChangeRenderProc(PopuP p)
1137 {
1138 Int2 i, j, k;
1139 PARS pars = NULL;
1140 PMSD pmsdThis = NULL;
1141 PDNMS pdnmsThis = NULL;
1142 UIEnum val;
1143 UIEnum eSetting;
1144 #ifdef _OPENGL
1145 Uint1 r, g, b;
1146 #endif
1147
1148 /* fetch the active structure */
1149 pdnmsThis = GetSelectedModelstruc();
1150 if (!pdnmsThis) return;
1151 pmsdThis = (PMSD) pdnmsThis->data.ptrvalue;
1152 pars = (PARS) pmsdThis->pGlobalPARS;
1153 if (!pars) return;
1154
1155 /* deal with mutually exclusive menu settings first */
1156 GetEnumPopup(Cn3D_pupRenderStyle[0], renderAlist[0], &eSetting);
1157 i = GetValue(Cn3D_pupPBB);
1158 if ((i == 2 || i == 3) && eSetting >= 6) {
1159 Message(MSG_ERROR, "Worm rendering can only be used for C-alpha-only backbone");
1160 SafeSetValue(Cn3D_pupPBB, 1);
1161 }
1162 GetEnumPopup(Cn3D_pupRenderStyle[1], renderAlist[1], &eSetting);
1163 i = GetValue(Cn3D_pupNABB);
1164 if ((i == 2 || i == 3) && eSetting >= 6) {
1165 Message(MSG_ERROR, "Worm rendering can only be used for P-only backbone");
1166 SafeSetValue(Cn3D_pupNABB, 1);
1167 }
1168
1169
1170 pars->PResiduesOn = GetStatus(Cn3D_lOnOffItem[2]);
1171 pars->NTResiduesOn = GetStatus(Cn3D_lOnOffItem[3]);
1172 pars->HeterogensOn = GetStatus(Cn3D_lOnOffItem[4]);
1173 pars->IonsOn = GetStatus(Cn3D_lOnOffItem[5]);
1174 pars->ConnectOn = GetStatus(Cn3D_lOnOffItem[6]);
1175 pars->SolventOn = GetStatus(Cn3D_lOnOffItem[7]);
1176 pars->ObjectOn = GetStatus(Cn3D_lOnOffItem[8]);
1177 pars->HydrogensOn = GetStatus(Cn3D_lOnOffItem[9]);
1178
1179 pars->PVirtualBBOn = FALSE;
1180 pars->PPartialBBOn = FALSE;
1181 pars->PCompleteBBOn = FALSE;
1182
1183 i = GetValue(Cn3D_pupPBB);
1184 switch (i) {
1185 case 1:
1186 pars->PVirtualBBOn = TRUE; /* alpha c trace */
1187 break;
1188 case 2:
1189 pars->PPartialBBOn = TRUE; /* partial atoms */
1190 break;
1191 case 3:
1192 pars->PCompleteBBOn = TRUE; /* all atoms */
1193 break;
1194 default:; /* none */
1195 }
1196
1197 pars->NTVirtualBBOn = FALSE;
1198 pars->NTPartialBBOn = FALSE;
1199 pars->NTCompleteBBOn = FALSE;
1200
1201 j = GetValue(Cn3D_pupNABB);
1202 switch (j) {
1203 case 1:
1204 pars->NTVirtualBBOn = TRUE;
1205 break;
1206 case 2:
1207 pars->NTPartialBBOn = TRUE;
1208 break;
1209 case 3:
1210 pars->NTCompleteBBOn = TRUE;
1211 break;
1212 default:;
1213 }
1214
1215 for (i = 0; i < 9; i++) {
1216 if (i == 6) {
1217 pars->ConnectColor = C_yellow;
1218 continue;
1219 }
1220 GetEnumPopup(Cn3D_pupColorStyle[i], colorAlist[i], &val);
1221 switch (i) {
1222 case 0: /* prot bb */
1223 pars->PBBColor = val;
1224 break;
1225 case 1: /* na bb */
1226 pars->NTBBColor = val;
1227 break;
1228 case 2: /* prot sc */
1229 pars->PResColor = val;
1230 break;
1231 case 3: /* na sc */
1232 pars->NTResColor = val;
1233 break;
1234 case 4: /* hets */
1235 pars->HetColor = val;
1236 break;
1237 case 5: /* ions */
1238 pars->IonColor = val;
1239 break;
1240 case 7: /* solvent */
1241 pars->SolventColor = val;
1242 break;
1243 case 8: /* object */
1244 pars->ObjectColor = val;
1245 break;
1246 default:
1247 ;
1248 }
1249 }
1250
1251 for (i = 0; i < 9; i++) {
1252 if (GetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], &val)) {
1253 j = (Int2) val;
1254 } else {
1255 j = 1;
1256 }
1257
1258 if (i == 8) { /* different values for 3d-object arrow settings */
1259 k = j;
1260 } else {
1261 switch (j) {
1262 case 1:
1263 k = R_WIRE;
1264 break;
1265 case 2:
1266 k = R_STICK;
1267 break;
1268 case 3:
1269 k = R_BALLNSTICK;
1270 break;
1271 case 4:
1272 k = R_THICKWIRE;
1273 break;
1274 case 5:
1275 k = R_SPACE;
1276 break;
1277 case 6:
1278 k = R_WORMWIRE;
1279 break;
1280 #ifdef _OPENGL
1281 case 7:
1282 k = R_WORMTHIN;
1283 break;
1284 case 8:
1285 k = R_WORMFAT;
1286 break;
1287 #endif
1288 default:
1289 ;
1290 }
1291 }
1292
1293 switch (i) {
1294 case 0: /* prot bb */
1295 pars->PBBRender = k;
1296 break;
1297 case 1: /* na bb */
1298 pars->NTBBRender = k;
1299 break;
1300 case 2: /* prot sc */
1301 pars->PResRender = k;
1302 break;
1303 case 3: /* na sc */
1304 pars->NTResRender = k;
1305 break;
1306 case 4: /* hets */
1307 pars->HetRender = k;
1308 break;
1309 case 5: /* ions */
1310 pars->IonRender = k;
1311 break;
1312 case 6: /* connections */
1313 pars->ConnectRender = k;
1314 break;
1315 case 7: /* solvent */
1316 pars->SolventRender = k;
1317 break;
1318 case 8: /* object */
1319 pars->ObjectArrows = k;
1320 break;
1321 default:
1322 ;
1323 }
1324 }
1325
1326 #ifdef _OPENGL
1327 if (GetEnumPopup(Cn3D_pupBackgroundColor, bgColorAList, &val)) {
1328 j = (Int2) val;
1329 } else {
1330 j = 1;
1331 }
1332 switch (j) {
1333 case 1:
1334 k = C_black;
1335 break;
1336 case 2:
1337 k = C_white;
1338 break;
1339 case 3:
1340 default:
1341 k = -1;
1342 }
1343 if (k == -1) {
1344 r = pars->BGColRGB[0];
1345 g = pars->BGColRGB[1];
1346 b = pars->BGColRGB[2];
1347 if (p == Cn3D_pupBackgroundColor)
1348 Nlm_ChooseColorDialog(&r, &g, &b, TRUE);
1349 } else {
1350 r = Cn3d_PaletteRGB[k][0];
1351 g = Cn3d_PaletteRGB[k][1];
1352 b = Cn3d_PaletteRGB[k][2];
1353 }
1354 pars->BGColRGB[0] = r;
1355 pars->BGColRGB[1] = g;
1356 pars->BGColRGB[2] = b;
1357 #endif
1358
1359 if (GetStatus(Cn3D_immediateRedraw)) {
1360 fnCn3D_RedrawWrapper(Cn3D_bRedraw);
1361 }
1362 }
1363
ButtonOnOffProc(ButtoN b)1364 static void ButtonOnOffProc(ButtoN b)
1365 {
1366 MasterChangeRenderProc(NULL);
1367 }
1368
PopupOnOffProc(PopuP p)1369 static void PopupOnOffProc(PopuP p)
1370 {
1371 MasterChangeRenderProc(p);
1372 }
1373
Cn3D_RenStruc(IteM i)1374 void Cn3D_RenStruc(IteM i)
1375 {
1376 PARS pars = NULL;
1377 PDNMS pdnmsThis = NULL;
1378
1379 /* fetch the active structure */
1380 pdnmsThis = GetSelectedModelstruc();
1381 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1382 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1383 if (!pars) return;
1384
1385 /* use "default" Structure settings */
1386 SetStructureRenderSettings(pars);
1387
1388 ResetRenderCtrls();
1389 Cn3dObjMgrGetSelected();
1390 Cn3D_Redraw(FALSE);
1391 return;
1392 }
1393
Cn3D_RenWire(IteM i)1394 void Cn3D_RenWire(IteM i)
1395 {
1396 PARS pars = NULL;
1397 PDNMS pdnmsThis = NULL;
1398 PMSD pmsdThis = NULL;
1399 PDNML pdnmlThis = NULL;
1400 PMLD pmldThis = NULL;
1401
1402 /* fetch the active structure */
1403 pdnmsThis = GetSelectedModelstruc();
1404 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1405 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1406 if (!pars) return;
1407
1408 pars->HydrogensOn = FALSE;
1409 pars->ObjectOn = FALSE;
1410 pars->SolventOn = FALSE;
1411 pars->PPartialBBOn = FALSE;
1412 pars->PVirtualBBOn = FALSE;
1413 pars->PCompleteBBOn = TRUE;
1414 pars->PResiduesOn = TRUE;
1415 pars->NTVirtualBBOn = FALSE;
1416 pars->NTPartialBBOn = FALSE;
1417 pars->NTResiduesOn = TRUE;
1418 pars->NTCompleteBBOn = TRUE;
1419 pars->HeterogensOn = TRUE;
1420 pars->IonsOn = TRUE;
1421 pars->ConnectOn = TRUE;
1422 pars->PBBRender = R_WIRE;
1423 pars->PResRender = R_WIRE;
1424 pars->NTBBRender = R_WIRE;
1425 pars->NTResRender = R_WIRE;
1426 pars->HetRender = R_WIRE;
1427 pars->IonRender = R_SPACE;
1428 pars->ConnectRender = R_WIRE;
1429 pars->SolventRender = R_THICKWIRE;
1430
1431 ResetRenderCtrls();
1432 Cn3dObjMgrGetSelected();
1433 Cn3D_Redraw(FALSE);
1434 return;
1435 }
1436
Cn3D_RenTube(IteM i)1437 void Cn3D_RenTube(IteM i)
1438 {
1439 PARS pars = NULL;
1440 PDNMS pdnmsThis = NULL;
1441
1442 /* fetch the active structure */
1443 pdnmsThis = GetSelectedModelstruc();
1444 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1445 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1446 if (!pars) return;
1447
1448 pars->HydrogensOn = FALSE;
1449 pars->ObjectOn = FALSE;
1450 pars->SolventOn = FALSE;
1451 pars->PPartialBBOn = FALSE;
1452 pars->PVirtualBBOn = FALSE;
1453 pars->PCompleteBBOn = TRUE;
1454 pars->PResiduesOn = TRUE;
1455 pars->NTVirtualBBOn = FALSE;
1456 pars->NTPartialBBOn = FALSE;
1457 pars->NTResiduesOn = TRUE;
1458 pars->NTCompleteBBOn = TRUE;
1459 pars->HeterogensOn = TRUE;
1460 pars->IonsOn = TRUE;
1461 pars->ConnectOn = TRUE;
1462 pars->PBBRender = R_THICKWIRE;
1463 pars->PResRender = R_STICK;
1464 pars->NTBBRender = R_THICKWIRE;
1465 pars->NTResRender = R_STICK;
1466 pars->HetRender = R_THICKWIRE;
1467 pars->IonRender = R_SPACE;
1468 pars->ConnectRender = R_STICK;
1469 pars->SolventRender = R_BALLNSTICK;
1470 ResetRenderCtrls();
1471 Cn3dObjMgrGetSelected();
1472 Cn3D_Redraw(FALSE);
1473 return;
1474 }
1475
1476
Cn3D_RenHier(IteM i)1477 void Cn3D_RenHier(IteM i)
1478 {
1479 PARS pars = NULL;
1480 PDNMS pdnmsThis = NULL;
1481
1482 /* fetch the active structure */
1483 pdnmsThis = GetSelectedModelstruc();
1484 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1485 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1486 if (!pars) return;
1487
1488 pars->HydrogensOn = FALSE;
1489 pars->ObjectOn = FALSE;
1490 pars->SolventOn = FALSE;
1491 pars->PPartialBBOn = FALSE;
1492 pars->PVirtualBBOn = FALSE;
1493 pars->PCompleteBBOn = TRUE;
1494 pars->PResiduesOn = TRUE;
1495 pars->NTVirtualBBOn = FALSE;
1496 pars->NTPartialBBOn = FALSE;
1497 pars->NTResiduesOn = TRUE;
1498 pars->NTCompleteBBOn = TRUE;
1499 pars->HeterogensOn = TRUE;
1500 pars->IonsOn = TRUE;
1501 pars->ConnectOn = TRUE;
1502 pars->PBBRender = R_THICKWIRE;
1503 pars->PResRender = R_WIRE;
1504 pars->NTBBRender = R_THICKWIRE;
1505 pars->NTResRender = R_WIRE;
1506 pars->HetRender = R_STICK;
1507 pars->IonRender = R_SPACE;
1508 pars->ConnectRender = R_STICK;
1509 pars->SolventRender = R_BALLNSTICK;
1510 ResetRenderCtrls();
1511 Cn3dObjMgrGetSelected();
1512 Cn3D_Redraw(FALSE);
1513 return;
1514 }
1515
Cn3D_RenSpace(IteM i)1516 void Cn3D_RenSpace(IteM i)
1517 {
1518 PARS pars = NULL;
1519 PDNMS pdnmsThis = NULL;
1520
1521 /* fetch the active structure */
1522 pdnmsThis = GetSelectedModelstruc();
1523 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1524 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1525 if (!pars) return;
1526
1527 pars->HydrogensOn = TRUE;
1528 pars->ObjectOn = FALSE;
1529 pars->SolventOn = FALSE;
1530 pars->PPartialBBOn = FALSE;
1531 pars->PVirtualBBOn = FALSE;
1532 pars->PCompleteBBOn = TRUE;
1533 pars->PResiduesOn = TRUE;
1534 pars->NTVirtualBBOn = FALSE;
1535 pars->NTPartialBBOn = FALSE;
1536 pars->NTResiduesOn = TRUE;
1537 pars->NTCompleteBBOn = TRUE;
1538 pars->HeterogensOn = TRUE;
1539 pars->IonsOn = TRUE;
1540 pars->ConnectOn = TRUE;
1541 pars->PBBRender = R_SPACE;
1542 pars->PResRender = R_SPACE;
1543 pars->NTBBRender = R_SPACE;
1544 pars->NTResRender = R_SPACE;
1545 pars->HetRender = R_SPACE;
1546 pars->IonRender = R_SPACE;
1547 pars->ConnectRender = R_STICK;
1548 pars->SolventRender = R_BALLNSTICK;
1549 ResetRenderCtrls();
1550 Cn3dObjMgrGetSelected();
1551 Cn3D_Redraw(FALSE);
1552 return;
1553 }
1554
Cn3D_RenBS(IteM i)1555 void Cn3D_RenBS(IteM i)
1556 {
1557 PARS pars = NULL;
1558 PDNMS pdnmsThis = NULL;
1559
1560 /* fetch the active structure */
1561 pdnmsThis = GetSelectedModelstruc();
1562 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1563 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1564 if (!pars) return;
1565
1566 pars->HydrogensOn = FALSE;
1567 pars->ObjectOn = FALSE;
1568 pars->SolventOn = FALSE;
1569 pars->PPartialBBOn = FALSE;
1570 pars->PVirtualBBOn = FALSE;
1571 pars->PCompleteBBOn = TRUE;
1572 pars->PResiduesOn = TRUE;
1573 pars->NTVirtualBBOn = FALSE;
1574 pars->NTPartialBBOn = FALSE;
1575 pars->NTResiduesOn = TRUE;
1576 pars->NTCompleteBBOn = TRUE;
1577 pars->HeterogensOn = TRUE;
1578 pars->IonsOn = TRUE;
1579 pars->ConnectOn = TRUE;
1580 pars->PBBRender = R_BALLNSTICK;
1581 pars->PResRender = R_BALLNSTICK;
1582 pars->NTBBRender = R_BALLNSTICK;
1583 pars->NTResRender = R_BALLNSTICK;
1584 pars->HetRender = R_BALLNSTICK;
1585 pars->IonRender = R_SPACE;
1586 pars->ConnectRender = R_STICK;
1587 pars->SolventRender = R_BALLNSTICK;
1588 ResetRenderCtrls();
1589 Cn3dObjMgrGetSelected();
1590 Cn3D_Redraw(FALSE);
1591 return;
1592 }
1593
1594 /**
1595 Render with alignment settings.
1596 */
1597
Cn3D_RenAlign(IteM i)1598 void Cn3D_RenAlign(IteM i)
1599 {
1600 PARS pars = NULL;
1601 PDNMS pdnmsThis = NULL;
1602
1603 /* fetch the active structure */
1604 pdnmsThis = GetSelectedModelstruc();
1605 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1606 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1607 if (!pars) return;
1608
1609 /* use "default" Align settings instead */
1610 SetAlignRenderSettings(pars);
1611
1612 ResetRenderCtrls();
1613 Cn3dObjMgrGetSelected();
1614 Cn3D_Redraw(FALSE);
1615 return;
1616 }
1617
Cn3D_RenDefault(IteM i)1618 void Cn3D_RenDefault(IteM i)
1619 {
1620 PARS pars = NULL;
1621 PDNMS pdnmsThis = NULL;
1622 PMSD pmsdThis = NULL;
1623
1624 /* fetch the active structure */
1625 pdnmsThis = GetSelectedModelstruc();
1626 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1627 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1628 if (!pars) return;
1629
1630 if (pmsdThis->pdnmsSlaves)
1631 SetAlignAlgorRender(pars);
1632 else
1633 SetStructureAlgorRender(pars);
1634 ResetRenderCtrls();
1635 ResetDisplayCtrls();
1636 Cn3dObjMgrGetSelected();
1637 Cn3D_Redraw(FALSE);
1638 return;
1639 }
1640
1641
1642
Cn3D_ColCPK(IteM i)1643 void Cn3D_ColCPK(IteM i)
1644 {
1645 PARS pars = NULL;
1646 PDNMS pdnmsThis = NULL;
1647
1648 /* fetch the active structure */
1649 pdnmsThis = GetSelectedModelstruc();
1650 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1651 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1652 if (!pars) return;
1653
1654 pars->PBBColor = C_CPK;
1655 pars->PResColor = C_CPK;
1656 pars->NTBBColor = C_CPK;
1657 pars->NTResColor = C_CPK;
1658 pars->HetColor = C_CPK;
1659 pars->IonColor = C_CPK;
1660 pars->SolventColor = C_CPK;
1661 pars->ObjectColor = C_BYSECSTRUC;
1662 ResetRenderCtrls();
1663 Cn3dObjMgrGetSelected();
1664 Cn3D_RedrawNUpdate(FALSE);
1665 }
1666
1667
Cn3D_ColDomain(IteM i)1668 void Cn3D_ColDomain(IteM i)
1669 {
1670 PARS pars = NULL;
1671 PDNMS pdnmsThis = NULL;
1672
1673 /* fetch the active structure */
1674 pdnmsThis = GetSelectedModelstruc();
1675 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1676 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1677 if (!pars) return;
1678
1679 pars->PBBColor = C_BYDOMAIN;
1680 pars->PResColor = C_BYDOMAIN;
1681 pars->NTBBColor = C_CPK;
1682 pars->NTResColor = C_CPK;
1683 pars->HetColor = C_CPK;
1684 pars->IonColor = C_CPK;
1685 pars->SolventColor = C_CPK;
1686 pars->ObjectColor = C_BYDOMAIN;
1687 ResetRenderCtrls();
1688 Cn3dObjMgrGetSelected();
1689 Cn3D_RedrawNUpdate(FALSE);
1690 return;
1691 }
1692
1693
Cn3D_ColCyChain(IteM i)1694 void Cn3D_ColCyChain(IteM i)
1695 {
1696 PARS pars = NULL;
1697 PDNMS pdnmsThis = NULL;
1698
1699 /* fetch the active structure */
1700 pdnmsThis = GetSelectedModelstruc();
1701 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1702 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1703 if (!pars) return;
1704
1705 pars->PBBColor = C_BYCHAIN;
1706 pars->PResColor = C_BYCHAIN;
1707 pars->NTBBColor = C_BYCHAIN;
1708 pars->NTResColor = C_BYCHAIN;
1709 pars->HetColor = C_CPK;
1710 pars->IonColor = C_CPK;
1711 pars->SolventColor = C_CPK;
1712 pars->ObjectColor = C_BYCHAIN;
1713 ResetRenderCtrls();
1714 Cn3dObjMgrGetSelected();
1715 Cn3D_RedrawNUpdate(FALSE);
1716 return;
1717 }
1718
Cn3D_ColSecStruc(IteM i)1719 void Cn3D_ColSecStruc(IteM i)
1720 {
1721 PARS pars = NULL;
1722 PDNMS pdnmsThis = NULL;
1723
1724 /* fetch the active structure */
1725 pdnmsThis = GetSelectedModelstruc();
1726 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1727 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1728 if (!pars) return;
1729
1730 /* use "default" Structure settings */
1731 SetStructureColorSettings(pars);
1732
1733 ResetRenderCtrls();
1734 Cn3dObjMgrGetSelected();
1735 Cn3D_RedrawNUpdate(FALSE);
1736 return;
1737 }
1738
Cn3D_ColObject(IteM i)1739 void Cn3D_ColObject(IteM i)
1740 {
1741 PARS pars = NULL;
1742 PDNMS pdnmsThis = NULL;
1743
1744 /* fetch the active structure */
1745 pdnmsThis = GetSelectedModelstruc();
1746 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1747 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1748 if (!pars) return;
1749
1750 pars->PBBColor = C_BYOBJECT;
1751 pars->PResColor = C_BYOBJECT;
1752 pars->NTBBColor = C_BYOBJECT;
1753 pars->NTResColor = C_BYOBJECT;
1754 pars->HetColor = C_BYOBJECT;
1755 pars->IonColor = C_BYOBJECT;
1756 pars->SolventColor = C_BYOBJECT;
1757 pars->ObjectColor = C_BYOBJECT;
1758 ResetRenderCtrls();
1759 Cn3dObjMgrGetSelected();
1760 Cn3D_RedrawNUpdate(FALSE);
1761 return;
1762 }
1763
Cn3D_ColStrucAlign(IteM i)1764 void Cn3D_ColStrucAlign(IteM i)
1765 { /* menu function for setting up color by conservation */
1766 PARS pars = NULL;
1767 PDNMS pdnmsThis = NULL;
1768
1769 /* fetch the active structure */
1770 pdnmsThis = GetSelectedModelstruc();
1771 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1772 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1773 if (!pars) return;
1774
1775 /* use "default" Align settings */
1776 SetAlignColorSettings(pars);
1777
1778 ResetRenderCtrls();
1779 Cn3dObjMgrGetSelected();
1780 Cn3D_RedrawNUpdate(FALSE);
1781 return;
1782 }
1783
Cn3D_ColSeqCons(IteM i)1784 void Cn3D_ColSeqCons(IteM i)
1785 { /* menu function for setting up color by conservation */
1786 PARS pars = NULL;
1787 PDNMS pdnmsThis = NULL;
1788
1789 /* fetch the active structure */
1790 pdnmsThis = GetSelectedModelstruc();
1791 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1792 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1793 if (!pars) return;
1794
1795 pars->ConsColAlg = (Nlm_Int2) GetObjectExtra(i);
1796 pars->PBBColor = C_BYSEQCONS;
1797 pars->PResColor = C_BYSEQCONS;
1798
1799 pars->NTBBColor = C_CPK;
1800 pars->NTResColor = C_CPK;
1801 pars->HetColor = C_CPK;
1802 pars->IonColor = C_CPK;
1803 pars->SolventColor = C_CPK;
1804 pars->ObjectColor = C_BYSECSTRUC;
1805
1806 ResetRenderCtrls();
1807 Cn3dObjMgrGetSelected();
1808 Cn3D_RedrawNUpdate(FALSE);
1809 return;
1810 }
1811
Cn3D_ColRes(IteM i)1812 void Cn3D_ColRes(IteM i)
1813 {
1814 PARS pars = NULL;
1815 PDNMS pdnmsThis = NULL;
1816
1817 /* fetch the active structure */
1818 pdnmsThis = GetSelectedModelstruc();
1819 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1820 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1821 if (!pars) return;
1822
1823 pars->PBBColor = C_BYRES;
1824 pars->PResColor = C_BYRES;
1825 pars->NTBBColor = C_CPK;
1826 pars->NTResColor = C_CPK;
1827 pars->HetColor = C_CPK;
1828 pars->IonColor = C_CPK;
1829 pars->SolventColor = C_CPK;
1830 pars->ObjectColor = C_BYSECSTRUC;
1831 ResetRenderCtrls();
1832 Cn3dObjMgrGetSelected();
1833 Cn3D_RedrawNUpdate(FALSE);
1834 return;
1835 }
1836
Cn3D_ColHydro(IteM i)1837 void Cn3D_ColHydro(IteM i)
1838 {
1839 PARS pars = NULL;
1840 PDNMS pdnmsThis = NULL;
1841
1842 /* fetch the active structure */
1843 pdnmsThis = GetSelectedModelstruc();
1844 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1845 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1846 if (!pars) return;
1847
1848 pars->PBBColor = C_BYHYDRO;
1849 pars->PResColor = C_BYHYDRO;
1850 pars->NTBBColor = C_CPK;
1851 pars->NTResColor = C_CPK;
1852 pars->HetColor = C_CPK;
1853 pars->IonColor = C_CPK;
1854 pars->SolventColor = C_CPK;
1855 pars->ObjectColor = C_BYSECSTRUC;
1856 ResetRenderCtrls();
1857 Cn3dObjMgrGetSelected();
1858 Cn3D_RedrawNUpdate(FALSE);
1859 return;
1860 }
1861
1862
Cn3D_ColTemp(IteM i)1863 void Cn3D_ColTemp(IteM i)
1864 {
1865 PARS pars = NULL;
1866 PDNMS pdnmsThis = NULL;
1867
1868 /* fetch the active structure */
1869 pdnmsThis = GetSelectedModelstruc();
1870 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
1871 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
1872 if (!pars) return;
1873
1874 pars->PBBColor = C_BYTEMP;
1875 pars->PResColor = C_BYTEMP;
1876 pars->NTBBColor = C_BYTEMP;
1877 pars->NTResColor = C_BYTEMP;
1878 pars->HetColor = C_BYTEMP;
1879 pars->IonColor = C_BYTEMP;
1880 pars->SolventColor = C_BYTEMP;
1881 pars->ObjectColor = C_BYSECSTRUC;
1882 ResetRenderCtrls();
1883 Cn3dObjMgrGetSelected();
1884 Cn3D_RedrawNUpdate(FALSE);
1885
1886 return;
1887 }
1888
1889
ResetRenderCtrls(void)1890 void LIBCALL ResetRenderCtrls(void)
1891 {
1892 Int2 i, j, k;
1893 PARS pars = NULL;
1894 PMSD pmsdThis = NULL;
1895 PDNMS pdnmsThis = NULL;
1896 PDNML pdnmlThis = NULL;
1897 PMLD pmldThis = NULL;
1898
1899
1900 /* fetch the active structure */
1901 pdnmsThis = GetSelectedModelstruc();
1902 if (!pdnmsThis ||
1903 !(pmsdThis = (PMSD) pdnmsThis->data.ptrvalue) ||
1904 !(pars = (PARS) pmsdThis->pGlobalPARS)) {
1905
1906 for (k = 2; k < 10; k++) {
1907 SafeSetStatus(Cn3D_lOnOffItem[k], FALSE);
1908 }
1909 SafeSetValue(Cn3D_pupPBB, 4);
1910 SafeSetValue(Cn3D_pupNABB, 4);
1911 for (k = 0; k < 9; k++) {
1912 SetEnumPopup(Cn3D_pupRenderStyle[k], renderAlist[k],
1913 (UIEnum) renderDefaults[k]);
1914 if (k != 6)
1915 SetEnumPopup(Cn3D_pupColorStyle[k], colorAlist[k],
1916 (UIEnum) colorDefaults[k]);
1917 }
1918 #ifdef _OPENGL
1919 SetEnumPopup(Cn3D_pupBackgroundColor, bgColorAList, (UIEnum) 1);
1920 #endif
1921 return;
1922 }
1923
1924 SafeSetStatus(Cn3D_lOnOffItem[2], pars->PResiduesOn);
1925 SafeSetStatus(Cn3D_lOnOffItem[3], pars->NTResiduesOn);
1926 SafeSetStatus(Cn3D_lOnOffItem[4], pars->HeterogensOn);
1927 SafeSetStatus(Cn3D_lOnOffItem[5], pars->IonsOn);
1928 SafeSetStatus(Cn3D_lOnOffItem[6], pars->ConnectOn);
1929 SafeSetStatus(Cn3D_lOnOffItem[7], pars->SolventOn);
1930 SafeSetStatus(Cn3D_lOnOffItem[8], pars->ObjectOn);
1931 SafeSetStatus(Cn3D_lOnOffItem[9], pars->HydrogensOn);
1932
1933 /* yanli added */
1934 /* alpha C trace only control */
1935 pdnmlThis = pmsdThis->pdnmlModels;
1936 pmldThis = (PMLD) pdnmlThis->data.ptrvalue;
1937 if (pmldThis->iType == Model_type_ncbi_backbone) {
1938 if (GetValue(Cn3D_pupPBB) != 4) { /* so it can be off */
1939 pars->PVirtualBBOn = TRUE;
1940 pars->PPartialBBOn = FALSE;
1941 pars->PCompleteBBOn = FALSE;
1942 SafeSetValue(Cn3D_pupPBB, 1);
1943 }
1944 if (GetValue(Cn3D_pupNABB) != 4) {
1945 pars->NTVirtualBBOn = TRUE;
1946 pars->NTPartialBBOn = FALSE;
1947 pars->NTCompleteBBOn = FALSE;
1948 SafeSetValue(Cn3D_pupNABB, 1);
1949 }
1950 }
1951
1952
1953 /*BACKBONE controls */
1954 if (pars->PVirtualBBOn)
1955 SafeSetValue(Cn3D_pupPBB, 1);
1956 else if (pars->PPartialBBOn)
1957 SafeSetValue(Cn3D_pupPBB, 2);
1958 else if (pars->PCompleteBBOn)
1959 SafeSetValue(Cn3D_pupPBB, 3);
1960 else
1961 SafeSetValue(Cn3D_pupPBB, 4);
1962
1963 /* set status of BB items from PARS */
1964 if (pars->NTVirtualBBOn)
1965 SafeSetValue(Cn3D_pupNABB, 1);
1966 else if (pars->NTPartialBBOn)
1967 SafeSetValue(Cn3D_pupNABB, 2);
1968 else if (pars->NTCompleteBBOn)
1969 SafeSetValue(Cn3D_pupNABB, 3);
1970 else
1971 SafeSetValue(Cn3D_pupNABB, 4);
1972
1973
1974 for (i = 0; i < 9; i++) {
1975 k = 0;
1976 j = R_DEFAULT;
1977 switch (i) {
1978 case 0: /* prot bb */
1979 j = pars->PBBRender;
1980 k = pars->PBBColor;
1981 break;
1982 case 1: /* na bb */
1983 j = pars->NTBBRender;
1984 k = pars->NTBBColor;
1985 break;
1986 case 2: /* prot sc */
1987 j = pars->PResRender;
1988 k = pars->PResColor;
1989 break;
1990 case 3: /* na sc */
1991 j = pars->NTResRender;
1992 k = pars->NTResColor;
1993 break;
1994 case 4: /* hets */
1995 j = pars->HetRender;
1996 k = pars->HetColor;
1997 break;
1998 case 5: /* ions */
1999 j = pars->IonRender;
2000 k = pars->IonColor;
2001 break;
2002 case 6: /* connections */
2003 j = pars->ConnectRender;
2004 k = pars->ConnectColor;
2005 break;
2006 case 7: /* solvent */
2007 j = pars->SolventRender;
2008 k = pars->SolventColor;
2009 break;
2010 case 8: /* 3-d objects */
2011 j = pars->ObjectArrows;
2012 k = pars->ObjectColor;
2013 break;
2014 }
2015
2016 if (i != 6) /* skip connections */
2017 SetEnumPopup(Cn3D_pupColorStyle[i], colorAlist[i], (UIEnum) k);
2018
2019 if (i == 8) { /* special settings for 3d-object arrows */
2020 SetEnumPopup(Cn3D_pupRenderStyle[8], renderAlist[8], (UIEnum) j);
2021 } else {
2022 switch (j) {
2023 case R_STICK:
2024 SetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], (UIEnum) 2);
2025 break;
2026 case R_BALLNSTICK:
2027 SetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], (UIEnum) 3);
2028 break;
2029 case R_THICKWIRE:
2030 SetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], (UIEnum) 4);
2031 break;
2032 case R_SPACE:
2033 SetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], (UIEnum) 5);
2034 break;
2035 case R_WORMWIRE:
2036 SetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], (UIEnum) 6);
2037 break;
2038 #ifdef _OPENGL
2039 case R_WORMTHIN:
2040 SetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], (UIEnum) 7);
2041 break;
2042 case R_WORMFAT:
2043 SetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], (UIEnum) 8);
2044 break;
2045 #endif
2046 case R_DEFAULT:
2047 case R_WIRE:
2048 default:
2049 SetEnumPopup(Cn3D_pupRenderStyle[i], renderAlist[i], (UIEnum) 1);
2050 break;
2051 }
2052 }
2053 }
2054
2055 #ifdef _OPENGL
2056 if (pars->BGColRGB[0] == Cn3d_PaletteRGB[C_black][0] &&
2057 pars->BGColRGB[1] == Cn3d_PaletteRGB[C_black][1] &&
2058 pars->BGColRGB[2] == Cn3d_PaletteRGB[C_black][2])
2059 SetEnumPopup(Cn3D_pupBackgroundColor, bgColorAList, (UIEnum) 1);
2060 else if (pars->BGColRGB[0] == Cn3d_PaletteRGB[C_white][0] &&
2061 pars->BGColRGB[1] == Cn3d_PaletteRGB[C_white][1] &&
2062 pars->BGColRGB[2] == Cn3d_PaletteRGB[C_white][2])
2063 SetEnumPopup(Cn3D_pupBackgroundColor, bgColorAList, (UIEnum) 2);
2064 else
2065 SetEnumPopup(Cn3D_pupBackgroundColor, bgColorAList, (UIEnum) 3);
2066 #endif
2067
2068 }
2069
2070
MasterChangeLabelsProc(void)2071 static void MasterChangeLabelsProc(void)
2072 {
2073 Int2 i, k, nameval;
2074 Uint1 codeval;
2075 Boolean NumOn, NameOn, PDBOn, WhiteOn, TopOn;
2076 PARS pars = NULL;
2077 PMSD pmsdThis = NULL;
2078 PDNMS pdnmsThis = NULL;
2079
2080 /* fetch the active structure */
2081 pdnmsThis = GetSelectedModelstruc();
2082 if (!pdnmsThis ||
2083 !(pmsdThis = (PMSD) pdnmsThis->data.ptrvalue) ||
2084 !(pars = (PARS) pmsdThis->pGlobalPARS))
2085 return;
2086
2087 pars->PBBLabelInterval = (Uint1) GetValue(Cn3D_pupLabelAA);
2088 pars->NTBBLabelInterval = (Uint1) GetValue(Cn3D_pupLabelNT);
2089
2090 /* set termini labels */
2091 pars->PTermLabelOn = (Uint1) GetStatus(Cn3D_lOnOffLabel[2]);
2092 pars->NTTermLabelOn = (Uint1) GetStatus(Cn3D_lOnOffLabel[3]);
2093 #ifdef _OPENGL
2094 pars->IonLabelOn = (Uint1) GetStatus(Cn3D_bIonLabel);
2095 #endif
2096
2097
2098 for (i = 0; i < 2; i++) {
2099 nameval = GetValue(Cn3D_pupLResName[i]);
2100 if (nameval == 3)
2101 codeval = (Uint1) L_1LETR;
2102 else
2103 codeval = (Uint1) L_3LETR;
2104 switch (i) {
2105 case 0: /* aa */
2106 /* clear bits */
2107 pars->PBBLabelStyle =
2108 pars->PBBLabelStyle & ~((Uint1) (L_3LETR | L_1LETR));
2109 /* set bit */
2110 pars->PBBLabelStyle = pars->PBBLabelStyle | (Uint1) codeval;
2111 break;
2112 case 1: /* na */
2113 pars->NTBBLabelStyle =
2114 pars->NTBBLabelStyle & ~((Uint1) (L_3LETR | L_1LETR));
2115 pars->NTBBLabelStyle = pars->NTBBLabelStyle | (Uint1) codeval;
2116 break;
2117 default:;
2118 }
2119
2120 NameOn = GetStatus(Cn3D_bLTermName[i]);
2121 switch (i) {
2122 case 0: /* aa */
2123 if (NameOn)
2124 pars->PTermLabelStyle |= ((Uint1) L_NAME);
2125 else
2126 pars->PTermLabelStyle &= ~((Uint1) L_NAME);
2127 break;
2128 case 1: /* na */
2129 if (NameOn)
2130 pars->NTTermLabelStyle |= ((Uint1) L_NAME);
2131 else
2132 pars->NTTermLabelStyle &= ~((Uint1) L_NAME);
2133 break;
2134 default:;
2135 }
2136
2137 NumOn = GetStatus(Cn3D_bLNum[i]);
2138 switch (i) {
2139 case 0: /* aa */
2140 if (NumOn)
2141 pars->PBBLabelStyle = pars->PBBLabelStyle | (Uint1) L_NUM;
2142 else
2143 pars->PBBLabelStyle =
2144 pars->PBBLabelStyle & (Uint1) ~ L_NUM;
2145 break;
2146 case 1: /* na */
2147 if (NumOn)
2148 pars->NTBBLabelStyle =
2149 pars->NTBBLabelStyle | (Uint1) L_NUM;
2150 else
2151 pars->NTBBLabelStyle =
2152 pars->NTBBLabelStyle & (Uint1) ~ L_NUM;
2153 break;
2154 default:;
2155 }
2156 NameOn = (Boolean) (nameval > 1);
2157 switch (i) {
2158 case 0: /* aa */
2159 if (NameOn)
2160 pars->PBBLabelStyle = pars->PBBLabelStyle | (Uint1) L_NAME;
2161 else
2162 pars->PBBLabelStyle =
2163 pars->PBBLabelStyle & (Uint1) ~ L_NAME;
2164 break;
2165 case 1: /* na */
2166 if (NameOn)
2167 pars->NTBBLabelStyle =
2168 pars->NTBBLabelStyle | (Uint1) L_NAME;
2169 else
2170 pars->NTBBLabelStyle =
2171 pars->NTBBLabelStyle & (Uint1) ~ L_NAME;
2172 break;
2173 default:;
2174 }
2175 PDBOn = (Boolean) (nameval == 4);
2176 switch (i) {
2177 case 0: /* aa */
2178 if (PDBOn)
2179 pars->PBBLabelStyle = pars->PBBLabelStyle | (Uint1) L_PDB;
2180 else
2181 pars->PBBLabelStyle =
2182 pars->PBBLabelStyle & (Uint1) ~ L_PDB;
2183 break;
2184 case 1: /* na */
2185 if (PDBOn)
2186 pars->NTBBLabelStyle =
2187 pars->NTBBLabelStyle | (Uint1) L_PDB;
2188 else
2189 pars->NTBBLabelStyle =
2190 pars->NTBBLabelStyle & (Uint1) ~ L_PDB;
2191 break;
2192 default:;
2193 }
2194 WhiteOn = GetStatus(Cn3D_bLWhite[i]);
2195 switch (i) {
2196 case 0: /* aa */
2197 if (WhiteOn)
2198 pars->PBBLabelStyle =
2199 pars->PBBLabelStyle | (Uint1) L_WHITE;
2200 else
2201 pars->PBBLabelStyle =
2202 pars->PBBLabelStyle & (Uint1) ~ L_WHITE;
2203 break;
2204 case 1: /* na */
2205 if (WhiteOn)
2206 pars->NTBBLabelStyle =
2207 pars->NTBBLabelStyle | (Uint1) L_WHITE;
2208 else
2209 pars->NTBBLabelStyle =
2210 pars->NTBBLabelStyle & (Uint1) ~ L_WHITE;
2211 break;
2212 default:;
2213 }
2214
2215 #ifndef _OPENGL
2216 TopOn = GetStatus(Cn3D_bLTop[i]);
2217 switch (i) {
2218 case 0: /* aa */
2219 if (TopOn)
2220 pars->PBBLabelJust = pars->PBBLabelJust | (Uint1) LA_FRONT;
2221 else
2222 pars->PBBLabelJust =
2223 pars->PBBLabelJust & (Uint1) ~ LA_FRONT;
2224 break;
2225 case 1: /* na */
2226 if (TopOn)
2227 pars->NTBBLabelJust =
2228 pars->NTBBLabelJust | (Uint1) LA_FRONT;
2229 else
2230 pars->NTBBLabelJust =
2231 pars->NTBBLabelJust & (Uint1) ~ LA_FRONT;
2232 break;
2233 default:;
2234 }
2235 k = (Int2) GetValue(Cn3D_pupLabelSize[i]);
2236 switch (i) {
2237 case 0: /* prot bb */
2238 pars->PBBLabelScale = k;
2239 break;
2240 case 1: /* na bb */
2241 pars->NTBBLabelScale = k;
2242 break;
2243 default:
2244 ;
2245 }
2246 #endif /* ndef _OPENGL */
2247
2248 }
2249
2250 if (GetStatus(Cn3D_LimmediateRedraw)) {
2251 Cn3D_RedrawProc(Cn3D_bLRedraw);
2252 }
2253 }
2254
LabelPopupOnOffProc(PopuP p)2255 static void LabelPopupOnOffProc(PopuP p)
2256 {
2257 MasterChangeLabelsProc();
2258 }
2259
LabelButtonOnOffProc(ButtoN b)2260 static void LabelButtonOnOffProc(ButtoN b)
2261 {
2262 MasterChangeLabelsProc();
2263 }
2264
LabelGroupOnOffProc(GrouP g)2265 static void LabelGroupOnOffProc(GrouP g)
2266 {
2267 MasterChangeLabelsProc();
2268 }
2269
ResetLabelCtrls(void)2270 void LIBCALL ResetLabelCtrls(void)
2271 {
2272 Int2 i, val, style, size, termStyle;
2273 PARS pars = NULL;
2274 PMSD pmsdThis = NULL;
2275 PDNMS pdnmsThis = NULL;
2276
2277 /* fetch the active structure */
2278 pdnmsThis = GetSelectedModelstruc();
2279 if (!pdnmsThis ||
2280 !(pmsdThis = (PMSD) pdnmsThis->data.ptrvalue) ||
2281 !(pars = (PARS) pmsdThis->pGlobalPARS)) {
2282
2283 SafeSetValue(Cn3D_pupLabelAA, 1);
2284 SafeSetValue(Cn3D_pupLabelNT, 1);
2285
2286 SafeSetStatus(Cn3D_lOnOffLabel[2], FALSE);
2287 SafeSetStatus(Cn3D_lOnOffLabel[3], FALSE);
2288
2289 for (i = 0; i < 2; i++) {
2290 SafeSetValue(Cn3D_pupLResName[i], 1);
2291 SafeSetStatus(Cn3D_bLTermName[i], FALSE);
2292 SafeSetStatus(Cn3D_bLNum[i], FALSE);
2293 SafeSetStatus(Cn3D_bLWhite[i], FALSE);
2294 #ifndef _OPENGL
2295 SafeSetStatus(Cn3D_bLTop[i], FALSE);
2296 SafeSetValue(Cn3D_pupLabelSize[i], 1);
2297 #endif
2298 }
2299 return;
2300 }
2301
2302 SafeSetValue(Cn3D_pupLabelAA, pars->PBBLabelInterval);
2303 SafeSetValue(Cn3D_pupLabelNT, pars->NTBBLabelInterval);
2304
2305 SafeSetStatus(Cn3D_lOnOffLabel[2], pars->PTermLabelOn);
2306 SafeSetStatus(Cn3D_lOnOffLabel[3], pars->NTTermLabelOn);
2307 #ifdef _OPENGL
2308 SafeSetStatus(Cn3D_bIonLabel, pars->IonLabelOn);
2309 #endif
2310
2311 for (i = 0; i < 2; i++) {
2312 val = 1;
2313 switch (i) {
2314 case 0:
2315 style = pars->PBBLabelStyle;
2316 size = pars->PBBLabelScale;
2317 termStyle = pars->PTermLabelStyle;
2318 break;
2319 case 1:
2320 style = pars->NTBBLabelStyle;
2321 size = pars->NTBBLabelScale;
2322 termStyle = pars->NTTermLabelStyle;
2323 break;
2324 default:
2325 break;
2326 }
2327 if (!(Boolean) (style & (Uint1) (L_NAME))) {
2328 val = 1;
2329 } else if ((Boolean) (style & (Uint1) (L_3LETR))) {
2330 val = 2;
2331 } else if ((Boolean) (style & (Uint1) (L_1LETR))) {
2332 val = 3;
2333 } else if ((Boolean) (style & (Uint1) L_PDB)) {
2334 val = 4;
2335 }
2336 SafeSetValue(Cn3D_pupLResName[i], val);
2337 SafeSetStatus(Cn3D_bLTermName[i], (termStyle & L_NAME) ? TRUE : FALSE);
2338 SafeSetStatus(Cn3D_bLNum[i], (Boolean) (style & (Uint1) L_NUM));
2339 SafeSetStatus(Cn3D_bLWhite[i],
2340 (Boolean) (style & (Uint1) ~ L_WHITE));
2341 #ifndef _OPENGL
2342 SafeSetStatus(Cn3D_bLTop[i], (Boolean) (style & (Uint1) LA_FRONT));
2343 SafeSetValue(Cn3D_pupLabelSize[i], size);
2344 #endif
2345 }
2346 }
2347
2348
Cn3D_RedrawProc(ButtoN b)2349 void Cn3D_RedrawProc(ButtoN b)
2350 {
2351 Int2 k;
2352 PARS pars = NULL;
2353 PMSD pmsdThis = NULL;
2354 PDNMS pdnmsThis = NULL;
2355 PDNML pdnmlThis = NULL;
2356 PMLD pmldThis = NULL;
2357
2358 /* fetch the active structure */
2359 pdnmsThis = GetSelectedModelstruc();
2360 if (!pdnmsThis ||
2361 !(pmsdThis = (PMSD) pdnmsThis->data.ptrvalue) ||
2362 !(pars = (PARS) pmsdThis->pGlobalPARS)) {
2363
2364 for (k = 2; k < 10; k++) {
2365 SafeSetStatus(Cn3D_lOnOffItem[k], FALSE);
2366 }
2367 SafeSetValue(Cn3D_pupPBB, 4);
2368 SafeSetValue(Cn3D_pupNABB, 4);
2369 for (k = 0; k < 9; k++) {
2370 SetEnumPopup(Cn3D_pupRenderStyle[k], renderAlist[k],
2371 (UIEnum) renderDefaults[k]);
2372 if (k != 6)
2373 SetEnumPopup(Cn3D_pupColorStyle[k], colorAlist[k],
2374 (UIEnum) colorDefaults[k]);
2375 }
2376 #ifdef _OPENGL
2377 SetEnumPopup(Cn3D_pupBackgroundColor, bgColorAList, (UIEnum) 1);
2378 #endif
2379 return;
2380 }
2381
2382 /* alpha C trace only control */
2383 pdnmlThis = pmsdThis->pdnmlModels;
2384 pmldThis = (PMLD) pdnmlThis->data.ptrvalue;
2385 if (pmldThis->iType == Model_type_ncbi_backbone) {
2386 if (GetValue(Cn3D_pupPBB) != 4) { /* so it can be off */
2387 pars->PVirtualBBOn = TRUE;
2388 pars->PPartialBBOn = FALSE;
2389 pars->PCompleteBBOn = FALSE;
2390 SafeSetValue(Cn3D_pupPBB, 1);
2391 }
2392 if (GetValue(Cn3D_pupNABB) != 4) {
2393 pars->NTVirtualBBOn = TRUE;
2394 pars->NTPartialBBOn = FALSE;
2395 pars->NTCompleteBBOn = FALSE;
2396 SafeSetValue(Cn3D_pupNABB, 1);
2397 }
2398 }
2399
2400 Cn3dObjMgrGetSelected();
2401 Cn3D_Redraw(FALSE);
2402 }
2403
2404
AlignLabelButtons(Handle master,Handle slave)2405 static void AlignLabelButtons(Handle master, Handle slave)
2406 {
2407 RecT pptPos, btnPos;
2408 Int2 delta;
2409
2410 GetPosition(master, &pptPos);
2411 GetPosition(slave, &btnPos);
2412 delta =
2413 (pptPos.bottom + pptPos.top) / 2 - (btnPos.bottom +
2414 btnPos.top) / 2;
2415 if (delta != 0) {
2416 OffsetRect(&btnPos, 0, delta);
2417 SetPosition(slave, &btnPos);
2418 AdjustPrnt((Nlm_GraphiC) slave, &btnPos, FALSE);
2419 }
2420 }
2421
2422 #ifdef _OPENGL
2423 extern void Nlm_FindAvailableFonts(PopuP);
2424 #endif
2425
LabelControls(Nlm_GrouP prnt)2426 GrouP LIBCALL LabelControls(Nlm_GrouP prnt)
2427 {
2428 GrouP g, h;
2429 Int2 k;
2430 PrompT ppt[4];
2431 PrompT ppt1, ppt2, ppt3, ppt4, ppt7, ppt8, ppt9;
2432 #ifdef _OPENGL
2433 GrouP h2, h3, h4, h5, h6, h7;
2434 PrompT ppt10, ppt11;
2435 #endif
2436
2437 g = HiddenGroup(prnt, -1, 0, NULL);
2438 StaticPrompt(g, "", 0, stdLineHeight, systemFont, 'l');
2439 StaticPrompt(g, "", 0, stdLineHeight, systemFont, 'l');
2440 if (!g)
2441 return NULL;
2442 SetGroupSpacing(g, 3, 9);
2443 /*
2444 #ifdef WIN_MOTIF
2445 SetGroupMargins ( g, 4, 1 );
2446 SetGroupSpacing ( g, 2, 1 );
2447 #else
2448 SetGroupMargins ( g, 1, 1 );
2449 SetGroupSpacing ( g, 0, 0 );
2450 #endif
2451 */
2452
2453 h = HiddenGroup(g, 0, -5, NULL);
2454 SetGroupSpacing(h, 5, 3);
2455
2456 Cn3D_lOnOffLabel[0] = NULL; /* Cn3D_pupLabelAA includes off setting */
2457 Cn3D_lOnOffLabel[1] = NULL; /* Cn3D_pupLabelNT includes off setting */
2458
2459 ppt1 =
2460 StaticPrompt(h, "Category", 0, stdLineHeight + 5, systemFont, 'c');
2461 ppt[0] =
2462 StaticPrompt(h, "Amino Acid", 0, popupMenuHeight, systemFont, 'l');
2463 ppt[1] =
2464 StaticPrompt(h, "Nucleic Acid", 0, popupMenuHeight, systemFont, 'l');
2465 ppt[2] =
2466 StaticPrompt(h, "N & C Termini", 0, popupMenuHeight, systemFont, 'l');
2467 ppt[3] =
2468 StaticPrompt(h, "5' & 3' Termini", 0, popupMenuHeight, systemFont, 'l');
2469 AlignObjects(ALIGN_CENTER, (HANDLE) ppt1, (HANDLE) ppt[3], NULL);
2470
2471 ppt2 =
2472 StaticPrompt(h, "On/Off", 0, stdLineHeight + 5, systemFont, 'c');
2473 Cn3D_pupLabelAA = PopupList(h, FALSE, LabelPopupOnOffProc);
2474 PopupItem(Cn3D_pupLabelAA, "none");
2475 PopupItem(Cn3D_pupLabelAA, "every AA");
2476 PopupItem(Cn3D_pupLabelAA, "every 5");
2477 PopupItem(Cn3D_pupLabelAA, "every 10");
2478 PopupItem(Cn3D_pupLabelAA, "every 20");
2479 PopupItem(Cn3D_pupLabelAA, "every 50");
2480 Cn3D_pupLabelNT = PopupList(h, FALSE, LabelPopupOnOffProc);
2481 PopupItem(Cn3D_pupLabelNT, "none");
2482 PopupItem(Cn3D_pupLabelNT, "every NA");
2483 PopupItem(Cn3D_pupLabelNT, "every 5");
2484 PopupItem(Cn3D_pupLabelNT, "every 10");
2485 PopupItem(Cn3D_pupLabelNT, "every 20");
2486 PopupItem(Cn3D_pupLabelNT, "every 50");
2487 Cn3D_lOnOffLabel[2] = CheckBox(h, "", LabelButtonOnOffProc);
2488 Cn3D_lOnOffLabel[3] = CheckBox(h, "", LabelButtonOnOffProc);
2489 AlignObjects(ALIGN_CENTER, (HANDLE) ppt2, (HANDLE) Cn3D_pupLabelAA,
2490 (HANDLE) Cn3D_pupLabelNT, (HANDLE) Cn3D_lOnOffLabel[2],
2491 (HANDLE) Cn3D_lOnOffLabel[3], NULL);
2492
2493 ppt3 = StaticPrompt(h, "Name", 0, stdLineHeight + 5, systemFont, 'c');
2494 for (k = 0; k < 2; k++) {
2495 Cn3D_pupLResName[k] = PopupList(h, FALSE, LabelPopupOnOffProc);
2496 PopupItem(Cn3D_pupLResName[k], "none");
2497 PopupItem(Cn3D_pupLResName[k], "3 letter");
2498 PopupItem(Cn3D_pupLResName[k], "1 letter");
2499 PopupItem(Cn3D_pupLResName[k], "PDB");
2500 }
2501 for (k = 0; k < 2; k++) {
2502 Cn3D_bLTermName[k] = CheckBox(h, "", LabelButtonOnOffProc);
2503 }
2504 AlignObjects(ALIGN_CENTER, (HANDLE) ppt3, (HANDLE) Cn3D_pupLResName[0],
2505 (HANDLE) Cn3D_pupLResName[1], (HANDLE) Cn3D_bLTermName[0],
2506 (HANDLE) Cn3D_bLTermName[1], NULL);
2507
2508 ppt4 = StaticPrompt(h, "Num", 0, stdLineHeight + 5, systemFont, 'c');
2509 for (k = 0; k < 2; k++) {
2510 Cn3D_bLNum[k] = CheckBox(h, "", LabelButtonOnOffProc);
2511 }
2512 for (k = 2; k < 4; k++) { /* just placeholders */
2513 Cn3D_bLNum[k] = (ButtoN) StaticPrompt(h, "", 0, stdLineHeight + 5, systemFont, 'c');
2514 }
2515 AlignObjects(ALIGN_CENTER, (HANDLE) ppt4, (HANDLE) Cn3D_bLNum[0],
2516 (HANDLE) Cn3D_bLNum[1], (HANDLE) Cn3D_bLNum[2],
2517 (HANDLE) Cn3D_bLNum[3], NULL);
2518
2519 #ifndef _OPENGL
2520 ppt7 =
2521 StaticPrompt(h, "On Top", 0, stdLineHeight + 5, systemFont, 'c');
2522 for (k = 0; k < 4; k++) {
2523 Cn3D_bLTop[k] = CheckBox(h, "", LabelButtonOnOffProc);
2524 }
2525 AlignObjects(ALIGN_CENTER, (HANDLE) ppt7, (HANDLE) Cn3D_bLTop[0],
2526 (HANDLE) Cn3D_bLTop[1], (HANDLE) Cn3D_bLTop[2],
2527 (HANDLE) Cn3D_bLTop[3], NULL);
2528 #endif
2529
2530 ppt8 = StaticPrompt(h, "White", 0, stdLineHeight + 5, systemFont, 'c');
2531 for (k = 0; k < 2; k++) {
2532 Cn3D_bLWhite[k] = CheckBox(h, "", LabelButtonOnOffProc);
2533 }
2534 for (k = 2; k < 4; k++) { /* just placeholders */
2535 Cn3D_bLWhite[k] = (ButtoN) StaticPrompt(h, "", 0, stdLineHeight + 5, systemFont, 'c');
2536 }
2537 AlignObjects(ALIGN_CENTER, (HANDLE) ppt8,
2538 (HANDLE) Cn3D_bLWhite[0], (HANDLE) Cn3D_bLWhite[1],
2539 (HANDLE) Cn3D_bLWhite[2], (HANDLE) Cn3D_bLWhite[3], NULL);
2540
2541 #ifndef _OPENGL
2542 ppt9 = StaticPrompt(h, "Size", 0, stdLineHeight + 5, systemFont, 'c');
2543 for (k = 0; k < 4; k++) {
2544 Cn3D_pupLabelSize[k] = PopupList(h, FALSE, LabelPopupOnOffProc);
2545 PopupItem(Cn3D_pupLabelSize[k], "1");
2546 PopupItem(Cn3D_pupLabelSize[k], "2");
2547 PopupItem(Cn3D_pupLabelSize[k], "3");
2548 PopupItem(Cn3D_pupLabelSize[k], "4");
2549 PopupItem(Cn3D_pupLabelSize[k], "5");
2550 PopupItem(Cn3D_pupLabelSize[k], "6");
2551 PopupItem(Cn3D_pupLabelSize[k], "7");
2552 PopupItem(Cn3D_pupLabelSize[k], "8");
2553 PopupItem(Cn3D_pupLabelSize[k], "9");
2554 PopupItem(Cn3D_pupLabelSize[k], "10");
2555 }
2556 AlignObjects(ALIGN_CENTER, (HANDLE) ppt9,
2557 (HANDLE) Cn3D_pupLabelSize[0],
2558 (HANDLE) Cn3D_pupLabelSize[1],
2559 (HANDLE) Cn3D_pupLabelSize[2],
2560 (HANDLE) Cn3D_pupLabelSize[3], NULL);
2561 #endif
2562
2563 #ifndef _OPENGL
2564 AlignLabelButtons(Cn3D_pupLabelSize[2], Cn3D_lOnOffLabel[2]);
2565 AlignLabelButtons(Cn3D_pupLabelSize[3], Cn3D_lOnOffLabel[3]);
2566 for (k = 0; k < 2; k++) {
2567 AlignLabelButtons(Cn3D_pupLabelSize[k], Cn3D_pupLResName[k]);
2568 AlignLabelButtons(Cn3D_pupLabelSize[k+2], Cn3D_bLTermName[k]);
2569 AlignLabelButtons(Cn3D_pupLabelSize[k], Cn3D_bLNum[k]);
2570 }
2571 for (k = 0; k < 4; k++) {
2572 AlignLabelButtons(Cn3D_pupLabelSize[k], Cn3D_bLTop[k]);
2573 AlignLabelButtons(Cn3D_pupLabelSize[k], Cn3D_bLWhite[k]);
2574 }
2575
2576 #else
2577 AlignLabelButtons(ppt[2], Cn3D_lOnOffLabel[2]);
2578 AlignLabelButtons(ppt[3], Cn3D_lOnOffLabel[3]);
2579 for (k = 0; k < 2; k++) {
2580 AlignLabelButtons(ppt[k], Cn3D_pupLResName[k]);
2581 AlignLabelButtons(ppt[k+2], Cn3D_bLTermName[k]);
2582 AlignLabelButtons(ppt[k], Cn3D_bLNum[k]);
2583 AlignLabelButtons(ppt[k], Cn3D_bLWhite[k]);
2584 }
2585
2586 h6 = HiddenGroup(g, 0, -1, NULL); /* blank horiz. space */
2587 SetGroupSpacing(h6, 5, 3);
2588
2589 h7 = HiddenGroup(g, 0, -1, NULL);
2590 Cn3D_bIonLabel = CheckBox(h7, "Show Ion Labels", LabelButtonOnOffProc);
2591
2592 h5 = HiddenGroup(g, 0, -1, NULL); /* blank horiz. space */
2593 SetGroupSpacing(h5, 5, 3);
2594
2595
2596 h2 = HiddenGroup(g, 0, -1, NULL);
2597 SetGroupSpacing(h2, 5, 3);
2598 ppt9 = StaticPrompt(h2, "Font: ", 0, stdLineHeight + 5, systemFont, 'c');
2599 Cn3D_pupLabelFont = PopupList(h2, FALSE, LabelPopupOnOffProc);
2600 Nlm_FindAvailableFonts(Cn3D_pupLabelFont);
2601 SetValue(Cn3D_pupLabelFont, 1);
2602 AlignLabelButtons(ppt9,Cn3D_pupLabelFont);
2603 ppt10 = StaticPrompt(h2, " Size: ", 0, stdLineHeight + 5, systemFont, 'c');
2604 Cn3D_pupLabelPoints = PopupList(h2, FALSE, LabelPopupOnOffProc);
2605 for (k=1; k<=30; k++) {
2606 char ss[3];
2607 sprintf(ss,"%i",k);
2608 PopupItem(Cn3D_pupLabelPoints, ss);
2609 }
2610 SetValue(Cn3D_pupLabelPoints, 12);
2611 AlignLabelButtons(ppt10,Cn3D_pupLabelPoints);
2612
2613 h3 = HiddenGroup(g, 0, -1, NULL);
2614 SetGroupSpacing(h3, 5, 3);
2615 ppt11 = StaticPrompt(h3, "Style: ", 0, stdLineHeight + 5, systemFont, 'c');
2616 Cn3D_bLFontBold = CheckBox(h3, "bold", LabelButtonOnOffProc);
2617 Cn3D_bLFontItalic = CheckBox(h3, "italic", LabelButtonOnOffProc);
2618 #ifndef WIN_MOTIF
2619 Cn3D_bLFontUnderlined = CheckBox(h3, "underlined", LabelButtonOnOffProc);
2620 #endif
2621
2622 h4 = HiddenGroup(g, 0, -1, NULL); /* blank horiz. space */
2623 SetGroupSpacing(h4, 5, 3);
2624
2625 AlignObjects(ALIGN_CENTER, (HANDLE) h5, (HANDLE) h2, (HANDLE) h3,
2626 (HANDLE) h4, (HANDLE) h6, (HANDLE) h7, (HANDLE) h, NULL);
2627
2628 #endif /* _OPENGL */
2629
2630 Cn3D_LimmediateRedraw =
2631 CheckBox(g, "Immediate Redraw on Every Change", NULL);
2632 Cn3D_bLRedraw = PushButton(g, "Apply!", Cn3D_RedrawProc);
2633 AlignObjects(ALIGN_CENTER, (HANDLE) Cn3D_bLRedraw,
2634 (HANDLE) Cn3D_LimmediateRedraw, (HANDLE) h, NULL);
2635
2636 ResetLabelCtrls();
2637 return g;
2638 }
2639
2640 #ifdef _OPENGL
2641
2642 #define CN3DTICKDEFAULT (6)
2643 static FloatHi Cn3D_Tick[] = {
2644 0.01L, 0.025L, 0.05L, 0.1L, 0.25L, 0.5L, 1.0L, 2.5L, 5.0L, 10.0L, 0.0L};
2645
Cn3D_SetQualityFromAppParams(void)2646 void Cn3D_SetQualityFromAppParams(void)
2647 {
2648 Char str[64];
2649 int i;
2650
2651 if (GetAppParam("CN3D", "QUALITY", "BIGCYLSIDES", NULL, str, sizeof(str)))
2652 SafeSetValue(Cn3D_pupQualBigCylSides, atoi(str) - QUAL_SIZE_MIN + 1);
2653 if (GetAppParam("CN3D", "QUALITY", "BONDCYLSIDES", NULL, str, sizeof(str)))
2654 SafeSetValue(Cn3D_pupQualBondCylSides, atoi(str) - QUAL_SIZE_MIN + 1);
2655 if (GetAppParam("CN3D", "QUALITY", "SPHERESLICES", NULL, str, sizeof(str)))
2656 SafeSetValue(Cn3D_pupQualSphSlices, atoi(str) - QUAL_SIZE_MIN + 1);
2657 if (GetAppParam("CN3D", "QUALITY", "SPHERESTACKS", NULL, str, sizeof(str)))
2658 SafeSetValue(Cn3D_pupQualSphStacks, atoi(str) - QUAL_SIZE_MIN + 1);
2659 if (GetAppParam("CN3D", "QUALITY", "WORMSEGMENTS", NULL, str, sizeof(str)))
2660 SafeSetValue(Cn3D_pupQualWormSegments, atoi(str)/2 + 1 - QUAL_SIZE_MIN/2);
2661 if (GetAppParam("CN3D", "QUALITY", "WORMSIDES", NULL, str, sizeof(str)))
2662 SafeSetValue(Cn3D_pupQualWormSides, atoi(str)/2 + 1 - QUAL_SIZE_MIN/2);
2663
2664 if (GetAppParam("CN3D", "SETTINGS", "ANIMATIONSPEED", NULL, str, sizeof(str))) {
2665 FloatHi tick;
2666 int i;
2667
2668 tick = atof(str);
2669 for (i=0; Cn3D_Tick[i] != 0.0L; i++)
2670 if (tick == Cn3D_Tick[i]) break;
2671 if (Cn3D_Tick[i] == 0.0L) i = CN3DTICKDEFAULT - 1;
2672 Cn3D_ColorData.OGL_Data->Tick = Cn3D_Tick[i];
2673 SetValue(Cn3D_pTick, i + 1);
2674 }
2675 }
2676
QualityChangePopupProc(Nlm_PopuP p)2677 static void QualityChangePopupProc(Nlm_PopuP p)
2678 {
2679 Char str[8];
2680
2681 sprintf(str, "%i", GetValue(Cn3D_pupQualBigCylSides) + QUAL_SIZE_MIN - 1);
2682 SetAppParam("CN3D", "QUALITY", "BIGCYLSIDES", str);
2683 sprintf(str, "%i", GetValue(Cn3D_pupQualBondCylSides) + QUAL_SIZE_MIN - 1);
2684 SetAppParam("CN3D", "QUALITY", "BONDCYLSIDES", str);
2685 sprintf(str, "%i", GetValue(Cn3D_pupQualSphSlices) + QUAL_SIZE_MIN - 1);
2686 SetAppParam("CN3D", "QUALITY", "SPHERESLICES", str);
2687 sprintf(str, "%i", GetValue(Cn3D_pupQualSphStacks) + QUAL_SIZE_MIN - 1);
2688 SetAppParam("CN3D", "QUALITY", "SPHERESTACKS", str);
2689 sprintf(str, "%i", 2 * (GetValue(Cn3D_pupQualWormSegments) - 1) + QUAL_SIZE_MIN);
2690 SetAppParam("CN3D", "QUALITY", "WORMSEGMENTS", str);
2691 sprintf(str, "%i", 2 * (GetValue(Cn3D_pupQualWormSides) - 1) + QUAL_SIZE_MIN);
2692 SetAppParam("CN3D", "QUALITY", "WORMSIDES", str);
2693
2694 if (GetStatus(Cn3D_QimmediateRedraw)) {
2695 Cn3D_RedrawProc(Cn3D_bQRedraw);
2696 }
2697 }
2698
2699 static Nlm_Int2 qSet[3][6] = {
2700 { 12, 6, 6, 4, 4, 6 }, /* low/fast */
2701 { 12, 6, 10, 8, 6, 6 }, /* med/med */
2702 { 30, 16, 16, 10, 10, 20 } /* high/slow */
2703 };
2704
OverallQualityChangeProc(Nlm_ButtoN pressed)2705 static void OverallQualityChangeProc(Nlm_ButtoN pressed)
2706 {
2707 int i, which = -1;
2708
2709 for (i=0; i<3; i++) {
2710 if (pressed == Cn3D_bQualOverall[i]) {
2711 which = i;
2712 break;
2713 }
2714 }
2715 SafeSetValue(Cn3D_pupQualBigCylSides, qSet[which][0] - QUAL_SIZE_MIN + 1);
2716 SafeSetValue(Cn3D_pupQualBondCylSides, qSet[which][1] - QUAL_SIZE_MIN + 1);
2717 SafeSetValue(Cn3D_pupQualSphSlices, qSet[which][2] - QUAL_SIZE_MIN + 1);
2718 SafeSetValue(Cn3D_pupQualSphStacks, qSet[which][3] - QUAL_SIZE_MIN + 1);
2719 SafeSetValue(Cn3D_pupQualWormSegments, qSet[which][4]/2 + 1 - QUAL_SIZE_MIN/2);
2720 SafeSetValue(Cn3D_pupQualWormSides, qSet[which][5]/2 + 1 - QUAL_SIZE_MIN/2);
2721 QualityChangePopupProc(NULL);
2722 }
2723
Cn3D_TickPopupProc(PopuP value)2724 static void Cn3D_TickPopupProc(PopuP value)
2725 {
2726 Int4 n;
2727 Char str[64];
2728
2729 OGL_StopPlaying(Cn3D_ColorData.OGL_Data);
2730 n = GetValue(Cn3D_pTick);
2731 Cn3D_ColorData.OGL_Data->Tick = Cn3D_Tick[n - 1];
2732
2733 sprintf(str, "%g", Cn3D_ColorData.OGL_Data->Tick);
2734 SetAppParam("CN3D", "SETTINGS", "ANIMATIONSPEED", str);
2735 }
2736
qualityItem(Nlm_GrouP h,char * title,Nlm_PopuP * pup,int def)2737 static Nlm_GrouP qualityItem(Nlm_GrouP h, char *title, Nlm_PopuP *pup, int def)
2738 {
2739 char numstr[3];
2740 Nlm_PrompT prompt;
2741 Nlm_GrouP i;
2742 int k;
2743
2744 i = Nlm_HiddenGroup(h, -2, 1, NULL);
2745 SetGroupSpacing(i, 15, 3);
2746 *pup = PopupList(i, FALSE, QualityChangePopupProc);
2747 if (*pup == Cn3D_pupQualWormSegments || *pup == Cn3D_pupQualWormSides) {
2748 /* only even numbers */
2749 for (k=QUAL_SIZE_MIN; k<=QUAL_SIZE_MAX; k+=2) {
2750 sprintf(numstr,"%i",k);
2751 PopupItem(*pup, numstr);
2752 }
2753 SetValue(*pup, def/2 + 1 - QUAL_SIZE_MIN/2);
2754 } else {
2755 for (k=QUAL_SIZE_MIN; k<=QUAL_SIZE_MAX; k++) {
2756 sprintf(numstr,"%i",k);
2757 PopupItem(*pup, numstr);
2758 }
2759 SetValue(*pup, def - QUAL_SIZE_MIN + 1);
2760 }
2761 prompt = StaticPrompt(i, title, 0, stdLineHeight + 5, systemFont, 'c');
2762 AlignLabelButtons(prompt, *pup);
2763 return i;
2764 }
2765
OGL_Quality(Nlm_GrouP prnt)2766 Nlm_GrouP LIBCALL OGL_Quality(Nlm_GrouP prnt)
2767 {
2768 Nlm_GrouP g, h, i[8], bg;
2769 Nlm_PrompT bp, p, q;
2770 int n=-1;
2771 char numstr[32];
2772
2773 g = Nlm_HiddenGroup(prnt, -1, 0, NULL);
2774 if (!g)
2775 return NULL;
2776 SetGroupSpacing(g, 3, 9);
2777
2778 h = Nlm_HiddenGroup(g, 1, 6, NULL);
2779 SetGroupSpacing(h, 5, 3);
2780
2781 /* blank space */
2782 bg = Nlm_HiddenGroup(h, 1, 6, NULL);
2783 SetGroupSpacing(bg, 5, 10);
2784 bp = StaticPrompt(bg, "", 0, stdLineHeight + 5, systemFont, 'c');
2785
2786 i[++n] = qualityItem(h, "Helix cylinder sides",
2787 &Cn3D_pupQualBigCylSides, qSet[1][0]);
2788 i[++n] = qualityItem(h, "Bond cylinder sides",
2789 &Cn3D_pupQualBondCylSides, qSet[1][1]);
2790 i[++n] = qualityItem(h, "Sphere slices",
2791 &Cn3D_pupQualSphSlices, qSet[1][2]);
2792 i[++n] = qualityItem(h, "Sphere stacks",
2793 &Cn3D_pupQualSphStacks, qSet[1][3]);
2794 i[++n] = qualityItem(h, "Worm segments",
2795 &Cn3D_pupQualWormSegments, qSet[1][4]);
2796 i[++n] = qualityItem(h, "Worm sides",
2797 &Cn3D_pupQualWormSides, qSet[1][5]);
2798
2799 bg = Nlm_HiddenGroup(h, 1, 6, NULL);
2800 SetGroupSpacing(bg, 5, 10);
2801 bp = StaticPrompt(bg, "", 0, stdLineHeight + 5, systemFont, 'c');
2802
2803 i[++n] = Nlm_HiddenGroup(h, -1, 6, NULL);
2804 SetGroupSpacing(i[n], 5, 10);
2805 p = StaticPrompt(i[n], "Set Overall Quality / Rendering Speed to:",
2806 0, stdLineHeight + 5, systemFont, 'c');
2807
2808 i[++n] = Nlm_HiddenGroup(h, -3, 6, NULL);
2809 SetGroupSpacing(i[n], 5, 10);
2810 Cn3D_bQualOverall[0] = PushButton(i[n], "low/fast", OverallQualityChangeProc);
2811 Cn3D_bQualOverall[1] = PushButton(i[n], "med/med", OverallQualityChangeProc);
2812 Cn3D_bQualOverall[2] = PushButton(i[n], "high/slow", OverallQualityChangeProc);
2813 AlignObjects(ALIGN_CENTER, (HANDLE) i[6], (HANDLE) i[7], (HANDLE) h, NULL);
2814
2815 bg = Nlm_HiddenGroup(h, 1, 6, NULL);
2816 SetGroupSpacing(bg, 5, 10);
2817 bp = StaticPrompt(bg, "", 0, stdLineHeight + 5, systemFont, 'c');
2818
2819 bg = HiddenGroup(h, 2, 1, NULL);
2820 StaticPrompt(bg, "Animation speed (seconds per image):",
2821 0, stdLineHeight + 5, systemFont, 'c');
2822 Cn3D_pTick = PopupList(bg, FALSE, Cn3D_TickPopupProc);
2823 for(n = 0; Cn3D_Tick[n] != 0.0L; n++) {
2824 sprintf(numstr,"%lg", Cn3D_Tick[n]);
2825 PopupItem(Cn3D_pTick, numstr);
2826 }
2827 SetValue(Cn3D_pTick, CN3DTICKDEFAULT);
2828 Cn3D_ColorData.OGL_Data->Tick = Cn3D_Tick[CN3DTICKDEFAULT];
2829
2830 bg = Nlm_HiddenGroup(h, 1, 6, NULL);
2831 SetGroupSpacing(bg, 5, 10);
2832 bp = StaticPrompt(bg, "", 0, stdLineHeight + 5, systemFont, 'c');
2833
2834 Cn3D_QimmediateRedraw =
2835 CheckBox(g, "Immediate Redraw on Every Change", NULL);
2836 Cn3D_bQRedraw = PushButton(g, "Apply!", Cn3D_RedrawProc);
2837 AlignObjects(ALIGN_CENTER, (HANDLE) Cn3D_bQRedraw,
2838 (HANDLE) Cn3D_QimmediateRedraw, (HANDLE) h, NULL);
2839
2840 return g;
2841 }
2842 #endif
2843
fnCn3D_RedrawWrapper(ButtoN b)2844 NLM_EXTERN void fnCn3D_RedrawWrapper(ButtoN b)
2845 {
2846 Cn3D_RedrawProc(b);
2847 Cn3D_SendUpdate();
2848 }
2849
2850 static CharPtr categorynames[] = {
2851 "", "", "Protein Sidechains", "Nucleotide Sidechains", "Heterogen",
2852 "Ions", "Connections", "Solvents", "3D Objects", "Hydrogens"
2853 };
2854
RenderStyle(GrouP h,Int2 i)2855 static PopuP RenderStyle(GrouP h, Int2 i)
2856 {
2857 PopuP p;
2858
2859 if (renderAlist[i] != empty_alist) {
2860 p = PopupList(h, FALSE, PopupOnOffProc);
2861 } else {
2862 p = PopupList(h, FALSE, NULL);
2863 }
2864 InitEnumPopup(p, renderAlist[i], NULL);
2865 return p;
2866 }
2867
ColorStyle(GrouP h,Int2 i)2868 static PopuP ColorStyle(GrouP h, Int2 i)
2869 {
2870 PopuP p;
2871 int j;
2872
2873 if (colorAlist[i] != empty_alist) {
2874 p = PopupList(h, FALSE, PopupOnOffProc);
2875 } else {
2876 p = PopupList(h, FALSE, NULL);
2877 }
2878 for (j=0; colorAlist[i][j].name; j++)
2879 PopupItem(p, Cn3D_ColorFuncName(colorAlist[i][j].value));
2880 return p;
2881 }
2882
RenderControls(Nlm_GrouP prnt)2883 GrouP LIBCALL RenderControls(Nlm_GrouP prnt)
2884 {
2885 GrouP g, h;
2886 Int2 k;
2887 PrompT ppt[10];
2888 PrompT ppt1, ppt2, ppt3, ppt4;
2889 RecT pptPos, btnPos;
2890 Int2 delta;
2891 #ifdef _OPENGL
2892 GrouP bg;
2893 PrompT ppt5;
2894 #endif
2895
2896 g = HiddenGroup(prnt, -1, 0, NULL);
2897 if (!g)
2898 return NULL;
2899 SetGroupSpacing(g, 3, 9);
2900 /*
2901 #ifdef WIN_MOTIF
2902 SetGroupMargins ( g, 4, 1 );
2903 SetGroupSpacing ( g, 2, 1 );
2904 #else
2905 SetGroupMargins ( g, 1, 1 );
2906 SetGroupSpacing ( g, 0, 0 );
2907 #endif
2908 */
2909
2910 h = HiddenGroup(g, 0, -11, NULL);
2911 SetGroupSpacing(h, 5, 3);
2912
2913 Cn3D_lOnOffItem[0] = NULL; /* Cn3D_pupPBB includes off setting */
2914 Cn3D_lOnOffItem[1] = NULL; /* Cn3D_pupNABB includes off setting */
2915
2916 ppt1 =
2917 StaticPrompt(h, "Category", 0, stdLineHeight + 5, systemFont, 'c');
2918 ppt[0] =
2919 StaticPrompt(h, "Protein Backbone", 0, popupMenuHeight,
2920 systemFont, 'l');
2921 ppt[1] =
2922 StaticPrompt(h, "Nucleotide Backbone", 0, popupMenuHeight,
2923 systemFont, 'l');
2924 for (k = 2; k < 10; k++) {
2925 ppt[k] =
2926 StaticPrompt(h, categorynames[k], 0, popupMenuHeight,
2927 systemFont, 'l');
2928 }
2929 AlignObjects(ALIGN_CENTER, (HANDLE) ppt1, (HANDLE) ppt[1], NULL);
2930
2931 ppt2 =
2932 StaticPrompt(h, "On/Off", 0, stdLineHeight + 5, systemFont, 'c');
2933 Cn3D_pupPBB = PopupList(h, FALSE, PopupOnOffProc);
2934 PopupItem(Cn3D_pupPBB, "alpha C trace");
2935 PopupItem(Cn3D_pupPBB, "partial atom");
2936 PopupItem(Cn3D_pupPBB, "all atoms");
2937 PopupItem(Cn3D_pupPBB, "none");
2938 Cn3D_pupNABB = PopupList(h, FALSE, PopupOnOffProc);
2939 PopupItem(Cn3D_pupNABB, "P trace");
2940 PopupItem(Cn3D_pupNABB, "partial atom");
2941 PopupItem(Cn3D_pupNABB, "all atoms");
2942 PopupItem(Cn3D_pupNABB, "none");
2943 for (k = 2; k < 10; k++) {
2944 Cn3D_lOnOffItem[k] = CheckBox(h, "", ButtonOnOffProc);
2945 }
2946 AlignObjects(ALIGN_CENTER, (HANDLE) ppt2, (HANDLE) Cn3D_pupPBB, NULL);
2947
2948 ppt3 =
2949 StaticPrompt(h, "Drawing Style", 0, stdLineHeight + 5, systemFont, 'c');
2950 for (k = 0; k < 10; k++) {
2951 if (k == 9) {
2952 StaticPrompt(h, " ", 0, popupMenuHeight, systemFont, 'l');
2953 Cn3D_pupRenderStyle[k] = NULL;
2954 } else {
2955 Cn3D_pupRenderStyle[k] = RenderStyle(h, k);
2956 }
2957 }
2958 AlignObjects(ALIGN_CENTER, (HANDLE) ppt3,
2959 (HANDLE) Cn3D_pupRenderStyle[0], NULL);
2960
2961 ppt4 = StaticPrompt(h, "Color", 0, stdLineHeight + 5, systemFont, 'c');
2962 for (k = 0; k < 10; k++) {
2963 if (k == 6 || k == 9) {
2964 StaticPrompt(h, " ", 0, popupMenuHeight, systemFont, 'l');
2965 Cn3D_pupColorStyle[k] = NULL;
2966 } else {
2967 Cn3D_pupColorStyle[k] = ColorStyle(h, k);
2968 }
2969 }
2970 AlignObjects(ALIGN_CENTER, (HANDLE) ppt4,
2971 (HANDLE) Cn3D_pupColorStyle[0], NULL);
2972
2973 #ifdef _OPENGL
2974 bg = HiddenGroup(g, 2, 1, NULL);
2975 SetGroupSpacing(bg, 10, 3);
2976 ppt5 = StaticPrompt(bg, "Background Color:", 0, stdLineHeight + 5, systemFont, 'c');
2977 Cn3D_pupBackgroundColor = PopupList(bg, FALSE, PopupOnOffProc);
2978 for (k=0; bgColorAList[k].name; k++)
2979 PopupItem(Cn3D_pupBackgroundColor, bgColorAList[k].name);
2980 SetEnumPopup(Cn3D_pupBackgroundColor, bgColorAList, (UIEnum) 1);
2981 #endif
2982
2983 Cn3D_immediateRedraw =
2984 CheckBox(g, "Immediate Redraw on Every Change", NULL);
2985
2986 Cn3D_bRedraw = PushButton(g, "Apply!", fnCn3D_RedrawWrapper);
2987
2988 for (k = 2; k < 10; k++) {
2989 GetPosition(Cn3D_lOnOffItem[k], &btnPos);
2990 GetPosition(ppt[k], &pptPos);
2991 delta =
2992 (pptPos.bottom + pptPos.top) / 2 - (btnPos.bottom +
2993 btnPos.top) / 2;
2994 if (delta != 0) {
2995 OffsetRect(&btnPos, 0, delta);
2996 SetPosition(Cn3D_lOnOffItem[k], &btnPos);
2997 AdjustPrnt((Nlm_GraphiC) Cn3D_lOnOffItem[k], &btnPos, FALSE);
2998 }
2999 }
3000
3001 AlignObjects(ALIGN_CENTER, (HANDLE) Cn3D_pupPBB, (HANDLE) Cn3D_pupNABB,
3002 (HANDLE) Cn3D_lOnOffItem[2], (HANDLE) Cn3D_lOnOffItem[3],
3003 (HANDLE) Cn3D_lOnOffItem[4], (HANDLE) Cn3D_lOnOffItem[5],
3004 (HANDLE) Cn3D_lOnOffItem[6], (HANDLE) Cn3D_lOnOffItem[7],
3005 (HANDLE) Cn3D_lOnOffItem[8], (HANDLE) Cn3D_lOnOffItem[9],
3006 NULL);
3007
3008 #ifdef _OPENGL
3009 AlignObjects(ALIGN_CENTER, (HANDLE) bg, (HANDLE) g, NULL);
3010 #endif
3011
3012 AlignObjects(ALIGN_CENTER, (HANDLE) Cn3D_bRedraw,
3013 (HANDLE) Cn3D_immediateRedraw, (HANDLE) h, NULL);
3014
3015 ResetRenderCtrls();
3016 return g;
3017 }
3018
3019
3020 /****************************************************************************/
3021
3022
Cn3D_SetRenderKeep(PRK prkThis)3023 static void Cn3D_SetRenderKeep(PRK prkThis)
3024 {
3025 if (prkThis == NULL) return;
3026 prkThis->NodeWhat = (Byte) CONVERT_ALL;
3027 prkThis->NodeType = (Byte) CONVERT_ALL;
3028 prkThis->Bond = (Byte) NO_BOND; /* use define */
3029 prkThis->Atom = (Byte) ATOM_NONE;
3030 prkThis->BondWidth = (float) 0;
3031 prkThis->LJust = 0;
3032 prkThis->LStyle = 0;
3033 prkThis->LScale = 1;
3034 return;
3035 }
3036
3037
NewRenderKeep(void)3038 PRK LIBCALL NewRenderKeep(void)
3039 {
3040 PRK prkThis = NULL;
3041 prkThis = (PRK) MemNew((size_t) (sizeof(RK)));
3042 if (!prkThis)
3043 return NULL;
3044 Cn3D_SetRenderKeep(prkThis);
3045 return prkThis;
3046 }
3047
Cn3D_DupRenderKeep(PRK prkDest,PRK prkSrc)3048 static void Cn3D_DupRenderKeep(PRK prkDest, PRK prkSrc)
3049 {
3050 if (prkDest == NULL || prkSrc == NULL) return;
3051 prkDest->NodeWhat = prkSrc->NodeWhat;
3052 prkDest->NodeType = prkSrc->NodeType;
3053 DDV_CopyColorCell(&(prkDest->Color), &(prkSrc->Color)); /* a fixed color */
3054 prkDest->Bond = prkSrc->Bond; /* use define */
3055 prkDest->Atom = prkSrc->Atom;
3056 prkDest->BondWidth = prkSrc->BondWidth;
3057 prkDest->LJust = prkSrc->LJust;
3058 prkDest->LStyle = prkSrc->LStyle;
3059 prkDest->LScale = prkSrc->LScale;
3060
3061 }
3062
CopyRenderKeep(PRK prkThis)3063 PRK LIBCALL CopyRenderKeep(PRK prkThis)
3064 {
3065 PRK prkNew = NULL;
3066 prkNew = NewRenderKeep();
3067 if (!prkNew) return NULL;
3068 Cn3D_DupRenderKeep(prkNew, prkThis);
3069 return prkNew;
3070 }
3071
FreeRenderKeep(PRK prkThis)3072 void LIBCALL FreeRenderKeep(PRK prkThis)
3073 {
3074 MemFree(prkThis);
3075 }
3076
3077 /*
3078 static void RotTransScale(PMSD pmsdThis, FloatLo fX,
3079 FloatLo fY,
3080 FloatLo fZ,
3081 Int4Ptr piX, Int4Ptr piY, Int4Ptr piZ)
3082 {
3083 FloatHi fXTemp, fYTemp, fZTemp;
3084
3085 if (!pmsdThis)
3086 return;
3087
3088 *piX = 0;
3089 *piY = 0;
3090 *piZ = 0;
3091 if (pmsdThis->pflTranslate)
3092 {
3093 fX = fX - pmsdThis->pflTranslate[0];
3094 fY = fY - pmsdThis->pflTranslate[1];
3095 fZ = fZ - pmsdThis->pflTranslate[2];
3096 }
3097 if (pmsdThis->ppflRotate)
3098 {
3099 fXTemp = (FloatHi) (fX * pmsdThis->ppflRotate[0][0] +
3100 fY * pmsdThis->ppflRotate[1][0] +
3101 fZ * pmsdThis->ppflRotate[2][0]);
3102 fYTemp = (FloatHi) (fX * pmsdThis->ppflRotate[0][1] +
3103 fY * pmsdThis->ppflRotate[1][1] +
3104 fZ * pmsdThis->ppflRotate[2][1]);
3105 fZTemp = (FloatHi) (fX * pmsdThis->ppflRotate[0][2] +
3106 fY * pmsdThis->ppflRotate[1][2] +
3107 fZ * pmsdThis->ppflRotate[2][2]);
3108 fX = (FloatLo) fXTemp;
3109 fY = (FloatLo) fYTemp;
3110 fZ = (FloatLo) fZTemp;
3111 }
3112 *piX = (Int4) (fX * VIEWSCALE);
3113 *piY = (Int4) (fY * VIEWSCALE);
3114 *piZ = (Int4) (fZ * VIEWSCALE);
3115 return;
3116 }
3117 */
3118
3119 /***********************************************************/
3120 /* These are the lowest-level calls to the 3D drawing */
3121 /* at this point all the decisions have been made */
3122
3123
RenderObject(PVNMO pvnmoThis)3124 void LIBCALL RenderObject(PVNMO pvnmoThis)
3125 {
3126 PMOD pmodThis = NULL;
3127 PMSD pmsdThis = NULL;
3128 PMGD pmgdThis = NULL;
3129 PMMD pmmdThis = NULL;
3130 PFB pfbThis = NULL;
3131 PFB pfbParent = NULL;
3132 PARS pars = NULL;
3133 Int4 i = 0;
3134 FloatLo fXFrom, fYFrom, fZFrom;
3135 FloatLo fXTo, fYTo, fZTo;
3136 Int4 iXFrom, iYFrom, iZFrom;
3137 Int4 iXTo, iYTo, iZTo;
3138 Int4 iCylRadius;
3139 #ifndef _OPENGL
3140 Nlm_Prim3D poly;
3141 #endif
3142 DDV_ColorCell iColor;
3143
3144 #ifdef DEBUG_N
3145 printf("RenderObject\n");
3146 #endif
3147 if (!pvnmoThis)
3148 return;
3149 pmodThis = (PMOD) pvnmoThis->data.ptrvalue;
3150 if (!pmodThis)
3151 return;
3152
3153 if (!pmodThis->ppflObject)
3154 return;
3155 if (!pmodThis->bVisible)
3156 return;
3157
3158 pmsdThis = ToMSDParent((PFB) pmodThis);
3159 if (!pmsdThis)
3160 return;
3161
3162 pars = (PARS) pmsdThis->pGlobalPARS;
3163 if (!pars)
3164 return;
3165
3166 if (Cn3d_ColorNow == C_BYCHAIN) {
3167 if (pmodThis->pvnContains == NULL)
3168 DDV_SetColorInCell(&iColor, Cn3d_PaletteRGB[ColorNumKinBB[0]]);
3169 else {
3170 pfbThis = (PFB) pmodThis->pvnContains->data.ptrvalue;
3171 if (!pfbThis)
3172 return;
3173 if (!IsMoleculeNode(pfbThis))
3174 pfbParent = (PFB) GetParentMol(pfbThis);
3175 else
3176 pfbParent = pfbThis;
3177 if (pfbParent) {
3178 pmmdThis = (PMMD) pfbParent;
3179 DDV_SetColorInCell(&iColor,
3180 Cn3d_PaletteRGB[
3181 ColorNumKinBB[(pmmdThis->pdnmmLink->choice % KIN_COLOR_NUM)]]);
3182 } else {
3183 DDV_SetColorInCell(&iColor, Cn3d_PaletteRGB[ColorNumKinBB[0]]);
3184 }
3185 }
3186 }
3187
3188 else if (Cn3d_ColorNow == C_BYOBJECT) {
3189 DDV_SetColorInCell(&iColor,
3190 Cn3d_PaletteRGB[bObjectColors[(Cn3d_lSlaveNum % NUM_SLAVES)]]);
3191 }
3192
3193 else if (Cn3d_ColorNow == C_BYSECSTRUC || Cn3d_ColorNow == C_BYDOMAIN) {
3194 if (pmodThis->pvnContains == NULL) {
3195 DDV_SetColorInCell(&iColor, Cn3d_PaletteRGB[ColorNumKinBB[0]]);
3196 } else {
3197 pfbThis = (PFB) pmodThis->pvnContains->data.ptrvalue;
3198 if (!pfbThis)
3199 return;
3200 if (!IsGraphNode(pfbThis))
3201 pfbParent = (PFB) GetParentGraph(pfbThis);
3202 else
3203 pfbParent = pfbThis;
3204 if (pfbParent && IsGraphAminoAcid(pfbParent)) {
3205 pmgdThis = (PMGD) pfbParent;
3206 if (Cn3d_ColorNow == C_BYSECSTRUC)
3207 DDV_CopyColorCell(&iColor, ColorFromSS(pmgdThis));
3208 if (Cn3d_ColorNow == C_BYDOMAIN)
3209 DDV_SetColorInCell(&iColor,
3210 Cn3d_PaletteRGB[ColorNumKinBB[(pmgdThis->iDomain % KIN_COLOR_NUM)]]);
3211 } else {
3212 DDV_SetColorInCell(&iColor, Cn3d_PaletteRGB[ColorNumKinBB[0]]);
3213 }
3214 }
3215 }
3216
3217 else DDV_SetColorInCell(&iColor, Cn3d_PaletteRGB[ColorNumKinBB[0]]);
3218
3219 if (Cn3d_ColorPass) {
3220 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, &iColor);
3221 return;
3222 }
3223
3224 #ifdef _OPENGL
3225 OGL_LoadName(NULL); /* disable highlighting of objects */
3226 #endif
3227
3228 switch (pmodThis->bWhat) {
3229 case OBJ_CYLINDER:
3230 /* switch to/from order, so that arrow is pointing from N to C */
3231 fXTo = (FloatLo) (pmodThis->ppflObject[0][0]);
3232 fYTo = (FloatLo) (pmodThis->ppflObject[0][1]);
3233 fZTo = (FloatLo) (pmodThis->ppflObject[0][2]);
3234 fXFrom = (FloatLo) (pmodThis->ppflObject[1][0]);
3235 fYFrom = (FloatLo) (pmodThis->ppflObject[1][1]);
3236 fZFrom = (FloatLo) (pmodThis->ppflObject[1][2]);
3237 /*
3238 RotTransScale(pmsdThis, fXFrom, fYFrom, fZFrom, &iXFrom, &iYFrom, &iZFrom);
3239 RotTransScale(pmsdThis, fXTo, fYTo, fZTo, &iXTo, &iYTo, &iZTo);
3240 */
3241
3242 #ifdef _OPENGL
3243 /*
3244 fXTo = iXFrom / VIEWSCALE;
3245 fYTo = iYFrom / VIEWSCALE;
3246 fZTo = iZFrom / VIEWSCALE;
3247 fXFrom = iXTo / VIEWSCALE;
3248 fYFrom = iYTo / VIEWSCALE;
3249 fZFrom = iZTo / VIEWSCALE;
3250 */
3251 OGL_AddCylinder3D(Cn3D_ColorData.OGL_Data, &iColor,
3252 (FloatHi) fXFrom, (FloatHi) fYFrom, (FloatHi) fZFrom, TRUE,
3253 (FloatHi) fXTo, (FloatHi) fYTo, (FloatHi) fZTo, TRUE,
3254 /*(FloatHi) pmodThis->flRadius*/ 1.8,
3255 GetValue(Cn3D_pupQualBigCylSides) + QUAL_SIZE_MIN - 1,
3256 (pars->ObjectArrows & ARROW_CYL));
3257
3258 #else /* _OPENGL */
3259 iCylRadius = (Int4) (pmodThis->flRadius * VIEWSCALE);
3260 AddCylinder3D(pic, NULL, (BigScalar) pmodThis,
3261 Cn3d_LayerNow,
3262 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->
3263 Palette, &iColor), iXFrom, iYFrom,
3264 iZFrom, iXTo, iYTo, iZTo, iCylRadius);
3265 #endif /* else _OPENGL */
3266 return;
3267 case OBJ_BRICK:
3268 #ifdef _OPENGL
3269 {
3270 FloatHi Nterm[3], Cterm[3], norm[3];
3271 /*Int4 xv, yv, zv;*/
3272
3273 /*RotTransScale(pmsdThis,
3274 pmodThis->ppflObject[0][0],
3275 pmodThis->ppflObject[0][1],
3276 pmodThis->ppflObject[0][2], &xv, &yv, &zv);
3277 Nterm[0] = xv; Nterm[1] = yv; Nterm[2] = zv;*/
3278 /*RotTransScale(pmsdThis,
3279 pmodThis->ppflObject[3][0],
3280 pmodThis->ppflObject[3][1],
3281 pmodThis->ppflObject[3][2], &xv, &yv, &zv);
3282 Nterm[0] += xv; Nterm[1] += yv; Nterm[2] += zv;
3283 Nterm[0] /= 2000000.0; Nterm[1] /= 2000000.0; Nterm[2] /= 2000000.0;*/
3284 Nterm[0] = (pmodThis->ppflObject[0][0] + pmodThis->ppflObject[3][0]) / 2;
3285 Nterm[1] = (pmodThis->ppflObject[0][1] + pmodThis->ppflObject[3][1]) / 2;
3286 Nterm[2] = (pmodThis->ppflObject[0][2] + pmodThis->ppflObject[3][2]) / 2;
3287
3288 /*RotTransScale(pmsdThis,
3289 pmodThis->ppflObject[4][0],
3290 pmodThis->ppflObject[4][1],
3291 pmodThis->ppflObject[4][2], &xv, &yv, &zv);
3292 Cterm[0] = xv; Cterm[1] = yv; Cterm[2] = zv;
3293 RotTransScale(pmsdThis,
3294 pmodThis->ppflObject[7][0],
3295 pmodThis->ppflObject[7][1],
3296 pmodThis->ppflObject[7][2], &xv, &yv, &zv);
3297 Cterm[0] += xv; Cterm[1] += yv; Cterm[2] += zv;
3298 Cterm[0] /= 2000000.0; Cterm[1] /= 2000000.0; Cterm[2] /= 2000000.0;*/
3299 Cterm[0] = (pmodThis->ppflObject[4][0] + pmodThis->ppflObject[7][0]) / 2;
3300 Cterm[1] = (pmodThis->ppflObject[4][1] + pmodThis->ppflObject[7][1]) / 2;
3301 Cterm[2] = (pmodThis->ppflObject[4][2] + pmodThis->ppflObject[7][2]) / 2;
3302
3303 /*RotTransScale(pmsdThis,
3304 pmodThis->ppflObject[2][0],
3305 pmodThis->ppflObject[2][1],
3306 pmodThis->ppflObject[2][2], &xv, &yv, &zv);
3307 norm[0] = xv; norm[1] = yv; norm[2] = zv;
3308 RotTransScale(pmsdThis,
3309 pmodThis->ppflObject[0][0],
3310 pmodThis->ppflObject[0][1],
3311 pmodThis->ppflObject[0][2], &xv, &yv, &zv);
3312 norm[0] -= xv; norm[1] -= yv; norm[2] -= zv;*/
3313 norm[0] = pmodThis->ppflObject[2][0] - pmodThis->ppflObject[0][0];
3314 norm[1] = pmodThis->ppflObject[2][1] - pmodThis->ppflObject[0][1];
3315 norm[2] = pmodThis->ppflObject[2][2] - pmodThis->ppflObject[0][2];
3316
3317 OGL_AddBrick3D(Cn3D_ColorData.OGL_Data, &iColor,
3318 Nterm, Cterm, norm, 2.0, 0.5,
3319 (pars->ObjectArrows & ARROW_BRICK));
3320
3321 }
3322 #else /* _OPENGL */
3323 fXFrom = pmodThis->ppflObject[0][0];
3324 fYFrom = pmodThis->ppflObject[0][1];
3325 fZFrom = pmodThis->ppflObject[0][2];
3326 fXTo = pmodThis->ppflObject[1][0];
3327 fYTo = pmodThis->ppflObject[1][1];
3328 fZTo = pmodThis->ppflObject[1][2];
3329 /*
3330 RotTransScale(pmsdThis, fXFrom,
3331 fYFrom, fZFrom, &iXFrom, &iYFrom, &iZFrom);
3332 RotTransScale(pmsdThis, fXTo, fYTo, fZTo, &iXTo, &iYTo, &iZTo);
3333 */
3334 Cn3d_AnyPrim = TRUE;
3335 poly = AddPoly3D(pic, NULL, (BigScalar) pmodThis,
3336 Cn3d_LayerNow,
3337 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->
3338 Palette, &iColor), iXFrom, iYFrom,
3339 iZFrom, iXTo, iYTo, iZTo);
3340 #ifdef DEBUG_N
3341 printf("%ld %ld %ld\n", (long) iXFrom, (long) iYFrom,
3342 (long) iZFrom);
3343 printf("%ld %ld %ld\n", (long) iXTo, (long) iYTo, (long) iZTo);
3344 #endif
3345 for (i = 2; i < 8; i++) {
3346 fXTo = pmodThis->ppflObject[i][0];
3347 fYTo = pmodThis->ppflObject[i][1];
3348 fZTo = pmodThis->ppflObject[i][2];
3349 /*RotTransScale(pmsdThis, fXTo, fYTo, fZTo, &iXTo, &iYTo, &iZTo);*/
3350 Cn3d_AnyPrim = TRUE;
3351 AddVertPoly3D(pic, poly, iXTo, iYTo, iZTo);
3352 #ifdef DEBUG_N
3353 printf("%ld %ld %ld\n", (long) iXTo, (long) iYTo, (long) iZTo);
3354 #endif
3355 }
3356 #endif /* else _OPENGL */
3357
3358 #ifdef DEBUG_N
3359 printf("%ld %ld %ld\n", (long) iXFrom, (long) iYFrom,
3360 (long) iZFrom);
3361 #endif
3362 return;
3363 case OBJ_SPHERE:
3364 case OBJ_CONE:
3365 case OBJ_TMESH:
3366 case OBJ_TRIANGLES:
3367 default:
3368 #ifdef DEBUG_N
3369 printf("Other \n");
3370 #endif
3371 return;
3372 }
3373 }
3374
3375
3376
3377 /* Mode determines how to combine PALD's */
3378 #define RL_CENTER 1 /* put at paldCenter */
3379 #define RL_CENTERPLUSY 2 /* put at paldCenter plus 1x Scale in y direction */
3380 #define RL_EXTRAPOL 3 /* paldTo + (paldTo - paldFrom)/2 */
3381 #define RL_BETACARB 4 /* approximates direction of H-alphs */
3382
RenderLabel(PDNMS pdnmsThis,CharPtr pclabel,PALD paldCenter,PALD paldFrom,PALD paldTo,DDV_ColorCell * iColor,Uint1 Just,Int2 Scale,Int2 Mode)3383 static void RenderLabel(PDNMS pdnmsThis, CharPtr pclabel,
3384 PALD paldCenter, PALD paldFrom, PALD paldTo,
3385 DDV_ColorCell * iColor, Uint1 Just, Int2 Scale,
3386 Int2 Mode)
3387 {
3388 FloatLo fXFrom, fYFrom, fZFrom;
3389 Int4 iX, iY, iZ;
3390 FloatLo fXTo, fYTo, fZTo;
3391 FloatLo fXCen, fYCen, fZCen;
3392 FloatLo fXt, fYt, fZt, l;
3393 PMSD pmsdThis = NULL;
3394 PALD paldPrim = NULL;
3395 Int2 flags;
3396
3397 if (!pdnmsThis)
3398 return;
3399 if (!pclabel)
3400 return;
3401 if (((Mode == RL_CENTER) || (Mode == RL_BETACARB))
3402 && (paldCenter == NULL)) return;
3403 if ((Mode == RL_CENTERPLUSY) && (paldCenter == NULL))
3404 return;
3405 if (((Mode == RL_EXTRAPOL) || (Mode == RL_BETACARB))
3406 && ((paldFrom == NULL) || (paldTo == NULL)))
3407 return;
3408
3409 pmsdThis = (PMSD) pdnmsThis->data.ptrvalue;
3410
3411 if (paldFrom) {
3412 fXFrom = (FloatLo) (paldFrom->pflvData[0]);
3413 fYFrom = (FloatLo) (paldFrom->pflvData[1]);
3414 fZFrom = (FloatLo) (paldFrom->pflvData[2]);
3415 }
3416 if (paldTo) {
3417 fXTo = (FloatLo) (paldTo->pflvData[0]);
3418 fYTo = (FloatLo) (paldTo->pflvData[1]);
3419 fZTo = (FloatLo) (paldTo->pflvData[2]);
3420 paldPrim = paldTo;
3421 }
3422 if (paldCenter) {
3423 fXCen = (FloatLo) (paldCenter->pflvData[0]);
3424 fYCen = (FloatLo) (paldCenter->pflvData[1]);
3425 fZCen = (FloatLo) (paldCenter->pflvData[2]);
3426 paldPrim = paldCenter;
3427 }
3428
3429
3430 switch (Mode) {
3431 case RL_CENTER:
3432 break;
3433 case RL_CENTERPLUSY:
3434 fYCen = fYCen + Scale;
3435 break;
3436 case RL_EXTRAPOL:
3437 fXCen = fXTo + (fXTo - fXFrom) / 2.0;
3438 fYCen = fYTo + (fYTo - fYFrom) / 2.0;
3439 fZCen = fZTo + (fZTo - fZFrom) / 2.0;
3440 break;
3441 case RL_BETACARB:
3442 fXt = (fXCen - fXFrom) + (fXCen - fXTo);
3443 fYt = (fYCen - fYFrom) + (fYCen - fYTo);
3444 fZt = (fZCen - fZFrom) + (fZCen - fZTo);
3445 l = sqrt(fXt*fXt + fYt*fYt + fZt*fZt) / 1.5;
3446 fXCen += fXt / l;
3447 fYCen += fYt / l;
3448 fZCen += fZt / l;
3449 fXt = (fYCen - fYFrom) * (fZCen - fZTo) - (fZCen - fZFrom) * (fYCen - fYTo);
3450 fYt = (fZCen - fZFrom) * (fXCen - fXTo) - (fXCen - fXFrom) * (fZCen - fZTo);
3451 fZt = (fXCen - fXFrom) * (fYCen - fYTo) - (fYCen - fYFrom) * (fXCen - fXTo);
3452 l = sqrt(fXt*fXt + fYt*fYt + fZt*fZt) / 1.1;
3453 fXCen += fXt / l;
3454 fYCen += fYt / l;
3455 fZCen += fZt / l;
3456 break;
3457 }
3458
3459 /*RotTransScale(pmsdThis, fXCen, fYCen, fZCen, &iX, &iY, &iZ);*/
3460
3461 #ifdef _OPENGL
3462 flags = 0;
3463 if (Just & LA_CENTER)
3464 flags = OGLTEXT3D_MIDDLE | OGLTEXT3D_CENTER;
3465 /* if (Just & LA_FRONT) flags = flags | OGLTEXT3D_FRONT; hard to do in OpenGL
3466 todo: get rid of the ui for this
3467 */
3468
3469 OGL_AddText3D(Cn3D_ColorData.OGL_Data, iColor, pclabel,
3470 (FloatHi) fXCen, (FloatHi) fYCen, (FloatHi) fZCen,
3471 flags);
3472 #else /* _OPENGL */
3473 flags = 0;
3474 if (Just & LA_LEFT)
3475 flags = flags | TEXT3D_LEFT;
3476 if (Just & LA_RIGHT)
3477 flags = flags | TEXT3D_RIGTH;
3478 if (Just & LA_UPPER)
3479 flags = flags | TEXT3D_UPPER;
3480 if (Just & LA_LOWER)
3481 flags = flags | TEXT3D_LOWER;
3482 /* only LA_CENTER and LA_FRONT are used */
3483 if (Just & LA_CENTER)
3484 flags = TEXT3D_MIDDLE | TEXT3D_CENTER;
3485 if (Just & LA_FRONT)
3486 flags = flags | TEXT3D_FRONT;
3487 Cn3d_AnyPrim = TRUE;
3488 if (paldPrim->pGraphic == NULL)
3489 paldPrim->pGraphic =
3490 (Pointer) AddSegment3D(pic, NULL, (BigScalar) paldPrim,
3491 Cn3d_LayerNow);
3492
3493 AddText3D(pic, (Segment3D) paldPrim->pGraphic, (BigScalar) 0,
3494 Cn3d_LayerNow,
3495 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->Palette,
3496 iColor), pclabel, iX, iY, iZ,
3497 (Uint4) (Scale * VIEWSCALE / 2), 0, flags);
3498 #endif /* else _OPENGL */
3499 return;
3500
3501 }
3502
3503 /*
3504 void ApplyTranslationRotationF(FloatLo * x, FloatLo * y, FloatLo * z,
3505 PMSD pmsdParent)
3506 {
3507 if (pmsdParent->pflTranslate) {
3508 Message(MSG_POST, "non-NULL pmsdParent->pflTranslate");
3509 *x = (*x) - pmsdParent->pflTranslate[0];
3510 *y = (*y) - pmsdParent->pflTranslate[1];
3511 *z = (*z) - pmsdParent->pflTranslate[2];
3512 }
3513 if (pmsdParent->ppflRotate) {
3514 FloatLo tx, ty, tz;
3515 Message(MSG_POST, "non-NULL pmsdParent->ppflRotate");
3516 tx = (FloatLo) (*x * pmsdParent->ppflRotate[0][0] +
3517 *y * pmsdParent->ppflRotate[1][0] +
3518 *z * pmsdParent->ppflRotate[2][0]);
3519 ty = (FloatLo) (*x * pmsdParent->ppflRotate[0][1] +
3520 *y * pmsdParent->ppflRotate[1][1] +
3521 *z * pmsdParent->ppflRotate[2][1]);
3522 tz = (FloatLo) (*x * pmsdParent->ppflRotate[0][2] +
3523 *y * pmsdParent->ppflRotate[1][2] +
3524 *z * pmsdParent->ppflRotate[2][2]);
3525 *x = tx;
3526 *y = ty;
3527 *z = tz;
3528 }
3529 }
3530 */
3531
3532 #ifdef _OPENGL
RenderBond(PALD paldFrom,Boolean bCapFrom,PALD paldTo,Boolean bCapTo,DDV_ColorCell * iColor,FloatLo fCylRadius)3533 static void RenderBond(PALD paldFrom, Boolean bCapFrom, PALD paldTo, Boolean bCapTo,
3534 DDV_ColorCell * iColor, FloatLo fCylRadius)
3535 #else
3536 static void RenderBond(PALD paldFrom, PALD paldTo, DDV_ColorCell * iColor,
3537 FloatLo fCylRadius)
3538 #endif
3539 {
3540
3541 /* paldFrom owns the bond */
3542
3543 FloatLo fXFrom, fYFrom, fZFrom;
3544 /*
3545 FloatLo fXTempF, fYTempF, fZTempF;
3546 FloatLo fXTempT, fYTempT, fZTempT;
3547 */
3548 FloatLo fXTo, fYTo, fZTo;
3549 #ifndef _OPENGL
3550 Int4 iXTo, iYTo, iZTo;
3551 Int4 iXFrom, iYFrom, iZFrom;
3552 Int4 iCylRadius;
3553 #endif
3554 PMSD pmsdParent = NULL;
3555 PMAD pmadFrom = NULL;
3556 PMAD pmadTo = NULL;
3557
3558 #ifdef DEBUG_N
3559 /*printf("%f\n", (float) fCylRadius);*/
3560 #endif
3561
3562 pmadFrom = (PMAD) paldFrom->pfbParent;
3563 pmadTo = (PMAD) paldTo->pfbParent;
3564 if ((!pmadFrom) || (!pmadTo))
3565 return;
3566 if ((AtomicNumber(pmadFrom) == Atom_element_h) &&
3567 (Cn3d_DoHydrogens == FALSE)) return;
3568 if ((AtomicNumber(pmadTo) == Atom_element_h) &&
3569 (Cn3d_DoHydrogens == FALSE)) return;
3570 pmsdParent = ToMSDParent((PFB) pmadFrom);
3571 fXFrom = (FloatLo) (paldFrom->pflvData[0]);
3572 fYFrom = (FloatLo) (paldFrom->pflvData[1]);
3573 fZFrom = (FloatLo) (paldFrom->pflvData[2]);
3574 fXTo = (FloatLo) (paldTo->pflvData[0]);
3575 fYTo = (FloatLo) (paldTo->pflvData[1]);
3576 fZTo = (FloatLo) (paldTo->pflvData[2]);
3577
3578 /*
3579 ApplyTranslationRotationF(&fXFrom, &fYFrom, &fZFrom, pmsdParent);
3580 ApplyTranslationRotationF(&fXTo, &fYTo, &fZTo, pmsdParent);
3581 */
3582
3583 Cn3d_AnyPrim = TRUE;
3584 /* scale */
3585 #ifndef _OPENGL
3586 iXFrom = (Int4) (fXFrom * VIEWSCALE);
3587 iYFrom = (Int4) (fYFrom * VIEWSCALE);
3588 iZFrom = (Int4) (fZFrom * VIEWSCALE);
3589 iXTo = (Int4) (fXTo * VIEWSCALE);
3590 iYTo = (Int4) (fYTo * VIEWSCALE);
3591 iZTo = (Int4) (fZTo * VIEWSCALE);
3592 iCylRadius = (Int4) (fCylRadius * VIEWSCALE);
3593 if (paldFrom->pGraphic == NULL)
3594 paldFrom->pGraphic = (Pointer) AddSegment3D(pic, NULL,
3595 (BigScalar) paldFrom,
3596 Cn3d_LayerNow);
3597 #endif /* ndef _OPENGL */
3598
3599 if (fCylRadius < CYL_THRESHOLD) {
3600 #ifdef _OPENGL
3601 OGL_AddLine3D(Cn3D_ColorData.OGL_Data, iColor, (FloatHi) fXFrom,
3602 (FloatHi) fYFrom, (FloatHi) fZFrom, (FloatHi) fXTo,
3603 (FloatHi) fYTo, (FloatHi) fZTo);
3604
3605 #else /* _OPENGL */
3606 AddLine3D(pic, (Segment3D) paldFrom->pGraphic,
3607 (BigScalar) paldFrom, Cn3d_LayerNow,
3608 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->Palette, iColor),
3609 iXFrom, iYFrom, iZFrom, iXTo, iYTo, iZTo);
3610 #endif /* else _OPENGL */
3611 } else {
3612 #ifdef _OPENGL
3613 OGL_AddCylinder3D(Cn3D_ColorData.OGL_Data, iColor,
3614 (FloatHi) fXFrom, (FloatHi) fYFrom, (FloatHi) fZFrom, bCapFrom,
3615 (FloatHi) fXTo, (FloatHi) fYTo, (FloatHi) fZTo, bCapTo,
3616 (FloatHi) fCylRadius,
3617 GetValue(Cn3D_pupQualBondCylSides) + QUAL_SIZE_MIN - 1, FALSE);
3618
3619 #else /* _OPENGL */
3620 AddCylinder3D(pic, (Segment3D) paldFrom->pGraphic,
3621 (BigScalar) paldFrom, Cn3d_LayerNow,
3622 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->
3623 Palette, iColor), iXFrom, iYFrom,
3624 iZFrom, iXTo, iYTo, iZTo, iCylRadius);
3625 #endif
3626 } /* else _OPENGL */
3627 return;
3628 }
3629
3630
3631 /* returns a pointer to the next atom down a linear chain of
3632 virual bonds 1-2-3; used when bonds describe a virtualBB (thiessen) */
GetAtomAfter(PALD pald1,PALD pald2)3633 static PMAD GetAtomAfter(PALD pald1, PALD pald2)
3634 {
3635 ValNodePtr pvnB2;
3636 PMAD pmad1, pmad2, pmad3 = NULL;
3637 PMBD pmbd;
3638
3639 pmad1 = (PMAD) pald1->pfbParent;
3640 pmad2 = (PMAD) pald2->pfbParent;
3641 pvnB2 = pmad2->pvnBonds;
3642
3643 /* find virtual bond from 2 to an atom other than 1 */
3644 while (pvnB2) {
3645 pmbd = (PMBD) pvnB2->data.ptrvalue;
3646 if (IsBondVirtual(pmbd)) {
3647 if (pmbd->pmadTo == pmad2)
3648 pmad3 = pmbd->pmadFrom;
3649 else
3650 pmad3 = pmbd->pmadTo;
3651 if (pmad3 && pmad3 != pmad1)
3652 break;
3653 pmad3 = NULL;
3654 }
3655 pvnB2 = pvnB2->next;
3656 }
3657 return pmad3;
3658 }
3659
3660 #ifdef _OPENGL
RenderHalfWormBond(PALD pald1,Boolean bCap1,PALD pald2,Boolean bCap2,DDV_ColorCell * iColor,FloatLo fCylRadius,Int4 iModel)3661 static void RenderHalfWormBond(PALD pald1, Boolean bCap1, PALD pald2, Boolean bCap2,
3662 DDV_ColorCell * iColor, FloatLo fCylRadius,
3663 Int4 iModel)
3664 #else
3665 static void RenderHalfWormBond(PALD pald1, PALD pald2,
3666 DDV_ColorCell * iColor, FloatLo fCylRadius,
3667 Int4 iModel)
3668 #endif
3669 {
3670 FloatLo fX1, fY1, fZ1, fX2, fY2, fZ2, fX3, fY3, fZ3, fX0, fY0, fZ0;
3671 PMAD pmad0, pmad1, pmad2, pmad3;
3672 PALD pald0, pald3;
3673 PMSD pmsdParent;
3674
3675 pmad1 = (PMAD) pald1->pfbParent;
3676 pmad2 = (PMAD) pald2->pfbParent;
3677 pmsdParent = ToMSDParent((PFB) pmad1);
3678
3679 fX1 = (FloatLo) (pald1->pflvData[0]);
3680 fY1 = (FloatLo) (pald1->pflvData[1]);
3681 fZ1 = (FloatLo) (pald1->pflvData[2]);
3682 fX2 = (FloatLo) (pald2->pflvData[0]);
3683 fY2 = (FloatLo) (pald2->pflvData[1]);
3684 fZ2 = (FloatLo) (pald2->pflvData[2]);
3685 /*
3686 ApplyTranslationRotationF(&fX1, &fY1, &fZ1, pmsdParent);
3687 ApplyTranslationRotationF(&fX2, &fY2, &fZ2, pmsdParent);
3688 */
3689
3690 pmad0 = GetAtomAfter(pald2, pald1);
3691 if (pmad0) {
3692 pald0 = GetAtomAltLocs(pmad0, iModel);
3693 if (!pald0) pald0 = pald1;
3694 fX0 = (FloatLo) (pald0->pflvData[0]);
3695 fY0 = (FloatLo) (pald0->pflvData[1]);
3696 fZ0 = (FloatLo) (pald0->pflvData[2]);
3697 /*ApplyTranslationRotationF(&fX0, &fY0, &fZ0, pmsdParent);*/
3698 } else {
3699 fX0 = fX1;
3700 fY0 = fY1;
3701 fZ0 = fZ1;
3702 }
3703 pmad3 = GetAtomAfter(pald1, pald2);
3704 if (pmad3) {
3705 pald3 = GetAtomAltLocs(pmad3, iModel);
3706 if (!pald3) pald3 = pald2;
3707 fX3 = (FloatLo) (pald3->pflvData[0]);
3708 fY3 = (FloatLo) (pald3->pflvData[1]);
3709 fZ3 = (FloatLo) (pald3->pflvData[2]);
3710 /*ApplyTranslationRotationF(&fX3, &fY3, &fZ3, pmsdParent);*/
3711 } else {
3712 fX3 = fX2;
3713 fY3 = fY2;
3714 fZ3 = fZ2;
3715 }
3716
3717 if (fCylRadius < CYL_THRESHOLD)
3718 fCylRadius = 0.0;
3719 Cn3d_AnyPrim = TRUE;
3720
3721 #ifdef _OPENGL
3722 Nlm_AddHalfWorm3D(Cn3D_ColorData.OGL_Data, iColor,
3723 (FloatHi) fX0, (FloatHi) fY0, (FloatHi) fZ0,
3724 (FloatHi) fX1, (FloatHi) fY1, (FloatHi) fZ1,
3725 (FloatHi) fX2, (FloatHi) fY2, (FloatHi) fZ2,
3726 (FloatHi) fX3, (FloatHi) fY3, (FloatHi) fZ3,
3727 bCap1, bCap2, (FloatHi) fCylRadius,
3728 GetValue(Cn3D_pupQualWormSegments) - 1 + QUAL_SIZE_MIN/2,
3729 2 * (GetValue(Cn3D_pupQualWormSides) - 1) + QUAL_SIZE_MIN);
3730 #else
3731 if (pald1->pGraphic == NULL)
3732 pald1->pGraphic = (Pointer) AddSegment3D(pic, NULL,
3733 (BigScalar) pald1,
3734 Cn3d_LayerNow);
3735 Nlm_AddHalfWorm3D(pic, (Segment3D) pald1->pGraphic,
3736 (BigScalar) pald1, Cn3d_LayerNow,
3737 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->Palette, iColor),
3738 (FloatHi) fX0, (FloatHi) fY0, (FloatHi) fZ0,
3739 (FloatHi) fX1, (FloatHi) fY1, (FloatHi) fZ1,
3740 (FloatHi) fX2, (FloatHi) fY2, (FloatHi) fZ2,
3741 (FloatHi) fX3, (FloatHi) fY3, (FloatHi) fZ3,
3742 (FloatHi) fCylRadius, 3);
3743 #endif /* _OPENGL */
3744
3745 return;
3746 }
3747
3748
RenderAnAtom(PALD paldAtom,DDV_ColorCell * iColor,FloatLo fRadius,FloatHi lfAlpha)3749 void LIBCALL RenderAnAtom(PALD paldAtom, DDV_ColorCell * iColor,
3750 FloatLo fRadius, FloatHi lfAlpha)
3751 {
3752 #ifndef _OPENGL
3753 Int4 iXAtom, iYAtom, iZAtom;
3754 Int4 iRadius;
3755 #endif
3756 FloatLo fXAtom, fYAtom, fZAtom;
3757 PMSD pmsdParent = NULL;
3758 PMAD pmadFrom = NULL;
3759 PMAD pmadAtom = NULL;
3760 if (!paldAtom)
3761 return;
3762 pmadAtom = (PMAD) paldAtom->pfbParent;
3763 if (!pmadAtom)
3764 return;
3765 if ((AtomicNumber(pmadAtom) == Atom_element_h) &&
3766 (Cn3d_DoHydrogens == FALSE)) return;
3767 pmsdParent = ToMSDParent((PFB) pmadAtom);
3768 fXAtom = (FloatLo) (paldAtom->pflvData[0]);
3769 fYAtom = (FloatLo) (paldAtom->pflvData[1]);
3770 fZAtom = (FloatLo) (paldAtom->pflvData[2]);
3771
3772 /*ApplyTranslationRotationF(&fXAtom, &fYAtom, &fZAtom, pmsdParent);*/
3773
3774 #ifdef _OPENGL
3775 OGL_AddSphere3D(Cn3D_ColorData.OGL_Data, (DDV_ColorCell *) iColor,
3776 (FloatHi) fXAtom, (FloatHi) fYAtom, (FloatHi) fZAtom,
3777 (FloatHi) fRadius,
3778 GetValue(Cn3D_pupQualSphSlices) + QUAL_SIZE_MIN - 1,
3779 GetValue(Cn3D_pupQualSphStacks) + QUAL_SIZE_MIN - 1,
3780 lfAlpha, pmsdParent->pdnSlaveToMasterTransforms);
3781
3782 #else /* _OPENGL */
3783 Cn3d_AnyPrim = TRUE; /* this probably can be deleted */
3784 /* yanli moved it out of OpenGL ifdef block */
3785 /* scale */
3786 iXAtom = (Int4) (fXAtom * VIEWSCALE);
3787 iYAtom = (Int4) (fYAtom * VIEWSCALE);
3788 iZAtom = (Int4) (fZAtom * VIEWSCALE);
3789 iRadius = (Int4) (fRadius * VIEWSCALE);
3790 if (paldAtom->pGraphic == NULL)
3791 paldAtom->pGraphic =
3792 (Pointer) AddSegment3D(pic, NULL, (BigScalar) paldAtom,
3793 Cn3d_LayerNow);
3794 AddSphere3D(pic, (Segment3D) paldAtom->pGraphic, (BigScalar) paldAtom,
3795 Cn3d_LayerNow,
3796 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->Palette,
3797 iColor), iXAtom, iYAtom, iZAtom, iRadius);
3798 #endif /* else _OPENGL */
3799
3800 return;
3801 }
3802
3803
3804
3805 /*******************************************************/
3806
RenderAllAtom(PFB pfbThis,Int4 iModel,Int4 iRenderWhat,Pointer ptr)3807 static void RenderAllAtom(PFB pfbThis, Int4 iModel, Int4 iRenderWhat,
3808 Pointer ptr)
3809 {
3810 PRK prKeep;
3811 PVNMA pvnmaThis = NULL;
3812 PMGD pmgdThis = NULL;
3813 PMAD pmadThis = NULL;
3814 PALD paldThis = NULL;
3815 PVNMB pvnmbThis = NULL;
3816 PMBD pmbdThis = NULL;
3817 PMMD pmmdTo = NULL;
3818 PMMD pmmdThis;
3819 FloatLo flAtemp = (FloatLo) 0;
3820 Int4 iTemp = 0;
3821 Int2 iBin = 0;
3822 FloatLo fRadius = (FloatLo) 0;
3823 Boolean bDraw = TRUE;
3824 ValNodePtr pvnB;
3825 PALD paldMid = NULL;
3826 PALD paldDrawTo = NULL;
3827 PMAD pmadDrawTo = NULL;
3828 DDV_ColorCell iColor;
3829 int iMenu;
3830 FloatHi lfAlpha;
3831
3832 prKeep = (PRK) ptr;
3833 if (!prKeep)
3834 return;
3835 if (!IsAtomNode(pfbThis))
3836 return;
3837 if (!(pfbThis->bMe & prKeep->NodeType))
3838 return;
3839 if (prKeep->NodeWhat != CONVERT_ALL && !(pfbThis->bWhat & prKeep->NodeWhat))
3840 return;
3841 pmadThis = (PMAD) pfbThis;
3842
3843 /* render only appropriate parts of backbones */
3844 if (iRenderWhat == RESIDUES && IsAtomBackBone(pfbThis))
3845 return;
3846 if (iRenderWhat == PARTIALBB && !IsAtomPartialBackBone(pfbThis))
3847 return;
3848 if (iRenderWhat == COMPLETEBB && !IsAtomBackBone(pfbThis))
3849 return;
3850 if (iRenderWhat == VIRTUALBB && !(IsAtomCAlpha(pfbThis) || IsAtomPAlpha(pfbThis)))
3851 return;
3852
3853 if (iRenderWhat == IONSON && !(pmadThis->bUpdate & AM_ION))
3854 return;
3855 if (iRenderWhat == HETSON && (pmadThis->bUpdate & AM_ION))
3856 return;
3857
3858 paldThis = GetAtomAltLocs(pmadThis, iModel);
3859 if (!paldThis)
3860 return; /* no location corresponding to this model */
3861
3862
3863 /* make the atomic-level color decisions here */
3864 DDV_CopyColorCell(&iColor, &(prKeep->Color));
3865 pmgdThis = GetParentGraph(pfbThis);
3866 if(!pmgdThis->bHighlighted) {
3867
3868 if (Cn3d_ColorNow == C_CPK) {
3869 DDV_SetColorInCell(&iColor,
3870 Cn3d_PaletteRGB[ElementKinColors[(Int1) pmadThis->pvnmaLink->choice]]);
3871 if (Cn3d_ColorPass) {
3872 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, &iColor);
3873 return;
3874 }
3875 }
3876
3877 else if (Cn3d_ColorNow == C_BYTEMP) {
3878 /* calculate temp factor */
3879 if (paldThis->iFloatNo == 4) { /* istotropic */
3880 iTemp = (Int4) paldThis->pflvData[4] * 100;
3881 }
3882 if (paldThis->iFloatNo == 9) { /* anisotropic *//* calculate the isotropic temp factor */
3883 flAtemp = (FloatLo) (((paldThis->pflvData[4] +
3884 paldThis->pflvData[5] +
3885 paldThis->pflvData[6]) / 3));
3886 iTemp = (Int4) flAtemp *100;
3887 }
3888 #ifdef DEBUG_Q
3889 printf("temp=%d\n", (int) iTemp);
3890 #endif
3891 if (iTemp < TempsKine[0])
3892 return; /* too low */
3893 if (iTemp > TempsKine[15])
3894 return; /* too high */
3895 /* find the bin */
3896 for (iBin = 1; iBin < KIN_COLOR_THERM; iBin++) {
3897 if ((iTemp < TempsKine[iBin + 1])
3898 && (iTemp >= TempsKine[iBin])) break;
3899 }
3900 DDV_SetColorInCell(&iColor, Cn3d_PaletteRGB[ThermKine[iBin]]);
3901 if (Cn3d_ColorPass) {
3902 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, &iColor);
3903 return;
3904 }
3905 }
3906 }
3907 /* otherwise the color should have been set by the calling routine */
3908
3909 bDraw = TRUE;
3910 /* set up the atom drawing size */
3911 switch (prKeep->Atom) {
3912 case ATOM_SPACE:
3913 fRadius =
3914 (FloatLo) ((ElementSize((Int1) pmadThis->pvnmaLink->choice)));
3915 break;
3916 case ATOM_2XBOND:
3917 fRadius = prKeep->BondWidth * 2;
3918 break;
3919 case ATOM_ISBOND:
3920 #ifdef _OPENGL
3921 fRadius = prKeep->BondWidth;
3922 #else
3923 fRadius = prKeep->BondWidth * (float) 0.9;
3924 #endif
3925 break;
3926 case ATOM_NONE:
3927 default:
3928 bDraw = FALSE;
3929 }
3930 #ifdef DEBUG_N
3931 /*printf("atom radius %f ", (float) fRadius);*/
3932 #endif
3933 if ((Cn3d_DoHydrogens == FALSE) && (pmadThis->pvnmaLink->choice == 1))
3934 bDraw = FALSE;
3935 if (Cn3d_ColorPass) {
3936 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, &iColor);
3937 return;
3938 }
3939
3940 if (IsProtein(pfbThis))
3941 iMenu = 0;
3942 else if (IsNA(pfbThis))
3943 iMenu = 1;
3944 else
3945 iMenu = -1;
3946
3947 pmmdThis = GetParentMol((PFB) paldThis);
3948 if (bDraw) {
3949 lfAlpha = 1.0;
3950 #ifdef _OPENGL
3951 if (pmadThis->bUpdate & AM_ION) {
3952 PMSD pmsdThis = ToMSDParent(pfbThis);
3953 if(GetStatus(Cn3D_bIonLabel))
3954 RenderLabel(pmsdThis->pdnmsLink,
3955 ElementName(AtomicNumber(pmadThis)), paldThis, NULL, NULL,
3956 &iColor, LA_CENTER, prKeep->LScale, RL_CENTER);
3957 lfAlpha = 0.55;
3958 }
3959 else if (pmmdThis && ((pmmdThis->bWhat & AM_SOL) || (pmmdThis->bWhat & AM_WAT))) {
3960 /* use alpha proportional to occupancy (if present, clamped to 1.0) */
3961 if (paldThis->iFloatNo >= 3 && paldThis->pflvData[3] < 1.0)
3962 lfAlpha = paldThis->pflvData[3] * 0.6;
3963 else
3964 lfAlpha = 0.6;
3965 }
3966 #endif
3967 RenderAnAtom(paldThis, &iColor, fRadius, lfAlpha);
3968 }
3969
3970 /* the rest of this routine handles half-bond drawing where the bonds */
3971 /* are owned by the parent atom */
3972 bDraw = TRUE;
3973 if (prKeep->Bond) {
3974 pvnB = pmadThis->pvnBonds; /* local bond list */
3975 while (pvnB) {
3976 pmbdThis = (PMBD) pvnB->data.ptrvalue;
3977 if (pmbdThis->pmadTo == pmadThis)
3978 pmadDrawTo = pmbdThis->pmadFrom;
3979 else
3980 pmadDrawTo = pmbdThis->pmadTo;
3981 if (!pmadDrawTo)
3982 goto nextbond;
3983 /* bond handler */
3984 bDraw = TRUE;
3985
3986 /* don't draw non-virtual bonds */
3987 if ((int) iRenderWhat == RESIDUES && IsBondVirtual(pmbdThis))
3988 bDraw = FALSE;
3989 if ((int) iRenderWhat == VIRTUALBB && !IsBondVirtual(pmbdThis))
3990 bDraw = FALSE;
3991 /* don't draw to other non backbone atoms */
3992 if ((int) iRenderWhat == COMPLETEBB &&
3993 (!IsAtomBackBone(pmadDrawTo) || IsBondVirtual(pmbdThis)))
3994 bDraw = FALSE;
3995 /* don't draw to non-backbone or carbonyls */
3996 if ((int) iRenderWhat == PARTIALBB &&
3997 (!IsAtomPartialBackBone(pmadDrawTo) || IsBondVirtual(pmbdThis)))
3998 bDraw = FALSE;
3999 /* no bonds to "ions" */
4000 /*if ((int) iRenderWhat == CONNECTON) {
4001 if (pmadThis->bUpdate & AM_ION) bDraw = FALSE;
4002 if (pmadDrawTo->bUpdate & AM_ION) bDraw = FALSE;
4003 }*/
4004 if ((Cn3d_DoHydrogens == FALSE) && (pmadDrawTo->pvnmaLink->choice == 1))
4005 bDraw = FALSE;
4006
4007 if (bDraw) {
4008 #ifdef _OPENGL
4009 Boolean bCapTo;
4010 PMGD pmgdTo;
4011 #endif
4012 paldDrawTo = GetAtomAltLocs(pmadDrawTo, iModel);
4013 if (!paldDrawTo)
4014 goto nextbond;
4015 if (!paldDrawTo->pflvData)
4016 goto nextbond;
4017 pmmdTo = GetParentMol((PFB) paldDrawTo);
4018 if ((pmmdTo != pmmdThis) && ((int) iRenderWhat != CONNECTON)) {
4019 goto nextbond; /* don't connect inter-mol bonds */
4020 }
4021 #ifdef _OPENGL
4022 /* try to avoid visibly open-ended cylinders/worms */
4023 bCapTo = FALSE;
4024 pmgdTo = GetParentGraph((PFB) pmadDrawTo);
4025 if (pmgdTo && !pmgdTo->bVisible)
4026 bCapTo = TRUE;
4027 #endif
4028 if (((int) iRenderWhat == RESIDUES) && (IsAtomBackBone(pmadDrawTo))) {
4029 /* draw a whole bond to bridge */
4030 #ifdef _OPENGL
4031 if (!bCapTo && pmgdTo &&
4032 ((IsGraphAminoAcid(pmgdTo) && GetStatus(Cn3D_pupPBB) != 3) ||
4033 (IsGraphNABase(pmgdTo) && GetStatus(Cn3D_pupNABB) != 3)))
4034 bCapTo = TRUE; /* cap if bond to undrawn backbone atoms */
4035 RenderBond(paldThis, FALSE, paldDrawTo, bCapTo,
4036 &iColor, prKeep->BondWidth);
4037 #else
4038 RenderBond(paldThis, paldDrawTo, &iColor, prKeep->BondWidth);
4039 #endif
4040
4041 } else {
4042 if (prKeep->Bond == HALF_WORM_BOND) {
4043 #ifdef _OPENGL
4044 /* need cap at atom location if there exists only one
4045 virtual bond from this atom (to another defined atom) */
4046 Boolean bCapFrom = FALSE;
4047 ValNodePtr pvnTmp;
4048 PMBD pmbdTmp;
4049 for (pvnTmp = pmadThis->pvnBonds; pvnTmp; pvnTmp = pvnTmp->next) {
4050 pmbdTmp = (PMBD) pvnTmp->data.ptrvalue;
4051 if (IsBondVirtual(pmbdTmp) &&
4052 pmbdTmp->pmadFrom && pmbdTmp->pmadFrom->pvnalLocate &&
4053 pmbdTmp->pmadTo && pmbdTmp->pmadTo->pvnalLocate) {
4054 if (!bCapFrom) {
4055 bCapFrom = TRUE;
4056 } else {
4057 bCapFrom = FALSE;
4058 break;
4059 }
4060 }
4061 }
4062
4063 RenderHalfWormBond(paldThis, bCapFrom, paldDrawTo, bCapTo,
4064 &iColor, prKeep->BondWidth, iModel);
4065 #else
4066 RenderHalfWormBond(paldThis, paldDrawTo, &iColor,
4067 prKeep->BondWidth, iModel);
4068 #endif
4069 } else {
4070 paldMid = NewALD(); /* phoney location */
4071 if (!paldMid)
4072 goto nextbond;
4073 paldMid->pfbParent = (PFB) pmadThis; /* link to this atom */
4074 paldMid->iFloatNo = (Int1) 3;
4075 paldMid->cAltConf = ' ';
4076 paldMid->pflvData = FLVector(0, 3);
4077 if (!paldMid->pflvData) {
4078 FreeALD(paldMid);
4079 return;
4080 }
4081 /* midpoint between the two atoms */
4082 paldMid->pflvData[0] =
4083 (paldThis->pflvData[0] +
4084 paldDrawTo->pflvData[0]) / (float) 2.0;
4085 paldMid->pflvData[1] =
4086 (paldThis->pflvData[1] +
4087 paldDrawTo->pflvData[1]) / (float) 2.0;
4088 paldMid->pflvData[2] =
4089 (paldThis->pflvData[2] +
4090 paldDrawTo->pflvData[2]) / (float) 2.0;
4091 if (paldMid && paldThis) {
4092
4093 #ifdef _OPENGL
4094 /* the reason is a bit obscure, but this comparison
4095 ensures that ends of OpenGL cylinders for bonds
4096 match up correctly (thiessen) */
4097 if (paldThis > paldDrawTo)
4098 RenderBond(paldThis, FALSE, paldMid, bCapTo,
4099 &iColor, prKeep->BondWidth);
4100 else
4101 RenderBond(paldMid, bCapTo, paldThis, FALSE,
4102 &iColor, prKeep->BondWidth);
4103 #else
4104 RenderBond(paldThis, paldMid, &iColor, prKeep->BondWidth);
4105 #endif /* _OPENGL */
4106 }
4107 FreeALD(paldMid);
4108 }
4109 }
4110 }
4111 nextbond:
4112 pvnB = pvnB->next;
4113 }
4114 }
4115 return;
4116 }
4117
4118
GetGraphNCBIstdaa(PMGD pmgdThis)4119 Int2 LIBCALL GetGraphNCBIstdaa(PMGD pmgdThis)
4120 {
4121
4122 Int2 i;
4123
4124 if (!(IsGraphAminoAcid(pmgdThis)))
4125 return 21;
4126 for (i = 0; i < MAX_NCBIstdaa; i++)
4127 if (pmgdThis->pcIUPAC[0] == NCBIstdaaUC[i]) {
4128 return i;
4129 }
4130 return 21; /* Xxx */
4131 }
4132
GetGraphNCBI4na(PMGD pmgdThis)4133 Int2 LIBCALL GetGraphNCBI4na(PMGD pmgdThis)
4134 {
4135 Int2 i;
4136 if (!(IsGraphNABase(pmgdThis)))
4137 return 16;
4138 for (i = 0; i < MAX_NCBIstdaa; i++)
4139 if (pmgdThis->pcIUPAC[0] == NCBI4naUC[i])
4140 return i;
4141 return 16; /* N (any) */
4142 }
4143
4144
SetAtomAndBondGeometry(PRK prKeep,Int2 iRenderNow)4145 static void SetAtomAndBondGeometry(PRK prKeep, Int2 iRenderNow)
4146 {
4147 switch (iRenderNow) {
4148 case R_NAME:
4149 case R_NUMBER:
4150 case R_PDBNUMBER:
4151 prKeep->Bond = (Byte) NO_BOND;
4152 prKeep->BondWidth = (FloatLo) 0;
4153 prKeep->Atom = (Byte) ATOM_NONE;
4154 break;
4155 case R_SPACE:
4156 prKeep->Bond = (Byte) NO_BOND;
4157 prKeep->BondWidth = (FloatLo) 0;
4158 prKeep->Atom = (Byte) ATOM_SPACE;
4159 break;
4160 case R_STICK:
4161 prKeep->Bond = (Byte) HALF_BOND;
4162 prKeep->BondWidth = HET_BOND_WIDTH;
4163 prKeep->Atom = (Byte) ATOM_ISBOND;
4164 break;
4165 case R_BALLNSTICK:
4166 prKeep->Bond = (Byte) HALF_BOND;
4167 prKeep->BondWidth = HET_BOND_WIDTH;
4168 prKeep->Atom = (Byte) ATOM_2XBOND;
4169 break;
4170 case R_THICKWIRE:
4171 prKeep->Bond = (Byte) HALF_BOND;
4172 prKeep->BondWidth = VIRT_BOND_WIDTH;
4173 prKeep->Atom = (Byte) ATOM_ISBOND;
4174 break;
4175 #ifdef _OPENGL
4176 case R_WORMTHIN:
4177 prKeep->Bond = (Byte) HALF_WORM_BOND;
4178 prKeep->BondWidth = HET_BOND_WIDTH;
4179 prKeep->Atom = (Byte) ATOM_NONE;
4180 break;
4181 case R_WORMFAT:
4182 prKeep->Bond = (Byte) HALF_WORM_BOND;
4183 prKeep->BondWidth = VIRT_BOND_WIDTH;
4184 prKeep->Atom = (Byte) ATOM_NONE;
4185 break;
4186 #endif
4187 case R_WORMWIRE:
4188 prKeep->Bond = (Byte) HALF_WORM_BOND;
4189 prKeep->BondWidth = (FloatLo) 0;
4190 prKeep->Atom = (Byte) ATOM_NONE;
4191 break;
4192 case R_DEFAULT:
4193 case R_WIRE:
4194 default:
4195 prKeep->Bond = (Byte) HALF_BOND;
4196 prKeep->BondWidth = (FloatLo) 0;
4197 prKeep->Atom = (Byte) ATOM_NONE;
4198 }
4199 }
4200
DoResidueLabel(PRK prkNew,Int4 iRenderWhat,PDNMG pdnmgThis,PMSD pmsdThis,Int4 iModel)4201 static void DoResidueLabel(PRK prkNew, Int4 iRenderWhat, PDNMG pdnmgThis,
4202 PMSD pmsdThis, Int4 iModel)
4203 {
4204 if ((iRenderWhat == NTBBLABELS) || (iRenderWhat == PBBLABELS)) {
4205
4206 Int2 iEnd;
4207 Int2 iSkip;
4208 PMAD pmadThis = NULL;
4209 CharPtr pcLabel = NULL;
4210 CharPtr pcLNum = NULL;
4211 CharPtr pcDash = NULL;
4212 CharPtr pcTemp = NULL;
4213 CharPtr pcTemp2 = NULL;
4214 CharPtr pcL = NULL;
4215 PDNMG pdnmgFrom = NULL;
4216 PDNMG pdnmgTo = NULL;
4217 PMAD pmadFrom = NULL;
4218 PMAD pmadTo = NULL;
4219 PALD paldThis = NULL;
4220 PALD paldFrom = NULL;
4221 PALD paldTo = NULL;
4222 PMGD pmgdThis = (PMGD) pdnmgThis->data.ptrvalue;
4223
4224 switch (iRenderWhat) {
4225 case PBBLABELS:
4226 prkNew->LJust = ((PARS) pmgdThis->pvnPARSList->data.ptrvalue)->PBBLabelJust;
4227 prkNew->LStyle = ((PARS) pmgdThis->pvnPARSList->data.ptrvalue)->PBBLabelStyle;
4228 prkNew->LScale = ((PARS) pmgdThis->pvnPARSList->data.ptrvalue)->PBBLabelScale;
4229 break;
4230 case NTBBLABELS:
4231 prkNew->LJust = ((PARS) pmgdThis->pvnPARSList->data.ptrvalue)->NTBBLabelJust;
4232 prkNew->LStyle = ((PARS) pmgdThis->pvnPARSList->data.ptrvalue)->NTBBLabelStyle;
4233 prkNew->LScale = ((PARS) pmgdThis->pvnPARSList->data.ptrvalue)->NTBBLabelScale;
4234 break;
4235 }
4236
4237 if (Cn3d_ColorNow == C_CPK || Cn3d_ColorNow == C_BYTEMP ||
4238 (prkNew->LStyle & L_WHITE))
4239 DDV_SetColorInCell((&prkNew->Color), Cn3d_PaletteRGB[C_white]);
4240 if (Cn3d_ColorPass) {
4241 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, &(prkNew->Color));
4242 return;
4243 }
4244
4245 switch ((int) Cn3d_LabelNow) {
4246 case 2:
4247 iSkip = 1;
4248 break;
4249 case 3:
4250 iSkip = 5;
4251 break;
4252 case 4:
4253 iSkip = 10;
4254 break;
4255 case 5:
4256 iSkip = 20;
4257 break;
4258 case 6:
4259 iSkip = 50;
4260 break;
4261 default:
4262 iSkip = 1;
4263 }
4264 if (((int) pdnmgThis->choice % (Int4) iSkip) != 0)
4265 return;
4266
4267 if (IsGraphAminoAcid(pmgdThis) && (prkNew->LStyle & L_NAME)) {
4268 Int2 iResId;
4269 iResId = GetGraphNCBIstdaa(pmgdThis);
4270 if (prkNew->LStyle & L_PDB) {
4271 pcLabel = StringSave(pmgdThis->pcGraphName);
4272 if (!pcLabel)
4273 pcLabel = StringSave("UNK");
4274 if (StringLen(pcLabel) > 3)
4275 pcLabel[3] = '\0'; /* truncate SER COOH dict. */
4276 } else if (prkNew->LStyle & L_1LETR)
4277 pcLabel = StringSave(pmgdThis->pcIUPAC);
4278 else
4279 pcLabel = StringSave(AminoAcidNameFromIdx(iResId, USE_MIXCASE));
4280 }
4281
4282 if (IsGraphNABase(pmgdThis) && (prkNew->LStyle & L_NAME)) {
4283 if ((prkNew->LStyle & L_1LETR) && (!(prkNew->LStyle & L_PDB))) {
4284 pcLabel = StringSave(pmgdThis->pcIUPAC);
4285 } else {
4286 pcLabel = StringSave(pmgdThis->pcGraphName);
4287 }
4288 if (!pcLabel)
4289 pcLabel = StringSave("UNK");
4290 pcTemp = pcLabel;
4291 if ((pmgdThis->bWhat & (Byte) DICT_LOCAL) &&
4292 ((pcLabel[0] == 'D') || (pcLabel[0] == 'R')) &&
4293 (pcLabel[1] == 'N') && (pcLabel[2] == 'A')) {
4294 pcTemp = (CharPtr) & pcLabel[3];
4295 }
4296 if (StringLen(pcTemp) > 3)
4297 pcTemp[3] = '\0'; /* truncate SER COOH dict. */
4298 pcTemp2 = pcLabel;
4299 pcLabel = StringSave(pcTemp);
4300 MemFree(pcTemp2);
4301 }
4302
4303 if (prkNew->LStyle & L_NUM) {
4304 if (prkNew->LStyle & L_PDB) {
4305 pcLNum = StringSave(pmgdThis->pcGraphNum);
4306 if (!pcLNum)
4307 pcLNum = StringSave("?");
4308 /* remove leading spaces */
4309 pcTemp = pcLNum;
4310 while ((pcTemp[0] == ' ') && (pcTemp[1] != '\0')) {
4311 pcTemp = (CharPtr) & pcTemp[1];
4312 }
4313 pcTemp2 = pcLNum;
4314 pcLNum = StringSave(pcTemp);
4315 MemFree(pcTemp2);
4316 } else {
4317 pcLNum = (CharPtr) MemNew((size_t) (INTSTRLEN));
4318 if (!pcLNum)
4319 return;
4320 sprintf(pcLNum, "%ld", (long) pdnmgThis->choice);
4321 }
4322 }
4323
4324 if ((pcLabel == NULL) && (pcLNum == NULL)) {
4325 pcL = StringSave(" ");
4326 } else if (pcLabel == NULL) {
4327 pcL = StringSave(pcLNum);
4328 MemFree(pcLNum);
4329 } else if (pcLNum == NULL) {
4330 pcL = StringSave(pcLabel);
4331 MemFree(pcLabel);
4332 } else {
4333 pcDash = StringSave("-");
4334 if (pcLNum == NULL)
4335 pcLNum = StringSave(" ");
4336 pcL = (CharPtr)
4337 MemNew((size_t)
4338 (StringLen(pcLabel) + StringLen(pcDash) +
4339 StringLen(pcLNum) + 4));
4340 if (!pcL)
4341 return;
4342 StringCpy(pcL, pcLabel);
4343 StringCat(pcL, pcDash);
4344 StringCat(pcL, pcLNum);
4345 MemFree(pcLabel);
4346 MemFree(pcDash);
4347 MemFree(pcLNum);
4348 }
4349 /* pcL is label ready to go */
4350
4351 pmadThis = GetMainAtom(pdnmgThis);
4352 paldThis = GetAtomAltLocs(pmadThis, iModel);
4353 if (!paldThis)
4354 return;
4355 iEnd = RL_BETACARB;
4356
4357 pdnmgTo = GetPrevGraph(pdnmgThis);
4358 pmadTo = GetMainAtom(pdnmgTo);
4359 paldTo = GetAtomAltLocs(pmadTo, iModel);
4360 if (!paldTo)
4361 iEnd = RL_CENTERPLUSY;
4362
4363 pdnmgFrom = GetNextGraph(pdnmgThis);
4364 pmadFrom = GetMainAtom(pdnmgFrom);
4365 paldFrom = GetAtomAltLocs(pmadFrom, iModel);
4366 if (!paldFrom)
4367 iEnd = RL_CENTERPLUSY;
4368
4369 RenderLabel(pmsdThis->pdnmsLink, pcL,
4370 paldThis, paldFrom, paldTo,
4371 &(prkNew->Color), prkNew->LJust, prkNew->LScale, iEnd);
4372 MemFree(pcL);
4373 }
4374 }
4375
4376
SelectColorForResidue(PDNMG pdnmgThis,Int4 currentRow,Int4 currentAlignLoc,PRK prkNew,PMMD pmmdThis,PARS pars,Int4 iRenderWhat)4377 static Uint1* SelectColorForResidue(PDNMG pdnmgThis, Int4 currentRow,
4378 Int4 currentAlignLoc, PRK prkNew,
4379 PMMD pmmdThis, PARS pars, Int4 iRenderWhat)
4380 {
4381 Int2 iResId;
4382 Uint1 *residueColor = NULL;
4383 PDNMM pdnmmThis;
4384 PMGD pmgdThis = (PMGD) pdnmgThis->data.ptrvalue;
4385
4386 switch (Cn3d_ColorNow) {
4387 case C_BYRES:
4388 if IsGraphAminoAcid(pmgdThis) {
4389 iResId = GetGraphNCBIstdaa(pmgdThis);
4390 residueColor = Cn3d_PaletteRGB[KinAAColor[iResId]];
4391 } else if IsGraphNABase(pmgdThis) {
4392 iResId = GetGraphNCBI4na(pmgdThis);
4393 residueColor = Cn3d_PaletteRGB[KinNAColor[iResId]];
4394 }
4395 break;
4396
4397 case C_BYSECSTRUC:
4398 if (IsGraphAminoAcid(pmgdThis)) {
4399 DDV_ColorCell *pMyCell = NULL;
4400 pMyCell = ColorFromSS(pmgdThis);
4401 if (pMyCell == NULL) return NULL;
4402 residueColor = pMyCell->rgb;
4403 }
4404 break;
4405
4406 case C_BYOBJECT:
4407 residueColor = Cn3d_PaletteRGB[bObjectColors[(Cn3d_lSlaveNum % NUM_SLAVES)]];
4408 break;
4409
4410 case C_BYSTRUCALIGN:
4411 if (IsGraphAminoAcid(pmgdThis)) {
4412 if (currentAlignLoc >= 0) {
4413 residueColor = Cn3d_PaletteRGB[C_red]; /* change conserved color to red */
4414 } else {
4415 /* use C_BYOBJECT colors for unaligned */
4416 residueColor = Cn3d_PaletteRGB[bObjectColors[(Cn3d_lSlaveNum % NUM_SLAVES)]];
4417 }
4418 }
4419 break;
4420
4421 case C_BYSEQCONS:
4422 if (IsGraphAminoAcid(pmgdThis)) {
4423 if (currentAlignLoc >= 0) {
4424 static Uint1 alignedColor[3];
4425 Nlm_Int4 RGBint =
4426 CSC_GetColumnColorByRow(currentRow, pdnmgThis->choice - 1);
4427 alignedColor[0] = (RGBint >> 16) & 0xFF;
4428 alignedColor[1] = (RGBint >> 8) & 0xFF;
4429 alignedColor[2] = RGBint & 0xFF;
4430 residueColor = alignedColor;
4431 } else {
4432 residueColor = Cn3D_UnalignedResidueColor;
4433 }
4434 }
4435 break;
4436
4437 case C_BYDOMAIN:
4438 if (IsGraphAminoAcid(pmgdThis)) {
4439 residueColor = Cn3d_PaletteRGB[ColorNumKinBB[(pmgdThis->iDomain % KIN_COLOR_NUM)]];
4440 }
4441 break;
4442
4443 case C_BYHYDRO:
4444 if (IsGraphAminoAcid(pmgdThis)) {
4445 iResId = GetGraphNCBIstdaa(pmgdThis);
4446 residueColor = Cn3d_PaletteRGB[PhobeAAColor[iResId]];
4447 } else if (IsGraphNABase(pmgdThis)) {
4448 iResId = GetGraphNCBI4na(pmgdThis);
4449 residueColor = Cn3d_PaletteRGB[KinNAColor[iResId]];
4450 }
4451 break;
4452
4453 case C_BYCHAIN:
4454 pdnmmThis = DNFromPFB((PFB) pmmdThis);
4455 residueColor =
4456 Cn3d_PaletteRGB[ColorNumKinBB[(pdnmmThis->choice % KIN_COLOR_NUM)]];
4457 break;
4458
4459 case C_BYCHOICE:
4460 if (prkNew->NodeWhat && AM_PROT) {
4461 if (iRenderWhat == RESIDUES) {
4462 residueColor = pars->PResColRGB;
4463 } else { /* backbone */
4464 residueColor = pars->PBBColRGB;
4465 }
4466 } else { /* nucleotide */
4467 if (iRenderWhat == RESIDUES) {
4468 residueColor = pars->NTResColRGB;
4469 } else { /* backbone */
4470 residueColor = pars->NTBBColRGB;
4471 }
4472 }
4473 break;
4474
4475 case C_CPK:
4476 case C_BYTEMP: /* atom-level colors will be set later in RenderAllAtom */
4477 default:
4478 residueColor = NULL;
4479 }
4480 return residueColor;
4481 }
4482
4483
4484 /* Sets color scheme for rendering a graph */
RenderGraph(PFB pfbThis,Int4 iModel,Int4 iRenderWhat,Pointer ptr)4485 static void LIBCALLBACK RenderGraph(PFB pfbThis, Int4 iModel, Int4 iRenderWhat,
4486 Pointer ptr)
4487 { /* traverser callback */
4488 PRK prKeep;
4489 PRK prkNew = NULL;
4490 PDNMG pdnmgThis = NULL;
4491 PMSD pmsdThis = NULL;
4492 PMMD pmmdThis = NULL;
4493 PMGD pmgdThis = NULL;
4494 PVNMA pvnmaThis = NULL;
4495 PMAD pmadThis = NULL;
4496 PVNMB pvnmbThis = NULL;
4497 PMBD pmbdThis = NULL;
4498 Byte bReservedThis = 0;
4499 static RK rkNew;
4500 Boolean addedResidueColors = FALSE;
4501 PARS parsResidue = NULL;
4502
4503 prkNew = &rkNew;
4504 prKeep = (PRK) ptr;
4505 if (!prKeep) return;
4506 Cn3D_DupRenderKeep(prkNew, prKeep);
4507
4508 if (!IsGraphNode(pfbThis))
4509 return;
4510 if (!(pfbThis->bMe & prKeep->NodeType))
4511 return;
4512 /*if (!(pfbThis->bWhat & prKeep->NodeWhat)) return;*/
4513 pmgdThis = (PMGD) pfbThis;
4514
4515 /* set up rendering styles for residue-wise structure elements */
4516 if (iRenderWhat == ANYBACKBONE || iRenderWhat == RESIDUES ||
4517 iRenderWhat == PBBLABELS || iRenderWhat == NTBBLABELS) {
4518
4519 /* use PARS structure at head of list to set residue-wise rendering styles */
4520 parsResidue = (PARS) pmgdThis->pvnPARSList->data.ptrvalue;
4521
4522 if (prKeep->NodeWhat & AM_PROT) {
4523 if (iRenderWhat == ANYBACKBONE) {
4524 if (parsResidue->PVirtualBBOn || parsResidue->PPartialBBOn ||
4525 parsResidue->PCompleteBBOn) {
4526 Cn3d_RenderNow = parsResidue->PBBRender;
4527 Cn3d_ColorNow = parsResidue->PBBColor;
4528 if (parsResidue->PVirtualBBOn) iRenderWhat = VIRTUALBB;
4529 else if (parsResidue->PPartialBBOn) iRenderWhat = PARTIALBB;
4530 else iRenderWhat = COMPLETEBB;
4531 } else return;
4532 }
4533 else if (iRenderWhat == RESIDUES) {
4534 if (parsResidue->PResiduesOn) {
4535 Cn3d_RenderNow = parsResidue->PResRender;
4536 Cn3d_ColorNow = parsResidue->PResColor;
4537 } else return;
4538 }
4539 else if (iRenderWhat == PBBLABELS) {
4540 if (parsResidue->PBBLabelInterval > 1) {
4541 Cn3d_RenderNow = R_NAME;
4542 Cn3d_ColorNow = parsResidue->PBBColor;
4543 Cn3d_LabelNow = parsResidue->PBBLabelInterval;
4544 } else return;
4545 }
4546 else return;
4547 }
4548
4549 else if (prKeep->NodeWhat & (AM_DNA | AM_RNA)) {
4550 if (iRenderWhat == ANYBACKBONE) {
4551 if (parsResidue->NTVirtualBBOn || parsResidue->NTPartialBBOn ||
4552 parsResidue->NTCompleteBBOn) {
4553 Cn3d_RenderNow = parsResidue->NTBBRender;
4554 Cn3d_ColorNow = parsResidue->NTBBColor;
4555 if (parsResidue->NTVirtualBBOn) iRenderWhat = VIRTUALBB;
4556 else if (parsResidue->NTPartialBBOn) iRenderWhat = PARTIALBB;
4557 else iRenderWhat = COMPLETEBB;
4558 } else return;
4559 }
4560 else if (iRenderWhat == RESIDUES) {
4561 if (parsResidue->NTResiduesOn) {
4562 Cn3d_RenderNow = parsResidue->NTResRender;
4563 Cn3d_ColorNow = parsResidue->NTResColor;
4564 } else return;
4565 }
4566 else if (iRenderWhat == NTBBLABELS) {
4567 if (parsResidue->NTBBLabelInterval > 1) {
4568 Cn3d_RenderNow = R_NAME;
4569 Cn3d_ColorNow = parsResidue->NTBBColor;
4570 Cn3d_LabelNow = parsResidue->NTBBLabelInterval;
4571 } else return;
4572 }
4573 else return;
4574 }
4575 else return;
4576 }
4577 prkNew->NodeWhat = (Byte) CONVERT_ALL;
4578 SetAtomAndBondGeometry(prkNew, Cn3d_RenderNow);
4579
4580 pdnmgThis = DNFromPFB(pfbThis);
4581 ASSERT(pdnmgThis != NULL);
4582 pmsdThis = ToMSDParent(pfbThis);
4583 ASSERT(pmsdThis != NULL);
4584 pmmdThis = GetParentMol((PFB) pmgdThis);
4585 ASSERT(pmmdThis != NULL);
4586
4587 if (IsGraphAminoAcid(pmgdThis) || IsGraphNABase(pmgdThis)) {
4588
4589 Boolean lowercase = FALSE;
4590 Int4 currentRow, currentAlignLoc = -2;
4591 SeqIdPtr currentSip;
4592 Uint1 *residueColor = NULL;
4593 SeqAlignPtr salp = NULL;
4594 SeqAnnotPtr sanp;
4595
4596 /* get pointer to current SeqAlign */
4597 for (sanp = Cn3D_ColorData.sap; sanp != NULL; sanp = sanp->next) {
4598 if (sanp->data != NULL) {
4599 salp = sanp->data;
4600 break;
4601 }
4602 }
4603
4604 /* see if we're doing by-row or by-SeqId storage */
4605 currentRow = -1;
4606 currentSip = pmmdThis->pSeqId;
4607 if (salp) {
4608 currentRow = ViewMgr_TRow2VRow(salp, pmmdThis->iTargetRow);
4609 /* if this sequence is part of the alignment, but is hidden, do nothing */
4610 if (currentRow <= 0 && pmmdThis->iTargetRow > 0)
4611 return;
4612 currentSip = NULL;
4613 }
4614
4615 /* find out whether this residue is aligned by querying AlignMgr */
4616 if (salp && currentRow > 0) {
4617 currentAlignLoc = AlnMgrMapBioseqToSeqAlign(salp,
4618 pdnmgThis->choice - 1,
4619 currentRow,
4620 NULL);
4621 lowercase = (currentAlignLoc < 0);
4622 }
4623
4624 /* figure out what residue-wise color to use */
4625 residueColor = SelectColorForResidue(pdnmgThis, currentRow,
4626 currentAlignLoc, prkNew,
4627 pmmdThis, parsResidue, iRenderWhat);
4628 if (!residueColor)
4629 residueColor = Cn3d_PaletteRGB[C_white];
4630
4631 /* set color/case in sequence window if this is an aligned (or only) structure. */
4632 /* always color in DDV cell with backbone color. */
4633 if ((iRenderWhat == COMPLETEBB || iRenderWhat == PARTIALBB || iRenderWhat == VIRTUALBB) &&
4634 ((currentSip && currentRow <= 0) || (!currentSip && currentRow > 0))) {
4635
4636 DDV_ColorCell *pColorTo =
4637 DDV_GetColor(Cn3D_ColorData.pDDVColorGlobal,
4638 currentSip, currentRow, pdnmgThis->choice - 1);
4639 if (pColorTo == NULL) return;
4640
4641 /* can't display white or nearly-white letters in sequence window */
4642 if (residueColor[0] > 230 && residueColor[1] > 230 && residueColor[2] > 230)
4643 DDV_SetColorInCell(pColorTo, Cn3d_PaletteRGB[C_gray]);
4644 else
4645 DDV_SetColorInCell(pColorTo, residueColor);
4646
4647 if (Cn3d_ColorPass) {
4648 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, pColorTo);
4649 addedResidueColors = TRUE;
4650 } else {
4651 pColorTo->LowerCase = lowercase;
4652 DDV_SetColor(Cn3D_ColorData.pDDVColorGlobal, currentSip,
4653 currentRow, pdnmgThis->choice - 1, pColorTo);
4654 }
4655 }
4656
4657 /* check to see if we want to show aligned/unaligned regions in
4658 structure window (ignore if single structure) */
4659 if (salp && IsGraphAminoAcid(pmgdThis) &&
4660 ((currentAlignLoc >= 0 && !Cn3D_fAlignOn) ||
4661 (currentAlignLoc < 0 && !Cn3D_fUnalignOn))) {
4662 return;
4663 }
4664
4665 DDV_SetColorInCell(&(prkNew->Color), residueColor);
4666 }
4667
4668 /* special case so that non-residues can be colored by object */
4669 else if (Cn3d_ColorNow == C_BYOBJECT) {
4670 DDV_SetColorInCell(&(prkNew->Color),
4671 Cn3d_PaletteRGB[bObjectColors[(Cn3d_lSlaveNum % NUM_SLAVES)]]);
4672 }
4673
4674 /* ... then set the highlight color for whole residue if highlighted */
4675 if (pmgdThis->bHighlighted
4676 /* let any 'ole molecule be highlighted...
4677 && (IsGraphAminoAcid(pmgdThis) || IsGraphNABase(pmgdThis) ||
4678 IsHeterogen(pmmdThis) || IsIon(pmmdThis) || IsSolvent(pmmdThis))
4679 */
4680 ) {
4681
4682 DDV_ColorEntry *pColorEntry = DDV_SearchColorbyName(
4683 Cn3D_ColorData.pDDVColorGlobal->pvnSpecialColors, "Highlight");
4684 if (pColorEntry != NULL) {
4685 DDV_CopyColorCell(&(prkNew->Color), &(pColorEntry->ColorCell));
4686 if (Cn3d_ColorPass) {
4687 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette,
4688 &(prkNew->Color));
4689 addedResidueColors = TRUE;
4690 }
4691 }
4692 }
4693
4694 if (addedResidueColors) return;
4695
4696 /* control display show/off on MG level-- Yanli */
4697 if (pmgdThis->bVisible != 1)
4698 return;
4699
4700 DoResidueLabel(prkNew, iRenderWhat, pdnmgThis, pmsdThis, iModel);
4701
4702 #ifdef _OPENGL
4703 OGL_LoadName((Nlm_VoidPtr) pmgdThis);
4704 #endif
4705
4706 /* do the rendering */
4707
4708 /* deal with setting the NodeType/NodeWhat for virtual/backbone/realbb/residues */
4709 if ((prkNew->Bond == HALF_BOND) || (prkNew->Bond == HALF_WORM_BOND) ||
4710 (prkNew->Atom != ATOM_NONE)) { /* draw atoms or half-bonds */
4711 prkNew->NodeType = (Byte) AM_MAD;
4712 switch ((int) iRenderWhat) {
4713 case COMPLETEBB:
4714 prkNew->NodeWhat = (Byte) AM_BACKBONE;
4715 break;
4716 case PARTIALBB:
4717 prkNew->NodeWhat = (Byte) (AM_BACKBONE | AM_PARTIALBACKBONE);
4718 break;
4719 case VIRTUALBB:
4720 prkNew->NodeWhat = (Byte) (AM_CALPHA | AM_PALPHA); /* virtual */
4721 break;
4722 default:
4723 prkNew->NodeWhat = (Byte) CONVERT_ALL; /* do all the atoms */
4724 }
4725
4726 /* render all the atoms in this residue */
4727 pvnmaThis = pmgdThis->pvnmaAHead;
4728 while (pvnmaThis) {
4729 pmadThis = (PMAD) pvnmaThis->data.ptrvalue;
4730 if (pmadThis) RenderAllAtom((PFB) pmadThis, iModel, iRenderWhat, prkNew);
4731 pvnmaThis = pvnmaThis->next;
4732 }
4733 }
4734
4735 /* Traverse the InterResidueBonds & draw them as half bonds,
4736 connecting to this residue in its residue color */
4737 if (!(((int) iRenderWhat == VIRTUALBB) ||
4738 ((int) iRenderWhat == PARTIALBB) ||
4739 ((int) iRenderWhat == COMPLETEBB))
4740 && (prkNew->Bond)) {
4741 prkNew->NodeType = (Byte) AM_MAD;
4742 prkNew->NodeWhat = (Byte) CONVERT_ALL;
4743 pvnmbThis = pmmdThis->pvnmbIRBHead;
4744 while (pvnmbThis) { /* walk the inter-res bond list by hand */
4745 pmbdThis = (PMBD) pvnmbThis->data.ptrvalue;
4746 if (GetParentGraph((PFB) pmbdThis->pmadFrom) == pmgdThis) { /* this inter-res bond is in this graph */
4747 RenderAllAtom((PFB) pmbdThis->pmadFrom, iModel, iRenderWhat, prkNew);
4748 }
4749 if (GetParentGraph((PFB) pmbdThis->pmadTo) == pmgdThis) {
4750 RenderAllAtom((PFB) pmbdThis->pmadTo, iModel, iRenderWhat, prkNew);
4751 }
4752 pvnmbThis = pvnmbThis->next;
4753 }
4754 }
4755
4756 return;
4757 }
4758
4759
LabelChainTermini(Int4 iRenderWhat,Int4 iModel,PMMD pmmdThis,PRK prkNew)4760 static void LabelChainTermini(Int4 iRenderWhat, Int4 iModel,
4761 PMMD pmmdThis, PRK prkNew)
4762 {
4763 if (iRenderWhat == NTTERMLABELS || iRenderWhat == PTERMLABELS) {
4764
4765 PDNMG pdnmgFrom;
4766 PMAD pmadFrom;
4767 PALD paldFrom;
4768 PDNMG pdnmgTo;
4769 PMAD pmadTo;
4770 PALD paldTo;
4771 PVNMB pvnmbThis = NULL;
4772 PMBD pmbdThis = NULL;
4773 CharPtr pcN, pcC;
4774 CharPtr pcChain = NULL;
4775 Char pcTemp[32];
4776
4777 PMSD pmsdThis = ToMSDParent((PFB) pmmdThis);
4778 ASSERT(pmsdThis != NULL);
4779
4780 /* always do white termini labels - too hard to track with other colors,
4781 since we don't have residue-wise info at this point */
4782 DDV_SetColorInCell((&prkNew->Color), Cn3d_PaletteRGB[C_white]);
4783 if (Cn3d_ColorPass) {
4784 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, &(prkNew->Color));
4785 return;
4786 }
4787
4788 switch (iRenderWhat) {
4789 case PTERMLABELS:
4790 prkNew->LJust = ((PARS) pmsdThis->pGlobalPARS)->PTermLabelJust;
4791 prkNew->LStyle = ((PARS) pmsdThis->pGlobalPARS)->PTermLabelStyle;
4792 prkNew->LScale = ((PARS) pmsdThis->pGlobalPARS)->PTermLabelScale;
4793 break;
4794 case NTTERMLABELS:
4795 prkNew->LJust = ((PARS) pmsdThis->pGlobalPARS)->NTTermLabelJust;
4796 prkNew->LStyle = ((PARS) pmsdThis->pGlobalPARS)->NTTermLabelStyle;
4797 prkNew->LScale = ((PARS) pmsdThis->pGlobalPARS)->NTTermLabelScale;
4798 break;
4799 }
4800
4801 if ((iRenderWhat == PTERMLABELS)) {
4802 pcN = "N";
4803 pcC = "C";
4804 }
4805 else if (iRenderWhat == NTTERMLABELS) {
4806 pcN = "5'";
4807 pcC = "3'";
4808 }
4809 if (prkNew->LStyle & L_NAME)
4810 pcChain = pmmdThis->pcMolName;
4811 if (!pcChain)
4812 pcChain = " ";
4813 StringCpy(pcTemp, pcChain);
4814 StringCat(pcTemp, " ");
4815 StringCat(pcTemp, pcN);
4816 pdnmgTo = GetFirstGraph(pmmdThis);
4817 if (!pdnmgTo || !pdnmgTo->data.ptrvalue ||
4818 !((PMGD) pdnmgTo->data.ptrvalue)->bVisible)
4819 return;
4820 pmadTo = GetMainAtom(pdnmgTo);
4821 paldTo = GetAtomAltLocs(pmadTo, iModel);
4822 while (paldTo == NULL) { /* walk in */
4823 pdnmgTo = GetNextGraph(pdnmgTo);
4824 if (!pdnmgTo)
4825 return; /* bail if no next graph */
4826 pmadTo = GetMainAtom(pdnmgTo);
4827 paldTo = GetAtomAltLocs(pmadTo, iModel);
4828 }
4829 pdnmgFrom = GetNextGraph(pdnmgTo);
4830 if (!pdnmgFrom)
4831 return;
4832 pmadFrom = GetMainAtom(pdnmgFrom);
4833 paldFrom = GetAtomAltLocs(pmadFrom, iModel);
4834 RenderLabel(pmsdThis->pdnmsLink, pcTemp,
4835 NULL, paldFrom, paldTo,
4836 &(prkNew->Color), prkNew->LJust, prkNew->LScale,
4837 RL_EXTRAPOL);
4838 StringCpy(pcTemp, pcChain);
4839 StringCat(pcTemp, " ");
4840 StringCat(pcTemp, pcC);
4841 pdnmgTo = GetLastGraph(pmmdThis);
4842 if (!pdnmgTo || !pdnmgTo->data.ptrvalue ||
4843 !((PMGD) pdnmgTo->data.ptrvalue)->bVisible)
4844 return;
4845 pmadTo = GetMainAtom(pdnmgTo);
4846 paldTo = GetAtomAltLocs(pmadTo, iModel);
4847 while (paldTo == NULL) {
4848 pdnmgTo = GetPrevGraph(pdnmgTo);
4849 if (!pdnmgTo)
4850 return;
4851 pmadTo = GetMainAtom(pdnmgTo);
4852 paldTo = GetAtomAltLocs(pmadTo, iModel);
4853 }
4854 pdnmgFrom = GetPrevGraph(pdnmgTo);
4855 if (!pdnmgFrom)
4856 return;
4857 pmadFrom = GetMainAtom(pdnmgFrom);
4858 paldFrom = GetAtomAltLocs(pmadFrom, iModel);
4859 RenderLabel(pmsdThis->pdnmsLink, pcTemp,
4860 NULL, paldFrom, paldTo,
4861 &(prkNew->Color), prkNew->LJust, prkNew->LScale,
4862 RL_EXTRAPOL);
4863 }
4864 }
4865
RenderMolecule(PFB pfbThis,Int4 iModel,Int4 iRenderWhat,Pointer ptr)4866 static void LIBCALLBACK RenderMolecule(PFB pfbThis, Int4 iModel,
4867 Int4 iRenderWhat, Pointer ptr)
4868 { /* traverser callback */
4869 PRK prKeep;
4870 PRK prkNew = NULL;
4871 PDNMM pdnmmThis = NULL;
4872 PMMD pmmdThis = NULL;
4873 Byte bHold;
4874 static RK rkNew;
4875
4876 prkNew = &rkNew;
4877
4878 prKeep = (PRK) ptr;
4879 if (!prKeep) return;
4880 Cn3D_DupRenderKeep(prkNew, prKeep);
4881
4882 if (!IsMoleculeNode(pfbThis))
4883 return;
4884 if (!(pfbThis->bMe & prKeep->NodeType))
4885 return; /* same test for molecule */
4886
4887 bHold = prKeep->NodeWhat;
4888
4889 /* special case for anded DNA/RNA */
4890 if ((prKeep->NodeWhat == (Byte) (AM_DNA | AM_RNA)) &&
4891 ((pfbThis->bWhat & AM_DNA) || (pfbThis->bWhat & AM_RNA)))
4892 bHold = pfbThis->bWhat;
4893
4894 /* special case for anded WAT/SOL */
4895 else if ((prKeep->NodeWhat == (Byte) (AM_WAT | AM_SOL)) &&
4896 ((pfbThis->bWhat & AM_WAT) || (pfbThis->bWhat & AM_SOL)))
4897 bHold = pfbThis->bWhat;
4898
4899 /* special case for HET/ION some ions are also hets - e.g. heme(Fe) */
4900 else if ((prKeep->NodeWhat == (Byte) (AM_HET)) &&
4901 ((pfbThis->bWhat == (Byte) AM_ION) ||
4902 (pfbThis->bWhat == (Byte) AM_HET) ||
4903 (pfbThis->bWhat == (Byte) AM_POLY)))
4904 bHold = pfbThis->bWhat;
4905
4906 if (pfbThis->bWhat != bHold)
4907 return;
4908
4909 if ((iRenderWhat == HETSON) || (iRenderWhat == IONSON))
4910 if (!((pfbThis->bWhat == AM_HET) ||
4911 (pfbThis->bWhat == AM_POLY) || (pfbThis->bWhat == AM_ION)))
4912 return;
4913
4914 pdnmmThis = DNFromPFB(pfbThis);
4915 pmmdThis = (PMMD) pfbThis;
4916
4917 if (!Cn3D_IsVisible(Cn3D_ColorData.pDDVColorGlobal, pmmdThis))
4918 return;
4919
4920 LabelChainTermini(iRenderWhat, iModel, pmmdThis, prkNew);
4921
4922 prkNew->NodeType = (Byte) AM_MGD;
4923 /*prkNew->NodeWhat = (Byte) CONVERT_ALL;*/
4924 TraverseOneModel(pmmdThis->pdnmgHead, TRAVERSE_GRAPH, iModel,
4925 iRenderWhat, prkNew, RenderGraph);
4926 return;
4927 }
4928
4929
DoGraphicNull(PFB pfbThis,Int4 iModel,Int4 iIndex,Pointer ptr)4930 static void LIBCALLBACK DoGraphicNull(PFB pfbThis, Int4 iModel,
4931 Int4 iIndex, Pointer ptr)
4932 {
4933 PMAD pmadAtom;
4934 PALD paldLoc;
4935
4936 if (IsAtomNode(pfbThis)) {
4937 pmadAtom = (PMAD) pfbThis;
4938 paldLoc = GetAtomAltLocs(pmadAtom, iModel);
4939 while (paldLoc) {
4940 paldLoc->pGraphic = NULL;
4941 paldLoc = paldLoc->next; /* get next location */
4942 }
4943 }
4944 }
4945
4946
4947
4948 Cn3D_ColorFuncList Cn3D_ColorList[CN3DFUNCNUM] = {
4949 {C_CPK, "CPK", Cn3D_Color_CPK},
4950 {C_BYCHAIN, "Cycle Chain", Cn3D_Color_BYCHAIN},
4951 {C_BYTEMP, "Temperature", Cn3D_Color_BYTEMP},
4952 {C_BYRES, "Residue", Cn3D_Color_BYRES},
4953 {C_BYSECSTRUC, "Secondary Structure", Cn3D_Color_BYSECSTRUC},
4954 {C_BYHYDRO, "Hydrophobicity", Cn3D_Color_BYHYDRO},
4955 {C_BYOBJECT, "Cycle Object ", Cn3D_Color_BYOBJECT}, /* make long so menus sizes in Render Panel match */
4956 {C_BYDOMAIN, "Cycle Domain", Cn3D_Color_BYDOMAIN},
4957 {C_BYSTRUCALIGN,"Alignment", Cn3D_Color_BYSTRUCCONS},
4958 {C_BYSEQCONS, "Sequence Conservation", Cn3D_Color_BYSEQCONS}
4959 };
4960
4961
Cn3D_ColorFuncName(Int4 which)4962 Char * Cn3D_ColorFuncName(Int4 which)
4963 {
4964 int i;
4965 for(i = 0; i < CN3DFUNCNUM; i++)
4966 if(Cn3D_ColorList[i].Value == which) break;
4967 if (i < CN3DFUNCNUM)
4968 return Cn3D_ColorList[i].Name;
4969 Message(MSG_POST, "Bad color function number passed to Cn3D_ColorFuncFindName");
4970 return NULL;
4971 }
4972
Cn3D_ColorFuncFind(void)4973 Char * Cn3D_ColorFuncFind(void)
4974 {
4975 PARS pars = NULL;
4976 PDNMS pdnmsThis = NULL;
4977
4978 pdnmsThis = GetSelectedModelstruc(); /* fetch the active structure */
4979 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return NULL;
4980 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
4981 if (pars == NULL) return NULL;
4982 return Cn3D_ColorFuncName(pars->PBBColor);
4983 }
4984
Cn3D_ColorStandard(Int2 Setting)4985 static void Cn3D_ColorStandard(Int2 Setting)
4986 {
4987 PARS pars = NULL;
4988 PDNMS pdnmsThis = NULL;
4989
4990 pdnmsThis = GetSelectedModelstruc(); /* fetch the active structure */
4991 if (!pdnmsThis || !pdnmsThis->data.ptrvalue) return;
4992 pars = (PARS) ((PMSD) pdnmsThis->data.ptrvalue)->pGlobalPARS;
4993 if (pars == NULL) return;
4994
4995 pars->PBBColor = Setting;
4996 }
4997
Cn3D_Color_CPK(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)4998 void Cn3D_Color_CPK(DDV_ColorGlobal * pColorGlobal, void *pData,
4999 DDV_Range * pRange)
5000 {
5001 Cn3D_ColorStandard(C_CPK);
5002 }
5003
Cn3D_Color_BYCHAIN(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5004 void Cn3D_Color_BYCHAIN(DDV_ColorGlobal * pColorGlobal, void *pData,
5005 DDV_Range * pRange)
5006 {
5007 Cn3D_ColorStandard(C_BYCHAIN);
5008 }
5009
Cn3D_Color_BYTEMP(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5010 void Cn3D_Color_BYTEMP(DDV_ColorGlobal * pColorGlobal, void *pData,
5011 DDV_Range * pRange)
5012 {
5013 Cn3D_ColorStandard(C_BYTEMP);
5014 }
5015
Cn3D_Color_BYRES(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5016 void Cn3D_Color_BYRES(DDV_ColorGlobal * pColorGlobal, void *pData,
5017 DDV_Range * pRange)
5018 {
5019 Cn3D_ColorStandard(C_BYRES);
5020 }
5021
Cn3D_Color_BYSECSTRUC(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5022 void Cn3D_Color_BYSECSTRUC(DDV_ColorGlobal * pColorGlobal, void *pData,
5023 DDV_Range * pRange)
5024 {
5025 Cn3D_ColorStandard(C_BYSECSTRUC);
5026 }
5027
Cn3D_Color_BYHYDRO(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5028 void Cn3D_Color_BYHYDRO(DDV_ColorGlobal * pColorGlobal, void *pData,
5029 DDV_Range * pRange)
5030 {
5031 Cn3D_ColorStandard(C_BYHYDRO);
5032 }
5033
Cn3D_Color_BYOBJECT(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5034 void Cn3D_Color_BYOBJECT(DDV_ColorGlobal * pColorGlobal, void *pData,
5035 DDV_Range * pRange)
5036 {
5037 Cn3D_ColorStandard(C_BYOBJECT);
5038 }
5039
Cn3D_Color_BYDOMAIN(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5040 void Cn3D_Color_BYDOMAIN(DDV_ColorGlobal * pColorGlobal, void *pData,
5041 DDV_Range * pRange)
5042 {
5043 Cn3D_ColorStandard(C_BYDOMAIN);
5044 }
5045
Cn3D_Color_BYSTRUCCONS(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5046 void Cn3D_Color_BYSTRUCCONS(DDV_ColorGlobal * pColorGlobal, void *pData,
5047 DDV_Range * pRange)
5048 {
5049 Cn3D_ColorStandard(C_BYSTRUCALIGN);
5050 }
5051
Cn3D_Color_BYSEQCONS(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5052 void Cn3D_Color_BYSEQCONS(DDV_ColorGlobal * pColorGlobal, void *pData,
5053 DDV_Range * pRange)
5054 {
5055 Cn3D_ColorStandard(C_BYSEQCONS);
5056 }
5057
Cn3D_ColorSpecial(DDV_ColorGlobal * pColorGlobal,void * pData,DDV_Range * pRange)5058 void Cn3D_ColorSpecial(DDV_ColorGlobal * pColorGlobal, void *pData,
5059 DDV_Range * pRange)
5060 {
5061 ;
5062 }
5063
5064
RenderConnection(PRK prKeep,PMSD pmsdThis,Int2 iModel)5065 static void RenderConnection(PRK prKeep, PMSD pmsdThis, Int2 iModel)
5066 {
5067 PVNMB pvnmbThis;
5068
5069 DDV_SetColorInCell(&(prKeep->Color), Cn3d_PaletteRGB[C_yellow]);
5070 if (Cn3d_ColorPass) {
5071 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, &(prKeep->Color));
5072 return;
5073 }
5074
5075 #ifdef _OPENGL
5076 if (Cn3d_RenderNow == R_WORMWIRE || Cn3d_RenderNow == R_WORMTHIN ||
5077 Cn3d_RenderNow == R_WORMFAT)
5078 prKeep->Bond = (Byte) HALF_WORM_BOND;
5079 else
5080 #endif
5081 prKeep->Bond = (Byte) HALF_BOND;
5082 prKeep->Atom = (Byte) ATOM_NONE;
5083 switch (Cn3d_RenderNow) {
5084 case R_STICK:
5085 #ifdef _OPENGL
5086 case R_WORMTHIN:
5087 #endif
5088 prKeep->BondWidth = HET_BOND_WIDTH;
5089 break;
5090 case R_BALLNSTICK:
5091 case R_THICKWIRE:
5092 #ifdef _OPENGL
5093 case R_WORMFAT:
5094 #endif
5095 prKeep->BondWidth = VIRT_BOND_WIDTH;
5096 break;
5097 case R_DEFAULT:
5098 case R_WIRE:
5099 case R_WORMWIRE:
5100 default:
5101 prKeep->BondWidth = (FloatLo) 0;
5102 }
5103
5104 #ifdef _OPENGL
5105 OGL_LoadName(NULL); /* disable highlighting of connections */
5106 #endif
5107
5108 pvnmbThis = pmsdThis->pvnmbIMBHead;
5109 while (pvnmbThis) { /* walk the inter-mol bond list by hand */
5110 PMBD pmbdThis;
5111 PALD paldThis, paldDrawTo;
5112
5113 pmbdThis = (PMBD) pvnmbThis->data.ptrvalue;
5114 paldThis = GetAtomAltLocs(pmbdThis->pmadFrom, iModel);
5115 paldDrawTo = GetAtomAltLocs(pmbdThis->pmadTo, iModel);
5116
5117 if (paldThis && paldDrawTo) {
5118 int i;
5119 PALD pald;
5120 PMAD pmad;
5121
5122 for (i = 0; i < 2; i++) { /* check atoms at both ends of bond */
5123 PMMD pmmd = NULL;
5124 PMGD pmgd;
5125 if (i == 0) {
5126 pmad = pmbdThis->pmadFrom;
5127 pald = paldThis;
5128 } else {
5129 pmad = pmbdThis->pmadTo;
5130 pald = paldDrawTo;
5131 }
5132
5133 /* hide connections to undrawn atoms: if this is a connection to solvent, and solvent
5134 isn't on, don't draw. Ditto for ions, hets, sidechains, backbones... */
5135 if (!((PARS) pmsdThis->pGlobalPARS)->IonsOn && (pmad->bUpdate & AM_ION)) {
5136 goto skip_bond;
5137 }
5138 if (!((PARS) pmsdThis->pGlobalPARS)->HeterogensOn) {
5139 if (!pmmd) pmmd = GetParentMol((PFB) pald);
5140 if (pmmd && (pmmd->bWhat == AM_HET || pmmd->bWhat == AM_POLY))
5141 goto skip_bond;
5142 }
5143 if (!((PARS) pmsdThis->pGlobalPARS)->SolventOn) {
5144 if (!pmmd) pmmd = GetParentMol((PFB) pald);
5145 if (pmmd && ((pmmd->bWhat & AM_SOL) || (pmmd->bWhat & AM_WAT)))
5146 goto skip_bond;
5147 }
5148 pmgd = GetParentGraph((PFB) pmad);
5149 if (!pmgd) break;
5150 if (!((PARS) pmgd->pvnPARSList->data.ptrvalue)->PResiduesOn &&
5151 IsGraphAminoAcid(pmgd) && !IsAtomBackBone(pmad)) {
5152 goto skip_bond;
5153 }
5154 if (!((PARS) pmgd->pvnPARSList->data.ptrvalue)->NTResiduesOn &&
5155 IsGraphNABase(pmgd) && !IsAtomBackBone(pmad)) {
5156 goto skip_bond;
5157 }
5158 if (IsGraphAminoAcid(pmgd) && IsAtomBackBone(pmad)) {
5159 if (!((PARS) pmgd->pvnPARSList->data.ptrvalue)->PCompleteBBOn &&
5160 !((PARS) pmgd->pvnPARSList->data.ptrvalue)->PPartialBBOn)
5161 goto skip_bond;
5162 if (!IsAtomPartialBackBone(pmad) &&
5163 ((PARS) pmgd->pvnPARSList->data.ptrvalue)->PPartialBBOn)
5164 goto skip_bond;
5165 }
5166 if (IsGraphNABase(pmgd) && IsAtomBackBone(pmad)) {
5167 if (!((PARS) pmgd->pvnPARSList->data.ptrvalue)->NTCompleteBBOn &&
5168 !((PARS) pmgd->pvnPARSList->data.ptrvalue)->NTPartialBBOn)
5169 goto skip_bond;
5170 if (!IsAtomPartialBackBone(pmad) &&
5171 ((PARS) pmgd->pvnPARSList->data.ptrvalue)->NTPartialBBOn)
5172 goto skip_bond;
5173 }
5174 }
5175
5176 #ifdef _OPENGL
5177 RenderBond(paldThis, TRUE, paldDrawTo, TRUE,
5178 &(prKeep->Color), prKeep->BondWidth);
5179 #else
5180 RenderBond(paldThis, paldDrawTo,
5181 &(prKeep->Color), prKeep->BondWidth);
5182 #endif
5183 }
5184 skip_bond:
5185 pvnmbThis = pvnmbThis->next;
5186 }
5187 return;
5188 }
5189
RenderParts(PDNMS pdnmsThis,Int2 iModel,Byte bMolecule,Int2 iRenderWhat)5190 static void RenderParts(PDNMS pdnmsThis, Int2 iModel,
5191 Byte bMolecule, Int2 iRenderWhat)
5192 {
5193 PRK prKeep;
5194 PMSD pmsdThis;
5195 static RK rKeep;
5196
5197 prKeep = &rKeep;
5198
5199 if (!pdnmsThis ||
5200 !(pmsdThis = (PMSD) pdnmsThis->data.ptrvalue))
5201 return;
5202
5203 Cn3D_SetRenderKeep(prKeep);
5204
5205 if (iRenderWhat == CONNECTON) {
5206 RenderConnection(prKeep, pmsdThis, iModel);
5207 return;
5208 }
5209
5210 prKeep->NodeType = (Byte) AM_MMD;
5211 prKeep->NodeWhat = (Byte) bMolecule;
5212 TraverseOneModel(pdnmsThis, TRAVERSE_MOLECULE,
5213 iModel, (Int4) iRenderWhat, prKeep,
5214 RenderMolecule);
5215 }
5216
5217
fnARModelLoop(PDNMS pdnmsThis,PDNML pdnmlThis)5218 static void fnARModelLoop(PDNMS pdnmsThis, PDNML pdnmlThis)
5219 {
5220 PARS parsGlobal;
5221 PMSD pmsdThis = NULL;
5222 Int2 iModel = 0;
5223
5224 if (!pdnmsThis || !pdnmlThis) return;
5225
5226 pmsdThis = (PMSD) pdnmsThis->data.ptrvalue;
5227 if (!pmsdThis) return;
5228 parsGlobal = (PARS) pmsdThis->pGlobalPARS;
5229 if (!parsGlobal) return;
5230
5231 iModel = (Int2) pdnmlThis->choice;
5232 SetActiveModel(((PFB) pmsdThis), iModel);
5233
5234 Cn3d_DoHydrogens = parsGlobal->HydrogensOn;
5235
5236 /*
5237 * We're now doing a single set of traversals, even when special features
5238 * are present. Thus, decisions about which elements are enabled (i.e. PPartialBBOn,
5239 * NTResiduesOn, etc., are made on a residue-by-residue basis, so here
5240 * we must go ahead with all RenderPartss without testing these booleans
5241 * yet - that work will be postponed until RenderGraph.
5242 */
5243 RenderParts(pdnmsThis, iModel, AM_PROT, ANYBACKBONE);
5244 RenderParts(pdnmsThis, iModel, AM_PROT, RESIDUES);
5245 RenderParts(pdnmsThis, iModel, AM_PROT, PBBLABELS);
5246
5247 RenderParts(pdnmsThis, iModel, (AM_RNA | AM_DNA), ANYBACKBONE);
5248 RenderParts(pdnmsThis, iModel, (AM_RNA | AM_DNA), RESIDUES);
5249 RenderParts(pdnmsThis, iModel, (AM_DNA | AM_RNA), NTBBLABELS);
5250
5251
5252 /*
5253 * all the rest of this stuff is rendered based on each MSD's "global" PARS
5254 */
5255 if (parsGlobal->ObjectOn) {
5256 PVNMO pvnmoThis = pmsdThis->pvnmoHead;
5257 Cn3d_RenderNow = R_DEFAULT;
5258 Cn3d_ColorNow = parsGlobal->ObjectColor;
5259 while (pvnmoThis) { /* do the object traversal */
5260 if ((Int2) pvnmoThis->choice == iModel) {
5261 RenderObject(pvnmoThis);
5262 }
5263 pvnmoThis = pvnmoThis->next;
5264 }
5265 }
5266
5267 if (parsGlobal->HeterogensOn) {
5268 Cn3d_RenderNow = parsGlobal->HetRender;
5269 Cn3d_ColorNow = parsGlobal->HetColor;
5270 RenderParts(pdnmsThis, iModel, (Byte) (AM_HET), HETSON);
5271 RenderParts(pdnmsThis, iModel, (Byte) (AM_POLY), HETSON);
5272 }
5273 if (parsGlobal->ConnectOn) {
5274 Cn3d_RenderNow = parsGlobal->ConnectRender;
5275 Cn3d_ColorNow = parsGlobal->ConnectColor;
5276 RenderParts(pdnmsThis, iModel, 0, CONNECTON);
5277 }
5278 if (parsGlobal->SolventOn) {
5279 Cn3d_RenderNow = parsGlobal->SolventRender;
5280 Cn3d_ColorNow = parsGlobal->SolventColor;
5281 RenderParts(pdnmsThis, iModel, (Byte) (AM_SOL | AM_WAT), SOLVENTON);
5282 }
5283 if (parsGlobal->PTermLabelOn) {
5284 Cn3d_RenderNow = R_NAME;
5285 Cn3d_ColorNow = parsGlobal->PBBColor;
5286 RenderParts(pdnmsThis, iModel, (Byte) (AM_PROT), PTERMLABELS);
5287 }
5288 if (parsGlobal->NTTermLabelOn) {
5289 Cn3d_RenderNow = R_NAME;
5290 Cn3d_ColorNow = parsGlobal->NTBBColor;
5291 RenderParts(pdnmsThis, iModel, (Byte) (AM_DNA | AM_RNA), NTTERMLABELS);
5292 }
5293 if (parsGlobal->IonsOn) {
5294 Cn3d_RenderNow = parsGlobal->IonRender;
5295 Cn3d_ColorNow = parsGlobal->IonColor;
5296 RenderParts(pdnmsThis, iModel, (Byte) (AM_ION), IONSON);
5297 }
5298
5299 }
5300
fnMSPLoop(PDNMS pdnmsThis)5301 void LIBCALL fnMSPLoop(PDNMS pdnmsThis)
5302 {
5303 PMSD pmsdThis = NULL;
5304 PDNML pdnmlThis = NULL;
5305 PMLD pmldThis = NULL;
5306
5307 if (!pdnmsThis) return;
5308
5309 pmsdThis = (PMSD) pdnmsThis->data.ptrvalue;
5310 pdnmlThis = pmsdThis->pdnmlModels;
5311
5312 while (pdnmlThis) {
5313 pmldThis = (PMLD) pdnmlThis->data.ptrvalue;
5314 if (pmldThis->bSelected & (Byte) 0x01) {
5315 fnARModelLoop(pdnmsThis, pdnmlThis);
5316 }
5317 pdnmlThis = pdnmlThis->next;
5318 }
5319 return;
5320 }
5321
5322
5323 #ifdef _OPENGL
Cn3D_MakeOGLPalette(TCn3D_ColorData * ColorData)5324 static void Cn3D_MakeOGLPalette(TCn3D_ColorData * ColorData)
5325 {
5326 TOGL_Data *OGL_Data = ColorData->OGL_Data;
5327 ValNodePtr Palette, PaletteIndex, PaletteExpanded;
5328 Int4 i, j, TotalColors = 0;
5329 Int4 nShades; /* the number of palette entries per color */
5330 Uint1 *red, *green, *blue;
5331
5332 Palette = ColorData->pDDVColorGlobal->Palette;
5333 if (!Palette)
5334 return;
5335
5336 DDV_SetColorChoice(Palette); /* set up the indices */
5337
5338 /* count the colors */
5339 for (Palette = ColorData->pDDVColorGlobal->Palette; Palette;
5340 Palette = Palette->next) {
5341 TotalColors++;
5342 if (TotalColors > CN3D_MAX_PALETTE)
5343 break; /* limit the maximum number of colors for now */
5344 }
5345
5346 nShades = CN3D_MAX_PALETTE / TotalColors;
5347 ValNodeFreeData(OGL_Data->PaletteIndex);
5348 OGL_Data->PaletteIndex = NULL;
5349 ValNodeFreeData(OGL_Data->PaletteExpanded);
5350 OGL_Data->PaletteExpanded = NULL;
5351
5352 Palette = ColorData->pDDVColorGlobal->Palette;
5353 for (i = 0; Palette && i < TotalColors; i++, Palette = Palette->next) {
5354 /* create a color entry in the index */
5355 PaletteIndex =
5356 ValNodeAddPointer(&(OGL_Data->PaletteIndex), 0,
5357 MemNew(sizeof(TOGL_PaletteIndex)));
5358 DDV_CopyColorCell(&(((TOGL_PaletteIndex *) (PaletteIndex->data.ptrvalue))->ColorCell),
5359 &(((DDV_ColorEntry *) (Palette->data.ptrvalue))->ColorCell));
5360
5361 ((TOGL_PaletteIndex *) (PaletteIndex->data.ptrvalue))->Begin = i * nShades; /* start ramp */
5362 /* create a color ramp */
5363 for (j = 0; j < nShades; j++) {
5364 PaletteExpanded =
5365 ValNodeAddPointer(&(OGL_Data->PaletteExpanded), 0,
5366 MemNew(sizeof(DDV_ColorCell)));
5367
5368 ((DDV_ColorCell *) (PaletteExpanded->data.ptrvalue))->rgb[0] =
5369 (Uint1) (((DDV_ColorEntry *) (Palette->data.ptrvalue))->
5370 ColorCell.rgb[0] * (((float)(j + 1)) / nShades));
5371 ((DDV_ColorCell *) (PaletteExpanded->data.ptrvalue))->rgb[1] =
5372 (Uint1) (((DDV_ColorEntry *) (Palette->data.ptrvalue))->
5373 ColorCell.rgb[1] * (((float)(j + 1)) / nShades));
5374 ((DDV_ColorCell *) (PaletteExpanded->data.ptrvalue))->rgb[2] =
5375 (Uint1) (((DDV_ColorEntry *) (Palette->data.ptrvalue))->
5376 ColorCell.rgb[2] * (((float)(j + 1)) / nShades));
5377 }
5378 ((TOGL_PaletteIndex *) (PaletteIndex->data.ptrvalue))->End =
5379 i * nShades + nShades - 1; /* end ramp */
5380 }
5381
5382 /* set the system palette to the expanded OGL palette */
5383 TotalColors = ValNodeLen(OGL_Data->PaletteExpanded);
5384 red = Calloc((size_t) TotalColors + 1, sizeof(Uint1));
5385 blue = Calloc((size_t) TotalColors + 1, sizeof(Uint1));
5386 green = Calloc((size_t) TotalColors + 1, sizeof(Uint1));
5387
5388 for (Palette = OGL_Data->PaletteExpanded, i = 0;
5389 Palette;
5390 Palette = Palette->next, i++) {
5391 red[i] =
5392 ((DDV_ColorCell *) (Palette->data.ptrvalue))->rgb[0];
5393 green[i] =
5394 ((DDV_ColorCell *) (Palette->data.ptrvalue))->rgb[1];
5395 blue[i] =
5396 ((DDV_ColorCell *) (Palette->data.ptrvalue))->rgb[2];
5397 }
5398
5399 red[TotalColors] = OGL_Data->Background.rgb[0];
5400 green[TotalColors] = OGL_Data->Background.rgb[1];
5401 blue[TotalColors] = OGL_Data->Background.rgb[2];
5402
5403 Nlm_Set3DColorMap(OGL_Data->Panel, (Uint1) (TotalColors + 1),
5404 red, green, blue, &OGL_Data->display);
5405 MemFree(red);
5406 MemFree(green);
5407 MemFree(blue);
5408 }
5409 #endif /* _OPENGL */
5410
5411
MakeStrucPalette(PDNMS pdnmsThis)5412 void LIBCALL MakeStrucPalette(PDNMS pdnmsThis)
5413 {
5414 PMSD pmsdThis = NULL;
5415 PDNMS pdnmsThisSlave = NULL;
5416 PARS pars = NULL;
5417 SeqAnnotPtr sanp;
5418 SeqAlignPtr salp = NULL;
5419
5420 if (!pdnmsThis) return;
5421 pmsdThis = (PMSD) pdnmsThis->data.ptrvalue;
5422
5423 pars = (PARS) pmsdThis->pGlobalPARS;
5424 if (!pars)return;
5425
5426 /* make column colors available */
5427 for (sanp = Cn3D_ColorData.sap; sanp != NULL; sanp = sanp->next) {
5428 if (sanp->data != NULL) {
5429 salp = sanp->data;
5430 CSC_CalculateColumnColors(salp, pars->ConsColAlg);
5431 break;
5432 }
5433 }
5434
5435 #ifdef _OPENGL
5436 /* if 8-bit color: clear palette; do palette construction loops first */
5437 if (Cn3D_ColorData.OGL_Data->IndexMode) {
5438 #endif
5439 DDV_FreePalette(&(Cn3D_ColorData.pDDVColorGlobal->Palette));
5440
5441 Cn3d_ColorPass = TRUE;
5442 Cn3d_lSlaveNum = 0;
5443
5444 fnMSPLoop(pdnmsThis); /* go over the master */
5445
5446 if (AreNeighborsOn()) {
5447 pdnmsThisSlave = pmsdThis->pdnmsSlaves; /* go through the slave structures */
5448 while (pdnmsThisSlave) {
5449 Cn3d_lSlaveNum++;
5450 if (((PMSD) (pdnmsThisSlave->data.ptrvalue))->bVisible)
5451 fnMSPLoop(pdnmsThisSlave);
5452 pdnmsThisSlave = pdnmsThisSlave->next;
5453 }
5454 }
5455
5456 Cn3d_ColorPass = FALSE;
5457 ResetDisplayCtrls(); /* in case anything has been hidden */
5458
5459 #ifdef _OPENGL
5460 Cn3D_MakeOGLPalette(&Cn3D_ColorData); /* expand palette for 8-bit OpenGL */
5461 }
5462 #endif
5463
5464 /* tell the color-by-conservation module to apply appropriate colors
5465 to any rows that don't have structure - i.e., that haven't already
5466 been colored by the above structure traversals */
5467 if (salp) {
5468 /* use "show alignment" algorithm simply to color (red) aligned residues
5469 for unaligned rows, to match structure alignment view */
5470 if (pars->PBBColor == C_BYSTRUCALIGN)
5471 CSC_CalculateColumnColors(salp, CSC_SHOWALIGNED);
5472 CSC_SetNonStructureDDVRowCells(pmsdThis,
5473 (pars->PBBColor == C_BYSEQCONS || pars->PBBColor == C_BYSTRUCALIGN),
5474 (pars->PBBColor == C_BYSEQCONS)
5475 ? Cn3D_UnalignedResidueColor
5476 : Cn3d_PaletteRGB[C_black],
5477 Cn3D_ColorData.pDDVColorGlobal);
5478 }
5479
5480 return;
5481 }
5482
5483
5484 /*
5485 * Set up separate layers for each member of conf-ensembles, if and only
5486 * if there's a single pdb-model (and, of course, it has conf-ensembles).
5487 */
CheckForConfEnsembles(PDNMS pdnmsThis)5488 static void CheckForConfEnsembles(PDNMS pdnmsThis)
5489 {
5490 PDNML pdnmlThis = NULL;
5491 PMLD pmldThis;
5492 int nPDBModels = 0;
5493 BiostrucModelPtr pbsmModel;
5494 ModelCoordinateSetPtr pmcsCoordSet;
5495 CoordinatesPtr pcCoords;
5496 AtomicCoordinatesPtr pacCoords;
5497 ConformationEnsemblePtr pceEnsembles;
5498 AlternateConformationIdsPtr paciAltConfIDs;
5499 Nlm_CharPtr pcId;
5500 int nIDs;
5501
5502 Cn3d_nEnsembles = Cn3d_currentEnsemble = 0;
5503 if (!pdnmsThis ||
5504 !(pdnmlThis = ((PMSD) pdnmsThis->data.ptrvalue)->pdnmlModels))
5505 return;
5506
5507 while (pdnmlThis) { /* look for a pdb-model */
5508 pmldThis = (PMLD) pdnmlThis->data.ptrvalue;
5509 pbsmModel = pmldThis->pbsmModel;
5510
5511 if (pbsmModel->type == Model_type_pdb_model) {
5512 nPDBModels++;
5513 if (nPDBModels > 1) goto skip_it;
5514
5515 /* descend the asn1 object to see if this pdb-model has
5516 conf-ensembles; if so, build a string of alt-conf-ids for
5517 each ensemble into the Cn3d_altConfIDs array */
5518 if (!(pmcsCoordSet = pbsmModel->model_coordinates)) goto skip_it;
5519 if (pmcsCoordSet->Coordinates_coordinates->choice !=
5520 Coordinates_coordinates_literal) goto skip_it;
5521 pcCoords = (ValNodePtr)
5522 pmcsCoordSet->Coordinates_coordinates->data.ptrvalue;
5523 if (pcCoords->choice != Coordinates_atomic) goto skip_it;
5524 pacCoords = (AtomicCoordinatesPtr) pcCoords->data.ptrvalue;
5525 if (!(pceEnsembles = pacCoords->conf_ensembles)) goto skip_it;
5526 while (pceEnsembles) {
5527 paciAltConfIDs = pceEnsembles->alt_conf_ids;
5528 nIDs = 0;
5529 while (paciAltConfIDs) {
5530 pcId = (Nlm_CharPtr) paciAltConfIDs->data.ptrvalue;
5531 Cn3d_altConfIDs[Cn3d_nEnsembles][nIDs] = *pcId;
5532 if (nIDs == MAXALTCONF - 2) break;
5533 nIDs++;
5534 Cn3d_altConfIDs[Cn3d_nEnsembles][nIDs] = '\0';
5535 paciAltConfIDs = paciAltConfIDs->next;
5536 }
5537 Cn3d_nEnsembles++;
5538 if (Cn3d_nEnsembles == MAXALTCONF) break;
5539 pceEnsembles = pceEnsembles->next;
5540 }
5541 if (Cn3d_nEnsembles < 2) goto skip_it;
5542 }
5543
5544 pdnmlThis = pdnmlThis->next;
5545 }
5546 return;
5547
5548 skip_it:
5549 Cn3d_nEnsembles = Cn3d_currentEnsemble = 0;
5550 }
5551
fnARLoop(PDNMS pdnmsThis)5552 void LIBCALL fnARLoop(PDNMS pdnmsThis)
5553 {
5554 /* the rendering engine */
5555 PDNML pdnmlThis = NULL;
5556 Int2 iTest;
5557 PMSD pmsdThis = NULL;
5558 PMLD pmldThis = NULL;
5559
5560
5561 pmsdThis = (PMSD) pdnmsThis->data.ptrvalue;
5562
5563 iTest =
5564 TraverseModels(pdnmsThis, TRAVERSE_ATOM, 0, NULL, DoGraphicNull);
5565
5566 CheckForConfEnsembles(pdnmsThis);
5567
5568 pdnmlThis = pmsdThis->pdnmlModels;
5569 while (pdnmlThis) {
5570 pmldThis = (PMLD) pdnmlThis->data.ptrvalue;
5571
5572 if (pmldThis->bSelected & (Byte) 0x01) {
5573
5574 #ifdef _OPENGL
5575 Int4 i;
5576 DDV_ColorCell Color;
5577
5578 /* set font display lists according to current label control panel menu */
5579 Cn3D_SetOGLFont(Cn3D_ColorData.OGL_Data);
5580
5581 OGL_Start(Cn3D_ColorData.OGL_Data, Cn3d_LayerNow);
5582 OGL_PushTransformation(((PMSD) (pdnmsThis->data.ptrvalue))->pdnSlaveToMasterTransforms);
5583
5584 if (MeshLoaded) {
5585 Color.rgb[0] = 255;
5586 Color.rgb[1] = 0;
5587 Color.rgb[2] = 0;
5588 for (i = 0; i < Mesh.NumTri; i++)
5589 OGL_AddTri3D(Cn3D_ColorData.OGL_Data, &Color,
5590 Mesh.Vertices[Mesh.Tri[i].Vertex[0] - 1].Vertex,
5591 Mesh.Vertices[Mesh.Tri[i].Vertex[1] - 1].Vertex,
5592 Mesh.Vertices[Mesh.Tri[i].Vertex[2] - 1].Vertex,
5593 Mesh.Vertices[Mesh.Tri[i].Vertex[0] - 1].Normal);
5594 }
5595 #endif /* _OPENGL */
5596
5597 fnARModelLoop(pdnmsThis, pdnmlThis);
5598
5599 #ifdef _OPENGL
5600 OGL_PopTransformation();
5601 OGL_End();
5602 #endif /* _OPENGL */
5603
5604 Cn3d_LayerNow++;
5605
5606 if (Cn3d_nEnsembles &&
5607 pmldThis->pbsmModel->type == Model_type_pdb_model) {
5608 #ifdef _OPENGL
5609 OGL_SetLayer(Cn3D_ColorData.OGL_Data, Cn3d_LayerNow - 1,
5610 (Cn3d_currentEnsemble == 0) ? TRUE : FALSE);
5611 #endif
5612 Cn3d_currentEnsemble++;
5613 if (Cn3d_currentEnsemble < Cn3d_nEnsembles) {
5614 continue; /* don't go to next pndml until ensembles done */
5615 } else {
5616 Cn3d_nEnsembles = 0; /* turn off ensembles */
5617 }
5618 }
5619
5620 } /* if model selected */
5621
5622 pdnmlThis = pdnmlThis->next;
5623 } /* while(pdnmlThis) */
5624 }
5625
5626
5627 #ifndef _OPENGL
Cn3d_Lock3DPalette(Picture3D ppic)5628 void Cn3d_Lock3DPalette(Picture3D ppic)
5629 {
5630 ValNodePtr Palette;
5631 Int4 i = 0;
5632
5633 Palette = Cn3D_ColorData.pDDVColorGlobal->Palette;
5634 if (!Palette) {
5635 AllocPalette3D(ppic, 1);
5636 SetColor3D(ppic, 0, 255, 255, 255);
5637 return;
5638 }
5639
5640 DDV_SetColorChoice(Palette);
5641
5642 while (Palette) {
5643 i++;
5644 if (i > CN3D_MAX_PALETTE)
5645 break; /* limit the maximum number of colors for now */
5646 Palette = Palette->next;
5647 }
5648
5649 AllocPalette3D(ppic, (Uint1) i);
5650 if (readErrors())
5651 return;
5652
5653 Palette = Cn3D_ColorData.pDDVColorGlobal->Palette;
5654 i = 0;
5655
5656 while (Palette) {
5657 SetColor3D(ppic, (Uint1) i,
5658 ((DDV_ColorEntry *) (Palette->data.ptrvalue))->
5659 ColorCell.rgb[0],
5660 ((DDV_ColorEntry *) (Palette->data.ptrvalue))->
5661 ColorCell.rgb[1],
5662 ((DDV_ColorEntry *) (Palette->data.ptrvalue))->
5663 ColorCell.rgb[2]);
5664 if (readErrors())
5665 return;
5666 i++;
5667 if (i > CN3D_MAX_PALETTE)
5668 break; /* limit the maximum number of colors for now */
5669 Palette = Palette->next;
5670 }
5671 }
5672 #endif /* ndef _OPENGL */
5673
5674
5675 #ifdef _OPENGL
AlgorithmicRendering(void)5676 void LIBCALL AlgorithmicRendering(void)
5677 #else
5678 Picture3D LIBCALL AlgorithmicRendering(Picture3D p3d)
5679 #endif
5680 {
5681 PDNMS pdnmsThis = NULL, pdnmsThisSlave = NULL;
5682 PMSD pmsdThis = NULL;
5683 Int2 Cn3d_LayerNow_sofar = 0;
5684 Int2 i = 0;
5685
5686 #ifndef _OPENGL
5687 pic = p3d; /* pic is the global 3d picture for algorend.c */
5688 #endif
5689
5690 /* fetch the active structure */
5691 pdnmsThis = GetSelectedModelstruc();
5692 pmsdThis = (PMSD) pdnmsThis->data.ptrvalue;
5693 if (!pdnmsThis || !pmsdThis)
5694 return
5695 #ifndef _OPENGL
5696 NULL
5697 #endif
5698 ;
5699 Cn3d_LayerNow = 0;
5700 Cn3d_AnyPrim = FALSE; /* has any primitive been drawn? */
5701 Cn3d_ColorPass = FALSE;
5702 Cn3d_lSlaveNum = 0;
5703
5704 MakeStrucPalette(pdnmsThis);
5705
5706 #ifndef _OPENGL
5707 Cn3d_Lock3DPalette(p3d); /* Allocates the Picture3D palette */
5708 #endif
5709
5710 #ifdef _OPENGL
5711 OGL_SetLayers(Cn3D_ColorData.OGL_Data, FALSE); /* null all the layers out */
5712 OGL_ClearTransparentSpheres();
5713 #endif /* _OPENGL */
5714
5715 /* do master */
5716 if (pmsdThis->bVisible)
5717 fnARLoop(pdnmsThis);
5718
5719 /* then go through the slaves */
5720 if (AreNeighborsOn()) {
5721 pdnmsThisSlave = pmsdThis->pdnmsSlaves;
5722 while (pdnmsThisSlave) {
5723 Cn3d_lSlaveNum++;
5724 if (((PMSD) (pdnmsThisSlave->data.ptrvalue))->bVisible) {
5725 fnARLoop(pdnmsThisSlave);
5726 }
5727 pdnmsThisSlave = pdnmsThisSlave->next;
5728 }
5729 }
5730
5731 #ifdef _OPENGL
5732 OGL_SetLayerTop3D(Cn3D_ColorData.OGL_Data, Cn3d_LayerNow - 1);
5733 return;
5734 #else /* _OPENGL */
5735 SetLayerTop3D(Cn3d_LayerNow - 1);
5736 if (Cn3d_AnyPrim)
5737 return p3d; /* has a primitive been drawn? */
5738 else {
5739 if (p3d != NULL)
5740 DeletePicture3D(p3d);
5741 return NULL;
5742 }
5743 #endif /* else _OPENGL */
5744 }
5745
5746
5747 #ifndef _OPENGL
Do3DOrigin(Picture3D p3d)5748 Picture3D LIBCALL Do3DOrigin(Picture3D p3d)
5749 {
5750 FloatLo fFrom[3];
5751 FloatLo fTo[3];
5752 Int4 iXFrom, iYFrom, iZFrom;
5753 Int4 iXTo, iYTo, iZTo;
5754 CharPtr pclabel[] = { "X", "Y", "Z" };
5755 PDNMS pdnmsThis = NULL;
5756 PMSD pmsdThis = NULL;
5757 Int4 i;
5758 DDV_ColorCell iColor;
5759
5760 /* appends origin onto p3d */
5761
5762 if (p3d == NULL) { /* origin forced because no other primitives */
5763 Cn3d_LayerNow = 0;
5764 SetLayerTop3D(0);
5765 Cn3d_ColorPass = FALSE;
5766 }
5767
5768 pdnmsThis = GetSelectedModelstruc();
5769 if (!pdnmsThis)
5770 return NULL;
5771 pmsdThis = (PMSD) pdnmsThis->data.ptrvalue;
5772 DDV_SetColorInCell(&iColor, Cn3d_PaletteRGB[C_white]);
5773 if (Cn3d_ColorPass) {
5774 DDV_RequestColor(&Cn3D_ColorData.pDDVColorGlobal->Palette, &iColor);
5775 return NULL;
5776 }
5777
5778
5779 for (i = 0; i < 3; i++) {
5780 fFrom[i] = 0.0;
5781 fTo[i] = 0.0;
5782 }
5783 for (i = 0; i < 3; i++) {
5784 fFrom[i] = 5.0;
5785 fTo[i] = -5.0;
5786 /*
5787 RotTransScale(pmsdThis, fFrom[0],
5788 fFrom[1], fFrom[2], &iXFrom, &iYFrom, &iZFrom);
5789 RotTransScale(pmsdThis, fTo[0],
5790 fTo[1], fTo[2], &iXTo, &iYTo, &iZTo);
5791 */
5792 AddLine3D(p3d, NULL, (BigScalar) 0, Cn3d_LayerNow,
5793 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->Palette,
5794 &iColor), iXFrom, iYFrom, iZFrom, iXTo,
5795 iYTo, iZTo);
5796 AddText3D(p3d, NULL, (BigScalar) 0, Cn3d_LayerNow,
5797 DDV_ColorIndex(Cn3D_ColorData.pDDVColorGlobal->Palette,
5798 &iColor), pclabel[i], iXFrom, iYFrom,
5799 iZFrom, (Uint4) (4 * VIEWSCALE / 2), 0, 0);
5800 fFrom[i] = 0.0;
5801 fTo[i] = 0.0;
5802 }
5803
5804 return p3d;
5805 }
5806
5807 #endif /* ndef _OPENGL */
5808
5809