CorzSpaZio 1.3.1.0

A CorzSpaZio update. Changes..

+   You can now set the volume label from the drives list context menu.
	There is also a HotKey for this, which is F2 (standard rename hotkey).

+   You can now open the Recycle Bin from the drive list context menu for
	"My Computer", or whatever you call it on your system.

+   Added an edit CorzSpaZio.ini option to the Tray Menu. You can also
	disable this menu item in your CorzSpaZio.ini; sometimes useful in a
	professional setting.

	You can also set your preferred editor inside CorzSpaZio.ini (by default
	it is Windows Notepad).

+   Optical disks (including mounted disk images) now have an "Eject Disk"
	option in their context menu.

+   Network disks now have a "Disconnect Mapped Drive" option in their
	context menu.

+   CorzSpaZio will noe recognise SSD drives and give them a different icon
	in the list. I don't think the icon is actually an SSD drive, but it's
	the closest thing I could find inside shell32.dll. The 16x16 icon looks
	not too bad. I have no idea yet if this works.

~   For compatibility, the drive serial (in the dump file) is now in
	hexidecimal format.

~   Sometimes Windows doesn't return the correct drive label for mapped net-
	work drives. In this case, CorzSpaZio will use an improved method for
	retrieving this data. The label should now never be blank, unless of
	course, you set it that way!

~   If your main window is off-screen at launch (for example you login via
	RDP on a smaller device) CorzSpaZio will now fix this immediately on
	launch. Previously you had to restart CorzSpaZio to see the changes.

~   CorzSpaZio will no longer attempt an internet connexion to do version
	checking.

~   CorzSpaZio will timeout the version check connexion if nothing is
	received within five seconds. This shouldn't be needed as my server is
	fairly reliable, but you never know...

~   Finally for version checking, you can now specify "always" as the
	check frequency. This was designed for debugging purposes, but my server
	won't mind if you enable it. With version_checking=always, CorzSpaZio
	will check for a new version of itself at every shutdown.

*   The "Start With Windows?" dialog you get on first run wasn't setting the
	startup link correctly until the next time CorzSpaZio launched. It will
	now set the link immediately.

*   Fixes an issue I recently introduced where the email test caused
	CorzSpaZio to crash.


Full details in the itstory.

Grab the latest CorzSpaZio beta from the usual place.

for now..

;o) Cor

ffe2.. ffe Re-EnCoded!

Finding myself using ffe increasingly these days, especially with the lovely new x265 codec, I started adding and updating the code with things I wanted (man, some of this old code makes me chuckle), then I got carried away..

