基于 FLTK 制作用户管理程序

博主：小学生菲利克斯
发布时间：2024 年 01 月 08 日
66 次浏览
暂无评论
12743字数
分类：教程

本示例展示了基于 FLTK 和 SQLITE 制作用户管理程序。代码比较长，但是不难看懂。

main.rs

mod store {
    use super::Userdata;
    use anyhow::Result;
    use rusqlite::Connection;

    pub struct Database {
        conn: Connection,
    }

    impl Database {
        pub fn create_connection() -> Result<Self> {
            let conn = Connection::open(":memory:")?;

            conn.execute(
                r#"CREATE TABLE IF NOT EXISTS userdata (
                id INTEGER PRIMARY KEY,
                username TEXT NOT NULL,
                age INTEGER NOT NULL
            );"#,
                (),
            )?;

            Ok(Self { conn })
        }

        pub fn insert_userdata(&self, username: &str, age: u64) -> Result<()> {
            self.conn.execute(
                r#"INSERT INTO userdata (username, age) VALUES (?, ?);"#,
                (username, age),
            )?;
            Ok(())
        }

        pub fn insert_many_userdata(&mut self, count: u64, username: &str, age: u64) -> Result<()> {
            let tx = self.conn.transaction()?;
            for _ in 0..count {
                tx.execute(
                    r#"INSERT INTO userdata (username, age) VALUES (?, ?);"#,
                    (username, age),
                )?;
            }
            tx.commit()?;
            Ok(())
        }

        pub fn update_userdata(&self, id: u64, username: &str, age: u64) -> Result<()> {
            self.conn.execute(
                r#"UPDATE userdata
                SET username = ?, age = ?
                WHERE id=?;"#,
                (username, age, id),
            )?;
            Ok(())
        }

        pub fn delete_userdata(&self, id: u64) -> Result<()> {
            self.conn
                .execute(r#"DELETE FROM userdata WHERE id=?;"#, (id,))?;
            Ok(())
        }

        pub fn get_all_userdata(&self, limit: u64, offset: u64) -> Result<Vec<Userdata>> {
            let mut stmt = self
                .conn
                .prepare("SELECT id, username, age FROM userdata limit ? offset ?")?;
            let person_iter = stmt.query_map([limit, offset], |row| {
                Ok(Userdata {
                    id: row.get(0)?,
                    username: row.get(1)?,
                    age: row.get(2)?,
                })
            })?;

            let mut result = Vec::new();
            for person in person_iter {
                result.push(person?);
            }

            Ok(result)
        }

        pub fn get_count(&self) -> Result<u64> {
            let mut stmt = self.conn.prepare("SELECT COUNT(*) FROM userdata;")?;
            let rows = stmt.query([])?.and_then(|row| {
                let count: u64 = row.get(0)?;
                anyhow::Ok(count)
            });

            for row in rows {
                return Ok(row?);
            }
            Ok(0)
        }
    }
}

use fltk::{
    app::{channel, App},
    dialog::{alert_default, input_default},
};

#[derive(Clone, Debug, Default)]
pub struct Userdata {
    pub id: u64,
    pub username: String,
    pub age: u64,
}

mod ui {

    use super::Userdata;
    use fltk::app::Sender;
    // use fltk::prelude::WidgetExt;

    fl2rust_macro::include_ui!("ui/main.fl");

    #[derive(Clone)]
    pub enum Message {
        Insert,
        QueryAll,
        SelectUser,
        UpdateUser,
        DeleteUser,
        SetRows,
        Before,
        Next,
        Refresh,
        InsertMany,
        SetPage
    }

    trait SenderForAppUi {
        fn bind<W>(&self, widget: &mut W, message: Message)
        where
            W: WidgetExt + Sized;
    }

    impl SenderForAppUi for Sender<Message> {
        fn bind<W>(&self, widget: &mut W, message: Message)
        where
            W: WidgetExt + Sized,
        {
            widget.emit(self.clone(), message);
        }
    }

    macro_rules! emit {
        ($sender:expr, {$($widget:expr => $message:expr),+}) => {
            $(
                let sender = $sender.clone();
                $widget.set_callback(move |_| sender.send($message));
            )+
        };
    }

