Merge branch 'main' into tmp_sedit

doc/docbook/system/mann/view.xml

@@ -99,7 +99,7 @@ subcommands:
     </term>
     <listitem>
       <para>
-	Get (without arguments) or set the eye point. Setting the eye point also changes center while keeping the
+	Get (without arguments) or set the eye point. Setting the eye point also changes the center while keeping the
 	azimuth, elevation, and view size static.
       </para>
     </listitem>

include/bu/defines.h

@@ -203,6 +203,20 @@
  */
 typedef int(*bu_clbk_t)(int, const char**,void*,void*);
 
+/**
+ * When callbacks are used, there are different points during the execution
+ * process when the callback may need to be triggered.  Establish common
+ * definitions so various libraries can use a consistent convention.
+ */
+// Make some definitions so it's clear what callback slot we are addressing
+#define BU_CLBK_PRE -1
+#define BU_CLBK_DURING 0
+#define BU_CLBK_POST 1
+/* In some cases (rt launches are an example) the client application may need
+ * to take action when a subprocess ends, not simply when the command returns.
+ * Distinguished from BU_CLBK_POST with this setting. */
+#define BU_CLBK_LINGER 2
+
 /** @} */
 
 #endif  /* BU_DEFINES_H */

include/ged/defines.h

@@ -345,27 +345,15 @@ GED_EXPORT void ged_destroy(struct ged *);
 GED_EXPORT extern void ged_init(struct ged *gedp);
 GED_EXPORT extern void ged_free(struct ged *gedp);
 
-
-
-// Make some definitions so it's clear what callback slot we are addressing
-#define GED_CLBK_PRE -1
-#define GED_CLBK_DURING 0
-#define GED_CLBK_POST 1
-
-// In some cases (rt launches in particular) the client application may need
-// to take action when the subprocess ends, not simply when the command
-// returns.  Distinguished from GED_CLBK_POST with this setting.
-#define GED_CLBK_LINGER 2
-
 // Associate a callback function pointer for a command.  If mode is less than
 // zero, function will be registered to run BEFORE actual cmd logic is run, and
 // if greater than zero will be registered to run AFTER the cmd logic is run.
 // If mode is zero, then it is intended to be used *during* command execution
 // and it will be up to the command's implementation to incorporate the
-// callback into its execution logic. A "GED_CLBK_DURING" will be a no-op
+// callback into its execution logic. A "BU_CLBK_DURING" will be a no-op
 // unless the command implementation logic of the libged command in question
 // utilizes it.  The "search" command is an example of a command that utilizes
-// a "GED_CLBK_DURING" callback. PRE and POST callbacks are handled
+// a "BU_CLBK_DURING" callback. PRE and POST callbacks are handled
 // automatically by ged_exec, and command implementations should not invoke
 // them directly. LINGER is a special case involving commands utilizing long
 // running subprocesses.
@@ -383,7 +371,7 @@ GED_EXPORT extern void ged_free(struct ged *gedp);
 // d optionally associates user supplied data with the callback.  The bu_clbk_t
 // function signature has two data pointers - this value will be supplied as
 // the second pointer argument.  (The first will usually be the ged pointer,
-// but that is not guaranteed in the GED_CLBK_DURING and GED_CLBK_LINGER cases
+// but that is not guaranteed in the BU_CLBK_DURING and BU_CLBK_LINGER cases
 // - check the command implementation to see what data it is returning via the
 // first ptr.)
 //

src/gtools/gsh/gsh.cpp

@@ -347,10 +347,10 @@ GshState::GshState()
     view_checkpoint();
 
     // Assign gsh specific open/close db handlers to the gedp
