I am anything you want me to be!

REALIZEUI is the ultimate time saving program for the Windows OS. REALIZEUI allows you to easily create user interfaces that not only launch programs, but launch programs with variable parameters derived from the Ui. REALIZEUI is the Supreme Companion for command line programs. In fact you will find that REALIZEUI not only accelerates the way you work, but also definitively redefines the way you work by an order of magnitude. Once you use REALIZEUI once you'll never stop. You're about to enter a new paradigm.

Addressing the inherent challenges of scripting

There are an array of scripting languages that help us to automate tasks: vbscript, batch files, python, csscript, PowerShell and others. The power of scripts lies in the ability to pass dynamic arguments to alter what the scripts do as opposed to a script being hard-coded. Up until the advent of REALIZEUI passing arguments into scripts has been a challenge seemingly stuck in the stone age. Typing in dos prompts is the legacy way of doing things. While scripting is immensely powerful and serves a great purpose, what if?

• What if you could easily and quickly build a UI to pass arrays of arguments to your scripts?
• What if you could easily wire up a Database or CSV file to any type of script?
• What if you could just drag and drop a file and process it using a sequence of regular expressions?
• What if you could click a button to run any process on every record in a Database or CSV file?
• What if there was a revolutionary file type that can embed any text based file, manipulate it, then run it?
• What if there was a way to directly inject multiple variables into any file while bypassing traditional command line arguments?
• What if the syntax to build the UI are just ultra-simple single line statements?
• What if you wanted the perfect app to really leverage complex command line programs?
• What if every aspect of the user interface was 100% skinnable?
• What if the you could easily build a preset system using CSV files or Databases?
• Enter the realm of the future: REALIZEUI

REALIZEUI is a CUSTOM FRONT END DESIGNER, this front end is known as a CHiP (Custom Hyper Interface Prototype). This CHiP is a rich collection of Controls of different types, controls like textboxes, drop down lists, date and time pickers, buttons, numeric sliders etc. These controls populate a customizable window made of of rows and columns. What makes REALIZEUI Ultra-Powerful is that you can make a super responsive custom interface instantly by writing simple statements in a plain text file. This CHiP directly controls any command line program and can pass whatever values you need as hard-coded arguments or arguments based on control values. So each CHiP is like it's own program, or more accurately an Interface for a program. CHiPs are inherently infinitely flexible and allow you to create functional UI's ranging from very simplistic to super-intricate data driven monster CHiPs. Using the /auto_save option saves all control values so when you re-open your CHiP you can pick up exactly where you left off! In addition to auto-saving you can create complex preset systems using the '-ci' control (Internal CSV Dropdown Control) which facilitates storing and managing named preset values for every control.

CHiP syntax is designed to be absolutely minimalist in structure, there is zero fluff. The following text creates the CHiP above, note the simplicity. The substitution syntax is also simple, just use the control name within tildes ~ControlName~. Options and controls are defined using the premise of simplicity. CHiP Controls are preceded by the dash character '-' and CHiP Options are preceded by the backslash character '/'.

-a Resize|nconvert.exe|-q ~Quality~ -ratio -resize ~Vertical~ "~!~"

-s Pixels|400|3000|50|1650|

-s Quality|5|100|5|100|%

-b Vertical|0 ~Pixels~|~Pixels~ 0|False

A CHiP's design & function is defined in a .CHiP file (a text file with the extension .CHiP). The type, contents, color, and sequence of the controls are 100% user definable. For example you can fill a slider with the numerical range and increments you need in order to suit a specific task such as using a slider thats 100-5000 for resizing files. Lastly you will add buttons to execute whatever program you want using these parameters. REALIZEUI runs CHiP's, CHiP's run your programs.

• Populate a combobox with the filtered contents of a specific recursed folder that lists files and/or directories.
• Populate a combobox with the contents of a MSSQL or ODBC database query.
• Populate a combobox with the key value pairs of a parsed csv file.