    impl UserInterface {
        pub fn emit(&mut self, sender: Sender<Message>) {
            emit!(sender, {
                self.btn_insert_new => Message::Insert,
                self.btn_insert_to_select => Message::UpdateUser,
                self.btn_delete_select => Message::DeleteUser,
                self.btn_refresh =>  Message::Refresh,
                self.btn_set_rows => Message::SetRows,
                self.btn_go_before => Message::Before,
                self.btn_go_next =>  Message::Next,
                self.btn_many => Message::InsertMany,
                self.sql_browser => Message::SelectUser
            });
        }

        pub fn get_edit_userdata(&self) -> Userdata {
            Userdata {
                id: self.input_id.value().parse::<u64>().unwrap_or(0),
                username: self.input_username.value(), 
                age: self.input_age.value().parse::<u64>().unwrap_or(0),
            }
        }

        pub fn set_edit_userdata(&mut self, userdata: &Userdata) {
            self.input_username.set_value(&userdata.username);
            self.input_age.set_value(userdata.age.to_string().as_str());
            self.input_id.set_value(userdata.id.to_string().as_str());
        }

        fn sql_browser_prefare(&mut self) {
            self.sql_browser.clear();
            self.sql_browser.set_text_size(16);
            let widths = &[50, 100, 50];
            self.sql_browser.set_column_widths(widths);
            self.sql_browser.set_column_char('\t');
            self.sql_browser.add("ID\tUSERNAME\tAGE");
        }

        fn sql_browser_add_data(&mut self, userdata: &Userdata) {
            self.sql_browser.add_with_data(
                &format!("{}\t{}\t{}", userdata.id, userdata.username, userdata.age),
                userdata.clone(),
            );
        }

        pub fn load_query_data(&mut self, userdata: &[Userdata]) {
            self.sql_browser_prefare();
            for user in userdata {
                self.sql_browser_add_data(&user);
            }
        }

        pub fn get_select_userdata(&self) -> Option<Userdata> {
            let index = self.sql_browser.selected_items();
            if index.len() > 0 {
                let data: Option<Userdata> = unsafe { self.sql_browser.data(index[0]) };
                return data;
            }
            None
        }

        pub fn set_page(&mut self, page: u64) {
            self.op_page.set_value(page.to_string().as_str());
        }
    }
}

use anyhow::Result;
use store::Database;
use ui::{Message, UserInterface};

fn manage_error_in_alert<T>(result: Result<T>) {
    if let Err(error) = result {
        alert_default(error.to_string().as_str())
    }
}

fn main() {
    let app = App::default();
    let (s, r) = channel::<Message>();
    let mut app_ui = UserInterface::make_window();
    let mut database = Database::create_connection().unwrap();
    app_ui.emit(s.clone());
    s.send(Message::QueryAll);

    let mut limit = 10;
    let mut page = 0;

    while app.wait() {
        if let Some(message) = r.recv() {
            match message {
                Message::Insert => {
                    let userdata = app_ui.get_edit_userdata();
                    manage_error_in_alert(
                        database.insert_userdata(&userdata.username, userdata.age),
                    );
                    s.send(Message::QueryAll)
                }
                Message::QueryAll => match database.get_all_userdata(limit, page * limit) {
                    Ok(users) => {
                        app_ui.load_query_data(&users);
                        app_ui.set_page(page as u64);
                    }
                    Err(error) => alert_default(error.to_string().as_str()),
                },
                Message::SelectUser => {
                    if let Some(userdata) = app_ui.get_select_userdata() {
                        app_ui.set_edit_userdata(&userdata)
                    }
                }
                Message::UpdateUser => {
                    if let Some(s_user) = app_ui.get_select_userdata() {
                        let j = app_ui.get_edit_userdata();

                        database
                            .update_userdata(s_user.id, &j.username, j.age)
                            .unwrap();
                        s.send(Message::QueryAll)
                    }
                }
                Message::DeleteUser => {
                    if let Some(s_user) = app_ui.get_select_userdata() {
                        database.delete_userdata(s_user.id).unwrap();
                        s.send(Message::QueryAll);
                    }
                }
                Message::SetRows => {
                    if let Some(rows) =
                        input_default("Set display rows:", limit.to_string().as_str())
                    {
                        if let Ok(rows) = rows.parse::<u64>() {
                            limit = rows
                        }
                    }
                    page = 0;
                    s.send(Message::QueryAll)
                }

                Message::Before => {
                    if page > 0 {
                        page = page - 1;
                        s.send(Message::QueryAll)
                    }
                }

                Message::Next => {
                    let count = database.get_count().unwrap();
                    if (page + 1) * limit < count {
                        page = page + 1;
                        s.send(Message::QueryAll)
                    }
                }

                Message::Refresh => {
                    page = 0;
                    s.send(Message::QueryAll);
                }

                Message::InsertMany => {
                    if let Some(count) = input_default("Insert count:", "1") {
                        if let Ok(count) = count.parse::<u64>() {
                            if count > 10000 {
                                alert_default("Count is over the limit 10000");
                            } else {
                                let userdata = app_ui.get_edit_userdata();
                                let _ = database.insert_many_userdata(
                                    count,
                                    &userdata.username,
                                    userdata.age,
                                );
                            }
                        }
                    }
                }

                Message::SetPage => {

                }
            }
        }
    }
}