-    ged_clbk_set(gedp, "opendb", GED_CLBK_PRE, &gsh_pre_opendb_clbk, (void *)this);
-    ged_clbk_set(gedp, "opendb", GED_CLBK_POST, &gsh_post_opendb_clbk, (void *)this);
-    ged_clbk_set(gedp, "closedb", GED_CLBK_PRE, &gsh_pre_closedb_clbk, (void *)this);
-    ged_clbk_set(gedp, "closedb", GED_CLBK_POST, &gsh_post_closedb_clbk, (void *)this);
+    ged_clbk_set(gedp, "opendb", BU_CLBK_PRE, &gsh_pre_opendb_clbk, (void *)this);
+    ged_clbk_set(gedp, "opendb", BU_CLBK_POST, &gsh_post_opendb_clbk, (void *)this);
+    ged_clbk_set(gedp, "closedb", BU_CLBK_PRE, &gsh_pre_closedb_clbk, (void *)this);
+    ged_clbk_set(gedp, "closedb", BU_CLBK_POST, &gsh_post_closedb_clbk, (void *)this);
 
 
     // Assign gsh specific I/O handlers to the gedp
@@ -359,7 +359,7 @@ GshState::GshState()
     gedp->ged_io_data = (void *)this;
 
     // Tell libged how to clear the screen
-    ged_clbk_set(gedp, "clear", GED_CLBK_POST, &Gsh_ClearScreen, (void *)this);
+    ged_clbk_set(gedp, "clear", BU_CLBK_POST, &Gsh_ClearScreen, (void *)this);
 }
 
 GshState::~GshState()

src/libged/dm/ert.cpp

@@ -157,7 +157,7 @@ ged_ert_core(struct ged *gedp, int argc, const char *argv[])
     bu_clbk_t clbk = NULL;
     void *u1 = NULL;
     void *u2 = NULL;
-    ged_clbk_get(&clbk, &u2, gedp, "ert", GED_CLBK_LINGER);
+    ged_clbk_get(&clbk, &u2, gedp, "ert", BU_CLBK_LINGER);
 
     // We need to know the pid of the rt command that has been launched
     int rt_pid = -1;
@@ -167,7 +167,7 @@ ged_ert_core(struct ged *gedp, int argc, const char *argv[])
     clbk = NULL;
     u1 = (void *)&rt_pid;
     u2 = NULL;
-    ged_clbk_get(&clbk, &u2, gedp, "ert", GED_CLBK_DURING);
+    ged_clbk_get(&clbk, &u2, gedp, "ert", BU_CLBK_DURING);
 
     if (clbk)
 	(*clbk)(argc, argv, u1, u2);

src/libged/exec.cpp

@@ -114,7 +114,7 @@ ged_exec(struct ged *gedp, int argc, const char *argv[])
     // Check for a pre-exec callback.
     bu_clbk_t f = NULL;
     void *d = NULL;
