public static void setValue(Key key, object value)
{
if (HttpContext.Current != null)
HttpContext.Current.Items[key.ToString()] = value;
else
CallContext.SetData(key.ToString(), value);
}
private void LoadSettings()
{
// Kill all
CreditServiceButton = Key.Unknown;
DIPSwitch1 = Key.Unknown;
DIPSwitch2 = Key.Unknown;
DIPSwitch3 = Key.Unknown;
DIPSwitch4 = Key.Unknown;
DIPSwitch5 = Key.Unknown;
DIPSwitch6 = Key.Unknown;
DIPSwitch7 = Key.Unknown;
DIPSwitch8 = Key.Unknown;
CreditLeftCoinSlot = Key.Unknown;
CreditRightCoinSlot = Key.Unknown;
Enum.TryParse<Key>(Settings.Key_VS_CreditServiceButton, out this.CreditServiceButton);
Enum.TryParse<Key>(Settings.Key_VS_DIPSwitch1, out this.DIPSwitch1);
Enum.TryParse<Key>(Settings.Key_VS_DIPSwitch2, out this.DIPSwitch2);
Enum.TryParse<Key>(Settings.Key_VS_DIPSwitch3, out this.DIPSwitch3);
Enum.TryParse<Key>(Settings.Key_VS_DIPSwitch4, out this.DIPSwitch4);
Enum.TryParse<Key>(Settings.Key_VS_DIPSwitch5, out this.DIPSwitch5);
Enum.TryParse<Key>(Settings.Key_VS_DIPSwitch6, out this.DIPSwitch6);
Enum.TryParse<Key>(Settings.Key_VS_DIPSwitch7, out this.DIPSwitch7);
Enum.TryParse<Key>(Settings.Key_VS_DIPSwitch8, out this.DIPSwitch8);
Enum.TryParse<Key>(Settings.Key_VS_CreditLeftCoinSlot, out this.CreditLeftCoinSlot);
Enum.TryParse<Key>(Settings.Key_VS_CreditRightCoinSlot, out this.CreditRightCoinSlot);
}
public PencilKeyInfo(Pencil.Gaming.Key key, int scancode, KeyAction action, KeyModifiers modifiers)
{
Key = key;
Scancode = scancode;
Action = action;
Modifiers = modifiers;
}
public override void ControlHandle(Key k)
{
switch (k)
{
case Key.Up:
if (option > 0) option--;
if (topRow > option) topRow--;
break;
case Key.Down:
if (option < Materiatory.MATERIATORY_SIZE - 1) option++;
if (topRow < option - rows + 1) topRow++;
break;
case Key.X:
if (trashing)
{
MenuState.MateriaScreen.ChangeControl(MenuState.MateriaArrange);
}
else
{
MenuState.MateriaScreen.ChangeToDefaultControl();
}
trashing = false;
break;
case Key.Circle:
if (Trashing)
{
MenuState.MateriaScreen.ChangeControl(MenuState.MateriaPrompt);
break;
}
MateriaOrb neworb = MenuState.Party.Materiatory.Get(option);
MateriaOrb oldorb;
switch (MenuState.MateriaTop.OptionY)
{
case 0:
oldorb = MenuState.Party.Selected.Weapon.Slots[MenuState.MateriaTop.OptionX];
if (oldorb != null)
oldorb.Detach(MenuState.Party.Selected);
MenuState.Party.Materiatory.Put(oldorb, option);
if (neworb != null)
neworb.Attach(MenuState.Party.Selected);
MenuState.Party.Selected.Weapon.AttachMateria(neworb, MenuState.MateriaTop.OptionX);
MenuState.MateriaScreen.ChangeToDefaultControl();
break;
case 1:
oldorb = MenuState.Party.Selected.Armor.Slots[MenuState.MateriaTop.OptionX];
if (oldorb != null)
oldorb.Detach(MenuState.Party.Selected);
MenuState.Party.Materiatory.Put(oldorb, option);
if (neworb != null)
neworb.Attach(MenuState.Party.Selected);
MenuState.Party.Selected.Armor.AttachMateria(neworb, MenuState.MateriaTop.OptionX);
MenuState.MateriaScreen.ChangeToDefaultControl();
break;
default: break;
}
break;
default:
break;
}
}
void RefreshData()
{
_Key = null;
_Group = null;
groupKey.Visible = false;
}
public bool WasKeyPressed(Key key)
{
var previouseMouseButtonState = _previousKeyboardState[key];
var currentMouseButtonState = _currentKeyboardState[key];
return !previouseMouseButtonState && currentMouseButtonState;
}
public bool WasKeyReleased(Key key)
{
var previouseMouseButtonState = _previousKeyboardState[key];
var currentMouseButtonState = _currentKeyboardState[key];
return previouseMouseButtonState && !currentMouseButtonState;
}
/// <summary>
/// Try and get the KeyInput which corresponds to the given Key and modifiers
/// TODO: really think about this method
/// </summary>
internal bool TryGetKeyInput(Key key, ModifierKeys modifierKeys, out KeyInput keyInput)
{
// First just check and see if there is a direct mapping
var keyType = new KeyType(key, modifierKeys);
if (_cache.TryGetValue(keyType, out keyInput))
{
return true;
}
// Next consider only the shift key part of the requested modifier. We can
// re-apply the original modifiers later
keyType = new KeyType(key, modifierKeys & ModifierKeys.Shift);
if (_cache.TryGetValue(keyType, out keyInput))
{
// Reapply the modifiers
keyInput = KeyInputUtil.ChangeKeyModifiers(keyInput, ConvertToKeyModifiers(modifierKeys));
return true;
}
// Last consider it without any modifiers and reapply
keyType = new KeyType(key, ModifierKeys.None);
if (_cache.TryGetValue(keyType, out keyInput))
{
// Reapply the modifiers
keyInput = KeyInputUtil.ChangeKeyModifiers(keyInput, ConvertToKeyModifiers(modifierKeys));
return true;
}
return false;
}
public void ColumnName()
{
var x = new Key();
Assert.IsNull(x.ColumnFamily);
Assert.IsNull(x.ColumnQualifier);
Assert.IsNull(x.Column);
x = new Key { ColumnFamily = "CF" };
Assert.AreEqual("CF", x.ColumnFamily);
Assert.IsNull(x.ColumnQualifier);
Assert.AreEqual("CF", x.Column);
x = new Key { ColumnFamily = "CF", ColumnQualifier = "CQ" };
Assert.AreEqual("CF", x.ColumnFamily);
Assert.AreEqual("CQ", x.ColumnQualifier);
Assert.AreEqual("CF:CQ", x.Column);
x = new Key { Column = "CF" };
Assert.AreEqual("CF", x.ColumnFamily);
Assert.IsNull(x.ColumnQualifier);
Assert.AreEqual("CF", x.Column);
x = new Key { Column = "CF:CQ" };
Assert.AreEqual("CF", x.ColumnFamily);
Assert.AreEqual("CQ", x.ColumnQualifier);
Assert.AreEqual("CF:CQ", x.Column);
}
/// <summary>
/// Initializes a new instance of the <see cref="Xwt.KeyEventArgs"/> class.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="modifiers">The modifier keys.</param>
/// <param name="isRepeat">the key has been pressed more then once.</param>
/// <param name="timestamp">The timestamp of the key event.</param>
public KeyEventArgs (Key key, ModifierKeys modifiers, bool isRepeat, long timestamp)
{
this.Key = key;
this.Modifiers = modifiers;
this.IsRepeat = isRepeat;
this.Timestamp = timestamp;
}
protected static KeyEventArgs CreateKeyEventArgs(
Key key,
ModifierKeys modKeys = ModifierKeys.None)
{
var device = new MockKeyboardDevice(InputManager.Current) { ModifierKeysImpl = modKeys };
return device.CreateKeyEventArgs(key, modKeys);
}
public static char GetCharFromKey(Key key)
{
char ch = ' ';
int virtualKey = KeyInterop.VirtualKeyFromKey(key);
byte[] keyboardState = new byte[256];
GetKeyboardState(keyboardState);
uint scanCode = MapVirtualKey((uint)virtualKey, MapType.MAPVK_VK_TO_VSC);
StringBuilder stringBuilder = new StringBuilder(2);
int result = ToUnicode((uint)virtualKey, scanCode, keyboardState, stringBuilder, stringBuilder.Capacity, 0);
switch (result)
{
case -1:
break;
case 0:
break;
case 1:
{
ch = stringBuilder[0];
break;
}
default:
{
ch = stringBuilder[0];
break;
}
}
return ch;
}
public KeyboardState( params Key [] keys )
: this()
{
PressedKeys = new Key [ keys.Length ];
for ( int i = 0; i < keys.Length; i++ )
PressedKeys [ i ] = keys [ i ];
}
public StoreDataCommand(Key key, object objectToBeStored, DateTime expiry)
: base(key)
{
this.expiry = expiry;
if (objectToBeStored is int)
{
this.objType = StoredObjectType.IntCounter;
dataToBeStored = Encoding.UTF8.GetBytes(objectToBeStored.ToString());
}
else if (objectToBeStored is uint)
{
this.objType = StoredObjectType.UIntCounter;
dataToBeStored = Encoding.UTF8.GetBytes(objectToBeStored.ToString());
}
else if (objectToBeStored is long)
{
this.objType = StoredObjectType.LongCounter;
dataToBeStored = Encoding.UTF8.GetBytes(objectToBeStored.ToString());
}
else
{
this.objType = StoredObjectType.SerializableObject;
using (MemoryStream ms = new MemoryStream())
{
new BinaryFormatter().Serialize(ms, objectToBeStored);
dataToBeStored = new byte[ms.Length];
Array.Copy(ms.GetBuffer(), dataToBeStored, dataToBeStored.Length);
}
}
}
public void KeyUp(Key key)
{
if (key == Key.Space)
{
SpaceCraft.SetThrottle(0);
SpaceCraft.Stage();
}
if (key == Key.X)
{
SpaceCraft.SetThrottle(0);
}
if (key == Key.Z)
{
SpaceCraft.SetThrottle(100);
}
if (key == Key.Q && !IsRetrograde)
{
IsPrograde = !IsPrograde;
}
if (key == Key.W && !IsPrograde)
{
IsRetrograde = !IsRetrograde;
}
}
protected override int procKeyEvent(Key key)
{
int idx = -1;
switch (key)
{
case Key.UpArrow:
_selectedIdx = (_selectedIdx - 1 < 0 ?
(_selectedIdx + _menuItems.Length - 1) :
_selectedIdx - 1) % _menuItems.Length;
break;
case Key.DownArrow:
_selectedIdx = (_selectedIdx + 1) % _menuItems.Length;
break;
case Key.Return:
idx = _selectedIdx; break;
default:
idx = 0;
foreach (MenuItem mi in _menuItems)
{
if (mi.Key == key) break;
idx++;
}
break;
}
return idx;
}
/// <summary>
///
/// </summary>
/// <param name="jointType"></param>
/// <param name="threshold"></param>
/// <param name="comparator"></param>
/// <param name="name"></param>
/// <param name="key"></param>
protected AThresholdGesture(JointType jointType, double threshold, ThresholdComparator comparator, string name, Key key)
: base(name, key)
{
this.jointType = jointType;
this.threshold = threshold;
this.comparator = comparator;
}
KeyEventArgs GetKeyEventArgs(Key key)
{
return new KeyEventArgs(Keyboard.PrimaryDevice, new FakePresentationSource(), 0, key)
{
RoutedEvent = UIElement.KeyDownEvent
};
}
public SceneTitle()
{
sceneType = SceneType.Title;
_menuItems = new MenuItem[]
{
new MenuItem(Key.S, "Start"),
new MenuItem(Key.O, "Option"),
new MenuItem(Key.Q, "Quit")
};
_keys = new Key[]
{
Key.UpArrow, Key.DownArrow, Key.Return, Key.M, Key.O, Key.Q
};
_cursor = ResourceManager.GetColoredCursorGraphic(Constants.Color_Foreground);
if (_menuSurfaces == null)
{
_menuSurfaces = new SurfaceCollection();
_menuRects = new Rectangle[_menuItems.Length];
ImageUtil.CreateStrMenu(_menuItems, Constants.Color_Foreground, ResourceManager.MiddlePFont,
ref _menuSurfaces, ref _menuRects, Constants.ScreenWidth);
}
}
public SceneGameOver()
{
sceneType = SceneType.GameOver;
_menuItems = new MenuItem[]
{
new MenuItem(Key.R, Properties.Resources.MenuItem_RetryStage),
new MenuItem(Key.M, Properties.Resources.MenuItem_MapSelect),
new MenuItem(Key.T, Properties.Resources.MenuItem_ReturnTitle)
};
_keys = new Key[]
{
Key.UpArrow, Key.DownArrow, Key.Return, Key.Escape,
Key.M, Key.R, Key.T
};
_cursor = ResourceManager.GetColoredCursorGraphic(_foreColor);
_overImgSurface = ResourceManager.LoadSurface(Constants.Filename_GameoverImage);
ImageUtil.SetColor(_overImgSurface, _foreColor);
_menuSurfaces = new SurfaceCollection();
_menuRects = new Rectangle[_menuItems.Length];
ImageUtil.CreateStrMenu(_menuItems, _foreColor, ref _menuSurfaces, ref _menuRects, Constants.ScreenWidth);
}
public override bool ConsumeKey(Key key)
{
if (ActiveChild.ConsumeKey(key))
{
CalculateSize();
return true;
}
if (key == Key.Down)
{
if (ActiveChild == mainRowContainer)
{
ActiveChild = bottomRowContainer;
return true;
}
}
else if (key == Key.Up)
{
if (ActiveChild == bottomRowContainer)
{
ActiveChild = mainRowContainer;
return true;
}
}
return false;
}
public CacheEntry(Key key, QrFactorization qrFactorization)
{
Key = key;
QrFactorization = qrFactorization;
MatrixCrossproduct = ImmutableMatrix.OfMatrix(ComputeMatrixCrossproduct(key.Matrix, qrFactorization.IndependentColumnIndexes));
MatrixCrossproductInverse = ImmutableMatrix.OfMatrix(MatrixCrossproduct.Inverse());
}
public override bool TryGetToken(EndpointAddress target, EndpointAddress issuer, out GenericXmlSecurityToken cachedToken)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
cachedToken = null;
lock (thisLock)
{
GenericXmlSecurityToken tmp;
Key key = new Key(target.Uri, issuer == null ? null : issuer.Uri);
if (this.cache.TryGetValue(key, out tmp))
{
// if the cached token is going to expire soon, remove it from the cache and return a cache miss
if (tmp.ValidTo < DateTime.UtcNow + TimeSpan.FromMinutes(1))
{
this.cache.Remove(key);
OnTokenRemoved(key);
}
else
{
cachedToken = tmp;
}
}
}
return (cachedToken != null);
}
public DomainEvent()
{
//AggregateRootId = aggregateRootId;
//EventVersion = version;
EventState = EventState.Sequence;
Key = new Key { KeyName = this.GetType().Name };
}
public NesVSUnisystemDIPKeyboardConnection(IntPtr handle, IInputSettingsVSUnisystemDIP settings)
{
DirectInput di = new DirectInput();
keyboard = new Keyboard(di);
keyboard.SetCooperativeLevel(handle, CooperativeLevel.Nonexclusive | CooperativeLevel.Foreground);
if (settings.CreditServiceButton != "")
CreditServiceButton = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.CreditServiceButton);
if (settings.DIPSwitch1 != "")
DIPSwitch1 = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.DIPSwitch1);
if (settings.DIPSwitch2 != "")
DIPSwitch2 = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.DIPSwitch2);
if (settings.DIPSwitch3 != "")
DIPSwitch3 = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.DIPSwitch3);
if (settings.DIPSwitch4 != "")
DIPSwitch4 = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.DIPSwitch4);
if (settings.DIPSwitch5 != "")
DIPSwitch5 = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.DIPSwitch5);
if (settings.DIPSwitch6 != "")
DIPSwitch6 = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.DIPSwitch6);
if (settings.DIPSwitch7 != "")
DIPSwitch7 = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.DIPSwitch7);
if (settings.DIPSwitch8 != "")
DIPSwitch8 = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.DIPSwitch8);
if (settings.CreditLeftCoinSlot != "")
CreditLeftCoinSlot = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.CreditLeftCoinSlot);
if (settings.CreditRightCoinSlot != "")
CreditRightCoinSlot = (SlimDX.DirectInput.Key)Enum.Parse(typeof(SlimDX.DirectInput.Key), settings.CreditRightCoinSlot);
NesEmu.EMUShutdown += NesEmu_EMUShutdown;
}
public void The_Corresponding_Relationship_Should_Also_Have_The_Column_Removed()
{
// Create database and relationships
Database db = RelationshipDatabaseLoader.GetDb();
Relationship relationship = db.Tables[1].Relationships[0];
Assert.That(relationship.PrimaryKey, Is.SameAs(db.Tables[0].Keys[0]));
Assert.That(relationship.ForeignKey, Is.SameAs(db.Tables[1].Keys[0]));
Assert.That(relationship.PrimaryKey.Columns[0].Name, Is.EqualTo("Column1"));
Assert.That(relationship.PrimaryKey.Columns[1].Name, Is.EqualTo("Column2"));
IKey originalKey = db.Tables[1].Keys[0];
IKey newKey = new Key(originalKey.Name, originalKey.Keytype);
newKey.Parent = new Table("Table2");
newKey.Parent.AddColumn(new Column("Column2"));
newKey.Description = "new description";
newKey.AddColumn("Column2");
KeyChangeOperation op = new KeyChangeOperation(db.Tables[1].Keys[0], newKey);
op.RunOperation();
op.RunSecondStep();
// Make sure the relationship is still the same, and has the same references.
Relationship relationship2 = db.Tables[1].Relationships[0];
Assert.That(relationship2, Is.SameAs(relationship));
Assert.That(relationship2.PrimaryKey, Is.SameAs(db.Tables[0].Keys[0]));
Assert.That(relationship2.ForeignKey, Is.SameAs(db.Tables[1].Keys[0]));
Assert.That(relationship2.PrimaryKey.Columns, Has.Count(2));
Assert.That(relationship2.ForeignKey.Columns, Has.Count(1));
Assert.That(relationship2.ForeignKey.Columns[0].Name, Is.EqualTo("Column2"));
}
public KeyEventArgs (KeyboardDevice keyboard, PresentationSource inputSource,
int timestamp, Key key)
: base (keyboard, timestamp)
{
this.inputSource = inputSource;
this.key = key;
}
public IconButton(IGameWindow window, Camera<OrthographicProjection> camera, Vector2 position, IRenderable renderable, Key? hotkey = null)
: base(window, camera, position)
{
Renderable = renderable;
IsSelected = false;
Hotkey = hotkey;
}
public PlayerViewModel(string name, Key key, int allowedShots)
{
Name = name;
Key = key;
AllowedShots = allowedShots;
scores = new Dictionary<string, int>();
}
protected override bool OnKeyPressed(Key key, char? character, bool repeat)
{
if (Shortcut == null || repeat || Shortcut != key)
return false;
Clicked.Raise();
return true;
}
internal void MergeRows(DataRow[] rows)
{
Debug.Assert(_dataSet != null);
DataTable?src = null;
DataTable?dst = null;
DataKey key = default(DataKey);
Index? ndxSearch = null;
bool fEnforce = _dataSet.EnforceConstraints;
_dataSet.EnforceConstraints = false;
for (int i = 0; i < rows.Length; i++)
{
DataRow row = rows[i];
if (row == null)
{
throw ExceptionBuilder.ArgumentNull($"{nameof(rows)}[{i}]");
}
if (row.Table == null)
{
throw ExceptionBuilder.ArgumentNull($"{nameof(rows)}[{i}].{nameof(DataRow.Table)}");
}
//somebody is doing an 'automerge'
if (row.Table.DataSet == _dataSet)
{
continue;
}
if (src != row.Table)
{ // row.Table changed from prev. row.
src = row.Table;
dst = MergeSchema(row.Table);
if (dst == null)
{
Debug.Assert(MissingSchemaAction.Ignore == _missingSchemaAction, "MergeSchema failed");
_dataSet.EnforceConstraints = fEnforce;
return;
}
if (dst._primaryKey != null)
{
key = GetSrcKey(src, dst);
}
if (key.HasValue)
{
// Getting our own copy instead. ndxSearch = dst.primaryKey.Key.GetSortIndex();
// IMO, Better would be to reuse index
// ndxSearch = dst.primaryKey.Key.GetSortIndex(DataViewRowState.OriginalRows | DataViewRowState.Added );
if (null != ndxSearch)
{
ndxSearch.RemoveRef();
ndxSearch = null;
}
ndxSearch = new Index(dst, dst._primaryKey !.Key.GetIndexDesc(), DataViewRowState.OriginalRows | DataViewRowState.Added, null);
ndxSearch.AddRef(); // need to addref twice, otherwise it will be collected
ndxSearch.AddRef(); // in past first adref was done in const
}
}
if (row._newRecord == -1 && row._oldRecord == -1)
{
continue;
}
DataRow?targetRow = null;
if (0 < dst !.Rows.Count && ndxSearch != null)
{
targetRow = dst.FindMergeTarget(row, key, ndxSearch);
}
targetRow = dst.MergeRow(row, targetRow, _preserveChanges, ndxSearch);
if (targetRow.Table._dependentColumns != null && targetRow.Table._dependentColumns.Count > 0)
{
targetRow.Table.EvaluateExpressions(targetRow, DataRowAction.Change, null);
}
}
if (null != ndxSearch)
{
ndxSearch.RemoveRef();
ndxSearch = null;
}
_dataSet.EnforceConstraints = fEnforce;
}
public bool IsKeyDown(Key key) => _keysDown.Contains(key);
// Gets registered dependencies and lifetimes public bool TryGetDependency(Key key, out IoC.IDependency dependency, out ILifetime lifetime) => Parent.TryGetDependency(key, out dependency, out lifetime);
/// <summary>
/// Processes keyboard input.
/// </summary>
private void processKeyInput()
{
if (!Input.anyKeyDown)
{
return;
}
// Fix for a bug in Linux where typing would still control game elements even if
// a textbox was focused.
if (GUIUtility.keyboardControl != 0)
{
return;
}
// process any key input for settings
if (waitForKey)
{
KeyCode key = NodeTools.fetchKey();
// if the time is up or we have no key to process, reset.
if (((keyWaitTime + 5.0) < Planetarium.GetUniversalTime()) || key == KeyCode.None)
{
currentWaitKey = Key.NONE;
waitForKey = false;
return;
}
// which key are we waiting for?
switch (currentWaitKey)
{
case Key.PROGINC:
options.progInc = key;
break;
case Key.PROGDEC:
options.progDec = key;
break;
case Key.NORMINC:
options.normInc = key;
break;
case Key.NORMDEC:
options.normDec = key;
break;
case Key.RADIINC:
options.radiInc = key;
break;
case Key.RADIDEC:
options.radiDec = key;
break;
case Key.TIMEINC:
options.timeInc = key;
break;
case Key.TIMEDEC:
options.timeDec = key;
break;
case Key.PAGEINC:
options.pageIncrement = key;
break;
case Key.PAGECON:
options.pageConics = key;
break;
case Key.HIDEWINDOW:
options.hideWindow = key;
break;
case Key.ADDWIDGET:
options.addWidget = key;
break;
}
currentWaitKey = Key.NONE;
waitForKey = false;
return;
}
// process normal keyboard input
// change increment
if (Input.GetKeyDown(options.pageIncrement))
{
if (Event.current.alt)
{
options.downIncrement();
}
else
{
options.upIncrement();
}
}
// prograde increment
if (Input.GetKeyDown(options.progInc))
{
curState.addPrograde(options.increment);
}
// prograde decrement
if (Input.GetKeyDown(options.progDec))
{
curState.addPrograde(-options.increment);
}
// normal increment
if (Input.GetKeyDown(options.normInc))
{
curState.addNormal(options.increment);
}
// normal decrement
if (Input.GetKeyDown(options.normDec))
{
curState.addNormal(-options.increment);
}
// radial increment
if (Input.GetKeyDown(options.radiInc))
{
curState.addRadial(options.increment);
}
// radial decrement
if (Input.GetKeyDown(options.radiDec))
{
curState.addRadial(-options.increment);
}
// UT increment
if (Input.GetKeyDown(options.timeInc))
{
curState.addUT(options.increment * (options.largeUTIncrement ? 10.0 : 1.0));
}
// UT decrement
if (Input.GetKeyDown(options.timeDec))
{
curState.addUT(-options.increment * (options.largeUTIncrement ? 10.0 : 1.0));
}
// Page Conics
if (Input.GetKeyDown(options.pageConics))
{
options.pageConicsMode();
}
// hide/show window
if (Input.GetKeyDown(options.hideWindow))
{
shown = !shown;
}
// open node gizmo
if (Input.GetKeyDown(options.addWidget))
{
curState.node.CreateNodeGizmo();
}
}
protected override Expression VisitFieldExpression(FieldExpression expression)
{
var tupleExpression = GetTupleExpression(expression);
// Materialize non-owned field.
if (expression.Owner == null || expression.UnderlyingProperty == null)
{
if (expression.Field.IsEnum)
{
var underlyingType = Enum.GetUnderlyingType(expression.Type.StripNullable());
if (expression.Field.IsNullable)
{
underlyingType = underlyingType.ToNullable();
}
var result = Expression.Convert(
tupleExpression.MakeTupleAccess(underlyingType, expression.Mapping.Offset),
expression.Type);
return(result);
}
if (WellKnownOrmTypes.Key.IsAssignableFrom(expression.Field.ValueType))
{
Expression <Func <Domain, string, Key> > keyParseLambda = (d, s) => Key.Parse(d, s);
Expression <Func <ItemMaterializationContext, Domain> > domainExtractorLambda = imc => imc.Session.Domain;
var result = keyParseLambda.BindParameters(
domainExtractorLambda.BindParameters(itemMaterializationContextParameter),
tupleExpression.MakeTupleAccess(WellKnownTypes.String, expression.Mapping.Offset));
return(result);
}
var tupleAccess = tupleExpression.MakeTupleAccess(expression.Type, expression.Mapping.Offset);
return(tupleAccess);
}
return(MaterializeThroughOwner(expression, tupleExpression));
}
internal static bool IsMouse(this Key @this)
{
return((int)@this > (int)Key.KeyCount);
}
public static SetRolesRequest Deserialize(Stream stream, SetRolesRequest instance, long limit)
{
if (instance.Role == null)
{
instance.Role = new List <uint>();
}
if (instance.MemberId == null)
{
instance.MemberId = new List <EntityId>();
}
while (true)
{
if (limit < (long)0 || stream.Position < limit)
{
int num = stream.ReadByte();
if (num == -1)
{
if (limit >= (long)0)
{
throw new EndOfStreamException();
}
break;
}
else if (num == 10)
{
if (instance.AgentId != null)
{
EntityId.DeserializeLengthDelimited(stream, instance.AgentId);
}
else
{
instance.AgentId = EntityId.DeserializeLengthDelimited(stream);
}
}
else if (num == 18)
{
long position = (long)ProtocolParser.ReadUInt32(stream);
position += stream.Position;
while (stream.Position < position)
{
instance.Role.Add(ProtocolParser.ReadUInt32(stream));
}
if (stream.Position != position)
{
throw new ProtocolBufferException("Read too many bytes in packed data");
}
}
else if (num == 26)
{
instance.MemberId.Add(EntityId.DeserializeLengthDelimited(stream));
}
else
{
Key key = ProtocolParser.ReadKey((byte)num, stream);
if (key.Field == 0)
{
throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
}
ProtocolParser.SkipKey(stream, key);
}
}
else
{
if (stream.Position != limit)
{
throw new ProtocolBufferException("Read past max limit");
}
break;
}
}
return(instance);
}
protected ForeignKey CreateForeignKey(Key dependentKey, Key principalKey) => CreateForeignKey(dependentKey.DeclaringEntityType, dependentKey.Properties, principalKey);
static void Main(string[] args)
{
// The code provided will print ‘Hello World’ to the console.
// Press Ctrl+F5 (or go to Debug > Start Without Debugging) to run your app.
Console.WriteLine("Hello Omnibasis!");
var testTransfer = false;
//define connections
var conn1Config = new Dictionary <string, object>();
//config connection 1
conn1Config.Add("baseUrl", "https://test.ipdb.io");
BlockchainConnection conn1 = new BlockchainConnection(conn1Config);
var conn2Config = new Dictionary <string, object>();
var headers2 = new Dictionary <string, string>();
//config connection 2
conn2Config.Add("baseUrl", "https://test.ipdb.io");
BlockchainConnection conn2 = new BlockchainConnection(conn2Config);
//add connections
IList <BlockchainConnection> connections = new List <BlockchainConnection>();
connections.Add(conn1);
connections.Add(conn2);
//...You can add as many nodes as you want
//multiple connections
var builderWithConnections = BigchainDbConfigBuilder
.addConnections(connections)
.setTimeout(60000); //override default timeout of 20000 milliseconds
// single connection
var builder = BigchainDbConfigBuilder
.baseUrl("https://test.ipdb.io");
if (!AsyncContext.Run(() => builder.setup()))
{
Console.WriteLine("Failed to setup");
}
;
// prepare your key
var algorithm = SignatureAlgorithm.Ed25519;
var privateKey = Key.Import(algorithm, Utils.StringToByteArray(privateKeyString), KeyBlobFormat.PkixPrivateKey);
var publicKey = PublicKey.Import(algorithm, Utils.StringToByteArray(publicKeyString), KeyBlobFormat.PkixPublicKey);
//Account account = new Account();
//Dictionary<string, string> assetData = new Dictionary<string, string>();
//assetData.Add("msg", "Hello!");
Random random = new Random();
TestAsset assetData = new TestAsset();
assetData.msg = "Hello Omnibasis!";
assetData.city = "I was born in San Diego";
assetData.temperature = random.Next(60, 80);
assetData.datetime = DateTime.Now;
//MetaData metaData = new MetaData();
//metaData.setMetaData("msg", "My first transaction");
TestMetadata metaData = new TestMetadata();
metaData.msg = "My first transaction";
// Set up, sign, and send your transaction
var transaction = BigchainDbTransactionBuilder <TestAsset, TestMetadata>
.init()
.addAssets(assetData)
.addMetaData(metaData)
.operation(Operations.CREATE)
.buildAndSignOnly(publicKey, privateKey);
//.buildAndSign(account.PublicKey, account.PrivateKey);
//var info = transaction.toHashInput();
var createTransaction = AsyncContext.Run(() => TransactionsApi <TestAsset, TestMetadata> .sendTransactionAsync(transaction));
string assetId2 = "";
// the asset's ID is equal to the ID of the transaction that created it
if (createTransaction != null && createTransaction.Data != null)
{
assetId2 = createTransaction.Data.Id;
//"2984ac294290ce6f15124140dad652fc8a306aca62c38237174988dfcf31a3e6"
var testTran2 = AsyncContext.Run(() => TransactionsApi <object, object> .getTransactionByIdAsync(assetId2));
if (testTran2 != null)
{
Console.WriteLine("Hello assetId: " + assetId2);
}
else
{
Console.WriteLine("Failed to find assetId: " + assetId2);
}
}
else if (createTransaction != null)
{
Console.WriteLine("Failed to send transaction: " + createTransaction.Messsage.Message);
}
//}
if (!string.IsNullOrEmpty(assetId2) && testTransfer)
{
// Describe the output you are fulfilling on the previous transaction
FulFill spendFrom = new FulFill();
spendFrom.TransactionId = assetId2;
spendFrom.OutputIndex = 0;
// Change the metadata if you want
//MetaData transferMetadata = new MetaData();
//metaData.setMetaData("msg", "My second transaction");
TestMetadata transferMetadata = new TestMetadata();
transferMetadata.msg = "My second transaction";
// the asset's ID is equal to the ID of the transaction that created it
// By default, the 'amount' of a created digital asset == "1". So we spend "1" in our TRANSFER.
string amount = "1";
BlockchainAccount account = new BlockchainAccount();
Details details = null;
// Use the previous transaction's asset and TRANSFER it
var build2 = BigchainDbTransactionBuilder <Asset <string>, TestMetadata> .
init().
addMetaData(metaData).
addInput(details, spendFrom, publicKey).
addOutput("1", account.Key.PublicKey).
addAssets(assetId2).
operation(Operations.TRANSFER).
buildAndSignOnly(publicKey, privateKey);
var transferTransaction = AsyncContext.Run(() => TransactionsApi <Asset <string>, TestMetadata> .sendTransactionAsync(build2));
if (transferTransaction != null && transferTransaction.Data != null)
{
string assetIdTransfer = transferTransaction.Data.Id;
var testTran2 = AsyncContext.Run(() => TransactionsApi <object, object> .getTransactionByIdAsync(assetIdTransfer));
if (testTran2 != null)
{
Console.WriteLine("Hello transfer assetId: " + assetIdTransfer);
}
else
{
Console.WriteLine("Failed to find transfer assetId: " + assetIdTransfer);
}
}
else if (transferTransaction != null)
{
Console.WriteLine("Failed to send transaction: " + createTransaction.Messsage.Message);
}
}
Console.ReadKey(true);
// Go to http://aka.ms/dotnet-get-started-console to continue learning how to build a console app!
}
protected ForeignKey CreateForeignKey(EntityType dependEntityType, IReadOnlyList <Property> dependentProperties, Key principalKey)
{
var foreignKey = dependEntityType.AddForeignKey(dependentProperties, principalKey, principalKey.DeclaringEntityType);
foreignKey.IsUnique = true;
return(foreignKey);
}
object IProjectModelElement.GetProperty(Key propertyName)
{
return(_dataHolder.GetData(propertyName));
}
private void HandleKey(Key key, RawKeyEventType type)
{
var rawKeyEvent = new RawKeyEventArgs(KeyboardDevice.Instance, (uint)DateTime.Now.Ticks, type, key, InputModifiers.None);
_view.Input(rawKeyEvent);
}
public void PutData <T>(Key <T> key, T val) where T : class
{
_dataHolder.PutData(key, val);
}
void IProjectModelElement.SetProperty(Key propertyName, object propertyValue)
{
_dataHolder.PutData(propertyName, propertyValue);
}
public HotKeyIsSetEventArgs(RoutedEvent routedevent, Key key, ModifierKeys modifier)
: base(routedevent)
{
UserKey = key;
UserModifier = modifier;
}
public T GetData <T>(Key <T> key) where T : class
{
return(_dataHolder.GetData(key));
}
public override void ControlHandle(Key k)
{
switch (k)
{
case Key.Up:
if (_option > 0)
{
_option--;
}
if (_topRow > _option)
{
_topRow--;
}
break;
case Key.Down:
if (_option < _equipment.Count - 1)
{
_option++;
}
if (_topRow < _option - rows + 1)
{
_topRow++;
}
break;
case Key.Circle:
MenuState.EquipTop.Changed = true;
switch (MenuState.EquipTop.Option)
{
case 0:
MenuState.Party.Materiatory.Swap(MenuState.Party.Selected.Weapon, (Weapon)_equipment[_option].Item, MenuState.Party.Selected);
MenuState.Party.Inventory.AddToInventory(MenuState.Party.Selected.Weapon);
MenuState.Party.Selected.Weapon = (Weapon)_equipment[_option].Item;
break;
case 1:
MenuState.Party.Materiatory.Swap(MenuState.Party.Selected.Armor, (Armor)_equipment[_option].Item, MenuState.Party.Selected);
MenuState.Party.Inventory.AddToInventory(MenuState.Party.Selected.Armor);
MenuState.Party.Selected.Armor = (Armor)_equipment[_option].Item;
break;
case 2:
if (MenuState.Party.Selected.Accessory != null)
{
MenuState.Party.Inventory.AddToInventory(MenuState.Party.Selected.Accessory);
}
MenuState.Party.Selected.Accessory = (Accessory)_equipment[_option].Item;
break;
}
MenuState.Party.Inventory.DecreaseCount(_equipment[_option].Slot);
MenuState.EquipScreen.ChangeToDefaultControl();
break;
case Key.X:
MenuState.EquipScreen.ChangeToDefaultControl();
break;
}
}
protected override bool HandleKeyPress(Key key)
{
return(Judgement.Result == HitResult.None && UpdateJudgement(true));
}
static Клавиатура()
{
//var КультураИнфо = InputLanguageManager.Current.CurrentInputLanguage;
byte первый = 0;
byte последний = 172;
var именаКлавиш = Enum.GetNames(typeof(Key));
var номер = Enum.ToObject(typeof(Key), 10);
var h = new Key();
var Юникод = (int)Key.A;
foreach (var клавиша in именаКлавиш)
{
Клавиши.Добавить(new СтрокаЮникода(клавиша));
}
ЮНИКОДСимволКодыРусскихБуквПрописные = new ГруппаТипизированная()
{
ТипХранящихсяОбъектов = typeof(Символ)
};
var ЮНИКОДСимволКодыРусскихБуквЗаглавные = new ГруппаТипизированная()
{
ТипХранящихсяОбъектов = typeof(Символ)
};
ЮНИКОДРусскихБукв = new ГруппаОбъектов();
char большая;
for (var с = 'а'; с <= 'е'; с++)
{
большая = с.ToString().ToUpper()[0];
ЮНИКОДСимволКодыРусскихБуквПрописные.Добавить(new Символ(большая));
ЮНИКОДСимволКодыРусскихБуквПрописные.Добавить(new Символ(с));
ЮНИКОДРусскихБукв.Добавить(new ЦелоеЧисло(с));
}
большая = 'ё'.ToString().ToUpper()[0];
ЮНИКОДСимволКодыРусскихБуквПрописные.Добавить(new Символ(большая));
ЮНИКОДСимволКодыРусскихБуквПрописные.Добавить(new Символ('ё'));
ЮНИКОДРусскихБукв.Добавить(new ЦелоеЧисло('ё'));
for (var с = 'ж'; с <= 'я'; с++)
{
большая = с.ToString().ToUpper()[0];
ЮНИКОДСимволКодыРусскихБуквПрописные.Добавить(new Символ(большая));
ЮНИКОДСимволКодыРусскихБуквПрописные.Добавить(new Символ(с));
ЮНИКОДРусскихБукв.Добавить(new ЦелоеЧисло(с));
}
var русскаяРаскладка = new Dictionary <Key, char>
{
[Key.F] = 'а',
[Key.OemComma] = 'б',
[Key.D] = 'в',
[Key.U] = 'г',
[Key.L] = 'д',
[Key.T] = 'е',
[Key.Oem3] = 'ё',
[Key.Oem1] = 'ж',
[Key.P] = 'з',
[Key.B] = 'и',
[Key.Q] = 'й',
[Key.R] = 'к',
[Key.K] = 'л',
[Key.V] = 'м',
[Key.Y] = 'н',
[Key.J] = 'о',
[Key.G] = 'п',
[Key.H] = 'р',
[Key.C] = 'с',
[Key.N] = 'т',
[Key.E] = 'у',
[Key.A] = 'ф',
[Key.Oem4] = 'х',
[Key.W] = 'ц',
[Key.I] = 'ш',
[Key.O] = 'щ',
[Key.M] = 'ь',
[Key.Oem6] = 'ъ',
[Key.Oem7] = 'э',
[Key.OemPeriod] = 'ю',
[Key.Z] = 'я'
};
усскаяРаскладка = new Dictionary <Key, Адрес>();
// здесь должна быть пара key, modifiers
//}; // или Инт это трансформация
// слварь это описание типа связей между элементами (одностороней поиск по ключу)
// клавишам можно сопаставить действия (удалить, Вставить,)
//var словарьЮникода = new Dictionary<Адрес, Строка>(); // либо инт
foreach (var key in русскаяРаскладка.Keys)
{
try
{
var символ = русскаяРаскладка[key];
усскаяРаскладка[key] =
ЮНИКОДСимволКодыРусскихБуквПрописные.Список.Find(
c => ((Символ)c).Значение == символ).СобственныйАдресПримитива;
}
catch { }
}
}
public HotKeyEventArgs(Key key, ModifierKeys modifier, RaiseLocalEvent KeyPressevent)
{
Key = key;
Modifier = modifier;
KeyPressEvent = KeyPressevent;
}
private static Transaction CreateTransaction(Network network, Key inkey, int height, Money amount, Key outKey, uint256 prevOutHash)
{
var coinbase = new Transaction();
coinbase.AddInput(new TxIn(new OutPoint(prevOutHash, 1), inkey.ScriptPubKey));
coinbase.AddOutput(new TxOut(amount, outKey));
return(coinbase);
}
public static AccountFieldTags Deserialize(Stream stream, AccountFieldTags instance, long limit)
{
BinaryReader binaryReader = new BinaryReader(stream);
if (instance.GameLevelInfoTags == null)
{
instance.GameLevelInfoTags = new List <ProgramTag>();
}
if (instance.GameStatusTags == null)
{
instance.GameStatusTags = new List <ProgramTag>();
}
if (instance.GameAccountTags == null)
{
instance.GameAccountTags = new List <RegionTag>();
}
while (true)
{
if (limit < (long)0 || stream.Position < limit)
{
int num = stream.ReadByte();
if (num == -1)
{
if (limit >= (long)0)
{
throw new EndOfStreamException();
}
break;
}
else if (num == 21)
{
instance.AccountLevelInfoTag = binaryReader.ReadUInt32();
}
else if (num == 29)
{
instance.PrivacyInfoTag = binaryReader.ReadUInt32();
}
else if (num == 37)
{
instance.ParentalControlInfoTag = binaryReader.ReadUInt32();
}
else if (num == 58)
{
instance.GameLevelInfoTags.Add(ProgramTag.DeserializeLengthDelimited(stream));
}
else if (num == 74)
{
instance.GameStatusTags.Add(ProgramTag.DeserializeLengthDelimited(stream));
}
else if (num == 90)
{
instance.GameAccountTags.Add(RegionTag.DeserializeLengthDelimited(stream));
}
else
{
Key key = ProtocolParser.ReadKey((byte)num, stream);
if (key.Field == 0)
{
throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
}
ProtocolParser.SkipKey(stream, key);
}
}
else
{
if (stream.Position != limit)
{
throw new ProtocolBufferException("Read past max limit");
}
break;
}
}
return(instance);
}
private static ChainIndexer GenerateChainWithHeightAndActivatedBip9(int blockAmount, Network network, Key key, BIP9DeploymentsParameters parameter, Target bits = null)
{
var chain = new ChainIndexer(network);
uint nonce = RandomUtils.GetUInt32();
uint256 prevBlockHash = chain.Genesis.HashBlock;
for (int i = 0; i < blockAmount; i++)
{
Block block = network.Consensus.ConsensusFactory.CreateBlock();
Transaction coinbase = CreateCoinbaseTransaction(network, key, chain.Height + 1);
block.AddTransaction(coinbase);
block.UpdateMerkleRoot();
block.Header.BlockTime = new DateTimeOffset(new DateTime(2017, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddDays(i));
block.Header.HashPrevBlock = prevBlockHash;
block.Header.Nonce = nonce;
if (bits != null)
{
block.Header.Bits = bits;
}
if (parameter != null)
{
uint version = ThresholdConditionCache.VersionbitsTopBits;
version |= ((uint)1) << parameter.Bit;
block.Header.Version = (int)version;
}
chain.SetTip(block.Header);
prevBlockHash = block.GetHash();
}
return(chain);
}
private void OtpInformation_FormClosing(object sender, FormClosingEventArgs e)
{
if (this.DialogResult == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
try
{
if (string.IsNullOrEmpty(this.textBoxKey.Text))
{
MessageBox.Show("A key must be set");
e.Cancel = true;
return;
}
if (this.textBoxKey.Text.Length < 8)
{
MessageBox.Show("Key must be at least 8 characters. If you are provided with less data then pad it up to 8 characters with '='s");
e.Cancel = true;
return;
}
// set the default settings
int size = 6;
int step = 30;
OtpHashMode hashMode = OtpHashMode.Sha1;
Key key = null;
if (this.checkBoxCustomSettings.Checked)
{
size = (this.radioButtonEight.Checked) ? 8 : 6;
if (int.TryParse(this.textBoxStep.Text, out step))
{
if (step != 30)
{
if (step <= 0)
{
this.textBoxStep.Text = "30";
MessageBox.Show("The time step must be a non-zero positive integer. The standard value is 30. If you weren't specifically given an alternate value just use 30.");
e.Cancel = true;
return;
}
else if (MessageBox.Show("You have selected a non-standard time step. 30 is the standard recommended value. You should only proceed if you were specifically told to use this time step size. Do you wish to proceed?", "Non-standard time step size", MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.No)
{
e.Cancel = true;
return;
}
}
}
else
{
this.textBoxStep.Text = "30";
MessageBox.Show("The time step must be a non-zero positive integer. The standard value is 30. If you weren't specifically given an alternate value just use 30.");
e.Cancel = true;
return;
}
// need to do encoding here
key = ProtectedKey.CreateProtectedKeyAndDestroyPlaintextKey(Base32.Decode(this.textBoxKey.Text.Replace(" ", string.Empty).Replace("-", string.Empty)));
}
else
{
key = ProtectedKey.CreateProtectedKeyAndDestroyPlaintextKey(Base32.Decode(this.textBoxKey.Text.Replace(" ", string.Empty).Replace("-", string.Empty)));
}
// hashmode
if (this.radioButtonSha1.Checked)
{
hashMode = OtpHashMode.Sha1;
}
else if (this.radioButtonSha256.Checked)
{
hashMode = OtpHashMode.Sha256;
}
else if (this.radioButtonSha512.Checked)
{
hashMode = OtpHashMode.Sha512;
}
this.Data = new OtpAuthData()
{
Key = key,
Size = size,
Step = step,
OtpHashMode = hashMode
};
}
catch
{
e.Cancel = true;
}
}
/// Checks to see if the given key is held down. Will poll the keyboard for fresh data before checking.
/// </summary>
/// <param name="k">The key to check.</param>
/// <returns>True if the key is held down, false otherwise.</returns>
public static bool isKeyHeldDown(Key k)
{
return(isKeyHeldDown(k, true));
}
private static ChainIndexer GenerateChainWithHeight(int blockAmount, Network network, Key key, Target bits = null)
{
return(GenerateChainWithHeightAndActivatedBip9(blockAmount, network, key, null, bits));
}
public DasState(Key key)
{
PressedKey = key;
}
/// <summary>
/// Checks to see if the press of this key is the first press, and polls the keyboard for the most up-to-date data.
/// </summary>
/// <param name="k">The key to check.</param>
/// <returns>True if this is the first press; else false</returns>
public static bool isFirstPress(Key k)
{
return(isFirstPress(k, true));
}
/// <summary>
/// Returns the hash code value for this map entry.
/// </summary>
/// <returns>Hash code.</returns>
public override int GetHashCode()
{
return(((Key == null) ? 0 : Key.GetHashCode()) ^
((Value == null) ? 0 : Value.GetHashCode()));
}
public AutoShiftState(Key key)
{
PressedKey = key;
}
