public static void RemoveMessageFilter(IMessageFilter value)
{
lock (message_filters)
{
message_filters.Remove(value);
}
}
public DefaultConsumingProcess(IIdGenerator idGenerator,
IExchangeResolver exchangeResolver,
IMessageSerializer serializer,
IMessageTypeResolver messageTypeResolver,
IConsumerContainer consumerContainer,
IMessageFilter messageFilters,
IQueueFactory queueFactory,
IConsumerInvoker consumerInvoker,
RogerOptions options,
IAggregator aggregator)
{
this.consumerContainer = consumerContainer;
this.queueFactory = queueFactory;
this.consumerInvoker = consumerInvoker;
this.options = options;
this.aggregator = aggregator;
this.exchangeResolver = exchangeResolver;
bindingKeyResolver = new DefaultRoutingKeyResolver();
this.messageTypeResolver = messageTypeResolver;
this.serializer = serializer;
this.idGenerator = idGenerator;
supportedMessageTypesResolver = new DefaultSupportedMessageTypesResolver();
this.messageFilters = messageFilters;
aggregator.Subscribe(this);
}
public static void AddMessageFilter(IMessageFilter value)
{
lock (message_filters)
{
message_filters.Add(value);
}
}
public void CreateAndDispose_intermediateFilterRegistredAndLeft_exceptionThrown()
{
Exception gotException = null;
IMessageFilter intermediateFilter = null;
var thread = new Thread(() =>
{
intermediateFilter = new TestMessageFilter();
try
{
using (new StaComCrossThreadInvoker())
{
IMessageFilter commonFilter = null;
NativeMethods.CoRegisterMessageFilter(intermediateFilter, out commonFilter);
}
}
catch (Exception ex)
{
gotException = ex;
}
});
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
thread.Join();
Assert.IsInstanceOf <InvalidOperationException>(gotException);
}
/// <summary>
/// Unregisters a previous instance of IMessageFilter with OLE on the current thread.
/// </summary>
/// <remarks>
/// It is not necessary to call Unregister() unless you need to explicitly do so as it is handled
/// in the destructor.
/// </remarks>
public static void Unregister()
{
IMessageFilter oldFilter = null;
// Call CoRegisterMessageFilter().
NativeMethods.CoRegisterMessageFilter(newFilter: null, oldFilter: out oldFilter);
}
internal void AfterSerialization(IMessageFilter filter, IEnvelope envelope)
{
if (IsEnabled())
{
AfterSerialization(filter.GetType().Name, envelope.CorrelationId, envelope.SessionId);
}
}
internal void RegisteredSerializationFilter(string configurationType, IMessageFilter filter)
{
if (IsEnabled())
{
RegisteredSerializationFilter(configurationType, filter.GetType().Name);
}
}
/// <summary>
/// Function to add a new filter to the window hook.
/// </summary>
/// <param name="hwnd">Window handle to hook.</param>
/// <param name="filter">Filter to uninstall from the hook</param>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="hwnd"/> parameter is <see cref="IntPtr.Zero"/>, or the <paramref name="filter"/> parameter is <b>null</b>.</exception>
public static void RemoveFilter(IntPtr hwnd, IMessageFilter filter)
{
if (hwnd == IntPtr.Zero)
{
throw new ArgumentNullException(nameof(hwnd));
}
lock (_registeredHooks)
{
if (!_registeredHooks.TryGetValue(hwnd, out MessageFilterHook hook))
{
return;
}
hook.RemoveFilter(filter);
if (hook._hooked)
{
return;
}
_registeredHooks.Remove(hwnd);
hook.UninstallWindowProcedure();
}
}
public override void InitAdapter(nessScanning control, IMessageFilter messageFilter, IntPtr handle)
{
m_Control = control;
m_MessageFilter = messageFilter;
m_Twain.Init(handle);
m_ScannerDeviceData = m_Twain.TwainDevice;
}
/// <summary>
/// Function to process the messages through the installed message filters.
/// </summary>
/// <param name="hwnd">Window handle receiving the message.</param>
/// <param name="msg">Message being received.</param>
/// <param name="wParam">Window parameter 1.</param>
/// <param name="lParam">Window parameter 2.</param>
/// <returns>The result of a call to the previous window procedure if the message was not processed, or <see cref="IntPtr.Zero"/> if the message was processed.</returns>
private IntPtr NewWndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam)
{
if (!_hooked)
{
UninstallWindowProcedure();
return(UserApi.CallWindowProc(_defaultWndProc, hwnd, msg, wParam, lParam));
}
var windowMessage = new Message
{
HWnd = hwnd,
Msg = msg,
WParam = wParam,
LParam = lParam
};
// Send a copy of the message to any installed filters.
// ReSharper disable once LoopCanBeConvertedToQuery
// ReSharper disable once ForCanBeConvertedToForeach
for (int i = 0; i < _messageFilters.Count; i++)
{
// ReSharper disable once InconsistentlySynchronizedField
IMessageFilter filter = _messageFilters[i];
if (filter.PreFilterMessage(ref windowMessage))
{
return(windowMessage.Result);
}
}
return(UserApi.CallWindowProc(_defaultWndProc, hwnd, msg, wParam, lParam));
}
private void UnregisterFilter()
{
if (_oldMessageFilter != null)
{
_messageFilter = _oldMessageFilter;
CoRegisterMessageFilter(_messageFilter, out _oldMessageFilter);
}
}
/**
* 设置消息处理器
* @param {String} key 消息类型
* @param {MessageFilter} val 消息处理器
*/
public void setFilter(string key, IMessageFilter val)
{
if (this.filters.ContainsKey(key))
{
throw new Exception($"分发器{ key }已存在");
}
this.filters.Add(key, val);
}
public static string ApplyTo(this IMessageFilter messageFilter, string message)
{
if (messageFilter != null)
{
return(messageFilter.Filter(message));
}
return(message);
}
public RaygunMessage BuildMessage(Exception exception, LoggingEvent loggingEvent, Dictionary <string, string> userCustomData,
IMessageFilter exceptionFilter, IMessageFilter renderedMessageFilter, IgnoredDataSettings ignoredFieldSettings, string customApplicationVersion)
{
var raygunMessageBuilder = Mindscape.Raygun4Net.RaygunMessageBuilder.New;
var httpContext = _httpContextFactory();
if (httpContext != null && httpContext.Instance != null)
{
LogLog.Debug(DeclaringType, "RaygunAppender: Setting http details on the raygun message from http context");
var messageOptions = new RaygunRequestMessageOptions(
ignoredFieldSettings.IgnoredSensitiveFieldNames,
ignoredFieldSettings.IgnoredQueryParameterNames,
ignoredFieldSettings.IgnoredFormNames,
ignoredFieldSettings.IgnoredHeaderNames,
ignoredFieldSettings.IgnoredCookieNames,
ignoredFieldSettings.IgnoredServerVariableNames)
{
IsRawDataIgnored = ignoredFieldSettings.IsRawDataIgnored
};
raygunMessageBuilder.SetHttpDetails(httpContext.Instance, messageOptions);
}
raygunMessageBuilder
.SetExceptionDetails(exception)
.SetClientDetails()
.SetTags(ExtractTags(loggingEvent.GetProperties()))
.SetUser(ExtractAffectedUser(loggingEvent.GetProperties()))
.SetEnvironmentDetails()
.SetMachineName(Environment.MachineName)
.SetVersion(GetApplicationVersion(customApplicationVersion))
.SetUserCustomData(FilterRenderedMessageInUserCustomData(userCustomData, renderedMessageFilter));
var raygunMessage = raygunMessageBuilder.Build();
if (exception != null)
{
if (raygunMessage.Details.Error != null)
{
raygunMessage.Details.Error.Message = exceptionFilter.ApplyTo(exception.Message);
}
}
else
{
LogLog.Debug(DeclaringType, "RaygunAppender: No exception object found in error, creating raygun error message from the rendered message and calling class");
raygunMessage.Details.Error = new RaygunErrorMessage
{
Message = renderedMessageFilter.ApplyTo(loggingEvent.RenderedMessage),
ClassName = loggingEvent.LocationInformation.ClassName
};
}
return(raygunMessage);
}
public TConfiguration WithSerializationFilter(IMessageFilter filter)
{
MessageFilterInvoker.Add(filter);
// Log.
MessengerEventSource.Log.RegisteredSerializationFilter(GetType().Name, filter);
// Continue.
return(this as TConfiguration);
}
private void Revoke()
{
if (_isRegistered)
{
IMessageFilter revokedFilter;
var hr = CoRegisterMessageFilter(_oldFilter, out revokedFilter);
_oldFilter = null;
_isRegistered = false;
}
}
public AppInsightsV2Controller([NotNull] ITenantRepository tenantRepository,
[NotNull] IMessageFilter messageFilter,
[NotNull] IIndexNameBuilder indexNameBuilder,
[NotNull] ConnectionSettings elasticClientSettings)
{
_tenantRepository = tenantRepository ?? throw new ArgumentNullException(nameof(tenantRepository));
_messageFilter = messageFilter ?? throw new ArgumentNullException(nameof(messageFilter));
_indexNameBuilder = indexNameBuilder ?? throw new ArgumentNullException(nameof(indexNameBuilder));
_elasticClientSettings = elasticClientSettings ?? throw new ArgumentNullException(nameof(elasticClientSettings));
}
internal RuntimeHostControl(RuntimeHostSurface hostSurface)
{
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
InitializeHost(hostSurface);
messageFilter = new RTDesignerMessageFilter((DesignerActionUIService)hostSurface.GetService(typeof(DesignerActionUIService)),
(ISelectionService)(hostSurface.GetService(typeof(ISelectionService))));
Application.AddMessageFilter(messageFilter);
}
private void AddMessageMilter(IMessageFilter filter)
{
List <IMessageFilter> list = new List <IMessageFilter>((IEnumerable <IMessageFilter>) this.currentFilters);
if (!list.Contains(filter))
{
list.Add(filter);
}
this.currentFilters = list;
}
public MessageInterceptor(IDialog dialog,
IMessageFilter filter,
Action <MessageReceivedEventArgs <TMessage> > callback)
{
this.Dialog = dialog;
this.Dialog.MessageDispatching += this.Dialog_MessageDispatching;
this.Filter = filter;
this.Callback = callback;
}
/// <summary>
/// Creates and registers this filter.
/// </summary>
/// <param name="maximumTotalWaitTimeInMilliseconds">
/// Number of milliseconds before message filter stops spin waiting call to finish, call canceled and COM exceptions popup.
/// </param>
public StaComCrossThreadInvoker(uint maximumTotalWaitTimeInMilliseconds)
{
var t = Thread.CurrentThread;
if (t.GetApartmentState() != ApartmentState.STA) throw new InvalidOperationException("StaComCrossThreadInvoker can be used only from STA thread.");
AffinedThreadId = t.ManagedThreadId;
_maximumTotalWaitTimeInMilliseconds = maximumTotalWaitTimeInMilliseconds;
_oldFilter = null;
int hr = NativeMethods.CoRegisterMessageFilter(this, out _oldFilter);
if (hr != S_OK) throw new COMException("Failed to create message filter",hr);
}
/// <summary>Constructor; initializes the window and constructs the tab thumbnail image to use when dragging.</summary>
/// <param name="tab">Tab that was torn out of its parent window.</param>
/// <param name="tabRenderer">Renderer instance to use when drawing the actual tab.</param>
public TitleBarTornTabForm(TitleBarTabItem tab, BaseTabRenderer tabRenderer, IMessageFilter messageFilter)
{
m_messageFilter = messageFilter;
m_layeredWindow = new LayeredWindow();
m_initialized = false;
// Set drawing styles
SetStyle(ControlStyles.DoubleBuffer, true);
// This should show up as a semi-transparent borderless window
Opacity = 0.70;
ShowInTaskbar = false;
FormBorderStyle = FormBorderStyle.None;
// ReSharper disable DoNotCallOverridableMethodsInConstructor
BackColor = Color.Fuchsia;
// ReSharper restore DoNotCallOverridableMethodsInConstructor
TransparencyKey = Color.Fuchsia;
AllowTransparency = true;
Disposed += TornTabForm_Disposed;
// Get the tab thumbnail (full size) and then draw the actual representation of the tab onto it as well
Bitmap tabContents = tab.GetImage();
Bitmap contentsAndTab = new Bitmap(tabContents.Width, tabContents.Height + tabRenderer.TabHeight, tabContents.PixelFormat);
Graphics tabGraphics = Graphics.FromImage(contentsAndTab);
tabGraphics.DrawImage(tabContents, 0, tabRenderer.TabHeight);
bool oldShowAddButton = tabRenderer.ShowAddButton;
tabRenderer.ShowAddButton = false;
tabRenderer.Render(
new ListWithEvents <TitleBarTabItem>
{
tab
}, tabGraphics, new Point(0, 0), new Point(0, 0), true);
tabRenderer.ShowAddButton = oldShowAddButton;
// Scale the thumbnail down to half size
m_tabThumbnail = new Bitmap(contentsAndTab.Width / 2, contentsAndTab.Height / 2, contentsAndTab.PixelFormat);
Graphics thumbnailGraphics = Graphics.FromImage(m_tabThumbnail);
thumbnailGraphics.InterpolationMode = InterpolationMode.High;
thumbnailGraphics.CompositingQuality = CompositingQuality.HighQuality;
thumbnailGraphics.SmoothingMode = SmoothingMode.AntiAlias;
thumbnailGraphics.DrawImage(contentsAndTab, 0, 0, m_tabThumbnail.Width, m_tabThumbnail.Height);
Width = m_tabThumbnail.Width - 1;
Height = m_tabThumbnail.Height - 1;
m_cursorOffset = new Point(tabRenderer.TabContentWidth / 4, tabRenderer.TabHeight / 4);
SetWindowPosition(Cursor.Position);
}
private void AddMessageMilter(IMessageFilter filter)
{
var messageFilters = new List <IMessageFilter>(currentFilters);
if (!messageFilters.Contains(filter))
{
messageFilters.Add(filter);
}
currentFilters = messageFilters;
}
public void AddMessageFilter(IMessageFilter filter)
{
if (!MessageFilters.Contains(filter))
{
MessageFilters.AddLast(filter);
}
else
{
MessageFilters.Find(filter).Value = filter;
}
}
/// <summary>
/// Function to add a filter to the window procedure hook.
/// </summary>
/// <param name="filter">The filter to add to the hook.</param>
private void AddFilter(IMessageFilter filter)
{
var filters = new List <IMessageFilter>(_messageFilters);
if (!_messageFilters.Contains(filter))
{
filters.Add(filter);
}
_messageFilters = filters;
}
private void AddMessageMilter(IMessageFilter filter)
{
// Make a copy of the filters in order to support a lightweight threadsafe
var filters = new List <IMessageFilter>(this.currentFilters);
if (!filters.Contains(filter))
{
filters.Add(filter);
}
this.currentFilters = filters;
}
public DataProvider(bool includeExtensionFields, IMessageNameTransformation messageNameTransformation, IMessageFieldNameTransformation messageFieldNameTransformation, IEnumNameTransformation enumNameTransformation, IEnumEntryNameTransformation enumEntryNameTransformation, IMessageFilter messageFilter)
{
_includeExtensionFields = includeExtensionFields;
_messageNameTransformation = messageNameTransformation;
_messageFieldNameTransformation = messageFieldNameTransformation;
_enumNameTransformation = enumNameTransformation;
_enumEntryNameTransformation = enumEntryNameTransformation;
_messageFilter = messageFilter;
_enumByXmlEnumName = new Dictionary <String, Data.Enum>();
}
private void RemoveMessageFilter(IMessageFilter filter)
{
List <IMessageFilter> list = new List <IMessageFilter>((IEnumerable <IMessageFilter>) this.currentFilters);
list.Remove(filter);
if (list.Count == 0)
{
this.isDisposed = true;
this.RestoreWndProc();
}
this.currentFilters = list;
}
public ISubscription RegisterSubscription <T>(T instance, Action <ISubscriberConfigurator> configure = null)
{
var configurator = CreateConfigurator(configure);
IInputChannel inputChannel = OnCreateInputChannel(configurator);
IMessageFilter messageFilter = OnCreateMessageFilter(inputChannel);
ISubscriptionDispatcher dispatcher = new SubscriptionDispatcher(configurator.ErrorSubscriber, BusId);
return(new TypeSubscription(inputChannel, messageFilter, dispatcher, instance));
}
public ISubscriber CreateSubscriber(Action <ISubscriberConfigurator> configure = null)
{
var configurator = CreateConfigurator(configure);
IInputChannel inputChannel = OnCreateInputChannel(configurator);
IMessageFilter messageFilter = OnCreateMessageFilter(inputChannel);
ICallbackDispatcher dispatcher = new CallBackDispatcher(configurator.ErrorSubscriber, BusId);
return(new Subscriber(inputChannel, messageFilter, dispatcher));
}
public IMessageFilter CreateFilter(byte key, MessageFilterType type)
{
IMessageFilter filter = null;
Dictionary <byte, IMessageFilter> map = null;
if (filterMap.TryGetValue(type, out map))
{
var pos = posMap[type];
map.TryGetValue((byte)(key & pos), out filter);
}
return(filter ?? Empty.Instance);
}
public static void AddMessageFilter(IntPtr hwnd, IMessageFilter messageFilter)
{
lock (MessageFilterHook.RegisteredHooks)
{
hwnd = MessageFilterHook.GetSafeWindowHandle(hwnd);
MessageFilterHook local_0;
if (!MessageFilterHook.RegisteredHooks.TryGetValue(hwnd, out local_0))
{
local_0 = new MessageFilterHook(hwnd);
MessageFilterHook.RegisteredHooks.Add(hwnd, local_0);
}
local_0.AddMessageMilter(messageFilter);
}
}
/// <summary>
/// Adds a message filter to a window.
/// </summary>
/// <param name="hwnd">The handle of the window.</param>
/// <param name="messageFilter">The message filter.</param>
public static void AddMessageFilter(IntPtr hwnd, IMessageFilter messageFilter)
{
lock (RegisteredHooks)
{
hwnd = GetSafeWindowHandle(hwnd);
MessageFilterHook hook;
if (!RegisteredHooks.TryGetValue(hwnd, out hook))
{
hook = new MessageFilterHook(hwnd);
RegisteredHooks.Add(hwnd, hook);
}
hook.AddMessageMilter(messageFilter);
}
}
public static void RemoveMessageFilter(IntPtr hwnd, IMessageFilter messageFilter)
{
lock (MessageFilterHook.RegisteredHooks)
{
hwnd = MessageFilterHook.GetSafeWindowHandle(hwnd);
MessageFilterHook local_0;
if (!MessageFilterHook.RegisteredHooks.TryGetValue(hwnd, out local_0))
return;
local_0.RemoveMessageFilter(messageFilter);
if (!local_0.isDisposed)
return;
MessageFilterHook.RegisteredHooks.Remove(hwnd);
local_0.RestoreWndProc();
}
}
///<summary>
///</summary>
///<param name="subscriber"></param>
///<param name="filter">the filter associated with this subscriber</param>
/// <returns>return if the <paramref name="subscriber"/>is already subscribed</returns>
/// <remarks>if there is already a filer, subscribing will generate a DisJunction filter for them. <see cref="MessageFilters.DisJunctionFilter"/>
/// </remarks>
public bool Subscribe(IMessageListener subscriber, IMessageFilter filter)
{
if (filter == null)
filter = NullMsgFilter.Instance;
if (generalSubscribers.ContainsKey(subscriber)) {
IMessageFilter existingFilter = generalSubscribers[subscriber];
if (existingFilter != null)
generalSubscribers[subscriber] = MessageFilters.DisJunctionFilter(
new IMessageFilter[] {filter, existingFilter});
else
generalSubscribers[subscriber] = filter;
return true;
}
else {
generalSubscribers.Add(subscriber, filter);
return false;
}
}
private InvokationResult InvokeHandler(Type handlerType, object message)
{
var success = true;
Exception exception = null;
var numberOfRetrys = config.NumberOfRetrys;
for (var i = 0; i < numberOfRetrys; i++)
{
var methodInfo = handlerType.GetMethod("Handle", new[] { message.GetType() });
var messageFilters = new IMessageFilter[0];
objectFactory.BeginScope();
try
{
var handler = objectFactory.CreateInstance(handlerType);
messageFilters = MessageFilterResolver.GetMessageFilters(objectFactory);
var isLocalMessage = message.GetType().IsLocal();
if (!isLocalMessage) messageFilters.Apply(x => x.Before());
methodInfo.Invoke(handler, new[] { message });
if (!isLocalMessage) messageFilters.Apply(x => x.After());
break;
}
catch (Exception ex)
{
log.Error(string.Format("Attempt {1}: Failed to handle message '{0}'.", message.GetType().Name, i + 1), ex.InnerException);
success = false;
messageFilters.Apply(x => x.OnError(ex.InnerException));
exception = ex.InnerException;
}
objectFactory.EndScope();
}
return new InvokationResult(success, exception);
}
private void AddMessageMilter(IMessageFilter filter)
{
// Make a copy of the filters in order to support a lightweight threadsafe
var filters = new List<IMessageFilter>(this.currentFilters);
if (!filters.Contains(filter))
filters.Add(filter);
this.currentFilters = filters;
}
public static void RemoveMessageFilter (IMessageFilter value)
{
lock (message_filters) {
message_filters.Remove (value);
}
}
public static void AddMessageFilter (IMessageFilter value)
{
lock (message_filters) {
message_filters.Add (value);
}
}
public bool Subscribe(IMessageListener subscriber, IMessageFilter filter, object source)
{
return GetSourceSpecificBroadcaster(source).Subscribe(subscriber, filter);
}
private void RemoveMessageFilter(IMessageFilter filter)
{
// Make a copy of the filters in order to support a lightweight threadsafe
var filters = new List<IMessageFilter>(this.currentFilters);
filters.Remove(filter);
// If there are no more filters, then we can remove the hook
if (filters.Count == 0)
{
this.isDisposed = true;
this.RestoreWndProc();
}
this.currentFilters = filters;
}
public MessageRouter(ILogger logger, IDataOperations dataOperations, IMessageFilter filter)
{
_logger = logger;
_dataOperations = dataOperations;
_filter = filter;
}
public void AddFilter(IMessageFilter filter)
{
messageFilters.AddFilter(filter);
}
public MessageHandler(object container, Type containerType, Type messageType, MessageHandlerAttribute handlerAttribute, Action<object, object, Message> action, Type tokenType, IMessageFilter filter)
{
Container = container;
ContainerType = containerType;
MessageType = messageType;
Attribute = handlerAttribute;
Action = action;
TokenType = tokenType;
Filter = filter;
}
/// <summary>
/// Removes a message filter associated with a window.
/// </summary>
/// <param name="hwnd">The handle of the window.</param>
/// <param name="messageFilter">The message filter.</param>
public static void RemoveMessageFilter(IntPtr hwnd, IMessageFilter messageFilter)
{
lock (RegisteredHooks)
{
hwnd = GetSafeWindowHandle(hwnd);
MessageFilterHook hook;
if (RegisteredHooks.TryGetValue(hwnd, out hook))
{
hook.RemoveMessageFilter(messageFilter);
if (hook.isDisposed)
{
RegisteredHooks.Remove(hwnd);
hook.RestoreWndProc();
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="value"></param>
public static void AddMessageFilter(IMessageFilter value)
{
MessageFilters.Add(value);
}
private void UnregisterFilter()
{
_messageFilter = null;
CoRegisterMessageFilter(null, out _messageFilter);
}
internal void RegisteredSerializationFilter(string configurationType, IMessageFilter filter)
{
if (IsEnabled())
RegisteredSerializationFilter(configurationType, filter.GetType().ToString(), Thread.CurrentThread.ManagedThreadId, GetTask());
}
internal void AfterSerialization(IMessageFilter filter, IEnvelope envelope)
{
if (IsEnabled())
AfterSerialization(filter.GetType().Name, envelope.CorrelationId, envelope.SessionId, Thread.CurrentThread.ManagedThreadId, GetTask());
}
public void RemoveFilter(IMessageFilter filter)
{
messageFilters.RemoveFilter(filter);
}
public void RegisterMessageFilter(IMessageFilter filter)
{
_filters.Add(filter);
}
private void RemoveMessageFilter(IMessageFilter filter)
{
List<IMessageFilter> list = new List<IMessageFilter>((IEnumerable<IMessageFilter>) this.currentFilters);
list.Remove(filter);
if (list.Count == 0)
{
this.isDisposed = true;
this.RestoreWndProc();
}
this.currentFilters = list;
}
private static extern int CoRegisterMessageFilter(
IMessageFilter lpMessageFilter,
out IMessageFilter lplpMessageFilter
);
protected SubscriptionBase(IInputChannel inputChannel, IMessageFilter messageFilter, IDispatcher dispatcher)
{
_inputChannel = inputChannel;
_messageFilter = messageFilter;
_dispatcher = dispatcher;
}
/// <summary>
///
/// </summary>
/// <param name="filter"></param>
public static void RemoveMessageFilter(IMessageFilter filter)
{
MessageFilters.Remove(filter);
}
public bool Contains(IMessageFilter messageFilter)
{
return filters.Contains(messageFilter);
}
/// <summary>
/// Initializes a new map
/// </summary>
public MapBox()
#endif
#pragma warning restore 1587
{
SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint, true);
base.DoubleBuffered = true;
_map = new Map(ClientSize);
VariableLayerCollection.VariableLayerCollectionRequery += HandleVariableLayersRequery;
_map.MapNewTileAvaliable += HandleMapNewTileAvaliable;
_activeTool = Tools.None;
LostFocus += HandleMapBoxLostFocus;
_progressBar = new ProgressBar
{
Style = ProgressBarStyle.Marquee,
Location = new Point(2, 2),
Size = new Size(50, 10)
};
Controls.Add(_progressBar);
_progressBar.Visible = false;
_mousePreviewFilter = new MouseWheelGrabber(this);
Application.AddMessageFilter(_mousePreviewFilter);
}
public static int LastRetryResult = int.MinValue; // no such value should be returned ever
#endregion Fields
#region Methods
/// <summary>
/// Imitates COM busy for some time.
/// </summary>
/// <param name="messageFilter"></param>
/// <param name="comBusyTime"></param>
public static void RetryRejectedCall(IMessageFilter messageFilter, uint comBusyTime)
{
LastRetryResult = messageFilter.RetryRejectedCall(IntPtr.Zero, comBusyTime, 0);
}
public ModelOverviewForm(WbContext WbContext, Overview be)
{
InitializeComponent();
wbContext = WbContext;
wbOverview = be;
UpdateTabText();
workbenchMenuManager = new WorkbenchMenuManager(wbContext);
userDatatypesForm = new UserDatatypesForm(wbContext);
historyForm = new UndoHistoryForm(wbContext);
modelObjectDescriptionForm = new ModelObjectDescriptionForm(wbContext);
wheelMessageFilter = new WheelMessageFilter(this);
Application.AddMessageFilter(wheelMessageFilter);
SetupSideBar();
UpdateColors();
}
private void AddMessageMilter(IMessageFilter filter)
{
List<IMessageFilter> list = new List<IMessageFilter>((IEnumerable<IMessageFilter>) this.currentFilters);
if (!list.Contains(filter))
list.Add(filter);
this.currentFilters = list;
}