-    if ((ged_clbk_get(&f, &d, gedp, cmdname.c_str(), GED_CLBK_PRE) == BRLCAD_OK) && f) {
+    if ((ged_clbk_get(&f, &d, gedp, cmdname.c_str(), BU_CLBK_PRE) == BRLCAD_OK) && f) {
 	cret = ged_clbk_exec(gedp->ged_result_str, gedp, GED_CMD_RECURSION_LIMIT, f, argc, argv, gedp, d);
 	if (cret != BRLCAD_OK)
 	    bu_log("error running %s pre-execution callback\n", cmdname.c_str());
@@ -139,7 +139,7 @@ ged_exec(struct ged *gedp, int argc, const char *argv[])
     }
 
     // Command execution complete - check for a post command callback.
-    if ((ged_clbk_get(&f, &d, gedp, cmdname.c_str(), GED_CLBK_POST) == BRLCAD_OK) && f) {
+    if ((ged_clbk_get(&f, &d, gedp, cmdname.c_str(), BU_CLBK_POST) == BRLCAD_OK) && f) {
 	cret = ged_clbk_exec(gedp->ged_result_str, gedp, GED_CMD_RECURSION_LIMIT, f, argc, argv, gedp, d);
 	if (cret != BRLCAD_OK)
 	    bu_log("error running %s post-execution callback\n", cmdname.c_str());

src/libged/ged.cpp

@@ -548,9 +548,9 @@ ged_clbk_set(struct ged *gedp, const char *cmd_str, int mode, bu_clbk_t f, void
 	return (BRLCAD_ERROR | GED_UNKNOWN);
     const struct ged_cmd *cmd = cm_it->second;
 
-    std::map<ged_func_ptr, std::pair<bu_clbk_t, void *>> *cm = (mode == GED_CLBK_PRE) ? &gedip->cmd_prerun_clbk : &gedip->cmd_postrun_clbk;
-    cm = (mode == GED_CLBK_DURING) ? &gedip->cmd_during_clbk : cm;
-    cm = (mode == GED_CLBK_LINGER) ? &gedip->cmd_linger_clbk : cm;
+    std::map<ged_func_ptr, std::pair<bu_clbk_t, void *>> *cm = (mode == BU_CLBK_PRE) ? &gedip->cmd_prerun_clbk : &gedip->cmd_postrun_clbk;
+    cm = (mode == BU_CLBK_DURING) ? &gedip->cmd_during_clbk : cm;
+    cm = (mode == BU_CLBK_LINGER) ? &gedip->cmd_linger_clbk : cm;
     std::map<ged_func_ptr, std::pair<bu_clbk_t, void *>>::iterator c_it = cm->find(cmd->i->cmd);
     if (c_it != cm->end())
 	ret |= GED_OVERRIDE;
@@ -578,9 +578,9 @@ ged_clbk_get(bu_clbk_t *f, void **d, struct ged *gedp, const char *cmd_str, int
 	return (BRLCAD_ERROR | GED_UNKNOWN);
     const struct ged_cmd *cmd = cm_it->second;
 
-    std::map<ged_func_ptr, std::pair<bu_clbk_t, void *>> *cm = (mode == GED_CLBK_PRE) ? &gedip->cmd_prerun_clbk : &gedip->cmd_postrun_clbk;
-    cm = (mode == GED_CLBK_DURING) ? &gedip->cmd_during_clbk : cm;
-    cm = (mode == GED_CLBK_LINGER) ? &gedip->cmd_linger_clbk : cm;
+    std::map<ged_func_ptr, std::pair<bu_clbk_t, void *>> *cm = (mode == BU_CLBK_PRE) ? &gedip->cmd_prerun_clbk : &gedip->cmd_postrun_clbk;
+    cm = (mode == BU_CLBK_DURING) ? &gedip->cmd_during_clbk : cm;
+    cm = (mode == BU_CLBK_LINGER) ? &gedip->cmd_linger_clbk : cm;
     std::map<ged_func_ptr, std::pair<bu_clbk_t, void *>>::iterator c_it = cm->find(cmd->i->cmd);
     if (c_it == cm->end()) {
 	// Nothing set, which is fine - return NULL

src/libged/open/open.cpp

@@ -98,7 +98,7 @@ ged_opendb_core(struct ged *gedp, int argc, const char *argv[])
 	// non-standard behavior for ged_exec.
 	bu_clbk_t opendb_clbk = NULL;
 	void *opendb_clbk_data = NULL;
-	ged_clbk_get(&opendb_clbk, &opendb_clbk_data, gedp, "opendb", GED_CLBK_POST);
+	ged_clbk_get(&opendb_clbk, &opendb_clbk_data, gedp, "opendb", BU_CLBK_POST);
 	if (opendb_clbk)
 	    (*opendb_clbk)(argc, argv, (void *)gedp, opendb_clbk_data);
 

src/libged/search/search.c

@@ -366,7 +366,7 @@ ged_search_core(struct ged *gedp, int argc, const char *argv_orig[])
     void *u1 = (void *)gedp;
     void *u2 = NULL;
 
-    if (ged_clbk_get(&clbk, &u2, gedp, argv_orig[0], GED_CLBK_DURING) == BRLCAD_ERROR) {
+    if (ged_clbk_get(&clbk, &u2, gedp, argv_orig[0], BU_CLBK_DURING) == BRLCAD_ERROR) {
 	bu_log("search cmd callback retrieval error\n");
 	return BRLCAD_ERROR;
     }

src/libqtcad/QgViewCtrl.cpp

@@ -173,8 +173,8 @@ QgViewCtrl::raytrace_cmd()
     const char *av[4] = {NULL};
     struct bu_vls pid_str = BU_VLS_INIT_ZERO;
 
-    ged_clbk_set(gedp, "ert", GED_CLBK_DURING, &rt_cmd_start, (void *)this);
-    ged_clbk_set(gedp, "ert", GED_CLBK_LINGER, &rt_cmd_done, (void *)this);
+    ged_clbk_set(gedp, "ert", BU_CLBK_DURING, &rt_cmd_start, (void *)this);
+    ged_clbk_set(gedp, "ert", BU_CLBK_LINGER, &rt_cmd_done, (void *)this);
 
     if (raytrace_running) {
 	if (pid < 0)
@@ -192,8 +192,8 @@ QgViewCtrl::raytrace_cmd()
     emit view_changed(QG_VIEW_REFRESH);
 
 cmd_cleanup:
-    ged_clbk_set(gedp, "ert", GED_CLBK_DURING, NULL, NULL);
-    ged_clbk_set(gedp, "ert", GED_CLBK_LINGER, NULL, NULL);
+    ged_clbk_set(gedp, "ert", BU_CLBK_DURING, NULL, NULL);
+    ged_clbk_set(gedp, "ert", BU_CLBK_LINGER, NULL, NULL);
     bu_vls_free(&pid_str);
 }
 

src/mged/f_db.c

@@ -381,16 +381,16 @@ f_opendb(ClientData clientData, Tcl_Interp *interpreter, int argc, const char *a
     void * opendb_clbk_data[2] = {NULL};
     bu_clbk_t closedb_clbk[2] = {NULL};
     void * closedb_clbk_data[2] = {NULL};
-    ged_clbk_get(&opendb_clbk[0], &opendb_clbk_data[0], s->gedp, "opendb", GED_CLBK_PRE);
-    ged_clbk_get(&opendb_clbk[1], &opendb_clbk_data[1], s->gedp, "opendb", GED_CLBK_POST);
-    ged_clbk_get(&closedb_clbk[0], &closedb_clbk_data[0], s->gedp, "closedb", GED_CLBK_PRE);
-    ged_clbk_get(&closedb_clbk[1], &closedb_clbk_data[1], s->gedp, "closedb", GED_CLBK_POST);
+    ged_clbk_get(&opendb_clbk[0], &opendb_clbk_data[0], s->gedp, "opendb", BU_CLBK_PRE);
+    ged_clbk_get(&opendb_clbk[1], &opendb_clbk_data[1], s->gedp, "opendb", BU_CLBK_POST);
+    ged_clbk_get(&closedb_clbk[0], &closedb_clbk_data[0], s->gedp, "closedb", BU_CLBK_PRE);
+    ged_clbk_get(&closedb_clbk[1], &closedb_clbk_data[1], s->gedp, "closedb", BU_CLBK_POST);
 
     // Assign the local values
-    ged_clbk_set(s->gedp, "opendb", GED_CLBK_PRE, NULL, NULL);
-    ged_clbk_set(s->gedp, "opendb", GED_CLBK_POST, &mged_post_opendb_clbk, (void *)&ctx);
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_PRE, &mged_pre_closedb_clbk, (void *)&ctx);
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_POST, &mged_post_closedb_clbk, (void *)&ctx);
+    ged_clbk_set(s->gedp, "opendb", BU_CLBK_PRE, NULL, NULL);
+    ged_clbk_set(s->gedp, "opendb", BU_CLBK_POST, &mged_post_opendb_clbk, (void *)&ctx);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_PRE, &mged_pre_closedb_clbk, (void *)&ctx);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_POST, &mged_post_closedb_clbk, (void *)&ctx);
 
     const char **av = (const char **)bu_calloc(argc+2, sizeof(const char *), "av");
     int ind = 0;
@@ -409,10 +409,10 @@ f_opendb(ClientData clientData, Tcl_Interp *interpreter, int argc, const char *a
     ctx.ged_ret = ged_exec_opendb(s->gedp, argc+ind, (const char **)av);
 
     // Done - restore standard values
-    ged_clbk_set(s->gedp, "opendb", GED_CLBK_PRE, opendb_clbk[0], opendb_clbk_data[0]);
-    ged_clbk_set(s->gedp, "opendb", GED_CLBK_POST, opendb_clbk[1], opendb_clbk_data[1]);
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_PRE, closedb_clbk[0], closedb_clbk_data[0]);
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_POST, closedb_clbk[1], closedb_clbk_data[1]);
+    ged_clbk_set(s->gedp, "opendb", BU_CLBK_PRE, opendb_clbk[0], opendb_clbk_data[0]);
+    ged_clbk_set(s->gedp, "opendb", BU_CLBK_POST, opendb_clbk[1], opendb_clbk_data[1]);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_PRE, closedb_clbk[0], closedb_clbk_data[0]);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_POST, closedb_clbk[1], closedb_clbk_data[1]);
 
     if (ctx.ged_ret == GED_HELP) {
 	Tcl_Eval(interpreter, "help opendb");
@@ -455,17 +455,17 @@ f_closedb(ClientData clientData, Tcl_Interp *interpreter, int argc, const char *
 
     bu_clbk_t closedb_clbk[2] = {NULL};
     void * closedb_clbk_data[2] = {NULL};
-    ged_clbk_get(&closedb_clbk[0], &closedb_clbk_data[0], s->gedp, "closedb", GED_CLBK_PRE);
-    ged_clbk_get(&closedb_clbk[1], &closedb_clbk_data[1], s->gedp, "closedb", GED_CLBK_POST);
+    ged_clbk_get(&closedb_clbk[0], &closedb_clbk_data[0], s->gedp, "closedb", BU_CLBK_PRE);
+    ged_clbk_get(&closedb_clbk[1], &closedb_clbk_data[1], s->gedp, "closedb", BU_CLBK_POST);
 
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_PRE, closedb_clbk[0], (void *)&ctx);
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_POST, closedb_clbk[1], (void *)&ctx);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_PRE, closedb_clbk[0], (void *)&ctx);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_POST, closedb_clbk[1], (void *)&ctx);
 
     const char *av[1] = {"closedb"};
     ged_exec_closedb(s->gedp, 1, (const char **)av);
 
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_PRE, closedb_clbk[0], closedb_clbk_data[0]);
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_POST, closedb_clbk[1], closedb_clbk_data[1]);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_PRE, closedb_clbk[0], closedb_clbk_data[0]);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_POST, closedb_clbk[1], closedb_clbk_data[1]);
 
     return ctx.ret;
 }

