src/MainActivity.java

@@ -0,0 +1,41 @@
+package net.micode.notes;
+
+import android.os.Bundle;
+
+import androidx.activity.EdgeToEdge;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.graphics.Insets;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
+
+/**
+ * 笔记应用主Activity
+ * 应用启动时显示的入口页面
+ * 继承自AppCompatActivity，使用AndroidX兼容库
+ */
+public class MainActivity extends AppCompatActivity {
+
+    /**
+     * Activity创建时的生命周期回调方法
+     * 初始化Activity布局和界面
+     *
+     * @param savedInstanceState 保存的状态数据，用于Activity重建
+     */
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        // 启用边缘到边缘显示，允许内容延伸到系统UI区域（状态栏和导航栏）
+        EdgeToEdge.enable(this);
+        // 设置Activity的布局文件为activity_main.xml
+        setContentView(R.layout.activity_main);
+        // 设置窗口插入监听器，处理系统UI区域（如状态栏、导航栏）与内容的交互
+        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
+            // 获取系统栏（状态栏和导航栏）的插入区域
+            Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
+            // 为视图设置内边距，避免内容被系统栏遮挡
+            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
+            // 返回处理后的插入信息
+            return insets;
+        });
+    }
+}

src/data/Notes.java

@@ -83,6 +83,8 @@ public class Notes {
         public static final String ORIGIN_PARENT_ID = "origin_parent_id";
         public static final String GTASK_ID = "gtask_id";
         public static final String VERSION = "version";
+        public static final String PINNED = "pinned";
+        public static final String TITLE = "title"; // 便签标题字段
     }
 
     /**

src/data/NotesDatabaseHelper.java

@@ -37,7 +37,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
     // 数据库名称
     private static final String DB_NAME = "note.db";
     // 数据库版本号，用于数据库升级管理
-    private static final int DB_VERSION = 4;
+    private static final int DB_VERSION = 6;
 
     // 表名常量接口
     public interface TABLE {
@@ -61,6 +61,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
                     NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
                     NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
+                    NoteColumns.TITLE + " TEXT NOT NULL DEFAULT ''," +
                     NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
                     NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
                     NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
@@ -68,7 +69,8 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
                     NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
                     NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
-                    NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
+                    NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.PINNED + " INTEGER NOT NULL DEFAULT 0" +
                     ")";
 
     // 创建data表的SQL语句
@@ -186,15 +188,16 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     " END";
 
     // 触发器：当文件夹被移动到回收站时，将该文件夹下的所有便签也移动到回收站
-    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
+    // 但保持便签的PARENT_ID不变，这样可以在回收站中查看完整的文件夹结构
+    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER = 
             "CREATE TRIGGER folder_move_notes_on_trash " +
                     " AFTER UPDATE ON " + TABLE.NOTE +
                     " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
                     " BEGIN" +
                     "  UPDATE " + TABLE.NOTE +
-                    "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+                    "   SET " + NoteColumns.ORIGIN_PARENT_ID + "=parent_id" +
                     "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
-                    " END";
+                    " END;";
 
     /**
      * 构造方法
@@ -346,6 +349,18 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
             oldVersion++;
         }
 
+        // 从版本4升级到版本5
+        if (oldVersion == 4) {
+            upgradeToV5(db);
+            oldVersion++;
+        }
+
+        // 从版本5升级到版本6：添加title列，用于存储便签标题
+        if (oldVersion == 5) {
+            upgradeToV6(db);
+            oldVersion++;
+        }
+
         // 如果需要，重新创建触发器
         if (reCreateTriggers) {
             reCreateNoteTableTriggers(db);
@@ -400,4 +415,22 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
                 + " INTEGER NOT NULL DEFAULT 0");
     }
+    
+    /**
+     * 升级到版本5：添加pinned列，用于标识便签是否被置顶
+     * @param db SQLiteDatabase对象
+     */
+    private void upgradeToV5(SQLiteDatabase db) {
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.PINNED
+                + " INTEGER NOT NULL DEFAULT 0");
+    }
+    
+    /**
+     * 升级到版本6：添加title列，用于存储便签标题
+     * @param db SQLiteDatabase对象
+     */
+    private void upgradeToV6(SQLiteDatabase db) {
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.TITLE
+                + " TEXT NOT NULL DEFAULT ''");
+    }
 }

