MainPage.xaml.cs

MainPage.xaml.cs (103772B)
      1 // Copyright (c) Microsoft. All rights reserved.
      2 
      3 using Windows.UI.Xaml;
      4 using Windows.UI.Xaml.Controls;
      5 using Windows.UI.Xaml.Controls.Primitives;
      6 using Windows.UI.Xaml.Input;
      7 using Windows.UI.Xaml.Media;
      8 using Windows.UI.Xaml.Navigation;
      9 using System;
     10 using System.Collections.Generic;
     11 using Windows.Phone.UI.Input;
     12 using Windows.UI.Xaml.Media.Animation;
     13 using System.Collections.ObjectModel;
     14 using Windows.UI.ViewManagement;
     15 using Windows.Storage;
     16 using Windows.Media.Playback;
     17 using System.Threading.Tasks;
     18 using TagLib;
     19 using System.IO;
     20 using Windows.UI.Xaml.Media.Imaging;
     21 using System.IO.Compression;
     22 using System.Runtime.InteropServices.WindowsRuntime;
     23 using Windows.ApplicationModel.DataTransfer;
     24 using Windows.Foundation;
     25 using System.Linq;
     26 using Windows.Storage.FileProperties;
     27 using Coding4Fun.Toolkit.Controls;
     28 using Windows.ApplicationModel.Activation;
     29 using Windows.Storage.Streams;
     30 using Windows.Storage.Pickers;
     31 using Windows.Storage.AccessCache;
     32 using Windows.Phone.Devices.Notification;
     33 using System.Runtime.InteropServices;
     34 using Windows.Media;
     35 using System.Text;
     36 
     37 namespace File360
     38 {
     39     public sealed partial class MainPage : Page, IFolderPickerContinuable
     40     {
     41 
     42 
     43 
     44         //[DllImport("KernelBase.dll")]
     45         //public static extern void KernelDll();
     46         #region Variables
     47 
     48         public bool GridType = true;
     49         public ItemsControl musicItemsControlGrid = null;
     50 
     51         #region SettingsVaribles
     52         ApplicationDataContainer settings = ApplicationData.Current.LocalSettings;
     53         StorageFolder folder;
     54         BitmapImage niy = new BitmapImage(new Uri("ms-appx:///Assets/IMG-20150528-WA0003.jpg", UriKind.Absolute));
     55         ImageSource musicCoverArt = null;
     56         IReadOnlyList<IStorageItem> Items;
     57 
     58         ObservableCollection<sdlist> sd = new ObservableCollection<sdlist>();
     59         ObservableCollection<MusicList> music = new ObservableCollection<MusicList>();
     60         ObservableCollection<PictureList> picture = new ObservableCollection<PictureList>();
     61         ObservableCollection<VideoList> video = new ObservableCollection<VideoList>();
     62 
     63         public IStorageFolder CurrentFolder = null;
     64         ScrollViewer gridScrollViewer;
     65         TextBlock txtBlockRe = null;
     66         ItemsControl itemsControlGrid = null;
     67         List<IStorageItem> SelectedItems = new List<IStorageItem>();
     68         bool InZipRoot = false;
     69 
     70         #region LibraryVariables
     71         public bool IsVideoLibraryOpen = false;
     72         public bool IsPictureLibraryOpen = false;
     73         public bool IsMusicLibraryOpen = false;
     74         #endregion
     75 
     76         bool singleTap = true;
     77 
     78         App app = (App)Application.Current;
     79         bool IsSDLoading = true;
     80         bool IsPhoneLoading = true;
     81         private bool IsMediaOpen = false;
     82         private DispatcherTimer musicDispatcher = new DispatcherTimer();
     83 
     84         #region FileOperationVariables
     85         bool IS_FILE_MOVE = false;
     86         #endregion
     87 
     88         #region MusicVariables
     89         SystemMediaTransportControls systemControls;
     90         string title = String.Empty;
     91         string artist = String.Empty;
     92         #endregion
     93 
     94 
     95         #endregion
     96 
     97         public MainPage()
     98         {
     99 
    100             this.InitializeComponent();
    101             SDGridView.ItemsSource = sd;
    102             SideMenu.InitializeDrawerLayout();
    103             Addresser.InitializeComponent();
    104             #region MusicPlayerInitialization
    105 
    106 
    107             // Hook up app to system transport controls.
    108 
    109             systemControls = SystemMediaTransportControls.GetForCurrentView();
    110 
    111             systemControls.ButtonPressed += async (sender, args) =>
    112             {
    113                 switch (args.Button)
    114 
    115                 {
    116 
    117                     case SystemMediaTransportControlsButton.Play:
    118 
    119                         await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    120 
    121                         {
    122                             mediaPlayer.Play();
    123 
    124                         });
    125 
    126                         break;
    127 
    128                     case SystemMediaTransportControlsButton.Pause:
    129                         await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    130 
    131    {
    132 
    133       mediaPlayer.Pause();
    134 
    135    });
    136 
    137                         break;
    138 
    139                     default:
    140 
    141                         break;
    142 
    143                 }
    144             };
    145 
    146             // Register to handle the following system transpot control buttons.
    147 
    148             systemControls.IsPlayEnabled = true;
    149 
    150             systemControls.IsPauseEnabled = true;
    151             #endregion
    152             musicCoverArt = niy;
    153             #region SettingsSerializer
    154             if (settings.Values.Count == 0)
    155             {
    156                 settings.Values["userName"] = "User";
    157                 app.UserName = (string)settings.Values["userName"];
    158                 settings.Values["itemType"] = 1;
    159                 GridType = (int)settings.Values["itemType"] == 1;
    160 
    161                 settings.Values["musicPlayer"] = "1";
    162                 settings.Values["picturesPlayer"] = "1";
    163                 settings.Values["videoPlayer"] = "1";
    164                 settings.Values["ebookViewer"] = "1";
    165                 settings.Values["musThumbnail"] = "0";
    166                 settings.Values["vidThumbnail"] = "0";
    167                 settings.Values["picThumbnail"] = "0";
    168             }
    169             else
    170             {
    171                 app.UserName = (string)settings.Values["userName"];
    172                 GridType = (int)settings.Values["itemType"] == 1;
    173             }
    174             ChangeTemplate();
    175             #endregion
    176             #region Orientation
    177             Window.Current.SizeChanged += Current_SizeChanged;
    178             #endregion
    179             #region MediaPlayerDispatcherInitialization
    180             musicDispatcher.Interval = TimeSpan.FromMilliseconds(1000);
    181 
    182             mediaPlayer.MediaFailed += async (s, t) =>
    183             {
    184                 await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, delegate
    185                 {
    186                     UpdateMusic("no media", "", TimeSpan.FromSeconds(0));
    187                     musicSlider.Value = 0;
    188                     playPause.Content = "5";
    189                     currentDuration.Text = "--:--";
    190                     mediaDuration.Text = "--:--";
    191                     if (musicDispatcher.IsEnabled)
    192                         musicDispatcher.Stop();
    193                 });
    194             };
    195 
    196             mediaPlayer.MediaEnded += async (s, t) =>
    197             {
    198                 await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, delegate
    199                 {
    200                     UpdateMusic("no media", "", mediaPlayer.NaturalDuration.TimeSpan);
    201                     musicSlider.Value = 0;
    202                     playPause.Content = "5";
    203                     currentDuration.Text = "--:--";
    204                     mediaDuration.Text = "--:--";
    205                     musicDispatcher.Stop();
    206                 });
    207             };
    208             musicDispatcher.Tick += (s, t) =>
    209             {
    210                 musicSlider.Value = mediaPlayer.Position.TotalSeconds;
    211                 currentDuration.Text = mediaPlayer.Position.Minutes + ":" + mediaPlayer.Position.Seconds;
    212 
    213             };
    214             #endregion
    215             #region CriticalStartup
    216             HideStatusBar();
    217             Loaded += MainPageLoaded;
    218             HardwareButtons.BackPressed += HardwareButtons_BackPressed;
    219             #endregion
    220         }
    221 
    222 
    223         #region FileOperationsNotifier
    224 
    225         private void PasteBarSelectionChanged(object sender, SelectionChangedEventArgs e)
    226         {
    227             if (PasteFlipView.SelectedIndex == 0)
    228                 IS_FILE_MOVE = false;
    229             else IS_FILE_MOVE = true;
    230         }
    231         #endregion
    232 
    233         #region MainEvents
    234         private void MainPageLoaded(object sender, RoutedEventArgs e)
    235         {
    236             SDLoad.Begin();
    237             PhoneLoad.Begin();
    238             GetSDRoot();
    239             gridScrollViewer = SDGridView.GetFirstLogicalChildByType<ScrollViewer>(false);
    240             gridScrollViewer.VerticalScrollMode = ScrollMode.Auto;
    241             LoadMemoryData();
    242             //SettingsTab.Height = Window.Current.Bounds.Width * 2 / 3;
    243             PasteFlipView.SelectionChanged += PasteBarSelectionChanged;
    244             AppearancePanel.Begin();
    245             SubFrame.ContentTransitions = new TransitionCollection { new PaneThemeTransition { Edge = EdgeTransitionLocation.Bottom } };
    246 
    247         }
    248         private async void HideStatusBar()
    249         {
    250             StatusBar statusBar = Windows.UI.ViewManagement.StatusBar.GetForCurrentView();
    251 
    252             // Hide the status bar
    253             await statusBar.HideAsync();
    254         }
    255         public void OpenDialog()
    256         {
    257             if (!this.DialogBox.IsOpen)
    258             {
    259                 this.DialogBox.IsOpen = true;
    260                 this.DialogBox.LeftButtonHandler += ExitApplicaton;
    261             }
    262         }
    263         #region Navigaion Methods
    264         protected override void OnNavigatedTo(NavigationEventArgs e)
    265         {
    266 
    267         }
    268         #endregion
    269 
    270         #region BackButtonHandler
    271         public async void HardwareButtons_BackPressed(object sender, BackPressedEventArgs e)
    272         {
    273             e.Handled = true;
    274             if (PictureDisplayer.Visibility == Visibility.Visible)
    275             {
    276                 PictureFlipView.Items.Clear();
    277                 PictureDisplayer.Visibility = Visibility.Collapsed;
    278             }
    279             else if (FileMoveDialog.Visibility == Visibility.Visible)
    280             {
    281                 CloseDialog(2);
    282             }
    283             else if (SubFrameGrid.Visibility == Visibility.Visible)
    284             {
    285                 CloseDialog(0);
    286             }
    287             else if (IsMediaOpen)
    288             {
    289                 MediaOpenRev.Begin();
    290                 IsMediaOpen = false;
    291             }
    292 
    293             else if (SortMenu.Visibility == Visibility.Visible)
    294             {
    295                 SortMenu.Visibility = Visibility.Collapsed;
    296             }
    297             else if (WebBrowser.Visibility == Visibility.Visible)
    298             {
    299                 WebBrowser.Visibility = Visibility.Collapsed;
    300             }
    301             else if (this.SideMenu.IsDrawerOpen == true)
    302             {
    303                 this.SideMenu.CloseDrawer();
    304             }
    305             else if (SDGridView.SelectionMode == ListViewSelectionMode.Multiple)
    306             {
    307                 UnselectAll();
    308             }
    309             else if (InZipRoot)
    310             {
    311                 GetFilesAndFolder(CurrentFolder);
    312                 InZipRoot = false;
    313             }
    314             else if (!this.Addresser.Root)
    315             {
    316                 try
    317                 {
    318                     int curFoldCharNm = CurrentFolder.Path.LastIndexOf(CurrentFolder.Name);
    319                     StorageFolder sf = await StorageFolder.GetFolderFromPathAsync(CurrentFolder.Path.Remove(curFoldCharNm));
    320                     this.Addresser.RemoveLast();
    321                     GetFilesAndFolder(sf);
    322                 }
    323                 catch { }
    324             }
    325             else
    326             {
    327                 OpenDialog();
    328             }
    329         }
    330         #endregion
    331 
    332         #endregion
    333         #region Music
    334         #region MusicEvents
    335         //private void MusicSegmentChanged(object sender, RangeBaseValueChangedEventArgs e)
    336         //{
    337         //    //    if (!(mediaPlayer.CurrentState == MediaPlayerState.Closed))
    338         //    //    {
    339         //    //        if (mediaPlayer.CanSeek)
    340         //    //        {
    341         //    //            mediaPlayer.Position = TimeSpan.FromSeconds(e.NewValue);
    342         //    //        }
    343         //    //    }
    344         //    //    else
    345         //    //    {
    346         //    //        musicSlider.Value = 0;
    347         //    //    }
    348         //}
    349         internal async void PlayMedia(IStorageFile selectedItem)
    350         {
    351 
    352             mediaPlayer.Source = new Uri(selectedItem.Path);
    353 
    354             mediaPlayer.MediaOpened += async (s, t) =>
    355             {
    356                 await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, delegate
    357                 {
    358                     musicSlider.Maximum = mediaPlayer.NaturalDuration.TimeSpan.TotalSeconds;
    359                     playPause.Content = "8";
    360                     UpdateMusic(title, artist, mediaPlayer.NaturalDuration.TimeSpan);
    361                     musicDispatcher.Start();
    362                 });
    363             };
    364             mediaPlayer.Play();
    365 
    366             #region TagLib AlbumArt
    367             Tag tags = null;
    368             var fileStream = await selectedItem.OpenStreamForReadAsync();
    369             try
    370             {
    371                 var tagFile = TagLib.File.Create(new StreamFileAbstraction(selectedItem.Name, fileStream, fileStream));
    372                 if (selectedItem.FileType == ".mp3" || selectedItem.FileType == ".wma")
    373                     tags = tagFile.GetTag(TagTypes.Id3v2);
    374                 else if (selectedItem.FileType == ".m4a")
    375                     tags = tagFile.GetTag(TagLib.TagTypes.MovieId);
    376                 try
    377                 {
    378                     title = tags.Title;
    379                 }
    380                 catch (NullReferenceException)
    381                 {
    382                     title = selectedItem.Name;
    383                 }
    384                 try
    385                 {
    386                     artist = String.Concat(tags.Performers);
    387                 }
    388                 catch (NullReferenceException)
    389                 {
    390                     artist = String.Empty;
    391                 }
    392                 if (tags.Pictures != null)
    393                 {
    394                     try
    395                     {
    396                         MemoryStream ms = new MemoryStream(tags.Pictures[0].Data.Data);
    397                         WriteableBitmap wm = null;
    398                          var wwmV = wm.FromStream(ms, Windows.Graphics.Imaging.BitmapPixelFormat.Unknown);
    399                         await wwmV.ContinueWith(delegate
    400                         {
    401 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
    402                             Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    403 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
    404                             {
    405                                 ms.Dispose();
    406                             ImageBrush im = new ImageBrush();
    407                             im.ImageSource = wwmV.Result;
    408                             im.Stretch = Stretch.UniformToFill;
    409                                 musicArt.Visibility = Visibility.Collapsed;
    410                                 imageContainerMedia.Background = im;
    411                             });
    412                         });
    413                     }
    414 
    415                     catch (IndexOutOfRangeException)
    416                     {
    417                         imageContainerMedia.Background = (SolidColorBrush)App.Current.Resources["PhoneChromeBrush"];
    418                         musicArt.Visibility = Visibility.Visible;
    419                     }
    420                     catch (UnauthorizedAccessException)
    421                     {
    422                     }
    423                     #endregion
    424                 }
    425                 else
    426                 {
    427                     imageContainerMedia.Background = (SolidColorBrush)App.Current.Resources["PhoneChromeBrush"];
    428                     musicArt.Visibility = Visibility.Visible;
    429                 }
    430             }
    431             catch
    432             {
    433                 imageContainerMedia.Background = (SolidColorBrush)App.Current.Resources["PhoneChromeBrush"];
    434                 musicArt.Visibility = Visibility.Visible;
    435             }
    436             MusicStatusUpdate();
    437         }
    438 
    439         private void UpdateMusic(string songName, string songArtist, TimeSpan duration)
    440         {
    441             try
    442             {
    443                 SongName.Text = songName;
    444                 SongArtist.Text = songArtist;
    445                 mediaDuration.Text = duration.Minutes + ":" + duration.Seconds;
    446             }
    447             catch
    448             {
    449                 SongName.Text = "no media";
    450                 SongArtist.Text = "";
    451                 mediaDuration.Text = "--:--";
    452             }
    453         }
    454         #endregion
    455         #region MusicMenu
    456         public void MusicMenuClick()
    457         {
    458             if (IsMediaOpen)
    459             {
    460                 MediaOpenRev.Begin();
    461                 IsMediaOpen = false;
    462                 //OpenMusic.Content = "u";
    463                 return;
    464             }
    465             else if (!IsMediaOpen)
    466             {
    467                 //BitmapImage bm = new BitmapImage(new Uri("ms-appx:///SampleData/SampleDataSource1/SampleDataSource1_Files/image01.png", UriKind.RelativeOrAbsolute));
    468                 //var wb = await WinRTXamlToolkit.Imaging.WriteableBitmapFromBitmapImageExtension.FromBitmapImage(bm);
    469                 //ColorSampler cs = new ColorSampler();
    470                 //WriteableBitmap wd = wb;
    471                 //MusicDock.Background = new SolidColorBrush(cs.GetPixel(wd));
    472                 MediaOpen.Begin();
    473                 IsMediaOpen = true;
    474                 //OpenMusic.Content = "d";
    475                 return;
    476             }
    477         }
    478 
    479         private void PlayCurrent(object sender, RoutedEventArgs e)
    480         {
    481             if (mediaPlayer.CurrentState == MediaElementState.Playing)
    482             {
    483                 mediaPlayer.Pause();
    484                 playPause.Content = "5";
    485                 DurationBlink.Begin();
    486             }
    487             else if (mediaPlayer.CurrentState == MediaElementState.Paused)
    488             {
    489                 mediaPlayer.Play();
    490                 playPause.Content = "8";
    491                 DurationBlink.Stop();
    492             }
    493 
    494             else if (mediaPlayer.CurrentState == MediaElementState.Stopped)
    495             {
    496                 KnownFolders.MusicLibrary.GetFilesAsync().Completed += (es,st)=>
    497                 {
    498                     mediaPlayer.Source = new Uri(es.GetResults().First().Path);
    499                     mediaPlayer.Play();
    500                     playPause.Content = "8";
    501                 };
    502 
    503             }
    504 
    505         }
    506         #endregion
    507         #endregion
    508 
    509         #region MediaMaipulations
    510         private void mediaFragManipDelta(object sender, ManipulationDeltaRoutedEventArgs e)
    511         {
    512             if (e.Cumulative.Translation.X > 0)
    513                 MediaFragment.RenderTransform = new CompositeTransform { TranslateX = e.Cumulative.Translation.X };
    514             else if (e.Delta.Translation.X < -25)
    515             {
    516                 MediaOpen.Begin();
    517                 IsMediaOpen = true;
    518             }
    519         }
    520 
    521         private void mediaFragManipCompleted(object sender, ManipulationCompletedRoutedEventArgs e)
    522         {
    523             var transform = (CompositeTransform)MediaFragment.RenderTransform;
    524             if (transform == null) return;
    525             var up = transform.TranslateX;
    526 
    527             var snapLimit = ActualHeight / 1.1;
    528 
    529             // Get init position of _listFragment
    530             var initialPosition = ActualHeight;
    531 
    532             // If current left coordinate is smaller than snap limit, close drawer
    533             if (Math.Abs(initialPosition - up) < snapLimit)
    534             {
    535                 MediaOpenRev.Begin();
    536                 IsMediaOpen = false;
    537             }
    538             else
    539             {
    540                 MediaOpen.Begin();
    541                 IsMediaOpen = true;
    542             }
    543         }
    544         #endregion
    545 
    546         #region NotifyHelpers
    547         public void NotifyUser(string info)
    548         {
    549             statusMsg.Text = info;
    550         }
    551 
    552         public void AI(string header, string msg)
    553         {
    554             aiText.Text = header;
    555             aiSubText.Text = msg;
    556             aiBorder.Visibility = Visibility.Visible;
    557             DispatcherTimer dt = new DispatcherTimer();
    558             dt.Interval = new TimeSpan(0, 0, 4);
    559             dt.Tick += delegate
    560             {
    561                 aiBorder.Visibility = Visibility.Collapsed;
    562                 dt.Stop();
    563             };
    564             dt.Start();
    565         }
    566         #endregion
    567         #region Pictures
    568 
    569 
    570         public void DisplayPhoto(IStorageFile selectedItem)
    571         {
    572             FlipViewItem fvi = new FlipViewItem();
    573             ScrollViewer scv = new ScrollViewer();
    574             Image im = new Image();
    575             BitmapImage bi = new BitmapImage(new Uri(selectedItem.Path));
    576             im.Source = bi;
    577             scv.Content = im;
    578             fvi.Content = scv;
    579             PictureFlipView.Items.Add(fvi);
    580             PictureDisplayer.Visibility = Visibility.Visible;
    581         }
    582 
    583         #endregion
    584 
    585 
    586         #region MainGrid
    587         public void CloseDrawer()
    588         {
    589             SideMenu.CloseDrawer();
    590         }
    591 
    592 
    593 
    594         private void ChangeTemplate()
    595         {
    596             if (!GridType)
    597             {
    598                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["ListViewItemsPanel"];
    599                 SDGridView.ItemTemplate = (DataTemplate)Resources["ListFoldersView"];
    600                 gridList.ContentText = "list";
    601                 gridList.ImageText = "b";
    602                 settings.Values["itemType"] = 0;
    603                 GridType = false;
    604             }
    605             else
    606             {
    607                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
    608                 SDGridView.ItemTemplate = (DataTemplate)Resources["GridFoldersView"];
    609                 gridList.ContentText = "grid";
    610                 gridList.ImageText = "N";
    611                 settings.Values["itemType"] = 1;
    612                 GridType = true;
    613             }
    614         }
    615 
    616         private async void GetSDRoot()
    617         {
    618 
    619             if (ApplicationData.Current.LocalSettings.Values.ContainsKey("FolderTokenSettingsKey"))
    620             {
    621                 string token = (string)ApplicationData.Current.LocalSettings.Values["FolderTokenSettingsKey"];
    622                 // if we do, use it to get the StorageFolder instance
    623                 folder = await StorageApplicationPermissions.FutureAccessList.GetFolderAsync(token);
    624                 this.Addresser.Reset();
    625                 try
    626                 {
    627                     GetFilesAndFolder(folder);
    628                     RootFolder.Text = "3";
    629                     IsMusicLibraryOpen = false;
    630                     IsVideoLibraryOpen = false;
    631                     IsPictureLibraryOpen = false;
    632                 }
    633                 catch (Exception ex)
    634                 {
    635                     ShowStatus(ex.Message);
    636                     //AI("no sdcard is detected", 2);
    637                 }
    638             }
    639         }
    640 
    641 
    642         #region UserFolderCommunication
    643 
    644 
    645         private void Reset()
    646         {
    647             SDGridView.ItemsSource = null;
    648             sd.Clear();
    649         }
    650 
    651 
    652         #endregion
    653         #region OrientationHelpers
    654         private void Current_SizeChanged(object sender, Windows.UI.Core.WindowSizeChangedEventArgs e)
    655         {
    656             //var b = Window.Current.Bounds;
    657             VisualStateManager.GoToState(this, "Portrait", false);
    658         }
    659         public bool IsVertical()
    660         {
    661             if (Window.Current.Bounds.Height > Window.Current.Bounds.Width) return true;
    662             else return false;
    663         }
    664         #endregion
    665         #endregion
    666 
    667 
    668 
    669         #region ExitApplication
    670 
    671         private void ExitApplicaton(object sender, RoutedEventArgs e)
    672         {
    673             Application.Current.Exit();
    674         }
    675         #endregion
    676         #region FileLister
    677         public async void GetFilesAndFolder(IStorageFolder anyFolder)
    678         {
    679             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async delegate
    680             {
    681                 ShowStatus(anyFolder.Path);
    682                 if (anyFolder != null)
    683                 {
    684                     Items = null;
    685                     sd.Clear();
    686                     SDGridView.ItemsSource = null;
    687                     CurrentFolder = anyFolder;
    688                     Items = await anyFolder.GetItemsAsync();
    689                     if (Items.Count == 0)
    690                     {
    691                         CurrentFolder = anyFolder;
    692                         headerText.Text = anyFolder.Name;
    693                         sd.Clear();
    694                         switch (anyFolder.Path)
    695                         {
    696                             case @"D:\Documents":
    697                                 //display documents missing sad face
    698                                 break;
    699                             case @"D:\Music":
    700                                 //display music missing sad face
    701                                 break;
    702                             case @"D:\Videos":
    703                                 //display videos missing sad face
    704                                 break;
    705                             case @"D:\Pictures":
    706                                 //display pictures missing sad face
    707                                 break;
    708                             default:
    709                                 EmptyFolderStack.Visibility = Visibility.Visible;
    710                                 //default options for other empty folders
    711                                 break;
    712 
    713                         }
    714                         return;
    715                     }
    716                     //if (GridType)
    717                     //    SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
    718                     //else SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["ListViewItemsPanel"];
    719                     else
    720                     {
    721                         EmptyFolderStack.Visibility = Visibility.Collapsed;
    722                         foreach (IStorageItem Data in Items)
    723                         {
    724                             if (Data.IsOfType(StorageItemTypes.Folder))
    725                             {
    726                                 IStorageFolder Folder;
    727                                 Folder = (IStorageFolder)Data;
    728                                 //IReadOnlyList<IStorageItem> item = await Folder.GetItemsAsync();
    729                                 headerText.Text = anyFolder.Name;
    730                                 if (CurrentFolder.Path == @"D:\")
    731                                 {
    732                                     if (Folder.Name == "Videos") sd.Add(new sdlist(Folder.Name, "o", ""));
    733                                     else if (Folder.Name == "Pictures") sd.Add(new sdlist(Folder.Name, "f", ""));
    734                                     else if (Folder.Name == "Music") sd.Add(new sdlist(Folder.Name, "g", ""));
    735                                     else if (Folder.Name == "Downloads") sd.Add(new sdlist(Folder.Name, "e", ""));
    736                                     else if (Folder.Name == "Documents") sd.Add(new sdlist(Folder.Name, "n", ""));
    737                                     else sd.Add(new sdlist(Folder.Name, "h", ""));
    738                                 }
    739                                 else sd.Add(new sdlist(Folder.Name, "h", ""));
    740                             }
    741                             if (Data.IsOfType(StorageItemTypes.File))
    742                             {
    743                                 IStorageFile File = (IStorageFile)Data;
    744                                 string fn = File.Name;
    745                                 string fi = File.FileType;
    746                                 #region FileTypes
    747                                 if (fi == ".mp3")
    748                                 {
    749                                     if (((string)settings.Values["musThumbnail"] == "1"))
    750                                     {
    751 
    752                                         #region Mp3
    753 
    754                                         //var fileStream = await File.OpenStreamForReadAsync();
    755                                         //var tagFile = TagLib.File.Create(new StreamFileAbstraction(File.Name, fileStream, fileStream));
    756                                         //var tags = tagFile.GetTag(TagTypes.Id3v2);
    757                                         //try
    758                                         //{
    759                                         //    if (tags.Pictures != null)
    760                                         //    {
    761                                         //        MemoryStream ms = new MemoryStream(tags.Pictures[0].Data.Data);
    762                                         //        WriteableBitmap wm = null;
    763                                         //        WriteableBitmap wwm = await wm.FromStream(ms, Windows.Graphics.Imaging.BitmapPixelFormat.Unknown);
    764 
    765                                         //        ms.Dispose();
    766                                         //        ImageBrush im = new ImageBrush();
    767                                         //        im.ImageSource = wwm;
    768                                         //        im.Stretch = Stretch.UniformToFill;
    769                                         //        sd.Add(new sdlist(fn, im, ""));
    770                                         //        #endregion
    771                                         //    }
    772                                         //}
    773                                         //catch (IndexOutOfRangeException ex)
    774                                         //{
    775                                         //    BitmapImage bm = new BitmapImage(new Uri("ms-appx:///Assets/IMG-20150528-WA0003.jpg", UriKind.Absolute));
    776                                         //    ImageBrush im = new ImageBrush();
    777                                         //    im.ImageSource = bm;
    778                                         //    sd.Add(new sdlist(fn, im, ""));
    779                                         //}
    780                                         //catch (Exception ex)
    781                                         //{
    782                                         //    AI(ex.Message, 2);
    783                                         //}
    784                                         #endregion
    785                                     }
    786                                     else sd.Add(new sdlist(fn, "m"));
    787 
    788                                 }
    789                                 else if (fi == ".wma")
    790                                 {
    791                                     if (((string)settings.Values["musThumbnail"] == "1"))
    792                                     { }
    793                                     #region wma-work in progress
    794 
    795                                     //var fileStream = await File.OpenStreamForReadAsync();
    796                                     //var tagFile = TagLib.File.Create(new StreamFileAbstraction(File.Name, fileStream, fileStream));
    797                                     //var tags = tagFile.GetTag(TagTypes.Id3v2);
    798                                     //try
    799                                     //{
    800                                     //    if (tags.Pictures != null)
    801                                     //    {
    802                                     //        MemoryStream ms = new MemoryStream(tags.Pictures[0].Data.Data);
    803                                     //        WriteableBitmap wm = null;
    804                                     //        WriteableBitmap wwm = await wm.FromStream(ms, Windows.Graphics.Imaging.BitmapPixelFormat.Unknown);
    805 
    806                                     //        ms.Dispose();
    807                                     //        ImageBrush im = new ImageBrush();
    808                                     //        im.ImageSource = wwm;
    809                                     //        im.Stretch = Stretch.UniformToFill;
    810                                     //        sd.Add(new sdlist(fn, im, ""));
    811                                     //        #endregion
    812                                     //    }
    813                                     //}
    814                                     //catch (IndexOutOfRangeException ex)
    815                                     //{
    816                                     //    BitmapImage bm = new BitmapImage(new Uri("ms-appx:///Assets/IMG-20150528-WA0003.jpg", UriKind.Absolute));
    817                                     //    ImageBrush im = new ImageBrush();
    818                                     //    im.ImageSource = bm;
    819                                     //    sd.Add(new sdlist(fn, im, ""));
    820                                     //}
    821                                     //catch (Exception ex)
    822                                     //{
    823                                     //    AI(ex.Message, 2);
    824                                     //}
    825                                     #endregion
    826                                     else sd.Add(new sdlist(fn, "m"));
    827 
    828                                 }
    829                                 else if (fi == ".docx")
    830                                 {
    831                                     sd.Add(new sdlist(fn, "k"));
    832 
    833                                 }
    834                                 else if (fi == ".png")
    835                                 {
    836                                     if (((string)settings.Values["picThumbnail"] == "1"))
    837                                         await GetThumbnailImageAsync((StorageFile)File, ThumbnailMode.ListView);
    838                                     else sd.Add(new sdlist(fn, "p"));
    839                                 }
    840                                 else if (fi == ".jpg")
    841                                 {
    842                                     if (((string)settings.Values["picThumbnail"] == "1"))
    843                                         await GetThumbnailImageAsync((StorageFile)File, ThumbnailMode.ListView);
    844                                     else sd.Add(new sdlist(fn, "p"));
    845                                 }
    846                                 else if (fi == ".mp4")
    847                                 {
    848                                     if (((string)settings.Values["vidThumbnail"] == "1"))
    849                                     {
    850                                         try
    851                                         {
    852                                             await GetThumbnailImageAsync((StorageFile)File, ThumbnailMode.ListView);
    853                                         }
    854                                         catch
    855                                         {
    856                                             sd.Add(new sdlist(fn, "v"));
    857                                         }
    858                                     }
    859                                     else sd.Add(new sdlist(fn, "v"));
    860                                 }
    861                                 else if (fi == ".mov")
    862                                 {
    863                                     if (((string)settings.Values["vidThumbnail"] == "1"))
    864                                     {
    865                                         try
    866                                         {
    867                                             await GetThumbnailImageAsync((StorageFile)File, ThumbnailMode.ListView);
    868                                         }
    869                                         catch
    870                                         {
    871                                             sd.Add(new sdlist(fn, "v"));
    872                                         }
    873                                     }
    874                                     else sd.Add(new sdlist(fn, "v"));
    875                                 }
    876                                 else if (fi == ".zip")
    877                                 {
    878                                     sd.Add(new sdlist(fn, "z"));
    879 
    880                                 }
    881                                 else if (fi == ".cs")
    882                                 {
    883                                     sd.Add(new sdlist(fn, "c"));
    884                                 }
    885                                 else if (fi == ".pdf")
    886                                 {
    887                                     sd.Add(new sdlist(fn, "b"));
    888                                 }
    889                                 else if (fi == ".vcf")
    890                                 {
    891                                     sd.Add(new sdlist(fn, "l"));
    892                                 }
    893                                 else if (fi == ".doc")
    894                                 {
    895                                     sd.Add(new sdlist(fn, "k"));
    896                                 }
    897                                 else if (fi == ".xlx")
    898                                 {
    899                                     sd.Add(new sdlist(fn, "j"));
    900                                 }
    901                                 else if (fi == ".xlsx")
    902                                 {
    903                                     sd.Add(new sdlist(fn, "j"));
    904                                 }
    905                                 else if (fi == ".7z")
    906                                 {
    907                                     sd.Add(new sdlist(fn, "7"));
    908                                 }
    909                                 else if (fi == ".xml")
    910                                 {
    911                                     sd.Add(new sdlist(fn, "x"));
    912                                 }
    913                                 else if (fi == ".txt")
    914                                 {
    915                                     sd.Add(new sdlist(fn, "a"));
    916                                 }
    917                                 else if (fi == ".rar")
    918                                 {
    919                                     sd.Add(new sdlist(fn, "r"));
    920                                 }
    921                                 else
    922                                 {
    923                                     sd.Add(new sdlist(fn, "i"));
    924 
    925                                 }
    926                                 #endregion
    927                             }
    928                         }
    929                     }
    930                 }
    931                 //else AI("This folder contains no items", 2);
    932                 SDGridView.ItemsSource = sd;
    933             });
    934         }
    935 
    936         #endregion
    937         #region LateralMenu
    938         private void Menu_Click(object sender, RoutedEventArgs e)
    939         {
    940             if (SideMenu.IsDrawerOpen == false)
    941             {
    942                 SideMenu.OpenDrawer();
    943             }
    944             else
    945             {
    946                 SideMenu.CloseDrawer();
    947             }
    948         }
    949         #endregion
    950         #region ListBox
    951         Object preObj = null;
    952         Object curObj = null;
    953         SideBarMenuButton stkChildren = null;
    954 
    955         private void SideMenuLeft_SelectionChanged(object sender, SelectionChangedEventArgs e)
    956         {
    957             ListBox lBox = (ListBox)sender;
    958             curObj = lBox.SelectedItem;
    959             stkChildren = (SideBarMenuButton)curObj;
    960             if (stkChildren.ContentText == "Settings") return;
    961             if (preObj != null)
    962             {
    963                 SideBarMenuButton preSBMB = (SideBarMenuButton)preObj;
    964                 preSBMB.BackgroundColor = null;
    965             }
    966             preObj = curObj;
    967             stkChildren.BackgroundColor = (SolidColorBrush)Application.Current.Resources["PhoneAccentBrush"];
    968         }
    969         #endregion
    970         #region MenuHandlers
    971         #region SDCard
    972         private async void SDCardEnumerator(object sender, RoutedEventArgs e)
    973         {
    974             if (IsSDLoading)
    975             {
    976                 textBlock.Visibility = Visibility.Visible;
    977             }
    978             if (!IsSDLoading)
    979             {
    980                 StorageFolder folder;
    981                 // check if we already have a token
    982                 if (ApplicationData.Current.LocalSettings.Values.ContainsKey("FolderTokenSettingsKey"))
    983                 {
    984                     string token = (string)ApplicationData.Current.LocalSettings.Values["FolderTokenSettingsKey"];
    985                     // if we do, use it to get the StorageFolder instance
    986                     folder = await StorageApplicationPermissions.FutureAccessList.GetFolderAsync(token);
    987                     this.Addresser.Reset();
    988                     await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, delegate
    989                     {
    990                         IsMusicLibraryOpen = false;
    991                         IsVideoLibraryOpen = false;
    992                         IsPictureLibraryOpen = false;
    993                         headerText.Text = "SD Card";
    994                         RootFolder.Text = "3";
    995                         if (GridType)
    996                         {
    997                             SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
    998                             SDGridView.ItemTemplate = (DataTemplate)Resources["GridFoldersView"];
    999                         }
   1000                         else
   1001                         {
   1002                             SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["ListViewItemsPanel"];
   1003                             SDGridView.ItemTemplate = (DataTemplate)Resources["ListFoldersView"];
   1004                         }
   1005                         GetFilesAndFolder(folder);
   1006                     });
   1007                 }
   1008                 else
   1009                 {
   1010                     // if we don't, this is the first time the code is being executed; user has to give
   1011                     // us a consent to use the folder
   1012                     FolderPicker folderPicker = new FolderPicker();
   1013                     folderPicker.FileTypeFilter.Add("*");
   1014                     folderPicker.PickFolderAndContinue();
   1015 
   1016                 }
   1017             }
   1018         }
   1019         #endregion
   1020         #region Phone
   1021         private void PhoneStorageEnumerator(object sender, TappedRoutedEventArgs e)
   1022         {
   1023 
   1024         }
   1025         #endregion
   1026         #region Pictures
   1027         private async void PicturesLibraryTapped(object sender, RoutedEventArgs e)
   1028         {
   1029             IsPictureLibraryOpen = true;
   1030             var picturesAlbums = await KnownFolders.PicturesLibrary.GetItemsAsync();
   1031             if (picturesAlbums.Count != 0)
   1032             {
   1033                 sd.Clear();
   1034                 SDGridView.ItemsSource = null;
   1035                 headerText.Text = "Pictures";
   1036                 RootFolder.Text = "M";
   1037                 this.Addresser.Reset();
   1038                 SDGridView.ItemTemplate = (DataTemplate)Resources["PicturesView"];
   1039                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1040                 Items = picturesAlbums;
   1041                 foreach (var pFo in picturesAlbums)
   1042                 {
   1043                     try
   1044                     {
   1045                         if (pFo.IsOfType(StorageItemTypes.Folder))
   1046                             await GetThumbnailImageAsync((StorageFolder)pFo, ThumbnailMode.PicturesView);
   1047                         else await GetThumbnailImageAsync((StorageFile)pFo, ThumbnailMode.PicturesView);
   1048                     }
   1049                     catch (Exception ex)
   1050                     {
   1051                         ShowStatus(ex.Message + ex.Source + ex.StackTrace);
   1052                     }
   1053 
   1054                 }
   1055                 SDGridView.ItemsSource = sd;
   1056             }
   1057             else
   1058             {
   1059                 AI("no pictures", "there no pictures in your phone");
   1060             }
   1061         }
   1062 
   1063         private void SettingsPage(object sender, RoutedEventArgs e)
   1064         {
   1065 
   1066             if (!Frame.Navigate(typeof(SettingsPage)))
   1067             {
   1068                 throw new Exception("Failed to create scenario list");
   1069             }
   1070         }
   1071 
   1072         #endregion
   1073         #region Video
   1074         private async void VideoLibraryTapped(object sender, RoutedEventArgs e)
   1075         {
   1076             Items = await KnownFolders.VideosLibrary.GetItemsAsync();
   1077             if (Items.Count != 0)
   1078             {
   1079                 sd.Clear();
   1080                 SDGridView.ItemsSource = null;
   1081                 SDGridView.ItemTemplate = VideosView;
   1082                 SDGridView.ItemsPanel = GridViewItemsPanel;
   1083                 this.Addresser.Reset();
   1084                 RootFolder.Text = ")";
   1085                 headerText.Text = "Videos";
   1086                 IsVideoLibraryOpen = true;
   1087                 foreach (var pFo in Items)
   1088                 {
   1089                     try
   1090                     {
   1091                         if (pFo.IsOfType(StorageItemTypes.Folder))
   1092                             await GetThumbnailImageAsync((StorageFolder)pFo, ThumbnailMode.VideosView);
   1093                         else await GetThumbnailImageAsync((StorageFile)pFo, ThumbnailMode.VideosView);
   1094                     }
   1095                     catch (Exception)
   1096                     {
   1097                         //AI(ex.Message + ex.Source + ex.StackTrace, 2);
   1098                     }
   1099 
   1100                 }
   1101                 SDGridView.ItemsSource = sd;
   1102             }
   1103             else
   1104             {
   1105                 AI("no videos", "there no videos in your phone");
   1106             }
   1107         }
   1108 
   1109         private void ChangeListSource(int listType)
   1110         {
   1111             SDGridView.ItemsSource = null;
   1112             switch (listType)
   1113             {
   1114                 
   1115                 case 0:
   1116                     sd.Clear();
   1117                     SDGridView.ItemsSource = sd;
   1118                     break;
   1119                 case 1:
   1120                     music.Clear();
   1121                     SDGridView.ItemsSource = music;
   1122                     IsMusicLibraryOpen = true;
   1123                     break;
   1124                 case 2:
   1125                     picture.Clear();
   1126                     SDGridView.ItemsSource = picture;
   1127                     IsPictureLibraryOpen = true;
   1128                     break;
   1129                 case 3:
   1130                     video.Clear();
   1131                     SDGridView.ItemsSource = video;
   1132                     IsVideoLibraryOpen = true;
   1133                     break;
   1134                 default:
   1135                     throw new NotImplementedException();
   1136             }
   1137         }
   1138 
   1139         #region Music
   1140         private async void MusicLibraryClick(object sender, RoutedEventArgs e)
   1141         {
   1142             var musicFolder = KnownFolders.MusicLibrary;
   1143             IReadOnlyList<IStorageItem> musicItems = await musicFolder.GetItemsAsync();
   1144             ChangeListSource(1);
   1145             if (musicItems.Count != 0)
   1146             {
   1147                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1148                 SDGridView.ItemTemplate = (DataTemplate)Resources["MusicsView"];
   1149                 RootFolder.Text = "y";
   1150                 this.Addresser.Reset();
   1151                 Items = musicItems;
   1152                 IsMusicLibraryOpen = true;
   1153                 headerText.Text = "Music";
   1154                 await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async delegate
   1155                 {
   1156                     foreach (var pFo in musicItems)
   1157                     {
   1158                         try
   1159                         {
   1160                             if (pFo.IsOfType(StorageItemTypes.Folder))
   1161                             {
   1162                                 music.Add(new MusicList(pFo.Name, 0));//0 is passed as dummy count, the dummy value should be replaced by the folder's children count.
   1163                             }
   1164                             else
   1165                             {
   1166 
   1167                                 IStorageFile File = (IStorageFile)pFo;
   1168                                 if (File.FileType == ".mp3")
   1169                                 {
   1170                                     var fileStream = await File.OpenStreamForReadAsync();
   1171                                     var tagFile = TagLib.File.Create(new StreamFileAbstraction(File.Name, fileStream, fileStream));
   1172                                     var tags = tagFile.GetTag(TagTypes.Id3v2);
   1173                                     try
   1174                                     {
   1175                                         if (tags.Pictures != null)
   1176                                         {
   1177                                             WriteableBitmap wm = null;
   1178 
   1179                                             try
   1180                                             {
   1181                                                 wm.FromByteArray(tags.Pictures[0].Data.Data);
   1182                                             }
   1183                                             catch (UnauthorizedAccessException)
   1184                                             {
   1185 
   1186                                             }
   1187                                             catch (NullReferenceException)
   1188                                             {
   1189 
   1190                                             }
   1191                                             ImageBrush im = new ImageBrush();
   1192                                             im.ImageSource = wm;
   1193                                             im.Stretch = Stretch.UniformToFill;
   1194                                             music.Add(new MusicList(tags.Title, tags.AlbumArtists[0], tags.Album, im));
   1195                                             #endregion
   1196                                         }
   1197                                     }
   1198                                     catch (IndexOutOfRangeException)
   1199                                     {
   1200                                         music.Add(new MusicList(pFo.Name, tags.AlbumArtists[0], tags.Album, null));
   1201                                     }
   1202                                 }
   1203                                 else if (File.FileType == ".m4a")
   1204                                     music.Add(new MusicList(pFo.Name,"","",null));
   1205                             }
   1206                         }
   1207                         catch (Exception ex)
   1208                         {
   1209                             ShowStatus(ex.Message + ex.Source + ex.StackTrace);
   1210                         }
   1211                     }
   1212                 });
   1213             }
   1214             else
   1215             {
   1216                 ShowStatus("no music content can be found :(");
   1217             }
   1218         }
   1219 
   1220         private async Task GetThumbnailImageAsync(StorageFile item, ThumbnailMode mode)
   1221         {
   1222             if (item == null)
   1223                 return;
   1224             using (var thumbnail = await item.GetThumbnailAsync(mode))
   1225             {
   1226                 if (thumbnail != null)
   1227                 {
   1228                     sd.Add(new sdlist(item.DisplayName, thumbnail, ""));
   1229                     return;
   1230                 }
   1231             }
   1232         }
   1233         //public async Task<bool> IsEmpty(IStorageFolder directory)
   1234         //{
   1235         //    var items = await directory.GetItemsAsync();
   1236         //    ShowStatus(directory.Path);
   1237         //    bool isEmpty = items.Count == 0;
   1238         //    if (isEmpty)
   1239         //    {
   1240         //        //Storyboard story = new Storyboard();
   1241         //        switch (directory.Path)
   1242         //        {
   1243 
   1244         //            case "D:/Documents":
   1245         //            //EmptyFolderStack.Visibility = Visibility.Visible;
   1246         //                break;
   1247         //            case "D:/Music":
   1248         //                EmptyFolderStack.Visibility = Visibility.Visible;
   1249         //                break;
   1250         //            default:
   1251         //                EmptyFolderStack.Visibility = Visibility.Visible;
   1252         //                break;
   1253 
   1254 
   1255         //        }
   1256         //        return true;
   1257         //    }
   1258         //    else
   1259         //    {
   1260         //        EmptyFolderStack.Visibility = Visibility.Collapsed;
   1261         //        return false;
   1262         //    }
   1263         //}
   1264         #endregion
   1265 
   1266         #endregion
   1267         #region ImageHelpers
   1268         public async Task GetThumbnailImageAsync(StorageFolder item, ThumbnailMode mode)
   1269         {
   1270             if (item == null)
   1271                 return;
   1272             using (var thumbnail = await item.GetThumbnailAsync(mode))
   1273             {
   1274                 if (thumbnail != null /*&& thumbnail.Type == ThumbnailType.Image && thumbnail.Type == ThumbnailType.Icon*/)
   1275                 {
   1276                     sd.Add(new sdlist(item.DisplayName, thumbnail, "2"));
   1277                     return;
   1278                 }
   1279             }
   1280         }
   1281         #endregion
   1282 
   1283         #region UI
   1284         public double PicHeight
   1285         {
   1286             get
   1287             {
   1288                 if (IsVertical()) return Window.Current.Bounds.Height / 3;
   1289                 else return Window.Current.Bounds.Width / 3;
   1290             }
   1291         }
   1292         public double PicWidth
   1293         {
   1294             get
   1295             {
   1296                 if (IsVertical()) return Window.Current.Bounds.Width / 2;
   1297                 else return Window.Current.Bounds.Height / 2;
   1298             }
   1299         }
   1300         public double ImageHeight
   1301         {
   1302             get
   1303             {
   1304                 if (IsVertical()) return Window.Current.Bounds.Height / 3.5;
   1305                 else return Window.Current.Bounds.Width / 3.5;
   1306             }
   1307         }
   1308         public double ImageWidth
   1309         {
   1310             get
   1311             {
   1312                 if (IsVertical()) return Window.Current.Bounds.Width / 2.2;
   1313                 else return Window.Current.Bounds.Height / 2.2;
   1314             }
   1315         }
   1316         public double Space
   1317         {
   1318             get { return Window.Current.Bounds.Height / 600; }
   1319         }
   1320         public double GridHeight
   1321         {
   1322             get
   1323             {
   1324                 if (IsVertical()) return Window.Current.Bounds.Height / 4;
   1325                 else return Window.Current.Bounds.Width / 4;
   1326             }
   1327         }
   1328         public double GridWidth
   1329         {
   1330             get
   1331             {
   1332                 if (IsVertical()) return Window.Current.Bounds.Width / 3;
   1333                 else return Window.Current.Bounds.Height / 3;
   1334             }
   1335         }
   1336 
   1337         #endregion
   1338         #region FolderPicker
   1339 
   1340 
   1341         public void ContinueFolderPicker(FolderPickerContinuationEventArgs args)
   1342         {
   1343             folder = args.Folder;
   1344             if (folder != null)
   1345             {
   1346                 try
   1347                 {
   1348                     var id = folder.FolderRelativeId;
   1349                     if (folder != null)
   1350                     {
   1351                         if (folder.IsOfType(StorageItemTypes.Folder))
   1352                         {
   1353                             this.Addresser.Reset();
   1354                         }
   1355                         // after that, we can store the folder for future reuse
   1356                         string pickedFolderToken = StorageApplicationPermissions.FutureAccessList.Add(folder);
   1357                         ApplicationData.Current.LocalSettings.Values.Add("FolderTokenSettingsKey", pickedFolderToken);
   1358                         StorageApplicationPermissions.FutureAccessList.AddOrReplace("PickedFolderToken", folder);
   1359                         string mruToken = Windows.Storage.AccessCache.StorageApplicationPermissions.MostRecentlyUsedList.Add(folder);
   1360                         IsMusicLibraryOpen = false;
   1361                         IsVideoLibraryOpen = false;
   1362                         IsPictureLibraryOpen = false;
   1363                         headerText.Text = "SD Card";
   1364                         RootFolder.Text = "3";
   1365                         if (GridType)
   1366                         {
   1367                             SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1368                             SDGridView.ItemTemplate = (DataTemplate)Resources["GridFoldersView"];
   1369                         }
   1370                         else
   1371                         {
   1372                             SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["ListViewItemsPanel"];
   1373                             SDGridView.ItemTemplate = (DataTemplate)Resources["ListFoldersView"];
   1374                         }
   1375                         GetFilesAndFolder(folder);
   1376                     }
   1377                     else
   1378                     {
   1379                         return;
   1380                     }
   1381                 }
   1382                 catch
   1383                 { return; }
   1384             }
   1385         }
   1386         #endregion
   1387         #region FolderInteraction
   1388         private void FolderHold(object sender, HoldingRoutedEventArgs e)
   1389         {
   1390             if (SDGridView.SelectionMode == ListViewSelectionMode.None)
   1391             {
   1392                 //folderHold.Begin();
   1393                 operationBar.Visibility = Windows.UI.Xaml.Visibility.Visible;
   1394                 //compressButton.Visibility = Visibility.Visible;
   1395                 //sortButton.Visibility = Visibility.Collapsed;
   1396                 operationBarNormal.Visibility = Visibility.Collapsed;//Start Cool Animations also :)
   1397                 
   1398                 SDGridView.SelectionMode = ListViewSelectionMode.Multiple;
   1399                 //int index = SDGridView.Items.IndexOf(((sdlist)((ItemsControl)sender).DataContext));
   1400                 //SDGridView.SelectedIndex = index;
   1401             }
   1402         }
   1403 
   1404         private void ItemDoubleTap(object sender, DoubleTappedRoutedEventArgs e)
   1405         {
   1406             if (SDGridView.SelectionMode == ListViewSelectionMode.Multiple) return;
   1407             singleTap = false;
   1408             Rename((ItemsControl)sender);
   1409 
   1410         }
   1411 
   1412         private async void Rename(ItemsControl itemsControl)
   1413         {
   1414             itemsControlGrid = itemsControl;
   1415             var sdl = await CurrentFolder.GetItemsAsync();
   1416             int index = SDGridView.Items.IndexOf(((sdlist)itemsControlGrid.DataContext));
   1417             var selectedItem = sdl.ElementAt(index);
   1418             SDGridView.SelectedIndex = index;
   1419             Windows.UI.Xaml.Controls.TextBox txtBoxRe = new Windows.UI.Xaml.Controls.TextBox();
   1420             txtBoxRe.TextAlignment = TextAlignment.Center;
   1421             //txtBoxRe.Margin = new Thickness(0, 4, 0, 4);
   1422             StackPanel stk = itemsControlGrid.GetFirstLogicalChildByType<StackPanel>(false);
   1423             txtBlockRe = stk.GetLogicalChildrenByType<TextBlock>(false).ElementAt(0);
   1424             stk.Children.Add(txtBoxRe);
   1425             txtBlockRe.Visibility = Visibility.Collapsed;
   1426             txtBoxRe.GotFocus += (s, ex) =>
   1427             {
   1428                 try
   1429                 {
   1430                     txtBoxRe.Select(0, txtBoxRe.Text.LastIndexOf('.'));
   1431                 }
   1432                 catch
   1433                 {
   1434                     txtBoxRe.SelectAll();
   1435                 }
   1436             };
   1437             txtBoxRe.LostFocus += (s, ex) =>
   1438             {
   1439                 txtBoxRe.Visibility = Visibility.Collapsed;
   1440                 txtBlockRe.Visibility = Visibility.Visible;
   1441             };
   1442             txtBoxRe.KeyDown += async (s, ex) =>
   1443             {
   1444                 if (ex.Key == Windows.System.VirtualKey.Enter)
   1445                 {
   1446                     if (txtBoxRe.Text == String.Empty)
   1447                     {
   1448                         txtBoxRe.Visibility = Visibility.Collapsed;
   1449                         txtBlockRe.Visibility = Visibility.Visible;
   1450                     }
   1451                     else if (txtBoxRe.Text.Contains("/") || txtBoxRe.Text.Contains(@"\"))
   1452                     {
   1453                         AI("Cannot rename File or Folder", @"A file or folder can't contain any of the following characters: \ / : * ? " + "\"" + " < > |");
   1454                     }
   1455                     else
   1456                     {
   1457                         try
   1458                         {
   1459                             txtBlockRe.Text = txtBoxRe.Text;
   1460                             txtBoxRe.Visibility = Visibility.Collapsed;
   1461                             txtBlockRe.Visibility = Visibility.Visible;
   1462                             await selectedItem.RenameAsync(txtBoxRe.Text, NameCollisionOption.GenerateUniqueName);
   1463                         }
   1464                         catch
   1465                         {
   1466                             AI("Rename operation failed", "Cannot rename this file at the moment");
   1467                         }
   1468                         GetFilesAndFolder(CurrentFolder);
   1469                     }
   1470                 }
   1471             };
   1472             txtBoxRe.Focus(FocusState.Programmatic);
   1473         }
   1474 
   1475         private async void GridItemClick(object sender, TappedRoutedEventArgs e)
   1476         {
   1477             e.Handled = true;
   1478             ShowStatus(SDGridView.SelectedIndex.ToString());
   1479             if (SDGridView.SelectedIndex != -1) return;
   1480             singleTap = true;
   1481             await Task.Delay(200);
   1482             itemsControlGrid = (ItemsControl)sender;
   1483             //if (!singleTap) return;
   1484             int index = SDGridView.Items.IndexOf((sdlist)(itemsControlGrid.DataContext));
   1485             IStorageItem selectedItem = Items.ElementAt(index);
   1486             if (selectedItem.IsOfType(StorageItemTypes.Folder))
   1487             {
   1488                 #region Folder PopOut Animation
   1489                 //Storyboard story = new Storyboard();
   1490                 //itemsControlGrid.RenderTransform = new CompositeTransform();
   1491                 //itemsControlGrid.RenderTransformOrigin = new Point(0.5, 0.5);
   1492                 //CircleEase ease = new CircleEase();
   1493                 //DoubleAnimation opacity = new DoubleAnimation { From = 1, To = 0, Duration = TimeSpan.FromMilliseconds(100), EasingFunction=ease  };
   1494                 //Storyboard.SetTargetProperty(opacity, "(UIElement.Opacity)");
   1495                 //Storyboard.SetTarget(opacity, itemsControlGrid);
   1496                 //DoubleAnimation scaleX = new DoubleAnimation { From = 1, To = 6, Duration = TimeSpan.FromMilliseconds(100), EasingFunction = ease };
   1497                 //Storyboard.SetTargetProperty(scaleX, "(UIElement.RenderTransform).(CompositeTransform.ScaleX)");
   1498                 //Storyboard.SetTarget(scaleX, itemsControlGrid);
   1499                 //DoubleAnimation scaleY = new DoubleAnimation { From = 1, To = 6, Duration = TimeSpan.FromMilliseconds(100), EasingFunction = ease };
   1500                 //Storyboard.SetTargetProperty(scaleY, "(UIElement.RenderTransform).(CompositeTransform.ScaleY)");
   1501                 //Storyboard.SetTarget(scaleY, itemsControlGrid);
   1502                 //story.Children.Add(scaleX);
   1503                 //story.Children.Add(scaleY);
   1504                 //story.Children.Add(opacity);
   1505                 //story.Begin();
   1506                 #endregion
   1507                 Addresser.Address(((IStorageFolder)selectedItem).Name, ((IStorageFolder)selectedItem).Path);
   1508                 if (IsVideoLibraryOpen || IsPictureLibraryOpen)
   1509                 {
   1510                     SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1511                     SDGridView.ItemTemplate = (DataTemplate)Resources["PicturesView"];
   1512                 }
   1513                 else if (IsMusicLibraryOpen)
   1514                 {
   1515                     SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1516                     SDGridView.ItemTemplate = (DataTemplate)Resources["MusicsView"];
   1517                 }
   1518                 GetFilesAndFolder((IStorageFolder)selectedItem);
   1519                 return;
   1520             }
   1521             else if (selectedItem.IsOfType(StorageItemTypes.File))
   1522             {
   1523                 ExecuteFile((IStorageFile)selectedItem);
   1524                 return;
   1525             }
   1526         }
   1527 
   1528         private async void VideoItemClick(object sender, TappedRoutedEventArgs e)
   1529         {
   1530             singleTap = true;
   1531             await Task.Delay(200);
   1532             itemsControlGrid = (ItemsControl)sender;
   1533             if (!singleTap) return;
   1534             int index = SDGridView.Items.IndexOf((sdlist)(itemsControlGrid.DataContext));
   1535             IStorageItem selectedItem = Items.ElementAt(index);
   1536             if (selectedItem.IsOfType(StorageItemTypes.Folder))
   1537             {
   1538                 Addresser.Address(((IStorageFolder)selectedItem).Name, ((IStorageFolder)selectedItem).Path);
   1539                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1540                 SDGridView.ItemTemplate = (DataTemplate)Resources["PicturesView"];
   1541 
   1542                 GetFilesAndFolder((IStorageFolder)selectedItem);
   1543                 return;
   1544             }
   1545             else if (selectedItem.IsOfType(StorageItemTypes.File))
   1546             {
   1547                 ExecuteFile((IStorageFile)selectedItem);
   1548                 return;
   1549             }
   1550         }
   1551         private async void PictureItemClick(object sender, TappedRoutedEventArgs e)
   1552         {
   1553             singleTap = true;
   1554             await Task.Delay(200);
   1555             itemsControlGrid = (ItemsControl)sender;
   1556             if (!singleTap) return;
   1557             int index = SDGridView.Items.IndexOf((sdlist)(itemsControlGrid.DataContext));
   1558             IStorageItem selectedItem = Items.ElementAt(index);
   1559             if (selectedItem.IsOfType(StorageItemTypes.Folder))
   1560             {
   1561                 Addresser.Address(((IStorageFolder)selectedItem).Name, ((IStorageFolder)selectedItem).Path);
   1562                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1563                 SDGridView.ItemTemplate = (DataTemplate)Resources["PicturesView"];
   1564 
   1565                 GetFilesAndFolder((IStorageFolder)selectedItem);
   1566                 return;
   1567             }
   1568             else if (selectedItem.IsOfType(StorageItemTypes.File))
   1569             {
   1570                 ExecuteFile((IStorageFile)selectedItem);
   1571                 return;
   1572             }
   1573         }
   1574         private async void MusicItemClick(object sender, TappedRoutedEventArgs e)
   1575         {
   1576             singleTap = true;
   1577             await Task.Delay(200);
   1578             musicItemsControlGrid = (ItemsControl)sender;
   1579             if (!singleTap) return;
   1580             int index = SDGridView.Items.IndexOf((sdlist)(musicItemsControlGrid.DataContext));
   1581             IStorageItem selectedItem = Items.ElementAt(index);
   1582             if (selectedItem.IsOfType(StorageItemTypes.Folder))
   1583             {
   1584                 Addresser.Address(((IStorageFolder)selectedItem).Name, ((IStorageFolder)selectedItem).Path);
   1585                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1586                 SDGridView.ItemTemplate = (DataTemplate)Resources["MusicsView"];
   1587 
   1588                 GetFilesAndFolder((IStorageFolder)selectedItem);
   1589                 return;
   1590             }
   1591             else if (selectedItem.IsOfType(StorageItemTypes.File))
   1592             {
   1593                 ExecuteFile((IStorageFile)selectedItem);
   1594                 return;
   1595             }
   1596         }
   1597         #endregion
   1598         #region MusicStatusUpdater(work-in progress)
   1599         public async void MusicStatusUpdate()
   1600         {
   1601             await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, delegate
   1602             {
   1603                 Grid grd = null;
   1604                 if (!IsMusicLibraryOpen) return;
   1605                     grd = musicItemsControlGrid.GetFirstLogicalChildByType<Grid>(false);
   1606                 if (grd.Children.Count == 2)
   1607                 {
   1608                     Border brdB = grd.GetFirstLogicalChildByType<Border>(false);
   1609                     grd.Children.Remove(brdB);
   1610                     return;
   1611                 }
   1612                 Border brd = new Border();
   1613                 brd.CornerRadius = new CornerRadius(150);
   1614                 TextBlock txt = new TextBlock();
   1615                 brd.VerticalAlignment = VerticalAlignment.Center;
   1616                 brd.HorizontalAlignment = HorizontalAlignment.Center;
   1617                 brd.Background = new SolidColorBrush(Windows.UI.Color.FromArgb(200, 0, 0, 0));
   1618                 txt.FontFamily = new FontFamily("Assets/Font/iconFont.ttf#iconfont");
   1619                 txt.Margin = new Thickness(20);
   1620                 txt.FontSize = 50;
   1621                 txt.Foreground = new SolidColorBrush(Windows.UI.Color.FromArgb(255, 255, 255, 255));
   1622                 txt.VerticalAlignment = VerticalAlignment.Center;
   1623                 txt.HorizontalAlignment = HorizontalAlignment.Center;
   1624                 txt.Text = "2";
   1625                 brd.Child = txt;
   1626                 grd.Children.Add(brd);
   1627             });
   1628         }
   1629         #endregion
   1630         #region FileExecution
   1631         private async void ExecuteFile(IStorageFile selectedItem)
   1632         {
   1633 
   1634             if (selectedItem.FileType == ".zip")
   1635             {
   1636                 //var temps = await ApplicationData.Current.TemporaryFolder.GetItemsAsync();
   1637                 //foreach (var temp in temps)
   1638                 //{
   1639                 //    await temp.DeleteAsync();
   1640                 //}
   1641                 //temps = await ApplicationData.Current.TemporaryFolder.GetItemsAsync();
   1642                 //if (temps.Count == 0)
   1643                     GetFilesAndFolder((IStorageFolder)await OpenZip(selectedItem));
   1644             }
   1645             else if (selectedItem.FileType == ".mp3")
   1646             {
   1647                 if ((string)settings.Values["musicPlayer"] == "1")
   1648                     PlayMedia(selectedItem);
   1649                 else await Windows.System.Launcher.LaunchFileAsync(selectedItem);
   1650             }
   1651             else if (selectedItem.FileType == ".wma")
   1652             {
   1653                 if ((string)settings.Values["musicPlayer"] == "1")
   1654                     PlayMedia(selectedItem);
   1655                 else await Windows.System.Launcher.LaunchFileAsync(selectedItem);
   1656             }
   1657             else if (selectedItem.FileType == ".m4a")
   1658             {
   1659                 if ((string)settings.Values["musicPlayer"] == "1")
   1660                     PlayMedia(selectedItem);
   1661                 else await Windows.System.Launcher.LaunchFileAsync(selectedItem);
   1662             }
   1663             else if (selectedItem.FileType == ".mp4")
   1664             {
   1665                 if ((string)settings.Values["videosPlayer"] == "1")
   1666                 {
   1667                     PlayVideo(selectedItem);
   1668                 }
   1669                 else await Windows.System.Launcher.LaunchFileAsync(selectedItem);
   1670             }
   1671             else if (selectedItem.FileType == ".mov")
   1672             {
   1673                 if ((string)settings.Values["videosPlayer"] == "1")
   1674                 {
   1675                     PlayVideo(selectedItem);
   1676                 }
   1677                 else await Windows.System.Launcher.LaunchFileAsync(selectedItem);
   1678             }
   1679             else if (selectedItem.FileType == ".jpg")
   1680             {
   1681                 if ((string)settings.Values["picturesPlayer"] == "1")
   1682                 {
   1683                     DisplayPhoto(selectedItem);
   1684                 }
   1685                 else await Windows.System.Launcher.LaunchFileAsync(selectedItem);
   1686             }
   1687             else
   1688             {
   1689                 await Windows.System.Launcher.LaunchFileAsync(selectedItem);
   1690             }
   1691         }
   1692 
   1693         private void PlayVideo(IStorageFile selectedItem)
   1694         {
   1695             this.Frame.Navigate(typeof(VideoPage),selectedItem);
   1696             //mediaPlayer.Source = new Uri(selectedItem.Path);
   1697             //musicArt.Text = "";
   1698             //mediaPlayer.MediaOpened += async (s, t) =>
   1699             //{
   1700             //    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, delegate
   1701             //    {
   1702             //        musicSlider.Maximum = mediaPlayer.NaturalDuration.TimeSpan.TotalSeconds;
   1703             //        playPause.Content = "8";
   1704             //        UpdateMusic(title, artist, mediaPlayer.NaturalDuration.TimeSpan);
   1705             //        musicDispatcher.Start();
   1706             //    });
   1707             //};
   1708             //mediaPlayer.Play();
   1709             //var fileStream = await selectedItem.OpenStreamForReadAsync();
   1710             //MusicStatusUpdate();
   1711         }
   1712 
   1713         #endregion
   1714         #region ZipFileHelpers
   1715         public async Task<StorageFolder> OpenZip(IStorageFile compressedFile)
   1716         {
   1717             try
   1718             {
   1719                 //using (MemoryStream zipMemoryStream = new MemoryStream(WindowsRuntimeBufferExtensions.ToArray(await FileIO.ReadBufferAsync(compressedFile))))
   1720                 //{
   1721                 //    using (ZipArchive zipArchive = new ZipArchive(zipMemoryStream, ZipArchiveMode.Read))
   1722                 //    {
   1723                 //        var files = zipArchive.Entries;
   1724                 //        foreach (var file in files)
   1725                 //        {
   1726                 //            try
   1727                 //            {
   1728                 //                var uncompressedFol = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(file.Name, CreationCollisionOption.ReplaceExisting);
   1729                 //            }
   1730                 //            catch
   1731                 //            {
   1732                 //                var uncompressedFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(file.Name, CreationCollisionOption.ReplaceExisting);
   1733                 //            }
   1734 
   1735                 //            return ApplicationData.Current.TemporaryFolder;
   1736                 //        }
   1737                 //        return null;
   1738                 //    }
   1739                 //}
   1740                 var zipArchive = new System.IO.Compression.ZipArchive(await compressedFile.OpenStreamForReadAsync());
   1741 
   1742                 foreach (var entry in zipArchive.Entries)
   1743                 {
   1744                     using (var entryStream = entry.Open())
   1745                     {
   1746                         if (true)//IsFileBinary(entry.Name)  ?
   1747                         {
   1748                             using (BinaryReader br = new BinaryReader(entryStream))
   1749                             {
   1750                                 //var fileSize = await reader.LoadAsync((uint)entryStream.Length);
   1751                                 var fileSize = br.BaseStream.Length;
   1752                                 byte[] read = br.ReadBytes((int)fileSize);
   1753 
   1754                                 var binaryContent = read;
   1755                             }
   1756                         }
   1757                     }
   1758                 }
   1759                 using (BinaryReader b = new BinaryReader(await compressedFile.OpenStreamForReadAsync())) 
   1760                 {
   1761                     // Do not do this.
   1762                     while (b.PeekChar() != -1)
   1763                     {
   1764                         int v = b.ReadInt32();
   1765                     }
   1766                 }
   1767             }
   1768             catch (Exception ex)
   1769             {
   1770                 ShowStatus(ex.Message);
   1771                 return null;
   1772             }
   1773             return null;
   1774         }
   1775 
   1776         byte[] CentralDirImage = {50,01,05,06,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00};
   1777 
   1778                 public List<string> ReadCentralDir()
   1779         {
   1780             if (this.CentralDirImage == null)
   1781                 throw new InvalidOperationException("Central directory currently does not exist");
   1782  
   1783             List<string> result = new List<string>();
   1784  
   1785             for (int pointer = 0; pointer < this.CentralDirImage.Length; )
   1786             {
   1787                 uint signature = BitConverter.ToUInt32(CentralDirImage, pointer);
   1788                 if (signature != 0x02014b50)
   1789                     break;
   1790  
   1791                 bool encodeUTF8 = (BitConverter.ToUInt16(CentralDirImage, pointer + 8) & 0x0800) != 0;
   1792                 ushort method = BitConverter.ToUInt16(CentralDirImage, pointer + 10);
   1793                 uint modifyTime = BitConverter.ToUInt32(CentralDirImage, pointer + 12);
   1794                 uint crc32 = BitConverter.ToUInt32(CentralDirImage, pointer + 16);
   1795                 uint comprSize = BitConverter.ToUInt32(CentralDirImage, pointer + 20);
   1796                 uint fileSize = BitConverter.ToUInt32(CentralDirImage, pointer + 24);
   1797                 ushort filenameSize = BitConverter.ToUInt16(CentralDirImage, pointer + 28);
   1798                 ushort extraSize = BitConverter.ToUInt16(CentralDirImage, pointer + 30);
   1799                 ushort commentSize = BitConverter.ToUInt16(CentralDirImage, pointer + 32);
   1800                 uint headerOffset = BitConverter.ToUInt32(CentralDirImage, pointer + 42);
   1801                 uint headerSize = (uint)( 46 + filenameSize + extraSize + commentSize);
   1802 
   1803                 Encoding encoder = encodeUTF8 ? Encoding.UTF8 : Encoding.Unicode;
   1804  
   1805                 string zfe = new string();
   1806                 zfe.Method = (Compression)method;
   1807                 zfe.FilenameInZip = encoder.GetString(CentralDirImage, pointer + 46, filenameSize);
   1808                 zfe.FileOffset = GetFileOffset(headerOffset);
   1809                 zfe.FileSize = fileSize;
   1810                 zfe.CompressedSize = comprSize;
   1811                 zfe.HeaderOffset = headerOffset;
   1812                 zfe.HeaderSize = headerSize;
   1813                 zfe.Crc32 = crc32;
   1814                 zfe.ModifyTime = DosTimeToDateTime(modifyTime);
   1815                 if (commentSize > 0)
   1816                     zfe.Comment = encoder.GetString(CentralDirImage, pointer + 46 + filenameSize + extraSize, commentSize);
   1817  
   1818                 result.Add(zfe);
   1819                 pointer += (46 + filenameSize + extraSize + commentSize);
   1820             }
   1821  
   1822             return result;
   1823         }
   1824 
   1825 
   1826         public async Task<StorageFile> CreateZip(StorageFile file)
   1827         {
   1828             if (CurrentFolder != null)
   1829             {
   1830                 try
   1831                 {
   1832                     using (MemoryStream zipMemoryStream = new MemoryStream())
   1833                     {
   1834                         using (System.IO.Compression.ZipArchive zipArchive = new System.IO.Compression.ZipArchive(zipMemoryStream, ZipArchiveMode.Create))
   1835                         {
   1836                             try
   1837                             {
   1838                                 byte[] buffer = WindowsRuntimeBufferExtensions.ToArray(await FileIO.ReadBufferAsync(file));
   1839                                 ZipArchiveEntry entry = zipArchive.CreateEntry(file.Name);
   1840                                 using (Stream entryStream = entry.Open())
   1841                                 {
   1842                                     await entryStream.WriteAsync(buffer, 0, buffer.Length);
   1843                                 }
   1844                                 GetFilesAndFolder(CurrentFolder);
   1845                             }
   1846                             catch (Exception ex)
   1847                             {
   1848                                 ShowStatus(ex.Message);
   1849                             }
   1850                         }
   1851 
   1852                         // Created new file to store compressed files
   1853                         var compressedFileName = file.Name + ".zip";
   1854                         StorageFile zipFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(compressedFileName, CreationCollisionOption.GenerateUniqueName);
   1855                         using (IRandomAccessStream zipStream = await zipFile.OpenAsync(FileAccessMode.ReadWrite))
   1856                         {
   1857                             // Write compressed data from memory to file
   1858                             using (Stream outstream = zipStream.AsStreamForWrite())
   1859                             {
   1860                                 byte[] buffer = zipMemoryStream.ToArray();
   1861                                 outstream.Write(buffer, 0, buffer.Length);
   1862                                 outstream.Flush();
   1863                                 return zipFile;
   1864                             }
   1865                         }
   1866                     }
   1867                 }
   1868                 catch (Exception ex)
   1869                 {
   1870                     ShowStatus(ex.Message);
   1871                     return null;
   1872                 }
   1873             }
   1874             else
   1875             {
   1876                 ShowStatus("Error! This is not a valid folder");
   1877                 return null;
   1878             }
   1879         }
   1880         #endregion
   1881         #region BottomBarmenuEventHandlers
   1882         private void GridListChange(object sender, RoutedEventArgs e)
   1883         {
   1884             if (GridType)
   1885             {
   1886                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["ListViewItemsPanel"];
   1887                 SDGridView.ItemTemplate = (DataTemplate)Resources["ListFoldersView"];
   1888                 gridList.ContentText = "list";
   1889                 gridList.ImageText = "b";
   1890                 GridType = false;
   1891             }
   1892             else
   1893             {
   1894                 SDGridView.ItemsPanel = (ItemsPanelTemplate)Resources["GridViewItemsPanel"];
   1895                 SDGridView.ItemTemplate = (DataTemplate)Resources["GridFoldersView"];
   1896                 gridList.ContentText = "grid";
   1897                 gridList.ImageText = "N";
   1898                 GridType = true;
   1899             }
   1900         }
   1901         private void SelectAll(object sender, RoutedEventArgs e)
   1902         {
   1903             SDGridView.SelectionMode = ListViewSelectionMode.Multiple;
   1904             SDGridView.SelectAll();
   1905             operationBar.Visibility = Visibility.Visible;
   1906             operationBarNormal.Visibility = Visibility.Collapsed;
   1907             //folderHold.Begin();
   1908         }
   1909         private void selectBox_Unchecked(object sender, RoutedEventArgs e)
   1910         {
   1911             UnselectAll();
   1912         }
   1913         public void UnselectAll()
   1914         {
   1915             SDGridView.SelectionMode = ListViewSelectionMode.None;
   1916             operationBar.Visibility = Visibility.Collapsed;
   1917             operationBarNormal.Visibility = Visibility.Visible;
   1918         }
   1919         #endregion
   1920         #region SDGridViewSelectionChanged
   1921         private void SDGridViewSelectionChanged(object sender, SelectionChangedEventArgs e)
   1922         {
   1923             if (SDGridView.SelectedIndex == -1)
   1924             {
   1925                 //operationBar.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
   1926                 //operationBarNormal.Visibility = Visibility.Visible;
   1927                 //headerText.Visibility = Windows.UI.Xaml.Visibility.Visible;
   1928                 //folderHoldRev.Begin();
   1929                 SDGridView.SelectionMode = ListViewSelectionMode.None;
   1930                 //SDGridView.IsItemClickEnabled = true;
   1931                 return;
   1932             }
   1933             else { return; }
   1934         }
   1935         #endregion
   1936 
   1937 
   1938 
   1939         #region FileSortingMethods
   1940 
   1941         private void OpenSortMenu(object sender, RoutedEventArgs e)
   1942         {
   1943             OpenSortMenuAnim.Begin();
   1944             //ToggleMenu(SortMenu);
   1945         }
   1946 
   1947         private void ToggleMenu(Panel element)
   1948         {
   1949             if (element.Visibility == Visibility.Visible)
   1950                 element.Visibility = Visibility.Collapsed;
   1951             else element.Visibility = Visibility.Visible;
   1952         }
   1953 
   1954         private void SortMenuItemClick(object sender, RoutedEventArgs e)
   1955         {
   1956             Button bt = (Button)sender;
   1957             string buttonName = bt.Content.ToString();
   1958             if (buttonName == "Name")
   1959             {
   1960                 Sort(0);
   1961             }
   1962             else if (buttonName == "Type")
   1963             {
   1964                 Sort(1);
   1965             }
   1966             else if (buttonName == "Size")
   1967             {
   1968                 Sort(2);
   1969             }
   1970             else if (buttonName == "Date")
   1971             {
   1972                 Sort(3);
   1973             }
   1974             SortMenu.Visibility = Visibility.Collapsed;
   1975         }
   1976 
   1977         public void Sort(int sortType)
   1978         {
   1979             try
   1980             {
   1981                 switch (sortType)
   1982                 {
   1983                     case 0:
   1984                         sd.OrderBy(o => o.Name);
   1985                         break;
   1986                     case 1:
   1987                         sd.OrderBy(o => o.Image);
   1988                         break;
   1989                     case 2:
   1990                         sd.OrderBy(o => o.Name);
   1991                         break;
   1992                     case 3:
   1993                         sd.OrderBy(o => o.Name);
   1994                         break;
   1995                 }
   1996             }
   1997             catch (ArgumentNullException)
   1998             {
   1999 
   2000             }
   2001         }
   2002 
   2003         #endregion
   2004         private void ListBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
   2005         {
   2006             if (stkChildren != null && stkChildren.ContentText == "Settings") return;
   2007             this.Addresser.Reset();
   2008             sd.Clear();
   2009             SDGridView.ItemsSource = null;
   2010             headerText.Text = String.Empty;
   2011         }
   2012         private void PhoneRefreshTapped(object sender, TappedRoutedEventArgs e)
   2013         {
   2014 
   2015         }
   2016         private void PhoneEnumerator(object sender, RoutedEventArgs e)
   2017         {
   2018             FolderPicker fp = new FolderPicker();
   2019             fp.PickFolderAndContinue();
   2020             if (IsPhoneLoading)
   2021             {
   2022                 phoneWarning.Visibility = Visibility.Visible;
   2023             }
   2024         }
   2025 
   2026         private Task LoadMemoryData()
   2027         {
   2028             textBlock.Visibility = Visibility.Collapsed;
   2029             phoneWarning.Visibility = Visibility.Collapsed;
   2030             IStorageItem sf = ApplicationData.Current.LocalFolder;
   2031 
   2032             var properties = sf.GetBasicPropertiesAsync().Completed += (es, t) =>
   2033             {
   2034                 es.GetResults().RetrievePropertiesAsync(new[] { "System.FreeSpace" }).Completed += (ex, tx) =>
   2035                 {
   2036                     var freeSpace = ex.GetResults()["System.FreeSpace"];
   2037 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
   2038                     Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
   2039 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
   2040                     {
   2041                         float freeSpaceGB = (float)Double.Parse((freeSpace.ToString())) / 1000000000;
   2042                         FreeSpace.Text = Math.Round(freeSpaceGB, 2).ToString();
   2043                         sdProgbar.Maximum = 16.00;
   2044                         sdProgbar.Value = 16.00 - freeSpaceGB;
   2045                         IsSDLoading = false;
   2046                         IsPhoneLoading = false;
   2047                         SDLoad.Stop();
   2048                         symbolIcon.Visibility = Visibility.Collapsed;
   2049                         PhoneLoad.Stop();
   2050                         symbolIcon1.Visibility = Visibility.Collapsed;
   2051                     });
   2052                 };
   2053             };
   2054 
   2055             return null;
   2056         }
   2057 
   2058         private void AddFile(object sender, RoutedEventArgs e)
   2059         {
   2060             CurrentFolder.CreateFileAsync("New File", CreationCollisionOption.GenerateUniqueName).Completed += (es,t) =>
   2061                {
   2062 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
   2063                    Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, delegate
   2064 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
   2065                    {
   2066                        GetFilesAndFolder(CurrentFolder);
   2067                    });
   2068                };
   2069         }
   2070         private void AddZip(object sender, RoutedEventArgs e)
   2071         {
   2072             InputPrompt ip = new InputPrompt();
   2073             ip.Completed += (async (ex, t) =>
   2074             {
   2075                 StorageFile sf = await CurrentFolder.CreateFileAsync(t.Result + ".zip", CreationCollisionOption.GenerateUniqueName);
   2076                 if (sf != null && CreateZip(sf).IsCompleted)
   2077                 {
   2078 
   2079                     GetFilesAndFolder(CurrentFolder);
   2080                 }
   2081             });
   2082             ip.Title = "Enter file name";
   2083             ip.Show();
   2084         }
   2085 
   2086         private void AddFolder(object sender, RoutedEventArgs e)
   2087         {
   2088             InputPrompt ip = new InputPrompt();
   2089             ip.Completed += (async (ex, t) =>
   2090             {
   2091                 StorageFolder sf = await CurrentFolder.CreateFolderAsync(t.Result, CreationCollisionOption.GenerateUniqueName);
   2092                 GetFilesAndFolder(CurrentFolder);
   2093             });
   2094             ip.Title = "Enter folder name";
   2095             ip.Show();
   2096         }
   2097         private async void DeleteItem(object sender, RoutedEventArgs e)
   2098         {
   2099             var sdl = SDGridView.SelectedItems;
   2100             foreach (var sdli in sdl)
   2101             {
   2102                 try
   2103                 {
   2104                     var si = (sdlist)sdli;
   2105                     IStorageItem selectedItem = Items.ElementAt(sd.IndexOf(si));
   2106                     await selectedItem.DeleteAsync();
   2107                     sd.Remove(si);
   2108                 }
   2109                 catch (Exception ex)
   2110                 {
   2111                     AI("Cannot Delete File", "Cannot delete file because the file may be locked");
   2112                     ShowStatus(ex.Message);
   2113                 }
   2114             }
   2115             //GetFilesAndFolder(CurrentFolder);
   2116         }
   2117 
   2118         private void RenameItem(object sender, RoutedEventArgs e)
   2119         {
   2120             Rename((ItemsControl)sender);
   2121         }
   2122 
   2123         List<StorageFile> clipboard = new List<StorageFile>();
   2124         private void CutItems(object sender, RoutedEventArgs e)
   2125         {
   2126             clipboard.Clear();
   2127             var sdl = SDGridView.SelectedItems;
   2128             foreach (var sdli in sdl)
   2129             {
   2130                 try
   2131                 {
   2132                     var si = (sdlist)sdli;
   2133                     IStorageItem selectedItem = Items.ElementAt(sd.IndexOf(si));
   2134                     if (selectedItem.IsOfType(StorageItemTypes.File))
   2135                     {
   2136                         StorageFile sf = (StorageFile)selectedItem;
   2137 
   2138                         clipboard.Add(sf);
   2139                     }
   2140 
   2141                 }
   2142                 catch (Exception ex)
   2143                 {
   2144                     ShowStatus(ex.Message);
   2145                     AI("Cannot add to clipboard",ex.Message);
   2146                 }
   2147 
   2148             }
   2149         }
   2150 
   2151         #region ShowStatus
   2152         public void ShowStatus(string info)
   2153         {
   2154             NotifyUser(info);
   2155         }
   2156         #endregion
   2157 
   2158         private void PasteItem(object sender, RoutedEventArgs e)
   2159         {
   2160             OpenDialog(2);
   2161         }
   2162         private void OverwriteContents(object sender, RoutedEventArgs e)
   2163         {
   2164             FileMoveDialog.Visibility = Visibility.Collapsed;
   2165             ProgInfoView.Visibility = Visibility.Visible;
   2166             int clipCount = 0;
   2167             if ((clipCount = clipboard.Count) != 0)
   2168             {
   2169                 progFileDest.Text = CurrentFolder.Name;
   2170                 progTotalSize.Text = clipCount.ToString();
   2171                 if (IS_FILE_MOVE)//move
   2172                 {
   2173                     cmstatus.Text = "moving";
   2174                     try
   2175                     {
   2176                         foreach (var item in clipboard)
   2177                         {
   2178                             progFileSource.Text = item.Name;
   2179                             progCurrentSize.Text = clipboard.IndexOf(item).ToString();
   2180                             var tb = item.MoveAsync(CurrentFolder, item.Name, NameCollisionOption.ReplaceExisting);
   2181                             tb.Completed += async (i, s) =>
   2182                             {
   2183                                 await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, delegate
   2184                                 {
   2185                                     ProgInfoView.Visibility = Visibility.Collapsed;
   2186                                     ProgressDialog.Visibility = Visibility.Collapsed;
   2187                                 });
   2188                             };
   2189                         }
   2190                         GetFilesAndFolder(CurrentFolder);
   2191                     }
   2192                     catch (Exception ex)
   2193                     {
   2194                         AI("Error copying file", ex.Message);
   2195                     }
   2196                 }
   2197                 else//copy
   2198                 {
   2199                     cmstatus.Text = "copying";
   2200                     try
   2201                     {
   2202                         foreach (var item in clipboard)
   2203                         {
   2204                             progFileSource.Text = item.Name;
   2205                             progCurrentSize.Text = clipboard.IndexOf(item).ToString();
   2206                             var tb = item.CopyAsync(CurrentFolder, item.Name, NameCollisionOption.ReplaceExisting);
   2207                             tb.Completed += async (i, s) =>
   2208                             {
   2209                                 await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, delegate
   2210                                 {
   2211                                     ProgInfoView.Visibility = Visibility.Collapsed;
   2212                                     ProgressDialog.Visibility = Visibility.Collapsed;
   2213                                 });
   2214                             };
   2215                         }
   2216                         GetFilesAndFolder(CurrentFolder);
   2217                     }
   2218                     catch (Exception ex)
   2219                     {
   2220                         AI("Error copying file", ex.Message);
   2221                     }
   2222                 }
   2223             }
   2224         }
   2225 
   2226         private void KeepBothFiles(object sender, RoutedEventArgs e)
   2227         {
   2228             FileMoveDialog.Visibility = Visibility.Collapsed;
   2229             ProgInfoView.Visibility = Visibility.Visible;
   2230             int clipCount = 0;
   2231             if ((clipCount = clipboard.Count) != 0)
   2232             {
   2233                 progFileDest.Text = CurrentFolder.Name;
   2234                 progTotalSize.Text = clipCount.ToString();
   2235                 if (IS_FILE_MOVE)//move
   2236                 {
   2237                     cmstatus.Text = "moving";
   2238                     try
   2239                     {
   2240                         foreach (var item in clipboard)
   2241                         {
   2242                             progFileSource.Text = item.Name;
   2243                             progCurrentSize.Text = clipboard.IndexOf(item).ToString();
   2244                             var tb = item.MoveAsync(CurrentFolder, item.Name, NameCollisionOption.GenerateUniqueName);
   2245                             tb.Completed += async (i, s) =>
   2246                             {
   2247                                 await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, delegate
   2248                                 {
   2249                                     ProgInfoView.Visibility = Visibility.Collapsed;
   2250                                     ProgressDialog.Visibility = Visibility.Collapsed;
   2251                                 });
   2252                             };
   2253                         }
   2254                         GetFilesAndFolder(CurrentFolder);
   2255                     }
   2256                     catch (Exception ex)
   2257                     {
   2258                         AI("Error copying file", ex.Message);
   2259                     }
   2260                 }
   2261                 else//copy
   2262                 {
   2263                     cmstatus.Text = "copying";
   2264                     try
   2265                     {
   2266                         foreach (var item in clipboard)
   2267                         {
   2268                             progFileSource.Text = item.Name;
   2269                             progCurrentSize.Text = clipboard.IndexOf(item).ToString();
   2270                             var tb = item.CopyAsync(CurrentFolder, item.Name, NameCollisionOption.GenerateUniqueName);
   2271                             tb.Completed += async (i, s) =>
   2272                             {
   2273                                 await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, delegate
   2274                                 {
   2275                                     ProgInfoView.Visibility = Visibility.Collapsed;
   2276                                     ProgressDialog.Visibility = Visibility.Collapsed;
   2277                                 });
   2278                             };
   2279                         }
   2280                         GetFilesAndFolder(CurrentFolder);
   2281                     }
   2282                     catch (Exception ex)
   2283                     {
   2284                         AI("Error copying file", ex.Message);
   2285                     }
   2286                 }
   2287             }
   2288         }
   2289 
   2290         #region InternetBrowser
   2291         private void Browser(object sender, RoutedEventArgs e)
   2292         {
   2293             WebBrowser.Visibility = Visibility.Visible;
   2294         }
   2295         private void Button_Click(object sender, RoutedEventArgs e)
   2296         {
   2297             try
   2298             {
   2299                 webView.Navigate(new Uri(webAddressBar.Text));
   2300             }
   2301             catch
   2302             {
   2303                 webView.Navigate(new Uri("https://www.google.com/"));
   2304             }
   2305         }
   2306         #endregion
   2307         #region FileShare
   2308         private void ShareContent(object sender, RoutedEventArgs e)
   2309         {
   2310             DataTransferManager dataTransferManager = DataTransferManager.GetForCurrentView();
   2311             dataTransferManager.DataRequested += new TypedEventHandler<DataTransferManager, DataRequestedEventArgs>(ShareStorageItemsHandler);
   2312             // If the user clicks the share button, invoke the share flow programatically.
   2313             DataTransferManager.ShowShareUI();
   2314         }
   2315 
   2316         private void ShareStorageItemsHandler(DataTransferManager sender, DataRequestedEventArgs e)
   2317         {
   2318             DataRequest request = e.Request;
   2319             request.Data.Properties.Title = "File360";
   2320             request.Data.Properties.Description = "files & folders";
   2321 
   2322             // Because we are making async calls in the DataRequested event handler,
   2323             // we need to get the deferral first.
   2324             DataRequestDeferral deferral = request.GetDeferral();
   2325 
   2326             // Make sure we always call Complete on the deferral.
   2327             try
   2328             {
   2329 
   2330 
   2331                 var sdl = SDGridView.SelectedItems;
   2332                 foreach (var sdli in sdl)
   2333                 {
   2334                     try
   2335                     {
   2336                         var si = (sdlist)sdli;
   2337                         SelectedItems.Add(Items.ElementAt(sd.IndexOf(si)));
   2338                     }
   2339                     catch (Exception ex)
   2340                     {
   2341                         ShowStatus(ex.Message);
   2342                     }
   2343                 }
   2344 
   2345                 request.Data.SetStorageItems(SelectedItems);
   2346             }
   2347             finally
   2348             {
   2349                 deferral.Complete();
   2350             }
   2351         }
   2352         #endregion
   2353 
   2354         private async void DeleteThisFolder(object sender, RoutedEventArgs e)
   2355         {
   2356             int index = CurrentFolder.Path.LastIndexOf(CurrentFolder.Name);
   2357             var sf = await StorageFolder.GetFolderFromPathAsync(CurrentFolder.Path.Remove(index));
   2358             await CurrentFolder.DeleteAsync();
   2359             GetFilesAndFolder(sf);
   2360             headerText.Text = CurrentFolder.Name;
   2361             this.Addresser.RemoveLast();
   2362         }
   2363 
   2364         private async void PersonalStorageEnumerator(object sender, RoutedEventArgs e)
   2365         {
   2366             var HomeFolderP = ApplicationData.Current.LocalFolder;
   2367             var HomeFolder = await HomeFolderP.CreateFolderAsync("Home", CreationCollisionOption.OpenIfExists);
   2368             GetFilesAndFolder(HomeFolder);
   2369             this.Addresser.Reset();
   2370             headerText.Text = "Home";
   2371             RootFolder.Text = "|";
   2372         }
   2373 
   2374         private void NowPlaying(object sender, RoutedEventArgs e)
   2375         {
   2376             MusicMenuClick();
   2377         }
   2378 
   2379         private async void PreviousFolder(object sender, RoutedEventArgs e)
   2380         {
   2381             if (!this.Addresser.Root)
   2382             {
   2383                 try
   2384                 {
   2385                     int curFoldCharNm = CurrentFolder.Path.LastIndexOf(CurrentFolder.Name);
   2386                     StorageFolder sf = await StorageFolder.GetFolderFromPathAsync(CurrentFolder.Path.Remove(curFoldCharNm));
   2387                     this.Addresser.RemoveLast();
   2388                     GetFilesAndFolder(sf);
   2389                 }
   2390                 catch { }
   2391             }
   2392             else
   2393             {
   2394                 SideMenu.OpenDrawer();
   2395             }
   2396         }
   2397 
   2398         #endregion
   2399 
   2400         private void password_rect_Tapped(object sender, TappedRoutedEventArgs e)
   2401         {
   2402             OpenDialog(1);
   2403         }
   2404 
   2405 
   2406         //#region Bluetooth
   2407         //private async void OpenBluetoothSettings(object sender, RoutedEventArgs e)
   2408         //{
   2409         //    await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings-bluetooth:"));
   2410         //}
   2411         //#endregion
   2412 
   2413         #region HelpMenu
   2414         private void HelpOpen(object sender, RoutedEventArgs e)
   2415         {
   2416             OpenDialog(0);
   2417         }
   2418 
   2419         private void HelpPageClose(object sender, RoutedEventArgs e)
   2420         {
   2421             CloseDialog(0);
   2422         }
   2423         #endregion
   2424 
   2425 
   2426         #region FTP
   2427         private void OpenFTP(object sender, RoutedEventArgs e)
   2428         {
   2429             FTPOpen.Begin();
   2430             FTPActive.Begin();
   2431         }
   2432         #endregion
   2433         #region Music
   2434         private void musicToggle_Checked(object sender, RoutedEventArgs e)
   2435         {
   2436             settings.Values["musicPlayer"] = "1";
   2437         }
   2438         private void musicToggle_Unchecked(object sender, RoutedEventArgs e)
   2439         {
   2440             settings.Values["musicPlayer"] = "0";
   2441         }
   2442 
   2443         private void musThumbnailToggle_Checked(object sender, RoutedEventArgs e)
   2444         {
   2445             settings.Values["musThumbnail"] = "1";
   2446         }
   2447 
   2448         private void musThumbnailToggle_Unchecked(object sender, RoutedEventArgs e)
   2449         {
   2450             settings.Values["musThumbnail"] = "0";
   2451         }
   2452         #endregion
   2453         #region Videos
   2454         private void videosToggle_Checked(object sender, RoutedEventArgs e)
   2455         {
   2456             settings.Values["videosPlayer"] = "1";
   2457         }
   2458         private void videosToggle_Unchecked(object sender, RoutedEventArgs e)
   2459         {
   2460             settings.Values["videosPlayer"] = "0";
   2461         }
   2462         private void vidThumbnailToggle_Checked(object sender, RoutedEventArgs e)
   2463         {
   2464             settings.Values["vidThumbnail"] = "1";
   2465         }
   2466 
   2467         private void vidThumbnailToggle_Unchecked(object sender, RoutedEventArgs e)
   2468         {
   2469             settings.Values["vidThumbnail"] = "0";
   2470         }
   2471 
   2472         #endregion
   2473         #region Ebooks
   2474         private void ebookToggle_Checked(object sender, RoutedEventArgs e)
   2475         {
   2476             settings.Values["ebookViewer"] = "1";
   2477         }
   2478         private void ebookToggle_Unchecked(object sender, RoutedEventArgs e)
   2479         {
   2480             settings.Values["ebookViewer"] = "0";
   2481         }
   2482         #endregion
   2483         #region Pictures
   2484         private void picturesToggle_Checked(object sender, RoutedEventArgs e)
   2485         {
   2486             settings.Values["picturesPlayer"] = "1";
   2487         }
   2488 
   2489         private void picturesToggle_Unchecked(object sender, RoutedEventArgs e)
   2490         {
   2491             settings.Values["picturesPlayer"] = "0";
   2492         }
   2493 
   2494         private void picThumbnailToggle_Checked(object sender, RoutedEventArgs e)
   2495         {
   2496             settings.Values["picThumbnail"] = "1";
   2497         }
   2498 
   2499         private void picThumbnailToggle_Unchecked(object sender, RoutedEventArgs e)
   2500         {
   2501             settings.Values["picThumbnail"] = "0";
   2502         }
   2503         #endregion
   2504 
   2505         #region DialogOpenClose
   2506         public void OpenDialog(int dialogNo)
   2507         {
   2508             ProgressDialog.Visibility = Visibility.Visible;
   2509             switch(dialogNo)
   2510             {
   2511                 case 0:
   2512                     SubFrameGrid.Visibility = Visibility.Visible;
   2513                     SubFrame.Navigate(typeof(HelpPage));
   2514                     SubFrameHeader.Text = "HELP";
   2515                     break;
   2516 
   2517                 case 1:
   2518                     SubFrameGrid.Visibility = Visibility.Visible;
   2519                     SubFrame.Navigate(typeof(VaultPage));
   2520                     SubFrameHeader.Text = "VAULT";
   2521                     break;
   2522                 case 2:
   2523                     FileMoveDialog.Visibility = Visibility.Visible;
   2524                     break;
   2525                 case 3:
   2526                     ProgInfoView.Visibility = Visibility.Visible;
   2527                     break;
   2528 
   2529             }
   2530         }
   2531 
   2532 
   2533         public void CloseDialog(int dialogNo)
   2534         {
   2535             ProgressDialog.Visibility = Visibility.Collapsed ;
   2536             switch (dialogNo)
   2537             {
   2538                 case 0:
   2539                     SubFrameGrid.Visibility = Visibility.Collapsed;
   2540                     break;
   2541 
   2542                 case 1:
   2543                     SubFrameGrid.Visibility = Visibility.Collapsed;
   2544                     break;
   2545                 case 2:
   2546                     FileMoveDialog.Visibility = Visibility.Collapsed;
   2547                     break;
   2548                 case 3:
   2549                     ProgInfoView.Visibility = Visibility.Collapsed;
   2550                     break;
   2551 
   2552             }
   2553         }
   2554         #endregion
   2555 
   2556         private void CloseDialog(object sender, RoutedEventArgs e)
   2557         {
   2558             CloseDialog(2);
   2559         }
   2560 
   2561         private void musicSlider_ManipulationStarted(object sender, ManipulationStartedRoutedEventArgs e)
   2562         {
   2563             ((Storyboard)Resources["SeekOpen"]).Begin();
   2564         }
   2565 
   2566         private void musicSlider_ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
   2567         {
   2568             int m = (int)(e.Delta.Translation.X *0.4);
   2569             if (m < 1 && m> -1)
   2570                 return;
   2571             if (mediaPlayer.CanSeek && m > 0)
   2572             {
   2573                 mediaPlayer.Position.Add(new TimeSpan(0, 0, m));
   2574             }
   2575             else if(mediaPlayer.CanSeek)
   2576             {
   2577                 mediaPlayer.Position.Subtract(new TimeSpan(0, 0, m));
   2578             }
   2579         }
   2580 
   2581         private void musicSlider_ManipulationCompleted(object sender, ManipulationCompletedRoutedEventArgs e)
   2582         {
   2583             ((Storyboard)Resources["SeekClose"]).Begin();
   2584         }
   2585 
   2586         private void StopFTP(object sender, RoutedEventArgs e)
   2587         {
   2588             FTPOpen.Stop();
   2589             FTPActive.Stop();
   2590         }
   2591 
   2592         private void searchBox_TextChanged(object sender, TextChangedEventArgs e)
   2593         {
   2594             try
   2595             {
   2596                 sd.Where(x => x.Name == searchBox.Text);
   2597             }
   2598             catch (ArgumentNullException)
   2599             {
   2600                 sd.Clear();
   2601             }
   2602         }
   2603     }
   2604 }
	file360
	Log \| Files \| Refs
file360
