Videos for Developers
Sharing Macros in the Common Project (2:24)

Sharing Macros in Session Documents (3:39)

Setting up the Reflection Terminal User Control (10:42)

Running Extra! Macros in Reflection Desktop (3:07)

This video provides an overview of the Reflection Terminal User Control, demonstrating how to use Microsoft Visual Studio with Terminal User Control to create an application with Reflection. Supporting reference resources are identified. (10:42)
Audio Transcript:
0:00 - 0:19
This video is about programming with the Reflection Terminal User Control. This control is available in Reflection 2011 R2 and later versions of Reflection.

0:20 - 0:32
In this video, we'll cover a quick overview, the requirements for using the control, a quick demo of using the control, and the reference.

0:38 - 0:54
This is the Reflection Workspace showing the host screen.
When we talk about the terminal user control, this is the host screen that is embedded within the Workspace that is the actual terminal emulation screen.

1:02 - 1:09
This screen object can be programmed against outside of the Reflection Workspace in a custom application.

1:10 - 1:19
This screenshot shows an example of an application that was created to interact with the terminal user control.

1:20 - 1:55
As you can see, the right upper portion is the terminal user control. And the outside portion of the application was created to either put data into the host screen or perhaps navigate to screens with different mouse options or use various UI separate from the workspace model of how you would interact with the host screen.

1:59 - 2:03
So at this point, we'll go through a demo of creating your own application using the terminal user control.

2:10 - 2:24
This is Visual Studio 2010. We'll do new project and the type of application needs to be a Windows form application.

2:31 - 2:40
You see the various types of .NET applications but it has to be a Windows form application to consume the terminal user control.

3:11 - 4:01
This is the Visual Studio form editor for the Win Form application. On this side is the toolbox with the various controls on the machine that we installed Reflection 2011 on that has a Visual Studio IDE. In particular, with 2011 we will get a 2011 group with various controls inside of it.
In this case we are going to use the IBM terminal control.
As the terminal control is added to the form, additional references are automatically added to the project.

4:05 - 4:58
So to start off, we are going to need to initialize this terminal control. And we need to do that on a form load. So on Form Load, we are going to reference the terminal user control, which was named ibmTerminalControl1 and the call you would make is called InitInstance. You can call with a method to give it a HostType; in this case, we're going to use IBM3270. 

4:58 - 5:37
But you could have passed it a session file as well. Instead of creating a new host type, if you use the session file version, then it would be the session file that you created within your workspace. For example, let's say "hostb.rd3x" was the session file name, we could just pass that in as the argument. So in this case we are just going to add a call to create a new session.

5:37 - 6:43
Then we go to the terminal user control and we look at the events. There is a TerminalInitializedEvent that we'll add an event handler for. This event is triggered when the InitInstance call has finished. When it's ready, we can make additional calls onto it and at this point, we are going to reference the IbmTerminal object to set the HostAddress to a host name and then we're going to connect.

6:46 - 7:07
As you notice, as we type this, the IBM terminal interface and all of its properties, method, and events are currently documented in the Reflection API terminal object. That is what is actually being rendered here.

7:12 - 7:18
At this point, we are ready to build and run.

7:25 - 7:51
Now you notice the form loaded. There was a short pause as it gets initialized. And then we set the host name to "hostb" and then we connect and you get the host screen.

7:53 - 8:23
This was a quick demo of working with the terminal user control.
The key things to remember when working with the terminal user control are to call InitInstance, then add the event handler TerminalInitializedEvent. After those two are done, you are ready to interact with your terminal user control to do other tasks.

8:26 - 9:57
For reference, go to the Reflection Workspace Help and then go to .NET API Help. The core application API that the terminal user control is defined in is in this section called UserControl.Ibmhosts. When you go to the Overview, you'll see the InitInstance method. The key thing that you would get out of this is that there are only a few properties or methods on this particular control. What you would do is get the IbmTerminal property from the terminal user control and once you get that you would use the Attachmate.Reflection.Emulation.IbmHosts block, which is here, then go to interfaces and then IbmTerminal and this is where you would find the properties and methods that you would use to interact with the host.

10:01 - 10:34
This quick demo is also documented in the .NET API Guide. There is a section called Using the IBM Terminal User Control and there is a quick tutorial going through the IDE and creating an application. And that's it for the terminal user control demo. Thank you!