atomes 1.1.14
atomes: an atomic scale modeling tool box
Loading...
Searching...
No Matches
m_box.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: 'm_box.c'
24*
25* Contains:
26*
27
28 - The functions to create the 'Model -> Box' submenu
29
30*
31* List of functions:
32
33 G_MODULE_EXPORT void set_box_axis_style (GtkWidget * widg, gpointer data);
34 G_MODULE_EXPORT void show_hide_box_axis (GSimpleAction * action, GVariant * parameter, gpointer data);
35 G_MODULE_EXPORT void change_box_axis_radio (GSimpleAction * action, GVariant * parameter, gpointer data);
36
37 GtkWidget * create_box_axis_menu (char * name, int val, int box, GtkWidget * menu, tint * data);
38 GtkWidget * create_color_widget (GtkWidget * widg, glwin * view, int va);
39 GtkWidget * create_layout_widget (gchar * str, GtkWidget * menu, int vab, gpointer data);
40 GtkWidget * menu_box_axis (glwin * view, int id, int ab);
41
42 GMenuItem * menu_box_axis (glwin * view, int popm, int ab);
43
44 GMenu * axis_box_style (glwin * view, int popm, int ab, int abs);
45 GMenu * axis_box_param (glwin * view, int popm, int ab, int style);
46 GMenuItem * menu_box_axis (glwin * view, int popm, int ab);
47
48*/
49
50#include "global.h"
51#include "glview.h"
52#include "glwindow.h"
53#include "color_box.h"
54#include "submenus.h"
55
56#ifdef GTK4
57G_MODULE_EXPORT void box_advanced (GSimpleAction * action, GVariant * parameter, gpointer data);
58extern G_MODULE_EXPORT void window_bonds (GSimpleAction * action, GVariant * parameter, gpointer data);
59#else
60G_MODULE_EXPORT void box_advanced (GtkWidget * widg, gpointer data);
61extern G_MODULE_EXPORT void window_bonds (GtkWidget * widg, gpointer data);
62extern G_MODULE_EXPORT void window_lines (GtkWidget * widg, gpointer data);
63#endif
64
65#ifdef GTK3
66// GTK3 Menu Action To Check
75G_MODULE_EXPORT void set_box_axis_style (GtkWidget * widg, gpointer data)
76{
77 tint * the_data = (tint *)data;
78 int j, k, o;
79 j = the_data -> b;
80 o = the_data -> c;
81 project * this_proj = get_project_by_id(the_data -> a);
82 k = this_proj -> modelgl -> anim -> last -> img -> box_axis[o];
83 int dim[2]={OGL_BOX, OGL_AXIS};
84 int i, m, l;
85 l = (k == NONE) ? 2 : (j == WIREFRAME) ? 2 : 1;
86 m = (k == NONE) ? 0 : (j == WIREFRAME) ? 1 : 2;
87 if (k != j && gtk_check_menu_item_get_active ((GtkCheckMenuItem *)widg))
88 {
89 this_proj -> modelgl -> anim -> last -> img -> box_axis[o] = NONE - 1;
90 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)this_proj -> modelgl -> ogl_box_axis[o][l], FALSE);
91 gtk_widget_show (this_proj -> modelgl -> ogl_box_axis[o][3+2*(m-1)]);
92 gtk_widget_hide (this_proj -> modelgl -> ogl_box_axis[o][3+2*(l-1)]);
93 if (widg != this_proj -> modelgl -> ogl_box_axis[o][(k == NONE) ? 1 : m])
94 {
95 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)this_proj -> modelgl -> ogl_box_axis[o][(k == NONE) ? 1 : m], TRUE);
96 }
97 for (i=1; i<dim[o]; i++) widget_set_sensitive (this_proj -> modelgl -> ogl_box_axis[o][i], 1);
98 this_proj -> modelgl -> anim -> last -> img -> box_axis[o] = (k == NONE) ? WIREFRAME : j;
99 }
100 else if (k == j && ! gtk_check_menu_item_get_active ((GtkCheckMenuItem *)widg))
101 {
102 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)this_proj -> modelgl -> ogl_box_axis[o][(k == NONE) ? 1 : m], TRUE);
103 }
104 else if (j == 0)
105 {
106 for (i=1; i<3; i++)
107 {
108 gtk_check_menu_item_set_active ((GtkCheckMenuItem *)this_proj -> modelgl -> ogl_box_axis[o][i], FALSE);
109 widget_set_sensitive (this_proj -> modelgl -> ogl_box_axis[o][i], 0);
110 widget_set_sensitive (this_proj -> modelgl -> ogl_box_axis[o][i], 0);
111 }
112 widget_set_sensitive (this_proj -> modelgl -> ogl_box_axis[o][4], 0);
113 for (i=6; i<dim[o]; i++)
114 {
115 widget_set_sensitive (this_proj -> modelgl -> ogl_box_axis[o][i], 0);
116 }
117 if (widg != this_proj -> modelgl -> ogl_box_axis[o][0]) gtk_check_menu_item_set_active ((GtkCheckMenuItem *)this_proj -> modelgl -> ogl_box_axis[o][0], FALSE);
118 this_proj -> modelgl -> anim -> last -> img -> box_axis[o] = NONE;
119 }
120 this_proj -> modelgl -> create_shaders[o+MDBOX] = TRUE;
121 update (this_proj -> modelgl);
122}
123
135GtkWidget * create_box_axis_menu (char * name, int val, int box, GtkWidget * menu, tint * data)
136{
137 GtkWidget * box_widget = gtk3_menu_item (menu, name, IMG_NONE, NULL, G_CALLBACK(set_box_axis_style), data,
138 FALSE, 0, 0, TRUE, (data -> b != 0) ? TRUE : FALSE, (box == val && val != NONE) ? TRUE : FALSE);
139 if (data -> b != 0)
140 {
141 if (val == NONE)
142 {
143 widget_set_sensitive (box_widget, 0);
144 }
145 }
146 return box_widget;
147}
148
158GtkWidget * create_color_widget (GtkWidget * widg, glwin * view, int va)
159{
160 GtkWidget * color_widget = color_box(view, -1, 0, 0);
161 gtk_menu_item_set_submenu ((GtkMenuItem *)widg, color_widget);
162 if (va == NONE)
163 {
164 widget_set_sensitive (color_widget, 0);
165 }
166 return color_widget;
167}
168
179GtkWidget * create_layout_widget (gchar * str, GtkWidget * menu, int vab, gpointer data)
180{
181 GtkWidget * layout = create_menu_item (TRUE, str);
182 gtk_menu_shell_append ((GtkMenuShell *)menu, layout);
183 g_signal_connect (G_OBJECT (layout), "activate", G_CALLBACK(window_bonds), data);
184 if (vab == NONE) widget_set_sensitive (layout, 0);
185 return layout;
186}
187
197GtkWidget * menu_box_axis (glwin * view, int id, int ab)
198{
199 GtkWidget * widg;
200 gchar * menu_title[2]={"Box", "Axis"};
201 GtkWidget * ab_menu;
202 GtkWidget * menu_ab = gtk_menu_new ();
203 if (id == 0 && ab == 0)
204 {
205 view -> ogl_box[0] = create_menu_item (TRUE, menu_title[ab]);
206 gtk_menu_item_set_submenu ((GtkMenuItem *)view -> ogl_box[0], menu_ab);
207 widget_set_sensitive (view -> ogl_box[0], get_project_by_id(view -> proj) -> cell.ltype);
208 }
209 else
210 {
211 ab_menu = create_menu_item (TRUE, menu_title[ab]);
212 gtk_menu_item_set_submenu ((GtkMenuItem *)ab_menu, menu_ab);
213 if (ab == 0) widget_set_sensitive (ab_menu, get_project_by_id(view -> proj) -> cell.ltype);
214 }
215
216 GtkWidget * menul;
217 int i = view -> anim -> last -> img -> box_axis[ab];
218 if (id == 0)
219 {
220 view -> ogl_box_axis[ab][0] = create_box_axis_menu ("Show/_Hide", i, i, menu_ab, & view -> colorp[0][ab]);
221 }
222 else
223 {
224 widg = create_box_axis_menu ("Show/Hide", i, i, menu_ab, & view -> colorp[0][ab]);
225 }
226 widg = create_menu_item (FALSE, "Style");
227 gtk_menu_shell_append ((GtkMenuShell *)menu_ab, widg);
228 GtkWidget * menus = gtk_menu_new ();
229 gtk_menu_item_set_submenu ((GtkMenuItem *)widg, menus);
230 gchar * str;
231 str = g_strdup_printf ("Width [ %f pts ]", view -> anim -> last -> img -> box_axis_line[ab]);
232 if (id == 0)
233 {
234 view -> ogl_box_axis[ab][1] = create_box_axis_menu (text_styles[1], i, 1, menus, & view -> colorp[1][ab]);
235 view -> ogl_box_axis[ab][2] = create_box_axis_menu (text_styles[4], i, 4, menus, & view -> colorp[4][ab]);
236 view -> ogl_box_axis[ab][3] = create_menu_item (TRUE, "_Lines");
237 gtk_menu_shell_append ((GtkMenuShell *)menu_ab, view -> ogl_box_axis[ab][3]);
238 menul = gtk_menu_new ();
239 gtk_menu_item_set_submenu ((GtkMenuItem *)view -> ogl_box_axis[ab][3], menul);
240 view -> ogl_box_axis[ab][4] = create_layout_widget (str, menul, view -> anim -> last -> img -> box_axis[ab], & view -> colorp[WIREFRAME][ab]);
241 }
242 else
243 {
244 create_box_axis_menu (text_styles[1], i, 1, menus, & view -> colorp[1][ab]);
245 create_box_axis_menu (text_styles[4], i, 4, menus, & view -> colorp[4][ab]);
246 if (i == WIREFRAME)
247 {
248 widg = create_menu_item (FALSE, "Lines");
249 gtk_menu_shell_append ((GtkMenuShell *)menu_ab, widg);
250 menul = gtk_menu_new ();
251 gtk_menu_item_set_submenu ((GtkMenuItem *)widg, menul);
252 widg = create_layout_widget (str, menul, view -> anim -> last -> img -> box_axis[ab], & view -> colorp[WIREFRAME][ab]);
253 }
254 }
255 g_free (str);
256
257 str = g_strdup_printf ("Radius [ %f Å ]", view -> anim -> last -> img -> box_axis_rad[ab]);
258 if (id == 0)
259 {
260 view -> ogl_box_axis[ab][5] = create_menu_item (FALSE, "Cylinders");
261 gtk_menu_shell_append ((GtkMenuShell *)menu_ab, view -> ogl_box_axis[ab][5]);
262 menul = gtk_menu_new ();
263 gtk_menu_item_set_submenu ((GtkMenuItem *)view -> ogl_box_axis[ab][5], menul);
264 view -> ogl_box_axis[ab][6] = create_layout_widget (str, menul, view -> anim -> last -> img -> box_axis[ab], & view -> colorp[CYLINDERS][ab]);
265 }
266 else if (i == CYLINDERS)
267 {
268 widg = create_menu_item (FALSE, "Cylinders");
269 gtk_menu_shell_append ((GtkMenuShell *)menu_ab, widg);
270 menul = gtk_menu_new ();
271 gtk_menu_item_set_submenu ((GtkMenuItem *)widg, menul);
272 widg = create_layout_widget (str, menul, view -> anim -> last -> img -> box_axis[ab], & view -> colorp[CYLINDERS][ab]);
273 }
274 g_free (str);
275
276 if (ab == 0)
277 {
278 widg = create_menu_item (FALSE, "Color");
279 gtk_menu_shell_append ((GtkMenuShell *)menu_ab, widg);
280 if (id == 0)
281 {
282 view -> ogl_box_axis[ab][7] = create_color_widget (widg, view, i);
283 }
284 else
285 {
286 widg = create_color_widget (widg, view, i);
287 }
288 add_advanced_item (menu_ab, G_CALLBACK(box_advanced), (gpointer)view, FALSE, 0, 0);
289 }
290 else
291 {
292 menu_axis (menu_ab, view, id);
293 }
294
295 if (id == 0 && ab == 0)
296 {
297 return view -> ogl_box[0];
298 }
299 else
300 {
301 return ab_menu;
302 }
303}
304#else
314G_MODULE_EXPORT void show_hide_box_axis (GSimpleAction * action, GVariant * parameter, gpointer data)
315{
316 tint * the_data = (tint *)data;
317 glwin * view = get_project_by_id(the_data -> a) -> modelgl;
318 const gchar * name = g_action_get_name ((GAction *)action);
319 int lgt = strlen (name);
320 gchar * str = g_strdup_printf ("%c%c", name[lgt-2], name[lgt-1]);
321 if (g_strcmp0(str, ".1") == 0)
322 {
323 g_free (str);
324 str = g_strdup_printf ("%.*s.0.0", lgt-4, name);
325 g_action_group_activate_action ((GActionGroup *)view -> action_group, (const gchar *)str, NULL);
326 g_free (str);
327 }
328 else
329 {
330 GVariant * state;
331 gboolean show;
332 state = g_action_get_state (G_ACTION (action));
333 show = ! g_variant_get_boolean (state);
334 if (show)
335 {
336 view -> anim -> last -> img -> box_axis[the_data -> c] = WIREFRAME;
337 }
338 else
339 {
340 view -> anim -> last -> img -> box_axis[the_data -> c] = NONE;
341 }
342 view -> create_shaders[the_data -> c+MDBOX] = TRUE;
343 update (view);
344 g_action_change_state (G_ACTION (action), g_variant_new_boolean (show));
345 g_variant_unref (state);
346 }
347}
348
358G_MODULE_EXPORT void change_box_axis_radio (GSimpleAction * action, GVariant * parameter, gpointer data)
359{
360 tint * the_data = (tint *)data;
361 int i, j;
362 i = the_data -> c;
363 glwin * view = get_project_by_id (the_data -> a) -> modelgl;
364 const gchar * style = g_variant_get_string (parameter, NULL);
365 int lgt = strlen (style);
366 gchar * name = g_strdup_printf ("%c%c", style[lgt-2], style[lgt-1]);
367 if (g_strcmp0(name, ".1") == 0)
368 {
369 name = g_strdup_printf ("%.*s.0", lgt-2, style);
370 gchar * str = g_strdup_printf ("set-%s-style", (i) ? "axis" : "box");
371 g_action_group_activate_action ((GActionGroup *)view -> action_group, (const gchar *)str, g_variant_new_string((const gchar *)name));
372 g_free (str);
373 g_free (name);
374 }
375 else
376 {
377 gchar * style_name = NULL;
378 gchar * str = g_strdup_printf ("set-%s-style", (i) ? "axis" : "box");
379 for (j=0; j<2; j++)
380 {
381 style_name = g_strdup_printf ("%s.%d.0", str, j);
382 if (g_strcmp0(style, (const gchar *)style_name) == 0)
383 {
384 view -> anim -> last -> img -> box_axis[i] = (j == 0) ? WIREFRAME : CYLINDERS;
385 view -> create_shaders[i+MDBOX] = TRUE;
386 update (view);
387 g_free (style_name);
388 style_name = NULL;
389 break;
390 }
391 g_free (style_name);
392 style_name = NULL;
393 }
394 g_free (str);
395 g_action_change_state (G_ACTION (action), parameter);
396 }
397}
398
409GMenu * axis_box_style (glwin * view, int popm, int ab, int abs)
410{
411 GMenu * menu = g_menu_new ();
412 gchar * str = g_strdup_printf ("%s-style", (ab) ? "axis" : "box");
413 append_opengl_item (view, menu, text_styles[1], str, popm, 0, NULL, IMG_NONE, NULL, FALSE,
414 G_CALLBACK(change_box_axis_radio), & view -> colorp[1][ab], FALSE, (abs == WIREFRAME) ? TRUE : FALSE,
415 TRUE, (abs != NONE) ? TRUE : FALSE);
416 g_free (str);
417 str = g_strdup_printf ("%s-style", (ab) ? "axis" : "box");
418 append_opengl_item (view, menu, text_styles[4], str, popm, 1, NULL, IMG_NONE, NULL, FALSE,
419 G_CALLBACK(change_box_axis_radio), & view -> colorp[4][ab], FALSE, (abs == CYLINDERS) ? TRUE : FALSE,
420 TRUE, (abs != NONE) ? TRUE : FALSE);
421 g_free (str);
422 return menu;
423}
424
435GMenu * axis_box_param (glwin * view, int popm, int ab, int style)
436{
437 gchar * str, * key;
438 if (style == WIREFRAME)
439 {
440 str = g_strdup_printf ("Width [ %f pts ]", view -> anim -> last -> img -> box_axis_line[ab]);
441 key = g_strdup_printf ("%s-width", (ab) ? "axis" : "box");
442 }
443 else if (style == CYLINDERS)
444 {
445 str = g_strdup_printf ("Radius [ %f Å ]", view -> anim -> last -> img -> box_axis_rad[ab]);
446 key = g_strdup_printf ("%s-radius", (ab) ? "axis" : "box");
447 }
448 else
449 {
450 str = g_strdup_printf (" length [ %f Å ]", view -> anim -> last -> img -> axis_length);
451 key = g_strdup_printf ("axis-legnth");
452 }
453 GMenu * menu = g_menu_new ();
454 append_opengl_item (view, menu, str, key, popm, ab, NULL, IMG_NONE, NULL, FALSE,
455 G_CALLBACK(window_bonds), & view -> colorp[style][ab], FALSE, FALSE, FALSE, TRUE);
456 g_free (str);
457 g_free (key);
458 return menu;
459}
460
470GMenuItem * menu_box_axis (glwin * view, int popm, int ab)
471{
472 GMenuItem * ab_item = g_menu_item_new ((ab) ? "Axis" : "Box", (ab) ? NULL : (get_project_by_id(view -> proj) -> cell.ltype) ? NULL : "None");
473 int i = view -> anim -> last -> img -> box_axis[ab];
474 GMenu * menu = g_menu_new ();
475 append_opengl_item (view, menu, "Show/Hide", (ab) ? "show-axis" : "show-box", popm, popm, NULL, IMG_NONE, NULL, FALSE,
476 G_CALLBACK(show_hide_box_axis), & view -> colorp[0][ab], TRUE, (i != NONE) ? TRUE : FALSE, FALSE, (ab) ? TRUE : get_project_by_id(view -> proj) -> cell.ltype);
477
478 append_submenu (menu, "Style", axis_box_style (view, popm, ab, i));
479 GMenuItem * item ;
480 if (i == WIREFRAME)
481 {
482 item = g_menu_item_new ("Lines", (view -> anim -> last -> img -> box_axis[ab]) != NONE ? NULL : "None");
483 g_menu_item_set_attribute (item, "custom", "s", (ab) ? "axis-lines" : "box-lines", NULL);
484 g_menu_item_set_submenu (item, (GMenuModel *)axis_box_param (view, popm, ab, WIREFRAME));
485 g_menu_append_item (menu, item);
486 }
487 if (i == CYLINDERS)
488 {
489 item = g_menu_item_new ("Cylinders", (view -> anim -> last -> img -> box_axis[ab]) != NONE ? NULL : "None");
490 g_menu_item_set_attribute (item, "custom", "s", (ab) ? "axis-cylinders" : "box-cylinders", NULL);
491 g_menu_item_set_submenu (item, (GMenuModel *)axis_box_param (view, popm, ab, CYLINDERS));
492 g_menu_append_item (menu, item);
493 }
494
495 if (ab == 0)
496 {
497 GMenu * menuc = g_menu_new ();
498 append_opengl_item (view, menuc, "box-color", "box-color", popm, popm, NULL, IMG_NONE, NULL, TRUE, NULL, NULL, FALSE, FALSE, FALSE, FALSE);
499 append_opengl_item (view, menuc, "More colors ...", "box-color", popm, popm, NULL, IMG_NONE, NULL, FALSE,
500 G_CALLBACK(to_run_box_color_window), view, FALSE, FALSE, FALSE, get_project_by_id(view -> proj) -> cell.ltype);
501 append_submenu (menu, "Color", menuc);
502 g_object_unref (menuc);
503 append_opengl_item (view, menu, "Advanced", "box-advanced", popm, popm, NULL, IMG_STOCK, DPROPERTIES, FALSE,
504 G_CALLBACK(box_advanced), (gpointer)view, FALSE, FALSE, FALSE, TRUE);
505 }
506 else
507 {
508 menu_axis (menu, view, popm);
509 }
510 g_menu_item_set_submenu (ab_item, (GMenuModel *)menu);
511 return ab_item;
512}
513#endif
color_box
GtkWidget * color_box(glwin *view, int ideo, int spec, int geo)
create the color palette pointers and menus GTK3 version
Definition color_box.c:254
color_box.h
Structure definitions for color management Function declarations for color management.
to_run_box_color_window
G_MODULE_EXPORT void to_run_box_color_window(GtkWidget *widg, gpointer data)
to run box color selection window callback GTK3
Definition w_colors.c:187
colorp
color colorp[64]
layout
PangoLayout * layout
Definition curve.c:79
val
float val
Definition dlp_init.c:117
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
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)
proj
project * proj
append_submenu
void append_submenu(GMenu *menu, const gchar *label, GMenu *submenu)
append a GMenuItem with a subenu to a GMenu, and use markup for the GMenuItem
Definition gui.c:602
add_advanced_item
GtkWidget * add_advanced_item(GtkWidget *menu, GCallback handler, gpointer data, gboolean accel, guint key, GdkModifierType mod)
DPROPERTIES
#define DPROPERTIES
Definition global.h:178
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_menu_item
GtkWidget * create_menu_item(gboolean add_mnemo, gchar *action)
get_project_by_id
project * get_project_by_id(int p)
get project pointer using id number
Definition project.c:120
update
void update(glwin *view)
update the rendering of the OpenGL window
Definition glview.c:439
glview.h
Variable declarations related to the OpenGL window Function declarations related to the OpenGL wind...
action
action
Definition glview.h:189
CYLINDERS
@ CYLINDERS
Definition glview.h:177
WIREFRAME
@ WIREFRAME
Definition glview.h:174
NONE
@ NONE
Definition glview.h:172
OGL_BOX
#define OGL_BOX
Definition glwin.h:58
MDBOX
@ MDBOX
Definition glwin.h:93
OGL_AXIS
#define OGL_AXIS
Definition glwin.h:59
text_styles
char * text_styles[OGL_STYLES]
Definition m_style.c:54
set_box_axis_style
G_MODULE_EXPORT void set_box_axis_style(GtkWidget *widg, gpointer data)
glwindow.h
Function declarations for the creation of the OpenGL window.
append_opengl_item
void append_opengl_item(glwin *view, GMenu *menu, const gchar *name, gchar *key, int mpop, int item_id, gchar *accel, int image_format, gpointer icon, gboolean custom, GCallback handler, gpointer data, gboolean check, gboolean status, gboolean radio, gboolean sensitive)
create_layout_widget
GtkWidget * create_layout_widget(gchar *str, GtkWidget *menu, int vab, gpointer data)
menu_axis
void menu_axis(GMenu *menu_ab, glwin *view, int popm)
create the 'Axis' submenu GTK4
Definition m_axis.c:304
change_box_axis_radio
G_MODULE_EXPORT void change_box_axis_radio(GSimpleAction *action, GVariant *parameter, gpointer data)
handle a box/axis radio menu item signal GTK4
Definition m_box.c:358
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
window_bonds
G_MODULE_EXPORT void window_bonds(GtkWidget *widg, gpointer data)
create bond(s) configuration window(s) callback GTK3
Definition w_bonds.c:373
axis_box_style
GMenu * axis_box_style(glwin *view, int popm, int ab, int abs)
create the box/axis '-> Style' submenu GTK4
Definition m_box.c:409
box_advanced
G_MODULE_EXPORT void box_advanced(GtkWidget *widg, gpointer data)
create the box edition window callback GTK3
Definition w_box.c:177
window_lines
G_MODULE_EXPORT void window_lines(GtkWidget *widg, gpointer data)
axis_box_param
GMenu * axis_box_param(glwin *view, int popm, int ab, int style)
create the box/axis '-> Length/Width/Radius' submenus GTK4
Definition m_box.c:435
show_hide_box_axis
G_MODULE_EXPORT void show_hide_box_axis(GSimpleAction *action, GVariant *parameter, gpointer data)
handle the 'box/axis' show/hide signal GTK4
Definition m_box.c:314
glwin
Definition glwin.h:875
tint
Definition global.h:98
submenus.h
Function declarations for the creation of the OpenGL window menus.
b
int b
Definition tab-1.c:95
c
int c
Definition tab-1.c:95
a
int a
Definition tab-1.c:95
img
GtkWidget * img
Definition workspace.c:70