275 lines
12 KiB
C++
275 lines
12 KiB
C++
#include "data_models.h"
|
|
#include <print>
|
|
|
|
// Global data instances
|
|
SettingsData g_settings;
|
|
PhoneData g_phone;
|
|
BrowserData g_browser;
|
|
std::vector<Conversation> g_conversations;
|
|
std::vector<Contact> g_contacts;
|
|
int g_selected_conversation = -1;
|
|
int g_selected_contact = -1;
|
|
|
|
// Data model handles
|
|
Rml::DataModelHandle g_settings_model;
|
|
Rml::DataModelHandle g_phone_model;
|
|
Rml::DataModelHandle g_messages_model;
|
|
Rml::DataModelHandle g_contacts_model;
|
|
Rml::DataModelHandle g_browser_model;
|
|
|
|
void initializeSampleData()
|
|
{
|
|
// Initialize contacts
|
|
g_contacts = {
|
|
{1, "Alice Johnson", "+1 (555) 123-4567", "alice@example.com", "#E91E63", "A"},
|
|
{2, "Andrew Smith", "+1 (555) 234-5678", "andrew@example.com", "#9C27B0", "A"},
|
|
{3, "Bob Williams", "+1 (555) 345-6789", "bob@example.com", "#2196F3", "B"},
|
|
{4, "Brian Davis", "+1 (555) 456-7890", "brian@example.com", "#00BCD4", "B"},
|
|
{5, "Carol Martinez", "+1 (555) 567-8901", "carol@example.com", "#4CAF50", "C"},
|
|
{6, "David Lee", "+1 (555) 678-9012", "david@example.com", "#FF9800", "D"},
|
|
{7, "John Wilson", "+1 (555) 789-0123", "john@example.com", "#F44336", "J"},
|
|
{8, "Mom", "+1 (555) 890-1234", "mom@example.com", "#673AB7", "M"},
|
|
{9, "Mike Brown", "+1 (555) 901-2345", "mike@example.com", "#3F51B5", "M"},
|
|
{10, "Sarah Taylor", "+1 (555) 012-3456", "sarah@example.com", "#009688", "S"}
|
|
};
|
|
|
|
// Initialize conversations
|
|
g_conversations = {
|
|
{1, "John Wilson", "#4CAF50", "Hey, are you coming to the party tonight?", "2:30 PM", 2, {
|
|
{"them", "Hey!", "2:25 PM"},
|
|
{"them", "What are you up to?", "2:26 PM"},
|
|
{"me", "Not much, just working", "2:27 PM"},
|
|
{"them", "Cool! There's a party at Mike's tonight", "2:28 PM"},
|
|
{"them", "Hey, are you coming to the party tonight?", "2:30 PM"}
|
|
}},
|
|
{2, "Mom", "#673AB7", "Don't forget to call your grandmother!", "1:15 PM", 0, {
|
|
{"them", "Hi sweetie!", "1:00 PM"},
|
|
{"me", "Hi Mom!", "1:05 PM"},
|
|
{"them", "How are you doing?", "1:10 PM"},
|
|
{"me", "I'm good, how are you?", "1:12 PM"},
|
|
{"them", "Don't forget to call your grandmother!", "1:15 PM"}
|
|
}},
|
|
{3, "Alice Johnson", "#E91E63", "Thanks for the help with the project!", "Yesterday", 0, {
|
|
{"me", "Here's the file you needed", "Yesterday"},
|
|
{"them", "Thanks for the help with the project!", "Yesterday"}
|
|
}},
|
|
{4, "Bob Williams", "#2196F3", "Did you see the game last night?", "Yesterday", 0, {
|
|
{"them", "Did you see the game last night?", "Yesterday"}
|
|
}},
|
|
{5, "Work Group", "#FF9800", "Sarah: Meeting moved to 3pm", "Mon", 0, {
|
|
{"Sarah", "Meeting moved to 3pm", "Mon"}
|
|
}},
|
|
{6, "Sarah Taylor", "#009688", "See you at the coffee shop!", "Sun", 0, {
|
|
{"them", "See you at the coffee shop!", "Sun"}
|
|
}},
|
|
{7, "David Lee", "#F44336", "Great talking to you!", "Sat", 0, {
|
|
{"them", "Great talking to you!", "Sat"}
|
|
}}
|
|
};
|
|
|
|
// Initialize browser tabs
|
|
g_browser.tabs = {
|
|
{"example.com", "Example Domain", false},
|
|
{"rmlui.github.io", "RmlUi Documentation", false},
|
|
{"github.com", "GitHub", false}
|
|
};
|
|
|
|
std::println("Sample data initialized: {} contacts, {} conversations, {} browser tabs",
|
|
g_contacts.size(), g_conversations.size(), g_browser.tabs.size());
|
|
}
|
|
|
|
void setupDataModels(Rml::Context* context)
|
|
{
|
|
// Messages data model
|
|
if (auto constructor = context->CreateDataModel("messages"))
|
|
{
|
|
if (auto msg_handle = constructor.RegisterStruct<Message>())
|
|
{
|
|
msg_handle.RegisterMember("from", &Message::from);
|
|
msg_handle.RegisterMember("text", &Message::text);
|
|
msg_handle.RegisterMember("time", &Message::time);
|
|
}
|
|
|
|
if (auto conv_handle = constructor.RegisterStruct<Conversation>())
|
|
{
|
|
conv_handle.RegisterMember("id", &Conversation::id);
|
|
conv_handle.RegisterMember("name", &Conversation::name);
|
|
conv_handle.RegisterMember("color", &Conversation::color);
|
|
conv_handle.RegisterMember("last_message", &Conversation::last_message);
|
|
conv_handle.RegisterMember("time", &Conversation::time);
|
|
conv_handle.RegisterMember("unread", &Conversation::unread);
|
|
conv_handle.RegisterMember("messages", &Conversation::messages);
|
|
}
|
|
|
|
constructor.RegisterArray<std::vector<Message>>();
|
|
constructor.RegisterArray<std::vector<Conversation>>();
|
|
|
|
constructor.Bind("conversations", &g_conversations);
|
|
constructor.Bind("selected_conversation", &g_selected_conversation);
|
|
|
|
constructor.BindEventCallback("select_conversation",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
if (!args.empty()) {
|
|
g_selected_conversation = args[0].Get<int>();
|
|
std::println("Selected conversation: {}", g_selected_conversation);
|
|
handle.DirtyVariable("selected_conversation");
|
|
}
|
|
});
|
|
|
|
g_messages_model = constructor.GetModelHandle();
|
|
std::println("Messages data model created");
|
|
}
|
|
|
|
// Contacts data model
|
|
if (auto constructor = context->CreateDataModel("contacts"))
|
|
{
|
|
if (auto contact_handle = constructor.RegisterStruct<Contact>())
|
|
{
|
|
contact_handle.RegisterMember("id", &Contact::id);
|
|
contact_handle.RegisterMember("name", &Contact::name);
|
|
contact_handle.RegisterMember("phone", &Contact::phone);
|
|
contact_handle.RegisterMember("email", &Contact::email);
|
|
contact_handle.RegisterMember("color", &Contact::color);
|
|
contact_handle.RegisterMember("initial", &Contact::initial);
|
|
}
|
|
|
|
constructor.RegisterArray<std::vector<Contact>>();
|
|
|
|
constructor.Bind("contacts", &g_contacts);
|
|
constructor.Bind("selected_contact", &g_selected_contact);
|
|
|
|
constructor.BindEventCallback("select_contact",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
if (!args.empty()) {
|
|
g_selected_contact = args[0].Get<int>();
|
|
std::println("Selected contact: {}", g_selected_contact);
|
|
handle.DirtyVariable("selected_contact");
|
|
}
|
|
});
|
|
|
|
g_contacts_model = constructor.GetModelHandle();
|
|
std::println("Contacts data model created");
|
|
}
|
|
|
|
// Settings data model
|
|
if (auto constructor = context->CreateDataModel("settings"))
|
|
{
|
|
constructor.Bind("wifi", &g_settings.wifi);
|
|
constructor.Bind("bluetooth", &g_settings.bluetooth);
|
|
constructor.Bind("airplane_mode", &g_settings.airplane_mode);
|
|
constructor.Bind("location", &g_settings.location);
|
|
constructor.Bind("dark_mode", &g_settings.dark_mode);
|
|
constructor.Bind("notifications", &g_settings.notifications);
|
|
constructor.Bind("do_not_disturb", &g_settings.do_not_disturb);
|
|
constructor.Bind("user_name", &g_settings.user_name);
|
|
constructor.Bind("user_email", &g_settings.user_email);
|
|
constructor.Bind("wifi_network", &g_settings.wifi_network);
|
|
constructor.Bind("battery_percent", &g_settings.battery_percent);
|
|
constructor.Bind("battery_remaining", &g_settings.battery_remaining);
|
|
constructor.Bind("storage_used", &g_settings.storage_used);
|
|
|
|
g_settings_model = constructor.GetModelHandle();
|
|
std::println("Settings data model created");
|
|
}
|
|
|
|
// Phone data model
|
|
if (auto constructor = context->CreateDataModel("phone"))
|
|
{
|
|
constructor.Bind("dial_number", &g_phone.dial_number);
|
|
constructor.Bind("is_calling", &g_phone.is_calling);
|
|
constructor.Bind("call_contact", &g_phone.call_contact);
|
|
constructor.Bind("call_duration", &g_phone.call_duration);
|
|
|
|
constructor.BindEventCallback("dial_press",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
if (!args.empty()) {
|
|
g_phone.dial_number += args[0].Get<Rml::String>();
|
|
std::println("Dial: {}", g_phone.dial_number);
|
|
handle.DirtyVariable("dial_number");
|
|
}
|
|
});
|
|
|
|
constructor.BindEventCallback("dial_backspace",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
if (!g_phone.dial_number.empty()) {
|
|
g_phone.dial_number.pop_back();
|
|
handle.DirtyVariable("dial_number");
|
|
}
|
|
});
|
|
|
|
constructor.BindEventCallback("dial_clear",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
g_phone.dial_number.clear();
|
|
handle.DirtyVariable("dial_number");
|
|
});
|
|
|
|
constructor.BindEventCallback("make_call",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
if (!g_phone.dial_number.empty()) {
|
|
g_phone.is_calling = true;
|
|
g_phone.call_contact = g_phone.dial_number;
|
|
std::println("Calling: {}", g_phone.call_contact);
|
|
handle.DirtyVariable("is_calling");
|
|
handle.DirtyVariable("call_contact");
|
|
}
|
|
});
|
|
|
|
constructor.BindEventCallback("end_call",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
g_phone.is_calling = false;
|
|
g_phone.call_contact = "";
|
|
g_phone.call_duration = "00:00";
|
|
handle.DirtyVariable("is_calling");
|
|
handle.DirtyVariable("call_contact");
|
|
handle.DirtyVariable("call_duration");
|
|
});
|
|
|
|
g_phone_model = constructor.GetModelHandle();
|
|
std::println("Phone data model created");
|
|
}
|
|
|
|
// Browser data model
|
|
if (auto constructor = context->CreateDataModel("browser"))
|
|
{
|
|
if (auto tab_handle = constructor.RegisterStruct<BrowserTab>())
|
|
{
|
|
tab_handle.RegisterMember("url", &BrowserTab::url);
|
|
tab_handle.RegisterMember("title", &BrowserTab::title);
|
|
tab_handle.RegisterMember("is_loading", &BrowserTab::is_loading);
|
|
}
|
|
|
|
constructor.RegisterArray<std::vector<BrowserTab>>();
|
|
|
|
constructor.Bind("current_url", &g_browser.current_url);
|
|
constructor.Bind("page_title", &g_browser.page_title);
|
|
constructor.Bind("page_content", &g_browser.page_content);
|
|
constructor.Bind("tabs", &g_browser.tabs);
|
|
constructor.Bind("current_tab", &g_browser.current_tab);
|
|
constructor.Bind("can_go_back", &g_browser.can_go_back);
|
|
constructor.Bind("can_go_forward", &g_browser.can_go_forward);
|
|
|
|
constructor.BindEventCallback("navigate",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
if (!args.empty()) {
|
|
g_browser.current_url = args[0].Get<Rml::String>();
|
|
g_browser.page_title = "Loading...";
|
|
g_browser.can_go_back = true;
|
|
std::println("Navigating to: {}", g_browser.current_url);
|
|
handle.DirtyVariable("current_url");
|
|
handle.DirtyVariable("page_title");
|
|
handle.DirtyVariable("can_go_back");
|
|
}
|
|
});
|
|
|
|
constructor.BindEventCallback("refresh",
|
|
[](Rml::DataModelHandle handle, Rml::Event& event, const Rml::VariantList& args) {
|
|
std::println("Refreshing page");
|
|
});
|
|
|
|
g_browser_model = constructor.GetModelHandle();
|
|
std::println("Browser data model created");
|
|
}
|
|
|
|
std::println("All data models initialized");
|
|
}
|