I'll create a comprehensive AI-powered office suite called "Quarix" with all
the features you requested. This will be a substantial application with
multiple modules.
# main.py
import customtkinter as ctk
from tkinter import messagebox, filedialog
import threading
import time
import json
import os
from PIL import Image, ImageTk, ImageDraw, ImageFont
import google.generativeai as genai
from datetime import datetime
import sqlite3
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import numpy as np
from docx import Document
from pptx import Presentation
from pptx.util import Inches
import openpyxl
from openpyxl.chart import BarChart, Reference
import requests
import webbrowser
# Configure appearance
ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")
class QuarixApp:
def __init__(self):
self.root = ctk.CTk()
self.root.title("Quarix AI Office Suite")
self.root.geometry("1400x900")
self.root.configure(fg_color="#0a0a0a")
# Initialize Gemini AI
self.setup_gemini()
# Initialize database
self.init_database()
# Start with splash screen
self.show_splash_screen()
def setup_gemini(self):
"""Setup Gemini AI API"""
try:
# You need to set your API key here
genai.configure(api_key="YOUR_GEMINI_API_KEY")
self.model = genai.GenerativeModel('gemini-pro')
self.ai_enabled = True
except Exception as e:
print(f"AI initialization failed: {e}")
self.ai_enabled = False
def init_database(self):
"""Initialize SQLite database for app data"""
self.conn = sqlite3.connect('quarix_data.db')
cursor = self.conn.cursor()
# Create tables for different modules
cursor.execute('''
CREATE TABLE IF NOT EXISTS documents (
id INTEGER PRIMARY KEY,
title TEXT,
content TEXT,
created_date TEXT,
modified_date TEXT
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS presentations (
id INTEGER PRIMARY KEY,
title TEXT,
slides_data TEXT,
created_date TEXT,
modified_date TEXT
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS spreadsheets (
id INTEGER PRIMARY KEY,
title TEXT,
data TEXT,
created_date TEXT,
modified_date TEXT
)
''')
self.conn.commit()
def show_splash_screen(self):
"""Show animated splash screen"""
self.splash_frame = ctk.CTkFrame(self.root,
fg_color="#000000")
self.splash_frame.pack(fill="both", expand=True)
# Create canvas for animation
self.canvas = ctk.CTkCanvas(
self.splash_frame,
width=1400,
height=900,
bg="#000000",
highlightthickness=0
)
self.canvas.pack(fill="both", expand=True)
# Start writing animation
self.animate_quarix_writing()
def animate_quarix_writing(self):
"""Animate invisible pen writing Quarix"""
text = "Quarix"
x_start = 600
y_pos = 400
# Clear canvas
self.canvas.delete("all")
# Animate each letter appearing
for i in range(len(text) + 1):
self.root.after(i * 300, lambda i=i:
self.draw_text_portion(text[:i], x_start, y_pos))
# After writing, show icon and fade to main screen
self.root.after(len(text) * 300 + 1000,
self.show_icon_and_fade)
def draw_text_portion(self, text, x, y):
"""Draw portion of text with glowing effect"""
self.canvas.delete("text")
# Create glowing effect with multiple text layers
colors = ["#1a1a2e", "#16213e", "#0f3460", "#533483"]
offsets = [3, 2, 1, 0]
for color, offset in zip(colors, offsets):
self.canvas.create_text(
x + offset, y + offset,
text=text,
font=("Arial", 48, "bold"),
fill=color,
tags="text"
)
# Main text
self.canvas.create_text(
x, y,
text=text,
font=("Arial", 48, "bold"),
fill="#00d4ff",
tags="text"
)
def show_icon_and_fade(self):
"""Show icon and fade to main screen"""
# Add icon placeholder (you can replace with your icon)
self.canvas.create_oval(
650, 500, 750, 600,
fill="#00d4ff",
outline="#ffffff",
width=3,
tags="icon"
)
self.canvas.create_text(
700, 550,
text="Q",
font=("Arial", 36, "bold"),
fill="#ffffff",
tags="icon"
)
# Fade to main screen after 2 seconds
self.root.after(2000, self.fade_to_main)
def fade_to_main(self):
"""Fade to main application screen"""
self.splash_frame.destroy()
self.create_main_interface()
def create_main_interface(self):
"""Create the main application interface"""
# Main container
self.main_container = ctk.CTkFrame(self.root,
fg_color="#0a0a0a")
self.main_container.pack(fill="both", expand=True, padx=10,
pady=10)
# Header
self.create_header()
# Navigation sidebar
self.create_sidebar()
# Main content area
self.create_content_area()
# Show home screen by default
self.show_home_screen()
def create_header(self):
"""Create application header"""
header_frame = ctk.CTkFrame(self.main_container, height=80,
fg_color="#1a1a2e")
header_frame.pack(fill="x", padx=5, pady=(0, 10))
header_frame.pack_propagate(False)
# Logo and title
title_frame = ctk.CTkFrame(header_frame,
fg_color="transparent")
title_frame.pack(side="left", padx=20, pady=15)
ctk.CTkLabel(
title_frame,
text="Quarix AI Office Suite",
font=ctk.CTkFont(size=24, weight="bold"),
text_color="#00d4ff"
).pack(side="left")
# AI Status indicator
ai_frame = ctk.CTkFrame(header_frame, fg_color="transparent")
ai_frame.pack(side="right", padx=20, pady=15)
ai_status = "🤖 AI Online" if self.ai_enabled else "🤖 AI
Offline"
ai_color = "#00ff00" if self.ai_enabled else "#ff0000"
ctk.CTkLabel(
ai_frame,
text=ai_status,
font=ctk.CTkFont(size=14),
text_color=ai_color
).pack()
def create_sidebar(self):
"""Create navigation sidebar"""
self.sidebar_frame = ctk.CTkFrame(self.main_container,
width=250, fg_color="#16213e")
self.sidebar_frame.pack(side="left", fill="y", padx=(0, 10))
self.sidebar_frame.pack_propagate(False)
# Navigation buttons
nav_buttons = [
("🏠 Home", self.show_home_screen),
("📄 Documents", self.show_document_module),
("📊 Presentations", self.show_presentation_module),
("📈 Spreadsheets", self.show_spreadsheet_module),
(" Database", self.show_database_module),
("🤖 AI Assistant", self.show_ai_assistant),
("⚙️Settings", self.show_settings)
]
ctk.CTkLabel(
self.sidebar_frame,
text="Navigation",
font=ctk.CTkFont(size=18, weight="bold"),
text_color="#00d4ff"
).pack(pady=20)
for text, command in nav_buttons:
btn = ctk.CTkButton(
self.sidebar_frame,
text=text,
command=command,
width=200,
height=40,
font=ctk.CTkFont(size=14),
fg_color="#0f3460",
hover_color="#533483"
)
btn.pack(pady=5, padx=10)
def create_content_area(self):
"""Create main content area"""
self.content_frame = ctk.CTkFrame(self.main_container,
fg_color="#0f0f23")
self.content_frame.pack(side="right", fill="both",
expand=True)
def clear_content(self):
"""Clear content area"""
for widget in self.content_frame.winfo_children():
widget.destroy()
def show_home_screen(self):
"""Show home screen with feature overview"""
self.clear_content()
# Scrollable frame for home content
scroll_frame = ctk.CTkScrollableFrame(self.content_frame,
fg_color="transparent")
scroll_frame.pack(fill="both", expand=True, padx=20, pady=20)
# Welcome section
welcome_frame = ctk.CTkFrame(scroll_frame, fg_color="#1a1a2e")
welcome_frame.pack(fill="x", pady=(0, 20))
ctk.CTkLabel(
welcome_frame,
text="Welcome to Quarix AI Office Suite",
font=ctk.CTkFont(size=32, weight="bold"),
text_color="#00d4ff"
).pack(pady=20)
ctk.CTkLabel(
welcome_frame,
text="Your AI-powered productivity companion with 30+
intelligent features",
font=ctk.CTkFont(size=16),
text_color="#ffffff"
).pack(pady=(0, 20))
# Quick actions grid
self.create_quick_actions(scroll_frame)
# AI Features showcase
self.create_ai_features_showcase(scroll_frame)
def create_quick_actions(self, parent):
"""Create quick action buttons"""
actions_frame = ctk.CTkFrame(parent, fg_color="#1a1a2e")
actions_frame.pack(fill="x", pady=(0, 20))
ctk.CTkLabel(
actions_frame,
text="Quick Actions",
font=ctk.CTkFont(size=20, weight="bold"),
text_color="#00d4ff"
).pack(pady=(20, 10))
# Grid of action buttons
grid_frame = ctk.CTkFrame(actions_frame,
fg_color="transparent")
grid_frame.pack(pady=(0, 20), padx=20)
actions = [
("📝 New Document", self.new_document),
("📊 New Presentation", self.new_presentation),
("📈 New Spreadsheet", self.new_spreadsheet),
("🤖 AI Chat", self.show_ai_assistant),
("📁 Open File", self.open_file),
("💾 Recent Files", self.show_recent_files)
]
for i, (text, command) in enumerate(actions):
row = i // 3
col = i % 3
btn = ctk.CTkButton(
grid_frame,
text=text,
command=command,
width=200,
height=80,
font=ctk.CTkFont(size=14, weight="bold"),
fg_color="#0f3460",
hover_color="#533483"
)
btn.grid(row=row, column=col, padx=10, pady=10)
def create_ai_features_showcase(self, parent):
"""Create AI features showcase"""
ai_frame = ctk.CTkFrame(parent, fg_color="#1a1a2e")
ai_frame.pack(fill="x", pady=(0, 20))
ctk.CTkLabel(
ai_frame,
text="30 AI-Powered Features",
font=ctk.CTkFont(size=20, weight="bold"),
text_color="#00d4ff"
).pack(pady=(20, 10))
# Features grid
features_grid = ctk.CTkFrame(ai_frame, fg_color="transparent")
features_grid.pack(pady=(0, 20), padx=20)
ai_features = [
"Smart Writing Assistant", "Auto Grammar Check", "Content
Summarization",
"Language Translation", "Voice to Text", "Smart
Formatting",
"Data Analysis", "Chart Generation", "Presentation
Design",
"Email Composer", "Meeting Notes", "Task Automation",
"Code Generation", "Image Analysis", "PDF Processing",
"Spell Check Plus", "Style Suggestions", "Plagiarism
Detection",
"Research Assistant", "Citation Generator", "Template
Suggestions",
"Smart Tables", "Formula Helper", "Data Visualization",
"Slide Layouts", "Color Schemes", "Font Pairing",
"Database Queries", "Report Generation", "Export
Optimization"
]
# Create scrollable text widget for features
features_text = ctk.CTkTextbox(
features_grid,
width=800,
height=200,
font=ctk.CTkFont(size=12)
)
features_text.pack()
# Add features to text widget
for i, feature in enumerate(ai_features, 1):
features_text.insert("end", f"{i:2d}. {feature}\n")
features_text.configure(state="disabled")
class DocumentModule:
"""Document processing module with AI features"""
def __init__(self, parent_app):
self.app = parent_app
self.current_doc = None
self.ai_features = AIFeatures(parent_app)
def create_interface(self, parent):
"""Create document interface"""
# Toolbar
toolbar = ctk.CTkFrame(parent, height=60, fg_color="#1a1a2e")
toolbar.pack(fill="x", padx=5, pady=(0, 10))
toolbar.pack_propagate(False)
# Toolbar buttons
toolbar_buttons = [
("📄 New", self.new_document),
("📁 Open", self.open_document),
("💾 Save", self.save_document),
("🤖 AI Assist", self.show_ai_menu),
("📝 Format", self.show_format_menu),
("🔍 Find", self.find_replace)
]
for text, command in toolbar_buttons:
btn = ctk.CTkButton(
toolbar,
text=text,
command=command,
width=100,
height=35,
font=ctk.CTkFont(size=12),
fg_color="#0f3460",
hover_color="#533483"
)
btn.pack(side="left", padx=5, pady=12)
# Main editor area
editor_frame = ctk.CTkFrame(parent, fg_color="#0f0f23")
editor_frame.pack(fill="both", expand=True, padx=5)
# Text editor
self.text_editor = ctk.CTkTextbox(
editor_frame,
font=ctk.CTkFont(size=14),
wrap="word"
)
self.text_editor.pack(fill="both", expand=True, padx=10,
pady=10)
# Status bar
self.status_bar = ctk.CTkLabel(
parent,
text="Ready",
font=ctk.CTkFont(size=10),
fg_color="#1a1a2e",
height=25
)
self.status_bar.pack(fill="x", padx=5, pady=(5, 0))
def new_document(self):
"""Create new document"""
self.text_editor.delete("1.0", "end")
self.current_doc = None
self.status_bar.configure(text="New document created")
def open_document(self):
"""Open existing document"""
file_path = filedialog.askopenfilename(
title="Open Document",
filetypes=[
("Text files", "*.txt"),
("Word documents", "*.docx"),
("All files", "*.*")
]
)
if file_path:
try:
if file_path.endswith('.docx'):
doc = Document(file_path)
content = '\n'.join([paragraph.text for paragraph
in doc.paragraphs])
else:
with open(file_path, 'r', encoding='utf-8') as
file:
content = file.read()
self.text_editor.delete("1.0", "end")
self.text_editor.insert("1.0", content)
self.current_doc = file_path
self.status_bar.configure(text=f"Opened:
{os.path.basename(file_path)}")
except Exception as e:
messagebox.showerror("Error", f"Failed to open file:
{str(e)}")
def save_document(self):
"""Save document"""
if not self.current_doc:
self.save_document_as()
else:
try:
content = self.text_editor.get("1.0", "end-1c")
if self.current_doc.endswith('.docx'):
doc = Document()
doc.add_paragraph(content)
doc.save(self.current_doc)
else:
with open(self.current_doc, 'w', encoding='utf-8')
as file:
file.write(content)
self.status_bar.configure(text=f"Saved:
{os.path.basename(self.current_doc)}")
except Exception as e:
messagebox.showerror("Error", f"Failed to save file:
{str(e)}")
def save_document_as(self):
"""Save document as new file"""
file_path = filedialog.asksaveasfilename(
title="Save Document As",
defaultextension=".txt",
filetypes=[
("Text files", "*.txt"),
("Word documents", "*.docx"),
("All files", "*.*")
]
)
if file_path:
self.current_doc = file_path
self.save_document()
def show_ai_menu(self):
"""Show AI assistance menu"""
ai_window = ctk.CTkToplevel(self.app.root)
ai_window.title("AI Document Assistant")
ai_window.geometry("600x500")
ai_window.configure(fg_color="#0a0a0a")
# AI features buttons
ai_features = [
("✍️Improve Writing", self.ai_features.improve_writing),
("📝 Summarize Text", self.ai_features.summarize_text),
("🌐 Translate", self.ai_features.translate_text),
("✅ Grammar Check", self.ai_features.grammar_check),
("📊 Extract Data", self.ai_features.extract_data),
("🎨 Format Document", self.ai_features.format_document),
("📧 Generate Email", self.ai_features.generate_email),
("📋 Create Outline", self.ai_features.create_outline)
]
for i, (text, command) in enumerate(ai_features):
btn = ctk.CTkButton(
ai_window,
text=text,
command=lambda cmd=command:
self.execute_ai_feature(cmd, ai_window),
width=250,
height=40,
font=ctk.CTkFont(size=14),
fg_color="#0f3460",
hover_color="#533483"
)
btn.pack(pady=10, padx=20)
def execute_ai_feature(self, feature_func, window):
"""Execute AI feature with selected text"""
try:
selected_text = self.text_editor.selection_get()
except:
selected_text = self.text_editor.get("1.0", "end-1c")
if selected_text.strip():
result = feature_func(selected_text)
if result:
# Show result in new window
self.show_ai_result(result, window)
else:
messagebox.showwarning("Warning", "Please select text or
ensure document has content")
def show_ai_result(self, result, parent_window):
"""Show AI processing result"""
result_window = ctk.CTkToplevel(parent_window)
result_window.title("AI Result")
result_window.geometry("700x500")
result_window.configure(fg_color="#0a0a0a")
# Result text area
result_text = ctk.CTkTextbox(
result_window,
font=ctk.CTkFont(size=12),
wrap="word"
)
result_text.pack(fill="both", expand=True, padx=20, pady=20)
result_text.insert("1.0", result)
# Action buttons
btn_frame = ctk.CTkFrame(result_window,
fg_color="transparent")
btn_frame.pack(fill="x", padx=20, pady=(0, 20))
ctk.CTkButton(
btn_frame,
text="Replace Original",
command=lambda: self.replace_text(result, result_window),
fg_color="#0f3460",
hover_color="#533483"
).pack(side="left", padx=(0, 10))
ctk.CTkButton(
btn_frame,
text="Insert Below",
command=lambda: self.insert_text(result, result_window),
fg_color="#0f3460",
hover_color="#533483"
).pack(side="left", padx=(0, 10))
ctk.CTkButton(
btn_frame,
text="Copy to Clipboard",
command=lambda: self.copy_to_clipboard(result),
fg_color="#0f3460",
hover_color="#533483"
).pack(side="left")
def replace_text(self, new_text, window):
"""Replace selected text with AI result"""
try:
self.text_editor.delete("sel.first", "sel.last")
self.text_editor.insert("insert", new_text)
except:
self.text_editor.delete("1.0", "end")
self.text_editor.insert("1.0", new_text)
window.destroy()
def insert_text(self, new_text, window):
"""Insert AI result below current text"""
self.text_editor.insert("end", f"\n\n{new_text}")
window.destroy()
def copy_to_clipboard(self, text):
"""Copy text to clipboard"""
self.app.root.clipboard_clear()
self.app.root.clipboard_append(text)
messagebox.showinfo("Success", "Text copied to clipboard")
def show_format_menu(self):
"""Show formatting options"""
format_window = ctk.CTkToplevel(self.app.root)
format_window.title("Format Document")
format_window.geometry("400x300")
format_window.configure(fg_color="#0a0a0a")
# Format options
format_options = [
("📝 Title Case", self.format_title_case),
("🔤 UPPER CASE", self.format_upper_case),
("🔡 lower case", self.format_lower_case),
("📋 Remove Extra Spaces", self.remove_extra_spaces),
("📄 Add Line Numbers", self.add_line_numbers),
("🎨 Smart Formatting", self.smart_format)
]
for text, command in format_options:
btn = ctk.CTkButton(
format_window,
text=text,
command=command,
width=300,
height=35,
font=ctk.CTkFont(size=12),
fg_color="#0f3460",
hover_color="#533483"
)
btn.pack(pady=5, padx=20)
def format_title_case(self):
"""Format selected text to title case"""
try:
selected = self.text_editor.selection_get()
formatted = selected.title()
self.text_editor.delete("sel.first", "sel.last")
self.text_editor.insert("insert", formatted)
except:
messagebox.showwarning("Warning", "Please select text to
format")
def format_upper_case(self):
"""Format selected text to upper case"""
try:
selected = self.text_editor.selection_get()
formatted = selected.upper()
self.text_editor.delete("sel.first", "sel.last")
self.text_editor.insert("insert", formatted)
except:
messagebox.showwarning("Warning", "Please select text to
format")
def format_lower_case(self):
"""Format selected text to lower case"""
try:
selected = self.text_editor.selection_get()
formatted = selected.lower()
self.text_editor.delete("sel.first", "sel.last")
self.text_editor.insert("insert", formatted)
except:
messagebox.showwarning("Warning", "Please select text to
format")
def remove_extra_spaces(self):
"""Remove extra spaces from document"""
content = self.text_editor.get("1.0", "end-1c")
# Remove multiple spaces and empty lines
import re
formatted = re.sub(r' +', ' ', content) # Multiple spaces to
single
formatted = re.sub(r'\n\s*\n', '\n\n', formatted) # Multiple
newlines to double
self.text_editor.delete("1.0", "end")
self.text_editor.insert("1.0", formatted)
self.status_bar.configure(text="Removed extra spaces")
def add_line_numbers(self):
"""Add line numbers to document"""
content = self.text_editor.get("1.0", "end-1c")
lines = content.split('\n')
numbered_lines = [f"{i+1:3d}. {line}" for i, line in
enumerate(lines)]
self.text_editor.delete("1.0", "end")
self.text_editor.insert("1.0", '\n'.join(numbered_lines))
self.status_bar.configure(text="Added line numbers")
def smart_format(self):
"""Apply smart formatting using AI"""
content = self.text_editor.get("1.0", "end-1c")
if content.strip():
formatted = self.ai_features.smart_format(content)
if formatted:
self.text_editor.delete("1.0", "end")
self.text_editor.insert("1.0", formatted)
self.status_bar.configure(text="Applied smart
formatting")
def find_replace(self):
"""Show find and replace dialog"""
find_window = ctk.CTkToplevel(self.app.root)
find_window.title("Find & Replace")
find_window.geometry("400x200")
find_window.configure(fg_color="#0a0a0a")
# Find entry
ctk.CTkLabel(find_window, text="Find:",
font=ctk.CTkFont(size=12)).pack(pady=(20, 5))
find_entry = ctk.CTkEntry(find_window, width=300)
find_entry.pack(pady=5)
# Replace entry
ctk.CTkLabel(find_window, text="Replace with:",
font=ctk.CTkFont(size=12)).pack(pady=(10, 5))
replace_entry = ctk.CTkEntry(find_window, width=300)
replace_entry.pack(pady=5)
# Buttons
btn_frame = ctk.CTkFrame(find_window, fg_color="transparent")
btn_frame.pack(pady=20)
ctk.CTkButton(
btn_frame,
text="Find Next",
command=lambda: self.find_next(find_entry.get()),
fg_color="#0f3460",
hover_color="#533483"
).pack(side="left", padx=5)
ctk.CTkButton(
btn_frame,
text="Replace All",
command=lambda: self.replace_all(find_entry.get(),
replace_entry.get(), find_window),
fg_color="#0f3460",
hover_color="#533483"
).pack(side="left", padx=5)
def find_next(self, search_term):
"""Find next occurrence of search term"""
if not search_term:
return
content = self.text_editor.get("1.0", "end-1c")
start_pos = self.text_editor.index("insert")
pos = content.find(search_term, int(start_pos.split('.')[0]) -
1)
if pos != -1:
line = pos // len(content.split('\n')[0]) + 1
col = pos % len(content.split('\n')[0])
self.text_editor.mark_set("insert", f"{line}.{col}")
self.text_editor.see("insert")
def replace_all(self, find_text, replace_text, window):
"""Replace all occurrences"""
if not find_text:
return
content = self.text_editor.get("1.0", "end-1c")
new_content = content.replace(find_text, replace_text)
self.text_editor.delete("1.0", "end")
self.text_editor.insert("1.0", new_content)
count = content.count(find_text)
self.status_bar.configure(text=f"Replaced {count}
occurrences")
window.destroy()
class PresentationModule:
"""Presentation module with AI-powered slide generation"""