src/model/Note.java

@@ -83,6 +83,28 @@ public class Note {
         mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
         mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
     }
+    
+    public void setNoteValue(String key, int value) {
+        mNoteDiffValues.put(key, value);
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+    }
+    
+    /**
+     * 设置便签的置顶状态
+     * @param isPinned 是否置顶，true表示置顶，false表示取消置顶
+     */
+    public void setPinned(boolean isPinned) {
+        setNoteValue(NoteColumns.PINNED, isPinned ? 1 : 0);
+    }
+    
+    /**
+     * 获取便签的置顶状态
+     * @return 是否置顶，1表示置顶，0表示取消置顶
+     */
+    public Integer getPinned() {
+        return mNoteDiffValues.getAsInteger(NoteColumns.PINNED);
+    }
 
     public void setTextData(String key, String value) {
         mNoteData.setTextData(key, value);

src/model/WorkingNote.java

@@ -39,6 +39,7 @@ public class WorkingNote {
     private Note mNote;
     private long mNoteId;
     private String mContent;
+    private String mTitle; // 便签标题
     private int mMode;
     private long mAlertDate;
     private long mModifiedDate;
@@ -49,6 +50,7 @@ public class WorkingNote {
     private Context mContext;
     private static final String TAG = "WorkingNote";
     private boolean mIsDeleted;
+    private boolean mIsPinned;
     private NoteSettingChangedListener mNoteSettingStatusListener;
 
     // 数据表查询投影列
@@ -69,7 +71,9 @@ public class WorkingNote {
             NoteColumns.BG_COLOR_ID,
             NoteColumns.WIDGET_ID,
             NoteColumns.WIDGET_TYPE,
-            NoteColumns.MODIFIED_DATE
+            NoteColumns.MODIFIED_DATE,
+            NoteColumns.PINNED,
+            NoteColumns.TITLE
     };
 
     // 数据表投影列索引
@@ -84,6 +88,8 @@ public class WorkingNote {
     private static final int NOTE_WIDGET_ID_COLUMN = 3;
     private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
     private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
+    private static final int NOTE_PINNED_COLUMN = 6;
+    private static final int NOTE_TITLE_COLUMN = 7;
 
     private WorkingNote(Context context, long folderId) {
         mContext = context;
@@ -93,8 +99,10 @@ public class WorkingNote {
         mNote = new Note();
         mNoteId = 0;
         mIsDeleted = false;
+        mIsPinned = false;
         mMode = 0;
         mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+        mTitle = ""; // 初始化标题为空字符串
     }
 
     private WorkingNote(Context context, long noteId, long folderId) {
@@ -122,6 +130,11 @@ public class WorkingNote {
                 mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
                 mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
                 mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
+                mIsPinned = cursor.getInt(NOTE_PINNED_COLUMN) == 1;
+                // 读取便签标题
+                if (cursor.getColumnCount() > NOTE_TITLE_COLUMN) {
+                    mTitle = cursor.getString(NOTE_TITLE_COLUMN);
+                }
             }
             cursor.close();
         } else {
@@ -319,6 +332,21 @@ public class WorkingNote {
     public boolean hasClockAlert() {
         return (mAlertDate > 0 ? true : false);
     }
+    
+    /**
+     * 检查便签是否被置顶
+     */
+    public boolean isPinned() {
+        return mIsPinned;
+    }
+    
+    /**
+     * 设置便签的置顶状态
+     */
+    public void setPinned(boolean isPinned) {
+        mIsPinned = isPinned;
+        mNote.setPinned(isPinned);
+    }
 
     public String getContent() {
         return mContent;
@@ -364,6 +392,23 @@ public class WorkingNote {
         return mWidgetType;
     }
 
+    /**
+     * 获取便签标题
+     */
+    public String getTitle() {
+        return mTitle;
+    }
+    
+    /**
+     * 设置便签标题
+     */
+    public void setTitle(String title) {
+        if (!TextUtils.equals(mTitle, title)) {
+            mTitle = title;
+            mNote.setNoteValue(NoteColumns.TITLE, title);
+        }
+    }
+
     /**
      * 便签设置变更监听器接口
      */

src/tool/DataUtils.java

@@ -24,6 +24,7 @@ import android.content.ContentValues;
 import android.content.OperationApplicationException;
 import android.database.Cursor;
 import android.os.RemoteException;
+import android.text.TextUtils;
 import android.util.Log;
 
 import net.micode.notes.data.Notes;
@@ -33,6 +34,8 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
 
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * 数据操作工具类
@@ -97,6 +100,82 @@ public class DataUtils {
         }
         return false;  // 异常情况
     }
+    
+    /**
+     * 字数统计相关方法
+     * 用于统计文本中的中文字数、数字和英文字符
+     * 统计规则：
+     * 1. 中文字符：每个汉字算1个字数
+     * 2. 数字：每个数字算1个字数
+     * 3. 英文字符：每个英文字母算1个字数
+     * 4. 不统计标点符号与空格
+     */
+    
+    // 中文字符正则表达式
+    private static final Pattern CHINESE_CHAR_PATTERN = Pattern.compile("[\\u4e00-\\u9fa5]");
+    // 数字正则表达式
+    private static final Pattern NUMBER_PATTERN = Pattern.compile("[0-9]");
+    // 英文字符正则表达式
+    private static final Pattern ENGLISH_CHAR_PATTERN = Pattern.compile("[a-zA-Z]");
+
+    /**
+     * 统计文本总字数
+     * @param text 要统计的文本
+     * @return 总字数
+     */
+    public static int getTotalWordCount(String text) {
+        if (TextUtils.isEmpty(text)) {
+            return 0;
+        }
+
+        int chineseCount = countChineseCharacters(text);
+        int numberCount = countNumbers(text);
+        int englishCount = countEnglishCharacters(text);
+
+        return chineseCount + numberCount + englishCount;
+    }
+
+    /**
+     * 统计中文字符数
+     * @param text 要统计的文本
+     * @return 中文字符数
+     */
+    private static int countChineseCharacters(String text) {
+        Matcher matcher = CHINESE_CHAR_PATTERN.matcher(text);
+        int count = 0;
+        while (matcher.find()) {
+            count++;
+        }
+        return count;
+    }
+
+    /**
+     * 统计数字字符数
+     * @param text 要统计的文本
+     * @return 数字字符数
+     */
+    private static int countNumbers(String text) {
+        Matcher matcher = NUMBER_PATTERN.matcher(text);
+        int count = 0;
+        while (matcher.find()) {
+            count++;
+        }
+        return count;
+    }
+
+    /**
+     * 统计英文字符数
+     * @param text 要统计的文本
+     * @return 英文字符数
+     */
+    private static int countEnglishCharacters(String text) {
+        Matcher matcher = ENGLISH_CHAR_PATTERN.matcher(text);
+        int count = 0;
+        while (matcher.find()) {
+            count++;
+        }
+        return count;
+    }
 
     /**
      * 移动单个便签到指定文件夹
@@ -111,7 +190,13 @@ public class DataUtils {
     public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
         ContentValues values = new ContentValues();
         values.put(NoteColumns.PARENT_ID, desFolderId);      // 设置新父文件夹
-        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);  // 记录原始父文件夹，用于撤销
+        
+        // 只有当移动到回收站时，才记录原始父文件夹ID
+        // 从回收站恢复时，保留原始的ORIGIN_PARENT_ID，以便递归恢复子项
+        if (desFolderId == Notes.ID_TRASH_FOLER) {
+            values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);  // 记录原始父文件夹，用于撤销
+        }
+        
         values.put(NoteColumns.LOCAL_MODIFIED, 1);           // 标记为本地已修改，需要同步
         resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
     }
@@ -123,6 +208,7 @@ public class DataUtils {
      * 1. 支持空集合的检查
      * 2. 使用事务保证数据一致性
      * 3. 自动标记为本地修改，触发同步
+     * 4. 移动到回收站时记录原始父文件夹ID
      *
      * @param resolver 内容解析器
      * @param ids 要移动的便签ID集合
@@ -140,6 +226,26 @@ public class DataUtils {
         for (long id : ids) {
             ContentProviderOperation.Builder builder = ContentProviderOperation
                     .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            
+            // 如果是移动到回收站，记录原始父文件夹ID
+            if (folderId == Notes.ID_TRASH_FOLER) {
+                // 首先查询当前父文件夹ID
+                Cursor cursor = resolver.query(
+                        ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id),
+                        new String[]{NoteColumns.PARENT_ID},
+                        null,
+                        null,
+                        null);
+                if (cursor != null) {
+                    if (cursor.moveToFirst()) {
+                        long currentParentId = cursor.getLong(0);
+                        // 保存原始父文件夹ID
+                        builder.withValue(NoteColumns.ORIGIN_PARENT_ID, currentParentId);
+                    }
+                    cursor.close();
+                }
+            }
+            
             builder.withValue(NoteColumns.PARENT_ID, folderId);      // 设置新父文件夹
             builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);        // 标记为本地修改
             operationList.add(builder.build());
@@ -159,6 +265,34 @@ public class DataUtils {
         }
         return false;
     }
+    
+    /**
+     * 获取指定文件夹下的所有直接子项（包括便签和子文件夹）
+     *
+     * @param resolver 内容解析器
+     * @param folderId 文件夹ID
+     * @return 子项ID集合，没有子项时返回空集合
+     */
+    public static HashSet<Long> getFolderItems(ContentResolver resolver, long folderId) {
+        HashSet<Long> items = new HashSet<Long>();
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[]{NoteColumns.ID},
+                NoteColumns.PARENT_ID + "=?",
+                new String[]{String.valueOf(folderId)},
+                null);
+        
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                do {
+                    long id = cursor.getLong(0);
+                    items.add(id);
+                } while (cursor.moveToNext());
+            }
+            cursor.close();
+        }
+        
+        return items;
+    }
 
     /**
      * 获取用户文件夹数量（排除系统文件夹）
@@ -201,6 +335,11 @@ public class DataUtils {
      * @return true表示便签存在且不在回收站中，false表示不存在或在回收站中
      */
     public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+        // 根文件夹永远可见
+        if (noteId == Notes.ID_ROOT_FOLDER) {
+            return true;
+        }
+        
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null,
                 NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,

src/ui/NoteEditActivity.java

@@ -43,9 +43,13 @@ import android.view.MotionEvent;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.WindowManager;
+import android.text.Editable;
+import android.text.TextWatcher;
 import android.widget.CheckBox;
 import android.widget.CompoundButton;
 import android.widget.CompoundButton.OnCheckedChangeListener;
+import android.widget.Button;
+import android.app.Dialog;
 import android.widget.EditText;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
@@ -150,6 +154,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
     private LinearLayout mEditTextList;            // 清单模式下的编辑列表容器
     private String mUserQuery;                     // 搜索查询词（用于高亮显示）
     private Pattern mPattern;                      // 搜索高亮正则表达式模式
+    private TextView mWordCountView;               // 字数统计显示控件
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -192,32 +197,33 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         mWorkingNote = null;
 
         // 处理查看笔记的意图
-        if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
-            long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
-            mUserQuery = "";
-
-            // 处理从搜索结果打开的情况
-            if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
-                noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
-                mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
-            }
+            if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
+                long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
+                mUserQuery = "";
+
+                // 处理从搜索结果打开的情况
+                if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
+                    noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
+                    mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
+                }
 
-            // 检查笔记是否存在
-            if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
-                Intent jump = new Intent(this, NotesListActivity.class);
-                startActivity(jump);
-                showToast(R.string.error_note_not_exist);
-                finish();
-                return false;
-            } else {
-                // 加载笔记
-                mWorkingNote = WorkingNote.load(this, noteId);
-                if (mWorkingNote == null) {
-                    Log.e(TAG, "load note failed with note id" + noteId);
+                // 检查笔记是否存在
+                // 对于回收站中的便签，使用existInNoteDatabase而不是visibleInNoteDatabase
+                if (!DataUtils.existInNoteDatabase(getContentResolver(), noteId)) {
+                    Intent jump = new Intent(this, NotesListActivity.class);
+                    startActivity(jump);
+                    showToast(R.string.error_note_not_exist);
                     finish();
                     return false;
+                } else {
+                    // 加载笔记
+                    mWorkingNote = WorkingNote.load(this, noteId);
+                    if (mWorkingNote == null) {
+                        Log.e(TAG, "load note failed with note id" + noteId);
+                        finish();
+                        return false;
+                    }
                 }
-            }
             // 隐藏软键盘
             getWindow().setSoftInputMode(
                     WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
@@ -299,6 +305,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             // 普通模式，显示内容并高亮搜索词
             mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
             mNoteEditor.setSelection(mNoteEditor.getText().length());
+            // 更新字数统计
+            updateWordCount();
         }
 
         // 隐藏所有背景选择指示器
@@ -318,6 +326,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
 
         // 显示提醒信息
         showAlertHeader();
+
     }
 
     /**
@@ -438,6 +447,26 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
 
         mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
+        // 初始化字数统计控件
+        mWordCountView = (TextView) findViewById(R.id.tv_word_count);
+        // 设置文本变化监听器
+        mNoteEditor.addTextChangedListener(new TextWatcher() {
+            @Override
+            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+                // 文本变化前的处理，暂不需要
+            }
+
+            @Override
+            public void onTextChanged(CharSequence s, int start, int before, int count) {
+                // 文本变化时更新字数统计
+                updateWordCount();
+            }
+
+            @Override
+            public void afterTextChanged(Editable s) {
+                // 文本变化后的处理，暂不需要
+            }
+        });
     }
 
     @Override
@@ -450,6 +479,47 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         clearSettingState();  // 清除设置状态
     }
 
+    /**
+     * 更新字数统计显示
+     */
+    private void updateWordCount() {
+        if (mWordCountView != null) {
+            String content = getCurrentNoteContent();
+            int wordCount = DataUtils.getTotalWordCount(content);
+            mWordCountView.setText(getString(R.string.note_word_count, wordCount));
+        }
+    }
+    
+    /**
+     * 获取当前便签的内容，根据不同模式选择不同的获取方式
+     * @return 当前便签的内容
+     */
+    private String getCurrentNoteContent() {
+        StringBuilder content = new StringBuilder();
+        
+        // 检查当前模式
+        if (mNoteEditor.getVisibility() == View.VISIBLE) {
+            // 普通模式，直接获取编辑框内容
+            content.append(mNoteEditor.getText().toString());
+        } else if (mEditTextList.getVisibility() == View.VISIBLE) {
+            // 清单模式，收集所有列表项的内容
+            for (int i = 0; i < mEditTextList.getChildCount(); i++) {
+                View itemView = mEditTextList.getChildAt(i);
+                EditText editText = (EditText) itemView.findViewById(R.id.et_edit_text);
+                if (editText != null && !TextUtils.isEmpty(editText.getText())) {
+                    // 添加当前列表项的内容
+                    content.append(editText.getText().toString());
+                    // 添加换行符，保持原有格式
+                    if (i < mEditTextList.getChildCount() - 1) {
+                        content.append("\n");
+                    }
+                }
+            }
+        }
+        
+        return content.toString();
+    }
+
     /**
      * 更新桌面小部件
      */
@@ -573,6 +643,16 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         } else {
             menu.findItem(R.id.menu_delete_remind).setVisible(false);
         }
