# Module to on-demand render MaterialIcons-Regular.svg
# into photo images using tksvg.
#
# chw January 2019
# image_ncg contributed by dzach May/July 2019

package require Tk
package require tdom
package require tksvg

namespace eval ::MaterialIcons {

	}
	set template0 {
	    <?xml version="1.0" encoding="UTF-8" standalone="no"?>
	    <svg id="%%s" width="%g" height="%g" viewBox="%s" version="1.1">
	      <g>
		<path fill="%%s" fill-opacity="%%g"
		 stroke="%%s" stroke-width="%%g"
		 transform="rotate(%%g,256,256) scale(1,-1) translate(0,%g)"
		 d="%%s"/>
	      </g>
	    </svg>
	}
	lassign $bbox x1 y1 x2 y2
	set w [expr {$x2 - $x1}]
	set h [expr {$y2 - $y1}]

	variable glyph
	tailcall lsort [array names glyph $pattern]
    }

    # Return SVG for named icon with optional fill color and opacity.

    proc svg {name {color black} {opacity 1.0}
	{stroke none} {strokewidth 1.0} {angle 0}} {
	variable glyph
	variable template
	if {![info exists glyph($name)]} {
	    return -code error "glyph $name does not exist"
	}
	tailcall format $template $name $color $opacity \
	    $stroke $strokewidth $angle $glyph($name)
    }

    # Return photo image for named icon with optional size, fill color,
    # and opacity. If size is negative, it specifies pixels, else points
    # taking the current tk scaling into account.

    proc image {name {size 16} {color black} {opacity 1.0}} {

	} elseif {$val < 0} {
	    set val [expr {-1.0 * $val}]
	}
	return $val
    }

    # Like the "image_nc" method but accepting many options:
    #   name		glyph name to be rendered
    #   imgname		name of photo image
    #   -size S		size with optional unit suffix
    #   -fill C		fill color
    #   -opacity O	fill opacity
    #   -stroke C	stroke color
    #   -strokewidth S	stroke width with optional unit suffix
    #   -angle A	angle in degrees

    proc image_ncg {name imgname args} {
	variable viewbox
	array set opts {
	    -size 24d -fill black -opacity 1.0 -stroke none
	    -strokewidth 1.0 -angle 0
	}
	array set opts $args
	lassign $viewbox x y w h
	set size [val2px $opts(-size)]
	if {$size == 0} {
	    return -code error "invalid size"
	}
	set scale [expr {1.0 * $size / $w}]
	# if stroke width has units or is negative, don't scale it
	if {![string is double -strict $opts(-strokewidth)] ||
	    $opts(-strokewidth) < 0} {
	    # reverse the scale
	    set opts(-strokewidth) \
		[expr {abs([val2px $opts(-strokewidth)] / $scale)}]
	}
	tailcall ::image create photo $imgname \
	    -format [list svg -scale $scale] \
	    -data [svg $name $opts(-fill) $opts(-opacity) $opts(-stroke) \
		$opts(-strokewidth) $opts(-angle)]
    }

    # Make some procs visible in MaterialIcons ensemble.

    namespace ensemble create -subcommands {
	names svg image image_nc flush rebuild image_ncg
    }

}

package provide MaterialIcons 0.2

