Пример #1
0
 internal NoteDockStatusChangedEventArgs(DockStatus newStatus, DockStatus oldStatus)
 {
     _NewStatus = newStatus;
     _OldStatus = oldStatus;
 }
Пример #2
0
        private void Win_Main_Loaded(object sender, RoutedEventArgs e)
        {
            //check and merge previous settings
            Setting.Upgrade();

            //create tray icon so you can still use the app when notes fail to load
            if (App.TrayIcon == null)
            {
                using (var stream = Application.GetResourceStream(new Uri("pack://application:,,,/DesktopNote;component/Resources/stickynote.ico")).Stream) {
                    App.TrayIcon = new TaskbarIcon {
                        Icon        = new System.Drawing.Icon(stream),
                        ToolTipText = nameof(DesktopNote),
                        ContextMenu = (ContextMenu)Resources["TrayMenu"],
                    };
                }

                //tray icon double click
                App.TrayIcon.TrayMouseDoubleClick += TrayIcon_TrayMouseDoubleClick;
            }

            //load settings and content
            if (CurrentSetting.Flags.HasFlag(Setting.NoteFlag.Existing) && !Helpers.LoadNote(this))
            {
                Close(true); return;
            }

            //save when settings changed
            CurrentSetting.PropertyChanged += CurrentSetting_PropertyChanged;

            //apply settings
            Width  = CurrentSetting.Win_Size.Width;
            Height = CurrentSetting.Win_Size.Height;
            Left   = CurrentSetting.Win_Pos.X;
            Top    = CurrentSetting.Win_Pos.Y;

            LastDockStatus = (DockStatus)CurrentSetting.DockedTo;
            //DockedTo = DockStatus.None;
            RTB_Main.FontFamily = new FontFamily(CurrentSetting.Font);
            RTB_Main.Foreground = new SolidColorBrush(CurrentSetting.FontColor);
            RTB_Main.Background = new SolidColorBrush(CurrentSetting.BackColor);
            Rec_BG.Fill         = new SolidColorBrush(CurrentSetting.PaperColor);

            if (App.FormatWindow == null)
            {
                App.FormatWindow = new Win_Format(this);
                ((Xceed.Wpf.Toolkit.ColorPicker)App.FormatWindow.CP_Font.Content).SelectedColor = CurrentSetting.FontColor;
                ((Xceed.Wpf.Toolkit.ColorPicker)App.FormatWindow.CP_Back.Content).SelectedColor = CurrentSetting.BackColor;

                //add fonts to menu
                foreach (var f in Fonts.SystemFontFamilies)
                {
                    var mi = new ComboBoxItem {
                        Content    = f.Source,
                        FontFamily = f,
                        FontSize   = FontSize + 4,
                        ToolTip    = f.Source
                    };
                    App.FormatWindow.CB_Font.Items.Add(mi);
                    if (f.Source == CurrentSetting.Font)
                    {
                        mi.IsSelected = true;
                    }
                }
                App.FormatWindow.CB_Font.Items.SortDescriptions.Add(new SortDescription("Content", ListSortDirection.Ascending));
            }

            //reset dependency property values saved explicitly
            //this is to reduce format inconsistency across reloads
            if (RTB_Main.Document.Blocks.Count > 0)
            {
                RTB_Main.FontSize = RTB_Main.Document.Blocks.FirstBlock.FontSize;
                foreach (var b in RTB_Main.Document.Blocks)
                {
                    //unify font for new paragraghs. otherwise wont be able to change fonts after reload.
                    //doesnt affect specifically set font sizes in Inlines & Run.
                    b.ClearValue(TextElement.FontSizeProperty);
                    b.ClearValue(TextElement.FontFamilyProperty);
                    b.ClearValue(TextElement.ForegroundProperty);
                    b.ClearValue(TextElement.BackgroundProperty);
                }

                //reset Padding on List
                foreach (var block in RTB_Main.Document.Blocks)
                {
                    resetPadding(block);
                }
            }

            //without the below two lines, Load actions can be undone.
            RTB_Main.IsUndoEnabled = false;
            RTB_Main.IsUndoEnabled = true;

            //trigger dock after 2s
            if (CurrentSetting.AutoDock)
            {
                Task.Run(() => { Thread.Sleep(2000); Dispatcher.Invoke(() => DockToSide(true)); });
            }

            //start save note thread
            SaveNoteTask = Task.Run(SaveNoteThread, SaveCoundDownCancel.Token);

            //add hook
            var source = PresentationSource.FromVisual(this) as System.Windows.Interop.HwndSource;

            source.AddHook(WndProc);

            //update stuff
            if (!Setting.NoteList.Contains(CurrentSetting.Doc_Location))
            {
                Setting.NoteList.Add(CurrentSetting.Doc_Location);
                Setting.Save();
            }
            App.MainWindows.Add(this);
        }
