public BrowseResult Browse(BrowseParams browseParams)
        {
            if(browseParams==null) browseParams = new BrowseParams();

            FileDialog dialog = new OpenFileDialog();
            return OpenDialog(dialog, browseParams);
        }

		public void Merge()
		{
			var openDialog = new OpenFileDialog()
			{
				Filter = "firesec2 files|*.fscp",
				DefaultExt = "firesec2 files|*.fscp"
			};
			if (openDialog.ShowDialog().Value)
			{
				ServiceFactory.Events.GetEvent<ConfigurationClosedEvent>().Publish(null);
				ZipConfigActualizeHelper.Actualize(openDialog.FileName, false);
				var folderName = AppDataFolderHelper.GetLocalFolder("Administrator/MergeConfiguration");
				var configFileName = Path.Combine(folderName, "Config.fscp");
				if (Directory.Exists(folderName))
					Directory.Delete(folderName, true);
				Directory.CreateDirectory(folderName);
				File.Copy(openDialog.FileName, configFileName);
				LoadFromZipFile(configFileName);
				ServiceFactory.ContentService.Invalidate();

				FiresecManager.UpdateConfiguration();

				ServiceFactory.Events.GetEvent<ConfigurationChangedEvent>().Publish(null);
				ServiceFactory.Layout.Close();
				if (ApplicationService.Modules.Any(x => x.Name == "Устройства, Зоны, Направления"))
					ServiceFactory.Events.GetEvent<ShowDeviceEvent>().Publish(Guid.Empty);
				else if (ApplicationService.Modules.Any(x => x.Name == "Групповой контроллер"))
					ServiceFactory.Events.GetEvent<ShowXDeviceEvent>().Publish(Guid.Empty);

				ServiceFactory.SaveService.FSChanged = true;
				ServiceFactory.SaveService.PlansChanged = true;
				ServiceFactory.SaveService.GKChanged = true;
				ServiceFactory.Layout.ShowFooter(null);
			}
		}

        private void OnLoadModule(object sender, System.Windows.RoutedEventArgs e)
        {
            OpenFileDialog dialog = new OpenFileDialog()
            {
                CheckFileExists = true,
                Filter          = "Binary Files (*.bin, *.exe, *.img, *.iso, *.o)|*.bin;*.exe;*.img;*.iso;*.o|"
                                + "All Files (*.*)|*.*|Image Files (*.img, *.iso)|*.img;*.iso|"
                                + "Object Files (*.bin, *.o, *.exe)|*.bin;*.o;*.exe",
                FilterIndex     = 0,
                Title           = "Select Debug Binary",
                Multiselect     = true,
            };
            bool? result = dialog.ShowDialog(this);

            if (result.HasValue && result.Value)
            {
                foreach (string modulePath in dialog.FileNames)
                {
                    try
                    {
                        Loader.LoadImage(modulePath, null);
                    }
                    catch (Exception x)
                    {
                        var msg = String.Format("An error occured and the module '{0}' "
                            + "has not been loaded:\n{1}", modulePath, x.ToString());

                        MessageBox.Show(msg, "Error Loading Module", MessageBoxButton.OK,
                            MessageBoxImage.Error);
                    }
                }
                this.RefreshItems();
            }
        }

        private void NewOutputFormatMenuItem_Click(object sender, RoutedEventArgs e)
        {
            ClearCanvas();

            var newOutputFormatOpenFileDialog = new OpenFileDialog
            {
                Filter = "dll files (*.dll)|*.dll",
                DefaultExt = ".dll",
                Title = "Please select dll file"
            };

            if (newOutputFormatOpenFileDialog.ShowDialog() == true)
            {
                string pathToCopy = Path.Combine(AssemblyPath, @"Printers\",
                    Path.GetFileName(newOutputFormatOpenFileDialog.FileName));

                try
                {
                    File.Copy(newOutputFormatOpenFileDialog.FileName, pathToCopy, true);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                MessageBox.Show("Printer added successfully!", "Information", MessageBoxButton.OK,
                    MessageBoxImage.Information);
            }
        }

        private void BtnImportClick(object sender, RoutedEventArgs e)
        {
            var ofd = new OpenFileDialog
            {
                Filter = "Text files (*.txt)|*.txt"
            };

            var result = ofd.ShowDialog();

            if (result == true)
            {
                if (!File.Exists(ofd.FileName))
                {
                    return;
                }

                var accounts = Utils.GetLogins(ofd.FileName);
                var num = 0;

                foreach (var account in accounts)
                {
                    if (!Checker.Accounts.Exists(a => a.Username == account.Username))
                    {
                        Checker.Accounts.Add(account);
                        num++;
                    }
                }

                this.ShowMessageAsync(
                    "Import", num > 0 ? string.Format("Imported {0} accounts.", num) : "No new accounts found.");

                RefreshAccounts();
                MainWindow.Instance.UpdateControls();
            }
        }

        /// <inheritdoc/>
        public async Task<string> GetImageKeyAsync()
        {
            try
            {
                var dlg = new OpenFileDialog()
                {
                    Filter = "All (*.*)|*.*",
                    FilterIndex = 0,
                    FileName = ""
                };

                if (dlg.ShowDialog(_serviceProvider.GetService<MainWindow>()) == true)
                {
                    var path = dlg.FileName;
                    var bytes = System.IO.File.ReadAllBytes(path);
                    var key = _serviceProvider.GetService<ProjectEditor>().Project.AddImageFromFile(path, bytes);
                    return await Task.Run(() => key);
                }
            }
            catch (Exception ex)
            {
                _serviceProvider.GetService<ILog>().LogError($"{ex.Message}{Environment.NewLine}{ex.StackTrace}");
            }

            return null;
        }

        public override InteriorField[,] GetLayout()
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.DefaultExt = "txt";
            DirectoryInfo currentDir = new DirectoryInfo(Environment.CurrentDirectory);
            openFileDialog.InitialDirectory = (currentDir.EnumerateDirectories().FirstOrDefault(d => d.Name == DataSubdirName) ?? currentDir).FullName;
            if (openFileDialog.ShowDialog().GetValueOrDefault())
            {
                this.LayoutIdentifier = openFileDialog.FileName;
                using (StreamReader readLines = new StreamReader(openFileDialog.OpenFile()))
                {
                    List<List<InteriorField>> layout = readLines
                        .ReadToEnd()
                        .Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
                        .Select(s => s
                            .Select(c => this.CreateField(c)).ToList()).ToList();

                    int columnsCount = layout.Max(l => l.Count);
                    InteriorField[,] result = new InteriorField[layout.Count, columnsCount];
                    for (int row = 0; row < layout.Count; row++)
                    {
                        for (int col = 0; col < layout[row].Count; col++)
                        {
                            result[row, col] = layout[row][col];
                        }
                    }
                    return result;
                }
            }
            else
            {
                return null;
            }
        }

        public static MEFile OpenFile()
        {
            string content = "";
            // Create OpenFileDialog
            OpenFileDialog dlg = new OpenFileDialog();

            // Set filter for file extension and default file extension
            dlg.DefaultExt = ".txt";
            dlg.Filter = TextFileFilter;

            // Display OpenFileDialog by calling ShowDialog method
            bool? result = dlg.ShowDialog();

            // Get the selected file name and display in a TextBox
            if (result == true)
            {
                content = File.ReadAllText(dlg.FileName);
                string FileName = Path.GetFileNameWithoutExtension(dlg.SafeFileName);
                string Extension = Path.GetExtension(dlg.SafeFileName);
                return new MEFile(FileName, Extension, content, dlg.FileName);
            }
            else
            {
                return MEFile.ERROR_ME_FILE;
            }

            throw new NotImplementedException();
        }

        private void btnAdd_Click(object sender, RoutedEventArgs e)
        {
            bool? result = null;

            OpenFileDialog fileDlg = new OpenFileDialog();
            fileDlg.Filter = "Dynamic Linked Libraries|*.dll";
            fileDlg.Title = "Add Plugin Assembly...";
            fileDlg.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            result = fileDlg.ShowDialog(this);

            if (result != null && result == true)
            {
                if (ValidateAndAddAssembly(fileDlg.FileName))
                {
                    // Notify the user of the impending restart
                    MessageBox.Show(this, "The application must now restart to ensure the Plugin is fully functional.", "Plugin Added!", MessageBoxButton.OK, MessageBoxImage.Information);

                    // Restart
                    try
                    {
                        Process.Start(Application.ResourceAssembly.Location);
                        Application.Current.Shutdown();
                    }
                    catch (Exception ex)
                    {
                        PluginManager.log.Error("An exception was thrown while attempting to restart the application as a result of a plugin removal.", ex);
                    }
                }
            }
        }

        public void LoadImage()
        {
            var filedialog = new OpenFileDialog()
            {
                Multiselect = false
            };

            if (filedialog.ShowDialog() == true)
            {
                var temp = File.ReadAllBytes(filedialog.FileName);
                var newtemp = new ushort[0x10000];

                for (int i = 0; i < temp.Length; i++)
                {
                    if (i % 2 == 0)
                    {
                        newtemp[i / 2] |= (ushort)(temp[i] << 8);
                    }
                    else
                    {
                        newtemp[i / 2] |= (ushort)(temp[i]);
                    }
                }

                App.CPU.SetMemory(newtemp);
            }
        }

        private void OpenCommandHandler(object sender, RoutedEventArgs e)
        {
            OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
            dlg.FileName = "Document"; // Default file name
            dlg.DefaultExt = ".txt"; // Default file extension
            dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension

            // Show open file dialog box
            Nullable<bool> result = dlg.ShowDialog();

            // Process open file dialog box results
            if (result == true)
            {
                // Open document
                string filename = dlg.FileName;

                TextRange range;
                FileStream fStream;
                if (File.Exists(filename))
                {
                    tabControl1.SelectedIndex = 1;
                    range = new TextRange(rtb1.Document.ContentStart, rtb1.Document.ContentEnd);
                    fStream = new FileStream(filename, FileMode.OpenOrCreate);
                    range.Load(fStream, DataFormats.Text);
                    fStream.Close();                    
                }
                FormatWholeDocument();
            }
        }

        public void ExecuteOpenFileDialog()
        {
            var dialog = new OpenFileDialog { InitialDirectory = _defaultPath };
            dialog.ShowDialog();

            SelectedPath = dialog.FileName;
        }

        /// <summary>
        /// vykonávacia logika príkazu
        /// </summary>
        /// <param name="parameter">parameter príkazu</param>
        public void Execute(object parameter)
        {
            if (((MainWindowViewModel)parameter).HadProject == true)
            {
                string messageText = "Nemôžu byť otvorené dva projekty súčasne. Vymazať projekt?";
                string messageCaption = "Vymazať projekt";
                MessageBoxResult res = MessageBox.Show(messageText, messageCaption, MessageBoxButton.YesNoCancel, MessageBoxImage.Question, MessageBoxResult.Cancel);
                if (res == MessageBoxResult.Yes)
                {
                    OpenFileDialog dialog = new OpenFileDialog();
                    dialog.Filter = "XML documents (.xml)|*.xml";
                    if (dialog.ShowDialog() == true)
                    {
                        string filename = dialog.FileName;

                        ((MainWindowViewModel)parameter).Load(filename);
                    }
                }

                ((MainWindow)Application.Current.MainWindow).mainFrame.Navigate(new Uri("Views/Pages/WelcomePage.xaml", UriKind.Relative));

            }
            else
            {
                OpenFileDialog dialog = new OpenFileDialog();
                dialog.Filter = "XML documents (.xml)|*.xml";
                if (dialog.ShowDialog() == true)
                {
                    string filename = dialog.FileName;

                    ((MainWindowViewModel)parameter).Load(filename);
                }
                ((MainWindowViewModel)parameter).HadProject = true;
            }
        }

		void Browse()
		{
			var dialog = new OpenFileDialog();
			if (dialog.ShowDialog() ?? false) {
				SvcUtilPath = dialog.FileName;
			}
		}

        private void OpenCommand_Execute(object sender, ExecutedRoutedEventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            if (ofd.ShowDialog() == true)
            {
                ellipses.Clear();

                StreamReader sr = new StreamReader(ofd.FileName);
                while (!sr.EndOfStream)
                {
                    String[] g = sr.ReadLine().Split(' ');
                    Circle circle = new Circle() { R = double.Parse(g[0]), X = double.Parse(g[1]), Y = double.Parse(g[2]) };
                    ellipses.Add(circle);
                }
                sr.Close();

                vd = new VD<Circle, DeloneCircle>(ellipses[0], ellipses[1], null);
                for (int i = 2; i < ellipses.Count; i++)
                    vd.Insert(ellipses[i]);

                if (vd != null)
                    BuildTriples(vd.NextTriple(vd.NullTriple), gg_triples, true);
                else
                    gg_triples.Children.Clear();
                triple = vd.NextTriple(vd.NullTriple);
            }
        }

        public void Run()
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = "Zip Files (*.zip)|*.zip|" + Utility.AllFilesFilter;
            if (openFileDialog.ShowDialog() == true)
            {
                WaitWindow waitWindow = new WaitWindow("Importing collection...");
                waitWindow.ShowDialog(this.ParentWindow, () =>
                {
                    try
                    {
                        using (CollectionImporterBase importer = new ArchivedCollectionImporter(openFileDialog.FileName, this.CollectionManager))
                        {
                            importer.Import();
                        }
                    }
                    catch (Exception ex)
                    {
                        Utility.WriteToErrorLog("Error importing: " + ex.ToString());
                        MessageBox.Show("Error importing backup: " + ex.Message);
                    }

                    this.ParentWindow.Dispatcher.BeginInvokeAction(() =>
                    {
                        CollectionManagerGlobal.OnCollectionChanged();
                    });
                });
            }
        }

        public static string OpenTest(string courseName_copy, string groupName_copy, string testName_copy)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = "TST Files (*.tst) |*.tst";
            Nullable<bool> resultOfDialog = openFileDialog.ShowDialog();
            string resultOfParsing;
            _courseName = courseName_copy;
            _groupName = groupName_copy;
            _testName = testName_copy;

            if (resultOfDialog == true)
            {
                string pathOfTest = openFileDialog.FileName;
                SelectDirectoryPath(pathOfTest);
                try
                {
                    resultOfParsing = TestParser.Instance.ParseTest(pathOfTest, folderPath);
                }
                catch(Exception)
                {
                    resultOfParsing = "Wystąpił problem podczas odczytu plik";
                }

                if(resultOfParsing == "Ok")
                {
                    ZipDirectory(folderPath, fileName);
                    if(IS_OK == true)
                        unzipTest();
                }
                return resultOfParsing;
            }
            return "";
        }

 public string ShowOpenFileDialog()
 {
     var dlg = new OpenFileDialog();
     if (dlg.ShowDialog() == true)
         return dlg.FileName;
     return null;
 }

        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            OpenFileDialog openFileDialog1 = new OpenFileDialog();

            const string initialDirectory = "g:\\temp\\";

            if (Directory.Exists(initialDirectory))
                openFileDialog1.InitialDirectory = initialDirectory;

            openFileDialog1.Filter = "txt files (*.txt)|*.txt|All files (*.*)|*.*";
            openFileDialog1.FilterIndex = 2;
            openFileDialog1.RestoreDirectory = true;

            if (openFileDialog1.ShowDialog() == true)
            {
                var result = LogParser.Parse(openFileDialog1.FileName);
                _battles = LogParser.DivideIntoBattlesAndApplyGuards(result);
                ListBattles.Items.Clear();

                ListBattles.BeginInit();
                foreach (var battle in _battles)
                {
                    ListBattles.Items.Add(battle.ToString());
                }
                ListBattles.EndInit();
            }
        }

        private void AddLanguageFile_OnClick(object sender, RoutedEventArgs e)
        {
            // Configure open file dialog box.
            OpenFileDialog dlg = new OpenFileDialog { DefaultExt = ".txt", Filter = "Language Files (.txt)|*.txt" };

            // Show open file dialog box.
            bool? result = dlg.ShowDialog();

            // Process open file dialog box results 
            if (result != true)
            {
                return;
            }

            // Show language name dialog box.
            TextBoxWindow textboxDlg = new TextBoxWindow();
            result = textboxDlg.ShowDialog("Add Language", "Please enter the name of the language!");

            if (result != true)
            {
                return;
            }

            // Add language file to project.
            ProjectSettings projectSettings = (ProjectSettings)this.DataContext;
            LanguageFile languageFile = new LanguageFile { LanguageTag = textboxDlg.Text, Path = dlg.FileName };
            projectSettings.AddLanguageFile(languageFile);

            // Refresh list.
            this.LanguageFileList.Items.Refresh();
        }