Yes, at long last (and when I look at the date of the original ffe release I see I ain't kidding), ffe2 is here!

It's HUGE. Okay, the size hasn't actually changed much, but the feature-set...

Here is the latest entry from the ffe version.nfo.

ffe2 The Highlights:

Batch operation
Automatic concatenation
Fully Customizable Preset Control, Help Buttons and Infinite Custom Command buttons!
Fully Customizable Command Buttons (you favourite settings and templates at a click)
Import/Export. Share your presets, custom command buttons, and settings, amongst other uses.
Drag-And-Drop commands (automatically generate media reports or run jobs for dropped files)
Cool Floating Drop Window (automatically run your drag-and-drop command and more)
More and Improved Controls!
Dynamic @tokens
Quit and Shutdown when done
Pre-Job Commands (run .bat files before the job)
Post-Job Commands (and after, with @token support)
Post-File Command (run custom commands on all created files, using @tokens, even inside a batch)
Media Info Reporting (ffprobe and MediaInfo support)
Improved Console Output (ffmpeg output AND now, ffe output!)
Live CPU priority Selector
Improved logging
Per-Job logging
Delayed/Timed Job Start (set jobs for after bed-time)
Recent files menu
Comprehensive command-line capabilities
Expanded tray menu.
Improved App Menu   (app global settings)
Output Toggle       (roll your own output for image sequences and more)
Windows Batch Script Output (a .bat you can run wherever ffmpeg is)
Lots of new context menus and options.
And Much, MUCH More!

In addition to the old ffe goodies..

	Magic Auto-Transforming Output Filename (never worry about overwriting previous tests)
	Infinite fully-customizable user presets in a handy drop-down
	Handy, fully customizable selectors for all your common ffmpeg settings
	URL input and output (HTTP/FTP/etc.)
	Live, interactive shell console output
	Accepts files and presets on the command-line.
	Super-Handy App menu for common settings.
	Drag-And-Drop file handling
	Optional Mouse-Over Help
	Handy HotKey operations.
	Comprehensive logging.
	And much more!

	And don't forget ffe comes with a Rastafarian-coloured logo!


You will note that as well as a raft of new features and fixes, the
application menu (aka. "app menu" - the one you get by clicking the icon
in the top-left of the window, right-clicking the window's title bar, or
hitting Alt+Space) has been much expanded.

This is used for application global toggles and settings. The tray, also
much expanded, is used for one-off commands, and the main GUI is for
your regular ffmpeg fun and games, which makes sense to me. Basically,
everything you can /see/, can be saved to a preset.

It should also be noted, the console output area is fully editable. You
can copy from there, paste, type. In other words, if you are ever
wondering, "where can I paste this groovy command I found on the web, so
I can edit and try it?" No need to switch to your text editor, there's
an edit area right there! You can drag files in, too; their paths get
pasted in-place. Handy.



NOTE: source code is available. If you don't like something, change it. Or
write a nice comment on the ffe page and I might do it.


Hackers, be warned; the source is a labyrinthine maze with bits hacked on
and in as need arises. There's no architecture to speak of. Watch out for
redundant bits, silly bits, you name it. Having said all that, it works,
and V2 sure is an improvement.

Have fun!



V2 The Details:


+   Batch Runs.

	ffe can now process multiple files. All you do is replace the file name
	with an asterisk/question mark. Your input could look something like..

		I:\Rip\ffe\Test\*.avi

	Which would have ffe process every AVI file in the specified directory,
	applying whatever options you have set in your various settings.

	You can also do:

		I:\Rip\ffe\Test\*.*

	which would process ALL the files in the directory.

	In other words, you can use regular Windows file name wildcards. These
	are all fine..

		I:\Rip\TV\Test\*.*
		I:\Rip\TV\Test\*.mkv
		I:\Rip\TV\Test\Suits*.*
		I:\Rip\TV\Test\Suits.S01E??.*

	The output input will display the */? to let you know a batch operation
	will occur. The actual output name will be created dynamically during
	the batch run and appears in that same space (which is greyed out during
	the run), displaying whatever file ffmpeg is currently outputting.

	Your console output and log file (if created) will contain output for
	the entire batch operation, and will be saved at the end of the batch
	run, to wherever you specify.

	And you can of course save batch jobs as presets. If you regularly find
	yourself, for example, grabbing the first fifty frames from a bunch of
	movies, you can setup an ffe batch job to process them all and then, in
	the future, simply drop the movies in your specified folder and launch
	ffe with the preset on the command-line. Or create a generic preset and
	drag in the folder... ffe is designed to accommodate many styles of
	working, at least, all the fast ones!

	You could make a single-click ffe shortcut on your desktop to handle the
	entire job.

	NOTE: You cannot create batch jobs with URLs as the input. However,
	there's nothing to stop you using URL for the output, perhaps an FTP
	directory.


+   Concatenation (joining).

	At the end of your batch operation, you can have ffe fire-up ffmpeg's
	built-in concatenation routines to join all the output files together.
	The concatenated output name can be set in your ini (default: "joined").

	To enable this, check the "join" checkbox before you run the job.

	NOTE: although ffmpeg/ffe will allow you to join *any* files together,
	it is obviously only going to work correctly if you join files with the
	same output format, dimensions and such. HOWEVER, if you are looking for
	some zany, original video effects, or to create an audio track, go right
	ahead!

	NOTE: If you have overwrite enabled, this also applies to any
	concatenated output; you won't have to respond to ffmpeg's command line
	prompts, unless you want to.

	The concatenation task details also appear in your job log.


+   Improved the log output and final time readings. Instead of always
	getting rounded seconds, you will now get a more human readable output,
	with hours and minutes. Accuracy is also improved for short timings
	(under a minute) where the readout will /not/ be rounded.

	The original (rounded seconds) output will appear in braces next to the
	regular output, in case you like seeing that, e.g..

		Completed in 3.19755239240638 seconds	(3.2 seconds)


+   Added "Abort Batch" to tray menu. If you use the regular "F4" to quit
	the ffmpeg task during a batch run, ffe will skip right to the next
	file. If you want to abort the /entire/ batch, use the tray menu item.
	There is also a hotkey for this, which is: Pause/Break.

	NOTE: Pause/Break will also abort any single task, so makes sense to use
	for all aborts.


+   Customizable Control Buttons.

	These are nifty. You can specify /any/ number of custom buttons to add
	whatever parameters you want to the extra/input parameters input. Okay,
	it's actually 500, but seriously, no way you are fitting 500 buttons in
	there.

	Custom buttons are simply a place to store your argument "sinppets".
	Things which are often used and could be applied to many presets (which
	can be thought of as "scenarios").

	For example, you might have a button called "Add Subs", which would add:

		 -scodec copy -metadata:s:s:0 language=eng

	into the extra arguments. Or another button (keeping with the subs
	theme) named "Subs Probe", which adds something like:

		  -probesize <bytes> -analyzeduration <microseconds>

	Or whatever you like. This is especially useful for filters and other
	things you use over and over, as well as a place to put "templates",
	base settings that you can tweak on a per-job basis, perhaps saving the
	actual button value as <what-unit-it-is>, in case you forget.

	You can control how many columns of buttons there are, or set it to auto
	and let ffe work it out (the number of rows is always worked out
	automatically).

	There is no theoretical limit to the number of columns you can create,
	though you will need a wide monitor and a large window to display
	double-digits of columns!

	For example, if you have 10 buttons but only specify 3 columns, you will
	only see (with default button dimension settings) NINE buttons, as there
	is a limit to the number of rows which can be displayed inside the
	interface - ffe will stop creating custom buttons when it has filled all
	the rows. So ensure you create enough columns to house all your custom
	buttons, or set it to "auto" and ensure your window is wide enough.

	You can also control the width of the actual buttons and the font size
	used (as well as spacing, Y-position and button height). You can have
	HEAPS of small buttons or a few, well labelled big buttons. Your call.
	Hovering your mouse over any custom button pops up help text with the
	contents of the button.

	Buttons are created left-to-right, row-by-row. A few example buttons are
	provided. Old ffe.ini files without custom buttons will get the samples
	automatically installed with this and later versions of ffe.

	Click the button and its parameters will appear in your extra arguments
	input. Simple. Click the button a second time to remove that same
	command. Like I said, nifty.

	You can set the number of columns directly from the App Menu (up to 24
	columns, if you need more, set it in ffe.ini, or use the Auto setting),
	and have the buttons re-created live inside the GUI, with any new
	buttons you just created appearing instantly.

	If you don't want to change the number of columns, only refresh (perhaps
	to show manually added buttons - though why - the GUI inputs are
	great!), simply re-select the current number of columns!

	As mentioned, there is also an "auto" setting, which will automatically
	select the number of columns based on the width of the window and number
	of buttons. This works great and is what I use myself. In auto mode,
	resizing the main window recalculates the buttons.

	If you Shift+Click any of the buttons, you can edit the button directly
	from within ffe. NOTE: If you /change/ the name of the button, you will
	create a new button.

	Or rather, if you want to create a new button, simply enter a new name
	in the button editor name input. The idea of this is that it is QUICK to
	create a new button:

		Shift+Click ANY button
		Type Name <enter>
		Type/Paste Function <enter>

		Voila! A New Custom Button.

		And the code goes directly into the extra arguments input, so you
		don't even have to click the button you just made.

	Each button also has a context (right-click) menu where you can choose
	to rename or delete your button if required. There is no warning with
	the delete option, okay, there's one, the very first time you use the
	facility. THEN there is no warning. You have been warned!

	You can use "&" symbols in the names part to specify accelerators for
	these buttons, i.e. "Blur &1", which would enable you to activate that
	button by doing "Alt+1" on your keyboard. Or "&Blur", which would enable
	you to activate it with Alt+B.

	** BY THE WAY, if you don't *see* the accelerators when you launch ffe,
	hit the ALT key one time.

	As a bonus, if you hold down the Ctrl key while you click the button,
	the action will apply not to the extra parameters input, but to the
	INPUT parameters override, so you can use your custom buttons to keep
	snippets for either or both inputs. Ctrl+Click the button a second time
	to remove the arguments from the override input.

	See the [custom buttons] section of ffe.ini for the actual button data.

	You generally don't need to concern yourself with this as all the
	create/edit/rename/delete functionality can be got at from the GUI,
	however, for those that like this sort of info, here it is..

	A [custom buttons] section looks something like this..

		[custom buttons]
		&Sharpen A=-vf "unsharp=5:5:1.0:5:5:0.0"
		Sha&rpen B=-vf "unsharp=luma_msize_x=7:luma_msize_y=7:luma_amount=2.5"
		&Blur=-vf "unsharp=7:7:-2:7:7:-2"
		BoxBlur &1=-vf boxblur=2:1
		BoxBlur &2=-vf boxblur=2:1:cr=0:ar=0
		&PNG 1/s=-r 1 "output%05d.png"
		HQ &JPG 1/s=-r 1 -qscale:v 2 "output%05d.jpg"
		&Glow=-vf "frei0r=glow:20"
		Pi&xelate= -vf "frei0r=pixeliz0r:0.02:0.02"

	On the left, the name of the button (including &Accelerators). This will
	be the text on the button itself. It is also used for the pop-up tooltip
	(along with the command). On the right goes the command to add to the
	extra parameters.

	Don't worry about colons and quotes and stuff leaking into your file
	names via the MATOF string; ffe is smart enough to handle this. Usually
	you don't need the quotes, anyway, but they can improve readability.

	You can include notes along with the button. These notes will be
	displayed in the mouseover ToolTip. This is a handy place to put
	explanations for obscure parameters. These are stored inside the custom
	buttons section of ffe.ini, simply added onto the end of the command
	after a pipe "|" character, like so..

		[custom buttons]
		add SRT subs=-scodec copy -metadata:s:s:0 language=eng|merge subs in original SRT text format and set the language to English.

	NOTE: when editing custom buttons, the final (3 of 3) dialog is the
	comment input. If you immediately dismiss this dialog (Esc key) any
	current value will remain unchanged. It's quicker if you just want to
	edit the actual command - the most likely scenario. If you want to
	delete the comment, delete it in the input and click <OK>, as usual.