src/mged/setup.c

@@ -526,13 +526,13 @@ mged_setup(struct mged_state *s)
     s->gedp->ged_create_io_handler = &tclcad_create_io_handler;
     s->gedp->ged_delete_io_handler = &tclcad_delete_io_handler;
 
-    ged_clbk_set(s->gedp, "opendb", GED_CLBK_PRE, &mged_pre_opendb_clbk, (void *)&mged_global_db_ctx);
-    ged_clbk_set(s->gedp, "opendb", GED_CLBK_POST, &mged_post_opendb_clbk, (void *)&mged_global_db_ctx);
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_PRE, &mged_pre_closedb_clbk, (void *)&mged_global_db_ctx);
-    ged_clbk_set(s->gedp, "closedb", GED_CLBK_POST, &mged_post_closedb_clbk, (void *)&mged_global_db_ctx);
+    ged_clbk_set(s->gedp, "opendb", BU_CLBK_PRE, &mged_pre_opendb_clbk, (void *)&mged_global_db_ctx);
+    ged_clbk_set(s->gedp, "opendb", BU_CLBK_POST, &mged_post_opendb_clbk, (void *)&mged_global_db_ctx);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_PRE, &mged_pre_closedb_clbk, (void *)&mged_global_db_ctx);
+    ged_clbk_set(s->gedp, "closedb", BU_CLBK_POST, &mged_post_closedb_clbk, (void *)&mged_global_db_ctx);
 
     // Register during-execution callback function for search command