The path name of the window to which the event was reported (the
\fIwindow\fR field from the event).  Valid for all event types.
.IP "\fB%X\fR, \fB%Y\fR" 5
The \fIx_root\fR and  \fIy_root\fR fields from the event.
If a virtual-root window manager is being used then the substituted
values are the corresponding x-coordinate and y-coordinate in the virtual root.
Valid only for
\fBButtonPress\fR, \fBButtonRelease\fR, \fBEnter\fR, \fBKeyPress\fR,
\fBKeyRelease\fR, \fBLeave\fR and \fBMotion\fR events.
Same meaning as \fB%x\fR and \fB%y\fR, except relative to the (virtual) root
window.
.LP
The replacement string for a %-replacement is formatted as a proper
Tcl list element.
This means that spaces or special characters such as \fB$\fR and
\fB{\fR may be preceded by backslashes.

    Tcl_Obj *name;		/* Name specified without an option. */
    int fromX, fromY;		/* Values specified for -from option. */
    int fromX2, fromY2;		/* Second coordinate pair for -from option. */
    int toX, toY;		/* Values specified for -to option. */
    int toX2, toY2;		/* Second coordinate pair for -to option. */
    int zoomX, zoomY;		/* Values specified for -zoom option. */
    int subsampleX, subsampleY;	/* Values specified for -subsample option. */
    double rotate;		/* Degrees to rotate the image with. */
    double scaleX, scaleY;	/* Resize factors in the X and Y directions. */
    int stoX, stoY;		/* Target width/height for -scaleto option. */
    int mirrorX, mirrorY;	/* 1 if mirroring the resp. axis requested */
    char *filtername;		/* Name of the interpolating lowpass filter. */
    int smoothedge;		/* Pixel width of frame used in edge smoothing:
                                 * default value is 0 (means no smoothing)
                                 * and 1 may be specified in the Tcl command. */
    double blur;		/* Defines the effect of blurring the image,
				 * must be > 1.0 */
    Tcl_Obj *format;		/* Value specified for -format option. */
    XColor *background;		/* Value specified for -background option. */

 * OPT_ZOOM:			Set if -zoom option allowed/specified.
 * OPT_ROTATE:			Set if -rotate option allowed/specified.
 * OPT_SCALE:			Set if -scale option allowed/specified.
 * OPT_MIRROR:			Set if -mirror option allowed/specified.
 * OPT_FILTER:			Set if -filter option allowed/specified.
 * OPT_SMOOTHEDGE:		Set if -smoothedge option allowed/specified.
 * OPT_BLUR:			Set if -blur option allowed/specified.
 * OPT_SCALETO:			Set if -scaleto option allowed/specified.
 */

#define OPT_BACKGROUND	1
#define OPT_COMPOSITE	2
#define OPT_FORMAT	4
#define OPT_FROM	8
#define OPT_GRAYSCALE	0x10
#define OPT_SHRINK	0x20
#define OPT_SUBSAMPLE	0x40
#define OPT_TO		0x80
#define OPT_ZOOM	0x100
#define OPT_ROTATE	0x200
#define OPT_SCALE	0x400
#define OPT_MIRROR	0x800
#define OPT_FILTER	0x1000
#define OPT_SMOOTHEDGE	0x2000
#define OPT_BLUR	0x4000
#define OPT_SCALETO	0x8000

/*
 * List of option names. The order here must match the order of declarations
 * of the OPT_* constants above.
 */

static const char *const optionNames[] = {

    "-zoom",
    "-rotate",
    "-scale",
    "-mirror",
    "-filter",
    "-smoothedge",
    "-blur",
    "-scaleto",
    NULL
};

/*
 * Message to generate when an attempt to resize an image fails due to memory
 * problems.
 */

	 */

	index = 2;
	memset(&options, 0, sizeof(options));
	options.zoomX = options.zoomY = 1;
	options.subsampleX = options.subsampleY = 1;
	options.scaleX = options.scaleY = 1;
	options.stoX = options.stoY = -1;
	options.rotate = 0;
	options.mirrorX = options.mirrorY = 0;
	options.filtername = NULL;
	options.smoothedge = 0;
	options.blur = 0;
	options.name = NULL;
	options.compositingRule = TK_PHOTO_COMPOSITE_OVERLAY;
	if (ParseSubcommandOptions(&options, interp,
		OPT_FROM | OPT_TO | OPT_ZOOM | OPT_SUBSAMPLE | OPT_SHRINK |
		OPT_COMPOSITE | OPT_BACKGROUND | OPT_SCALETO |
		OPT_ROTATE | OPT_SCALE | OPT_MIRROR | OPT_FILTER | OPT_BLUR,
		&index, objc, objv) != TCL_OK) {
	    return TCL_ERROR;
	}
	if ((options.filtername == NULL) && (options.smoothedge != 0)) {
	    options.filtername = "Mitchell";
	}

		    Tcl_GetString(options.name)));
	    Tcl_SetErrorCode(interp, "TK", "LOOKUP", "PHOTO",
		    Tcl_GetString(options.name), NULL);
	    return TCL_ERROR;
	}
	Tk_PhotoGetImage(srcHandle, &block);

	if (options.options & OPT_SCALETO) {
	    int corr;

	    /* No rotation, no smoothedge, please. */
	    options.rotate = 0;
	    options.smoothedge = 0;
	    options.options &= ~(OPT_ROTATE | OPT_SCALE);
	    options.toX = options.toY = 0;
	    corr = (options.stoX > block.width) ? 2 : 1;
	    options.scaleX =
		(double) options.stoX / (double) (block.width - corr);
	    options.toX2 = options.stoX;
	    if (options.stoY < 0) {
		options.scaleY = options.scaleX;
		options.toY2 = (int) (block.height * options.scaleY + 0.5);
	    } else {
		corr = (options.stoY > block.height) ? 2 : 1;
		options.scaleY =
		    (double) options.stoY / (double) (block.height - corr);
		options.toY2 = options.stoY;
	    }
	}

        if (options.options & (OPT_ROTATE | OPT_SCALE |
			       OPT_MIRROR | OPT_FILTER | OPT_SCALETO)) {
	    int sameSrc = (block.pixelPtr == masterPtr->pix32);
	    PhotoMaster savedMaster;

	    savedMaster = *masterPtr;
	    if (sameSrc) {
		masterPtr->pix32 = NULL;
		masterPtr->width = masterPtr->height = 0;

	    }
	    optPtr->name = objv[index];
	    continue;
	}

	/*
	 * For the -from, -to, -zoom, -subsample, -background, -rotate,
	 * -scale, -filter, -mirror, -smoothedge, -blur, -scaleto options,
	 * parse the values given. Report an error if too few or too many
	 * values are given.
	 */

	if (bit == OPT_BACKGROUND) {
	    /*
	     * The -background option takes a single XColor value.
	     */

			}
		    }
		}
	    } else {
		Tcl_AppendResult(interp, "the \"-scale\" option ",
			"requires one or two values", (char *) NULL);
		return TCL_ERROR;
	    }
	} else if (bit == OPT_SCALETO) {
	    if (index + 1 < objc) {
		*optIndexPtr = ++index;
		if ((Tcl_GetIntFromObj(interp, objv[index], &optPtr->stoX)
		     != TCL_OK) || (optPtr->stoX <= 0)) {
		    Tcl_AppendResult(interp,
			 "the -scaleto X value is invalid", (char *) NULL);
		    return TCL_ERROR;
		}
		if (index + 1 < objc) {
		    if (*(Tcl_GetString(objv[index+1])) != '-') {
			*optIndexPtr = ++index;
			if ((Tcl_GetIntFromObj(interp, objv[index], &optPtr->stoY)
			     != TCL_OK) || (optPtr->stoY <= 0)) {
			    Tcl_AppendResult(interp,
				"the -scaleto Y value is invalid",
				(char *) NULL);
			    return TCL_ERROR;
			}
		    }
		}
	    } else {
		Tcl_AppendResult(interp, "the \"-scaleto\" option ",
			"requires one or two values", (char *) NULL);
		return TCL_ERROR;
	    }
	} else if (bit == OPT_MIRROR) {
	    if (index + 1 < objc) {
		char *temp;

		*optIndexPtr = ++index;
                temp = Tcl_GetString(objv[index]);

	return TCL_ERROR;
    }
    if (GetStatBuf(interp, objv[1], Tcl_FSStat, &buf) != TCL_OK) {
	return TCL_ERROR;
    }
#if defined(_WIN32)
    /* We use a value of 0 to indicate the access time not available */
    if (Tcl_GetAccessTimeFromStat(&buf) == 0) {
        Tcl_SetObjResult(interp, Tcl_ObjPrintf(
                             "could not get access time for file \"%s\"",
                             TclGetString(objv[1])));
        return TCL_ERROR;
    }
#endif

    if (objc == 3) {
	/*
	 * Need separate variable for reading longs from an object on 64-bit
	 * platforms. [Bug 698146]
	 */

	long newTime;

	if (TclGetLongFromObj(interp, objv[2], &newTime) != TCL_OK) {
	    return TCL_ERROR;
	}

	tval.actime = newTime;
	tval.modtime = Tcl_GetModificationTimeFromStat(&buf);

	if (Tcl_FSUtime(objv[1], &tval) != 0) {
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		    "could not set access time for file \"%s\": %s",
		    TclGetString(objv[1]), Tcl_PosixError(interp)));
	    return TCL_ERROR;
	}

	/*
	 * Do another stat to ensure that the we return the new recognized
	 * atime - hopefully the same as the one we sent in. However, fs's
	 * like FAT don't even know what atime is.
	 */

	if (GetStatBuf(interp, objv[1], Tcl_FSStat, &buf) != TCL_OK) {
	    return TCL_ERROR;
	}
    }

    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(Tcl_GetAccessTimeFromStat(&buf)));
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrModifyTimeCmd --

	return TCL_ERROR;
    }
    if (GetStatBuf(interp, objv[1], Tcl_FSStat, &buf) != TCL_OK) {
	return TCL_ERROR;
    }