~   Because of the custom buttons and their accelerators, I have moved all
	Alt+hotkeys to Ctrl+Hotkeys, leaving you free to use ALL available
	accelerators for your custom buttons. Yum.


+   Console output messages. ffe will now drop useful messages into the
	console output, for example, confirmation when you wipe or add a preset,
	save or update a custom button, change AppMenu items and so on.

	Also, when you load a preset, ffe will use this facility to inform you
	if the status of any hidden settings have changed, e.g..

		loading preset: Apple Movies
		default_extension: "mp4"

	Because of this and other console output enhancements and integrations,
	console output has become integral to ffe's operations and you can no
	longer disable it.

	If you really need to not see it, ffe will allow you to resize the main
	window small enough to hide it!


+   Automatic backup of wiped presets. You can still use the old method
	(creating a second preset with some string added to the end, which will
	be ignored during presets load) but ffe will now create an automatic
	backup of any wiped preset, just in case.

	Obviously, these backup presets do not appear in the presets drop-down.

	There is also a new context menu on the presets drop-down, with an
	option to delete all backup (wiped) presets.


+   A quick way to update the location of your ffmpeg binary: drag it into
	ffe's file input.


+   NEVER OVERWRITE fail-safe. This just happens, there is no setting.
	Basically, ffe will never instruct ffmpeg to overwrite a file which has
	been created in the current job. This is to prevent people shooting
	themselves in the foot, waking up the next morning to find their
	expected dozen 1080p TV episodes have been transformed into unplayable
	subtitles files, which could potentially happen if you used the *.*
	wildcard on a directory which contained auxiliary files, e.g..

		my-movie.mkv
		my-movie.srt

	And didn't double-check your parameters! When encountering this
	(admittedly, your) instruction, ffe will give the to-be-created file a
	random suffix. Remember, when using wildcards in general, it's usually
	wise to specify as *much* as possible of the file name.


+   Added a "short test" button, which simply adds parameters to the extra
	params input, specifying we process only the first 1000 frames, a thing
	I do a lot. You can, of course, then edit this setting inside the extra
	parameters input, as usual.

	You can also specify the number of frames the button adds; Shift+Click
	the button to edit this number before insertion. Right-click the button
	for an edit-only option. And of course you can edit ffe.ini directly.


+   There are now up to FIVE configurable help buttons that open (by
	default) the basic, formats, filters and codecs help files, as well as
	the FULL ffmpeg help text, respectively, within the console output. As
	usual, Shift+Click opens the help text in your default .nfo viewer.

	These are super-handy when when you want to quickly check an ffmpeg
	parameter, of which there are a ridiculous amount, which btw, I love.

	These texts are also dumped to your data directory (second and
	subsequent viewings in the same session will load these dumped files
	rather than create afresh with ffmpeg.exe). They are always created
	fresh at least once per session, in case you updated your ffmpeg binary.

	You can edit these buttons; the text they show and what they do; inside
	ffe.ini. The format is fairly straightforward..

	help_texts="Main|help.nfo|-h,Formats|help-formats.nfo|-formats,Filters|help-filters.nfo|-filters,Codecs|help-codecs.nfo|-codecs,Full|help-full.nfo|-h full"

	Each help file section is separated by a comma "," and each property is
	separated by a pipe "|" character, basically..

		Title|output-filename.ext|ffmpeg command

	The first entry will be CAPITALISED and used in the ToolTip entry, which
	makes for faster recognition, should you forget which button is which
	and need to hover over them to get help.

	With this in mind, I also added a wee help text which pops up the name
	of the button in Big Letters in the space above the buttons. The text
	there will appear Proper Case, regardless of how you enter it in your
	preference. Yes, I am evil!

	And as I mentioned, you can have up to five buttons. Or none at all.
	Your call.

	NOTE: when using the help launch option (Shift+Click), ffe will use your
	system's default viewer/editor for that type, so use whatever file
	extension launches your preferred viewer.


+   Delayed Job Start. In the System Tray menu, is an option to start your
	job at a later time. A simple dialog will let you choose how many days,
	hours and minutes you wish to delay the job for, or alternatively, pick
	an exact date+time from the picker.

	At any rate, ffe will then go into suspend mode until your chosen time
	arrives.

	You will note the delayed start system tray menu item is now checked. If
	you wish to abort the delayed start, uncheck that. This also works if
	you were daft enough to start the delayed start with no input & output
	files specified!

	Once delayed start is activated, ffe posts a handy, human-readable
	countdown timer in its main window TitleBar, lets you know exactly how
	long there is to go. For those that don't know chops from cheese, you
	can disable this inside ffe.ini.

	There is a HotKey for this: Ctrl_D.

	IMPORTANT: In suspend mode, ffe will still accept changes to the job's
	parameters.