+        
+        // 根据便签的置顶状态设置菜单项标题
+        MenuItem pinItem = menu.findItem(R.id.menu_pin_note);
+        if (pinItem != null) {
+            if (mWorkingNote.isPinned()) {
+                pinItem.setTitle(R.string.menu_unpin_note);
+            } else {
+                pinItem.setTitle(R.string.menu_pin_note);
+            }
+        }
         return true;
     }
 
@@ -597,15 +677,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                 getWorkingText();
                 sendTo(this, mWorkingNote.getContent());
                 break;
-            case R.id.menu_send_to_desktop: // 发送到桌面
-                sendToDesktop();
-                break;
             case R.id.menu_alert:         // 设置提醒
                 setReminder();
                 break;
             case R.id.menu_delete_remind: // 删除提醒
                 mWorkingNote.setAlertDate(0, false);
                 break;
+            case R.id.menu_pin_note: // 置顶/取消置顶
+                mWorkingNote.setPinned(!mWorkingNote.isPinned());
+                break;
             default:
                 break;
         }
@@ -681,15 +761,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             } else {
                 Log.d(TAG, "Wrong note id, should not happen");
             }
-            // 根据同步模式决定删除方式
-            if (!isSyncMode()) {
-                if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
-                    Log.e(TAG, "Delete Note error");
-                }
-            } else {
-                if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
-                    Log.e(TAG, "Move notes to trash folder error, should not happens");
-                }
+            // 所有模式下，都将删除的笔记移动到回收站
+            if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
+                Log.e(TAG, "Move notes to trash folder error, should not happens");
             }
         }
         mWorkingNote.markDeleted(true);
