public DropDownBoxListWindow (IListDataProvider provider, WindowType windowType) : base (windowType)
{
this.DataProvider = provider;
this.TransientFor = IdeApp.Workbench.RootWindow;
this.TypeHint = Gdk.WindowTypeHint.Menu;
this.Decorated = false;
this.BorderWidth = 1;
list = new ListWidget (this);
list.SelectItem += delegate {
var sel = list.Selection;
if (sel >= 0 && sel < DataProvider.IconCount) {
DataProvider.ActivateItem (sel);
Destroy ();
}
};
SetSizeRequest (list.WidthRequest, list.HeightRequest);
vScrollbar = new ScrolledWindow ();
vScrollbar.VScrollbar.SizeAllocated += (o, args) => {
var minWidth = list.WidthRequest + args.Allocation.Width;
if (this.Allocation.Width < minWidth)
SetSizeRequest (minWidth, list.HeightRequest);
};
vScrollbar.Child = list;
var vbox = new VBox ();
vbox.PackStart (vScrollbar, true, true, 0);
Add (vbox);
}
internal CustomShortcut(
string shortcutName,
string targetPath,
string targetArguments,
CustomShortcutType shortcutType,
WindowType windowType,
string shortcutRootFolder,
string basicIconToUse = null,
string workingFolder = null
)
{
var vbsFolderPath =
DirectoryUtils.GetUniqueDirName(CustomShortcutGetters.CustomShortcutVbsPath + shortcutName) + "\\";
var shortcutPath = $"{shortcutRootFolder}{new DirectoryInfo(vbsFolderPath).Name}\\{shortcutName}.lnk";
ShortcutName = shortcutName.CleanInvalidFilenameChars();
ShortcutItem = new ShortcutItem(shortcutPath);
TargetPath = targetPath;
TargetArguments = targetArguments;
ShortcutType = shortcutType;
VbsFolderPath = vbsFolderPath;
WorkingFolder = workingFolder;
WindowType = windowType;
Directory.CreateDirectory(VbsFolderPath);
if (basicIconToUse != null && File.Exists(basicIconToUse)) BasicShortcutIcon = basicIconToUse;
}
public IceTabPageDCCFile(WindowType windowType, string sCaption)
: base(windowType, sCaption)
{
InitializeComponent();
dccFiles = new List<DccFileStruct>();
}
public static bool GetCurrentMediaItem(out MediaItem currentMediaItem, WindowType windowType)
{
currentMediaItem = new MediaItem();
switch (windowType)
{
case WindowType.Movie:
return GetMovieMediaItem(ref currentMediaItem);
case WindowType.Show:
return GetShowMediaItem(ref currentMediaItem);
case WindowType.Season:
return GetSeasonMediaItem(ref currentMediaItem);
case WindowType.Episode:
return GetEpisodeMediaItem(ref currentMediaItem);
case WindowType.List:
return GetListMediaItem(ref currentMediaItem);
}
return false;
}
public Window(WindowType window_type)
: base(window_type)
{
_context = SynchronizationContext.Current;
CommunicationHandler.addReceiver(this);
this.SetIconFromFile("masgau.ico");
}
public void SaveFile(String FilePath, String mainFolder)
{
if(Directory.Exists(mainFolder))
{
if(File.Exists(FilePath) || Directory.Exists(FilePath))
{
WindowOpen = true;
WinType = WindowType.Save;
DragStat.Dragging = false; // Ensure nothing is being draged.
FileToSave = FilePath;
MainFolder = mainFolder; // example: Application.dataPath/Saves;
GetAllSubDirectoriesAndFiles( MainFolder );
AddWidth();
AddScrollPosition(0);
AddPath(MainFolder, 0);
}
else Debug.LogError("I need a path for a temporary save file that actually exists!");
}
else
{
if(File.Exists(mainFolder)) Debug.LogError("I need a main directory, not a file!");
else Debug.LogError("I need a path for a main directory that actually exists!");
}
}
/// <summary>
/// Displays content in a window
/// </summary>
/// <param name="windowTitle">Title text shown in window</param>
/// <param name="windowContents">Contents of the window</param>
/// <param name="isModal">Determines wheter the window is modal or not</param>
/// <param name="onClosingHandler">Event handler invoked when window is closing, and can be handled to cancel window closure</param>
/// <param name="windowType">The type of the window</param>
/// <param name="onClosedHandler">Event handler invoked when window is closed</param>
/// <param name="top">The distance from the top of the application at which to position the window</param>
/// <param name="left">The distance from the left of the application at which to position the window</param>
/// <returns>The window</returns>
public object ShowWindow(string windowTitle, FrameworkElement windowContents, bool isModal = false,
EventHandler<CancelEventArgs> onClosingHandler = null, EventHandler onClosedHandler = null,
WindowType windowType = WindowType.Floating, double? top = null, double? left = null)
{
if (windowContents == null)
throw new ArgumentNullException("windowContents");
int hashCode = windowContents.GetHashCode();
FloatingWindow floatingWindow = null;
if (!m_FloatingWindows.TryGetValue(hashCode, out floatingWindow))
{
// not existing yet
floatingWindow = new FloatingWindow()
{
Title = windowTitle ?? string.Empty,
};
switch (windowType)
{
case WindowType.Floating:
if (FloatingWindowStyle != null)
floatingWindow.Style = FloatingWindowStyle;
break;
case WindowType.DesignTimeFloating:
if (DesignTimeWindowStyle != null)
floatingWindow.Style = DesignTimeWindowStyle;
else if (FloatingWindowStyle != null) // fallback to FloatingWindowStyle
floatingWindow.Style = FloatingWindowStyle;
break;
}
floatingWindow.Closed += (o, e) =>
{
if (onClosedHandler != null)
onClosedHandler.Invoke(o, e);
m_FloatingWindows.Remove(hashCode);
if (floatingWindow != null)
floatingWindow.Content = null;
};
if (onClosingHandler != null)
floatingWindow.Closing += onClosingHandler;
floatingWindow.Content = windowContents;
m_FloatingWindows.Add(hashCode, floatingWindow);
}
if (top != null)
floatingWindow.VerticalOffset = (double)top;
if (left != null)
floatingWindow.HorizontalOffset = (double)left;
floatingWindow.Show(isModal);
return floatingWindow;
}
public void OpenBugGUI()
{
_windowType = WindowType.BugWindow;
_popUpError = true;
if (GuiAllowScreenshot)
_takeScreenshot = true;
}
public IceTabPageDCCFile(WindowType windowType, string sCaption, FormMain parent)
: base(windowType, sCaption, parent)
{
InitializeComponent();
this._parent = parent;
dccFiles = new List<DccFileStruct>();
}
/**
* Returns window value for a given window type, size and position.
*
* Window is first looked up in cache. If it doesn't exist,
* it is generated. The cached value is then returned.
*
* @param type window function type
* @param n sample position in the window
* @param N window length
* @return window value for n-th sample
*/
public static double Apply(WindowType type, int n, int N)
{
KeyValuePair<WindowType, int> key = new KeyValuePair<WindowType, int>(type, N);
if (!windowsCache.ContainsKey(key))
CreateWindow(key);
return windowsCache[key][n];
}
public static float[] MakeLowPassKernel(double sampleRate, int filterOrder, double cutoffFrequency, WindowType windowType)
{
filterOrder |= 1;
float[] numArray = FilterBuilder.MakeSinc(sampleRate, cutoffFrequency, filterOrder);
float[] window = FilterBuilder.MakeWindow(windowType, filterOrder);
FilterBuilder.ApplyWindow(numArray, window);
FilterBuilder.Normalize(numArray);
return numArray;
}
public Window(Context ctx, WindowType type = WindowType.SCREEN_APPLICATION_WINDOW)
{
_context = ctx;
if (type == WindowType.SCREEN_APPLICATION_WINDOW)
this.CreateWindow();
else
this.CreateWindowType(type);
}
private RacerDetails(WindowType type)
{
InitializeComponent();
_type = type;
foreach(string rClass in DataManager.Settings.Classes)
{
cboClass.Items.Add(rClass);
}
}
public Window(int width, int height, string title, WindowType type, int display, bool visible)
{
NativeWindow = new NativeWindow(width, height, title, GameWindowFlags.Default, GraphicsMode.Default, DisplayDevice.GetDisplay((DisplayIndex)display));
NativeWindow.Closing += WindowClosing;
NativeWindow.Resize += WindowResize;
Keyboard = new Keyboard(this);
Mouse = new Mouse(this);
Type = type;
Visible = visible;
}
public static float[] MakeBandPassKernel(double sampleRate, int filterOrder, double cutoff1, double cutoff2, WindowType windowType)
{
double cutoffFrequency = (cutoff2 - cutoff1) / 2.0;
double num1 = 2.0 * Math.PI * (cutoff2 - cutoffFrequency) / sampleRate;
float[] numArray = FilterBuilder.MakeLowPassKernel(sampleRate, filterOrder, cutoffFrequency, windowType);
for (int index = 0; index < numArray.Length; ++index)
{
int num2 = index - filterOrder / 2;
numArray[index] *= (float) (2.0 * Math.Cos(num1 * (double) num2));
}
return numArray;
}
public static float[] MakeLowPassKernel(double sampleRate, int filterOrder, double cutoffFrequency, WindowType windowType)
{
filterOrder |= 1;
var h = MakeSinc(sampleRate, cutoffFrequency, filterOrder);
var w = MakeWindow(windowType, filterOrder);
ApplyWindow(h, w);
Normalize(h);
return h;
}
private void ToolWindow_DockStateChanged(object sender, EventArgs e)
{
if (DockState == DockState.Document)
{
this.TabPageContextMenuStrip = DocumentContextMenu;
windowType = WindowType.Document;
}
else
{
this.TabPageContextMenuStrip = ToolWindowContextMenu;
windowType = WindowType.Tool;
}
}
public static Complex[] MakeComplexKernel(double sampleRate, int filterOrder, double bandwidth, double offset, WindowType windowType)
{
double num1 = 2.0 * Math.PI * offset / sampleRate;
float[] numArray = FilterBuilder.MakeLowPassKernel(sampleRate, filterOrder, bandwidth * 0.5, windowType);
Complex[] complexArray = new Complex[numArray.Length];
for (int index = 0; index < complexArray.Length; ++index)
{
int num2 = index - filterOrder / 2;
double num3 = num1 * (double) num2;
complexArray[index].Real = numArray[index] * (float) Math.Cos(num3);
complexArray[index].Imag = (float) (-(double) numArray[index] * Math.Sin(num3));
}
return complexArray;
}
public static void sendTo(Expr expr, Image image, WindowType windowType)
{
copyToClipBoard(expr, image);
if (windowType == WindowType.WindowTypeQQ) {
Process qqProcess = Process.GetProcessesByName("QQ").FirstOrDefault();
if (qqProcess != null)
{
IntPtr qqHandle = qqProcess.MainWindowHandle;
Console.Out.WriteLine(qqProcess.ProcessName);
SetForegroundWindow(qqHandle);
SendKeys.SendWait("^V");
}
else
{
MessageBox.Show("找不到QQ窗口", "发送失败", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else if (windowType == WindowType.WindowTypeWeChat)
{
Process weChatProcess = Process.GetProcessesByName("WeChat").FirstOrDefault();
if (weChatProcess != null)
{
IntPtr weChatHandle = weChatProcess.MainWindowHandle;
Console.Out.WriteLine(weChatProcess.ProcessName);
SetForegroundWindow(weChatHandle);
SendKeys.SendWait("^V");
}
else
{
MessageBox.Show("找不到微信窗口", "发送失败", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Update recently used exprs
List<Expr> recentlyUsedExprs = SettingUtility.getRecentlyUsedExprs();
for (int i = 0; i < recentlyUsedExprs.Count; i++)
{
if (recentlyUsedExprs[i].id == expr.id)
{
recentlyUsedExprs.Remove(recentlyUsedExprs[i]);
}
}
recentlyUsedExprs.Insert(0, expr);
SettingUtility.setRecentlyUsedExprs(recentlyUsedExprs);
if (SettingUtility.exprsDisplayer != null)
{
SettingUtility.exprsDisplayer.loadRecentlyUsedExprs();
}
}
byte type; //This holds type information, used in deciding which kind of window we need to send.
#endregion Fields
#region Constructors
public Windows(WindowType type, Point3 pos, World world, Player p)
{
try
{
id = FreeId();
this.type = (byte)type;
this.p = p;
switch (Type)
{
case WindowType.Chest:
name = "Chest"; //We change this to "Large Chest" Later if it needs it :3
container = world.GetBlockContainer(pos);
items = container.Items;
container.AddPlayer(p);
break;
case WindowType.Dispenser:
name = "Workbench";
//container = world.GetBlockContainer(pos); // We don't have a container for this yet.
items = new Item[9];
break;
case WindowType.Furnace:
name = "Furnace";
//container = world.GetBlockContainer(pos); // We don't have a container for this yet.
items = new Item[3];
break;
case WindowType.Workbench:
name = "Dispenser";
items = new Item[10];
break;
case WindowType.EnchantmentTable:
name = "Enchant";
items = new Item[1];
break;
case WindowType.BrewingStand:
name = "Brewing Stand";
//container = world.GetBlockContainer(pos); // We don't have a container for this yet.
items = new Item[4];
break;
}
if (Type == WindowType.Workbench || Type == WindowType.EnchantmentTable)
{
for (int i = 0; i < InventorySize; i++)
items[i] = Item.Nothing;
}
}
catch { Logger.Log("Error making window!"); }
}
//public Window () : this (Context.GetInstance (ContextType.Application)) {}
//public Window (WindowType type) : this (Context.GetInstance (ContextType.Application), type) {}
public Window(Context ctx, WindowType type = WindowType.SCREEN_APPLICATION_WINDOW)
{
context = ctx;
if (screen_create_window_type (out handle, ctx.Handle, type) != 0) {
throw new Exception ("Unable to create window");
}
if (type != WindowType.SCREEN_APPLICATION_WINDOW &&
type != WindowType.SCREEN_CHILD_WINDOW) {
return;
}
if (screen_create_window_group (handle, handle.ToString ()) != 0) {
throw new Exception ("Unable to create window group");
}
context.RegisterWindow (this);
}
public static float[] MakeBandPassKernel(double sampleRate, int filterOrder, double cutoff1, double cutoff2, WindowType windowType)
{
var bw = (cutoff2 - cutoff1) / 2;
var fshift = cutoff2 - bw;
var shiftRadians = 2 * Math.PI * fshift / sampleRate;
var h = MakeLowPassKernel(sampleRate, filterOrder, bw, windowType);
for (var i = 0; i < h.Length; i++)
{
var n = i - filterOrder / 2;
h[i] *= (float) (2 * Math.Cos(shiftRadians * n));
}
return h;
}
public void OpenConfirmWindow(
WindowType type,
string text,
bool reset,
string buttonCmd)
{
MainContent.Visible = false;
confirmWindowSwitch.Visible = true;
confirmTitle.InnerText = type.ToString();
confirmText.InnerHtml = text;
switch (type)
{
case (WindowType.Confirm):
{
closeConfirmWindowButton.Text = "Cancel";
confirm.CommandArgument = buttonCmd;
}
break;
case (WindowType.Error):
{
if (buttonCmd == string.Empty)
{
confirm.Visible = false;
break;
}
closeConfirmWindowButton.Text = "Cancel";
confirm.CommandArgument = buttonCmd;
}
break;
default:
{
confirm.Visible = false;
}
break;
}
if (!reset) return;
closeConfirmWindowButton.CommandArgument = true.ToString();
}
public static IFirFilter CalcLinearBPFCoefficient(FirFilterType type, double w, double w0, int taps, WindowType window)
{
double[] coef;
if(taps % 2 == 1)
{
coef = new double[(taps + 1) / 2];
CalcOddLinearBPFCoefficient(type, coef, w, w0, GetWindow(window, taps));
return new OddLinearFir(coef);
}
else
{
coef = new double[taps / 2];
CalcEvenLinearBPFCoefficient(type, coef, w, w0, GetWindow(window, taps));
return new EvenLinearFir(coef);
}
}
public static double[] getWindow(WindowType type, int length)
{
switch (type)
{
case WindowType.BLACKMAN:
return getBlackmanWindow(length);
case WindowType.COSINE:
return getCosineWindow(length);
case WindowType.HAMMING:
return getHammingWindow(length);
case WindowType.HANNING:
return getHanningWindow(length);
case WindowType.NONE:
default:
return getRectangularWindow(length);
}
}
public static GameObject CreateWindowOfType(WindowType windowType)
{
GameObject windowGameObj;
switch (windowType)
{
case WindowType.PauseWindow:
windowGameObj = Resources.Load<GameObject>("PauseMenu");
break;
default:
windowGameObj = null;
Debug.Log("Error loading window resources.");
break;
}
return windowGameObj;
}
public static string GetWindowTypeName(WindowType windowType)
{
string windowTypeName;
switch(windowType)
{
case WindowType.PauseWindow:
windowTypeName = "PauseWindow";
break;
default:
Debug.Log("Error Renaming Window.");
windowTypeName = "";
break;
}
return windowTypeName;
}
private double[] CalculateFrequencyCentroid(WindowType windowType, int frameLength, double overlap)
{
var binWidth = sampleRate / frameLength;
var data = ForEachFrame(windowType, frameLength, overlap, (double[] sample, int idx) => {
sample = sample.Take(frameLength / 2).ToArray();
double limiter = 0;
for (int i = 0; i < sample.Length; i++)
{
limiter += i * binWidth * sample[i];
}
var denominator = sample.Sum();
return(limiter / denominator);
});
return(data);
}
public override void Execute(object parameter)
{
if (_mapBehaviorsList == null)
{
_mapBehaviorsList = new MapBehaviorsList()
{
Margin = new Thickness(10, 15, 10, 5)
};
}
_mapBehaviorsList.IsEdit = IsEdit;
WindowType windowType = MapApplication.Current.IsEditMode ? WindowType.DesignTimeFloating :
WindowType.Floating;
MapApplication.Current.ShowWindow(LocalizableStrings.GetString("MapBehaviors"), _mapBehaviorsList, false, null,
(sender, e) =>
{
_mapBehaviorsList = null;
}, windowType);
}
/// <summary>
/// Compute Fast Fourier Transform of (complex) data, in place.
/// </summary>
public static void transform(decimal[] data)
{
switch (Window)
{
case WindowType.Normal:
Window = WindowType.Hamming;
break;
case WindowType.Hamming:
Window = WindowType.Hanning;
Hamming(data);
break;
case WindowType.Hanning:
Window = WindowType.Normal;
Hann(data);
break;
}
transform_internal(data, -1);
}
private void PrepareWindow(int windowSize, WindowType windowType)
{
mWindowType = windowType;
switch (windowType)
{
case WindowType.Bartlett:
mWindow = WWWindowFunc.BartlettWindow(mProcessBlockSize + 1);
break;
case WindowType.Hann:
mWindow = WWWindowFunc.HannWindow(mProcessBlockSize + 1);
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
}
/**
* Converts one of the WindowType enumeration values to its name.
*
* @param type window type as an enum
* @return window function name
*/
public static string WindowTypeToString(WindowType type)
{
switch (type)
{
case WindowType.WIN_RECT:
return "Rectangular";
case WindowType.WIN_HAMMING:
return "Hamming";
case WindowType.WIN_HANN:
return "Hann";
case WindowType.WIN_BLACKMAN:
return "Blackman";
case WindowType.WIN_BARLETT:
return "Barlett";
case WindowType.WIN_FLATTOP:
return "Flat-top";
}
return "Unknown";
}
public void PlotSpectogram(PlotView view, WindowType windowType, int frameLength, double overlap)
{
var span = (int)Math.Round(frameLength * (1.0 - overlap));
int columns = waveList.Count / span;
var data = new double[columns, frameLength / 2];
for (int i = 0, beginPoint = 0; i < columns; i++, beginPoint += span)
{
var sample = GetSample(frameLength, beginPoint);
var fft = new FFTWrapper(sample);
var result = fft.CalculateMagnitude(windowType);
for (int y = 0; y < frameLength / 2; y++)
{
data[i, y] = 20 * Math.Log10(result[y]);
}
}
FillSpectogram(view, data);
}
//切换公共窗口
public void SwitchingPublicWindow(WindowType type)
{
m_curWindowType = type;
iTalkToWorldID = 0;
m_buttonsDict.ApplyAllItem(p => {
if (p.Key == type)
{
//更新按钮状态
p.Value.SetBoxCollider(false);
p.Value.SetSwith(2);
//更新面板显示
if (!m_windowDict.ContainsKey(type))
{
//初始化
InitPublicWindow(type, ChatRecordManager.Instance.GetPublicChatRecordList(type));
}
m_windowDict[type].Show();
}
else
{
p.Value.SetBoxCollider(true);
p.Value.SetSwith(1);
if (m_windowDict.ContainsKey(p.Key))
{
m_windowDict[p.Key].Close();
}
}
});
//界面功能
// bool isWorldWindow = type == WindowType.World;
// if(isWorldWindow)
// {
// int itemNum = ContainerInfomanager.Instance.GetItemNumber(CommonDefineManager.Instance.CommonDefine.WorldChatItem);
// Label_SpeakerNum.text = itemNum.ToString();
// Label_SpeakerNum.color = itemNum>0?new Color(1f,0.98f,0.435f):Color.red;
// }
//Speaker.SetActive(isWorldWindow);
Button_Send.gameObject.SetActive(type != WindowType.System);
Input_Chat.gameObject.SetActive(type != WindowType.System);
}
public DropDownBoxListWindow(IListDataProvider provider, WindowType windowType) : base(windowType)
{
Accessible.Name = "DropDownBoxListWindow";
this.DataProvider = provider;
this.TransientFor = IdeApp.Workbench.RootWindow;
this.TypeHint = Gdk.WindowTypeHint.DropdownMenu;
this.Decorated = false;
this.BorderWidth = 1;
list = new ListWidget(this);
list.Accessible.Name = "DropDownBoxListWindow.List";
list.SelectItem += delegate {
var sel = list.Selection;
if (sel >= 0 && sel < DataProvider.IconCount)
{
try {
DataProvider.ActivateItem(sel);
// This is so parent window of dropdown regains focus
TransientFor?.Present();
} catch (Exception ex) {
LoggingService.LogInternalError("Offset seems to be out of sync with the snapshot.", ex);
}
Destroy();
}
};
SetSizeRequest(list.WidthRequest + WidthModifier, list.HeightRequest);
vScrollbar = new ScrolledWindow();
vScrollbar.VScrollbar.SizeAllocated += (o, args) => {
var minWidth = list.WidthRequest + args.Allocation.Width;
if (this.Allocation.Width < minWidth)
{
SetSizeRequest(minWidth, list.HeightRequest);
}
};
vScrollbar.Child = list;
var vbox = new VBox();
vbox.PackStart(vScrollbar, true, true, 0);
Add(vbox);
}
public BookViewModel(WindowType type, Book book)
{
Locations = new ObservableCollection <string>();
Locations.Add("Jaworzno");
Locations.Add("Miedźno");
AddEditCommand = new RelayCommand(AddEditCommandExecute);
CancelCommand = new RelayCommand(CancelCommandExecute);
if (type == Models.WindowType.NewRecord)
{
Book = new Book();
WindowType = "Nowa książka";
Book.OwnershipDate = DateTime.Now;
Book.Location = "Jaworzno";
}
else
{
WindowType = "Edycja książki";
Book = book;
}
}
public async Task OpenConfiguration(
DataProvider dataProvider, byte selectedTabIndex = 0,
WindowType hostIdentifier = WindowType.Root)
{
try
{
var viewModel = new ConfigViewModel(dataProvider)
{
SelectedTabIndex = selectedTabIndex
};
var view = new ConfigDialog {
ViewModel = viewModel
};
await DialogHost.Show(view, Common.GetEnumDescription(hostIdentifier));
}
catch (Exception e)
{
}
}
public static WindowFunction GetWindow(WindowType type, int order)
{
switch (type)
{
case WindowType.Hamming:
return(new WindowFunction(new Window.Hamming(order).Get));
case WindowType.Hanning:
return(new WindowFunction(new Window.Hanning(order).Get));
case WindowType.Blackman:
return(new WindowFunction(new Window.Blackman(order).Get));
case WindowType.Keiser:
return(new WindowFunction(new Window.Keiser(order, 20).Get));
default:
return(new WindowFunction(Constant1));
}
}
public MainWindow()
{
InitializeComponent();
Library.Init();
_browser = new EyeTrackerBrowser();
_browser.EyeTrackerFound += _browser_EyetrackerFound;
_browser.EyeTrackerRemoved += _browser_EyetrackerRemoved;
_browser.EyeTrackerUpdated += _browser_EyetrackerUpdated;
MapControll.ZoneHaveChanged += MapControll_ZoneHaveChanged;
_initialHeadPos = new Point3D(0, 0, 0);
_headPos = new Point3D(0, 0, 0);
windowType = WindowType.Map;
}
//Main Function
public Window CreateWindow(WindowType type, string openParam, object closeParam, Window.VoidHandle openHandle)
{
Window wnd = WindowManager.instance.FindWindow(type);
if (wnd != null)
{
wnd.show = true;
if (openHandle != null)
{
openHandle();
}
wnd.Show();
}
else
{
wnd = UIHelper.CreateWindow(type, openParam, closeParam, openHandle);
}
return(wnd);
}
private bool InitWindow <T>(WindowType type, T data = default, string message = null, Action noCallBack = null,
Action yesCallBack = null)
{
// UpdateContainer();
var path = string.Format(PathUtils.windowPath, type.ToString().ToLower());
BaseWindow windowPrefab = Resources.Load <BaseWindow>(path);
BaseWindow window = Instantiate(windowPrefab, uiMainCanvas);
windowList.Add(window.type, window);
if (window != null)
{
BaseWindowGeneric <T> _window = window as BaseWindowGeneric <T>;
_window.SetupData(data, message, noCallBack, yesCallBack);
_window.transform.SetAsLastSibling();
_window.OnShow();
return(true);
}
return(false);
}
public IEnumerator CreateWindowsAnyn(WindowType type, bool isResource = false)
{
if (!goPool.ContainsKey(type))
{
if (!isResource)
{
var assetbundleReq = AssetBundleManager.Instance.LoadAssetAsynCoro <GameObject>(WindowPrefabPath, type.ToString());
yield return(assetbundleReq);
goPool.Add(type, assetbundleReq.asset as GameObject);
}
else
{
var req = Resources.LoadAsync <GameObject>(WindowPrefabPath + "/" + type.ToString());
yield return(req);
goPool.Add(type, req.asset as GameObject);
}
}
}
public CompletionListWindow(WindowType type = WindowType.Popup) : base(type)
{
if (IdeApp.Workbench != null)
{
this.TransientFor = IdeApp.Workbench.RootWindow;
}
TypeHint = Gdk.WindowTypeHint.Combo;
SizeAllocated += new SizeAllocatedHandler(ListSizeChanged);
Events = Gdk.EventMask.PropertyChangeMask;
WindowTransparencyDecorator.Attach(this);
DataProvider = this;
HideDeclarationView();
List.ListScrolled += (object sender, EventArgs e) => {
HideDeclarationView();
UpdateDeclarationView();
};
List.WordsFiltered += delegate {
RepositionDeclarationViewWindow();
};
}
/* STFTCalculator initialization
* + LAYOUT:
* - Initialize the first few parameters necessary to calculate FFT
* - Check for validity of frequency range for LBP calculation
* - Generate frequency vector
* - Generate taper window
* - Initialize LBP alarm level array
* - Configure saving options
* + INPUT:
* - Fs: sampling frequency
* - n_epoch: number of data points to calculate FFT
* - n_skip: number of data points skipped between different FFT calculated epochs
* - n_lvls: number of alarm levels
* - BPFR: range of frequency band to calculate power as LBP
* - win_type: type of taper to use; [default]`WindowType.Rectangle` means no taper
* - scaling_psd: option to scale power spectral density, [default]"true"
* - file_prefix: prefix of file to save STFT calculation to, [default]"" (empty)
* - saving_option: option to save the STFT calculation to, [default]"false" for performance
* with the current implementation to save the file to
*/
public STFTCalculator(double Fs, int n_epoch, int n_skip, int n_lvls, double[] BPFR,
WindowType win_type = WindowType.Rectangle, bool scaling_psd = true,
string file_prefix = "", bool saving_option = false)
{
Configure_STFT_Parameters(Fs, n_epoch, n_skip);
current_count = 0;
ready2plt = false;
data_array = new double[n_epoch];
Configure_Frequency_Range(BPFR);
GenerateFrequencyVector();
GenerateWindow(win_type, scaling_psd);
this.n_lvls = n_lvls;
Reset_Level_Tally();
this.saving_option = saving_option;
Configure_Saving_Options(file_prefix);
}
public virtual Window Show(object viewModel, WindowType windowType, Window?owner = null)
{
if (viewModel is null)
{
throw new ArgumentNullException(nameof(viewModel));
}
Window window = GetWindow(viewModel, owner);
if (windowType == WindowType.Dialog)
{
window.ShowDialog();
}
else
{
window.Show();
}
return(window);
}
public WindowUIMenu(WindowImage wimg, WindowType wtype, List <string> wbuttons, string wtitle, string werror, bool wexit, int id, ExitDefault ex)
{
//GameObject unityHook = GameObject.Find("WindowUI");
uh = Resources.FindObjectsOfTypeAll <UnityHook>()[0];
// uh = (UnityHook) unityHook.GetComponent(typeof(UnityHook));
wum = new WindowUIManager(uh);
windowUI = uh.windowUI;
uh.activeMenu = this;
img = wimg;
type = wtype;
buttons = wbuttons;
title = wtitle;
error = werror;
exit = wexit;
this.ex = ex;
this.id = id;
this.background = false;
}
public void CloseWindow(WindowID windowID)
{
BaseWindow window = mAllWindows[windowID];
if (window == null)
{
return;
}
WindowType type = window.Type;
window.Close();
List <BaseWindow> list = null;
mOpenWindows.TryGetValue(type, out list);
if (list != null)
{
list.Remove(window);
}
DealWindowStack(window, false);
}
public object ShowWindow(string windowTitle, FrameworkElement windowContents, bool isModal = false,
EventHandler <System.ComponentModel.CancelEventArgs> onHidingHandler = null,
EventHandler onHideHandler = null, WindowType windowType = WindowType.Floating,
double?top = null, double?left = null)
{
if (WindowManager == null)
{
WindowManager = new ESRI.ArcGIS.Mapping.Controls.WindowManager()
{
FloatingWindowStyle = Application.Current.Resources["BuilderWindowStyle"] as Style
}
}
;
else if (WindowManager.FloatingWindowStyle == null)
{
WindowManager.FloatingWindowStyle = Application.Current.Resources["BuilderWindowStyle"] as Style;
}
return(WindowManager.ShowWindow(windowTitle, windowContents, isModal, onHidingHandler, onHideHandler,
windowType, top, left));
}
public WindowComponent SwitchWindow(WindowType type)
{
WindowComponent desiredWindow = FindWindowOfType(type);
if (desiredWindow != null)
{
if (desiredWindow.gameObject.activeInHierarchy)
{
desiredWindow.CloseWindow();
return(null);
}
else
{
CloseWindows();
desiredWindow.gameObject.SetActive(true);
return(desiredWindow);
}
}
return(null);
}
public AddEditGroup(WindowType windowType, IGroupsRepository groups)
{
InitializeComponent();
groupsRepository = groups;
// Initialize and data-bind to ViewModel
AddEditGroupViewModel = new AddEditGroupViewModel(groups);
this.DataContext = AddEditGroupViewModel;
// Set UI title
if (windowType == WindowType.AddGroup)
{
this.Title = "Add Group";
}
else if (windowType == WindowType.EditGroup)
{
this.Title = "Edit Group";
}
}
public static double[] ApplyLowFilter(double[] source, double fc, int N, WindowType window)
{
var result = new double[source.Length];
var w = GenerateWeights(window, N);
var h = GenerateH(fc, N);
for (int k = 0; k < source.Length; k++)
{
int windowN = N;
if (k + 1 < N)
{
windowN = k + 1;
}
for (int m = 0; m < windowN; m++)
{
result[k] += w[m] * source[k - m] * h[m];
}
}
return(result);
}
private IWindow GetWindowByType(WindowType type)
{
switch (type)
{
case WindowType.BarometricPressureHistory:
return(_windowFactory.CreateBarPressureHistory());
case WindowType.TemperatureHistory:
return(_windowFactory.CreateTemperatureHistory());
case WindowType.UnitSettings:
return(_windowFactory.CreateUnitSettingsWindow());
case WindowType.MainWindow:
return(_windowFactory.CreateMainWindow());
case WindowType.DateAndTimeSettings:
return(_windowFactory.CreateDateAndTimeSettingsWindow());
}
throw new NotSupportedException();
}
/// <summary>
/// <para>Computes the power spectrum of input time-domain signal.</para>
/// <para>Chinese Simplified: 计算输入信号的功率频谱。</para>
/// </summary>
/// <param name="x">
/// <para>input time-domain signal.</para>
/// <para>Chinese Simplified: 输入的时域波形。</para>
/// </param>
/// <param name="samplingRate">
/// <para>sampling rate of the input time-domain signal, in samples per second.</para>
/// <para>Chinese Simplified: 输入信号的采样率，以S/s为单位。</para>
/// </param>
/// <param name="spectrum">
/// <para>output sequence containing the power spectrum.</para>
/// <para>Chinese Simplified: 输出功率谱。</para>
/// </param>
/// <param name="df">
/// <para>the frequency resolution of the spectrum, in hertz.</para>
/// <para>Chinese Simplified: 功率谱的频谱间隔，以Hz为单位。</para>
/// </param>
/// <param name="unitSettings">
/// <para>unit settings of the output power spectrum</para>
/// <para>Chinese Simplified: 设置功率谱的单位。</para>
/// </param>
/// <param name="windowType">
/// <para>the time-domain window to apply to the time signal.</para>
/// <para>Chinese Simplified: 窗类型。</para>
/// </param>
/// <param name="windowPara">
/// <para>parameter for a Kaiser/Gaussian/Dolph-Chebyshev window, If window is any other window, this parameter is ignored</para>
/// <para>Chinese Simplified: 窗调整系数，仅用于Kaiser/Gaussian/Dolph-Chebyshev窗。</para>
/// </param>
public static void PowerSpectrum(double[] x, double samplingRate, ref double[] spectrum, out double df,
UnitConvSetting unitSettings, WindowType windowType, double windowPara)
{
int spectralLines = spectrum.Length; //谱线数是输出数组的大小
SpectralInfo spectralInfo = new SpectralInfo();
AdvanceRealFFT(x, spectralLines, windowType, spectrum, ref spectralInfo);
double scale = 1.0 / spectralInfo.FFTSize;
//CBLASNative.cblas_dscal(spectralLines, scale, spectrum, 1);
for (int i = 0; i < spectrum.Length; i++)
{
spectrum[i] = spectrum[i] * scale;
}
df = 0.5 * samplingRate / spectralInfo.spectralLines; //计算频率间隔
//Unit Conversion
UnitConversion(spectrum, df, SpectrumType.Amplitude, unitSettings, Window.WindowENBWFactor[(int)windowType]);
}
void MainMenuUIClick(MouseEvent mouseEvent)
{
CameraController cameraController = Camera.main.GetComponent <CameraController>();
if (mouseEvent.srcElement.className.Contains("CloseMenu"))
{
UI.document.getElementsByClassName("menu")[0].innerHTML = "";
selectedWindowType = WindowType.None;
}
else if (mouseEvent.srcElement.className.Contains("GoToMainMenu"))
{
UI.document.Run("CreateLoadingScreen", "Leave");
PhotonNetwork.Disconnect();
PhotonNetwork.LoadLevel("Levels/menu");
}
else if (mouseEvent.srcElement.className.Contains("CloseTheGame"))
{
Application.Quit();
return;
}
}
public void OpenWindow(WindowType windowType)
{
GameObject window = GetWindowByWindowType(windowType);
if (window == null)
{
Debug.LogError("Открыть Window не удалось. Ресурс не найден.");
}
else
{
GameObject.Instantiate(window, canvas.transform);
// ----------------------------------- Чтобы открывалось только одно окно
//if (curOpenWindow != null)
//{
// GameObject.Destroy(curOpenWindow);
// Resources.UnloadUnusedAssets();
//}
//curOpenWindow = GameObject.Instantiate(window, canvas.transform);
}
}
public bool ShowWindowWithNoData(WindowType type, string _message = null, Action noCallBack = null,
Action yesCallBack = null)
{
if (windowList.ContainsKey(type))
{
BaseWindow window = windowList[type];
if (window != null)
{
window.SetupData(_message, noCallBack, yesCallBack);
window.transform.SetAsLastSibling();
window.OnShow();
return(true);
}
return(false);
}
bool check = InitWindow(type, _message, noCallBack, yesCallBack);
return(check);
}
/// <summary>
/// Finds the moving median sequence from the sequence of values
/// and the specified non-negative window width. The tail values
/// (such that there is not enough data in the window around them
/// get handled using <see cref="TailValuesHandling"/> flag passed).
/// </summary>
/// <typeparam name="T">The type of elements in the sequence.</typeparam>
/// <typeparam name="C">The numeric calculator for the <typeparamref name="T"/> type.</typeparam>
/// <param name="values">The sequence of values.</param>
/// <param name="windowWidth">
/// A non-negative window width applied to both sides of the current value.
/// It means that, e.g. when the window width is 1, the window will consist
/// of three values: the current value, one value to the left and one value to the right.
/// </param>
/// <param name="windowType">
/// The type of the window for calculation of the median.
/// See <see cref="WindowType"/>
/// </param>
/// <param name="tailValuesHandling">
/// A flag specifying how the tail values should be handled
/// (such that there is not enough data in the window around them).
/// See <see cref="TailValuesHandling"/>.
/// </param>
/// <returns>A sequence of moving medians calculated from the source sequence.</returns>
public static List <T> MovingMedian <T, C>(
this IList <T> values,
int windowWidth,
WindowType windowType = WindowType.Symmetric,
TailValuesHandling tailValuesHandling = TailValuesHandling.UseSymmetricAvailableWindow)
where C : ICalc <T>, new()
{
Contract.Requires <ArgumentNullException>(values != null, "values");
Contract.Requires <ArgumentOutOfRangeException>(windowWidth >= 0, "The window width should be non-negative");
Contract.Requires <ArgumentException>(
tailValuesHandling != TailValuesHandling.UseSymmetricAvailableWindow ||
windowType == WindowType.Symmetric,
"Symmetric tail values handling is only available for symmetric windows.");
return(MovingStatistic <T, C>(
values,
windowWidth,
windowType,
tailValuesHandling,
StatisticExtensionMethods.SampleAverage <T, C>));
}
private void WindowTypeChanger(WindowType type)
{
WinType = type;
Refresher();
switch (type)
{
case WindowType.Load:
checkBox1.Visible = true;
this.Name = "Загрузить";
this.Text = "Загрузить";
button1.Text = "Загрузить в файл";
break;
case WindowType.Save:
checkBox1.Visible = false;
button1.Text = "Сохранить в файл";
this.Name = "Сохранить";
this.Text = "Сохранить";
break;
}
}
private void WindowVisibility(WindowType windowType)
{
switch (windowType)
{
case WindowType.RegisterWindow:
LoginWindowVisibility = Visibility.Collapsed;
RegisterWindowVisibility = Visibility.Visible;
break;
case WindowType.ChangePasswordWindow:
LoginWindowVisibility = Visibility.Collapsed;
ChangePasswordWindowVisibility = Visibility.Visible;
break;
default:
RegisterWindowVisibility = Visibility.Collapsed;
ChangePasswordWindowVisibility = Visibility.Collapsed;
LoginWindowVisibility = Visibility.Visible;
break;
}
}
public static double[] getWindow(WindowType type, int length)
{
switch (type)
{
case WindowType.BLACKMAN:
return(getBlackmanWindow(length));
case WindowType.COSINE:
return(getCosineWindow(length));
case WindowType.HAMMING:
return(getHammingWindow(length));
case WindowType.HANNING:
return(getHanningWindow(length));
case WindowType.NONE:
default:
return(getRectangularWindow(length));
}
}
