Intensive - First Application!

xXJDrocks450Xx

Well-Known Member
Intensive Full.png
Introduction

I've had quite a history over the past year. As many of you know I worked on smaller projects like SLEEK- Launcher, the FreeSO Installer, and the late V2PC. What all those had in common was that I was feeling around to see where I wanted to focus on for my actual project that I would devote my time into.
I have come to a point where I feel like software development rather than game development is more interesting to me. Intensive has been in development upwards of 4 or 5 months now, so there are some things to share about it already which I will go into more detail about in the future.
What is Intensive?
Intensive is merely the project name. The project contains 3 total divisions:
Binoculars is the main editor itself where you can place and edit nodes to form programs. Intensive is planned to allow for Text --> Visual code conversion and back which could be really useful. Included in Binoculars is the

  1. Intensive Explorer: which contains everything about your project.
  2. Toolbox: which allows you to select a "functional node" out of loaded assemblies (can be changed from your project's properties), out of a "keywords" list which contains statements like foreach, if, etc., out of your custom functional nodes, and extra menus like recent functional nodes.
  3. History and Recycling Bin: Right now, the history browser tracks your changes and lays them out to you. Perhaps later on going back to a previous revision of your project will be implemented. The recycling bin will contain deleted Intensive Explorer nodes like classes and methods. This also contains an "auto save" option. Auto-save is enabled by default.
  4. Companion: When a node that performs a task
Node Dispatcher: Where you can make custom nodes that can perform certain tasks. Right now they're not very complex but I plan to expand on this idea in the future. Right now they can ask for parameters and have multiple "actions" tied to them. Say you had a node "Run", the actions could be "Run Method as a Background Task", or "Run Method on current thread". You could make custom parameters for which method to run and so on. Later on I can see this really fleshing out with return values and some more cool features I have not thought of quite yet. Additionally, nodes can be Global (Accessible from any project) or Local (Only for the project it was create in).
Stalker (Planned): Stalker is planned to be a way to follow through your code node for node. Much like Visual Studio and Volcanic's "Tracer" do already. This has not even been started yet so I cannot say much about how it works or what specifically it will do besides the usual step over, out and in.
I will post here with updates and other information pertaining to Intensive. If any of you are interested, send me a PM! I would really appreciate a couple of people to get your opinion on features currently in the works or entirely new features that you think might be cool.
 
Capture.PNG
Tray buttons: Open in Dispatch button
New Button Styles
I've been experimenting with a bunch of different styles for Intensive. The most recent style is shown above. The image above is to be placed on a button that opens Node Dispatch which you can find out more about in the first post here in this thread.

Tray buttons: Disabled button (left), enabled button (right)
Rename and Delete Buttons
The delete button has been functional for quite some time however it and Rename now use the special binoculars-tray style buttons (2nd picture from the top). Rename will reveal a small dialog within the editor (not in a new window). Delete will of course remove the node selected in Intensive Explorer. The reason I mention this small detail is because it highlights the new buttons being worked on and how they look.
upload_2017-3-4_2-54-24.png
Intensive Explorer with a Class Contents List opened. ("Method" is the chosen scope's name)
Class Contents List
In Intensive, when you select a node from Intensive Explorer it will show a list of everything in that specific scope. From there you can select a node from the list to jump to where that node is located in the actual script. Otherwise you can click the opened node again (in this case, "Method") to close it. Lastly, the nodes in the picture above are just for example and don't actually do anything yet!
That is not all Intensive can do, but I will release information periodically here.
Thank you to all who follow Intensive.
 
Latest features + Things in the works
Animation2.gif Animation3.gif
Tray buttons example -- Node Tree Editor beginnings
Working - Tray
The tray (shown above in GIF 1) has buttons that have graphics on them and can have as many operations as necessary. In the future perhaps user selected actions could go in the tray. This would not be hard as adding and removing buttons is done using the XAML editor, and actually initializing them is done in code behind with one line. The class for these buttons will handle the rest like calling the action tied to it, mouse hover events, etc.
Very Early - Node Tree Editor
I have a few things planned for this. Number one different orientations. In the GIF above, you saw that when entered it renders each node in a straight line is pretty boring. In the future once nodes having a return true and return false nodes, this will begin to look a lot more interesting. Perhaps different orientations like Tile (where they're in uniform rows and columns), or even different node sizes on screen are all possible in the future.
Animation4.gif
Working - Notification Bar
To be adopted more within the application later, right now it works as intended showing a completely custom message. After 5 seconds it hides or you can press the fancy X button to hide it as well. Is it all you've hoped for? It better be. Oh and don't say it looks too Microsoft Edge like! I can't help it :( .
Slight UI Changes
The two "TextBlock" buttons beneath the Intensive Explorer are likely to be removed in the near future in favor of the tray. The Intensive Explorer is now resizable in preparation for possible 'Add Ins' to the sidebar there. Like perhaps adding other things like the dearly beloved "Class Viewer" that only me and Matt have seen. If you are curious it was removed for being pointless as class viewing is the entire point of Intensive Explorer. Don't make fun of me for my poor decisions. The Tray now looks like it's part of the Sidebar which in my opinion looks very nice.
DYqtWnS.gif
Working - Resizing
Why did it take me so long to make elements in Binoculars react correctly to being resized? Well it's very simple... i don't really care. Long story short, it looks nice. Here's a 3 MB GIF portraying that. Pay no attention to the Kikwi! That's only for Rhys if he reads my post.
Thanks for following Intensive!
More info coming sooner than last time... hopefully.
 
Finally another update!
Sorry for the lack of posts! Busyness as well as taking a small break to focus on other things have gotten in the way of the project. After such a long time I feel energized to continue this so that's a great thing isn't it?
Animation5.gif
Custom Color Picker
It's not a huge deal or anything, but since colors are such a large focus of Intensive, I thought if I wanted it done right, I had to do it myself.
You can select swatches from images on your PC and click directly onto them or select from a list of colors to select a color. Along with that, when you select a color you can control the brightness. You can even select from a hex color value, and select from fine tuned RGB values. Along with that, it looks pretty fancy too :cool:.
Animation7.gifAnimation5.gifAnimation6.gif
Left: Custom Swatches with color selection methods. Center: Editable RGB values; Right: Editable HEX color value;
 
Care for a little eye candy?
Intensive is coming along great but I've been focusing on other things recently. However, that's not to say that things haven't gotten done since the last time we spoke! Take a look at some of this smooth jazz:
New Animations and Logos:
While there isn't much to show, work is still being done on Intensive and hopefully soon we will be looking at the first (small) application made with Intensive!
 
Time to put on those 3D - ana-glyph glasses again, probably collecting dust somewhere. (Try putting some on, it looks really intensive with them on BTW :cool:)
 
More Good News!
upload_2017-5-27_1-53-44.png
Intensive has gotten a bright new UI redesign!
New Save File Structure
Intensive's file structure has come a long way since the first builds. This time around, optimization to things like node color, names, and other data stored along with the nodes, has decreased the size of save files. As an added bonus, the file structure has become more readable to users by using friendlier labels.
As an additional plus, node names now can have extra characters like '!' and '/', just in case you need it ;) . Lastly, all nodes (Class Nodes, Method Nodes, and Functional Nodes) now have a unique ID, prefaced with a character that describes the type of node they are for Intensive Explorer to interpret. ('N' - Functional Node, 'C' - Class Node, 'M' - Method Node)
Node Information
Filling in the blank space beneath Intensive Explorer is Node Information. Right now it's pretty bare. However, as time progresses, it will hopefully be fleshed out into something legitimately useful. Like having a section for tags or comments for nodes of all types. Plus adding to it is super easy as it does all the formatting and stylizing for you! Well, in this case, me!
upload_2017-5-27_2-10-33.png upload_2017-5-27_2-11-22.png
(Left) New Add Item Dialog; (Right) Original Add New Item Dialog
(My Favorite Change) Add Item Dialog Redesign and Overhaul
In the center of the screencap above, the Add Item Dialog is looking pretty great I'd say. The spaces on the left half of the menu are pretty self-explanatory so I won't talk about them too much. However, on the right there is a smaller, fully featured Intensive Explorer to select where you want to place the item.
Note: If you clicked "ADD NODE" when a node was already selected, Intensive Explorer within the "Add Item" dialog will have selected that node.
Thanks as usual to whoever follows my project, and hopefully you might find these updates interesting!
 
Thought I Forgot about Notifications?
You're right I did! Who cares either way?
upload_2017-5-27_2-20-46.png
Notification - Style: Warning
upload_2017-5-27_2-25-7.png
Notification - Style: Information
???
Notification - Style: Special
Notification Styles
Notifications have 3 preset styles that are selected when the Notification is shown. Not much more to say there...
 
Intensive is back with so much new stuff to talk about!
Intensive Care is alive and well giving the utmost precise care to all the genius masterminds who once in awhile need a break from everyday programming.
1. Colorful Colors to soothe the eyes:
Windows now open directly in the Binoculars window rather then in their own windows, the lack of borders gives me more room for creativity. Check out how windows look now:
upload_2017-7-20_16-55-20.png upload_2017-7-20_16-56-4.png upload_2017-7-20_16-57-1.png
Examples of: Node Dispatcher (Custom Node Creator) :: Add New Dialog :: File Select Dialog
Additionally, opened windows dim the rest of the window, and add a subtle but tasteful blur to the background UIElements. Taking it one step further, the color of the background slowly fades to a randomly selected color. It's more fun to look at than a garbage bin and that's saying something!
2. Intensives Animations actually work:
Animation10.gif
Example of new Animations
There are now 5 completely unique animations in the Animation Project: Glide. What are those you might ask? Well we got:
  • GlideToPoint: Moves a visual to a specified point in its containing Panel (WPF: Grid, Canvas, etc.) within a specified TimeSpan.
  • OpacityGlide: Changes the Opacity of the visual to a specified value gradually within a specified TimeSpan, again.
  • GrowGlide: Changes the specified visual's Width and Height values to a Size within a specified.. you get the point.
  • MouseGlide: Performs a HitTest on a specified visual a number of times within a specified TimeSpan to detect whether or not the Left Mouse Button is being held down over the visual or not.
  • ColorGlide: Changes a visual's Background's SolidColorBrush.Color property to another color gradually within a specified TimeSpan.
Additionally they have been made less hardware intensive (get it?) and more accurate as well.
3. Nodes can now be moved around, selected as true and false, and custom nodes can be added to the Workspace.
Animation7.gif Animation8.gif Animation9.gif
Adding Node from Unused Nodes Tray :: Adding Node from Custom Nodes Tray :: Moving a node around the Workspace.
Note: This doesn't mean nodes are functional for making programs yet, this does mean however that nodes can be saved and loaded properly.
4. RECYCLE option in the Quick Options Menu (Bottom of the Window)
The Recycle option has been introduced. What it does is it removes the Node from Intensive Explorer and the Workspace, however it is accessible from the History tab (Top of the window to the left). Once it has been moved to the history tab, it can be recovered by selecting it in the Recycle Bin section. (Not yet implemented) It will be removed from that section and deleted entirely in 10 days.
5. Lookup - More Info Soon!
Lookup is a console within Binoculars that allows the user to look at information about every node created since runtime, along with having commands to look at values universally used throughout Binoculars for various tasks. Like I said, more information will release when Lookup is more mature. That being said, as of now it is functional for a small amount of tasks.
 
Last edited:
Generating C# Code from node tree form is getting there!
upload_2017-7-25_12-49-42.png
Showing a project with one class, "ClassyClass", one method "Mannie Method", and one declared "String" with default value, "StringyString".
upload_2017-7-25_12-53-54.png
Showing a source file with one class, "ClassyClass", one method "Mannie Method", and one declared "String" with default value, "StringyString".
Code Generation:
Compilation is in it's early stages, but it's still cool to see this coming together! Code generation uses the CSharpCodeProvider class to generate code for things like classes, class members, etc. During the generation process, each node has its data saved to the project file, ensuring that the data found in the project save file is the same as the data that is getting code generated for it. Additionally, this process gets the information to generate directly from the save file rather than from nodes loaded into memory, because the latter would require that the nodes to compile had all been opened at least once. That really isn't an option with larger files as one might imagine.
Node Information section has some new fields:
The people reading these who have a keen eye might have noticed the section "Node Information" has a new field: "Comments". Comments has a text box that when you press enter will save the comments for the class/method/node currently opened. This can be seen working above where the comment for ClassyClass was saved using Node Information. Expect more in the soon, because there will be more!
New Property Create Dialog:
upload_2017-7-25_13-18-58.png upload_2017-7-25_13-24-32.png
The previous dialog (right) did not match the style at all and from a functionality standpoint, barely worked as it was made so early in development that I hadn't thought much about these would be applied in the future. This fresh new design was made knowing how I wanted to apply properties in Intensive.
Node Companion:
upload_2017-7-25_13-32-53.pngupload_2017-7-25_13-38-29.png
Note that the situation I'm about to describe 1) Does not take formal parameters into consideration and 2) Is concept only and is not functional yet!

When you click a node that can perform a task, in this case a node that represents the Glide.GrowGlide class (briefly mentioned in the previous post). The companion allows you to edit the way the node does its job, as you might have expected. For example, if you click "Declare New Instance", the node then knows to declare a new instance of GrowGlide and then to call the selected method above: BeginEffect(); Additionally, when we press select variable, we can make a new variable to assign a value, the new instance is one of the valid return values! So lets say we made a new variable, and selected the value to set it as is the new instance of Glide.GrowGlide.

In case you didn't get all that, here's the code we should expect this to generate:
Glide.GrowGlide <variable name> = new Glide.GrowGlide();
<variable name>.BeginEffect();
Likewise, if you didn't specify a variable to set the new instance as, we should get this code:
new Glide.GrowGlide().BeginEffect();

That wraps things up for this post. Thank you so much for visiting my project's thread, and I really appreciate you taking the time to read my little spiel :D.
 
C# Source File Generation Progress + Companion Changes + Lookup
Lookup

Animation10.gif

"TRYWRITE" Command to compile all to file.
image.png

Node Information being shown in Lookup
image.png

Call Stack being shown in Lookup
Lookup provides ways for users to see more detailed information about values used in Binoculars. This could be useful in the event that Intensive "mods" or "extensions" are supported in the future.
upload_2017-7-31_21-8-5.png A list of commands that Lookup can do with descriptions.​
Companion
Animation10.gif

Companion redesign - new animations

image1.png image2.png image.png
Parameters are now functional! They save to Intensive Save File (as you can see in the above picture), and can be applied to method invoke expressions as of now.
The current varieties of parameter types that are recognized by Companion are:
  • ByRef Parameters (SomeMethod will change the inputted value, or output a value to a value of 5)
    • Out: Returns a value to the variable passed in. Int32 i; SomeMethod(out i); //Returns i = 5;
    • Ref: Type passed in is a reference to a type. Used for value types, since reference types already are references to a value. Int32 i; SomeMethod(ref i); //i = 5;
  • Formal Parameters
    • Optional Parameters: These have a value set in the parameter declaration that will be used if the variable doesn't have another value set when the method is invoked.
      • public void SomeMethod(int count = 4); SomeMethod(); //count = 4
      • SomeMethod(6); //count = 6;
    • Formal Parameter: These must be set to a value of the type specified when the method is invoked.
      • public void SomeMethod(int count); SomeMethod(); //Compiler Error
      • SomeMethod(4); //count = 4;
If you're curious you can read up on Value Types and Reference Types at: https://docs.microsoft.com/en-us/do...es/data-types/value-types-and-reference-types
C# Source File Support:
upload_2017-7-31_22-29-15.png
Comments now save, and namespace "Imports" (aka using directives) are working as well.
Comments are loaded when nodes are loaded, and saved when nodes are saved. The compilation process goes as follows:
  1. All nodes run the save function, specified by their type.
  2. Classes are reloaded from file, and saved to the namespace.
  3. Methods are reloaded from file, and saved to the class they belong to.
  4. Func Nodes are reloaded from file and their expressions are loaded with parameters and it all is saved to the method.
  5. All statements, such as property declaration statements, are saved to either the class or method they belong to.
    1. NOTE: Properties, in a C# sense, are not the same as properties in a Binoculars sense! C# Properties have get and set accessors that allow functions to be done when a value is received or set. Binoculars, at the moment, cannot do this. Additionally, properties are only valid in classes in C#, however properties in a Binoculars sense can be used in methods and classes. It's mainly just another name for a variable.
That's all I got for now, thank you very much for following Intensive!
EDIT: Fixed pictures not appearing big enough to see clearly.
 
Last edited:
First Application Made with Binoculars
First_Intensive_Built_Application01.gif
This console application was generated completely using Binoculars. It's so great to finally have some working product for all my work!
The way that the code is written right now means that Binoculars is fully capable of working with a variety of methods in C# not just Console. Variable assignments and all that jazz are forthcoming of course but right methods with parameters should be fully functional as of now. I say "should be" because I simply haven't had enough time to experiment with methods other than Console.WriteLine and Console.ReadKey, both of which shown to be functional in the GIF above.
Things to do right now are as follows:
  1. Change compilation strategy to recognize only true/false nodes rather than all nodes. As you can see above, even though the Console nodes are not connected at all (and have true and false lines which is a bug) they are still compiled like anything else. After the strategy is changed, only nodes selected as true or false will be included in the compiled program/assembly.
  2. Implement a dialog to handle assigning parameters an object value (properties in Binoculars) or a constant value (e.g. "Hello World", 1, 'c', true, etc.) which is currently working now.
  3. Implement ways to change the currently included assemblies for a project. This is included in the UI, however it isn't functional. Right now for testing purposes, it uses the application's currently loaded assemblies.
  4. Rework node dispatcher. I have thought of a good use for "custom nodes", where the user can input C# code into a box and that custom node will run that code. Granted it's only a thought and probably will not be tested in practice until much later.
That's it for right now, thanks for following Intensive!
 
Back
Top