/// <summary>
    /// Submit Button Click Event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSubmit_Click(object sender, EventArgs e)
    {
        NoteAdmin _Noteadmin = new NoteAdmin();
        Note _NoteAccess = new Note();

        _NoteAccess.CaseID = ItemID;
        _NoteAccess.AccountID = null;
        _NoteAccess.CreateDte = System.DateTime.Now;
        _NoteAccess.CreateUser = HttpContext.Current.User.Identity.Name;
        _NoteAccess.NoteTitle = txtNoteTitle.Text.Trim();
        _NoteAccess.NoteBody = ctrlHtmlText.Html ;

        bool Check = _Noteadmin.Insert(_NoteAccess);

        if (Check)
        {
            //redirect to main page
            Response.Redirect(CancelLink);
        }
        else
        {
            //display error message
            lblError.Text  = "An error occurred while updating. Please try again.";
            lblError.Visible = true;
        }
    }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            string item = null;
            _isEditMode = false;

            if (NavigationContext.QueryString.TryGetValue("item", out item))
            {
                //call get note;
                if (_manager != null)
                {
                    _currentNote = _manager.Retrieve(Convert.ToInt32(item));
                    //set node properties to the UI
                    if (_currentNote == null)
                    {
                        tbContent.Text = string.Empty;
                        tbTitle.Text = string.Empty;
                    }
                    else
                    {
                        tbContent.Text = _currentNote.Content;
                        tbTitle.Text = _currentNote.Title;
                        _isEditMode = true;
                    }
                }
            }
        }

 /// <summary>
 /// Play an array of Notes
 /// </summary>
 /// <param name="notes">An array of Note objects, each defining a frequency and duration</param>
 public void Play(Note[] notes)
 {
     foreach (Note note in notes)
     {
         Play(note.Frequency, note.Duration);
     }
 }

 //Button Add click handler
 private void btnAdd_Click(object sender, EventArgs e)
 {
     if (CheckUpCount() == true)
     {
         try
         {
             //show Editor dialog
             frmEditor EditorForm = new frmEditor();
             EditorForm.ShowDialog();
             //add new data to data-collection
             if (EditorForm.IsCanceled == false)
             {
                 Note NewNote = new Note(EditorForm.TextName, EditorForm.TextArray);
                 EncryptedData.AddNote(NewNote);
             }
         }
         catch (OutOfMemoryException Exc)
         {
             MessageBox.Show(Exc.ToString());
         }
         catch (ArgumentException Exc)
         {
             MessageBox.Show(Exc.ToString());
         }
         //add new record to grid
         UpdateGrid();
     }
 }

		private void NoteDeletedHandler (object noteMgr, Note deletedNote)
		{
			deletedNotes [deletedNote.Id] = deletedNote.Title;
			fileRevisions.Remove (deletedNote.Id);

			Write (localManifestFilePath);
		}

        async void CheckForResumedStartup()
        {
            if (await FileHelper.ExistsAsync(App.TransientFilename))
            {
                // Read the file.
                string str = await FileHelper.ReadTextAsync(App.TransientFilename);

                // Delete the file.
                await FileHelper.DeleteFileAsync(App.TransientFilename);

                // Break down the file contents.
                string[] contents = str.Split('\x1F');
                string filename = contents[0];
                bool isNoteEdit = Boolean.Parse(contents[1]);
                string entryText = contents[2];
                string editorText = contents[3];

                // Create the Note object and initialize it with saved data.
                Note note = new Note(filename);
                note.Title = entryText;
                note.Text = editorText;

                // Navigate to NotePage.
                NotePage notePage = new NotePage(note, isNoteEdit);
                await this.Navigation.PushAsync(notePage);
            }
        }

    public void Open(List<Minion> minions, List<Note> notes)
    {
        //Transform parent = this.transform.parent;

        this.minion = null;
        foreach (Minion m in minions) {
            if (m.gameObject.name == this.minionName) {
                this.minion = m;
                break;
            }
        }

        this.note = null;
        foreach (Note n in notes) {
            if (n.gameObject.name == this.noteName) {
                this.note = n;
                break;
            }
        }

        if (this.minion != null) {
            this.minion.EnableClicks();
            this.minion.gameObject.GetComponent<SpriteRenderer>().color = Color.white;
        }
        if (this.note != null) {
            this.note.EnableClicks();
            this.note.gameObject.GetComponent<SpriteRenderer>().color = Color.white;
        }
    }

        public void AddNotes(string SqlWhereClause = null)
        {
            int idFld = m_NotesTable.FindField("Notes_ID");
            int ownerFld = m_NotesTable.FindField("OwnerID");
            int typeFld = m_NotesTable.FindField("Type");
            int notesFld = m_NotesTable.FindField("Notes");
            int dsFld = m_NotesTable.FindField("DataSourceID");

            ICursor theCursor;

            if (SqlWhereClause == null) { theCursor = m_NotesTable.Search(null, false); }
            else
            {
                IQueryFilter QF = new QueryFilterClass();
                QF.WhereClause = SqlWhereClause;
                theCursor = m_NotesTable.Search(QF, false);
            }

            IRow theRow = theCursor.NextRow();

            while (theRow != null)
            {
                Note anNote = new Note();
                anNote.Notes_ID = theRow.get_Value(idFld).ToString();
                anNote.OwnerID = theRow.get_Value(ownerFld).ToString();
                anNote.Notes = theRow.get_Value(notesFld).ToString();
                anNote.Type = theRow.get_Value(typeFld).ToString();
                anNote.DataSourceID = theRow.get_Value(dsFld).ToString();
                anNote.RequiresUpdate = true;

                m_NotesDictionary.Add(anNote.Notes_ID, anNote);

                theRow = theCursor.NextRow();
            }
        }

        private static void Go(long userId)
        {
            var settings = new MongoServerSettings
            {
                Server = new MongoServerAddress("127.0.0.1", 27017),
                SafeMode = SafeMode.False
            };
            var mongoServer = new MongoServer(settings);

            var database = mongoServer.GetDatabase("Test");

            var map = new NoteMap();
            var collection = new EntityCollection<Note>(database, map.GetDescriptor(), true);

            var note = new Note
            {
                NoteID = "1",
                Title = "This is a book.",
                Content = "Oh yeah",
                UserID = 123321L
            };
            // collection.InsertOnSubmit(note);
            // collection.SubmitChanges();
            // var data = collection.SelectTo(n => new { n.NoteID, n.UserID });
            collection.Log = Console.Out;
            var a = 4;
            collection.Update(
                n => new Note { },
                n => true);
        }

        public float ComputeFitness(Note[] individual)
        {
            float weighted_sum = 0;
            for (int i = 0; i < metrics.Length; i++)
            {
                var x = metrics[i].Generate(individual);
                var t = target_metrics[i];
                float magx = 0;
                float magt = 0;
                float dot = 0;
                foreach(var v in x.Values)
                    magx += v * v;
                foreach(var v in t.Values)
                    magt += v * v;
                foreach (var p in x.Keys)
                {
                    float f1 = x[p];
                    if (!t.ContainsKey(p))
                        continue;

                    float f2 = t[p];
                    dot += f1 * f2;
                }
                magx = (float)Math.Sqrt(magx);
                magt = (float)Math.Sqrt(magt);
                if (magx == 0 || magt == 0)
                    return 0;
                weighted_sum += dot / (magx * magt);
            }
            return weighted_sum / metrics.Length;
        }

        public List<Note> GetNotes(Roll roll)
        {
            string sql = NotesSql(roll);
            var reader = Data_Context.RunSelectSQLQuery(sql, 30);

            var notes = new List<Note>();

            if (reader.HasRows)
            {
                var sReader = new SpecialistsReader();
                while (reader.Read())
                {
                    string uName = reader["Author"] as string;
                    var spec = sReader.GetSpecialist(uName);
                    string n = reader["Note"] as string;
                    DateTime date = reader.GetDateTime(4);
                    string step = reader["StepTypeID"] as string;

                    var note = new Note(spec, n, date, step);
                    notes.Add(note);
                }
                return notes;
            }
            else return null;
        }

        public NoteContent(object sender , object sender1)
        {
            this.InitializeComponent();
            item = (Button)sender;
            item1 = (Button) sender1;
            notepadRepository = new NotepadRepository();
            ourNotes = notepadRepository.GetNotes(item.Content.ToString().ToLower());
            notepad = ourNotes[0].notepad;

            foreach (Note note in ourNotes)
            {
                if (note.title == item1.Content.ToString().ToLower())
                    CurrNote = note;
            }
            if (CurrNote != null)
            {
                if (CurrNote.title == "+")
                    CurrNote.title = "New Title";
                NoteAct.Text = CurrNote.content;
                //NoteAct.Document.SetText(new Windows.UI.Text.TextSetOptions(), CurrNote.content);
                NoteName.Text = CurrNote.title;
            }
            AppTitle.Text = notepad;
                foreach (Note note in ourNotes)
            {
                notes.Items.Add(createNoteButton(note.title,note.content));
            }
        }

        public NewItemWindow(Note source)
            : this()
        {
            Title = "Edit Note";

            NoteEditControl.SourceNote = source;
        }

        /// <summary>
        /// Handles the Click event of the lbAddNote control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
        protected void lbAddNote_Click( object sender, EventArgs e )
        {
            var rockContext = new RockContext();
            var service = new NoteService( rockContext );

            var note = new Note();
            note.IsSystem = false;
            note.IsAlert = false;
            note.NoteTypeId = noteType.Id;
            note.EntityId = contextEntity.Id;
            note.Text = tbNewNote.Text;

            if ( noteType.Sources != null )
            {
                var source = noteType.Sources.DefinedValues.FirstOrDefault();
                if ( source != null )
                {
                    note.SourceTypeValueId = source.Id;
                }
            }

            service.Add( note );
            rockContext.SaveChanges();

            ShowNotes();
        }

 public static int getNoteIndex(Note note)
 {
     switch (note)
     {
         case Note.C1:
         case Note.Cs:
             return 0;
         case Note.D1:
         case Note.Ds:
             return 1;
         case Note.E1:
             return 2;
         case Note.F1:
         case Note.Fs:
             return 3;
         case Note.G1:
         case Note.Gs:
             return 4;
         case Note.A1:
         case Note.As:
             return 5;
         case Note.B1:
             return 6;
         case Note.C2:
             return 7;
         default:
             return -1;
     }
 }

        public IEnumerable<MethodValue> GetValues(ReflectedInstance value, Type type, MethodInfo methodInfo)
        {
            if (methodInfo.Name == "Beep")
            {
                Note[] melody = new Note[] {
                    new Note(Note.C, 0, 100),
                    new Note(Note.C, 0, 100),
                    new Note(Note.D, 0, 100),
                    new Note(Note.E, 0, 100),
                    new Note(Note.F, 0, 100),
                    new Note(Note.G, 0, 100),
                    new Note(Note.A, 0, 100),
                    new Note(Note.B, 0, 100),
                    new Note(Note.C, 1, 100),
                    new Note(Note.D, 1, 100),
                    new Note(Note.E, 1, 100),
                    new Note(Note.F, 1, 100),
                    new Note(Note.G, 1, 100),
                    new Note(Note.A, 1, 100),
                    new Note(Note.B, 1, 100),
                    new Note(Note.C, 2, 100)
                };

                var parameters = methodInfo.GetParameters();
                foreach (var note in melody)
                {
                    var methodValue = methodInfo.Invoke("Beep", new object[] { note.Frequency, note.Duration });
                    var parameter = new MethodValueParam(parameters[0].Name, parameters[0], note.Frequency);
                    var parameter1 = new MethodValueParam(parameters[1].Name, parameters[1], note.Duration);
                    yield return new MethodValue(methodValue, parameter, parameter1);
                }
            }
        }

        public static DialogResult showDialog(
			Form parent,
			Note note,
			bool fCanDelete )
        {
            using ( FNote dlg = new FNote() )
            {
                dlg.cmdDelete.Visible = fCanDelete;
                foreach ( string s in Directory.GetDirectories( Global.Preferences.MainPath ) )
                {
                    int i;
                    if ( int.TryParse( s.Substring( s.LastIndexOf('_') + 1 ), out i ) )
                        if ( i > 400000 )
                            dlg.cboOrder.Items.Add( i.ToString() );
                }
                if ( note.RegardingDate != DateTime.MinValue )
                    dlg.dtp.Date = note.RegardingDate;
                if ( note.OrderNumber != 0 )
                    dlg.cboOrder.Text = note.OrderNumber.ToString();
                dlg.txt.Text = note.Text;
                DialogResult retVal = dlg.ShowDialog( parent );
                if ( retVal == DialogResult.OK )
                {
                    note.Text = dlg.txt.Text;
                    note.RegardingDate = dlg.optDatum.Checked ?
                        dlg.dtp.Date : DateTime.MinValue;
                    int.TryParse( dlg.cboOrder.Text, out note.OrderNumber );
                }
                return retVal;
            }
        }

        public ActionResult AddOrMod(string title, string content, int id = -1)
        {
            if (!User.Identity.IsAuthenticated) return Redirect(_client.OAuthCheckUrl());
            try
            {
                var note = new Note();
                if (id != -1)
                {
                    note = _entities.Notes.SingleOrDefault(m => m.Id == id);
                    if (note == null)
                    {
                        throw new Exception("Note not exists.");
                    }

                }
                note.Title = title;
                note.Content = content;
                note.User = User.Identity.Name;

                if(note.EntityState != EntityState.Modified)
                _entities.AddToNotes(note);
                _entities.SaveChanges();
                _entities.Refresh(RefreshMode.StoreWins, note);
                return Json(new { code = 0, data = note }, JsonRequestBehavior.AllowGet);
            }
            catch (Exception ex)
            {
                return Json(new { code = 1, data = ex.Message }, JsonRequestBehavior.AllowGet);
            }
        }

    private void ReadBeatFromTxt(string fileName)
    {
        string noteString = Resources.Load<TextAsset>(fileName).text;
        string[] lines = noteString.Split('\n');

        int bpm = Int32.Parse(lines[1]);
        int quantize = Int32.Parse(lines[2]);
        float beatLen = 60.0f / (float)bpm * (4.0f / (float)quantize);

        uint count = 0;
        uint notecount = 0;
        for (int i = 3; i < lines.Length; ++i) {
            foreach (char c in lines[i]) {
                switch (c) {
                    case '0':
                        notecount++;
                        Note newNote
                            = new Note(notecount,
                                       (int)((count * beatLen + NoteMover.NoteDelay) * 1000000) + BEAT_DELAY_TEMP);
                        NoteList.Enqueue(newNote);
                        count++;
                        break;
                    case '-':
                        count++; break;
                    case ' ':
                        break;
                    case ';':
                        Turnline newTurnline = new Turnline(
                        (int)((count * beatLen + NoteMover.NoteDelay) * 1000000) + BEAT_DELAY_TEMP);
                        FlipList.Enqueue(newTurnline);
                        break;
                }
            }
        }
    }

 public void TestNote()
 {
     Note note = new Note(TITLE, "");
     Assert.AreEqual(note.Title, TITLE);
     note.Content = CONTENT;
     Assert.AreEqual(note.Content, CONTENT);
 }