/// <summary>
/// Create PDF document from given HTML.<br/>
/// </summary>
/// <param name="html">HTML source to create PDF from</param>
/// <param name="pageSize">the page size to use for each page in the generated pdf </param>
/// <param name="margin">the margin to use between the HTML and the edges of each page</param>
/// <param name="cssData">optional: the style to use for html rendering (default - use W3 default style)</param>
/// <param name="stylesheetLoad">optional: can be used to overwrite stylesheet resolution logic</param>
/// <param name="imageLoad">optional: can be used to overwrite image resolution logic</param>
/// <returns>the generated image of the html</returns>
public static PdfDocument GeneratePdf(string html, PageSize pageSize, int margin = 20, CssData cssData = null, EventHandler<HtmlStylesheetLoadEventArgs> stylesheetLoad = null, EventHandler<HtmlImageLoadEventArgs> imageLoad = null)
{
var config = new PdfGenerateConfig();
config.PageSize = pageSize;
config.SetMargins(margin);
return GeneratePdf(html, config, cssData, stylesheetLoad, imageLoad);
}
public CusCtlTellPanelChar(Liplis.MainSystem.Liplis lips, ObjSetting os, string url, string title, string discription, int newsEmotion, int newsPoint, Bitmap charBody, EventHandler enter, IContainer components)
{
this.lips = lips;
this.os = os;
initCms(components);
initDataPanelNonThum(url, title, discription, newsEmotion, newsPoint, charBody, enter);
}
/// <summary>
/// Create a new game screen. Should be done every time there is a new game.
/// </summary>
/// <param name="theScreenEvent"></param>
/// <param name="contentManager"></param>
public GameScreen(EventHandler theScreenEvent,ContentManager contentManager)
: base(theScreenEvent)
{
bScoreWasAdded = false;
this.contentManager = contentManager;
dlDoubleJumpTimer = new DanLabel(1150, 20, 100, 50);
//Init our intrepid hero
csHero = new ControlledSprite();
bg = new LayeredBackground();
djeJumpEffect = new DoubleJumpEffect();
altimeter = new Altimeter(); // Make a camera for the screen with an altimeter
cCamera = new Camera(50, 100, 600, 520, altimeter);
blocks = new List<Sprite>();
Sprite sp = new Sprite();
blocks.Add(sp);
sp = new Sprite();
blocks.Add(sp);
sp = new Sprite();
blocks.Add(sp);
sp = new Sprite();
blocks.Add(sp);
sp = new Sprite();
blocks.Add(sp);
// REVIST Set up the Arcing Block Manager with the difficulty
arcingBlockManager = new ArcingBlockManager(cCamera, blocks, contentManager, 500, 300, 150, "Sprites/block2");
}
protected override void InitControl()
{
base.InitControl();
BackColor = Color.White;
Anchor = System.Windows.Forms.AnchorStyles.None;
lblFolder = new FluidLabel();
lblFolder.Bounds = new Rectangle(10, 10, 240, 35);
lblFolder.Font = new Font(FontFamily.GenericSerif, 9, FontStyle.Regular);
Controls.Add(lblFolder);
lblFile = new FluidLabel();
lblFile.Bounds = new Rectangle(10, 40, 240, 20);
lblFile.Font = new Font(FontFamily.GenericSerif, 9, FontStyle.Bold);
Controls.Add(lblFile);
lblSent = new FluidLabel();
lblSent.Bounds = new Rectangle(10, 65, 180, 20);
lblSent.Font = new Font(FontFamily.GenericSerif, 9, FontStyle.Regular);
Controls.Add(lblSent);
lblRecieved = new FluidLabel();
lblRecieved.Bounds = new Rectangle(10, 80, 180, 20);
lblRecieved.Font = new Font(FontFamily.GenericSerif, 9, FontStyle.Regular);
Controls.Add(lblRecieved);
UpdateStatus += new EventHandler(OnStatusUpdate);
OnStatusUpdate(this, null);
}
public HtmlToClrEventProxy(object sender, string eventName, EventHandler eventHandler) {
this.eventHandler = eventHandler;
this.eventName = eventName;
Type htmlToClrEventProxyType = typeof(HtmlToClrEventProxy);
typeIReflectImplementation = htmlToClrEventProxyType as IReflect;
}
public void GetServices(EventHandler<AsyncWorkerCallbackEventArgs<IList<MediaService>>> callback)
{
try
{
AsyncWorkerHandle<IList<MediaService>> handle = AsyncWorkerHelper.DoWork<IList<MediaService>>(
delegate(object sender, DoWorkEventArgs e)
{
List<MediaService> services = new List<MediaService>();
foreach (var item in ServiceProvider.GetServices<IDeviceConnectorService>())
{
services.Add(new MediaService()
{
Id = item.Value.Uri.ToString(),
Name = item.Value.Name,
ContractName = item.Value.Name,
HostName = item.Value.HostName,
Uri = item.Value.Uri,
});
}
e.Result = services;
},
null, callback);
}
catch (Exception ex)
{
ExceptionHandler.Handle(ex);
}
}
private void toolStripButton1_Click(object sender, EventArgs e)
{
try
{
_nombreDocumento = this.toolStripTextBox1.Text;
//leemos el documento
_procesador = new XBRLProcesadorProveedor(new Uri(_nombreDocumento));
//le decimos al componente que tenemos las clases generadas
_procesador.OptimizarEnsamblado(System.Reflection.Assembly.GetExecutingAssembly());
//procesamos el documento
_procesador.Procesar();
//obtenemos las instancias
IXBRLContenedorInstanciasObjetos contenedor = _procesador.ContenedorInstanciasConceptos;
this.conceptosMenu.DropDownItems.Clear();
//obtenemos los conceptos existentes en las instancias
foreach (string nombreConcepto in contenedor.Conceptos)
{
//por cada concepto creamos un submenu
EventHandler manejadorEvento = new EventHandler(pulsameToolStripMenuItem_Click);
this.conceptosMenu.DropDownItems.Add(nombreConcepto, null, manejadorEvento);
}
}
catch { }
}
internal static void ToggleFindToolBar(Decorator findToolBarHost, EventHandler handlerFindClicked, bool enable)
{
if (enable)
{
// Create FindToolBar and attach it to the host.
FindToolBar findToolBar = new FindToolBar();
findToolBarHost.Child = findToolBar;
findToolBarHost.Visibility = Visibility.Visible;
KeyboardNavigation.SetTabNavigation(findToolBarHost, KeyboardNavigationMode.Continue);
FocusManager.SetIsFocusScope(findToolBarHost, true);
// Initialize FindToolBar
findToolBar.SetResourceReference(Control.StyleProperty, FindToolBarStyleKey);
findToolBar.FindClicked += handlerFindClicked;
findToolBar.DocumentLoaded = true;
findToolBar.GoToTextBox();
}
else
{
// Reset FindToolBar state to its initial state.
FindToolBar findToolBar = findToolBarHost.Child as FindToolBar;
findToolBar.FindClicked -= handlerFindClicked;
findToolBar.DocumentLoaded = false;
// Remov FindToolBar form its host.
findToolBarHost.Child = null;
findToolBarHost.Visibility = Visibility.Collapsed;
KeyboardNavigation.SetTabNavigation(findToolBarHost, KeyboardNavigationMode.None);
findToolBarHost.ClearValue(FocusManager.IsFocusScopeProperty);
}
}
public UICommand(IContainer container)
{
container.Add(this);
InitializeComponent();
ClickForwarderDelegate = new EventHandler(ClickForwarder);
}
internal AnimationLayer(AnimationStorage ownerStorage)
{
Debug.Assert(ownerStorage != null);
_ownerStorage = ownerStorage;
_removeRequestedHandler = new EventHandler(OnRemoveRequested);
}
private void RegisterCommand(ToolbarCommand id, EventHandler callback)
{
var menuCommandID = new CommandID(PackageConstants.GuidTortoiseGitToolbarCmdSet, (int)id);
var menuItem = new OleMenuCommand(callback, menuCommandID);
menuItem.Visible = false;
_commandService.AddCommand(menuItem);
}
public AnnoToolsForm()
{
InitializeComponent();
LocalizeUI();
MouseMode();
Disposed += new EventHandler(FloatingToolsForm_Disposed);
}
public MainForm ()
{
_checkedListBox = new CheckedListBox ();
_checkedListBox.Dock = DockStyle.Top;
_checkedListBox.Font = new Font (_checkedListBox.Font.FontFamily, _checkedListBox.Font.Height + 8);
_checkedListBox.Height = 120;
Controls.Add (_checkedListBox);
//
// _threeDCheckBox
//
_threeDCheckBox = new CheckBox ();
_threeDCheckBox.Checked = _checkedListBox.ThreeDCheckBoxes;
_threeDCheckBox.FlatStyle = FlatStyle.Flat;
_threeDCheckBox.Location = new Point (8, 125);
_threeDCheckBox.Text = "3D checkboxes";
_threeDCheckBox.CheckedChanged += new EventHandler (ThreeDCheckBox_CheckedChanged);
Controls.Add (_threeDCheckBox);
//
// MainForm
//
ClientSize = new Size (300, 150);
Location = new Point (250, 100);
StartPosition = FormStartPosition.Manual;
Text = "bug #82100";
Load += new EventHandler (MainForm_Load);
}
public Label () :base ()
{
// Defaults in the Spec
autosize = false;
TabStop = false;
string_format = new StringFormat();
string_format.FormatFlags = StringFormatFlags.LineLimit;
TextAlign = ContentAlignment.TopLeft;
image = null;
UseMnemonic = true;
image_list = null;
image_align = ContentAlignment.MiddleCenter;
SetUseMnemonic (UseMnemonic);
flat_style = FlatStyle.Standard;
SetStyle (ControlStyles.Selectable, false);
SetStyle (ControlStyles.ResizeRedraw |
ControlStyles.UserPaint |
ControlStyles.AllPaintingInWmPaint |
ControlStyles.SupportsTransparentBackColor
| ControlStyles.OptimizedDoubleBuffer
, true);
HandleCreated += new EventHandler (OnHandleCreatedLB);
}
public void AttachEssentailHandlers(
EventHandler<ImageRequestEventArgs> reqImageHandler,
EventHandler<TextRequestEventArgs> reqStyleSheetHandler)
{
this.requestImage = reqImageHandler;
this.requestStyleSheet = reqStyleSheetHandler;
}
public IntWithRandom()
{
InitializeComponent();
if (Core.Language == Language.English)
{
drawnas_1.Text = "Range";
drawnas_2.Text = "Gauss";
}
EnableUndo = true;
this.SuspendLayout();
Anchor = AnchorStyles.Left | AnchorStyles.Right;
this.ResumeLayout(false);
Reading = false;
Writing = false;
Reading = true;
Read();
Reading = false;
HandleDestroyed += new EventHandler(IntWithRandom_HandleDestroyed);
}
/// <summary>
/// Initialize new instance.
/// </summary>
/// <param name="errorHandler">
/// Initial event handler of <see cref="TransportError"/>. This handler may be null.
/// </param>
protected EventLoop( EventHandler<RpcTransportErrorEventArgs> errorHandler )
{
if ( errorHandler != null )
{
this.TransportError += errorHandler;
}
}
/// <summary>
/// The provider's constructor sets up the MenuAction objects and the MenuGroup which holds them.
/// </summary>
public DataGridMenuProvider()
{
// Set up the MenuGroup which holds the MenuAction items.
MenuGroup dataOperationsGroup = new MenuGroup("DataGroup", "DataGrid");
isDatasourceSetMenuAction = new MenuAction("You need to set ItemsSource to enable some column operations.");
generateStockColumnsMenuAction = new MenuAction("Generate Columns");
generateStockColumnsMenuAction.Execute += new EventHandler<MenuActionEventArgs>(GenerateStockColumnsMenuAction_Execute);
addColumnsMenuAction = new MenuAction("Add/Edit Columns...");
addColumnsMenuAction.Execute += new EventHandler<MenuActionEventArgs>(AddColumnsMenuAction_Execute);
removeColumnsMenuAction = new MenuAction("Remove Columns");
removeColumnsMenuAction.Execute += new EventHandler<MenuActionEventArgs>(RemoveColumnsMenuAction_Execute);
dataOperationsGroup.HasDropDown = true;
dataOperationsGroup.Items.Add(isDatasourceSetMenuAction);
dataOperationsGroup.Items.Add(generateStockColumnsMenuAction);
dataOperationsGroup.Items.Add(addColumnsMenuAction);
dataOperationsGroup.Items.Add(removeColumnsMenuAction);
this.Items.Add(dataOperationsGroup); // Can have groups - show up as sub menus
// The UpdateItemStatus event is raised immediately before
// the menu show, which provides the opportunity to set states.
UpdateItemStatus += new EventHandler<MenuActionEventArgs>(DataGridMenuProvider_UpdateItemStatus);
}
public void CanExecuteChangedTest()
{
var command = new RelayCommand(() =>
{
},
() => true);
var canExecuteChangedCalled = 0;
var canExecuteChangedEventHandler = new EventHandler((s, e) => canExecuteChangedCalled++);
command.CanExecuteChanged += canExecuteChangedEventHandler;
command.RaiseCanExecuteChanged(true);
#if SILVERLIGHT
Assert.AreEqual(1, canExecuteChangedCalled);
#else
// In WPF, cannot trigger the CanExecuteChanged event like this
Assert.AreEqual(0, canExecuteChangedCalled);
#endif
command.CanExecuteChanged -= canExecuteChangedEventHandler;
command.RaiseCanExecuteChanged(true);
#if SILVERLIGHT
Assert.AreEqual(1, canExecuteChangedCalled);
#else
// In WPF, cannot trigger the CanExecuteChanged event like this
Assert.AreEqual(0, canExecuteChangedCalled);
#endif
}
public void Intercept(IInvocation invocation)
{
switch (invocation.Method.Name)
{
case "Close":
_closedSubscribers(invocation.InvocationTarget, EventArgs.Empty);
_closedSubscribers = delegate { };
break;
case "add_Closed":
{
var propertyChangedEventHandler = (EventHandler) invocation.Arguments[0];
_closedSubscribers += propertyChangedEventHandler;
}
break;
case "remove_Closed":
{
var propertyChangedEventHandler = (EventHandler) invocation.Arguments[0];
_closedSubscribers -= propertyChangedEventHandler;
}
break;
}
if (invocation.TargetType != null)
invocation.Proceed();
}
public MainForm ()
{
//
// _richTextBox
//
_richTextBox = new RichTextBox ();
_richTextBox.Dock = DockStyle.Top;
_richTextBox.Height = 160;
Controls.Add (_richTextBox);
//
// _wordWrapCheckBox
//
_wordWrapCheckBox = new CheckBox ();
_wordWrapCheckBox.Checked = _richTextBox.WordWrap;
_wordWrapCheckBox.Location = new Point (8, 170);
_wordWrapCheckBox.Text = "WordWrap";
_wordWrapCheckBox.CheckedChanged += new EventHandler (WordWrapCheckBox_CheckedChanged);
Controls.Add (_wordWrapCheckBox);
//
// MainForm
//
ClientSize = new Size (300, 200);
Location = new Point (250, 100);
StartPosition = FormStartPosition.Manual;
Text = "bug #81488";
Load += new EventHandler (MainForm_Load);
}
/// <summary>
/// Starts an animation to a particular value on the specified dependency property.
/// You can pass in an event handler to call when the animation has completed.
/// </summary>
public static void StartAnimation(UIElement animatableElement, DependencyProperty dependencyProperty, double toValue, double animationDurationSeconds, EventHandler completedEvent)
{
double fromValue = (double)animatableElement.GetValue(dependencyProperty);
DoubleAnimation animation = new DoubleAnimation();
animation.From = fromValue;
animation.To = toValue;
animation.Duration = TimeSpan.FromSeconds(animationDurationSeconds);
animation.Completed += delegate(object sender, EventArgs e)
{
//
// When the animation has completed bake final value of the animation
// into the property.
//
animatableElement.SetValue(dependencyProperty, animatableElement.GetValue(dependencyProperty));
CancelAnimation(animatableElement, dependencyProperty);
if (completedEvent != null)
{
completedEvent(sender, e);
}
};
animation.Freeze();
animatableElement.BeginAnimation(dependencyProperty, animation);
}
public CodeEditBox()
{
this.LoadDefaultProperties();
InitializeComponent();
textChanged = new EventHandler<TextChangedEventArgs>(OnTextChanged);
rowsChanged = new EventHandler(OnRowsChanged);
autoCompiler.GotFocus += (s, e) => { Focus(); };
autoCompiler.MouseDown += AutoCompiler_MouseDown;
autoCompiler.Visible = false;
SetStyle(ControlStyles.Selectable, true);
SetStyle(ControlStyles.UserPaint, true);
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
PropertyJoin.ChangedPropertyEvent(this, new string[] {
"SyntaxHighlighter",
"CommentChar",
"PrefixChar"
}, UpdateSyntax);
AddRow(new Row(this));
ClearHistory();
Zoom = 1;
}
public MainPage()
{
this.Unloaded += new RoutedEventHandler(MainPage_Unloaded);
BindingValidationError += new EventHandler<ValidationErrorEventArgs>(MainPage_BindingValidationError);
// Required to initialize variables
InitializeComponent();
}
internal InteractiveEvaluator(
IContentType contentType,
HostServices hostServices,
IViewClassifierAggregatorService classifierAggregator,
IInteractiveWindowCommandsFactory commandsFactory,
ImmutableArray<IInteractiveWindowCommand> commands,
string responseFilePath,
string initialWorkingDirectory,
string interactiveHostPath,
Type replType)
{
Debug.Assert(responseFilePath == null || PathUtilities.IsAbsolute(responseFilePath));
_contentType = contentType;
_responseFilePath = responseFilePath;
_workspace = new InteractiveWorkspace(this, hostServices);
_contentTypeChangedHandler = new EventHandler<ContentTypeChangedEventArgs>(LanguageBufferContentTypeChanged);
_classifierAggregator = classifierAggregator;
_initialWorkingDirectory = initialWorkingDirectory;
_commandsFactory = commandsFactory;
_commands = commands;
var hostPath = interactiveHostPath;
_interactiveHost = new InteractiveHost(replType, hostPath, initialWorkingDirectory);
_interactiveHost.ProcessStarting += ProcessStarting;
}
public MainWindow()
{
InitializeComponent();
Reporter = this;
TestingElement.BubblingTestEvent.GetEventTracer().EventRaising += EventTracer_EventRaising;
TestingElement.BubblingTestEvent.GetEventTracer().EventRaised += EventTracer_EventRaised;
TestingElement.TunnelingTestEvent.GetEventTracer().EventRaising += EventTracer_EventRaising;
TestingElement.TunnelingTestEvent.GetEventTracer().EventRaised += EventTracer_EventRaised;
TestingElement.ChildrenTestEvent.GetEventTracer().EventRaising += EventTracer_EventRaising;
TestingElement.ChildrenTestEvent.GetEventTracer().EventRaised += EventTracer_EventRaised;
TestingElement.DescendentsTestEvent.GetEventTracer().EventRaising += EventTracer_EventRaising;
TestingElement.DescendentsTestEvent.GetEventTracer().EventRaised += EventTracer_EventRaised;
TestingElement.ParentTestEvent.GetEventTracer().EventRaising += EventTracer_EventRaising;
TestingElement.ParentTestEvent.GetEventTracer().EventRaised += EventTracer_EventRaised;
TestingElement.SiblingsTestEvent.GetEventTracer().EventRaising += EventTracer_EventRaising;
TestingElement.SiblingsTestEvent.GetEventTracer().EventRaised += EventTracer_EventRaised;
TestingElement.SpreadTestEvent.GetEventTracer().EventRaising += EventTracer_EventRaising;
TestingElement.SpreadTestEvent.GetEventTracer().EventRaised += EventTracer_EventRaised;
InitElementOwnerTable();
InitElements();
//Location and Size
Left = Properties.Settings.Default.X;
Top = Properties.Settings.Default.Y;
LocationChanged += new EventHandler(MainWindow_LocationChanged);
}
/// <summary>
/// Initializes a new instance of the <see cref="WindowsFormsMemberToken"/> class.
/// </summary>
/// <param name="objectToObserve">The object to observe.</param>
/// <param name="propertyName">The property path.</param>
/// <param name="remainingPath">The remaining path.</param>
/// <param name="callback">The callback.</param>
/// <param name="pathNavigator">The path navigator.</param>
public WindowsFormsMemberToken(object objectToObserve, string propertyName, string remainingPath, Action<object, string> callback, IPathNavigator pathNavigator)
: base(objectToObserve, propertyName, remainingPath, callback, pathNavigator)
{
_actualHandler = CurrentTarget_PropertyChanged;
AcquireTarget(objectToObserve);
}
public SnapToPixelsImage()
{
_sourceDownloaded = new EventHandler(OnSourceDownloaded);
_sourceFailed = new EventHandler<ExceptionEventArgs>(OnSourceFailed);
LayoutUpdated += new EventHandler(OnLayoutUpdated);
}
private Texture2D texturaSelecionado; // botão em estado selecionado
#endregion Fields
#region Constructors
public clsButton(Game game, Texture2D TexturaNaoSelecionado, Texture2D TexturaSelecionado, Vector2 Posicao, EventHandler evento)
{
texturaNaoSelecionado = TexturaNaoSelecionado;
texturaSelecionado = TexturaSelecionado;
posicao = Posicao;
eventoClick = evento;
}
void Window1_Loaded(object sender, RoutedEventArgs e)
{
Logging.Setup();
Logging.AddToAuthorun();
ShowInTaskbar = false;
RegisterHotkey();
_Model = new Model();
this.DataContext = _Model;
foreach (string s in Environment.GetCommandLineArgs())
{
if (File.Exists(s) && System.IO.Path.GetExtension(s) != ".exe")
{
_Model.Open(s);
}
}
if (!_Model._Loaded) _Model.Load();
KeyDown += new KeyEventHandler(Window1_KeyDown);
Closed += new EventHandler(Window1_Closed);
Closing += new System.ComponentModel.CancelEventHandler(Window1_Closing);
App.Current.Deactivated += new EventHandler(Current_Deactivated);
_RitchTextBox.Focus();
_RitchTextBox.TextChanged += new TextChangedEventHandler(RitchTextBox_TextChanged);
new DispatcherTimer().StartRepeatMethod(60 * 10, Update);
this.Show();
}
private void NewLabirint()
{
labParts = new PictureBox[X, Y];
for (int i = 0; i < X; i++)
{
for (int j = 0; j < Y; j++)
{
labParts[i, j] = new PictureBox();
int xPos = (i * size) + 220;
int yPos = (j * size) + 150;
labParts[i, j].SetBounds(xPos, yPos, size, size);
if ((i == 0 && j == 0) || (i == 19 && j == 19) || (i == 19 && j == 40) || (i == 0 && j == 21) || (i == 21 && j == 0) || (i == 40 && j == 19) || (i == 21 && j == 21) || (i == X - 1 && j == Y - 1))
{
labParts[i, j].BackColor = Color.LightGreen;
}
else if (i == 20 || j == 20)
{
labParts[i, j].BackColor = Color.ForestGreen;
}
else
{
labParts[i, j].BackColor = Color.White;
EventHandler clickEvent = new EventHandler(PictureBox_Click);
labParts[i, j].Click += clickEvent;
}
/*2*/
if ((i == 21 && (j == 4 || j == 5 || j == 7 || j == 8 || j == 9 || j == 15)) ||
(i == 22 && (j == 2 || j == 5 || j == 7 || j == 9 || j == 10 || j == 12 || j == 13 || j == 14 || j == 15 || j == 17 || j == 18 || j == 19)) ||
(i == 23 && (j == 1 || j == 2 || j == 3 || j == 14 || j == 17 || j == 19)) ||
(i == 24 && (j == 1 || j == 6 || j == 7 || j == 9 || j == 11 || j == 13 || j == 14 || j == 16 || j == 17 || j == 19)) ||
(i == 25 && (j == 1 || j == 3 || j == 4 || j == 7 || j == 9 || j == 11 || j == 13 || j == 17 || j == 19)) ||
(i == 26 && (j == 1 || j == 3 || j == 4 || j == 5 || j == 9 || j == 11 || j == 13 || j == 15 || j == 16 || j == 17 || j == 19)) ||
(i == 27 && (j == 0 || j == 7 || j == 8 || j == 9 || j == 11 || j == 13 || j == 15 || j == 17 || j == 19)) ||
(i == 28 && (j == 0 || j == 1 || j == 2 || j == 3 || j == 4 || j == 6 || j == 7 || j == 11 || j == 13 || j == 15 || j == 17 || j == 19)) ||
(i == 29 && (j == 0 || j == 1 || j == 2 || j == 3 || j == 9 || j == 10 || j == 11 || j == 13 || j == 19)) ||
(i == 30 && (j == 1 || j == 5 || j == 6 || j == 7 || j == 9 || j == 17 || j == 18 || j == 19)) ||
(i == 31 && (j == 1 || j == 4 || j == 5 || j == 7 || j == 9 || j == 10 || j == 11 || j == 14 || j == 15 || j == 19)) ||
(i == 32 && (j == 3 || j == 4 || j == 7 || j == 9 || j == 13 || j == 15 || j == 16)) ||
(i == 33 && (j == 2 || j == 3 || j == 6 || j == 7 || j == 8 || j == 9 || j == 11 || j == 16 || j == 17 || j == 18)) ||
(i == 34 && (j == 1 || j == 2 || j == 5 || j == 6 || j == 11 || j == 12 || j == 13 || j == 14)) ||
(i == 35 && (j == 4 || j == 5 || j == 6 || j == 9 || j == 14 || j == 15 || j == 17 || j == 18)) ||
(i == 36 && (j == 2 || j == 3 || j == 4 || j == 7 || j == 8 || j == 9 || j == 11 || j == 17)) ||
(i == 37 && (j == 0 || j == 1 || j == 2 || j == 6 || j == 7 || j == 8 || j == 9 || j == 11 || j == 13 || j == 14 || j == 15 || j == 17)) ||
(i == 38 && (j == 0 || j == 4 || j == 5 || j == 6 || j == 7 || j == 8 || j == 9 || j == 11 || j == 13 || j == 15 || j == 17 || j == 18)) ||
(i == 39 && (j == 0 || j == 2 || j == 4 || j == 5 || j == 6 || j == 7 || j == 8 || j == 9 || j == 11 || j == 15 || j == 17)) ||
(i == 40 && (j == 0 || j == 11 || j == 12 || j == 13 || j == 14 || j == 15 || j == 17)))
{
labParts[i, j].BackColor = Color.Black;
}
/*3*/
if ((i == 0 && (j == 23 || j == 35 || j == 39 || j == 41)) ||
(i == 1 && (j == 23 || j == 35 || j == 39 || j == 41)) ||
(i == 2 && (j == 21 || j == 23 || j == 25 || j == 26 || j == 27 || j == 28 || j == 29 || j == 30 || j == 31 || j == 32 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 3 && (j == 21 || j == 23 || j == 25 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 4 && (j == 21 || j == 23 || j == 25 || j == 27 || j == 28 || j == 29 || j == 30 || j == 31 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 5 && (j == 21 || j == 23 || j == 25 || j == 27 || j == 31 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 6 && (j == 21 || j == 23 || j == 25 || j == 27 || j == 29 || j == 31 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 7 && (j == 21 || j == 23 || j == 25 || j == 27 || j == 28 || j == 29 || j == 31 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 8 && (j == 21 || j == 23 || j == 25 || j == 31 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 9 && (j == 21 || j == 23 || j == 25 || j == 26 || j == 27 || j == 28 || j == 29 || j == 30 || j == 31 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 10 && (j == 21 || j == 35 || j == 37 || j == 39)) ||
(i == 11 && (j == 24 || j == 25 || j == 26 || j == 27 || j == 28 || j == 29 || j == 30 || j == 31 || j == 32 || j == 33 || j == 35 || j == 37 || j == 39)) ||
(i == 12 && (j == 22 || j == 32 || j == 35 || j == 37 || j == 39)) ||
(i == 13 && (j == 22 || j == 24 || j == 25 || j == 26 || j == 27 || j == 28 || j == 29 || j == 30 || j == 32 || j == 34 || j == 35 || j == 37 || j == 39)) ||
(i == 14 && (j == 22 || j == 25 || j == 30 || j == 32 || j == 34 || j == 37 || j == 39)) ||
(i == 15 && (j == 22 || j == 24 || j == 26 || j == 27 || j == 28 || j == 30 || j == 32 || j == 34 || j == 36 || j == 37 || j == 39)) ||
(i == 16 && (j == 22 || j == 24 || j == 25 || j == 26 || j == 27 || j == 28 || j == 30 || j == 32 || j == 34 || j == 36 || j == 39)) ||
(i == 17 && (j == 22 || j == 30 || j == 32 || j == 34 || j == 36 || j == 38)) ||
(i == 18 && (j == 22 || j == 23 || j == 24 || j == 25 || j == 26 || j == 27 || j == 28 || j == 29 || j == 30 || j == 32 || j == 34 || j == 36 || j == 38)) ||
(i == 19 && (j == 31 || j == 36)))
{
labParts[i, j].BackColor = Color.Black;
}
/*4*/
if ((i == 21 && (j == 24 || j == 25 || j == 30 || j == 31 || j == 33 || j == 34 || j == 35 || j == 36 || j == 37 || j == 38 || j == 39 || j == 40)) ||
(i == 22 && (j == 21 || j == 22 || j == 24 || j == 25 || j == 27 || j == 28 || j == 30 || j == 31 || j == 33 || j == 34 || j == 35 || j == 36 || j == 37 || j == 38 || j == 40)) ||
(i == 23 && (j == 21 || j == 22 || j == 27 || j == 28 || j == 37 || j == 38 || j == 40)) ||
(i == 24 && (j == 25 || j == 26 || j == 30 || j == 31 || j == 32 || j == 33 || j == 34 || j == 36 || j == 37 || j == 38 || j == 40)) ||
(i == 25 && (j == 22 || j == 23 || j == 25 || j == 26 || j == 30 || j == 31 || j == 32 || j == 33 || j == 34 || j == 36 || j == 37 || j == 38 || j == 40)) ||
(i == 26 && (j == 22 || j == 23 || j == 27 || j == 28 || j == 30 || j == 31 || j == 32 || j == 33 || j == 34 || j == 36 || j == 37 || j == 38 || j == 40)) ||
(i == 27 && (j == 24 || j == 25 || j == 27 || j == 28 || j == 30 || j == 31 || j == 32 || j == 33 || j == 34 || j == 36 || j == 37 || j == 38 || j == 40)) ||
(i == 28 && (j == 21 || j == 22 || j == 24 || j == 25 || j == 30 || j == 31 || j == 32 || j == 3 || j == 34 || j == 36 || j == 37 || j == 38 || j == 40)) ||
(i == 29 && (j == 21 || j == 22 || j == 23 || j == 27 || j == 28 || j == 33 || j == 34 || j == 40)) ||
(i == 30 && (j == 23 || j == 25 || j == 27 || j == 28 || j == 30 || j == 31 || j == 34 || j == 39 || j == 40)) ||
(i == 31 && (j == 21 || j == 25 || j == 27 || j == 30 || j == 31 || j == 35 || j == 36 || j == 38 || j == 39 || j == 40)) ||
(i == 32 && (j == 21 || j == 23 || j == 24 || j == 27 || j == 30 || j == 32 || j == 31 || j == 33 || j == 35 || j == 36 || j == 38 || j == 39)) ||
(i == 33 && (j == 21 || j == 23 || j == 24 || j == 26 || j == 30 || j == 31 || j == 32 || j == 33 || j == 35 || j == 36 || j == 39)) ||
(i == 34 && (j == 21 || j == 22 || j == 26 || j == 31 || j == 32 || j == 35 || j == 36 || j == 37 || j == 39)) ||
(i == 35 && (j == 21 || j == 22 || j == 24 || j == 25 || j == 29 || j == 35 || j == 36 || j == 37 || j == 39)) ||
(i == 36 && (j == 22 || j == 24 || j == 25 || j == 29 || j == 30 || j == 31 || j == 32 || j == 33 || j == 37)) ||
(i == 37 && (j == 23 || j == 29 || j == 30 || j == 31 || j == 32 || j == 33 || j == 34 || j == 36 || j == 37 || j == 38 || j == 39)) ||
(i == 38 && (j == 22 || j == 23 || j == 25 || j == 26 || j == 36 || j == 37 || j == 38 || j == 39)) ||
(i == 39 && (j == 25 || j == 26 || j == 28 || j == 29 || j == 30 || j == 31 || j == 32 || j == 33 || j == 34 || j == 36 || j == 37 || j == 38 || j == 39)) ||
(i == 40 && (j == 22 || j == 23 || j == 24 || j == 36 || j == 37 || j == 38 || j == 39)))
{
labParts[i, j].BackColor = Color.Black;
}
this.Controls.Add(labParts[i, j]);
}
}
}
/// <summary>
/// 取消订阅事件处理函数。
/// </summary>
/// <param name="id">事件类型编号。</param>
/// <param name="handler">要取消订阅的事件处理函数。</param>
public void Unsubscribe(int id, EventHandler <GameEventArgs> handler)
{
mEventPool.Unsubscribe(id, handler);
}
public EventFireCounter(Action <EventHandler> subscribe, Action <EventHandler> unsubscribe)
{
this.unsubscribe = unsubscribe;
handler = new EventHandler(OnEvent);
subscribe(OnEvent);
}
private static OleMenuCommand CreateMenuCommand([NotNull] IMenuCommandService mcs, int cmdId, [CanBeNull] EventHandler invokeHandler)
{
Contract.Requires(mcs != null);
Contract.Ensures(Contract.Result <OleMenuCommand>() != null);
var menuCommandId = new CommandID(GuidList.guidResXManager_VSIXCmdSet, cmdId);
var menuCommand = new OleMenuCommand(invokeHandler, menuCommandId);
mcs.AddCommand(menuCommand);
return(menuCommand);
}
void InvokeAsync(string method, EventHandler <ResultEventArgs> completedEvent, object userState, object[] args)
{
var invokeUserState = new InvokeUserState(userState, completedEvent);
InvokeAsync(method, args, OnAsyncOperationCompleted, invokeUserState);
}
public InvokeUserState(object userState, EventHandler <ResultEventArgs> handler)
{
UserState = userState;
Handler = handler;
}
/// <summary>
/// Begins asynchronous progress display in the progress bar</summary>
/// <param name="message">Message to display with progress meter</param>
/// <param name="argument">Worker argument</param>
/// <param name="workHandler">Background thread delegate</param>
/// <param name="progressCompleteHandler">Event handler for work completion event</param>
/// <param name="autoIncrement">Whether to auto increment the progress meter</param>
public void RunProgressInStatusBarAsync(string message, object argument, DoWorkEventHandler workHandler, EventHandler <ProgressCompleteEventArgs> progressCompleteHandler, bool autoIncrement)
{
var statusItem = new ProgressViewModel()
{
Cancellable = false,
Description = message,
IsIndeterminate = autoIncrement
};
// Add the part to the status bar
ComposablePart part = m_composer.AddPart(statusItem);
statusItem.Tag = new StatusBarProgressContext(progressCompleteHandler, part);
statusItem.RunWorkerThread(argument, workHandler);
statusItem.RunWorkerCompleted += statusItem_RunWorkerCompleted;
}
public CheckRole()
{
InitializeComponent();
Load += new EventHandler(Form1_Load);
}
// Инициализация DataGridView для работы с массивами (различные настройки и обработчики событий);
// при добавление кнопок управления кол-вом строк и столбцов уменьшает размеры DataGridView
public static void InitGridForArr(DataGridView dgv,
int defaultColWidth, bool readOnly,
bool showRowsIndexes, bool showColsIndexes,
bool changeRowsCountButtons, bool changeColsCountButtons,
bool square,
int changeButtonsSize = 22, int changeButtonsMargin = 6)
{
List <Button> buttons = new List <Button>();
int shiftSize = changeButtonsSize + changeButtonsMargin;
if (changeRowsCountButtons)
{
// -
Button minusButton = new Button {
Width = changeButtonsSize,
Height = changeButtonsSize,
Left = dgv.Left,
Top = dgv.Top + (changeColsCountButtons ? shiftSize : 0),
Text = "\u2014", // длинное тире (один символ Unicode с кодом 0x2014)
Parent = dgv.Parent,
Name = dgv.Name + "_MinusRowButton",
};
if (square)
{
minusButton.Click += (sender, e) =>
{
if (dgv.RowCount > 1)
{
dgv.ColumnCount--;
dgv.RowCount--;
}
}
}
;
else
{
minusButton.Click += (sender, e) => {
if (dgv.RowCount > 1)
{
dgv.RowCount--;
}
}
};
buttons.Add(minusButton);
// +
Button plusButton = new Button {
Width = changeButtonsSize,
Height = changeButtonsSize,
Left = minusButton.Left,
Top = minusButton.Top + shiftSize,
Text = "+",
Parent = dgv.Parent,
Name = dgv.Name + "_PlusRowButton",
};
if (square)
{
plusButton.Click += (sender, e) => {
dgv.RowCount++;
dgv.ColumnCount++;
}
}
;
else
{
plusButton.Click += (sender, e) =>
{
dgv.RowCount++;
}
};
buttons.Add(plusButton);
// уменьшение размера и сдвиг грида
dgv.Width -= shiftSize;
dgv.Left += shiftSize;
}
if (changeColsCountButtons)
{
// -
Button minusButton = new Button {
Width = changeButtonsSize,
Height = changeButtonsSize,
Left = dgv.Left,
Top = dgv.Top,
Text = "\u2014", // длинное тире (один символ Unicode с кодом 0x2014)
Parent = dgv.Parent,
Name = dgv.Name + "_MinusColButton",
};
if (square)
{
minusButton.Click += (sender, e) => {
if (dgv.ColumnCount > 1)
{
dgv.ColumnCount--;
dgv.RowCount--;
}
}
}
;
else
{
minusButton.Click += (sender, e) => {
if (dgv.ColumnCount > 1)
{
dgv.ColumnCount--;
}
}
};
buttons.Add(minusButton);
// +
Button plusButton = new Button {
Width = changeButtonsSize,
Height = changeButtonsSize,
Left = minusButton.Left + shiftSize,
Top = minusButton.Top,
Text = "+",
Parent = dgv.Parent,
Name = dgv.Name + "_PlusColButton",
};
if (square)
{
plusButton.Click += (sender, e) => {
dgv.ColumnCount++;
dgv.RowCount++;
}
}
;
else
{
plusButton.Click += (sender, e) => {
dgv.ColumnCount++;
}
};
buttons.Add(plusButton);
// уменьшение размера грида и сдвиг кнопок
dgv.Height -= minusButton.Height + changeButtonsMargin;
dgv.Top += minusButton.Height + changeButtonsMargin;
}
// запрет добавления новых строк
dgv.AllowUserToAddRows = false;
// запрет удаления строк
dgv.AllowUserToDeleteRows = false;
// запрет менять столбцы местами
dgv.AllowUserToOrderColumns = false;
// запрет изменять ширину столбцов
dgv.AllowUserToResizeColumns = false;
// запрет изменять ширину строк
dgv.AllowUserToResizeRows = false;
// запрет менять ширину заголовка строк (серые ячейки)
dgv.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.DisableResizing;
// запрет менять ширину заголовка столбцов (серые ячейки)
dgv.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;
// разрешаем прокрутку содержимого (на всякий случай)
dgv.ScrollBars = ScrollBars.Both;
// установить ширину заголовка строк в 65 пикселей
dgv.RowHeadersWidth = defaultColWidth;
// установить высоту заголовка столбцов равной высоте строки по умолчанию
dgv.ColumnHeadersHeight = dgv.RowTemplate.Height;
dgv.RowHeadersVisible = showRowsIndexes;
dgv.ColumnHeadersVisible = showColsIndexes;
dgv.ReadOnly = readOnly;
// делегат (анонимный метод), который настраивает строки и столбцы
// (задает заголовки и, где надо, размеры)
Action updateHeaders = () => {
if (showRowsIndexes)
{
for (int r = 0; r < dgv.RowCount; r++)
{
dgv.Rows[r].HeaderCell.Value = string.Format("[ {0} ]", r);
}
}
if (showColsIndexes)
{
for (int c = 0; c < dgv.ColumnCount; c++)
{
DataGridViewColumn column = dgv.Columns[c];
column.SortMode = DataGridViewColumnSortMode.NotSortable;
column.HeaderCell.Value = string.Format("[ {0} ]", c);
}
}
};
// привязываем обработчик события добавления столбца, чтобы изменять его размер
dgv.ColumnAdded += (sender, e) => {
e.Column.Width = defaultColWidth;
e.Column.SortMode = DataGridViewColumnSortMode.NotSortable;
updateHeaders();
};
dgv.RowsAdded += (sender, e) => {
updateHeaders();
};
// привязываем обработчик событий, который очищает выделенные ячейки по клавише delete
dgv.PreviewKeyDown += (sender, e) => {
if (dgv.Enabled && !dgv.ReadOnly && e.KeyValue == 46)
{
foreach (var cell in dgv.SelectedCells)
{
((DataGridViewCell)cell).Value = null;
}
}
};
// обработчик событий, который активирует и дективирует кнопки в зависимости от состояния dgv
EventHandler eh = (sender, e) => {
foreach (Button b in buttons)
{
b.Enabled = dgv.Enabled && !dgv.ReadOnly;
}
};
// привязываем созданный выше обработчик к событиям изменения свойств Enabled и ReadOnly DataGridView
dgv.EnabledChanged += eh;
dgv.ReadOnlyChanged += eh;
eh(dgv, EventArgs.Empty);
// привязываем обработчик событий, который меняет выравнивание в ячейках в зависимости от содержимого
// (целые числа - выравнивание вправо, иначе - влево)
dgv.CellValidated += (sender, e) => {
DataGridViewCell cell = dgv[e.ColumnIndex, e.RowIndex];
int temp;
// выравнивание (если конвертится в int - по правому краю, иначе - по левому)
cell.Style.Alignment =
int.TryParse("" + cell.Value, out temp) ? DataGridViewContentAlignment.MiddleRight : DataGridViewContentAlignment.MiddleLeft;
};
// привязываем обработчик событий, который нужным образом отрисовывает содержимое ячеек заголовков
// (чтобы не рисовались всякие стрелки-звездочки и умещался весь текст)
StringFormat sf = new StringFormat {
Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center,
};
dgv.CellPainting += (sender, e) => {
if (e.ColumnIndex < 0 || e.RowIndex < 0)
{
e.PaintBackground(e.CellBounds, false);
if (e.RowIndex >= 0 || e.ColumnIndex >= 0)
{
e.Graphics.DrawString(
(e.ColumnIndex < 0 ? dgv.Rows[e.RowIndex].HeaderCell.Value : dgv.Columns[e.ColumnIndex].HeaderCell.Value).ToString(),
dgv.RowHeadersDefaultCellStyle.Font,
new SolidBrush(dgv.RowHeadersDefaultCellStyle.ForeColor),
e.CellBounds,
sf
);
}
e.Handled = true;
}
};
// установка минимального кол-ва столбцов и строк
// (обязательно после привязки обработчика события добавления столбца)
if (dgv.RowCount == 0)
{
dgv.RowCount = 3;
}
}
/// <summary>
/// Rawlerのroot用のクラス。
/// </summary>
public RawlerRoot()
: base()
{
this.backgroundWorker.DoWork += new System.ComponentModel.DoWorkEventHandler(backgroundWorker_DoWork);
reportevent = new EventHandler <RawlerLib.Event.EventStringArgs>(r_ReportEvent);
}
ToolStripMenuItem Add(string txt, EventHandler onClick)
{
return(Add(null, txt, onClick));
}
public MruMenuItem(String _filename, String entryname, EventHandler eventHandler)
: base(entryname, eventHandler)
{
filename = _filename;
}
/// <summary>
/// Removes an image from the image manager so it is no longer animated.
/// </summary>
public static void StopAnimate(Image image, EventHandler onFrameChangedHandler)
{
// Make sure we have a list of images
if (image == null || s_imageInfoList == null)
{
return;
}
// Acquire a writer lock to modify the image info list - See comments on Animate() about this locking.
bool readerLockHeld = s_rwImgListLock.IsReaderLockHeld;
LockCookie lockDowngradeCookie = default;
t_threadWriterLockWaitCount++;
try
{
if (readerLockHeld)
{
lockDowngradeCookie = s_rwImgListLock.UpgradeToWriterLock(Timeout.Infinite);
}
else
{
s_rwImgListLock.AcquireWriterLock(Timeout.Infinite);
}
}
finally
{
t_threadWriterLockWaitCount--;
Debug.Assert(t_threadWriterLockWaitCount >= 0, "threadWriterLockWaitCount less than zero.");
}
try
{
// Find the corresponding reference and remove it
for (int i = 0; i < s_imageInfoList.Count; i++)
{
ImageInfo imageInfo = s_imageInfoList[i];
if (image == imageInfo.Image)
{
if ((onFrameChangedHandler == imageInfo.FrameChangedHandler) || (onFrameChangedHandler != null && onFrameChangedHandler.Equals(imageInfo.FrameChangedHandler)))
{
s_imageInfoList.Remove(imageInfo);
}
break;
}
}
}
finally
{
if (readerLockHeld)
{
s_rwImgListLock.DowngradeFromWriterLock(ref lockDowngradeCookie);
}
else
{
s_rwImgListLock.ReleaseWriterLock();
}
}
}
private async void App_OnStartup(object sender, StartupEventArgs e)
{
try
{
Log.Info("Boot strapping the services and UI.");
//Apply theme
applyTheme();
//Define MainViewModel before services so I can setup a delegate to call into the MainViewModel
//This is to work around the fact that the MainViewModel is created after the services.
MainViewModel mainViewModel = null;
Action <KeyValue> fireKeySelectionEvent = kv =>
{
if (mainViewModel != null) //Access to modified closure is a good thing here, for once!
{
mainViewModel.FireKeySelectionEvent(kv);
}
};
//Create services
var errorNotifyingServices = new List <INotifyErrors>();
IAudioService audioService = new AudioService();
IDictionaryService dictionaryService = new DictionaryService();
IPublishService publishService = new PublishService();
ISuggestionStateService suggestionService = new SuggestionStateService();
ICalibrationService calibrationService = CreateCalibrationService();
ICapturingStateManager capturingStateManager = new CapturingStateManager(audioService);
ILastMouseActionStateManager lastMouseActionStateManager = new LastMouseActionStateManager();
IKeyStateService keyStateService = new KeyStateService(suggestionService, capturingStateManager, lastMouseActionStateManager, calibrationService, fireKeySelectionEvent);
IInputService inputService = CreateInputService(keyStateService, dictionaryService, audioService, calibrationService, capturingStateManager, errorNotifyingServices);
IKeyboardOutputService keyboardOutputService = new KeyboardOutputService(keyStateService, suggestionService, publishService, dictionaryService, fireKeySelectionEvent);
IMouseOutputService mouseOutputService = new MouseOutputService(publishService);
errorNotifyingServices.Add(audioService);
errorNotifyingServices.Add(dictionaryService);
errorNotifyingServices.Add(publishService);
errorNotifyingServices.Add(inputService);
//Release keys on application exit
ReleaseKeysOnApplicationExit(keyStateService, publishService);
//Compose UI
var mainWindow = new MainWindow(audioService, dictionaryService, inputService);
Thread.CurrentThread.CurrentCulture = Settings.Default.Language.ToCultureInfo();
Thread.CurrentThread.CurrentUICulture = Settings.Default.Language.ToCultureInfo();
OptiKey.Properties.Resources.Culture = Settings.Default.Language.ToCultureInfo();
IWindowManipulationService mainWindowManipulationService = new WindowManipulationService(
mainWindow,
() => Settings.Default.MainWindowOpacity,
() => Settings.Default.MainWindowState,
() => Settings.Default.MainWindowPreviousState,
() => Settings.Default.MainWindowFloatingSizeAndPosition,
() => Settings.Default.MainWindowDockPosition,
() => Settings.Default.MainWindowDockSize,
() => Settings.Default.MainWindowFullDockThicknessAsPercentageOfScreen,
() => Settings.Default.MainWindowCollapsedDockThicknessAsPercentageOfFullDockThickness,
() => Settings.Default.MainWindowMinimisedPosition,
o => Settings.Default.MainWindowOpacity = o,
state => Settings.Default.MainWindowState = state,
state => Settings.Default.MainWindowPreviousState = state,
rect => Settings.Default.MainWindowFloatingSizeAndPosition = rect,
pos => Settings.Default.MainWindowDockPosition = pos,
size => Settings.Default.MainWindowDockSize = size,
t => Settings.Default.MainWindowFullDockThicknessAsPercentageOfScreen = t,
t => Settings.Default.MainWindowCollapsedDockThicknessAsPercentageOfFullDockThickness = t);
errorNotifyingServices.Add(mainWindowManipulationService);
mainViewModel = new MainViewModel(
audioService, calibrationService, dictionaryService, keyStateService,
suggestionService, capturingStateManager, lastMouseActionStateManager,
inputService, keyboardOutputService, mouseOutputService, mainWindowManipulationService, errorNotifyingServices);
mainWindow.MainView.DataContext = mainViewModel;
//Setup actions to take once main view is loaded (i.e. the view is ready, so hook up the services which kicks everything off)
Action postMainViewLoaded = mainViewModel.AttachServiceEventHandlers;
if (mainWindow.MainView.IsLoaded)
{
postMainViewLoaded();
}
else
{
RoutedEventHandler loadedHandler = null;
loadedHandler = (s, a) =>
{
postMainViewLoaded();
mainWindow.MainView.Loaded -= loadedHandler; //Ensure this handler only triggers once
};
mainWindow.MainView.Loaded += loadedHandler;
}
//Show the main window
mainWindow.Show();
//Display splash screen and check for updates (and display message) after the window has been sized and positioned for the 1st time
EventHandler sizeAndPositionInitialised = null;
sizeAndPositionInitialised = async(_, __) =>
{
mainWindowManipulationService.SizeAndPositionInitialised -= sizeAndPositionInitialised; //Ensure this handler only triggers once
await ShowSplashScreen(inputService, audioService, mainViewModel);
inputService.RequestResume(); //Start the input service
await CheckForUpdates(inputService, audioService, mainViewModel);
};
if (mainWindowManipulationService.SizeAndPositionIsInitialised)
{
sizeAndPositionInitialised(null, null);
}
else
{
mainWindowManipulationService.SizeAndPositionInitialised += sizeAndPositionInitialised;
}
}
catch (Exception ex)
{
Log.Error("Error starting up application", ex);
throw;
}
}
public static void Main(string[] args)
{
FunctionsContainer funcList = new FunctionsContainer(); // Creating the mission conatiner
funcList["Double"] = val => val * 2; // Double the Value
funcList["Triple"] = val => val * 3; // Triple the Value
funcList["Square"] = val => val * val; // Square the Value
funcList["Sqrt"] = val => Math.Sqrt(val); // Taking the square root
funcList["Plus2"] = val => val + 2; // Double the Value
PrintAvailableFunctions(funcList);
// This handler will output the screen every mission that was activated and it's value
EventHandler <double> LogHandler = (sender, val) =>
{
IMission mission = sender as IMission;
if (mission != null)
{
Console.WriteLine($"Mission of Type: {mission.Type} with the Name {mission.Name} returned {val}");
}
};
EventHandler <double> SqrtHandler = (sender, val) =>
{
// This function will Create a sqrt mission and will continue to sqrt until a number less than 2
SingleMission sqrtMission = new SingleMission(funcList["Sqrt"], "SqrtMission");
double newVal;
do
{
newVal = sqrtMission.Calculate(val); // getting the new Val
Console.WriteLine($"sqrt({val}) = {newVal}");
val = newVal; // Storing the new Val;
} while (val > 2);
Console.WriteLine("----------------------------------------");
};
ComposedMission mission1 = new ComposedMission("mission1")
.Add(funcList["Square"])
.Add(funcList["Sqrt"]);
ComposedMission mission2 = new ComposedMission("mission2")
.Add(funcList["Triple"])
.Add(funcList["Plus2"])
.Add(funcList["Square"]);
SingleMission mission3 = new SingleMission(funcList["Double"], "mission3");
ComposedMission mission4 = new ComposedMission("mission4")
.Add(funcList["Triple"])
.Add(funcList["Stam"]) // Notice that this function does not exist and still it works
.Add(funcList["Plus2"]);
PrintAvailableFunctions(funcList);
funcList["Stam"] = val => val + 100;
SingleMission mission5 = new SingleMission(funcList["Stam"], "mission5");
var missionList = new List <IMission>()
{
mission1, mission2, mission3, mission4, mission5
};
foreach (var m in missionList)
{
m.OnCalculate += LogHandler;
m.OnCalculate += SqrtHandler;
}
missionList.Add(mission2);
missionList.Add(mission1);
missionList.Add(mission3);
missionList.Add(mission5);
RunMissions(missionList, 100);
RunMissions(missionList, 2);
PrintAvailableFunctions(funcList);
}
private static extern bool SetConsoleCtrlHandler(EventHandler handler, bool add);
/// <summary>
/// Unsubscribe from the PortletChanged event.
/// </summary>
public static void Unsubscribe(EventHandler <EventArgs <string> > eventHandler)
{
lock (EventSync)
Providers.Instance.CacheProvider.Events.PortletChanged.Unsubscribe(eventHandler);
}
/// <summary>
/// Adds an image to the image manager. If the image does not support animation this method does nothing.
/// This method creates the image list and spawns the animation thread the first time it is called.
/// </summary>
public static void Animate(Image image, EventHandler onFrameChangedHandler)
{
if (image == null)
{
return;
}
ImageInfo? imageInfo = null;
// See comment in the class header about locking the image ref.
lock (image)
{
// could we avoid creating an ImageInfo object if FrameCount == 1 ?
imageInfo = new ImageInfo(image);
}
// If the image is already animating, stop animating it
StopAnimate(image, onFrameChangedHandler);
// Acquire a writer lock to modify the image info list. If the thread has a reader lock we need to upgrade
// it to a writer lock; acquiring a reader lock in this case would block the thread on itself.
// If the thread already has a writer lock its ref count will be incremented w/o placing the request in the
// writer queue. See ReaderWriterLock.AcquireWriterLock method in the MSDN.
bool readerLockHeld = s_rwImgListLock.IsReaderLockHeld;
LockCookie lockDowngradeCookie = default;
t_threadWriterLockWaitCount++;
try
{
if (readerLockHeld)
{
lockDowngradeCookie = s_rwImgListLock.UpgradeToWriterLock(Timeout.Infinite);
}
else
{
s_rwImgListLock.AcquireWriterLock(Timeout.Infinite);
}
}
finally
{
t_threadWriterLockWaitCount--;
Debug.Assert(t_threadWriterLockWaitCount >= 0, "threadWriterLockWaitCount less than zero.");
}
try
{
if (imageInfo.Animated)
{
// Construct the image array
//
if (s_imageInfoList == null)
{
s_imageInfoList = new List<ImageInfo>();
}
// Add the new image
//
imageInfo.FrameChangedHandler = onFrameChangedHandler;
s_imageInfoList.Add(imageInfo);
// Construct a new timer thread if we haven't already
//
if (s_animationThread == null)
{
s_animationThread = new Thread(new ThreadStart(AnimateImages));
s_animationThread.Name = nameof(ImageAnimator);
s_animationThread.IsBackground = true;
s_animationThread.Start();
}
}
}
finally
{
if (readerLockHeld)
{
s_rwImgListLock.DowngradeFromWriterLock(ref lockDowngradeCookie);
}
else
{
s_rwImgListLock.ReleaseWriterLock();
}
}
}
public void CreateShipTypePayType(ShipTypePayTypeInfoVM _viewInfo, EventHandler<RestClientEventArgs<dynamic>> callback)
{
string relativeUrl = "/CommonService/ShipTypePayType/Create";
var msg = _viewInfo.ConvertVM<ShipTypePayTypeInfoVM, ShipTypePayTypeInfo>();
restClient.Create(relativeUrl, msg, callback);
}
private MenuItem CreateMenuItem(string text, EventHandler click)
{
return(new MenuItem(I18N.GetString(text), click));
}
public DashWidgetView(DashSquare square)
{
RelativeLayout layout = new RelativeLayout();
var tapGestureRecognizer = new TapGestureRecognizer();
tapGestureRecognizer.Tapped += (s, e) => {
EventHandler <WidgetTappedEventArgs> handler = Tapped;
if (handler != null)
{
handler(this, new WidgetTappedEventArgs(square.NavigateType));
}
};
layout.GestureRecognizers.Add(tapGestureRecognizer);
var backgroundImage = new Image()
{
Source = new FileImageSource()
{
File = square.BackgroundImage
},
Aspect = Aspect.AspectFill,
InputTransparent = false
};
layout.Children.Add(backgroundImage,
Constraint.Constant(0),
Constraint.Constant(0),
Constraint.RelativeToParent((parent) => {
return(parent.Width);
}),
Constraint.RelativeToParent((parent) => {
return(parent.Height);
}));
var iconImage = new Image()
{
Source = new FileImageSource()
{
File = square.IconImage
},
InputTransparent = true
};
layout.Children.Add(
iconImage,
Constraint.RelativeToParent((parent) => {
return((parent.Width / 2) - (iconImage.Width / 2));
}),
Constraint.RelativeToParent((parent) => {
return(parent.Height * .25);
}),
Constraint.RelativeToParent((parent) => {
return(parent.Width * .45);
}),
Constraint.RelativeToParent((parent) => {
return(parent.Width * .45);
})
);
iconImage.SizeChanged += (sender, e) => {
layout.ForceLayout();
};
var dashlabel = new Label()
{
Text = square.Text,
XAlign = TextAlignment.Center,
TextColor = Color.White,
FontFamily = Device.OnPlatform("AvenirNextCondensed-Bold", "sans-serif-condensed", null),
InputTransparent = true
};
layout.Children.Add(dashlabel,
Constraint.Constant(0),
Constraint.RelativeToParent((parent) => {
return(parent.Height - 30);
}),
Constraint.RelativeToParent((parent) => {
return(parent.Width);
}),
Constraint.RelativeToParent((parent) => {
return(parent.Height);
}));
Content = layout;
}
public void DeleteBatchShipTypePayType(List<int?> sysNos, EventHandler<RestClientEventArgs<dynamic>> callback)
{
string relativeUrl = "/CommonService/ShipTypePayType/Delete";
restClient.Delete(relativeUrl, sysNos, callback);
}
/// <summary>
/// Factory method. Asynchronously loads a <see cref="SupplierList"/> collection, based on given parameters.
/// </summary>
/// <param name="name">The Name parameter of the SupplierList to fetch.</param>
/// <param name="callback">The completion callback method.</param>
public static void GetSupplierList(string name, EventHandler <DataPortalResult <SupplierList> > callback)
{
DataPortal.BeginFetch <SupplierList>(name, callback);
}
public static void GetPTIdentity(string username, string password, EventHandler <DataPortalResult <PTIdentity> > callback)
{
DataPortal.BeginFetch <PTIdentity>(new UsernameCriteria(username, password), callback);
}
/// <summary>
/// Constructor specifying the target object.
/// </summary>
/// <param name="targetObject">The target object the behavior is attached to.</param>
public CommandBehaviorBase(T targetObject)
{
_targetObject = new WeakReference(targetObject);
_commandCanExecuteChangedHandler = CommandCanExecuteChanged;
}
/// <summary>
/// Initialize a new instance of the ButtonSpecView class.
/// </summary>
/// <param name="redirector">Palette redirector.</param>
/// <param name="paletteMetric">Source for metric values.</param>
/// <param name="metricPadding">Padding metric for border padding.</param>
/// <param name="manager">Reference to owning manager.</param>
/// <param name="buttonSpec">Access</param>
public ButtonSpecView(PaletteRedirect redirector,
IPaletteMetric paletteMetric,
PaletteMetricPadding metricPadding,
ButtonSpecManagerBase manager,
ButtonSpec buttonSpec)
{
Debug.Assert(redirector != null);
Debug.Assert(manager != null);
Debug.Assert(buttonSpec != null);
// Remember references
_redirector = redirector;
Manager = manager;
ButtonSpec = buttonSpec;
_finishDelegate = OnFinishDelegate;
// Create delegate for paint notifications
NeedPaintHandler needPaint = OnNeedPaint;
// Intercept calls from the button for color remapping and instead use
// the button spec defined map and the container foreground color
RemapPalette = Manager.CreateButtonSpecRemap(redirector, buttonSpec);
// Use a redirector to get button values directly from palette
_palette = new PaletteTripleRedirect(RemapPalette,
PaletteBackStyle.ButtonButtonSpec,
PaletteBorderStyle.ButtonButtonSpec,
PaletteContentStyle.ButtonButtonSpec,
needPaint);
// Create the view for displaying a button
ViewButton = new ViewDrawButton(_palette, _palette, _palette, _palette,
paletteMetric, this, VisualOrientation.Top, false);
// Associate the view with the source component (for design time support)
if (buttonSpec.AllowComponent)
{
ViewButton.Component = buttonSpec;
}
// Use a view center to place button in centre of given space
ViewCenter = new ViewLayoutCenter(paletteMetric, metricPadding, VisualOrientation.Top)
{
ViewButton
};
// Create a controller for managing button behavior
ButtonSpecViewControllers controllers = CreateController(ViewButton, needPaint, OnClick);
ViewButton.MouseController = controllers.MouseController;
ViewButton.SourceController = controllers.SourceController;
ViewButton.KeyController = controllers.KeyController;
// We need notifying whenever a button specification property changes
ButtonSpec.ButtonSpecPropertyChanged += OnPropertyChanged;
// Associate the button spec with the view that is drawing it
ButtonSpec.SetView(ViewButton);
// Finally update view with current button spec settings
UpdateButtonStyle();
UpdateVisible();
UpdateEnabled();
UpdateChecked();
}
public MessageAction(string label, EventHandler handler) : this(label, false, handler)
{
}
// "Creating" a new SearchAgent here was not buying us much that we shouldn't just create it when it was called.
// TODO: TBD: a bit on the fence about the prospect of a "for-each-solution"; could make for an interesting API, but is it necessary?
/// <summary>
///
/// </summary>
/// <param name="agent"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static ISearchAgent ForEachSolution(this ISearchAgent agent, EventHandler <ProcessVariablesEventArgs> handler)
{
agent.ProcessVariables += handler;
return(agent);
}
/// <summary>
/// 检查订阅事件处理函数。
/// </summary>
/// <param name="id">事件类型编号。</param>
/// <param name="handler">要检查的事件处理函数。</param>
/// <returns>是否存在事件处理函数。</returns>
public bool Check(int id, EventHandler <GameEventArgs> handler)
{
return(mEventPool.Check(id, handler));
}
/// <summary>
/// 获得比较最适合的用于处理响应的类型
/// </summary>
/// <typeparam name="T">当前希望获得的结果</typeparam>
/// <param name="client">当前的HTTP客户端</param>
/// <param name="ctx">当前的上下文环境</param>
/// <param name="responseContent">当前用来处理结果的对象</param>
/// <param name="streamInvoker">如果希望能按流处理，那么用来处理响应的事件委托</param>
/// <param name="result">当前希望获得的结果实例</param>
/// <param name="targetStream">要将相应内容写入的流</param>
/// <param name="saveToFilePath">要将当前请求写入的文件路径</param>
/// <returns></returns>
public HttpResponseContent GetPreferedResponseType<T>(HttpClient client, HttpContext ctx, HttpResponseContent responseContent, EventHandler<ResponseStreamContent.RequireProcessStreamEventArgs> streamInvoker = null, T result = default(T), Stream targetStream = null, string saveToFilePath = null)
{
return responseContent;
}