#if defined(_WIN32)
    /* We use a value of 0 to indicate the modification time not available */
    if (Tcl_GetModificationTimeFromStat(&buf) == 0) {
        Tcl_SetObjResult(interp, Tcl_ObjPrintf(
                             "could not get modification time for file \"%s\"",
                             TclGetString(objv[1])));
        return TCL_ERROR;
    }
#endif
    if (objc == 3) {
	/*
	 * Need separate variable for reading longs from an object on 64-bit
	 * platforms. [Bug 698146]
	 */

	long newTime;

	if (TclGetLongFromObj(interp, objv[2], &newTime) != TCL_OK) {
	    return TCL_ERROR;
	}

	tval.actime = Tcl_GetAccessTimeFromStat(&buf);
	tval.modtime = newTime;

	if (Tcl_FSUtime(objv[1], &tval) != 0) {
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		    "could not set modification time for file \"%s\": %s",
		    TclGetString(objv[1]), Tcl_PosixError(interp)));
	    return TCL_ERROR;
	}

	/*
	 * Do another stat to ensure that the we return the new recognized
	 * mtime - hopefully the same as the one we sent in.
	 */

	if (GetStatBuf(interp, objv[1], Tcl_FSStat, &buf) != TCL_OK) {
	    return TCL_ERROR;
	}
    }

    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(Tcl_GetModificationTimeFromStat(&buf)));
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrLinkStatCmd --

    STORE_ARY("size",	Tcl_NewWideIntObj((Tcl_WideInt)statPtr->st_size));
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
    STORE_ARY("blocks",	Tcl_NewWideIntObj((Tcl_WideInt)statPtr->st_blocks));
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
    STORE_ARY("blksize", Tcl_NewLongObj((long)statPtr->st_blksize));
