public void ShouldNotMatchBlacklistedDirectory()
{
var filter = new FileFilter { DirectoryBlacklist = new Regex(@"BadDir") };
filter.IsMatch(@"C:\This\Is\A\BadDir").ShouldBeFalse();
filter.IsMatch(@"C:\This\Dir\Is\Ok").ShouldBeTrue();
}
public void ShouldOnlyReturnWhitelistedFilenames()
{
var filter = new FileFilter { FileExtensionWhitelist = new Regex(@"\.(?:cs|resx)") };
var fileNames = this.FileSystem.AllFiles(this.TestDirectoryPath, filter).Select(x => x.Name);
fileNames.ShouldNotContain(x => x.EndsWith(".txt"));
}
public void ShouldIgnoreBlacklistedDirectories()
{
var filter = new FileFilter { DirectoryBlacklist = new Regex(@"Directory1") };
var files = this.FileSystem.AllFiles(this.TestDirectoryPath, filter).Select(x => x.DirectoryName);
files.ShouldNotContain(x => x.Contains(@"\Directory1"));
}
/// <summary>
/// Scans the given directories for files matching the given filters.
/// </summary>
/// <param name="IEnumerator">An enumerator of directories.</param>
/// <param name="SearchPattern">A simple search pattern like "*.jpg".</param>
/// <param name="SearchOption">Include or do not include subdirectories.</param>
/// <param name="FileFilter">A delegate for filtering the found files.</param>
/// <returns>An enumeration of file infos.</returns>
public static IEnumerable<FileInfo> FileFilterPipe(this IEnumerator<String> IEnumerator,
String SearchPattern = "*",
SearchOption SearchOption = SearchOption.TopDirectoryOnly,
FileFilter FileFilter = null)
{
return new FileFilterPipe(SearchPattern, SearchOption, FileFilter, null, IEnumerator);
}
/// <summary>
/// Scans the given directories for files matching the given filters.
/// </summary>
/// <param name="IEnumerable">An enumeration of directories.</param>
/// <param name="SearchPattern">A simple search pattern like "*.jpg".</param>
/// <param name="SearchOption">Include or do not include subdirectories.</param>
/// <param name="FileFilter">A delegate for filtering the found files.</param>
/// <returns>An enumeration of file infos.</returns>
public static IEnumerable<FileInfo> FileFilterPipe(this IEndPipe<String> SourcePipe,
String SearchPattern = "*",
SearchOption SearchOption = SearchOption.TopDirectoryOnly,
FileFilter FileFilter = null)
{
return new FileFilterPipe(SourcePipe, SearchPattern, SearchOption, FileFilter).AsEnumerable();
}
public MainWindow()
: base(WindowType.Toplevel)
{
Build ();
languagebox.Changed += LanguageChanged;
Downloadbutton.Clicked += DownloadSub;
FileChooserD.FileSet += SelectFile;
MovieNodeView.NodeSelection.Changed += OnSelectionChanged;
MovieNodeView.AppendColumn ("Title", new CellRendererText (), "text", 0);
MovieNodeView.AppendColumn ("Year", new CellRendererText (), "text", 1);
MovieNodeView.AppendColumn ("Season", new CellRendererText (), "text", 2);
MovieNodeView.AppendColumn ("Episode", new CellRendererText (), "text", 3);
MovieNodeView.AppendColumn ("Uploader", new CellRendererText (), "text", 4);
MovieNodeView.AppendColumn ("Downloads", new CellRendererText (), "text", 5);
DetailNode.AppendColumn ("", new CellRendererText (), "text", 0);
DetailNode.AppendColumn ("", new CellRendererText (), "text", 1);
MovieNodeView.ShowAll ();
DetailNode.ShowAll ();
//FileChooser stuff
var filt = new FileFilter { Name = "Movies" };
filt.AddMimeType ("video/x-matroska");
filt.AddMimeType ("video/x-msvideo");
filt.AddMimeType ("video/vnd.mpegurl");
filt.AddMimeType ("video/x-m4v");
filt.AddMimeType ("video/mp4");
filt.AddMimeType ("video/quicktime");
filt.AddMimeType ("video/mpeg");
filt.AddMimeType ("video/x-dv");
filt.AddMimeType ("video/x-sgi-movie");
FileChooserD.AddFilter (filt);
var lastfolder = (string)ConfigurationManager.AppSettings["lastfolder"];
if (!String.IsNullOrEmpty(lastfolder)) FileChooserD.SetCurrentFolder(lastfolder);
}
private UploadFileChooserUI()
{
Glade.XML gxml = new Glade.XML (null, "organizer.glade", "filechooserdialog1", null);
gxml.Autoconnect (this);
_job = new ThreadStart(ProcessThumbnail);
_previewthread = new Thread(_job);
label16.WidthRequest = eventbox7.WidthRequest;
eventbox7.ModifyBg(Gtk.StateType.Normal, bgcolor);
eventbox8.ModifyBg(Gtk.StateType.Normal, bgcolor);
eventbox9.ModifyBg(Gtk.StateType.Normal, bgcolor);
filechooserdialog1.Title = "Select files to upload";
filechooserdialog1.SetIconFromFile(DeskFlickrUI.ICON_PATH);
filechooserdialog1.SetFilename(PersistentInformation.GetInstance().UploadFilename);
filechooserdialog1.SelectMultiple = true;
FileFilter imagefilter = new FileFilter();
imagefilter.AddMimeType("image/jpeg");
imagefilter.AddMimeType("image/png");
filechooserdialog1.Filter = imagefilter;
filechooserdialog1.SelectionChanged += new EventHandler(OnFileSelectedChanged);
filechooserdialog1.FileActivated += new EventHandler(OnOpenButtonClicked);
button10.Clicked += new EventHandler(OnOpenButtonClicked);
button11.Clicked += new EventHandler(OnCancelButtonClicked);
DeskFlickrUI.GetInstance().SetUploadWindow(false);
filechooserdialog1.ShowAll();
}
public void ShouldMatchFileExtension()
{
var filter = new FileFilter { FileExtensionWhitelist = new Regex(@"\.txt$") };
filter.IsMatch(@"C:\Dir\File.txt").ShouldBeTrue();
filter.IsMatch(@"C:\Dir\File.cs").ShouldBeFalse();
}
public static FileInfo SaveFile(SaveFileDialog fileDialog, FileFilter filter = null) {
if (filter != null && filter.Count > 0) {
fileDialog.Filter = filter.ToString();
if (filter.SelectedIndex + 1 <= filter.Count)
fileDialog.FilterIndex = filter.SelectedIndex;
}
return fileDialog.ShowDialog() == DialogResult.OK ? new FileInfo(fileDialog.FileName) : null;
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="Other">Filter to copy from</param>
public FileFilter(FileFilter Other)
: this(Other.DefaultNode.Type)
{
foreach (FileFilterNode OtherRule in Other.Rules)
{
AddRule(OtherRule.ToString(), OtherRule.Type);
}
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="Other">Filter to copy from</param>
public FileFilter(FileFilter Other)
: this()
{
foreach (FileFilterNode OtherRule in Other.Rules)
{
AddRule(OtherRule.ToString(), OtherRule.bInclude);
}
}
private void AddFileFilter(FileFilter ff)
{
ListViewItem lvi = new ListViewItem(ff.Name);
lvi.SubItems.Add(ff.Filter);
lvi.SubItems.Add(ff.DefaultExt);
lvi.Tag = ff;
lvFilters.Items.Add(lvi);
}
public FileEnumerator (string path,
FileFilter file_filter,
FileObjectifier file_objectifier)
{
this.path = path;
this.file_filter = file_filter;
this.file_objectifier = file_objectifier;
Reset ();
}
/// <summary>
/// Get the Image filters.
/// </summary>
/// <returns>The Image filters.</returns>
protected FileFilter GetImageFilters()
{
var _filterImage = new FileFilter();
_filterImage.Name = "Image Files";
_filterImage.AddPattern("*.jpg");
_filterImage.AddPattern("*.jpeg");
_filterImage.AddPattern("*.png");
_filterImage.AddPattern("*.bmp");
return _filterImage;
}
public static FilePath[] RecursiveListFiles(FilePath dir, FileFilter filter)
{
if (!dir.IsDirectory())
{
throw new ArgumentException(dir + " is not a directory");
}
IList<FilePath> fileList = new List<FilePath>();
RecursiveListFilesHelper(dir, filter, fileList);
return Sharpen.Collections.ToArray(fileList, new FilePath[fileList.Count]);
}
private Project CreateProject(FullPath rootPath) {
var configurationProvider = _configurationSectionProvider;
var section1 = ConfigurationSectionContents.Create(configurationProvider, ConfigurationSectionNames.SourceExplorerIgnoreObsolete);
var section2 = ConfigurationSectionContents.Create(configurationProvider, ConfigurationSectionNames.SearchableFilesIgnore);
var section3 = ConfigurationSectionContents.Create(configurationProvider, ConfigurationSectionNames.SearchableFilesInclude);
var fileFilter = new FileFilter(section1);
var directoryFilter = new DirectoryFilter(section1);
var searchableFilesFilter = new SearchableFilesFilter(section2, section3);
var hash = MD5Hash.CreateHash(section1.Contents.Concat(section2.Contents).Concat(section3.Contents));
return new Project(rootPath, fileFilter, directoryFilter, searchableFilesFilter, hash);
}
public void ShouldMatchCombinationOfExtensionWhitelistAndDirectoryBlacklist()
{
var filter = new FileFilter
{
DirectoryBlacklist = new Regex(@"BadDir"),
FileExtensionWhitelist = new Regex(@"\.txt$")
};
filter.IsMatch(@"C:\BadDir\file.txt").ShouldBeFalse("Should not match because of directory blacklist");
filter.IsMatch(@"C:\CoolDir\file.txt").ShouldBeTrue();
}
public static FileInfo GetFile(FileFilter filter = null, bool checkFileExists = true, bool restoreDirecory = true, bool MultiSelect = false) {
using (var fd = new OpenFileDialog()) {
fd.RestoreDirectory = restoreDirecory;
fd.CheckFileExists = checkFileExists;
fd.CheckPathExists = checkFileExists;
fd.Multiselect = MultiSelect;
fd.AddExtension = true;
if (filter != null && filter.Count > 0) {
fd.Filter = filter.ToString();
if (filter.SelectedIndex + 1 <= filter.Count)
fd.FilterIndex = filter.SelectedIndex;
}
return fd.ShowDialog() == DialogResult.OK ? new FileInfo(fd.FileName) : null;
}
}
public static FileInfo SaveFile(FileFilter filter = null, bool checkFileExists = false, bool checkPathExists = false, bool restoreDirecory = true, bool PermissionToCreate = false, bool PermissionToOverwrite = true) {
using (var fd = new SaveFileDialog()) {
fd.RestoreDirectory = restoreDirecory;
fd.CheckFileExists = checkFileExists;
fd.CheckPathExists = checkPathExists;
fd.CreatePrompt = PermissionToCreate;
fd.OverwritePrompt = PermissionToOverwrite;
fd.AddExtension = true;
if (filter != null && filter.Count > 0) {
fd.Filter = filter.ToString();
if (filter.SelectedIndex + 1 <= filter.Count)
fd.FilterIndex = filter.SelectedIndex;
}
return fd.ShowDialog() == DialogResult.OK ? new FileInfo(fd.FileName) : null;
}
}
public static void RecursiveListFilesHelper(FilePath dir, FileFilter filter, IList<FilePath> fileList)
{
foreach (FilePath f in dir.ListFiles())
{
if (f.IsDirectory())
{
RecursiveListFilesHelper(f, filter, fileList);
}
else
{
if (filter.Accept(f))
{
fileList.Add(f);
}
}
}
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build();
FileFilter filter = new FileFilter();
filter.Name = "INES rom (*.nes)";
filter.AddMimeType("Ines");
filter.AddPattern("*.nes");
filechooserwidget2.AddFilter(filter);
InitializeColumns();
LoadSettings();
MyNesSDL.Settings.LoadSettings(System.IO.Path.Combine(MainClass.WorkingFolder, "SDLSettings.conf"));
GameGenieFolder = MyNesSDL.Settings.Folder_GameGenieCodes;
StateFolder = MyNesSDL.Settings.Folder_STATE;
SnapsFolder = MyNesSDL.Settings.Folder_SNAPS;
}
private async Task<ICollection<FileSystemEntry>> GetFolderAsync(string path, FileFilter filter = FileFilter.None)
{
var parameters = new Dictionary<string, string>();
if (filter.HasFlag(FileFilter.Image))
{
parameters.Add("p", "1");
}
if (filter.HasFlag(FileFilter.Video))
{
parameters.Add("v", "1");
}
var response = await this.ApiCaller
.RequestAsync<FolderInformation>(HttpMethod.Get, path, parameters)
.ConfigureAwait(false);
return response.Files.Select(r => new FileSystemEntry(path, r)).ToList();
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
//set up the hex finder
FileFilter filter = new FileFilter();
filter.Name = "Intel Hex File (*.hex)";
filter.AddPattern("*.hex");
fileHex.AddFilter(filter);
fileHex.FileSet += HandleFileHexFileSet;
//refresh button
btnHexRefresh.Clicked += HandleFileHexFileSet;
//program button
btnHexProgram.Clicked += HandleBtnHexProgramClicked;
}
protected void OnGenerateButtonReleased(object sender, EventArgs e)
{
var fileChooserDialog = new FileChooserDialog (
"Select a PNG", this,
FileChooserAction.Save,
"Cancel", ResponseType.Cancel,
"Save", ResponseType.Accept);
var fileFilter = new FileFilter ();
fileFilter.Name = "png";
fileFilter.AddMimeType ("image/png");
fileFilter.AddPattern ("*.png");
fileChooserDialog.AddFilter (fileFilter);
if (fileChooserDialog.Run () == (int)ResponseType.Accept) {
string filename = fileChooserDialog.Filename;
bool continueSave = true;
if (System.IO.Path.GetExtension (filename) != ".png")
filename = System.IO.Path.ChangeExtension (filename, "png");
if (File.Exists (filename)) {
var messageDialog = new MessageDialog (this,
DialogFlags.Modal,
MessageType.Question,
ButtonsType.OkCancel,
"{0} already exists. Overwrite?",
filename);
if (messageDialog.Run () != (int)ResponseType.Ok)
continueSave = false;
messageDialog.Destroy ();
}
if (continueSave)
File.Copy (previewimage.File, filename, true);
}
fileChooserDialog.Destroy ();
}
// MainWindow Constructor
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
entry_dvd.Changed += OnEntry_dvdChanged;
// Adds "*.dvd" fillter to FileChooserDialog
FileFilter filter = new FileFilter();
filter.Name="*.dvd";
filter.AddPattern("*.dvd");
filechooserbutton.AddFilter(filter);
UnixUserInfo user = UnixUserInfo.GetRealUser();
// Checks existing of configuration file and loads configuration of the programm
if (!Directory.Exists(user.HomeDirectory + "/.linxbox360burner")) Directory.CreateDirectory(user.HomeDirectory + "/.linxbox360burner");
if (!File.Exists(user.HomeDirectory + "/.linxbox360burner/conf"))
{
config = new Conf();
config.Commit();
}
else
{
config = new Conf(user.HomeDirectory + "/.linxbox360burner/conf");
}
if (config.dvdrwremember) entry_dvd.Text = config.dvdrw;
dvddrive = new DVDdrive (entry_dvd.Text);
dvddrive.GetMediaInfo();
Gnome.Vfs.Vfs.Initialize();
vm = Gnome.Vfs.VolumeMonitor.Get();
vm.VolumeMounted += delegate(object o, Gnome.Vfs.VolumeMountedArgs args) {
DriveStateChanged();
};
vm.VolumeUnmounted += delegate(object o, Gnome.Vfs.VolumeUnmountedArgs args) {
DriveStateChanged();
};
}
public Task<string[]> ShowFileDialogAsync(FileDialog dialog, IWindowImpl parent)
{
var tcs = new TaskCompletionSource<string[]>();
var dlg = new global::Gtk.FileChooserDialog(dialog.Title, ((WindowImpl)parent),
dialog is OpenFileDialog
? FileChooserAction.Open
: FileChooserAction.Save,
"Cancel", ResponseType.Cancel,
"Open", ResponseType.Accept)
{
SelectMultiple = (dialog as OpenFileDialog)?.AllowMultiple ?? false,
};
foreach (var filter in dialog.Filters)
{
var ffilter = new FileFilter()
{
Name = filter.Name + " (" + string.Join(";", filter.Extensions.Select(e => "*." + e)) + ")"
};
foreach (var ext in filter.Extensions)
ffilter.AddPattern("*." + ext);
dlg.AddFilter(ffilter);
}
dlg.SetFilename(dialog.InitialFileName);
dlg.Modal = true;
dlg.Response += (_, args) =>
{
if (args.ResponseId == ResponseType.Accept)
tcs.TrySetResult(dlg.Filenames);
dlg.Hide();
dlg.Dispose();
};
dlg.Close += delegate
{
tcs.TrySetResult(null);
dlg.Dispose();
};
dlg.Show();
return tcs.Task;
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build();
wordStore = new ListStore(typeof(string), typeof(string));
var lexColumn = new TreeViewColumn();
var cellRendererText = new CellRendererText();
lexColumn.PackStart(cellRendererText, true);
lexColumn.AddAttribute(cellRendererText, "text", 0);
lexColumn.Title = "Con Word";
wordList.AppendColumn(lexColumn);
wordListFilter = new TreeModelFilter(wordStore, null);
wordListFilter.VisibleFunc = SearchFilter;
wordList.Model = wordListFilter;
statusbar1.Push(0, "No language loaded");
currentWord.WordChanged += OnCurrentWordChanged;
langFileFilter = new FileFilter();
langFileFilter.AddPattern("*.lang");
}
protected void ApplyFilter(FileChooserDialog dlg)
{
if (string.IsNullOrEmpty(Filter))
return;
var parts = Filter.Split('|');
if (parts.Length % 2 != 0)
return;
ResetFilter(dlg);
for (int i = 0; i < parts.Length - 1; i += 2)
{
var filter = new FileFilter();
filter.Name = parts[i];
var patterns = parts[i + 1].Split(';');
foreach (var pattern in patterns)
filter.AddPattern(pattern.Trim());
dlg.AddFilter(filter);
}
if (FilterIndex > 0 && FilterIndex <= dlg.Filters.Length)
dlg.Filter = dlg.Filters[FilterIndex - 1];
}
public MainWindow()
: base(WindowType.Toplevel)
{
this.AppHomeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + "/.config/GPartimage-ng";
Build ();
LogView.NodeStore = new NodeStore ( typeof(LogTreeNode) );
LogView.AppendColumn ("Время", new CellRendererText (), "text", 0);
LogView.AppendColumn ("Событие", new CellRendererText (), "text", 1);
CmdShell = "/bin/bash";
CfgCmdShell.Text = CmdShell;
PartImage = "/usr/sbin/partimage-ng";
CfgPartImage.Text = PartImage;
LoadHostList(HostList);
if(System.IO.Directory.Exists("/media")) ImageFileOpenButton.SetCurrentFolder("/media");
LoadDevList(DevList);
LoadDevList(SaveDevList);
LoadDelDevList(DelDevList);
FileFilter fileFilter;
fileFilter = new FileFilter();
fileFilter.Name = "Файл образа .img.gz";
fileFilter.AddPattern("*.img.gz");
ImageFileOpenButton.AddFilter(fileFilter);
fileFilter = new FileFilter();
fileFilter.Name = "Все файлы";
fileFilter.AddPattern("*.*");
ImageFileOpenButton.AddFilter(fileFilter);
LoadConfiguration();
}
public static IGrepEngine GetReplaceEngine(string fileName, GrepEngineInitParams param, FileFilter filter)
{
Debug.Assert(param != null);
Debug.Assert(filter != null);
LoadPlugins();
string fileExtension = Path.GetExtension(fileName).ToLower().TrimStart('.');
lock (lockObj)
{
if (fileTypeEngines.ContainsKey(fileExtension) && !fileTypeEngines[fileExtension].IsSearchOnly)
{
IGrepEngine engine = fileTypeEngines[fileExtension].CreateEngine();
if (engine != null && engine.Initialize(param, filter))
{
loadedEngines.Add(engine);
return(engine);
}
else
{
failedEngines[engine.GetType().Name] = "Failed to initialize the plugin. See error log for details.";
return(GetPlainTextEngine(fileExtension, param, filter));
}
}
else
{
return(GetPlainTextEngine(fileExtension, param, filter));
}
}
}
private void TestGetExistingFilesForInstrument(string testDir, string instrument)
{
var folderToWatch = CreateDirectory(testDir, instrument);
// Create a .sky files
var skyFile = CreateFile(folderToWatch, "test.sky");
List <string> dataFiles;
SetupTestFolder(folderToWatch, instrument, out dataFiles);
var watcher = new AutoQCFileSystemWatcher(new TestLogger());
AutoQcConfig config = new AutoQcConfig();
var mainSettings = MainSettings.GetDefault();
config.MainSettings = mainSettings;
Assert.AreEqual(mainSettings.QcFileFilter, FileFilter.GetFileFilter(AllFileFilter.NAME, string.Empty));
mainSettings.SkylineFilePath = skyFile;
mainSettings.IncludeSubfolders = false;
mainSettings.InstrumentType = instrument;
mainSettings.FolderToWatch = folderToWatch;
mainSettings.ValidateSettings();
watcher.Init(config);
var files = watcher.GetExistingFiles();
Assert.AreEqual(1, files.Count);
Assert.AreEqual(dataFiles[0], files[0]);
mainSettings.IncludeSubfolders = true;
mainSettings.ValidateSettings();
watcher.Init(config);
files = watcher.GetExistingFiles();
Assert.AreEqual(5, files.Count);
Assert.IsTrue(files.Contains(dataFiles[0]));
Assert.IsTrue(files.Contains(dataFiles[1]));
Assert.IsTrue(files.Contains(dataFiles[2]));
Assert.IsTrue(files.Contains(dataFiles[3]));
Assert.IsTrue(files.Contains(dataFiles[4]));
/* Files:
* "root_QC_"
* "QC_one"
* "one_1_a_QC_"
* "one_1_b_QC"
* "two_qc_"
*/
mainSettings.QcFileFilter = FileFilter.GetFileFilter(ContainsFilter.NAME, "QC");
watcher.Init(config);
files = watcher.GetExistingFiles();
Assert.AreEqual(4, files.Count);
Assert.IsTrue(files.Contains(dataFiles[0]));
Assert.IsTrue(files.Contains(dataFiles[1]));
Assert.IsTrue(files.Contains(dataFiles[2]));
Assert.IsTrue(files.Contains(dataFiles[3]));
mainSettings.QcFileFilter = FileFilter.GetFileFilter(StartsWithFilter.NAME, "QC_");
watcher.Init(config);
files = watcher.GetExistingFiles();
Assert.AreEqual(1, files.Count);
Assert.IsTrue(files.Contains(dataFiles[1]));
mainSettings.QcFileFilter = FileFilter.GetFileFilter(EndsWithFilter.NAME, "_QC_");
watcher.Init(config);
files = watcher.GetExistingFiles();
Assert.AreEqual(2, files.Count);
Assert.IsTrue(files.Contains(dataFiles[0]));
Assert.IsTrue(files.Contains(dataFiles[2]));
mainSettings.QcFileFilter = FileFilter.GetFileFilter(RegexFilter.NAME, "[ab]_QC");
watcher.Init(config);
files = watcher.GetExistingFiles();
Assert.AreEqual(2, files.Count);
Assert.IsTrue(files.Contains(dataFiles[2]));
Assert.IsTrue(files.Contains(dataFiles[3]));
}
static List <string> MultiFileChooser(Widget parent, string title, string defaultName,
string defaultFolder, string filterName,
string[] extensions, FileChooserAction action,
bool allowMultiple = true)
{
Window toplevel;
FileChooserDialog fChooser;
FileFilter filter;
string button;
List <string> path;
if (action == FileChooserAction.Save)
{
button = "gtk-save";
}
else
{
button = "gtk-open";
}
if (parent != null)
{
toplevel = parent.Toplevel as Window;
}
else
{
toplevel = null;
}
fChooser = new FileChooserDialog(title, toplevel, action,
"gtk-cancel", ResponseType.Cancel, button, ResponseType.Accept);
fChooser.SelectMultiple = allowMultiple;
if (defaultFolder != null)
{
fChooser.SetCurrentFolder(defaultFolder);
}
else if (App.Current.Config.LastDir != null)
{
fChooser.SetCurrentFolder(App.Current.Config.LastDir);
}
if (defaultName != null)
{
fChooser.CurrentName = defaultName;
}
if (filterName != null)
{
filter = new FileFilter();
filter.Name = filterName;
if (extensions != null)
{
foreach (string p in extensions)
{
filter.AddPattern(p);
}
}
fChooser.Filter = filter;
}
if (fChooser.Run() != (int)ResponseType.Accept)
{
path = new List <string> ();
}
else
{
path = new List <string> (fChooser.Filenames);
if (defaultFolder == null && fChooser.Filenames.Length > 0)
{
App.Current.Config.LastDir = System.IO.Path.GetDirectoryName(fChooser.Filenames [0]);
}
}
fChooser.Destroy();
return(path);
}
protected void OnSaveActionActivated(object sender, EventArgs e)
{
if (gameInfoList == null)
{
Gtk.MessageDialog dialog = new Gtk.MessageDialog(this,
Gtk.DialogFlags.DestroyWithParent,
Gtk.MessageType.Error,
Gtk.ButtonsType.Ok,
"No info entry to save !!");
dialog.Run();
dialog.Destroy();
return;
}
FileChooserDialog openD = new FileChooserDialog("Save text file",
this, FileChooserAction.Save,
Stock.Cancel, ResponseType.Cancel,
Stock.Save, ResponseType.Accept);
FileFilter filter = new FileFilter();
filter.Name = "Text file (*.txt)";
filter.AddMimeType("Text");
filter.AddPattern("*.txt");
openD.AddFilter(filter);
openD.SetFilename(filechooserwidget2.Filename.Replace(".nes", ".txt"));
if (openD.Run() == (int)ResponseType.Accept)
{
File.WriteAllLines(openD.Filename, gameInfoLines.ToArray(), System.Text.Encoding.UTF8);
try
{
Process.Start(openD.Filename);
}
catch
{
}
}
openD.Destroy();
}
private void ImportCsv(ref Collection <UserStringItem> collection)
{
//Import a csv file
try
{
#region ETO Open File Dialog
var fd = new Eto.Forms.OpenFileDialog
{
MultiSelect = false,
Title = m_dialog_import_title
};
//Add the option to read from 3dm's if we're a Document Text panel and not an Object Attribute Panel
var rhino_file_filter = new FileFilter(m_rhino_str, m_3_dm);
if (IsDocumentText)
{
fd.Filters.Add(rhino_file_filter);
}
//Add the other file type filters
fd.Filters.Add(new FileFilter(m_csvstr, m_csv));
fd.Filters.Add(new FileFilter(m_txtstr, m_txt));
fd.CurrentFilter = fd.Filters[0];
var result = fd.ShowDialog(RhinoEtoApp.MainWindow);
if (result != DialogResult.Ok)
{
return;
}
var file_name = fd.FileName;
if (IsFileLocked(new FileInfo(file_name)))
{
Dialogs.ShowMessage(m_file_locked_message, m_file_error_message_title,
ShowMessageButton.OK, ShowMessageIcon.Error);
return;
}
#endregion
//Lets open up a 3dm if we're in doc mode and need a 3dm
if (fd.CurrentFilter == rhino_file_filter)
{
Import3Dm(file_name);
return;
}
//Grab some csv either from csv file or txt file
#region Stream Reader to parse opened file
using (var reader = new StreamReader(file_name))
{
string line;
var csv_parser = new Regex(",(?=(?:[^\"]*\"[^\"]*\")*(?![^\"]*\"))");
while ((line = reader.ReadLine()) != null)
{
var x = csv_parser.Split(line);
if (!x.Any())
{
continue;
}
var entry = new UserStringItem {
Key = CreateUniqueKey(x[0], true, ref collection), Value = x[1]
};
collection.Add(entry);
}
}
#endregion
}
catch (Exception ex)
{
Rhino.Runtime.HostUtils.DebugString("Exception caught during Options - User Text - CSV Import");
Rhino.Runtime.HostUtils.ExceptionReport(ex);
}
}
protected void OnButtonFinishClicked(object sender, EventArgs e)
{
string saveTo = null;
progressFinal.Adjustment.Upper = 2;
logger.Info("Пользователь выбирает файл...");
using (FileChooserDialog Chooser = new FileChooserDialog("Выберите куда сохранить изменения...",
(Window)MainClass.MainWin.Toplevel,
FileChooserAction.Save,
"Отмена", ResponseType.Cancel,
"Сохранить", ResponseType.Accept))
{
Chooser.SetFilename(filePath);
Chooser.DoOverwriteConfirmation = true;
FileFilter Filter = new FileFilter();
Filter.AddPattern("*.xls");
Filter.AddPattern("*.xlsx");
Filter.Name = "Все поддерживаемые";
Chooser.AddFilter(Filter);
Filter = new FileFilter();
Filter.AddPattern("*.xls");
Filter.Name = "Excel 2003";
Chooser.AddFilter(Filter);
Filter = new FileFilter();
Filter.AddPattern("*.xlsx");
Filter.Name = "Excel 2007";
Chooser.AddFilter(Filter);
if ((ResponseType)Chooser.Run() == ResponseType.Accept)
{
saveTo = Chooser.Filename;
}
Chooser.Destroy();
}
if (String.IsNullOrEmpty(saveTo))
{
return;
}
progressFinal.Adjustment.Value++;
logger.Info("Обновляем таблицы...");
foreach (var row in xlsRows.Where(x => x.ChangePrice))
{
var priceCell = row.XlsRow.GetCell(row.ColumnsMap[UpdatingXLSRow.ColumnType.Price]);
priceCell.SetCellValue((double)row.NewPrice.Value);
}
progressFinal.Adjustment.Value++;
logger.Info("Записываем фаил...");
try
{
using (FileStream file = new FileStream(saveTo, FileMode.Create, FileAccess.Write))
{
wb.Write(file);
}
}
catch (IOException ex)
{
if (ex.HResult == -2147024864)
{
MessageDialogWorks.RunErrorDialog("Указанный файл уже открыт в другом приложении. Оно заблокировало доступ к файлу.");
return;
}
throw ex;
}
progressFinal.Adjustment.Value++;
if (checkOpenAfterSave.Active)
{
logger.Info("Открываем во внешем приложении...");
System.Diagnostics.Process.Start(saveTo);
}
logger.Info("Ок");
OnCloseTab(false);
}
public void AddFilter(FileFilter filter)
{
}
public DirectorySnippetExtractor(DirectoryFilter directoryFilter = null, FileFilter fileFilter = null)
{
fileFinder = new FileFinder(directoryFilter, fileFilter);
}
public virtual bool Initialize(GrepEngineInitParams param, FileFilter filter)
{
initParams = param;
FileFilter = filter;
return(true);
}
public GrepEngineBase()
{
FileFilter = new FileFilter();
}
// Load
protected void OnButton16Pressed(object sender, EventArgs e)
{
FileChooserDialog openD = new FileChooserDialog("Open My Nes palette present file",
this, FileChooserAction.Open,
Stock.Cancel, ResponseType.Cancel,
Stock.Open, ResponseType.Accept);
FileFilter filter = new FileFilter();
filter.Name = "My Nes Palette Present (*.mnpp)";
filter.AddMimeType("mnpp");
filter.AddPattern("*.mnpp");
openD.AddFilter(filter);
if (openD.Run() == (int)ResponseType.Accept)
{
string[] lines = File.ReadAllLines(openD.Filename);
if (combobox_paletteOf.Active == 0)
{
for (int i = 0; i < lines.Length; i++)
{
string[] pars = lines[i].Split(new char[] { '=' });
switch (pars[0])
{
case "Brightness":
NTSCPaletteGenerator.brightness = float.Parse(pars[1]);
hscale_Brightness.Value = (int)(NTSCPaletteGenerator.brightness * 1000);
break;
case "Contrast":
NTSCPaletteGenerator.contrast = float.Parse(pars[1]);
hscale_Contrast.Value = (int)(NTSCPaletteGenerator.contrast * 1000);
break;
case "Gamma":
NTSCPaletteGenerator.gamma = float.Parse(pars[1]);
hscale_Gamma.Value = (int)(NTSCPaletteGenerator.gamma * 1000);
break;
case "Hue":
NTSCPaletteGenerator.hue_tweak = float.Parse(pars[1]);
hscale_Hue.Value = (int)(NTSCPaletteGenerator.hue_tweak * 1000);
break;
case "Saturation":
NTSCPaletteGenerator.saturation = float.Parse(pars[1]);
hscale_Saturation.Value = (int)(NTSCPaletteGenerator.saturation * 1000);
break;
}
}
label_Brightness.Text = NTSCPaletteGenerator.brightness.ToString("F3");
label_Contrast.Text = NTSCPaletteGenerator.contrast.ToString("F3");
label_Gamma.Text = NTSCPaletteGenerator.gamma.ToString("F3");
label_Hue.Text = NTSCPaletteGenerator.hue_tweak.ToString("F3");
label_Saturation.Text = NTSCPaletteGenerator.saturation.ToString("F3");
int[] palette = NTSCPaletteGenerator.GeneratePalette();
ShowPalette(palette);
}
else
{
for (int i = 0; i < lines.Length; i++)
{
string[] pars = lines[i].Split(new char[] { '=' });
switch (pars[0])
{
case "Brightness":
PALBPaletteGenerator.brightness = float.Parse(pars[1]);
hscale_Brightness.Value = (int)(PALBPaletteGenerator.brightness * 1000);
break;
case "Contrast":
PALBPaletteGenerator.contrast = float.Parse(pars[1]);
hscale_Contrast.Value = (int)(PALBPaletteGenerator.contrast * 1000);
break;
case "Gamma":
PALBPaletteGenerator.gamma = float.Parse(pars[1]);
hscale_Gamma.Value = (int)(PALBPaletteGenerator.gamma * 1000);
break;
case "Hue":
PALBPaletteGenerator.hue_tweak = float.Parse(pars[1]);
hscale_Hue.Value = (int)(PALBPaletteGenerator.hue_tweak * 1000);
break;
case "Saturation":
PALBPaletteGenerator.saturation = float.Parse(pars[1]);
hscale_Saturation.Value = (int)(PALBPaletteGenerator.saturation * 1000);
break;
}
}
label_Brightness.Text = PALBPaletteGenerator.brightness.ToString("F3");
label_Contrast.Text = PALBPaletteGenerator.contrast.ToString("F3");
label_Gamma.Text = PALBPaletteGenerator.gamma.ToString("F3");
label_Hue.Text = PALBPaletteGenerator.hue_tweak.ToString("F3");
label_Saturation.Text = PALBPaletteGenerator.saturation.ToString("F3");
int[] palette = PALBPaletteGenerator.GeneratePalette();
ShowPalette(palette);
}
}
openD.Destroy();
}
public EntryBoxValidationFilePickerDialog(Window pSourceWindow, String pLabelText, string pRule, bool pRequired, FileFilter pFileFilter)
: base(pSourceWindow, pLabelText, KeyboardMode.None, pRule, pRequired)
{
//Parameters
_sourceWindow = pSourceWindow;
_fileFilter = pFileFilter;
//Entry
_entryValidation.Sensitive = false;
//Events
_button.Clicked += delegate { PopupDialog(); };
}
/// <summary>
/// Execute the task.
/// </summary>
/// <param name="Job">Information about the current job</param>
/// <param name="BuildProducts">Set of build products produced by this node.</param>
/// <param name="TagNameToFileSet">Mapping from tag names to the set of files they include</param>
/// <returns>True if the task succeeded</returns>
public override bool Execute(JobContext Job, HashSet <FileReference> BuildProducts, Dictionary <string, HashSet <FileReference> > TagNameToFileSet)
{
// Set the Engine directory
DirectoryReference EngineDir = DirectoryReference.Combine(CommandUtils.RootDirectory, "Engine");
if (!String.IsNullOrEmpty(Parameters.EngineDir))
{
EngineDir = DirectoryReference.Combine(CommandUtils.RootDirectory, Parameters.EngineDir);
}
// Set the Project directory
DirectoryReference ProjectDir = DirectoryReference.Combine(CommandUtils.RootDirectory, "Engine");
if (!String.IsNullOrEmpty(Parameters.ProjectDir))
{
ProjectDir = DirectoryReference.Combine(CommandUtils.RootDirectory, Parameters.ProjectDir);
}
// Resolve the input list
IEnumerable <FileReference> TargetFiles = ResolveFilespec(CommandUtils.RootDirectory, Parameters.Files, TagNameToFileSet);
HashSet <FileReference> Files = new HashSet <FileReference>();
HashSet <string> WildcardDependencies = new HashSet <string>();
foreach (FileReference TargetFile in TargetFiles)
{
// check all files are .target files
if (TargetFile.GetExtension() != ".target")
{
CommandUtils.LogError("Invalid file passed to TagReceipt task ({0})", TargetFile.FullName);
continue;
}
// Read the receipt
TargetReceipt Receipt;
if (!TargetReceipt.TryRead(TargetFile.FullName, out Receipt))
{
CommandUtils.LogWarning("Unable to load file using TagReceipt task ({0})", TargetFile.FullName);
continue;
}
// Convert the paths to absolute
Receipt.ExpandPathVariables(EngineDir, ProjectDir);
if (Parameters.BuildProducts)
{
foreach (BuildProduct BuildProduct in Receipt.BuildProducts)
{
if (String.IsNullOrEmpty(Parameters.BuildProductType) || BuildProduct.Type == BuildProductType)
{
Files.Add(new FileReference(BuildProduct.Path));
}
}
}
if (Parameters.RuntimeDependencies)
{
foreach (RuntimeDependency RuntimeDependency in Receipt.RuntimeDependencies)
{
if (String.IsNullOrEmpty(Parameters.StagedFileType) || RuntimeDependency.Type == StagedFileType)
{
// If it doesn't contain any wildcards, just add the pattern directly
if (FileFilter.FindWildcardIndex(RuntimeDependency.Path) == -1)
{
// Only add files that exist as dependencies are assumed to always exist
FileReference DependencyPath = new FileReference(RuntimeDependency.Path);
if (DependencyPath.Exists())
{
Files.Add(DependencyPath);
}
else
{
// Give a warning about files that don't exist so that we can clean up build.cs files
CommandUtils.LogWarning("File listed as RuntimeDependency in {0} does not exist ({1})", TargetFile.FullName, DependencyPath.FullName);
}
}
else
{
WildcardDependencies.Add(RuntimeDependency.Path);
}
}
}
}
if (Parameters.PrecompiledBuildDependencies)
{
foreach (string PrecompiledBuildDependency in Receipt.PrecompiledBuildDependencies)
{
// If it doesn't contain any wildcards, just add the pattern directly
if (FileFilter.FindWildcardIndex(PrecompiledBuildDependency) == -1)
{
// Only add files that exist as dependencies are assumed to always exist
FileReference DependencyPath = new FileReference(PrecompiledBuildDependency);
if (DependencyPath.Exists())
{
Files.Add(DependencyPath);
}
else
{
// Give a warning about files that don't exist so that we can clean up build.cs files
CommandUtils.LogWarning("File listed as PrecompiledBuildDependency in {0} does not exist ({1})", TargetFile.FullName, DependencyPath.FullName);
}
}
else
{
WildcardDependencies.Add(PrecompiledBuildDependency);
}
}
}
if (Parameters.PrecompiledRuntimeDependencies)
{
foreach (string PrecompiledRuntimeDependency in Receipt.PrecompiledRuntimeDependencies)
{
// If it doesn't contain any wildcards, just add the pattern directly
if (FileFilter.FindWildcardIndex(PrecompiledRuntimeDependency) == -1)
{
// Only add files that exist as dependencies are assumed to always exist
FileReference DependencyPath = new FileReference(PrecompiledRuntimeDependency);
if (DependencyPath.Exists())
{
Files.Add(DependencyPath);
}
else
{
// Give a warning about files that don't exist so that we can clean up build.cs files
CommandUtils.LogWarning("File listed as PrecompiledRuntimeDependency in {0} does not exist ({1})", TargetFile.FullName, DependencyPath.FullName);
}
}
else
{
WildcardDependencies.Add(PrecompiledRuntimeDependency);
}
}
}
}
// Turn any wildcards into a file list
Files.UnionWith(ResolveFilespecWithExcludePatterns(CommandUtils.RootDirectory, WildcardDependencies.ToList(), new List <string>(), TagNameToFileSet));
// Apply the tag to all the matching files
FindOrAddTagSet(TagNameToFileSet, Parameters.With).UnionWith(Files);
return(true);
}
private static void TestGetNewFilesForInstrument(string testDir, string instrument)
{
var logger = new TestLogger();
// folder to watch
var folderToWatch = CreateDirectory(testDir, instrument);
// Create a .sky files
var skyFile = CreateFile(folderToWatch, "test2_a.sky");
var config = new AutoQcConfig();
// 1. Look for files in folderToWatchOnly
var watcher = new AutoQCFileSystemWatcher(logger);
var mainSettings = MainSettings.GetDefault();
config.MainSettings = mainSettings;
mainSettings.SkylineFilePath = skyFile;
mainSettings.IncludeSubfolders = false;
mainSettings.InstrumentType = instrument;
mainSettings.FolderToWatch = folderToWatch;
mainSettings.ValidateSettings();
watcher.Init(config);
watcher.StartWatching(); // Start watching
Assert.AreEqual(0, watcher.GetExistingFiles().Count); // No existing files
// Create new files in the folder
List <string> dataFiles;
SetupTestFolder(folderToWatch, instrument, out dataFiles);
// Only one file should have been added to the queue since we are not monitoring sub-folders
Assert.IsNotNull(watcher.GetFile());
Assert.IsNull(watcher.GetFile());
watcher.Stop();
// 2. Look for files in subfolders
watcher = new AutoQCFileSystemWatcher(logger);
// folder to watch
folderToWatch = CreateDirectory(testDir, instrument + "_2");
// Create a .sky files
skyFile = CreateFile(folderToWatch, "test2_b.sky");
mainSettings.SkylineFilePath = skyFile;
mainSettings.InstrumentType = instrument;
mainSettings.FolderToWatch = folderToWatch;
mainSettings.IncludeSubfolders = true; // watch sub-folders
mainSettings.ValidateSettings();
watcher.Init(config);
watcher.StartWatching(); // Start watching
Assert.AreEqual(0, watcher.GetExistingFiles().Count); // No existing files
dataFiles.Clear();
SetupTestFolder(folderToWatch, instrument, out dataFiles); // Create new files in the folder
var files = new List <string>();
string f;
while ((f = watcher.GetFile()) != null)
{
files.Add(f);
}
Assert.AreEqual(5, files.Count);
Assert.IsTrue(files.Contains(dataFiles[0]));
Assert.IsTrue(files.Contains(dataFiles[1]));
Assert.IsTrue(files.Contains(dataFiles[2]));
Assert.IsTrue(files.Contains(dataFiles[3]));
Assert.IsTrue(files.Contains(dataFiles[4]));
// 3. Look for files in subfolders matching a pattern
watcher = new AutoQCFileSystemWatcher(logger);
// folder to watch
folderToWatch = CreateDirectory(testDir, instrument + "_3");
// Create a .sky files
skyFile = CreateFile(folderToWatch, "test2_c.sky");
mainSettings.SkylineFilePath = skyFile;
mainSettings.InstrumentType = instrument;
mainSettings.FolderToWatch = folderToWatch;
mainSettings.IncludeSubfolders = true; // watch sub-folders
mainSettings.QcFileFilter = FileFilter.GetFileFilter(ContainsFilter.NAME, "_QC_"); // file name pattern
mainSettings.ValidateSettings();
watcher.Init(config);
watcher.StartWatching(); // Start watching
Assert.AreEqual(0, watcher.GetExistingFiles().Count); // No existing files
dataFiles.Clear();
SetupTestFolder(folderToWatch, instrument, out dataFiles); // Create new files in the folder
files = new List <string>();
while ((f = watcher.GetFile()) != null)
{
files.Add(f);
}
Assert.AreEqual(2, files.Count);
Assert.IsTrue(files.Contains(dataFiles[0]));
Assert.IsTrue(files.Contains(dataFiles[2]));
}
/// <summary>
/// Returns an array of abstract pathnames denoting the files and
/// directories in the directory denoted by this abstract pathname that
/// satisfy the specified filter.
/// </summary>
public File[] listFiles(FileFilter @filter)
{
return(default(File[]));
}
public static IGrepEngine GetSearchEngine(string fileName, GrepEngineInitParams param, FileFilter filter)
{
Debug.Assert(param != null);
Debug.Assert(filter != null);
LoadPlugins();
string fileExtension = Path.GetExtension(fileName).ToLower();
if (fileExtension.Length > 1)
{
fileExtension = fileExtension.Substring(1);
}
if (!fileTypeEngines.ContainsKey(fileExtension))
{
foreach (GrepPlugin plugin in plugins)
{
if (plugin.Extensions.Contains(fileExtension))
{
fileTypeEngines[fileExtension] = plugin;
}
}
}
GrepEnginePlainText plainTextEngine = new GrepEnginePlainText();
plainTextEngine.Initialize(param, filter);
if (fileTypeEngines.ContainsKey(fileExtension) && fileTypeEngines[fileExtension].Enabled)
{
if (FrameworkVersionsAreCompatible(fileTypeEngines[fileExtension].Engine.FrameworkVersion, plainTextEngine.FrameworkVersion))
{
if (fileTypeEngines[fileExtension].Engine.Initialize(param, filter))
{
return(fileTypeEngines[fileExtension].Engine);
}
else
{
failedEngines[fileTypeEngines[fileExtension].Engine.GetType().Name] = "Failed to initialize the plugin. See error log for details.";
return(plainTextEngine);
}
}
else
{
failedEngines[fileTypeEngines[fileExtension].Engine.GetType().Name] = "Plugin developed under outdated framework. Please update the plugin.";
return(plainTextEngine);
}
}
else
{
return(plainTextEngine);
}
}
public void InsertFilter(int index, FileFilter filter)
{
fileTypes.InsertItem(filter.Name, index);
}
private static IGrepEngine GetPlainTextEngine(string fileExtension, GrepEngineInitParams param, FileFilter filter)
{
if (!poolKeys.ContainsKey(fileExtension))
{
poolKeys.Add(fileExtension, "GrepEnginePlainText");
}
IGrepEngine poolEngine = FetchFromPool(fileExtension);
if (poolEngine != null)
{
poolEngine.Initialize(param, filter);
return(poolEngine);
}
IGrepEngine engine = new GrepEnginePlainText();
loadedEngines.Add(engine);
engine.Initialize(param, filter);
return(engine);
}
public override void ViewDirectory(string directory, FileFilter filter)
{
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="directoryFilter">Directories to include.</param>
/// <param name="fileFilter">Files to include.</param>
public CachedSnippetExtractor(DirectoryFilter directoryFilter, FileFilter fileFilter, GetPackageOrderForComponent packageOrder = null, TranslatePackage translatePackage = null)
{
Guard.AgainstNull(directoryFilter, nameof(directoryFilter));
Guard.AgainstNull(fileFilter, nameof(fileFilter));
extractor = new DirectorySnippetExtractor(directoryFilter, fileFilter, packageOrder, translatePackage);
}
bool Execute()
{
SourcePath = STEM.Sys.IO.Path.AdjustPath(SourcePath);
try
{
List <string> files = null;
if (!ExpandSource && !RecurseSource && !FileFilter.Contains("|") && !FileFilter.Contains("!") && !FileFilter.Contains("<>") && !FileFilter.Contains("?") && !FileFilter.Contains("*"))
{
files = new List <string>();
files.Add(Path.Combine(SourcePath, FileFilter));
}
else
{
files = STEM.Sys.IO.Directory.STEM_GetFiles(SourcePath, FileFilter, DirectoryFilter, (RecurseSource ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly), ExpandSource);
}
foreach (string file in files)
{
try
{
if (System.IO.File.Exists(file))
{
STEM.Sys.IO.File.STEM_Delete(file, false, Retry, RetryDelaySeconds);
AppendToMessage(file + " deleted");
}
}
catch (Exception ex)
{
AppendToMessage(ex.ToString());
Exceptions.Add(ex);
}
}
if (DeleteEmptyDirectories)
{
if (RecurseSource)
{
foreach (string dir in STEM.Sys.IO.Directory.STEM_GetDirectories(SourcePath, DirectoryFilter, SearchOption.AllDirectories, ExpandSource))
{
try
{
if (Directory.GetFiles(dir, "*", SearchOption.AllDirectories).Length == 0)
{
Directory.Delete(dir, true);
AppendToMessage(dir + " deleted");
}
}
catch (Exception ex)
{
AppendToMessage(ex.ToString());
Exceptions.Add(ex);
}
}
}
if (Directory.GetFiles(SourcePath, "*", SearchOption.AllDirectories).Length == 0)
{
Directory.Delete(SourcePath, true);
AppendToMessage(SourcePath + " deleted");
}
}
}
catch (Exception ex)
{
AppendToMessage(ex.ToString());
Exceptions.Add(ex);
}
return(Exceptions.Count == 0);
}
private void SaveFile(object sender, EventArgs e)
{
//if file is selected exit
if (!string.IsNullOrEmpty(_txtFile.PostedFile.FileName))
{
var extension = Path.GetExtension(_txtFile.PostedFile.FileName).Replace(".", "");
if (!string.IsNullOrEmpty(FileFilter) && !FileFilter.ToLowerInvariant().Contains(extension.ToLowerInvariant()))
{
// trying to upload a file not allowed for current filter
var localizedString = Localization.GetString("UploadError", LocalResourceFile);
if (String.IsNullOrEmpty(localizedString))
{
localizedString = Utilities.GetLocalizedString("UploadError");
}
_lblMessage.Text = string.Format(localizedString, FileFilter, extension);
}
else
{
var folderManager = FolderManager.Instance;
var folderPath = PathUtils.Instance.GetRelativePath(PortalId, ParentFolder) + _cboFolders.SelectedItem.Value;
//Check if this is a User Folder
IFolderInfo folder;
if (IsUserFolder(_cboFolders.SelectedItem.Value))
{
//Make sure the user folder exists
folder = folderManager.GetFolder(PortalController.GetEffectivePortalId(PortalId), folderPath);
if (folder == null)
{
//Add User folder
var user = User ?? UserController.Instance.GetCurrentUserInfo();
//fix user's portal id
user.PortalID = PortalId;
folder = ((FolderManager)folderManager).AddUserFolder(user);
}
}
else
{
folder = folderManager.GetFolder(PortalId, folderPath);
}
var fileName = Path.GetFileName(_txtFile.PostedFile.FileName);
try
{
FileManager.Instance.AddFile(folder, fileName, _txtFile.PostedFile.InputStream, true);
}
catch (PermissionsNotMetException)
{
_lblMessage.Text += "<br />" + string.Format(Localization.GetString("InsufficientFolderPermission"), folder.FolderPath);
}
catch (NoSpaceAvailableException)
{
_lblMessage.Text += "<br />" + string.Format(Localization.GetString("DiskSpaceExceeded"), fileName);
}
catch (InvalidFileExtensionException)
{
_lblMessage.Text += "<br />" + string.Format(Localization.GetString("RestrictedFileType"), fileName, Host.AllowedExtensionWhitelist.ToDisplayString());
}
catch (Exception ex)
{
Logger.Error(ex);
_lblMessage.Text += "<br />" + string.Format(Localization.GetString("SaveFileError"), fileName);
}
}
if (string.IsNullOrEmpty(_lblMessage.Text))
{
var fileName = _txtFile.PostedFile.FileName.Substring(_txtFile.PostedFile.FileName.LastIndexOf("\\") + 1);
SetFilePath(fileName);
}
}
Mode = FileControlMode.Normal;
}
public AddSuperDomainWizard(Repository repository)
{
this.repository = repository;
this.Title = Mono.Unix.Catalog.GetString("Add Super Domain Wizard");
this.Icon = Gdk.Pixbuf.LoadFromResource("Allors.R1.Development.GtkSharp.Icons.allors.ico");
this.WindowPosition = WindowPosition.CenterOnParent;
this.DefaultWidth = 640;
this.DefaultHeight = 1;
var headerBox = new VBox
{
Spacing = 10,
BorderWidth = 10
};
this.VBox.PackStart(headerBox, false, false, 0);
headerBox.PackStart(new HtmlLabel("<span size=\"large\">Welcome to the Allors Add Super Domain Wizard</span>", 0.5f));
headerBox.PackStart(new HtmlLabel("This wizard makes this domain inherit from a new super domain.", 0.5f));
var form = new Form();
this.VBox.PackStart(form);
this.fileChooserButton = new FileChooserButton(Mono.Unix.Catalog.GetString("Select a Domain"), 0);
this.superDomainErrorMessage = new ErrorMessage();
this.ActionArea.Spacing = 10;
this.ActionArea.BorderWidth = 5;
this.ActionArea.LayoutStyle = ButtonBoxStyle.End;
var buttonCancel = new Button
{
CanDefault = true,
CanFocus = true,
UseStock = true,
UseUnderline = true,
Label = "gtk-cancel"
};
this.AddActionWidget(buttonCancel, -6);
var buttonOk = new Button
{
CanDefault = true,
CanFocus = true,
UseStock = true,
UseUnderline = true,
Label = "gtk-ok"
};
buttonOk.Clicked += this.OnButtonOkClicked;
this.ActionArea.PackStart(buttonOk);
// Layout
form.Attach(this.fileChooserButton, 0, 1, 0, 1, AttachOptions.Fill | AttachOptions.Expand, AttachOptions.Fill, 0, 0);
form.Attach(this.superDomainErrorMessage, 0, 1, 2, 3, AttachOptions.Fill, AttachOptions.Fill, 0, 0);
this.ShowAll();
this.ResetErrorMessages();
var filter = new FileFilter {
Name = "Allors repository (*.repository)"
};
filter.AddPattern("*.repository");
this.fileChooserButton.AddFilter(filter);
}
public DirectorySampleStream(Jfile dir, FileFilter fileFilter, bool recursive)
: this(new Jfile[] { dir }, fileFilter, recursive)
{
}
public virtual void SetFilter(FileFilter ff)
{
}
public void InsertFilter(int index, FileFilter filter)
{
}
public abstract void ViewDirectory(string directory, FileFilter filter);
/// <summary>
/// Responds to action performed events. </summary>
/// <param name="ae"> the ActionEvent that happened. </param>
public virtual void actionPerformed(ActionEvent ae)
{
string routine = "StateMod_OutputControl_JFrame.actionPerformed";
string action = ae.getActionCommand();
if (action.Equals(__BUTTON_ADD_ROW))
{
if (!__tableModel.canAddNewRow())
{
return;
}
__dirty = true;
int row = __worksheet.getRowCount();
StateMod_GraphNode n = new StateMod_GraphNode();
__worksheet.addRow(n);
n.setType("");
n.setID("");
n.setSwitch(-1);
__tableModel.setDirty(true);
// when a row is added, mark the second and third columns
// as uneditable. They will be set to editable as soon as
// the user enters a value in the first column
__worksheet.setCellEditable(row, 1, false);
__worksheet.setCellEditable(row, 2, false);
}
else if (action.Equals(__BUTTON_CLEAR_LIST))
{
__dirty = true;
__worksheet.clear();
setMessages("Add station to list.", "Ready");
__tableModel.setDirty(true);
}
else if (action.Equals(__BUTTON_CLOSE))
{
closeWindow();
}
else if (action.Equals(__BUTTON_DELETE_ROW))
{
int[] rows = __worksheet.getSelectedRows();
int length = rows.Length;
__tableModel.setDirty(true);
if (length == 0)
{
return;
}
for (int i = (length - 1); i >= 0; i--)
{
__worksheet.deleteRow(rows[i]);
}
__dirty = true;
setMessages("Time series list has changed.", "Ready");
}
else if (action.Equals(__BUTTON_HELP))
{
// REVISIT HELP (JTS - 2003-07-09)
}
else if (action.Equals(__BUTTON_SAVE_FILE))
{
JGUIUtil.setWaitCursor(this, true);
string lastDirectorySelected = JGUIUtil.getLastFileDialogDirectory();
JFileChooser fc = null;
if (!string.ReferenceEquals(lastDirectorySelected, null))
{
fc = new JFileChooser(lastDirectorySelected);
}
else
{
fc = new JFileChooser();
}
fc.setDialogTitle("Select Output Control File");
SimpleFileFilter @out = new SimpleFileFilter("out", "StateMod Output Control Files");
fc.addChoosableFileFilter(@out);
SimpleFileFilter tpl = new SimpleFileFilter("tpo", "StateMod Output Control Files");
fc.addChoosableFileFilter(tpl);
SimpleFileFilter xou = new SimpleFileFilter("xou", "StateMod Output Control Files");
fc.addChoosableFileFilter(xou);
fc.setAcceptAllFileFilterUsed(false);
fc.setFileFilter(tpl);
fc.setDialogType(JFileChooser.SAVE_DIALOG);
JGUIUtil.setWaitCursor(this, false);
int retVal = fc.showSaveDialog(this);
if (retVal != JFileChooser.APPROVE_OPTION)
{
return;
}
string currDir = (fc.getCurrentDirectory()).ToString();
if (!currDir.Equals(lastDirectorySelected, StringComparison.OrdinalIgnoreCase))
{
JGUIUtil.setLastFileDialogDirectory(currDir);
}
string filename = fc.getSelectedFile().getName();
FileFilter ff = fc.getFileFilter();
if (ff == @out)
{
filename = IOUtil.enforceFileExtension(filename, "out");
}
else if (ff == tpl)
{
filename = IOUtil.enforceFileExtension(filename, "tpo");
}
else if (ff == xou)
{
filename = IOUtil.enforceFileExtension(filename, "xou");
}
__dirty = false;
__tableModel.setDirty(false);
System.Collections.IList theGraphNodes = __worksheet.getAllData();
try
{
StateMod_GraphNode.writeStateModOutputControlFile(null, currDir + File.separator + filename, theGraphNodes, null);
}
catch (Exception e)
{
Message.printWarning(1, routine, "Error saving output control file\n" + "\"" + currDir + File.separator + filename + "\"", this);
Message.printWarning(2, routine, e);
}
}
else if (action.Equals(__BUTTON_LOAD_FILE))
{
JGUIUtil.setWaitCursor(this, true);
string lastDirectorySelected = JGUIUtil.getLastFileDialogDirectory();
JFileChooser fc = null;
if (!string.ReferenceEquals(lastDirectorySelected, null))
{
fc = new JFileChooser(lastDirectorySelected);
}
else
{
fc = new JFileChooser();
}
fc.setDialogTitle("Select Output Control File");
SimpleFileFilter @out = new SimpleFileFilter("out", "StateMod Output Control Files");
fc.addChoosableFileFilter(@out);
SimpleFileFilter tpl = new SimpleFileFilter("tpo", "StateMod Output Control Files");
fc.addChoosableFileFilter(tpl);
SimpleFileFilter xou = new SimpleFileFilter("xou", "StateMod Output Control Files");
fc.addChoosableFileFilter(xou);
fc.setAcceptAllFileFilterUsed(false);
fc.setFileFilter(tpl);
fc.setDialogType(JFileChooser.OPEN_DIALOG);
JGUIUtil.setWaitCursor(this, false);
int retVal = fc.showOpenDialog(this);
if (retVal != JFileChooser.APPROVE_OPTION)
{
return;
}
string currDir = (fc.getCurrentDirectory()).ToString();
if (!currDir.Equals(lastDirectorySelected, StringComparison.OrdinalIgnoreCase))
{
JGUIUtil.setLastFileDialogDirectory(currDir);
}
string filename = fc.getSelectedFile().getName();
JGUIUtil.setWaitCursor(this, true);
__dirty = false;
System.Collections.IList theGraphNodes = new List <object>(20, 1);
try
{
__worksheet.clear();
__tableModel.setDirty(false);
StateMod_GraphNode.readStateModOutputControlFile(theGraphNodes, currDir + File.separator + filename);
int size = theGraphNodes.Count;
StateMod_GraphNode g = null;
int row = 0;
for (int i = 0; i < size; i++)
{
row = __worksheet.getRowCount();
g = (StateMod_GraphNode)theGraphNodes[i];
if (i == 0)
{
if (g.getID().Equals("All"))
{
__useAllJCheckBox.setSelected(true);
}
else
{
__useAllJCheckBox.setSelected(false);
}
}
__worksheet.addRow(g);
__tableModel.fillIDColumn(row, g.getType());
}
__worksheet.setData(theGraphNodes);
}
catch (Exception e)
{
Message.printWarning(1, routine, "Error loading output control file\n" + "\"" + currDir + File.separator + filename + "\"", this);
Message.printWarning(2, routine, e);
}
JGUIUtil.setWaitCursor(this, false);
}
else if (action.Equals(__CHECKBOX_USE_ALL))
{
// if the use all checkbox is selected, subtle changes from the
// default functionality are made. The buttons to add and
// delete rows are disabled, and the ID of the only record
// in the worksheet is set to "All". This ID value is used
// in the table model to determine when the checkbox is
// selected. In addition, the ComboBox functionality of the
// first and third data columns is turned off.
if (__useAllJCheckBox.isSelected())
{
__addRowButton.setEnabled(false);
__deleteRowButton.setEnabled(false);
__worksheet.setColumnJComboBoxValues(0, null);
__worksheet.setColumnJComboBoxValues(2, null);
__worksheet.clear();
StateMod_GraphNode g = new StateMod_GraphNode();
g.setID("All");
__worksheet.setCellEditable(0, 0, false);
__worksheet.setCellEditable(0, 1, false);
__worksheet.setCellEditable(0, 2, false);
__worksheet.addRow(g);
}
else
{
__addRowButton.setEnabled(true);
__deleteRowButton.setEnabled(true);
System.Collections.IList v = StateMod_Util.arrayToList(StateMod_GraphNode.node_types);
v.Add("Other");
__worksheet.setColumnJComboBoxValues(0, v);
__worksheet.clear();
System.Collections.IList offOn = new List <object>();
offOn.Add("Off");
offOn.Add("On");
__worksheet.setCellEditable(0, 0, true);
__worksheet.setColumnJComboBoxValues(2, offOn);
}
}
}
private static bool FindBestSharedCookedBuild(ref string FinalCookedBuildPath, string ProjectFullPath, UnrealTargetPlatform TargetPlatform, string CookPlatform, string SharedCookedBuildCL)
{
string BuildRoot = CommandUtils.P4Enabled ? CommandUtils.P4Env.Branch.Replace("/", "+") : "";
int CurrentCLInt = CommandUtils.P4Enabled ? CommandUtils.P4Env.Changelist : 0;
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
CurrentCLInt = Version.Changelist;
BuildRoot = Version.BranchName;
}
System.GC.Collect();
string CurrentCL = CurrentCLInt.ToString();
FileReference ProjectFileRef = new FileReference(ProjectFullPath);
// get network location
ConfigHierarchy Hierarchy = ConfigCache.ReadHierarchy(ConfigHierarchyType.Engine, DirectoryReference.FromFile(ProjectFileRef), TargetPlatform);
List <string> CookedBuildPaths;
if (Hierarchy.GetArray("SharedCookedBuildSettings", "SharedCookedBuildPath", out CookedBuildPaths) == false)
{
CommandUtils.LogInformation("Unable to copy shared cooked build: SharedCookedBuildPath not set in Engine.ini SharedCookedBuildSettings");
return(false);
}
const string MetaDataFilename = "\\Metadata\\DevelopmentAssetRegistry.bin";
if (SharedCookedBuildCL == "usesyncedbuild")
{
foreach (string CookedBuildPath in CookedBuildPaths)
{
if (CurrentCL == "" && FinalCookedBuildPath.Contains("[CL]"))
{
CommandUtils.LogInformation("Unable to copy shared cooked build: Unable to determine CL number from P4 or UGS, and is required by SharedCookedBuildPath");
return(false);
}
if (CurrentCL == "" && FinalCookedBuildPath.Contains("[BRANCHNAME]"))
{
CommandUtils.LogInformation("Unable to copy shared cooked build: Unable to determine BRANCHNAME number from P4 or UGS, and is required by SharedCookedBuildPath");
return(false);
}
FinalCookedBuildPath = FinalCookedBuildPath.Replace("[CL]", CurrentCL.ToString());
FinalCookedBuildPath = FinalCookedBuildPath.Replace("[BRANCHNAME]", BuildRoot);
FinalCookedBuildPath = FinalCookedBuildPath.Replace("[PLATFORM]", CookPlatform);
// make sure that the directory and metadata file exist. otherwise this build might not be finished yet and we should skip it
if (Directory.Exists(FinalCookedBuildPath))
{
if (File.Exists(FinalCookedBuildPath + MetaDataFilename))
{
return(true);
}
}
}
}
else if (SharedCookedBuildCL == "userecentbuild")
{
// build our CookedBUildPath into a regex which we can execute on the directories and extract info from
string BestBuild = null;
int BestCLNumber = 0;
// find all the recent builds which are valid
foreach (string CookedBuildPath in CookedBuildPaths)
{
int IndexOfFirstParam = CookedBuildPath.IndexOf("[");
int CustomFolderStart = CookedBuildPath.LastIndexOf("\\", IndexOfFirstParam);
string CookedBuildDirectory = CookedBuildPath.Substring(0, CustomFolderStart);
string BuildNameWildcard = CookedBuildPath.Substring(CustomFolderStart);
BuildNameWildcard += MetaDataFilename;
FileFilter BuildSearch = new FileFilter();
// we know the platform and the branch name;
string BuildRule = BuildNameWildcard;
BuildRule = BuildRule.Replace("[BRANCHNAME]", BuildRoot);
BuildRule = BuildRule.Replace("[PLATFORM]", CookPlatform);
string IncludeRule = BuildRule.Replace("[CL]", "*");
string ForgetRule = BuildRule.Replace("[CL]", "*-PF-*"); // get rid of any preflights from the list... they don't count because who knows what they did...
BuildSearch.AddRule(IncludeRule);
BuildSearch.AddRule(ForgetRule, FileFilterType.Exclude);
List <FileReference> ValidBuilds = BuildSearch.ApplyToDirectory(new DirectoryReference(CookedBuildDirectory), false);
// figure out what the CL is
string BuildNameRegex = String.Format(".*{0}", CookedBuildPath.Substring(CustomFolderStart));
BuildNameRegex = BuildNameRegex.Replace("\\", "\\\\");
BuildNameRegex = BuildNameRegex.Replace("[BRANCHNAME]", BuildRoot);
BuildNameRegex = BuildNameRegex.Replace("+", "\\+");
BuildNameRegex = BuildNameRegex.Replace("[PLATFORM]", CookPlatform);
BuildNameRegex = BuildNameRegex.Replace("[CL]", "(?<CL>.*)");
Regex ExtractCL = new Regex(BuildNameRegex);
foreach (FileReference ValidBuild in ValidBuilds)
{
string BuildPath = ValidBuild.FullName.Replace(MetaDataFilename, "");
Match CLMatch = ExtractCL.Match(BuildPath);
if (CLMatch != null)
{
string CLNumber = CLMatch.Result("${CL}");
int CLNumberInt = int.Parse(CLNumber);
if (CLNumberInt <= CurrentCLInt)
{
if (CLNumberInt > BestCLNumber)
{
BestCLNumber = CLNumberInt;
BestBuild = BuildPath;
}
}
}
}
}
if (string.IsNullOrEmpty(BestBuild))
{
return(false);
}
FinalCookedBuildPath = BestBuild;
return(true);
}
return(false);
}
private void ConfigureDlg()
{
ybuttonExport.Clicked += (sender, e) => {
var parentWindow = GetParentWindow(this);
var folderChooser = new FileChooserDialog("Выберите папку выгрузки", parentWindow, FileChooserAction.SelectFolder,
Stock.Cancel, ResponseType.Cancel, Stock.Open, ResponseType.Accept);
folderChooser.ShowAll();
if ((ResponseType)folderChooser.Run() == ResponseType.Accept)
{
if (folderChooser.CurrentFolder == null)
{
folderChooser.Destroy();
return;
}
ViewModel.FolderPath = folderChooser.CurrentFolder;
var shortpath = folderChooser.CurrentFolder;
if (folderChooser.CurrentFolder.Length > 25)
{
shortpath = "..." + shortpath.Substring(shortpath.Length - 25);
}
ybuttonExport.Label = shortpath;
folderChooser.Destroy();
}
else
{
folderChooser.Destroy();
}
};
enummenubuttonExport.ItemsEnum = typeof(ExportType);
enummenubuttonExport.EnumItemClicked += (sender, e) => {
ViewModel.ExportCommand.Execute(e.ItemEnum);
};
enummenubuttonLoadActions.ItemsEnum = typeof(LoadAction);
enummenubuttonLoadActions.EnumItemClicked += (sender, e) => {
ViewModel.LoadActionCommand.Execute(e.ItemEnum);
};
enummenubuttonConfirmUpdate.ItemsEnum = typeof(ConfirmUpdateAction);
enummenubuttonConfirmUpdate.EnumItemClicked += (sender, e) => {
ViewModel.ConfirmUpdateDataCommand.Execute(e.ItemEnum);
};
ycheckDontChangeSellPrice.Binding.AddBinding(ViewModel, vm => vm.DontChangeSellPrice, w => w.Active);
ycheckDontChangeSellPrice.Active = true;
ycheckDontChangeSellPrice.TooltipText = "При включении у всех заменяемых номенклатур будут удалены все старые цены и будет создана одна новая цена, указанная в файле";
ybuttonConfirmLoadNew.Clicked += (sender, e) => { ViewModel.ConfirmLoadNewCommand.Execute(); };
yfilechooserbuttonImport.Binding.AddBinding(ViewModel, vm => vm.FilePath, w => w.Filename);
var fileFilter = new FileFilter();
fileFilter.AddPattern("*.csv");
yfilechooserbuttonImport.Filter = fileFilter;
yfilechooserbuttonImport.Title = "Выберите csv файл";
ytreeviewNomenclatures.ColumnsConfig = FluentColumnsConfig <NomenclatureCatalogNode> .Create()
.AddColumn("Действие")
.MinWidth(120)
.AddComboRenderer(x => x.ConflictSolveAction)
.SetDisplayFunc(x => x.GetEnumTitle())
.FillItems(((ConflictSolveAction[])Enum.GetValues(typeof(ConflictSolveAction))).ToList())
.AddSetter((c, n) => {
c.Editable = n.Source == Source.File && n.Status == NodeStatus.Conflict && n.DuplicateOf != null && ViewModel.CurrentState == LoadAction.LoadNew;
switch (ViewModel.CurrentState)
{
case LoadAction.LoadNew:
if (n.DuplicateOf == null || n.Source == Source.Base || !c.Editable)
{
c.Text = "";
}
break;
case LoadAction.UpdateData:
if (n.ConflictSolveAction != ConflictSolveAction.Ignore)
{
c.Text = "";
}
break;
}
})
.AddColumn("Источник")
.AddEnumRenderer((x) => x.Source)
.XAlign(0.5f)
.AddColumn("Статус")
.AddTextRenderer((x) => x.Status.GetEnumTitle())
.XAlign(0.5f)
.AddColumn("ID номенклатуры")
.AddTextRenderer(x => x.Id.ToString())
.AddSetter((c, n) => { if (n.Id == null)
{
c.Text = "Новый";
}
})
.XAlign(0.5f)
.AddColumn("Наименование")
.AddTextRenderer(x => x.Name)
.WrapMode(Pango.WrapMode.WordChar)
.WrapWidth(400)
.AddColumn("ID группы товаров")
.AddNumericRenderer(x => x.GroupId)
.XAlign(0.5f)
.AddColumn("ID поставщика")
.AddNumericRenderer(x => x.ShipperCounterpartyId)
.XAlign(0.5f)
.AddColumn("Цена закупки")
.AddNumericRenderer(x => x.PurchasePrice).Digits(2).WidthChars(10)
.XAlign(1)
.AddColumn("Цена продажи")
.AddNumericRenderer(x => x.SellPrice).Digits(2).WidthChars(10)
.XAlign(1)
.AddColumn("Единицы измерения")
.AddNumericRenderer(x => x.MeasurementUnit)
.XAlign(0.5f)
.AddColumn("Папка 1С")
.HeaderAlignment(0.5f)
.AddNumericRenderer(x => x.Folder1cName)
.XAlign(0.5f)
.AddColumn("Категория")
.HeaderAlignment(0.5f)
.AddTextRenderer(x => x.NomenclatureCategory)
.XAlign(0.5f)
.AddColumn("Объем тары")
.HeaderAlignment(0.5f)
.AddTextRenderer(x => x.TareVolume)
.XAlign(0.5f)
.AddColumn("Тип оборудования")
.AddTextRenderer(x => x.EquipmentTypeName)
.XAlign(0.5f)
.AddColumn("Доступность для продажи")
.AddTextRenderer(x => x.SaleCategory)
.XAlign(0.5f)
.AddColumn("Тип залога")
.AddTextRenderer(x => x.TypeOfDepositCategory)
.XAlign(0.5f)
.AddColumn("Тип топлива")
.AddTextRenderer(x => x.FuelTypeName)
.XAlign(0.5f)
.RowCells()
.AddSetter((CellRendererText c, NomenclatureCatalogNode n) => {
c.CellBackgroundGdk = GetGdkColor(n.BackgroundColor);
c.ForegroundGdk = GetGdkColor(n.ForegroundColor);
})
.Finish();
ViewModel.PropertyChanged += (sender, e) => {
Application.Invoke((s, args) => {
if (e.PropertyName == nameof(ViewModel.ProgressBarValue))
{
progressbar.Adjustment.Value = ViewModel.ProgressBarValue;
}
if (e.PropertyName == nameof(ViewModel.ProgressBarUpper))
{
progressbar.Adjustment.Upper = ViewModel.ProgressBarUpper;
}
if (e.PropertyName == nameof(ViewModel.Items))
{
ytreeviewNomenclatures.ItemsDataSource = ViewModel.Items;
}
if (e.PropertyName == nameof(ViewModel.IsConfirmUpdateDataButtonVisible))
{
enummenubuttonConfirmUpdate.Visible = ViewModel.IsConfirmUpdateDataButtonVisible;
}
if (e.PropertyName == nameof(ViewModel.IsConfirmLoadNewButtonVisible))
{
ycheckDontChangeSellPrice.Visible = ViewModel.IsConfirmUpdateDataButtonVisible;
}
if (e.PropertyName == nameof(ViewModel.IsConfirmLoadNewButtonVisible))
{
ybuttonConfirmLoadNew.Visible = ViewModel.IsConfirmLoadNewButtonVisible;
}
});
};
TextTagTable textTags = new TextTagTable();
var darkredtag = new TextTag("DarkRed");
darkredtag.ForegroundGdk = GetGdkColor(ConsoleColor.DarkRed);
textTags.Add(darkredtag);
var redtag = new TextTag("red");
redtag.ForegroundGdk = GetGdkColor(ConsoleColor.Red);
textTags.Add(redtag);
var greentag = new TextTag("Green");
greentag.ForegroundGdk = GetGdkColor(ConsoleColor.Green);
textTags.Add(greentag);
var darkgreentag = new TextTag("DrakGreen");
darkgreentag.ForegroundGdk = GetGdkColor(ConsoleColor.DarkGreen);
textTags.Add(darkgreentag);
var blackTag = new TextTag("Black");
blackTag.ForegroundGdk = GetGdkColor(ConsoleColor.Black);
textTags.Add(blackTag);
var yellowTag = new TextTag("Yellow");
yellowTag.ForegroundGdk = GetGdkColor(ConsoleColor.DarkYellow);
textTags.Add(yellowTag);
ViewModel.ProgressBarMessagesUpdated += (aList, aIdx) => {
Application.Invoke((s, args) => {
TextBuffer tempBuffer = new TextBuffer(textTags);
foreach (ColoredMessage message in ViewModel.ProgressBarMessages)
{
TextIter iter = tempBuffer.EndIter;
switch (message.Color)
{
case ConsoleColor.Black: tempBuffer.InsertWithTags(ref iter, "\n" + message.Text, blackTag); break;
case ConsoleColor.DarkRed: tempBuffer.InsertWithTags(ref iter, "\n" + message.Text, darkredtag); break;
case ConsoleColor.Green: tempBuffer.InsertWithTags(ref iter, "\n" + message.Text, greentag); break;
case ConsoleColor.Yellow: tempBuffer.InsertWithTags(ref iter, "\n" + message.Text, yellowTag); break;
case ConsoleColor.DarkGreen: tempBuffer.InsertWithTags(ref iter, "\n" + message.Text, darkgreentag); break;
case ConsoleColor.Red: tempBuffer.InsertWithTags(ref iter, "\n" + message.Text, redtag); break;
default: throw new NotImplementedException("Цвет не настроен");
}
}
ytextviewProgressStatus.Buffer = tempBuffer;
ScrollToEnd();
});
};
ytreeviewNomenclatures.Selection.Changed += (sender, e) => {
Application.Invoke((s, args) => {
ytextviewNodeMessages.Buffer.Clear();
TextBuffer tempBuffer = new TextBuffer(textTags);
var node = ytreeviewNomenclatures.GetSelectedObject <NomenclatureCatalogNode>();
if (node == null)
{
ytextviewNodeMessages.Buffer.Text = "Выберите запись для просмотра ошибок";
return;
}
foreach (ColoredMessage message in node.ErrorMessages)
{
TextIter iter = tempBuffer.EndIter;
switch (message.Color)
{
case ConsoleColor.Black: tempBuffer.InsertWithTags(ref iter, message.Text + "\n", blackTag); break;
case ConsoleColor.DarkRed: tempBuffer.InsertWithTags(ref iter, message.Text + "\n", darkredtag); break;
case ConsoleColor.Green: tempBuffer.InsertWithTags(ref iter, message.Text + "\n", greentag); break;
case ConsoleColor.Yellow: tempBuffer.InsertWithTags(ref iter, message.Text + "\n", yellowTag); break;
case ConsoleColor.DarkGreen: tempBuffer.InsertWithTags(ref iter, message.Text + "\n", darkgreentag); break;
case ConsoleColor.Red: tempBuffer.InsertWithTags(ref iter, message.Text + "\n", redtag); break;
default: throw new NotImplementedException("Цвет не настроен");
}
}
if (!node.ErrorMessages.Any() && node.Source == Source.File)
{
TextIter iter = tempBuffer.EndIter;
tempBuffer.InsertWithTags(ref iter, "Ошибок нет\n", darkgreentag);
}
if (node.Source == Source.Base)
{
TextIter iter = tempBuffer.EndIter;
tempBuffer.InsertWithTags(ref iter, "Данные из базы\n", blackTag);
}
ytextviewNodeMessages.Buffer = tempBuffer;
ScrollToEnd();
});
};
}
public static IGrepEngine GetSearchEngine(string fileName, GrepEngineInitParams param, FileFilter filter, SearchType searchType)
{
Debug.Assert(param != null);
Debug.Assert(filter != null);
LoadPlugins();
string fileExtension = Path.GetExtension(fileName).ToLower().TrimStart('.');
lock (lockObj)
{
if (searchType == SearchType.Hex)
{
return(GetHexEngine(param, filter));
}
IGrepEngine poolEngine = FetchFromPool(fileExtension);
if (poolEngine != null)
{
poolEngine.Initialize(param, filter);
return(poolEngine);
}
if (fileTypeEngines.ContainsKey(fileExtension))
{
IGrepEngine engine = fileTypeEngines[fileExtension].CreateEngine();
if (engine != null && engine.Initialize(param, filter))
{
loadedEngines.Add(engine);
logger.Debug(string.Format("Using plugin: {0} for extension {1}", engine.ToString(), fileExtension));
return(engine);
}
else
{
logger.Debug(string.Format("File type engines failed to initialize: {0}, using plainTextEngine", fileExtension));
failedEngines[engine.GetType().Name] = "Failed to initialize the plugin. See error log for details.";
return(GetPlainTextEngine(fileExtension, param, filter));
}
}
else
{
logger.Debug(string.Format("File type engines has no key for: {0}, using plainTextEngine", fileExtension));
return(GetPlainTextEngine(fileExtension, param, filter));
}
}
}