The collection of control values from your CHiP are passed as arguments to any command line program you specify. Furthermore the value of any of the parameters in the CHiP file or CHiP.def file can be referenced and injected into any command. Just enclose any option name (lowercase) in exclamation points as in: !your option!

REALIZEUI has a rich array of powerful controls to streamline your processes

REALIZEUI gives users the choice to use numerous controls to achieve their objectives however complex it may be. Apex buttons are extremely powerful. You define what happens to a file/folder when they are dropped onto this button type. For example you can have a Apex Button that resizes any image dropped on it to a specific dimension. The beauty about the is that you can have other controls on the CHiP designated to set parameters like width, height, quality, and any other settings you need to pass to a command line program. The Apex button can run a sequence of commands on every file/folder dropped on it.

In addition to the regular controls like buttons and textboxes REALIZEUI has some unique control types.

• REALIZEUI can swallow, manipulate, and eject any type of script file.
• Button that runs a sequence of Regular Expression operations on a file or the clipboard.
• Button that runs a function on every row returned from a database query or CSV file.
• Pop-up spreadsheets that display database query results or CSV records and can be clicked to execute a function using the rows values.
• Evaluation fields that can do complex arithmetic functions using values from other controls in the CHiP.
• Buttons that you can drag and drop files onto which execute regular expression operations on the dropped files.
• Pick RGB colors with transparency support from a color picker.

Evaluation fields are also extremely useful. They auto-evaluate numeric expressions on the fly and can reference other control values for cascading calculations.

Complimenting numeric evaluation fields are regular expression find/replace fields that auto update their text based on a regular expression. These regular expression fields are very useful for formatting values in very specific ways.

REALIZEUI is especially useful for web developers. It facilitates rapid testing by injecting content into any file or 100 files at once.

CHiPs can embed any type of script file for self containment

Embed any kind of text based file in the CHiP to make it portable

REALIZEUI can embed any type of text based file within it's CHiP and manipulate the file by injecting arguments into the file and then run the file directly or any program that references the file. Embedded files are fully editable and can be exported if desired. So instead of having 10 batch files and 10 powershell scripts and 10 vbscript files in separate directories, all 30 files can live inside of a single CHiP and be executed from buttons on the CHiP while being injected with variables from the CHiP on the fly! If you desire to maintain the files in their respective directories a CHiP can still consolidate them into a single UI for easy access.

Script injection

REALIZEUI can inject UI values into any text based file and subsequently run the file. For example this HTML file you are reading was generated from a template with placeholders having corresponding names for controls on the UI like (~Color~, ~Font~, ~Size~, etc...). This HTML file was updated in memory with the current values of the controls, written to disk, and then run. REALIZEUI's simple substitution syntax facilitates easy script injection in conjunction with the UI for changing multiple variables easily. Select which values in the UI controls that you want injected into any file or command line. Unlike a simple find and replace function. This Script Injection can find and recursively replace any amount of find/replace pairs at once followed by executing anything you want to do. In this instance this HTML file has an array of colors and fonts updated to reflect the current CHiP's selected values. Template files can live inside a CHiP or reside on the file system.