+   Floating Drop Window

	You can open a floating, transparent drop target which acts just like
	ffe's regular input file input, so you can drag in files and folders and
	have ffe process them immediately with your current drag-and-drop
	command, or just insert them into your file input. You can also use it
	to set the location of your ffmpeg binary, which some folk need to do a
	lot.

	The drop window floats above all other windows on your desktop, so it's
	always available to accept files and folders. During ffmpeg jobs, the
	drop window will hide itself.

	The floating window is created from an image. A few samples are
	provided. Many more here..

		http://corz.org/windows/software/ffe/files/

	You could use a regular rectangular image, but the facility is
	designed to be used with a partly transparent image, so you can have
	some useful shape floating on your desktop, something that fits well
	into a corner, or along an edge, or resembles Jessica Alba, or whatever.

	Click and drag anywhere inside the drop window to move it around.

	You cannot usefully resize this window, if you need a different size,
	use a different sized image! There is nothing to stop you using an image
	the size of your entire desktop or bigger (ffe will use a bit more
	memory, that's all), maybe create a live border around one the edge of
	one of your monitors. A few "strips" are provided for edge use.

	For PNG and ICO files, ffe produces a proper transparent window with
	full alpha blending - drop shadows will look lovely. This enables you to
	produce some beautiful and useful "shades". GIF, WMF and EMF do not
	supports partial transparencies, but you can still have useful shapes.

	NOTE: The floating window will change transparency (to 50%) when you
	hover your mouse /anywhere/ over the image rectangle, but only the
	visible parts of the window are *active*. In other words, if you drag a
	file onto an empty part, it will fall right through!

	This is by design (so you can click-through the window). If you need a
	window that can accept a drag-and-drop across the entire rectangular
	area, set the outlying transparency to 1%, rather than 0. It will still
	be invisible to the naked eye, but will prevent click- and drag-through.
	You can also apply this 1% to inner areas, whilst leaving the outside
	shape "shaped", i.e. completely transparent, for click-through.

	An example of this principle is included in the distribution, named:

		drop-movie-to-ffe-SOLID-CENTRE.png

	In this example, the outside (curved) edges of the floating window are
	completely transparent, if you click outside the shape (yet still within
	the "rectangle"), the click will pass straight through. If you click in
	the "transparent" middle section, although it "looks" transparent, it
	behaves just like the visible parts of the window; click and drag to
	move, accepts file, and so on.

	You can also set the overall transparency of the visible parts of the
	floating window (the transparent areas of a transparent image will
	always be 100% transparent - unless using the above-mentioned trick).
	You can set it from 0 (opaque) to 100 (completely transparent). As
	mentioned, it will jump to 50% visiblility when you hover your mouse,
	over it, for feedback (unless you already have the transparency set to
	within 10% of 50%, in which case it will jump to 0% transparency).

	ffe uses Windows GDI+ to handle images, so technically, anything GDI+
	can load, ffe can use.

	Yes, you can use animated GIF files**. And yes, they will animate. Note:
	dragging a file onto a wildly dancing elf could be tricky, though not
	impossible! Gently throbbing buckets and such-like work well, though.

	Image formats that I know work:

		PNG, GIF, ICO, JPEG, BMP, EMF, WMF, PCX (most), EPS (some) and TIFF

	Transparency supported:

		PNG, GIF, ICO, EMF and WMF

	Alpha Blending (proper shadows and semi-transparencies) supported:

		PNG and ICO

	Animation supported:

		GIF

	Right-Click the Drop Window for a fantastic context menu. There are
	options to refresh the menu and close the floating window, as well as
	pick a new images folder, open the current image's folder and exit ffe.
	But that is not all..

	Any /other/ allowed images you have sitting in the same folder as your
	drop window image will appear in an "Images" menu. And any images you
	have in folders inside /that/ folder will appear as submenus, and so on,
	all the way through the entire directory tree. Aye. Select any image to
	switch to that image, obviously.

	Drag one of your allowed image types into the drop window and it becomes
	the new drop window. Allowed types are set in ffe.ini - by default, png,
	gif, emf, wmf and ico files, because they can all have transparencies.

	The images (context) menu has two modes of operation, fixed and fluid.

	In fixed mode, you set a "root" Images directory and the context menu
	always displays that directory tree. You can also, optionally, have ffe
	copy all dragged images into your Images folder.

	In fluid mode, the Images menu instantly switches to the parent folder
	of whatever image you select or drop in.  When I say "instantly", I mean
	as soon as ffe has finished scanning the entire directory tree for
	allowed images, which could take a moment, especially if you choose HUGE
	media directories.

	When the drop window is active you can also use the left/right arrow
	keys to cycle through the current images menu, yes the WHOLE menu, right
	through all the subdirectories, in order. ffe should be good for up to
	five million items, though whether your system can handle a menu this
	big is another story.

	Remember, the hotkeys cycle through the *menu*, so if you have fluid
	mode disbled, drag in an image and hit left/right, you will get an image
	from the main drop window images folder. If Auto-Copy is enabled, your
	new image is also immediately available from the menu/keys.

	ffe is happy to use an image from *anywhere* on your system, regardless
	of which mode you are in, fluid or fixed, and regardless of whether or
	not the image is in your specied Images directory.

	If you key past the end/start, ffe cycles back to the start/end.

	It's okay to load LARGE animated GIF files. I haven't found one ffe
	couldn't handle (the largest one I have is just under 6MB). As they say,
	YMMV.

	You can switch the Drop Window on/off from the main GUI (the wee target
	button next to the file input) or the tray menu or by the HotKey (F9).
	You can also (from the tray and drop window context menus) toggle
	fixed/fluid mode as well as auto-copy images and choose a new location
	for your (fixed) image folder, pretty much everything you should need.

	NOTE: when fluid menu is enabled, the "Copy Dragged Images" and "Choose
	Image Folder" items are greyed out. While technically possible to allow
	users to alter these settings whilst in fluid menu mode, it would only
	lead to confusion. When fixed mode is enabled (or rather, fluid mode
	disabled), these items will again be active, which leads to the opposite
	of confusion.

	I discovered that the Drop Window also doubles up as a handy animated
	gif viewer, not only with left/right arrow control through an entire
	TREE of images, but showing the images directly on your desktop overlay,
	which everyone who sees it will agree is pretty darned cool.


	This drop window facility took way more code+time than I expected, so
	please use it HEAVILY!


	I should add, when I (and many thousands of others) want to get windows
	EXACITALY at the edge, or over the edge, or just want a super-easy way
	to do window moving and resizing in general, I use KDE-Mover-Sizer..

		http://corz.org/windows/software/accessories/KDE-resizing-moving-for-Windows.php

		(Drag window over corner of desktop, Alt+RightClick. Done.)


	** Animated GIF support is courtesy of trancexx. Cheers! If you are
	compiling your own ffe, you will find this support is trivial to
	remove/add, should you feel the need.


+   Recent files menu, in the system tray. Any files you create are added to
	this menu. Select a file to open it with your system's default viewer
	(whichever app is set for the "Open" verb).

	Files are only added once, from the bottom-up - the most recently
	created files go at the top.

	By default, this information is /not/ stored between sessions, but you
	can enable that, if you wish, inside ffe.ini.


+   Improved "singleton" behaviour. If ffe is already running and you send /
	drop a file to ffe.exe, it will now, rather than simply quit; instead
	bring the currently running instance to the front, inserting the new
	file path into the file path input.

	For those testing multiple ffmpeg binaries with multiple ffe setups, or
	whatever, you can disable this behaviour from inside ffe.ini and run
	multiple instances easily, perhaps with different settings, though
	multiple instances of the same installation also work fine.


+   Shutdown when done. It can be handy to have ffe shutdown your computer
	at the end of a long job. Set this to true to do exactly that.

	This setting is also available directly in the GUI.

+   Quit when done. Works exactly the same way as Shutdown when done.

	Both Shutdown when done and Quit when done also can be saved your inside
	presets for convenient scheduled operation.

	NOTE: If shutdown when done is enabled, the quit when done setting is
	not available. Before shutting down your computer, ffe will quit.


+   Click the label next to the output path input to COMPLETELY disable the
	output. This is handy if you are cooking up your own custom output, for
	example when creating image sequences. This state is saved/restored
	inside presets.


+   Intelligent Output Path.

	Okay, semi-intelligent. ffe will attempt to create valid paths in your
	output input (how confusing!), which is the input area where you enter
	(or better yet, ffe enters) the name of the output file.

	You can drag files and folders in there and ffe will work it out. For
	example, if you have an input file, "D:\path\to\movie.avi", the output
	input might read "D:\my\rips\movie.mkv". If you then drag the folder,
	"D:\some\other\folder" onto the output input, it will now read,
	"D:\some\other\folder\movie.mkv", automatically inserting the folder
	part before the file name part to create a valid output file path.

	If you now toggle the MATOF switch, the MATOF string will be added to
	and removed from this new path, e.g..

	  "D:\some\other\folder\movie[libx265][AAC][-strict experimental -preset medium -x265-params crf=22].mkv"

	Tip: If it's being too clever for its own good, delete the output and/or
	hit the MATOF button a couple of times! ;o)

	NOTE: As soon as you click your mouse in this input, you disable MATOF.