@@ -773,6 +847,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         edit.append(text);
         edit.requestFocus();
         edit.setSelection(length);
+
     }
 
     /**
@@ -798,6 +873,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
                     .setIndex(i);
         }
+        
+
     }
 
     /**
@@ -822,6 +899,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
 
         mNoteEditor.setVisibility(View.GONE);  // 隐藏普通编辑框
         mEditTextList.setVisibility(View.VISIBLE);  // 显示清单列表
+        
+
     }
 
     /**
@@ -877,6 +956,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
         }
 
+        
         edit.setOnTextViewChangeListener(this);  // 设置文本变化监听
         edit.setIndex(index);  // 设置项目索引
         edit.setText(getHighlightQueryResult(item, mUserQuery));  // 设置文本（支持高亮）
@@ -897,6 +977,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         } else {
             mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
         }
+        // 更新字数统计
+        updateWordCount();
     }
 
     /**
@@ -917,6 +999,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             mEditTextList.setVisibility(View.GONE);
             mNoteEditor.setVisibility(View.VISIBLE);
         }
+        
+        // 更新字数统计
+        updateWordCount();
     }
 
     /**
@@ -1003,6 +1088,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    
     /**
      * 生成快捷方式图标标题
      */

src/ui/NoteItemData.java

@@ -33,18 +33,20 @@ import net.micode.notes.tool.DataUtils;
 public class NoteItemData {
     // 数据库查询列投影
     static final String [] PROJECTION = new String [] {
-            NoteColumns.ID,              // 笔记ID
-            NoteColumns.ALERTED_DATE,    // 提醒时间
-            NoteColumns.BG_COLOR_ID,     // 背景颜色ID
-            NoteColumns.CREATED_DATE,    // 创建时间
-            NoteColumns.HAS_ATTACHMENT,  // 是否有附件
-            NoteColumns.MODIFIED_DATE,   // 修改时间
-            NoteColumns.NOTES_COUNT,     // 笔记数量（针对文件夹）
-            NoteColumns.PARENT_ID,       // 父文件夹ID
-            NoteColumns.SNIPPET,         // 内容摘要
-            NoteColumns.TYPE,            // 类型（笔记/文件夹/系统文件夹）
-            NoteColumns.WIDGET_ID,       // 小部件ID
-            NoteColumns.WIDGET_TYPE,     // 小部件类型
+            NoteColumns.ID,              // 0: 笔记ID
+            NoteColumns.ALERTED_DATE,    // 1: 提醒时间
+            NoteColumns.BG_COLOR_ID,     // 2: 背景颜色ID
+            NoteColumns.CREATED_DATE,    // 3: 创建时间
+            NoteColumns.HAS_ATTACHMENT,  // 4: 是否有附件
+            NoteColumns.MODIFIED_DATE,   // 5: 修改时间
+            NoteColumns.NOTES_COUNT,     // 6: 笔记数量（针对文件夹）
+            NoteColumns.PARENT_ID,       // 7: 父文件夹ID
+            NoteColumns.SNIPPET,         // 8: 内容摘要
+            NoteColumns.TITLE,           // 9: 笔记标题
+            NoteColumns.TYPE,            // 10: 类型（笔记/文件夹/系统文件夹）
+            NoteColumns.WIDGET_ID,       // 11: 小部件ID
+            NoteColumns.WIDGET_TYPE,     // 12: 小部件类型
+            NoteColumns.PINNED,          // 13: 是否置顶
     };
 
     // 列索引常量
@@ -57,9 +59,11 @@ public class NoteItemData {
     private static final int NOTES_COUNT_COLUMN           = 6;
     private static final int PARENT_ID_COLUMN             = 7;
     private static final int SNIPPET_COLUMN               = 8;
-    private static final int TYPE_COLUMN                  = 9;
-    private static final int WIDGET_ID_COLUMN             = 10;
-    private static final int WIDGET_TYPE_COLUMN           = 11;
+    private static final int TITLE_COLUMN                 = 9;
+    private static final int TYPE_COLUMN                  = 10;
+    private static final int WIDGET_ID_COLUMN             = 11;
+    private static final int WIDGET_TYPE_COLUMN           = 12;
+    private static final int PINNED_COLUMN                = 13;
 
     // 笔记数据字段
     private long mId;                 // 笔记ID
@@ -71,9 +75,11 @@ public class NoteItemData {
     private int mNotesCount;          // 笔记数量（针对文件夹）
     private long mParentId;           // 父文件夹ID
     private String mSnippet;          // 内容摘要
+    private String mTitle;            // 笔记标题
     private int mType;                // 类型
     private int mWidgetId;            // 小部件ID
     private int mWidgetType;          // 小部件类型
+    private boolean mIsPinned;        // 是否置顶
     private String mName;             // 联系人姓名（针对通话记录）
     private String mPhoneNumber;      // 电话号码（针对通话记录）
 
@@ -97,15 +103,40 @@ public class NoteItemData {
         mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
         mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
         mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
-        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
         mParentId = cursor.getLong(PARENT_ID_COLUMN);
         mSnippet = cursor.getString(SNIPPET_COLUMN);
         // 移除清单标记
         mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
                 NoteEditActivity.TAG_UNCHECKED, "");
+        mTitle = cursor.getString(TITLE_COLUMN);  // 读取标题字段，修复索引偏移问题
         mType = cursor.getInt(TYPE_COLUMN);
         mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
         mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
+        mIsPinned = (cursor.getInt(PINNED_COLUMN) > 0) ? true : false;
+
+        // 动态计算文件夹的便签数量
+        if (mType == Notes.TYPE_FOLDER && mParentId == Notes.ID_TRASH_FOLER) {
+            // 只对回收站中的文件夹进行动态计算
+            // 查询ORIGIN_PARENT_ID等于当前文件夹ID的便签数量
+            // 这样可以在回收站中显示文件夹内的便签数量
+            Cursor countCursor = context.getContentResolver().query(
+                    Notes.CONTENT_NOTE_URI,
+                    new String[]{"COUNT(*)"},
+                    Notes.NoteColumns.ORIGIN_PARENT_ID + "=?",
+                    new String[]{String.valueOf(mId)},
+                    null);
+            if (countCursor != null) {
+                if (countCursor.moveToFirst()) {
+                    mNotesCount = countCursor.getInt(0);
+                }
+                countCursor.close();
+            } else {
+                mNotesCount = 0;
+            }
+        } else {
+            // 对于其他文件夹，使用原来的NOTES_COUNT字段
+            mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
+        }
 
         // 初始化通话记录相关字段
         mPhoneNumber = "";
@@ -292,6 +323,32 @@ public class NoteItemData {
     public String getSnippet() {
         return mSnippet;
     }
+    
+    /**
+     * 获取标题
+     */
+    public String getTitle() {
+        return mTitle;
+    }
+    
+    /**
+     * 获取显示标题：优先使用标题字段，无标题时使用内容摘要的第一行
+     */
+    public String getDisplayTitle() {
+        if (!TextUtils.isEmpty(mTitle)) {
+            return mTitle;
+        }
+        // 没有标题时，返回内容摘要的第一行
+        if (!TextUtils.isEmpty(mSnippet)) {
+            int newlineIndex = mSnippet.indexOf('\n');
+            if (newlineIndex > 0) {
+                return mSnippet.substring(0, newlineIndex);
+            } else {
+                return mSnippet;
+            }
+        }
+        return "";
+    }
 
     /**
      * 检查是否有提醒
@@ -315,4 +372,12 @@ public class NoteItemData {
     public static int getNoteType(Cursor cursor) {
         return cursor.getInt(TYPE_COLUMN);
     }
+    
+    /**
+     * 检查笔记是否置顶
+     * @return 是否置顶
+     */
+    public boolean isPinned() {
+        return mIsPinned;
+    }
 }

src/ui/NotesListAdapter.java

@@ -113,6 +113,7 @@ public class NotesListAdapter extends CursorAdapter {
     public void setChoiceMode(boolean mode) {
         mSelectedIndex.clear();  // 清除之前的选中状态
         mChoiceMode = mode;
+        notifyDataSetChanged();  // 通知数据集变化，清除对勾标记
     }
 
     /**
@@ -151,6 +152,14 @@ public class NotesListAdapter extends CursorAdapter {
 
         return itemSet;
     }
+    
+    /**
+     * 获取选中位置的映射表
+     * @return 选中位置的映射表
+     */
+    public HashMap<Integer, Boolean> getSelectedIndex() {
+        return mSelectedIndex;
+    }
 
     /**
      * 获取所有选中的小部件属性集合

src/ui/NotesListItem.java

@@ -108,17 +108,26 @@ public class NotesListItem extends LinearLayout {
                 mTitle.setText(data.getSnippet()  // 设置文件夹名称
                         + context.getString(R.string.format_folder_files_count,
                         data.getNotesCount()));  // 添加笔记数量
-                mAlert.setVisibility(View.GONE);  // 文件夹不显示提醒图标
-            } else {
-                // 普通笔记类型
-                mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));  // 设置笔记内容片段
-                // 根据是否有提醒设置提醒图标
-                if (data.hasAlert()) {
-                    mAlert.setImageResource(R.drawable.clock);  // 有时钟图标
+                // 根据是否置顶设置置顶图标
+                if (data.isPinned()) {
+                    mAlert.setImageResource(R.drawable.arrow_up);  // 置顶标记
                     mAlert.setVisibility(View.VISIBLE);
                 } else {
                     mAlert.setVisibility(View.GONE);
                 }
+            } else {
+                // 普通笔记类型
+            mTitle.setText(DataUtils.getFormattedSnippet(data.getDisplayTitle()));  // 设置笔记标题，优先使用标题字段
+            // 根据是否置顶或有提醒设置图标
+            if (data.isPinned()) {
+                mAlert.setImageResource(R.drawable.arrow_up);  // 置顶标记
+                mAlert.setVisibility(View.VISIBLE);
+            } else if (data.hasAlert()) {
+                mAlert.setImageResource(R.drawable.clock);  // 有时钟图标
+                mAlert.setVisibility(View.VISIBLE);
+            } else {
+                mAlert.setVisibility(View.GONE);
+            }
             }
         }
         // 设置相对时间（如"5分钟前"、"昨天"等格式）