atomes 1.1.14
atomes: an atomic scale modeling tool box
Loading...
Searching...
No Matches
glwindow.c
Go to the documentation of this file.
1/* This file is part of the 'atomes' software
2
3'atomes' is free software: you can redistribute it and/or modify it under the terms
4of the GNU Affero General Public License as published by the Free Software Foundation,
5either version 3 of the License, or (at your option) any later version.
6
7'atomes' is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
8without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9See the GNU General Public License for more details.
10
11You should have received a copy of the GNU Affero General Public License along with 'atomes'.
12If not, see <https://www.gnu.org/licenses/>
13
14Copyright (C) 2022-2024 by CNRS and University of Strasbourg */
15
22/*
23* This file: 'glwindow.c'
24*
25* Contains:
26*
27
28 - The functions to create a project OpenGL window
29
30*
31* List of functions:
32
33 gboolean create_3d_model (int p, gboolean load);
34
35 G_MODULE_EXPORT gboolean on_key_pressed (GtkWidget * widg, GdkEventKey * event, gpointer data);
36 G_MODULE_EXPORT gboolean on_glwin_key_pressed (GtkEventControllerKey * self, guint keyval, guint keycode, GdkModifierType state, gpointer data);
37
38 void update_all_menus (glwin * view, int nats);
39 void menu_items_opengl (GtkWidget * menu, glwin * view, int pop);
40 void menu_items_model (GtkWidget * menu, glwin * view, int pop);
41 void menu_items_view (GtkWidget * menu, glwin * view, int popm);
42 void prepare_opengl_menu_bar (glwin * view);
43 void change_color_map (glwin * view, int col);
44 void set_motion (glwin * view, int axis, int da, int db, gboolean UpDown, GdkModifierType state);
45 void activate_glwin_action (gchar * action_string, gchar * action_name, glwin * view);
46 void glwin_key_pressed (guint keyval, GdkModifierType state, gpointer data);
47 void prep_model (int p);
48
49 G_MODULE_EXPORT void render_gl_image (GtkWidget * widg, gpointer data);
50 G_MODULE_EXPORT void on_win_realize (GtkWidget * widg, gpointer data);
51
52 GtkWidget * prep_rings_menu (glwin * view, int id);
53 GtkWidget * coord_menu (glwin * view);
54 GtkWidget * menu_opengl (glwin * view, int pop);
55 GtkWidget * menu_model (glwin * view, int pop);
56 GtkWidget * menu_view (glwin * view, int popm);
57
58 mat4_t insert_projection (glwin * view);
59
60 vec3_t get_insertion_coordinates (glwin * view);
61
62*/
63
64#include "global.h"
65#include "project.h"
66#include "calc.h"
67#include "glview.h"
68#include "initcoord.h"
69#include "submenus.h"
70#include "color_box.h"
71
72extern G_MODULE_EXPORT void opengl_advanced (GtkWidget * widg, gpointer data);
73extern G_MODULE_EXPORT void coord_properties (GtkWidget * widg, gpointer data);
74extern G_MODULE_EXPORT void set_style (GtkWidget * widg, gpointer data);
75extern G_MODULE_EXPORT void set_render (GtkWidget * widg, gpointer data);
76extern G_MODULE_EXPORT void set_mode (GtkWidget * widg, gpointer data);
77extern void set_sensitive_coord_menu (glwin * view, gboolean status);
78extern void set_color_map_sensitive (glwin * view);
79extern G_MODULE_EXPORT void set_selection_mode (GtkWidget * widg, gpointer data);
80
81extern gboolean spin (gpointer data);
82extern G_MODULE_EXPORT void spin_stop (GtkButton * but, gpointer data);
83extern G_MODULE_EXPORT void spin_go (GtkWidget * widg, gpointer data);
84extern void update_menus (glwin * view);
85extern G_MODULE_EXPORT void set_box_axis_style (GtkWidget * widg, gpointer data);
86extern G_MODULE_EXPORT void window_measures (GtkWidget * widg, gpointer data);
87extern G_MODULE_EXPORT void window_recorder (GtkWidget * widg, gpointer data);
88extern void window_encode (glwin * view, gboolean video);
89extern GtkWidget * menupoly (glwin * view, int jd, int id, gchar * poln);
90extern G_MODULE_EXPORT void set_color_map (GtkWidget * widg, gpointer data);
91#ifdef GTK4
92extern void update_menu_bar (glwin * view);
93extern G_MODULE_EXPORT void set_full_screen (GSimpleAction * action, GVariant * parameter, gpointer data);
94extern G_MODULE_EXPORT void add_object (GSimpleAction * action, GVariant * parameter, gpointer data);
95extern G_MODULE_EXPORT void label_unlabel_atoms (GSimpleAction * action, GVariant * parameter, gpointer data);
96extern G_MODULE_EXPORT void select_unselect_atoms (GSimpleAction * action, GVariant * parameter, gpointer data);
97extern G_MODULE_EXPORT void edit_in_new_project (GSimpleAction * action, GVariant * parameter, gpointer data);
98extern G_MODULE_EXPORT void remove_the_atoms (GSimpleAction * action, GVariant * parameter, gpointer data);
99extern G_MODULE_EXPORT void copy_the_atoms (GSimpleAction * action, GVariant * parameter, gpointer data);
100#else
101extern void prep_all_coord_menus (glwin * view);
102extern G_MODULE_EXPORT void set_full_screen (GtkWidget * widg, gpointer data);
103extern G_MODULE_EXPORT void to_reset_view (GtkWidget * widg, gpointer data);
104extern G_MODULE_EXPORT void add_object (GtkWidget * widg, gpointer data);
105extern G_MODULE_EXPORT void label_unlabel_atoms (GtkWidget * widg, gpointer data);
106extern G_MODULE_EXPORT void select_unselect_atoms (GtkWidget * widg, gpointer data);
107extern G_MODULE_EXPORT void remove_the_atoms (GtkWidget * widg, gpointer data);
108extern G_MODULE_EXPORT void copy_the_atoms (GtkWidget * widg, gpointer data);
109extern G_MODULE_EXPORT void edit_in_new_project (GtkWidget * widg, gpointer data);
110#endif
111extern void save_rotation_quaternion (glwin * view);
112extern void rotate_x_y (glwin * view, double angle_x, double angle_y);
113extern void translate (project * this_proj, int status, int axis, vec3_t trans);
114extern int selected_aspec;
115extern int is_selected;
116extern int is_labelled;
117extern G_MODULE_EXPORT void on_create_new_project (GtkWidget * widg, gpointer data);
118extern gchar * action_atoms[3];
119extern int get_selection_type (glwin * view);
120
121atomic_object * copied_object = NULL;
122
123#ifdef GTK3
132GtkWidget * prep_rings_menu (glwin * view, int id)
133{
134 if (id == 0)
135 {
136 return menu_rings (view, 0);
137 }
138 else
139 {
140 return menupoly (view, 0, 2, NULL);
141 }
142}
143
151GtkWidget * coord_menu (glwin * view)
152{
153 int i, j, k;
154 GtkWidget * widg;
155 for (j=4; j<10; j++)
156 {
157 if (j<9)
158 {
159 if (view -> ogl_poly[0][j] != NULL)
160 {
161 for (k=0; k<get_project_by_id(view -> proj) -> coord -> totcoord[j]; k++)
162 {
163 if (view -> ogl_poly[0][j][k] != NULL)
164 {
165 if (GTK_IS_WIDGET(view -> ogl_poly[0][j][k]))
166 {
167 widg = gtk_widget_get_parent (view -> ogl_poly[0][j][k]);
168 if (GTK_IS_WIDGET(widg))
169 {
170 g_object_ref (view -> ogl_poly[0][j][k]);
171 gtk_container_remove (GTK_CONTAINER(widg), view -> ogl_poly[0][j][k]);
172 }
173 }
174 }
175 }
176 }
177 }
178 if (view -> ogl_geom[0][j] != NULL)
179 {
180 for (k=0; k<get_project_by_id(view -> proj) -> coord -> totcoord[j]; k++)
181 {
182 if (view -> ogl_geom[0][j][k] != NULL)
183 {
184 if (GTK_IS_WIDGET(view -> ogl_geom[0][j][k]))
185 {
186 widg = gtk_widget_get_parent (view -> ogl_geom[0][j][k]);
187 if (GTK_IS_WIDGET(widg))
188 {
189 g_object_ref (view -> ogl_geom[0][j][k]);
190 gtk_container_remove (GTK_CONTAINER(widg), view -> ogl_geom[0][j][k]);
191 }
192 }
193 }
194 }
195 }
196 }
197 if (view -> ogl_chains[0]) view -> ogl_chains[0] = destroy_this_widget (view -> ogl_chains[0]);
198 for (i=0; i<2; i++)
199 {
200 for (j=2; j<4; j++)
201 {
202 detach_frag_mol_menu (view, i, j);
203 }
204 }
205 for (i=1; i<OGL_COORDS; i++)
206 {
207 view -> ogl_coord[i] = destroy_this_widget (view -> ogl_coord[i]);
208 }
209 for (i=0; i<2; i++)
210 {
211 view -> ogl_rings[i*6] = menu_item_new_with_submenu ("Ring(s)", view -> rings, prep_rings_menu (view, i*6));
212 }
213 view -> ogl_chains[0] = menu_item_new_with_submenu ("Chain(s)", view -> chains, add_menu_coord (view, 0, 9));
214 view -> ogl_coord[1] = menu_coord (view, 0);
215 view -> ogl_coord[2] = menu_item_new_with_submenu ("Polyhedra", TRUE, menu_poly (view, 0));
216 view -> ogl_coord[3] = menu_item_new_with_submenu ("Fragment(s)", get_project_by_id(view -> proj) -> coord -> totcoord[2], add_menu_coord (view, 0, 2));
217 view -> ogl_coord[4] = menu_item_new_with_submenu ("Molecule(s)", get_project_by_id(view -> proj) -> coord -> totcoord[3], add_menu_coord (view, 0, 3));
218 GtkWidget * menu = gtk_menu_new ();
219 gtk_menu_shell_append ((GtkMenuShell *)menu, view -> ogl_coord[1]);
220 gtk_menu_shell_append ((GtkMenuShell *)menu, view -> ogl_coord[2]);
221 gtk_menu_shell_append ((GtkMenuShell *)menu, view -> ogl_rings[0]);
222 gtk_menu_shell_append ((GtkMenuShell *)menu, view -> ogl_chains[0]);
223 gtk_menu_shell_append ((GtkMenuShell *)menu, view -> ogl_coord[3]);
224 gtk_menu_shell_append ((GtkMenuShell *)menu, view -> ogl_coord[4]);
225 gtk3_menu_item (menu, "Advanced", IMG_NONE, NULL, G_CALLBACK(coord_properties), (gpointer)& view -> colorp[30][0], TRUE, GDK_KEY_e, GDK_CONTROL_MASK, FALSE, FALSE, FALSE);
226 // add_advanced_item (menu, G_CALLBACK(coord_properties), (gpointer)& view -> colorp[30][0], TRUE, GDK_KEY_e, GDK_CONTROL_MASK);
227 return menu;
228}
229#endif
230
239void update_all_menus (glwin * view, int nats)
240{
241#ifdef GTK3
242 int i, j, k, l;
243 i = view -> anim -> last -> img -> style;
244 j = (nats <= 1000) ? BALL_AND_STICK : DEFAULT_STYLE;
245 if (i != j)
246 {
247 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_styles[j], FALSE);
248 if (i != SPACEFILL)
249 {
250 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_styles[i], TRUE);
251 set_style (view -> ogl_styles[i], & view -> colorp[i][0]);
252 }
253 else
254 {
255 i = view -> anim -> last -> img -> filled_type;
256 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> filled_styles[i], TRUE);
257 set_style (view -> filled_styles[i], & view -> colorp[OGL_STYLES+i][0]);
258 }
259 }
260 i = view -> anim -> last -> img -> render;
261 j = FILL;
262 if (i != j)
263 {
264 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_render[j], FALSE);
265 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_render[i], TRUE);
266 set_render (view -> ogl_render[i], & view -> colorp[i][0]);
267 }
268
269 update_menus (view);
270 for (i=0; i<2; i++)
271 {
272 widget_set_sensitive (view -> ogl_box[i], active_cell -> ltype);
273 if (view -> anim -> last -> img -> box_axis[i] == NONE)
274 {
275 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_box_axis[i][0], FALSE);
276 set_box_axis_style (view -> ogl_box_axis[i][0], & view -> colorp[0][i]);
277 }
278 else
279 {
280 j = (view -> anim -> last -> img -> box_axis[i] == WIREFRAME) ? 1 : 2;
281 k = j*j;
282 l = (view -> anim -> last -> img -> box_axis[i] == WIREFRAME) ? CYLINDERS : WIREFRAME;
283 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_box_axis[i][0], TRUE);
284 set_box_axis_style (view -> ogl_box_axis[i][0], & view -> colorp[0][i]);
285 view -> anim -> last -> img -> box_axis[i] = l;
286 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_box_axis[i][j], TRUE);
287 set_box_axis_style (view -> ogl_box_axis[i][j], & view -> colorp[k][i]);
288 }
289 }
290 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_rep[view -> anim -> last -> img -> rep], TRUE);
291 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_rep[! view -> anim -> last -> img -> rep], FALSE);
292 for (i=0; i<5; i++) gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_box_axis[1][8+i], FALSE);
293 if (view -> anim -> last -> img -> axispos != CUSTOM)
294 {
295 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_box_axis[1][8+view -> anim -> last -> img -> axispos], TRUE);
296 }
297 set_advanced_bonding_menus (view);
298 widget_set_sensitive (view -> ogl_clones[0], view -> allbonds[1]);
299 update_rings_menus (view);
300 update_chains_menus (view);
301 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_clones[0], view -> anim -> last -> img -> draw_clones);
302 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_clones[5], view -> anim -> last -> img -> cloned_poly);
303 int * cmap = save_color_map (view);
304 set_color_map_sensitive (view);
305 if (view -> color_styles[0])
306 {
307 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> color_styles[0], TRUE);
308 set_color_map (view -> color_styles[0], & view -> colorp[0][0]);
309 }
310 if (view -> color_styles[ATOM_MAPS])
311 {
312 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> color_styles[ATOM_MAPS], TRUE);
313 set_color_map (view -> color_styles[ATOM_MAPS], & view -> colorp[ATOM_MAPS][0]);
314 }
315 restore_color_map (view, cmap);
316 g_free (cmap);
317 gtk_range_set_value (GTK_RANGE(view -> ogl_quality), view -> anim -> last -> img -> quality);
318#else
319 update_menu_bar (view);
320#endif
321}
322
331G_MODULE_EXPORT void render_gl_image (GtkWidget * widg, gpointer data)
332{
333 glwin * view = (glwin *) data;
334 window_encode (view, FALSE);
335}
336
337#ifdef GTK3
338
348void menu_items_opengl (GtkWidget * menu, glwin * view, int pop)
349{
350 GtkWidget * style = gtk3_menu_item (menu, "Style", IMG_FILE, (gpointer)PACKAGE_MOL, NULL, NULL, FALSE, 0, 0, FALSE, FALSE, get_project_by_id(view -> proj) -> nspec);
351 gtk_menu_item_set_submenu ((GtkMenuItem *)style, menu_style(view, pop));
352 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Color Scheme(s)", get_project_by_id(view -> proj) -> nspec, menu_map(view, pop)));
353 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Render", get_project_by_id(view -> proj) -> nspec, menu_render(view, pop)));
354 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Quality", get_project_by_id(view -> proj) -> nspec, menu_quality(view, pop)));
355 gtk3_menu_item (menu, "Material And Light(s)", IMG_NONE, NULL, G_CALLBACK(opengl_advanced), (gpointer)view, FALSE, 0, 0, FALSE, FALSE, FALSE);
356 gtk3_menu_item (menu, "Render Image", IMG_FILE, (gpointer)PACKAGE_IMG, G_CALLBACK(render_gl_image), (gpointer)view, FALSE, 0, 0, FALSE, FALSE, FALSE);
357}
358
367GtkWidget * menu_opengl (glwin * view, int pop)
368{
369 GtkWidget * menu = gtk_menu_new ();
370 menu_items_opengl (menu, view, pop);
371 return menu;
372}
373
383void menu_items_model (GtkWidget * menu, glwin * view, int pop)
384{
385 if (get_project_by_id(view -> proj) -> nspec)
386 {
387 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Atom(s)", TRUE, menu_atoms (view, pop, 0)));
388 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Bond(s)", TRUE, menu_bonds (view, pop, 0)));
389 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Clone(s)", TRUE, menu_clones (view, pop)));
390 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_box_axis (view, 0, 0));
391 }
392}
393
402GtkWidget * menu_model (glwin * view, int pop)
403{
404 GtkWidget * menu = gtk_menu_new ();
405 menu_items_model (menu, view, pop);
406 return menu;
407}
408
418void menu_items_view (GtkWidget * menu, glwin * view, int popm)
419{
420 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Representation", TRUE, menu_rep (view, popm)));
421 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Projection", TRUE, menu_proj (view)));
422 gtk_menu_shell_append ((GtkMenuShell *)menu, menu_item_new_with_submenu ("Background", TRUE, menu_back (view)));
423 if (get_project_by_id(view -> proj) -> nspec) gtk_menu_shell_append ((GtkMenuShell *)menu, menu_box_axis (view, popm, 1));
424 if (! popm)
425 {
426 add_menu_separator (menu);
427 gtk3_menu_item (menu, "Reset view", IMG_STOCK, (gpointer)FITBEST, G_CALLBACK(to_reset_view), (gpointer)view, FALSE, 0, 0, FALSE, FALSE, FALSE);
428 gtk3_menu_item (menu, "Center molecule", IMG_STOCK, (gpointer)FITBEST, G_CALLBACK(to_center_this_molecule), (gpointer)view, FALSE, 0, 0, FALSE, FALSE, FALSE);
429 add_menu_separator (menu);
430 gtk3_menu_item (menu, "Fullscreen", IMG_STOCK, (gpointer)FULLSCREEN, G_CALLBACK(set_full_screen), (gpointer)view, TRUE, GDK_KEY_f, GDK_CONTROL_MASK, FALSE, FALSE, FALSE);
431 }
432}
433
442GtkWidget * menu_view (glwin * view, int popm)
443{
444 GtkWidget * menu = gtk_menu_new ();
445 menu_items_view (menu, view, popm);
446 return menu;
447}
448#endif
449
457void prepare_opengl_menu_bar (glwin * view)
458{
459#ifdef GTK3
460 view -> ogl_coord[0] = destroy_this_widget (view -> ogl_coord[0]);
461#endif
462 view -> menu_bar = destroy_this_widget (view -> menu_bar);
463#ifdef GTK3
464 view -> menu_bar = gtk_menu_bar_new ();
465 gtk_menu_shell_append ((GtkMenuShell *)view -> menu_bar, menu_item_new_with_submenu ("OpenGL", TRUE, menu_opengl(view, 0)));
466 project * this_proj = get_project_by_id (view -> proj);
467 gtk_menu_shell_append ((GtkMenuShell *)view -> menu_bar, menu_item_new_with_submenu ("Model", this_proj -> nspec, menu_model(view, 0)));
468 view -> ogl_coord[0] = create_menu_item (FALSE, "Chemistry");
469 gtk_menu_shell_append ((GtkMenuShell *)view -> menu_bar, view -> ogl_coord[0]);
470 widget_set_sensitive (view -> ogl_coord[0], this_proj -> nspec);
471 if (this_proj -> nspec)
472 {
473 gtk_menu_item_set_submenu ((GtkMenuItem *)view -> ogl_coord[0], coord_menu (view));
474 }
475 gtk_menu_shell_append ((GtkMenuShell *)view -> menu_bar, menu_item_new_with_submenu ("Tools", TRUE, menu_tools(view, 0)));
476 gtk_menu_shell_append ((GtkMenuShell *)view -> menu_bar, menu_item_new_with_submenu ("View", TRUE, menu_view(view, 0)));
477 gtk_menu_shell_append ((GtkMenuShell *)view -> menu_bar, menu_anim (view, 0));
478 show_the_widgets (view -> menu_bar);
479
480 if (this_proj -> nspec) update_all_menus (view, this_proj -> natomes);
481 add_box_child_start (GTK_ORIENTATION_HORIZONTAL, view -> menu_box, view -> menu_bar, TRUE, TRUE, 0);
482 show_the_widgets (view -> menu_bar);
483#else
484 update_menu_bar (view);
485#endif
486}
487
496void change_color_map (glwin * view, int col)
497{
498 int i, j;
499 i = ATOM_MAPS-1;
500 if (view -> custom_map) i++;
501 if (view -> anim -> last -> img -> color_map[col] < i-1)
502 {
503 if (view -> anim -> last -> img -> color_map[col] < 2)
504 {
505 j = col*ATOM_MAPS + view -> anim -> last -> img -> color_map[col] + 1;
506 }
507 else if (view -> anim -> last -> img -> color_map[col] == 2 && view -> adv_bonding[0])
508 {
509 j = col*ATOM_MAPS + view -> anim -> last -> img -> color_map[col] + 1;
510 }
511 else if (view -> anim -> last -> img -> color_map[col] == 3 && view -> adv_bonding[1])
512 {
513 j = col*ATOM_MAPS + view -> anim -> last -> img -> color_map[col] + 1;
514 }
515 else if (view -> anim -> last -> img -> color_map[col] == 4 && get_project_by_id(view -> proj) -> force_field[0])
516 {
517 j = col*ATOM_MAPS + view -> anim -> last -> img -> color_map[col] + 1;
518 }
519 else
520 {
521 j = col*ATOM_MAPS + ((view -> custom_map) ? 6 : 0);
522 }
523 }
524 else
525 {
526 j = col*ATOM_MAPS;
527 }
528 gboolean was_input = reading_input;
529 reading_input = TRUE;
530#ifdef GTK3
531 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> color_styles[j], TRUE);
532 set_color_map (view -> color_styles[j], & view -> colorp[j][0]);
533#else
534 gchar * variant = g_strdup_printf ("set-%s.%d.0", (col) ? "pmap" : "amap", j);
535 g_action_group_activate_action ((GActionGroup *)view -> action_group, (col) ? "set-pmap" : "set-amap", g_variant_new_string((const gchar *)variant));
536 g_free (variant);
537#endif
538 reading_input = was_input;
539}
540
553void set_motion (glwin * view, int axis, int da, int db, gboolean UpDown, GdkModifierType state)
554{
555 if (state & GDK_CONTROL_MASK)
556 {
557 if (view -> mode == EDITION)
558 {
559 vec3_t trans;
560 if (axis)
561 {
562 trans = vec3(view -> anim -> last -> img -> p_depth*(double) da / view -> pixels[axis], 0.0, 0.0);
563 }
564 else
565 {
566 trans = vec3(0.0, view -> anim -> last -> img -> p_depth*(double) da / view -> pixels[axis], 0.0);
567 }
568 translate (get_project_by_id(view -> proj), 1, 1, trans);
569 init_default_shaders (view);
570 update (view);
571 }
572 else if (state & GDK_SHIFT_MASK)
573 {
574 spin_go (NULL, & view -> colorp[db][axis]);
575 }
576 else
577 {
578 view -> anim -> last -> img -> c_shift[! axis] += (double) da / view -> pixels[axis];
579 if (view -> camera_widg[! axis + 5])
580 {
581 if (GTK_IS_WIDGET(view -> camera_widg[! axis + 5]))
582 {
583 gtk_spin_button_set_value ((GtkSpinButton *)view -> camera_widg[! axis + 5], - view -> anim -> last -> img -> c_shift[! axis]);
584 }
585 }
586 update (view);
587 }
588 }
589 else if ((state & GDK_SHIFT_MASK) && UpDown)
590 {
591 if (db == 1 && view -> anim -> last -> img -> zoom > ZOOM_MAX) zoom (view, -1);
592 if (db == 3) zoom (view, 1);
593 update (view);
594 }
595 else if (state != GDK_SHIFT_MASK)
596 {
597 save_rotation_quaternion (view);
598 double cameraAngle[2] = {0.0, 0.0};
599 cameraAngle[axis] = 0.5*da;
600 rotate_x_y (view, cameraAngle[0], cameraAngle[1]);
601 update (view);
602 }
603}
604
612mat4_t insert_projection (glwin * view)
613{
614 GLdouble w, h;
615 GLdouble dw, dh;
616 double gleft, gright, gbottom, gtop;
617 double zoom = view -> anim -> last -> img -> zoom;
618 zoom *= (view -> anim -> last -> img -> p_depth / view -> anim -> last -> img -> gnear);
619 dw = view -> anim -> last -> img -> c_shift[0]*2.0*zoom;
620 dh = view -> anim -> last -> img -> c_shift[1]*2.0*zoom;
621 double aspect = (double)view -> pixels[0] / (double)view -> pixels[1];
622 if (aspect > 1.0)
623 {
624 w = zoom * aspect;
625 h = zoom;
626 }
627 else
628 {
629 w = zoom;
630 h = zoom / aspect;
631 }
632 gleft = -w + dw;
633 gright = w + dw;
634 gbottom = -h + dh;
635 gtop = h + dh;
636 return m4_ortho (gleft, gright, gbottom, gtop, -view -> anim -> last -> img -> gfar, view -> anim -> last -> img -> gfar);
637}
638
646vec3_t get_insertion_coordinates (glwin * view)
647{
648 vec3_t pos;
649 mat4_t insert_pmv_matrix;
650 insert_pmv_matrix = m4_mul (insert_projection (view), view -> model_view_matrix);
651 pos = vec3 (view -> mouseX, view -> mouseY, 0.75);
652 return v3_un_project (pos, view -> view_port, insert_pmv_matrix);
653}
654
664void activate_glwin_action (gchar * action_string, gchar * action_name, glwin * view)
665{
666 GVariant * action_state = g_variant_new_string (action_string);
667 g_action_group_activate_action ((GActionGroup *)view -> action_group, action_name, action_state);
668 // g_variant_unref (action_state);
669}
670
680void glwin_key_pressed (guint keyval, GdkModifierType state, gpointer data)
681{
682 glwin * view = (glwin *)data;
683 int i;
684 switch (keyval)
685 {
686 case GDK_KEY_Escape:
687 if (view -> fullscreen)
688 {
689#ifdef GTK4
690 set_full_screen (NULL, NULL, view);
691#else
692 set_full_screen (NULL, view);
693#endif
694 }
695 break;
696 case GDK_KEY_Delete:
697 if (get_project_by_id(view -> proj) -> natomes && ! is_atom_win_active(view) && get_project_by_id(view -> proj) -> steps == 1 && view -> mode == EDITION)
698 {
699 opengl_project_changed (view -> proj);
700 is_selected = 1;
701 selected_aspec = -1;
702#ifdef GTK4
703 remove_the_atoms (NULL, NULL, & cut_sel);
704#else
705 remove_the_atoms (NULL, & cut_sel);
706#endif
707 }
708 break;
709 case GDK_KEY_space:
710 if (get_project_by_id(view -> proj) -> natomes)
711 {
712 if (view -> spin[0] || view -> spin[1])
713 {
714 for (i=0; i<2; i++)
715 {
716 view -> spin[i+2] = view -> spin[i];
717 view -> spin_speed[i+2] = view -> spin_speed[i];
718 view -> spin[i] = FALSE;
719 }
720 }
721 else if (view -> spin[2] || view -> spin[3])
722 {
723 for (i=0; i<2; i++)
724 {
725 view -> spin[i] = view -> spin[i+2];
726 view -> spin_speed[i] = view -> spin_speed[i+2];
727 g_timeout_add (REFRESH, (GSourceFunc) spin, & view -> colorp[0][i]);
728 view -> spin[i+2] = FALSE;
729 view -> spin_speed[i+2] = 0;
730 }
731 }
732 }
733 break;
734 case GDK_KEY_a:
735 if ((state & GDK_CONTROL_MASK) && get_project_by_id(view -> proj) -> natomes)
736 {
737 opengl_project_changed (view -> proj);
738 selected_aspec = -1;
739 i = get_selection_type (view);
740 if (view -> anim -> last -> img -> selected[i] -> selected == opengl_project -> natomes)
741 {
742#ifdef GTK4
743 select_unselect_atoms (NULL, NULL, & view -> colorp[0][0]);
744#else
745 select_unselect_atoms (NULL, & view -> colorp[0][0]);
746#endif
747 }
748 else
749 {
750#ifdef GTK4
751 select_unselect_atoms (NULL, NULL, & view -> colorp[0][1]);
752#else
753 select_unselect_atoms (NULL, & view -> colorp[0][1]);
754#endif
755 }
756 }
757#ifdef GTK4
758 else if (state & GDK_ALT_MASK)
759#else
760 else if (state & GDK_MOD1_MASK)
761#endif
762 {
763 if (view -> mode == EDITION)
764 {
765#ifdef GTK4
766 activate_glwin_action ("set-mouse-mode.0.0", "set-mouse-mode", view);
767#else
768 // GTK3 Menu Action To Check
769 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_mode[0], TRUE);
770 set_mode (view -> ogl_mode[0], & view -> colorp[0][0]);
771#endif
772 }
773 }
774 else if (get_project_by_id(view -> proj) -> natomes)
775 {
776 change_color_map (view, 0);
777 update (view);
778 }
779 break;
780 case GDK_KEY_A:
781 if (get_project_by_id(view -> proj) -> natomes)
782 {
783 // selection mode to coordination sphere
784#ifdef GTK4
785 activate_glwin_action ("set-sel-mode.0.0", "set-sel-mode", view);
786#else
787 // GTK3 Menu Action To Check
788 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_smode[0], TRUE);
789 set_selection_mode (view -> ogl_smode[0], & view -> colorp[0][0]);
790#endif
791 }
792 break;
793 case GDK_KEY_b:
794 if (get_project_by_id(view -> proj) -> natomes)
795 {
796#ifdef GTK4
797 activate_glwin_action ("set-style.0.0", "set-style", view);
798#else
799 // GTK3 Menu Action To Check
800 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_styles[BALL_AND_STICK], TRUE);
801 set_style (view -> ogl_styles[BALL_AND_STICK], & view -> colorp[BALL_AND_STICK][0]);
802#endif
803
804 }
805 break;
806 case GDK_KEY_c:
807 if (get_project_by_id(view -> proj) -> natomes)
808 {
809 if (state & GDK_CONTROL_MASK)
810 {
811 if (view -> anim -> last -> img -> selected[0] -> selected)
812 {
813 opengl_project_changed (view -> proj);
814 selected_aspec = -1;
815 is_selected = 1;
816 view -> nth_copy = 1;
817 view -> insert_coords = get_insertion_coordinates (view);
818#ifdef GTK4
819 copy_the_atoms (NULL, NULL, & cut_sel);
820#else
821 copy_the_atoms (NULL, & cut_sel);
822#endif
823 update_insert_combos ();
824 }
825 else
826 {
827 if (copied_object)
828 {
829 g_free (copied_object);
830 copied_object = NULL;
831 }
832 }
833 }
834 else
835 {
836#ifdef GTK4
837 activate_glwin_action ("set-style.8.0", "set-style", view);
838#else
839 // GTK3 Menu Action To Check
840 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_styles[CYLINDERS], TRUE);
841 set_style (view -> ogl_styles[CYLINDERS], & view -> colorp[CYLINDERS][0]);
842#endif
843 }
844 }
845 break;
846 case GDK_KEY_C:
847 if (get_project_by_id(view -> proj) -> natomes)
848 {
849 // selection mode to coordination sphere
850#ifdef GTK4
851 activate_glwin_action ("set-sel-mode.1.0", "set-sel-mode", view);
852#else
853 // GTK3 Menu Action To Check
854 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_smode[1], TRUE);
855 set_selection_mode (view -> ogl_smode[1], & view -> colorp[1][0]);
856#endif
857 }
858 break;
859 case GDK_KEY_d:
860 if (get_project_by_id(view -> proj) -> natomes)
861 {
862#ifdef GTK4
863 activate_glwin_action ("set-style.9.0", "set-style", view);
864#else
865 // GTK3 Menu Action To Check
866 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_styles[PUNT], TRUE);
867 set_style (view -> ogl_styles[PUNT], & view -> colorp[PUNT][0]);
868#endif
869 }
870 break;
871 case GDK_KEY_e:
872 if (get_project_by_id(view -> proj) -> natomes)
873 {
874 if (state & GDK_CONTROL_MASK)
875 {
876 coord_properties (NULL, & view -> colorp[30][0]);
877 }
878#ifdef GTK4
879 else if (state & GDK_ALT_MASK)
880#else
881 else if (state & GDK_MOD1_MASK)
882#endif
883 {
884 if (view -> mode == ANALYZE && get_project_by_id(view -> proj) -> steps == 1)
885 {
886#ifdef GTK4
887 activate_glwin_action ("set-mouse-mode.1.0", "set-mouse-mode", view);
888#else
889 // GTK3 Menu Action To Check
890 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_mode[1], TRUE);
891 set_mode (view -> ogl_mode[1], & view -> colorp[1][0]);
892#endif
893 }
894 }
895 }
896 break;
897 case GDK_KEY_f:
898#ifdef GTK4
899 if (state & GDK_CONTROL_MASK) set_full_screen (NULL, NULL, view);
900#else
901 if (state & GDK_CONTROL_MASK) set_full_screen (NULL, view);
902#endif
903 break;
904 case GDK_KEY_F:
905 if (get_project_by_id(view -> proj) -> natomes)
906 {
907 // selection mode to coordination sphere
908#ifdef GTK4
909 activate_glwin_action ("set-sel-mode.2.0", "set-sel-mode", view);
910#else
911 // GTK3 Menu Action To Check
912 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_smode[2], TRUE);
913 set_selection_mode (view -> ogl_smode[2], & view -> colorp[2][0]);
914#endif
915 }
916 break;
917 case GDK_KEY_i:
918 if (get_project_by_id(view -> proj) -> natomes)
919 {
920#ifdef GTK4
921 activate_glwin_action ("set-style.3.0", "set-style", view);
922#else
923 // GTK3 Menu Action To Check
924 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> filled_styles[1], TRUE);
925 set_style (view -> filled_styles[1], & view -> colorp[OGL_STYLES+1][0]);
926#endif
927 }
928 break;
929 case GDK_KEY_l:
930 if ((state & GDK_CONTROL_MASK) && get_project_by_id(view -> proj) -> natomes)
931 {
932 opengl_project_changed (view -> proj);
933 selected_aspec = is_selected = -1;
934 if (view -> labelled == opengl_project -> natomes*opengl_project -> steps)
935 {
936#ifdef GTK4
937 label_unlabel_atoms (NULL, NULL, & cut_lab);
938#else
939 label_unlabel_atoms (NULL, & cut_lab);
940#endif
941 }
942 else
943 {
944#ifdef GTK4
945 label_unlabel_atoms (NULL, NULL, & cut_sel);
946#else
947 label_unlabel_atoms (NULL, & cut_sel);
948#endif
949 }
950 }
951 break;
952 case GDK_KEY_m:
953 if (get_project_by_id(view -> proj) -> natomes)
954 {
955 if (state & GDK_CONTROL_MASK)
956 {
957 view -> anim -> last -> img -> m_is_pressed = 0;
958 window_measures (NULL, view);
959 }
960 else if (view -> anim -> last -> img -> m_is_pressed < 2)
961 {
962 view -> anim -> last -> img -> m_is_pressed ++;
963 }
964 else
965 {
966 view -> anim -> last -> img -> m_is_pressed = 0;
967 }
968 view -> create_shaders[MEASU] = TRUE;
969 update (view);
970 }
971 break;
972 case GDK_KEY_M:
973 if (get_project_by_id(view -> proj) -> natomes)
974 {
975 // selection mode to coordination sphere
976#ifdef GTK4
977 activate_glwin_action ("set-sel-mode.3.0", "set-sel-mode", view);
978#else
979 // GTK3 Menu Action To Check
980 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_smode[3], TRUE);
981 set_selection_mode (view -> ogl_smode[3], & view -> colorp[3][0]);
982#endif
983 }
984 break;
985 case GDK_KEY_n:
986 if (state & GDK_CONTROL_MASK) on_create_new_project (NULL, NULL);
987 break;
988 case GDK_KEY_o:
989 if (get_project_by_id(view -> proj) -> natomes)
990 {
991#ifdef GTK4
992 activate_glwin_action ("set-style.2.0", "set-style", view);
993#else
994 // GTK3 Menu Action To Check
995 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> filled_styles[0], TRUE);
996 set_style (view -> filled_styles[0], & view -> colorp[OGL_STYLES][0]);
997#endif
998 }
999 break;
1000 case GDK_KEY_p:
1001 if (get_project_by_id(view -> proj) -> natomes) change_color_map (view, 1);
1002 break;
1003 case GDK_KEY_r:
1004 if (get_project_by_id(view -> proj) -> natomes)
1005 {
1006 if (state & GDK_CONTROL_MASK)
1007 {
1008 window_recorder (NULL, (gpointer)view);
1009 }
1010 else
1011 {
1012#ifdef GTK4
1013 activate_glwin_action ("set-style.5.0", "set-style", view);
1014#else
1015 // GTK3 Menu Action To Check
1016 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> filled_styles[3], TRUE);
1017 set_style (view -> filled_styles[3], & view -> colorp[OGL_STYLES+3][0]);
1018#endif
1019 }
1020 }
1021 break;
1022 if ((state & GDK_CONTROL_MASK) && get_project_by_id(view -> proj) -> natomes) window_recorder (NULL, (gpointer)view);
1023 break;
1024 case GDK_KEY_s:
1025 if (get_project_by_id(view -> proj) -> natomes)
1026 {
1027 if (state & GDK_CONTROL_MASK)
1028 {
1029 spin_stop (NULL, data);
1030 }
1031 else
1032 {
1033#ifdef GTK4
1034 activate_glwin_action ("set-style.7.0", "set-style", view);
1035#else
1036 // GTK3 Menu Action To Check
1037 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_styles[SPHERES], TRUE);
1038 set_style (view -> ogl_styles[SPHERES], & view -> colorp[SPHERES][0]);
1039#endif
1040 }
1041 }
1042 break;
1043 case GDK_KEY_v:
1044 if (state & GDK_CONTROL_MASK)
1045 {
1046 if (copied_object && ! is_atom_win_active(view) && get_project_by_id(view -> proj) -> steps == 1 && view -> mode == EDITION)
1047 {
1048 //i = (! get_project_by_id(view -> proj) -> natomes) ? 1 : 0;
1049 opengl_project_changed (view -> proj);
1050#ifdef GTK4
1051 add_object (NULL, NULL, & view -> colorp[0][0]);
1052#else
1053 add_object (NULL, & view -> colorp[0][0]);
1054#endif
1055 view -> nth_copy ++;
1056 /*if (i)
1057 {
1058 i = activep;
1059 active_project_changed (view -> proj);
1060 frag_update = (active_project -> natomes > ATOM_LIMIT) ? 0 : 1;
1061 mol_update = (frag_update) ? ((active_project -> steps > STEP_LIMIT) ? 0 : 1) : 0;
1062 bonds_update = 1;
1063 on_calc_bonds_released (NULL, NULL);
1064 active_project_changed (i);
1065 }*/
1066 }
1067 }
1068 else if (get_project_by_id(view -> proj) -> natomes)
1069 {
1070#ifdef GTK4
1071 activate_glwin_action ("set-style.4.0", "set-style", view);
1072#else
1073 // GTK3 Menu Action To Check
1074 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> filled_styles[2], TRUE);
1075 set_style (view -> filled_styles[2], & view -> colorp[OGL_STYLES+2][0]);
1076#endif
1077 }
1078 break;
1079 case GDK_KEY_w:
1080 if (get_project_by_id(view -> proj) -> natomes)
1081 {
1082#ifdef GTK4
1083 activate_glwin_action ("set-style.1.0", "set-style", view);
1084#else
1085 // GTK3 Menu Action To Check
1086 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)view -> ogl_styles[WIREFRAME], TRUE);
1087 set_style (view -> ogl_styles[WIREFRAME], & view -> colorp[WIREFRAME][0]);
1088#endif
1089 }
1090 break;
1091 case GDK_KEY_x:
1092 if ((state & GDK_CONTROL_MASK) && get_project_by_id(view -> proj) -> natomes)
1093 {
1094 if (! is_atom_win_active(view) && get_project_by_id(view -> proj) -> steps == 1 && view -> mode == EDITION)
1095 {
1096 if (view -> anim -> last -> img -> selected[0] -> selected)
1097 {
1098 opengl_project_changed (view -> proj);
1099 selected_aspec = -1;
1100 is_selected = 1;
1101#ifdef GTK4
1102 copy_the_atoms (NULL, NULL, & cut_sel);
1103 remove_the_atoms (NULL, NULL, & cut_sel);
1104#else
1105 copy_the_atoms (NULL, & cut_sel);
1106 remove_the_atoms (NULL, & cut_sel);
1107#endif
1108 }
1109 }
1110 }
1111 break;
1112 case GDK_KEY_Right:
1113 if (get_project_by_id(view -> proj) -> natomes) set_motion (view, 1, 1, 1, FALSE, state);
1114 break;
1115 case GDK_KEY_Left:
1116 if (get_project_by_id(view -> proj) -> natomes) set_motion (view, 1, -1, 3, FALSE, state);
1117 break;
1118 case GDK_KEY_Up:
1119 if (get_project_by_id(view -> proj) -> natomes) set_motion (view, 0, 1, 3, TRUE, state);
1120 break;
1121 case GDK_KEY_Down:
1122 if (get_project_by_id(view -> proj) -> natomes) set_motion (view, 0, -1, 1, TRUE, state);
1123 break;
1124 }
1125}
1126
1127#ifdef GTK3
1137G_MODULE_EXPORT gboolean on_key_pressed (GtkWidget * widg, GdkEventKey * event, gpointer data)
1138{
1139 if (event -> type == GDK_KEY_PRESS)
1140 {
1141 glwin_key_pressed (event -> keyval, event -> state, data);
1142 }
1143 return FALSE;
1144}
1145#else
1157G_MODULE_EXPORT gboolean on_glwin_key_pressed (GtkEventControllerKey * self, guint keyval, guint keycode, GdkModifierType state, gpointer data)
1158{
1159 glwin_key_pressed (keyval, state, data);
1160 return TRUE;
1161}
1162#endif
1163
1172G_MODULE_EXPORT void on_win_realize (GtkWidget * widg, gpointer data)
1173{
1174 glwin * view = (glwin *)data;
1175 int * pix = get_project_by_id(view -> proj) -> tmp_pixels;
1176 int shift = 0;
1177 if (GTK_IS_WIDGET(view -> menu_bar)) shift = gtk_widget_get_allocated_height (view -> menu_bar);
1178 if (pix[0] > 0 && pix[1] > 0)
1179 {
1180 resize_this_window (view -> win, pix[0], pix[1]+shift);
1181 pix[0] = pix[1] = -1;
1182 }
1183 else
1184 {
1185 resize_this_window (view -> win, 500, 500);
1186 }
1187}
1188
1189#ifdef GTK3
1190#ifndef G_OS_WIN32
1198void gtk_window_change_gdk_visual (GtkWidget * win)
1199{
1200 // GTK+ > 3.15.1 uses an X11 visual optimized for GTK+'s OpenGL stuff
1201 // since revid dae447728d: https://github.com/GNOME/gtk/commit/dae447728d
1202 // However, in some cases it simply cannot start an OpenGL context.
1203 // This changes to the default X11 visual instead the GTK's default.
1204 GdkScreen * screen = gdk_screen_get_default ();
1205 GList * visuals = gdk_screen_list_visuals (screen);
1206 // printf("n visuals: %u\n", g_list_length(visuals));
1207 GdkX11Screen* x11_screen = GDK_X11_SCREEN (screen);
1208 g_assert (x11_screen != NULL);
1209 Visual * default_xvisual = DefaultVisual (GDK_SCREEN_XDISPLAY(x11_screen), GDK_SCREEN_XNUMBER(x11_screen));
1210 GdkVisual * default_visual = NULL;
1211 // int i = 0;
1212 while (visuals != NULL)
1213 {
1214 GdkVisual * visual = GDK_X11_VISUAL (visuals -> data);
1215 if (default_xvisual -> visualid == gdk_x11_visual_get_xvisual(GDK_X11_VISUAL (visuals -> data)) -> visualid)
1216 {
1217 // printf("Default visual %d\n", i);
1218 default_visual = visual;
1219 }
1220 // i++;
1221 visuals = visuals -> next;
1222 }
1223 gtk_widget_set_visual (win, default_visual);
1224}
1225#endif
1226#endif
1227
1228gboolean create_3d_model (int p, gboolean load)
1229{
1230 project * this_proj = get_project_by_id (p);
1231#ifndef GTKGLAREA
1232 if (! glXQueryExtension (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), NULL, NULL))
1233 {
1234 g_warning ("Sorry OpenGL is not supported !");
1235 return FALSE;
1236 }
1237 else
1238#endif
1239 {
1240 if (this_proj -> modelgl)
1241 {
1242 g_free (this_proj -> modelgl);
1243 this_proj -> modelgl = NULL;
1244 }
1245 this_proj -> modelgl = g_malloc0 (sizeof*this_proj -> modelgl);
1246 this_proj -> modelgl -> init = FALSE;
1247 this_proj -> modelgl -> proj = this_proj -> id;
1248 GtkWidget * gl_vbox;
1249 if (load)
1250 {
1251 gchar * str = g_strdup_printf ("%s - 3D view - [%s mode]", this_proj -> name, mode_name[0]);
1252 this_proj -> modelgl -> win = create_win (str, MainWindow, FALSE, TRUE);
1253#ifdef GTK3
1254#ifdef GTKGLAREA
1255#ifndef G_OS_WIN32
1256 if (! atomes_visual) gtk_window_change_gdk_visual (this_proj -> modelgl -> win);
1257#endif
1258#endif
1259#endif
1260 // this_proj -> modelgl -> accel_group = gtk_accel_group_new ();
1261 // gtk_window_add_accel_group (GTK_WINDOW (this_proj -> modelgl -> win), this_proj -> modelgl -> accel_group);
1262 g_free (str);
1263 gl_vbox = create_vbox (BSEP);
1264 add_container_child (CONTAINER_WIN, this_proj -> modelgl -> win, gl_vbox);
1265 this_proj -> modelgl -> menu_box = create_hbox (0);
1266 add_box_child_start (GTK_ORIENTATION_VERTICAL, gl_vbox, this_proj -> modelgl -> menu_box, FALSE, FALSE, 0);
1267#ifdef GTK3
1268 this_proj -> modelgl -> menu_bar = gtk_menu_bar_new ();
1269 add_box_child_start (GTK_ORIENTATION_HORIZONTAL, this_proj -> modelgl -> menu_box, this_proj -> modelgl -> menu_bar, TRUE, TRUE, 0);
1270#endif
1271 }
1272#ifdef GTKGLAREA
1273 this_proj -> modelgl -> plot = gtk_gl_area_new ();
1274#else
1275 this_proj -> modelgl -> plot = gtk_drawing_area_new ();
1276#endif
1277 gtk_widget_set_size_request (this_proj -> modelgl -> plot, 100, 100);
1278#ifndef GTKGLAREA
1279 gtk_widget_set_double_buffered (this_proj -> modelgl -> plot, FALSE);
1280 this_proj -> modelgl -> glcontext = NULL;
1281#endif
1282 gtk_widget_set_hexpand (this_proj -> modelgl -> plot, TRUE);
1283 gtk_widget_set_vexpand (this_proj -> modelgl -> plot, TRUE);
1284#ifdef GTKGLAREA
1285#ifdef GTK3
1286 gtk_widget_add_events (GTK_WIDGET (this_proj -> modelgl -> plot),
1287 GDK_SCROLL_MASK |
1288 GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
1289 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
1290#endif
1291#else
1292 gtk_widget_add_events (GTK_WIDGET (this_proj -> modelgl -> plot),
1293 GDK_SMOOTH_SCROLL_MASK |
1294 GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
1295 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
1296#endif
1297#ifdef GTK4
1298 if (load)
1299 {
1300 add_widget_gesture_and_key_action (this_proj -> modelgl -> win, NULL, NULL, NULL,
1301 NULL, NULL, NULL,
1302 "glwin-key-pressed", G_CALLBACK(on_glwin_key_pressed), this_proj -> modelgl,
1303 NULL, NULL, NULL,
1304 NULL, NULL, NULL);
1305 add_widget_gesture_and_key_action (this_proj -> modelgl -> plot, "glwin-button-pressed", G_CALLBACK(on_glwin_button_pressed), this_proj -> modelgl,
1306 "glwin-button-released", G_CALLBACK(on_glwin_button_released), this_proj -> modelgl,
1307 NULL, NULL, NULL,
1308 "glwin-pointer-motion", G_CALLBACK(on_glwin_pointer_motion), this_proj -> modelgl,
1309 "glwin-pointer-scroll", G_CALLBACK(on_glwin_pointer_scoll), this_proj -> modelgl);
1310 }
1311 else
1312 {
1313 add_widget_gesture_and_key_action (this_proj -> modelgl -> plot, "glwin-button-pressed", G_CALLBACK(on_lib_button_pressed), this_proj -> modelgl,
1314 "glwin-button-released", G_CALLBACK(on_lib_button_released), this_proj -> modelgl,
1315 NULL, NULL, NULL,
1316 "glwin-pointer-motion", G_CALLBACK(on_glwin_pointer_motion), this_proj -> modelgl,
1317 NULL, NULL, NULL);
1318 }
1319 // add_window_gesture_action (window, "opengl-context-click", "pressed", G_CALLBACK(on_pressed_gl), NULL);
1320#else
1321 g_signal_connect (G_OBJECT (this_proj -> modelgl -> plot), "motion-notify-event", G_CALLBACK(on_motion), this_proj -> modelgl);
1322 g_signal_connect (G_OBJECT (this_proj -> modelgl -> plot), "button-release-event", G_CALLBACK(on_glwin_button_event), this_proj -> modelgl);
1323 if (load)
1324 {
1325 g_signal_connect (G_OBJECT (this_proj -> modelgl -> plot), "button-press-event", G_CALLBACK(on_glwin_button_event), this_proj -> modelgl);
1326 g_signal_connect (G_OBJECT (this_proj -> modelgl -> plot), "scroll-event", G_CALLBACK(on_scrolled), this_proj -> modelgl);
1327 }
1328 else
1329 {
1330 g_signal_connect (G_OBJECT (this_proj -> modelgl -> plot), "button-press-event", G_CALLBACK(on_lib_pressed), this_proj -> modelgl);
1331 }
1332#endif
1333 if (load)
1334 {
1335 add_box_child_start (GTK_ORIENTATION_VERTICAL, gl_vbox, this_proj -> modelgl -> plot, FALSE, TRUE, 0);
1336#ifdef GTK3
1337 g_signal_connect (G_OBJECT (this_proj -> modelgl -> win), "key-press-event", G_CALLBACK(on_key_pressed), this_proj -> modelgl);
1338#endif
1339 g_signal_connect (G_OBJECT (this_proj -> modelgl -> win), "realize", G_CALLBACK(on_win_realize), this_proj -> modelgl);
1340 add_gtk_close_event (this_proj -> modelgl -> win, G_CALLBACK(hide_this_window), NULL);
1341 }
1342 g_signal_connect (G_OBJECT (this_proj -> modelgl -> plot), "realize", G_CALLBACK(on_realize), this_proj -> modelgl);
1343#ifdef GTKGLAREA
1344 g_signal_connect (G_OBJECT (this_proj -> modelgl -> plot), "render", G_CALLBACK(on_expose), this_proj -> modelgl);
1345#else
1346 g_signal_connect (G_OBJECT (this_proj -> modelgl -> plot), "draw", G_CALLBACK(on_expose), this_proj -> modelgl);
1347#endif
1348 return TRUE;
1349 }
1350}
1351
1359void prep_model (int p)
1360{
1361 project * this_proj = get_project_by_id (p);
1362 gboolean rendering = FALSE;
1363 gboolean adv_bonding[2];
1364 if (this_proj -> modelgl == NULL)
1365 {
1366 if (create_3d_model (p, TRUE))
1367 {
1368 /*GtkWidget * dummy = create_menu_item (FALSE, "Dummy");
1369 gtk_menu_shell_append ((GtkMenuShell *)this_proj -> modelgl -> menu_bar, dummy);
1370 show_the_widgets (this_proj -> modelgl -> win);
1371 destroy_this_widget (dummy);*/
1372 show_the_widgets (this_proj -> modelgl -> win);
1373#ifdef GTK3
1374#ifdef GTKGLAREA
1375#ifndef G_OS_WIN32
1376 if (atomes_visual == 0 && ! this_proj -> initgl)
1377 {
1378 this_proj -> modelgl -> plot = destroy_this_widget (this_proj -> modelgl -> plot);
1379 this_proj -> modelgl -> menu_bar = destroy_this_widget (this_proj -> modelgl -> menu_bar);
1380 this_proj -> modelgl -> win = destroy_this_widget (this_proj -> modelgl -> win);
1381 create_3d_model (p, TRUE);
1382 show_the_widgets (this_proj -> modelgl -> win);
1383 }
1384#endif // G_OS_WIN32
1385#endif // GTKGLAREA
1386#endif // GTK3
1387 if (atomes_visual < 0)
1388 {
1389 this_proj -> modelgl -> plot = destroy_this_widget (this_proj -> modelgl -> plot);
1390 this_proj -> modelgl -> menu_bar = destroy_this_widget (this_proj -> modelgl -> menu_bar);
1391 this_proj -> modelgl -> win = destroy_this_widget (this_proj -> modelgl -> win);
1392 }
1393 else
1394 {
1395 rendering = TRUE;
1396 }
1397 }
1398 if (rendering)
1399 {
1400 if (this_proj -> initgl)
1401 {
1402 active_project_changed (p);
1403#ifdef GTK3
1404 // GTK3 Menu Action To Check
1405 active_glwin -> ogl_box_axis[0] = g_malloc0 (OGL_BOX*sizeof*active_glwin -> ogl_box_axis[0]);
1406 active_glwin -> ogl_box_axis[1] = g_malloc0 (OGL_AXIS*sizeof*active_glwin -> ogl_box_axis[1]);
1407#endif
1408 prepare_opengl_menu_bar (active_glwin);
1409 if (reading_input)
1410 {
1411 adv_bonding[0] = (active_project -> natomes > ATOM_LIMIT) ? 0 : tmp_adv_bonding[0];
1412 adv_bonding[1] = (active_project -> steps > STEP_LIMIT) ? 0 : tmp_adv_bonding[1];
1413 frag_update = (active_project -> natomes > ATOM_LIMIT) ? 0 : 1;
1414 mol_update = (frag_update) ? ((active_project -> steps > STEP_LIMIT) ? 0 : 1) : 0;
1415 }
1416 else
1417 {
1418 frag_update = (force_mol) ? 1 : (active_project -> natomes > ATOM_LIMIT) ? 0 : 1;
1419 mol_update = (force_mol) ? 1 : (frag_update) ? ((active_project -> steps > STEP_LIMIT) ? 0 : 1) : 0;
1420 adv_bonding[0] = adv_bonding[1] = TRUE;
1421 }
1422 if (active_project -> natomes && adv_bonding[0] && adv_bonding[1])
1423 {
1424 bonds_update = 1;
1425 active_project -> runc[0] = FALSE;
1426 on_calc_bonds_released (NULL, NULL);
1427 }
1428 }
1429 }
1430 }
1431 else
1432 {
1433 if (gtk_widget_get_visible(this_proj -> modelgl -> win))
1434 {
1435 gtk_widget_hide (this_proj -> modelgl -> win);
1436 }
1437 else
1438 {
1439 gtk_widget_show (this_proj -> modelgl -> win);
1440 }
1441 }
1442}
action_name
gchar * action_name[5]
Definition atom_edit.c:60
coord_menu
GtkWidget * coord_menu(glwin *view)
restore_color_map
void restore_color_map(glwin *view, int *colm)
restore saved color maps
Definition bdcall.c:93
save_color_map
int * save_color_map(glwin *view)
save atoms and polyhedra color maps
Definition bdcall.c:77
force_mol
gboolean force_mol
Definition calc.c:71
calc.h
Variable declarations for the MD input preparation assistants.
axis
gchar * axis[3]
Definition w_axis.c:65
chains
integer function chains()
Definition chains.F90:54
update_insert_combos
void update_insert_combos()
update some GtkComboBox in the workspace if a project is removed
Definition close_p.c:60
color_box.h
Structure definitions for color management Function declarations for color management.
colorp
color colorp[64]
col
ColRGBA col
Definition d_measures.c:77
shift
int * shift
Definition d_measures.c:72
init_default_shaders
void init_default_shaders(glwin *view)
re-initialize the default OpenGL shaders
Definition ogl_shading.c:729
rep
dint rep
Definition dlp_edit.c:2239
reading_input
gboolean reading_input
Definition global.c:182
mol_update
int mol_update
Definition global.c:171
tmp_adv_bonding
gboolean tmp_adv_bonding[2]
Definition global.c:183
frag_update
int frag_update
Definition global.c:170
MainWindow
GtkWidget * MainWindow
Definition global.c:214
bonds_update
int bonds_update
Definition global.c:169
mode_name
gchar * mode_name[2]
Definition global.c:137
atomes_visual
int atomes_visual
Definition global.c:165
pop
GtkWidget * pop
Definition global.c:217
tmp_pixels
int tmp_pixels[2]
Definition global.c:173
global.h
Global variable declarations Global convenience function declarations Global data structure defin...
IMG_NONE
@ IMG_NONE
Definition global.h:232
IMG_STOCK
@ IMG_STOCK
Definition global.h:236
IMG_FILE
@ IMG_FILE
Definition global.h:235
active_glwin
glwin * active_glwin
Definition project.c:53
update_chains_menus
void update_chains_menus(glwin *view)
ATOM_LIMIT
#define ATOM_LIMIT
Atom number limit to compute fragment(s) and molecule(s) analysis automatically.
FITBEST
#define FITBEST
Definition global.h:171
cut_lab
tint cut_lab
Definition gui.c:130
gtk3_menu_item
GtkWidget * gtk3_menu_item(GtkWidget *menu, gchar *name, int icon_format, gpointer item_icon, GCallback handler, gpointer data, gboolean accel, guint key, GdkModifierType mod, gboolean check, gboolean radio, gboolean status)
is_atom_win_active
gboolean is_atom_win_active(glwin *view)
is the model edition window visible ?
Definition atom_edit.c:71
resize_this_window
void resize_this_window(GtkWidget *window, int x, int y)
resize this GtkWindow
Definition gtk-misc.c:561
create_win
GtkWidget * create_win(gchar *str, GtkWidget *parent, gboolean modal, gboolean resiz)
create a new GtkWindow
Definition gtk-misc.c:425
active_cell
cell_info * active_cell
Definition project.c:50
proj
project * proj
BSEP
#define BSEP
Definition global.h:217
opengl_project_changed
void opengl_project_changed(int id)
change the OpenGL project
Definition update_p.c:245
hide_this_window
G_MODULE_EXPORT gboolean hide_this_window(GtkWidget *win, GdkEvent *event, gpointer data)
hide a GtkWindow
Definition gtk-misc.c:2347
add_gtk_close_event
void add_gtk_close_event(GtkWidget *widg, GCallback handler, gpointer data)
add a close event signal and callback to a GtkWidget
Definition gtk-misc.c:2363
STEP_LIMIT
#define STEP_LIMIT
Definition global.h:249
on_calc_bonds_released
G_MODULE_EXPORT void on_calc_bonds_released(GtkWidget *widg, gpointer data)
compute bonding properties
Definition bdcall.c:471
CONTAINER_WIN
@ CONTAINER_WIN
Definition global.h:222
opengl_project
project * opengl_project
Definition project.c:54
add_box_child_start
void add_box_child_start(int orientation, GtkWidget *widg, GtkWidget *child, gboolean expand, gboolean fill, int padding)
Add a GtkWidget in a GtkBox at the initial position.
Definition gtk-misc.c:279
widget_set_sensitive
void widget_set_sensitive(GtkWidget *widg, gboolean sensitive)
Set sensitivity for a GtkWidget, ensuring it is a GtkWidget.
Definition gtk-misc.c:186
create_hbox
GtkWidget * create_hbox(int spacing)
create a GtkBox with horizontal orientation
Definition gtk-misc.c:793
FULLSCREEN
#define FULLSCREEN
Definition global.h:170
create_menu_item
GtkWidget * create_menu_item(gboolean add_mnemo, gchar *action)
destroy_this_widget
GtkWidget * destroy_this_widget(GtkWidget *widg)
destroy a GtkWidget
Definition gtk-misc.c:2010
cut_sel
tint cut_sel
Definition gui.c:129
add_container_child
void add_container_child(int type, GtkWidget *widg, GtkWidget *child)
Add a GtkWidget into another GtkWidget.
Definition gtk-misc.c:206
add_menu_separator
void add_menu_separator(GtkWidget *menu)
menu_item_new_with_submenu
GtkWidget * menu_item_new_with_submenu(gchar *name, gboolean active, GtkWidget *sub_menu)
create_vbox
GtkWidget * create_vbox(int spacing)
create a GtkBox with vertical orientation
Definition gtk-misc.c:781
active_project
project * active_project
Definition project.c:47
update_rings_menus
void update_rings_menus(glwin *view)
show_the_widgets
void show_the_widgets(GtkWidget *widg)
show GtkWidget
Definition gtk-misc.c:169
get_project_by_id
project * get_project_by_id(int p)
get project pointer using id number
Definition project.c:120
on_realize
G_MODULE_EXPORT void on_realize(GtkWidget *widg, gpointer data)
realize event for the OpenGL widget
Definition glview.c:1733
on_glwin_pointer_motion
G_MODULE_EXPORT void on_glwin_pointer_motion(GtkEventControllerMotion *motc, gdouble x, gdouble y, gpointer data)
handle mouse motion event in the OpenGL window GTK4
Definition glview.c:724
update
void update(glwin *view)
update the rendering of the OpenGL window
Definition glview.c:439
on_lib_button_released
G_MODULE_EXPORT void on_lib_button_released(GtkGesture *gesture, int n_press, double x, double y, gpointer data)
handle mouse button release event on the molecular library OpenGL window (limited interaction)
Definition glview.c:867
zoom
void zoom(glwin *view, int delta)
zoom in or zoom out in the OpenGL window
Definition glview.c:1003
on_lib_button_pressed
G_MODULE_EXPORT void on_lib_button_pressed(GtkGesture *gesture, int n_press, double x, double y, gpointer data)
handle mouse button press event on the molecular library OpenGL window (limited interaction)
Definition glview.c:851
on_glwin_button_released
G_MODULE_EXPORT void on_glwin_button_released(GtkGesture *gesture, int n_press, double x, double y, gpointer data)
mouse button released signal on the OpenGL window
Definition glview.c:988
on_glwin_button_pressed
G_MODULE_EXPORT void on_glwin_button_pressed(GtkGesture *gesture, int n_press, double x, double y, gpointer data)
mouse button pressed signal on the OpenGL window
Definition glview.c:972
on_glwin_pointer_scoll
G_MODULE_EXPORT gboolean on_glwin_pointer_scoll(GtkEventControllerScroll *event, gdouble dx, gdouble dy, gpointer data)
handle mouse scroll event on the OpenGL window
Definition glview.c:1052
on_expose
G_MODULE_EXPORT gboolean on_expose(GtkWidget *widg, cairo_t *cr, gpointer data)
OpenGL rendering widget expose event callback GTK3.
Definition glview.c:1805
glview.h
Variable declarations related to the OpenGL window Function declarations related to the OpenGL wind...
plot
image * plot
Definition ogl_draw.c:66
ZOOM_MAX
#define ZOOM_MAX
Maximum value for the OpenGL zoom factor.
Definition glview.h:125
CUSTOM
@ CUSTOM
Definition glview.h:210
to_center_this_molecule
G_MODULE_EXPORT void to_center_this_molecule(GtkWidget *widg, gpointer data)
center this molecule menu item callback GTK4
Definition popup.c:3975
action
action
Definition glview.h:189
REFRESH
#define REFRESH
Refresh time for spinning the OpenGL window in milliseconds.
Definition glview.h:130
ANALYZE
@ ANALYZE
Definition glview.h:157
EDITION
@ EDITION
Definition glview.h:158
render
render
Definition glview.h:182
FILL
@ FILL
Definition glview.h:183
DEFAULT_STYLE
#define DEFAULT_STYLE
Default OpenGL style: ball and stick.
Definition glview.h:43
SPHERES
@ SPHERES
Definition glview.h:176
SPACEFILL
@ SPACEFILL
Definition glview.h:175
BALL_AND_STICK
@ BALL_AND_STICK
Definition glview.h:173
CYLINDERS
@ CYLINDERS
Definition glview.h:177
WIREFRAME
@ WIREFRAME
Definition glview.h:174
NONE
@ NONE
Definition glview.h:172
PUNT
@ PUNT
Definition glview.h:178
OGL_COORDS
#define OGL_COORDS
Definition glwin.h:63
OGL_BOX
#define OGL_BOX
Definition glwin.h:58
OGL_STYLES
#define OGL_STYLES
Definition glwin.h:106
MEASU
@ MEASU
Definition glwin.h:99
OGL_AXIS
#define OGL_AXIS
Definition glwin.h:59
ATOM_MAPS
#define ATOM_MAPS
Definition glwin.h:61
activate_glwin_action
void activate_glwin_action(gchar *action_string, gchar *action_name, glwin *view)
the keyboard shortcut actions for the OpenGL window
Definition glwindow.c:664
set_sensitive_coord_menu
void set_sensitive_coord_menu(glwin *view, gboolean status)
glwin_key_pressed
void glwin_key_pressed(guint keyval, GdkModifierType state, gpointer data)
the keyboard shortcut actions for the OpenGL window
Definition glwindow.c:680
set_color_map_sensitive
void set_color_map_sensitive(glwin *view)
window_encode
void window_encode(glwin *view, gboolean video)
encoding a movie - creating the dialog
Definition w_encode.c:319
coord_properties
G_MODULE_EXPORT void coord_properties(GtkWidget *widg, gpointer data)
create the environments configuration window
Definition w_coord.c:1483
set_style
G_MODULE_EXPORT void set_style(GtkWidget *widg, gpointer data)
set style callback
Definition m_style.c:171
get_selection_type
int get_selection_type(glwin *view)
get selection type
Definition w_measures.c:83
save_rotation_quaternion
void save_rotation_quaternion(glwin *view)
save the rotation quaternion of the last image
Definition glview.c:537
set_selection_mode
G_MODULE_EXPORT void set_selection_mode(GtkWidget *widg, gpointer data)
set selection mode callback
Definition m_tools.c:133
is_labelled
int is_labelled
Definition popup.c:182
update_all_menus
void update_all_menus(glwin *view, int nats)
update all menus of the OpenGL window
Definition glwindow.c:239
prep_model
void prep_model(int p)
prepare, or display, the OpenGL model window
Definition glwindow.c:1359
opengl_advanced
G_MODULE_EXPORT void opengl_advanced(GtkWidget *widg, gpointer data)
create OpenGL rendering advanced window
Definition w_advance.c:1477
on_glwin_key_pressed
G_MODULE_EXPORT gboolean on_glwin_key_pressed(GtkEventControllerKey *self, guint keyval, guint keycode, GdkModifierType state, gpointer data)
keyboard key press event for the OpenGL window GTK4
Definition glwindow.c:1157
spin_go
G_MODULE_EXPORT void spin_go(GtkWidget *widg, gpointer data)
update_menus
void update_menus(glwin *view)
set_box_axis_style
G_MODULE_EXPORT void set_box_axis_style(GtkWidget *widg, gpointer data)
on_win_realize
G_MODULE_EXPORT void on_win_realize(GtkWidget *widg, gpointer data)
realize event for the OpenGL window
Definition glwindow.c:1172
set_render
G_MODULE_EXPORT void set_render(GtkWidget *widg, gpointer data)
set OpenGL rendering mode callback
Definition m_render.c:56
is_selected
int is_selected
Definition popup.c:181
set_full_screen
G_MODULE_EXPORT void set_full_screen(GtkWidget *widg, gpointer data)
set full screen callback GTK3
Definition popup.c:228
add_object
G_MODULE_EXPORT void add_object(GtkWidget *widg, gpointer data)
add object call back GTK3
Definition popup.c:712
prep_all_coord_menus
void prep_all_coord_menus(glwin *view)
copy_the_atoms
G_MODULE_EXPORT void copy_the_atoms(GtkWidget *widg, gpointer data)
copy selected atom(s) callback GTK3
Definition popup.c:1354
prepare_opengl_menu_bar
void prepare_opengl_menu_bar(glwin *view)
update the OpenGL window menu bar
Definition glwindow.c:457
label_unlabel_atoms
G_MODULE_EXPORT void label_unlabel_atoms(GtkWidget *widg, gpointer data)
label / unlabel a type of atom(s) callback GTK3
Definition popup.c:1502
window_recorder
G_MODULE_EXPORT void window_recorder(GtkWidget *widg, gpointer data)
create video recorder window
Definition w_record.c:152
translate
void translate(project *this_proj, int status, int axis, vec3_t trans)
translate
Definition atom_move.c:230
spin
gboolean spin(gpointer data)
spin
Definition w_spiner.c:56
action_atoms
gchar * action_atoms[3]
Definition atom_edit.c:61
menupoly
GtkWidget * menupoly(glwin *view, int jd, int id, gchar *poln)
select_unselect_atoms
G_MODULE_EXPORT void select_unselect_atoms(GtkWidget *widg, gpointer data)
select / unselect a type of atom(s) callback GTK3
Definition popup.c:1550
change_color_map
void change_color_map(glwin *view, int col)
change atom / polyhedra color map
Definition glwindow.c:496
create_3d_model
gboolean create_3d_model(int p, gboolean load)
Definition glwindow.c:1228
to_reset_view
G_MODULE_EXPORT void to_reset_view(GtkWidget *widg, gpointer data)
reset view callback - GTK3
Definition m_rep.c:200
window_measures
G_MODULE_EXPORT void window_measures(GtkWidget *widg, gpointer data)
create the measurements window
Definition w_measures.c:738
render_gl_image
G_MODULE_EXPORT void render_gl_image(GtkWidget *widg, gpointer data)
render image from the OpenGL window
Definition glwindow.c:331
set_mode
G_MODULE_EXPORT void set_mode(GtkWidget *widg, gpointer data)
set mouse mode callback
Definition m_tools.c:172
get_insertion_coordinates
vec3_t get_insertion_coordinates(glwin *view)
get the insertion coordinates to insert object in the 3D window
Definition glwindow.c:646
selected_aspec
int selected_aspec
Definition popup.c:179
set_color_map
G_MODULE_EXPORT void set_color_map(GtkWidget *widg, gpointer data)
set color map callback
Definition m_map.c:1011
on_create_new_project
G_MODULE_EXPORT void on_create_new_project(GtkWidget *widg, gpointer data)
create a new project
Definition work_menu.c:62
rotate_x_y
void rotate_x_y(glwin *view, double angle_x, double angle_y)
rotate the OpenGL camera
Definition glview.c:1078
edit_in_new_project
G_MODULE_EXPORT void edit_in_new_project(GtkWidget *widg, gpointer data)
create new project using selection callback GTK3
Definition popup.c:2193
spin_stop
G_MODULE_EXPORT void spin_stop(GtkButton *but, gpointer data)
stop spin
Definition w_spiner.c:138
copied_object
atomic_object * copied_object
Definition glwindow.c:121
set_motion
void set_motion(glwin *view, int axis, int da, int db, gboolean UpDown, GdkModifierType state)
handle keyboard motion event on the OpenGL window
Definition glwindow.c:553
insert_projection
mat4_t insert_projection(glwin *view)
calculate the insertion projection matrix to insert object in the 3D window
Definition glwindow.c:612
remove_the_atoms
G_MODULE_EXPORT void remove_the_atoms(GtkWidget *widg, gpointer data)
remove selected atom(s) callback GTK3
Definition popup.c:1296
glcontext
GLXContext glcontext
initcoord.h
Function declarations to handle the atomic coordination data.
set_advanced_bonding_menus
void set_advanced_bonding_menus(glwin *view)
menu_anim
GMenu * menu_anim(glwin *view, int popm)
create the 'Animate' submenu elements
Definition m_anim.c:139
menu_atoms
GMenu * menu_atoms(glwin *view, int popm, int at)
create the 'Atom(s)' submenu elements
Definition m_atoms.c:797
menu_back
GMenu * menu_back(glwin *view, int popm)
create the background color menu item GTK4
Definition m_back.c:68
menu_bonds
GMenu * menu_bonds(glwin *view, int popm, int at)
create the 'Bond(s)' submenu GTK4
Definition m_bonds.c:367
menu_box_axis
GMenuItem * menu_box_axis(glwin *view, int popm, int ab)
create the 'Model -> Box' and 'View -> Axis' submenus GTK4
Definition m_box.c:470
menu_clones
GMenu * menu_clones(glwin *view, int popm)
create the 'Clone(s)' submenu GTK4
Definition m_clones.c:180
menu_coord
GMenu * menu_coord(glwin *view, int popm)
create the 'Coordination' submenu GTK4
Definition m_coord.c:689
menu_rings
GMenu * menu_rings(glwin *view, int popm)
create the 'Ring(s)' submenu GTK4
Definition m_coord.c:705
add_menu_coord
GMenu * add_menu_coord(glwin *view, int popm, int id)
create a coordination type submenu
Definition m_coord.c:652
menu_map
GMenu * menu_map(glwin *view, int popm)
create the 'OpenGL -> Color Scheme(s)' submenu - GTK4
Definition m_map.c:1272
cloned_poly
G_MODULE_EXPORT void cloned_poly(GtkWidget *widg, gpointer data)
cloned polyehdra callback - GTK3
Definition m_poly.c:181
menu_poly
GMenu * menu_poly(glwin *view, int popm)
create the 'Chemistry -> Polyehdra' submenu - GTK4
Definition m_poly.c:490
menu_proj
GMenu * menu_proj(glwin *view, int popm)
create the 'View -> Projection' submenu - GTK4
Definition m_proj.c:164
menu_quality
GMenu * menu_quality(glwin *view, int popm)
create the 'OpenGL -> Quality' menu item - GTK4
Definition m_quality.c:167
menu_render
GMenu * menu_render(glwin *view, int popm)
create the 'OpenGL -> Render' submenu - GTK4
Definition m_render.c:182
menu_rep
GMenu * menu_rep(glwin *view, int popm)
create 'View -> Representation' submenu items - GTK4
Definition m_rep.c:513
menu_view
GMenu * menu_view(glwin *view, int popm)
create the 'View' submenu - GTK4
Definition m_rep.c:579
menu_style
GMenu * menu_style(glwin *view, int popm)
create the 'OpenGL -> Style' submenu - GTK4
Definition m_style.c:433
menu_tools
GMenu * menu_tools(glwin *view, int popm)
create the 'Tools' submenu - GTK4
Definition m_tools.c:770
project.h
Function declarations for reading atomes project file Function declarations for saving atomes proje...
active_project_changed
void active_project_changed(int id)
change the active project
Definition update_p.c:175
prep_rings_menu
GtkWidget * prep_rings_menu(glwin *view, int id)
atomic_object
Definition glwin.h:566
glwin
Definition glwin.h:875
vec3_t
Definition math_3d.h:130
submenus.h
Function declarations for the creation of the OpenGL window menus.
menu_items_view
void menu_items_view(GMenu *menu, glwin *view, int popm)
mat4_t
Definition math_3d.h:200
status
int status
Definition w_advance.c:160
pix
GdkPixbuf * pix
Definition workspace.c:69
img
GtkWidget * img
Definition workspace.c:70