386 lines
14 KiB
Plaintext
386 lines
14 KiB
Plaintext
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft Research Singularity
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// File: ChannelDemo.cs
|
|
//
|
|
// Note: Simple Singularity test program.
|
|
//
|
|
|
|
using System;
|
|
using System.Threading;
|
|
using Microsoft.Singularity.V1.Services;
|
|
using Microsoft.Singularity.Channels;
|
|
using Microsoft.Singularity.Directory;
|
|
using Microsoft.Singularity.Io;
|
|
using Microsoft.SingSharp;
|
|
|
|
using Microsoft.Singularity.Channels;
|
|
using Microsoft.Contracts;
|
|
using Microsoft.SingSharp.Reflection;
|
|
using Microsoft.Singularity.Applications;
|
|
using Microsoft.Singularity.Io;
|
|
using Microsoft.Singularity.Configuration;
|
|
[assembly: Transform(typeof(ApplicationResourceTransform))]
|
|
|
|
namespace Microsoft.Singularity.Applications.Tests {
|
|
[ConsoleCategory(DefaultAction=true)]
|
|
internal class Parameters {
|
|
[InputEndpoint("data")]
|
|
public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;
|
|
|
|
[OutputEndpoint("data")]
|
|
public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;
|
|
|
|
reflective internal Parameters();
|
|
|
|
internal int AppMain() {
|
|
return ConsoleDemo.AppMain(this);
|
|
}
|
|
}
|
|
|
|
public class ConsoleDemo
|
|
{
|
|
private static ConsoleDeviceContract.Imp
|
|
OpenConsoleInternal(DirectoryServiceContract.Imp! nsImp,
|
|
[Claims] char[]! in ExHeap deviceName)
|
|
{
|
|
ConsoleDeviceContract.Exp! exp;
|
|
ConsoleDeviceContract.Imp! imp;
|
|
ConsoleDeviceContract.NewChannel(out imp, out exp);
|
|
|
|
nsImp.SendBind(deviceName, exp);
|
|
switch receive
|
|
{
|
|
case nsImp.AckBind():
|
|
return imp;
|
|
break;
|
|
case nsImp.NakBind(rejectImp, error):
|
|
delete rejectImp;
|
|
delete imp;
|
|
break;
|
|
case nsImp.ChannelClosed():
|
|
throw new Exception("Channel closed during Console bind.");
|
|
delete imp;
|
|
break;
|
|
case nsImp.NakBindReparse(path, rest, linked, backExp):
|
|
assert linked == true;
|
|
assert rest == null;
|
|
delete backExp;
|
|
delete imp;
|
|
|
|
return OpenConsoleInternal(nsImp, path);
|
|
break;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static ConsoleDeviceContract.Imp OpenConsole(string! devName)
|
|
{
|
|
DirectoryServiceContract.Imp ns = DirectoryService.NewClientEndpoint();
|
|
ConsoleDeviceContract.Imp imp =
|
|
OpenConsoleInternal(ns, Bitter.FromString2(devName));
|
|
delete ns;
|
|
|
|
if (imp != null) {
|
|
switch receive
|
|
{
|
|
case imp.Success():
|
|
break;
|
|
case imp.ContractNotSupported():
|
|
throw new Exception("ConsoleOutput: ContractNotSupported");
|
|
break;
|
|
case imp.ChannelClosed():
|
|
throw new Exception("ConsoleOutput: ChannelClosed");
|
|
break;
|
|
}
|
|
}
|
|
return imp;
|
|
}
|
|
|
|
private static void ConsoleWrite(ConsoleDeviceContract.Imp! imp,
|
|
string! message)
|
|
{
|
|
char[]! in ExHeap m = Bitter.FromString2(message);
|
|
imp.SendWrite(m, 0, m.Length);
|
|
imp.RecvAckWrite(out m);
|
|
delete m;
|
|
}
|
|
|
|
private static void DrawLine(ConsoleDeviceContract.Imp! imp,
|
|
int x1, int y1, int x2, int y2,
|
|
char c)
|
|
{
|
|
int dx = x2 - x1;
|
|
int dy = y2 - y1;
|
|
|
|
if (dx == 0) {
|
|
if (dy == 0) {
|
|
imp.SendPutCharAt(c, x1, y1);
|
|
imp.RecvAckPutCharAt();
|
|
return;
|
|
}
|
|
|
|
dy = dy / Math.Abs(dy);
|
|
for (int y = y1; y != y2; y += dy) {
|
|
imp.SendPutCharAt(c, x1, y);
|
|
imp.RecvAckPutCharAt();
|
|
}
|
|
return;
|
|
}
|
|
else if (dy == 0) {
|
|
dx = dx / Math.Abs(dx);
|
|
for (int x = x1; x != x2; x += dx) {
|
|
imp.SendPutCharAt(c, x, y1);
|
|
imp.RecvAckPutCharAt();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (dx < 0) dx = -dx;
|
|
if (dy < 0) dy = -dy;
|
|
|
|
double scale = 0;
|
|
int end = 0;
|
|
if (dx > dy) {
|
|
scale = 1.0 / (double)dx;
|
|
end = dx;
|
|
}
|
|
else {
|
|
scale = 1.0 / (double)dy;
|
|
end = dy;
|
|
}
|
|
for (int i = 0; i < end; i++) {
|
|
double x = (x1 * i * scale) + (x2 * (end - i - 1) * scale);
|
|
double y = (y1 *i* scale) + (y2 * (end - i - 1) * scale);
|
|
imp.SendPutCharAt(c, (int)x, (int)y);
|
|
imp.RecvAckPutCharAt();
|
|
}
|
|
}
|
|
|
|
private static void BoxDemo(ConsoleDeviceContract.Imp! imp,
|
|
int columns, int rows)
|
|
{
|
|
int cc = columns / 2;
|
|
int cr = rows / 2;
|
|
int edge = Math.Min(cc, cr);
|
|
for (int i = 0 ; i < edge; i++) {
|
|
DrawLine(imp, cc - i, cr - i, cc - i, cr + i, '*');
|
|
DrawLine(imp, cc - i, cr + i, cc + i, cr + i, '*');
|
|
DrawLine(imp, cc + i, cr + i, cc + i, cr - i, '*');
|
|
DrawLine(imp, cc + i, cr - i, cc - i, cr - i, '*');
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(20));
|
|
DrawLine(imp, cc - i, cr - i, cc - i, cr + i, ' ');
|
|
DrawLine(imp, cc - i, cr + i, cc + i, cr + i, ' ');
|
|
DrawLine(imp, cc + i, cr + i, cc + i, cr - i, ' ');
|
|
DrawLine(imp, cc + i, cr - i, cc - i, cr - i, ' ');
|
|
}
|
|
}
|
|
|
|
private static void SpinBoxDemo(ConsoleDeviceContract.Imp! imp,
|
|
int columns, int rows)
|
|
{
|
|
const int twoPiSteps = 16;
|
|
int cc = columns / 2;
|
|
int cr = rows / 2;
|
|
int r = 2 * Math.Min(cc, cr) / 3;
|
|
double tau = 2 * Math.PI / twoPiSteps;
|
|
for (int i = 0 ; i < 5 * twoPiSteps; i++) {
|
|
double theta = i * tau;
|
|
int x = (int)(r * Math.Sin(theta));
|
|
int y = (int)(r * Math.Cos(theta));
|
|
DrawLine(imp, cc + x, cr + y, cc + y, cr - x, 'O');
|
|
DrawLine(imp, cc + y, cr - x, cc - x, cr - y, 'O');
|
|
DrawLine(imp, cc - x, cr - y, cc - y, cr + x, 'O');
|
|
DrawLine(imp, cc - y, cr + x, cc + x, cr + y, 'O');
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(20));
|
|
DrawLine(imp, cc + x, cr + y, cc + y, cr - x, ' ');
|
|
DrawLine(imp, cc + y, cr - x, cc - x, cr - y, ' ');
|
|
DrawLine(imp, cc - x, cr - y, cc - y, cr + x, ' ');
|
|
DrawLine(imp, cc - y, cr + x, cc + x, cr + y, ' ');
|
|
}
|
|
}
|
|
|
|
private static void AnnounceDemo(ConsoleDeviceContract.Imp! imp,
|
|
string! title)
|
|
{
|
|
Thread.Sleep(TimeSpan.FromSeconds(3));
|
|
imp.SendClear();
|
|
imp.RecvAckClear();
|
|
imp.SendSetCursorPosition(0, 1); // Avoid top line for thread state
|
|
imp.RecvAckSetCursorPosition();
|
|
char []! in ExHeap buffer = Bitter.FromString2(title);
|
|
imp.SendWrite(buffer, 0, title.Length);
|
|
imp.RecvAckWrite(out buffer);
|
|
delete buffer;
|
|
Thread.Sleep(TimeSpan.FromSeconds(1));
|
|
}
|
|
|
|
private static void RunDemo(ConsoleDeviceContract.Imp! imp)
|
|
{
|
|
// This is just a quick placeholder that shows
|
|
// we can write at arbitrary points on the screen.
|
|
|
|
AnnounceDemo(imp, "Text positioning demo (diagonal 2:1)");
|
|
|
|
int columns, rows;
|
|
imp.SendGetDisplayDimensions();
|
|
imp.RecvDisplayDimensions(out columns, out rows);
|
|
|
|
int oldColumn, oldRow;
|
|
imp.SendGetCursorPosition();
|
|
imp.RecvCursorPosition(out oldColumn, out oldRow);
|
|
|
|
char []! in ExHeap message = Bitter.FromString2("Hello World");
|
|
|
|
for (int i = 2; i < 11; i++) {
|
|
imp.SendSetCursorPosition(2 * i, i);
|
|
imp.RecvAckSetCursorPosition();
|
|
imp.SendWrite(message, 0, message.Length);
|
|
imp.RecvAckWrite(out message);
|
|
}
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(3000));
|
|
delete message;
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
AnnounceDemo(imp, "Testing PutCharAt(). Cursor here...");
|
|
|
|
for (int i = 0; i < columns; i++) {
|
|
imp.SendPutCharAt('#', i, 0);
|
|
imp.RecvAckPutCharAt();
|
|
imp.SendPutCharAt('#', i, rows - 1);
|
|
imp.RecvAckPutCharAt();
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(10));
|
|
}
|
|
for (int i = 0; i < rows; i++) {
|
|
imp.SendPutCharAt('#', 0, i);
|
|
imp.RecvAckPutCharAt();
|
|
imp.SendPutCharAt('#', columns - 1, i);
|
|
imp.RecvAckPutCharAt();
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(10));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
AnnounceDemo(imp, "Testing SetCursorSize(Large)...");
|
|
|
|
imp.SendSetCursorSize(CursorSize.Large);
|
|
switch receive {
|
|
case imp.AckSetCursorSize():
|
|
ConsoleWrite(imp, "okay");
|
|
break;
|
|
case imp.NotSupported():
|
|
ConsoleWrite(imp, "not supported");
|
|
break;
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
AnnounceDemo(imp, "Testing SetCursorSize(Small)...");
|
|
|
|
imp.SendSetCursorSize(CursorSize.Small);
|
|
switch receive {
|
|
case imp.AckSetCursorSize():
|
|
Console.Write("okay");
|
|
break;
|
|
case imp.NotSupported():
|
|
Console.Write("not supported");
|
|
break;
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
AnnounceDemo(imp, "Testing SetCursorPosition()/PutChar(). Cursor moving.");
|
|
|
|
imp.SendSetCursorPosition(columns / 2, rows / 2);
|
|
imp.RecvAckSetCursorPosition();
|
|
|
|
imp.SendCursorShow();
|
|
imp.RecvAckCursorShow();
|
|
for (int i = 0; i < columns; i++) {
|
|
imp.SendSetCursorPosition(i, rows / 2);
|
|
imp.RecvAckSetCursorPosition();
|
|
imp.SendPutChar('>');
|
|
imp.RecvAckPutChar();
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(10));
|
|
}
|
|
for (int i = 0; i < columns; i++) {
|
|
imp.SendSetCursorPosition(columns - i - 1, rows / 2);
|
|
imp.RecvAckSetCursorPosition();
|
|
imp.SendPutChar('<');
|
|
imp.RecvAckPutChar();
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(10));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
AnnounceDemo(imp, "Testing ClearCursorToEndOfLine().");
|
|
|
|
for (int c = 0; c < columns; c++) {
|
|
for (int r = 0; r < 10; r++) {
|
|
imp.SendPutCharAt('A', c, r + 3);
|
|
imp.RecvAckPutCharAt();
|
|
}
|
|
}
|
|
for (int r = 0; r < 5; r++) {
|
|
imp.SendSetCursorPosition(columns - r - 1, r + 3);
|
|
imp.RecvAckSetCursorPosition();
|
|
imp.SendClearCursorToEndOfLine();
|
|
imp.RecvAckClearCursorToEndOfLine();
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
|
|
}
|
|
for (int r = 5; r < 10; r++) {
|
|
imp.SendSetCursorPosition(columns - 10 + r, r + 3);
|
|
imp.RecvAckSetCursorPosition();
|
|
imp.SendClearCursorToEndOfLine();
|
|
imp.RecvAckClearCursorToEndOfLine();
|
|
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
AnnounceDemo(imp, "Cursor is about to be hidden and boxes drawn.");
|
|
|
|
imp.SendCursorHide();
|
|
imp.RecvAckCursorHide();
|
|
|
|
BoxDemo(imp, columns, rows);
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
AnnounceDemo(imp, "Spinning Box demo.");
|
|
|
|
SpinBoxDemo(imp, columns, rows);
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
imp.SendCursorShow();
|
|
imp.RecvAckCursorShow();
|
|
|
|
imp.SendClear();
|
|
imp.RecvAckClear();
|
|
|
|
imp.SendSetCursorPosition(oldColumn, oldRow);
|
|
imp.RecvAckSetCursorPosition();
|
|
}
|
|
|
|
internal static int AppMain(Parameters! config)
|
|
{
|
|
foreach (string s in new string [] { "/dev/video-text",
|
|
"/dev/conout" }) {
|
|
ConsoleDeviceContract.Imp imp = OpenConsole((!)s);
|
|
if (imp != null) {
|
|
Console.WriteLine("Opened {0}\n", s);
|
|
RunDemo(imp);
|
|
delete imp;
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
}
|