/// <summary>
/// Adds the folder item into the collection of sub-folders of this folder.
/// </summary>
/// <param name="item"></param>
public void AddFolder(IFolderViewModel item)
{
Application.Current.Dispatcher.Invoke(() =>
{
Folders.Add(item.FolderName.ToLower(), item);
});
}
/// <summary>
/// Create a new folder with a standard name
/// 'New folder n' underneath this folder.
/// </summary>
/// <returns>a viewmodel of the newly created directory or null</returns>
public IFolderViewModel CreateNewDirectory()
{
Logger.DebugFormat("Detail: Create new directory with standard name.");
lock (mLockObject)
{
try
{
string defaultFolderName = FileSystemModels.Local.Strings.STR_NEW_DEFAULT_FOLDER_NAME;
var newSubFolder = PathModel.CreateDir(new PathModel(FolderPath, FSItemType.Folder), defaultFolderName);
if (newSubFolder != null)
{
var newFolder = new FolderViewModel(newSubFolder);
Folders.Add(newFolder.FolderName, newFolder);
return(newFolder);
}
}
catch (Exception exp)
{
this.ShowNotification(FileSystemModels.Local.Strings.STR_MSG_UnknownError, exp.Message);
}
}
return(null);
}
/// <summary>
/// Setup the list of files to be a folder object for the cvs
/// library to process.
/// </summary>
/// <param name="filesCommitted">An array filenames that are to be committed
/// to the cvs repository.</param>
private Folders GetFoldersToCommit(ICollection filesCommitted)
{
Folders folders = new Folders();
Manager manager = new Manager(Environment.CurrentDirectory);
foreach (FileInfo file in filesCommitted)
{
Folder folder;
if (!folders.Contains(file.DirectoryName))
{
folder = new Folder();
DirectoryInfo cvsFolder =
new DirectoryInfo(Path.Combine(file.DirectoryName, "CVS"));
folder.Repository = Repository.Load(cvsFolder);
folder.Root = Root.Load(cvsFolder);
try {
folder.Tag = Tag.Load(cvsFolder);
} catch (CvsFileNotFoundException) {
// ignore, tag missing normal
}
folder.Entries = Entries.Load(cvsFolder);
folders.Add(file.DirectoryName, folder);
}
}
return(folders);
}
public ViewModel()
{
m_folders = new ObservableCollection <IFolder>();
//add Root items
Folders.Add(new Folder {
FolderLabel = "Dummy1", FullPath = @"C:\dummy1"
});
Folders.Add(new Folder {
FolderLabel = "Dummy2", FullPath = @"C:\dummy2"
});
Folders.Add(new Folder {
FolderLabel = "Dummy3", FullPath = @"C:\dummy3"
});
Folders.Add(new Folder {
FolderLabel = "Dummy4", FullPath = @"C:\dummy4"
});
//add sub items
Folders[0].Folders.Add(new Folder {
FolderLabel = "Dummy11", FullPath = @"C:\dummy11"
});
Folders[0].Folders.Add(new Folder {
FolderLabel = "Dummy12", FullPath = @"C:\dummy12"
});
Folders[0].Folders.Add(new Folder {
FolderLabel = "Dummy13", FullPath = @"C:\dummy13"
});
Folders[0].Folders.Add(new Folder {
FolderLabel = "Dummy14", FullPath = @"C:\dummy14"
});
}
public AssetsViewModel(
IObservable <AssetFileEventArgs> watcher,
ProjectReference projectReference,
IConfigurationContainer <ProjectConfiguration> configuration,
Lazy <AssetsView> assets,
PreviewFactory previewFactory,
Lazy <EditorViewModel> editor)
{
_projectReference = projectReference;
_configuration = configuration;
_assets = assets;
PreviewFactory = previewFactory;
_editor = editor;
_disposables = new CompositeDisposable();
_disposables.Add(watcher.ObserveOnDispatcher().Subscribe(OnAssetChanged));
foreach (var configurationDataFolder in _configuration.Value.DataFolders)
{
var folder = Path.Combine(_projectReference.Path, configurationDataFolder);
if (!folder.EndsWith(Path.DirectorySeparatorChar.ToString()))
{
folder += Path.DirectorySeparatorChar;
}
Folders.Add(new FolderViewModel(folder, folder, null, this));
}
}
public async Task GetCurrentFolderContent(string path = "/storage/emulated/0")
{
Folders.Clear();
List <IFolder> folders = await GetCurrentFolders(path);
foreach (var item in folders)
{
Folder folder = new Folder {
Name = item.Name,
Path = item.Path
};
Folders.Add(folder);
}
FilesList.Clear();
List <IFile> files = await GetCurrentFiles(path);
foreach (var item in files)
{
File file = new File {
Title = item.Name,
FullPath = item.Path,
};
FilesList.Add(file);
}
}
void LoadFolders()
{
try
{
FolderViewModel rootFolder = new FolderViewModel();
rootFolder.Root = this;
rootFolder.FolderPath = Path;
rootFolder.FolderName = ".";
Folders.Add(rootFolder);
////foreach (DirectoryInfo dir in new DirectoryInfo(Path).GetDirectories())
////{
//// try
//// {
//// Folders.Add(new FolderViewModel { Root = this, FolderPath = dir.FullName, FolderName = dir.Name });
//// }
//// catch (UnauthorizedAccessException ae)
//// {
//// Console.WriteLine(ae.Message);
//// }
//// catch (IOException ie)
//// {
//// Console.WriteLine(ie.Message);
//// }
////}
}
catch (UnauthorizedAccessException ae)
{
Console.WriteLine(ae.Message);
}
catch (IOException ie)
{
Console.WriteLine(ie.Message);
}
}
private bool ParsePath(FolderNode folder)
{
string[] subdirs = Directory.GetDirectories(folder.FullPath);
foreach (var subdir in subdirs)
{
// parse folder node
FolderNode fnode = new FolderNode(subdir);
Folders.Add(fnode);
fnode.Parent = folder;
folder.Childs.Add(fnode);
ParsePath(fnode);
}
string[] files = Directory.GetFiles(folder.FullPath);
foreach (var file in files)
{
if (File.Exists(file))
{
FileNode fnode = new FileNode(file);
Files.Add(fnode);
folder.Childs.Add(fnode);
fnode.Parent = folder;
}
}
return(true);
}
/// <summary>
/// When settings are modified the folders are updated
/// </summary>
private void Settings_SettingsModified(object sender, EventArgs e)
{
int selId = -1;
if (this.SelectedFolder != null)
{
selId = this.SelectedFolder.Id;
}
Folders.Clear();
switch (this.contentType)
{
case ContentType.Movie:
this.Folders.Add(ContentRootFolder.AllMoviesFolders);
break;
case ContentType.TvShow:
this.Folders.Add(ContentRootFolder.AllTvFolders);
break;
}
switch (this.contentType)
{
case ContentType.TvShow:
List <ContentRootFolder> allTvFolders = Settings.TvFolders.GetFolders(true);
foreach (ContentRootFolder folder in allTvFolders)
{
Folders.Add(new ContentRootFolder(folder));
}
break;
case ContentType.Movie:
List <ContentRootFolder> allMovieFolders = Settings.MovieFolders.GetFolders(true);
foreach (ContentRootFolder folder in allMovieFolders)
{
Folders.Add(new ContentRootFolder(folder));
}
break;
}
// Set selection
if (selId >= 0)
{
foreach (ContentRootFolder folder in Folders)
{
if (folder.Id == selId)
{
this.SelectedFolder = folder;
break;
}
}
}
else
{
this.SelectedFolder = this.Folders[0];
}
// Update move to item for selected contents
UpdateMoveToFolderMenuItems();
}
private void GetFolders(MAPIFolder folder)
{
try
{
Utils.Debug($"Try {folder.FullFolderPath}\n");
/*
* We reached an end of a folder chain
* There are only mails inside
*/
if (folder.Folders.Count == 0)
{
// Check if current folder path is in our FolderPaths list
if (FolderPaths.Contains(folder.FullFolderPath.ToLower()))
{
// if contains, include it into user folders
Folders.Add(folder);
}
}
else // There are still folders inside, check them too
{
foreach (MAPIFolder subfolder in folder.Folders)
{
GetFolders(subfolder);
}
}
}
catch (System.Exception e)
{
Utils.Debug($"Error getting folder {e.Message}\n{e.StackTrace}");
}
}
public void AddFolder(string folder)
{
List <string> temp = Folders;
Folders.Add(folder);
Folders = temp;
}
private NadeoPakFolder[] ReadFolders(GameBoxReader r)
{
var numFolders = r.ReadInt32();
var folders = new NadeoPakFolder[numFolders];
for (var i = 0; i < numFolders; i++)
{
var parentFolderIndex = r.ReadInt32(); // index into folders; -1 if this is a root folder
var name = r.ReadString();
var folder = new NadeoPakFolder(name, parentFolderIndex == -1 ? null : folders[parentFolderIndex]);
if (parentFolderIndex == -1)
{
Folders.Add(folder);
}
else
{
folders[parentFolderIndex].Folders.Add(folder);
}
folders[i] = folder;
}
if (folders.Length > 2 && folders[2].Name.Length > 4)
{
byte[] nameBytes = Encoding.Unicode.GetBytes(folders[2].Name);
blowfish.Initialize(nameBytes, 4, 4);
}
return(folders);
}
private void AddFolder(string name, IFolderViewModel folder)
{
Application.Current.Dispatcher.Invoke(() =>
{
Folders.Add(name.ToLower(), folder);
});
}
async Task ExecuteLoadFoldersCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Folders.Clear();
var NewFolders = await FolderDataStore.GetItemsAsync(true);
foreach (var ForFolder in NewFolders)
{
Folders.Add(ForFolder);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public MarketViewModel(MarketsViewModel marketsViewModel, MarketModel marketModel, SettingService settings)
{
if (marketsViewModel == null)
{
throw new ArgumentNullException(nameof(marketsViewModel));
}
_parent = marketsViewModel;
Model = marketModel;
_settings = settings;
CheckAllCommand = new RelayCommand <IList>(m => DoCheckAll(m), m => !_parent.IsBusy && !Active && SelectedSymbol != null);
AddSymbolCommand = new RelayCommand(() => DoAddSymbol(), () => !_parent.IsBusy);
DownloadSymbolListCommand = new RelayCommand(() => DoDownloadSymbolList(), !_parent.IsBusy);
DeleteSymbolsCommand = new RelayCommand <IList>(m => DoDeleteSymbols(m), m => !_parent.IsBusy && !Active && SelectedSymbol != null);
ImportSymbolsCommand = new RelayCommand(() => DoImportSymbols(), !_parent.IsBusy);
ExportSymbolsCommand = new RelayCommand <IList>(m => DoExportSymbols(m), m => !_parent.IsBusy && !Active && SelectedSymbol != null);
AddToSymbolListCommand = new RelayCommand <IList>(m => DoAddToSymbolList(m), m => !_parent.IsBusy && !Active && SelectedSymbol != null);
DeleteCommand = new RelayCommand(() => _parent?.DoDeleteMarket(this), () => !_parent.IsBusy && !Active);
NewFolderCommand = new RelayCommand(() => Folders.Add(new FolderViewModel(this, new FolderModel())), () => !_parent.IsBusy && !Active);
ImportFolderCommand = new RelayCommand(() => DoImportFolder(), () => !_parent.IsBusy && !Active);
ActiveCommand = new RelayCommand(() => DoActiveCommand(Model.Active), !_parent.IsBusy);
StartCommand = new RelayCommand(() => DoStartCommand(), () => !_parent.IsBusy && !Active);
StopCommand = new RelayCommand(() => DoStopCommand(), () => !_parent.IsBusy && Active);
Model.ModelChanged += DataFromModel;
DataFromModel();
DoActiveCommand(Active);
}
public IEntry this[string name]
{
get
{
return(Folders.OfType <IEntry>().Concat(Files)
.FirstOrDefault(e => e.Name.Equals(name,
StringComparison.InvariantCultureIgnoreCase)));
}
set
{
var folder = value as IFolder;
if (folder != null)
{
Folders.Add(folder);
}
var file = value as IFile;
if (file != null)
{
Files.Add(file);
}
var entry = value as VfsEntry;
if (entry != null)
{
entry.Parent = this;
}
}
}
// retrieves mail
private async void RetrieveMail()
{
Folders.Clear();
Emails.Clear();
folderTypes.Clear();
// connect to google
using (var client = new ImapClient())
{
await client.ConnectAsync("imap.gmail.com", 993, true);
client.AuthenticationMechanisms.Remove("XOAUTH2");
client.Authenticate("ece433tester", "thisclassman");
var inbox = client.Inbox;
inbox.Open(FolderAccess.ReadOnly);
Folders.Add(client.Inbox);
if ((client.Capabilities & (ImapCapabilities.SpecialUse | ImapCapabilities.XList)) != 0)
{
foreach (SpecialFolder folder in Enum.GetValues(typeof(SpecialFolder)))
{
var fold = client.GetFolder(folder);
if (fold != null)
{
fold.Open(FolderAccess.ReadOnly);
folderTypes.Add(folder);
Folders.Add(client.GetFolder(folder));
}
}
}
ShowFolder();
client.Disconnect(true);
}
}
protected override void InitLoad(object parameters)
{
if (parameters != null)
{
var filters = parameters.ToString().Split(';');
FilterItems = new ObservableCollection <FilterElement>()
{
new FilterElement()
{
FilterName = "全部",
FilterValue = "*.*"
}
};
foreach (var item in filters)
{
if (item.Contains('|'))
{
FilterItems.Add(new FilterElement()
{
FilterName = item.Split('|')[0],
FilterValue = item.Split('|')[1],
});
}
}
SelectManager = new SelectManager(SelectControlType.SelectFile, FilterItems.First().FilterValue);
//_curFilter = FilterItems.First().FilterValue;
var initFolders = SelectManager.InitFolders();
foreach (var item in initFolders)
{
Folders.Add(item);
}
}
}
public void Add(string part)
{
if (!HasFolder(part))
{
Folders.Add(new Folder(part, Path.Combine(FullPath, part)));
}
}
public void AddFolder(FolderViewModel folder, Mapping mapping)
{
folder.Status = TaskStatus.Inactive;
folder.Ass.Source = folder.DirInfo;
switch (mapping)
{
case Mapping.Source:
folder.Mapping = mapping;
folder.Ass.Mode = TaskMode.STORE;
folder.Ass.Target = new DirectoryInfo(Profile.StorageFolder.FullName + @"\" + folder.DirInfo.Name);
break;
case Mapping.Stored:
folder.Mapping = mapping;
folder.Ass.Mode = TaskMode.RESTORE;
folder.Ass.Target = new DirectoryInfo(Profile.GameFolder.FullName + @"\" + folder.DirInfo.Name);
break;
case Mapping.Unlinked:
folder.Mapping = mapping;
folder.Ass.Mode = TaskMode.LINK;
folder.Ass.Target = new DirectoryInfo(Profile.GameFolder.FullName + @"\" + folder.DirInfo.Name);
break;
}
folder.PropertyChanged += FolderPropertyChanged;
Folders.Add(folder);
}
private void CreateFolders()
{
foreach (var diffPart in Parts.Values)
{
var path = diffPart.Uri;
// format is folder/partfilename.ext
var folderEnd = path.LastIndexOf('/');
string folderPath;
if (folderEnd == -1)
{
folderPath = string.Empty;
}
else
{
folderPath = path.Substring(0, folderEnd);
}
var partPath = path.Substring(folderEnd + 1, path.Length - (folderEnd + 1));
// get existing folder or create new one
DiffPackageItem folder;
if (!Folders.TryGetValue(folderPath, out folder))
{
folder = new DiffPackageItem(this, folderPath, null);
Folders.Add(folderPath, folder);
}
folder.AddItem(new DiffPackageItem(this, partPath, diffPart));
}
}
public FileDataProvider(IEnumerable <string> folders)
{
foreach (var folder in folders)
{
Folders.Add(folder);
}
}
public FileSystem()
{
folders = new List <Folder>();
files = new List <File>();
Folders.Add(new Folder("root"));
}
private void lvFolder_Drop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent(DataFormats.FileDrop))
{
string[] file = (string[])e.Data.GetData(DataFormats.FileDrop);
foreach (string str in file)
{
FileAttributes attr = File.GetAttributes(str);
string value = string.Empty;
if (attr.HasFlag(FileAttributes.Directory))
{
value = str;
}
else
{
value = System.IO.Path.GetDirectoryName(str);
}
if (Folders.Where(f => f.Path == value).Count() < 1)
{
TargetFolder folder = new TargetFolder()
{
Path = value, Enable = true
};
Folders.Add(folder);
DataBase.SetFolder(folder);
}
}
}
}
public virtual void AddFolder(ISolutionFolder folder)
{
if (string.IsNullOrEmpty(folder.IdGuid))
{
folder.IdGuid = Guid.NewGuid().ToString().ToUpperInvariant();
}
bool isNew = false;
if (folder.Parent != null)
{
folder.Parent.RemoveFolder(folder);
}
else
{
// this is a new project/solution folder
isNew = true;
}
if (isNew)
{
this.ParentSolution.BeforeAddFolderToSolution(folder);
}
folder.Parent = this;
Folders.Add(folder);
if (isNew)
{
this.ParentSolution.AfterAddFolderToSolution(folder);
}
}
public LocalFilesystemEntry IterateDirectory(DirectoryInfo directoryInfo)
{
var directoryRelativePath = GetRelativePath(LocalDirectoryPath, directoryInfo.FullName, true);
LocalFilesystemEntry directory = new LocalFilesystemEntry(this, directoryRelativePath, true);
foreach (var childDirectoryInfo in directoryInfo.EnumerateDirectories())
{
var childDirectory = IterateDirectory(childDirectoryInfo);
directory.Items.Add(childDirectory);
}
foreach (var childFileInfo in directoryInfo.EnumerateFiles())
{
var childFileRelativePath = GetRelativePath(LocalDirectoryPath, childFileInfo.FullName, false);
var childFile = new LocalFilesystemEntry(this, childFileRelativePath, false);
{
var filepath_test = Path.Combine(LocalDirectoryPath, childFile.FullPath);
if (!File.Exists(filepath_test))
{
throw new Exception("Invalid filepaths");
}
}
directory.Items.Add(childFile);
Files.Add(childFile);
}
Folders.Add(directory);
FolderLookup[directory.FullPath] = directory;
return(directory);
}
private void AddDefaultFoldersAndFiles()
{
Folders.Add(new ProjectFolder("Assets.xcassets")
{
Folders =
{
new ProjectFolder("AppIcon.appiconset")
{
Files ={ }
}
}
});
Folders.Add(new ProjectFolder("Properties")
{
Files =
{
new AssemblyInfoFile(AssemblyName, AssemblyGuid, new Version(1, 0, 0, 0), new Version(1, 0, 0, 0))
}
});
Folders.Add(new ProjectFolder("Resources")
{
Files =
{
}
});
Files.Add(new AppDelegateFile(RootNamespace));
Files.Add(new EntitlementsPListFile());
Files.Add(new InfoPListFile(_appName, _bundleIdentifier));
Files.Add(new iOSMainFile(RootNamespace));
}
/// <summary>
/// Extract folders from a given URL
/// </summary>
/// <param name="url"></param>
private void ExtractFolders(string url)
{
var u = new Uri(url);
var port = (u.Port == 80) ? "" : ":" + u.Port;
if (u.ToString().EndsWith("//"))
{
ExtractFolders(u.ToString().Remove(u.ToString().Length - 1, 1));
return;
}
var offSetProtocol = url.IndexOf("://", StringComparison.Ordinal);
var protocol = url.Substring(0, offSetProtocol);
var foldersSplit = u.AbsolutePath.Split('/');
var path = "";
for (var i = 0; i < foldersSplit.Length; i++)
{
if (i + 1 != foldersSplit.Length)
{
path += foldersSplit[i] + "/";
}
if (ExistFolder(protocol + "://" + u.Host + port + path) || path.Contains("."))
{
continue;
}
Folders.Add(protocol + "://" + u.Host + port + path);
// ToDo use a list provided by the user
string[] ficheros = { ".listing", ".DS_Store", "WS_FTP.LOG" };
var path1 = path;
foreach (
var fichero in
ficheros.Where(fichero => !ExistMutexFile(protocol + "://" + u.Host + port + path1 + fichero)))
{
BackupModifiedFilenames.Add(protocol + "://" + u.Host + port + path + fichero);
}
// ToDo use a list provided by the user
string[] compressExt = { ".zip", ".rar", ".tar", ".gz", ".tar.gz" };
foreach (
var extension in
compressExt.Where(
extension =>
protocol + "://" + u.Host + path1.Substring(0, path1.Length - 1) !=
protocol + "://" + u.Host)
.Where(
extension =>
!ExistMutexFile(protocol + "://" + u.Host + port +
path1.Substring(0, path1.Length - 1) +
extension)))
{
BackupModifiedFilenames.Add(protocol + "://" + u.Host + port +
path.Substring(0, path.Length - 1) + extension);
}
}
}
private void UpdateFolders()
{
Folders.Clear();
foreach (var folder in m_dbhandler.GetFolders())
{
Folders.Add(folder);
}
}
public Folder AddFolder(string name)
{
Folder folder = new Folder(0, name, this);
Folders.Add(folder);
folder.Save();
return(folder);
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
var folders = new Folders();
var count = reader.NoOfChildren();
reader.MoveDown();
for (var i = 0; i < count; i++) {
folders.Add((Folder) context.ConvertAnother());
reader.MoveNext();
}
reader.MoveUp();
return folders;
}
/// <summary>
/// This will save all the selected folders to the <see cref="Settings"/> object
/// </summary>
private void SaveFolders()
{
var folders = new Folders();
foreach (DataGridViewRow row in FoldersDataGridView.Rows)
{
if(row.Cells[0].Value == null) continue;
folders.Add(row.Cells[0].Value.ToString());
}
// Save setting
Settings.Default["Folders"] = folders.SerializeToString();
Settings.Default.Save();
}