Пример #3
0
        /// <summary>
        /// Dock the MainWindow based on its location.
        /// </summary>
        /// <param name="changePos">Update LastDockStatus if set to True.</param>
        internal void DockToSide(bool changePos = false)
        {
            if (DockedTo == DockStatus.None)
            {
                double             toval;
                DependencyProperty tgtpro;
                double             pad = 15d;
                DockStatus         dockto;
                if (changePos)
                {
                    App.CurrScrnRect = new GetCurrentMonitor().GetInfo(this);
                    if (Left <= App.CurrScrnRect.Left) //dock left
                    {
                        toval  = App.CurrScrnRect.Left - ActualWidth + pad;
                        tgtpro = LeftProperty;
                        dockto = DockStatus.Left;
                    }

                    else if (Left + ActualWidth >= App.CurrScrnRect.Right) //dock right
                    {
                        toval  = App.CurrScrnRect.Right - pad;
                        tgtpro = LeftProperty;
                        dockto = DockStatus.Right;
                    }

                    else if (Top <= App.CurrScrnRect.Top) //dock top
                    {
                        toval  = App.CurrScrnRect.Top - ActualHeight + pad;
                        tgtpro = TopProperty;
                        dockto = DockStatus.Top;
                    }

                    else if (Top + ActualHeight >= App.CurrScrnRect.Bottom) //dock bottom
                    {
                        toval  = App.CurrScrnRect.Bottom - pad;
                        tgtpro = TopProperty;
                        dockto = DockStatus.Bottom;
                    }
                    else
                    {
                        LastDockStatus = DockStatus.None;
                        return;
                    }
                    LastDockStatus = dockto;
                }
                else //'restore last docking position
                {
                    dockto = LastDockStatus;
                    switch (LastDockStatus)
                    {
                    case DockStatus.Left:
                        toval  = App.CurrScrnRect.Left - ActualWidth + pad;
                        tgtpro = LeftProperty;
                        break;

                    case DockStatus.Right:
                        toval  = App.CurrScrnRect.Right - pad;
                        tgtpro = LeftProperty;
                        break;

                    case DockStatus.Top:
                        toval  = App.CurrScrnRect.Top - ActualHeight + pad;
                        tgtpro = TopProperty;
                        break;

                    case DockStatus.Bottom:
                        toval  = App.CurrScrnRect.Bottom - pad;
                        tgtpro = TopProperty;
                        break;

                    default:
                        return;
                    }
                }

                var anim_move = new DoubleAnimation(toval, new Duration(new TimeSpan(0, 0, 0, 0, 500)))
                {
                    EasingFunction = new CubicEase {
                        EasingMode = EasingMode.EaseOut
                    }
                };
                var anim_fade = new DoubleAnimation(0.4, new Duration(new TimeSpan(0, 0, 0, 0, 300)))
                {
                    BeginTime = new TimeSpan(0, 0, 0, 0, 200)
                };
                var anim_prop = new ObjectAnimationUsingKeyFrames();
                anim_prop.KeyFrames.Add(new DiscreteObjectKeyFrame(DockStatus.Docking, KeyTime.FromTimeSpan(new TimeSpan(0, 0, 0))));
                anim_prop.KeyFrames.Add(new DiscreteObjectKeyFrame(dockto, KeyTime.FromTimeSpan(new TimeSpan(0, 0, 0, 0, 500))));
                BeginAnimation(tgtpro, anim_move);
                BeginAnimation(OpacityProperty, anim_fade);
                BeginAnimation(DockedToProperty, anim_prop);
            }
        }
Пример #4
0
        internal static void ShiftPreviousDock(PNote note, DockStatus prevStatus, bool reorder)
        {
            try
            {
                int w, h;

                if (!PNStatic.Settings.GeneralSettings.UseSkins)
                {
                    w = PNStatic.Settings.GeneralSettings.DockWidth;
                    h = PNStatic.Settings.GeneralSettings.DockHeight;
                }
                else
                {
                    w = PNStatic.Docking.Skin.BitmapSkin.Width;
                    h = PNStatic.Docking.Skin.BitmapSkin.Height;
                }
                IEnumerable<PNote> notes;

                if (prevStatus != DockStatus.None)
                {
                    PNStatic.DockedNotes[prevStatus].Remove(note);
                }

                switch (prevStatus)
                {
                    case DockStatus.Left:
                    case DockStatus.Right:
                        notes = PNStatic.Notes.Where(n => n.DockStatus == prevStatus && n.Dialog.Top > note.Dialog.Top);
                        foreach (var n in notes)
                        {
                            n.Dialog.Top -= h;
                            if (reorder)
                            {
                                n.DockOrder -= 1;
                                SaveNoteDockStatus(n);
                            }
                        }
                        break;
                    case DockStatus.Top:
                    case DockStatus.Bottom:
                        notes = PNStatic.Notes.Where(n => n.DockStatus == prevStatus && n.Dialog.Left > note.Dialog.Left);
                        foreach (var n in notes)
                        {
                            n.Dialog.Left -= w;
                            if (reorder)
                            {
                                n.DockOrder -= 1;
                                SaveNoteDockStatus(n);
                            }
                        }
                        break;
                }
            }
            catch (Exception ex)
            {
                PNStatic.LogException(ex);
            }
        }
Пример #5
0
 internal static void ApplyDocking(DockStatus status)
 {
     try
     {
         foreach (var note in PNStatic.Notes.Where(note => note.Visible && note.DockStatus != status))
         {
             if (status == DockStatus.None)
             {
                 note.Dialog.UndockNote(note);
             }
             else
             {
                 note.Dialog.DockNote(note, status, false);
             }
         }
     }
     catch (Exception ex)
     {
         PNStatic.LogException(ex);
     }
 }
Пример #6
0
 internal NoteDockStatusChangedEventArgs(DockStatus newStatus, DockStatus oldStatus)
 {
     _NewStatus = newStatus;
     _OldStatus = oldStatus;
 }