++  You can now set the CPU priority of the ffmpeg task. There is a also
	sub-menu in the app menu for setting this. Note: you can adjust this
	live, whilst ffmpeg is running.

	In practice, CPU Priority doesn't make a huge difference, at least on my
	system, though could be handy for taxing jobs on computers with minimal
	resources, or for squeezing every last drop of speed out of ffmpeg for
	jobs you want done NOW.


~   Selected text in the console output window will now retain its selection
	when the output is not in focus. As well as being generally useful, it
	means you can actually see matches when using the search function!

	By the way, I didn't write the search function, it's one of those AutoIt
	UDFs, so apologies for any niggles you may have with it. Feel free to
	write a better one! I did improve its behaviour slightly (editing UDFs!
	AARRGH!!) so that you can Find >> Type >> Enter to get straight to a
	result.


+   ffe can now dump the log output next to the output file after every job.
	The preference (in ffe.ini) is:

		log_each_job=true/false

	Note: The per-job log will follow your global log_append setting. You
	can set this from the App Menu.


+   frei0r plugin support. OK, technically, ffe doesn't need to support
	ffmpeg plugins as it is only a front-end, HOWEVER, anyone who has tried
	to play with the the excellent frei0r plugins on Windows will realise
	that this isn't always straightforward. Inserting system environmental
	variables at run-time is outside the skill-set of the average user, for
	a start.

	ffe lets you choose a plugin folder, a place to dump your frei0r and
	other ffmpeg dlls, and injects this path into the system environment
	variables each time you run ffmpeg, ensuring point-and-click simplicity
	when running frei0r processing plugins.

	A couple of frei0r examples are included in the custom buttons. Enjoy!


+   You can now set the font and font size for the console output, defaults:

		console_output_font="Lucida Console"
		console_output_font_size=9

	BTW, I use:

		console_output_font="ProFontWindows"
		console_output_font_size=9


	For clarity, these settings are also used for the input parameter
	override and extra parameter inputs.


+   Added @tokens for the extra parameters input.

	Using tokens, you can have extra arguments like this (note: regular
	output is disabled in this example, as we are specifying our own
	(images))..

		-vframes 50 -r 1 "@parent\@item_[@ext]_%04d.png"

	Which would grab 50 images from the first 50 seconds of video (one per
	second) from an input file like this:

		V:\Surreal\Un Chien Andalou - 1929.mpg

	and output files named..

		V:\Surreal\Un Chien Andalou - 1929_[mpg]__0001.png
		V:\Surreal\Un Chien Andalou - 1929_[mpg]__0002.png
		V:\Surreal\Un Chien Andalou - 1929_[mpg]__0003.png

		And so on.

	Here are all the available @tokens:

		@item           Base name of input file, minus extension.
		@ext            File extension of input file.
		@oext           File extension of current output file.
		@ofilename      Basename of current output file.
		@outputfile     Complete path of current output file.

		@sec            Seconds value of clock. Range is 00 to 59
		@min            Minutes value of clock. Range is 00 to 59
		@hour           Hours value of clock in 24-hour format. Range is 00 to 23
		@mday           Current day of month. Range is 01 to 31
		@mon            Current month. Range is 01 to 12
		@year           Current four-digit year
		@wday           Numeric day of week. Range is 1 to 7 which corresponds to Sunday through Saturday.
		@yday           Current day of year. Range is 001 to 365 (366 in a leap year)

		@parent         Parent directory of input file
		@outdir         Output Directory (wherever ffe is currently outputting files)

		@tempdir        System Temp directory
		@datadir        ffe data directory (in portable mode, it is the program folder)
		@desktop        Current user's desktop folder
		@programfiles   Your Program Files directory
		@homedir        Current user's user directory, e.g. "C:\User\Fandango"
		@mydocuments    Current user's "My Documents" directory.


	And because @token processing is performed on the extra arguments, you
	can use @tokens in your custom buttons. Happy days!

	@tokens are also available for the input parameter override. I haven't
	played with this much, but the possibilities are mind-boggling. For
	example, a big directory full of movie.mkv + matching movie.srt files
	you want to combine, you could do something like this in your input
	parameters:

		-i "@parent\@item.srt"

	And WHAM! ffe processes the entire folder, adding subtitles to all the
	.mkv files and outputting them wherever.

	That cute input override should work for single files, too.


+   @Tokens can be used for ALL path preferences in ffe and inside
	ffe/ffe.ini. Try it!