# data file for the Fltk User Interface Designer (fluid)
version 1.0400
header_name {.h}
code_name {.cxx}
class UserInterface {open
} {
  Function {make_window()} {open
  } {
    Fl_Window {} {
      label {Sqlite 3 Sample} open
      xywh {364 207 786 409} type Double visible
    } {
      Fl_Input input_username {
        label {Username: }
        xywh {90 52 160 27}
      }
      Fl_Input input_age {
        label {Age: }
        xywh {90 88 160 27} type Float
      }
      Fl_Input input_id {
        label {ID:}
        xywh {90 18 160 27} deactivate
      }
      Fl_Button btn_insert_new {
        label {Insert New}
        xywh {25 129 100 31}
      }
      Fl_Button btn_many {
        label {Insert Many}
        comment BtnInsertMany
        xywh {25 169 100 31}
      }
      Fl_Button btn_insert_to_select {
        label {Update to select}
        xywh {135 130 115 30}
      }
      Fl_Button btn_delete_select {
        label {Delect select}
        xywh {135 170 115 30}
      }
      Fl_Button btn_set_rows {
        label {Set rows}
        xywh {392 18 100 30}
      }
      Fl_Button btn_refresh {
        label Refresh
        xywh {277 18 100 30}
      }
      Fl_Button btn_go_before {
        label Before
        xywh {280 305 60 30}
      }
      Fl_Button btn_go_next {
        label Next
        xywh {350 305 55 30}
      }
      Fl_Output op_page {
        label {Page: }
        xywh {670 307 50 28}
      }
      Fl_Browser sql_browser {selected
        xywh {277 63 445 225} type Multi
      }
    }
  }
}

[dependencies]
anyhow = "1.0.75"
fl2rust-macro = "0.5.17"
fltk = { version = "1.4.19", features = ["fltk-bundled"] }
rusqlite = { version = "0.30.0", features = ["bundled"] }

最后修改：2024 年 03 月 02 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

海绵宝宝
热评：“但是我只禁欲了 2 天”
海绵宝宝
are you sick? long time no see ...
海绵宝宝
有关ssh的一切 https://github.com/imk...
海绵宝宝
网站设计太糟糕了，正文页面太窄，显示不全，对safari很不友好
海绵宝宝
这段话主要介绍了睡眠与时间管理学的内容以及作者对文章的前言和写...

基于 FLTK 制作用户管理程序

小学生菲利克斯 • 2024 年 01 月 08 日

