/*
* Chemtool version 1.6.10
*
* written by Thomas Volk
* Jan 1998
* extensions and GTK-based rewrite by Martin Kroeker 1999-2006
* with contributions by Radek Liboska and Michael Banck
* You can use Chemtool under the terms
* of the GNU General Public License
*
* This software comes with ABSOLUTELY NO WARRANTY
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <ctype.h>
#include <gdk/gdkx.h>
#include "bitmap1.h"
#include "templates.h"
#include "chemcurs.h"
#include "chemtool.xpm"
#include <gdk/gdkkeysyms.h>
#include <stdio.h>
#include <stdlib.h>
#if 0
#include <unistd.h> /* memmove*/
#endif
#include <strings.h>
#include <string.h>
#include <signal.h>
#include <locale.h>
#include "ct.h"
#ifdef DISABLE_NLS
#define _(Text) Text
#else
#include <libintl.h>
#define _(Text) gettext(Text)
#endif
GtkWidget *filew;
GtkWidget *templates;
GtkWidget *messagew, *message;
GtkWidget *expw;
GtkWidget *mainw;
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *hexbutton, *pent1button, *pent2button, *octbutton, *ltextbutton,
*ctextbutton, *rtextbutton, *bondbutton, *movebutton, *markbutton,*colorbutton,
*rotatebutton, *hflipbutton, *vflipbutton, *copybutton, *addbutton,
*tempbutton, *cleanbutton, *rescalebutton, *splinebutton,*fontbutton,
*bgcolorbutton;
#if 0
GtkWidget *fontsel,*fontselw;
#endif
GtkWidget *textlabel;
GtkStyle *normalfontstyle,*seriffontstyle;
GtkWidget *scale, *pscale;
GtkWidget *bracketbutton, *rbracketbutton, *r2bracketbutton, *bracebutton, *box1button,
*box2button, *box3button, *box4button, *boxbutton;
GtkWidget *boxmenu;
GtkWidget *drawing_area, *preview_area;
#ifdef GTK24
/* --- Widgets used by the Configurable Options dialog --- */
GtkWidget *printer_dialog;
/* Widgets used for layout structure */
GtkWidget *master_vbox;
GtkWidget *notebook;
GtkWidget *table;
/* Widgets that contain data and are accessed from elsewhere */
GtkWidget *color_button;
GtkWidget *printer_name_entry;
GtkWidget *print_scale_spin;
GtkWidget *datadir_entry;
GtkWidget *datamask_entry;
GtkWidget *whiteout_check;
GtkWidget *intl_check;
GtkWidget *paper_size_combo;
GtkWidget *orientation_combo;
GtkWidget *print_cmd_combo;
GtkWidget *eps_preview_combo;
GtkWidget *bond_length_entry;
GtkWidget *dbond_dist_spin;
#else
GtkWidget *papermenu, *papersizes, *orientmenu, *orientations, *printcmdmenu,
*printcmds, *prqueue;
GtkWidget *epsoptionmenu,*epsoptions,*whiteoutbutton,*intlbutton;
GtkWidget *colorsel;
GtkWidget *colorseldialog;
GtkWidget *defaultdir, *defaultext,*base_bondlen,*doubledist;
#endif
GtkWidget *bondomenu, *bondmenu, *menuitem;
GtkWidget *fontmenu,*fontsizes;
GtkWidget *msgtext;
GtkWidget *pdbhbox, *labbutton[5],*sdfhbox,*sdflabel,*sdfbutton[3];
GtkWidget *babelcmds,*babelcmdmenu;
GtkWidget *babelexpcmds,*babelexpmenu;
GdkCursor *cursor_pencil, *cursor_text, *cursor_bonds, *cursor_markTLC,
*cursor_markBRC, *cursor_move, *cursor_rescale, *cursor_rotate,
*cursor_busy;
GdkBitmap *source, *mask;
GtkWidget *oldpixmap;
GdkColor fg = { 0, 0, 0, 0 }; /* Black */
GdkColor bg = { 0, 32767, 32767, 65535 }; /* Blue */
GdkColor wh = { 0, 65535, 65535, 65535 }; /* White */
GdkColor background={0,0xeeee,0x0000,0x0000};
#ifdef GTK2
GtkTextBuffer *msgtextbuffer;
GtkTextIter iter;
GtkAdjustment *msgadjustment;
#endif
char filename[512];
char expname[512];
static int loadsave = 1;
static int expmode = 0;
static int curbond = 0;
static int ringtype = 0;
int newpapersize = 0;
int neworientation = 0;
int newprintcommand = 0;
int newepsoption = 0;
int splinepoint = 0;
int oldwhiteout = 0;
int oldintlchars= 0;
int textentry=-1;
int pendown = 0;
struct
{
int x;
int y;
}
spline[4];
static gint
configure_event (GtkWidget * mainw, GdkEventConfigure * event)
/* callback function to create an empty white drawing area on startup */
{
if (picture)
gdk_pixmap_unref (picture);
picture = gdk_pixmap_new (mainw->window,
mainw->allocation.width + 100,
mainw->allocation.height + 100, -1);
gdk_draw_rectangle (picture,
mainw->style->white_gc,
(gint) TRUE, 0, 0,
(gint) mainw->allocation.width,
(gint) mainw->allocation.height);
Display_Mol ();
return (gint) TRUE;
}
static gint
configure_preview (GtkWidget * mainw, GdkEventConfigure * event)
/* callback function to create an empty white drawing area on startup */
{
if (preview) {
gdk_pixmap_unref (preview);
preview=NULL;
}
preview = gdk_pixmap_new (mainw->window, 200, 100, -1);
gdk_draw_rectangle (preview,
mainw->style->white_gc,
(gint) TRUE, 0, 0, (gint) 200, (gint) 100);
return (gint) TRUE;
}
static gint
expose_event (GtkWidget * mainw, GdkEventExpose * event)
/* callback function to redraw parts of the drawing area */
{
gdk_draw_pixmap (mainw->window,
mainw->style->fg_gc[GTK_WIDGET_STATE (mainw)],
picture,
event->area.x, event->area.y,
event->area.x, event->area.y,
(gint) event->area.width, (gint) event->area.height);
return (gint) FALSE;
}
void
yesnodialog (void (*YesFunc) (void))
/* Popup to show a warning message when unsaved changes are about to be
destroyed by Load or Quit (Modal toplevel dialog) */
{
GtkWidget *button, *label;
GtkWidget *yesno_window;
yesno_window = gtk_dialog_new ();
(void)gtk_signal_connect_object (GTK_OBJECT (yesno_window), "destroy",
GTK_SIGNAL_FUNC (gtk_grab_remove),
GTK_OBJECT (yesno_window));
(void)gtk_signal_connect_object (GTK_OBJECT (yesno_window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (yesno_window));
gtk_container_border_width (GTK_CONTAINER (yesno_window), 5);
label =
gtk_label_new (_
("The current drawing is not saved !\nDo you really wish to continue ?"));
gtk_misc_set_padding (GTK_MISC (label), 10, 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (yesno_window)->vbox), label, TRUE,
(gboolean) TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label (_("Yes"));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_grab_remove),
GTK_OBJECT (yesno_window));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (YesFunc),
GTK_OBJECT (yesno_window));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (yesno_window));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (yesno_window)->action_area),
button, (gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("No"));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_grab_remove),
GTK_OBJECT (yesno_window));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (yesno_window));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (yesno_window)->action_area),
button, (gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (button);
gtk_widget_realize (yesno_window);
gtk_grab_add (yesno_window);
#ifdef GTK2
gtk_window_set_transient_for (GTK_WINDOW (yesno_window),
GTK_WINDOW(mainw));
#else
gtk_window_set_transient_for (GTK_WINDOW (yesno_window),
GTK_WINDOW (gtk_widget_get_toplevel
(yesno_window)));
#endif
gtk_window_set_position (GTK_WINDOW (yesno_window), GTK_WIN_POS_MOUSE);
gtk_widget_show (yesno_window);
}
void
yesnodialog2 (void (*YesFunc) (void), char *somefile)
/* Popup to show a warning message when unsaved changes are about to be
destroyed by Load or Quit (Modal toplevel dialog) */
{
GtkWidget *button, *label;
GtkWidget *yesno_window;
char tmpstr[512];
yesno_window = gtk_dialog_new ();
(void)gtk_signal_connect_object (GTK_OBJECT (yesno_window), "destroy",
GTK_SIGNAL_FUNC (gtk_grab_remove),
GTK_OBJECT (yesno_window));
(void)gtk_signal_connect_object (GTK_OBJECT (yesno_window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (yesno_window));
gtk_container_border_width (GTK_CONTAINER (yesno_window), 5);
snprintf (tmpstr,512, _("File\n%s\nalready exists !\nOverwrite it ?"), somefile);
label = gtk_label_new (tmpstr);
gtk_misc_set_padding (GTK_MISC (label), 10, 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (yesno_window)->vbox), label, TRUE,
(gboolean) TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label (_("Yes"));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_grab_remove),
GTK_OBJECT (yesno_window));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (YesFunc),
GTK_OBJECT (yesno_window));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (yesno_window));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (yesno_window)->action_area),
button, (gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("No"));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_grab_remove),
GTK_OBJECT (yesno_window));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (yesno_window));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (yesno_window)->action_area),
button, (gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (button);
gtk_widget_realize (yesno_window);
gtk_grab_add (yesno_window);
#ifdef GTK2
gtk_window_set_transient_for (GTK_WINDOW (yesno_window),
GTK_WINDOW(mainw));
#else
gtk_window_set_transient_for (GTK_WINDOW (yesno_window),
GTK_WINDOW (gtk_widget_get_toplevel
(yesno_window)));
#endif
gtk_window_set_position (GTK_WINDOW (yesno_window), GTK_WIN_POS_MOUSE);
gtk_widget_show (yesno_window);
}
static gint
button_press_event (GtkWidget * mainw, GdkEventButton * event)
/* Handle mouse button presses depending on current drawing mode */
{
int event_x, event_y;
int i, spt;
char *tmpstr;
draw_ok= 1; /* valid data, allow drawing */
if (event->button == 1 && picture != NULL) /* Button 1 actions: */
{
event_x = (int) event->x;
event_y = (int) event->y;
switch (drawmode)
{
case 1:
/* Text mode: Insert a label */
if (event->state & GDK_CONTROL_MASK)
Add_number (event_x, event_y);
else
Add_atom (event_x, event_y);
#ifdef LIBUNDO
undo_snapshot ();
#endif
break;
case 0:
/* Line mode: show marker boxes around current position */
default:
Set_vector (event_x, event_y, curbond);
break;
case 2:
/* Bondtype mode: change bond at cursor to current default */
Set_bondtype (event_x, event_y, curbond);
#ifdef LIBUNDO
undo_snapshot ();
#endif
break;
case 3:
case 6:
case 7:
/* Move and rotate modes : initialize operation */
Set_pmove (event_x, event_y);
break;
case 4:
/* Mark mode : Set corner of rectangle */
gdk_window_set_cursor (drawing_area->window, cursor_markBRC);
Set_start_rec (event_x, event_y);
break;
case 8:
spline[splinepoint].x = round_coord (event_x, size_factor);
spline[splinepoint].y = round_coord (event_y, size_factor);
splinepoint++;
modify = 1;
if (splinepoint < 4)
{
for (i = 1; i < splinepoint; i++)
gdk_draw_line (picture, mygc[curpen],
(gint) (spline[i - 1].x * size_factor),
(gint) (spline[i - 1].y * size_factor),
(gint) (spline[i].x * size_factor),
(gint) (spline[i].y * size_factor));
CopyPlane ();
}
else
{
spt = 0;
if (curbond == 8)
spt = 1;
if (curbond == 9)
spt = 2;
if (curbond == 10)
spt = -1;
if (curbond == 12)
spt = -2;
add_spline (spline[0].x, spline[0].y, spline[1].x, spline[1].y,
spline[2].x, spline[2].y, spline[3].x, spline[3].y,
spt, 0, curpen);
splinepoint = 0;
Display_Mol ();
}
break;
;;
}
}
if (event->button == 2 && picture != NULL)
/* Second (middle) button */
{
event_x = (int) event->x;
event_y = (int) event->y;
if (drawmode == 2)
{
/* in bondtype mode, reverse direction of current bond */
Invert_vector (event_x, event_y);
#ifdef LIBUNDO
undo_snapshot ();
#endif
}
else if (drawmode == 1){
if (event->state & GDK_CONTROL_MASK){
tmpstr=(char*)gtk_entry_get_text (GTK_ENTRY (textbox));
atnum=atoi(tmpstr);
if (atnum>0)atnum--;
}
else
Fetch_atom (event_x, event_y);
}
else
{
/* in all other modes, set bondtype of current bond to next in list */
Add_double (event_x, event_y);
#ifdef LIBUNDO
undo_snapshot ();
#endif
}
}
if (event->button == 3 && picture != NULL)
/* Button 3 */
{
event_x = (int) event->x;
event_y = (int) event->y;
switch (drawmode)
{
case 0:
/* in line mode, delete bond at cursor */
if (event->state & GDK_CONTROL_MASK)
Del_rec ();
else
Del_vector (event_x, event_y);
#ifdef LIBUNDO
undo_snapshot ();
#endif
break;
case 1:
if (event->state & GDK_CONTROL_MASK)
atnum=0;
else
/* in text mode, deletes label at cursor */
Del_atom (event_x, event_y);
#ifdef LIBUNDO
undo_snapshot ();
#endif
break;
case 4:
#ifdef LIBUNDO
undo_snapshot ();
#endif
Del_rec ();
break;
case 3:
case 6:
/* in move and rotate modes - abort operation */
#ifdef LIBUNDO
do_undo();
#endif
break;
case 8:
/* in spline mode, abort current spline */
splinepoint = 0;
Display_Mol ();
break;
default:
break;
}
}
return (gint) TRUE;
}
static gint
button_release_event (GtkWidget * mainw, GdkEventButton * event)
/* completes drawing actions upon release of the mouse button */
{
int event_x, event_y;
draw_ok = 0;
if (event->button == 1 && picture != NULL)
/* release of the first (left) button */
{
event_x = (int) event->x;
event_y = (int) event->y;
if (drawmode == 0)
{
/* in line mode, adds bond from previous to current position */
if (event->state & GDK_CONTROL_MASK)
{
Add_ring (event_x, event_y, draw_angle, curbond, ringtype);
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer,&iter, "\n", -1);
gtk_adjustment_set_value(msgadjustment,gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, "\n", 1);
#endif
ringtype = 0;
}
else
Add_vector (event_x, event_y, curbond); /* add bond, redisplay */
#ifdef LIBUNDO
undo_snapshot ();
#endif
}
else
{
if (drawmode == 4)
{
/* in mark mode, defines final position for opposite corner of rectangle */
if (event->state & GDK_CONTROL_MASK)
{
Mark_rec (event_x, event_y, 1);
}
else
{
Mark_rec (event_x, event_y, 0);
}
gdk_window_set_cursor (drawing_area->window, cursor_markTLC);
FreePix ();
CreatePix ();
Display_Mol ();
#if 0
Movemode(mainw);
#endif
}
#ifdef LIBUNDO
if (drawmode > 4)
undo_snapshot ();
#endif
}
}
return (gint) TRUE;
}
static gint
motion_notify_event (GtkWidget * widget, GdkEventMotion * event)
/* handles mouse movement while a button is down */
{
gint x, y;
GdkModifierType state;
if (event->is_hint != 0)
(void) gdk_window_get_pointer (event->window, &x, &y, &state);
else
{
x = (gint) event->x;
y = (gint) event->y;
state = event->state;
}
if (( (state & GDK_BUTTON1_MASK)|| pendown==1) && picture != NULL)
{
/* dragging with button 1 (usually left) down */
switch (drawmode)
{
case 0:
/* in line mode, draw bond from last to current cursor position */
if (draw_ok) Put_vector (x, y);
break;
case 3:
/* in move mode, shift marked fragment to current cursor position */
if (event->state & GDK_CONTROL_MASK)
{
Put_pmove (x, y, 1);
}
else if (event->state & GDK_SHIFT_MASK)
{
Put_pmove (x, y, 2);
}
else
{
Put_pmove (x, y, 0);
}
break;
case 4:
/* in mark mode, draw rectangle between initial and current position */
if (draw_ok) Put_rec (x, y);
break;
case 6:
/* in rotate mode, rotate marked fragment by an amount proportional to
the distance between initial and current cursor position */
if (event->state & GDK_CONTROL_MASK)
{
Put_protate (x, y, 1);
}
else
{
Put_protate (x, y, 0);
}
break;
case 7:
if (state & GDK_CONTROL_MASK)
Put_pscale (x, y, 1);
else
Put_pscale (x, y, 0);
break;
default:
break;
}
}
return (gint) TRUE;
}
static gint
key_press_event (GtkWidget * mainw, GdkEventKey * event)
/* Handle key presses depending on current drawing mode */
{
struct dc *hpc;
static char label[MAXCL];
int direction=0;
int dx=0;
char errtext[101];
int x,y;
#ifdef GTK2
if (gtk_widget_is_focus(textbox)) return FALSE;
#endif
if (event->state & GDK_CONTROL_MASK)
{
if (!isdigit ((int) event->keyval))
return ((gint) FALSE);
ringtype = (int) (event->keyval - 48);
if (ringtype < 3)
ringtype += 10;
snprintf (errtext, 100,
_("\nNext ring drawn will have %d sides"), ringtype);
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value(msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext,
(gint) strlen (errtext));
#endif
return ((gint) TRUE);
}
if (event->state & GDK_MOD1_MASK) /* ALT+Cursor shifts grid */
{
if (gridtype == 0) return TRUE; /* nothing to do */
switch (event->keyval){
case GDK_Left:
gridx--;
if (gridx<-50) gridx=0;
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
break;
case GDK_Right:
gridx++;
if (gridx>50) gridx=0;
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
break;
case GDK_Up:
gridy--;
if (gridy<-50) gridy=0;
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
break;
case GDK_Down:
gridy++;
if (gridy>50) gridy=0;
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
break;
default:
return (gint) FALSE;
}
Display_Mol ();
return TRUE;
}
if (drawmode == 0 && picture != NULL) /* Button 1 actions: */
{
if (textentry >-1){ /* label input in progress */
if (event->keyval == GDK_Return) {
label[textentry] = '\0';
add_char (hp->tx, hp->ty, label, direction, 0, curpen,0,curfontsize);
textentry=-1;
Display_Mol ();
return(TRUE);
} else if (isprint((int)event->keyval)) {
label[textentry++]=(char)event->keyval;
gtk_entry_set_text(GTK_ENTRY(textbox),label);
return(TRUE);
}
if (event->keyval == GDK_BackSpace) {
label[--textentry]='\0';
gtk_entry_set_text(GTK_ENTRY(textbox),label);
}
}
switch (event->keyval)
{
case 'c':
case 'o':
case 'n':
case 's':
case 'p':
case 'h':
case 'f':
case 'i':
case 'r':
case 'b':
case 'd':
direction = Middle_Text;
label[0] = toupper ((int) event->keyval);
label[1] = '\0';
add_char (hp->tx, hp->ty, label, direction, 0,curpen,0,curfontsize);
break;
case 'l':
direction = Left_Text;
strcpy (label, "Cl");
add_char (hp->tx, hp->ty, label, direction, 0,curpen,0,curfontsize);
break;
case '1':
direction = Left_Text;
strcpy (label, "CH");
add_char (hp->tx, hp->ty, label, direction, 0, curpen,0,curfontsize);
break;
case '2':
direction = Left_Text;
strcpy (label, "CH_2");
add_char (hp->tx, hp->ty, label, direction, 0, curpen,0,curfontsize);
break;
case '3':
direction = Left_Text;
strcpy (label, "CH_3");
add_char (hp->tx, hp->ty, label, direction, 0, curpen,0,curfontsize);
break;
case '*':
direction = Middle_Text;
label[0] = '@';
label[1] = '\267';
label[2] = '\0';
add_char (hp->tx, hp->ty, label, direction, 0, curpen,0,curfontsize);
break;
case ' ':
direction=Left_Text;
/* fprintf(stderr,"start label entering\n");*/
memset(label,0,25);
textentry=0;
break;
case GDK_KP_Left:
case GDK_KP_4:
hpc=select_char(hp->tx,hp->ty,1);
if (hpc ) {
dx =3*hpc->direct *(int)strlen(hpc->c);
if (event->state & GDK_SHIFT_MASK) {/* dots */
add_char (hp->tx-15+dx,hp->ty-4,"@\267",Middle_Text,0,curpen,0,curfontsize);
add_char (hp->tx-15+dx,hp->ty+4,"@\267",Middle_Text,0,curpen,0,curfontsize);
}else{
add_struct(hp->tx-15+dx,hp->ty-12,hp->tx-15+dx,hp->ty+8,0,0,0,1,curpen);
}
}
break;
case GDK_KP_Up:
case GDK_KP_8:
hpc=select_char(hp->tx,hp->ty,1);
if (hpc ) {
dx =3*hpc->direct *(int)strlen(hpc->c);
if (event->state & GDK_SHIFT_MASK) {/* dots */
add_char (hp->tx-4+dx,hp->ty-20,"@\267",Middle_Text,0,curpen,0,curfontsize);
add_char (hp->tx+8+dx,hp->ty-20,"@\267",Middle_Text,0,curpen,0,curfontsize);
}else{
add_struct(hp->tx-10+dx,hp->ty-20,hp->tx+10+dx,hp->ty-20,0,0,0,1,curpen);
}
}
break;
case GDK_KP_Right:
case GDK_KP_6:
hpc=select_char(hp->tx,hp->ty,1);
if (hpc ) {
dx =5 *((int)strlen(hpc->c)-1);
if (event->state & GDK_SHIFT_MASK) {/* dots */
add_char (hp->tx+13+dx,hp->ty-4,"@\267",Middle_Text,0,curpen,0,curfontsize);
add_char (hp->tx+13+dx,hp->ty+4,"@\267",Middle_Text,0,curpen,0,curfontsize);
}else{
add_struct(hp->tx+15+dx,hp->ty-12,hp->tx+15+dx,hp->ty+8,0,0,0,1,curpen);
}
}
break;
case GDK_KP_Down:
case GDK_KP_2:
hpc=select_char(hp->tx,hp->ty,1);
if (hpc ) {
dx =3*hpc->direct *(int)strlen(hpc->c);
if (event->state & GDK_SHIFT_MASK) {/* dots */
add_char (hp->tx-4+dx,hp->ty+15,"@\267",Middle_Text,0,curpen,0,curfontsize);
add_char (hp->tx+8+dx,hp->ty+15,"@\267",Middle_Text,0,curpen,0,curfontsize);
}else{
add_struct(hp->tx-10+dx,hp->ty+15,hp->tx+10+dx,hp->ty+15,0,0,0,1,curpen);
}
}
break;
case GDK_KP_Home:
case GDK_KP_7:
hpc=select_char(hp->tx,hp->ty,1);
if (hpc ) {
dx =3*hpc->direct *(int)strlen(hpc->c);
if (event->state & GDK_SHIFT_MASK) {/* dots */
add_char (hp->tx-20+dx,hp->ty-10,"@\267",Middle_Text,0,curpen,0,curfontsize);
add_char (hp->tx-5+dx,hp->ty-20,"@\267",Middle_Text,0,curpen,0,curfontsize);
}else{
add_struct(hp->tx-20+dx,hp->ty-10,hp->tx-5+dx,hp->ty-20,0,0,0,1,curpen);
}
}
break;
case GDK_KP_Page_Up:
case GDK_KP_9:
hpc=select_char(hp->tx,hp->ty,1);
if (hpc) {
dx =5 *(int)strlen(hpc->c);
if (event->state & GDK_SHIFT_MASK) {/* dots */
add_char (hp->tx+20+dx,hp->ty-10,"@\267",Middle_Text,0,curpen,0,curfontsize);
add_char (hp->tx+5+dx,hp->ty-20,"@\267",Middle_Text,0,curpen,0,curfontsize);
}else{
add_struct(hp->tx+20+dx,hp->ty-10,hp->tx+5+dx,hp->ty-20,0,0,0,1,curpen);
}
}
break;
case GDK_KP_End:
case GDK_KP_1:
hpc=select_char(hp->tx,hp->ty,1);
if (hpc ) {
dx =3*hpc->direct *(int)strlen(hpc->c);
if (event->state & GDK_SHIFT_MASK) {/* dots */
add_char (hp->tx-20+dx,hp->ty+5,"@\267",Middle_Text,0,curpen,0,curfontsize);
add_char (hp->tx-5+dx,hp->ty+15,"@\267",Middle_Text,0,curpen,0,curfontsize);
}else{
add_struct(hp->tx-20+dx,hp->ty+5,hp->tx-5+dx,hp->ty+15,0,0,0,1,curpen);
}
}
break;
case GDK_KP_Page_Down:
case GDK_KP_3:
hpc=select_char(hp->tx,hp->ty,1);
if (hpc ) {
dx =5 *((int)strlen(hpc->c)-1);
if (event->state & GDK_SHIFT_MASK) {/* dots */
add_char (hp->tx+20+dx,hp->ty+5,"@\267",Middle_Text,0,curpen,0,curfontsize);
add_char (hp->tx+5+dx,hp->ty+15,"@\267",Middle_Text,0,curpen,0,curfontsize);
}else{
add_struct(hp->tx+20+dx,hp->ty+5,hp->tx+5+dx,hp->ty+15,0,0,0,1,curpen);
}
}
break;
case GDK_Left:
if (event->state & GDK_SHIFT_MASK){
pendown=1;
draw_ok=1;
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,-1,0);
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
Put_vector(x,y);
}else{
pendown=0;
draw_ok=0;
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,-1,0);
}
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
break;
case GDK_Right:
if (event->state & GDK_SHIFT_MASK){
pendown=1;
draw_ok=1;
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,1,0);
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
Put_vector(x,y);
}else{
pendown=0;
draw_ok=0;
}
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,1,0);
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
break;
case GDK_Up:
if (event->state & GDK_SHIFT_MASK){
pendown=1;
draw_ok=1;
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,0,-1);
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
Put_vector(x,y);
}else{
pendown=0;
draw_ok=0;
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,0,-1);
}
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
break;
case GDK_Down:
if (event->state & GDK_SHIFT_MASK){
pendown=1;
draw_ok=1;
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
Put_vector(x,y);
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,0,1);
}
else
{
pendown=0;
draw_ok=0;
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,0,1);
}
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
break;
case GDK_Return:
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
if (pendown==0){
Set_vector(x,y,curbond);
}else{
draw_ok=1;
Add_vector(x,y,curbond);
pendown=0;
Set_vector(x,y,curbond);
}
break;
default:
return (gint) FALSE;
}
Display_Mol ();
#ifdef LIBUNDO
undo_snapshot ();
#endif
}
else if (drawmode == 3 && picture != NULL)
{
switch (event->keyval){
case GDK_Left:
if (event->state & GDK_SHIFT_MASK)
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,-5,0);
else
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,-1,0);
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
Put_pmove(x,y,0);
break;
case GDK_Right:
if (event->state & GDK_SHIFT_MASK)
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,5,0);
else
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,1,0);
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
Put_pmove(x,y,0);
break;
case GDK_Up:
if (event->state & GDK_SHIFT_MASK)
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,0,-5);
else
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,0,-1);
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
Put_pmove(x,y,0);
break;
case GDK_Down:
if (event->state & GDK_SHIFT_MASK)
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,0,5);
else
XWarpPointer(GDK_DISPLAY(),None,None,0,0,0,0,0,1);
gtk_signal_emit_stop_by_name (GTK_OBJECT(mainw),
"key_press_event");
(void)gdk_window_get_pointer(drawing_area->window,&x,&y,NULL);
Put_pmove(x,y,0);
break;
case GDK_Return:
Unmark_all();
break;
default:
return (gint) FALSE;
}
Display_Mol ();
}
else if (importflag != 0 && event->keyval == GDK_Return)
{
pdbstore ();
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton, TRUE);
snprintf (errtext, 100,
_("\nImported %d bonds and %d labels"), hp->n, hp->nc);
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value (msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext,
(gint) strlen (errtext));
#endif
}
return (gint) TRUE;
}
#ifdef LIBUNDO
void
do_undo ()
{
int d;
struct data *hp_b;
struct dc *hp_c;
struct spline *hp_sp;
if (undo_get_undo_count () < 1)
return;
undo_undo ();
if (hp->n > 0)
{
hp_b = da_root.next;
if (hp_b->prev != &da_root)
{
for (d = 0; d < hp->n; d++)
{
hp_b = hp_b->prev;
if (hp_b->prev == &da_root)
{
da_root.next = hp_b;
break;
}
da_root.next = hp_b;
}
}
for (d = 0; d < hp->n; d++)
hp_b = hp_b->next;
new = hp_b;
}
else
{
new = da_root.next;
new->prev = &da_root;
}
if (hp->nc > 0)
{
hp_c = dac_root.next;
if (hp_c->prev != &dac_root)
{
for (d = 0; d < hp->nc; d++)
{
hp_c = hp_c->prev;
if (hp_c->prev == &dac_root)
{
dac_root.next = hp_c;
break;
}
dac_root.next = hp_c;
}
}
for (d = 0; d < hp->nc; d++)
hp_c = hp_c->next;
new_c = hp_c;
}
else
{
new_c = dac_root.next;
new_c->prev = &dac_root;
}
if (hp->nsp > 0)
{
hp_sp = sp_root.next;
if (hp_sp->prev != &sp_root)
{
for (d = 0; d < hp->nsp; d++)
{
hp_sp = hp_sp->prev;
if (hp_sp->prev == &sp_root)
{
sp_root.next = hp_sp;
break;
}
sp_root.next = hp_sp;
}
}
for (d = 0; d < hp->nsp; d++)
hp_sp = hp_sp->next;
sp_new = hp_sp;
}
else
{
sp_new = sp_root.next;
sp_new->prev = &sp_root;
}
FreePix ();
CreatePix ();
Display_Mol ();
}
void
do_redo ()
{
int d;
struct data *hp_b;
struct dc *hp_c;
struct spline *hp_sp;
if (undo_get_redo_count () > 0)
undo_redo ();
if (hp->n > 0)
{
hp_b = da_root.next;
if (hp_b->prev != &da_root)
{
for (d = 0; d < hp->n; d++)
{
hp_b = hp_b->prev;
if (hp_b->prev == &da_root)
{
da_root.next = hp_b;
break;
}
da_root.next = hp_b;
}
}
for (d = 0; d < hp->n; d++)
hp_b = hp_b->next;
new = hp_b;
}
else
{
new = da_root.next;
new->prev = &da_root;
}
if (hp->nc > 0)
{
hp_c = dac_root.next;
if (hp_c->prev != &dac_root)
{
for (d = 0; d < hp->nc; d++)
{
hp_c = hp_c->prev;
if (hp_c->prev == &dac_root)
{
dac_root.next = hp_c;
break;
}
dac_root.next = hp_c;
}
}
for (d = 0; d < hp->nc; d++)
hp_c = hp_c->next;
new_c = hp_c;
}
else
{
new_c = dac_root.next;
new_c->prev = &dac_root;
}
if (hp->nsp > 0)
{
hp_sp = sp_root.next;
if (hp_sp->prev != &sp_root)
{
for (d = 0; d < hp->nsp; d++)
{
hp_sp = hp_sp->prev;
if (hp_sp->prev == &sp_root)
{
sp_root.next = hp_sp;
break;
}
sp_root.next = hp_sp;
}
}
for (d = 0; d < hp->nsp; d++)
hp_sp = hp_sp->next;
sp_new = hp_sp;
}
else
{
sp_new = sp_root.next;
sp_new->prev = &sp_root;
}
FreePix ();
CreatePix ();
Display_Mol ();
}
#endif
void
Zoom (GtkWidget * mainw, gpointer inout)
/* increase or decrease zoom scale (two steps to either side ) */
{
if (inout && strcmp ((char *) inout , "0"))
{
if (zoom_factor != 0)
zoom_factor--;
}
else
{
if (zoom_factor < 4)
zoom_factor++;
}
gtk_option_menu_set_history(GTK_OPTION_MENU(fontmenu), (guint)zoom_factor+1);
curfontsize=zoom_factor+1;
FreePix ();
CreatePix ();
Display_Mol ();
if (importflag != 0)
pdbrotate (0, 0, 2);
}
void
Grid (GtkWidget * mainw)
/* show or hide grid */
{
if (gridtype < 2)
gridtype ++;
else
gridtype = 0;
FreePix ();
CreatePix ();
Display_Mol ();
if (importflag != 0)
pdbrotate (0, 0, 2);
}
void
change_color (GtkWidget * mainw)
/* increment current pencolor and update color selection button */
{
GdkPixmap *pixmap;
GtkWidget *pixmapwid;
GtkStyle *style=gtk_widget_get_style (mainw);;
if (curpen < 6)
curpen ++;
else
curpen = 0;
pixmap = gdk_pixmap_create_from_xpm_d (mainw->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_color[curpen]);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_remove (GTK_CONTAINER (colorbutton),oldpixmap);
gtk_container_add (GTK_CONTAINER (colorbutton), pixmapwid);
oldpixmap=pixmapwid;
}
void
CheckAndClear ()
/* called by Clear button, pops up an "are you sure" dialog if the current
drawing changed since last save, or calls real Clear function directly */
{
if (modify == 0 || hp->n + hp->nc + hp->nsp == 0)
{
Clear ();
}
else
{
yesnodialog (Clear);
}
}
void
Clear ()
/* deletes all atoms and bonds from memory and reinitializes drawing area */
{
char msgtmp[100];
clear_data ();
modify = 0;
atnum = 0;
mark.x = 300;
mark.y = 300;
hp->n = 0;
hp->nc = 0;
hp->nsp = 0;
hp->x = 200;
hp->y = 200;
hp->tx = 200;
hp->ty = 200;
if (pdbn)
{
free (pdbx);
free (pdby);
free (pdbz);
free (bondfrom);
free (bondto);
free (bondtype);
bondfrom = NULL;
bondto = NULL;
bondtype = NULL;
pdbx = NULL;
pdby = NULL;
pdbz = NULL;
free (atjust);
atjust = NULL;
free (atcode);
atcode = NULL;
pdbn = 0;
}
importflag = 0;
addflag = 0;
refx=refy=0;
#ifdef LIBUNDO
undo_snapshot ();
new = da_root.next;
new->prev = &da_root;
#endif
strcpy (filename, _("unnamed"));
gtk_window_set_title (GTK_WINDOW (window), "Chemtool 1.6.10");
snprintf(msgtmp,99,_("\nReady"));
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, msgtmp, -1);
gtk_adjustment_set_value (msgadjustment, gtk_adjustment_get_value (msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, msgtmp,
(gint)strlen(msgtmp));
#endif
FreePix ();
CreatePix ();
Display_Mol ();
}
void
do_fw ()
{
int error;
char errtext[255];
size_t msglen = 254;
strcpy (formula, "program cht not available or unable to write to");
strcpy (weight, filename);
strcat (weight, ".rad");
strcpy (eweight, " ?");
strcpy (compos, " ?");
error = export_fw (filename);
if (error != 0)
{
snprintf (errtext, msglen, _("\nHelper process failed - %s %s %s %s!"),
formula, weight, eweight, compos);
}
else
{
snprintf (errtext, msglen, _("\n%s %s %s %s"), formula, weight,
eweight, compos);
}
#ifdef GTK2
gtk_text_buffer_insert(msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value(msgadjustment,gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext,
(gint) strlen (errtext));
#endif
}
void
print_ps ()
{
char errtext[255];
size_t msglen = 254;
if (hp->n + hp->nc + hp->nsp == 0)
return;
if (print_ps_pic (filename) == 0)
{
snprintf(errtext,msglen,_("\nDrawing printed!"));
}
else
{
snprintf(errtext,msglen,_("\nFailed to print drawing !"));
}
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value (msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL,
errtext,(gint)strlen(errtext));
#endif
}
#ifdef GTK24
/* ************** Callback for Configurable Options Dialog ************** */
int options_dialog_ok (GtkWidget *widget, gpointer data) {
int newint;
GdkColor color;
papersize = gtk_combo_box_get_active (GTK_COMBO_BOX (paper_size_combo));
orient = gtk_combo_box_get_active (GTK_COMBO_BOX (orientation_combo));
printcmd = gtk_combo_box_get_active (GTK_COMBO_BOX (print_cmd_combo));
epsoption = gtk_combo_box_get_active (GTK_COMBO_BOX (eps_preview_combo));
use_whiteout = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (whiteout_check));
use_intlchars = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (intl_check));
strcpy (queuename, gtk_entry_get_text (GTK_ENTRY (printer_name_entry)));
printscale =
gtk_spin_button_get_value_as_float (GTK_SPIN_BUTTON (print_scale_spin)) / 100.0;
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (datadir_entry)));
strcpy (datamask, gtk_entry_get_text (GTK_ENTRY (datamask_entry)));
newint = atof(gtk_entry_get_text (GTK_ENTRY (bond_length_entry)));
if (newint != 0 && newint != bondlen_mm) {
size_factor /= bondlen_mm/10.668;
bondlen_mm = newint;
size_factor *= bondlen_mm/10.668;
}
newint = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dbond_dist_spin));
if (newint >= 0 && db_dist != newint) {
db_dist = newint;
mb_dist = (int) ( ((float)db_dist) * 2.5);
}
gtk_color_button_get_color (GTK_COLOR_BUTTON (color_button), &color);
gdk_colormap_alloc_color(gdk_colormap_get_system(), &color, FALSE, TRUE);
gdk_gc_set_foreground(background_gc, &color);
gdk_gc_set_background(background_gc, &color);
FreePix();
CreatePix();
Display_Mol();
gtk_widget_hide (printer_dialog);
return TRUE;
}
void prepare_options_dialog () {
char msgtmp[100];
gtk_color_button_set_color (GTK_COLOR_BUTTON (color_button), &background);
if (use_whiteout == 1) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (whiteout_check), TRUE);
}
else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (whiteout_check), FALSE);
}
if (use_intlchars == 1) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (intl_check), TRUE);
}
else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (intl_check), FALSE);
}
gtk_entry_set_text (GTK_ENTRY (datadir_entry), datadir);
gtk_entry_set_text (GTK_ENTRY (datamask_entry), datamask);
gtk_combo_box_set_active (GTK_COMBO_BOX (eps_preview_combo), epsoption);
snprintf (msgtmp, 100, "%6.4f", bondlen_mm);
gtk_entry_set_text (GTK_ENTRY (bond_length_entry), msgtmp);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dbond_dist_spin), db_dist);
gtk_combo_box_set_active (GTK_COMBO_BOX (print_cmd_combo), printcmd);
gtk_entry_set_text (GTK_ENTRY (printer_name_entry), queuename);
gtk_combo_box_set_active (GTK_COMBO_BOX (paper_size_combo), papersize);
gtk_combo_box_set_active (GTK_COMBO_BOX (orientation_combo), orient);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (print_scale_spin),
printscale * 100);
}
int print_setup_menu_activate (GtkWidget *widget, gpointer data) {
prepare_options_dialog ();
gtk_widget_show (printer_dialog);
return TRUE;
}
#else
void
setup_printer (GtkWidget * mainw, gpointer change)
{
char tmpstr[10];
double bondlen_new;
int doubledist_new;
if (atoi (change) == 1)
{
papersize = newpapersize;
orient = neworientation;
printcmd = newprintcommand;
epsoption = newepsoption;
oldwhiteout = use_whiteout;
oldintlchars = use_intlchars;
printscale =
gtk_spin_button_get_value_as_float ((GtkSpinButton *) pscale) / 100.;
queuename = (char*)gtk_entry_get_text (GTK_ENTRY (prqueue));
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (defaultdir)));
strcpy (datamask, gtk_entry_get_text (GTK_ENTRY (defaultext)));
bondlen_new=atof(gtk_entry_get_text (GTK_ENTRY(base_bondlen)));
if (bondlen_new != 0 && bondlen_mm != bondlen_new){
size_factor /= bondlen_mm/10.668;
bondlen_mm = bondlen_new;
size_factor *= bondlen_mm/10.668;
}
doubledist_new=atoi(gtk_entry_get_text (GTK_ENTRY(doubledist)));
if (doubledist_new >= 0 && db_dist != doubledist_new){
db_dist = doubledist_new;
mb_dist = (int) ( ((float)db_dist) * 2.5);
}
}
else
{
gtk_option_menu_set_history (GTK_OPTION_MENU (papermenu), (guint)papersize);
gtk_option_menu_set_history (GTK_OPTION_MENU (orientmenu), (guint)orient);
gtk_spin_button_set_value ((GtkSpinButton *) pscale, printscale * 100.);
gtk_option_menu_set_history (GTK_OPTION_MENU (epsoptionmenu), (guint)epsoption);
gtk_option_menu_set_history (GTK_OPTION_MENU (printcmdmenu), (guint)printcmd);
gtk_entry_set_text (GTK_ENTRY (prqueue), queuename);
gtk_entry_set_text (GTK_ENTRY (defaultdir), datadir);
gtk_entry_set_text (GTK_ENTRY (defaultext), datamask);
snprintf(tmpstr,10,"%6.4f",bondlen_mm);
gtk_entry_set_text (GTK_ENTRY (base_bondlen),tmpstr);
snprintf(tmpstr,10,"%d",db_dist);
gtk_entry_set_text (GTK_ENTRY (doubledist),tmpstr);
if (oldwhiteout != use_whiteout) {
/* toggle button triggers immediately, and resetting
the button state fires another event, which we use
here to actually reset the value */
if (use_whiteout == 1) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(whiteoutbutton),FALSE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(whiteoutbutton),TRUE);
}
if (oldintlchars != use_intlchars) {
/* toggle button triggers immediately, and resetting
the button state fires another event, which we use
here to actually reset the value */
if (use_intlchars == 1) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(intlbutton),FALSE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(intlbutton),TRUE);
}
}
}
int
newpaper (GtkWidget * mainw, gpointer newpaper)
{
int i;
for (i = 0; i < 11; i++)
{
if (!strcmp (newpaper, paper[i]))
{
newpapersize = i;
return TRUE;
}
}
return TRUE;
}
int
neworient (GtkWidget * mainw, gpointer newo)
{
neworientation = atoi (newo);
return TRUE;
}
int
newprcmd (GtkWidget * mainw, gpointer newc)
{
newprintcommand = atoi (newc);
return TRUE;
}
int
newepsopt (GtkWidget * mainw, gpointer newo)
{
newepsoption = atoi (newo);
return TRUE;
}
int
toggle_whiteout (GtkWidget *mainw, gpointer dummy)
{
if (use_whiteout==0)
use_whiteout=1;
else
use_whiteout=0;
return TRUE;
}
int
toggle_intlchars (GtkWidget *mainw, gpointer dummy)
{
if (use_intlchars==0)
use_intlchars=1;
else
use_intlchars=0;
return TRUE;
}
static void
set_bgcolor (GtkWidget * mainw, GtkColorSelection *colorsel)
/* Handle color data provided by the standard GTK color selector widget */
{
gdouble thecolor[4];
gtk_color_selection_get_color(colorsel,thecolor);
bgred=(int)(thecolor[0]*65535);
bggreen=(int)(thecolor[1]*65535);
bgblue=(int)(thecolor[2]*65535);
background.red=(gushort)bgred;
background.green=(gushort)bggreen;
background.blue=(gushort)bgblue;
(void)gdk_color_alloc(gdk_colormap_get_system(),&background);
gdk_gc_set_foreground(background_gc,&background);
gdk_gc_set_background(background_gc,&background);
snprintf(bghexcolor,10,"#%2.2x%2.2x%2.2x",(unsigned char)(bgred/256.),(unsigned char)(bggreen/256.),(unsigned char)(bgblue/256.));
#ifdef GTK2
gtk_label_set_text(GTK_LABEL(GTK_BIN(bgcolorbutton)->child),bghexcolor);
#else
gtk_label_set_text(GTK_LABEL(GTK_BUTTON(bgcolorbutton)->child),bghexcolor);
#endif
FreePix();
CreatePix();
Display_Mol();
}
#endif
static void
set_fontsize (GtkWidget *mainw, gpointer newfont)
{
curfontsize=GPOINTER_TO_INT(newfont);
}
int babelcmd (GtkWidget *mainw, gpointer newc)
{
/*@ignore@ splint does not recognize strdup */
babel=strdup(newc);
/*@end@*/
if (loadsave==7){
char expn[512];
int n,i;
strcpy(expn,filename);
n = (int) strlen (expn);
for (i = 0; i < (int) strlen (expn); i++)
{
if (expn[i] == '.')
n = i;
if (expn[i] == '/')
n = (int) strlen (expn);
}
expn[n] = '\0';
strcat(expn,".");
strcat(expn,babel);
gtk_file_selection_set_filename (GTK_FILE_SELECTION (filew), expn);
}
return TRUE;
}
void
Set_Textmode (GtkWidget * mainw, GdkEvent * the_event)
/* callback to force (left-justified) textmode when the text entry
widget acquires the focus in one of the drawing modes. This is
necessary to prevent interpretation of the typed text as shortcuts */
{
if (drawmode != 1)
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
(gboolean) TRUE);
}
void
Change_Font (GtkWidget * mainw)
{
if (serif_flag == 0) {
serif_flag=1;
gtk_widget_set_style(GTK_WIDGET(textlabel),seriffontstyle);
}
else
{
serif_flag=0;
gtk_widget_set_style(GTK_WIDGET(textlabel),normalfontstyle);
}
}
void
Change_Text (GtkWidget * mainw, gpointer textdir)
/* callback function for the (left, centered,right) text buttons,
sets drawmode to text with appropriate justification mode and handles
'radio button' status of the toolbar line - this is rather messy, as
we have to find out which button to deactivate */
{
if (importflag != 0)
return;
if (drawmode == 3)
{
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton,
(gboolean) FALSE);
}
if (drawmode == 4)
{
gtk_toggle_button_set_active ((GtkToggleButton *) markbutton,
(gboolean) FALSE);
}
if (drawmode == 6)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
(gboolean) FALSE);
}
if (drawmode == 7)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rescalebutton,
(gboolean) FALSE);
}
if (drawmode == 8)
{
gtk_toggle_button_set_active ((GtkToggleButton *) splinebutton,
(gboolean) FALSE);
}
if (drawmode == 2)
{
gtk_toggle_button_set_active ((GtkToggleButton *) bondbutton,
(gboolean) FALSE);
}
if (drawmode == 0)
{
switch (draw_angle)
{
case 1:
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton,
(gboolean) FALSE);
break;
case 2:
gtk_toggle_button_set_active ((GtkToggleButton *) pent1button,
(gboolean) FALSE);
break;
case 3:
gtk_toggle_button_set_active ((GtkToggleButton *) pent2button,
(gboolean) FALSE);
break;
case 4:
gtk_toggle_button_set_active ((GtkToggleButton *) octbutton,
(gboolean) FALSE);
break;
default:
fprintf (stderr, "invalid angle mode %d\n", draw_angle);
}
}
if (drawmode == 1)
{
switch (text_direct)
{
case 0:
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
(gboolean) FALSE);
break;
case -1:
gtk_toggle_button_set_active ((GtkToggleButton *) ctextbutton,
(gboolean) FALSE);
break;
case -2:
gtk_toggle_button_set_active ((GtkToggleButton *) rtextbutton,
(gboolean) FALSE);
break;
default:
fprintf (stderr, "invalid text mode %d\n", text_direct);
}
}
drawmode = 1;
text_direct = atoi (textdir);
gdk_window_set_cursor (drawing_area->window, cursor_text);
}
void
set_bond (GtkWidget * mainw, gpointer bondnum)
{
curbond = atoi (bondnum);
}
void
Bondmode (GtkWidget * mainw)
/* Callback to enter bondtype changing mode - handles 'radio button'
status of the toolbar after checking which button to deactivate */
{
if (importflag != 0)
return;
if (drawmode == 8)
{
gtk_toggle_button_set_active ((GtkToggleButton *) splinebutton,
(gboolean) FALSE);
}
if (drawmode == 7)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rescalebutton,
(gboolean) FALSE);
}
if (drawmode == 6)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
(gboolean) FALSE);
}
if (drawmode == 3)
{
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton,
(gboolean) FALSE);
}
if (drawmode == 4)
{
gtk_toggle_button_set_active ((GtkToggleButton *) markbutton,
(gboolean) FALSE);
}
if (drawmode == 0)
{
switch (draw_angle)
{
case 1:
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton,
(gboolean) FALSE);
break;
case 2:
gtk_toggle_button_set_active ((GtkToggleButton *) pent1button,
(gboolean) FALSE);
break;
case 3:
gtk_toggle_button_set_active ((GtkToggleButton *) pent2button,
(gboolean) FALSE);
break;
case 4:
gtk_toggle_button_set_active ((GtkToggleButton *) octbutton,
(gboolean) FALSE);
}
}
if (drawmode == 1)
{
switch (text_direct)
{
case 0:
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
(gboolean) FALSE);
break;
case -1:
gtk_toggle_button_set_active ((GtkToggleButton *) ctextbutton,
(gboolean) FALSE);
break;
case -2:
gtk_toggle_button_set_active ((GtkToggleButton *) rtextbutton,
(gboolean) FALSE);
}
}
drawmode = 2;
gdk_window_set_cursor (drawing_area->window, cursor_bonds);
}
void
Movemode (GtkWidget * mainw)
/* Callback function to enter 'move marked fragment' mode - checks and
updates radio button status of the toolbar */
{
if (importflag != 0)
return;
if (drawmode == 8)
{
gtk_toggle_button_set_active ((GtkToggleButton *) splinebutton,
(gboolean) FALSE);
}
if (drawmode == 7)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rescalebutton,
(gboolean) FALSE);
}
if (drawmode == 6)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
(gboolean) FALSE);
}
if (drawmode == 4)
{
gtk_toggle_button_set_active ((GtkToggleButton *) markbutton,
(gboolean) FALSE);
}
if (drawmode == 2)
{
gtk_toggle_button_set_active ((GtkToggleButton *) bondbutton,
(gboolean) FALSE);
}
if (drawmode == 0)
{
switch (draw_angle)
{
case 1:
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton,
(gboolean) FALSE);
break;
case 2:
gtk_toggle_button_set_active ((GtkToggleButton *) pent1button,
(gboolean) FALSE);
break;
case 3:
gtk_toggle_button_set_active ((GtkToggleButton *) pent2button,
(gboolean) FALSE);
break;
case 4:
gtk_toggle_button_set_active ((GtkToggleButton *) octbutton,
(gboolean) FALSE);
}
}
if (drawmode == 1)
{
switch (text_direct)
{
case 0:
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
(gboolean) FALSE);
break;
case -1:
gtk_toggle_button_set_active ((GtkToggleButton *) ctextbutton,
(gboolean) FALSE);
break;
case -2:
gtk_toggle_button_set_active ((GtkToggleButton *) rtextbutton,
(gboolean) FALSE);
}
}
drawmode = 3;
gdk_window_set_cursor (drawing_area->window, cursor_move);
Display_Mol ();
}
void
Markmode (GtkWidget * mainw)
/* Callback function to set 'mark fragment' mode, checks and updates
radio button state of the toolbar */
{
if (importflag != 0)
return;
if (drawmode == 8)
{
gtk_toggle_button_set_active ((GtkToggleButton *) splinebutton,
(gboolean) FALSE);
}
if (drawmode == 7)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rescalebutton,
(gboolean) FALSE);
}
if (drawmode == 6)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
(gboolean) FALSE);
}
if (drawmode == 3)
{
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton,
(gboolean) FALSE);
}
if (drawmode == 2)
{
gtk_toggle_button_set_active ((GtkToggleButton *) bondbutton,
(gboolean) FALSE);
}
if (drawmode == 0)
{
switch (draw_angle)
{
case 1:
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton,
(gboolean) FALSE);
break;
case 2:
gtk_toggle_button_set_active ((GtkToggleButton *) pent1button,
(gboolean) FALSE);
break;
case 3:
gtk_toggle_button_set_active ((GtkToggleButton *) pent2button,
(gboolean) FALSE);
break;
case 4:
gtk_toggle_button_set_active ((GtkToggleButton *) octbutton,
(gboolean) FALSE);
}
}
if (drawmode == 1)
{
switch (text_direct)
{
case 0:
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
(gboolean) FALSE);
break;
case -1:
gtk_toggle_button_set_active ((GtkToggleButton *) ctextbutton,
(gboolean) FALSE);
break;
case -2:
gtk_toggle_button_set_active ((GtkToggleButton *) rtextbutton,
(gboolean) FALSE);
}
}
drawmode = 4;
gdk_window_set_cursor (drawing_area->window, cursor_markTLC);
}
void
Rotatemode (GtkWidget * mainw)
/* Callback function to set 'rotate marked fragment' mode - checks and
updates radio button state of the toolbar */
{
if (drawmode == 8)
{
gtk_toggle_button_set_active ((GtkToggleButton *) splinebutton,
(gboolean) FALSE);
}
if (drawmode == 7)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rescalebutton,
(gboolean) FALSE);
}
if (drawmode == 3)
{
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton,
(gboolean) FALSE);
}
if (drawmode == 4)
{
gtk_toggle_button_set_active ((GtkToggleButton *) markbutton,
(gboolean) FALSE);
}
if (drawmode == 2)
{
gtk_toggle_button_set_active ((GtkToggleButton *) bondbutton,
(gboolean) FALSE);
}
if (drawmode == 0)
{
switch (draw_angle)
{
case 1:
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton,
(gboolean) FALSE);
break;
case 2:
gtk_toggle_button_set_active ((GtkToggleButton *) pent1button,
(gboolean) FALSE);
break;
case 3:
gtk_toggle_button_set_active ((GtkToggleButton *) pent2button,
(gboolean) FALSE);
break;
case 4:
gtk_toggle_button_set_active ((GtkToggleButton *) octbutton,
(gboolean) FALSE);
}
}
if (drawmode == 1)
{
switch (text_direct)
{
case 0:
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
(gboolean) FALSE);
break;
case -1:
gtk_toggle_button_set_active ((GtkToggleButton *) ctextbutton,
(gboolean) FALSE);
break;
case -2:
gtk_toggle_button_set_active ((GtkToggleButton *) rtextbutton,
(gboolean) FALSE);
}
}
drawmode = 6;
gdk_window_set_cursor (drawing_area->window, cursor_rotate);
}
void
Rescalemode (GtkWidget * mainw)
/* Callback function to set 'rescale marked fragment' mode - checks and
updates radio button state of the toolbar */
{
if (importflag != 0)
return;
if (drawmode == 8)
{
gtk_toggle_button_set_active ((GtkToggleButton *) splinebutton,
(gboolean) FALSE);
}
if (drawmode == 3)
{
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton,
(gboolean) FALSE);
}
if (drawmode == 4)
{
gtk_toggle_button_set_active ((GtkToggleButton *) markbutton,
(gboolean) FALSE);
}
if (drawmode == 2)
{
gtk_toggle_button_set_active ((GtkToggleButton *) bondbutton,
(gboolean) FALSE);
}
if (drawmode == 6)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
(gboolean) FALSE);
}
if (drawmode == 0)
{
switch (draw_angle)
{
case 1:
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton,
(gboolean) FALSE);
break;
case 2:
gtk_toggle_button_set_active ((GtkToggleButton *) pent1button,
(gboolean) FALSE);
break;
case 3:
gtk_toggle_button_set_active ((GtkToggleButton *) pent2button,
(gboolean) FALSE);
break;
case 4:
gtk_toggle_button_set_active ((GtkToggleButton *) octbutton,
(gboolean) FALSE);
}
}
if (drawmode == 1)
{
switch (text_direct)
{
case 0:
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
(gboolean) FALSE);
break;
case -1:
gtk_toggle_button_set_active ((GtkToggleButton *) ctextbutton,
(gboolean) FALSE);
break;
case -2:
gtk_toggle_button_set_active ((GtkToggleButton *) rtextbutton,
(gboolean) FALSE);
}
}
drawmode = 7;
gdk_window_set_cursor (drawing_area->window, cursor_rescale);
}
void
Splinemode (GtkWidget * mainw)
/* Callback function to set 'rescale marked fragment' mode - checks and
updates radio button state of the toolbar */
{
if (drawmode == 3)
{
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton,
(gboolean) FALSE);
}
if (drawmode == 4)
{
gtk_toggle_button_set_active ((GtkToggleButton *) markbutton,
(gboolean) FALSE);
}
if (drawmode == 2)
{
gtk_toggle_button_set_active ((GtkToggleButton *) bondbutton,
(gboolean) FALSE);
}
if (drawmode == 6)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
(gboolean) FALSE);
}
if (drawmode == 0)
{
switch (draw_angle)
{
case 1:
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton,
(gboolean) FALSE);
break;
case 2:
gtk_toggle_button_set_active ((GtkToggleButton *) pent1button,
(gboolean) FALSE);
break;
case 3:
gtk_toggle_button_set_active ((GtkToggleButton *) pent2button,
(gboolean) FALSE);
break;
case 4:
gtk_toggle_button_set_active ((GtkToggleButton *) octbutton,
(gboolean) FALSE);
}
}
if (drawmode == 1)
{
switch (text_direct)
{
case 0:
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
(gboolean) FALSE);
break;
case -1:
gtk_toggle_button_set_active ((GtkToggleButton *) ctextbutton,
(gboolean) FALSE);
break;
case -2:
gtk_toggle_button_set_active ((GtkToggleButton *) rtextbutton,
(gboolean) FALSE);
}
}
drawmode = 8;
gdk_window_set_cursor (drawing_area->window, cursor_pencil);
}
void
Change_Angle (GtkWidget * mainw, gpointer newangle)
/* Callback function to set 'line drawing' mode and appropriate grid
definition - checks and updates radio button state of the toolbar */
{
gboolean activate = (gboolean) FALSE;
if (importflag != 0)
return;
if (drawmode == 3)
{
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton, activate);
}
if (drawmode == 4)
{
gtk_toggle_button_set_active ((GtkToggleButton *) markbutton, activate);
}
if (drawmode == 6)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
activate);
}
if (drawmode == 7)
{
gtk_toggle_button_set_active ((GtkToggleButton *) rescalebutton,
activate);
}
if (drawmode == 8)
{
gtk_toggle_button_set_active ((GtkToggleButton *) splinebutton,
activate);
}
if (drawmode == 2)
{
gtk_toggle_button_set_active ((GtkToggleButton *) bondbutton, activate);
}
if (drawmode == 1)
{
gtk_toggle_button_set_active ((GtkToggleButton *) ltextbutton,
activate);
gtk_toggle_button_set_active ((GtkToggleButton *) ctextbutton,
activate);
gtk_toggle_button_set_active ((GtkToggleButton *) rtextbutton,
activate);
}
drawmode = 0;
gdk_window_set_cursor (drawing_area->window, cursor_pencil);
switch (draw_angle)
{
case 1:
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton, activate);
break;
case 2:
gtk_toggle_button_set_active ((GtkToggleButton *) pent1button,
activate);
break;
case 3:
gtk_toggle_button_set_active ((GtkToggleButton *) pent2button,
activate);
break;
case 4:
gtk_toggle_button_set_active ((GtkToggleButton *) octbutton, activate);
}
draw_angle = atoi (newangle);
}
void
CheckAndLoad ()
/* Callback function for 'Load' button - pops up an 'are you sure' dialog
if unsaved changes exist, else calls real load function directly */
{
if (modify == 0 || hp->n + hp->nc + hp->nsp == 0)
{
Load ();
}
else
{
yesnodialog (Load);
}
}
void
Load ()
/* called for loading drawings from file - sets i/o mode to loading and
pops up the file selection widget, making it modal */
{
loadsave = 1;
gtk_window_set_title (GTK_WINDOW (filew), _("Load from file..."));
savedpicture = gdk_pixmap_ref(picture);
if (preview){
gdk_pixmap_unref (preview);
preview=NULL;
}
preview = gdk_pixmap_new (filew->window, 200, 100, -1);
gdk_draw_rectangle (preview,
filew->style->white_gc,
(gint) TRUE, 0, 0, (gint) 200, (gint) 100);
picture = gdk_pixmap_ref(preview);
gtk_widget_show (preview_area);
gtk_widget_hide (pdbhbox);
gtk_widget_hide (sdfhbox);
if (babelin>-1) gtk_widget_hide (babelcmdmenu);
if (babelout>-1) gtk_widget_hide (babelexpmenu);
#ifndef GTK2
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (defaultdir)));
if (datamask && (int)strlen (datamask))
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, datamask));
else
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, "*"));
#endif
gtk_widget_show (filew);
gtk_window_set_modal (GTK_WINDOW (filew), (gboolean) TRUE);
}
void
Import ()
/* called for loading ISIS drawings from file - sets i/o mode to loading and
pops up the file selection widget, making it modal */
{
#ifdef GTK24
GtkFileFilter *mdlfilter;
#endif
loadsave = 4;
savedpicture = gdk_pixmap_ref(picture);
gtk_window_set_title (GTK_WINDOW (filew), _("Import MDL file..."));
if (preview) {
gdk_pixmap_unref (preview);
preview=NULL;
}
preview = gdk_pixmap_new (filew->window, 200, 100, -1);
gdk_draw_rectangle (preview, filew->style->white_gc,
(gint)TRUE, 0, 0, (gint)200, (gint)100);
picture = gdk_pixmap_ref(preview);
gtk_widget_show (preview_area);
gtk_widget_hide (pdbhbox);
gtk_widget_show (sdfhbox);
if (babelin >-1) gtk_widget_hide (babelcmdmenu);
if (babelout>-1) gtk_widget_hide (babelexpmenu);
#ifndef GTK2
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (defaultdir)));
#endif
#ifdef GTK24
mdlfilter = gtk_file_filter_new();
gtk_file_filter_add_pattern(mdlfilter,"*.mol");
gtk_file_filter_add_pattern(mdlfilter,"*.mdl");
gtk_file_filter_add_pattern(mdlfilter,"*.MOL");
gtk_file_filter_add_pattern(mdlfilter,"*.MDL");
gtk_file_filter_add_pattern(mdlfilter,"*.sdf");
gtk_file_filter_add_pattern(mdlfilter,"*.SDF");
#else
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, "*.mol,*.mdl,*.sdf"));
#endif
gtk_widget_show (filew);
gtk_window_set_modal (GTK_WINDOW (filew), (gboolean) TRUE);
}
void
Import_Babel ()
/* called for BABEL-based import of foreign files - sets i/o mode
and pops up the file selection widget, making it modal */
{
loadsave = 6;
savedpicture = gdk_pixmap_ref(picture);
gtk_window_set_title (GTK_WINDOW (filew), _("Import via BABEL..."));
gtk_widget_hide (preview_area);
gtk_widget_hide (pdbhbox);
gtk_widget_hide (sdfhbox);
gtk_widget_hide (babelexpmenu);
gtk_widget_show (babelcmdmenu);
#ifndef GTK2
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (defaultdir)));
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, "*"));
#endif
gtk_widget_show (filew);
gtk_window_set_modal (GTK_WINDOW (filew), (gboolean) TRUE);
}
void
Export_Babel ()
/* called for BABEL-based export of foreign files - sets i/o mode
and pops up the file selection widget, making it modal */
{
loadsave = 7;
savedpicture = gdk_pixmap_ref(picture);
gtk_window_set_title (GTK_WINDOW (filew), _("Export via BABEL..."));
gtk_widget_hide (preview_area);
gtk_widget_hide (pdbhbox);
gtk_widget_hide (sdfhbox);
gtk_widget_hide (babelcmdmenu);
gtk_widget_show (babelexpmenu);
#ifndef GTK2
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (defaultdir)));
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, "*"));
#endif
gtk_widget_show (filew);
gtk_window_set_modal (GTK_WINDOW (filew), (gboolean) TRUE);
}
void
Import_PDB ()
/* called for loading drawings from file - sets i/o mode to loading and
pops up the file selection widget, making it modal */
{
loadsave = 5;
savedpicture = gdk_pixmap_ref(picture);
gtk_window_set_title (GTK_WINDOW (filew), _("Import PDB file..."));
gtk_widget_hide (preview_area);
if (babelin >-1) gtk_widget_hide (babelcmdmenu);
if (babelout>-1) gtk_widget_hide (babelexpmenu);
gtk_widget_show (pdbhbox);
gtk_widget_hide (sdfhbox);
#ifndef GTK2
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (defaultdir)));
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, "*.pdb,*.ent"));
#endif
gtk_widget_show (filew);
gtk_window_set_modal (GTK_WINDOW (filew), (gboolean) TRUE);
}
void
Add ()
/* called for inserting drawings at the currently marked position - sets
i/o mode to adding and pops up the (modal) file selection dialog */
{
if (addflag == 0)
{
refx = hp->tx;
refy = hp->ty;
}
loadsave = 3;
if(picture != NULL)savedpicture = gdk_pixmap_ref(picture);
if (preview != NULL)picture = gdk_pixmap_ref(preview);
if (picture) {
gdk_pixmap_unref (picture);
picture=NULL;
}
picture = gdk_pixmap_new (filew->window, 200, 100, -1);
gdk_draw_rectangle (picture,
filew->style->white_gc,
(gint) TRUE, 0, 0, (gint) 200, (gint) 100);
gtk_widget_show (preview_area);
gtk_widget_hide (pdbhbox);
gtk_widget_hide (sdfhbox);
if (babelin >-1) gtk_widget_hide (babelcmdmenu);
if (babelout>-1) gtk_widget_hide (babelexpmenu);
gtk_window_set_title (GTK_WINDOW (filew), _("Add from file..."));
#ifndef GTK2
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (defaultdir)));
if (datamask && (int)strlen (datamask))
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, datamask));
else
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, "*"));
#endif
gtk_widget_show (filew);
gtk_window_set_modal (GTK_WINDOW (filew), (gboolean) TRUE);
}
void
show_or_raise (GtkWidget * thewidget)
{
if (!GTK_WIDGET_MAPPED (thewidget))
gtk_widget_show (thewidget);
else
gdk_window_raise (thewidget->window);
}
void
Add_template (GtkWidget * mainw, gpointer template)
{
int i, j, n;
int xdiff, ydiff;
int x, y, tx, ty, b;
int x1, y1, x2, y2;
if (addflag == 0)
{
refx = hp->tx;
refy = hp->ty;
}
Unmark_all();
xdiff = 0;
ydiff = 0;
xref = 0;
yref = 0;
i = GPOINTER_TO_INT(template) / 10;
j = GPOINTER_TO_INT(template) - i * 10;
if (template_refx[i][j] != 0 && template_refy[i][j]!=0)
{
xdiff = refx - template_refx[i][j];
ydiff = refy - template_refy[i][j];
}
for (n = 0; n < template_nb[i][j]; n++)
{
x = template_x[i][j][n];
y = template_y[i][j][n];
tx = template_tx[i][j][n];
ty = template_ty[i][j][n];
b = template_b[i][j][n];
x = x + xdiff;
y = y + ydiff;
tx = tx + xdiff;
ty = ty + ydiff;
if (GPOINTER_TO_INT(template) <175) /* templates beyond the 4th page are decoration */
add_struct (x, y, tx, ty, b, 1, 1, 0,curpen);
else
add_struct (x, y, tx, ty, b, 1, 1, 1,curpen);
}
for (n = 0; n < template_nl[i][j]; n++)
{
x = template_lx[i][j][n] + xdiff;
y = template_ly[i][j][n] + ydiff;
add_char (x, y, template_lt[i][j][n], template_lo[i][j][n], 1,curpen,0,curfontsize);
}
for (n = 0; n < template_ncrv[i][j]; n++)
{
x = template_crv[i][j][n][0] + xdiff;
y = template_crv[i][j][n][1] + ydiff;
x1 = template_crv[i][j][n][2] + xdiff;
y1 = template_crv[i][j][n][3] + ydiff;
x2 = template_crv[i][j][n][4] + xdiff;
y2 = template_crv[i][j][n][5] + ydiff;
tx = template_crv[i][j][n][6] + xdiff;
ty = template_crv[i][j][n][7] + ydiff;
b = template_crv[i][j][n][8];
add_spline (x, y, x1, y1, x2, y2, tx, ty, b, 1,curpen);
}
#ifdef LIBUNDO
undo_snapshot ();
#endif
mark.flag = 1;
mark.x = refx;
mark.y = refy;
mark.w = 200;
mark.h = 200;
Movemode (mainw);
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton,
(gboolean) TRUE);
CreatePix ();
Display_Mol ();
}
void
SaveAs ()
/* Callback for saving a drawing to file - sets i/o mode to saving and pops
up the (modal) file selection dialog with the current filename as the default */
{
if (hp->n + hp->nc + hp->nsp == 0)
return;
loadsave = 2;
savedpicture = gdk_pixmap_ref(picture);
if (filename != NULL)
gtk_file_selection_set_filename (GTK_FILE_SELECTION (filew), filename);
gtk_window_set_title (GTK_WINDOW (filew), _("Save as..."));
gtk_widget_hide (preview_area);
gtk_widget_hide (pdbhbox);
gtk_widget_hide (sdfhbox);
if (babelin >-1) gtk_widget_hide (babelcmdmenu);
if (babelout>-1) gtk_widget_hide (babelexpmenu);
gtk_widget_show (filew);
gtk_window_set_modal (GTK_WINDOW (filew), (gboolean) TRUE);
}
void
Save ()
/* Callback for saving drawing to file - uses current filename */
{
int error;
char errtext[255];
if (hp->n + hp->nc + hp->nsp == 0)
{
snprintf(errtext,255,_("\nNothing to save") );
#ifdef GTK2
gtk_text_buffer_insert(msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value(msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext,
(gint) strlen (errtext));
#endif
return;
}
if (strcmp (filename, _("unnamed")) != 0)
{
{
FILE *fp;
if ((fp = fopen (filename, "w")) == NULL)
error = 1;
else
{
error = save_mol (fp, 0);
if (!error)
fclose (fp);
}
}
if (error != 0)
{
snprintf (errtext,255, _("\nWriting to %s failed !"), filename);
}
else
{
snprintf (errtext,255,
_("\nDrawing saved in %s (%d bonds, %d labels)"),
filename, hp->n, hp->nc);
modify = 0;
}
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value (msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext, (gint) strlen (errtext));
#endif
}
else
SaveAs ();
return;
}
void
Export ()
/* Callback for exporting a drawing to file - pops
up the (modal) file selection dialog with the current filename as the default */
{
char expn[512];
char *exten[9] = { ".fig", ".tex", ".eps", ".xbm", ".svg", ".mol",".emf",".sxd",".png"};
int i, n;
if (hp->n + hp->nc + hp->nsp == 0)
return;
strcpy (expn, filename);
n = (int) strlen (expn);
for (i = 0; i < (int) strlen (expn); i++)
{
if (expn[i] == '.')
n = i;
if (expn[i] == '/')
n = (int) strlen (expn);
}
expn[n] = '\0';
strcat (expn, exten[expmode]);
gtk_file_selection_set_filename (GTK_FILE_SELECTION (expw), expn);
gtk_widget_show (expw);
gtk_window_set_modal (GTK_WINDOW (filew), (gboolean) TRUE);
}
void
do_export (GtkWidget * mainw, GtkFileSelection * exp)
/* initiates export of current drawing to the foreign format selected via
the export popup - pops down export dialog, calls appropriate function
and displays messagebox with file statistics or error message afterwards */
{
struct stat stbuf;
gtk_widget_hide (expw);
if (hp->n + hp->nc + hp->nsp == 0)
return;
strcpy (expname,
gtk_file_selection_get_filename (GTK_FILE_SELECTION (exp)));
if (stat (expname, &stbuf) == 0)
yesnodialog2 (really_export, expname);
else
really_export ();
}
void
really_export ()
{
size_t msglen = 255;
float expscale;
int error = 0;
char errtext[255];
FILE *fp;
expscale =
gtk_spin_button_get_value_as_int ((GtkSpinButton *) scale) / 100.;
switch (expmode)
{
case 0:
error = export_xfig (expname);
break;
case 1:
error = export_latex_pic (expname, expscale);
break;
case 2:
error = export_ps_pic (expname, expscale);
break;
case 3:
/* xbm output is slow - set 'busy' watch-shaped cursor */
/* gdk_window_set_cursor (drawing_area->window, cursor_busy);*/
/* while (g_main_iteration (FALSE));*/
/* allow gtk to redraw after the popup,
which may have obscured parts of our molecule */
if (mark.flag == 1)
{
xbmflag = 1;
FreePix ();
CreatePix ();
Display_Mol ();
}
error = export_bitmap (expname);
if (mark.flag == 1)
{
xbmflag = 0;
FreePix ();
CreatePix ();
Display_Mol ();
}
/* gdk_window_set_cursor (drawing_area->window, previous_cursor);*/
break;
case 4:
error = export_svg (expname);
break;
case 5:
if (!(fp = fopen (expname,"w"))) {
error = 1;
break;
}
error = export_mdl_mol (fp,0);
break;
case 6:
#ifdef EMF
error = export_emf (expname);
#else
if (figversion >= 3) error = export_emf (expname);
#endif
break;
case 7:
error = export_sxd (expname);
break;
case 8:
error = export_png_pic (expname, expscale);
}
if (error != 0)
{
snprintf (errtext, msglen, _("Writing to\n %s\nfailed !\n"), expname);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
}
else
{
snprintf (errtext, msglen,
_("\nDrawing exported as %s (%d bonds, %d labels)"),
expname, hp->n, hp->nc);
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value (msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext,
(gint) strlen (errtext));
#endif
}
}
void
exp_mode (GtkWidget * mainw, gpointer mode)
/* callback function to set export format selected in the export dialog */
{
char expn[255];
char *exten[9] = { ".fig", ".tex", ".eps", ".xbm", ".svg", ".mol", ".emf", ".sxd", ".png" };
int i, n;
strcpy (expn, gtk_file_selection_get_filename (GTK_FILE_SELECTION (expw)));
n = (int) strlen (expn);
for (i = 0; i < (int) strlen (expn); i++)
{
if (expn[i] == '.')
n = i;
if (expn[i] == '/')
n = (int) strlen (expn);
}
expn[n] = '\0';
expmode = atoi (mode);
if (expmode < 0 || expmode > 8)
expmode = 0;
strcat (expn, exten[expmode]);
gtk_file_selection_set_filename (GTK_FILE_SELECTION (expw), expn);
}
void
pdb_mode (GtkWidget * mainw, gpointer mode)
/* callback function to set pdb label handling */
{
pdbmode = atoi (mode);
if (pdbmode < 0 || pdbmode > 4)
pdbmode = 0;
}
void
sdf_mode (GtkWidget * mainw, gpointer mode)
/* callback function to set current sdf index and update preview */
{
char myfile[255];
char labeltext[40];
switch ( atoi (mode)) {
case 0:
default:
sdfindex=0;
break;
case 1:
sdfindex--;
if (sdfindex <0 ) sdfindex = 0;
break;
case 2:
sdfindex++;
break;
}
if (picture) {
gdk_pixmap_unref (picture);
picture = NULL;
}
picture = gdk_pixmap_new (filew->window, 200, 100, -1);
gdk_draw_rectangle (picture, filew->style->white_gc,
(gint)TRUE, 0, 0, (gint)200, (gint)100);
strcpy (myfile,
gtk_file_selection_get_filename (GTK_FILE_SELECTION(filew)));
preview_mdl_mol (myfile, sdfindex);
snprintf (labeltext,39,_("SDF entry: %d"),sdfindex+1);
gtk_label_set_text(GTK_LABEL(sdflabel),labeltext);
}
int
CheckAndQuit ()
/* Callback function for the Quit button - pops up an 'are you sure' dialog
if unsaved changes exist, or calls the real quit function directly */
{
if (modify == 0 || hp->n + hp->nc + hp->nsp == 0)
{
Quit ();
return ((int) FALSE);
}
else
{
yesnodialog (Quit);
return ((int) TRUE);
}
}
void
Quit ()
/* close down gtk function processing and terminate program */
{
gtk_main_quit ();
}
void
file_ok_sel (GtkWidget * mainw, GtkFileSelection * fs)
/* callback function for the Ok button of the file selection dialog - pops
down the file dialog, gets the name of the selected file, initiates load
or save operations as defined by the current i/o mode and displays error
message dialog if necessary */
{
int error;
char errtext[255];
char oldname[512];
char *tempstr;
struct stat stbuf;
gtk_widget_hide (filew);
gtk_grab_remove (filew);
picture = gdk_pixmap_ref(savedpicture);
strcpy (oldname, filename);
strcpy (filename,
gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
if (datadir == NULL || (int)strlen (datadir) == 0)
{
tempstr = strrchr (filename, '/');
strncpy (datadir, filename, strlen (filename) - strlen (tempstr) + 1);
#ifdef GTK24
gtk_entry_set_text (GTK_ENTRY (datadir_entry), datadir);
#else
gtk_entry_set_text (GTK_ENTRY (defaultdir), datadir);
#endif
}
switch (loadsave)
{
case 1:
error = load_mol (filename);
switch (error)
{
case 0:
modify = 0;
mark.flag = 0;
snprintf (errtext,255, "Chemtool 1.6.10 (%s)", filename);
gtk_window_set_title (GTK_WINDOW (window), errtext);
#ifdef LIBUNDO
undo_snapshot ();
#endif
break;
case 1:
snprintf (errtext,255, _("Unable to open %s\n"), filename);
strcpy (filename, oldname);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
break;
case 2:
snprintf (errtext,255, _("%s\n does not appear to be a Chemtool file\n"),
filename);
strcpy (filename, oldname);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
break;
case 3:
modify = 0;
snprintf (errtext,255,
_("%s was created by a newer version.\nSome features may be lost.\n"),
filename);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
snprintf (errtext,255, "Chemtool 1.6.10 (%s)", filename);
gtk_window_set_title (GTK_WINDOW (window), errtext);
#ifdef LIBUNDO
undo_snapshot ();
#endif
break;
default:
clear_data ();
snprintf (errtext,255, _("Error loading %s \n"), filename);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
}
CreatePix ();
Display_Mol ();
break;
case 2:
if (stat (filename, &stbuf) == 0)
yesnodialog2 (reallysave, filename);
else
reallysave ();
break;
case 3:
error = add_mol (filename);
strcpy (filename, oldname);
Movemode (mainw);
gtk_toggle_button_set_active ((GtkToggleButton *) movebutton,
(gboolean) TRUE);
CreatePix ();
Display_Mol ();
break;
case 4:
error = import_mdl_mol (filename,sdfindex);
switch (error)
{
case 0:
modify = 0;
if (strrchr (filename, '.')
&& strrchr (filename, '.') > strrchr (filename, '/'))
filename[(int) (strrchr (filename, '.') - filename)] = '\0';
snprintf (errtext,255, "Chemtool 1.6.10 (%s)", filename);
gtk_window_set_title (GTK_WINDOW (window), errtext);
#ifdef LIBUNDO
undo_snapshot ();
#endif
snprintf (errtext,255,
_("\nChoose orientation (Ctrl-Mouse1 for z), press Enter when done"));
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value(msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext,
(gint)strlen (errtext));
#endif
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
TRUE);
break;
case 1:
snprintf (errtext,255, _("Unable to open %s\n"), filename);
strcpy (filename, oldname);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
break;
case 2:
snprintf (errtext,255, _("Problems converting %s\n"), filename);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
break;
}
break;
case 5:
error = import_pdb (filename);
switch (error)
{
case 0:
modify = 0;
if (strrchr (filename, '.')
&& strrchr (filename, '.') > strrchr (filename, '/'))
filename[(int) (strrchr (filename, '.') - filename)] = '\0';
snprintf (errtext, 255, "Chemtool 1.6.10 (%s)", filename);
gtk_window_set_title (GTK_WINDOW (window), errtext);
#ifdef LIBUNDO
undo_snapshot ();
#endif
snprintf (errtext,255,
_("\nChoose orientation (Ctrl-Mouse1 for z), press Enter when done"));
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value(msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext,
(gint)strlen (errtext));
#endif
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
TRUE);
break;
case 1:
snprintf (errtext,255, _("Unable to open %s\n"), filename);
strcpy (filename, oldname);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
break;
}
break;
case 6:
error = import_babel (filename);
switch (error)
{
case 0:
modify = 0;
if (strrchr (filename, '.')
&& strrchr (filename, '.') > strrchr (filename, '/'))
filename[(int) (strrchr (filename, '.') - filename)] = '\0';
snprintf (errtext,255, "Chemtool 1.6.10 (%s)", filename);
gtk_window_set_title (GTK_WINDOW (window), errtext);
#ifdef LIBUNDO
undo_snapshot ();
#endif
snprintf (errtext,255,
_
("\nChoose orientation (Ctrl-Mouse1 for z), press Enter when done"));
#ifdef GTK2
gtk_text_buffer_insert (msgtextbuffer, &iter, errtext, -1);
gtk_adjustment_set_value(msgadjustment, gtk_adjustment_get_value(msgadjustment)+12.);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, errtext,
(gint)strlen (errtext));
#endif
gtk_toggle_button_set_active ((GtkToggleButton *) rotatebutton,
TRUE);
break;
case 1:
snprintf (errtext,255, _("Unable to open %s\n"), filename);
strcpy (filename, oldname);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
break;
case 2:
snprintf (errtext,255, _("Problems converting %s\n"), filename);
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
break;
}
break;
case 7:
error = export_babel(filename);
default:
break;
}
}
void
reallysave ()
{
int error;
char errtext[255];
FILE *fp;
if ((fp = fopen (filename, "w")) == NULL)
error = 1;
else
{
error = save_mol (fp, 0);
if (!error)
fclose (fp);
}
if (error != 0)
{
snprintf (errtext,255, _("Writing to\n %s\nfailed !\n"), filename);
}
else
{
snprintf (errtext,255,
_("Drawing saved in\n %s\n (%d bonds, %d labels)\n"),
filename, hp->n, hp->nc);
modify = 0;
}
gtk_label_set_text (GTK_LABEL (message), errtext);
gtk_widget_show (messagew);
gtk_grab_add (messagew);
snprintf (errtext,255, "Chemtool 1.6.10 (%s)", filename);
gtk_window_set_title (GTK_WINDOW (window), errtext);
}
int
main (int argc, char **argv)
/* Main program - initializes widgets and data structures */
{
int i, j;
int tmplnum[125];
char bondnums[BONDTYPES][3];
char msgtmp[100];
const char *fontsizelabel[7]={"8","10","12","14","17","20","24"};
GtkWidget *aboutw,*helpw,*helptext;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *expbutton[9];
GtkWidget *tbutton[125];
#ifdef MENU
GtkAccelGroup *accel_group;
GtkWidget *menu_bar;
GtkWidget *file, *file_menu;
GtkWidget *new, *open, *add, *import, *imppdb, *impany,*export, *expany,
*printps, *save, *saveas, *quit;
GtkWidget *edit, *edit_menu;
GtkWidget *print_setup, *save_setup;
GtkWidget *copy, *fliph, *flipv;
#ifdef LIBUNDO
GtkWidget *undo, *redo;
#endif
GtkWidget *view, *view_menu;
GtkWidget *zoomin, *zoomout, *center,*grid;
GtkWidget *tools, *tools_menu;
GtkWidget *templatem, *cht, *clean;
GtkWidget *help, *help_menu;
GtkWidget *about,*using;
#else
GtkWidget *loadbutton, *savebutton, *importbutton, *imppdbbutton,
*exportbutton, *printbutton, *zoominbutton;
GtkWidget *psetupbutton, *savesetupbutton;
GtkWidget *centerbutton, *zoomoutbutton, *clearbutton, *fwbutton,
*quitbutton, *aboutbutton;
#endif
GtkWidget *label;
GdkPixmap *pixmap;
GtkWidget *pixmapwid;
GtkAdjustment *adj_scale;
GSList *group;
GtkStyle *style;
GtkTooltips *tooltips, *temptips;
GtkWidget *templatebook, *page, *tvbox, *pbox;
GtkWidget *vscroll,*textscroll;
#ifndef GTK24
GtkAdjustment *adj_pscale;
GtkWidget *printer_dialog, *papersizeitem[11], *orientationitem,
*printcmditem;
GtkWidget *epsoptitem;
GtkWidget *pokbutton, *pcabutton;
#endif
GtkWidget *fontsizeitem[7];
GtkWidget *babelcmditem,*babelexpcmditem;
GdkColor black={0,0x0000,0x0000,0x0000},blue={0,0x0000,0x0000,0xe000},
green={0,0x0000,0xd000,0x0000},cyan={0,0,0xffff,0xffff},
red={0,0xffff,0x0000,0x0000},magenta={0,0xffff,0x0000,0xffff},
yellow={0,0xffff,0xffff,0x0000};
#ifdef GTK2
GtkTextBuffer *helptextbuffer;
GtkTextIter ht_iter;
#endif
char *helpmessage = _("Click and drag the mouse to draw bonds on the canvas. \n"
"The right mouse button is used to delete objects - either bonds\n"
"or text depending on which drawing mode is active.\n\n"
"The buttons with different ringtypes on them select drawing modes\n"
"with preferred angles, but you can actually draw at any angle in all modes.\n\n"
"The button with the segmented line on it lets you draw curves by marking\n"
"control points along the curve (a cubic spline).\n"
"You can select the bondtype and color using the appropriate button\n"
"or change them later by clicking on the desired bond in Bonds mode.\n\n"
"To draw a cyclic system, simply press the Ctrl key together with the\n"
"number key corresponding to the number of sides for the polygon, and\n"
"then draw one side while pressing the Ctrl button.\n\n"
"For drawing labels, write them into the text box in the top right of the window\n"
"and place them on the canvas with the mouse. You can also use a number of\n"
"keyboard shortcuts for common labels while in bond drawing mode:\n"
"Simply press the 'c' key, or n,o,p,s,f to add the element symbol at\n"
" the current drawing position, 1,2 and 3 for CH, CH_2 and CH_3, l for Cl,\n"
" * for a big dot.\n\n"
"The keys of the numeric keypad each insert an 'electron pair' line\n"
"around an atom symbol in the position corresponding to the location\n"
"of the key around the center of the numeric keypad.\n\n"
"The text mode uses the following prefixes for special text:\n"
"_ for subscripts, ^ for superscripts, @ for symbols (greek characters),\n"
"| for italic (slanted) characters and # for bold text.\n"
"When the text box is empty, clicking on any label in the drawing area\n"
"copies that label into the box for reuse.\n\n"
"Drawing is best done with the mouse, but you can also use the\n"
"cursor keys in combination with the Ctrl key for exact positioning.\n"
"When used with the Alt key, the cursor keys move the rectangular\n"
"or rhombic grid that can be projected on the drawing area.\n\n"
"If you need general drawing functions not provided by chemtool,\n"
"try exporting to fig format and editing your figure in Brian Smith's\n"
"xfig program. Its companion transfig/fig2dev is required by chemtool\n"
"for printing and for exporting to eps or LaTeX, while the fig, XBM and\n"
"SVG output are generated directly. Another useful and highly recommended\n"
"helper program is Babel - either in its original version, or in the form\n"
"of the new OpenBabel project. Using either version, chemtool is able to\n"
"import foreign data from a variety of file formats, while only molfile\n"
"im- and export is built into chemtool.\n\n"
"More help is available in the manual page for chemtool and in the file\n"
" README included in the source distribution as well as on the website.\n"
"This should normally get installed in /usr/share/doc/packages/chemtool.\n"
"If you find any bugs or have a question or suggestion, please contact the\n"
"main author, martin@ruby.chemie.uni-freiburg.de");
#ifndef DISABLE_NLS
(void) gtk_set_locale (); /* newer glibc requires this */
/* but we have to guard against locales that use a comma in numbers */
(void) setlocale (LC_NUMERIC, "C");
/*@ignore@*/
(void) bindtextdomain ("chemtool", LOCALEDIR);
/*@end@*/
#ifdef GTK2
bind_textdomain_codeset ("chemtool", "UTF-8");
(void) setlocale (LC_NUMERIC, "C");
#endif
(void) textdomain ("chemtool");
#endif
gtk_init (&argc, &argv); /*initialize GTK environment */
#ifdef LIBUNDO
undo_new ("chemtool");
undo_set_memory_limit (65536);
#endif
setup_data (); /*initialize chemtool structs */
#ifdef LIBUNDO
undo_snapshot ();
#endif
/*
* Create the 'About' pop-up
*/
aboutw = gtk_dialog_new ();
label =
gtk_label_new (_
(" Chemtool Version 1.6.10\nby\nMartin Kroeker,\nRadek Liboska,\nMichael Banck\nand\nThomas Volk\n\nhttp://ruby.chemie.uni-freiburg.de/~martin/chemtool/chemtool.html"));
#ifdef GTK2
gtk_label_set_justify(GTK_LABEL(label),GTK_JUSTIFY_CENTER);
#endif
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (aboutw)->vbox), label,
(gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label ("Ok");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (aboutw)->action_area), button,
(gboolean) TRUE, (gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (aboutw));
(void)gtk_signal_connect_object (GTK_OBJECT (aboutw), "delete_event",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (aboutw));
gtk_widget_show (button);
helpw = gtk_dialog_new();
gtk_widget_set_usize(helpw,480,500);
textscroll=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(textscroll),
GTK_POLICY_NEVER,GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (helpw)->vbox), textscroll,
(gboolean) TRUE, (gboolean) TRUE, 0);
#ifdef GTK2
helptext = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(helptext), FALSE);
helptextbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(helptext));
gtk_text_buffer_get_iter_at_offset (helptextbuffer, &ht_iter, 0);
#ifdef DISABLE_NLS
gtk_text_buffer_insert (helptextbuffer, &ht_iter, helpmessage,-1);
#else
gtk_text_buffer_insert (helptextbuffer, &ht_iter, gettext(helpmessage),-1);
#endif
#else
helptext = gtk_text_new(NULL,NULL);
gtk_text_set_editable(GTK_TEXT(helptext), FALSE);
gtk_text_freeze(GTK_TEXT(helptext));
#ifdef DISABLE_NLS
gtk_text_insert(GTK_TEXT(helptext),NULL,NULL,NULL,helpmessage,(gint)strlen(helpmessage));
#else
gtk_text_insert(GTK_TEXT(helptext),NULL,NULL,NULL,gettext(helpmessage),(gint)strlen(gettext(helpmessage)));
#endif
#endif
gtk_widget_show(textscroll);
gtk_container_add(GTK_CONTAINER(textscroll),helptext);
button = gtk_button_new_with_label ("Ok");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (helpw)->action_area), button,
(gboolean) TRUE, (gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (helpw));
(void)gtk_signal_connect_object (GTK_OBJECT (helpw), "delete_event",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (helpw));
gtk_widget_show (button);
gtk_widget_show (helptext);
gtk_widget_realize(helpw);
/*
* Build the file selection pop-up
*/
filew = gtk_file_selection_new ("File selection");
(void)gtk_signal_connect (GTK_OBJECT (filew), "delete_event",
(GtkSignalFunc) gtk_grab_remove, GTK_OBJECT (filew));
(void)gtk_signal_connect (GTK_OBJECT (filew), "delete_event",
(GtkSignalFunc) gtk_widget_hide, GTK_OBJECT (filew));
(void)gtk_signal_connect (GTK_OBJECT (filew), "delete_event",
restore_picture, NULL);
(void)gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
"clicked", (GtkSignalFunc) file_ok_sel, filew);
(void)gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
(filew)->cancel_button),
"clicked", (GtkSignalFunc) gtk_grab_remove,
GTK_OBJECT (filew));
(void)gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
(filew)->cancel_button),
"clicked", restore_picture, NULL);
(void)gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
(filew)->cancel_button),
"clicked", (GtkSignalFunc) gtk_widget_hide,
GTK_OBJECT (filew));
#ifdef GTK2
(void)gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->file_list),
"cursor_changed", (GtkSignalFunc) getpreview,
(gpointer) filew);
#else
(void)gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->file_list),
"select_row", (GtkSignalFunc) getpreview,
(gpointer) filew);
#endif
preview_area = gtk_drawing_area_new ();
gtk_drawing_area_size (GTK_DRAWING_AREA (preview_area), 200, 100);
gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (filew)->action_area),
preview_area, (gboolean) TRUE, (gboolean) FALSE, 0);
gtk_widget_show (preview_area);
/* Signals used to handle backing pixmap */
(void)gtk_signal_connect (GTK_OBJECT (preview_area), "expose_event",
(GtkSignalFunc) expose_event, NULL);
(void)gtk_signal_connect (GTK_OBJECT (preview_area), "configure_event",
(GtkSignalFunc) configure_preview, NULL);
pdbhbox = gtk_hbox_new ((gboolean) FALSE, 0);
label = gtk_label_new (_("PDB labels:"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (pdbhbox), label, TRUE, TRUE, 0);
labbutton[0] = gtk_radio_button_new_with_label (NULL, _("All"));
gtk_box_pack_start (GTK_BOX (pdbhbox), labbutton[0], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (labbutton[0]), "clicked",
GTK_SIGNAL_FUNC (pdb_mode), "0");
gtk_widget_show (labbutton[0]);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (labbutton[0]));
labbutton[1] = gtk_radio_button_new_with_label (group, _("non-H"));
gtk_box_pack_start (GTK_BOX (pdbhbox), labbutton[1], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (labbutton[1]), "clicked",
GTK_SIGNAL_FUNC (pdb_mode), "1");
gtk_widget_show (labbutton[1]);
labbutton[2] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (labbutton[0])),
_("no numbers"));
gtk_box_pack_start (GTK_BOX (pdbhbox), labbutton[2], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (labbutton[2]), "clicked",
GTK_SIGNAL_FUNC (pdb_mode), "2");
gtk_widget_show (labbutton[2]);
labbutton[3] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (labbutton[0])),
_("non H,no numbers"));
(void)gtk_signal_connect (GTK_OBJECT (labbutton[3]), "clicked",
GTK_SIGNAL_FUNC (pdb_mode), "3");
gtk_box_pack_start (GTK_BOX (pdbhbox), labbutton[3], (gboolean) TRUE,
(gboolean) TRUE, 0);
gtk_widget_show (labbutton[3]);
labbutton[4] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (labbutton[0])),
_("None"));
gtk_box_pack_start (GTK_BOX (pdbhbox), labbutton[4], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (labbutton[4]), "clicked",
GTK_SIGNAL_FUNC (pdb_mode), "4");
gtk_widget_show (labbutton[4]);
gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (filew)->main_vbox),
pdbhbox, (gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (pdbhbox);
sdfhbox = gtk_hbox_new ((gboolean) FALSE, 0);
sdflabel = gtk_label_new (_("SDF entry:"));
gtk_widget_show (sdflabel);
gtk_box_pack_start (GTK_BOX (sdfhbox), sdflabel, TRUE, TRUE, 0);
sdfbutton[0] = gtk_button_new_with_label (_("First"));
gtk_box_pack_start (GTK_BOX (sdfhbox), sdfbutton[0], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (sdfbutton[0]), "clicked",
GTK_SIGNAL_FUNC (sdf_mode), "0");
gtk_widget_show (sdfbutton[0]);
sdfbutton[1] = gtk_button_new_with_label (_("Previous"));
gtk_box_pack_start (GTK_BOX (sdfhbox), sdfbutton[1], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (sdfbutton[1]), "clicked",
GTK_SIGNAL_FUNC (sdf_mode), "1");
gtk_widget_show (sdfbutton[1]);
sdfbutton[2] =
gtk_button_new_with_label (_("Next"));
gtk_box_pack_start (GTK_BOX (sdfhbox), sdfbutton[2], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (sdfbutton[2]), "clicked",
GTK_SIGNAL_FUNC (sdf_mode), "2");
gtk_widget_show (sdfbutton[2]);
gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (filew)->main_vbox),
sdfhbox, (gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (sdfhbox);
check_babel();
if (babelin>-1){
babelcmdmenu = gtk_option_menu_new ();
babelcmds = gtk_menu_new ();
for (i=0;i<=babelin;i++){
snprintf(msgtmp,100,"%s ( %s )",intype[i],inmode[i]);
babelcmditem = gtk_menu_item_new_with_label (msgtmp);
gtk_menu_append (GTK_MENU (babelcmds), babelcmditem);
gtk_widget_show (babelcmditem);
(void)gtk_signal_connect_object (GTK_OBJECT (babelcmditem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) babelcmditem);
(void)gtk_signal_connect (GTK_OBJECT (babelcmditem), "activate",
GTK_SIGNAL_FUNC (babelcmd), inmode[i]);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (babelcmdmenu), babelcmds);
gtk_widget_show (babelcmdmenu);
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->main_vbox),
babelcmdmenu, (gboolean)TRUE,(gboolean)TRUE,0);
}
if (babelout>-1){
babelexpmenu = gtk_option_menu_new ();
babelexpcmds = gtk_menu_new ();
for (i=0;i<=babelout;i++){
snprintf(msgtmp,100,"%s ( %s )",outtype[i],outmode[i]);
babelexpcmditem = gtk_menu_item_new_with_label (msgtmp);
gtk_menu_append (GTK_MENU (babelexpcmds), babelexpcmditem);
gtk_widget_show (babelexpcmditem);
(void)gtk_signal_connect_object (GTK_OBJECT (babelexpcmditem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) babelexpcmditem);
(void)gtk_signal_connect (GTK_OBJECT (babelexpcmditem), "activate",
GTK_SIGNAL_FUNC (babelcmd), outmode[i]);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (babelexpmenu), babelexpcmds);
gtk_widget_show (babelexpmenu);
gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->main_vbox),
babelexpmenu, (gboolean)TRUE,(gboolean)TRUE,0);
}
gtk_widget_realize (filew);
/*
* Build the export pop-up
*/
expw = gtk_file_selection_new ("Export");
(void)gtk_signal_connect (GTK_OBJECT (expw), "delete_event",
(GtkSignalFunc) gtk_grab_remove, GTK_OBJECT (expw));
(void)gtk_signal_connect (GTK_OBJECT (expw), "delete_event",
(GtkSignalFunc) gtk_widget_hide, GTK_OBJECT (expw));
(void)gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (expw)->ok_button),
"clicked", (GtkSignalFunc) do_export, expw);
(void)gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
(expw)->cancel_button),
"clicked", (GtkSignalFunc) gtk_grab_remove,
GTK_OBJECT (expw));
(void)gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
(expw)->cancel_button),
"clicked", (GtkSignalFunc) gtk_widget_hide,
GTK_OBJECT (expw));
hbox = gtk_hbox_new (FALSE, 0);
label = gtk_label_new (_("Latex / EPS scale factor :"));
gtk_box_pack_start (GTK_BOX (hbox), label, (gboolean) TRUE,
(gboolean) FALSE, 0);
gtk_widget_show (label);
adj_scale = (GtkAdjustment *) gtk_adjustment_new (100., 1., 200., 1., 10., 0.);
scale = gtk_spin_button_new (adj_scale, 0., 0);
gtk_box_pack_start (GTK_BOX (hbox), scale, (gboolean) FALSE,
(gboolean) FALSE, 0);
gtk_widget_show (scale);
label = gtk_label_new ("%");
gtk_box_pack_start (GTK_BOX (hbox), label, (gboolean) FALSE,
(gboolean) FALSE, 0);
gtk_widget_show (label);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, (gboolean) TRUE,
(gboolean) FALSE, 0);
gtk_widget_show (label);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (expw)->main_vbox), hbox,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new ((gboolean) FALSE, 0);
expbutton[0] = gtk_radio_button_new_with_label (NULL, "XFig");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[0], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (expbutton[0]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "0");
gtk_widget_show (expbutton[0]);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (expbutton[0]));
expbutton[1] = gtk_radio_button_new_with_label (group, "LaTeX");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[1], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (expbutton[1]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "1");
gtk_widget_show (expbutton[1]);
expbutton[2] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (expbutton[0])),
"EPS");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[2], (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (expbutton[2]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "2");
gtk_widget_show (expbutton[2]);
expbutton[3] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (expbutton[0])),
"X Bitmap");
(void)gtk_signal_connect (GTK_OBJECT (expbutton[3]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "3");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[3], (gboolean) TRUE,
(gboolean) TRUE, 0);
gtk_widget_show (expbutton[3]);
expbutton[4] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (expbutton[0])),
"SVG");
(void)gtk_signal_connect (GTK_OBJECT (expbutton[4]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "4");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[4], (gboolean) TRUE,
(gboolean) TRUE, 0);
gtk_widget_show (expbutton[4]);
expbutton[5] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (expbutton[0])),
"MOL");
(void)gtk_signal_connect (GTK_OBJECT (expbutton[5]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "5");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[5], (gboolean) TRUE,
(gboolean) TRUE, 0);
gtk_widget_show (expbutton[5]);
expbutton[6] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (expbutton[0])),
"EMF");
(void)gtk_signal_connect (GTK_OBJECT (expbutton[6]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "6");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[6], (gboolean) TRUE,
(gboolean) TRUE, 0);
#ifdef EMF
gtk_widget_show (expbutton[6]);
#endif
expbutton[7] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (expbutton[0])),
"SXD");
(void)gtk_signal_connect (GTK_OBJECT (expbutton[7]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "7");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[7], (gboolean) TRUE,
(gboolean) TRUE, 0);
expbutton[8] =
gtk_radio_button_new_with_label (gtk_radio_button_group
(GTK_RADIO_BUTTON (expbutton[0])),
"PNG");
(void)gtk_signal_connect (GTK_OBJECT (expbutton[8]), "clicked",
GTK_SIGNAL_FUNC (exp_mode), "8");
gtk_box_pack_start (GTK_BOX (hbox), expbutton[8], (gboolean) TRUE,
(gboolean) TRUE, 0);
gtk_widget_show (expbutton[8]);
gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (expw)->main_vbox), hbox,
(gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (hbox);
/********************************************************************/
/*
* Build the (error) message pop-up
*/
messagew = gtk_dialog_new ();
(void)gtk_signal_connect_object (GTK_OBJECT (messagew), "destroy",
(GtkSignalFunc) gtk_grab_remove,
GTK_OBJECT (messagew));
(void)gtk_signal_connect_object (GTK_OBJECT (messagew), "destroy",
(GtkSignalFunc) gtk_widget_hide,
GTK_OBJECT (messagew));
message = gtk_label_new (_("Unknown error"));
gtk_misc_set_padding (GTK_MISC (message), 10, 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (messagew)->vbox), message,
(gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (message);
button = gtk_button_new_with_label ("OK");
/* Connect the ok_button */
(void)gtk_signal_connect_object (GTK_OBJECT (button),
"clicked", (GtkSignalFunc) gtk_grab_remove,
GTK_OBJECT (messagew));
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_hide,
GTK_OBJECT (messagew));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (messagew)->action_area), button,
(gboolean) TRUE, (gboolean) TRUE, 0);
gtk_widget_show (button);
/********************************************************************/
/* Configurable options dialog */
#ifdef GTK24
printer_dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (printer_dialog), _("Configurable options"));
gtk_window_set_resizable (GTK_WINDOW (printer_dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (printer_dialog), 12);
master_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_add (GTK_CONTAINER (printer_dialog), master_vbox);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbox), 12);
gtk_box_pack_end (GTK_BOX (master_vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_container_add (GTK_CONTAINER (hbox), button);
/* Thanks to using ...swapped, the callback_data gets passed as
the first argument to the callback function, so when we click
on the button, we hide the dialog, not the button. */
g_signal_connect_swapped (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_widget_hide), G_OBJECT (printer_dialog));
button = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_container_add (GTK_CONTAINER (hbox), button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (options_dialog_ok), NULL);
notebook = gtk_notebook_new ();
gtk_box_pack_end (GTK_BOX (master_vbox), notebook, TRUE, TRUE, 0);
/* First page: General options */
table = gtk_table_new (10, 3, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("_General"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), table, label);
/* Adjust the table spacing before section headings etc. */
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12);
gtk_table_set_row_spacing (GTK_TABLE (table), 3, 12);
gtk_table_set_row_spacing (GTK_TABLE (table), 7, 12);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 18);
gtk_table_set_row_spacing (GTK_TABLE (table), 6, 18);
/* Spacer label for left indent */
label = gtk_label_new (NULL);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, 0, 0, 6, 0);
/* The section headings */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Display</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 3, 0, 1, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Saving and Exporting</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 3, 3, 4, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Other</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 3, 8, 9, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
/* First section, "Display" */
hbox = gtk_hbox_new (FALSE, 12);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 3, 1, 2, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("_Background color:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
color_button = gtk_color_button_new ();
gtk_box_pack_start (GTK_BOX (hbox), color_button, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), color_button);
whiteout_check = gtk_check_button_new_with_mnemonic (
_("Add filled _white rectangle under labels"));
gtk_table_attach (GTK_TABLE (table), whiteout_check, 1, 3, 2, 3,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
/* Second section, "Saving and exporting" */
datadir_entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), datadir_entry, 2, 3, 4, 5,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
datamask_entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), datamask_entry, 2, 3, 5, 6,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
eps_preview_combo = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (eps_preview_combo), _("None"));
gtk_combo_box_append_text (GTK_COMBO_BOX (eps_preview_combo), _("EPSI"));
gtk_combo_box_append_text (GTK_COMBO_BOX (eps_preview_combo), _("TIFF mono"));
gtk_combo_box_append_text (GTK_COMBO_BOX (eps_preview_combo), _("TIFF color"));
gtk_table_attach (GTK_TABLE (table), eps_preview_combo, 2, 3, 6, 7,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("_Data directory:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), datadir_entry);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 4, 5, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("E_xtension:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), datamask_entry);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 5, 6, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label),
_("Preview image to add to _EPS files:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), eps_preview_combo);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 6, 7, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
intl_check = gtk_check_button_new_with_mnemonic (
_("Support national character sets in labels"));
gtk_table_attach (GTK_TABLE (table), intl_check, 1, 3, 7, 8,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
/* Third section, "Other" */
bond_length_entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), bond_length_entry, 2, 3, 9, 10,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 2, 3, 10, 11, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
dbond_dist_spin = gtk_spin_button_new_with_range (1, 100, 1);
gtk_box_pack_start (GTK_BOX (hbox), dbond_dist_spin, FALSE, FALSE, 0);
label = gtk_label_new ("px");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("Base bond _length:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), bond_length_entry);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 9, 10, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label),
_("Double bond _separation:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), dbond_dist_spin);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 10, 11, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
/* Second page, printing */
table = gtk_table_new (5, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("_Printing"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), table, label);
/* Table spacings */
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
/* No sections are necessary on this page */
print_cmd_combo = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (print_cmd_combo), "lpr");
gtk_combo_box_append_text (GTK_COMBO_BOX (print_cmd_combo), "lp");
gtk_combo_box_append_text (GTK_COMBO_BOX (print_cmd_combo), "kprinter");
gtk_table_attach (GTK_TABLE (table), print_cmd_combo, 1, 2, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
printer_name_entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), printer_name_entry,
1, 2, 1, 2, GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
paper_size_combo = gtk_combo_box_new_text ();
for (i = 0; i < 11; i++)
{
gtk_combo_box_append_text (GTK_COMBO_BOX (paper_size_combo), paper[i]);
}
gtk_table_attach (GTK_TABLE (table), paper_size_combo, 1, 2, 2, 3,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
orientation_combo = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (orientation_combo), _("Portrait"));
gtk_combo_box_append_text (GTK_COMBO_BOX (orientation_combo), _("Landscape"));
gtk_table_attach (GTK_TABLE (table), orientation_combo, 1, 2, 3, 4,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 4, 5, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
print_scale_spin = gtk_spin_button_new_with_range (1, 200, 1);
gtk_box_pack_start (GTK_BOX (hbox), print_scale_spin, FALSE, FALSE, 0);
label = gtk_label_new ("%");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("Print _command:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), print_cmd_combo);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("Printer _name:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), printer_name_entry);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("Paper si_ze:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), paper_size_combo);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("_Orientation:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), orientation_combo);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
label = gtk_label_new (NULL);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("Print sc_ale factor:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), print_scale_spin);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_EXPAND|GTK_FILL,
GTK_FILL, 0, 0);
gtk_widget_show_all (GTK_WIDGET (master_vbox));
(void)gtk_signal_connect_object (GTK_OBJECT (printer_dialog), "delete_event",
(GtkSignalFunc) gtk_widget_hide,
GTK_OBJECT (printer_dialog));
#else
/* old-style configuration menu for gtk1 builds */
/* Color selection dialog */
colorseldialog= gtk_color_selection_dialog_new(_("Select background color"));
colorsel=GTK_COLOR_SELECTION_DIALOG(colorseldialog)->colorsel;
(void)gtk_signal_connect(GTK_OBJECT(colorsel), "color_changed",
(GtkSignalFunc)set_bgcolor,(gpointer)colorsel);
(void)gtk_signal_connect_object(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(colorseldialog)->ok_button), "clicked",
(GtkSignalFunc)gtk_widget_hide,GTK_OBJECT(colorseldialog));
(void)gtk_signal_connect_object(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(colorseldialog)->cancel_button), "clicked",
(GtkSignalFunc)gtk_widget_hide,GTK_OBJECT(colorseldialog));
gtk_widget_hide(GTK_COLOR_SELECTION_DIALOG(colorseldialog)->help_button);
gtk_widget_realize(colorseldialog);
/********************************************************************/
/* Printer setup dialog */
printer_dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (printer_dialog),
_("Configurable options"));
gtk_widget_realize (printer_dialog);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (printer_dialog), vbox);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Paper size:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
papermenu = gtk_option_menu_new ();
papersizes = gtk_menu_new ();
for (i = 0; i < 11; i++)
{
papersizeitem[i] = gtk_menu_item_new_with_label (paper[i]);
gtk_menu_append (GTK_MENU (papersizes), papersizeitem[i]);
gtk_widget_show (papersizeitem[i]);
(void)gtk_signal_connect_object (GTK_OBJECT (papersizeitem[i]), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) papersizeitem[i]);
(void)gtk_signal_connect (GTK_OBJECT (papersizeitem[i]), "activate",
GTK_SIGNAL_FUNC (newpaper), (gpointer) paper[i]);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (papermenu), papersizes);
gtk_widget_show (papermenu);
gtk_box_pack_start (GTK_BOX (hbox), papermenu,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Orientation:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
orientmenu = gtk_option_menu_new ();
orientations = gtk_menu_new ();
orientationitem = gtk_menu_item_new_with_label (_("Portrait"));
gtk_menu_append (GTK_MENU (orientations), orientationitem);
gtk_widget_show (orientationitem);
(void)gtk_signal_connect (GTK_OBJECT (orientationitem), "activate",
GTK_SIGNAL_FUNC (neworient), "0");
orientationitem = gtk_menu_item_new_with_label (_("Landscape"));
gtk_menu_append (GTK_MENU (orientations), orientationitem);
gtk_widget_show (orientationitem);
(void)gtk_signal_connect (GTK_OBJECT (orientationitem), "activate",
GTK_SIGNAL_FUNC (neworient), "1");
gtk_option_menu_set_menu (GTK_OPTION_MENU (orientmenu), orientations);
gtk_widget_show (orientmenu);
gtk_box_pack_start (GTK_BOX (hbox), orientmenu,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Print scale factor :"));
gtk_box_pack_start (GTK_BOX (hbox), label, (gboolean) FALSE,
(gboolean) FALSE, 0);
gtk_widget_show (label);
adj_pscale = (GtkAdjustment *) gtk_adjustment_new (70., 1., 200., 1., 10., 0.);
pscale = gtk_spin_button_new (adj_pscale, 0., 0);
gtk_box_pack_start (GTK_BOX (hbox), pscale, (gboolean) FALSE,
(gboolean) FALSE, 0);
gtk_widget_show (pscale);
label = gtk_label_new ("%");
gtk_box_pack_start (GTK_BOX (hbox), label, (gboolean) FALSE,
(gboolean) FALSE, 0);
gtk_widget_show (label);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, (gboolean) TRUE,
(gboolean) FALSE, 0);
gtk_widget_show (label);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Print command:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
printcmdmenu = gtk_option_menu_new ();
printcmds = gtk_menu_new ();
printcmditem = gtk_menu_item_new_with_label ("lpr");
gtk_menu_append (GTK_MENU (printcmds), printcmditem);
gtk_widget_show (printcmditem);
(void)gtk_signal_connect_object (GTK_OBJECT (printcmditem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) printcmditem);
(void)gtk_signal_connect (GTK_OBJECT (printcmditem), "activate",
GTK_SIGNAL_FUNC (newprcmd), "0");
printcmditem = gtk_menu_item_new_with_label ("lp");
gtk_menu_append (GTK_MENU (printcmds), printcmditem);
gtk_widget_show (printcmditem);
(void)gtk_signal_connect_object (GTK_OBJECT (printcmditem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) printcmditem);
(void)gtk_signal_connect (GTK_OBJECT (printcmditem), "activate",
GTK_SIGNAL_FUNC (newprcmd), "1");
printcmditem = gtk_menu_item_new_with_label ("kprinter");
gtk_menu_append (GTK_MENU (printcmds), printcmditem);
gtk_widget_show (printcmditem);
(void)gtk_signal_connect_object (GTK_OBJECT (printcmditem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) printcmditem);
(void)gtk_signal_connect (GTK_OBJECT (printcmditem), "activate",
GTK_SIGNAL_FUNC (newprcmd), "2");
gtk_option_menu_set_menu (GTK_OPTION_MENU (printcmdmenu), printcmds);
gtk_widget_show (printcmdmenu);
gtk_box_pack_start (GTK_BOX (hbox), printcmdmenu,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Preview image to add to eps files :"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
epsoptionmenu = gtk_option_menu_new ();
epsoptions = gtk_menu_new ();
epsoptitem = gtk_menu_item_new_with_label (_("None"));
gtk_menu_append (GTK_MENU (epsoptions), epsoptitem);
gtk_widget_show (epsoptitem);
(void)gtk_signal_connect_object (GTK_OBJECT (epsoptitem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) epsoptitem);
(void)gtk_signal_connect (GTK_OBJECT (epsoptitem), "activate",
GTK_SIGNAL_FUNC (newepsopt), "0");
epsoptitem = gtk_menu_item_new_with_label (_("EPSI"));
gtk_menu_append (GTK_MENU (epsoptions), epsoptitem);
gtk_widget_show (epsoptitem);
(void)gtk_signal_connect_object (GTK_OBJECT (epsoptitem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) epsoptitem);
(void)gtk_signal_connect (GTK_OBJECT (epsoptitem), "activate",
GTK_SIGNAL_FUNC (newepsopt), "1");
epsoptitem = gtk_menu_item_new_with_label (_("TIFF mono"));
gtk_menu_append (GTK_MENU (epsoptions), epsoptitem);
gtk_widget_show (epsoptitem);
(void)gtk_signal_connect_object (GTK_OBJECT (epsoptitem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) epsoptitem);
(void)gtk_signal_connect (GTK_OBJECT (epsoptitem), "activate",
GTK_SIGNAL_FUNC (newepsopt), "2");
epsoptitem = gtk_menu_item_new_with_label (_("TIFF color"));
gtk_menu_append (GTK_MENU (epsoptions), epsoptitem);
gtk_widget_show (epsoptitem);
(void)gtk_signal_connect_object (GTK_OBJECT (epsoptitem), "activate",
GTK_SIGNAL_FUNC (gtk_menu_item_select),
(gpointer) epsoptitem);
(void)gtk_signal_connect (GTK_OBJECT (epsoptitem), "activate",
GTK_SIGNAL_FUNC (newepsopt), "2");
gtk_option_menu_set_menu (GTK_OPTION_MENU (epsoptionmenu), epsoptions);
gtk_widget_show (epsoptionmenu);
gtk_box_pack_start (GTK_BOX (hbox), epsoptionmenu,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Support national character sets in labels"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
intlbutton = gtk_check_button_new();
gtk_box_pack_start (GTK_BOX (hbox), intlbutton, FALSE, FALSE, 0);
(void)gtk_signal_connect (GTK_OBJECT(intlbutton), "toggled",
GTK_SIGNAL_FUNC(toggle_intlchars), NULL);
gtk_widget_show (intlbutton);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
snprintf(bghexcolor,10,"#%2.2x%2.2x%2.2x",(unsigned char)(bgred/256.),(unsigned char)(bggreen/256.),(unsigned char)(bgblue/256.));
label = gtk_label_new (_("Background color :"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
bgcolorbutton = gtk_button_new_with_label(bghexcolor);
gtk_box_pack_start (GTK_BOX (hbox), bgcolorbutton, FALSE, FALSE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT(bgcolorbutton), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_show),
GTK_OBJECT(colorseldialog));
gtk_widget_show (bgcolorbutton);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Add filled white rectangle under labels"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
whiteoutbutton = gtk_check_button_new();
gtk_box_pack_start (GTK_BOX (hbox), whiteoutbutton, FALSE, FALSE, 0);
(void)gtk_signal_connect (GTK_OBJECT(whiteoutbutton), "toggled",
GTK_SIGNAL_FUNC(toggle_whiteout), NULL);
gtk_widget_show (whiteoutbutton);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Printer name:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
prqueue = gtk_entry_new_with_max_length (32);
gtk_widget_show (prqueue);
gtk_box_pack_start (GTK_BOX (hbox), prqueue,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Data directory:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
defaultdir = gtk_entry_new_with_max_length ((guint16)PATH_MAX);
gtk_widget_show (defaultdir);
gtk_box_pack_start (GTK_BOX (hbox), defaultdir,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Extension:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
defaultext = gtk_entry_new_with_max_length (32);
gtk_widget_show (defaultext);
gtk_box_pack_start (GTK_BOX (hbox), defaultext,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Base bondlength (10.668mm) :"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
base_bondlen = gtk_entry_new_with_max_length (32);
snprintf(msgtmp,100,"%6.4f",bondlen_mm);
gtk_entry_set_text (GTK_ENTRY (base_bondlen),msgtmp);
gtk_widget_show (base_bondlen);
gtk_box_pack_start (GTK_BOX (hbox), base_bondlen,
(gboolean) TRUE, (gboolean) TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Doublebond separation (4 pixel) :"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
doubledist = gtk_entry_new_with_max_length (32);
snprintf(msgtmp,100,"%d",db_dist);
gtk_entry_set_text (GTK_ENTRY (doubledist),msgtmp);
gtk_widget_show (doubledist);
gtk_box_pack_start (GTK_BOX (hbox), doubledist,
(gboolean) TRUE, (gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (printer_dialog), "delete_event",
(GtkSignalFunc) gtk_widget_hide,
GTK_OBJECT (printer_dialog));
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
pokbutton = gtk_button_new_with_label (_("Ok"));
gtk_box_pack_start (GTK_BOX (hbox), pokbutton,
(gboolean) TRUE, (gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (pokbutton), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (printer_dialog));
(void)gtk_signal_connect (GTK_OBJECT (pokbutton), "clicked",
GTK_SIGNAL_FUNC (setup_printer), "1");
gtk_widget_show (pokbutton);
pcabutton = gtk_button_new_with_label (_("Cancel"));
gtk_box_pack_start (GTK_BOX (hbox), pcabutton,
(gboolean) TRUE, (gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (pcabutton), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (printer_dialog));
(void)gtk_signal_connect (GTK_OBJECT (pcabutton), "clicked",
GTK_SIGNAL_FUNC (setup_printer), "0");
gtk_widget_show (pcabutton);
#endif
/****************************************************************/
/*************************************************************/
/* Popup to show a selection of templates to insert into the drawing */
templates = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (templates), _("Templates"));
gtk_widget_realize (templates);
tvbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (templates), tvbox);
gtk_widget_show (tvbox);
(void)gtk_signal_connect_object (GTK_OBJECT (templates), "delete_event",
(GtkSignalFunc) gtk_widget_hide,
GTK_OBJECT (templates));
temptips = gtk_tooltips_new ();
templatebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (templatebook), GTK_POS_TOP);
label = gtk_label_new (_("Carbocycles"));
gtk_widget_show (label);
page = gtk_frame_new (_("Carbocycles"));
gtk_widget_show (page);
gtk_notebook_append_page (GTK_NOTEBOOK (templatebook), page, label);
pbox = gtk_table_new (5, 5, TRUE);
gtk_widget_show (pbox);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
tbutton[5 * i + j] = gtk_button_new ();
style = gtk_widget_get_style (templates);
pixmap = gdk_pixmap_create_from_xpm_d (templates->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **)
template_xpm[i][j]);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (tbutton[5 * i + j]), pixmapwid);
gtk_widget_show (tbutton[5 * i + j]);
gtk_table_attach_defaults (GTK_TABLE (pbox), tbutton[5 * i + j], (guint)j,
(guint)j + 1, (guint)i, (guint)i + 1);
tmplnum[5 * i + j] = 10 * i + j;
(void)gtk_signal_connect (GTK_OBJECT (tbutton[5 * i + j]), "clicked",
GTK_SIGNAL_FUNC (Add_template),
GINT_TO_POINTER(tmplnum[5 * i + j]) );
if ((int)strlen(template_tip[i][j]) >0 ) {
#ifdef DISABLE_NLS
gtk_tooltips_set_tip (temptips, tbutton[5 * i + j],
template_tip[i][j], NULL);
#else
gtk_tooltips_set_tip (temptips, tbutton[5 * i + j],
gettext(template_tip[i][j]), NULL);
#endif
}
}
}
gtk_container_add (GTK_CONTAINER (page), pbox);
label = gtk_label_new (_("Sugars"));
gtk_widget_show (label);
page = gtk_frame_new (_("Sugars"));
gtk_widget_show (page);
gtk_notebook_append_page (GTK_NOTEBOOK (templatebook), page, label);
pbox = gtk_table_new (5, 5, TRUE);
gtk_widget_show (pbox);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
tbutton[25 + 5 * i + j] = gtk_button_new ();
style = gtk_widget_get_style (templates);
pixmap = gdk_pixmap_create_from_xpm_d (templates->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) template_xpm[i +
5]
[j]);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (tbutton[25 + 5 * i + j]),
pixmapwid);
gtk_widget_show (tbutton[25 + 5 * i + j]);
gtk_table_attach_defaults (GTK_TABLE (pbox),
tbutton[25 + 5 * i + j], (guint)j, (guint)j + 1,
(guint)i, (guint)i + 1);
tmplnum[25 + 5 * i + j] = 10 * (i + 5) + j;
(void)gtk_signal_connect (GTK_OBJECT (tbutton[25 + 5 * i + j]), "clicked",
GTK_SIGNAL_FUNC (Add_template),
GINT_TO_POINTER(tmplnum[25 + 5 * i + j]) );
if ((int)strlen(template_tip[i+5][j]) >0 ) {
#ifdef DISABLE_NLS
gtk_tooltips_set_tip (temptips, tbutton[25 + 5 * i + j],
template_tip[i + 5][j], NULL);
#else
gtk_tooltips_set_tip (temptips, tbutton[25 + 5 * i + j],
gettext(template_tip[i + 5][j]), NULL);
#endif
}
}
}
gtk_container_add (GTK_CONTAINER (page), pbox);
label = gtk_label_new (_("Heterocycles"));
gtk_widget_show (label);
page = gtk_frame_new (_("Heterocycles"));
gtk_widget_show (page);
gtk_notebook_append_page (GTK_NOTEBOOK (templatebook), page, label);
pbox = gtk_table_new (5, 5, TRUE);
gtk_widget_show (pbox);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
tbutton[50 + 5 * i + j] = gtk_button_new ();
style = gtk_widget_get_style (templates);
pixmap = gdk_pixmap_create_from_xpm_d (templates->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) template_xpm[i +
10]
[j]);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (tbutton[50 + 5 * i + j]),
pixmapwid);
gtk_widget_show (tbutton[50 + 5 * i + j]);
gtk_table_attach_defaults (GTK_TABLE (pbox),
tbutton[50 + 5 * i + j], (guint)j,
(guint)j + 1, (guint)i,(guint)i + 1);
tmplnum[50 + 5 * i + j] = 10 * (i + 10) + j;
(void)gtk_signal_connect (GTK_OBJECT (tbutton[50 + 5 * i + j]), "clicked",
GTK_SIGNAL_FUNC (Add_template),
GINT_TO_POINTER(tmplnum[50 + 5 * i + j]) );
if ((int)strlen(template_tip[i+10][j]) >0 ) {
#ifdef DISABLE_NLS
gtk_tooltips_set_tip (temptips, tbutton[50 + 5 * i + j],
template_tip[i + 10][j], NULL);
#else
gtk_tooltips_set_tip (temptips, tbutton[50 + 5 * i + j],
gettext(template_tip[i + 10][j]), NULL);
#endif
}
}
}
gtk_container_add (GTK_CONTAINER (page), pbox);
label = gtk_label_new (_("Amino Acids"));
gtk_widget_show (label);
page = gtk_frame_new (_("Amino Acids"));
gtk_widget_show (page);
gtk_notebook_append_page (GTK_NOTEBOOK (templatebook), page, label);
pbox = gtk_table_new (5, 5, TRUE);
gtk_widget_show (pbox);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
tbutton[75 + 5 * i + j] = gtk_button_new ();
style = gtk_widget_get_style (templates);
pixmap = gdk_pixmap_create_from_xpm_d (templates->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) template_xpm[i +
15]
[j]);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (tbutton[75 + 5 * i + j]),
pixmapwid);
gtk_widget_show (tbutton[75 + 5 * i + j]);
gtk_table_attach_defaults (GTK_TABLE (pbox),
tbutton[75 + 5 * i + j],
(guint)j, (guint)j + 1, (guint)i,
(guint)i + 1);
tmplnum[75 + 5 * i + j] = 10 * (i + 15) + j;
(void)gtk_signal_connect (GTK_OBJECT (tbutton[75 + 5 * i + j]), "clicked",
GTK_SIGNAL_FUNC (Add_template),
GINT_TO_POINTER(tmplnum[75 + 5 * i + j]) );
if ((int)strlen(template_tip[i+15][j]) >0 ) {
#ifdef DISABLE_NLS
gtk_tooltips_set_tip (temptips, tbutton[75 + 5 * i + j],
template_tip[i + 15][j], NULL);
#else
gtk_tooltips_set_tip (temptips, tbutton[75 + 5 * i + j],
gettext(template_tip[i + 15][j]), NULL);
#endif
}
}
}
gtk_container_add (GTK_CONTAINER (page), pbox);
label = gtk_label_new (_("Symbols"));
gtk_widget_show (label);
page = gtk_frame_new (_("Symbols"));
gtk_widget_show (page);
gtk_notebook_append_page (GTK_NOTEBOOK (templatebook), page, label);
pbox = gtk_table_new (5, 5, TRUE);
gtk_widget_show (pbox);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{
tbutton[100 + 5 * i + j] = gtk_button_new ();
style = gtk_widget_get_style (templates);
pixmap = gdk_pixmap_create_from_xpm_d (templates->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) template_xpm[i +
20]
[j]);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (tbutton[100 + 5 * i + j]),
pixmapwid);
gtk_widget_show (tbutton[100 + 5 * i + j]);
gtk_table_attach_defaults (GTK_TABLE (pbox),
tbutton[100 + 5 * i + j],
(guint)j, (guint)j + 1, (guint)i,
(guint)i + 1);
tmplnum[100 + 5 * i + j] = 10 * (i + 20) + j;
(void)gtk_signal_connect (GTK_OBJECT (tbutton[100 + 5 * i + j]), "clicked",
GTK_SIGNAL_FUNC (Add_template),
GINT_TO_POINTER(tmplnum[100 + 5 * i + j]) );
if ((int)strlen(template_tip[i+20][j]) >0 ) {
#ifdef DISABLE_NLS
gtk_tooltips_set_tip (temptips, tbutton[100 + 5 * i + j],
template_tip[i + 20][j], NULL);
#else
gtk_tooltips_set_tip (temptips, tbutton[100 + 5 * i + j],
gettext(template_tip[i + 20][j]), NULL);
#endif
}
}
}
gtk_container_add (GTK_CONTAINER (page), pbox);
gtk_widget_show (templatebook);
gtk_box_pack_start (GTK_BOX (tvbox), templatebook, (gboolean) TRUE,
(gboolean) TRUE, 0);
button = gtk_button_new_with_label (_("Close"));
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (tvbox), button, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_hide),
GTK_OBJECT (templates));
/**************************************************************/
/*
* Create the main window
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (window, "Chemtool");
gtk_window_set_title (GTK_WINDOW (window), "Chemtool 1.6.10");
/* all pop-ups should appear topmost and at the current cursor position,
that is, near their respective toolbar buttons */
gtk_window_set_transient_for (GTK_WINDOW (filew), GTK_WINDOW (window));
gtk_window_set_position (GTK_WINDOW (filew), GTK_WIN_POS_MOUSE);
gtk_window_set_transient_for (GTK_WINDOW (expw), GTK_WINDOW (window));
gtk_window_set_position (GTK_WINDOW (expw), GTK_WIN_POS_MOUSE);
gtk_window_set_transient_for (GTK_WINDOW (messagew), GTK_WINDOW (window));
gtk_window_set_position (GTK_WINDOW (messagew), GTK_WIN_POS_MOUSE);
tooltips = gtk_tooltips_new (); /* initialize tool-tip message boxes */
/* initialize vertical stacking of button rows and drawing area */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
(void)gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (CheckAndQuit), NULL);
#ifdef MENU
/* build the menubar */
accel_group = gtk_accel_group_new ();
/* the menuitems of the file-menu */
file = gtk_menu_new ();
new = gtk_menu_item_new_with_label (_("New"));
gtk_menu_append (GTK_MENU (file), new);
(void)gtk_signal_connect_object (GTK_OBJECT (new), "activate",
GTK_SIGNAL_FUNC (CheckAndClear), NULL);
gtk_widget_add_accelerator (new, "activate", accel_group,
GDK_N, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (new);
open = gtk_menu_item_new_with_label (_("Open"));
gtk_menu_append (GTK_MENU (file), open);
(void)gtk_signal_connect_object (GTK_OBJECT (open), "activate",
GTK_SIGNAL_FUNC (CheckAndLoad), NULL);
gtk_widget_add_accelerator (open, "activate", accel_group,
GDK_O, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (open);
add = gtk_menu_item_new_with_label (_("Add"));
gtk_menu_append (GTK_MENU (file), add);
(void)gtk_signal_connect_object (GTK_OBJECT (add), "activate",
GTK_SIGNAL_FUNC (Add), NULL);
gtk_widget_add_accelerator (add, "activate", accel_group,
GDK_A, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (add);
import = gtk_menu_item_new_with_label (_("Import MOL"));
gtk_menu_append (GTK_MENU (file), import);
(void)gtk_signal_connect_object (GTK_OBJECT (import), "activate",
GTK_SIGNAL_FUNC (Import), NULL);
gtk_widget_add_accelerator (import, "activate", accel_group,
GDK_I, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (import);
imppdb = gtk_menu_item_new_with_label (_("Import PDB"));
gtk_menu_append (GTK_MENU (file), imppdb);
(void)gtk_signal_connect_object (GTK_OBJECT (imppdb), "activate",
GTK_SIGNAL_FUNC (Import_PDB), NULL);
gtk_widget_add_accelerator (imppdb, "activate", accel_group,
GDK_P, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (imppdb);
impany = gtk_menu_item_new_with_label (_("Import (Babel)"));
gtk_menu_append (GTK_MENU (file), impany);
(void)gtk_signal_connect_object (GTK_OBJECT (impany), "activate",
GTK_SIGNAL_FUNC (Import_Babel), NULL);
gtk_widget_add_accelerator (impany, "activate", accel_group,
GDK_B, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (impany);
if (babelin<0) gtk_widget_set_sensitive(impany,FALSE);
export = gtk_menu_item_new_with_label (_("Export..."));
gtk_menu_append (GTK_MENU (file), export);
(void)gtk_signal_connect_object (GTK_OBJECT (export), "activate",
GTK_SIGNAL_FUNC (Export), NULL);
gtk_widget_add_accelerator (export, "activate", accel_group,
GDK_E, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (export);
expany = gtk_menu_item_new_with_label (_("Export (Babel)"));
gtk_menu_append (GTK_MENU (file), expany);
(void)gtk_signal_connect_object (GTK_OBJECT (expany), "activate",
GTK_SIGNAL_FUNC (Export_Babel), NULL);
gtk_widget_add_accelerator (expany, "activate", accel_group,
GDK_X, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (expany);
if (babelout<0) gtk_widget_set_sensitive(expany,FALSE);
printps = gtk_menu_item_new_with_label (_("Print"));
gtk_menu_append (GTK_MENU (file), printps);
(void)gtk_signal_connect_object (GTK_OBJECT (printps), "activate",
GTK_SIGNAL_FUNC (print_ps), NULL);
gtk_widget_add_accelerator (printps, "activate", accel_group,
GDK_P, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (printps);
print_setup = gtk_menu_item_new_with_label (_("Setup Defaults"));
gtk_menu_append (GTK_MENU (file), print_setup);
#ifdef GTK24
(void)gtk_signal_connect_object (GTK_OBJECT (print_setup), "activate",
GTK_SIGNAL_FUNC (print_setup_menu_activate),
NULL);
#else
(void)gtk_signal_connect_object (GTK_OBJECT (print_setup), "activate",
GTK_SIGNAL_FUNC (gtk_widget_show),
GTK_OBJECT (printer_dialog));
#endif
gtk_widget_add_accelerator (print_setup, "activate", accel_group,
GDK_D, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (print_setup);
save_setup = gtk_menu_item_new_with_label (_("Save Config"));
gtk_menu_append (GTK_MENU (file), save_setup);
(void)gtk_signal_connect_object (GTK_OBJECT (save_setup), "activate",
GTK_SIGNAL_FUNC (writerc), NULL);
gtk_widget_add_accelerator (save_setup, "activate", accel_group,
GDK_numbersign, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_show (save_setup);
save = gtk_menu_item_new_with_label (_("Save"));
gtk_menu_append (GTK_MENU (file), save);
(void)gtk_signal_connect_object (GTK_OBJECT (save), "activate",
GTK_SIGNAL_FUNC (Save), NULL);
gtk_widget_add_accelerator (save, "activate", accel_group,
GDK_S, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (save);
saveas = gtk_menu_item_new_with_label (_("Save As..."));
gtk_menu_append (GTK_MENU (file), saveas);
(void)gtk_signal_connect_object (GTK_OBJECT (saveas), "activate",
GTK_SIGNAL_FUNC (SaveAs), NULL);
/* gtk_widget_add_accelerator (saveas, "activate", accel_group,
GDK_F4, 0,
GTK_ACCEL_VISIBLE); */
gtk_widget_show (saveas);
quit = gtk_menu_item_new_with_label (_("Quit"));
gtk_menu_append (GTK_MENU (file), quit);
(void)gtk_signal_connect_object (GTK_OBJECT (quit), "activate",
GTK_SIGNAL_FUNC (CheckAndQuit), NULL);
gtk_widget_add_accelerator (quit, "activate", accel_group,
GDK_Q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (quit);
file_menu = gtk_menu_item_new_with_label (_("File"));
gtk_menu_item_set_submenu (GTK_MENU_ITEM (file_menu), file);
gtk_widget_show (file_menu);
/* the menuitems of the edit-menu */
edit = gtk_menu_new ();
copy = gtk_menu_item_new_with_label (_("Copy"));
gtk_menu_append (GTK_MENU (edit), copy);
(void)gtk_signal_connect (GTK_OBJECT (copy), "activate",
GTK_SIGNAL_FUNC (copy_obj), GTK_OBJECT (window));
/* (void)gtk_signal_connect (GTK_OBJECT (copy), "activate",
GTK_SIGNAL_FUNC (gtk_toggle_button_set_active),
GTK_OBJECT (movebutton));*/
gtk_widget_add_accelerator (copy, "activate", accel_group,
GDK_V, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (copy);
fliph = gtk_menu_item_new_with_label (_("Flip horizontally"));
gtk_menu_append (GTK_MENU (edit), fliph);
(void)gtk_signal_connect (GTK_OBJECT (fliph), "activate",
GTK_SIGNAL_FUNC (flip_horiz), GTK_OBJECT (window));
gtk_widget_show (fliph);
flipv = gtk_menu_item_new_with_label (_("Flip vertically"));
gtk_menu_append (GTK_MENU (edit), flipv);
(void)gtk_signal_connect (GTK_OBJECT (flipv), "activate",
GTK_SIGNAL_FUNC (flip_vert), GTK_OBJECT (window));
gtk_widget_show (flipv);
#ifdef LIBUNDO
undo = gtk_menu_item_new_with_label (_("Undo"));
gtk_menu_append (GTK_MENU (edit), undo);
(void)gtk_signal_connect (GTK_OBJECT (undo), "activate",
GTK_SIGNAL_FUNC (do_undo), GTK_OBJECT (window));
gtk_widget_add_accelerator (undo, "activate", accel_group,
GDK_U, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (undo);
redo = gtk_menu_item_new_with_label (_("Redo"));
gtk_menu_append (GTK_MENU (edit), redo);
(void)gtk_signal_connect (GTK_OBJECT (redo), "activate",
GTK_SIGNAL_FUNC (do_redo), GTK_OBJECT (window));
gtk_widget_add_accelerator (redo, "activate", accel_group,
GDK_R, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (redo);
#endif
edit_menu = gtk_menu_item_new_with_label (_("Edit"));
gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit_menu), edit);
gtk_widget_show (edit_menu);
/* the menuitems of the view-menu */
view = gtk_menu_new ();
zoomin = gtk_menu_item_new_with_label (_("Zoom in"));
gtk_menu_append (GTK_MENU (view), zoomin);
(void)gtk_signal_connect (GTK_OBJECT (zoomin), "activate",
GTK_SIGNAL_FUNC (Zoom), "0");
gtk_widget_show (zoomin);
zoomout = gtk_menu_item_new_with_label (_("Zoom out"));
gtk_menu_append (GTK_MENU (view), zoomout);
(void)gtk_signal_connect (GTK_OBJECT (zoomout), "activate",
GTK_SIGNAL_FUNC (Zoom), "1");
gtk_widget_show (zoomout);
gtk_widget_add_accelerator (zoomin, "activate", accel_group,
GDK_equal, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (zoomout, "activate", accel_group,
GDK_minus, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
center = gtk_menu_item_new_with_label (_("Center"));
gtk_menu_append (GTK_MENU (view), center);
(void)gtk_signal_connect (GTK_OBJECT (center), "activate",
GTK_SIGNAL_FUNC (Center), GTK_OBJECT (window));
gtk_widget_add_accelerator (center, "activate", accel_group,
GDK_C, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (center);
grid = gtk_menu_item_new_with_label (_("Grid rect/rhomb/off"));
gtk_menu_append (GTK_MENU (view), grid);
(void)gtk_signal_connect (GTK_OBJECT (grid), "activate",
GTK_SIGNAL_FUNC (Grid), GTK_OBJECT (window));
gtk_widget_show (grid);
view_menu = gtk_menu_item_new_with_label (_("View"));
gtk_menu_item_set_submenu (GTK_MENU_ITEM (view_menu), view);
gtk_widget_show (view_menu);
/* the menuitems of the tools-menu */
tools = gtk_menu_new ();
templatem = gtk_menu_item_new_with_label (_("Templates..."));
gtk_menu_append (GTK_MENU (tools), templatem);
(void)gtk_signal_connect_object (GTK_OBJECT (templatem), "activate",
GTK_SIGNAL_FUNC (show_or_raise),
GTK_OBJECT (templates));
gtk_widget_add_accelerator (templatem, "activate", accel_group,
GDK_T, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (templatem);
cht = gtk_menu_item_new_with_label (_("Calculate Formula Weight"));
gtk_menu_append (GTK_MENU (tools), cht);
(void)gtk_signal_connect (GTK_OBJECT (cht), "activate",
GTK_SIGNAL_FUNC (do_fw), NULL);
gtk_widget_add_accelerator (cht, "activate", accel_group,
GDK_F, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show (cht);
clean = gtk_menu_item_new_with_label (_("Clean up drawing"));
gtk_menu_append (GTK_MENU (tools), clean);
(void)gtk_signal_connect (GTK_OBJECT (clean), "activate",
GTK_SIGNAL_FUNC (tidy_mol), NULL);
gtk_widget_show (clean);
tools_menu = gtk_menu_item_new_with_label (_("Tools"));
gtk_menu_item_set_submenu (GTK_MENU_ITEM (tools_menu), tools);
gtk_widget_show (tools_menu);
/* the menuitems of the help-menu */
help = gtk_menu_new ();
about = gtk_menu_item_new_with_label (_("About"));
gtk_menu_append (GTK_MENU (help), about);
(void)gtk_signal_connect_object (GTK_OBJECT (about), "activate",
GTK_SIGNAL_FUNC (gtk_widget_show),
GTK_OBJECT (aboutw));
/* gtk_widget_add_accelerator (about, "activate", accel_group,
GDK_F1, 0, GTK_ACCEL_VISIBLE);*/
gtk_widget_show (about);
using = gtk_menu_item_new_with_label (_("Help"));
gtk_menu_append (GTK_MENU (help), using);
(void)gtk_signal_connect_object (GTK_OBJECT (using), "activate",
GTK_SIGNAL_FUNC (gtk_widget_show),
GTK_OBJECT (helpw));
gtk_widget_add_accelerator (using, "activate", accel_group,
GDK_F1, 0, GTK_ACCEL_VISIBLE);
gtk_widget_show (using);
help_menu = gtk_menu_item_new_with_label (_("Help"));
gtk_menu_item_set_submenu (GTK_MENU_ITEM (help_menu), help);
gtk_widget_show (help_menu);
/* build the menubar */
menu_bar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox), menu_bar, (gboolean) FALSE,
(gboolean) FALSE, 2);
gtk_widget_show (menu_bar);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), file_menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), edit_menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), view_menu);
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), tools_menu);
gtk_menu_item_right_justify (GTK_MENU_ITEM (help_menu));
gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), help_menu);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
#else
/* initialize horizontal packing of the first row of buttons */
/* define the first row of buttons, with label,callback and tooltip text */
/* Load | Add | Save | Import | Export | ZoomIn | Center | ZoomOut | Clear | Quit | About */
hbox = gtk_hbox_new (TRUE, 0);
loadbutton = gtk_button_new_with_label (_("Load"));
gtk_box_pack_start (GTK_BOX (hbox), loadbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (loadbutton), "clicked",
GTK_SIGNAL_FUNC (CheckAndLoad), NULL);
gtk_tooltips_set_tip (tooltips, loadbutton, _("Load a chemtool sketch"),
NULL);
gtk_widget_show (loadbutton);
addbutton = gtk_button_new_with_label (_("Add"));
gtk_box_pack_start (GTK_BOX (hbox), addbutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (addbutton), "clicked",
GTK_SIGNAL_FUNC (Add), NULL);
gtk_tooltips_set_tip (tooltips, addbutton, _("Add fragment from file"),
NULL);
gtk_widget_show (addbutton);
tempbutton = gtk_button_new_with_label (_("Templates"));
gtk_box_pack_start (GTK_BOX (hbox), tempbutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (tempbutton), "clicked",
GTK_SIGNAL_FUNC (show_or_raise),
GTK_OBJECT (templates));
gtk_tooltips_set_tip (tooltips, tempbutton, _("Add template structure"),
NULL);
gtk_widget_show (tempbutton);
savebutton = gtk_button_new_with_label (_("Save"));
gtk_box_pack_start (GTK_BOX (hbox), savebutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (savebutton), "clicked",
GTK_SIGNAL_FUNC (Save), NULL);
gtk_tooltips_set_tip (tooltips, savebutton, _("Save sketch to file"), NULL);
gtk_widget_show (savebutton);
exportbutton = gtk_button_new_with_label (_("Export"));
gtk_box_pack_start (GTK_BOX (hbox), exportbutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (exportbutton), "clicked",
GTK_SIGNAL_FUNC (Export), NULL);
(void)gtk_signal_connect (GTK_OBJECT (exportbutton), "clicked",
GTK_SIGNAL_FUNC (gtk_file_selection_set_filename),
GTK_OBJECT (expw));
gtk_tooltips_set_tip (tooltips, exportbutton,
_("Create EPS, XFig, PicTeX or XBM file"), NULL);
gtk_widget_show (exportbutton);
printbutton = gtk_button_new_with_label (_("Print"));
gtk_box_pack_start (GTK_BOX (hbox), printbutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (printbutton), "clicked",
GTK_SIGNAL_FUNC (print_ps), NULL);
gtk_tooltips_set_tip (tooltips, printbutton,
_("Print file to a postscript printer"), NULL);
gtk_widget_show (printbutton);
psetupbutton = gtk_button_new_with_label (_("Setup"));
gtk_box_pack_start (GTK_BOX (hbox), psetupbutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (psetupbutton), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_show),
GTK_OBJECT (printer_dialog));
gtk_tooltips_set_tip (tooltips, psetupbutton,
_("Setup default options"), NULL);
gtk_widget_show (psetupbutton);
savesetupbutton = gtk_button_new_with_label (_("Save Config"));
gtk_box_pack_start (GTK_BOX (hbox), savesetupbutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (savesetupbutton), "clicked",
GTK_SIGNAL_FUNC (writerc), NULL);
gtk_tooltips_set_tip (tooltips, savesetupbutton,
_("Save default options"), NULL);
gtk_widget_show (savesetupbutton);
importbutton = gtk_button_new_with_label (_("Import"));
gtk_box_pack_start (GTK_BOX (hbox), importbutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (importbutton), "clicked",
GTK_SIGNAL_FUNC (Import), NULL);
gtk_tooltips_set_tip (tooltips, importbutton,
_("Read a file written in MDL/molfile format"), NULL);
gtk_widget_show (importbutton);
imppdbbutton = gtk_button_new_with_label (_("ImportPDB"));
gtk_box_pack_start (GTK_BOX (hbox), imppdbbutton, (gboolean) TRUE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (imppdbbutton), "clicked",
GTK_SIGNAL_FUNC (Import_PDB), NULL);
gtk_tooltips_set_tip (tooltips, imppdbbutton,
_("Read a file written in PDB format"), NULL);
gtk_widget_show (imppdbbutton);
zoominbutton = gtk_button_new_with_label (_("Zoom In"));
gtk_box_pack_start (GTK_BOX (hbox), zoominbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (zoominbutton), "clicked",
GTK_SIGNAL_FUNC (Zoom), "0");
gtk_tooltips_set_tip (tooltips, zoominbutton, _("Increase zoom scale"),
NULL);
gtk_widget_show (zoominbutton);
centerbutton = gtk_button_new_with_label (_("Center"));
gtk_box_pack_start (GTK_BOX (hbox), centerbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (centerbutton), "clicked",
GTK_SIGNAL_FUNC (Center), GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, centerbutton,
_("Center molecule in drawing area"), NULL);
gtk_widget_show (centerbutton);
zoomoutbutton = gtk_button_new_with_label (_("Zoom Out"));
gtk_box_pack_start (GTK_BOX (hbox), zoomoutbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (zoomoutbutton), "clicked",
GTK_SIGNAL_FUNC (Zoom), "1");
gtk_tooltips_set_tip (tooltips, zoomoutbutton, _("Decrease zoom scale"),
NULL);
gtk_widget_show (zoomoutbutton);
clearbutton = gtk_button_new_with_label (_("Clear"));
gtk_box_pack_start (GTK_BOX (hbox), clearbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (clearbutton), "clicked",
GTK_SIGNAL_FUNC (CheckAndClear), NULL);
gtk_tooltips_set_tip (tooltips, clearbutton, _("Remove molecule"), NULL);
gtk_widget_show (clearbutton);
fwbutton = gtk_button_new_with_label (_("FW"));
gtk_box_pack_start (GTK_BOX (hbox), fwbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (fwbutton), "clicked",
GTK_SIGNAL_FUNC (do_fw), NULL);
gtk_tooltips_set_tip (tooltips, fwbutton, _("Calculate Formula Mass"),
NULL);
gtk_widget_show (fwbutton);
quitbutton = gtk_button_new_with_label (_("Quit"));
gtk_box_pack_start (GTK_BOX (hbox), quitbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (quitbutton), "clicked",
GTK_SIGNAL_FUNC (CheckAndQuit), NULL);
gtk_tooltips_set_tip (tooltips, quitbutton, _("Exit Chemtool"), NULL);
gtk_widget_show (quitbutton);
aboutbutton = gtk_button_new_with_label (_("About"));
gtk_box_pack_end (GTK_BOX (hbox), aboutbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (aboutbutton), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_show),
GTK_OBJECT (aboutw));
gtk_tooltips_set_tip (tooltips, aboutbutton, _("About Chemtool"), NULL);
gtk_widget_show (aboutbutton);
gtk_box_pack_start (GTK_BOX (vbox), hbox, (gboolean) FALSE,
(gboolean) FALSE, 0);
gtk_widget_show (hbox);
#endif /* menubar or button row */
/* end top row */
/* initialize horizontal packing of second row of buttons */
#ifdef GTK2
hbox = gtk_hbox_new (FALSE, 4);
#else
hbox = gtk_hbox_new (FALSE, 5);
#endif
gtk_widget_realize (window);
/* complete setup of base window, but do not show it yet - we just
need a pointer to it and its color settings for the button pixmaps */
/* Second row has pixmap icons for line drawing on hexagonal, pentagonal
(two orientations) and octagonal grid; left-justfied,centered and
right-justified text; bondtype, move, mark and rotate mode;
vertical and horizontal flipping; copying; and a text entry box */
style = gtk_widget_get_style (window);
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_hex);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
hexbutton = gtk_toggle_button_new ();
gtk_container_add (GTK_CONTAINER (hexbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), hexbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (hexbutton), "clicked",
GTK_SIGNAL_FUNC (Change_Angle), "1");
gtk_tooltips_set_tip (tooltips, hexbutton,
_("Draw at 0/30/60/90 degree angles"), NULL);
gtk_widget_show (hexbutton);
pent1button = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_pent1);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (pent1button), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), pent1button, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (pent1button), "clicked",
GTK_SIGNAL_FUNC (Change_Angle), "2");
gtk_tooltips_set_tip (tooltips, pent1button,
_("Draw at 0/36/72/... degree angles"), NULL);
#ifdef MENU
gtk_widget_add_accelerator (pent1button, "clicked", accel_group,
GDK_F5, 0, GTK_ACCEL_VISIBLE);
#endif
gtk_widget_show (pent1button);
pent2button = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_pent2);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (pent2button), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), pent2button, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (pent2button), "clicked",
GTK_SIGNAL_FUNC (Change_Angle), "3");
gtk_tooltips_set_tip (tooltips, pent2button,
_("Draw at 18/54/90/... degree angles"), NULL);
gtk_widget_show (pent2button);
octbutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_octa);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (octbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), octbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (octbutton), "clicked",
GTK_SIGNAL_FUNC (Change_Angle), "4");
gtk_tooltips_set_tip (tooltips, octbutton,
_("Draw at 0/45/90... degree angles"), NULL);
gtk_widget_show (octbutton);
splinebutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_spline);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (splinebutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), splinebutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (splinebutton), "clicked",
GTK_SIGNAL_FUNC (Splinemode), NULL);
gtk_tooltips_set_tip (tooltips, splinebutton,
_("Draw curves based on 4 control points"), NULL);
gtk_widget_show (splinebutton);
ltextbutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_ltext);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (ltextbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), ltextbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (ltextbutton), "clicked",
GTK_SIGNAL_FUNC (Change_Text), "0");
gtk_tooltips_set_tip (tooltips, ltextbutton, _("Draw left-justified text"),
NULL);
gtk_widget_show (ltextbutton);
ctextbutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_mtext);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (ctextbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), ctextbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (ctextbutton), "clicked",
GTK_SIGNAL_FUNC (Change_Text), "-1");
gtk_tooltips_set_tip (tooltips, ctextbutton, _("Draw centered text"), NULL);
gtk_widget_show (ctextbutton);
rtextbutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_rtext);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (rtextbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), rtextbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (rtextbutton), "clicked",
GTK_SIGNAL_FUNC (Change_Text), "-2");
gtk_tooltips_set_tip (tooltips, rtextbutton, _("Draw right-justified text"),
NULL);
gtk_widget_show (rtextbutton);
fontbutton = gtk_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_font);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
#if 0
fontselw=gtk_window_new(GTK_WINDOW_TOPLEVEL);
fontsel=gtk_font_selection_new();
gtk_widget_show(fontsel);
gtk_container_add(GTK_CONTAINER(fontselw),fontsel);
gtk_widget_realize(fontselw);
#endif
gtk_container_add (GTK_CONTAINER (fontbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), fontbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
#if 0
(void)gtk_signal_connect_object (GTK_OBJECT (fontbutton), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_show), GTK_OBJECT(fontselw));
#else
(void)gtk_signal_connect (GTK_OBJECT (fontbutton), "clicked",
GTK_SIGNAL_FUNC (Change_Font), NULL);
#endif
gtk_tooltips_set_tip (tooltips, fontbutton, _("Set current textfont"),
NULL);
gtk_widget_show (fontbutton);
bondomenu = gtk_option_menu_new ();
bondmenu = gtk_menu_new ();
group = NULL;
for (i = 0; i < BONDTYPES; i++)
{
int ii = i;
menuitem = gtk_menu_item_new();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_bond[i]);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (menuitem), pixmapwid);
gtk_container_set_border_width (GTK_CONTAINER (menuitem), 0);
gtk_menu_append (GTK_MENU (bondmenu), menuitem);
gtk_widget_show (menuitem);
snprintf (bondnums[i],3, "%d", ii);
(void)gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
GTK_SIGNAL_FUNC (set_bond), bondnums[i]);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (bondomenu), bondmenu);
gtk_box_pack_start (GTK_BOX (hbox), bondomenu, (gboolean) FALSE,
(gboolean) TRUE, 0);
gtk_tooltips_set_tip (tooltips, bondomenu, _("Choose default bond type"),
NULL);
gtk_widget_show (bondomenu);
colorbutton= gtk_toggle_button_new();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_color);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (colorbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), colorbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (colorbutton), "clicked",
GTK_SIGNAL_FUNC (change_color), NULL);
gtk_tooltips_set_tip (tooltips, colorbutton,
_("Select pen color"),
NULL);
oldpixmap=pixmapwid;
gtk_widget_show (colorbutton);
bondbutton = gtk_toggle_button_new_with_label (_("Bonds"));
gtk_box_pack_start (GTK_BOX (hbox), bondbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (bondbutton), "clicked",
GTK_SIGNAL_FUNC (Bondmode), NULL);
gtk_tooltips_set_tip (tooltips, bondbutton, _("Toggle bond types"), NULL);
gtk_widget_show (bondbutton);
markbutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_mark);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (markbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), markbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (markbutton), "clicked",
GTK_SIGNAL_FUNC (Markmode), NULL);
gtk_tooltips_set_tip (tooltips, markbutton,
_("Mark objects for moving, rotating or deleting"),
NULL);
gtk_widget_show (markbutton);
movebutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_mov);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (movebutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), movebutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (movebutton), "clicked",
GTK_SIGNAL_FUNC (Movemode), NULL);
gtk_tooltips_set_tip (tooltips, movebutton, _("Move marked object"), NULL);
gtk_widget_show (movebutton);
rotatebutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_rot);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (rotatebutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), rotatebutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (rotatebutton), "clicked",
GTK_SIGNAL_FUNC (Rotatemode), NULL);
gtk_tooltips_set_tip (tooltips, rotatebutton, _("Rotate marked object"),
NULL);
gtk_widget_show (rotatebutton);
hflipbutton = gtk_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_horiz);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (hflipbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), hflipbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (hflipbutton), "clicked",
GTK_SIGNAL_FUNC (flip_horiz),
GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, hflipbutton, _("Flip object horizontally"),
NULL);
gtk_widget_show (hflipbutton);
vflipbutton = gtk_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_vert);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (vflipbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), vflipbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (vflipbutton), "clicked",
GTK_SIGNAL_FUNC (flip_vert),
GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, vflipbutton, _("Flip object vertically"),
NULL);
gtk_widget_show (vflipbutton);
copybutton = gtk_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_copy);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (copybutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), copybutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (copybutton), "clicked",
GTK_SIGNAL_FUNC (copy_obj), GTK_OBJECT (window));
(void)gtk_signal_connect_object (GTK_OBJECT (copybutton), "clicked",
GTK_SIGNAL_FUNC (gtk_toggle_button_set_active),
GTK_OBJECT (movebutton));
#ifdef MENU
(void)gtk_signal_connect_object (GTK_OBJECT (copy), "activate",
GTK_SIGNAL_FUNC (gtk_toggle_button_set_active),
GTK_OBJECT (movebutton));
#endif
gtk_tooltips_set_tip (tooltips, copybutton, _("Copy marked object"), NULL);
gtk_widget_show (copybutton);
rescalebutton = gtk_toggle_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_scale);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (rescalebutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), rescalebutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (rescalebutton), "clicked",
GTK_SIGNAL_FUNC (Rescalemode), NULL);
gtk_tooltips_set_tip (tooltips, rescalebutton, _("Rescale marked object"),
NULL);
gtk_widget_show (rescalebutton);
boxmenu = gtk_menu_new ();
bracketbutton = gtk_menu_item_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_bracket);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (bracketbutton), pixmapwid);
gtk_menu_append (GTK_MENU (boxmenu), bracketbutton);
(void)gtk_signal_connect_object (GTK_OBJECT (bracketbutton), "activate",
GTK_SIGNAL_FUNC (add_bracket),
GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, bracketbutton,
_("Draw brackets around object"), NULL);
gtk_widget_show (bracketbutton);
rbracketbutton = gtk_menu_item_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_r_bracket);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (rbracketbutton), pixmapwid);
gtk_menu_append (GTK_MENU (boxmenu), rbracketbutton);
(void)gtk_signal_connect_object (GTK_OBJECT (rbracketbutton), "activate",
GTK_SIGNAL_FUNC (add_r_bracket),
GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, rbracketbutton,
_("Draw rounded brackets around object"), NULL);
gtk_widget_show (rbracketbutton);
r2bracketbutton = gtk_menu_item_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_r2_bracket);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (r2bracketbutton), pixmapwid);
gtk_menu_append (GTK_MENU (boxmenu), r2bracketbutton);
(void)gtk_signal_connect_object (GTK_OBJECT (r2bracketbutton), "activate",
GTK_SIGNAL_FUNC (add_r2_bracket),
GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, r2bracketbutton,
_("Draw round brackets around object"), NULL);
gtk_widget_show (r2bracketbutton);
bracebutton = gtk_menu_item_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_brace);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (bracebutton), pixmapwid);
gtk_menu_append (GTK_MENU (boxmenu), bracebutton);
(void)gtk_signal_connect_object (GTK_OBJECT (bracebutton), "activate",
GTK_SIGNAL_FUNC (add_brace),
GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, bracebutton, _("Draw braces around object"),
NULL);
gtk_widget_show (bracebutton);
box1button = gtk_menu_item_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_box1);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (box1button), pixmapwid);
gtk_menu_append (GTK_MENU (boxmenu), box1button);
(void)gtk_signal_connect_object (GTK_OBJECT (box1button), "activate",
GTK_SIGNAL_FUNC (add_box1), GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, box1button,
_("Draw simple box around object"), NULL);
gtk_widget_show (box1button);
box2button = gtk_menu_item_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_box2);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (box2button), pixmapwid);
gtk_menu_append (GTK_MENU (boxmenu), box2button);
(void)gtk_signal_connect_object (GTK_OBJECT (box2button), "activate",
GTK_SIGNAL_FUNC (add_box2), GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, box2button,
_("Draw shaded box around object"), NULL);
gtk_widget_show (box2button);
box3button = gtk_menu_item_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_box3);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (box3button), pixmapwid);
gtk_menu_append (GTK_MENU (boxmenu), box3button);
(void)gtk_signal_connect_object (GTK_OBJECT (box3button), "activate",
GTK_SIGNAL_FUNC (add_box3), GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, box3button,
_("Draw fancy box around object"), NULL);
gtk_widget_show (box3button);
box4button = gtk_menu_item_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_box4);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (box4button), pixmapwid);
gtk_menu_append (GTK_MENU (boxmenu), box4button);
(void)gtk_signal_connect_object (GTK_OBJECT (box4button), "activate",
GTK_SIGNAL_FUNC (add_box4), GTK_OBJECT (window));
gtk_tooltips_set_tip (tooltips, box4button,
_("Draw rounded box around object"), NULL);
gtk_widget_show (box4button);
gtk_widget_realize (boxmenu);
boxbutton = gtk_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_bracket);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (boxbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), boxbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect_object (GTK_OBJECT (boxbutton), "clicked",
GTK_SIGNAL_FUNC (show_boxmenu), NULL);
gtk_tooltips_set_tip (tooltips, boxbutton,
_("Draw brackets and boxes around object"), NULL);
gtk_widget_show (boxbutton);
cleanbutton = gtk_button_new ();
pixmap = gdk_pixmap_create_from_xpm_d (window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **) xpm_clean);
pixmapwid = gtk_pixmap_new (pixmap, mask);
gtk_widget_show (pixmapwid);
gdk_pixmap_unref (pixmap);
gtk_container_add (GTK_CONTAINER (cleanbutton), pixmapwid);
gtk_box_pack_start (GTK_BOX (hbox), cleanbutton, (gboolean) FALSE,
(gboolean) TRUE, 0);
(void)gtk_signal_connect (GTK_OBJECT (cleanbutton), "clicked",
GTK_SIGNAL_FUNC (tidy_mol), NULL);
gtk_tooltips_set_tip (tooltips, cleanbutton,
_("Removes duplicate bonds, etc."), NULL);
gtk_widget_show (cleanbutton);
gtk_box_pack_start (GTK_BOX (vbox), hbox, (gboolean) FALSE, (gboolean) TRUE,
0);
gtk_widget_show (hbox);
/*end second row */
hbox=gtk_hbox_new(FALSE,0);
normalfontstyle=gtk_style_copy(gtk_widget_get_default_style());
seriffontstyle=gtk_style_copy(gtk_widget_get_default_style());
#ifdef GTK2
pango_font_description_free(normalfontstyle->font_desc);
normalfontstyle->font_desc=pango_font_description_from_string("Helvetica Bold 12");
pango_font_description_free(seriffontstyle->font_desc);
seriffontstyle->font_desc=pango_font_description_from_string("Times Medium 12");
#else
gdk_font_unref(normalfontstyle->font);
normalfontstyle->font=gdk_font_load("*-helvetica-bold-r-normal--12-*");
gdk_font_unref(seriffontstyle->font);
seriffontstyle->font=gdk_font_load("*-times-medium-r-normal--12-*");
if (!normalfontstyle->font)
normalfontstyle=gtk_style_copy(gtk_widget_get_default_style());
if (!seriffontstyle->font)
seriffontstyle=gtk_style_copy(gtk_widget_get_default_style());
#endif
textlabel = gtk_label_new(_("Text :"));
gtk_widget_set_style(GTK_WIDGET(textlabel),normalfontstyle);
gtk_widget_show(textlabel);
gtk_box_pack_start (GTK_BOX (hbox), textlabel, (gboolean) FALSE,
(gboolean) TRUE, 0);
textbox = gtk_entry_new_with_max_length (100);
gtk_widget_set_usize(textbox,700,20);
gtk_box_pack_start (GTK_BOX (hbox), textbox, (gboolean) FALSE,
(gboolean) FALSE, 0);
(void)gtk_signal_connect (GTK_OBJECT (textbox), "focus_in_event",
(GtkSignalFunc) Set_Textmode, NULL);
gtk_tooltips_set_tip (tooltips, textbox,
_
("Prefix a character with _ for subscript, ^ for superscript, @ for symbols, | for italic, # for bold text; e.g. H_2O, @a_D^2^0"),
NULL);
gtk_widget_show (textbox);
fontmenu = gtk_option_menu_new ();
gtk_tooltips_set_tip (tooltips, fontmenu, _("Select current text size"), NULL);
fontsizes = gtk_menu_new ();
for (i = 0; i < 7; i++)
{
fontsizeitem[i] = gtk_menu_item_new_with_label (fontsizelabel[i]);
gtk_menu_append (GTK_MENU (fontsizes), fontsizeitem[i]);
gtk_widget_show (fontsizeitem[i]);
(void)gtk_signal_connect (GTK_OBJECT (fontsizeitem[i]), "activate",
GTK_SIGNAL_FUNC (set_fontsize),
GINT_TO_POINTER(i));
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (fontmenu), fontsizes);
gtk_widget_show (fontmenu);
gtk_option_menu_set_history(GTK_OPTION_MENU(fontmenu), (guint)3);
gtk_box_pack_start (GTK_BOX (hbox), fontmenu,
(gboolean) FALSE, (gboolean) FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, (gboolean) FALSE, (gboolean) FALSE,
0);
gtk_widget_show (hbox);
/* drawing area */
/***********************the canvas pixmap ***********************/
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, (gboolean) TRUE,
(gboolean) TRUE, 0);
gtk_widget_show (scrolled_window);
gtk_widget_set_usize (window, 800, 580);
if (!picture)
picture = gdk_pixmap_new (window->window, 800, 600, -1);
drawing_area = gtk_drawing_area_new ();
gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 1600, 1600);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW
(scrolled_window), drawing_area);
gtk_widget_show (drawing_area);
mygc[0]=gdk_gc_new(window->window);
(void)gdk_color_alloc(gdk_colormap_get_system(),&black);
gdk_gc_set_foreground(mygc[0],&black);
mygc[1]=gdk_gc_new(window->window);
(void)gdk_color_alloc(gdk_colormap_get_system(),&blue);
gdk_gc_set_foreground(mygc[1],&blue);
mygc[2]=gdk_gc_new(window->window);
(void)gdk_color_alloc(gdk_colormap_get_system(),&green);
gdk_gc_set_foreground(mygc[2],&green);
mygc[3]=gdk_gc_new(window->window);
(void)gdk_color_alloc(gdk_colormap_get_system(),&cyan);
gdk_gc_set_foreground(mygc[3],&cyan);
mygc[4]=gdk_gc_new(window->window);
(void)gdk_color_alloc(gdk_colormap_get_system(),&red);
gdk_gc_set_foreground(mygc[4],&red);
mygc[5]=gdk_gc_new(window->window);
(void)gdk_color_alloc(gdk_colormap_get_system(),&magenta);
gdk_gc_set_foreground(mygc[5],&magenta);
mygc[6]=gdk_gc_new(window->window);
(void)gdk_color_alloc(gdk_colormap_get_system(),&yellow);
gdk_gc_set_foreground(mygc[6],&yellow);
/* Signals used to handle backing pixmap */
(void)gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
(GtkSignalFunc) expose_event, NULL);
(void)gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
(GtkSignalFunc) configure_event, NULL);
(void)gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
(GtkSignalFunc) motion_notify_event, NULL);
(void)gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
(GtkSignalFunc) button_press_event, NULL);
(void)gtk_signal_connect (GTK_OBJECT (drawing_area), "button_release_event",
(GtkSignalFunc) button_release_event, NULL);
(void)gtk_signal_connect (GTK_OBJECT (window), "key_press_event",
(GtkSignalFunc) key_press_event, NULL);
gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
/*status line - used for cht output*/
hbox = gtk_hbox_new (FALSE, 5);
gtk_widget_set_usize (hbox, 800, 20);
#ifdef GTK2
msgtext = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(msgtext), (gboolean) FALSE);
msgtextbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (msgtext));
#else
msgtext = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (msgtext), (gboolean) FALSE);
gtk_box_pack_start (GTK_BOX (hbox), msgtext, (gboolean) TRUE,
(gboolean) TRUE, 0);
#endif
#ifdef GTK2
vscroll = gtk_scrolled_window_new(NULL,NULL);
msgadjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW(vscroll));
gtk_widget_set_usize(vscroll,790,12);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(vscroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(vscroll),msgtext);
#else
vscroll = gtk_vscrollbar_new (GTK_TEXT (msgtext)->vadj);
#endif
gtk_box_pack_start (GTK_BOX (hbox), vscroll, (gboolean) FALSE,
(gboolean) FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, (gboolean) FALSE,
(gboolean) FALSE, 0);
snprintf(msgtmp,99,_("Ready"));
#ifdef GTK2
gtk_text_buffer_get_iter_at_offset (msgtextbuffer, &iter, 0);
gtk_text_buffer_insert (msgtextbuffer, &iter, msgtmp, -1);
#else
gtk_text_insert (GTK_TEXT (msgtext), NULL, NULL, NULL, msgtmp,(gint)strlen(msgtmp));
#endif
gtk_widget_show (msgtext);
gtk_widget_show (vscroll);
gtk_widget_show (hbox);
gtk_widget_show (window);
set_icon(window);
/* initialize cursor shapes */
source =
gdk_bitmap_create_from_data (NULL, (gchar *) pencil_bits, pencil_width,
pencil_height);
mask =
gdk_bitmap_create_from_data (NULL, (gchar *) pencil_mask_bits,
pencil_width, pencil_height);
cursor_pencil =
gdk_cursor_new_from_pixmap (source, mask, &fg, &bg, pencil_x_hot,
pencil_y_hot);
gdk_pixmap_unref (source);
gdk_pixmap_unref (mask);
source =
gdk_bitmap_create_from_data (NULL, (gchar *) text_bits, text_width,
text_height);
mask =
gdk_bitmap_create_from_data (NULL, (gchar *) text_mask_bits, text_width,
text_height);
cursor_text =
gdk_cursor_new_from_pixmap (source, mask, &fg, &bg, text_x_hot,
text_y_hot);
gdk_pixmap_unref (source);
gdk_pixmap_unref (mask);
source =
gdk_bitmap_create_from_data (NULL, (gchar *) bonds_bits, bonds_width,
bonds_height);
mask =
gdk_bitmap_create_from_data (NULL, (gchar *) bonds_mask_bits, bonds_width,
bonds_height);
cursor_bonds =
gdk_cursor_new_from_pixmap (source, mask, &fg, &wh, bonds_x_hot,
bonds_y_hot);
gdk_pixmap_unref (source);
gdk_pixmap_unref (mask);
cursor_markTLC = gdk_cursor_new (GDK_TOP_LEFT_CORNER);
cursor_markBRC = gdk_cursor_new (GDK_BOTTOM_RIGHT_CORNER);
cursor_move = gdk_cursor_new (GDK_FLEUR);
cursor_rescale = gdk_cursor_new (GDK_SIZING);
cursor_rotate = gdk_cursor_new (GDK_EXCHANGE);
/* cursor_busy = gdk_cursor_new (GDK_WATCH); */
/*@ignore@ splint does not know all signal names */
(void) signal (SIGSEGV, ct_crash);
(void) signal (SIGFPE, ct_crash);
(void) signal (SIGBUS, ct_crash);
(void) signal (SIGHUP, ct_crash);
(void) signal (SIGPIPE, SIG_IGN);
/*@end@*/
if (!Load_Font() )
{
fprintf (stderr, "chemtool: can't load any font\n");
exit (1);
}
gtk_toggle_button_set_active ((GtkToggleButton *) hexbutton, TRUE);
/* default to linedrawing at hexagonal angles */
text_direct = -1; /* and centered text */
expmode = 0; /*default to xfig export */
orient = 0;
printcmd = 0;
epsoption = 0;
use_whiteout = 0;
use_intlchars = 0;
strcpy (filename, _("unnamed"));
gtk_file_selection_set_filename (GTK_FILE_SELECTION (expw), filename);
printscale = 0.7;
papersize = 0;
queuename = getenv ("PRINTER");
if (queuename == (char *) NULL)
{
queuename = malloc (33 * sizeof (char));
strcpy (queuename, "lp");
}
check_fig2dev ();
if (figversion ==0) {
#ifdef MENU
gtk_widget_set_sensitive(printps,FALSE);
#else
gtk_widget_set_sensitive(printbutton,FALSE);
#endif
gtk_widget_set_sensitive(expbutton[0],FALSE);
gtk_widget_set_sensitive(expbutton[1],FALSE);
gtk_widget_set_sensitive(expbutton[2],FALSE);
gtk_widget_set_sensitive(expbutton[8],FALSE);
}
#ifndef EMF
if (figversion >=3 )gtk_widget_show (expbutton[6]);
#endif
check_fig2sxd();
if (have_fig2sxd) gtk_widget_show(expbutton[7]);
bgred=bgblue=bggreen=65535;
readrc ();
background.red=(gushort)bgred;
background.green=(gushort)bggreen;
background.blue=(gushort)bgblue;
background_gc=gdk_gc_new(window->window);
(void)gdk_color_alloc(gdk_colormap_get_system(),&background);
gdk_gc_set_foreground(background_gc,&background);
gdk_gc_set_background(background_gc,&background);
snprintf(bghexcolor,10,"#%2.2x%2.2x%2.2x",(unsigned char)(bgred/256.),(unsigned char)(bggreen/256.),(unsigned char)(bgblue/256.));
#ifndef GTK2
gtk_label_set_text(GTK_LABEL(GTK_BUTTON(bgcolorbutton)->child),bghexcolor);
gtk_entry_set_text (GTK_ENTRY (prqueue), queuename);
gtk_option_menu_set_history (GTK_OPTION_MENU (papermenu), (guint)papersize);
gtk_option_menu_set_history (GTK_OPTION_MENU (printcmdmenu), (guint)printcmd);
gtk_option_menu_set_history (GTK_OPTION_MENU (epsoptionmenu), (guint) epsoption);
gtk_spin_button_set_value ((GtkSpinButton *) pscale, printscale * 100.);
if (use_whiteout==1) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(whiteoutbutton),TRUE);
if (use_intlchars==1) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(intlbutton),TRUE);
snprintf(msgtmp,100,"%6.4f",bondlen_mm);
gtk_entry_set_text (GTK_ENTRY (base_bondlen),msgtmp);
if (datadir && (int)strlen (datadir) > 1)
{
gtk_entry_set_text (GTK_ENTRY (defaultdir), datadir);
gtk_entry_set_text (GTK_ENTRY (defaultext), datamask);
gtk_file_selection_complete (GTK_FILE_SELECTION (filew),
strcat (datadir, datamask));
strcpy (datadir, gtk_entry_get_text (GTK_ENTRY (defaultdir)));
}
#else
if (datadir && (int)strlen (datadir) > 1)
{
char dir_mask[PATH_MAX];
strcpy (dir_mask, datadir);
strcat (dir_mask, datamask);
gtk_file_selection_complete (GTK_FILE_SELECTION (filew), dir_mask);
}
#endif
mark.flag = False;
head.width = 2000;
head.height = 5000;
zoom_factor = 2;
pdbx = pdby = pdbz = NULL;
atcode = NULL;
atjust = bondtype = NULL;
bondfrom = bondto = NULL;
hp->x = hp->y = 200;
hp->tx = hp->ty = 200;
tmpx=(int*)NULL;
tmpy=(int*)NULL;
gridtype=0;
gridx=gridy = 0;
atnum = 0;
if (argc == 2)
{
strcpy (filename, argv[1]);
#if 0
if(strrchr(filename,'/')) { /* change working directory to obtain absolute path */
char dirname[256];
strcpy(dirname,filename); /* and strip path from filename - gtkfilesel may */
char *start= strrchr(dirname,'/');
*start='\0'; /* get confused by relative paths, stripping off */
start++;
chdir(dirname); /* a level with every invocation of the file dialog */
memmove(filename,start,strlen(start)+1);
}
#endif
load_mol (filename);
}
FreePix ();
CreatePix ();
Display_Mol ();
gtk_main (); /* enter the gtk eventloop */
return 0;
}
void
show_boxmenu ()
{
gtk_menu_popup (GTK_MENU (boxmenu), NULL, NULL, NULL, NULL, 0, 0);
}
void
ct_crash (signal)
int signal;
{
FILE *fp;
fp = fopen ("crashdump.cht", "w");
save_mol (fp, 0);
switch (signal)
{
case SIGSEGV:
fprintf (stderr, "Memory allocation problem (SIGSEGV) -");
break;
case SIGFPE:
fprintf (stderr, "Invalid math somewhere (SIGFPE) -");
break;
case SIGBUS:
fprintf (stderr, "Memory access problem (SIGBUS) -");
break;
case SIGHUP:
fprintf (stderr, "Ordered to quit (SIGHUP) - ");
}
fprintf (stderr, " dumping current drawing to file crashdump.cht\n");
fclose (fp);
exit (1);
}
void
restore_picture ()
{
if (savedpicture)
picture = gdk_pixmap_ref(savedpicture);
}
void
getpreview (GtkWidget * w, gint row, gint column, GdkEventButton * bevent,
gpointer data)
{
char myfile[255];
if (bevent && bevent->type == GDK_2BUTTON_PRESS)
return;
if (loadsave != 1 && loadsave != 3 && loadsave != 4)
return;
strcpy (myfile,
gtk_file_selection_get_filename (GTK_FILE_SELECTION (filew)));
if (picture){
gdk_pixmap_unref (picture);
picture=NULL;
}
picture = gdk_pixmap_new (filew->window, 200, 100, -1);
gdk_draw_rectangle (picture,
filew->style->white_gc,
(gint) TRUE, 0, 0, (gint) 200, (gint) 100);
if (loadsave == 4) {
sdfindex = 0;
preview_mdl_mol(myfile,sdfindex);
} else
load_preview (myfile);
}
void
set_icon(GtkWidget *w) {
/* Set icon for the main chemtool window */
GdkWindow *win;
GdkPixmap *icon;
GdkBitmap *iconmask;
gtk_widget_realize(w);
win = w->window;
if (!win) return;
icon = gdk_pixmap_create_from_xpm_d(win, &iconmask, NULL, chemtool_xpm);
gdk_window_set_icon(win, NULL, icon, iconmask);
}
syntax highlighted by Code2HTML, v. 0.9.1