+   ffprobe media reporting (instant .nfo files!).

	If you have ffmpeg, you most likely have ffprobe sitting right next to
	it. Let's use it. ffe can now generate a media report for your files
	which you can view in ffe's console viewport and/or your favourite
	viewer.

	You can set the reporting format (ini, xml, csv, etc.) as well as the
	output file location (dynamic @tokens supported) and file extension (the
	default being "auto").

	By the way, these values are gathered fresh each time you click the
	button, so you can change them (from the app menu) and then create a
	report with a /different/ format instantly.

	The other settings are available inside ffe.ini, along with the ability
	to add any extra parameters you may need to pass to ffpprobe, as well as
	the ability to automatically unescape the output, if required.

	Note: the "compact" report might wrap in your console viewport, but the
	saved version will be just fine! It is only /vertically/ compact!

	Yes, you can use URLs as input files for media reporting, the same as
	regular ffmpeg file processing, grab all the info from an rtmp stream,
	or whatever.


+   MediaInfo Support. Same as above, but instead using the excellent
	MediaInfo:

		http://mediaarea.net/en/MediaInfo

	You want the CLI version, in 32 or 64 bit, depending on your OS. Install
	it somewhere in your program files if you haven't already.

	And again, you can pass it extra parameters inside fee.ini, if required.

	Sadly, you cannot use URLs as input with MediaInfo.


+   Automatic audio file extension from codec.

	If you are extracting an audio stream from a movie file; video set to
	disabled, audio set to copy; ffe will probe the video file to discover
	what audio codec is used and, assuming MATOF is enabled, automatically
	set this as the output file extension.

	If you have a batch job, the extension will temporarily show as ".wav",
	but once the job starts, ffe will insert the correct extension. Yes, you
	can easily rip the audio tracks from a bunch of movies at-once.

	If you /choose/ an audio codec, ffe will of course honour your decision
	and re-encode the audio to that format, as usual.

	NOTE: If you move ffprobe.exe away from ffe.exe, this will not work.


+   Added a new command-line switch, "run", which works exactly the same way
	as the old "go" switch, except ffe will quit when the job is done.

	Note: when using the "run" switch, you will NOT be asked whether or not
	you wish to abort the quit process (unlike setting quit_when_done=true).
	ffe will simply quit.


+   Same again, but for shutdown, using the unsurprisingly named, "shutdown"
	switch. Works exactly the same way as the "run" switch, above, except
	that ffe will shutdown your computer at the end of the job.

	Just like, "quit", if used with a "run" switch, THERE WILL BE NO PROMPT.
	The machine will simply shutdown. Use with caution!

	Don't worry if these are set inside a preset that you then run live in
	ffe (as opposed to via the command-line). If there is a window visible,
	ffe will always warn the user before a shutdown.


+   Pre-Job and Post-Job Commands.

	You can now specify a set of windows shell commands to run before and/or
	after ffmpeg job runs. You can set the name of this file inside ffe.ini,
	or create one from ffe's system tray menu.

	You can enter a simple file name, in which case it is assumed to be
	inside your data directory (in portable mode, that is the same directory
	as ffe.exe) or you can enter the full path to the file.

	These are standard windows commands, EXACTLY LIKE YOU WOULD PUT IN A
	.BAT (Windows Batch Script) FILE.

	I use this to empty target folder then copy test files over from the
	source folder for a fresh batch of tests, but the facility has many
	potential uses.

	Post-Run commands are handy for doing things like..

		mkvpropedit "@outputfile" --edit track:s1 --set flag-default=1

	  (setting the subtitle track of a movie as the "Default Track",
	   which ffmpeg currently cannot do)

	You can also set these file paths inside individual ffe presets for per-
	preset pre- and/or post-run commands. These settings can be inherited
	with presets, too.

	If a pre-run commands file exists for the current preset, you will have
	an "Edit Pre-Job Commands File" option in your ffe system tray menu.
	Otherwise you will have a "Create Pre-Job Commands File" option. Same
	for the Post-Run commands.

	You can enable/disable this facility for individual jobs/presets from
	the main GUI. If the commands file does not exist, the gui controls are
	greyed out.

	When enabled, you can right-click either of the two controls to specify
	a new pre or post-job commands file at any time.

	NOTE: ffe can either run the .bat file with the Windows shell, where the
	Windows command interpreter processes the file like a regular batch
	file, which should work fine, or else process the commands itself,
	one-by-one.

	Using the first method, you should name your commands file <name>.bat.
	Using the built-in method, ffe doesn't care what extension you use, it
	will run the commands, in order, one-by-one. Your call.

	If you are doing complicated loops and GOTOs, you definitely want to use
	the former method, like so..

		run_commands_with_shell=true


+   Post-File Comands.

	You might have looked at the example Post-Job command (above) and
	thought, "But what if I'm running a batch?". Good Question!

	A Post-File command is a command which is run on every file which is
	output by ffmpeg. While your post-job batch script will run at the very
	end of the job, the post-file command runs for each and every file you
	create, as soon as it is created.

	Of course it is designed for post-processing @outputfile, but just like
	the pre- and post-job commands, it can be anything at all.

	You can switch this facility on/off inside the main GUI (job buttons).

	Right-click the control to get a fancy input dialog where you can enter
	the actual command to be run. You can drag files into that input to have
	their paths pasted in-place (where the caret is).

	NOTE: UNLIKE the pre-job and post-job commands, this command is not
	processed by the Windows Command Interpreter, it is run directly by ffe.

	You will probably want to put quotes around any paths you use, which
	includes "@outputfile", though because the command is run directly by
	ffe you shouldn't need to put quotes around the exe's path, for example,
	this is fine..

		C:\Program Files\Video\Converters\MKVToolNIX\mkvpropedit.exe "@outputfile" --edit track:s1 --set flag-default=1

	It's basically:

		<PROGRAM> <ARGUMENTS>

	However, if you try to do something like this..

		C:\Program Files (x86)\MediaInfo\MediaInfo.exe "@outputfile" > "@outputfile.nfo"

	ffe will recognise you are trying to do a shell redirection, grab the
	Std I/O and save it to the specified file. How cool is that!


+   Drag-And-Drop Commands.

	What?

	Basically, this is a command you can set to be performed whenever you
	drag and drop a new file onto ffe's file input. Currently available
	commands are "go", which immediately runs the current job with the new
	file, and "report" which immediately produces a media report using your
	current media reporting preferences.

	You can switch this functionality from the app menu.


