/*
* Our class command procedure. This is different from usual class command
* procs as we actually use the SheetCmd() procedure and then carefully
* subvert their actions to our own uses.
*/
static int NamesCmd(ClientData clientData, Tcl_Interp *interp,
int argc, char **argv) {
Tk_Window tkwin;
edNames *en;
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " pathName ?options?\"", (char *)NULL);
return TCL_ERROR;
}
/*
* Allocate
*/
if (NULL == (en = (edNames *)xmalloc(sizeof(edNames)))) {
return TCL_ERROR;
}
/*
* Call common sheet initialisation code
*/
tkwin = SheetCmdCommon(interp, Tk_MainWindow(interp),
configSpecs, (tkSheet *)en,
argv[1], "EdNames");
if (NULL == tkwin) {
xfree(en);
return TCL_ERROR;
}
/*
* Initialised rest of edNames structure.
*/
en->xx = NULL;
en->xScrollCmd = NULL;
TKSHEET(en)->extensionData = (ClientData)en;
TKSHEET(en)->extension = EdNamesSheetExtension;
/*
* Register our instance of the widget class
*/
Tcl_CreateCommand(interp, Tk_PathName(tkwin),
NamesWidgetCmd, (ClientData)en,
(Tcl_CmdDeleteProc *)NULL);
/*
* And process our arguments - send them to Configure
*/
if (NamesConfigure(interp, en, argc-2, argv+2, 0) != TCL_OK) {
Tk_DestroyWindow(tkwin);
return TCL_ERROR;
}
Tcl_SetResult(interp, Tk_PathName(tkwin), TCL_VOLATILE);
return TCL_OK;
}
int
GraphViewCmd(CLIENT_ARGS)
{
SimGraph *graph;
Tk_Window tkwin = (Tk_Window) clientData;
if (argc < 2) {
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " pathName ?options?\"", (char *) NULL);
return TCL_ERROR;
}
tkwin = Tk_CreateWindowFromPath(interp, tkwin,
argv[1], (char *) NULL);
if (tkwin == NULL) {
return TCL_ERROR;
}
graph = (SimGraph *)ckalloc(sizeof (SimGraph));
graph->tkwin = tkwin;
graph->interp = interp;
graph->flags = 0;
Tk_SetClass(graph->tkwin, "GraphView");
Tk_CreateEventHandler(graph->tkwin,
VisibilityChangeMask |
ExposureMask |
StructureNotifyMask,
SimGraphEventProc, (ClientData) graph);
Tcl_CreateCommand(interp, Tk_PathName(graph->tkwin),
DoGraphCmd, (ClientData) graph, (void (*)()) NULL);
/*
Tk_MakeWindowExist(graph->tkwin);
*/
if (getenv("XSYNCHRONIZE") != NULL) {
XSynchronize(Tk_Display(tkwin), 1);
}
InitNewGraph(graph);
DoNewGraph(graph);
if (ConfigureSimGraph(interp, graph, argc-2, argv+2, 0) != TCL_OK) {
/* XXX: destroy graph */
Tk_DestroyWindow(graph->tkwin);
return TCL_ERROR;
}
interp->result = Tk_PathName(graph->tkwin);
return TCL_OK;
}
/*
** Create the window name for a child widget. Space to hold the name
** is obtained from HtmlAlloc() and must be freed by the calling function.
*/
static char *MakeWindowName(
HtmlWidget *htmlPtr, /* The HTML widget */
HtmlElement *pElem /* The input that needs a child widget */
){
int n;
char *zBuf;
n = strlen(Tk_PathName(htmlPtr->clipwin));
zBuf = HtmlAlloc( n + 20 );
sprintf(zBuf,"%s.x%d",Tk_PathName(htmlPtr->clipwin), pElem->input.cnt);
return zBuf;
}
/*
* Add a consensus trace to the trace display.
*/
void cons_edc_trace(EdStruct *xx, int start, int end, int strand, int match,
int exception) {
Read *r;
char *pname;
char buf[1024];
Tcl_Interp *interp = EDINTERP(xx->ed);
int exists;
tman_dc *ed;
DisplayContext *dc;
static int cons_counter = 0;
Tcl_CmdInfo info;
int pos;
/* Produce the read structure */
if (NULL == (r = cons_trace(xx, start, end, strand, match, exception))) {
bell();
return;
}
/* Create a trace display */
pname = get_default_string(interp, gap_defs, "TRACE_DISPLAY.WIN");
Tcl_VarEval(interp, "trace_create ",
Tk_PathName(EDTKWIN(xx->ed)), pname, " ",
Tk_PathName(EDTKWIN(xx->ed)),
" consensus", NULL);
pname = interp->result;
/* Fill out the tman_dc and DisplayContext structures */
sprintf(buf, "Cons %d", cons_counter++);
dc = getTDisplay(xx, buf, 0, 0, &exists);
strcpy(dc->path, pname);
ed = find_free_edc();
ed->dc = dc;
ed->pos = start-1;
ed->xx = xx;
ed->seq = 0;
ed->type = TRACE_TYPE_CON;
/* Add the Read to the trace widget */
Tcl_GetCommandInfo(interp, interp->result, &info);
trace_memory_load((DNATrace *)info.clientData, r);
dc->tracePtr = (DNATrace *)info.clientData;
/* Adjust position */
Tcl_Eval(interp, "update idletasks");
pos = positionInContig(xx, xx->cursorSeq, xx->cursorPos) - start;
repositionSeq(xx, dc, pos);
}
static int AddPane(
Tcl_Interp *interp, Paned *pw,
int destIndex, Tk_Window slaveWindow,
int objc, Tcl_Obj *const objv[])
{
Pane *pane;
if (!Ttk_Maintainable(interp, slaveWindow, pw->core.tkwin)) {
return TCL_ERROR;
}
if (Ttk_SlaveIndex(pw->paned.mgr, slaveWindow) >= 0) {
Tcl_AppendResult(interp,
Tk_PathName(slaveWindow), " already added",
NULL);
return TCL_ERROR;
}
pane = CreatePane(interp, pw, slaveWindow);
if (!pane) {
return TCL_ERROR;
}
if (ConfigurePane(interp, pw, pane, slaveWindow, objc, objv) != TCL_OK) {
DestroyPane(pw, pane);
return TCL_ERROR;
}
Ttk_InsertSlave(pw->paned.mgr, destIndex, slaveWindow, pane);
return TCL_OK;
}
DoSetWandState(SimView *view, short state)
{
char buf[256];
sprintf(buf, "UISetToolState %s %d", Tk_PathName(view->tkwin), state);
Eval(buf);
}
static void
EmbWinStructureProc(
ClientData clientData, /* Pointer to record describing window item. */
XEvent *eventPtr) /* Describes what just happened. */
{
TkTextEmbWindowClient *client = clientData;
TkTextSegment *ewPtr = client->parent;
TkTextIndex index;
Tcl_HashEntry *hPtr;
if (eventPtr->type != DestroyNotify) {
return;
}
hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.sharedTextPtr->windowTable,
Tk_PathName(client->tkwin));
if (hPtr != NULL) {
/*
* This may not exist if the entire widget is being deleted.
*/
Tcl_DeleteHashEntry(hPtr);
}
ewPtr->body.ew.tkwin = NULL;
client->tkwin = NULL;
index.tree = ewPtr->body.ew.sharedTextPtr->tree;
index.linePtr = ewPtr->body.ew.linePtr;
index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr);
TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index);
TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL,
index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY);
}
/* ARGSUSED */
static int
EmbWinDeleteProc(
TkTextSegment *ewPtr, /* Segment being deleted. */
TkTextLine *linePtr, /* Line containing segment. */
int treeGone) /* Non-zero means the entire tree is being
* deleted, so everything must get cleaned
* up. */
{
TkTextEmbWindowClient *client;
client = ewPtr->body.ew.clients;
while (client != NULL) {
TkTextEmbWindowClient *next = client->next;
Tcl_HashEntry *hPtr = NULL;
if (client->tkwin != NULL) {
hPtr = Tcl_FindHashEntry(
&ewPtr->body.ew.sharedTextPtr->windowTable,
Tk_PathName(client->tkwin));
}
TkTextWinFreeClient(hPtr, client);
client = next;
}
ewPtr->body.ew.clients = NULL;
Tk_FreeConfigOptions((char *) &ewPtr->body.ew, ewPtr->body.ew.optionTable,
NULL);
/*
* Free up all memory allocated.
*/
ckfree((char *) ewPtr);
return 0;
}
static void
OpenGLEventProc(ClientData clientData, XEvent *eventPtr)
{
OpenGLClientData *OpenGLPtr = (OpenGLClientData *) clientData;
if (eventPtr->type == DestroyNotify)
{
#ifndef _WIN32
glXMakeContextCurrent(OpenGLPtr->display, None, None, 0);
#else
wglMakeCurrent(OpenGLPtr->hDC,0);
#endif
XSync(OpenGLPtr->display, False);
// glXDestroyWindow(OpenGLPtr->display, OpenGLPtr->glx_win);
#ifndef _WIN32
glXDestroyContext(OpenGLPtr->display, OpenGLPtr->cx);
#else
wglDeleteContext( OpenGLPtr->cx );
#endif
XSync(OpenGLPtr->display, False);
Tcl_DeleteCommand(OpenGLPtr->interp, Tk_PathName(OpenGLPtr->tkwin));
OpenGLPtr->tkwin = NULL;
Tk_EventuallyFree((ClientData) OpenGLPtr, (Tcl_FreeProc*)OpenGLDestroy);
}
}
DidTool(SimView *view, char *name, short x, short y)
{
char buf[256];
if (view != NULL) {
sprintf(buf, "UIDidTool%s %s %d %d",
name, Tk_PathName(view->tkwin), x, y);
Eval(buf);
}
}
static int
PlaceInfoCommand(
Tcl_Interp *interp, /* Interp into which to place result. */
Tk_Window tkwin) /* Token for the window to get info on. */
{
char buffer[32 + TCL_INTEGER_SPACE];
Slave *slavePtr;
slavePtr = FindSlave(tkwin);
if (slavePtr == NULL) {
return TCL_OK;
}
if (slavePtr->masterPtr != NULL) {
Tcl_AppendElement(interp, "-in");
Tcl_AppendElement(interp, Tk_PathName(slavePtr->masterPtr->tkwin));
}
sprintf(buffer, " -x %d", slavePtr->x);
Tcl_AppendResult(interp, buffer, NULL);
sprintf(buffer, " -relx %.4g", slavePtr->relX);
Tcl_AppendResult(interp, buffer, NULL);
sprintf(buffer, " -y %d", slavePtr->y);
Tcl_AppendResult(interp, buffer, NULL);
sprintf(buffer, " -rely %.4g", slavePtr->relY);
Tcl_AppendResult(interp, buffer, NULL);
if (slavePtr->flags & CHILD_WIDTH) {
sprintf(buffer, " -width %d", slavePtr->width);
Tcl_AppendResult(interp, buffer, NULL);
} else {
Tcl_AppendResult(interp, " -width {}", NULL);
}
if (slavePtr->flags & CHILD_REL_WIDTH) {
sprintf(buffer, " -relwidth %.4g", slavePtr->relWidth);
Tcl_AppendResult(interp, buffer, NULL);
} else {
Tcl_AppendResult(interp, " -relwidth {}", NULL);
}
if (slavePtr->flags & CHILD_HEIGHT) {
sprintf(buffer, " -height %d", slavePtr->height);
Tcl_AppendResult(interp, buffer, NULL);
} else {
Tcl_AppendResult(interp, " -height {}", NULL);
}
if (slavePtr->flags & CHILD_REL_HEIGHT) {
sprintf(buffer, " -relheight %.4g", slavePtr->relHeight);
Tcl_AppendResult(interp, buffer, NULL);
} else {
Tcl_AppendResult(interp, " -relheight {}", NULL);
}
Tcl_AppendElement(interp, "-anchor");
Tcl_AppendElement(interp, Tk_NameOfAnchor(slavePtr->anchor));
Tcl_AppendElement(interp, "-bordermode");
Tcl_AppendElement(interp, borderModeStrings[slavePtr->borderMode]);
return TCL_OK;
}
static void
SetHelpMenu(
TkMenu *menuPtr) /* The menu we are checking */
{
TkMenuEntry *cascadeEntryPtr;
int useMotifHelp = 0;
const char *option = NULL;
if (menuPtr->tkwin) {
option = Tk_GetOption(menuPtr->tkwin, "useMotifHelp", "UseMotifHelp");
if (option != NULL) {
Tcl_GetBoolean(NULL, option, &useMotifHelp);
}
}
if (!useMotifHelp) {
return;
}
for (cascadeEntryPtr = menuPtr->menuRefPtr->parentEntryPtr;
cascadeEntryPtr != NULL;
cascadeEntryPtr = cascadeEntryPtr->nextCascadePtr) {
if ((cascadeEntryPtr->menuPtr->menuType == MENUBAR)
&& (cascadeEntryPtr->menuPtr->masterMenuPtr->tkwin != NULL)
&& (menuPtr->masterMenuPtr->tkwin != NULL)) {
TkMenu *masterMenuPtr = cascadeEntryPtr->menuPtr->masterMenuPtr;
char *helpMenuName = ckalloc(strlen(Tk_PathName(
masterMenuPtr->tkwin)) + strlen(".help") + 1);
strcpy(helpMenuName, Tk_PathName(masterMenuPtr->tkwin));
strcat(helpMenuName, ".help");
if (strcmp(helpMenuName,
Tk_PathName(menuPtr->masterMenuPtr->tkwin)) == 0) {
cascadeEntryPtr->entryFlags |= ENTRY_HELP_MENU;
} else {
cascadeEntryPtr->entryFlags &= ~ENTRY_HELP_MENU;
}
ckfree(helpMenuName);
}
}
}
static void
CheckbuttonInitialize(Tcl_Interp *interp, void *recordPtr)
{
Checkbutton *checkPtr = recordPtr;
Tcl_Obj *variableObj;
/* default -variable is the widget name:
*/
variableObj = Tcl_NewStringObj(Tk_PathName(checkPtr->core.tkwin), -1);
Tcl_IncrRefCount(variableObj);
checkPtr->checkbutton.variableObj = variableObj;
BaseInitialize(interp, recordPtr);
}
/* ++ Ttk_Maintainable(interp, slave, master) --
* Utility routine. Verifies that 'master' may be used to maintain
* the geometry of 'slave' via Tk_MaintainGeometry:
*
* + 'master' is either 'slave's parent -OR-
* + 'master is a descendant of 'slave's parent.
* + 'slave' is not a toplevel window
* + 'slave' belongs to the same toplevel as 'master'
*
* Returns: 1 if OK; otherwise 0, leaving an error message in 'interp'.
*/
int Ttk_Maintainable(Tcl_Interp *interp, Tk_Window slave, Tk_Window master)
{
Tk_Window ancestor = master, parent = Tk_Parent(slave);
if (Tk_IsTopLevel(slave) || slave == master) {
goto badWindow;
}
while (ancestor != parent) {
if (Tk_IsTopLevel(ancestor)) {
goto badWindow;
}
ancestor = Tk_Parent(ancestor);
}
return 1;
badWindow:
Tcl_AppendResult(interp,
"can't add ", Tk_PathName(slave),
" as slave of ", Tk_PathName(master),
NULL);
return 0;
}
static void
EmbWinLostSlaveProc(
ClientData clientData, /* Pointer to record describing window item. */
Tk_Window tkwin) /* Window that was claimed away by another
* geometry manager. */
{
TkTextEmbWindowClient *client = clientData;
TkTextSegment *ewPtr = client->parent;
TkTextIndex index;
Tcl_HashEntry *hPtr;
TkTextEmbWindowClient *loop;
Tk_DeleteEventHandler(client->tkwin, StructureNotifyMask,
EmbWinStructureProc, client);
Tcl_CancelIdleCall(EmbWinDelayedUnmap, client);
if (client->textPtr->tkwin != Tk_Parent(tkwin)) {
Tk_UnmaintainGeometry(tkwin, client->textPtr->tkwin);
} else {
Tk_UnmapWindow(tkwin);
}
hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.sharedTextPtr->windowTable,
Tk_PathName(client->tkwin));
Tcl_DeleteHashEntry(hPtr);
client->tkwin = NULL;
ewPtr->body.ew.tkwin = NULL;
/*
* Free up the memory allocation for this client.
*/
loop = ewPtr->body.ew.clients;
if (loop == client) {
ewPtr->body.ew.clients = client->next;
} else {
while (loop->next != client) {
loop = loop->next;
}
loop->next = client->next;
}
ckfree((char *) client);
index.tree = ewPtr->body.ew.sharedTextPtr->tree;
index.linePtr = ewPtr->body.ew.linePtr;
index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr);
TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index);
TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL,
index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY);
}
static void
Percents_Any(
QE_ExpandArgs *args, /* %-substitution args. */
QE_ExpandProc proc, /* Function to return value for a given
* %-char. */
CONST char *chars /* NULL-terminated list of %-chars. */
)
{
struct {
TreeCtrl *tree;
} *data = args->clientData;
char chars2[64];
switch (args->which) {
case 'd': /* detail */
QE_ExpandDetail(args->bindingTable, args->event, args->detail,
args->result);
break;
case 'e': /* event */
QE_ExpandEvent(args->bindingTable, args->event, args->result);
break;
case 'P': /* pattern */
QE_ExpandPattern(args->bindingTable, args->event, args->detail, args->result);
break;
case 'W': /* object */
QE_ExpandString((char *) args->object, args->result);
break;
case 'T': /* tree */
QE_ExpandString(Tk_PathName(data->tree->tkwin), args->result);
break;
case '?':
strcpy(chars2, "TWPed");
strcat(chars2, chars);
DumpPercents(args, proc, chars2);
break;
default:
QE_ExpandUnknown(args->which, args->result);
break;
}
}
int Ttk_GetSlaveIndexFromObj(
Tcl_Interp *interp, Ttk_Manager *mgr, Tcl_Obj *objPtr, int *indexPtr)
{
const char *string = Tcl_GetString(objPtr);
int slaveIndex = 0;
Tk_Window tkwin;
/* Try interpreting as an integer first:
*/
if (Tcl_GetIntFromObj(NULL, objPtr, &slaveIndex) == TCL_OK) {
if (slaveIndex < 0 || slaveIndex >= mgr->nSlaves) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp,
"Slave index ", Tcl_GetString(objPtr), " out of bounds",
NULL);
return TCL_ERROR;
}
*indexPtr = slaveIndex;
return TCL_OK;
}
/* Try interpreting as a slave window name;
*/
if ( (*string == '.')
&& (tkwin = Tk_NameToWindow(interp, string, mgr->masterWindow)))
{
slaveIndex = Ttk_SlaveIndex(mgr, tkwin);
if (slaveIndex < 0) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp,
string, " is not managed by ", Tk_PathName(mgr->masterWindow),
NULL);
return TCL_ERROR;
}
*indexPtr = slaveIndex;
return TCL_OK;
}
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Invalid slave specification ", string, NULL);
return TCL_ERROR;
}
/* UpdateScrollbar --
* Call the -scrollcommand callback to sync the scrollbar.
* Returns: Whatever the -scrollcommand does.
*/
static int UpdateScrollbar(Tcl_Interp *interp, ScrollHandle h)
{
Scrollable *s = h->scrollPtr;
WidgetCore *corePtr = h->corePtr;
char arg1[TCL_DOUBLE_SPACE + 2];
char arg2[TCL_DOUBLE_SPACE + 2];
int code;
h->flags &= ~SCROLL_UPDATE_REQUIRED;
if (s->scrollCmd == NULL) {
return TCL_OK;
}
arg1[0] = arg2[0] = ' ';
Tcl_PrintDouble(interp, (double)s->first / s->total, arg1+1);
Tcl_PrintDouble(interp, (double)s->last / s->total, arg2+1);
Tcl_Preserve(corePtr);
code = Tcl_VarEval(interp, s->scrollCmd, arg1, arg2, NULL);
if (WidgetDestroyed(corePtr)) {
Tcl_Release(corePtr);
return TCL_ERROR;
}
Tcl_Release(corePtr);
if (code != TCL_OK && !Tcl_InterpDeleted(interp)) {
/* Disable the -scrollcommand, add to stack trace:
*/
ckfree(s->scrollCmd);
s->scrollCmd = 0;
Tcl_AddErrorInfo(interp, /* @@@ "horizontal" / "vertical" */
"\n (scrolling command executed by ");
Tcl_AddErrorInfo(interp, Tk_PathName(h->corePtr->tkwin));
Tcl_AddErrorInfo(interp, ")");
}
return code;
}
/* $pw panes --
* Return list of managed panes.
*/
static int PanedPanesCommand(
void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
Paned *pw = recordPtr;
Ttk_Manager *mgr = pw->paned.mgr;
Tcl_Obj *panes;
int i;
if (objc != 2) {
Tcl_WrongNumArgs(interp, 2, objv, "");
return TCL_ERROR;
}
panes = Tcl_NewListObj(0, NULL);
for (i = 0; i < Ttk_NumberSlaves(mgr); ++i) {
const char *pathName = Tk_PathName(Ttk_SlaveWindow(mgr,i));
Tcl_ListObjAppendElement(interp, panes, Tcl_NewStringObj(pathName,-1));
}
Tcl_SetObjResult(interp, panes);
return TCL_OK;
}
void
SimGraphEventProc(ClientData clientData, XEvent *eventPtr)
{
SimGraph *graph = (SimGraph *) clientData;
if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
graph->visible = 1;
EventuallyRedrawGraph(graph);
} else if (eventPtr->type == MapNotify) {
graph->visible = 1;
} else if (eventPtr->type == UnmapNotify) {
graph->visible = 0;
} else if (eventPtr->type == VisibilityNotify) {
if (eventPtr->xvisibility.state == VisibilityFullyObscured)
graph->visible = 0;
else
graph->visible = 1;
} else if (eventPtr->type == ConfigureNotify) {
DoResizeGraph(graph,
eventPtr->xconfigure.width,
eventPtr->xconfigure.height);
EventuallyRedrawGraph(graph);
} else if (eventPtr->type == DestroyNotify) {
Tcl_DeleteCommand(graph->interp, Tk_PathName(graph->tkwin));
graph->tkwin = NULL;
if (graph->flags & VIEW_REDRAW_PENDING) {
//fprintf(stderr, "SimGraphEventProc Destroy token %d\n", graph->draw_graph_token);
assert(graph->draw_graph_token != 0);
if (graph->draw_graph_token != 0) {
Tk_DeleteTimerHandler(graph->draw_graph_token);
graph->draw_graph_token = 0;
}
graph->flags &= ~VIEW_REDRAW_PENDING;
}
Tk_EventuallyFree((ClientData) graph, DestroySimGraph);
}
}
/*ARGSUSED*/
static int
EmbWinLayoutProc(
TkText *textPtr, /* Text widget being layed out. */
TkTextIndex *indexPtr, /* Identifies first character in chunk. */
TkTextSegment *ewPtr, /* Segment corresponding to indexPtr. */
int offset, /* Offset within segPtr corresponding to
* indexPtr (always 0). */
int maxX, /* Chunk must not occupy pixels at this
* position or higher. */
int maxChars, /* Chunk must not include more than this many
* characters. */
int noCharsYet, /* Non-zero means no characters have been
* assigned to this line yet. */
TkWrapMode wrapMode, /* Wrap mode to use for line:
* TEXT_WRAPMODE_CHAR, TEXT_WRAPMODE_NONE, or
* TEXT_WRAPMODE_WORD. */
register TkTextDispChunk *chunkPtr)
/* Structure to fill in with information about
* this chunk. The x field has already been
* set by the caller. */
{
int width, height;
TkTextEmbWindowClient *client;
if (offset != 0) {
Tcl_Panic("Non-zero offset in EmbWinLayoutProc");
}
client = EmbWinGetClient(textPtr, ewPtr);
if (client == NULL) {
ewPtr->body.ew.tkwin = NULL;
} else {
ewPtr->body.ew.tkwin = client->tkwin;
}
if ((ewPtr->body.ew.tkwin == NULL) && (ewPtr->body.ew.create != NULL)) {
int code, isNew;
Tk_Window ancestor;
Tcl_HashEntry *hPtr;
const char *before, *string;
Tcl_DString name, buf, *dsPtr = NULL;
before = ewPtr->body.ew.create;
/*
* Find everything up to the next % character and append it to the
* result string.
*/
string = before;
while (*string != 0) {
if ((*string == '%') && (string[1] == '%' || string[1] == 'W')) {
if (dsPtr == NULL) {
Tcl_DStringInit(&buf);
dsPtr = &buf;
}
if (string != before) {
Tcl_DStringAppend(dsPtr, before, (int) (string-before));
before = string;
}
if (string[1] == '%') {
Tcl_DStringAppend(dsPtr, "%", 1);
} else {
/*
* Substitute string as proper Tcl list element.
*/
int spaceNeeded, cvtFlags, length;
const char *str = Tk_PathName(textPtr->tkwin);
spaceNeeded = Tcl_ScanElement(str, &cvtFlags);
length = Tcl_DStringLength(dsPtr);
Tcl_DStringSetLength(dsPtr, length + spaceNeeded);
spaceNeeded = Tcl_ConvertElement(str,
Tcl_DStringValue(dsPtr) + length,
cvtFlags | TCL_DONT_USE_BRACES);
Tcl_DStringSetLength(dsPtr, length + spaceNeeded);
}
before += 2;
string++;
}
string++;
}
/*
* The window doesn't currently exist. Create it by evaluating the
* creation script. The script must return the window's path name:
* look up that name to get back to the window token. Then register
* ourselves as the geometry manager for the window.
*/
if (dsPtr != NULL) {
Tcl_DStringAppend(dsPtr, before, (int) (string-before));
code = Tcl_GlobalEval(textPtr->interp, Tcl_DStringValue(dsPtr));
Tcl_DStringFree(dsPtr);
} else {
code = Tcl_GlobalEval(textPtr->interp, ewPtr->body.ew.create);
}
if (code != TCL_OK) {
createError:
Tcl_BackgroundException(textPtr->interp, code);
goto gotWindow;
}
Tcl_DStringInit(&name);
Tcl_DStringAppend(&name, Tcl_GetStringResult(textPtr->interp), -1);
Tcl_ResetResult(textPtr->interp);
ewPtr->body.ew.tkwin = Tk_NameToWindow(textPtr->interp,
Tcl_DStringValue(&name), textPtr->tkwin);
Tcl_DStringFree(&name);
if (ewPtr->body.ew.tkwin == NULL) {
goto createError;
}
for (ancestor = textPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
if (ancestor == Tk_Parent(ewPtr->body.ew.tkwin)) {
break;
}
if (Tk_TopWinHierarchy(ancestor)) {
badMaster:
Tcl_AppendResult(textPtr->interp, "can't embed ",
Tk_PathName(ewPtr->body.ew.tkwin), " relative to ",
Tk_PathName(textPtr->tkwin), NULL);
Tcl_BackgroundError(textPtr->interp);
ewPtr->body.ew.tkwin = NULL;
goto gotWindow;
}
}
if (Tk_TopWinHierarchy(ewPtr->body.ew.tkwin)
|| (textPtr->tkwin == ewPtr->body.ew.tkwin)) {
goto badMaster;
}
if (client == NULL) {
/*
* We just used a '-create' script to make a new window, which we
* now need to add to our client list.
*/
client = (TkTextEmbWindowClient *)
ckalloc(sizeof(TkTextEmbWindowClient));
client->next = ewPtr->body.ew.clients;
client->textPtr = textPtr;
client->tkwin = NULL;
client->chunkCount = 0;
client->displayed = 0;
client->parent = ewPtr;
ewPtr->body.ew.clients = client;
}
client->tkwin = ewPtr->body.ew.tkwin;
Tk_ManageGeometry(client->tkwin, &textGeomType, client);
Tk_CreateEventHandler(client->tkwin, StructureNotifyMask,
EmbWinStructureProc, client);
/*
* Special trick! Must enter into the hash table *after* calling
* Tk_ManageGeometry: if the window was already managed elsewhere in
* this text, the Tk_ManageGeometry call will cause the entry to be
* removed, which could potentially lose the new entry.
*/
hPtr = Tcl_CreateHashEntry(&textPtr->sharedTextPtr->windowTable,
Tk_PathName(client->tkwin), &isNew);
Tcl_SetHashValue(hPtr, ewPtr);
}
/*
* See if there's room for this window on this line.
*/
gotWindow:
if (ewPtr->body.ew.tkwin == NULL) {
width = 0;
height = 0;
} else {
width = Tk_ReqWidth(ewPtr->body.ew.tkwin) + 2*ewPtr->body.ew.padX;
height = Tk_ReqHeight(ewPtr->body.ew.tkwin) + 2*ewPtr->body.ew.padY;
}
if ((width > (maxX - chunkPtr->x))
&& !noCharsYet && (textPtr->wrapMode != TEXT_WRAPMODE_NONE)) {
return 0;
}
/*
* Fill in the chunk structure.
*/
chunkPtr->displayProc = TkTextEmbWinDisplayProc;
chunkPtr->undisplayProc = EmbWinUndisplayProc;
chunkPtr->measureProc = NULL;
chunkPtr->bboxProc = EmbWinBboxProc;
chunkPtr->numBytes = 1;
if (ewPtr->body.ew.align == ALIGN_BASELINE) {
chunkPtr->minAscent = height - ewPtr->body.ew.padY;
chunkPtr->minDescent = ewPtr->body.ew.padY;
chunkPtr->minHeight = 0;
} else {
chunkPtr->minAscent = 0;
chunkPtr->minDescent = 0;
chunkPtr->minHeight = height;
}
chunkPtr->width = width;
chunkPtr->breakIndex = -1;
chunkPtr->breakIndex = 1;
chunkPtr->clientData = ewPtr;
if (client != NULL) {
client->chunkCount += 1;
}
return 1;
}
void
TkpDrawMenuEntry(
TkMenuEntry *mePtr, /* The entry to draw */
Drawable d, /* What to draw into */
Tk_Font tkfont, /* Precalculated font for menu */
const Tk_FontMetrics *menuMetricsPtr,
/* Precalculated metrics for menu */
int x, /* X-coordinate of topleft of entry */
int y, /* Y-coordinate of topleft of entry */
int width, /* Width of the entry rectangle */
int height, /* Height of the current rectangle */
int strictMotif, /* Boolean flag */
int drawArrow) /* Whether or not to draw the cascade arrow
* for cascade items. Only applies to
* Windows. */
{
GC gc, indicatorGC;
XColor *indicatorColor, *disableColor = NULL;
TkMenu *menuPtr = mePtr->menuPtr;
Tk_3DBorder bgBorder, activeBorder;
const Tk_FontMetrics *fmPtr;
Tk_FontMetrics entryMetrics;
int padY = (menuPtr->menuType == MENUBAR) ? 3 : 0;
int adjustedY = y + padY;
int adjustedHeight = height - 2 * padY;
/*
* Choose the gc for drawing the foreground part of the entry.
*/
if ((mePtr->state == ENTRY_ACTIVE) && !strictMotif) {
gc = mePtr->activeGC;
if (gc == NULL) {
gc = menuPtr->activeGC;
}
} else {
TkMenuEntry *cascadeEntryPtr;
int parentDisabled = 0;
for (cascadeEntryPtr = menuPtr->menuRefPtr->parentEntryPtr;
cascadeEntryPtr != NULL;
cascadeEntryPtr = cascadeEntryPtr->nextCascadePtr) {
if (cascadeEntryPtr->namePtr != NULL) {
const char *name = Tcl_GetString(cascadeEntryPtr->namePtr);
if (strcmp(name, Tk_PathName(menuPtr->tkwin)) == 0) {
if (cascadeEntryPtr->state == ENTRY_DISABLED) {
parentDisabled = 1;
}
break;
}
}
}
if (((parentDisabled || (mePtr->state == ENTRY_DISABLED)))
&& (menuPtr->disabledFgPtr != NULL)) {
gc = mePtr->disabledGC;
if (gc == NULL) {
gc = menuPtr->disabledGC;
}
} else {
gc = mePtr->textGC;
if (gc == NULL) {
gc = menuPtr->textGC;
}
}
}
indicatorGC = mePtr->indicatorGC;
if (indicatorGC == NULL) {
indicatorGC = menuPtr->indicatorGC;
}
if (mePtr->indicatorFgPtr) {
indicatorColor = Tk_GetColorFromObj(menuPtr->tkwin,
mePtr->indicatorFgPtr);
} else {
indicatorColor = Tk_GetColorFromObj(menuPtr->tkwin,
menuPtr->indicatorFgPtr);
}
if (menuPtr->disabledFgPtr != NULL) {
disableColor = Tk_GetColorFromObj(menuPtr->tkwin,
menuPtr->disabledFgPtr);
}
bgBorder = Tk_Get3DBorderFromObj(menuPtr->tkwin,
(mePtr->borderPtr == NULL)
? menuPtr->borderPtr : mePtr->borderPtr);
if (strictMotif) {
activeBorder = bgBorder;
} else {
activeBorder = Tk_Get3DBorderFromObj(menuPtr->tkwin,
(mePtr->activeBorderPtr == NULL)
? menuPtr->activeBorderPtr : mePtr->activeBorderPtr);
}
if (mePtr->fontPtr == NULL) {
fmPtr = menuMetricsPtr;
} else {
tkfont = Tk_GetFontFromObj(menuPtr->tkwin, mePtr->fontPtr);
Tk_GetFontMetrics(tkfont, &entryMetrics);
fmPtr = &entryMetrics;
}
/*
* Need to draw the entire background, including padding. On Unix, for
* menubars, we have to draw the rest of the entry taking into account the
* padding.
*/
DrawMenuEntryBackground(menuPtr, mePtr, d, activeBorder,
bgBorder, x, y, width, height);
if (mePtr->type == SEPARATOR_ENTRY) {
DrawMenuSeparator(menuPtr, mePtr, d, gc, tkfont,
fmPtr, x, adjustedY, width, adjustedHeight);
} else if (mePtr->type == TEAROFF_ENTRY) {
DrawTearoffEntry(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, adjustedY,
width, adjustedHeight);
} else {
DrawMenuEntryLabel(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, adjustedY,
width, adjustedHeight);
DrawMenuEntryAccelerator(menuPtr, mePtr, d, gc, tkfont, fmPtr,
activeBorder, x, adjustedY, width, adjustedHeight, drawArrow);
if (!mePtr->hideMargin) {
if (mePtr->state == ENTRY_ACTIVE) {
bgBorder = activeBorder;
}
DrawMenuEntryIndicator(menuPtr, mePtr, d, bgBorder, indicatorColor,
disableColor, tkfont, fmPtr, x, adjustedY, width,
adjustedHeight);
}
}
}
DisplayContext *manageTrace(edview *xx,
char *format,
char *rawDataFile,
int baseNum,
int leftCutOff,
int cutLength,
int complemented,
int baseSpacing,
char *traceTitle,
int allow_dup,
int small_seq
) {
char *traceName;
DisplayContext *dc;
int exists;
Tcl_Interp *interp = EDINTERP(xx->ed);
char buf[1024];
char *pname;
Tcl_CmdInfo info;
char *edpath;
char seqbuf[1024];
if ((traceName=(char *)strrchr(rawDataFile,'/'))==NULL)
traceName = rawDataFile;
else
traceName++;
dc = getTDisplay(xx, traceName, allow_dup, small_seq, &exists);
if (exists) {
repositionSeq(xx, dc, baseNum);
flashCursor(xx, dc);
return dc;
}
pname = get_default_string(interp, gap5_defs, "TRACE_DISPLAY.WIN");
/*
* If we're the bottom half of a join editor, combine traces with the
* top half.
*/
if (inJoinMode(xx) && xx->link && xx == xx->link->xx[1] && !small_seq) {
edpath = Tk_PathName(EDTKWIN(xx->link->xx[0]->ed));
} else {
edpath = Tk_PathName(EDTKWIN(xx->ed));
}
if (small_seq) {
/* Mini-traces embedded in the editor */
//sprintf(seqbuf, "%d %d", small_seq, xx->lines_per_seq-1);
sprintf(seqbuf, "%d %d", small_seq, 3);
if (TCL_OK != Tcl_VarEval(interp, "trace_small_add ",
edpath, pname, " {", rawDataFile, "} {",
edpath, "} ", seqbuf, NULL)) {
freeTDisplay(traceName);
puts(Tcl_GetStringResult(interp));
return NULL;
}
} else {
/* The full-blown trace display. */
if (TCL_OK != Tcl_VarEval(interp, "trace_add ",
edpath, pname, " {", rawDataFile, "} {",
edpath, "} {", traceTitle, "}", NULL)) {
freeTDisplay(traceName);
return NULL;
}
}
strcpy(dc->path, Tcl_GetStringResult(interp));
/* Get Trace widget pointer */
if (-1 == Tcl_GetCommandInfo(interp, Tcl_GetStringResult(interp), &info)) {
freeTDisplay(traceName);
return NULL;
}
dc->tracePtr = (DNATrace *)info.clientData;
/* Set orientation and cutoffs */
if (complemented)
Tcl_VarEval(interp, dc->path, " complement", NULL);
dc->complemented = complemented;
sprintf(buf, "%s left_cutoff %d", dc->path, leftCutOff);
Tcl_Eval(interp, buf);
sprintf(buf, "%s right_cutoff %d", dc->path, leftCutOff + cutLength);
Tcl_Eval(interp, buf);
/* Tcl_VarEval(interp, "update idletasks", NULL); */
/* Adjust position */
repositionSeq(xx, dc, baseNum);
return dc;
}
/*
* Given two already loaded traces (ed1 and ed2), produce a new trace display
* containing the traces differences over the region that the traces overlap.
*/
DisplayContext *diff_edc_traces(EdStruct *xx, tman_dc *ed1, tman_dc *ed2) {
Tcl_CmdInfo info;
Read *r1, *r2, *r;
char *pname;
Tcl_Interp *interp = EDINTERP(xx->ed);
tman_dc *ed;
DisplayContext *dc;
static int diff_counter = 0;
int exists;
char buf[1024], name[1024];
int start, start1;
/* Get the two read structures */
Tcl_GetCommandInfo(interp, ed1->dc->path, &info);
r1 = ((DNATrace *)info.clientData)->read;
Tcl_GetCommandInfo(interp, ed2->dc->path, &info);
r2 = ((DNATrace *)info.clientData)->read;
/* Produce a diff read structure */
r = diff_readings(xx, r1, ed1->seq, ed1->pos, r2, ed2->seq, ed2->pos,
&start, &start1);
if (r == NULL) {
bell();
return NULL;
}
/* Create a trace display */
pname = get_default_string(interp, gap_defs, "TRACE_DISPLAY.WIN");
if (ed1->seq)
sprintf(name, " {diffs: #%d #%d}",
DB_Number(xx, ed1->seq), DB_Number(xx, ed2->seq));
else
sprintf(name, " {diffs: =%d #%d}",
-DB_Number(xx, ed1->seq), DB_Number(xx, ed2->seq));
Tcl_VarEval(interp, "trace_create ",
Tk_PathName(EDTKWIN(xx->ed)), pname, " ",
Tk_PathName(EDTKWIN(xx->ed)),
name, NULL);
pname = interp->result;
/* Fill out the tman_dc and DisplayContext structures */
sprintf(buf, "Diffs %d", diff_counter++);
dc = getTDisplay(xx, buf, 0, 0, &exists);
strcpy(dc->path, pname);
ed = find_free_edc();
ed->dc = dc;
ed->pos = start-1;
ed->xx = xx;
ed->type = TRACE_TYPE_DIFF;
ed->derivative_seq = ed1->seq ? ed1->seq : ed2->seq;
ed->derivative_offset = start1;
/* Add the Read to the trace widget */
Tcl_GetCommandInfo(interp, interp->result, &info);
trace_memory_load((DNATrace *)info.clientData, r);
dc->tracePtr = (DNATrace *)info.clientData;
/* Adjust position */
{
int num, end;
int pos = positionInContig(xx, xx->cursorSeq, xx->cursorPos);
num = tman_get_trace_position(xx, ed, pos, &end);
repositionSeq(xx, dc, num);
}
return dc;
}
int
Tk_SelectionObjCmd(
ClientData clientData, /* Main window associated with
* interpreter. */
Tcl_Interp *interp, /* Current interpreter. */
int objc, /* Number of arguments. */
Tcl_Obj *const objv[]) /* Argument objects. */
{
Tk_Window tkwin = clientData;
char *path = NULL;
Atom selection;
char *selName = NULL, *string;
int count, index;
Tcl_Obj **objs;
static const char *const optionStrings[] = {
"clear", "get", "handle", "own", NULL
};
enum options {
SELECTION_CLEAR, SELECTION_GET, SELECTION_HANDLE, SELECTION_OWN
};
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "option ?arg ...?");
return TCL_ERROR;
}
if (Tcl_GetIndexFromObj(interp, objv[1], optionStrings, "option", 0,
&index) != TCL_OK) {
return TCL_ERROR;
}
switch ((enum options) index) {
case SELECTION_CLEAR: {
static const char *const clearOptionStrings[] = {
"-displayof", "-selection", NULL
};
enum clearOptions { CLEAR_DISPLAYOF, CLEAR_SELECTION };
int clearIndex;
for (count = objc-2, objs = ((Tcl_Obj **)objv)+2; count > 0;
count-=2, objs+=2) {
string = Tcl_GetString(objs[0]);
if (string[0] != '-') {
break;
}
if (count < 2) {
Tcl_AppendResult(interp, "value for \"", string,
"\" missing", NULL);
return TCL_ERROR;
}
if (Tcl_GetIndexFromObj(interp, objs[0], clearOptionStrings,
"option", 0, &clearIndex) != TCL_OK) {
return TCL_ERROR;
}
switch ((enum clearOptions) clearIndex) {
case CLEAR_DISPLAYOF:
path = Tcl_GetString(objs[1]);
break;
case CLEAR_SELECTION:
selName = Tcl_GetString(objs[1]);
break;
}
}
if (count == 1) {
path = Tcl_GetString(objs[0]);
} else if (count > 1) {
Tcl_WrongNumArgs(interp, 2, objv, "?-option value ...?");
return TCL_ERROR;
}
if (path != NULL) {
tkwin = Tk_NameToWindow(interp, path, tkwin);
}
if (tkwin == NULL) {
return TCL_ERROR;
}
if (selName != NULL) {
selection = Tk_InternAtom(tkwin, selName);
} else {
selection = XA_PRIMARY;
}
Tk_ClearSelection(tkwin, selection);
break;
}
case SELECTION_GET: {
Atom target;
char *targetName = NULL;
Tcl_DString selBytes;
int result;
static const char *const getOptionStrings[] = {
"-displayof", "-selection", "-type", NULL
};
enum getOptions { GET_DISPLAYOF, GET_SELECTION, GET_TYPE };
int getIndex;
for (count = objc-2, objs = ((Tcl_Obj **)objv)+2; count>0;
count-=2, objs+=2) {
string = Tcl_GetString(objs[0]);
if (string[0] != '-') {
break;
}
if (count < 2) {
Tcl_AppendResult(interp, "value for \"", string,
"\" missing", NULL);
return TCL_ERROR;
}
if (Tcl_GetIndexFromObj(interp, objs[0], getOptionStrings,
"option", 0, &getIndex) != TCL_OK) {
return TCL_ERROR;
}
switch ((enum getOptions) getIndex) {
case GET_DISPLAYOF:
path = Tcl_GetString(objs[1]);
break;
case GET_SELECTION:
selName = Tcl_GetString(objs[1]);
break;
case GET_TYPE:
targetName = Tcl_GetString(objs[1]);
break;
}
}
if (path != NULL) {
tkwin = Tk_NameToWindow(interp, path, tkwin);
}
if (tkwin == NULL) {
return TCL_ERROR;
}
if (selName != NULL) {
selection = Tk_InternAtom(tkwin, selName);
} else {
selection = XA_PRIMARY;
}
if (count > 1) {
Tcl_WrongNumArgs(interp, 2, objv, "?-option value ...?");
return TCL_ERROR;
} else if (count == 1) {
target = Tk_InternAtom(tkwin, Tcl_GetString(objs[0]));
} else if (targetName != NULL) {
target = Tk_InternAtom(tkwin, targetName);
} else {
target = XA_STRING;
}
Tcl_DStringInit(&selBytes);
result = Tk_GetSelection(interp, tkwin, selection, target,
SelGetProc, &selBytes);
if (result == TCL_OK) {
Tcl_DStringResult(interp, &selBytes);
} else {
Tcl_DStringFree(&selBytes);
}
return result;
}
case SELECTION_HANDLE: {
Atom target, format;
char *targetName = NULL;
char *formatName = NULL;
register CommandInfo *cmdInfoPtr;
int cmdLength;
static const char *const handleOptionStrings[] = {
"-format", "-selection", "-type", NULL
};
enum handleOptions {
HANDLE_FORMAT, HANDLE_SELECTION, HANDLE_TYPE
};
int handleIndex;
for (count = objc-2, objs = ((Tcl_Obj **)objv)+2; count > 0;
count-=2, objs+=2) {
string = Tcl_GetString(objs[0]);
if (string[0] != '-') {
break;
}
if (count < 2) {
Tcl_AppendResult(interp, "value for \"", string,
"\" missing", NULL);
return TCL_ERROR;
}
if (Tcl_GetIndexFromObj(interp, objs[0],handleOptionStrings,
"option", 0, &handleIndex) != TCL_OK) {
return TCL_ERROR;
}
switch ((enum handleOptions) handleIndex) {
case HANDLE_FORMAT:
formatName = Tcl_GetString(objs[1]);
break;
case HANDLE_SELECTION:
selName = Tcl_GetString(objs[1]);
break;
case HANDLE_TYPE:
targetName = Tcl_GetString(objs[1]);
break;
}
}
if ((count < 2) || (count > 4)) {
Tcl_WrongNumArgs(interp, 2, objv, "?-option value ...? window command");
return TCL_ERROR;
}
tkwin = Tk_NameToWindow(interp, Tcl_GetString(objs[0]), tkwin);
if (tkwin == NULL) {
return TCL_ERROR;
}
if (selName != NULL) {
selection = Tk_InternAtom(tkwin, selName);
} else {
selection = XA_PRIMARY;
}
if (count > 2) {
target = Tk_InternAtom(tkwin, Tcl_GetString(objs[2]));
} else if (targetName != NULL) {
target = Tk_InternAtom(tkwin, targetName);
} else {
target = XA_STRING;
}
if (count > 3) {
format = Tk_InternAtom(tkwin, Tcl_GetString(objs[3]));
} else if (formatName != NULL) {
format = Tk_InternAtom(tkwin, formatName);
} else {
format = XA_STRING;
}
string = Tcl_GetStringFromObj(objs[1], &cmdLength);
if (cmdLength == 0) {
Tk_DeleteSelHandler(tkwin, selection, target);
} else {
cmdInfoPtr = (CommandInfo *) ckalloc((unsigned) (
sizeof(CommandInfo) - 3 + cmdLength));
cmdInfoPtr->interp = interp;
cmdInfoPtr->charOffset = 0;
cmdInfoPtr->byteOffset = 0;
cmdInfoPtr->buffer[0] = '\0';
cmdInfoPtr->cmdLength = cmdLength;
strcpy(cmdInfoPtr->command, string);
Tk_CreateSelHandler(tkwin, selection, target, HandleTclCommand,
cmdInfoPtr, format);
}
return TCL_OK;
}
case SELECTION_OWN: {
register LostCommand *lostPtr;
char *script = NULL;
int cmdLength;
static const char *const ownOptionStrings[] = {
"-command", "-displayof", "-selection", NULL
};
enum ownOptions { OWN_COMMAND, OWN_DISPLAYOF, OWN_SELECTION };
int ownIndex;
for (count = objc-2, objs = ((Tcl_Obj **)objv)+2; count > 0;
count-=2, objs+=2) {
string = Tcl_GetString(objs[0]);
if (string[0] != '-') {
break;
}
if (count < 2) {
Tcl_AppendResult(interp, "value for \"", string,
"\" missing", NULL);
return TCL_ERROR;
}
if (Tcl_GetIndexFromObj(interp, objs[0], ownOptionStrings,
"option", 0, &ownIndex) != TCL_OK) {
return TCL_ERROR;
}
switch ((enum ownOptions) ownIndex) {
case OWN_COMMAND:
script = Tcl_GetString(objs[1]);
break;
case OWN_DISPLAYOF:
path = Tcl_GetString(objs[1]);
break;
case OWN_SELECTION:
selName = Tcl_GetString(objs[1]);
break;
}
}
if (count > 2) {
Tcl_WrongNumArgs(interp, 2, objv, "?-option value ...? ?window?");
return TCL_ERROR;
}
if (selName != NULL) {
selection = Tk_InternAtom(tkwin, selName);
} else {
selection = XA_PRIMARY;
}
if (count == 0) {
TkSelectionInfo *infoPtr;
TkWindow *winPtr;
if (path != NULL) {
tkwin = Tk_NameToWindow(interp, path, tkwin);
}
if (tkwin == NULL) {
return TCL_ERROR;
}
winPtr = (TkWindow *)tkwin;
for (infoPtr = winPtr->dispPtr->selectionInfoPtr;
infoPtr != NULL; infoPtr = infoPtr->nextPtr) {
if (infoPtr->selection == selection) {
break;
}
}
/*
* Ignore the internal clipboard window.
*/
if ((infoPtr != NULL)
&& (infoPtr->owner != winPtr->dispPtr->clipWindow)) {
Tcl_SetResult(interp, Tk_PathName(infoPtr->owner), TCL_STATIC);
}
return TCL_OK;
}
tkwin = Tk_NameToWindow(interp, Tcl_GetString(objs[0]), tkwin);
if (tkwin == NULL) {
return TCL_ERROR;
}
if (count == 2) {
script = Tcl_GetString(objs[1]);
}
if (script == NULL) {
Tk_OwnSelection(tkwin, selection, NULL, NULL);
return TCL_OK;
}
cmdLength = strlen(script);
lostPtr = (LostCommand *)
ckalloc((unsigned) (sizeof(LostCommand) - 3 + cmdLength));
lostPtr->interp = interp;
strcpy(lostPtr->command, script);
Tk_OwnSelection(tkwin, selection, LostSelection, lostPtr);
return TCL_OK;
}
}
return TCL_OK;
}
static PyObject *
tkwin_repr(TkWinObject * self)
{
return PyString_FromString(Tk_PathName(self->tkwin));
}
static int
tkwin_compare(TkWinObject * self, TkWinObject * other)
{
return strcmp(Tk_PathName(self->tkwin), Tk_PathName(other->tkwin));
}
static int
CreateBLine(Tcl_Interp* interp, Tk_Canvas canvas, Tk_Item *itemPtr,
int argc, CONST84 char** argv)
{
BLineItem *linePtr = (BLineItem *) itemPtr;
int i;
tagsOption.parseProc = Tk_CanvasTagsParseProc;
tagsOption.printProc = Tk_CanvasTagsPrintProc;
if (argc < 4)
{
Tcl_AppendResult(interp, "wrong # args: should be \"",
Tk_PathName(Tk_CanvasTkwin(canvas)), "\" create ",
itemPtr->typePtr->name, " x1 y1 x2 y2 ?x3 y3 ...? ?options?",
(char *) NULL);
return TCL_ERROR;
}
/*
* Carry out initialization that is needed to set defaults and to
* allow proper cleanup after errors during the the remainder of
* this procedure.
*/
linePtr->numPoints = 0;
linePtr->coordPtr = NULL;
linePtr->width = 1;
linePtr->capStyle = CapButt;
linePtr->joinStyle = JoinRound;
linePtr->borderWidth = 2;
linePtr->relief = TK_RELIEF_RAISED;
linePtr->border = NULL;
/*
* Count the number of points and then parse them into a point
* array. Leading arguments are assumed to be points if they
* start with a digit or a minus sign followed by a digit.
*/
for (i = 4; i < (argc-1); i+=2)
{
if ((!isdigit(UCHAR(argv[i][0]))) &&
((argv[i][0] != '-') || (!isdigit(UCHAR(argv[i][1])))))
{
break;
}
}
if (BLineCoords(interp, canvas, itemPtr, i, argv) != TCL_OK)
{
goto error;
}
if (ConfigureBLine(interp, canvas, itemPtr, argc-i, argv+i, 0) == TCL_OK)
{
return TCL_OK;
}
error:
DeleteBLine(canvas, itemPtr, Tk_Display(Tk_CanvasTkwin(canvas)));
return TCL_ERROR;
}
static int
ConfigureSlave(
Tcl_Interp *interp, /* Used for error reporting. */
Tk_Window tkwin, /* Token for the window to manipulate. */
Tk_OptionTable table, /* Token for option table. */
int objc, /* Number of config arguments. */
Tcl_Obj *const objv[]) /* Object values for arguments. */
{
register Master *masterPtr;
Tk_SavedOptions savedOptions;
int mask;
Slave *slavePtr;
Tk_Window masterWin = (Tk_Window) NULL;
if (Tk_TopWinHierarchy(tkwin)) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"can't use placer on top-level window \"%s\"; use "
"wm command instead", Tk_PathName(tkwin)));
Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "TOPLEVEL", NULL);
return TCL_ERROR;
}
slavePtr = CreateSlave(tkwin, table);
if (Tk_SetOptions(interp, (char *) slavePtr, table, objc, objv,
slavePtr->tkwin, &savedOptions, &mask) != TCL_OK) {
goto error;
}
/*
* Set slave flags. First clear the field, then add bits as needed.
*/
slavePtr->flags = 0;
if (slavePtr->heightPtr) {
slavePtr->flags |= CHILD_HEIGHT;
}
if (slavePtr->relHeightPtr) {
slavePtr->flags |= CHILD_REL_HEIGHT;
}
if (slavePtr->relWidthPtr) {
slavePtr->flags |= CHILD_REL_WIDTH;
}
if (slavePtr->widthPtr) {
slavePtr->flags |= CHILD_WIDTH;
}
if (!(mask & IN_MASK) && (slavePtr->masterPtr != NULL)) {
/*
* If no -in option was passed and the slave is already placed then
* just recompute the placement.
*/
masterPtr = slavePtr->masterPtr;
goto scheduleLayout;
} else if (mask & IN_MASK) {
/* -in changed */
Tk_Window tkwin;
Tk_Window ancestor;
tkwin = slavePtr->inTkwin;
/*
* Make sure that the new master is either the logical parent of the
* slave or a descendant of that window, and that the master and slave
* aren't the same.
*/
for (ancestor = tkwin; ; ancestor = Tk_Parent(ancestor)) {
if (ancestor == Tk_Parent(slavePtr->tkwin)) {
break;
}
if (Tk_TopWinHierarchy(ancestor)) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"can't place %s relative to %s",
Tk_PathName(slavePtr->tkwin), Tk_PathName(tkwin)));
Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "HIERARCHY", NULL);
goto error;
}
}
if (slavePtr->tkwin == tkwin) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"can't place %s relative to itself",
Tk_PathName(slavePtr->tkwin)));
Tcl_SetErrorCode(interp, "TK", "GEOMETRY", "LOOP", NULL);
goto error;
}
if ((slavePtr->masterPtr != NULL)
&& (slavePtr->masterPtr->tkwin == tkwin)) {
/*
* Re-using same old master. Nothing to do.
*/
masterPtr = slavePtr->masterPtr;
goto scheduleLayout;
}
if ((slavePtr->masterPtr != NULL) &&
(slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin))) {
Tk_UnmaintainGeometry(slavePtr->tkwin, slavePtr->masterPtr->tkwin);
}
UnlinkSlave(slavePtr);
masterWin = tkwin;
}
/*
* If there's no master specified for this slave, use its Tk_Parent.
*/
if (masterWin == NULL) {
masterWin = Tk_Parent(slavePtr->tkwin);
slavePtr->inTkwin = masterWin;
}
/*
* Manage the slave window in this master.
*/
masterPtr = CreateMaster(masterWin);
slavePtr->masterPtr = masterPtr;
slavePtr->nextPtr = masterPtr->slavePtr;
masterPtr->slavePtr = slavePtr;
Tk_ManageGeometry(slavePtr->tkwin, &placerType, slavePtr);
/*
* Arrange for the master to be re-arranged at the first idle moment.
*/
scheduleLayout:
Tk_FreeSavedOptions(&savedOptions);
if (!(masterPtr->flags & PARENT_RECONFIG_PENDING)) {
masterPtr->flags |= PARENT_RECONFIG_PENDING;
Tcl_DoWhenIdle(RecomputePlacement, masterPtr);
}
return TCL_OK;
/*
* Error while processing some option, cleanup and return.
*/
error:
Tk_RestoreSavedOptions(&savedOptions);
return TCL_ERROR;
}
static int
EmbWinConfigure(
TkText *textPtr, /* Information about text widget that contains
* embedded window. */
TkTextSegment *ewPtr, /* Embedded window to be configured. */
int objc, /* Number of strings in objv. */
Tcl_Obj *const objv[]) /* Array of objects describing configuration
* options. */
{
Tk_Window oldWindow;
TkTextEmbWindowClient *client;
/*
* Copy over client specific value before querying or setting.
*/
client = EmbWinGetClient(textPtr, ewPtr);
if (client != NULL) {
ewPtr->body.ew.tkwin = client->tkwin;
} else {
ewPtr->body.ew.tkwin = NULL;
}
oldWindow = ewPtr->body.ew.tkwin;
if (Tk_SetOptions(textPtr->interp, (char *) &ewPtr->body.ew,
ewPtr->body.ew.optionTable, objc, objv, textPtr->tkwin, NULL,
NULL) != TCL_OK) {
return TCL_ERROR;
}
if (oldWindow != ewPtr->body.ew.tkwin) {
if (oldWindow != NULL) {
Tcl_DeleteHashEntry(Tcl_FindHashEntry(
&textPtr->sharedTextPtr->windowTable,
Tk_PathName(oldWindow)));
Tk_DeleteEventHandler(oldWindow, StructureNotifyMask,
EmbWinStructureProc, client);
Tk_ManageGeometry(oldWindow, NULL, NULL);
if (textPtr->tkwin != Tk_Parent(oldWindow)) {
Tk_UnmaintainGeometry(oldWindow, textPtr->tkwin);
} else {
Tk_UnmapWindow(oldWindow);
}
}
if (client != NULL) {
client->tkwin = NULL;
}
if (ewPtr->body.ew.tkwin != NULL) {
Tk_Window ancestor, parent;
Tcl_HashEntry *hPtr;
int isNew;
/*
* Make sure that the text is either the parent of the embedded
* window or a descendant of that parent. Also, don't allow a
* top-level window to be managed inside a text.
*/
parent = Tk_Parent(ewPtr->body.ew.tkwin);
for (ancestor = textPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
if (ancestor == parent) {
break;
}
if (Tk_TopWinHierarchy(ancestor)) {
badMaster:
Tcl_AppendResult(textPtr->interp, "can't embed ",
Tk_PathName(ewPtr->body.ew.tkwin), " in ",
Tk_PathName(textPtr->tkwin), NULL);
ewPtr->body.ew.tkwin = NULL;
if (client != NULL) {
client->tkwin = NULL;
}
return TCL_ERROR;
}
}
if (Tk_TopWinHierarchy(ewPtr->body.ew.tkwin)
|| (ewPtr->body.ew.tkwin == textPtr->tkwin)) {
goto badMaster;
}
if (client == NULL) {
/*
* Have to make the new client.
*/
client = (TkTextEmbWindowClient *)
ckalloc(sizeof(TkTextEmbWindowClient));
client->next = ewPtr->body.ew.clients;
client->textPtr = textPtr;
client->tkwin = NULL;
client->chunkCount = 0;
client->displayed = 0;
client->parent = ewPtr;
ewPtr->body.ew.clients = client;
}
client->tkwin = ewPtr->body.ew.tkwin;
/*
* Take over geometry management for the window, plus create an
* event handler to find out when it is deleted.
*/
Tk_ManageGeometry(ewPtr->body.ew.tkwin, &textGeomType, client);
Tk_CreateEventHandler(ewPtr->body.ew.tkwin, StructureNotifyMask,
EmbWinStructureProc, client);
/*
* Special trick! Must enter into the hash table *after* calling
* Tk_ManageGeometry: if the window was already managed elsewhere
* in this text, the Tk_ManageGeometry call will cause the entry
* to be removed, which could potentially lose the new entry.
*/
hPtr = Tcl_CreateHashEntry(&textPtr->sharedTextPtr->windowTable,
Tk_PathName(ewPtr->body.ew.tkwin), &isNew);
Tcl_SetHashValue(hPtr, ewPtr);
}
}
return TCL_OK;
}