-    ged_clbk_set(s->gedp, "search", GED_CLBK_DURING, &mged_db_search_callback, (void *)s->interp);
+    ged_clbk_set(s->gedp, "search", BU_CLBK_DURING, &mged_db_search_callback, (void *)s->interp);
 
     struct tclcad_io_data *t_iod = tclcad_create_io_data();
     t_iod->io_mode = TCL_READABLE;

src/qged/QgEdApp.cpp

@@ -247,10 +247,10 @@ QgEdApp::QgEdApp(int &argc, char *argv[], int swrast_mode, int quad_mode) :QAppl
     }
 
     // Assign QGED specific open/close db handlers to the gedp
-    ged_clbk_set(mdl->gedp, "opendb", GED_CLBK_PRE, &qged_pre_opendb_clbk, (void *)qApp);
-    ged_clbk_set(mdl->gedp, "opendb", GED_CLBK_POST, &qged_post_opendb_clbk, (void *)qApp);
-    ged_clbk_set(mdl->gedp, "closedb", GED_CLBK_PRE, &qged_pre_closedb_clbk, (void *)qApp);
-    ged_clbk_set(mdl->gedp, "closedb", GED_CLBK_POST, &qged_post_closedb_clbk, (void *)qApp);
+    ged_clbk_set(mdl->gedp, "opendb", BU_CLBK_PRE, &qged_pre_opendb_clbk, (void *)qApp);
+    ged_clbk_set(mdl->gedp, "opendb", BU_CLBK_POST, &qged_post_opendb_clbk, (void *)qApp);
+    ged_clbk_set(mdl->gedp, "closedb", BU_CLBK_PRE, &qged_pre_closedb_clbk, (void *)qApp);
+    ged_clbk_set(mdl->gedp, "closedb", BU_CLBK_POST, &qged_post_closedb_clbk, (void *)qApp);
 
     // Assign QGED specific I/O handlers to the gedp
     mdl->gedp->ged_create_io_handler = &qt_create_io_handler;