+   Script Output (including batches).

	Hold down the SHIFT key when you click the "Do It" button, and instead
	of sending commands to ffmpeg, ffe will run through the job, saving the
	ffmpeg commands to a regular Windows batch script you can use to run the
	ffmpeg job wherever/whenever you like, send to others, whatever, even
	when/where ffe isn't around.

	You can setup long batch operations, with concatenation, use presets,
	all with a single click, even automate the process, run from inside
	other batch scripts.

	Note: If your job contains pre-job shell commands, they too will appear
	inside the batch file.

	If your job includes concatenating files, the concatenation list will
	be saved to the same folder as your batch script (which you get to
	choose). The idea being, that is where you will run the batch from. So
	long as you keep the files together (ffe-concat-list.txt and ffe.bat),
	everything will work as expected. If you need to do something tricky,
	edit your .bat file accordingly.

	You can also set this as a launch switch, exactly the same as "go",
	"run", etc. (so you could also set it as an Explorer context command)
	The switch is "generate". It acts like "run" in that after completion of
	the job, ffe will quit. The batch file (and concat list, if applicable)
	will be saved to the current working directory.

	The following example would generate a "ffe-concat-list.txt" and
	"ffe.bat" in the current working directory. Running the batch file gets
	you all the .mkv files inside "I:\Rip" converted to x265 and joined
	together into one movie file (assuming you have this exact preset AND
	hypothetical directory, and that joining is enabled, of course)..

		ffe.exe generate(x265 HEVC AAC medium AAC) "I:\Rip\*.mkv"

	When used this way, you won't see the main ffe GUI; ffe will simply
	generate the batch file and then exit. The one or two files will be
	immediately available for further processing by other devious processes.

	When scripting, don't forget to specify output files, or else ensure
	MATOF is enabled for your specified preset, or else ffe may present you
	with a file save dialog! Testing first is always advised.


+   Import / Export..

	There are new items in the preset selector's context (right-click) menu.
	Also in ffe's system tray menu..

	"Import Data" can import ANY ffe setting, be it preset, custom button or
	main settings. ffe will present you with a dialog to choose which
	settings, if available, you want to import (if the file only contains
	presets, you will only get that option).

	Note: if your import file contains only two main settings (inside an
	[ffe] section), ffe will only write those two settings to your ffe.ini,
	everything else will be untouched. Same for buttons; new buttons being
	added onto the end of your current buttons, as expected.

	NOT SO WITH PRESETS, which will be completely replaced, assuming you
	have an existing preset with the same name. New presets get tagged onto
	the end of your existing presets.

	ffe will always create a time-stamped backup of your current ffe.ini
	before performing import operations. This is placed with other backup
	ini files, in your ffe data directory.

	"Export Data" works the same way, but for exporting; you can export main
	settings, buttons and/or presets. Export all three and you basically
	create a condensed (no comments) version of your ffe.ini file.


+   Added "Open Log File" item to the tray menu.


+   Retain settings on exit.

	ffe can remember what you were doing and restore it all the next time
	you run ffe. You can toggle this behaviour from the app menu (Ctrl+E).

	Note: when launched with a job ("go" or "run") on the command-line, this
	behaviour will be temporarily disabled. It will /not/ be disabled if you
	load a job from the command-line using the "load" switch.

	NOTE: this doesn't affect your default preset. ffe creates a separate
	temporary preset to house all your settings.

	NOTE: If you run multiple instances of ffe, later-quitting instances
	will, by design, overwrite the exit settings of earlier instances. The
	/last/ instance is the one that will be remembered for tomorrow/next
	session, though note, if you had five instances of ffe running and quit
	instance 3, then open another instance of ffe, it (ffe6) would open with
	instance 3's settings, as instance 3 was the "last quit".

	Of course, if you are using multiple portable versions, none of this
	applies, they will each retain their own settings.

	FYI, the ini [section] is named "FFE-EXIT-SETTINGS".


+   You can drag files into the console output area. Its path will be pasted
	into place (for working on parameters for ffmpeg). Same goes for the
	input parameter override and extra arguments inputs.

	NOTE: Input override parameters are not added to the MATOF string, as
	this creates LONG file names.

	The two wee buttons next to the input parameters override are "+", which
	simply adds:

		-i ""

	to your input and places the caret bewtween the quotes. Then you can
	drag a file in and its path goes precisely where required. You can do
	this multiple times, ffe will place the new -i "" at the end and pop the
	caret inbetween the quotes. It's something I do a lot, and one click
	beats one click plus seven keystrokes any day!

	And "x", which instantly deleted the entire contents of the input.
	Another oft-used time-saver.


+   Greatly expanded the built-in lists of audio and video encoders.
	Basically, I added them all. At least, all the ones you would find in an
	official (free) binary. If you roll-your-own, you can add whatever you
	need (libfdk_aac is already there).

	NOTE: If you upgrade, YOU WON'T GET THESE. You might want to copy the
	prefs from the new supplied ini file, or else copy your presets into a
	fresh ini file, which has all the new goodies.

	NO! That sounds too complex. Better to use ffe's new import facility and
	the ffe-upgrade.ini. Drag-and-drop - you're done. See below for details.


+   Improved help ToolTips. Hover your mouse over any control (for the drop-
	downs, hover over the chevron) to get mostly useful help and tips.


+   You can now also disable the helpful ToolTips, inside ffe.ini and from
	the ffe app menu (restart required). I don't recommend this. No, I don't
	recommend this. For a start, how will you remember the contents of all
	your custom buttons? Go on, leave the tips enabled!


+   Added more console output, for those that like that sort of thing. Note:
	I mean StdOut. You would need to be running ffe from inside another
	process/debugger/code-monster to see this stuff.


+   You can now choose to NOT sort the presets drop-down.

	By default, ffe sorts the list of presets to make it easier for regular
	folk to find their chosen preset. But you might prefer ffe not do this.

	With sorting disabled you get your presets presented in the order they
	appear inside ffe.ini; most likely the order in which they were created,
	but you may have mindfully changed this. Also, the default "ffe" preset
	will, by default, always be at the top.


+   You can now pause/suspend the ffmpeg process by using the hotkey
	"SCROLLLOCK" (aka. "ScrLk") while your job is running. Press SCROLLLOCK
	again to resume. This can be handy if ffmpeg is eating all your CPU
	cycles and you have some other short CPU-hungry task to perform.


+   You can now set whether or not you want ffe to kill the ffmpeg process
	when it is itself quit. You could setup a job, start it, and then quit
	ffe and ffmpeg will continue running in the background, until the job is
	complete. Not something I recommend, but there it is.

	Of course, this means you can also explicitly tell ffe to do the
	opposite, killing any ffmpeg process when it quits, the default.

	This setting can also be inherited from and set inside presets.

		kill_ffmpeg_on_exit=true

	Neither should happen, but you never can tell with ffmpeg+users.


