tkgrid.c

linux系统下的音频通信

	    }
	    slavePtr = GetGrid(slave);
	    if (slavePtr->masterPtr != NULL) {

	    	/*
	    	 * For "forget", reset all the settings to their defaults
	    	 */

	    	if (c == 'f') {
		    slavePtr->column = slavePtr->row = -1;
		    slavePtr->numCols = 1;
		    slavePtr->numRows = 1;
		    slavePtr->padX = slavePtr->padY = 0;
		    slavePtr->iPadX = slavePtr->iPadY = 0;
		    slavePtr->doubleBw = 2*Tk_Changes(tkwin)->border_width;
		    slavePtr->flags = 0;
		    slavePtr->sticky = 0;
	    	}
		Tk_ManageGeometry(slave, (Tk_GeomMgr *) NULL,
			(ClientData) NULL);
		if (slavePtr->masterPtr->tkwin != Tk_Parent(slavePtr->tkwin)) {
		    Tk_UnmaintainGeometry(slavePtr->tkwin,
			    slavePtr->masterPtr->tkwin);
		}
		Unlink(slavePtr);
		Tk_UnmapWindow(slavePtr->tkwin);
	    }
	}
    } else if ((c == 'i') && (strncmp(argv[1], "info", length) == 0)) {
	register Gridder *slavePtr;
	Tk_Window slave;
	char buffer[70];
    
	if (argc != 3) {
	    Tcl_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " info window\"", (char *) NULL);
	    return TCL_ERROR;
	}
	slave = Tk_NameToWindow(interp, argv[2], tkwin);
	if (slave == NULL) {
	    return TCL_ERROR;
	}
	slavePtr = GetGrid(slave);
	if (slavePtr->masterPtr == NULL) {
	    interp->result[0] = '\0';
	    return TCL_OK;
	}
    
	Tcl_AppendElement(interp, "-in");
	Tcl_AppendElement(interp, Tk_PathName(slavePtr->masterPtr->tkwin));
	sprintf(buffer, " -column %d -row %d -columnspan %d -rowspan %d",
		slavePtr->column, slavePtr->row,
		slavePtr->numCols, slavePtr->numRows);
	Tcl_AppendResult(interp, buffer, (char *) NULL);
	sprintf(buffer, " -ipadx %d -ipady %d -padx %d -pady %d",
		slavePtr->iPadX/2, slavePtr->iPadY/2, slavePtr->padX/2,
		slavePtr->padY/2);
	Tcl_AppendResult(interp, buffer, (char *) NULL);
	StickyToString(slavePtr->sticky,buffer);
	Tcl_AppendResult(interp, " -sticky ", buffer, (char *) NULL);
    } else if((c == 'l') && (strncmp(argv[1], "location", length) == 0)) {
	Tk_Window master;
	register SlotInfo *slotPtr;
	int x, y;		/* Offset in pixels, from edge of parent. */
	int i, j;		/* Corresponding column and row indeces. */
	int endX, endY;		/* end of grid */

	if (argc != 5) {
	    Tcl_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " location master x y\"", (char *)NULL);
	    return TCL_ERROR;
	}

	master = Tk_NameToWindow(interp, argv[2], tkwin);
	if (master == NULL) {
	    return TCL_ERROR;
	}

	if (Tk_GetPixels(interp, master, argv[3], &x) != TCL_OK) {
	    return TCL_ERROR;
	}
	if (Tk_GetPixels(interp, master, argv[4], &y) != TCL_OK) {
	    return TCL_ERROR;
	}

	masterPtr = GetGrid(master);
	if (masterPtr->masterDataPtr == NULL) {
	    sprintf(interp->result, "%d %d", -1, -1);
	    return TCL_OK;
	}
	gridPtr = masterPtr->masterDataPtr;

	/* 
	 * Update any pending requests.  This is not always the
	 * steady state value, as more configure events could be in
	 * the pipeline, but its as close as its easy to get.
	 */

	while (masterPtr->flags & REQUESTED_RELAYOUT) {
	    Tk_CancelIdleCall(ArrangeGrid, (ClientData) masterPtr);
	    ArrangeGrid ((ClientData) masterPtr);
	}
	SetGridSize(masterPtr);
	endX = MAX(gridPtr->columnEnd, gridPtr->columnMax);
	endY = MAX(gridPtr->rowEnd, gridPtr->rowMax);

	slotPtr  = masterPtr->masterDataPtr->columnPtr;
	if (x < masterPtr->masterDataPtr->startX) {
	    i = -1;
	} else {
	    x -= masterPtr->masterDataPtr->startX;
	    for (i=0;slotPtr[i].offset < x && i < endX; i++) {
		/* null body */
	    }
	}

	slotPtr  = masterPtr->masterDataPtr->rowPtr;
	if (y < masterPtr->masterDataPtr->startY) {
	    j = -1;
	} else {
	    y -= masterPtr->masterDataPtr->startY;
	    for (j=0;slotPtr[j].offset < y && j < endY; j++) {
		/* null body */
	    }
	}

	sprintf(interp->result, "%d %d", i, j);
    } else if ((c == 'p') && (strncmp(argv[1], "propagate", length) == 0)) {
	Tk_Window master;
	int propagate;
    
	if (argc > 4) {
	    Tcl_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " propagate window ?boolean?\"",
		    (char *) NULL);
	    return TCL_ERROR;
	}
	master = Tk_NameToWindow(interp, argv[2], tkwin);
	if (master == NULL) {
	    return TCL_ERROR;
	}
	masterPtr = GetGrid(master);
	if (argc == 3) {
	    interp->result = (masterPtr->flags & DONT_PROPAGATE) ? "0" : "1";
	    return TCL_OK;
	}
	if (Tcl_GetBoolean(interp, argv[3], &propagate) != TCL_OK) {
	    return TCL_ERROR;
	}
	if ((!propagate) ^ (masterPtr->flags&DONT_PROPAGATE)) {
	    masterPtr->flags  ^= DONT_PROPAGATE;
      
	    /*
	     * Re-arrange the master to allow new geometry information to
	     * propagate upwards to the master's master.
	     */
      
	    if (masterPtr->abortPtr != NULL) {
		*masterPtr->abortPtr = 1;
	    }
	    if (!(masterPtr->flags & REQUESTED_RELAYOUT)) {
		masterPtr->flags |= REQUESTED_RELAYOUT;
		Tcl_DoWhenIdle(ArrangeGrid, (ClientData) masterPtr);
	    }
	}
    } else if ((c == 's') && (strncmp(argv[1], "size", length) == 0)
	    && (length > 1)) {
	Tk_Window master;

	if (argc != 3) {
	    Tcl_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " size window\"", (char *) NULL);
	    return TCL_ERROR;
	}
	master = Tk_NameToWindow(interp, argv[2], tkwin);
	if (master == NULL) {
	    return TCL_ERROR;
	}
	masterPtr = GetGrid(master);

	if (masterPtr->masterDataPtr != NULL) {
	    SetGridSize(masterPtr);
	    gridPtr = masterPtr->masterDataPtr;
	    sprintf(interp->result, "%d %d",
		MAX(gridPtr->columnEnd, gridPtr->columnMax),
		MAX(gridPtr->rowEnd, gridPtr->rowMax));
	} else {
	    sprintf(interp->result, "%d %d",0, 0);
	}
    } else if ((c == 's') && (strncmp(argv[1], "slaves", length) == 0)
	    && (length > 1)) {
	Tk_Window master;
	Gridder *slavePtr;
	int i, value;
	int row = -1, column = -1;
 
	if ((argc < 3) || ((argc%2) == 0)) {
	    Tcl_AppendResult(interp, "wrong # args: should be \"",
		    argv[0], " slaves window ?-option value...?\"",
		    (char *) NULL);
	    return TCL_ERROR;
	}

	for (i=3; i<argc; i+=2) {
	    length = strlen(argv[i]);
	    if ((*argv[i] != '-') || (length < 2)) {
		Tcl_AppendResult(interp, "invalid args: should be \"",
			argv[0], " slaves window ?-option value...?\"",
			(char *) NULL);
		return TCL_ERROR;
	    }
	    if (Tcl_GetInt(interp, argv[i+1], &value) != TCL_OK) {
		return TCL_ERROR;
	    }
	    if (value < 0) {
		Tcl_AppendResult(interp, argv[i],
			" is an invalid value: should NOT be < 0",
			(char *) NULL);
		return TCL_ERROR;
	    }
	    if (strncmp(argv[i], "-column", length) == 0) {
		column = value;
	    } else if (strncmp(argv[i], "-row", length) == 0) {
		row = value;
	    } else {
		Tcl_AppendResult(interp, argv[i],
			" is an invalid option: should be \"",
			"-row, -column\"",
			(char *) NULL);
		return TCL_ERROR;
	    }
	}
	master = Tk_NameToWindow(interp, argv[2], tkwin);
	if (master == NULL) {
	    return TCL_ERROR;
	}
	masterPtr = GetGrid(master);

	for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
					     slavePtr = slavePtr->nextPtr) {
	    if (column>=0 && (slavePtr->column > column
		    || slavePtr->column+slavePtr->numCols-1 < column)) {
		continue;
	    }
	    if (row>=0 && (slavePtr->row > row ||
		    slavePtr->row+slavePtr->numRows-1 < row)) {
		continue;
	    }
	    Tcl_AppendElement(interp, Tk_PathName(slavePtr->tkwin));
	}

    /*
     * Sample argument combinations:
     *  grid columnconfigure <master> <index> -option
     *  grid columnconfigure <master> <index> -option value -option value
     *  grid rowconfigure <master> <index>
     *  grid rowconfigure <master> <index> -option
     *  grid rowconfigure <master> <index> -option value -option value.
     */
   
    } else if(((c == 'c') && (strncmp(argv[1], "columnconfigure", length) == 0)
	    && (length >= 3)) ||
            ((c == 'r') && (strncmp(argv[1], "rowconfigure", length) == 0) 
            && (length >=2))) {
	Tk_Window master;
	SlotInfo *slotPtr = NULL;
	int slot;		/* the column or row number */
	size_t length;		/* the # of chars in the "-option" string */
	int slotType;		/* COLUMN or ROW */
	int size;		/* the configuration value */
	int checkOnly;		/* check the size only */
	int argcPtr;		/* Number of items in index list */
	char **argvPtr;		/* array of indeces */
	char **indexP;		/* String value of current index list item. */
	int ok;			/* temporary TCL result code */
	int i;

	if (((argc%2 != 0) && (argc>6)) || (argc < 4)) {
	    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
		    " ", argv[1], " master index ?-option value...?\"",
		    (char *)NULL);
	    return TCL_ERROR;
	}

	master = Tk_NameToWindow(interp, argv[2], tkwin);
	if (master == NULL) {
	    return TCL_ERROR;
	}

	if (Tcl_SplitList(interp, argv[3], &argcPtr, &argvPtr) != TCL_OK) {
	    return TCL_ERROR;
	}

	checkOnly = ((argc == 4) || (argc == 5));
	masterPtr = GetGrid(master);
	slotType = (c == 'c') ? COLUMN : ROW;
	if (checkOnly && argcPtr > 1) {
	    Tcl_AppendResult(interp, argv[3],
		    " must be a single element.", (char *) NULL);
	    Tcl_Free((char *)argvPtr);
	    return TCL_ERROR;
	}
	for (indexP=argvPtr; *indexP != NULL; indexP++) {
	    if (Tcl_GetInt(interp, *indexP, &slot) != TCL_OK) {
		Tcl_Free((char *)argvPtr);
		return TCL_ERROR;
	    }
	    ok = CheckSlotData(masterPtr, slot, slotType, checkOnly);
	    if ((ok!=TCL_OK) && ((argc<4) || (argc>5))) {
		Tcl_AppendResult(interp, argv[0],
			" ", argv[1], ": \"", *argvPtr,"\" is out of range",
			(char *) NULL);
		Tcl_Free((char *)argvPtr);
		return TCL_ERROR;
	    } else if (ok == TCL_OK) {
		slotPtr = (slotType == COLUMN) ?
			masterPtr->masterDataPtr->columnPtr :
			masterPtr->masterDataPtr->rowPtr;
	    }

	    /*
	     * Return all of the options for this row or column.  If the
	     * request is out of range, return all 0's.
	     */

	    if (argc == 4) {
		Tcl_Free((char *)argvPtr);
	    }
	    if ((argc == 4) && (ok == TCL_OK)) {
		sprintf(interp->result,"-minsize %d -pad %d -weight %d",
			slotPtr[slot].minSize,slotPtr[slot].pad,
			slotPtr[slot].weight);
		return (TCL_OK);
	    } else if (argc == 4) {
		sprintf(interp->result,"-minsize %d -pad %d -weight %d", 0,0,0);
		return (TCL_OK);
	    }

	    /*
	     * Loop through each option value pair, setting the values as required.
	     * If only one option is given, with no value, the current value is
	     * returned.
	     */

	    for (i=4; i<argc; i+=2) {
		length = strlen(argv[i]);
		if ((*argv[i] != '-') || length < 2) {
		    Tcl_AppendResult(interp, "invalid arg \"",
			    argv[i], "\" :expecting -minsize, -pad, or -weight.",
			    (char *) NULL);
		    Tcl_Free((char *)argvPtr);
		    return TCL_ERROR;
		}
		if (strncmp(argv[i], "-minsize", length) == 0) {
		    if (argc == 5) {
		    	int value =  ok == TCL_OK ? slotPtr[slot].minSize : 0;
			sprintf(interp->result,"%d",value);
		    } else if (Tk_GetPixels(interp, master, argv[i+1], &size)
			    != TCL_OK) {
			Tcl_Free((char *)argvPtr);
			return TCL_ERROR;
		    } else {
			slotPtr[slot].minSize = size;
		    }
		}
		else if (strncmp(argv[i], "-weight", length) == 0) {
		    int wt;
		    if (argc == 5) {
		    	int value =  ok == TCL_OK ? slotPtr[slot].weight : 0;
			sprintf(interp->result,"%d",value);
		    } else if (Tcl_GetInt(interp, argv[i+1], &wt) != TCL_OK) {
			Tcl_Free((char *)argvPtr);
			return TCL_ERROR;
		    } else if (wt < 0) {
			Tcl_AppendResult(interp, "invalid arg \"", argv[i],
				"\": should be non-negative", (char *) NULL);
			Tcl_Free((char *)argvPtr);
			return TCL_ERROR;
		    } else {
			slotPtr[slot].weight = wt;
		    }
		}
		else if (strncmp(argv[i], "-pad", length) == 0) {
		    if (argc == 5) {
		    	int value =  ok == TCL_OK ? slotPtr[slot].pad : 0;
			sprintf(interp->result,"%d",value);
		    } else if (Tk_GetPixels(interp, master, argv[i+1], &size)
			    != TCL_OK) {
			Tcl_Free((char *)argvPtr);
			return TCL_ERROR;
		    } else if (size < 0) {
			Tcl_AppendResult(interp, "invalid arg \"", argv[i],
				"\": should be non-negative", (char *) NULL);
			Tcl_Free((char *)argvPtr);
			return TCL_ERROR;
		    } else {
			slotPtr[slot].pad = size;
		    }
		} else {
		    Tcl_AppendResult(interp, "invalid arg \"",
			    argv[i], "\": expecting -minsize, -pad, or -weight.",
			    (char *) NULL);
		    Tcl_Free((char *)argvPtr);
		    return TCL_ERROR;
		}
	    }
	}
	Tcl_Free((char *)argvPtr);

	/*
	 * If we changed a property, re-arrange the table,
	 * and check for constraint shrinkage.
	 */

	if (argc != 5) {
	    if (slotType == ROW) {
		int last = masterPtr->masterDataPtr->rowMax - 1;
		while ((last >= 0) && (slotPtr[last].weight == 0)
			&& (slotPtr[last].pad == 0)
			&& (slotPtr[last].minSize == 0)) {
		    last--;
		}
		masterPtr->masterDataPtr->rowMax = last+1;
	    } else {
		int last = masterPtr->masterDataPtr->columnMax - 1;
		while ((last >= 0) && (slotPtr[last].weight == 0)
			&& (slotPtr[last].pad == 0)