@@ -448,16 +448,16 @@ QgEdApp::run_cmd(struct bu_vls *msg, int argc, const char **argv)
 	// If we need command-specific subprocess awareness for
 	// a command, set it up
 	if (BU_STR_EQUAL(argv[0], "ert")) {
-	    ged_clbk_set(gedp, "ert", GED_CLBK_DURING, &raytrace_start, (void *)this);
-	    ged_clbk_set(gedp, "ert", GED_CLBK_LINGER, &raytrace_done, (void *)this);
+	    ged_clbk_set(gedp, "ert", BU_CLBK_DURING, &raytrace_start, (void *)this);
+	    ged_clbk_set(gedp, "ert", BU_CLBK_LINGER, &raytrace_done, (void *)this);
 	}
 
 	// Ask the model to execute the command
 	ret = mdl->run_cmd(msg, argc, argv);
 
 	if (BU_STR_EQUAL(argv[0], "ert")) {
-	    ged_clbk_set(gedp, "ert", GED_CLBK_DURING, NULL, NULL);
-	    ged_clbk_set(gedp, "ert", GED_CLBK_LINGER, NULL, NULL);
+	    ged_clbk_set(gedp, "ert", BU_CLBK_DURING, NULL, NULL);
+	    ged_clbk_set(gedp, "ert", BU_CLBK_LINGER, NULL, NULL);
 	}
     } else {
 	for (int i = 0; i < argc; i++) {