static int FrameConfigure(Tcl_Interp *interp, void *recordPtr, int mask)
{
Frame *framePtr = recordPtr;
int width, height;
/*
* Make sure -padding resource, if present, is correct:
*/
if (framePtr->frame.paddingObj) {
Ttk_Padding unused;
if (Ttk_GetPaddingFromObj(interp,
framePtr->core.tkwin,
framePtr->frame.paddingObj,
&unused) != TCL_OK) {
return TCL_ERROR;
}
}
/* See <<NOTE-SIZE>>
*/
if ( TCL_OK != Tk_GetPixelsFromObj(
interp,framePtr->core.tkwin,framePtr->frame.widthObj,&width)
|| TCL_OK != Tk_GetPixelsFromObj(
interp,framePtr->core.tkwin,framePtr->frame.heightObj,&height)
)
{
return TCL_ERROR;
}
if ((width > 0 || height > 0) && (mask & GEOMETRY_CHANGED)) {
Tk_GeometryRequest(framePtr->core.tkwin, width, height);
}
return TtkCoreConfigure(interp, recordPtr, mask);
}
static int
OpenGLConfigure(Tcl_Interp *interp, OpenGLClientData *OpenGLPtr,
int argc, CONST84 char** argv, int flags)
{
int height, width;
if (Tk_ConfigureWidget(interp, OpenGLPtr->tkwin, configSpecs,
argc, argv, (char *) OpenGLPtr, flags) != TCL_OK)
{
return TCL_ERROR;
}
if (sscanf(OpenGLPtr->geometry, "%dx%d", &width, &height) != 2)
{
Tcl_AppendResult(interp, "bad geometry \"", OpenGLPtr->geometry,
"\": expected widthxheight", (char *) NULL);
return TCL_ERROR;
}
Tk_GeometryRequest(OpenGLPtr->tkwin, width, height);
Tk_DefineCursor(OpenGLPtr->tkwin, OpenGLPtr->cursor);
return TCL_OK;
}
void
EmbedGeometryRequest(
Container *containerPtr, /* Information about the container window. */
int width, int height) /* Size that the child has requested. */
{
TkWindow *winPtr = containerPtr->parentPtr;
/*
* Forward the requested size into our geometry management hierarchy via
* the container window. We need to send a Configure event back to the
* embedded application even if we decide not to resize the window; to
* make this happen, process all idle event handlers synchronously here
* (so that the geometry managers have had a chance to do whatever they
* want to do), and if the window's size didn't change then generate a
* configure event.
*/
Tk_GeometryRequest((Tk_Window)winPtr, width, height);
if (containerPtr->embeddedHWnd != NULL) {
while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) {
/* Empty loop body. */
}
SetWindowPos(containerPtr->embeddedHWnd, NULL, 0, 0,
winPtr->changes.width, winPtr->changes.height, SWP_NOZORDER);
}
}
static void
EmbedGeometryRequest(
Container *containerPtr, /* Information about the embedding. */
int width, int height) /* Size that the child has requested. */
{
TkWindow *winPtr = containerPtr->parentPtr;
/*
* Forward the requested size into our geometry management hierarchy via
* the container window. We need to send a Configure event back to the
* embedded application if we decide not to honor its request; to make
* this happen, process all idle event handlers synchronously here (so
* that the geometry managers have had a chance to do whatever they want
* to do), and if the window's size didn't change then generate a
* configure event.
*/
Tk_GeometryRequest((Tk_Window) winPtr, width, height);
while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) {
/* Empty loop body. */
}
if ((winPtr->changes.width != width)
|| (winPtr->changes.height != height)) {
EmbedSendConfigure(containerPtr);
}
}
/* ++ RecomputeSize --
* Recomputes the required size of the master window,
* makes geometry request.
*/
static void RecomputeSize(Ttk_Manager *mgr)
{
int width = 1, height = 1;
if (mgr->managerSpec->RequestedSize(mgr->managerData, &width, &height)) {
Tk_GeometryRequest(mgr->masterWindow, width, height);
ScheduleUpdate(mgr, MGR_RELAYOUT_REQUIRED);
}
mgr->flags &= ~MGR_RESIZE_REQUIRED;
}
static int
PaxWidgetConfigure(Tcl_Interp * interp, PaxWidget * paxwidget,
int argc, char**argv, int flags)
{
if (Tk_ConfigureWidget(interp, paxwidget->tkwin, configSpecs, argc, argv,
(char*) paxwidget, flags) != TCL_OK)
return TCL_ERROR;
if ((configSpecs[CFGIDX_OBJECT].specFlags & TK_CONFIG_OPTION_SPECIFIED)
!= 0)
{
PyObject * tkwin = TkWin_FromTkWindow(paxwidget->interp,
paxwidget->tkwin);
if (!tkwin)
{
print_failure_message("Cannot initialize tkwin object");
return TCL_ERROR;
}
paxWidget_CallMethodArgs(paxwidget->obj, InitTkWinObjectIdx,
Py_BuildValue("(O)", tkwin));
Py_DECREF(tkwin);
}
if (paxwidget->width > 0 || paxwidget->height > 0)
{
Tk_GeometryRequest(paxwidget->tkwin, paxwidget->width,
paxwidget->height);
}
if (!paxwidget->background_inited
|| (configSpecs[CFGIDX_BACKGROUND].specFlags
& TK_CONFIG_OPTION_SPECIFIED) != 0)
{
PyObject * border = PaxBorder_FromTkBorder(paxwidget->background,
paxwidget->tkwin, 1);
if (!border)
{
print_failure_message("Cannot initialize tkborder objects");
return TCL_ERROR;
}
paxWidget_CallMethodArgs(paxwidget->obj, InitTkBorderIdx,
Py_BuildValue("(O)", border));
Py_DECREF(border);
paxwidget->background_inited = 1;
Tk_SetBackgroundFromBorder(paxwidget->tkwin, paxwidget->background);
}
return TCL_OK;
}
static int
imfsample_configure(Tcl_Interp *interp, Imfsample *imfsample,
int argc, char **argv, int flags)
{
/* Interpret the configuration arguments according to the specs. */
if (Tk_ConfigureWidget(interp, imfsample->tkwin, config_specs,
argc, argv, (char *) imfsample, flags) != TCL_OK)
return TCL_ERROR;
/* Set the background for the window and create a graphics context
for use during redisplay. */
Tk_SetWindowBackground(imfsample->tkwin,
Tk_3DBorderColor(imfsample->fg_border)->pixel);
Tk_SetWindowBackground(imfsample->tkwin,
Tk_3DBorderColor(imfsample->bg_border)->pixel);
Tk_SetWindowBackground(imfsample->tkwin,
Tk_3DBorderColor(imfsample->cu_border)->pixel);
if ((imfsample->copygc == None) && 1/*imfsample->double_buffer*/) {
XGCValues gcValues;
gcValues.function = GXcopy;
gcValues.graphics_exposures = False;
imfsample->copygc = XCreateGC(imfsample->display,
DefaultRootWindow(imfsample->display),
GCFunction|GCGraphicsExposures,
&gcValues);
}
if (imfsample->gc == None) {
imfsample->gc = XCreateGC(imfsample->display,
DefaultRootWindow(imfsample->display),
None, NULL);
}
/* Register the desired geometry for the window, then arrange for
the window to be redisplayed. */
Tk_GeometryRequest(imfsample->tkwin, imfsample->width, imfsample->height);
Tk_SetInternalBorder(imfsample->tkwin, imfsample->border_width);
/* Make sure the resized widget is redrawn. */
imfsample->redraw = TRUE;
if (!imfsample->update_pending) {
Tcl_DoWhenIdle(imfsample_display, (ClientData) imfsample);
imfsample->update_pending = 1;
}
return TCL_OK;
}
/*--------------------------------------------------------------------------*/
int sci_opentk(char *fname, unsigned long l)
{
Tcl_Interp *TCLinterpLocal = NULL;
CheckRhs(0, 0);
CheckLhs(1, 1);
TCLinterpLocal = Tcl_CreateInterp();
Tcl_Init(TCLinterpLocal);
Tk_Init(TCLinterpLocal);
TKmainWindow = Tk_MainWindow(TCLinterpLocal);
Tk_GeometryRequest(TKmainWindow, 200, 200);
Tk_SetWindowBackground(TKmainWindow, WhitePixelOfScreen(Tk_Screen(TKmainWindow)));
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
int
common_dm(int argc, const char *argv[])
{
int status;
struct bu_vls vls = BU_VLS_INIT_ZERO;
if (dbip == DBI_NULL)
return TCL_OK;
if (BU_STR_EQUAL(argv[0], "idle")) {
/* redraw after scaling */
if (gedp && gedp->ged_gvp &&
gedp->ged_gvp->gv_adaptive_plot &&
gedp->ged_gvp->gv_redraw_on_zoom &&
(am_mode == AMM_SCALE ||
am_mode == AMM_CON_SCALE_X ||
am_mode == AMM_CON_SCALE_Y ||
am_mode == AMM_CON_SCALE_Z))
{
if (redraw_visible_objects() == TCL_ERROR) {
return TCL_ERROR;
}
}
am_mode = AMM_IDLE;
scroll_active = 0;
if (rubber_band->rb_active) {
rubber_band->rb_active = 0;
if (mged_variables->mv_mouse_behavior == 'p')
rb_set_dirty_flag();
else if (mged_variables->mv_mouse_behavior == 'r')
rt_rect_area();
else if (mged_variables->mv_mouse_behavior == 'z')
zoom_rect_area();
}
return TCL_OK;
}
if (BU_STR_EQUAL(argv[0], "m")) {
int x;
int y;
int old_orig_gui;
int stolen = 0;
fastf_t fx, fy;
if (argc < 3) {
Tcl_AppendResult(INTERP, "dm m: need more parameters\n",
"dm m xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
old_orig_gui = mged_variables->mv_orig_gui;
fx = dm_Xx2Normal(dmp, atoi(argv[1]));
fy = dm_Xy2Normal(dmp, atoi(argv[2]), 0);
x = fx * GED_MAX;
y = fy * GED_MAX;
if (mged_variables->mv_faceplate &&
mged_variables->mv_orig_gui) {
#define MENUXLIM (-1250)
if (x >= MENUXLIM && scroll_select(x, y, 0)) {
stolen = 1;
goto end;
}
if (x < MENUXLIM && mmenu_select(y, 0)) {
stolen = 1;
goto end;
}
}
mged_variables->mv_orig_gui = 0;
fy = dm_Xy2Normal(dmp, atoi(argv[2]), 1);
y = fy * GED_MAX;
end:
if (mged_variables->mv_mouse_behavior == 'q' && !stolen) {
point_t view_pt;
point_t model_pt;
if (grid_state->gr_snap)
snap_to_grid(&fx, &fy);
if (mged_variables->mv_perspective_mode)
VSET(view_pt, fx, fy, 0.0);
else
VSET(view_pt, fx, fy, 1.0);
MAT4X3PNT(model_pt, view_state->vs_gvp->gv_view2model, view_pt);
VSCALE(model_pt, model_pt, base2local);
if (dmp->dm_zclip)
bu_vls_printf(&vls, "qray_nirt %lf %lf %lf",
model_pt[X], model_pt[Y], model_pt[Z]);
else
bu_vls_printf(&vls, "qray_nirt -b %lf %lf %lf",
model_pt[X], model_pt[Y], model_pt[Z]);
} else if ((mged_variables->mv_mouse_behavior == 'p' ||
mged_variables->mv_mouse_behavior == 'r' ||
mged_variables->mv_mouse_behavior == 'z') && !stolen) {
if (grid_state->gr_snap)
snap_to_grid(&fx, &fy);
rubber_band->rb_active = 1;
rubber_band->rb_x = fx;
rubber_band->rb_y = fy;
rubber_band->rb_width = 0.0;
rubber_band->rb_height = 0.0;
rect_view2image();
rb_set_dirty_flag();
} else if (mged_variables->mv_mouse_behavior == 's' && !stolen) {
#if 0
if (grid_state->gr_snap) {
snap_to_grid(&fx, &fy);
x = fx * GED_MAX;
y = fy * GED_MAX;
}
#endif
bu_vls_printf(&vls, "mouse_solid_edit_select %d %d", x, y);
} else if (mged_variables->mv_mouse_behavior == 'm' && !stolen) {
#if 0
if (grid_state->gr_snap) {
snap_to_grid(&fx, &fy);
x = fx * GED_MAX;
y = fy * GED_MAX;
}
#endif
bu_vls_printf(&vls, "mouse_matrix_edit_select %d %d", x, y);
} else if (mged_variables->mv_mouse_behavior == 'c' && !stolen) {
#if 0
if (grid_state->gr_snap) {
snap_to_grid(&fx, &fy);
x = fx * GED_MAX;
y = fy * GED_MAX;
}
#endif
bu_vls_printf(&vls, "mouse_comb_edit_select %d %d", x, y);
} else if (mged_variables->mv_mouse_behavior == 'o' && !stolen) {
#if 0
if (grid_state->gr_snap) {
snap_to_grid(&fx, &fy);
x = fx * GED_MAX;
y = fy * GED_MAX;
}
#endif
bu_vls_printf(&vls, "mouse_rt_obj_select %d %d", x, y);
} else if (adc_state->adc_draw && mged_variables->mv_transform == 'a' && !stolen) {
point_t model_pt;
point_t view_pt;
if (grid_state->gr_snap)
snap_to_grid(&fx, &fy);
VSET(view_pt, fx, fy, 1.0);
MAT4X3PNT(model_pt, view_state->vs_gvp->gv_view2model, view_pt);
VSCALE(model_pt, model_pt, base2local);
bu_vls_printf(&vls, "adc xyz %lf %lf %lf\n", model_pt[X], model_pt[Y], model_pt[Z]);
} else if (grid_state->gr_snap && !stolen &&
SEDIT_TRAN && mged_variables->mv_transform == 'e') {
point_t view_pt;
point_t model_pt;
snap_to_grid(&fx, &fy);
MAT4X3PNT(view_pt, view_state->vs_gvp->gv_model2view, curr_e_axes_pos);
view_pt[X] = fx;
view_pt[Y] = fy;
MAT4X3PNT(model_pt, view_state->vs_gvp->gv_view2model, view_pt);
VSCALE(model_pt, model_pt, base2local);
bu_vls_printf(&vls, "p %lf %lf %lf", model_pt[X], model_pt[Y], model_pt[Z]);
} else if (grid_state->gr_snap && !stolen &&
OEDIT_TRAN && mged_variables->mv_transform == 'e') {
point_t view_pt;
point_t model_pt;
snap_to_grid(&fx, &fy);
MAT4X3PNT(view_pt, view_state->vs_gvp->gv_model2view, curr_e_axes_pos);
view_pt[X] = fx;
view_pt[Y] = fy;
MAT4X3PNT(model_pt, view_state->vs_gvp->gv_view2model, view_pt);
VSCALE(model_pt, model_pt, base2local);
bu_vls_printf(&vls, "translate %lf %lf %lf", model_pt[X], model_pt[Y], model_pt[Z]);
} else if (grid_state->gr_snap && !stolen &&
STATE != ST_S_PICK && STATE != ST_O_PICK &&
STATE != ST_O_PATH && !SEDIT_PICK && !EDIT_SCALE) {
point_t view_pt;
point_t model_pt;
point_t vcenter;
snap_to_grid(&fx, &fy);
MAT_DELTAS_GET_NEG(vcenter, view_state->vs_gvp->gv_center);
MAT4X3PNT(view_pt, view_state->vs_gvp->gv_model2view, vcenter);
view_pt[X] = fx;
view_pt[Y] = fy;
MAT4X3PNT(model_pt, view_state->vs_gvp->gv_view2model, view_pt);
VSCALE(model_pt, model_pt, base2local);
bu_vls_printf(&vls, "center %lf %lf %lf", model_pt[X], model_pt[Y], model_pt[Z]);
} else
bu_vls_printf(&vls, "M 1 %d %d\n", x, y);
status = Tcl_Eval(INTERP, bu_vls_addr(&vls));
mged_variables->mv_orig_gui = old_orig_gui;
bu_vls_free(&vls);
return status;
}
if (BU_STR_EQUAL(argv[0], "am")) {
if (argc < 4) {
Tcl_AppendResult(INTERP, "dm am: need more parameters\n",
"dm am <r|t|s> xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
dml_omx = atoi(argv[2]);
dml_omy = atoi(argv[3]);
switch (*argv[1]) {
case 'r':
am_mode = AMM_ROT;
break;
case 't':
am_mode = AMM_TRAN;
if (grid_state->gr_snap) {
int save_edflag;
if ((STATE == ST_S_EDIT || STATE == ST_O_EDIT) &&
mged_variables->mv_transform == 'e') {
if (STATE == ST_S_EDIT) {
save_edflag = es_edflag;
if (!SEDIT_TRAN)
es_edflag = STRANS;
} else {
save_edflag = edobj;
edobj = BE_O_XY;
}
snap_keypoint_to_grid();
if (STATE == ST_S_EDIT)
es_edflag = save_edflag;
else
edobj = save_edflag;
} else
snap_view_center_to_grid();
}
break;
case 's':
if (STATE == ST_S_EDIT && mged_variables->mv_transform == 'e' &&
ZERO(acc_sc_sol))
acc_sc_sol = 1.0;
else if (STATE == ST_O_EDIT && mged_variables->mv_transform == 'e') {
edit_absolute_scale = acc_sc_obj - 1.0;
if (edit_absolute_scale > 0.0)
edit_absolute_scale /= 3.0;
}
am_mode = AMM_SCALE;
break;
default:
Tcl_AppendResult(INTERP, "dm am: need more parameters\n",
"dm am <r|t|s> xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
return TCL_OK;
}
if (BU_STR_EQUAL(argv[0], "adc")) {
fastf_t fx, fy;
fastf_t td; /* tick distance */
if (argc < 4) {
Tcl_AppendResult(INTERP, "dm adc: need more parameters\n",
"dm adc 1|2|t|d xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
dml_omx = atoi(argv[2]);
dml_omy = atoi(argv[3]);
switch (*argv[1]) {
case '1':
fx = dm_Xx2Normal(dmp, dml_omx) * GED_MAX - adc_state->adc_dv_x;
fy = dm_Xy2Normal(dmp, dml_omy, 1) * GED_MAX - adc_state->adc_dv_y;
bu_vls_printf(&vls, "adc a1 %lf\n", RAD2DEG*atan2(fy, fx));
Tcl_Eval(INTERP, bu_vls_addr(&vls));
bu_vls_free(&vls);
am_mode = AMM_ADC_ANG1;
break;
case '2':
fx = dm_Xx2Normal(dmp, dml_omx) * GED_MAX - adc_state->adc_dv_x;
fy = dm_Xy2Normal(dmp, dml_omy, 1) * GED_MAX - adc_state->adc_dv_y;
bu_vls_printf(&vls, "adc a2 %lf\n", RAD2DEG*atan2(fy, fx));
Tcl_Eval(INTERP, bu_vls_addr(&vls));
bu_vls_free(&vls);
am_mode = AMM_ADC_ANG2;
break;
case 't':
{
point_t model_pt;
point_t view_pt;
VSET(view_pt, dm_Xx2Normal(dmp, dml_omx), dm_Xy2Normal(dmp, dml_omy, 1), 0.0);
if (grid_state->gr_snap)
snap_to_grid(&view_pt[X], &view_pt[Y]);
MAT4X3PNT(model_pt, view_state->vs_gvp->gv_view2model, view_pt);
VSCALE(model_pt, model_pt, base2local);
bu_vls_printf(&vls, "adc xyz %lf %lf %lf\n", model_pt[X], model_pt[Y], model_pt[Z]);
Tcl_Eval(INTERP, bu_vls_addr(&vls));
bu_vls_free(&vls);
am_mode = AMM_ADC_TRAN;
}
break;
case 'd':
fx = (dm_Xx2Normal(dmp, dml_omx) * GED_MAX -
adc_state->adc_dv_x) * view_state->vs_gvp->gv_scale * base2local * INV_GED;
fy = (dm_Xy2Normal(dmp, dml_omy, 1) * GED_MAX -
adc_state->adc_dv_y) * view_state->vs_gvp->gv_scale * base2local * INV_GED;
td = sqrt(fx * fx + fy * fy);
bu_vls_printf(&vls, "adc dst %lf\n", td);
Tcl_Eval(INTERP, bu_vls_addr(&vls));
bu_vls_free(&vls);
am_mode = AMM_ADC_DIST;
break;
default:
Tcl_AppendResult(INTERP, "dm adc: unrecognized parameter - ", argv[1],
"\ndm adc 1|2|t|d xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
return TCL_OK;
}
if (BU_STR_EQUAL(argv[0], "con")) {
if (argc < 5) {
Tcl_AppendResult(INTERP, "dm con: need more parameters\n",
"dm con r|t|s x|y|z xpos ypos\n",
"dm con a x|y|1|2|d xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
dml_omx = atoi(argv[3]);
dml_omy = atoi(argv[4]);
switch (*argv[1]) {
case 'a':
switch (*argv[2]) {
case 'x':
am_mode = AMM_CON_XADC;
break;
case 'y':
am_mode = AMM_CON_YADC;
break;
case '1':
am_mode = AMM_CON_ANG1;
break;
case '2':
am_mode = AMM_CON_ANG2;
break;
case 'd':
am_mode = AMM_CON_DIST;
break;
default:
Tcl_AppendResult(INTERP, "dm con: unrecognized parameter - ", argv[2],
"\ndm con a x|y|1|2|d xpos ypos\n", (char *)NULL);
}
break;
case 'r':
switch (*argv[2]) {
case 'x':
am_mode = AMM_CON_ROT_X;
break;
case 'y':
am_mode = AMM_CON_ROT_Y;
break;
case 'z':
am_mode = AMM_CON_ROT_Z;
break;
default:
Tcl_AppendResult(INTERP, "dm con: unrecognized parameter - ", argv[2],
"\ndm con r|t|s x|y|z xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
break;
case 't':
switch (*argv[2]) {
case 'x':
am_mode = AMM_CON_TRAN_X;
break;
case 'y':
am_mode = AMM_CON_TRAN_Y;
break;
case 'z':
am_mode = AMM_CON_TRAN_Z;
break;
default:
Tcl_AppendResult(INTERP, "dm con: unrecognized parameter - ", argv[2],
"\ndm con r|t|s x|y|z xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
break;
case 's':
switch (*argv[2]) {
case 'x':
if (STATE == ST_S_EDIT && mged_variables->mv_transform == 'e' &&
ZERO(acc_sc_sol))
acc_sc_sol = 1.0;
else if (STATE == ST_O_EDIT && mged_variables->mv_transform == 'e') {
edit_absolute_scale = acc_sc[0] - 1.0;
if (edit_absolute_scale > 0.0)
edit_absolute_scale /= 3.0;
}
am_mode = AMM_CON_SCALE_X;
break;
case 'y':
if (STATE == ST_S_EDIT && mged_variables->mv_transform == 'e' &&
ZERO(acc_sc_sol))
acc_sc_sol = 1.0;
else if (STATE == ST_O_EDIT && mged_variables->mv_transform == 'e') {
edit_absolute_scale = acc_sc[1] - 1.0;
if (edit_absolute_scale > 0.0)
edit_absolute_scale /= 3.0;
}
am_mode = AMM_CON_SCALE_Y;
break;
case 'z':
if (STATE == ST_S_EDIT && mged_variables->mv_transform == 'e' &&
ZERO(acc_sc_sol))
acc_sc_sol = 1.0;
else if (STATE == ST_O_EDIT && mged_variables->mv_transform == 'e') {
edit_absolute_scale = acc_sc[2] - 1.0;
if (edit_absolute_scale > 0.0)
edit_absolute_scale /= 3.0;
}
am_mode = AMM_CON_SCALE_Z;
break;
default:
Tcl_AppendResult(INTERP, "dm con: unrecognized parameter - ", argv[2],
"\ndm con r|t|s x|y|z xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
break;
default:
Tcl_AppendResult(INTERP, "dm con: unrecognized parameter - ", argv[1],
"\ndm con r|t|s x|y|z xpos ypos\n", (char *)NULL);
return TCL_ERROR;
}
return TCL_OK;
}
if (BU_STR_EQUAL(argv[0], "size")) {
int width, height;
/* get the window size */
if (argc == 1) {
bu_vls_printf(&vls, "%d %d", dmp->dm_width, dmp->dm_height);
Tcl_AppendResult(INTERP, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
return TCL_OK;
}
/* set the window size */
if (argc == 3) {
width = atoi(argv[1]);
height = atoi(argv[2]);
dmp->dm_width = width;
dmp->dm_height = height;
#if defined(DM_X) || defined(DM_TK) || defined(DM_OGL) || defined(DM_WGL)
# if 0
Tk_ResizeWindow(((struct dm_xvars *)dmp->dm_vars.pub_vars)->xtkwin, width, height);
# else
#if defined(HAVE_TK)
Tk_GeometryRequest(((struct dm_xvars *)dmp->dm_vars.pub_vars)->xtkwin, width, height);
#endif
# endif
#endif
return TCL_OK;
}
Tcl_AppendResult(INTERP, "Usage: dm size [width height]\n", (char *)NULL);
return TCL_ERROR;
}
#if defined(DM_X) || defined(DM_TK) || defined(DM_OGL) || defined(DM_WGL)
if (BU_STR_EQUAL(argv[0], "getx")) {
if (argc == 1) {
struct bu_vls tmp_vls = BU_VLS_INIT_ZERO;
/* Bare set command, print out current settings */
bu_vls_struct_print2(&tmp_vls, "dm internal X variables", dm_xvars_vparse,
(const char *)dmp->dm_vars.pub_vars);
Tcl_AppendResult(INTERP, bu_vls_addr(&tmp_vls), (char *)NULL);
bu_vls_free(&tmp_vls);
} else if (argc == 2) {
bu_vls_struct_item_named(&vls, dm_xvars_vparse, argv[1], (const char *)dmp->dm_vars.pub_vars, COMMA);
Tcl_AppendResult(INTERP, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
}
return TCL_OK;
}
#endif
if (BU_STR_EQUAL(argv[0], "bg")) {
int r, g, b;
if (argc != 1 && argc != 4) {
bu_vls_printf(&vls, "Usage: dm bg [r g b]");
Tcl_AppendResult(INTERP, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
return TCL_ERROR;
}
/* return background color of current display manager */
if (argc == 1) {
bu_vls_printf(&vls, "%d %d %d",
dmp->dm_bg[0],
dmp->dm_bg[1],
dmp->dm_bg[2]);
Tcl_AppendResult(INTERP, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
return TCL_OK;
}
if (sscanf(argv[1], "%d", &r) != 1 ||
sscanf(argv[2], "%d", &g) != 1 ||
sscanf(argv[3], "%d", &b) != 1) {
bu_vls_printf(&vls, "Usage: dm bg r g b");
Tcl_AppendResult(INTERP, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
return TCL_ERROR;
}
dirty = 1;
return DM_SET_BGCOLOR(dmp, r, g, b);
}
Tcl_AppendResult(INTERP, "dm: bad command - ", argv[0], "\n", (char *)NULL);
return TCL_ERROR;
}
void
TkpComputeMenuButtonGeometry(
TkMenuButton *mbPtr) /* Widget record for menu button. */
{
int width, height, mm, pixels;
int avgWidth, txtWidth, txtHeight;
int haveImage = 0, haveText = 0;
Tk_FontMetrics fm;
mbPtr->inset = mbPtr->highlightWidth + mbPtr->borderWidth;
width = 0;
height = 0;
txtWidth = 0;
txtHeight = 0;
avgWidth = 0;
if (mbPtr->image != None) {
Tk_SizeOfImage(mbPtr->image, &width, &height);
haveImage = 1;
} else if (mbPtr->bitmap != None) {
Tk_SizeOfBitmap(mbPtr->display, mbPtr->bitmap, &width, &height);
haveImage = 1;
}
if (haveImage == 0 || mbPtr->compound != COMPOUND_NONE) {
Tk_FreeTextLayout(mbPtr->textLayout);
mbPtr->textLayout = Tk_ComputeTextLayout(mbPtr->tkfont, mbPtr->text,
-1, mbPtr->wrapLength, mbPtr->justify, 0, &mbPtr->textWidth,
&mbPtr->textHeight);
txtWidth = mbPtr->textWidth;
txtHeight = mbPtr->textHeight;
avgWidth = Tk_TextWidth(mbPtr->tkfont, "0", 1);
Tk_GetFontMetrics(mbPtr->tkfont, &fm);
haveText = (txtWidth != 0 && txtHeight != 0);
}
/*
* If the menubutton is compound (ie, it shows both an image and text),
* the new geometry is a combination of the image and text geometry. We
* only honor the compound bit if the menubutton has both text and an
* image, because otherwise it is not really a compound menubutton.
*/
if (mbPtr->compound != COMPOUND_NONE && haveImage && haveText) {
switch ((enum compound) mbPtr->compound) {
case COMPOUND_TOP:
case COMPOUND_BOTTOM:
/*
* Image is above or below text.
*/
height += txtHeight + mbPtr->padY;
width = (width > txtWidth ? width : txtWidth);
break;
case COMPOUND_LEFT:
case COMPOUND_RIGHT:
/*
* Image is left or right of text.
*/
width += txtWidth + mbPtr->padX;
height = (height > txtHeight ? height : txtHeight);
break;
case COMPOUND_CENTER:
/*
* Image and text are superimposed.
*/
width = (width > txtWidth ? width : txtWidth);
height = (height > txtHeight ? height : txtHeight);
break;
case COMPOUND_NONE:
break;
}
if (mbPtr->width > 0) {
width = mbPtr->width;
}
if (mbPtr->height > 0) {
height = mbPtr->height;
}
width += 2*mbPtr->padX;
height += 2*mbPtr->padY;
} else {
if (haveImage) {
if (mbPtr->width > 0) {
width = mbPtr->width;
}
if (mbPtr->height > 0) {
height = mbPtr->height;
}
} else {
width = txtWidth;
height = txtHeight;
if (mbPtr->width > 0) {
width = mbPtr->width * avgWidth;
}
if (mbPtr->height > 0) {
height = mbPtr->height * fm.linespace;
}
}
}
if (! haveImage) {
width += 2*mbPtr->padX;
height += 2*mbPtr->padY;
}
if (mbPtr->indicatorOn) {
mm = WidthMMOfScreen(Tk_Screen(mbPtr->tkwin));
pixels = WidthOfScreen(Tk_Screen(mbPtr->tkwin));
mbPtr->indicatorHeight= (INDICATOR_HEIGHT * pixels)/(10*mm);
mbPtr->indicatorWidth = (INDICATOR_WIDTH * pixels)/(10*mm)
+ 2*mbPtr->indicatorHeight;
width += mbPtr->indicatorWidth;
} else {
mbPtr->indicatorHeight = 0;
mbPtr->indicatorWidth = 0;
}
Tk_GeometryRequest(mbPtr->tkwin, (int) (width + 2*mbPtr->inset),
(int) (height + 2*mbPtr->inset));
Tk_SetInternalBorder(mbPtr->tkwin, mbPtr->inset);
}
static void
imfsample_display(ClientData cldata)
{
char *str;
int row, col, namex, namey, n, sx, sy, update = FALSE, done;
Imfsample *imfsample = (Imfsample *) cldata;
Display *dpy = imfsample->display;
Tk_Window tkwin = imfsample->tkwin;
GC gc;
Pixmap pm = None;
Drawable d;
Tk_Font tkfont;
int winwidth = Tk_Width(Tk_Parent(tkwin));
int winheight = Tk_Height(Tk_Parent(tkwin));
char tclbuf[100];
int rslt;
imfsample->update_pending = 0;
if (!Tk_IsMapped(tkwin)) {
return;
}
/* Check if we need to redraw the entire imfsample. */
if (imfsample->imfapp) {
if (imfsample->oldfirst != imfsample->firstvisrow
|| imfsample->redraw) {
imfsample->oldfirst = imfsample->firstvisrow;
update = TRUE;
}
}
/* Create a pixmap for double-buffering if necessary. */
if (imfsample->double_buffer) {
update = TRUE;
pm = Tk_GetPixmap(imfsample->display, Tk_WindowId(tkwin),
Tk_Width(tkwin), Tk_Height(tkwin),
DefaultDepthOfScreen(Tk_Screen(tkwin)));
d = pm;
} else {
d = Tk_WindowId(tkwin);
}
if (black_color == NULL) {
black_color = Tk_GetColor(interp, tkwin, Tk_GetUid("black"));
}
if (white_color == NULL) {
white_color = Tk_GetColor(interp, tkwin, Tk_GetUid("white"));
}
if (black_border == NULL) {
black_border = Tk_Get3DBorder(interp, tkwin, "black");
}
if (white_border == NULL) {
white_border = Tk_Get3DBorder(interp, tkwin, "white");
}
/* Collect GC and font for subsequent work. */
gc = imfsample->gc;
XSetClipMask(dpy, gc, None);
if (imfsample->show_names) {
#ifdef WIN32
tkfont = Tk_GetFont(interp, tkwin, "-family arial -size 8");
#elif defined (MAC)
tkfont = Tk_GetFont(interp, tkwin, "-family helvetica -size 11");
#else
tkfont = Tk_GetFont(interp, tkwin, "-family helvetica -size 12");
#endif
XSetFont(imfsample->display, gc, Tk_FontId(tkfont));
}
/* Redraw the entire widget background/border, but not if we
are just updating the selected image. */
if (imfsample->selected == imfsample->previous
/* Always redraw if we have only one image (e.g. closeups). */
|| (imfsample->numimages == 1 && imfsample->selected == -1)
|| update) {
done = FALSE;
if (imfsample->with_terrain >= 0
/* Terrain tiles are not supported on Windows yet. */
&& use_clip_mask) {
ImageFamily *timf =
imfsample->imf_list[imfsample->with_terrain];
Image *timg;
TkImage *tkimg;
timg = best_image(timf, 64, 64);
if (timg) {
tkimg = (TkImage *) timg->hook;
if (tkimg && tkimg->colr) {
XSetFillStyle(dpy, gc, FillTiled);
XSetTile(dpy, gc, tkimg->colr);
XFillRectangle(dpy, d, gc, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin));
done = TRUE;
}
}
}
if (!done) {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border, 0, 0,
Tk_Width(tkwin), Tk_Height(tkwin),
imfsample->border_width, imfsample->relief);
}
}
#if 0
for (i = 0; i < imfsample->numimages; i++) {
if (imf_interp_hook)
imfsample->imf_list[i] =
(*imf_interp_hook)(imfsample->imf_list[i], NULL, TRUE);
}
#endif
/* Tweak the default item width/height to something better. */
if (imfsample->iheight == 0) {
imfsample->iheight = 32;
if (imfsample->numimages == 1)
imfsample->iheight = imfsample->height;
}
if (imfsample->iwidth == 0) {
imfsample->iwidth = 32;
if (imfsample->numimages == 1)
imfsample->iwidth = imfsample->width;
}
imfsample->eltw = imfsample->iwidth;
if (imfsample->show_grid)
imfsample->eltw += 2;
else
imfsample->eltw += 2 * imfsample->pad;
if (imfsample->show_names && !imfsample->show_grid)
imfsample->eltw += 80;
imfsample->elth = imfsample->iheight;
if (imfsample->show_grid)
imfsample->elth += 2;
else
imfsample->elth += 2 * imfsample->pad;
/* Fix a lower bound on the vertical spacing. */
/* (should be determined by choice of app font) */
if (imfsample->elth < 10 && !imfsample->show_grid)
imfsample->elth = 10;
/* Compute and save the number of columns to use. */
imfsample->cols = winwidth / imfsample->eltw;
if (imfsample->cols <= 0)
imfsample->cols = 1;
/* We can get a little wider spacing by recalculating the element
width. */
if (imfsample->show_names && !imfsample->show_grid)
imfsample->eltw = (winwidth - 10) / imfsample->cols;
imfsample->rows = imfsample->numimages / imfsample->cols;
/* Account for a last partial row. */
if (imfsample->rows * imfsample->cols < imfsample->numimages)
++(imfsample->rows);
/* Compute the number of visible rows. It would be time-consuming
to render all the images, so try to do only the visible ones. */
imfsample->numvisrows = winheight / imfsample->elth;
if (imfsample->numvisrows > imfsample->rows)
imfsample->numvisrows = imfsample->rows;
if (imfsample->numvisrows < 1)
imfsample->numvisrows = min(1, imfsample->rows);
if (imfsample->firstvisrow + imfsample->numvisrows > imfsample->rows)
imfsample->firstvisrow = imfsample->rows - imfsample->numvisrows;
/* Imfapp-specific code that adjusts the canvas content to fit a resized
window and also sets the canvas scrollregion correctly. */
if (imfsample->imfapp
&& imfsample->redraw) {
imfsample->width = Tk_Width(Tk_Parent(tkwin));
imfsample->height = imfsample->rows * imfsample->elth + 7;
Tk_GeometryRequest(tkwin, imfsample->width, imfsample->height);
/* There must be a better way to do this ... */
sprintf(tclbuf,
".images.canvas configure -scrollregion [ list 0 0 0 %d ]",
imfsample->height);
rslt = Tcl_Eval(interp, tclbuf);
if (rslt == TCL_ERROR) {
fprintf(stderr, "Error: %s\n", Tcl_GetStringResult(interp));
}
/* Force a redraw of the scrollbar if the window was resized. */
if (imfsample->numimages) {
sprintf(tclbuf, ".images.canvas.content yview scroll 0 units");
} else {
sprintf(tclbuf, ".images.scroll set 0 1");
}
rslt = Tcl_Eval(interp, tclbuf);
if (rslt == TCL_ERROR) {
fprintf(stderr, "Error: %s\n", Tcl_GetStringResult(interp));
}
}
/* Now iterate through all the images we want to draw. */
for (row = imfsample->firstvisrow;
row <= (imfsample->firstvisrow + imfsample->numvisrows);
++row) {
if (row < 0)
continue;
for (col = 0; col < imfsample->cols; ++col) {
n = row * imfsample->cols + col;
if (n >= imfsample->numimages)
break;
sx = col * imfsample->eltw;
sy = (row - imfsample->firstvisrow) * imfsample->elth;
/* Erase the old selected imf if we picked a new one. */
if (n == imfsample->previous && n != imfsample->selected) {
done = FALSE;
if (imfsample->with_terrain >= 0
/* Terrain tiles are not supported on Windows yet. */
&& use_clip_mask) {
ImageFamily *timf =
imfsample->imf_list[imfsample->with_terrain];
Image *timg;
TkImage *tkimg;
timg = best_image(timf, 64, 64);
if (timg) {
tkimg = (TkImage *) timg->hook;
if (tkimg && tkimg->colr) {
XSetFillStyle(dpy, gc, FillTiled);
XSetTile(dpy, gc, tkimg->colr);
if (imfsample->show_grid) {
XFillRectangle(dpy, d, gc, sx, sy + 2,
imfsample->eltw,
imfsample->elth);
} else {
XFillRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw,
imfsample->elth);
}
done = TRUE;
}
}
}
if (!done) {
if (imfsample->show_grid) {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border,
sx, sy + 2,
imfsample->eltw, imfsample->elth,
imfsample->border_width,
imfsample->relief);
} else {
Tk_Fill3DRectangle(tkwin, d, imfsample->bg_border,
sx, sy + 7,
imfsample->eltw, imfsample->elth,
imfsample->border_width,
imfsample->relief);
}
}
}
/* Just draw the old erased image if we selected a new one, else
draw every image. */
if (imfsample->selected == imfsample->previous
|| n == imfsample->previous
|| update) {
if (imfsample->show_grid) {
Tk_Fill3DRectangle(tkwin, d, imfsample->cu_border,
sx + 2, sy + 2,
imfsample->iwidth, imfsample->iheight,
imfsample->border_width, imfsample->relief);
draw_one_main_image(imfsample, d, gc,
imfsample->imf_list[n],
sx + 2, sy + 2,
imfsample->iwidth,
imfsample->iheight);
} else {
draw_one_main_image(imfsample, d, gc,
imfsample->imf_list[n],
sx + imfsample->pad,
sy + imfsample->pad,
imfsample->iwidth,
imfsample->iheight);
}
if (imfsample->show_names && !imfsample->show_grid) {
namex = sx + 5;
namey = sy + imfsample->elth + 3;
XSetClipMask(dpy, gc, None);
XSetFillStyle(dpy, gc, FillSolid);
XSetForeground(dpy, gc,
Tk_3DBorderColor(
imfsample->fg_border)->pixel);
str = imfsample->imf_list[n]->name;
Tk_DrawChars(dpy, d, gc, tkfont, str, strlen(str),
namex, namey);
}
}
/* Box the selected imf. */
if (n == imfsample->selected) {
XSetClipMask(dpy, gc, None);
XSetFillStyle(dpy, gc, FillSolid);
XSetForeground(dpy, gc, Tk_3DBorderColor(imfsample->fg_border)->pixel);
if (imfsample->show_grid) {
/* A rectangle on the Mac is 1 pixel smaller in both directions. */
#ifdef MAC
XDrawRectangle(dpy, d, gc, sx + 2, sy + 2,
imfsample->eltw - 2, imfsample->elth - 2);
#else
XDrawRectangle(dpy, d, gc, sx + 2, sy + 2,
imfsample->eltw - 3, imfsample->elth - 3);
#endif
} else {
#ifdef MAC
XDrawRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw, imfsample->elth);
#else
XDrawRectangle(dpy, d, gc, sx, sy + 7,
imfsample->eltw - 1, imfsample->elth - 1);
#endif
}
}
}
}
/* Reset the old selected image to the new one if it exists. */
if (imfsample->selected != -1) {
imfsample->previous = imfsample->selected;
}
/* Reset the redraw flag. */
imfsample->redraw = FALSE;
/* If double-buffered, copy to the screen and release the pixmap. */
if (imfsample->double_buffer) {
XCopyArea(imfsample->display, pm, Tk_WindowId(tkwin),
imfsample->copygc,
0, 0, (unsigned) winwidth, (unsigned) winheight, 0, 0);
Tk_FreePixmap(imfsample->display, pm);
}
if (imfsample->show_names) {
Tk_FreeFont(tkfont);
}
/* In theory this shouldn't be necessary, but in practice the
interface widgets (esp. the progress bar fill color) are
affected by the last value of the foreground left over from
drawing, so set to a consistent value. */
/* (Note that as of 2000-09-16, some color errors persist, so
this might not really be necessary -sts) */
XSetForeground(imfsample->display, imfsample->gc, black_color->pixel);
XSetBackground(imfsample->display, imfsample->gc, white_color->pixel);
XSetForeground(imfsample->display, imfsample->copygc, black_color->pixel);
XSetBackground(imfsample->display, imfsample->copygc, white_color->pixel);
}
static void
ComputeScaleGeometry(
register TkScale *scalePtr) /* Information about widget. */
{
char valueString[PRINT_CHARS];
int tmp, valuePixels, x, y, extraSpace;
Tk_FontMetrics fm;
Tk_GetFontMetrics(scalePtr->tkfont, &fm);
scalePtr->fontHeight = fm.linespace + SPACING;
/*
* Horizontal scales are simpler than vertical ones because all sizes are
* the same (the height of a line of text); handle them first and then
* quit.
*/
if (scalePtr->orient == ORIENT_HORIZONTAL) {
y = scalePtr->inset;
extraSpace = 0;
if (scalePtr->labelLength != 0) {
scalePtr->horizLabelY = y + SPACING;
y += scalePtr->fontHeight;
extraSpace = SPACING;
}
if (scalePtr->showValue) {
scalePtr->horizValueY = y + SPACING;
y += scalePtr->fontHeight;
extraSpace = SPACING;
} else {
scalePtr->horizValueY = y;
}
y += extraSpace;
scalePtr->horizTroughY = y;
y += scalePtr->width + 2*scalePtr->borderWidth;
if (scalePtr->tickInterval != 0) {
scalePtr->horizTickY = y + SPACING;
y += scalePtr->fontHeight + SPACING;
}
Tk_GeometryRequest(scalePtr->tkwin,
scalePtr->length + 2*scalePtr->inset, y + scalePtr->inset);
Tk_SetInternalBorder(scalePtr->tkwin, scalePtr->inset);
return;
}
/*
* Vertical scale: compute the amount of space needed to display the
* scales value by formatting strings for the two end points; use
* whichever length is longer.
*/
sprintf(valueString, scalePtr->format, scalePtr->fromValue);
valuePixels = Tk_TextWidth(scalePtr->tkfont, valueString, -1);
sprintf(valueString, scalePtr->format, scalePtr->toValue);
tmp = Tk_TextWidth(scalePtr->tkfont, valueString, -1);
if (valuePixels < tmp) {
valuePixels = tmp;
}
/*
* Assign x-locations to the elements of the scale, working from left to
* right.
*/
x = scalePtr->inset;
if ((scalePtr->tickInterval != 0) && (scalePtr->showValue)) {
scalePtr->vertTickRightX = x + SPACING + valuePixels;
scalePtr->vertValueRightX = scalePtr->vertTickRightX + valuePixels
+ fm.ascent/2;
x = scalePtr->vertValueRightX + SPACING;
} else if (scalePtr->tickInterval != 0) {
scalePtr->vertTickRightX = x + SPACING + valuePixels;
scalePtr->vertValueRightX = scalePtr->vertTickRightX;
x = scalePtr->vertTickRightX + SPACING;
} else if (scalePtr->showValue) {
scalePtr->vertTickRightX = x;
scalePtr->vertValueRightX = x + SPACING + valuePixels;
x = scalePtr->vertValueRightX + SPACING;
} else {
scalePtr->vertTickRightX = x;
scalePtr->vertValueRightX = x;
}
scalePtr->vertTroughX = x;
x += 2*scalePtr->borderWidth + scalePtr->width;
if (scalePtr->labelLength == 0) {
scalePtr->vertLabelX = 0;
} else {
scalePtr->vertLabelX = x + fm.ascent/2;
x = scalePtr->vertLabelX + fm.ascent/2
+ Tk_TextWidth(scalePtr->tkfont, scalePtr->label,
scalePtr->labelLength);
}
Tk_GeometryRequest(scalePtr->tkwin, x + scalePtr->inset,
scalePtr->length + 2*scalePtr->inset);
Tk_SetInternalBorder(scalePtr->tkwin, scalePtr->inset);
}
void
TkpComputeButtonGeometry(
TkButton *butPtr) /* Button whose geometry may have changed. */
{
int width = 0, height = 0, charWidth = 1, haveImage = 0, haveText = 0;
int txtWidth = 0, txtHeight = 0;
MacButton *mbPtr = (MacButton*)butPtr;
Tk_FontMetrics fm;
DrawParams drawParams;
/*
* First figure out the size of the contents of the button.
*/
TkMacOSXComputeButtonParams(butPtr, &mbPtr->btnkind, &mbPtr->drawinfo);
/*
* If the indicator is on, get its size.
*/
if ( butPtr->indicatorOn ) {
switch (butPtr->type) {
case TYPE_RADIO_BUTTON:
GetThemeMetric(kThemeMetricRadioButtonWidth, &butPtr->indicatorDiameter);
break;
case TYPE_CHECK_BUTTON:
GetThemeMetric(kThemeMetricCheckBoxWidth, &butPtr->indicatorDiameter);
break;
default:
break;
}
/* Allow 2px extra space next to the indicator. */
butPtr->indicatorSpace = butPtr->indicatorDiameter + 2;
} else {
butPtr->indicatorSpace = 0;
butPtr->indicatorDiameter = 0;
}
if (butPtr->image != NULL) {
Tk_SizeOfImage(butPtr->image, &width, &height);
haveImage = 1;
} else if (butPtr->bitmap != None) {
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
haveImage = 1;
}
if (haveImage == 0 || butPtr->compound != COMPOUND_NONE) {
Tk_FreeTextLayout(butPtr->textLayout);
butPtr->textLayout = Tk_ComputeTextLayout(butPtr->tkfont,
Tcl_GetString(butPtr->textPtr), -1, butPtr->wrapLength,
butPtr->justify, 0, &butPtr->textWidth, &butPtr->textHeight);
txtWidth = butPtr->textWidth;
txtHeight = butPtr->textHeight;
charWidth = Tk_TextWidth(butPtr->tkfont, "0", 1);
Tk_GetFontMetrics(butPtr->tkfont, &fm);
haveText = (txtWidth != 0 && txtHeight != 0);
}
if (haveImage && haveText) { /* Image and Text */
switch ((enum compound) butPtr->compound) {
case COMPOUND_TOP:
case COMPOUND_BOTTOM:
/*
* Image is above or below text.
*/
height += txtHeight + butPtr->padY;
width = (width > txtWidth ? width : txtWidth);
break;
case COMPOUND_LEFT:
case COMPOUND_RIGHT:
/*
* Image is left or right of text.
*/
width += txtWidth + butPtr->padX;
height = (height > txtHeight ? height : txtHeight);
break;
case COMPOUND_CENTER:
/*
* Image and text are superimposed.
*/
width = (width > txtWidth ? width : txtWidth);
height = (height > txtHeight ? height : txtHeight);
break;
default:
break;
}
width += butPtr->indicatorSpace;
} else if (haveImage) { /* Image only */
width = butPtr->width > 0 ? butPtr->width : width + butPtr->indicatorSpace;
height = butPtr->height > 0 ? butPtr->height : height;
} else { /* Text only */
width = txtWidth + butPtr->indicatorSpace;
height = txtHeight;
if (butPtr->width > 0) {
width = butPtr->width * charWidth;
}
if (butPtr->height > 0) {
height = butPtr->height * fm.linespace;
}
}
/* Add padding */
width += 2 * butPtr->padX;
height += 2 * butPtr->padY;
/*
* Now figure out the size of the border decorations for the button.
*/
if (butPtr->highlightWidth < 0) {
butPtr->highlightWidth = 0;
}
butPtr->inset = 0;
butPtr->inset += butPtr->highlightWidth;
if (TkMacOSXComputeButtonDrawParams(butPtr,&drawParams)) {
HIRect tmpRect;
HIRect contBounds;
int paddingx = 0;
int paddingy = 0;
tmpRect = CGRectMake(0, 0, width, height);
HIThemeGetButtonContentBounds(&tmpRect, &mbPtr->drawinfo, &contBounds);
/* If the content region has a minimum height, match it. */
if (height < contBounds.size.height) {
height = contBounds.size.height;
}
/* If the content region has a minimum width, match it. */
if (width < contBounds.size.width) {
width = contBounds.size.width;
}
/* Pad to fill difference between content bounds and button bounds. */
paddingx = contBounds.origin.x;
paddingy = contBounds.origin.y;
if (height < paddingx - 4) {
/* can't have buttons much shorter than button side diameter. */
height = paddingx - 4;
}
} else {
height += butPtr->borderWidth*2;
width += butPtr->borderWidth*2;
}
width += butPtr->inset*2;
height += butPtr->inset*2;
Tk_GeometryRequest(butPtr->tkwin, width, height);
Tk_SetInternalBorder(butPtr->tkwin, butPtr->inset);
}
void
TkpComputeButtonGeometry(
TkButton *butPtr) /* Button whose geometry may have changed. */
{
int width, height, avgWidth, haveImage = 0, haveText = 0;
int xInset, yInset, txtWidth, txtHeight;
Tk_FontMetrics fm;
DrawParams drawParams;
/*
* First figure out the size of the contents of the button.
*/
width = 0;
height = 0;
txtWidth = 0;
txtHeight = 0;
avgWidth = 0;
butPtr->indicatorSpace = 0;
if (butPtr->image != NULL) {
Tk_SizeOfImage(butPtr->image, &width, &height);
haveImage = 1;
} else if (butPtr->bitmap != None) {
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
haveImage = 1;
}
if (haveImage == 0 || butPtr->compound != COMPOUND_NONE) {
Tk_FreeTextLayout(butPtr->textLayout);
butPtr->textLayout = Tk_ComputeTextLayout(butPtr->tkfont,
Tcl_GetString(butPtr->textPtr), -1, butPtr->wrapLength,
butPtr->justify, 0, &butPtr->textWidth, &butPtr->textHeight);
txtWidth = butPtr->textWidth;
txtHeight = butPtr->textHeight;
avgWidth = Tk_TextWidth(butPtr->tkfont, "0", 1);
Tk_GetFontMetrics(butPtr->tkfont, &fm);
haveText = (txtWidth != 0 && txtHeight != 0);
}
/*
* If the button is compound (ie, it shows both an image and text),
* the new geometry is a combination of the image and text geometry.
* We only honor the compound bit if the button has both text and an
* image, because otherwise it is not really a compound button.
*/
if (butPtr->compound != COMPOUND_NONE && haveImage && haveText) {
switch ((enum compound) butPtr->compound) {
case COMPOUND_TOP:
case COMPOUND_BOTTOM:
/*
* Image is above or below text.
*/
height += txtHeight + butPtr->padY;
width = (width > txtWidth ? width : txtWidth);
break;
case COMPOUND_LEFT:
case COMPOUND_RIGHT:
/*
* Image is left or right of text.
*/
width += txtWidth + butPtr->padX;
height = (height > txtHeight ? height : txtHeight);
break;
case COMPOUND_CENTER:
/*
* Image and text are superimposed.
*/
width = (width > txtWidth ? width : txtWidth);
height = (height > txtHeight ? height : txtHeight);
break;
case COMPOUND_NONE:
break;
}
if (butPtr->width > 0) {
width = butPtr->width;
}
if (butPtr->height > 0) {
height = butPtr->height;
}
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
butPtr->indicatorSpace = height;
if (butPtr->type == TYPE_CHECK_BUTTON) {
butPtr->indicatorDiameter = (65 * height)/100;
} else {
butPtr->indicatorDiameter = (75 * height)/100;
}
}
width += 2 * butPtr->padX;
height += 2 * butPtr->padY;
} else if (haveImage) {
if (butPtr->width > 0) {
width = butPtr->width;
}
if (butPtr->height > 0) {
height = butPtr->height;
}
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
butPtr->indicatorSpace = height;
if (butPtr->type == TYPE_CHECK_BUTTON) {
butPtr->indicatorDiameter = (65 * height)/100;
} else {
butPtr->indicatorDiameter = (75 * height)/100;
}
}
} else {
width = txtWidth;
height = txtHeight;
if (butPtr->width > 0) {
width = butPtr->width * avgWidth;
}
if (butPtr->height > 0) {
height = butPtr->height * fm.linespace;
}
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
butPtr->indicatorDiameter = fm.linespace;
if (butPtr->type == TYPE_CHECK_BUTTON) {
butPtr->indicatorDiameter =
(80 * butPtr->indicatorDiameter)/100;
}
butPtr->indicatorSpace = butPtr->indicatorDiameter + avgWidth;
}
}
/*
* Now figure out the size of the border decorations for the button.
*/
if (butPtr->highlightWidth < 0) {
butPtr->highlightWidth = 0;
}
/*
* The width and height calculation for Appearance buttons with images &
* non-Appearance buttons with images is different. In the latter case,
* we add the borderwidth to the inset, since we are going to stamp a
* 3-D border over the image. In the former, we add it to the height,
* directly, since Appearance will draw the border as part of our control.
*
* When issuing the geometry request, add extra space for the indicator,
* if any, and for the border and padding, plus if this is an image two
* extra pixels so the display can be offset by 1 pixel in either
* direction for the raised or lowered effect.
*
* The highlight width corresponds to the default ring on the Macintosh.
* As such, the highlight width is only added if the button is the default
* button. The actual width of the default ring is one less than the
* highlight width as there is also one pixel of spacing.
* Appearance buttons with images do not have a highlight ring, because the
* Bevel button type does not support one.
*/
if ((butPtr->image == None) && (butPtr->bitmap == None)) {
width += 2*butPtr->padX;
height += 2*butPtr->padY;
}
if ((butPtr->type == TYPE_BUTTON)) {
if ((butPtr->image == None) && (butPtr->bitmap == None)) {
butPtr->inset = 0;
if (butPtr->defaultState != STATE_DISABLED) {
butPtr->inset += butPtr->highlightWidth;
}
} else {
butPtr->inset = 0;
width += (2 * butPtr->borderWidth + 4);
height += (2 * butPtr->borderWidth + 4);
}
} else if (butPtr->type == TYPE_LABEL) {
butPtr->inset = butPtr->borderWidth;
} else if (butPtr->indicatorOn) {
butPtr->inset = 0;
} else {
/*
* Under Appearance, the Checkbutton or radiobutton with an image
* is represented by a BevelButton with the Sticky defProc...
* So we must set its height in the same way as the Button
* with an image or bitmap.
*/
if (butPtr->image != None || butPtr->bitmap != None) {
int border;
butPtr->inset = 0;
if (butPtr->borderWidth <= 2) {
border = 6;
} else {
border = 2 * butPtr->borderWidth + 2;
}
width += border;
height += border;
} else {
butPtr->inset = butPtr->borderWidth;
}
}
if (TkMacOSXComputeDrawParams(butPtr, &drawParams)) {
xInset = butPtr->indicatorSpace + DEF_INSET_LEFT + DEF_INSET_RIGHT;
yInset = DEF_INSET_TOP + DEF_INSET_BOTTOM;
} else {
xInset = butPtr->indicatorSpace+butPtr->inset*2;
yInset = butPtr->inset*2;
}
Tk_GeometryRequest(butPtr->tkwin, width + xInset, height + yInset);
Tk_SetInternalBorder(butPtr->tkwin, butPtr->inset);
}
/* Initialisation, based on tkMain.c */
value camltk_opentk(value argv) /* ML */
{
/* argv must contain argv[0], the application command name */
value tmp = Val_unit;
char *argv0;
Begin_root(tmp);
if ( argv == Val_int(0) ){
failwith("camltk_opentk: argv is empty");
}
argv0 = String_val( Field( argv, 0 ) );
if (!cltk_slave_mode) {
/* Create an interpreter, dies if error */
#if TCL_MAJOR_VERSION >= 8
Tcl_FindExecutable(String_val(argv0));
#endif
cltclinterp = Tcl_CreateInterp();
if (Tcl_Init(cltclinterp) != TCL_OK)
tk_error(cltclinterp->result);
Tcl_SetVar(cltclinterp, "argv0", String_val (argv0), TCL_GLOBAL_ONLY);
{ /* Sets argv if needed */
int argc = 0;
tmp = Field(argv, 1); /* starts from argv[1] */
while ( tmp != Val_int(0) ) {
argc++;
tmp = Field(tmp, 1);
}
if( argc != 0 ){
int i;
char *args;
char **tkargv;
char argcstr[256];
tkargv = malloc( sizeof( char* ) * argc );
tmp = Field(argv, 1); /* starts from argv[1] */
i = 0;
while ( tmp != Val_int(0) ) {
tkargv[i] = String_val(Field(tmp, 0));
tmp = Field(tmp, 1);
i++;
}
sprintf( argcstr, "%d", argc );
Tcl_SetVar(cltclinterp, "argc", argcstr, TCL_GLOBAL_ONLY);
args = Tcl_Merge(argc, tkargv); /* args must be freed by Tcl_Free */
Tcl_SetVar(cltclinterp, "argv", args, TCL_GLOBAL_ONLY);
Tcl_Free(args);
free( tkargv );
}
}
if (Tk_Init(cltclinterp) != TCL_OK)
tk_error(cltclinterp->result);
/* Retrieve the main window */
cltk_mainWindow = Tk_MainWindow(cltclinterp);
if (NULL == cltk_mainWindow)
tk_error(cltclinterp->result);
Tk_GeometryRequest(cltk_mainWindow,200,200);
}
/* Create the camlcallback command */
Tcl_CreateCommand(cltclinterp,
CAMLCB, CamlCBCmd,
(ClientData)NULL,(Tcl_CmdDeleteProc *)NULL);
/* This is required by "unknown" and thus autoload */
Tcl_SetVar(cltclinterp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);
/* Our hack for implementing break in callbacks */
Tcl_SetVar(cltclinterp, "BreakBindingsSequence", "0", TCL_GLOBAL_ONLY);
/* Load the traditional rc file */
{
char *home = getenv("HOME");
if (home != NULL) {
char *f = stat_alloc(strlen(home)+strlen(RCNAME)+2);
f[0]='\0';
strcat(f, home);
strcat(f, "/");
strcat(f, RCNAME);
if (0 == access(f,R_OK))
if (TCL_OK != Tcl_EvalFile(cltclinterp,f)) {
stat_free(f);
tk_error(cltclinterp->result);
};
stat_free(f);
}
}
End_roots();
return Val_unit;
}
void
TkpComputeButtonGeometry(
register TkButton *butPtr) /* Button whose geometry may have changed. */
{
int width, height, avgWidth, txtWidth, txtHeight;
int haveImage = 0, haveText = 0;
Tk_FontMetrics fm;
butPtr->inset = butPtr->highlightWidth + butPtr->borderWidth;
/*
* Leave room for the default ring if needed.
*/
if (butPtr->defaultState != DEFAULT_DISABLED) {
butPtr->inset += 5;
}
butPtr->indicatorSpace = 0;
width = 0;
height = 0;
txtWidth = 0;
txtHeight = 0;
avgWidth = 0;
if (butPtr->image != NULL) {
Tk_SizeOfImage(butPtr->image, &width, &height);
haveImage = 1;
} else if (butPtr->bitmap != None) {
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
haveImage = 1;
}
if (haveImage == 0 || butPtr->compound != COMPOUND_NONE) {
Tk_FreeTextLayout(butPtr->textLayout);
butPtr->textLayout = Tk_ComputeTextLayout(butPtr->tkfont,
Tcl_GetString(butPtr->textPtr), -1, butPtr->wrapLength,
butPtr->justify, 0, &butPtr->textWidth, &butPtr->textHeight);
txtWidth = butPtr->textWidth;
txtHeight = butPtr->textHeight;
avgWidth = Tk_TextWidth(butPtr->tkfont, "0", 1);
Tk_GetFontMetrics(butPtr->tkfont, &fm);
haveText = (txtWidth != 0 && txtHeight != 0);
}
/*
* If the button is compound (i.e., it shows both an image and text), the
* new geometry is a combination of the image and text geometry. We only
* honor the compound bit if the button has both text and an image,
* because otherwise it is not really a compound button.
*/
if (butPtr->compound != COMPOUND_NONE && haveImage && haveText) {
switch ((enum compound) butPtr->compound) {
case COMPOUND_TOP:
case COMPOUND_BOTTOM:
/*
* Image is above or below text.
*/
height += txtHeight + butPtr->padY;
width = (width > txtWidth ? width : txtWidth);
break;
case COMPOUND_LEFT:
case COMPOUND_RIGHT:
/*
* Image is left or right of text.
*/
width += txtWidth + butPtr->padX;
height = (height > txtHeight ? height : txtHeight);
break;
case COMPOUND_CENTER:
/*
* Image and text are superimposed.
*/
width = (width > txtWidth ? width : txtWidth);
height = (height > txtHeight ? height : txtHeight);
break;
case COMPOUND_NONE:
break;
}
if (butPtr->width > 0) {
width = butPtr->width;
}
if (butPtr->height > 0) {
height = butPtr->height;
}
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
butPtr->indicatorSpace = height;
if (butPtr->type == TYPE_CHECK_BUTTON) {
butPtr->indicatorDiameter = (65*height)/100;
} else {
butPtr->indicatorDiameter = (75*height)/100;
}
}
width += 2*butPtr->padX;
height += 2*butPtr->padY;
} else {
if (haveImage) {
if (butPtr->width > 0) {
width = butPtr->width;
}
if (butPtr->height > 0) {
height = butPtr->height;
}
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
butPtr->indicatorSpace = height;
if (butPtr->type == TYPE_CHECK_BUTTON) {
butPtr->indicatorDiameter = (65*height)/100;
} else {
butPtr->indicatorDiameter = (75*height)/100;
}
}
} else {
width = txtWidth;
height = txtHeight;
if (butPtr->width > 0) {
width = butPtr->width * avgWidth;
}
if (butPtr->height > 0) {
height = butPtr->height * fm.linespace;
}
if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
butPtr->indicatorDiameter = fm.linespace;
if (butPtr->type == TYPE_CHECK_BUTTON) {
butPtr->indicatorDiameter =
(80*butPtr->indicatorDiameter)/100;
}
butPtr->indicatorSpace = butPtr->indicatorDiameter + avgWidth;
}
}
}
/*
* When issuing the geometry request, add extra space for the indicator,
* if any, and for the border and padding, plus two extra pixels so the
* display can be offset by 1 pixel in either direction for the raised or
* lowered effect.
*/
if ((butPtr->image == NULL) && (butPtr->bitmap == None)) {
width += 2*butPtr->padX;
height += 2*butPtr->padY;
}
if ((butPtr->type == TYPE_BUTTON) && !Tk_StrictMotif(butPtr->tkwin)) {
width += 2;
height += 2;
}
Tk_GeometryRequest(butPtr->tkwin, (int) (width + butPtr->indicatorSpace
+ 2*butPtr->inset), (int) (height + 2*butPtr->inset));
Tk_SetInternalBorder(butPtr->tkwin, butPtr->inset);
}
/*--------------------------------------------------------------------------*/
static void *DaemonOpenTCLsci(void* in)
/* Checks if tcl/tk has already been initialised and if not */
/* initialise it. It must find the tcl script */
{
char *SciPath = NULL;
char *SciPathShort = NULL;
char *TkScriptpathShort = NULL;
BOOL tkStarted = FALSE;
BOOL bOK = FALSE;
char TkScriptpath[PATH_MAX];
char MyCommand[2048]; /* @TODO: Check for buffer overflow */
#ifndef _MSC_VER
DIR *tmpdir = NULL;
#endif
FILE *tmpfile2 = NULL;
SciPath = GetSciPath();
/* test SCI validity */
if (SciPath == NULL)
{
sciprint(_("The SCI environment variable is not set.\nTCL initialisation failed !\n"));
}
SciPathShort = getshortpathname(SciPath, &bOK);
#ifdef TCL_MAJOR_VERSION
#ifdef TCL_MINOR_VERSION
#if TCL_MAJOR_VERSION >= 8
#if TCL_MINOR_VERSION > 0
Tcl_FindExecutable(" ");
#endif
#endif
#endif
#endif
#ifdef _MSC_VER
strcpy(TkScriptpath, SciPathShort);
strcat(TkScriptpath, "/modules/tclsci/tcl/TK_Scilab.tcl");
TkScriptpathShort = getshortpathname(TkScriptpath, &bOK);
tmpfile2 = fopen(TkScriptpathShort, "r");
if (tmpfile2 == NULL)
{
sciprint(_("Unable to find Tcl initialisation scripts.\nCheck your SCI environment variable.\nTcl initialisation failed !"));
}
else
{
fclose(tmpfile2);
}
#else
tmpdir = opendir(SciPathShort);
if (tmpdir == NULL)
{
sciprint(_("The SCI environment variable is not set.\nTcl initialisation failed !\n"));
}
else
{
closedir(tmpdir);
}
strcpy(TkScriptpath, SciPathShort);
strcat(TkScriptpath, "/modules/tclsci/tcl/TK_Scilab.tcl");
TkScriptpathShort = getshortpathname(TkScriptpath, &bOK);
tmpfile2 = fopen(TkScriptpathShort, "r");
if (tmpfile2 == NULL)
{
sciprint(_("Unable to find Tcl initialisation scripts.\nCheck your SCI environment variable.\nTcl initialisation failed !"));
}
else
{
fclose(tmpfile2);
}
#endif /* _MSC_VER */
if (getTclInterp() == NULL)
{
releaseTclInterp();
initTclInterp();
#ifdef _MSC_VER
/* Initialize TCL_LIBRARY & TK_LIBRARY variables environment */
/* Windows only */
SetTclTkEnvironment(SciPathShort);
#endif
if ( getTclInterp() == NULL )
{
Scierror(999, _("Tcl Error: Unable to create Tcl interpreter (Tcl_CreateInterp).\n"));
}
releaseTclInterp();
if ( Tcl_Init(getTclInterp()) == TCL_ERROR)
{
releaseTclInterp();
Scierror(999, _("Tcl Error: Error during the Tcl initialization (Tcl_Init): %s\n"), Tcl_GetStringResult(getTclInterp()));
}
releaseTclInterp();
if (getenv("SCI_DISABLE_TK") == NULL)
{
/* When SCI_DISABLE_TK is set in the env disable the TK init
* process. It is causing issues when Scilab is
* used through ssh. */
if ( Tk_Init(getTclInterp()) == TCL_ERROR)
{
releaseTclInterp();
Scierror(999, _("Tcl Error: Error during the TK initialization (Tk_Init): %s\n"), Tcl_GetStringResult(getTclInterp()));
}
else
{
tkStarted = TRUE;
}
releaseTclInterp();
}
sprintf(MyCommand, "set SciPath \"%s\";", SciPathShort);
if ( Tcl_Eval(getTclInterp(), MyCommand) == TCL_ERROR )
{
releaseTclInterp();
Scierror(999, _("Tcl Error: Error during the Scilab/Tcl init process. Could not set SciPath: %s\n"), Tcl_GetStringResult(getTclInterp()));
}
releaseTclInterp();
Tcl_CreateCommand(getTclInterp(), "ScilabEval", TCL_EvalScilabCmd, (ClientData)1, NULL);
releaseTclInterp();
}
if (TKmainWindow == NULL && tkStarted)
{
TKmainWindow = Tk_MainWindow(getTclInterp());
releaseTclInterp();
Tk_GeometryRequest(TKmainWindow, 2, 2);
//printf("TkScriptpathShort : |%s|\n", TkScriptpathShort);
if ( Tcl_EvalFile(getTclInterp(), TkScriptpathShort) == TCL_ERROR )
{
releaseTclInterp();
Scierror(999, _("Tcl Error: Error during the Scilab/TK init process. Error while loading %s: %s\n"), TkScriptpathShort, Tcl_GetStringResult(getTclInterp()));
}
releaseTclInterp();
}
if (SciPath)
{
FREE(SciPath);
SciPath = NULL;
}
if (SciPathShort)
{
FREE(SciPathShort);
SciPathShort = NULL;
}
if (TkScriptpathShort)
{
FREE(TkScriptpathShort);
TkScriptpathShort = NULL;
}
// This start a periodic and endless call to "update"
// TCL command. This causes any TCL application to start
// and run as if it's in the main program thread.
startTclLoop();
return(0);
}