The values in the UI can be linked to internal CSV files( database records, CSV files, or simply typed in or modified using the various controls you defined.

Unlock the power of CSV Files & Databases to Drive CHiPs

REALIZEUI is a BOSS when it come to utilizing data sources to populate your CHiPs

Page through Datasets retrieved from MSSQL, ODBC Sources and CSV files. REALIZEUI can reference internal and file based CSV files. Internal CSV files (saved in the CHiP) can be auto-generated or imported from files. These internal CSV can be used to save presets which can update every control with the selected rows values. Furthermore internal CSV's can be exported and iterated to run any function for every row.

• Multithreaded database results can be pulled from multiple databases simultaneously.
• The dataset from your query can also be saved directly to a CSV file.
• CHiPS have a auto-expand function that automatically creates a new CHiP with a UI based on your queried columns which can be paged to view all the records with their respective fields.
• This functionality allows one to quickly create advanced database driven preset systems.

It's the Ultimate way to experiment on the Command Line

Quickly change multiple parameters with a UI to trigger complex command line programs.

Populate your CHiP's controls directly from CSV files to leverage the power of Datasets

REALIZEUI also connects directly to local or remote databases. You can run any process against a entire query result or just one record which you can manipulate any way you desire. Connect REALIZEUI natively to Microsoft SQL or any database supporting ODBC. REALIZEUI not only displays Database or CSV results in a Grid, the Grid records can be clicked to execute any function on any entry! To say this functionality is powerful is an understatement.

Apex Buttons: Ultra-Powerful Custom Drag and Drop Operations

Define precisely what happens to a file or folder when dropped onto a button

REALIZEUI facilitates the creation of a 'surface' for multiple drag and drop operations. Define multiple buttons to process files or folders any way you like and then just drag your files/folders onto the button, done! Enter the realm of Apex Buttons. The simple syntax uses a single line to define a control type and the functionality that you want it to have. It's very simplistic to use but extremely powerful.

The center column of controls is defined by the simple commands below (Button Name|Executable|Arguments). The "~!~" is the place holder for the files/folders that are dropped onto the Apex Buttons. This structure is much more efficient than having a folder full of separate batch files. Even if one were to write a single batch file to encapsulate all the functionality in this single CHiP it would be a lot more writing and in the end more difficult to use than this drag and drop UI. CHiPs greatly simplify the way one works.

-a Rotate_90|C:\Ancient\XnView\nconvert.exe|-overwrite -jpegtrans rot90 "~!~"

-a Rotate_180|C:\Ancient\XnView\nconvert.exe|-overwrite -jpegtrans rot180 "~!~"

-a Rotate_270|C:\Ancient\XnView\nconvert.exe|-overwrite -jpegtrans rot270 "~!~"

-a Vertical_Flip|C:\Ancient\XnView\nconvert.exe|~File_Type_Change~ -q ~Quality~ ~OverWrite~ -yflip "~!~"

-a Horizontal_Flip|C:\Ancient\XnView\nconvert.exe|~File_Type_Change~ -q ~Quality~ ~OverWrite~ -xflip "~!~"

Substitution Syntax for Apex Buttons when file/folders are dropped onto the buttons.

For example dropping the file C:\Master\Ultimate.jpg

• ~!~ Represents the file Name: C:\Master\Ultimate.jpg
• ~!_d~ Represents the file directory: C:\Master\
• ~!_f~ Represents the file name & extension: Ultimate.jpg
• ~!_e~ Represents the file name without extension: Ultimate
• ~!_x~ Represents the file extension: jpg
• ~!_z~ Represents the fully qualified path without the file extension: C:\Master\Ultimate

Simple to use CHiP Syntax!

The UI below is generated from just a few lines of text and is quite useful. Choose your desired values using the controls on the CHiP, then just drag your files onto the button to resize the files. The values of the controls are injected into the command line.

/auto_save true

/myapp C:\Ancient\IrfanView\i_view32.exe

/widths 300|175

/title REALIZEUI Simple Resizer

/top true

-s Width|100|4000|100|2500| Pixels

-s Icon_Width|16|128|16|128| Pixels

-s Quality|10|100|10|90|%

-s Sharpen_Percent|10|100|10|80|%

-a Drop_To_Resize|!myapp!|"~!~" ~Size~ ~OverWrite~ ~Sharpen_~ /resample /aspectratio /jpgq=~Quality~ /convert="$D$F"

-b Size|/resize=(~Iconize~)| |True

-b Iconize|~Icon_Width~|~Width~|False

-b OverWrite| |/makecopy|True

-b Sharpen_|/sharpen=~Sharpen_Percent~| |False

-a 800_Pix|!myapp!|"~!~" /resize=(800) ~OverWrite~ ~Sharpen_~ /resample /aspectratio /jpgq=~Quality~ /convert="$D$F"

Tabbed Power

Utilize tabs to goup your CHiP's functions.