...  While I'm here, I should explain what "inherited from and set inside
	presets" means. This behaviour obviously occurs with all the regular
	settings you see inside the GUI, that's how presets work. Other settings
	are more "global", and obviously wouldn't make sense to have on a
	per-preset basis, for example, window transparency.

	Simply put, most settings, whether or not they can be set in the GUI,
	can be inherited from presets. Regardless of how the option is set
	(either from the App Menu, or manually inside ffe.ini), e.g.
	kill_ffmpeg_on_exit=true; when you load a preset that setting becomes
	active, just like regular preset settings.

	Unless a setting is explicitly set inside a preset, it will be left as-
	is; a facility which can be put to a great many uses. This means that
	whatever is in your default "ffe" preset will be used to setup all the
	parameters for a command-line job, unless they are specifically set in
	the loaded preset's own settings.

	This means you can "stack" presets, loaded presets inheriting settings
	from previously loaded presets (unless specifically set otherwise).
	Using the add/replace option, you can also stack ffmpeg arguments, but
	that's another story..

	You could load a preset which sets, e.g., shutdown_when_done=true, and
	then load another preset that contains the parameters for a job. The
	shutdown_when_done setting will still be set to true, as it was not
	explicitly set to false inside the second preset. Of course, clicking
	the shutdown button is easier, but this is just an example.

	When you load a preset, everything in the GUI (including all the ffe job
	buttons) can be set/unset/specified by the preset, as well as the
	following settings..

		Setting:                    Type        Where Set:

		kill_ffmpeg_on_exit         bool        ffe.ini
		default_extension           bool        ffe.ini
		batch_commands_timeout      int         ffe.ini


	These settings will NOT be saved with a preset, they are read-only. They
	can be set manually inside a preset (in ffe.ini). They also don't show
	up in the GUI, being reserved for people who know what they are doing.
	You will see them in your main [ffe] settings already.

	batch_commands_timeout will beinherited and saved with presets.
	quit_when_done and shutdown_when_done *will* be saved to presets, so
	long as that's not your default preset. This is to prevent folk shooting
	themselves in the foot. If you really want these things in your default
	preset (which would be inherited by all presets not specifically
	disabling this behaviour!), feel free to edit them into ffe.ini. ffe
	will respect this.

	If any of these non-visible settings have changed, ffe will post a
	message to the console output stating this, e.g..

		loading preset: Batch x265 (HEVC) & Shutdown
		kill_ffmpeg_on_exit: enabled
		shutdown_when_done=true


+   Vastly improved code comments.


+   Console Output can now be word-wrapped.


+   You can now set ffe to start in a minimized state.

	NOTE: if you quit ffe in a minimized state, that is the way it will
	launch next time. This works even when "Retain Exit Settings" is set to
	false.

	This setting enables you to set it permanently, or just for next launch.

	The same is true for the maximized state, though why anyone would want
	to maximize ffe, indeed any window, is beyond me.


~   The "q" HotKey (the one ffmpeg uses) has been changed to "F4". Of course
	ffe still sends an actual "q", but you no longer do. This prevents
	people from unwittingly quitting the ffmpeg process while attempting to
	setup parameters for the next job, which is doable.


	IMPORTANT: The settings are not only enabled whilst ffmpeg is running,
	they are LIVE. For example, you are merging 50 movie files with their
	corresponding .srt files and half way through the job you switch (in
	your extra parameters input)..

		language=eng

	to..

		language=de

	Every video file created FROM THAT POINT will have German as the
	subtitle language title.

	This is super-useful, but a big gotcha for the unwary. Now you know!


~   ffe now uses matroska (.mkv) as its default container. You can change
	this inside ffe.ini. This setting can also be set inside and inherited
	from presets.

		default_extension=mkv


~   ffe will now load whatever file you specify on the command-line when
	using the go() switch, regardless of whether or not a file is specified
	inside the preset. Essentially, the command-line overrides the ini
	settings, e.g..

		go(x265 medium preset crf=22 AAC(HQ) Audio) "I:\Rip\ffe\Movie.flv"

	The output file name will be created dynamically, unless you have an
	outputfile= specified inside your preset, which will be used whenever
	possible.

	If you have MATOF disabled and the input file contains batch commands
	("*" or "?" characters) MATOF will be automatically enabled.

	You can specify a directory for outputfile, and ffe will create dynamic
	file names within that directory.


~   MATOF status is now saved and recalled with presets.


~   You can now hold down the SHIFT key when you save over an existing
	preset (including the default 'ffe' preset) to skip the warning dialogs.


~   ffe will no longer attempt to stay inside your desktop, it interfered
	with multi-monitor usage. It will now live happily on any one of your
	many, many monitors.


~   The "resize_order" preference has been changed to "resize_first", so it
	makes sense. Old presets will be automatically update for a few ffe
	versions.


~   ffe will no longer save blank preferences (resize, crop, etc.) inside
	your ffe.ini. Only ini hackers saw these, but still. Not only this, ffe
	will compact out the blank prefs of any preset you re-save.


~   ffe will now fix up any illegal characters in the MATOF output file name
	so that it doesn't produce an error when using such things as filters
	(with perhaps quotes and colons in them). Which is to say, it didn't
	used to. *Ahem*.


~   Replaced all relevant input boxes with my own fancy input box. This has
	better text, accepts drag&drop and remembers its size and position.

	The first time you use it, you get a half-screen-width input box in the
	middle of the screen, which you will immediately want to get to the
	optimum size and position for your workstation. From that point onwards,
	ffe will remember the size and position of the inputbox, FOR EACH
	INDIVIDUAL CONTROL.

	If, like me, you want three different widths for inputting custom button
	names, arguments and notes, ffe will make it so.

	Some controls (like inputting short test frames number) still use the
	standard Windows control. You are just typing a number, hitting enter,
	nothing fancy required.


~   The log_file preference is now log_location, as it can also be a folder.


~   As soon as you click inside the output path input, MATOF is immediately
	disabled. This should prevent some annoyance.


~   The "outfile" pref has been renamed to "outputfile". It had to be done.
	This version of ffe will update any legacy preferences it finds.


*   ffe will now correctly /add/ your selected preset arguments to the
	existing preset arguments when 'add to ..my settings' is selected, which
	didn't always happen.


*   Fixed incorrect placement of GUI on launch when previously quit whilst
	minimized.


*   Lots and LOTS of minor and not-so-minor undocumented improvements and
	fixes, error-checking and reporting, logic and so on. En-Joy!


Get to the ffe page with more information (hopefully I will soon get a chance to update it!), downloads, goodies and more, here.

for now..

;o) Cor

 ©  2017 « corz.org » 17.2.24  

Welcome to corz.org!

If something isn't working, I'm probably improving it, try again in a minute. If it's still not working, please mail me!