#endif
    STORE_ARY("atime",	Tcl_NewWideIntObj(Tcl_GetAccessTimeFromStat(statPtr)));
    STORE_ARY("mtime",	Tcl_NewWideIntObj(Tcl_GetModificationTimeFromStat(statPtr)));
    STORE_ARY("ctime",	Tcl_NewWideIntObj(Tcl_GetChangeTimeFromStat(statPtr)));
    mode = (unsigned short) statPtr->st_mode;
    STORE_ARY("mode",	Tcl_NewIntObj(mode));
    STORE_ARY("type",	Tcl_NewStringObj(GetTypeFromMode(mode), -1));
#undef STORE_ARY

    return TCL_OK;
}

	oldStyleBuf->st_ino	= (ino_t) buf.st_ino;
	oldStyleBuf->st_dev	= buf.st_dev;
	oldStyleBuf->st_rdev	= buf.st_rdev;
	oldStyleBuf->st_nlink	= buf.st_nlink;
	oldStyleBuf->st_uid	= buf.st_uid;
	oldStyleBuf->st_gid	= buf.st_gid;
	oldStyleBuf->st_size	= (off_t) buf.st_size;
	oldStyleBuf->st_atime	= Tcl_GetAccessTimeFromStat(&buf);
	oldStyleBuf->st_mtime	= Tcl_GetModificationTimeFromStat(&buf);
	oldStyleBuf->st_ctime	= Tcl_GetChangeTimeFromStat(&buf);
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
	oldStyleBuf->st_blksize	= buf.st_blksize;
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
#ifdef HAVE_BLKCNT_T
	oldStyleBuf->st_blocks	= (blkcnt_t) buf.st_blocks;
#else

    Tcl_Close(interp, out);

    /*
     * Set modification date of copied file.
     */

    if (Tcl_FSLstat(source, &sourceStatBuf) == 0) {
	tval.actime = Tcl_GetAccessTimeFromStat(&sourceStatBuf);
	tval.modtime = Tcl_GetModificationTimeFromStat(&sourceStatBuf);
	Tcl_FSUtime(target, &tval);
    }

  done:
    return result;
}