<p>本示例展示了基于 FLTK 和 SQLITE 制作用户管理程序。代码比较长，但是不难看懂。</p><p>main.rs</p><pre><code class="lang-rust">mod store {
    use super::Userdata;
    use anyhow::Result;
    use rusqlite::Connection;

pub struct Database {
        conn: Connection,
    }

impl Database {
        pub fn create_connection() -&gt; Result&lt;Self&gt; {
            let conn = Connection::open(&quot;:memory:&quot;)?;

conn.execute(
                r#&quot;CREATE TABLE IF NOT EXISTS userdata (
                id INTEGER PRIMARY KEY,
                username TEXT NOT NULL,
                age INTEGER NOT NULL
            );&quot;#,
                (),
            )?;

Ok(Self { conn })
        }

pub fn insert_userdata(&amp;self, username: &amp;str, age: u64) -&gt; Result&lt;()&gt; {
            self.conn.execute(
                r#&quot;INSERT INTO userdata (username, age) VALUES (?, ?);&quot;#,
                (username, age),
            )?;
            Ok(())
        }

pub fn insert_many_userdata(&amp;mut self, count: u64, username: &amp;str, age: u64) -&gt; Result&lt;()&gt; {
            let tx = self.conn.transaction()?;
            for _ in 0..count {
                tx.execute(
                    r#&quot;INSERT INTO userdata (username, age) VALUES (?, ?);&quot;#,
                    (username, age),
                )?;
            }
            tx.commit()?;
            Ok(())
        }

pub fn update_userdata(&amp;self, id: u64, username: &amp;str, age: u64) -&gt; Result&lt;()&gt; {
            self.conn.execute(
                r#&quot;UPDATE userdata
                SET username = ?, age = ?
                WHERE id=?;&quot;#,
                (username, age, id),
            )?;
            Ok(())
        }

pub fn delete_userdata(&amp;self, id: u64) -&gt; Result&lt;()&gt; {
            self.conn
                .execute(r#&quot;DELETE FROM userdata WHERE id=?;&quot;#, (id,))?;
            Ok(())
        }

pub fn get_all_userdata(&amp;self, limit: u64, offset: u64) -&gt; Result&lt;Vec&lt;Userdata&gt;&gt; {
            let mut stmt = self
                .conn
                .prepare(&quot;SELECT id, username, age FROM userdata limit ? offset ?&quot;)?;
            let person_iter = stmt.query_map([limit, offset], |row| {
                Ok(Userdata {
                    id: row.get(0)?,
                    username: row.get(1)?,
                    age: row.get(2)?,
                })
            })?;

let mut result = Vec::new();
            for person in person_iter {
                result.push(person?);
            }

Ok(result)
        }

pub fn get_count(&amp;self) -&gt; Result&lt;u64&gt; {
            let mut stmt = self.conn.prepare(&quot;SELECT COUNT(*) FROM userdata;&quot;)?;
            let rows = stmt.query([])?.and_then(|row| {
                let count: u64 = row.get(0)?;
                anyhow::Ok(count)
            });

for row in rows {
                return Ok(row?);
            }
            Ok(0)
        }
    }
}

use fltk::{
    app::{channel, App},
    dialog::{alert_default, input_default},
};

#[derive(Clone, Debug, Default)]
pub struct Userdata {
    pub id: u64,
    pub username: String,
    pub age: u64,
}

