viewmol-2.4.1/ 0040755 0002727 0002727 00000000000 10145666545 011362 5 ustar jrh jrh viewmol-2.4.1/source/ 0040755 0002727 0002727 00000000000 10145666463 012661 5 ustar jrh jrh viewmol-2.4.1/source/Makefile 0100644 0002727 0002727 00000032023 10114362246 014302 0 ustar jrh jrh #*******************************************************************************
# *
# Viewmol *
# *
# M A K E F I L E *
# *
# Copyright (c) Joerg-R. Hill, October 2003 *
# *
#*******************************************************************************
#
# $Id: Makefile,v 1.6 2003/11/07 12:53:50 jrh Exp $
# $Log: Makefile,v $
# Revision 1.6 2003/11/07 12:53:50 jrh
# Release 2.4
#
# Revision 1.5 2000/12/10 15:36:51 jrh
# Release 2.3
#
# Revision 1.4 1999/05/24 01:24:15 jrh
# Release 2.2.1
#
# Revision 1.3 1999/02/07 21:42:47 jrh
# Release 2.2
#
# Revision 1.1 1996/12/10 18:39:05 jrh
# Initial revision
#
# Do not edit this file - to set machine specific options edit getmachine!
#
BAGGER =
CC = $(COMPILER) -c $(CFLAGS) -I$(INCLUDE) $(OPT) $(BAGGER)
CCNOP = $(COMPILER) -c $(CFLAGS) -I$(INCLUDE) $(BAGGER)
OBJ = annotate.o atommodule.o balanceform.o basisform.o bondform.o \
bondorder.o build.o calcmo.o cellform.o coledit.o confform.o \
cylinder.o device.o distort.o draw.o drawel.o drawform.o drawop.o \
drawsp.o elementmodule.o ellipse.o energylevelmodule.o feedback.o \
fileselect.o getmem.o getrc.o hardcopy.o historymodule.o hpgl.o \
inert.o infoform.o init.o input.o insint.o intern.o labelmodule.o \
lightmodule.o makemenu.o maketics.o manual.o marcub.o matrix.o \
messgb.o miller.o mkconn.o mkunitc.o mo.o modifygeo.o moform.o \
moleculemodule.o mouseaction.o mousecb.o normod.o optiform.o \
osname.o postscript.o printform.o pseform.o quaternion.o ray.o \
raytrace.o readgrid.o redraw.o resource.o runprog.o runscript.o \
save.o saveform.o shadow.o specform.o spectrummodule.o TabBook.o \
thermo.o thermoform.o viewmol.o viewmolmodule.o waveform.o \
window.o xfont.o zoom.o $(SCANDIR)
ALLOBJ = $(OBJ) tm.o bio.o readgamess.o readgauss.o readmopac.o readpdb.o \
readframe.o eof.o scandir.o
all : viewmol tm bio readgamess readgauss readmopac readpdb translations;
annotate.o : ../annotate.c ../viewmol.h ; $(CC) ../annotate.c
atommodule.o : ../atommodule.c ../viewmol.h ../modules.h ; $(CC) ../atommodule.c
balanceform.o : ../balanceform.c ../viewmol.h ; $(CC) ../balanceform.c
basisform.o : ../basisform.c ../viewmol.h ; $(CC) ../basisform.c
bio.o : ../bio.c ; $(CCNOP) ../bio.c
bondform.o : ../bondform.c ../viewmol.h ; $(CC) ../bondform.c
bondorder.o : ../bondorder.c ../viewmol.h ; $(CC) ../bondorder.c
build.o : ../build.c ../viewmol.h ../isotopes.h ; $(CC) ../build.c
calcmo.o : ../calcmo.c ../viewmol.h ; $(CC) ../calcmo.c
cellform.o : ../cellform.c ../viewmol.h ../dialog.h ; $(CC) ../cellform.c
coledit.o : ../coledit.c ../viewmol.h ../dialog.h ; $(CC) ../coledit.c
confform.o : ../confform.c ../viewmol.h ../dialog.h ; $(CC) ../confform.c
cylinder.o : ../cylinder.c ; $(CC) ../cylinder.c
device.o : ../device.c ; $(CC) ../device.c
distort.o : ../distort.c ../viewmol.h ; $(CC) ../distort.c
draw.o : ../draw.c ../viewmol.h ; $(CC) ../draw.c
drawel.o : ../drawel.c ../viewmol.h ; $(CC) ../drawel.c
drawform.o : ../drawform.c ../viewmol.h ; $(CC) ../drawform.c
drawop.o : ../drawop.c ../viewmol.h ; $(CC) ../drawop.c
drawsp.o : ../drawsp.c ../viewmol.h ; $(CC) ../drawsp.c
elementmodule.o : ../elementmodule.c ../viewmol.h ../modules.h ; $(CC) ../elementmodule.c
ellipse.o : ../ellipse.c ; $(CC) ../ellipse.c
energylevelmodule.o : ../energylevelmodule.c ../viewmol.h ../modules.h ; $(CC) ../energylevelmodule.c
eof.o : ../eof.c ; $(CC) ../eof.c
feedback.o : ../feedback.c ../viewmol.h ; $(CC) ../feedback.c
fileselect.o : ../fileselect.c ; $(CC) ../fileselect.c
getmem.o : ../getmem.c ; $(CC) ../getmem.c
getrc.o : ../getrc.c ../viewmol.h ../isotopes.h ; $(CC) ../getrc.c
hardcopy.o : ../hardcopy.c ; $(CC) ../hardcopy.c
historymodule.o : ../historymodule.c ../viewmol.h ../modules.h ; $(CC) ../historymodule.c
hpgl.o : ../hpgl.c ; $(CC) ../hpgl.c
inert.o : ../inert.c ../viewmol.h ; $(CC) ../inert.c
infoform.o : ../infoform.c ../dialog.h ; $(CC) ../infoform.c
init.o : ../init.c ../viewmol.h ../menudef.h ; $(CC) -DINIT ../init.c
input.o : ../input.c ../viewmol.h ; $(CC) ../input.c
insint.o : ../insint.c ../viewmol.h ; $(CC) ../insint.c
intern.o : ../intern.c ../viewmol.h ; $(CC) ../intern.c
labelmodule.o : ../labelmodule.c ../viewmol.h ../modules.h ; $(CC) ../labelmodule.c
lightmodule.o : ../lightmodule.c ../viewmol.h ../modules.h ; $(CC) ../lightmodule.c
makemenu.o : ../makemenu.c ; $(CC) ../makemenu.c
maketics.o : ../maketics.c ; $(CC) ../maketics.c
manual.o : ../manual.c ../viewmol.h ; $(CC) ../manual.c
marcub.o : ../marcub.c ../marcub.h ; $(CC) ../marcub.c
matrix.o : ../matrix.c ; $(CC) ../matrix.c
messgb.o : ../messgb.c ../messgb.h ; $(CC) ../messgb.c
miller.o : ../miller.c ../viewmol.h ; $(CC) ../miller.c
mkconn.o : ../mkconn.c ../viewmol.h ; $(CC) ../mkconn.c
mkunitc.o : ../mkunitc.c ../viewmol.h ; $(CC) ../mkunitc.c
mo.o : ../mo.c ../viewmol.h ; $(CC) ../mo.c
modifygeo.o : ../modifygeo.c ../viewmol.h ; $(CC) ../modifygeo.c
moform.o : ../moform.c ../viewmol.h ; $(CC) ../moform.c
moleculemodule.o : ../moleculemodule.c ../viewmol.h ../modules.h ; $(CC) ../moleculemodule.c
mouseaction.o : ../mouseaction.c ../viewmol.h ; $(CC) ../mouseaction.c
mousecb.o : ../mousecb.c ../viewmol.h ; $(CC) ../mousecb.c
normod.o : ../normod.c ../viewmol.h ; $(CC) ../normod.c
optiform.o : ../optiform.c ../viewmol.h ; $(CC) ../optiform.c
osname.o : ../osname.c ; $(CC) ../osname.c
postscript.o : ../postscript.c ../viewmol.h ; $(CC) ../postscript.c
printform.o : ../printform.c ../viewmol.h ../menu.h ; $(CC) ../printform.c
pseform.o : ../pseform.c ../viewmol.h ; $(CC) ../pseform.c
quaternion.o : ../quaternion.c ; $(CC) ../quaternion.c
ray.o : ../ray.c ../viewmol.h ; $(CC) ../ray.c
raytrace.o : ../raytrace.c ../viewmol.h ; $(CC) ../raytrace.c
readframe.o : ../readframe.c ; $(CC) ../readframe.c
readgrid.o : ../readgrid.c ../viewmol.h ; $(CC) ../readgrid.c
readgamess.o : ../readgamess.c ; $(CC) ../readgamess.c
readgauss.o : ../readgauss.c ../isotopes.h ; $(CC) ../readgauss.c
readmopac.o : ../readmopac.c ; $(CC) ../readmopac.c
readpdb.o : ../readpdb.c ; $(CC) ../readpdb.c
redraw.o : ../redraw.c ../viewmol.h ; $(CC) ../redraw.c
resource.o : ../resource.c ; $(CC) ../resource.c
runprog.o : ../runprog.c ; $(CC) ../runprog.c
runscript.o : ../runscript.c ../viewmol.h ../dialog.h ; $(CC) ../runscript.c
save.o : ../save.c ../viewmol.h ; $(CC) ../save.c
saveform.o : ../saveform.c ../viewmol.h ; $(CC) ../saveform.c
scandir.o : ../scandir.c ; $(CC) ../scandir.c
shadow.o : ../shadow.c ../viewmol.h ; $(CC) ../shadow.c
specform.o : ../specform.c ; $(CC) ../specform.c
spectrummodule.o : ../spectrummodule.c ../viewmol.h ../modules.h ; $(CC) ../spectrummodule.c
TabBook.o : ../TabBook.c ; $(CC) -DMOTIF ../TabBook.c
thermo.o : ../thermo.c ../viewmol.h ; $(CC) ../thermo.c
thermoform.o : ../thermoform.c ../viewmol.h ; $(CC) ../thermoform.c
tm.o : ../tm.c ; $(CC) ../tm.c
viewmol.o : ../viewmol.c ../viewmol.h ../fallbacks.h ; $(CC) ../viewmol.c
viewmolmodule.o : ../viewmolmodule.c ; $(CC) ../viewmolmodule.c
waveform.o : ../waveform.c ../viewmol.h ; $(CC) ../waveform.c
window.o : ../window.c ../viewmol.h ; $(CC) ../window.c
xdnd.o : ../xdnd.c ../xdnd.h ; $(CC) ../xdnd.c
xfont.o : ../xfont.c ; $(CC) ../xfont.c
zoom.o : ../zoom.c ../viewmol.h ; $(CC) ../zoom.c
viewmol : ; /bin/sh getmachine viewmol
viewmol_: $(OBJ) ; $(COMPILER) -o viewmol $(BAGGER) $(LDFLAGS) $(OBJ) $(LIBRARY) $(LIBS)
tm : ; /bin/sh getmachine tm
tm_ : tm.o readframe.o getmem.o ; $(COMPILER) -o tm $(LDFLAGS) tm.o readframe.o getmem.o -lm
bio : ; /bin/sh getmachine bio
bio_ : bio.o readframe.o getmem.o ; $(COMPILER) -o bio $(LDFLAGS) bio.o readframe.o getmem.o
readgamess: ; /bin/sh getmachine readgamess
readgamess_: readgamess.o eof.o getmem.o ; $(COMPILER) -o readgamess $(LDFLAGS) readgamess.o eof.o getmem.o -lm
readgauss: ; /bin/sh getmachine readgauss
readgauss_: readgauss.o eof.o getmem.o ; $(COMPILER) -o readgauss $(LDFLAGS) readgauss.o eof.o getmem.o
readmopac: ; /bin/sh getmachine readmopac
readmopac_: readmopac.o eof.o getmem.o ; $(COMPILER) -o readmopac $(LDFLAGS) readmopac.o eof.o getmem.o
readpdb: ; /bin/sh getmachine readpdb
readpdb_: readpdb.o eof.o ; $(COMPILER) -o readpdb $(LDFLAGS) readpdb.o eof.o
translations: ; /bin/sh makeTranslations
htmldoc: ; cd ../doc; latex2html -address "Jörg-Rüdiger Hill `date`" -white -no_navigation -html_version "4.0,unicode" -t Viewmol -noinfo viewmol.tex
tar : ; tar -cvf viewmol.tar `echo $(ALLOBJ) | sed "s/\.o/\.c/g"` \
Makefile *.h readgulp readdmol* readmol readpqs writecar writemol \
writetm writegauss.py viewmolrc getmachine checkres README* \
bugs scripts locale makeTranslations `find doc -type f -print | grep -v RCS` ; \
gzip -9 viewmol.tar; mv viewmol.tar.gz viewmol.tgz
distribution: ; tar -cvzf viewmol.tgz `echo $(ALLOBJ) | sed "s/\.o/\.c/g"` \
Makefile *.h readgulp readdmol* readmol readpqs writecar writemol \
writetm writegauss.py viewmolrc getmachine Xdefaults.* \
doc/html doc/viewmol.pdf doc/viewmol.html
snapshot: ; tar -cvf viewmol-`date +'%Y%m%d'`.tar `echo $(ALLOBJ) | sed "s/\.o/\.c/g"` \
Makefile *.h readgulp readdmol readdmol.awk readmol readpqs writecar \
writemol writetm writegauss.py viewmolrc getmachine locale; \
gzip -9 viewmol-`date +'%Y%m%d'`.tar; \
mv viewmol-`date +'%Y%m%d'`.tar.gz viewmol-`date +'%Y%m%d'`.tgz; \
cd web; ./updateWeb
clean : ; /bin/sh getmachine clean
clean_ : ; rm -f $(ALLOBJ) *.il
viewmol-2.4.1/source/TabBook.c 0100644 0002727 0002727 00000104004 07752700021 014327 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* T A B B O O K . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: TabBook.c,v 1.2 2003/11/07 11:20:49 jrh Exp $
* $Log: TabBook.c,v $
* Revision 1.2 2003/11/07 11:20:49 jrh
* Release 2.4
*
* Revision 1.1 2000/12/10 15:40:30 jrh
* Initial revision
*
*/
/*
TabBook.h - TabBook widget (Like Motif Notebook)
See TabBook documentation
Copyright 1996 COMPUTER GENERATION, INC.,
The software is provided "as is", without warranty of any kind, express
or implied, including but not limited to the warranties of
merchantability, fitness for a particular purpose and noninfringement.
In no event shall Computer Generation, inc. nor the author be liable for
any claim, damages or other liability, whether in an action of contract,
tort or otherwise, arising from, out of or in connection with the
software or the use or other dealings in the software.
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation.
Author:
Gary Aviv
Computer Generation, Inc.,
gary@compgen.com
*/
/*
;+
TabBook.c - TabBook widget (Like Motif Notebook)
MODULE NAME: $RCSfile: TabBook.c,v $
AUTHOR: $Author: jrh $
FUNCTIONS: Boolean XcgTabBookSetActivePage(Widget w, int page, int option );
int XcgTabBookGetActivePage(Widget w );
Widget XcgTabBookGetActivePageWidget(Widget w);
USAGE: See Actual Functions For Description
;-
*/
/* Revision History:
$Log: TabBook.c,v $
Revision 1.2 2003/11/07 11:20:49 jrh
Release 2.4
Revision 1.1 2000/12/10 15:40:30 jrh
Initial revision
Revision 1.3 1997/05/30 12:28:24 gary
Guard against realizing with no children
Revision 1.2 1997/04/25 16:40:04 gary
Chenged default of XcgNanchorChild from XcgANCHOR_NORTHWEST to XcgANCHOR_NORTH
Revision 1.1 1997/04/10 18:16:25 jeff
Initial revision
$log
Guard against realizing with no children
$log
*/
#define VERSION "$Revision: 1.2 $"
#include
#include
#include
#include
#include
#ifdef MOTIF
#include
#include
#include
#include
#else
#include
#include
#endif
/*
#include
#include
#include
*/
#include "TabBookP.h"
/* debugging */
#define TRACE_ON(a) fprintf a
#define TRACE_OFF(a)
#define CheckWidgetClass(routine) \
if (XtClass(w) != xcgTabBookWidgetClass) \
wrong_widget(routine)
/* Private Definitions */
static void ResizeAllManagers( TabBookWidget cw );
static void FrameInsideArea(TabBookWidget cw, Boolean erase);
static void draw_tab_bottom(TabBookWidget cw , Widget child, Boolean active);
static void draw_tab_for_button(TabBookWidget cw , Widget child);
static void create_GC(TabBookWidget cw );
static void InsertChild(Widget w);
static void ExposeMeth(Widget w, XEvent *event, Region region );
static void ClassInitialize(), ClassPartInitialize(), Initialize();
static void Resize(Widget w);
static Boolean ConstraintSetValues(Widget current, Widget request, Widget new,
ArgList args,Cardinal *num_args);
static Boolean SetValues(Widget current, Widget request, Widget new,
ArgList args,Cardinal *num_args);
static XtGeometryResult GeometryManager(Widget w,XtWidgetGeometry *request,
XtWidgetGeometry *reply);
XtGeometryResult TabBookPreferredGeometry(Widget widget,
XtWidgetGeometry *request, XtWidgetGeometry *reply);
static void ChangeManaged(Widget w);
/*static void Realize(Widget w, XtValueMask * valueMask,
XSetWindowAttributes * attributes ); */
static void DoLayout(TabBookWidget cw);
static void unmanage_all_Pages(TabBookWidget cw );
static void activate_cb(Widget w, XtPointer fieldp ,XtPointer cb_data);
static Widget find_nth_button(TabBookWidget cw , int page);
static void wrong_widget(char * routine);
#define offset(field) XtOffsetOf(TabBookRec, field)
static XtResource resources[] =
{
{XcgNautoManage, XcgCAutoManage, XtRBoolean , sizeof(Boolean),
offset(tabBook.auto_manage), XtRImmediate, (XtPointer) True},
{XcgNactivePage, XcgCActivePage, XtRInt , sizeof(int),
offset(tabBook.active_page), XtRImmediate, (XtPointer) 1},
{ XcgNnewPageCallback, XcgCNewPageCallback, XmRCallback,sizeof(XtCallbackList),
offset(tabBook.newPageCallback), XmRCallback, NULL },
};
#undef offset
#define offset(field) XtOffsetOf(TabBookConstraintRec, field)
static XtResource constraint_resources[] =
{
{XcgNresizeChild, XcgCResizeChild, XtRInt , sizeof(int),
offset(tabBook.resize_child), XtRImmediate, (XtPointer) XcgRESIZE_NONE},
{XcgNanchorChild, XcgCAnchorChild, XtRInt , sizeof(int),
offset(tabBook.anchor_child), XtRImmediate, (XtPointer) XcgANCHOR_NORTH},
};
#undef offset
TabBookClassRec tabBookClassRec = {
{ /* core_class fields */
#ifdef MOTIF
/* superclass */ (WidgetClass) &xmBulletinBoardClassRec,
#else
(WidgetClass) &constraintClassRec,
#endif
/* class_name */ "TabBook",
/* widget_size */ sizeof(TabBookRec),
/* class_initialize */ ClassInitialize,
/* class_part_init */ ClassPartInitialize,
/* class_inited */ FALSE,
/* initialize */ Initialize,
/* initialize_hook */ NULL,
/* realize */ XtInheritRealize, /* Realize, */
/* actions */ NULL,
/* num_actions */ 0,
/* resources */ (XtResourceList)resources,
/* num_resources */ (Cardinal)XtNumber(resources),
/* xrm_class */ NULLQUARK,
/* compress_motion */ TRUE,
/* compress_exposure */ TRUE,
/* compress_enterleave*/ TRUE,
/* visible_interest */ FALSE,
/* destroy */ NULL,
/* resize */ Resize,
/* expose */ ExposeMeth,
/* set_values */ SetValues,
/* set_values_hook */ NULL,
/* set_values_almost */ XtInheritSetValuesAlmost,
/* get_values_hook */ NULL,
/* accept_focus */ NULL,
/* version */ XtVersion,
/* callback_private */ NULL,
/* tm_table */ NULL,
/* query_geometry */ TabBookPreferredGeometry,
/* display_accelerator*/ XtInheritDisplayAccelerator,
/* extension */ NULL
},
{ /* composite_class fields */
/* geometry_manager */ GeometryManager,
/* change_managed */ ChangeManaged,
/* insert_child */ InsertChild, /* XtInheritInsertChild,*/
/* delete_child */ XtInheritDeleteChild,
/* extension */ NULL
},
{ /* constraint_class fields */
/* subresourses */ (XtResourceList)constraint_resources,
/* subresource_count */ (Cardinal)XtNumber(constraint_resources),
/* constraint_size */ sizeof(TabBookConstraintRec),
/* initialize */ NULL, /*ConstraintInitialize,*/
/* destroy */ NULL,
/* set_values */ ConstraintSetValues,
/* extension */ NULL
},
#ifdef MOTIF
{ /*** xmManager-Class ***/
/* translations */ XtInheritTranslations,
/* syn_resources */ NULL,
/* num_syn_resources */ 0,
/* syn_constraint_resources */ NULL,
/* num_syn_constraint_resources */ 0,
/* parent_process */ XmInheritParentProcess,
/* extension */ NULL
},
{ /* Bulletin Board */
/* always_install_accelerators */ False,
/* geo_matrix_create */ XmInheritGeoMatrixCreate, /*NULL,*/
/* focus_moved_proc */ XmInheritFocusMovedProc,
/* extension */ NULL
},
#endif
{ /* TabBook_class fields */
/* dummy */ 0
}
};
WidgetClass xcgTabBookWidgetClass = (WidgetClass)&tabBookClassRec;
/****************************************************************
*
* Private Procedures
*
****************************************************************/
static void ClassInitialize()
{
}
static void ClassPartInitialize(class)
WidgetClass class;
{
}
/* ARGSUSED */
static void Initialize(Widget request, Widget new, ArgList args, Cardinal num_args)
{
TabBookWidget cw = (TabBookWidget)new;
Pixel select_color ;
cw->tabBook.managed_before = False;
cw->tabBook.old_active_page = 0;
cw->tabBook.total_managers = 0;
cw->tabBook.total_buttons = 0;
cw->tabBook.cur_height = 0;
cw->tabBook.cur_width = 0;
cw->tabBook.layout_completed = False;
cw->tabBook.active_manager = NULL;
cw->tabBook.active_tab = NULL;
cw->tabBook. y_margin = 2; /* reserved margin around each pushbutton ... */
cw->tabBook. x_margin = 2; /* Used to draw Tab around it */
cw->tabBook. x_spacing = 2; /* x space between each button */
cw->tabBook. x_angle = 4; /* space on the right to draw andled line */
cw->tabBook.border = cw->tabBook.x_margin + 2 ; /* border around TabBook inside area */
cw->tabBook.clip = NULL;
/* compute all the colors we will need */
cw->tabBook.drawBackground_color = cw->core.background_pixel;
XmGetColors(XtScreen(cw), cw->core.colormap,
cw->tabBook.drawBackground_color,
&cw->tabBook.drawForeground_color,
&cw->tabBook.top_shadow_color,
&cw->tabBook.bot_shadow_color,
&select_color );
create_GC(cw );
/* create the clip window in which all manager children will be
re-parented */
cw->tabBook.clip = XtVaCreateManagedWidget("TabBookClip",
xmBulletinBoardWidgetClass, new,
XmNmarginHeight,0, XmNmarginWidth,0, NULL);
}
/*
Creates the various graphic contexts we will need
*/
static void create_GC(TabBookWidget cw )
{
XtGCMask valuemask;
XGCValues myXGCV;
valuemask = GCForeground | GCBackground | GCLineWidth | GCFillStyle ;
myXGCV.foreground = cw->tabBook.drawForeground_color;
myXGCV.background = cw->tabBook.drawBackground_color;
myXGCV.fill_style = FillSolid;
myXGCV.line_width = cw->tabBook.x_margin ;
/* | GCJoinStyle ;
myXGCV.join_style = JoinRound; */
if (cw->tabBook.drawForeground_GC )
XtReleaseGC((Widget) cw, cw->tabBook.drawForeground_GC );
cw->tabBook.drawForeground_GC = XtGetGC((Widget)cw, valuemask, &myXGCV);
myXGCV.foreground = cw->tabBook.drawBackground_color;
if (cw->tabBook.drawBackground_GC )
XtReleaseGC((Widget) cw, cw->tabBook.drawBackground_GC );
cw->tabBook.drawBackground_GC = XtGetGC((Widget)cw, valuemask, &myXGCV);
myXGCV.foreground = cw->tabBook.bot_shadow_color;
if (cw->tabBook.bot_shadow_GC )
XtReleaseGC((Widget) cw, cw->tabBook.bot_shadow_GC );
cw->tabBook.bot_shadow_GC = XtGetGC((Widget)cw, valuemask, &myXGCV);
myXGCV.foreground = cw->tabBook.top_shadow_color;
if (cw->tabBook.top_shadow_GC )
XtReleaseGC((Widget) cw, cw->tabBook.top_shadow_GC );
cw->tabBook.top_shadow_GC = XtGetGC((Widget)cw, valuemask, &myXGCV);
}
static void Resize(Widget w)
{
TabBookWidget cw = (TabBookWidget)w;
/* Position x, y;
Dimension width, height; */
Boolean bigger;
TRACE_OFF((stderr,"Resize Old=%dx%d New=%dx%d \n",cw->tabBook.cur_width,cw->tabBook.cur_height,cw->core.width,cw->core.height ));
if (cw->tabBook.cur_height )
FrameInsideArea(cw, True ); /* erase old frame */
if (cw->core.height <= cw->tabBook.cur_height
&& cw->core.width <= cw->tabBook.cur_width )
bigger = False;
else
bigger = True;
cw->tabBook.cur_height = cw->core.height;
cw->tabBook.cur_width = cw->core.width;
/* new frame will be drawn when expose is next called unless it
got smaller */
if (bigger == False)
FrameInsideArea(cw, False); /* redraw new frame */
/* now resize all manager children */
ResizeAllManagers( cw );
}
/*
Resize all managers to fit (or to enlarge out) in the TabBook
inside area
*/
static void ResizeAllManagers( TabBookWidget cw )
{
XmBulletinBoardRec * clip = (XmBulletinBoardRec *) cw->tabBook.clip;
WidgetList widget_list = clip->composite.children;
Cardinal num_children = clip->composite.num_children;
Cardinal n = 0;
Dimension border = 2 * cw->tabBook.border;
Dimension inside_width = cw->tabBook.cur_width - border;
Dimension inside_height = cw->tabBook.cur_height -
cw->tabBook.button_bot - border;
XtResizeWidget(cw->tabBook.clip, inside_width,
inside_height ,
clip->core.border_width) ;
XtMoveWidget(cw->tabBook.clip, cw->tabBook.border ,
cw->tabBook.button_bot + cw->tabBook.border);
#define _TOP 0
#define _BOTTOM (inside_height - child->core.height)
#define _RIGHT (inside_width - child->core.width)
#define _LEFT 0
#define _CENTER_VERT (inside_height - child->core.height)/2
#define _CENTER_HORIZ (inside_width - child->core.width)/2
for (n=0; n < num_children; n++)
{
Widget child = widget_list[n];
if ( XtIsSubclass(child, xmManagerWidgetClass ) )
{
TabBookConstraints cw_c = (TabBookConstraints)
child->core.constraints;
switch (cw_c->tabBook.resize_child)
{
case XcgRESIZE_NONE:
break;
case XcgRESIZE_BOTH:
XtResizeWidget(child, inside_width,inside_height,
child->core.border_width) ;
break;
case XcgRESIZE_HORIZONTAL:
XtResizeWidget(child, inside_width,
child->core.height,
child->core.border_width) ;
break;
case XcgRESIZE_VERTICAL:
XtResizeWidget(child, child->core.width,
inside_height,
child->core.border_width) ;
break;
}
switch (cw_c->tabBook.anchor_child)
{
case XcgANCHOR_CENTER:
XtMoveWidget(child, _CENTER_HORIZ, _CENTER_VERT);
break;
case XcgANCHOR_NORTH:
XtMoveWidget(child, _CENTER_HORIZ, _TOP);
break;
case XcgANCHOR_EAST:
XtMoveWidget(child, _RIGHT, _CENTER_VERT);
break;
case XcgANCHOR_SOUTH:
XtMoveWidget(child, _CENTER_HORIZ, _BOTTOM);
break;
case XcgANCHOR_WEST:
XtMoveWidget(child, _LEFT, _CENTER_VERT);
break;
case XcgANCHOR_NORTHEAST:
XtMoveWidget(child, _RIGHT, _TOP);
break;
case XcgANCHOR_NORTHWEST:
XtMoveWidget(child, _LEFT, _TOP);
break;
case XcgANCHOR_SOUTHEAST:
XtMoveWidget(child, _RIGHT,_BOTTOM);
break;
case XcgANCHOR_SOUTHWEST:
XtMoveWidget(child, _LEFT,_BOTTOM);
break;
}
}
}
}
static XtGeometryResult GeometryManager(Widget w,XtWidgetGeometry *request,
XtWidgetGeometry *reply)
{
TabBookWidget cw = (TabBookWidget) XtParent(w);
TRACE_OFF((stderr,"GeometryManager request=%dx%d\n",
request->width, request->height ));
/* only honor changes in width or height */
if (request->request_mode & ~(CWWidth | CWHeight | XtCWQueryOnly))
return XtGeometryNo;
if (request->request_mode & CWWidth )
reply->width = request->width;
else
reply->width = w->core.width;
if (request->request_mode & CWHeight )
reply->height = request->height;
else
reply->height = w->core.height;
if (reply->height == request->height
&& reply->width == request->width)
return XtGeometryNo;
if (request->request_mode & XtCWQueryOnly)
return XtGeometryYes;
if (XtClass(w) == xmPushButtonWidgetClass )
{
reply->request_mode = CWWidth | CWHeight;
XClearArea(XtDisplay(cw), XtWindow(cw), 0, 0,
cw->tabBook.cur_width, cw->tabBook.button_bot , True);
w->core.width = reply->width;
w->core.height = reply->height;
DoLayout(cw);
}
return(XtGeometryYes);
}
/* ARGSUSED */
static Boolean SetValues(Widget current, Widget request, Widget new,
ArgList args,Cardinal *num_args)
{
TabBookWidget cw_new = (TabBookWidget) new;
TabBookWidget cw_cur = (TabBookWidget) current;
if (cw_new->tabBook.active_page != cw_cur->tabBook.active_page )
{
if (cw_new->tabBook.layout_completed )
{
Widget button = find_nth_button(cw_new, cw_new->tabBook.active_page );
/* emulate user pressing this button */
if (button && XtIsRealized(new))
activate_cb(button, NULL, NULL);
}
}
return FALSE;
}
static Boolean ConstraintSetValues(Widget current, Widget request, Widget new,
ArgList args,Cardinal *num_args)
{
/* TabBookWidget cw_new = (TabBookWidget) new->core.parent ;
TabBookWidget cw_cur = (TabBookWidget) current->core.parent ;
TabBookConstraints cw_c = (TabBookConstraints) new->core.constraints; */
return( FALSE );
}
static void ChangeManaged(Widget w)
{
TabBookWidget cw = (TabBookWidget)w;
TRACE_OFF((stderr,"Change Managed\n"));
DoLayout(cw);
/* first time, unmanage all but active manager */
if (!cw->tabBook.managed_before)
{
if (cw->tabBook.auto_manage )
unmanage_all_Pages(cw); /* Unmanage all pages except active one */
if (cw->tabBook.newPageCallback )
{
XcgTabBookCallbackData rcb_data;
memset(&rcb_data, 0, sizeof(rcb_data));
rcb_data.reason = XcgNewPage; /* reason for callback */
rcb_data.prev_active_page = 0; /* 0 when initially called */
rcb_data.active_page = cw->tabBook.active_page; /* new active page */
XtCallCallbackList((Widget)cw, cw->tabBook.newPageCallback,
(XtPointer) &rcb_data);
}
}
cw->tabBook.managed_before = True;
}
XtGeometryResult TabBookPreferredGeometry(Widget widget,
XtWidgetGeometry *request, XtWidgetGeometry *reply)
{
TabBookWidget cw = (TabBookWidget)widget;
/* Dimension width, height */;
TRACE_OFF((stderr,"Query Geometry\n"));
if (! cw->tabBook.layout_completed)
DoLayout(cw);
request->request_mode &= CWWidth | CWHeight;
reply->request_mode = CWWidth | CWHeight;
reply->width = cw->tabBook.cur_width ;
reply->height = cw->tabBook.cur_height ;
/* called with NULL request */
if (! request->request_mode )
{
if (reply->width != cw->core.width
|| reply->height != cw->core.height)
return XtGeometryNo; /* current and desired size the same */
else
return XtGeometryAlmost; /* this is our desired size */
}
/* called with non-NULL request */
if ( request->width == reply->width &&
request->height == reply->height)
return XtGeometryYes; /* requested change is correct */
if (reply->width != cw->core.width
|| reply->height != cw->core.height)
return XtGeometryNo; /* we want to stay the size we are now */
return XtGeometryAlmost; /* this is our desired size */
}
/*
Layout the children
*/
static void DoLayout(TabBookWidget cw)
{
XmBulletinBoardRec * clip = (XmBulletinBoardRec *) cw->tabBook.clip;
WidgetList widget_list = cw->composite.children;
Cardinal num_children = cw->composite.num_children;
Cardinal n = 0;
XtWidgetGeometry size;
Dimension max_x, max_y, low_button_y ;
XtGeometryResult GResult ;
Dimension width_return, height_return;
int max_button_height = 0;
max_x = max_y = 0;
/* place all the buttons side by side */
for (n=0; n < num_children; n++)
{
Widget child = widget_list[n];
if ( XtClass(child) == xmPushButtonWidgetClass)
{
XtQueryGeometry(child, NULL, &size);
if (max_x) /* all but first button, space from its left neighbor */
max_x += cw->tabBook.x_spacing;
max_x += cw->tabBook.x_margin ;
XtMoveWidget(child, max_x, cw->tabBook.y_margin );
max_x += size.width + cw->tabBook.x_margin + cw->tabBook.x_angle ;
if (max_button_height < size.height)
max_button_height = size.height;
if (max_y < size.height)
max_y = size.height; /* max height */
continue;
}
}
cw->tabBook.button_bot = low_button_y = max_y + cw->tabBook.y_margin ;
low_button_y += cw->tabBook.border; /* allow space for inside border */
/* Set all buttons to the same height, the max height */
for (n=0; n < num_children; n++)
{
Widget child = widget_list[n];
if ( XtClass(child) == xmPushButtonWidgetClass)
{
XtResizeWidget(child, child->core.width,
max_button_height, child->core.border_width) ;
}
}
/* now position all manager ancestors below buttons, all at x=0,
y=low_button_y (plus margin) and expand the TabBook width and
height to accomodate all these managers */
widget_list = clip->composite.children;
num_children = clip->composite.num_children;
for (n=0; n < num_children; n++)
{
Widget child = widget_list[n];
if ( XtIsSubclass(child, xmManagerWidgetClass ) )
{
XtQueryGeometry(child, NULL, &size);
size.height += low_button_y ;
if (max_y < size.height)
max_y = size.height; /* max height */
size.width += cw->tabBook.border;
if (max_x < size.width)
max_x = size.width; /* max width */
}
}
cw->tabBook.cur_width = max_x + cw->tabBook.border ;
cw->tabBook.cur_height = max_y + cw->tabBook.border ; /* space for right border */
cw->tabBook.layout_completed = True;
if (cw->core.height != cw->tabBook.cur_height
|| cw->core.width != cw->tabBook.cur_width)
{
GResult = XtMakeResizeRequest((Widget)cw, cw->tabBook.cur_width, cw->tabBook.cur_height,
&width_return, &height_return);
cw->tabBook.cur_height = cw->core.height;
cw->tabBook.cur_width = cw->core.width;
}
ResizeAllManagers( cw );
}
/*
Use standard method to chain Realize request. Use this opportunity
to position child widgets.
*/
#if 0
static void Realize(Widget w, XtValueMask * valueMask,
XSetWindowAttributes * attributes )
{
/* TabBookWidget new = (TabBookWidget) w; */
TRACE_OFF((stderr,"Realize\n"));
(*(&coreClassRec)->core_class.realize)(w, valueMask, attributes );
}
#endif
/*
Draw (or erase) the shadow around the inside area of the TabBook
*/
static void FrameInsideArea(TabBookWidget cw, Boolean erase)
{
Dimension left_x, top_y, p_width, p_height, thickness;
XPoint points[4];
GC gc1, gc2;
if (!XtIsRealized((Widget)cw))
return;
if (erase)
gc1 = gc2 = cw->tabBook.drawBackground_GC ;
else
{
gc1 = cw->tabBook.top_shadow_GC ;
gc2 = cw->tabBook.bot_shadow_GC ;
}
/* draw shadow around inside area */
thickness = cw->tabBook.x_margin ;
left_x = 0 + thickness/2 ;
top_y = cw->tabBook.button_bot + thickness/2 ;
p_width = cw->tabBook.cur_width ;
p_height = cw->tabBook.cur_height - cw->tabBook.button_bot ;
/* note that lines are drawn centered on their (x,y) pixel. we
want to specify the outside pixel to contain the line so we
have to add in the thickness/2
*/
points[0].x = left_x ;
points[0].y = top_y + p_height; /* lower left */
points[1].x = 0;
points[1].y = - p_height; /* upper left */
points[2].x = p_width - thickness;
points[2].y = 0; /* upper right */
/* draw left and top edges */
XDrawLines(XtDisplay(cw), XtWindow(cw), gc1 ,
points, 3, CoordModePrevious);
points[0].x = left_x + p_width - thickness;
points[0].y = top_y ; /* upper right */
points[1].x = 0;
points[1].y = p_height - thickness; /* lower right*/
points[2].x = - p_width;
points[2].y = 0; /* lower left */
/* draw right and bottom edge */
XDrawLines(XtDisplay(cw), XtWindow(cw), gc2 ,
points, 3, CoordModePrevious);
}
/*
Draw shadows around tab buttons and the inside area
*/
static void draw_frames(TabBookWidget cw )
{
WidgetList widget_list = cw->composite.children;
Cardinal num_children = cw->composite.num_children;
Cardinal n = 0;
/* draw shadow around each button */
for (n=0; n < num_children; n++)
{
Widget child = widget_list[n];
if ( XtClass(child) == xmPushButtonWidgetClass)
{
draw_tab_for_button(cw, child);
}
}
FrameInsideArea(cw, False);
/* activate the current page's tab */
draw_tab_bottom(cw , cw->tabBook.active_tab, True);
}
static void ExposeMeth(Widget w, XEvent *xevent, Region region)
{
TabBookWidget cw = (TabBookWidget) w;
XExposeEvent * event = (XExposeEvent *) xevent;
/* WidgetList widget_list = cw->composite.children;
Cardinal num_children = cw->composite.num_children;
Cardinal n = 0; */
TRACE_OFF((stderr,"Expose %d \n", event->count));
if (!XtIsRealized(w))
return;
if (event->count != 0)
return;
draw_frames(cw);
}
/*
Draw the Tab looking border around the child widget which is a push button
*/
static void draw_tab_for_button(TabBookWidget cw , Widget child)
{
/* XtWidgetGeometry size;*/
Dimension left_x, top_y, p_width, p_height, thickness;
XPoint points[4];
if (!child)
return;
if (!XtIsRealized((Widget)cw))
return;
thickness = cw->tabBook.x_margin ;
left_x = child->core.x - cw->tabBook.x_margin + thickness/2 ;
top_y = child->core.y - cw->tabBook.y_margin + thickness/2 ;
p_width = child->core.width + 2*(cw->tabBook.x_margin) ;
p_height = cw->tabBook.button_bot - child->core.y +1;
/* note that lines are drawn centered on their (x,y) pixel. we
want to specify the outside pixel to contain the line so we
have to add in the thickness/2
*/
points[0].x = left_x ;
points[0].y = top_y + p_height; /* lower left */
points[1].x = 0;
points[1].y = - p_height; /* upper left */
points[2].x = p_width - thickness;
points[2].y = 0; /* upper right */
/* draw left and top edges */
XDrawLines(XtDisplay(cw), XtWindow(cw), cw->tabBook.top_shadow_GC ,
points, 3, CoordModePrevious);
points[0].x = left_x + p_width - thickness;
points[0].y = top_y ; /* upper right */
points[1].x = cw->tabBook.x_angle ;
points[1].y = cw->tabBook.x_angle ; /* angle out */
points[2].x = 0;
points[2].y = p_height - cw->tabBook.x_angle ; /* lower right */
/* draw right edge */
XDrawLines(XtDisplay(cw), XtWindow(cw), cw->tabBook.bot_shadow_GC ,
points, 3, CoordModePrevious);
}
/*
We draw the bottom line of the Tab to either activate or deactivate the
page
*/
static void draw_tab_bottom(TabBookWidget cw , Widget child, Boolean active)
{
/* XtWidgetGeometry size; */
Dimension left_x, top_y, p_width, p_height, thickness;
XPoint points[4];
if (!XtIsRealized((Widget)cw) || child == (Widget) 0)
return;
thickness = cw->tabBook.x_margin ;
left_x = child->core.x - cw->tabBook.x_margin + 1 + thickness/2 ;
top_y = child->core.y - cw->tabBook.y_margin + thickness/2 ;
p_width = child->core.width + 2*(cw->tabBook.x_margin) ;
p_height = cw->tabBook.button_bot - child->core.y + 1 + thickness/2 ;
points[0].x = left_x ;
points[0].y = top_y + p_height; /* lower left */
points[1].x = p_width ;
points[1].y = 0; /* lower right */
XDrawLines(XtDisplay(cw), XtWindow(cw),
active ? cw->tabBook.drawBackground_GC : cw->tabBook.top_shadow_GC ,
points, 2, CoordModePrevious);
}
/*
Return page number (1,2,..) coressponding to this child's
tab page
*/
static int find_page(TabBookWidget cw , Widget tab)
{
int page=1;
WidgetList widget_list = cw->composite.children;
Cardinal num_children = cw->composite.num_children;
Cardinal n = 0;
for (n=0; n < num_children; n++ )
{
Widget child = widget_list[n];
if (tab == child)
return page;
if ( XtClass(child) == xmPushButtonWidgetClass)
page++;
}
return 0; /* error */
}
/*
Return page Widget of n'th manager
*/
static Widget find_nth_manager(TabBookWidget cw , int page)
{
XmBulletinBoardRec * clip = (XmBulletinBoardRec *) cw->tabBook.clip;
WidgetList widget_list = clip->composite.children;
Cardinal num_children = clip->composite.num_children;
Cardinal n = 0;
int page_count ;
for (page_count=0, n=0; n < num_children; n++ )
{
Widget child = widget_list[n];
if ( XtIsSubclass(child, xmManagerWidgetClass ) )
{
page_count++;
if (page == page_count)
return child;
}
}
return NULL; /* error */
}
/*
Return page Widget of n'th button
*/
static Widget find_nth_button(TabBookWidget cw , int page)
{
WidgetList widget_list = cw->composite.children;
Cardinal num_children = cw->composite.num_children;
Cardinal n = 0;
int page_count ;
for (page_count=0, n=0; n < num_children; n++ )
{
Widget child = widget_list[n];
if ( XtClass(child) == xmPushButtonWidgetClass)
{
page_count++;
if (page == page_count)
return child;
}
}
return NULL; /* error */
}
/*
Unmanage all pages except active one
*/
static void unmanage_all_Pages(TabBookWidget cw )
{
XmBulletinBoardRec * clip = (XmBulletinBoardRec *) cw->tabBook.clip;
WidgetList widget_list = clip->composite.children;
Cardinal num_children = clip->composite.num_children;
Cardinal n = 0;
for (n=0; n < num_children; n++ )
{
Widget child = widget_list[n];
if ( XtIsSubclass(child, xmManagerWidgetClass ) )
{
if (cw->tabBook.active_manager == child )
XtManageChild(child);
else
XtUnmanageChild(child);
}
}
}
/*
Tab PushButton callback - activate this tab and deactivate
the formerly activated tab
*/
static void activate_cb(Widget w, XtPointer ctx ,XtPointer cb_data)
{
TabBookWidget cw = (TabBookWidget) XtParent(w);
XcgTabBookCallbackData rcb_data;
XmPushButtonCallbackStruct * but_cb_data =
(XmPushButtonCallbackStruct * ) cb_data;
int option;
if (cw->tabBook.active_tab == w)
return; /* pressed the already active tab button */
if (ctx) /* callback called internally rather from button event */
option = *(int *) ctx;
else
option = 0;
rcb_data.reason = XcgNewPage; /* reason for callback */
if (but_cb_data)
rcb_data.event = but_cb_data->event; /* button event */
else
rcb_data.event = NULL; /* not a real event, emulated */
rcb_data.prev_active_page = cw->tabBook.active_page ; /* 0 when initially called */
rcb_data.active_page = find_page(cw, w); /* new active page */
rcb_data.button = w; /* the button widget which was
pressed (emulated or actual*/
rcb_data.ret_veto = False;
rcb_data.future1 = 0;
rcb_data.future2 = NULL;
/* callback not called if we are here as a result of user
calling XcgTabBookSetActivePage with option set to
XcgTabBook_OPT_NO_CB */
if (cw->tabBook.newPageCallback && !(option & XcgTabBook_OPT_NO_CB) )
XtCallCallbackList((Widget)cw, cw->tabBook.newPageCallback,
(XtPointer) &rcb_data);
if (rcb_data.ret_veto )
return;
draw_tab_bottom(cw , cw->tabBook.active_tab, False);
draw_tab_bottom(cw , w, True);
cw->tabBook.active_tab = w;
cw->tabBook.old_active_page = cw->tabBook.active_page ;
if (cw->tabBook.auto_manage && cw->tabBook.active_manager )
XtUnmanageChild(cw->tabBook.active_manager);
cw->tabBook.active_page = rcb_data.active_page ;
cw->tabBook.active_manager = find_nth_manager(cw, cw->tabBook.active_page );
if (cw->tabBook.auto_manage && cw->tabBook.active_manager )
XtManageChild(cw->tabBook.active_manager);
}
/*
If child is push button, change its resources to meet our needs
*/
static void InsertChild(Widget w)
{
TabBookWidget cw = (TabBookWidget) XtParent(w);
TRACE_OFF((stderr,"Insert Child\n"));
if ( XtClass(w) == xmPushButtonWidgetClass)
{
cw->tabBook.total_buttons ++;
XtVaSetValues(w, XmNfillOnArm, False,
XmNshadowThickness, 0,
NULL);
XtAddCallback(w, XmNactivateCallback,
(XtCallbackProc) activate_cb, NULL);
if (cw->tabBook.active_page == cw->tabBook.total_buttons)
cw->tabBook.active_tab = w;
}
else if ( XtIsSubclass(w, xmManagerWidgetClass ) )
{
if (cw->tabBook.clip == NULL)
/* first child inserted is our own clipping widget */
goto inherit_insert;
cw->tabBook.total_managers ++;
if (cw->tabBook.active_page == cw->tabBook.total_managers)
cw->tabBook.active_manager = w;
w->core.parent = cw->tabBook.clip ; /* reparent */
}
else
{
XtAppError(XtWidgetToApplicationContext((Widget)cw),
"TabBook: Only Buttons and manager widgets may be children of TabBook");
}
inherit_insert:
/* call insert child of superclass, which we know is at least a
composite widget */
(*((CompositeWidgetClass)(tabBookClassRec.core_class.superclass))->
composite_class.insert_child) (w) ;
}
/* a routine to halt execution and force
a core dump for debugging analysis
when a public routine is called with the wrong class of widget
*/
static void wrong_widget(char * routine)
{
int mypid = getpid();
TRACE_OFF((stderr, "Wrong class of widget passed to %s\n", routine));
fflush(stderr);
kill(mypid, SIGABRT);
}
/* ---------------- Widget API ---------------------------- */
/*
;+
XcgTabBookSetActivePage -- The active page is changed
Func: The active page is changed to the passed page number. Page
numbers begin with 1. If this results in a new active page,
the result is as if the user pressed the corresponding tab button.
It is also equivalent to setting the resource
C-Call: Boolean XcgTabBookSetActivePage(Widget w, int page, int option )
Input: w - TabBook widget
page - The new active page number (1,2,...)
option - bitmapped
XcgTabBook_OPT_NO_CB - don't call NewPage callback
Return: True - page has been changed
False - non-existent page number
;-
*/
Boolean XcgTabBookSetActivePage(Widget w, int page, int option )
{
# define ROUTINE "XcgTabBookSetActivePage"
TabBookWidget cw = (TabBookWidget) w;
CheckWidgetClass(ROUTINE); /* make sure we are called with a TabBook widget */
if (cw->tabBook.layout_completed && cw->tabBook.active_page != page )
{
Widget button = find_nth_button(cw, page );
/* emulate user pressing this button */
if (button)
{
activate_cb(button, &option, NULL);
return True;
}
else
return False;
}
cw->tabBook.active_page = page ;
return True;
# undef ROUTINE
}
/*
;+
XcgTabBookGetActivePage -- The active page is returned
Func: The current active page is returned.
C-Call: int XcgTabBookGetActivePage(Widget w)
Input: w - TabBook widget
Return: The current active page number (1,2,...)
A zero means the widget has not been managed at least once
;-
*/
int XcgTabBookGetActivePage(Widget w)
{
# define ROUTINE "XcgTabBookGetActivePage"
TabBookWidget cw = (TabBookWidget) w;
CheckWidgetClass(ROUTINE); /* make sure we are called with a TabBook widget */
return cw->tabBook.active_page ;
# undef ROUTINE
}
/*
;+
XcgTabBookGetActivePageWidget -- The manager widget child of the active page is returned
Func: The manager widget child of the active page is returned.
C-Call: Widget XcgTabBookGetActivePageWidget(Widget w)
Input: w - TabBook widget
Return: The manager Widget representing the active page.
A NULL means the widget has not been managed at least once
;-
*/
Widget XcgTabBookGetActivePageWidget(Widget w)
{
# define ROUTINE "XcgTabBookGetActivePageWidget"
TabBookWidget cw = (TabBookWidget) w;
CheckWidgetClass(ROUTINE); /* make sure we are called with a TabBook widget */
return find_nth_manager(cw, cw->tabBook.active_page );
# undef ROUTINE
}
viewmol-2.4.1/source/TabBook.h 0100644 0002727 0002727 00000010504 07752712707 014353 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* T A B B O O K . H *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: TabBook.h,v 1.2 2003/11/07 12:53:27 jrh Exp $
* $Log: TabBook.h,v $
* Revision 1.2 2003/11/07 12:53:27 jrh
* Release 2.4
*
* Revision 1.1 2000/12/10 15:40:37 jrh
* Initial revision
*
*/
/*
TabBook.h - Public definitions for TabBook widget
See TabBook documentation
Copyright 1996 COMPUTER GENERATION, INC.,
The software is provided "as is", without warranty of any kind, express
or implied, including but not limited to the warranties of
merchantability, fitness for a particular purpose and noninfringement.
In no event shall Computer Generation, inc. nor the author be liable for
any claim, damages or other liability, whether in an action of contract,
tort or otherwise, arising from, out of or in connection with the
software or the use or other dealings in the software.
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation.
Author:
Gary Aviv
Computer Generation, Inc.,
gary@compgen.com
*/
/* Revision History:
$Log: TabBook.h,v $
Revision 1.2 2003/11/07 12:53:27 jrh
Release 2.4
Revision 1.1 2000/12/10 15:40:37 jrh
Initial revision
Revision 1.1 1997/05/01 22:20:51 eric
Initial revision
$log
Initial
$log
*/
#ifndef _XcgTabBook_h
#define _XcgTabBook_h
/***********************************************************************
*
* TabBook Widget
*
***********************************************************************/
/*
New resource names/classes
*/
#define XcgNautoManage "autoManage"
#define XcgCAutoManage "AutoManage"
#define XcgNactivePage "activePage"
#define XcgCActivePage "ActivePage"
#define XcgNnewPageCallback "newPageCallback,"
#define XcgCNewPageCallback "NewPageCallback,"
/*
Constraint resource names/classes
*/
#define XcgNresizeChild "resizeChild"
#define XcgCResizeChild "ResizeChild"
#define XcgRESIZE_NONE 0
#define XcgRESIZE_VERTICAL 1
#define XcgRESIZE_HORIZONTAL 2
#define XcgRESIZE_BOTH (XcgRESIZE_VERTICAL | XcgRESIZE_HORIZONTAL)
#define XcgNanchorChild "anchorChild"
#define XcgCAnchorChild "AnchorChild"
#define XcgANCHOR_CENTER 0
#define XcgANCHOR_EAST 1
#define XcgANCHOR_NORTH 2
#define XcgANCHOR_NORTHEAST 3
#define XcgANCHOR_NORTHWEST 4
#define XcgANCHOR_SOUTH 5
#define XcgANCHOR_SOUTHEAST 6
#define XcgANCHOR_SOUTHWEST 7
#define XcgANCHOR_WEST 8
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
typedef struct _TabBookClassRec *TabBookWidgetClass;
typedef struct _TabBookRec *TabBookWidget;
extern WidgetClass xcgTabBookWidgetClass;
#define XcgTabBook_OPT_NO_CB 1
Boolean XcgTabBookSetActivePage(Widget w, int page, int option );
int XcgTabBookGetActivePage(Widget w );
Widget XcgTabBookGetActivePageWidget(Widget w);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
/*
* Callback reasons. Try to stay out of range of the Motif XmCR_* reasons.
*/
typedef enum _XcgTabBookgReasonType {
XcgNewPage = 202 /* New page is active */
} XcgTabBookReasonType;
/*
** Struct passed to application when called back
*/
typedef struct _XcgTabBookCallbackData
{
XcgTabBookReasonType reason; /* reason for callback */
XEvent *event; /* button event, NULL if emulated */
int prev_active_page; /* 0 when initially called */
int active_page; /* new active page */
Widget button; /* the button widget which was
pressed (emulated or actual*/
Boolean ret_veto; /* caller may set to True to stop page change */
int future1;
void * future2;
} XcgTabBookCallbackData;
#endif /* _XcgTabBook_h */
viewmol-2.4.1/source/TabBookP.h 0100644 0002727 0002727 00000007056 07752712720 014476 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* T A B B O O K P . H *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: TabBookP.h,v 1.2 2003/11/07 12:53:36 jrh Exp $
* $Log: TabBookP.h,v $
* Revision 1.2 2003/11/07 12:53:36 jrh
* Release 2.4
*
* Revision 1.1 2000/12/10 15:40:50 jrh
* Initial revision
*
*/
/* TabBook widget private definitions */
#ifndef _XcgTabBookP_h
#define _XcgTabBookP_h
#include "TabBook.h"
#include
#ifdef MOTIF
#include
# if XmVersion >= 1002 /* If motif version >= 1.2 */
# include
# endif
#include
#include
#endif
#define XtInheritLayout ((Boolean (*)())_XtInherit)
typedef struct {
int dummy;
} TabBookClassPart;
typedef struct _TabBookClassRec {
CoreClassPart core_class;
CompositeClassPart composite_class;
ConstraintClassPart constraint_class;
#ifdef MOTIF
XmManagerClassPart manager_class;
XmBulletinBoardClassPart bulletin_class;
#endif
TabBookClassPart tabBook_class;
} TabBookClassRec;
extern TabBookClassRec tabBookClassRec;
typedef struct _TabBookPart
{
int y_margin ; /* reserved margin around each pushbutton ... */
int x_margin ; /* Used to draw Tab around it */
int x_spacing; /* x space between each button */
int x_angle; /* space on the right to draw andled line */
int border; /* border around entire TabBook */
Dimension button_bot; /* largest button goes this far */
Dimension cur_width;
Dimension cur_height;
Boolean layout_completed; /* layout was done at least once */
Boolean managed_before; /* manged was done at least once */
Boolean auto_manage; /* manager children are automatically mapped when appropriate */
Widget active_tab; /* the current page's tab Button */
Widget active_manager; /* the current page's manager widget */
int active_page; /* 1,2,.. */
int total_buttons;
int total_managers;
int old_active_page; /* 1,2,.. 0 means none, i.e. init */
GC drawBackground_GC ; /* the drawing area background */
Pixel drawBackground_color; /* ... and its color */
GC drawForeground_GC ; /* the drawing area foreground */
Pixel drawForeground_color; /* ... and its color */
GC bot_shadow_GC; /* for drawing lines, bottom shadow */
Pixel bot_shadow_color; /* ... and its color */
GC top_shadow_GC; /* for drawing lines, top shadow */
Pixel top_shadow_color; /* ... and its color */
XtCallbackList newPageCallback;
Widget clip; /* clip the manager children */
} TabBookPart;
typedef struct _TabBookRec {
CorePart core;
CompositePart composite;
ConstraintPart constraint;
#ifdef MOTIF
XmManagerPart manager;
XmBulletinBoardPart bulletin_board;
#endif
TabBookPart tabBook;
} TabBookRec;
typedef struct _TabBookConstraintPart
{
int resize_child; /* constraint resources */
int anchor_child;
} TabBookConstraintPart;
typedef struct _TabBookConstraintRec {
TabBookConstraintPart tabBook;
} TabBookConstraintRec, *TabBookConstraints;
#endif /* _XcgTabBookP_h */
viewmol-2.4.1/source/annotate.c 0100644 0002727 0002727 00000025475 07752675131 014652 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* A N N O T A T E . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: annotate.c,v 1.5 2003/11/07 10:56:25 jrh Exp $
* $Log: annotate.c,v $
* Revision 1.5 2003/11/07 10:56:25 jrh
* Release 2.4
*
* Revision 1.4 2000/12/10 15:01:05 jrh
* Release 2.3
*
* Revision 1.3 1999/05/24 01:24:31 jrh
* Release 2.2.1
*
* Revision 1.2 1999/02/07 21:43:52 jrh
* Release 2.2
*
* Revision 1.1 1998/01/26 00:33:05 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
void modifyAnnotation(int, int, int);
void getAnnotation(Widget, caddr_t, caddr_t);
int makeAnnotation(int, int, float, float, float, int, const GLfloat *, int,
int, char *);
void deleteAnnotation(int *);
void moveAnnotation(int, double, double);
void setAnnotation(Widget, caddr_t, XmDrawingAreaCallbackStruct *);
int TextGetBaseline(Widget);
extern void redraw(int);
extern void pixelToWorld(int, double *, double *);
extern void setCursor(Widget, unsigned int);
extern int StringWidth(XFontStruct *, char *);
extern int StringHeight(XFontStruct *);
extern void *getmem(size_t, size_t);
extern void *expmem(void *, size_t, size_t);
extern void fremem(void **);
extern char *getStringResource(Widget, char *);
extern void getScreenCoordinates(double, double, double, double *, double *,
double *);
extern void modifyGeometry(int, char *);
extern PyLabelSpecObject *label_new(void);
extern struct WINDOW windows[];
extern struct MOLECULE *molecules;
extern struct ANNOTATION *annotation;
extern int nAnnotations, annotate, imol;
extern Pixel stdcol[9];
void modifyAnnotation(int which, int x, int y)
{
XmFontListEntry entry;
XmFontList fontlist;
XmFontType ret;
XFontStruct *font;
Widget text;
Dimension width, height;
Pixel bg;
int l, xs;
char str[MAXLENLINE], def[]="variable";
register char *p;
if ((which != (-1)) || annotate)
{
if ((p=getStringResource(windows[VIEWER].widget, "font")) == NULL) p=def;
entry=XmFontListEntryLoad(XtDisplay(windows[VIEWER].widget), p, XmFONT_IS_FONT, "TAG");
fontlist=XmFontListAppendEntry(NULL, entry);
font=(XFontStruct *)XmFontListEntryGetFont(entry, &ret);
XmFontListEntryFree(&entry);
XtVaGetValues(windows[VIEWER].widget, XtNbackground, &bg, NULL);
text=XtVaCreateWidget("annotation", xmTextWidgetClass, windows[VIEWER].widget,
XmNfontList, fontlist,
XmNshadowThickness, 0,
XmNmarginWidth, 3,
XmNmarginHeight, 0,
XmNcolumns, 10,
XmNresizeWidth, True,
XtNbackground, bg,
NULL);
/* Lesstif does not yet have XmTextGetBaseline implemented */
/* height=XmTextGetBaseline(text); */
height=TextGetBaseline(text);
if (which == (-1)) XtVaSetValues(text, XmNx, x-3, XmNy, y-height-1, NULL);
if (which != (-1))
{
annotation[which].widget=text;
XtVaGetValues(windows[VIEWER].widget, XmNwidth, &width, XmNheight, &height, NULL);
XtVaSetValues(annotation[which].widget, XmNx, (Position)(0.5*(annotation[which].x+1.0)*(double)width),
XmNy, height-(Position)(0.5*(annotation[which].y+1.0)*(double)height+TextGetBaseline(annotation[which].widget)),
NULL);
/* moveAnnotation(which, 2.0*(double)x/(double)width, 2.0*(double)y/(double)height); */
xs=(int)(0.5*(annotation[which].x+1.0)*(double)width);
l=xs;
p=annotation[which].text;
while (*p && (l < x))
{
strncpy(str, annotation[which].text, p-annotation[which].text+1);
str[p-annotation[which].text+1]='\0';
p++;
l=xs+StringWidth(windows[VIEWER].font, str);
}
if (annotation[which].text[0])
{
XtVaSetValues(annotation[which].widget, XmNvalue, annotation[which].text,
XmNcursorPosition, (XmTextPosition)(p-annotation[which].text-1),
XmNcolumns, (int)strlen(annotation[which].text),
NULL);
annotation[which].flags&=~DRAWANN;
}
}
XtManageChild(text);
XtAddCallback(text, XmNactivateCallback, (XtCallbackProc)getAnnotation, (XmAnyCallbackStruct *)which);
XmProcessTraversal(text, XmTRAVERSE_CURRENT);
}
setCursor(windows[VIEWER].widget, XC_top_left_arrow);
annotate=FALSE;
}
void getAnnotation(Widget w, caddr_t which, caddr_t call_data)
{
Dimension h;
Position x, y;
const GLfloat black[4] = {0.0, 0.0, 0.0, 0.0};
double xpix, ypix;
int i, active;
char *text;
active=(int)which;
text=XmTextGetString(w);
if (*text != '\0')
{
XtVaGetValues(w, XmNx, &x, XmNy, &y, NULL);
pixelToWorld(VIEWER, &xpix, &ypix);
/* h=XmTextGetBaseline(w); */
h=TextGetBaseline(w);
if (active == (-1))
{
x+=3;
y+=h;
i=makeAnnotation((-1), COORDINATES, (float)(windows[VIEWER].left+x*xpix),
(float)(windows[VIEWER].top-y*ypix), 0.0,
stdcol[BLACK], black, EDITABLE | MOVEABLE, (-1), text);
}
else
{
if (annotation[active].flags & GEOMETRY)
{
molecules[imol].internals[annotation[active].userdata].type=
(-molecules[imol].internals[annotation[active].userdata].type);
if (strcmp(annotation[active].text, text))
modifyGeometry(annotation[active].userdata, text);
deleteAnnotation(&active);
}
else
{
strcpy(annotation[active].text, text);
annotation[active].flags|=DRAWANN;
}
active=(-1);
}
}
else
deleteAnnotation(&active);
XtFree(text);
XtDestroyWidget(w);
}
int makeAnnotation(int which, int type, float x, float y, float z, int color,
const GLfloat color_rgb[4], int flags, int userdata, char *text)
{
PyLabelSpecObject *newLabel;
Dimension width, height;
double xpix, ypix;
register int i;
if (which == (-1))
{
nAnnotations++;
if (annotation == NULL)
annotation=(struct ANNOTATION *)getmem(1, sizeof(struct ANNOTATION));
else
annotation=(struct ANNOTATION *)expmem((void *)annotation, nAnnotations,
sizeof(struct ANNOTATION));
which=nAnnotations-1;
}
if ((newLabel=label_new()) != NULL)
{
newLabel->labelID=which;
annotation[which].pyObject=newLabel;
}
annotation[which].widget=NULL;
if (text != NULL)
strncpy(annotation[which].text, text, MAXLENLINE-1);
XtVaGetValues(windows[VIEWER].widget, XtNwidth, &width, XtNheight, &height, NULL);
pixelToWorld(VIEWER, &xpix, &ypix);
if (type == CENTERED)
{
i=StringHeight(windows[VIEWER].font);
annotation[which].x=((windows[VIEWER].left+windows[VIEWER].right
-xpix*(double)StringWidth(windows[VIEWER].font,
annotation[which].text)))/((double)width*xpix);
annotation[which].y=2.0*(windows[VIEWER].top-2.*(double)y*ypix*(double)i)/((double)height*ypix);
annotation[which].z=0.0;
}
else
{
/* x and y are in pixels */
annotation[which].x=2.0*x/((double)width*xpix);
annotation[which].y=2.0*y/((double)height*ypix);
annotation[which].z=z;
}
annotation[which].color=color;
annotation[which].color_rgb[0]=color_rgb[0];
annotation[which].color_rgb[1]=color_rgb[1];
annotation[which].color_rgb[2]=color_rgb[2];
annotation[which].color_rgb[3]=color_rgb[3];
annotation[which].flags=flags | DRAWANN;
annotation[which].userdata=userdata;
return(which);
}
void deleteAnnotation(int *which)
{
register int i;
if (*which != (-1))
{
Py_DECREF(annotation[*which].pyObject);
if (annotation[*which].widget)
{
XtDestroyWidget(annotation[*which].widget);
annotation[*which].widget=NULL;
}
}
if (*which > (-1) && *which != nAnnotations-1)
{
for (i=(*which)+1; ilabelID=i-1;
annotation[i-1].widget=annotation[i].widget;
annotation[i-1].x=annotation[i].x;
annotation[i-1].y=annotation[i].y;
annotation[i-1].z=annotation[i].z;
annotation[i-1].color=annotation[i].color;
annotation[i-1].color_rgb[0]=annotation[i].color_rgb[0];
annotation[i-1].color_rgb[1]=annotation[i].color_rgb[1];
annotation[i-1].color_rgb[2]=annotation[i].color_rgb[2];
annotation[i-1].color_rgb[3]=annotation[i].color_rgb[3];
annotation[i-1].flags=annotation[i].flags;
annotation[i-1].userdata=annotation[i].userdata;
strcpy(annotation[i-1].text, annotation[i].text);
}
}
if (*which != (-1))
{
nAnnotations--;
if (nAnnotations)
annotation=(struct ANNOTATION *)expmem((void *)annotation, nAnnotations,
sizeof(struct ANNOTATION));
else
fremem((void *)&annotation);
*which=(-1);
}
}
void scaleAnnotation(float scale)
{
register int i;
for (i=0; iascent+margin+1);
}
viewmol-2.4.1/source/atommodule.c 0100644 0002727 0002727 00000024374 07752675212 015204 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* A T O M M O D U L E . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: atommodule.c,v 1.2 2003/11/07 10:57:14 jrh Exp $
* $Log: atommodule.c,v $
* Revision 1.2 2003/11/07 10:57:14 jrh
* Release 2.4
*
* Revision 1.1 2000/12/10 15:01:16 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include "viewmol.h"
#define PyAtom_API_pointers 1
#define PyAtomSpec_Type_NUM 0
PyAtomSpecObject *atom_new(void);
static PyObject *atom_getElement(PyObject *, PyObject *);
static PyObject *atom_coordinates(PyObject *, PyObject *);
static PyObject *atom_radius(PyObject *, PyObject *);
static PyObject *atom_radiusScaleFactor(PyObject *, PyObject *);
static PyObject *atom_neutronScatteringFactor(PyObject *, PyObject *);
static PyObject *atom_name(PyObject *, PyObject *);
static PyObject *atom_replace(PyObject *, PyObject *);
static PyObject *atom_delete(PyObject *, PyObject *);
static PyObject *atom_getattr(PyAtomSpecObject *, char *);
static void atom_dealloc(PyAtomSpecObject *);
extern PyElementSpecObject *element_new(void);
extern void buildMolecule(struct MOLECULE *, int, int, int);
extern int checkInterrupt(void);
extern void makeINSIntensity(void);
extern struct MOLECULE *molecules;
extern struct ELEMENT *elements;
extern int nmolecule, ne, element;
static char PyAtomSpec_Type__doc__[] =
"Atom specification";
statichere PyTypeObject PyAtomSpec_Type = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"AtomSpec", /*tp_name*/
sizeof(PyAtomSpecObject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)atom_dealloc, /*tp_dealloc*/
0, /*tp_print*/
(getattrfunc)atom_getattr, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
/* Space for future expansion */
0L,0L,
/* Documentation string */
PyAtomSpec_Type__doc__
};
static PyMethodDef atom_methods[] = {
{"getElement", atom_getElement, 1},
{"coordinates", atom_coordinates, 1},
{"radius", atom_radius, 1},
{"radiusScaleFactor", atom_radiusScaleFactor, 1},
{"neutronScatteringFactor", atom_neutronScatteringFactor, 1},
{"name", atom_name, 1},
{"replace", atom_replace, 1},
{"delete", atom_delete, 1},
{NULL, NULL}
};
PyAtomSpecObject *atom_new(void)
{
PyAtomSpecObject *self;
self=PyObject_NEW(PyAtomSpecObject, &PyAtomSpec_Type);
if (self == NULL)
{
PyErr_NoMemory();
return(NULL);
}
self->moleculeID=0;
self->atomID=0;
return(self);
}
static PyObject *atom_getElement(PyObject *self, PyObject *args)
{
PyAtomSpecObject *s;
PyElementSpecObject *element;
int imol, iatom;
register int i;
if (checkInterrupt()) return(NULL);
if (!self)
{
Py_INCREF(Py_None);
return(Py_None);
}
s=(PyAtomSpecObject *)self;
imol=s->moleculeID;
iatom=s->atomID;
element=element_new();
if (element == NULL) return(NULL);
for (i=0; ielementID=i;
return((PyObject *)element);
}
}
for (i=0; ielementID=i;
return((PyObject *)element);
}
}
return(NULL);
}
static PyObject *atom_coordinates(PyObject *self, PyObject *args)
{
PyAtomSpecObject *s;
PyObject *tuple;
int imol, iatom;
double x=1.0e302, y=1.0e302, z=1.0e302;
if (checkInterrupt()) return(NULL);
if (!self)
{
Py_INCREF(Py_None);
return(Py_None);
}
s=(PyAtomSpecObject *)self;
imol=s->moleculeID;
iatom=s->atomID;
if (!PyArg_ParseTuple(args, "|ddd", &x, &y, &z)) return(NULL);
if (x < 1.0e300 && y < 1.0e300 && z < 1.0e300) /* set */
{
molecules[imol].atoms[iatom].x=x;
molecules[imol].atoms[iatom].y=y;
molecules[imol].atoms[iatom].z=z;
}
else
{
if ((tuple=PyTuple_New(4))) /* get */
{
PyTuple_SetItem(tuple, 0, PyFloat_FromDouble(molecules[imol].atoms[iatom].x));
PyTuple_SetItem(tuple, 1, PyFloat_FromDouble(molecules[imol].atoms[iatom].y));
PyTuple_SetItem(tuple, 2, PyFloat_FromDouble(molecules[imol].atoms[iatom].z));
PyTuple_SetItem(tuple, 3, PyString_FromString(molecules[imol].atoms[iatom].name));
return(tuple);
}
}
Py_INCREF(Py_None);
return(Py_None);
}
static PyObject *atom_radius(PyObject *self, PyObject *args)
{
PyAtomSpecObject *s;
double radius=-1.0e0;
int imol, iatom;
if (checkInterrupt()) return(NULL);
if (!self)
{
Py_INCREF(Py_None);
return(Py_None);
}
s=(PyAtomSpecObject *)self;
imol=s->moleculeID;
iatom=s->atomID;
if (!PyArg_ParseTuple(args, "|d", &radius)) return(NULL);
if (radius != -1.0e0) /* set */
{
if (radius >= 0.0)
molecules[imol].atoms[iatom].rad=radius;
else
{
PyErr_SetString(PyExc_ValueError, "Value out of range");
return(NULL);
}
}
else /* get */
return(PyFloat_FromDouble(molecules[imol].atoms[iatom].rad));
Py_INCREF(Py_None);
return(Py_None);
}
static PyObject *atom_radiusScaleFactor(PyObject *self, PyObject *args)
{
PyAtomSpecObject *s;
double radScale=-1.0e0;
int imol, iatom;
if (checkInterrupt()) return(NULL);
if (!self)
{
Py_INCREF(Py_None);
return(Py_None);
}
s=(PyAtomSpecObject *)self;
imol=s->moleculeID;
iatom=s->atomID;
if (!PyArg_ParseTuple(args, "|d", &radScale)) return(NULL);
if (radScale != -1.0e0) /* set */
{
if (radScale >= 0.0)
molecules[imol].atoms[iatom].radScale=radScale;
else
{
PyErr_SetString(PyExc_ValueError, "Value out of range");
return(NULL);
}
}
else /* get */
return(PyFloat_FromDouble(molecules[imol].atoms[iatom].radScale));
Py_INCREF(Py_None);
return(Py_None);
}
static PyObject *atom_neutronScatteringFactor(PyObject *self, PyObject *args)
{
PyAtomSpecObject *s;
double factor=-1.0e0;
int imol, iatom;
if (checkInterrupt()) return(NULL);
if (!self)
{
Py_INCREF(Py_None);
return(Py_None);
}
s=(PyAtomSpecObject *)self;
imol=s->moleculeID;
iatom=s->atomID;
if (!PyArg_ParseTuple(args, "|d", &factor)) return(NULL);
if (factor != -1.0e0) /* set */
{
if (factor >= 0.0)
{
molecules[imol].atoms[iatom].neutronScatterfac=factor;
makeINSIntensity();
}
else
{
PyErr_SetString(PyExc_ValueError, "Value out of range");
return(NULL);
}
}
else /* get */
return(PyFloat_FromDouble(molecules[imol].atoms[iatom].neutronScatterfac));
Py_INCREF(Py_None);
return(Py_None);
}
static PyObject *atom_name(PyObject *self, PyObject *args)
{
PyAtomSpecObject *s;
int imol, iatom;
char *n=NULL, name[MAXLENLINE];
if (checkInterrupt()) return(NULL);
if (!self)
{
Py_INCREF(Py_None);
return(Py_None);
}
s=(PyAtomSpecObject *)self;
imol=s->moleculeID;
iatom=s->atomID;
if (!PyArg_ParseTuple(args, "|s", &n)) return(NULL);
if (n != NULL) /* set */
{
if (strlen(n) > 8)
{
PyErr_SetString(PyExc_ValueError, "Name is too long");
return(NULL);
}
else
strncpy(molecules[imol].atoms[iatom].name, n, 8);
}
else /* get */
{
sprintf(name, "%s%d", molecules[imol].atoms[iatom].name, iatom+1);
return(PyString_FromString(name));
}
Py_INCREF(Py_None);
return(Py_None);
}
static PyObject *atom_replace(PyObject *self, PyObject *args)
{
PyAtomSpecObject *s;
int imol, iatom, i, found;
char *symbol;
if (checkInterrupt()) return(NULL);
if (!self)
{
Py_INCREF(Py_None);
return(Py_None);
}
s=(PyAtomSpecObject *)self;
imol=s->moleculeID;
iatom=s->atomID;
if (!PyArg_ParseTuple(args, "s", &symbol)) return(NULL);
symbol[0]=toupper(symbol[0]);
symbol[1]=tolower(symbol[1]);
found=FALSE;
for (i=0; imoleculeID;
iatom=s->atomID;
buildMolecule(&molecules[imol], iatom, DELETE_ATOM, FALSE);
}
Py_INCREF(Py_None);
return(Py_None);
}
static void atom_dealloc(PyAtomSpecObject *self)
{
if (!self) return;
PyMem_DEL(self);
}
static PyObject *atom_getattr(PyAtomSpecObject *self, char *name)
{
return(Py_FindMethod(atom_methods, (PyObject *)self, name));
}
void initAtomModule(void)
{
PyObject *module, *dict;
static void *PyAtom_API[PyAtom_API_pointers];
PyAtomSpec_Type.ob_type=&PyType_Type;
module=Py_InitModule("atom", atom_methods);
dict=PyModule_GetDict(module);
PyAtom_API[PyAtomSpec_Type_NUM]=(void *)&PyAtomSpec_Type;
PyDict_SetItemString(dict, "_C_API", PyCObject_FromVoidPtr((void *)PyAtom_API, NULL));
}
viewmol-2.4.1/source/balanceform.c 0100644 0002727 0002727 00000020702 07752675227 015304 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* B A L A N C E F O R M . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: balanceform.c,v 1.2 2003/11/07 10:57:27 jrh Exp $
* $Log: balanceform.c,v $
* Revision 1.2 2003/11/07 10:57:27 jrh
* Release 2.4
*
* Revision 1.1 2000/12/10 15:01:29 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
#include "dialog.h"
void balanceExit(Widget, caddr_t, XmPushButtonCallbackStruct *);
void GetInt(Widget, caddr_t, XmPushButtonCallbackStruct *);
int checkReaction(void);
extern void MapBox(Widget, caddr_t, XmToggleButtonCallbackStruct *);
extern Widget CreatePushButtonRow(Widget, struct PushButtonRow *, int);
extern Widget initShell(Widget, char *, Widget *, Widget *);
extern void getSumFormula(struct MOLECULE *, char *, int);
extern XmString makeIndexedString(char *);
extern void *getmem(size_t, size_t);
extern void *expmem(void *, size_t, size_t);
extern void fremem(void **);
extern void ringBell(void);
extern XtAppContext app;
extern struct WINDOW windows[];
extern struct MOLECULE *molecules;
extern Widget topShell;
extern int nmolecule, ne;
static Widget dialog, *stoichioNumber;
static int *balancedReactions=NULL, nmolecule_saved=0, cont;
static char **balancedReactants=NULL, *reactants=NULL;
void balanceDialog(Widget widget, caddr_t dummy, XmAnyCallbackStruct *data)
{
XEvent event;
Widget form, board, form1, label=NULL, sep;
static struct PushButtonRow buttons[] = {
{ "ok", balanceExit, (XtPointer)TRUE, NULL },
{ "cancel", balanceExit, (XtPointer)FALSE, NULL },
};
XmString name;
size_t mnc;
int found;
char formula[MAXLENLINE], last[MAXLENLINE], *p;
register int i, j, k;
/* This function creates the dialog for manually balancing reactions */
if (balancedReactions)
{
mnc=0;
k=0;
for (i=0; i 0)
k++;
}
}
if (nmolecule_saved == k) return;
fremem((void **)&balancedReactions);
fremem((void **)&balancedReactants);
fremem((void **)&reactants);
balancedReactions=(int *)getmem((size_t)nmolecule, sizeof(int));
balancedReactants=(char **)getmem((size_t)nmolecule, sizeof(char *));
reactants=(char *)getmem(mnc, sizeof(char));
}
else
{
mnc=0;
for (i=0; ina; j++)
{
found=FALSE;
for (k=0; katoms[j].element->symbol))
{
found=TRUE;
count[k]+=mol->stoichioNumber;
}
}
if (!found)
{
strcpy(&elements[4*nelem], mol->atoms[j].element->symbol);
count[nelem]=mol->stoichioNumber;
nelem++;
}
}
}
found=TRUE;
for (i=0; i
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "tiffio.h"
#include "viewmol.h"
#include "dialog.h"
void basisDialog(int);
void basisDialogExit(Widget, caddr_t, XmPushButtonCallbackStruct *);
void getBasisfunction(Widget, caddr_t, XmToggleButtonCallbackStruct *);
extern void MapBox(Widget, caddr_t, XmAnyCallbackStruct *);
extern Widget CreateToggleBox(Widget, struct PushButtonRow *, int, int,
int, int, int);
extern char *getStringResource(Widget, char *);
/* extern char *bfname(int);
extern void bfnamn(int, int *, int*);*/
extern void *getmem(size_t, size_t);
extern void CreatePushButtonRow(Widget, struct PushButtonRow *, int);
extern void calcmo(void);
extern void redraw(int);
extern void deleteAnnotation(int *);
extern void annotateWavefunction(void);
extern Widget initShell(Widget, char *, Widget *, Widget *);
extern struct WINDOW windows[];
extern struct MOLECULE *molecules;
extern Widget topShell;
extern int iwavef, selectAtom, selectAtomAnnotation;
static Widget dialog;
void basisDialog(int bfAtom)
{
struct MOLECULE *mol;
Widget board, form, form1, atomname, sep;
Widget radiobox;
XmString name;
static struct PushButtonRow buttons[] = {
{ "ok", basisDialogExit, (XtPointer)TRUE, NULL },
{ "cancel", basisDialogExit, (XtPointer)FALSE, NULL }
};
struct PushButtonRow *radiobox_buttons;
/*int start, end;*/
char *label, *word, aname[MAXLENLINE];
register int i, j;
/* This function creates the dialog for selecting a basis function */
selectAtom=FALSE;
deleteAnnotation(&selectAtomAnnotation);
dialog=initShell(windows[VIEWER].widget, "basisForm", &board,
&form);
atomname=XtVaCreateManagedWidget("atomname", xmLabelWidgetClass, form,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
NULL);
if (windows[VIEWER].set >= 0)
mol=&molecules[windows[VIEWER].set];
else
mol=&molecules[0];
word=getStringResource(atomname, "labelString");
sprintf(aname, word, mol->atoms[bfAtom].name, bfAtom+1);
name=XmStringCreateSimple(aname);
XtVaSetValues(atomname, XmNlabelString, name, NULL);
XmStringFree(name);
form1=XtVaCreateWidget("controlarea", xmRowColumnWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
/*bfnamn(bfAtom, &start, &end);
radiobox_buttons=(struct PushButtonRow *)getmem(end-start+2, sizeof(struct PushButtonRow)); */
radiobox_buttons=(struct PushButtonRow *)getmem(mol->atoms[bfAtom].nBasisFunctions+1, sizeof(struct PushButtonRow));
/*label=(char *)getmem(end-start+1, 19*sizeof(char));*/
label=(char *)getmem(mol->atoms[bfAtom].nBasisFunctions, 19*sizeof(char));
j=0;
/*for (i=start; i<=end; i++)*/
for (i=0; iatoms[bfAtom].nBasisFunctions; i++)
{
if (iwavef == BASIS_IN_MO)
{
/* sprintf(&label[19*j], "%10.6f*%s", mol->orbitals[mol->imo].coeff[i], bfname(i));*/
sprintf(&label[19*j], "%10.6f*%s", mol->orbitals[mol->imo].coeff[i], mol->atoms[bfAtom].basisFunctionNames[i]);
radiobox_buttons[j].label=&(label[19*j]);
}
else
/* radiobox_buttons[j].label=bfname(i);*/
radiobox_buttons[j].label=mol->atoms[bfAtom].basisFunctionNames[i];
radiobox_buttons[j].callback=getBasisfunction;
radiobox_buttons[j].client_data=(XtPointer)i;
radiobox_buttons[j++].widget=(Widget)NULL;
}
radiobox=CreateToggleBox(form1, radiobox_buttons, j, (int)XmVERTICAL, j/10+1,
True, 0);
/*mol->ibasfu=start;*/
mol->ibasfu=0;
sep=XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, form1,
XmNorientation, XmHORIZONTAL,
XmNtraversalOn, False,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, radiobox,
NULL);
XtManageChild(form1);
CreatePushButtonRow(form, buttons, 2);
XtAddCallback(dialog, XmNpopupCallback, (XtCallbackProc)MapBox, (XmAnyCallbackStruct *)NULL);
XtManageChild(form);
XtManageChild(board);
}
void getBasisfunction(Widget widget, caddr_t which, XmToggleButtonCallbackStruct *data)
{
if (data->set) molecules[windows[VIEWER].set].ibasfu=(int)which;
}
void basisDialogExit(Widget widget, caddr_t what, XmPushButtonCallbackStruct *data)
{
XtDestroyWidget(dialog);
if ((int)what)
{
calcmo();
annotateWavefunction();
redraw(VIEWER);
}
else
{
iwavef=ALL_OFF;
molecules[windows[VIEWER].set].ibasfu=(-1);
}
}
viewmol-2.4.1/source/bio.c 0100644 0002727 0002727 00000013057 10114366251 013565 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* B I O . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: bio.c,v 1.7 2004/08/29 14:48:09 jrh Exp $
* $Log: bio.c,v $
* Revision 1.7 2004/08/29 14:48:09 jrh
* Release 2.4.1
*
* Revision 1.6 2003/11/07 10:57:49 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:01:48 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:28:23 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:44:18 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:02 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:39:47 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#define TRUE 1
#define FALSE 0
#define MAXLENLINE 82
int readFrame(FILE *, int, int, double, int, long *);
void readNormalModes(FILE *);
void readXtlFile(FILE *);
extern void *getmem(size_t, size_t);
extern void fremem(void **);
int main(int argc, char **argv)
{
FILE *mainfile, *file;
char line[MAXLENLINE], hessian[MAXLENLINE], *word;
long offset;
int version, pbc=FALSE, multiStruct=FALSE;
if ((mainfile=fopen(argv[1], "r")) == NULL)
{
printf("$error noFile 1 %s\n", argv[1]);
printf("$end\n");
exit(-1);
}
fgets(line, MAXLENLINE, mainfile);
if (strstr(line, "!BIOSYM archive") == NULL &&
strstr(line, "TITLE") == NULL)
{
printf("$error wrongFiletype 1 %s\n", argv[1]);
printf("$end\n");
exit(-1);
}
if (strstr(line, "TITLE") != NULL)
{
printf("$title\n%s", &line[6]);
readXtlFile(mainfile);
return(0);
}
sscanf(line+15, "%d", &version);
/*if (version < 2)
{
printf("$error unsupportedVersion 1 %d\n", version);
printf("$end\n");
exit(-1);
} */
fgets(line, MAXLENLINE, mainfile);
if (strstr(line, "PBC=ON") != NULL) pbc=TRUE;
/* Find out whether there is more than one structure */
/* in the file */
offset=ftell(mainfile);
while (fgets(line, MAXLENLINE, mainfile) != NULL)
{
if (strstr(line, "end") != NULL)
{
fgets(line, MAXLENLINE, mainfile);
if (fgets(line, MAXLENLINE, mainfile) != NULL) multiStruct=TRUE;
break;
}
}
(void)fseek(mainfile, offset, SEEK_SET);
if (multiStruct)
{
printf("$grad cartesian gradients\n");
while (readFrame(mainfile, pbc, FALSE, 1.0, version, &offset));
}
(void)fseek(mainfile, offset, SEEK_SET);
(void)readFrame(mainfile, pbc, TRUE, 1.0, version, &offset);
fclose(mainfile);
strcpy(hessian, argv[1]);
if ((word=strrchr(hessian, '.')))
strcpy(word, ".hessian");
else
strcat(hessian, ".hessian");
if ((file=fopen(hessian, "r")) != NULL)
{
readNormalModes(file);
fclose(file);
}
printf("$end\n");
return(0);
}
void readNormalModes(FILE *file)
{
double *nm;
int nfreq;
char line[MAXLENLINE], *word;
register int i, j;
fgets(line, MAXLENLINE, file);
if (strncmp(line, "!BIOSYM hessian", 15)) return;
while (fgets(line, MAXLENLINE, file) != NULL)
{
if (strstr(line, "#frequencies and intensities"))
{
printf("$vibrational spectrum\n");
fscanf(file, "%d\n", &nfreq);
for (i=0; i
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
#include "dialog.h"
void bondDialog(Widget, caddr_t, XmAnyCallbackStruct *);
void bondDialogExit(Widget, caddr_t, XmPushButtonCallbackStruct *);
void GetHBond(Widget, caddr_t, XmToggleButtonCallbackStruct *);
void GetHBondThreshold(Widget, struct SLIDER *, XmScrollBarCallbackStruct *);
struct MenuItem *makeElementMenu(void);
void GetRadiusScale(Widget, caddr_t, XmToggleButtonCallbackStruct *);
void GetScaleFactor(Widget, struct SLIDER *, XmScrollBarCallbackStruct *);
static int compareElements(const void *s1, const void *s2);
extern void MapBox(Widget, caddr_t, XmAnyCallbackStruct *);
extern Widget CreateToggleBox(Widget, struct PushButtonRow *, int, int,
int, int, int);
extern void CreatePushButtonRow(Widget, struct PushButtonRow *, int);
extern char *getStringResource(Widget, char *);
extern void GetMessageBoxButton(Widget, XtPointer, caddr_t);
extern int messgb(Widget, int, char *, struct PushButtonRow *, int);
extern void setBondType(Widget, caddr_t, XmToggleButtonCallbackStruct *);
extern void GetSlider(Widget, struct SLIDER *, XmScrollBarCallbackStruct *);
extern void redraw(int);
extern int makeConnectivity(struct MOLECULE *, int, int);
extern Widget initShell(Widget, char *, Widget *, Widget *);
extern Widget makeMenu(Widget, int, char *, struct MenuItem *);
extern void *getmem(size_t, size_t);
extern void *expmem(void *, size_t, size_t);
extern void fremem(void **);
extern struct WINDOW windows[];
extern struct MOLECULE *molecules;
extern Widget topShell;
extern double hbondThreshold, scaleRadius;
extern int nmolecule, bondType, showHBond;
static Widget dialog, slider1, slider2;
static double hbondThreshold_save, scaleFactor;
static double scaleRadius_save, *radScale_save;
static struct ELEMENT *scaleElement=NULL;
static int bondType_save, showHBond_save, mol;
static char *labels;
void bondDialog(Widget widget, caddr_t which, XmAnyCallbackStruct *data)
{
Widget board, form, form1, sep, hb, element;
Widget radiobox;
int na;
short decimals;
struct MenuItem *menu;
static struct SLIDER threshold;
static struct SLIDER scaleRad;
static struct PushButtonRow buttons[] = {
{ "ok", bondDialogExit, (XtPointer)TRUE, NULL },
{ "cancel", bondDialogExit, (XtPointer)FALSE, NULL }
};
static struct PushButtonRow radiobox_buttons[] = {
{ "single", setBondType, (XtPointer)SINGLE_BONDS, NULL },
{ "multiple", setBondType, (XtPointer)MULTIPLE_BONDS, NULL },
{ "conjugated", setBondType, (XtPointer)CONJUGATION, NULL },
};
register int i, j, k;
/* This function creates the bond order dialog */
bondType_save=bondType;
showHBond_save=showHBond;
hbondThreshold_save=hbondThreshold;
scaleRadius_save=scaleRadius;
mol=windows[VIEWER].set;
if (mol < 0)
{
na=0;
for (i=0; isymbol))
{
XtVaSetValues(element, XmNmenuHistory, menu[i].widget, NULL);
break;
}
i++;
}
}
(void)XtVaCreateManagedWidget("atoms", xmLabelWidgetClass, form1, NULL);
slider2=XtVaCreateManagedWidget("scaleRadius", xmScaleWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNshowValue, True,
XmNsensitive, True,
NULL);
XtVaGetValues(slider2, XmNdecimalPoints, &decimals, NULL);
if (scaleElement != NULL)
XtVaSetValues(slider2, XmNvalue, (int)(scaleElement->radScale*pow(10.0, (double)decimals)),
NULL);
else
XtVaSetValues(slider2, XmNvalue, (int)(scaleRadius*pow(10.0, (double)decimals)), NULL);
scaleRad.number=&scaleFactor;
scaleRad.decimals=decimals;
scaleRad.draw=NULL;
XtAddCallback(slider2, XmNvalueChangedCallback, (XtCallbackProc)GetScaleFactor, &scaleRad);
XtAddCallback(slider2, XmNdragCallback, (XtCallbackProc)GetScaleFactor, &scaleRad);
XtManageChild(element);
sep=XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNtraversalOn, False,
NULL);
CreatePushButtonRow(form, buttons, XtNumber(buttons));
XtAddCallback(dialog, XmNpopupCallback, (XtCallbackProc)MapBox, (XmAnyCallbackStruct *)NULL);
XtManageChild(form1);
XtManageChild(form);
XtManageChild(board);
}
void bondDialogExit(Widget button, caddr_t which, XmPushButtonCallbackStruct *data)
{
register int i, j, k;
if (!(int)which)
{
bondType=bondType_save;
showHBond=showHBond_save;
hbondThreshold=hbondThreshold_save;
scaleRadius=scaleRadius_save;
k=0;
if (mol < 0)
{
for (i=0; iset)
{
*(int *)which=TRUE;
XtVaSetValues(slider1, XmNsensitive, True, NULL);
}
else
{
*(int *)which=FALSE;
XtVaSetValues(slider1, XmNsensitive, False, NULL);
}
for (i=0; ina, sizeof(int));
menu=(struct MenuItem *)getmem((size_t)(mol->na+2), sizeof(struct MenuItem));
labels=(char *)getmem((size_t)mol->na+2, MAXLENLINE*sizeof(char));
menu[0].label=all;
menu[0].class=&xmPushButtonGadgetClass;
menu[0].callback=GetRadiusScale;
menu[0].callback_data=0;
menu[0].widget=NULL;
menu[0].subitems=NULL;
word=getStringResource(topShell, "elementMenuPrefix");
j=1;
for (i=0; ina; i++)
{
if (!done[i])
{
if (strcmp(mol->atoms[i].element->symbol, "Uc"))
{
strncpy(&labels[MAXLENLINE*j], word, MAXLENLINE-4);
strcat(&labels[MAXLENLINE*j], " ");
strcat(&labels[MAXLENLINE*j], mol->atoms[i].element->symbol);
menu[j].label=&labels[MAXLENLINE*j];
menu[j].class=&xmPushButtonGadgetClass;
menu[j].callback=GetRadiusScale;
menu[j].callback_data=(XtPointer)mol->atoms[i].element;
menu[j].widget=NULL;
menu[j].subitems=NULL;
j++;
}
for (k=i; kna; k++)
{
if (!strcmp(mol->atoms[i].element->symbol, mol->atoms[k].element->symbol))
done[k]=TRUE;
}
}
}
menu[j++].label=NULL;
fremem((void **)&done);
menu=(struct MenuItem *)expmem((void *)menu, (size_t)j, sizeof(struct MenuItem));
qsort((void *)(&menu[1]), (size_t)(j-2), sizeof(struct MenuItem), compareElements);
return(menu);
}
void GetRadiusScale(Widget button, caddr_t which, XmToggleButtonCallbackStruct *data)
{
short decimals;
scaleElement=(struct ELEMENT *)which;
XtVaGetValues(slider2, XmNdecimalPoints, &decimals, NULL);
if (scaleElement == NULL)
XtVaSetValues(slider2, XmNvalue, (int)(scaleRadius*pow((double)10.0, (double)decimals)), NULL);
else
XtVaSetValues(slider2, XmNvalue, (int)(scaleElement->radScale*pow((double)10.0, (double)decimals)), NULL);
}
void GetScaleFactor(Widget widget, struct SLIDER *slider, XmScrollBarCallbackStruct *data)
{
register int i, j;
*(slider->number)=(double)(data->value)/pow((double)10.0, (double)slider->decimals);
if (scaleElement != NULL)
scaleElement->radScale=*(slider->number);
else
scaleRadius=*(slider->number);
for (i=0; iradScale;
makeConnectivity(&molecules[i], FALSE, TRUE);
}
redraw(VIEWER);
}
int compareElements(const void *s1, const void *s2)
{
struct MenuItem *p1, *p2;
register int i;
p1=(struct MenuItem *)s1;
p2=(struct MenuItem *)s2;
i=strcmp(p1->label, p2->label);
return(i);
}
viewmol-2.4.1/source/bondorder.c 0100644 0002727 0002727 00000015745 07752675313 015020 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* B O N D O R D E R . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: bondorder.c,v 1.5 2003/11/07 10:58:19 jrh Exp $
* $Log: bondorder.c,v $
* Revision 1.5 2003/11/07 10:58:19 jrh
* Release 2.4
*
* Revision 1.4 2000/12/10 15:02:22 jrh
* Release 2.3
*
* Revision 1.3 1999/05/24 01:24:49 jrh
* Release 2.2.1
*
* Revision 1.2 1999/02/07 21:44:46 jrh
* Release 2.2
*
* Revision 1.1 1998/01/26 00:34:45 jrh
* Initial revision
*
*/
#include
#include
#include
#include "viewmol.h"
extern struct MOLECULE *molecules;
extern void *getmem(size_t, size_t);
void calculateShift(struct MOLECULE *, struct BOND *, int *, int, int, int);
void findConjugation(struct MOLECULE *, struct BOND *, int *, int, int);
void vectorProduct(double *, double *, double *);
double scalarProduct(double *, double *);
void bondOrder(struct MOLECULE *mol, struct BOND *bond, int *connectivity,
int maxBondsPerAtom)
{
int i, j, ni, nj, bo=1;
/* Assign bond orders by counting electrons. If the number of electrons
for an atom is set to -1 assign only single bonds. */
i=bond->first;
if (mol->atoms[i].nelectrons == (-1))
{
bond->order=1;
return;
}
j=bond->second;
if (mol->atoms[j].nelectrons == (-1))
{
bond->order=1;
return;
}
/* Compare number of electrons with number of atoms atom is bound to
and deduce bond order */
do
{
if (mol->atoms[i].nelectrons > 4)
ni=8-mol->atoms[i].nelectrons;
else
ni=mol->atoms[i].nelectrons;
if (mol->atoms[j].nelectrons > 4)
nj=8-mol->atoms[j].nelectrons;
else
nj=mol->atoms[j].nelectrons;
ni-=mol->atoms[i].nbonds-mol->atoms[i].hbonds;
nj-=mol->atoms[j].nbonds-mol->atoms[j].hbonds;
if (ni < 0)
ni=mol->atoms[i].nelectrons-mol->atoms[i].nbonds+mol->atoms[i].hbonds;
if (nj < 0)
nj=mol->atoms[j].nelectrons-mol->atoms[j].nbonds+mol->atoms[j].hbonds;
if (ni > 0 && nj > 0)
{
mol->atoms[i].nbonds++;
mol->atoms[j].nbonds++;
bo++;
}
else
break;
} while (bo <= 4);
bond->order=bo;
/* Bond order has been found, calculate shift vector to draw multiple bonds. */
if (bo > 1) calculateShift(mol, bond, connectivity, maxBondsPerAtom, i, j);
}
void calculateShift(struct MOLECULE *mol, struct BOND *bond, int *connectivity,
int maxBondsPerAtom, int i, int j)
{
double v1[3], v2[3], v3[3];
int ni, nj, bo, kh=(-1);
register double r1, r2;
register int k, l;
/* Rules for multiple bonds: Shall be in the same plane as other bond framework,
but do not use hydrogens to determine this plane
unless impossible otherwise. */
bo=abs(bond->order);
ni=(mol->atoms[i].nbonds >= mol->atoms[j].nbonds ? i : j);
nj=(ni == i ? j : i);
l=0;
do
{
k=abs(connectivity[maxBondsPerAtom*ni+l]);
if (k != nj && strcmp(mol->atoms[k].element->symbol, "H")) break;
if (k != nj && !strcmp(mol->atoms[k].element->symbol, "H")) kh=k;
l++;
} while (l < maxBondsPerAtom);
/* No non-hydrogen atom found so we have to use a hydrogen atom */
if (l == maxBondsPerAtom && kh != (-1)) k=kh;
v1[0]=mol->atoms[k].x-mol->atoms[ni].x;
v1[1]=mol->atoms[k].y-mol->atoms[ni].y;
v1[2]=mol->atoms[k].z-mol->atoms[ni].z;
r1=scalarProduct(v1, v1);
v2[0]=mol->atoms[nj].x-mol->atoms[ni].x;
v2[1]=mol->atoms[nj].y-mol->atoms[ni].y;
v2[2]=mol->atoms[nj].z-mol->atoms[ni].z;
r2=scalarProduct(v2, v2);
if (r1 != 0.0 && r2 != 0.0)
r1=fabs(scalarProduct(v1, v2)/(sqrt(r1*r2))+1.0);
else
r1=0.0;
if (r1 > 1.0e-6)
{
vectorProduct(v1, v2, v3);
vectorProduct(v2, v3, v1);
r1=mol->bondShift/sqrt(scalarProduct(v1, v1));
if (bo == 2) r1*=0.5;
bond->x=v1[0]*r1;
bond->y=v1[1]*r1;
bond->z=v1[2]*r1;
}
else
{
v1[0]=1.0;
v1[1]=0.0;
v1[2]=0.0;
r1=scalarProduct(v1, v2)/sqrt(r2);
if (bo == 2) r2=0.5;
else r2=1.0;
bond->x=r2*mol->bondShift*sqrt(1.0-r1*r1);
bond->y=r2*mol->bondShift*r1;
bond->z=0.0;
}
/*v3[0]=0.5*(v1[0]-v2[0]);
v3[1]=0.5*(v1[1]-v2[1]);
v3[2]=0.5*(v1[2]-v2[2]);
r1=mol->bondShift/sqrt(scalarProduct(v3, v3));
if (bo == 2) r1*=0.5;
bond->x=v3[0]*r1;
bond->y=v3[1]*r1;
bond->z=v3[2]*r1; */
}
void findConjugation(struct MOLECULE *mol, struct BOND *bonds, int *connectivity,
int maxBondsPerAtom, int nb)
{
int atom1, atom2, conjugated;
register int i, j, k, l;
for (i=0; inb; i++)
{
if (abs(mol->bonds[i].order) == 2)
{
atom1=mol->bonds[i].first;
while (TRUE)
{
for (j=0; jnb; j++)
{
if ((mol->bonds[j].first == atom1
|| mol->bonds[j].second == atom1)
&& mol->bonds[j].order == 1)
{
atom2=mol->bonds[j].first == atom1
? mol->bonds[j].second : mol->bonds[j].first;
for (k=0; knb; k++)
{
if ((mol->bonds[k].first == atom2
|| mol->bonds[k].second == atom2)
&& abs(mol->bonds[k].order) == 2)
{
conjugated=TRUE;
for (l=0; lnb; l++)
{
if (l == i || l == j || l == k) continue;
if (mol->bonds[l].first != atom1
&& mol->bonds[l].second != atom1) continue;
if (mol->bonds[l].order != 1
&& mol->bonds[l].order != (-2))
{
conjugated=FALSE;
break;
}
}
if (conjugated)
{
mol->bonds[i].order=(-2);
mol->bonds[j].order=(-2);
mol->bonds[k].order=(-2);
/* calculate shift vector for bond j */
calculateShift(mol, &(mol->bonds[j]), connectivity,
maxBondsPerAtom, atom1, atom2);
break;
}
}
}
}
}
if (atom1 == mol->bonds[i].second) break;
atom1=mol->bonds[i].second;
}
}
}
}
void vectorProduct(double *v1, double *v2, double *v3)
{
v3[0]=v1[1]*v2[2]-v1[2]*v2[1];
v3[1]=v1[2]*v2[0]-v1[0]*v2[2];
v3[2]=v1[0]*v2[1]-v1[1]*v2[0];
}
double scalarProduct(double *v1, double *v2)
{
return(v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2]);
}
viewmol-2.4.1/source/build.c 0100644 0002727 0002727 00000037310 10037763442 014120 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* B U I L D . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: build.c,v 1.4 2003/11/07 10:58:28 jrh Exp $
* $Log: build.c,v $
* Revision 1.4 2003/11/07 10:58:28 jrh
* Release 2.4
*
* Revision 1.3 2000/12/10 15:02:33 jrh
* Release 2.3
*
* Revision 1.2 1999/05/24 01:24:52 jrh
* Release 2.2.1
*
* Revision 1.1 1999/02/07 21:45:03 jrh
* Initial revision
*
*
*/
#include
#include
#include
#include
#include "viewmol.h"
void buildMolecule(struct MOLECULE *, int, int, int);
void replaceAtom(struct MOLECULE *, int);
void addAtom(struct MOLECULE *, int, int);
void changeCoordination(struct MOLECULE *);
extern int makeConnectivity(struct MOLECULE *, int, int);
extern double centerMolecule(struct MOLECULE *);
extern void setWindowSize(double);
extern int findBondPartners(int *, int, int);
extern int findAttachedAtoms(int *, int, int);
extern void changeBondLength(int, int, int *, double);
extern int changeAngle(int, int, int *, double);
extern void vectorProduct(double *, double *, double *);
extern void *getmem(size_t, size_t);
extern void fremem(void **);
extern void *expmem(void *, size_t, size_t);
extern double bondAngle(struct ATOM *, int, int, int);
extern void clearGeometry(Widget, caddr_t, XmAnyCallbackStruct *);
extern void addUndo(struct MOLECULE *);
extern struct WINDOW windows[];
extern struct MOLECULE *molecules;
extern struct ELEMENT *elements;
extern double torsionDefault;
extern int element, bondType, localGeometry;
void buildMolecule(struct MOLECULE *mol, int picked, int operation, int setWindow)
{
int which, *list;
register int i, j, k;
/* Save coordinates before any change */
if (mol->na > 0) addUndo(mol);
if (mol->internals == NULL)
mol->internals=(struct INTERNAL *)getmem((size_t)1, sizeof(struct INTERNAL));
else
mol->internals=(struct INTERNAL *)expmem((void *)mol->internals,
(size_t)mol->ninternal+1, sizeof(struct INTERNAL));
switch (operation)
{
case DELETE_ATOM: mol->na--;
for (i=picked; ina; i++)
{
mol->atoms[i].x=mol->atoms[i+1].x;
mol->atoms[i].y=mol->atoms[i+1].y;
mol->atoms[i].z=mol->atoms[i+1].z;
mol->atoms[i].rad=mol->atoms[i+1].rad;
mol->atoms[i].radScale=mol->atoms[i+1].radScale;
mol->atoms[i].mass=mol->atoms[i+1].mass;
mol->atoms[i].neutronScatterfac=mol->atoms[i+1].neutronScatterfac;
mol->atoms[i].nbonds=mol->atoms[i+1].nbonds;
mol->atoms[i].nelectrons=mol->atoms[i+1].nelectrons;
mol->atoms[i].ref=mol->atoms[i+1].ref;
mol->atoms[i].flags=mol->atoms[i+1].flags;
mol->atoms[i].element=mol->atoms[i+1].element;
mol->atoms[i].basis=mol->atoms[i+1].basis;
strcpy(mol->atoms[i].name, mol->atoms[i+1].name);
strcpy(mol->atoms[i].basisname, mol->atoms[i+1].basisname);
}
mol->atoms=(struct ATOM *)expmem((void *)mol->atoms,
(size_t)mol->na, sizeof(struct ATOM));
/* Scan through list of internal coordinates and delete all
which contain deleted atom */
for (i=0; ininternal; i++)
{
if (mol->internals[i].atoms[0] == picked ||
mol->internals[i].atoms[1] == picked ||
mol->internals[i].atoms[2] == picked ||
mol->internals[i].atoms[3] == picked)
clearGeometry((Widget)0, (caddr_t)i, (XmAnyCallbackStruct *)0);
}
/* Scan through lists of bonds added or deleted by user
and change numbering of bonded atoms */
for (i=0; inbAdded; i++)
{
if (mol->addedBonds[3*i] > picked) mol->addedBonds[3*i]--;
if (mol->addedBonds[3*i+1] > picked) mol->addedBonds[3*i+1]--;
}
for (i=0; inbDeleted; i++)
{
if (mol->deletedBonds[2*i] > picked) mol->deletedBonds[2*i]--;
if (mol->deletedBonds[2*i+1] > picked) mol->deletedBonds[2*i+1]--;
}
/* Change coordination at atoms bond to deleted atom if
user desires so */
if (localGeometry)
{
list=(int *)getmem((size_t)mol->nb, sizeof(int));
j=0;
for (i=0; inb; i++)
{
if (mol->bonds[i].first == picked || mol->bonds[i].second == picked)
{
list[j++]=i;
mol->bonds[i].order=(-1); /* mark bond as hydrogen bond to ex- */
} /* clude it from findBondPartners */
if (mol->bonds[i].first > picked) mol->bonds[i].first--;
if (mol->bonds[i].second > picked) mol->bonds[i].second--;
}
for (i=0; ibonds[k].first == picked)
mol->internals[mol->ninternal].atoms[1]=mol->bonds[k].second;
else if (mol->bonds[k].second == picked)
mol->internals[mol->ninternal].atoms[1]=mol->bonds[k].first;
changeCoordination(mol);
}
fremem((void **)&list);
}
makeConnectivity(mol, FALSE, FALSE);
break;
case REPLACE_ATOM: replaceAtom(mol, picked);
break;
case ADD_ATOM: which=mol->na++;
mol->atoms=(struct ATOM *)expmem((void *)mol->atoms,
(size_t)mol->na, sizeof(struct ATOM));
replaceAtom(mol, which);
if (mol->unitcell) makeConnectivity(mol, FALSE, TRUE);
addAtom(mol, which, picked);
break;
}
if (mol->ninternal == 0)
fremem((void **)&(mol->internals));
else
mol->internals=(struct INTERNAL *)expmem((void *)mol->internals,
(size_t)mol->ninternal, sizeof(struct INTERNAL));
}
void replaceAtom(struct MOLECULE *mol, int which)
{
#include "isotopes.h"
int *move, nmove;
register int i;
mol->atoms[which].rad=elements[element].rad;
mol->atoms[which].radScale=elements[element].radScale;
mol->atoms[which].element=&elements[element];
mol->atoms[which].neutronScatterfac=0.0;
mol->atoms[which].basis=(struct BASISSET *)NULL;
strcpy(mol->atoms[which].name, elements[element].symbol);
strcpy(mol->atoms[which].basisname, "");
for (i=0; iatoms[which].name, pse[i], 2))
{
mol->atoms[which].mass=isotope[i][0];
mol->atoms[which].nelectrons=electrons[i];
}
}
/* Adjust bond lengths */
move=(int *)getmem((size_t)mol->na, sizeof(int));
for (i=0; inb; i++)
{
if (mol->bonds[i].first == which || mol->bonds[i].second == which)
{
mol->internals[mol->ninternal].atoms[0]=mol->bonds[i].first;
mol->internals[mol->ninternal].atoms[1]=mol->bonds[i].second;
mol->internals[mol->ninternal].type=BONDLENGTH;
move[0]=mol->bonds[i].first == which ? mol->bonds[i].second : mol->bonds[i].first;
if ((nmove=findAttachedAtoms(move, 1, which)) > 0)
changeBondLength(mol->ninternal, nmove, move,
0.9*(mol->atoms[mol->bonds[i].first].rad
+mol->atoms[mol->bonds[i].second].rad));
}
}
fremem((void *)&move);
}
void addAtom(struct MOLECULE *mol, int which, int picked)
{
mol->atoms[which].flags=ORIGINAL;
mol->atoms[which].nbonds=0;
if (picked == -1) /* if atom is not attached to another atom */
{
mol->atoms[which].x=0.0;
mol->atoms[which].y=0.0;
mol->atoms[which].z=0.0;
return;
}
else
{
mol->atoms[which].x=mol->atoms[picked].x+1.0;
mol->atoms[which].y=mol->atoms[picked].y;
mol->atoms[which].z=mol->atoms[picked].z;
}
mol->nb++;
mol->bonds=(struct BOND *)expmem((void *)mol->bonds, (size_t)mol->nb,
sizeof(struct BOND));
mol->bonds[mol->nb-1].first=picked;
mol->bonds[mol->nb-1].second=which;
mol->bonds[mol->nb-1].order=1;
mol->bonds[mol->nb-1].frac=mol->atoms[picked].rad/(mol->atoms[picked].rad+mol->atoms[which].rad);
mol->internals[mol->ninternal].atoms[0]=which;
mol->internals[mol->ninternal].atoms[1]=picked;
mol->internals[mol->ninternal].type=BONDLENGTH;
changeBondLength(mol->ninternal, 1, &which,
0.9*(mol->atoms[which].rad+mol->atoms[picked].rad));
changeCoordination(mol);
setWindowSize(centerMolecule(mol));
}
void changeCoordination(struct MOLECULE *mol)
{
double v1[3], v2[3], v3[3], t=torsionDefault, angle, sign;
int *bondPartners, *nbonds, max, imax, picked, added=FALSE;
int linear=FALSE, useDummy=FALSE;
register int i, j, n;
bondPartners=(int *)getmem((size_t)mol->na, sizeof(int));
picked=mol->internals[mol->ninternal].atoms[1];
bondPartners[0]=picked;
n=findBondPartners(bondPartners, 1, -1);
if (n < 3) return;
bondPartners=(int *)expmem((void *)bondPartners, (size_t)((n+2)*mol->na),
sizeof(int));
nbonds=(int *)getmem((size_t)n, sizeof(int));
max=0;
imax=0;
for (i=1; ina]=bondPartners[i];
if (abs(nbonds[i]=findAttachedAtoms(&bondPartners[i*mol->na], 1,
picked)) > max)
{
max=abs(nbonds[i]);
imax=i;
}
}
mol->internals[mol->ninternal].atoms[3]=bondPartners[imax*mol->na+1];
angle=180.;
sign=1.0;
for (i=1; ina-2 || mol->na < 4))
{
mol->internals[mol->ninternal].atoms[0]=bondPartners[i];
mol->internals[mol->ninternal].atoms[2]=bondPartners[imax];
if (n > 4 && max <= 1)
mol->internals[mol->ninternal].atoms[3]=(-1);
else
{
if (bondAngle(mol->atoms, bondPartners[i],
picked, bondPartners[imax]) < 179.9)
linear=FALSE;
else
{
if (nbonds[imax] > 1)
{
for (j=0; jatoms, bondPartners[i], picked,
bondPartners[imax*mol->na+j]) < 179.9)
{
mol->internals[mol->ninternal].atoms[3]=bondPartners[imax*mol->na+j];
break;
}
}
}
else
mol->internals[mol->ninternal].atoms[3]=(-1);
linear=TRUE;
}
}
mol->internals[mol->ninternal].type=ANGLE;
if (n == 3 && mol->atoms[picked].nelectrons > 4)
{
n+=mol->atoms[picked].nelectrons-4;
added=TRUE;
}
switch (n)
{
case 3: (void)changeAngle(mol->ninternal, nbonds[i],
&bondPartners[i*mol->na], 180.);
break;
case 4: (void)changeAngle(mol->ninternal, nbonds[i],
&bondPartners[i*mol->na], sign*120.0);
if (linear) sign=(-1.0);
break;
case 5: (void)changeAngle(mol->ninternal, nbonds[i],
&bondPartners[i*mol->na], 109.47122);
break;
default: (void)changeAngle(mol->ninternal, nbonds[i],
&bondPartners[i*mol->na], angle);
angle=90.;
break;
}
if (added)
{
n-=mol->atoms[picked].nelectrons-4;
added=FALSE;
}
if (n > 3)
{
mol->internals[mol->ninternal].type=TORSION;
if (mol->internals[mol->ninternal].atoms[3] >= 0)
{
if (!changeAngle(mol->ninternal, nbonds[i], &bondPartners[i*mol->na], t))
{
useDummy=TRUE;
v1[0]=mol->atoms[bondPartners[i]].x-mol->atoms[picked].x;
v1[1]=mol->atoms[bondPartners[i]].y-mol->atoms[picked].y;
v1[2]=mol->atoms[bondPartners[i]].z-mol->atoms[picked].z;
v2[0]=mol->atoms[bondPartners[imax]].x-mol->atoms[picked].x;
v2[1]=mol->atoms[bondPartners[imax]].y-mol->atoms[picked].y;
v2[2]=mol->atoms[bondPartners[imax]].z-mol->atoms[picked].z;
vectorProduct(v1, v2, v3);
mol->atoms=(struct ATOM *)expmem((void *)mol->atoms, (size_t)(mol->na+1),
sizeof(struct ATOM));
mol->atoms[mol->na].x=mol->atoms[bondPartners[imax]].x+v3[0];
mol->atoms[mol->na].y=mol->atoms[bondPartners[imax]].y+v3[1];
mol->atoms[mol->na].z=mol->atoms[bondPartners[imax]].z+v3[2];
mol->internals[mol->ninternal].atoms[3]=mol->na;
(void)changeAngle(mol->ninternal, nbonds[i], &bondPartners[i*mol->na], t);
}
if (n > 5)
t+=360.0/(double)(n-3);
else
t+=360.0/(double)(n-2);
}
else
{
if (n > 4)
{
if (!useDummy)
{
useDummy=TRUE;
v1[0]=mol->atoms[bondPartners[i]].x-mol->atoms[picked].x;
v1[1]=mol->atoms[bondPartners[i]].y-mol->atoms[picked].y;
v1[2]=mol->atoms[bondPartners[i]].z-mol->atoms[picked].z;
v2[0]=mol->atoms[bondPartners[imax]].x-mol->atoms[picked].x;
v2[1]=mol->atoms[bondPartners[imax]].y-mol->atoms[picked].y;
v2[2]=mol->atoms[bondPartners[imax]].z-mol->atoms[picked].z;
vectorProduct(v1, v2, v3);
mol->atoms=(struct ATOM *)expmem((void *)mol->atoms, (size_t)(mol->na+1),
sizeof(struct ATOM));
mol->atoms[mol->na].x=mol->atoms[bondPartners[imax]].x+v3[0];
mol->atoms[mol->na].y=mol->atoms[bondPartners[imax]].y+v3[1];
mol->atoms[mol->na].z=mol->atoms[bondPartners[imax]].z+v3[2];
}
mol->internals[mol->ninternal].atoms[3]=mol->na;
(void)changeAngle(mol->ninternal, nbonds[i], &bondPartners[i*mol->na], t);
if (n > 5)
t+=360.0/(double)(n-3);
else
t+=360.0/(double)(n-2);
}
}
}
}
} /* end of for-loop */
fremem((void **)&bondPartners);
fremem((void **)&nbonds);
if (useDummy) mol->atoms=(struct ATOM *)expmem((void *)mol->atoms, (size_t)(mol->na),
sizeof(struct ATOM));
}
viewmol-2.4.1/source/calcmo.c 0100644 0002727 0002727 00000035744 07752675333 014303 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* C A L C M O . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: calcmo.c,v 1.6 2003/11/07 10:58:35 jrh Exp $
* $Log: calcmo.c,v $
* Revision 1.6 2003/11/07 10:58:35 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:02:43 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:24:54 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:45:16 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:08 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:39:57 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
#include "dialog.h"
void setGridObject(struct GRIDOBJECT *, double, double, int, int, int);
extern double makemo(struct ATOM *, struct ORBITAL *, double, double, double,
int, int, int, int);
extern int runMoloch(double *, double, double, double, int, struct ORBITAL *, int);
extern void GetMessageBoxButton(Widget, XtPointer, caddr_t);
extern char *getStringResource(Widget, char *);
extern void *getmem(size_t, size_t);
extern void *expmem(void *, size_t, size_t);
extern void setCursor(Widget, int);
extern int norbs(struct MOLECULE *);
/* extern char *bfname(int);*/
extern void fremem(void **);
extern void restoreGeometry(struct SAVE *, int);
extern int messgb(Widget, int, char *, struct PushButtonRow *, int);
extern int runProg(char *, int, char *, char *, char *, pid_t *);
extern struct WINDOW windows[];
extern struct MOLECULE *molecules;
extern double gridres;
extern int iwavef;
extern int bfatom;
extern Widget topShell;
extern char moloch[];
static int imol;
void calcmo(void)
{
struct ORBITAL *orb=NULL;
double fac, boxf, step;
#ifdef DEBUG
double d, m, a;
#endif
int mo=0, morb;
register double x, y, z;
register int i, j, k, l;
imol=windows[MO].set;
if (molecules[imol].ngridobjects == 0)
{
molecules[imol].ngridobjects++;
molecules[imol].gridObjects=(struct GRIDOBJECT *)getmem(molecules[imol].ngridobjects,
sizeof(struct GRIDOBJECT));
setGridObject(&(molecules[imol].gridObjects[0]), windows[VIEWER].far,
gridres, iwavef, molecules[imol].imo, molecules[imol].ibasfu);
}
else
{
j=FALSE;
for (i=0; icoeff=(double *)getmem((size_t)morb, sizeof(double));
orb->coeff[molecules[imol].ibasfu]=1.0;
mo=0;
break;
case BASIS_IN_MO: orb=(struct ORBITAL *)getmem((size_t)1, sizeof(struct ORBITAL));
orb->coeff=(double *)getmem((size_t)morb, sizeof(double));
orb->coeff[molecules[imol].ibasfu]=molecules[imol].orbitals[molecules[imol].imo].coeff[molecules[imol].ibasfu];
mo=0;
break;
case MOLECULAR_ORBITAL: mo=molecules[imol].imo;
orb=molecules[imol].orbitals;
break;
case DENSITY: mo=-1;
orb=molecules[imol].orbitals;
break;
}
#ifndef DEBUG
if ((iwavef == MOLECULAR_ORBITAL || iwavef == DENSITY) && molecules[imol].needMoloch)
{
#endif
if (runMoloch(molecules[imol].gridObjects[molecules[imol].ngridobjects-1].grid,
gridres, boxf, step, mo, molecules[imol].orbitals,
molecules[imol].nbasfu)) iwavef=0;
#ifndef DEBUG
}
else
{
#else
d=0.0;
m=0.0;
#endif
i=0;
z=-boxf;
for (j=0; j<=gridres; j++)
{
y=-boxf;
for (k=0; k<=gridres; k++)
{
x=-boxf;
for (l=0; l<=gridres; l++)
{
#ifdef DEBUG
a=molecules[imol].gridObjects[molecules[imol].ngridobjects-1].grid[i];
#endif
molecules[imol].gridObjects[molecules[imol].ngridobjects-1].grid[i++]
=makemo(molecules[imol].atoms, orb, x, y, z, molecules[imol].na,
morb, molecules[imol].nbasfu, mo);
#ifdef DEBUG
printf("%15.10f %15.10f %15.10f\n", a,
molecules[imol].gridObjects[molecules[imol].ngridobjects-1].grid[i-1],
a-molecules[imol].gridObjects[molecules[imol].ngridobjects-1].grid[i-1]);
d=d+fabs(molecules[imol].gridObjects[molecules[imol].ngridobjects-1].grid[i-1]-a);
m=m > fabs(molecules[imol].gridObjects[molecules[imol].ngridobjects-1].grid[i-1]-a)
? m : fabs(molecules[imol].gridObjects[molecules[imol].ngridobjects-1].grid[i-1]-a);
#endif
x+=step;
}
y+=step;
}
z+=step;
}
#ifndef DEBUG
}
#else
printf("%d grid points, average deviation %15.10f, maximum %15.10f\n", i,
d/((gridres+1.0)*(gridres+1.0)*(gridres+1.0)), m);
#endif
restoreGeometry(molecules[imol].coord, imol);
if (iwavef == BASIS_FUNCTION || iwavef == BASIS_IN_MO)
{
fremem((void **)&orb->coeff);
fremem((void **)&orb);
}
setCursor(windows[VIEWER].widget, XC_top_left_arrow);
if (windows[MO].widget != NULL) setCursor(windows[MO].widget, XC_top_left_arrow);
}
int runMoloch(double *grid, double gridres, double box, double step, int imo,
struct ORBITAL *orbitals, int nbasfu)
{
static struct PushButtonRow buttons[] = {{"continue", GetMessageBoxButton,
(XtPointer)0, NULL}};
FILE *infile, *outfile;
pid_t pid;
char line[MAXLENLINE], mofile[MAXLENLINE], *word;
register int i, j;
if (access("control", F_OK))
{
word=getStringResource(topShell, "noControlFile");
messgb(topShell, 1, word, buttons, 1);
return(TRUE);
}
rename("control", "control.save");
if (!access("propinp", F_OK))
rename("propinp", "propinp.save");
if ((infile=fopen("control.save", "r")) == NULL)
{
word=getStringResource(topShell, "unableToOpen");
sprintf(line, word, "control.save");
messgb(topShell, 1, line, buttons, 1);
return(TRUE);
}
if ((outfile=fopen("control", "w")) == NULL)
{
word=getStringResource(topShell, "unableToOpen");
sprintf(line, word, "control");
messgb(topShell, 1, line, buttons, 1);
return(TRUE);
}
while (fgets(line, MAXLENLINE, infile) != NULL)
{
if (strstr(line, "$end")) break;
if (strstr(line, "$scfmo"))
{
fprintf(outfile, "%s", line);
if ((word=strtok(line, "=")) != NULL)
strcpy(mofile, strtok(NULL, " \t\n"));
else
strcpy(mofile, "control");
continue;
}
if (!strstr(line, "$properties"))
{
fprintf(outfile, "%s", line);
continue;
}
else
{
do
{
fgets(line, MAXLENLINE, infile);
}
while (!(word=strchr(line, '$')));
continue;
}
}
fprintf(outfile, "$properties file=propinp\n");
fprintf(outfile, "$end\n");
fclose(infile);
fclose(outfile);
outfile=fopen("propinp", "w");
fprintf(outfile, "$properties\n");
fprintf(outfile, " trace off\n");
fprintf(outfile, " moments off\n");
fprintf(outfile, " potential off\n");
fprintf(outfile, " cowan-griffin off\n");
fprintf(outfile, " localization off\n");
fprintf(outfile, " population analyses off\n");
fprintf(outfile, " plot active\n");
fprintf(outfile, " firstorder off\n");
fprintf(outfile, " fit off\n");
j=0;
for (i=0; i<=imo; i++)
if (!strcmp(molecules[imol].orbitals[i].symmetry,
molecules[imol].orbitals[imo].symmetry)) j++;
fprintf(outfile, "$grid #1\n");
if (imo != -1)
fprintf(outfile, " mo %d%s\n", j, molecules[imol].orbitals[imo].symmetry);
else
fprintf(outfile, " mo\n");
fprintf(outfile, " origin .000000 .000000 .000000\n");
fprintf(outfile, " vector1 1.000000 .000000 .000000\n");
fprintf(outfile, " vector2 .000000 1.000000 .000000\n");
fprintf(outfile, " vector3 .000000 .000000 1.000000\n");
fprintf(outfile, " grid1 range %13.6f%13.6f points %d\n", -box, -box+gridres*step, (int)(gridres)+1);
fprintf(outfile, " grid2 range %13.6f%13.6f points %d\n", -box, -box+gridres*step, (int)(gridres)+1);
fprintf(outfile, " grid3 range %13.6f%13.6f points %d\n", -box, -box+gridres*step, (int)(gridres)+1);
fprintf(outfile, " infile = %s\n", mofile);
fprintf(outfile, " outfile = grid.dat\n");
fprintf(outfile, "$end\n");
fclose(outfile);
if (runProg(moloch, TRUE, "/dev/null", "/dev/null", "/dev/null", &pid))
{
iwavef=ALL_OFF;
word=getStringResource(topShell, "molochFailed");
messgb(topShell, 1, word, buttons, 1);
return(TRUE);
}
rename("control.save", "control");
unlink("propinp");
if (!access("propinp.save", F_OK)) rename("propinp.save", "propinp");
if ((infile=fopen("grid.dat", "r")) == NULL)
{
word=getStringResource(topShell, "noMolochOutput");
messgb(topShell, 1, word, buttons, 1);
return(TRUE);
}
while (fgets(line, MAXLENLINE, infile) != NULL)
if (strstr(line, "$plotdata")) break;
i=0;
while (fgets(line, MAXLENLINE, infile) != NULL)
{
if (strchr(line, '$')) break;
while ((word=strchr(line, 'D')) != NULL) *word='E';
word=line;
if (strlen(line) > 76)
{
sscanf(word, "%16le", &grid[i++]);
word+=16;
while (sscanf(word, "%16le", &grid[i++]) != EOF) word+=16;
}
else
{
sscanf(word, "%15le", &grid[i++]);
word+=15;
while (sscanf(word, "%15le", &grid[i++]) != EOF) word+=15;
}
i--;
}
fclose(infile);
unlink("grid.dat");
return(FALSE);
}
void setGridObject(struct GRIDOBJECT *gridObject, double start, double gridres,
int iwavef, int imo, int ibasfu)
{
char *word;
gridObject->origin[0]=0.0;
gridObject->origin[1]=0.0;
gridObject->origin[2]=0.0;
gridObject->vector1[0]=1.0;
gridObject->vector1[1]=0.0;
gridObject->vector1[2]=0.0;
gridObject->vector2[0]=0.0;
gridObject->vector2[1]=1.0;
gridObject->vector2[2]=0.0;
gridObject->vector3[0]=0.0;
gridObject->vector3[1]=0.0;
gridObject->vector3[2]=1.0;
gridObject->start[0]=gridObject->start[1]=gridObject->start[2]=(-start);
gridObject->step[0]=gridObject->step[1]=gridObject->step[2]=2.0*start/gridres;
gridObject->ngridpoints[0]=gridObject->ngridpoints[1]=gridObject->ngridpoints[2]=(int)gridres;
gridObject->npoints[0]=gridObject->ngridpoints[0];
gridObject->npoints[1]=gridObject->ngridpoints[1];
gridObject->npoints[2]=gridObject->ngridpoints[2];
gridObject->resolution=gridres;
gridObject->type=iwavef;
gridObject->mo=imo;
gridObject->basisfunction=ibasfu;
switch (iwavef)
{
case BASIS_FUNCTION: word=getStringResource(topShell, "basisfunctionTitle");
sprintf(gridObject->text, word, ibasfu+1,
molecules[imol].atoms[bfatom].name,
/* bfatom+1, bfname(ibasfu));*/
bfatom+1, molecules[imol].atoms[bfatom].basisFunctionNames[ibasfu]);
break;
case BASIS_IN_MO: word=getStringResource(topShell, "basisfunctionInMOTitle");
sprintf(gridObject->text, word, ibasfu+1, imo+1,
molecules[imol].atoms[bfatom].name, bfatom+1,
molecules[imol].orbitals[imo].coeff[ibasfu],
/* bfname(ibasfu));*/
molecules[imol].atoms[bfatom].basisFunctionNames[ibasfu]);
break;
case MOLECULAR_ORBITAL: word=getStringResource(topShell, "molecularOrbitalTitle");
sprintf(gridObject->text, word, imo+1,
molecules[imol].orbitals[imo].symmetry,
molecules[imol].orbitals[imo].energy);
break;
case DENSITY: word=getStringResource(topShell, "electronDensityTitle");
sprintf(gridObject->text, word);
break;
}
}
clock_t getCPUTime(void)
{
struct tms buffer;
if (times(&buffer) != -1)
return(buffer.tms_utime+buffer.tms_stime);
else
return((clock_t)0);
}
viewmol-2.4.1/source/cellform.c 0100644 0002727 0002727 00000022021 10114366336 014612 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* C E L L F O R M . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: cellform.c,v 1.5 2004/08/29 14:49:02 jrh Exp $
* $Log: cellform.c,v $
* Revision 1.5 2004/08/29 14:49:02 jrh
* Release 2.4.1
*
* Revision 1.4 2003/11/07 10:58:46 jrh
* Release 2.4
*
* Revision 1.3 2000/12/10 15:02:51 jrh
* Release 2.3
*
* Revision 1.2 1999/05/24 01:24:56 jrh
* Release 2.2.1
*
* Revision 1.1 1999/02/07 21:45:28 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
#include "dialog.h"
void unitcellExit(Widget, caddr_t, XmPushButtonCallbackStruct *);
void setCellSliders(struct MOLECULE *);
void makeNewCell(Widget, struct SLIDER *, XmScrollBarCallbackStruct *);
void makeMillerPlane(Widget, struct SLIDER *, XmScrollBarCallbackStruct *);
extern void GetSlider(Widget, struct SLIDER *, XmScrollBarCallbackStruct *);
extern void drawMolecule(Widget, caddr_t, XmDrawingAreaCallbackStruct *);
extern int redraw(int);
extern void expandCell(int, int);
extern void millerPlane(void);
extern void MapBox(Widget, caddr_t, XmToggleButtonCallbackStruct *);
extern Widget CreatePushButtonRow(Widget, struct PushButtonRow *, int);
extern Widget CreateToggleBox(Widget, struct PushButtonRow *, int, int,
int, int, int);
extern void changeBoolean(Widget, int *, XmDrawingAreaCallbackStruct *);
extern Widget initShell(Widget, char *, Widget *, Widget *);
extern void setMenuItem(int, int);
extern void *getmem(size_t, size_t);
extern void fremem(void **);
extern struct WINDOW windows[];
extern struct MOLECULE *molecules;
extern Widget topShell;
extern int showUnitCell, iwavef;
static Widget dialog, millerButton, cellWidgets[3], millerWidgets[3];
static struct MOLECULE *mol;
static int showUnitCell_save, showMiller_save;
static int miller_save[3];
static double cellFactor_save[3], miller[3];
void unitcellDialog(Widget widget, caddr_t dummy, XmAnyCallbackStruct *data)
{
Widget form, form1, board, togglebox, sep;
short decimals;
static struct SLIDER cellSliders[3], millerSliders[3];
static struct PushButtonRow checkbox_button[] = {{"visible", changeBoolean,
(XtPointer)&showUnitCell, NULL},
{"miller", changeBoolean,
(XtPointer)NULL, NULL}};
static struct PushButtonRow buttons[] = {
{ "ok", unitcellExit, (XtPointer)TRUE, NULL },
{ "cancel", unitcellExit, (XtPointer)FALSE, NULL },
};
char line[]=" value";
register int i;
/* This function creates the dialog for the "Unit cell" option */
millerPlane();
if (windows[VIEWER].set < 0)
mol=&molecules[0];
else
mol=&molecules[windows[VIEWER].set];
setMenuItem(VIEWER_UNITCELL, False);
showUnitCell_save=showUnitCell;
showMiller_save=mol->unitcell->showMiller;
cellFactor_save[0]=mol->unitcell->factor[0];
cellFactor_save[1]=mol->unitcell->factor[1];
cellFactor_save[2]=mol->unitcell->factor[2];
miller_save[0]=mol->unitcell->miller[0];
miller_save[1]=mol->unitcell->miller[1];
miller_save[2]=mol->unitcell->miller[2];
dialog=initShell(windows[VIEWER].widget, "unitcellForm", &board,
&form);
checkbox_button[1].client_data=(XtPointer)&(mol->unitcell->showMiller);
togglebox=CreateToggleBox(form, checkbox_button, XtNumber(checkbox_button),
XmHORIZONTAL, 1, False, ((mol->unitcell->showMiller << 1) | showUnitCell));
millerButton=checkbox_button[1].widget;
sep=XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, form,
NULL);
form1=XtVaCreateWidget("rowcolumn", xmRowColumnWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNpacking, XmPACK_COLUMN,
XmNnumColumns, (short)3,
NULL);
for (i=0; i<3; i++)
{
line[0]=(char)(97+i);
cellWidgets[i]=XtVaCreateManagedWidget(line, xmScaleWidgetClass, form1,
XmNorientation, XmHORIZONTAL,
XmNshowValue, True,
XmNsensitive, True,
NULL);
XtVaGetValues(cellWidgets[i], XmNdecimalPoints, &decimals, NULL);
XtVaSetValues(cellWidgets[i], XmNvalue, (int)(mol->unitcell->factor[i]*pow(10.0,
(double)decimals)), NULL);
cellSliders[i].number=&(mol->unitcell->factor[i]);
cellSliders[i].decimals=decimals;
cellSliders[i].draw=(void (*)())drawMolecule;
XtAddCallback(cellWidgets[i], XmNvalueChangedCallback, (XtCallbackProc)makeNewCell,
&cellSliders[i]);
line[0]=(char)(104+i);
if (i > 0) line[0]+=2;
millerWidgets[i]=XtVaCreateManagedWidget(line, xmScaleWidgetClass, form1,
XmNorientation, XmHORIZONTAL,
XmNshowValue, True,
XmNsensitive, True,
XmNdecimalPoints, 0,
XmNvalue, mol->unitcell->miller[i],
NULL);
miller[i]=(double)(mol->unitcell->miller[i]);
millerSliders[i].number=&miller[i];
millerSliders[i].decimals=0;
millerSliders[i].draw=(void (*)())drawMolecule;
XtAddCallback(millerWidgets[i], XmNvalueChangedCallback, (XtCallbackProc)makeMillerPlane,
&millerSliders[i]);
}
XtManageChild(form1);
sep=XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, form,
NULL);
CreatePushButtonRow(form, buttons, XtNumber(buttons));
XtAddCallback(dialog, XmNpopupCallback, (XtCallbackProc)MapBox,
(XmAnyCallbackStruct *)NULL);
XtManageChild(form);
XtManageChild(board);
}
void unitcellExit(Widget button, caddr_t which,
XmPushButtonCallbackStruct *data)
{
XtDestroyWidget(dialog);
dialog=NULL;
if (!(int)which)
{
showUnitCell=showUnitCell_save;
mol->unitcell->showMiller=showMiller_save;
if (mol->unitcell->factor[0] != cellFactor_save[0] ||
mol->unitcell->factor[1] != cellFactor_save[1] ||
mol->unitcell->factor[2] != cellFactor_save[2])
{
mol->unitcell->factor[0]=cellFactor_save[0];
mol->unitcell->factor[1]=cellFactor_save[1];
mol->unitcell->factor[2]=cellFactor_save[2];
expandCell(TRUE, TRUE);
}
mol->unitcell->miller[0]=miller_save[0];
mol->unitcell->miller[1]=miller_save[1];
mol->unitcell->miller[2]=miller_save[2];
redraw(VIEWER);
}
setMenuItem(VIEWER_UNITCELL, True);
}
void setCellSliders(struct MOLECULE *mol)
{
short decimals;
register int i;
if (dialog)
{
for (i=0; i<3; i++)
{
XtVaGetValues(cellWidgets[i], XmNdecimalPoints, &decimals, NULL);
XtVaSetValues(cellWidgets[i], XmNvalue, (int)(mol->unitcell->factor[i]*pow(10.0,
(double)decimals)), NULL);
}
}
}
void makeNewCell(Widget w, struct SLIDER *slider, XmScrollBarCallbackStruct *data)
{
GetSlider(w, slider, data);
expandCell(TRUE, TRUE);
redraw(VIEWER);
}
void makeMillerPlane(Widget w, struct SLIDER *slider, XmScrollBarCallbackStruct *data)
{
static int save=(-1);
GetSlider(w, slider, data);
mol->unitcell->miller[0]=(int)(miller[0]);
mol->unitcell->miller[1]=(int)(miller[1]);
mol->unitcell->miller[2]=(int)(miller[2]);
if (mol->unitcell->miller[0] == 0 && mol->unitcell->miller[1] == 0 && mol->unitcell->miller[2] == 0)
{
save=mol->unitcell->showMiller;
mol->unitcell->showMiller=FALSE;
XtVaSetValues(millerButton, XmNsensitive, False,
XmNset, False,
NULL);
}
else
{
if (save != -1) mol->unitcell->showMiller=save;
XtVaSetValues(millerButton, XmNsensitive, True, NULL);
if (save == TRUE)
XtVaSetValues(millerButton, XmNset, True, NULL);
if (mol->unitcell->miller[0] != miller_save[0] || mol->unitcell->miller[1] != miller_save[1] ||
mol->unitcell->miller[2] != miller_save[2]) millerPlane();
}
redraw(VIEWER);
}
viewmol-2.4.1/source/coledit.c 0100644 0002727 0002727 00000075307 07752675356 014474 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* C O L E D I T . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: coledit.c,v 1.6 2003/11/07 10:58:54 jrh Exp $
* $Log: coledit.c,v $
* Revision 1.6 2003/11/07 10:58:54 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:03:02 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:24:58 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:45:41 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:11 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:40:03 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
#include "dialog.h"
void colorEditor(Widget, caddr_t, XmAnyCallbackStruct *);
void colorEditorExit(Widget, caddr_t, XmPushButtonCallbackStruct *);
void GetColor(Widget, caddr_t, XmToggleButtonCallbackStruct *);
void SetColor(Widget, float *, XmScrollBarCallbackStruct *);
void getRGBColor(Widget, Pixel, float *, float *, float *);
void storeColor(Pixel, struct WINDOW *, int);
void SetSmooth(Widget, int *, XmToggleButtonCallbackStruct *);
XVisualInfo *getVisualInfo(Display *, Visual *);
Colormap getRGBcolormap(Display *, int, XVisualInfo *);
extern Widget CreatePushButtonRow(Widget, struct PushButtonRow *, int);
extern void MapBox(Widget, caddr_t, XmAnyCallbackStruct *);
extern void GetMessageBoxButton(Widget, XtPointer, caddr_t);
extern Pixel getPixel(int);
extern void redraw(int);
extern char *getStringResource(Widget, char *);
extern int getIntResource(Widget, char *);
extern void setMenuItem(int, int);
extern void *getmem(size_t, size_t);
extern void *expmem(void *, size_t, size_t);
extern void fremem(void **);
extern int messgb(Widget, int, char *, struct PushButtonRow *, int);
extern Widget initShell(Widget, char *, Widget *, Widget *);
extern Widget topShell;
extern struct MOLECULE *molecules;
extern struct WINDOW windows[];
extern struct ELEMENT *elements;
extern Pixel stdcol[9], historyColor;
extern float historyColor_rgb[4];
extern int rgbMode, ne, debug, projectionMode;
extern int nmolecule;
static Widget dialog, red, green, blue, button[9];
static Pixel pixelSave;
static float rSave, gSave, bSave;
static int window, where, smoothSave;
void colorEditor(Widget widget, caddr_t which, XmAnyCallbackStruct *data)
{
Widget board, form, form1, form2=(Widget)0, smoothRed, smoothGreen, smoothBlue;
Pixmap selected, unselected;
Pixel p;
static struct PushButtonRow buttons[] = {
{ "ok", colorEditorExit, (XtPointer)TRUE, NULL },
{ "cancel", colorEditorExit, (XtPointer)FALSE, NULL }
};
static unsigned char selectedData[] = {
0xff, 0xff, 0xff, 0x01, 0x00, 0x80, 0x01, 0x00, 0xb8, 0x01, 0x00, 0xb8,
0x01, 0x00, 0x9c, 0x01, 0x00, 0x9c, 0x01, 0x00, 0x8e, 0x01, 0x00, 0x8e,
0x01, 0x00, 0x87, 0x01, 0x00, 0x87, 0x01, 0x80, 0x83, 0x01, 0x80, 0x83,
0x01, 0x80, 0x81, 0x19, 0xc0, 0x81, 0x39, 0xc0, 0x80, 0x71, 0xe0, 0x80,
0xe1, 0x60, 0x80, 0xc1, 0x71, 0x80, 0x81, 0x33, 0x80, 0x01, 0x3f, 0x80,
0x01, 0x1e, 0x80, 0x01, 0x1c, 0x80, 0x01, 0x00, 0x80, 0xff, 0xff, 0xff};
static unsigned char unselectedData[] = {
0xff, 0xff, 0xff, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80,
0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0xff, 0xff, 0xff};
float *c=NULL, r, g, b, r1, g1, b1;
int depth;
char buttonName[8];
register int i, j;
/* This function creates the dialog for the color editor */
setMenuItem(VIEWER_FOREGROUND, False);
setMenuItem(VIEWER_BACKGROUND, False);
if (windows[SPECTRUM].widget != 0)
{
setMenuItem(SPECTRUM_FOREGROUND, False);
setMenuItem(SPECTRUM_BACKGROUND, False);
}
if (windows[MO].widget != 0)
{
setMenuItem(MO_FOREGROUND, False);
setMenuItem(MO_BACKGROUND, False);
}
if (windows[HISTORY].widget != 0)
{
setMenuItem(HISTORY_ENERGY, False);
setMenuItem(HISTORY_GRADIENT, False);
setMenuItem(HISTORY_BACKGROUND, False);
}
window=(int)which & 0x7;
where=((int)which & 0xFFFFFFF8) >> 3;
dialog=initShell(topShell, "colorEditor", &board, &form);
form1=XtVaCreateWidget("controlarea1", xmRowColumnWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNradioBehavior, True,
NULL);
switch (where)
{
case BACKGROUND: if (rgbMode)
{
r=windows[window].background_rgb[0];
g=windows[window].background_rgb[1];
b=windows[window].background_rgb[2];
pixelSave=-1;
}
else
{
getRGBColor(windows[window].widget, windows[window].background, &r, &g, &b);
pixelSave=windows[window].background;
}
break;
case FOREGROUND: if (rgbMode)
{
r=windows[window].foreground_rgb[0];
g=windows[window].foreground_rgb[1];
b=windows[window].foreground_rgb[2];
pixelSave=-1;
}
else
{
getRGBColor(windows[window].widget, windows[window].foreground, &r, &g, &b);
pixelSave=windows[window].foreground;
}
break;
case GNORM: if (rgbMode)
{
r=historyColor_rgb[0];
g=historyColor_rgb[1];
b=historyColor_rgb[2];
pixelSave=-1;
}
else
{
getRGBColor(windows[window].widget, historyColor, &r, &g, &b);
pixelSave=historyColor;
}
break;
}
XtVaGetValues(topShell, XtNdepth, &depth, NULL);
j=WHITE;
for (i=0; i<=MAGENTA; i++)
{
sprintf(buttonName, "button%1d", i);
p=getPixel(i);
selected=XCreatePixmapFromBitmapData(XtDisplay(dialog), XtWindow(dialog),
(char *)selectedData, 24, 24, stdcol[j], p, depth);
unselected=XCreatePixmapFromBitmapData(XtDisplay(dialog), XtWindow(dialog),
(char *)unselectedData, 24, 24, stdcol[BLACK], p, depth);
button[i]=XtVaCreateManagedWidget(buttonName, xmToggleButtonWidgetClass, form1,
XmNlabelType, XmPIXMAP,
XmNlabelPixmap, unselected,
XmNselectPixmap, selected,
XmNindicatorOn, False,
NULL);
XtAddCallback(button[i], XmNvalueChangedCallback, (XtCallbackProc)GetColor, (caddr_t)i);
getRGBColor(button[i], p, &r1, &g1, &b1);
if (r1 == r && g1 == g && b1 == b) XtVaSetValues(button[i], XmNset, True, NULL);
j=BLACK;
}
if (rgbMode && where == BACKGROUND && window == VIEWER)
{
form2=XtVaCreateWidget("controlarea2", xmRowColumnWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, form1,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
smoothRed=XtVaCreateManagedWidget("smoothRed", xmToggleButtonWidgetClass, form2,
XtVaTypedArg, XmNforeground, XmRString, "Red", 4,
NULL);
XtAddCallback(smoothRed, XmNvalueChangedCallback, (XtCallbackProc)SetSmooth,
(XtPointer)1);
if (windows[window].smooth & 1) XtVaSetValues(smoothRed, XmNset, True, NULL);
smoothGreen=XtVaCreateManagedWidget("smoothGreen", xmToggleButtonWidgetClass, form2,
XtVaTypedArg, XmNforeground, XmRString, "Green", 6,
NULL);
XtAddCallback(smoothGreen, XmNvalueChangedCallback, (XtCallbackProc)SetSmooth,
(XtPointer)2);
if (windows[window].smooth & 2) XtVaSetValues(smoothGreen, XmNset, True, NULL);
smoothBlue=XtVaCreateManagedWidget("smoothBlue", xmToggleButtonWidgetClass, form2,
XtVaTypedArg, XmNforeground, XmRString, "Blue", 5,
NULL);
XtAddCallback(smoothBlue, XmNvalueChangedCallback, (XtCallbackProc)SetSmooth,
(XtPointer)4);
if (windows[window].smooth & 4) XtVaSetValues(smoothBlue, XmNset, True, NULL);
}
rSave=r;
gSave=g;
bSave=b;
red=XtVaCreateManagedWidget("red", xmScaleWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XtVaTypedArg, XmNtroughColor, XmRString, "Red", 4,
XtVaTypedArg, XmNforeground, XmRString, "Red", 4,
XmNvalue, (int)(1000.*r),
XmNminimum, 0,
XmNmaximum, 1000,
XmNdecimalPoints, 3,
XmNshowValue, True,
XmNsensitive, True,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
switch (where)
{
case FOREGROUND: c=&windows[window].foreground_rgb[0];
break;
case BACKGROUND: c=&windows[window].background_rgb[0];
break;
case GNORM: c=&historyColor_rgb[0];
break;
}
XtAddCallback(red, XmNvalueChangedCallback, (XtCallbackProc)SetColor, c);
XtAddCallback(red, XmNdragCallback, (XtCallbackProc)SetColor, c);
green=XtVaCreateManagedWidget("green", xmScaleWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XtVaTypedArg, XmNtroughColor, XmRString, "Green", 6,
XtVaTypedArg, XmNforeground, XmRString, "Green", 6,
XmNvalue, (int)(1000.*g),
XmNminimum, 0,
XmNmaximum, 1000,
XmNdecimalPoints, 3,
XmNshowValue, True,
XmNsensitive, True,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
switch (where)
{
case FOREGROUND: c=&windows[window].foreground_rgb[1];
break;
case BACKGROUND: c=&windows[window].background_rgb[1];
break;
case GNORM: c=&historyColor_rgb[1];
break;
}
XtAddCallback(green, XmNvalueChangedCallback, (XtCallbackProc)SetColor, c);
XtAddCallback(green, XmNdragCallback, (XtCallbackProc)SetColor, c);
blue=XtVaCreateManagedWidget("blue", xmScaleWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XtVaTypedArg, XmNtroughColor, XmRString, "Blue", 5,
XtVaTypedArg, XmNforeground, XmRString, "Blue", 5,
XmNvalue, (int)(1000.*b),
XmNminimum, 0,
XmNmaximum, 1000,
XmNdecimalPoints, 3,
XmNshowValue, True,
XmNsensitive, True,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
switch (where)
{
case FOREGROUND: c=&windows[window].foreground_rgb[2];
break;
case BACKGROUND: c=&windows[window].background_rgb[2];
break;
case GNORM: c=&historyColor_rgb[2];
break;
}
XtAddCallback(blue, XmNvalueChangedCallback, (XtCallbackProc)SetColor, c);
XtAddCallback(blue, XmNdragCallback, (XtCallbackProc)SetColor, c);
XtManageChild(form1);
if (rgbMode && where == BACKGROUND && window == VIEWER) XtManageChild(form2);
CreatePushButtonRow(form, buttons, 2);
XtAddCallback(dialog, XmNpopupCallback, (XtCallbackProc)MapBox, (XmAnyCallbackStruct *)NULL);
XtManageChild(form);
XtManageChild(board);
}
void colorEditorExit(Widget widget, caddr_t which, XmPushButtonCallbackStruct *data)
{
XColor c;
Colormap colormap;
XtDestroyWidget(dialog);
if (!(int)which)
{
switch (where)
{
case BACKGROUND: windows[window].background=pixelSave;
windows[window].background_rgb[0]=rSave;
windows[window].background_rgb[1]=gSave;
windows[window].background_rgb[2]=bSave;
windows[window].smooth=smoothSave;
break;
case FOREGROUND: windows[window].foreground=pixelSave;
windows[window].foreground_rgb[0]=rSave;
windows[window].foreground_rgb[1]=gSave;
windows[window].foreground_rgb[2]=bSave;
break;
case GNORM: historyColor=pixelSave;
historyColor_rgb[0]=rSave;
historyColor_rgb[1]=gSave;
historyColor_rgb[2]=bSave;
break;
}
if (!rgbMode)
{
c.pixel=pixelSave;
c.red=(unsigned short)(rSave*65535.+0.5);
c.green=(unsigned short)(gSave*65535.+0.5);
c.blue=(unsigned short)(bSave*65535.+0.5);
c.flags=DoRed | DoGreen | DoBlue;
XtVaGetValues(windows[window].widget,
XmNcolormap, &colormap,
NULL);
XStoreColor(XtDisplay(windows[window].widget), colormap, &c);
}
redraw(window);
}
if (projectionMode != ORTHO) setMenuItem(VIEWER_FOREGROUND, True);
setMenuItem(VIEWER_BACKGROUND, True);
if (windows[SPECTRUM].widget != 0)
{
setMenuItem(SPECTRUM_FOREGROUND, True);
setMenuItem(SPECTRUM_BACKGROUND, True);
}
if (windows[MO].widget != 0)
{
setMenuItem(MO_FOREGROUND, True);
setMenuItem(MO_BACKGROUND, True);
}
if (windows[HISTORY].widget != 0)
{
setMenuItem(HISTORY_ENERGY, True);
setMenuItem(HISTORY_GRADIENT, True);
setMenuItem(HISTORY_BACKGROUND, True);
}
}
void GetColor(Widget widget, caddr_t which, XmToggleButtonCallbackStruct *data)
{
XColor c;
Colormap colormap;
float r, g, b;
if (data->set)
{
getRGBColor(widget, stdcol[(int)which], &r, &g, &b);
switch (where)
{
case BACKGROUND: windows[window].background_rgb[0]=r;
windows[window].background_rgb[1]=g;
windows[window].background_rgb[2]=b;
c.pixel=windows[window].background;
break;
case FOREGROUND: windows[window].foreground_rgb[0]=r;
windows[window].foreground_rgb[1]=g;
windows[window].foreground_rgb[2]=b;
c.pixel=windows[window].foreground;
break;
case GNORM: historyColor_rgb[0]=r;
historyColor_rgb[1]=g;
historyColor_rgb[2]=b;
c.pixel=historyColor;
break;
}
XtVaSetValues(red, XmNvalue, (int)(1000.*r), NULL);
XtVaSetValues(green, XmNvalue, (int)(1000.*g), NULL);
XtVaSetValues(blue, XmNvalue, (int)(1000.*b), NULL);
if (!rgbMode)
{
c.red=(unsigned short)(r*65535.+0.5);
c.green=(unsigned short)(g*65535.+0.5);
c.blue=(unsigned short)(b*65535.+0.5);
c.flags=DoRed | DoGreen | DoBlue;
XtVaGetValues(widget,
XmNcolormap, &colormap,
NULL);
XStoreColor(XtDisplay(windows[window].widget), colormap, &c);
}
redraw(window);
}
}
void SetColor(Widget widget, float *color, XmScrollBarCallbackStruct *data)
{
Colormap colormap;
XColor c;
float r, g, b;
register int i;
*color=0.001*(double)(data->value);
switch (where)
{
case BACKGROUND: c.pixel=windows[window].background;
c.red=(unsigned short)(windows[window].background_rgb[0]*65535.+0.5);
c.green=(unsigned short)(windows[window].background_rgb[1]*65535.+0.5);
c.blue=(unsigned short)(windows[window].background_rgb[2]*65535.+0.5);
break;
case FOREGROUND: c.pixel=windows[window].foreground;
c.red=(unsigned short)(windows[window].foreground_rgb[0]*65535.+0.5);
c.green=(unsigned short)(windows[window].foreground_rgb[1]*65535.+0.5);
c.blue=(unsigned short)(windows[window].foreground_rgb[2]*65535.+0.5);
break;
case GNORM: c.pixel=historyColor;
c.red=(unsigned short)(historyColor_rgb[0]*65535.+0.5);
c.green=(unsigned short)(historyColor_rgb[1]*65535.+0.5);
c.blue=(unsigned short)(historyColor_rgb[2]*65535.+0.5);
break;
}
if (!rgbMode)
{
c.flags=DoRed | DoGreen | DoBlue;
XtVaGetValues(windows[window].widget,
XmNcolormap, &colormap,
NULL);
XStoreColor(XtDisplay(windows[window].widget), colormap, &c);
}
for (i=0; i<=MAGENTA; i++)
{
XtVaSetValues(button[i], XmNset, False, NULL);
getRGBColor(button[i], stdcol[i], &r, &g, &b);
if ((unsigned short)(65535.*r+0.5) == c.red && (unsigned short)(65535.*g+0.5) == c.green
&& (unsigned short)(65535.*b+0.5) == c.blue)
{
XtVaSetValues(button[i], XmNset, True, NULL);
break;
}
}
redraw(window);
}
void getRGBColor(Widget widget, Pixel pixel, float *r, float *g, float *b)
{
Display *display;
Colormap colormap;
XColor color;
display=XtDisplay(widget);
XtVaGetValues(widget, XmNcolormap, &colormap, NULL);
color.pixel=pixel;
XQueryColor(display, colormap, &color);
*r=(float)(color.red)/65535.;
*g=(float)(color.green)/65535.;
*b=(float)(color.blue)/65535.;
}
void storeColor(Pixel pixel, struct WINDOW *window, int where)
{
Display *display;
Colormap colormap;
XColor c;
switch (where)
{
case BACKGROUND: getRGBColor(window->widget, pixel, &(window->background_rgb[0]),
&(window->background_rgb[1]), &(window->background_rgb[2]));
break;
case FOREGROUND: getRGBColor(window->widget, pixel, &(window->foreground_rgb[0]),
&(window->foreground_rgb[1]), &(window->foreground_rgb[2]));
break;
case GNORM: display=XtDisplay(window->widget);
XtVaGetValues(window->widget, XmNcolormap, &colormap, NULL);
c.pixel=pixel;
XQueryColor(display, colormap, &c);
historyColor_rgb[0]=(float)(c.red)/65535.;
historyColor_rgb[1]=(float)(c.green)/65535.;
historyColor_rgb[2]=(float)(c.blue)/65535.;
break;
}
if (rgbMode) return;
/*if (rgbMode)
colormap=DefaultColormapOfScreen(XtScreen(window->widget));
else*/
XtVaGetValues(window->widget, XmNcolormap, &colormap, NULL);
c.flags=DoRed | DoGreen | DoBlue;
switch (where)
{
case BACKGROUND: c.pixel=window->background;
c.red=(unsigned short)(window->background_rgb[0]*65535.+0.5);
c.green=(unsigned short)(window->background_rgb[1]*65535.+0.5);
c.blue=(unsigned short)(window->background_rgb[2]*65535.+0.5);
break;
case FOREGROUND: c.pixel=window->foreground;
c.red=(unsigned short)(window->foreground_rgb[0]*65535.+0.5);
c.green=(unsigned short)(window->foreground_rgb[1]*65535.+0.5);
c.blue=(unsigned short)(window->foreground_rgb[2]*65535.+0.5);
break;
case GNORM: c.pixel=historyColor;
c.red=(unsigned short)(historyColor_rgb[0]*65535.+0.5);
c.green=(unsigned short)(historyColor_rgb[1]*65535.+0.5);
c.blue=(unsigned short)(historyColor_rgb[2]*65535.+0.5);
break;
}
XStoreColor(XtDisplay(window->widget), colormap, &c);
}
void loadColorMap(void)
{
char *colorname[9] = { "black", "white", "red", "green", "blue", "yellow",
"magenta", "cyan1", "SkyBlue"};
Display *display;
Colormap colormap;
XColor hardwarecolor, exactcolor;
register int i;
display=XtDisplay(windows[VIEWER].widget);
XtVaGetValues(windows[VIEWER].widget,
XmNcolormap, &colormap,
NULL);
for (i=0; i<9; i++)
{
if (XAllocNamedColor(display, colormap, colorname[i], &hardwarecolor,
&exactcolor))
stdcol[i]=hardwarecolor.pixel;
else
stdcol[i]=0L;
}
}
void loadAtomColors(XVisualInfo *visualInfo, Colormap colormap)
{
static struct PushButtonRow buttons[] = {{"exit", GetMessageBoxButton, (XtPointer)0, NULL}};
static unsigned long *pixels;
static int allocated=0;
Display *display;
XColor c;
float r, g, b;
unsigned long nramp;
struct ELEMENT **e;
char *word;
size_t total=0;
int reserved=0, count=0, hasOrbitals=FALSE;
register int i, j, k;
for (i=0; icolormap_size-20-reserved)/count;
pixels=(unsigned long *)getmem((size_t)(nramp*count), sizeof(unsigned long));
while (!XAllocColorCells(display, colormap, True, NULL, 0, pixels,
(unsigned long)(nramp*count-reserved)))
{
nramp--;
if (nramp < 3)
{
word=getStringResource(topShell, "noColors");
messgb(topShell, 3, word, buttons, 1);
exit(-1);
}
}
allocated=nramp*count-reserved;
}
else
nramp=(allocated+reserved)/count;
if (reserved) nramp-=reserved/count+1;
if (debug) printf("%ld colors per atom available.\n", nramp);
k=0;
c.flags=DoRed | DoGreen | DoBlue;
for (i=0; idark[0];
g=e[i]->dark[1];
b=e[i]->dark[2];
c.pixel=pixels[k];
c.red=(unsigned short)(r*65535.+0.5);
c.green=(unsigned short)(g*65535.+0.5);
c.blue=(unsigned short)(b*65535.+0.5);
XStoreColor(display, colormap, &c);
e[i]->colormap[0]=pixels[k++];
r=(e[i]->light[0]-e[i]->dark[0])/(nramp-1);
g=(e[i]->light[1]-e[i]->dark[1])/(nramp-1);
b=(e[i]->light[2]-e[i]->dark[2])/(nramp-1);
for (j=1; jdark[0]+j*r)*65535.+0.5);
c.green=(unsigned short)((e[i]->dark[1]+j*g)*65535.+0.5);
c.blue=(unsigned short)((e[i]->dark[2]+j*b)*65535.+0.5);
XStoreColor(display, colormap, &c);
if (j == nramp/2) e[i]->colormap[1]=pixels[k];
k++;
}
r=e[i]->light[0];
g=e[i]->light[1];
b=e[i]->light[2];
c.pixel=pixels[k];
c.red=(unsigned short)(r*65535.+0.5);
c.green=(unsigned short)(g*65535.+0.5);
c.blue=(unsigned short)(b*65535.+0.5);
XStoreColor(display, colormap, &c);
e[i]->colormap[2]=pixels[k++];
}
}
fremem((void **)&e);
}
void allocWindowColors(void)
{
static struct PushButtonRow buttons[] = {{"exit", GetMessageBoxButton, (XtPointer)0, NULL}};
Display *display;
Colormap colormap;
Pixel pixel;
unsigned long ncolors=9, *pixels;
char *word;
register int i;
if (rgbMode)
{
XtVaGetValues(windows[VIEWER].widget, XmNbackground, &pixel, NULL);
getRGBColor(windows[VIEWER].widget, pixel, &(windows[VIEWER].background_rgb[0]),
&(windows[VIEWER].background_rgb[1]), &(windows[VIEWER].background_rgb[2]));
XtVaGetValues(windows[VIEWER].widget, XmNforeground, &pixel, NULL);
getRGBColor(windows[VIEWER].widget, pixel, &(windows[VIEWER].foreground_rgb[0]),
&(windows[VIEWER].foreground_rgb[1]), &(windows[VIEWER].foreground_rgb[2]));
windows[VIEWER].background_rgb[3]=1.0;
windows[VIEWER].foreground_rgb[3]=1.0;
}
else
{
display=XtDisplay(windows[VIEWER].widget);
XtVaGetValues(windows[VIEWER].widget, XmNcolormap, &colormap, NULL);
pixels=(unsigned long *)getmem((size_t)ncolors, sizeof(unsigned long));
if (!XAllocColorCells(display, colormap, True, NULL, 0, pixels, ncolors))
{
word=getStringResource(topShell, "noColors");
messgb(topShell, 3, word, buttons, 1);
exit(-1);
}
i=0;
windows[VIEWER].background=pixels[i++];
windows[VIEWER].foreground=pixels[i++];
windows[SPECTRUM].background=pixels[i++];
windows[SPECTRUM].foreground=pixels[i++];
windows[HISTORY].background=pixels[i++];
windows[HISTORY].foreground=pixels[i++];
historyColor=pixels[i++];
windows[MO].background=pixels[i++];
windows[MO].foreground=pixels[i++];
XtVaGetValues(windows[VIEWER].widget, XmNbackground, &pixel, NULL);
storeColor(pixel, &windows[VIEWER], BACKGROUND);
XtVaGetValues(windows[VIEWER].widget, XmNforeground, &pixel, NULL);
storeColor(pixel, &windows[VIEWER], FOREGROUND);
fremem((void **)&pixels);
}
}
void SetSmooth(Widget widget, int *which, XmToggleButtonCallbackStruct *data)
{
if (data->set) windows[window].smooth |= (int)which;
else windows[window].smooth &= ~(int)which;
redraw(window);
}
XVisualInfo *getVisualInfo(Display *display, Visual *vi)
{
XVisualInfo template;
int items;
template.visual=vi;
template.visualid=vi->visualid;
/* leaks memory */
return(XGetVisualInfo(display, VisualIDMask, &template, &items));
}
Colormap getRGBcolormap(Display *dpy, int scrnum, XVisualInfo *visinfo)
{
/*
* Return an X colormap to use for OpenGL RGB-mode rendering.
* Input: dpy - the X display
* scrnum - the X screen number
* visinfo - the XVisualInfo as returned by glXChooseVisual()
* Return: an X Colormap or 0 if there's a _serious_ error.
*/
Atom hp_cr_maps;
Status status;
int numCmaps, i, using_mesa;
XStandardColormap *standardCmaps;
Window root = RootWindow(dpy,scrnum);
/*
* First check if visinfo's visual matches the default/root visual.
*/
if (visinfo->visual==DefaultVisual(dpy,scrnum)) {
/* use the default/root colormap */
return DefaultColormap( dpy, scrnum );
}
/*
* Check if we're using Mesa.
*/
if (strstr(glXQueryServerString( dpy, scrnum, GLX_VERSION ), "Mesa")) {
using_mesa = 1;
}
else {
using_mesa = 0;
}
/*
* Next, if we're using Mesa and displaying on an HP with the "Color
* Recovery" feature and the visual is 8-bit TrueColor, search for a
* special colormap initialized for dithering. Mesa will know how to
* dither using this colormap.
*/
if (using_mesa) {
hp_cr_maps = XInternAtom( dpy, "_HP_RGB_SMOOTH_MAP_LIST", True );
if (hp_cr_maps
&& visinfo->visual->class==TrueColor
&& visinfo->depth==8) {
status = XGetRGBColormaps( dpy, root, &standardCmaps,
&numCmaps, hp_cr_maps );
if (status) {
for (i=0; i < numCmaps; i++) {
if (standardCmaps[i].visualid==visinfo->visual->visualid) {
Colormap cmap = standardCmaps[i].colormap;
XFree(standardCmaps);
return cmap;
}
}
XFree(standardCmaps);
}
}
}
/*
* Next, try to find a standard X colormap.
*/
#ifndef SOLARIS_BUG
status = XmuLookupStandardColormap( dpy, visinfo->screen,
visinfo->visualid,
visinfo->depth,
XA_RGB_DEFAULT_MAP,
/* replace */ False,
/* retain */ True);
if (status == 1) {
status = XGetRGBColormaps( dpy, root, &standardCmaps,
&numCmaps, XA_RGB_DEFAULT_MAP);
if (status == 1) {
for (i = 0; i < numCmaps; i++) {
if (standardCmaps[i].visualid == visinfo->visualid) {
Colormap cmap = standardCmaps[i].colormap;
XFree(standardCmaps);
return cmap;
}
}
XFree(standardCmaps);
}
}
#endif
/*
* If we get here, give up and just allocate a new colormap.
*/
return XCreateColormap( dpy, root, visinfo->visual, AllocNone );
}
viewmol-2.4.1/source/confform.c 0100644 0002727 0002727 00000023653 07752675370 014653 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* C O N F F O R M . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: confform.c,v 1.4 2003/11/07 10:59:04 jrh Exp $
* $Log: confform.c,v $
* Revision 1.4 2003/11/07 10:59:04 jrh
* Release 2.4
*
* Revision 1.3 2000/12/10 15:03:36 jrh
* Release 2.3
*
* Revision 1.2 1999/05/24 01:25:00 jrh
* Release 2.2.1
*
* Revision 1.1 1999/02/07 21:45:59 jrh
* Initial revision
*
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
#include "dialog.h"
void configurationDialog(Widget, caddr_t, XmAnyCallbackStruct *);
void configurationDialogExit(Widget, caddr_t, XmPushButtonCallbackStruct *);
void SetLanguage(Widget, caddr_t, XmToggleButtonCallbackStruct *);
void GetString(Widget, caddr_t, XmAnyCallbackStruct *);
#if defined LINUX || defined DARWIN
int matchXdefaults(const struct dirent *);
#else
int matchXdefaults(struct dirent *);
#endif
extern Widget makeViewerMenu(Widget);
extern void makeSpectrumMenu(void);
extern void makeHistoryMenu(void);
extern void makeMODiagramMenu(void);
extern void MapBox(Widget, caddr_t, XmAnyCallbackStruct *);
extern Widget CreateToggleBox(Widget, struct PushButtonRow *, int, int,
int, int, int);
extern void CreatePushButtonRow(Widget, struct PushButtonRow *, int);
extern char *getStringResource(Widget, char *);
extern void checkProgram(char *, char *);
extern void saveConfiguration(void);
extern void GetMessageBoxButton(Widget, XtPointer, caddr_t);
extern int messgb(Widget, int, char *, struct PushButtonRow *, int);
extern Widget initShell(Widget, char *, Widget *, Widget *);
extern void getFormats(void);
extern void *getmem(size_t, size_t);
extern void fremem(void **);
extern struct WINDOW windows[];
extern Widget topShell;
extern int saveLanguage;
extern char language[], webbrowser[], moloch[], raytracer[], displayImage[];
static Widget dialog;
static XrmDatabase database;
static struct PushButtonRow *radiobox_buttons=NULL;
static char language_save[20];
void configurationDialog(Widget widget, caddr_t which, XmAnyCallbackStruct *data)
{
Widget board, form, sep, b, m, r, d;
Widget radiobox=(Widget)NULL;
struct dirent **namelist;
static struct PushButtonRow buttons[] = {
{ "ok", configurationDialogExit, (XtPointer)1, NULL },
{ "save", configurationDialogExit, (XtPointer)2, NULL },
{ "cancel", configurationDialogExit, (XtPointer)3, NULL }
};
int n, lang=0;
char filename[FILENAME_MAX];
char *p;
register int i;
/* This function creates the configuration dialog */
strcpy(language_save, language);
dialog=initShell(windows[VIEWER].widget, "configurationForm",
&board, &form);
database=XrmGetDatabase(XtDisplay(windows[VIEWER].widget));
strcpy(filename, getenv("VIEWMOLPATH"));
strcat(filename, "/locale");
if ((n=scandir(filename, &namelist, matchXdefaults, alphasort)) > 0)
{
radiobox_buttons=(struct PushButtonRow *)getmem((size_t)n,
sizeof(struct PushButtonRow));
for (i=0; id_name;
radiobox_buttons[i].label=p;
radiobox_buttons[i].callback=SetLanguage;
radiobox_buttons[i].client_data=(XtPointer)p;
radiobox_buttons[i].widget=NULL;
if (!strcmp(language, p)) lang=i;
}
radiobox=CreateToggleBox(form, radiobox_buttons, n,
XmVERTICAL, 4, True, lang);
sep=XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNtraversalOn, False,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, radiobox,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
}
(void)XtVaCreateManagedWidget("browserLabel", xmLabelWidgetClass, form, NULL);
b=XtVaCreateManagedWidget("browser", xmTextWidgetClass, form,
XmNvalue, webbrowser,
NULL);
XtAddCallback(b, XmNvalueChangedCallback, (XtCallbackProc)GetString, webbrowser);
(void)XtVaCreateManagedWidget("molochLabel", xmLabelWidgetClass, form, NULL);
m=XtVaCreateManagedWidget("moloch", xmTextWidgetClass, form,
XmNvalue, moloch,
NULL);
XtAddCallback(m, XmNvalueChangedCallback, (XtCallbackProc)GetString, moloch);
(void)XtVaCreateManagedWidget("raytracerLabel", xmLabelWidgetClass, form, NULL);
r=XtVaCreateManagedWidget("raytracer", xmTextWidgetClass, form,
XmNvalue, raytracer,
NULL);
XtAddCallback(r, XmNvalueChangedCallback, (XtCallbackProc)GetString, raytracer);
(void)XtVaCreateManagedWidget("displayImageLabel", xmLabelWidgetClass, form, NULL);
d=XtVaCreateManagedWidget("displayImage", xmTextWidgetClass, form,
XmNvalue, displayImage,
NULL);
XtAddCallback(d, XmNvalueChangedCallback, (XtCallbackProc)GetString, displayImage);
sep=XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNtraversalOn, False,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, radiobox,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
CreatePushButtonRow(form, buttons, XtNumber(buttons));
XtAddCallback(dialog, XmNpopupCallback, (XtCallbackProc)MapBox, (XmAnyCallbackStruct *)NULL);
XtManageChild(form);
XtManageChild(board);
}
void SetLanguage(Widget button, caddr_t which, XmToggleButtonCallbackStruct *data)
{
char filename[FILENAME_MAX];
if (data->set)
{
strcpy(filename, getenv("VIEWMOLPATH"));
/* strcat(filename, "/Xdefaults.");*/
strcat(filename, "/locale/");
strcat(filename, (char *)which);
strcat(filename, "/Viewmol");
XrmCombineFileDatabase(filename, &database, True);
windows[VIEWER].menu=makeViewerMenu(windows[VIEWER].widget);
if (windows[SPECTRUM].widget != NULL) makeSpectrumMenu();
if (windows[HISTORY].widget != NULL) makeHistoryMenu();
if (windows[MO].widget != NULL) makeMODiagramMenu();
if (strcmp(language, (char *)which)) saveLanguage=TRUE;
strcpy(language, (char *)which);
getFormats();
}
}
void configurationDialogExit(Widget button, caddr_t which, XmPushButtonCallbackStruct *dummy)
{
static struct PushButtonRow buttons[] = {{"ok", GetMessageBoxButton, (XtPointer)0, NULL}};
XmToggleButtonCallbackStruct data;
char *word, line[MAXLENLINE];
switch ((int)which)
{
case 1: checkProgram(line, webbrowser);
if (line[0] == '\0')
{
word=getStringResource(topShell, "wrongBrowser");
messgb(topShell, 0, word, buttons, 1);
}
else
strcpy(webbrowser, line);
checkProgram(line, moloch);
if (line[0] == '\0')
{
word=getStringResource(topShell, "wrongMoloch");
messgb(topShell, 0, word, buttons, 1);
}
else
strcpy(moloch, line);
checkProgram(line, raytracer);
if (line[0] == '\0')
{
if (raytracer[0] != '\0')
{
word=getStringResource(topShell, "noFile");
sprintf(line, word, raytracer);
}
else
{
word=getStringResource(topShell, "noRayshade");
strcpy(line, word);
}
messgb(topShell, 0, line, buttons, 1);
}
else
strcpy(raytracer, line);
checkProgram(line, displayImage);
if (line[0] == '\0')
{
if (displayImage[0] == '\0')
{
word=getStringResource(topShell, "noFile");
sprintf(line, word, displayImage);
}
else
{
word=getStringResource(topShell, "noDisplay");
strcpy(line, word);
}
messgb(topShell, 0, line, buttons, 1);
}
else
strcpy(displayImage, line);
break;
case 2: saveConfiguration();
break;
case 3: data.set=TRUE;
SetLanguage((Widget)0, (caddr_t)language_save, &data);
strcpy(language, language_save);
break;
}
XtDestroyWidget(dialog);
if (radiobox_buttons != NULL) fremem((void **)&radiobox_buttons);
}
void GetString(Widget w, caddr_t text, XmAnyCallbackStruct *data)
{
char *str;
str=XmTextGetString(w);
strcpy((char *)text, str);
}
#if defined LINUX || defined DARWIN
int matchXdefaults(const struct dirent *d)
#else
int matchXdefaults(struct dirent *d)
#endif
{
/*return(!fnmatch("Xdefaults.*", d->d_name, 0));*/
return(fnmatch(".*", d->d_name, 0));
}
viewmol-2.4.1/source/cylinder.c 0100644 0002727 0002727 00000006676 07752675376 014667 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* C Y L I N D E R . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: cylinder.c,v 1.6 2003/11/07 10:59:10 jrh Exp $
* $Log: cylinder.c,v $
* Revision 1.6 2003/11/07 10:59:10 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:03:46 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:25:02 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:46:18 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:17 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:40:09 jrh
* Initial revision
*
*/
#include
#include
#include
extern void (*drawCylinder)(GLUquadricObj *, GLdouble, GLdouble, GLdouble, GLint, GLint);
extern void (*drawCone)(GLUquadricObj *, GLdouble, GLdouble, GLdouble, GLint, GLint);
GLdouble buildRotationMatrix(double x, double y, double z, GLdouble tmat[4][4])
{
double height, d, ca, sa, cb, sb;
height=sqrt((double)(x*x + y*y + z*z));
/* Builds the rotation matrix for rotating a vector defined by
the points (0, 0, 0) and (0, 0, height) to the orientation
(x, y, z) */
if ((d=sqrt((double)(x*x + y*y))) != 0.0)
{
ca=y/d;
sa=x/d;
y=x*sa+y*ca;
}
else
{
ca=1.0;
sa=0.0;
}
if ((d=sqrt((double)(y*y + z*z))) != 0.0)
{
cb=z/d;
sb=y/d;
}
else
{
cb=1.0;
sb=0.0;
}
tmat[0][0]=ca;
tmat[1][0]=sa*cb;
tmat[2][0]=sa*sb;
tmat[3][0]=0.0e0;
tmat[0][1]=(-sa);
tmat[1][1]=ca*cb;
tmat[2][1]=ca*sb;
tmat[3][1]=0.0e0;
tmat[0][2]=0.;
tmat[1][2]=(-sb);
tmat[2][2]=cb;
tmat[3][2]=0.0e0;
tmat[0][3]=tmat[1][3]=tmat[2][3]=0.0e0;
tmat[3][3]=1.0e0;
return(height);
}
void cylinder(double x1, double y1, double z1, double x2, double y2, double z2,
double r, int n, GLenum mode)
{
GLUquadricObj *obj;
double vx=x2-x1, vy=y2-y1, vz=z2-z1;
GLdouble tmat[4][4], height;
height=buildRotationMatrix(vx, vy, vz, tmat);
tmat[3][0]=x1;
tmat[3][1]=y1;
tmat[3][2]=z1;
/* Select drawing function depending on mode */
obj=gluNewQuadric();
gluQuadricDrawStyle(obj, mode);
gluQuadricTexture(obj, GL_TRUE);
if (mode == GLU_FILL) gluQuadricNormals(obj, (GLenum)GLU_SMOOTH);
else gluQuadricNormals(obj, (GLenum)GLU_NONE);
glPushMatrix();
glMultMatrixd((GLdouble *)tmat);
(*drawCylinder)(obj, r, r, height, n, 1);
glPopMatrix();
}
void cone(double x1, double y1, double z1, double x2, double y2, double z2,
double rBase, int n)
{
GLUquadricObj *obj;
double vx=x2-x1, vy=y2-y1, vz=z2-z1;
GLdouble tmat[4][4], height;
height=buildRotationMatrix(vx, vy, vz, tmat);
tmat[3][0]=x1;
tmat[3][1]=y1;
tmat[3][2]=z1;
obj=gluNewQuadric();
gluQuadricDrawStyle(obj, (GLenum)GLU_FILL);
gluQuadricNormals(obj, (GLenum)GLU_SMOOTH);
glPushMatrix();
glMultMatrixd((GLdouble *)tmat);
(*drawCone)(obj, rBase, 0.0e0, height, n, 1);
glPopMatrix();
}
viewmol-2.4.1/source/device.c 0100644 0002727 0002727 00000006663 07752675407 014304 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* D E V I C E . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: device.c,v 1.4 2003/11/07 10:59:19 jrh Exp $
* $Log: device.c,v $
* Revision 1.4 2003/11/07 10:59:19 jrh
* Release 2.4
*
* Revision 1.3 2000/12/10 15:04:26 jrh
* Release 2.3
*
* Revision 1.2 1999/05/24 01:25:04 jrh
* Release 2.2.1
*
* Revision 1.1 1999/02/07 21:46:29 jrh
* Initial revision
*
*
*/
#include
#include
#include
#include
#include
#define MAXLENLINE 80
void findInputDevices(Widget);
extern Widget topShell;
extern int debug;
extern int spaceballButtonPress, spaceballMotionNotify;
static XDevice *spaceball;
static struct {int min;
float range;} axis[6];
void findInputDevices(Widget w)
{
Display *display;
XExtensionVersion *version;
XDeviceInfo *list;
XAnyClassPtr classinfo;
XValuatorInfoPtr info;
XAxisInfoPtr a;
XEventClass eventList[2];
int ndev;
register int i, j, k;
display=XtDisplay(topShell);
version=XGetExtensionVersion(display, "XInputExtension");
if (version == NULL || ((int)version) == NoSuchExtension) return;
XFree(version);
list=XListInputDevices(display, &ndev);
for (i=0; iclass)
{
case ValuatorClass: info=(XValuatorInfoPtr)classinfo;
if (info->num_axes < 6) goto nextDevice;
a=(XAxisInfoPtr)((char *)info+sizeof(XValuatorInfo));
for (k=0; k<6; k++)
{
axis[k].min=a->min_value;
axis[k].range=2.0/(float)(a->max_value-a->min_value);
}
break;
}
classinfo=(XAnyClassPtr)((char *)classinfo+classinfo->length);
}
spaceball=XOpenDevice(display, list[i].id);
DeviceButtonPress(spaceball, spaceballButtonPress, eventList[0]);
DeviceMotionNotify(spaceball, spaceballMotionNotify, eventList[1]);
XSelectExtensionEvent(display, XtWindow(w), eventList, 2);
break;
}
nextDevice:;
}
XFreeDeviceList(list);
}
void switchPointerDevice(void)
{
FILE *file;
char line[MAXLENLINE], command[MAXLENLINE];
if ((file=popen("xsetpointer -l", "r")) != NULL)
{
while (fgets(line, MAXLENLINE, file) != NULL)
{
if (strstr(line, "XExtensionDevice"))
{
strcpy(command, "xsetpointer ");
strcat(command, strtok(line, " \t"));
system(command);
}
}
fclose(file);
}
}
viewmol-2.4.1/source/dialog.h 0100644 0002727 0002727 00000002374 07752712246 014275 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* D I A L O G . H *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: dialog.h,v 1.6 2003/11/07 12:48:38 jrh Exp $
* $Log: dialog.h,v $
* Revision 1.6 2003/11/07 12:48:38 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:04:36 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:25:06 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:46:41 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:20 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:45:27 jrh
* Initial revision
*
*/
struct PushButtonRow
{
char *label;
void (*callback)();
XtPointer client_data;
Widget widget;
};
viewmol-2.4.1/source/distort.c 0100644 0002727 0002727 00000003641 07752675415 014525 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* D I S T O R T . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: distort.c,v 1.6 2003/11/07 10:59:25 jrh Exp $
* $Log: distort.c,v $
* Revision 1.6 2003/11/07 10:59:25 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:04:51 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:25:08 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:46:57 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:24 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:40:16 jrh
* Initial revision
*
*/
#include
#include "viewmol.h"
#include "dialog.h"
extern struct MOLECULE *molecules;
extern struct WINDOW windows[];
void distortGeometry(double);
extern int calcInternal(struct MOLECULE *, int);
extern int ninternal;
void distortGeometry(double factor)
{
struct MOLECULE *mol;
int mode;
register int i, l, n;
mol=&molecules[windows[SPECTRUM].set];
mode=mol->mode;
if (mode != -1)
{
n=mol->na;
if (mol->unitcell) n-=8;
for (i=0; iatoms[i].ref;
mol->atoms[i].x+=factor*mol->cnm[mode+mol->nmodes*l];
mol->atoms[i].y+=factor*mol->cnm[mode+mol->nmodes*(l+1)];
mol->atoms[i].z+=factor*mol->cnm[mode+mol->nmodes*(l+2)];
l+=3;
}
for (i=0; ininternal; i++)
(void)calcInternal(mol, i);
}
}
viewmol-2.4.1/source/draw.c 0100644 0002727 0002727 00000150043 10114366425 013751 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* D R A W . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: draw.c,v 1.7 2004/08/29 14:49:57 jrh Exp $
* $Log: draw.c,v $
* Revision 1.7 2004/08/29 14:49:57 jrh
* Release 2.4.1
*
* Revision 1.6 2003/11/07 10:59:34 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:04:57 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:25:10 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:36:48 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:27 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:40:22 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
int renderMolecule(struct MOLECULE *, int, int);
void wireModel(struct MOLECULE *, Dimension, int);
void stickModel(struct MOLECULE *, int);
void balls(struct MOLECULE *, double, int);
void setAtomProperties(struct ELEMENT *, int);
void drawIntern(struct MOLECULE *);
void drawUnitCell(struct MOLECULE *, Dimension, int);
void drawMillerPlane(struct MOLECULE *, int);
void labelAtoms(struct MOLECULE *, int);
void drawAnnotation(void);
void drawForces(struct MOLECULE *, int);
void drawNormalMode(struct MOLECULE *, int);
void drawArrow(double, double, double, double, double, double);
void drawGround(void);
void setupProjection(int);
void setupModelview(int);
void shadow(GLfloat v0[3], GLfloat v1[3], GLfloat v2[3], GLfloat vector[4]);
void shadowColor(void);
extern void setWindowColor(int, Pixel, const float *);
extern int StringWidth(XFontStruct *, char *);
extern int StringHeight(XFontStruct *);
extern void cone(double, double, double, double, double, double, double, int);
extern double dist(double, double, double, double, double, double);
extern void pixelToWorld(int, double *, double *);
extern void (*drawBegin)(GLenum), (*drawEnd)(void);
extern void (*drawVertex3d)(double, double, double);
extern void (*drawNormal3d)(double, double, double);
extern void (*drawColor4fv)(const GLfloat *);
extern void (*drawSphere)(GLUquadricObj *, GLdouble, GLint, GLint);
extern void (*drawString)(char *, double, double, double, double, GLuint, char);
extern void (*drawLineStipple)(GLint, GLushort);
extern void (*drawLineWidth)(GLfloat);
extern void (*drawDisable)(GLenum);
extern void raytracerBegin(GLenum);
extern void manual(Widget, caddr_t, caddr_t);
extern char *getStringResource(Widget, char *);
extern void printDialog(Widget, caddr_t, XmAnyCallbackStruct *);
extern void marchingCube(struct GRIDOBJECT *, double, int, void (*)(GLenum),
void (*)(void), void (*)(double, double, double),
void (*)(double, double, double), int, int);
extern void ellipse(double, double, double, double, double, double, double,
double, double, int);
extern void cylinder(double, double, double, double, double, double, double,
int, GLenum);
extern void raytracerMaterial(struct ELEMENT *);
extern void transformCoordinates(int, float input[4], float output[4]);
extern void redraw(int);
extern void *getmem(size_t, size_t);
extern void *expmem(void *, size_t, size_t);
extern void fremem(void **);
extern clock_t getCPUTime(void);
extern void scaleAnnotation(float);
extern void moveAnnotation(int, double, double);
extern void selectMolecule(Widget, caddr_t, XmToggleButtonCallbackStruct *);
extern void quaternionToMatrix(int, float *);
extern void incrementQuaternion(double, double, double, float *);
extern void deleteSelection(void);
extern void getScreenCoordinates(double, double, double, double *, double *,
double *);
extern struct MOLECULE *molecules;
extern struct ELEMENT *elements;
extern struct WINDOW windows[];
extern struct ANNOTATION *annotation;
extern Pixel stdcol[9];
extern Widget topShell;
extern GLfloat light0p[], light1p[];
extern int ne, nmolecule;
extern int label, showForces, animate, showUnitCell, showInertia;
extern int primitive, bfatom, lights, moveItem, projectionMode, showHBond;
extern int shadows, ground, drawIcon;
extern double amplitude, forceScale, wnScale;
extern double gridres, sphereres, lineWidth, drawingSpeed;
extern float *transObject, *rotObject;
extern int rgbMode, picking, swapBuffers, selectAtom;
extern int iwavef, interp, debug, setins, nAnnotations;
extern double *grid, level, weight;
extern char *formBondLength, *formBondAngle, *formTorsionAngle;
void drawBackground(int window, Pixel color, double depthBufferClear)
{
float background_rgb[4] = {0.0, 0.0, 1.0, 0.0};
int clear=GL_COLOR_BUFFER_BIT;
if (windows[window].smooth)
{
background_rgb[0]=windows[window].background_rgb[0];
background_rgb[1]=windows[window].background_rgb[1];
background_rgb[2]=windows[window].background_rgb[2];
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
glShadeModel(GL_SMOOTH);
glBegin(GL_POLYGON);
if (windows[window].smooth & 1) background_rgb[0]=0.7;
if (windows[window].smooth & 2) background_rgb[1]=0.7;
if (windows[window].smooth & 4) background_rgb[2]=0.7;
setWindowColor(FOREGROUND, color, background_rgb);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(1.0, 0.0, 0.0);
if (windows[window].smooth & 1) background_rgb[0]=0.3;
if (windows[window].smooth & 2) background_rgb[1]=0.3;
if (windows[window].smooth & 4) background_rgb[2]=0.3;
setWindowColor(FOREGROUND, color, background_rgb);
glVertex3f(1.0, 1.0, 0.0);
glVertex3f(0.0, 1.0, 0.0);
glEnd();
glShadeModel(GL_FLAT);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
clear=GL_DEPTH_BUFFER_BIT;
}
else
{
setWindowColor(BACKGROUND, color, windows[window].background_rgb);
if (depthBufferClear != 0.0) clear|=GL_DEPTH_BUFFER_BIT;
}
if (depthBufferClear != 0.0)
glClearDepth(depthBufferClear);
if (shadows) clear|=GL_STENCIL_BUFFER_BIT;
glClear(clear);
}
void drawMolecule(Widget w, caddr_t client_data, XmDrawingAreaCallbackStruct *data)
{
struct MOLECULE *mol;
double clockTick;
GLfloat light1t[4];
GLfloat light0c[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat light1c[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat ground0[3] = {0.0, 0.0, 0.0};
GLfloat ground1[3] = {1.0, 0.0, 0.0};
GLfloat ground2[3] = {0.0, 0.0, 1.0};
clock_t startTime=0;
Dimension width, height;
int renderMode;
register int found, i;
XtRemoveAllCallbacks(windows[VIEWER].widget, XmNexposeCallback);
XtVaGetValues(windows[VIEWER].widget, XtNwidth, &width, XtNheight, &height, NULL);
startTime=getCPUTime();
glGetIntegerv(GL_RENDER_MODE, &renderMode);
if (renderMode == GL_RENDER && !drawIcon)
glXMakeCurrent(XtDisplay(windows[VIEWER].widget), XtWindow(windows[VIEWER].widget),
windows[VIEWER].context);
if (!picking)
{
drawBackground(VIEWER, windows[VIEWER].background, windows[VIEWER].far);
}
if (nAnnotations > 0) drawAnnotation();
setupProjection(picking);
if (shadows) glPushMatrix();
if (primitive == GLU_FILL && (windows[VIEWER].mode != WIREMODEL || iwavef != ALL_OFF))
{
if (lights & 0x1)
{
glPushMatrix();
quaternionToMatrix(GL_MODELVIEW, &rotObject[4*LIGHTNO0]);
glLightfv(GL_LIGHT0, GL_POSITION, light0p);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0c);
glPopMatrix();
}
if (lights & 0x2)
{
glPushMatrix();
quaternionToMatrix(GL_MODELVIEW, &rotObject[4*LIGHTNO1]);
glLightfv(GL_LIGHT1, GL_POSITION, light1p);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1c);
glPopMatrix();
}
}
if (projectionMode == PERSPECTIVE && ground)
{
drawGround();
}
glTranslatef(transObject[3*WORLD], transObject[3*WORLD+1], transObject[3*WORLD+2]);
quaternionToMatrix(GL_MODELVIEW, &rotObject[4*WORLD]);
for (i=0; i %.1f fps (< %.2f ms per frame)\n", drawingSpeed, 1000./clockTick);
}
XtAddCallback(windows[VIEWER].widget, XmNexposeCallback, (XtCallbackProc)drawMolecule, NULL);
}
int renderMolecule(struct MOLECULE *mol, int width, int lighting)
{
double boxf;
const float black[4] = {0.0, 0.0, 0.0, 1.0};
int prim=GL_LINE_LOOP;
register int i, found=0;
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
if (windows[VIEWER].mode == WIREMODEL || primitive == GLU_POINT)
{
glShadeModel(GL_FLAT);
wireModel(mol, width, lighting);
}
if (primitive != GLU_FILL || windows[VIEWER].mode == WIREMODEL)
glShadeModel(GL_FLAT);
else
{
glShadeModel(GL_SMOOTH);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
if (lighting)
{
glEnable(GL_LIGHTING);
if (lights & 0x1) glEnable(GL_LIGHT0);
if (lights & 0x2) glEnable(GL_LIGHT1);
}
}
if (windows[VIEWER].mode == STICKMODEL || windows[VIEWER].mode == BALLMODEL)
stickModel(mol, lighting);
if (windows[VIEWER].mode == STICKMODEL)
{
if (lighting) glPassThrough((GLfloat)(ADD_DEPTH+(int)(windows[VIEWER].far)));
balls(mol, -(mol->bondRadius), lighting);
if (lighting) glPassThrough((GLfloat)(ADD_DEPTH));
}
if (windows[VIEWER].mode == BALLMODEL)
balls(mol, 0.5, lighting);
if (windows[VIEWER].mode == CUPMODEL)
{
balls(mol, 1.3, lighting);
stickModel(mol, lighting);
}
if (mol->unitcell && showUnitCell)
drawUnitCell(mol, width, lighting);
if (primitive == GLU_FILL) glDisable(GL_CULL_FACE);
if ((mol->imo != -1 || mol->ibasfu != -1 || iwavef != ALL_OFF) && !selectAtom)
{
if (iwavef > DENSITY && iwavef-DENSITY <= mol->ngridobjects)
found=iwavef-DENSITY;
else
{
for (i=0; ingridobjects; i++)
{
if ((mol->gridObjects[i].type & ~GRIDREAD) == iwavef)
{
if ((iwavef == MOLECULAR_ORBITAL && mol->gridObjects[i].mo == mol->imo) ||
(iwavef == BASIS_IN_MO && mol->gridObjects[i].mo == mol->imo &&
mol->gridObjects[i].basisfunction == mol->ibasfu) ||
(iwavef == BASIS_FUNCTION && mol->gridObjects[i].basisfunction == mol->ibasfu) ||
iwavef >= DENSITY)
{
found=i+1;
if (debug) printf("Found MO/basis function: %d\n", found);
break;
}
}
}
}
if (found)
{
boxf=windows[VIEWER].far;
gridres=mol->gridObjects[found-1].resolution;
(*drawLineWidth)((GLfloat)1.);
switch (primitive)
{
case GLU_POINT: prim=GL_POINTS;
break;
case GLU_LINE: prim=GL_LINE_LOOP;
break;
case GLU_FILL: prim=GL_TRIANGLE_STRIP;
break;
}
if (primitive == GLU_FILL)
{
glShadeModel(GL_SMOOTH);
if (lighting)
{
glEnable(GL_LIGHTING);
if (lights & 0x1) glEnable(GL_LIGHT0);
if (lights & 0x2) glEnable(GL_LIGHT1);
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
}
for (i=0; iunitcell != NULL)
glTranslatef(mol->unitcell->corners[0].x, mol->unitcell->corners[0].y,
mol->unitcell->corners[0].z);
else
glTranslatef(mol->transx, mol->transy, mol->transz);
marchingCube(&(mol->gridObjects[found-1]), level, prim, drawBegin,
drawEnd, drawVertex3d, drawNormal3d, interp, debug);
if (iwavef != DENSITY)
{
for (i=0; igridObjects[found-1]), level, prim, drawBegin,
drawEnd, drawVertex3d, drawNormal3d, interp, debug);
level=(-level);
}
glPopMatrix();
glPassThrough((GLfloat)VISIBILITY);
}
}
if (mol->unitcell && mol->unitcell->showMiller)
{
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
drawMillerPlane(mol, lighting);
glDisable(GL_BLEND);
}
if (showForces && !picking) drawForces(mol, lighting);
if (mol->mode != -1 && animate == ARROWS && mol->cnm != NULL)
drawNormalMode(mol, lighting);
glDisable(GL_DEPTH_TEST);
if (primitive == GLU_FILL)
{
glShadeModel(GL_FLAT);
if (lighting)
{
glDisable(GL_LIGHTING);
if (lights & 0x1) glDisable(GL_LIGHT0);
if (lights & 0x2) glDisable(GL_LIGHT1);
}
glDisable(GL_BLEND);
}
if (showInertia)
{
(*drawLineWidth)((GLfloat)1.);
if (lighting)
setWindowColor(FOREGROUND, stdcol[BLACK], black);
else
shadowColor();
ellipse(0.0, 0.0, 0.0, mol->tinert[0][0],
mol->tinert[0][1], mol->tinert[0][2],
mol->tinert[1][0], mol->tinert[1][1],
mol->tinert[1][2], 40);
ellipse(0.0, 0.0, 0.0, mol->tinert[1][0],
mol->tinert[1][1], mol->tinert[1][2],
mol->tinert[2][0], mol->tinert[2][1],
mol->tinert[2][2], 40);
ellipse(0.0, 0.0, 0.0, mol->tinert[2][0],
mol->tinert[2][1], mol->tinert[2][2],
mol->tinert[0][0], mol->tinert[0][1],
mol->tinert[0][2], 40);
}
if (mol->ninternal && lighting) drawIntern(mol);
return(found);
}
void wireModel(struct MOLECULE *mol, Dimension width, int lighting)
{
double x, y, z, nline, sline;
int first, second;
register int i;
if (lineWidth == 0.0)
nline=width*0.005;
else
nline=lineWidth;
sline=2.0*nline;
(*drawLineWidth)((GLfloat)nline);
for (i=0; inb; i++)
{
first=mol->bonds[i].first;
second=mol->bonds[i].second;
x=mol->atoms[first].x+mol->bonds[i].frac
*(mol->atoms[second].x-mol->atoms[first].x);
y=mol->atoms[first].y+mol->bonds[i].frac
*(mol->atoms[second].y-mol->atoms[first].y);
z=mol->atoms[first].z+mol->bonds[i].frac
*(mol->atoms[second].z-mol->atoms[first].z);
if (abs(mol->bonds[i].order) != 2)
{
if (mol->bonds[i].order == (-1)) /* Hydrogen bond */
{
if (!showHBond) continue;
glEnable(GL_LINE_STIPPLE); /* Dashed lines */
(*drawLineStipple)(1, 0xf0f0);
}
if (picking || mol->atoms[first].flags & SELECTED)
{
glPushName(first+1);
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
}
else
(*drawBegin)(GL_LINE_STRIP);
if (mol->bonds[i].order == (-1))
setAtomProperties(mol->bondStyle, lighting);
else
setAtomProperties(mol->atoms[first].element, lighting);
(*drawVertex3d)(mol->atoms[first].x, mol->atoms[first].y,
mol->atoms[first].z);
(*drawVertex3d)(x, y, z);
if (picking || mol->atoms[first].flags & SELECTED ||
mol->atoms[second].flags & SELECTED)
{
(*drawEnd)();
glPopName();
if (mol->atoms[first].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
glPushName(second+1);
if (mol->atoms[second].flags & SELECTED)
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
(*drawVertex3d)(x, y, z);
}
if (mol->bonds[i].order != (-1))
setAtomProperties(mol->atoms[second].element, lighting);
(*drawVertex3d)(mol->atoms[second].x, mol->atoms[second].y,
mol->atoms[second].z);
(*drawEnd)();
if (mol->atoms[second].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
if (picking) glPopName();
if (mol->bonds[i].order == (-1)) (*drawDisable)(GL_LINE_STIPPLE);
}
if (abs(mol->bonds[i].order) > 1)
{
if (picking || mol->atoms[first].flags & SELECTED)
{
glPushName(first+1);
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
}
else
(*drawBegin)(GL_LINE_STRIP);
setAtomProperties(mol->atoms[first].element, lighting);
(*drawVertex3d)(mol->atoms[first].x-mol->bonds[i].x,
mol->atoms[first].y-mol->bonds[i].y,
mol->atoms[first].z-mol->bonds[i].z);
(*drawVertex3d)(x-mol->bonds[i].x, y-mol->bonds[i].y,
z-mol->bonds[i].z);
if (picking || mol->atoms[first].flags & SELECTED ||
mol->atoms[second].flags & SELECTED)
{
(*drawEnd)();
glPopName();
if (mol->atoms[first].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
glPushName(second+1);
if (mol->atoms[second].flags & SELECTED)
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
(*drawVertex3d)(x-mol->bonds[i].x, y-mol->bonds[i].y,
z-mol->bonds[i].z);
}
setAtomProperties(mol->atoms[second].element, lighting);
(*drawVertex3d)(mol->atoms[second].x-mol->bonds[i].x,
mol->atoms[second].y-mol->bonds[i].y,
mol->atoms[second].z-mol->bonds[i].z);
(*drawEnd)();
if (mol->atoms[second].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
if (picking) glPopName();
if (mol->bonds[i].order == (-2))
{
glEnable(GL_LINE_STIPPLE); /* Dashed lines */
(*drawLineStipple)(1, 0xf0f0);
}
if (picking || mol->atoms[first].flags & SELECTED)
{
glPushName(first+1);
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
}
else
(*drawBegin)(GL_LINE_STRIP);
setAtomProperties(mol->atoms[first].element, lighting);
(*drawVertex3d)(mol->atoms[first].x+mol->bonds[i].x,
mol->atoms[first].y+mol->bonds[i].y,
mol->atoms[first].z+mol->bonds[i].z);
(*drawVertex3d)(x+mol->bonds[i].x, y+mol->bonds[i].y,
z+mol->bonds[i].z);
if (picking || mol->atoms[first].flags & SELECTED ||
mol->atoms[second].flags & SELECTED)
{
(*drawEnd)();
glPopName();
if (mol->atoms[first].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
glPushName(second+1);
if (mol->atoms[second].flags & SELECTED)
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
(*drawVertex3d)(x+mol->bonds[i].x, y+mol->bonds[i].y,
z+mol->bonds[i].z);
}
setAtomProperties(mol->atoms[second].element, lighting);
(*drawVertex3d)(mol->atoms[second].x+mol->bonds[i].x,
mol->atoms[second].y+mol->bonds[i].y,
mol->atoms[second].z+mol->bonds[i].z);
(*drawEnd)();
if (mol->atoms[second].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
if (picking) glPopName();
if (mol->bonds[i].order == (-2))
(*drawDisable)(GL_LINE_STIPPLE);
}
}
x=0.01*windows[VIEWER].far;
for (i=0; ina; i++)
{
if (mol->atoms[i].nbonds == 0)
{
if (picking) glPushName(i+1);
setAtomProperties(mol->atoms[i].element, lighting);
if (mol->atoms[i].flags & SELECTED)
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
(*drawVertex3d)(mol->atoms[i].x-x, mol->atoms[i].y,
mol->atoms[i].z);
(*drawVertex3d)(mol->atoms[i].x+x, mol->atoms[i].y,
mol->atoms[i].z);
(*drawVertex3d)(mol->atoms[i].x, mol->atoms[i].y-x,
mol->atoms[i].z);
(*drawVertex3d)(mol->atoms[i].x, mol->atoms[i].y+x,
mol->atoms[i].z);
(*drawVertex3d)(mol->atoms[i].x, mol->atoms[i].y,
mol->atoms[i].z-x);
(*drawVertex3d)(mol->atoms[i].x, mol->atoms[i].y,
mol->atoms[i].z+x);
(*drawEnd)();
if (mol->atoms[i].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
if (picking) glPopName();
}
}
}
void stickModel(struct MOLECULE *mol, int lighting)
{
double x, y, z, f=0.1;
double xold, yold, zold;
int first, second;
register int i, j;
(*drawLineWidth)(1.);
glTexEnvf(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_MODULATE);
for (i=0; inb; i++)
{
first=mol->bonds[i].first;
second=mol->bonds[i].second;
if (mol->bonds[i].order == (-1))
{
if (!showHBond) continue;
glDisable(GL_CULL_FACE);
setAtomProperties(mol->bondStyle, lighting);
xold=mol->atoms[first].x;
yold=mol->atoms[first].y;
zold=mol->atoms[first].z;
for (j=1; j<10; j+=2)
{
x=xold+f*(mol->atoms[second].x-mol->atoms[first].x);
y=yold+f*(mol->atoms[second].y-mol->atoms[first].y);
z=zold+f*(mol->atoms[second].z-mol->atoms[first].z);
cylinder(xold, yold, zold, x, y, z, mol->bondRadius, (int)sphereres,
(GLenum)primitive);
xold=x+f*(mol->atoms[second].x-mol->atoms[first].x);
yold=y+f*(mol->atoms[second].y-mol->atoms[first].y);
zold=z+f*(mol->atoms[second].z-mol->atoms[first].z);
}
glEnable(GL_CULL_FACE);
}
else
{
x=mol->atoms[first].x+mol->bonds[i].frac
*(mol->atoms[second].x-mol->atoms[first].x);
y=mol->atoms[first].y+mol->bonds[i].frac
*(mol->atoms[second].y-mol->atoms[first].y);
z=mol->atoms[first].z+mol->bonds[i].frac
*(mol->atoms[second].z-mol->atoms[first].z);
setAtomProperties(mol->atoms[first].element, lighting);
glPushName(first+1);
if (mol->atoms[first].flags & SELECTED)
glEnable(GL_TEXTURE_2D);
cylinder(mol->atoms[first].x, mol->atoms[first].y,
mol->atoms[first].z, x, y, z,
mol->bondRadius, (int)sphereres, (GLenum)primitive);
if (mol->atoms[first].flags & SELECTED)
glDisable(GL_TEXTURE_2D);
glPopName();
setAtomProperties(mol->atoms[second].element, lighting);
glPushName(second+1);
if (mol->atoms[second].flags & SELECTED)
glEnable(GL_TEXTURE_2D);
cylinder(mol->atoms[second].x, mol->atoms[second].y,
mol->atoms[second].z, x, y, z,
mol->bondRadius, (int)sphereres, (GLenum)primitive);
if (mol->atoms[second].flags & SELECTED)
glDisable(GL_TEXTURE_2D);
glPopName();
}
}
}
void balls(struct MOLECULE *mol, double fac, int lighting)
{
GLUquadricObj *obj;
register double rad;
register int i;
(*drawLineWidth)(1.);
obj=gluNewQuadric();
gluQuadricDrawStyle(obj, (GLenum)primitive);
gluQuadricTexture(obj, GL_TRUE);
if (primitive == GLU_FILL) gluQuadricNormals(obj, (GLenum)GLU_SMOOTH);
else gluQuadricNormals(obj, (GLenum)GLU_NONE);
glTexEnvf(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_MODULATE);
for (i=0; ina; i++)
{
if (fac < 0.0)
rad=-fac;
else
rad=fac*mol->atoms[i].rad*mol->atoms[i].radScale;
glPushMatrix();
glTranslated(mol->atoms[i].x, mol->atoms[i].y,
mol->atoms[i].z);
setAtomProperties(mol->atoms[i].element, lighting);
glPushName(i+1);
if (mol->atoms[i].flags & SELECTED)
glEnable(GL_TEXTURE_2D);
(*drawSphere)(obj, rad, (int)sphereres, (int)sphereres);
if (mol->atoms[i].flags & SELECTED)
glDisable(GL_TEXTURE_2D);
glPopName();
glPopMatrix();
}
}
void drawIntern(struct MOLECULE *mol)
{
const float black[4] = {0.0, 0.0, 0.0, 0.0};
const float white[4] = {1.0, 1.0, 1.0, 0.0};
Dimension width, height;
char line[24], *form;
double xpix, ypix;
double wx1, wy1, wz, wx2, wy2, matrix[16];
double h;
register int i, j, k;
if ((rgbMode && windows[VIEWER].background_rgb[0] == 0.0 &&
windows[VIEWER].background_rgb[1] == 0.0 &&
windows[VIEWER].background_rgb[2] == 0.0) ||
(!rgbMode && windows[VIEWER].background == stdcol[BLACK]))
setWindowColor(FOREGROUND, stdcol[WHITE], white);
else
setWindowColor(FOREGROUND, stdcol[BLACK], black);
pixelToWorld(VIEWER, &xpix, &ypix);
h=(double)StringHeight(windows[VIEWER].font)*ypix;
if (!picking)
{
glEnable(GL_LINE_STIPPLE);
(*drawLineStipple)(1, 0xf0f0);
(*drawLineWidth)((GLfloat)1.);
}
for (i=0; ininternal; i++)
{
switch (abs(mol->internals[i].type))
{
case BONDAVERAGE: form=formBondLength;
break;
case BONDLENGTH: j=mol->internals[i].atoms[0];
k=mol->internals[i].atoms[1];
form=formBondLength;
(*drawBegin)(GL_LINES);
if (j & 0x20000000 && k & 0x20000000)
{
j&=0x1fffffff;
k&=0x1fffffff;
(*drawVertex3d)(mol->unitcell->corners[j].x, mol->unitcell->corners[j].y,
mol->unitcell->corners[j].z);
(*drawVertex3d)(mol->unitcell->corners[k].x, mol->unitcell->corners[k].y,
mol->unitcell->corners[k].z);
}
else
{
(*drawVertex3d)(mol->atoms[j].x, mol->atoms[j].y,
mol->atoms[j].z);
(*drawVertex3d)(mol->atoms[k].x, mol->atoms[k].y,
mol->atoms[k].z);
}
(*drawEnd)();
break;
case ANGLE: /* j=mol->internals[i].atoms[1]; */
form=formBondAngle;
(*drawBegin)(GL_LINE_STRIP);
j=mol->internals[i].atoms[0];
if (j & 0x20000000)
{
j&=0x1fffffff;
(*drawVertex3d)(mol->unitcell->corners[j].x, mol->unitcell->corners[j].y,
mol->unitcell->corners[j].z);
}
else
(*drawVertex3d)(mol->atoms[j].x, mol->atoms[j].y,
mol->atoms[j].z);
j=mol->internals[i].atoms[1];
if (j & 0x20000000)
{
j&=0x1fffffff;
(*drawVertex3d)(mol->unitcell->corners[j].x, mol->unitcell->corners[j].y,
mol->unitcell->corners[j].z);
}
else
(*drawVertex3d)(mol->atoms[j].x, mol->atoms[j].y,
mol->atoms[j].z);
j=mol->internals[i].atoms[2];
if (j & 0x20000000)
{
j&=0x1fffffff;
(*drawVertex3d)(mol->unitcell->corners[j].x, mol->unitcell->corners[j].y,
mol->unitcell->corners[j].z);
}
else
(*drawVertex3d)(mol->atoms[j].x, mol->atoms[j].y,
mol->atoms[j].z);
(*drawEnd)();
break;
case TORSION: /* j=mol->internals[i].atoms[1];
k=mol->internals[i].atoms[2]; */
form=formTorsionAngle;
(*drawBegin)(GL_LINE_STRIP);
j=mol->internals[i].atoms[0];
if (j & 0x20000000)
{
j&=0x1fffffff;
(*drawVertex3d)(mol->unitcell->corners[j].x, mol->unitcell->corners[j].y,
mol->unitcell->corners[j].z);
}
else
(*drawVertex3d)(mol->atoms[j].x, mol->atoms[j].y,
mol->atoms[j].z);
j=mol->internals[i].atoms[1];
if (j & 0x20000000)
{
j&=0x1fffffff;
(*drawVertex3d)(mol->unitcell->corners[j].x, mol->unitcell->corners[j].y,
mol->unitcell->corners[j].z);
}
else
(*drawVertex3d)(mol->atoms[j].x, mol->atoms[j].y,
mol->atoms[j].z);
j=mol->internals[i].atoms[2];
if (j & 0x20000000)
{
j&=0x1fffffff;
(*drawVertex3d)(mol->unitcell->corners[j].x, mol->unitcell->corners[j].y,
mol->unitcell->corners[j].z);
}
else
(*drawVertex3d)(mol->atoms[j].x, mol->atoms[j].y,
mol->atoms[j].z);
j=mol->internals[i].atoms[3];
if (j & 0x20000000)
{
j&=0x1fffffff;
(*drawVertex3d)(mol->unitcell->corners[j].x, mol->unitcell->corners[j].y,
mol->unitcell->corners[j].z);
}
else
(*drawVertex3d)(mol->atoms[j].x, mol->atoms[j].y,
mol->atoms[j].z);
(*drawEnd)();
break;
default: (*drawDisable)(GL_LINE_STIPPLE);
return;
}
if (mol->internals[i].type > 0)
{
sprintf(line, form, mol->internals[i].value);
if (picking)
{
glGetDoublev(GL_MODELVIEW_MATRIX, matrix);
wx1=matrix[0]*mol->internals[i].x
+matrix[4]*mol->internals[i].y
+matrix[8]*mol->internals[i].z+matrix[12];
wy1=matrix[1]*mol->internals[i].x
+matrix[5]*mol->internals[i].y
+matrix[9]*mol->internals[i].z+matrix[13]
-ypix*windows[VIEWER].font->descent;
wz=matrix[2]*mol->internals[i].x
+matrix[6]*mol->internals[i].y
+matrix[10]*mol->internals[i].z+matrix[14];
wx2=wx1+(double)StringWidth(windows[VIEWER].font, line)*xpix;
wy2=wy1+h;
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushName((GLuint)((i+1) | 0x40000000));
glBegin(GL_POLYGON);
glVertex3d(wx1, wy1, wz);
glVertex3d(wx2, wy1, wz);
glVertex3d(wx2, wy2, wz);
glVertex3d(wx1, wy2, wz);
glEnd();
glPopMatrix();
glPopName();
}
else
{
(*drawString)(line, mol->internals[i].x, mol->internals[i].y,
mol->internals[i].z, 0.0, windows[VIEWER].GLfontId,
'l');
}
}
else
{
XtVaGetValues(windows[VIEWER].widget, XtNwidth, &width, XtNheight, &height, NULL);
for (j=0; jinternals[i].x, mol->internals[i].y, mol->internals[i].z,
&wx1, &wy1, &wz);
moveAnnotation(j, 2.0*wx1/(double)width-1.0, 2.0*wy1/(double)height-1.0);
/* printf("%f %f\n", 2.0*wx1/(double)width-1.0, 2.0*wy1/(double)height-1.0);*/
}
}
}
}
(*drawDisable)(GL_LINE_STIPPLE);
}
void drawUnitCell(struct MOLECULE *mol, Dimension width, int lighting)
{
GLUquadricObj *obj;
double nline, sline;
double x, y, z;
int first, second;
register int i;
/*char name[4];*/
nline=1.0;
sline=2.0;
if (windows[VIEWER].mode == WIREMODEL)
{
if (lineWidth == 0.0)
nline=width*0.01;
else
nline=lineWidth;
sline=2.0*nline;
(*drawLineWidth)((GLfloat)nline);
}
else
{
(*drawLineWidth)(1.);
glTexEnvf(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_MODULATE);
obj=gluNewQuadric();
gluQuadricDrawStyle(obj, (GLenum)primitive);
gluQuadricTexture(obj, GL_TRUE);
if (primitive == GLU_FILL) gluQuadricNormals(obj, (GLenum)GLU_SMOOTH);
else gluQuadricNormals(obj, (GLenum)GLU_NONE);
glTexEnvf(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_MODULATE);
for (i=0; iunitcell->nc; i++)
{
glPushMatrix();
glTranslated(mol->unitcell->corners[i].x, mol->unitcell->corners[i].y,
mol->unitcell->corners[i].z);
setAtomProperties(mol->unitcell->corners[i].element, lighting);
(*drawSphere)(obj, mol->bondRadius, (int)sphereres, (int)sphereres);
glPopMatrix();
/* sprintf(name, "%d", i);
(*drawString)(name, mol->unitcell->corners[i].x+0.05, mol->unitcell->corners[i].y+0.05,
mol->unitcell->corners[i].z+0.05, 0.0, windows[VIEWER].GLfontId, 'l');
*/ }
}
for (i=0; iunitcell->ne; i++)
{
first=mol->unitcell->edges[i].first;
second=mol->unitcell->edges[i].second;
x=mol->unitcell->corners[first].x+0.5*(mol->unitcell->corners[second].x
-mol->unitcell->corners[first].x);
y=mol->unitcell->corners[first].y+0.5*(mol->unitcell->corners[second].y
-mol->unitcell->corners[first].y);
z=mol->unitcell->corners[first].z+0.5*(mol->unitcell->corners[second].z
-mol->unitcell->corners[first].z);
setAtomProperties(mol->unitcell->corners[first].element, lighting);
if (picking) glPushName((GLuint)((first+1) | 0x20000000));
if (windows[VIEWER].mode == WIREMODEL)
{
if (mol->unitcell->corners[first].flags & SELECTED)
{
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
}
else
(*drawBegin)(GL_LINE_STRIP);
(*drawVertex3d)(mol->unitcell->corners[first].x,
mol->unitcell->corners[first].y,
mol->unitcell->corners[first].z);
(*drawVertex3d)(x, y, z);
if (picking || mol->unitcell->corners[first].flags & SELECTED ||
mol->unitcell->corners[second].flags & SELECTED)
{
(*drawEnd)();
glPopName();
if (mol->unitcell->corners[first].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
glPushName((GLuint)((second+1) | 0x20000000));
if (mol->unitcell->corners[second].flags & SELECTED)
(*drawLineWidth)((GLfloat)sline);
(*drawBegin)(GL_LINES);
(*drawVertex3d)(x, y, z);
}
}
else
{
if (mol->unitcell->corners[first].flags & SELECTED) glEnable(GL_TEXTURE_2D);
cylinder(mol->unitcell->corners[first].x, mol->unitcell->corners[first].y,
mol->unitcell->corners[first].z, x, y, z,
mol->bondRadius, (int)sphereres, (GLenum)primitive);
if (mol->unitcell->corners[first].flags & SELECTED) glDisable(GL_TEXTURE_2D);
}
setAtomProperties(mol->unitcell->corners[second].element, lighting);
if (windows[VIEWER].mode == WIREMODEL)
{
(*drawVertex3d)(mol->unitcell->corners[second].x,
mol->unitcell->corners[second].y,
mol->unitcell->corners[second].z);
(*drawEnd)();
if (mol->unitcell->corners[second].flags & SELECTED)
(*drawLineWidth)((GLfloat)nline);
}
else
{
if (picking)
{
glPopName();
glPushName((GLuint)((second+1) | 0x20000000));
}
if (mol->unitcell->corners[second].flags & SELECTED) glEnable(GL_TEXTURE_2D);
cylinder(mol->unitcell->corners[second].x, mol->unitcell->corners[second].y,
mol->unitcell->corners[second].z, x, y, z,
mol->bondRadius, (int)sphereres, (GLenum)primitive);
if (mol->unitcell->corners[second].flags & SELECTED) glDisable(GL_TEXTURE_2D);
}
if (picking) glPopName();
}
}
void drawMillerPlane(struct MOLECULE *mol, int lighting)
{
int step;
register int i, j;
setAtomProperties(mol->unitcell->millerPlanes[0].element, lighting);
step=mol->unitcell->nmiller % 3 ? 4 : 3;
(*drawBegin)(GL_POLYGON);
for (i=0; iunitcell->nmiller; i+=step)
{
for (j=0; junitcell->millerPlanes[i+j].x, mol->unitcell->millerPlanes[i+j].y,
mol->unitcell->millerPlanes[i+j].z);
}
(*drawEnd)();
}
void labelAtoms(struct MOLECULE *mol, int what)
{
const float black[4] = {0.0, 0.0, 0.0, 0.0};
const float white[4] = {1.0, 1.0, 1.0, 0.0};
char name[MAXLENLINE];
register int i;
if ((rgbMode && windows[VIEWER].background_rgb[0] == 0.0 &&
windows[VIEWER].background_rgb[1] == 0.0 &&
windows[VIEWER].background_rgb[2] == 0.0) ||
(!rgbMode && windows[VIEWER].background == stdcol[BLACK]))
setWindowColor(FOREGROUND, stdcol[WHITE], white);
else
setWindowColor(FOREGROUND, stdcol[BLACK], black);
for (i=0; ina; i++)
{
if (strncmp(mol->atoms[i].name, "Uc", 2) && strncmp(mol->atoms[i].name, "Mp", 2))
{
switch(what)
{
case LABEL: sprintf(name, "%s%d", mol->atoms[i].name, i+1);
break;
case INS: sprintf(name, "%f", mol->atoms[i].neutronScatterfac);
break;
}
glPushName(i+1);
(*drawString)(name, mol->atoms[i].x+0.05, mol->atoms[i].y+0.05,
mol->atoms[i].z+0.05, 0.0, windows[VIEWER].GLfontId, 'l');
glPopName();
}
}
}
void drawAnnotation()
{
Dimension width, height;
register double h, l;
float savedRGBColor[3];
int savedColor;
register int i;
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
if (!picking) glLoadIdentity();
else glPushName((GLuint)0x80000000); /* The name of the "molecule" */
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
XtVaGetValues(windows[VIEWER].widget, XtNwidth, &width, XtNheight, &height, NULL);
h=2.0*(double)StringHeight(windows[VIEWER].font)/height;
for (i=0; ihistory == NULL) return;
i=0;
while ((i < mol->na) && (mol->atoms[i].flags & ORIGINAL)) i++;
/*if (mol->unitcell && i != mol->na) i+=8;*/
j=i*(mol->cycle-1);
if (lighting)
setWindowColor(FOREGROUND, stdcol[BLACK], black);
else
shadowColor();
(*drawLineWidth)((GLfloat)1.);
if (drawBegin != glBegin) primitive=GLU_LINE;
for (i=0; ina; i++)
{
k=mol->atoms[i].ref;
if (mol->atoms[i].flags & X_FIXED)
gx=0.0;
else
gx=-100.0*forceScale*mol->history[j+k].gx;
if (mol->atoms[i].flags & Y_FIXED)
gy=0.0;
else
gy=-100.0*forceScale*mol->history[j+k].gy;
if (mol->atoms[i].flags & Z_FIXED)
gz=0.0;
else
gz=-100.0*forceScale*mol->history[j+k].gz;
drawArrow(mol->atoms[i].x, mol->atoms[i].y, mol->atoms[i].z, gx, gy, gz);
}
if (drawBegin != glBegin) primitive=primitiveSave;
}
void drawNormalMode(struct MOLECULE *mol, int lighting)
{
const float black[4] = {0.0, 0.0, 0.0, 0.0};
int primitiveSave=primitive, mode;
register int i, j;
if (mol->normal_modes == NULL) return;
mode=mol->mode;
if (mode == (-1)) return;
if (lighting)
setWindowColor(FOREGROUND, stdcol[BLACK], black);
else
shadowColor();
if (drawBegin != glBegin) primitive=GLU_LINE;
for (i=0; ina; i++)
{
j=3*mol->atoms[i].ref;
drawArrow(mol->atoms[i].x, mol->atoms[i].y, mol->atoms[i].z,
amplitude*mol->cnm[mode+mol->nmodes*j],
amplitude*mol->cnm[mode+mol->nmodes*(j+1)],
amplitude*mol->cnm[mode+mol->nmodes*(j+2)]);
}
if (drawBegin != glBegin) primitive=primitiveSave;
}
void drawArrow(double x1, double y1, double z1, double x2, double y2, double z2)
{
double length;
if ((length=dist(x1, y1, z1, x1+x2, y1+y2, z1+z2)) > 1.0e-04)
{
if (length > 0.2*windows[VIEWER].top || drawBegin != glBegin)
cylinder(x1, y1, z1, x1+0.8*x2, y1+0.8*y2, z1+0.8*z2, 0.01*length,
(int)sphereres, (GLenum)primitive);
else
{
(*drawLineWidth)((GLfloat)1.);
(*drawBegin)(GL_LINES);
(*drawVertex3d)(x1, y1, z1);
(*drawVertex3d)(x1+0.8*x2, y1+0.8*y2, z1+0.8*z2);
(*drawEnd)();
}
cone(x1+0.8*x2, y1+0.8*y2, z1+0.8*z2, x1+x2, y1+y2, z1+z2,
0.03*length, (int)sphereres);
}
}
void setupProjection(int picking)
{
GLfloat xview, yview, zview;
Dimension width, height;
if (!picking)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
}
if (projectionMode == ORTHO)
glOrtho(windows[VIEWER].left, windows[VIEWER].right, windows[VIEWER].bottom,
windows[VIEWER].top, windows[VIEWER].near, windows[VIEWER].far);
else
{
XtVaGetValues(windows[VIEWER].widget, XtNwidth, &width, XtNheight, &height, NULL);
if (2.0*windows[VIEWER].far > transObject[3*VIEWPOINT+2])
zview=2.0*windows[VIEWER].far-transObject[3*VIEWPOINT+2];
else
zview=0.1;
yview=0.75*windows[VIEWER].near*windows[VIEWER].top/windows[VIEWER].far;
xview=yview*(double)(width)/(double)(height);
glFrustum(xview, (-xview), yview, (-yview), zview,
10.0*windows[VIEWER].far-transObject[3*VIEWPOINT+2]);
glTranslatef(transObject[3*VIEWPOINT], transObject[3*VIEWPOINT+1],
transObject[3*VIEWPOINT+2]);
quaternionToMatrix(GL_PROJECTION, &rotObject[4*VIEWPOINT]);
gluLookAt(0.0, 0.0, 3.0*windows[VIEWER].far, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void setupModelview(int i)
{
glTranslatef(transObject[3*(i+MOLECULES)], transObject[3*(i+MOLECULES)+1],
transObject[3*(i+MOLECULES)+2]);
quaternionToMatrix(GL_MODELVIEW, &rotObject[4*(i+MOLECULES)]);
}
void drawGround(void)
{
GLdouble plane[4]={0.0, 1.0, 0.0, 0.0};
setWindowColor(FOREGROUND, windows[VIEWER].foreground,
windows[VIEWER].foreground_rgb);
if (shadows)
{
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 3, 0xffffffff);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
}
glPassThrough((GLfloat)(ADD_DEPTH+(int)(3.0*windows[VIEWER].far)));
glBegin(GL_POLYGON);
glVertex3d(10.0*windows[VIEWER].left, windows[VIEWER].bottom, 10.0*windows[VIEWER].near);
glVertex3d(10.0*windows[VIEWER].left, windows[VIEWER].bottom, 10.0*windows[VIEWER].far);
glVertex3d(10.0*windows[VIEWER].right, windows[VIEWER].bottom, 10.0*windows[VIEWER].far);
glVertex3d(10.0*windows[VIEWER].right, windows[VIEWER].bottom, 10.0*windows[VIEWER].near);
glEnd();
plane[3]=(-windows[VIEWER].bottom);
glClipPlane(GL_CLIP_PLANE0, plane);
glPassThrough((GLfloat)(ADD_DEPTH));
}
void shadow(GLfloat ground0[3], GLfloat ground1[3], GLfloat ground2[3], GLfloat lightpos[4])
{
GLfloat vec0[3], vec1[3], plane[4];
GLfloat shadowMat[4][4];
register GLfloat dot;
/* Need 2 vectors to find cross product. */
vec0[0]=ground1[0]-ground0[0];
vec0[1]=ground1[1]-ground0[1];
vec0[2]=ground1[2]-ground0[2];
vec1[0]=ground2[0]-ground0[0];
vec1[1]=ground2[1]-ground0[1];
vec1[2]=ground2[2]-ground0[2];
/* find cross product to get A, B, and C of plane equation */
plane[0]=vec0[1]*vec1[2]-vec0[2]*vec1[1];
plane[1]=vec0[0]*vec1[2]-vec0[2]*vec1[0];
plane[2]=vec0[0]*vec1[1]-vec0[1]*vec1[0];
plane[3]=-(plane[0]*ground0[0]+plane[1]*ground0[1]+plane[2]*ground0[2]);
/* Find dot product between light position vector and ground plane normal. */
dot=plane[0]*lightpos[0]+plane[1]*lightpos[1]+plane[2]*lightpos[2]
+plane[3]*lightpos[3];
shadowMat[0][0]=dot-lightpos[0]*plane[0];
shadowMat[1][0]=(-lightpos[0]*plane[1]);
shadowMat[2][0]=(-lightpos[0]*plane[2]);
shadowMat[3][0]=(-lightpos[0]*plane[3]);
shadowMat[0][1]=(-lightpos[1]*plane[0]);
shadowMat[1][1]=dot-lightpos[1]*plane[1];
shadowMat[2][1]=(-lightpos[1]*plane[2]);
shadowMat[3][1]=(-lightpos[1]*plane[3]);
shadowMat[0][2]=(-lightpos[2]*plane[0]);
shadowMat[1][2]=(-lightpos[2]*plane[1]);
shadowMat[2][2]=dot-lightpos[2]*plane[2];
shadowMat[3][2]=(-lightpos[2]*plane[3]);
shadowMat[0][3]=(-lightpos[3]*plane[0]);
shadowMat[1][3]=(-lightpos[3]*plane[1]);
shadowMat[2][3]=(-lightpos[3]*plane[2]);
shadowMat[3][3]=dot-lightpos[3]*plane[3];
glMultMatrixf((const GLfloat *)shadowMat);
}
void setAtomProperties(struct ELEMENT *element, int lighting)
{
GLfloat v[4];
if (drawBegin == raytracerBegin) raytracerMaterial(element);
if (!lighting)
{
shadowColor();
return;
}
if (rgbMode)
{
v[0]=0.5*(element->dark[0]+element->light[0]);
v[1]=0.5*(element->dark[1]+element->light[1]);
v[2]=0.5*(element->dark[2]+element->light[2]);
v[3]=element->alpha;
}
if (primitive == GLU_FILL && (windows[VIEWER].mode != WIREMODEL ||
!strcmp(element->symbol, "Ps") || !strcmp(element->symbol, "Ms")))
{
if (rgbMode)
{
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, element->ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, v);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, element->specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, element->emission);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, element->shininess);
}
else
{
glMaterialiv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, element->colormap);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, element->shininess);
}
}
else
{
if (rgbMode)
(*drawColor4fv)(v);
else
glIndexi(element->colormap[1]);
}
}
void shadowColor(void)
{
GLfloat v[4]={0.0, 0.0, 0.0, 1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, v);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, v);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, v);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, v);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0);
}
void viewerKeyAction(KeySym keysym)
{
XmToggleButtonCallbackStruct data;
switch (keysym)
{
case XK_F1: manual((Widget)0, (caddr_t)0, (caddr_t)0);
break;
case XK_Print: printDialog((Widget)0, (caddr_t)VIEWER, (XmAnyCallbackStruct *)0);
break;
case XK_KP_Add:
case XK_plus: forceScale*=1.4;
break;
case XK_KP_Subtract:
case XK_minus: forceScale/=1.4;
break;
case XK_Up: windows[VIEWER].top/=1.5;
windows[VIEWER].bottom/=1.5;
windows[VIEWER].right/=1.5;
windows[VIEWER].left/=1.5;
if (nAnnotations) scaleAnnotation(1.0/1.5);
break;
case XK_Down: windows[VIEWER].top*=1.5;
windows[VIEWER].bottom*=1.5;
windows[VIEWER].right*=1.5;
windows[VIEWER].left*=1.5;
if (nAnnotations) scaleAnnotation(1.5);
break;
case XK_Tab: if (nmolecule > 1)
{
data.set=TRUE;
windows[VIEWER].set++;
if (windows[VIEWER].set >= nmolecule)
{
windows[VIEWER].set=(-1);
(void)selectMolecule((Widget)0,
(XtPointer)&windows[VIEWER].selectMenu[0], &data);
}
else
(void)selectMolecule((Widget)0,
(XtPointer)&windows[VIEWER].selectMenu[windows[VIEWER].set+2], &data);
}
break;
case XK_x: incrementQuaternion(5.0, 0.0, 0.0, &rotObject[4*moveItem]);
break;
case XK_X: incrementQuaternion(-5.0, 0.0, 0.0, &rotObject[4*moveItem]);
break;
case XK_y: incrementQuaternion(0.0, 5.0, 0.0, &rotObject[4*moveItem]);
break;
case XK_Y: incrementQuaternion(0.0, -5.0, 0.0, &rotObject[4*moveItem]);
break;
case XK_z: incrementQuaternion(0.0, 0.0, 5.0, &rotObject[4*moveItem]);
break;
case XK_Z: incrementQuaternion(0.0, 0.0, -5.0, &rotObject[4*moveItem]);
break;
case XK_0: rotObject[4*moveItem]=rotObject[4*moveItem+1]=rotObject[4*moveItem+2]=0.0;
rotObject[4*moveItem+3]=1.0;
break;
case XK_Escape: deleteSelection();
break;
}
redraw(VIEWER);
}
viewmol-2.4.1/source/drawel.c 0100644 0002727 0002727 00000044546 07752675434 014325 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* D R A W E L . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: drawel.c,v 1.6 2003/11/07 10:59:40 jrh Exp $
* $Log: drawel.c,v $
* Revision 1.6 2003/11/07 10:59:40 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:05:02 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:25:12 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:47:09 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:29 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:40:27 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include "viewmol.h"
void updateMOs(int);
extern double makeTics(double, double, double *, char *);
extern void setWindowColor(int, Pixel, const float*);
extern void (*drawBegin)(GLenum), (*drawEnd)(void), (*drawVertex2d)(double, double);
extern void (*drawString)(char *, double, double, double, double, GLuint, char);
extern void (*drawLineStipple)(GLint, GLushort);
extern void (*drawLineWidth)(GLfloat);
extern void (*drawDisable)(GLenum);
extern void printDialog(Widget, caddr_t, XmAnyCallbackStruct *);
extern void pixelToWorld(int, double *, double *);
extern void drawBackground(int, Pixel, double);
extern int StringWidth(XFontStruct *, char *);
extern int StringHeight(XFontStruct *);
extern void setMenuItem(int, int);
extern void fremem(void **);
extern void deleteGridObjects(void);
extern void redraw(int);
extern void annotateWavefunction(void);
extern char *getStringResource(Widget, char *);
extern void selectMolecule(Widget, caddr_t, XmToggleButtonCallbackStruct *);
extern int makeAnnotation(int, int, float, float, float, int, const GLfloat *,
int, int, char *);
extern int existsGridObject(void);
extern void calcmo(void);
extern struct MOLECULE *molecules;
extern struct WINDOW windows[];
extern Widget topShell;
extern Pixel stdcol[9];
extern double denres, *grid;
extern int nmolecule, iwavef;
extern int unit, selectAtom, selectAtomAnnotation, automaticRecalculate;
extern int picking, swapBuffers;
void drawMODiagram(Widget w, caddr_t client_data, XmDrawingAreaCallbackStruct *data)
{
char line[15], trans[15];
char form[8], units[7];
double scan[500];
double eunit=1.0, e1h, e2h, e;
double xpix, ypix, strl=0.0e0;
double ticMark, ticSave, ticInc;
double smax, shape, center, ehelp, fac;
double off1, off2, off;
const float red[4] = {1.0, 0.0, 0.0, 0.0};
const float green[4] = {0.0, 1.0, 0.0, 0.0};
const float blue[4] = {0.0, 0.0, 1.0, 0.0};
const float white[4] = {1.0, 1.0, 1.0, 0.0};
int renderMode, imol, draw, spin;
register double l;
register int i, j;
/* This subroutine draws a MO energy diagram */
/* Convert units from Hartree/particle */
switch (unit)
{
case HARTREE: eunit=1.0; /* to Hartree/particle */
strcpy(units, "Eh");
break;
case KJ_MOL: eunit=2625.5001; /* to kJ/mol */
strcpy(units, "kJ/mol");
break;
case EV: eunit=27.211611; /* to eV */
strcpy(units, "eV");
break;
case CM: eunit=4.3598149e6/(6.626176*2.99792458); /* to 1/cm (E/hc) */
strcpy(units, "1/cm");
break;
}
imol=windows[MO].set;
glGetIntegerv(GL_RENDER_MODE, &renderMode);
if (renderMode == GL_RENDER)
glXMakeCurrent(XtDisplay(windows[MO].widget), XtWindow(windows[MO].widget), windows[MO].context);
if (!picking)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
}
pixelToWorld(MO, &xpix, &ypix);
drawBackground(MO, windows[MO].background, (double)0.0);
setWindowColor(FOREGROUND, windows[MO].foreground, windows[MO].foreground_rgb);
if (molecules[imol].orbitals[0].spin != ALPHAANDBETA)
off=ypix*(double)StringHeight(windows[MO].greekFont);
else
off=0.0;
glOrtho(windows[MO].left, windows[MO].right, windows[MO].bottom-off,
windows[MO].top, windows[MO].near, windows[MO].far);
e1h=(windows[MO].bottom-off)*eunit;
e2h=windows[MO].top*eunit;
glShadeModel(GL_FLAT);
/* Calculate and draw tic marks */
glPushName(imol);
ticInc=makeTics(e1h, e2h, &ticMark, form);
ticSave=ticMark;
do
{
if (fabs(ticMark) < 1.0e-5) ticMark=0.0;
sprintf(line, form, ticMark);
l=(double)(StringWidth(windows[MO].font, line)+9.0);
strl= strl > l ? strl : l;
(*drawString)(line, 2.0*xpix, ticMark/eunit-5.0*ypix, 0.0, 0.0, windows[MO].GLfontId, 'l');
ticMark+=ticInc;
} while (ticMark < e2h);
strl*=xpix;
ticMark=ticSave;
(*drawLineWidth)((GLfloat)1.);
glEnable(GL_LINE_STIPPLE); /* Dotted lines */
(*drawLineStipple)(1, 0x3333);
(*drawBegin)(GL_LINES);
(*drawVertex2d)(strl, 0.0);
(*drawVertex2d)(1.0e0, 0.0);
(*drawEnd)();
(*drawDisable)(GL_LINE_STIPPLE);
(*drawBegin)(GL_LINES);
(*drawVertex2d)(strl, windows[MO].bottom-off);
(*drawVertex2d)(strl, windows[MO].top);
(*drawEnd)();
do
{
(*drawBegin)(GL_LINES);
(*drawVertex2d)(strl-5.0*xpix, ticMark/eunit);
(*drawVertex2d)(strl+5.0*xpix, ticMark/eunit);
(*drawEnd)();
ticMark+=ticInc;
} while (ticMark < e2h);
(*drawString)(units, 2.0*xpix, (ticMark-5.0*ticInc/2.0)/eunit, 0.0, 0.0, windows[MO].GLfontId, 'l');
/* Check for UHF calculation and label alpha and beta eigenvalues */
if (molecules[imol].orbitals[0].spin != ALPHAANDBETA)
{
(*drawString)("a", 0.25+0.75*strl+5.0*xpix, windows[MO].bottom+5.0*ypix, 0.0, 0.0, windows[MO].GLgreekFontId, 'c');
(*drawString)("b", 0.75+0.25*strl-5.0*xpix, windows[MO].bottom+5.0*ypix, 0.0, 0.0, windows[MO].GLgreekFontId, 'c');
}
/* Draw energy levels */
if (windows[MO].mode == DENSITY_OF_STATES)
{
if (molecules[imol].orbitals[0].spin == ALPHAANDBETA)
{
e=windows[MO].bottom;
smax=0.0;
for (i=0; i<500; i++)
{
scan[i]=0.0;
for (j=0; j scan[i] ? smax : scan[i];
e+=(windows[MO].top-windows[MO].bottom)/500.0;
}
(*drawBegin)(GL_LINE_STRIP);
(*drawVertex2d)(scan[0]*(1.0-strl)/smax+strl, windows[MO].bottom);
for (i=1; i<500; i++)
(*drawVertex2d)(scan[i]*(1.0-strl)/smax+strl, windows[MO].bottom+
(double)i*(windows[MO].top-windows[MO].bottom)/500.0);
(*drawEnd)();
}
else
{
draw=TRUE;
spin=ALPHA;
setWindowColor(FOREGROUND, stdcol[BLUE], blue);
while (draw)
{
e=windows[MO].bottom;
smax=0.0;
for (i=0; i<500; i++)
{
scan[i]=0.0;
for (j=0; j scan[i] ? smax : scan[i];
e+=(windows[MO].top-windows[MO].bottom)/500.0;
}
(*drawBegin)(GL_LINE_STRIP);
(*drawVertex2d)(scan[0]*(1.0-strl)/smax+strl, windows[MO].bottom);
for (i=1; i<500; i++)
(*drawVertex2d)(scan[i]*(1.0-strl)/smax+strl, windows[MO].bottom+
(double)i*(windows[MO].top-windows[MO].bottom)/500.0);
(*drawEnd)();
switch (spin)
{
case ALPHA: spin=BETA;
(*drawBegin)(GL_LINE_STRIP);
(*drawVertex2d)(0.25+0.75*strl, windows[MO].bottom+0.5*StringHeight(windows[MO].greekFont)*ypix);
(*drawVertex2d)(0.25, windows[MO].bottom+0.5*StringHeight(windows[MO].greekFont)*ypix);
(*drawEnd)();
setWindowColor(FOREGROUND, stdcol[GREEN], green);
break;
case BETA: draw=FALSE;
(*drawBegin)(GL_LINE_STRIP);
(*drawVertex2d)(0.75+0.25*strl-10.0*xpix, windows[MO].bottom+0.5*StringHeight(windows[MO].greekFont)*ypix);
(*drawVertex2d)(0.75-0.5*strl-10.0*xpix, windows[MO].bottom+0.5*StringHeight(windows[MO].greekFont)*ypix);
(*drawEnd)();
break;
}
}
}
}
else
{
for (i=0; i %s", molecules[imol].orbitals[molecules[imol].imosave].symmetry,
molecules[imol].orbitals[molecules[imol].imo].symmetry);
ehelp=fabs(ehelp)/2.0+molecules[imol].orbitals[molecules[imol].imo < molecules[imol].imosave ? molecules[imol].imo : molecules[imol].imosave].energy+13.*ypix;
}
else
{
ehelp=molecules[imol].orbitals[molecules[imol].imo].energy;
sprintf(line, "%.6f", eunit*molecules[imol].orbitals[molecules[imol].imo].energy);
sprintf(trans, "%s", molecules[imol].orbitals[molecules[imol].imo].symmetry);
}
off1=(double)(StringWidth(windows[MO].font, trans)+4)/2.0;
off2=(double)(StringWidth(windows[MO].font, line)+4)/2.0;
off=xpix*(off1 > off2 ? off1 : off2);
setWindowColor(FOREGROUND, stdcol[WHITE], white);
if (ehelp-windows[MO].bottom < 27.0*ypix)
{
glRectd(center-off, ehelp+27.0*ypix, center+off, ehelp);
setWindowColor(FOREGROUND, windows[MO].foreground, windows[MO].foreground_rgb);
(*drawBegin)(GL_LINE_LOOP);
(*drawVertex2d)(center-off, ehelp+27.0*ypix);
(*drawVertex2d)(center-off, ehelp);
(*drawVertex2d)(center+off, ehelp);
(*drawVertex2d)(center+off, ehelp+27.0*ypix);
(*drawEnd)();
(*drawString)(trans, center-(off1-2.0)*xpix, ehelp+16.0*ypix, 0.0, 0.0, windows[MO].GLfontId, 'l');
(*drawString)(line, center-(off2-2.0)*xpix, ehelp+3.0*ypix, 0.0, 0.0, windows[MO].GLfontId, 'l');
}
else
{
glRectd(center-off, ehelp-27.0*ypix, center+off, ehelp);
setWindowColor(FOREGROUND, windows[MO].foreground, windows[MO].foreground_rgb);
(*drawBegin)(GL_LINE_LOOP);
(*drawVertex2d)(center-off, ehelp-27.0*ypix);
(*drawVertex2d)(center-off, ehelp);
(*drawVertex2d)(center+off, ehelp);
(*drawVertex2d)(center+off, ehelp-27.0*ypix);
(*drawEnd)();
(*drawString)(trans, center-(off1-2.0)*xpix, ehelp-11.0*ypix, 0.0, 0.0, windows[MO].GLfontId, 'l');
(*drawString)(line, center-(off2-2.0)*xpix, ehelp-24.0*ypix, 0.0, 0.0, windows[MO].GLfontId, 'l');
}
}
}
glPopName();
if (swapBuffers) glXSwapBuffers(XtDisplay(windows[MO].widget), XtWindow(windows[MO].widget));
}
void quitMODiagram(Widget w, caddr_t client_data, XmAnyCallbackStruct *data)
{
register int imol;
if (windows[MO].widget == NULL) return;
imol=windows[MO].set;
deleteGridObjects();
glXMakeCurrent(XtDisplay(windows[VIEWER].widget), XtWindow(windows[VIEWER].widget), windows[VIEWER].context);
fremem((void **)&windows[MO].font);
XtUnmanageChild(XtParent(windows[MO].widget));
XtDestroyWidget(XtParent(windows[MO].widget));
windows[MO].widget=0;
setMenuItem(VIEWER_ENERGYLEVEL, True);
if (nmolecule > 0)
{
molecules[imol].imo=(-1);
molecules[imol].imosave=(-1);
redraw(VIEWER);
}
}
void setTransition(Widget w, caddr_t dummy, XmToggleButtonCallbackStruct *data)
{
register int imol;
imol=windows[MO].set;
if (data->set)
molecules[imol].imosave=molecules[imol].imo;
else
molecules[imol].imosave=(-1);
}
void MODiagramKeyAction(KeySym keysym)
{
XmToggleButtonCallbackStruct data;
struct MOLECULE *mol;
int imoSave, spin;
mol=&molecules[windows[MO].set];
imoSave=mol->imo;
switch (keysym)
{
case XK_Print: printDialog((Widget)0, (caddr_t)MO, (XmAnyCallbackStruct *)0);
break;
case XK_Down: if (mol->imo != -1)
{
spin=mol->orbitals[mol->imo].spin;
while (mol->orbitals[--mol->imo].spin != spin && mol->imo >= 0);
if (mol->imo < 0)
{
mol->imo=mol->nbasfu;
while (mol->orbitals[--mol->imo].spin != spin && mol->imo >= 0);
}
}
break;
case XK_Up: if (mol->imo != -1)
{
spin=mol->orbitals[mol->imo].spin;
while (mol->orbitals[++mol->imo].spin != spin && mol->imo < mol->nbasfu);
if (mol->imo >= mol->nbasfu)
{
mol->imo=-1;
while (mol->orbitals[++mol->imo].spin != spin && mol->imo < mol->nbasfu);
}
}
break;
case XK_Left: if (mol->imo != -1)
{
if (mol->orbitals[mol->imo].spin == BETA)
while (mol->orbitals[--mol->imo].spin == BETA && mol->imo >= 0);
}
break;
case XK_Right: if (mol->imo != -1)
{
if (mol->orbitals[mol->imo].spin == ALPHA)
while (mol->orbitals[++mol->imo].spin == ALPHA && mol->imo < mol->nbasfu);
}
break;
case XK_Tab: if (nmolecule > 1)
{
data.set=TRUE;
do
{
windows[MO].set++;
if (windows[MO].set >= nmolecule) windows[MO].set=0;
} while (molecules[windows[MO].set].orbitals == NULL);
(void)selectMolecule((Widget)0, (XtPointer)&windows[MO].selectMenu[windows[MO].set],
&data);
}
break;
}
updateMOs(imoSave);
annotateWavefunction();
}
void updateMOs(int imoSave)
{
struct MOLECULE *mol;
const GLfloat black[4] = {0.0, 0.0, 0.0, 0.0};
char *word;
mol=&molecules[windows[MO].set];
if (automaticRecalculate)
{
switch (iwavef)
{
case BASIS_IN_MO: word=getStringResource(topShell, "selectAtomTitle");
selectAtomAnnotation=makeAnnotation(selectAtomAnnotation,
CENTERED, 0.0, 1.0, 0.0, stdcol[BLACK],
black, 0, 0, word);
selectAtom=TRUE;
break;
case MOLECULAR_ORBITAL: selectAtom=FALSE;
if (!existsGridObject()) calcmo();
break;
}
}
if (mol->imo != imoSave && grid != NULL)
fremem((void **)&grid);
if (mol->orbitals[mol->imo].occupation == 0.0 && mol->needMoloch)
setMenuItem(VIEWER_WAVEFUNCTION, False);
else if (mol->basisset != NULL)
setMenuItem(VIEWER_WAVEFUNCTION, True);
}
viewmol-2.4.1/source/drawform.c 0100644 0002727 0002727 00000033554 07752675446 014670 0 ustar jrh jrh /*******************************************************************************
* *
* Viewmol *
* *
* D R A W F O R M . C *
* *
* Copyright (c) Joerg-R. Hill, October 2003 *
* *
********************************************************************************
*
* $Id: drawform.c,v 1.6 2003/11/07 10:59:50 jrh Exp $
* $Log: drawform.c,v $
* Revision 1.6 2003/11/07 10:59:50 jrh
* Release 2.4
*
* Revision 1.5 2000/12/10 15:05:13 jrh
* Release 2.3
*
* Revision 1.4 1999/05/24 01:25:14 jrh
* Release 2.2.1
*
* Revision 1.3 1999/02/07 21:47:29 jrh
* Release 2.2
*
* Revision 1.2 1998/01/26 00:47:31 jrh
* Release 2.1
*
* Revision 1.1 1996/12/10 18:40:31 jrh
* Initial revision
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include