mod ui {

use super::Userdata;
    use fltk::app::Sender;
    // use fltk::prelude::WidgetExt;

fl2rust_macro::include_ui!(&quot;ui/main.fl&quot;);

#[derive(Clone)]
    pub enum Message {
        Insert,
        QueryAll,
        SelectUser,
        UpdateUser,
        DeleteUser,
        SetRows,
        Before,
        Next,
        Refresh,
        InsertMany,
        SetPage
    }

trait SenderForAppUi {
        fn bind&lt;W&gt;(&amp;self, widget: &amp;mut W, message: Message)
        where
            W: WidgetExt + Sized;
    }

impl SenderForAppUi for Sender&lt;Message&gt; {
        fn bind&lt;W&gt;(&amp;self, widget: &amp;mut W, message: Message)
        where
            W: WidgetExt + Sized,
        {
            widget.emit(self.clone(), message);
        }
    }

macro_rules! emit {
        ($sender:expr, {$($widget:expr =&gt; $message:expr),+}) =&gt; {
            $(
                let sender = $sender.clone();
                $widget.set_callback(move |_| sender.send($message));
            )+
        };
    }

impl UserInterface {
        pub fn emit(&amp;mut self, sender: Sender&lt;Message&gt;) {
            emit!(sender, {
                self.btn_insert_new =&gt; Message::Insert,
                self.btn_insert_to_select =&gt; Message::UpdateUser,
                self.btn_delete_select =&gt; Message::DeleteUser,
                self.btn_refresh =&gt;  Message::Refresh,
                self.btn_set_rows =&gt; Message::SetRows,
                self.btn_go_before =&gt; Message::Before,
                self.btn_go_next =&gt;  Message::Next,
                self.btn_many =&gt; Message::InsertMany,
                self.sql_browser =&gt; Message::SelectUser
            });
        }

pub fn get_edit_userdata(&amp;self) -&gt; Userdata {
            Userdata {
                id: self.input_id.value().parse::&lt;u64&gt;().unwrap_or(0),
                username: self.input_username.value(), 
                age: self.input_age.value().parse::&lt;u64&gt;().unwrap_or(0),
            }
        }

pub fn set_edit_userdata(&amp;mut self, userdata: &amp;Userdata) {
            self.input_username.set_value(&amp;userdata.username);
            self.input_age.set_value(userdata.age.to_string().as_str());
            self.input_id.set_value(userdata.id.to_string().as_str());
        }

fn sql_browser_prefare(&amp;mut self) {
            self.sql_browser.clear();
            self.sql_browser.set_text_size(16);
            let widths = &amp;[50, 100, 50];
            self.sql_browser.set_column_widths(widths);
            self.sql_browser.set_column_char(&#039;\t&#039;);
            self.sql_browser.add(&quot;ID\tUSERNAME\tAGE&quot;);
        }

fn sql_browser_add_data(&amp;mut self, userdata: &amp;Userdata) {
            self.sql_browser.add_with_data(
                &amp;format!(&quot;{}\t{}\t{}&quot;, userdata.id, userdata.username, userdata.age),
                userdata.clone(),
            );
        }

pub fn load_query_data(&amp;mut self, userdata: &amp;[Userdata]) {
            self.sql_browser_prefare();
            for user in userdata {
                self.sql_browser_add_data(&amp;user);
            }
        }

pub fn get_select_userdata(&amp;self) -&gt; Option&lt;Userdata&gt; {
            let index = self.sql_browser.selected_items();
            if index.len() &gt; 0 {
                let data: Option&lt;Userdata&gt; = unsafe { self.sql_browser.data(index[0]) };
                return data;
            }
            None
        }

pub fn set_page(&amp;mut self, page: u64) {
            self.op_page.set_value(page.to_string().as_str());
        }
    }
}

use anyhow::Result;
use store::Database;
use ui::{Message, UserInterface};

fn manage_error_in_alert&lt;T&gt;(result: Result&lt;T&gt;) {
    if let Err(error) = result {
        alert_default(error.to_string().as_str())
    }
}

fn main() {
    let app = App::default();
    let (s, r) = channel::&lt;Message&gt;();
    let mut app_ui = UserInterface::make_window();
    let mut database = Database::create_connection().unwrap();
    app_ui.emit(s.clone());
    s.send(Message::QueryAll);

let mut limit = 10;
    let mut page = 0;

while app.wait() {
        if let Some(message) = r.recv() {
            match message {
                Message::Insert =&gt; {
                    let userdata = app_ui.get_edit_userdata();
                    manage_error_in_alert(
                        database.insert_userdata(&amp;userdata.username, userdata.age),
                    );
                    s.send(Message::QueryAll)
                }
                Message::QueryAll =&gt; match database.get_all_userdata(limit, page * limit) {
                    Ok(users) =&gt; {
                        app_ui.load_query_data(&amp;users);
                        app_ui.set_page(page as u64);
                    }
                    Err(error) =&gt; alert_default(error.to_string().as_str()),
                },
                Message::SelectUser =&gt; {
                    if let Some(userdata) = app_ui.get_select_userdata() {
                        app_ui.set_edit_userdata(&amp;userdata)
                    }
                }
                Message::UpdateUser =&gt; {
                    if let Some(s_user) = app_ui.get_select_userdata() {
                        let j = app_ui.get_edit_userdata();

database
                            .update_userdata(s_user.id, &amp;j.username, j.age)
                            .unwrap();
                        s.send(Message::QueryAll)
                    }
                }
                Message::DeleteUser =&gt; {
                    if let Some(s_user) = app_ui.get_select_userdata() {
                        database.delete_userdata(s_user.id).unwrap();
                        s.send(Message::QueryAll);
                    }
                }
                Message::SetRows =&gt; {
                    if let Some(rows) =
                        input_default(&quot;Set display rows:&quot;, limit.to_string().as_str())
                    {
                        if let Ok(rows) = rows.parse::&lt;u64&gt;() {
                            limit = rows
                        }
                    }
                    page = 0;
                    s.send(Message::QueryAll)
                }

Message::Before =&gt; {
                    if page &gt; 0 {
                        page = page - 1;
                        s.send(Message::QueryAll)
                    }
                }

Message::Next =&gt; {
                    let count = database.get_count().unwrap();
                    if (page + 1) * limit &lt; count {
                        page = page + 1;
                        s.send(Message::QueryAll)
                    }
                }

Message::Refresh =&gt; {
                    page = 0;
                    s.send(Message::QueryAll);
                }

Message::InsertMany =&gt; {
                    if let Some(count) = input_default(&quot;Insert count:&quot;, &quot;1&quot;) {
                        if let Ok(count) = count.parse::&lt;u64&gt;() {
                            if count &gt; 10000 {
                                alert_default(&quot;Count is over the limit 10000&quot;);
                            } else {
                                let userdata = app_ui.get_edit_userdata();
                                let _ = database.insert_many_userdata(
                                    count,
                                    &amp;userdata.username,
                                    userdata.age,
                                );
                            }
                        }
                    }
                }

Message::SetPage =&gt; {

}
            }
        }
    }
}
</code></pre><pre><code># data file for the Fltk User Interface Designer (fluid)
version 1.0400
header_name {.h}
code_name {.cxx}
class UserInterface {open
} {
  Function {make_window()} {open
  } {
    Fl_Window {} {
      label {Sqlite 3 Sample} open
      xywh {364 207 786 409} type Double visible
    } {
      Fl_Input input_username {
        label {Username: }
        xywh {90 52 160 27}
      }
      Fl_Input input_age {
        label {Age: }
        xywh {90 88 160 27} type Float
      }
      Fl_Input input_id {
        label {ID:}
        xywh {90 18 160 27} deactivate
      }
      Fl_Button btn_insert_new {
        label {Insert New}
        xywh {25 129 100 31}
      }
      Fl_Button btn_many {
        label {Insert Many}
        comment BtnInsertMany
        xywh {25 169 100 31}
      }
      Fl_Button btn_insert_to_select {
        label {Update to select}
        xywh {135 130 115 30}
      }
      Fl_Button btn_delete_select {
        label {Delect select}
        xywh {135 170 115 30}
      }
      Fl_Button btn_set_rows {
        label {Set rows}
        xywh {392 18 100 30}
      }
      Fl_Button btn_refresh {
        label Refresh
        xywh {277 18 100 30}
      }
      Fl_Button btn_go_before {
        label Before
        xywh {280 305 60 30}
      }
      Fl_Button btn_go_next {
        label Next
        xywh {350 305 55 30}
      }
      Fl_Output op_page {
        label {Page: }
        xywh {670 307 50 28}
      }
      Fl_Browser sql_browser {selected
        xywh {277 63 445 225} type Multi
      }
    }
  }
}</code></pre><pre><code class="lang-toml">[dependencies]
anyhow = &quot;1.0.75&quot;
fl2rust-macro = &quot;0.5.17&quot;
fltk = { version = &quot;1.4.19&quot;, features = [&quot;fltk-bundled&quot;] }
rusqlite = { version = &quot;0.30.0&quot;, features = [&quot;bundled&quot;] }</code></pre>

基于 FLTK 制作用户管理程序

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

随笔：一次与性有关的奇妙经历

随笔：写给曾经暗恋过的你

使用 pyautogui 自动刷屏

编译能在 Windows XP 上运行的 Rust 程序

修改任务栏上的文件资源管理器的打开位置

使用 Win_ISO_Patching_Scripts 更新系统镜像

使用 FFmpeg 提取字幕文件

实现遗传算法

随笔：下载器项目的再思考

使用 GNU 工具链编译 rust-analyzer

基于 FLTK 制作用户管理程序

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

基于 FLTK 制作用户管理程序

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款