🌐 Hybrid Browser MA2C
✅ Navigateur initialisé
Prêt pour la navigation et le traitement d'emails
"""
# UTILISER setHtml au lieu de setUrl
self.web_view.setHtml(initial_html)
# URL fictive pour la barre d'adresse
initial_url_display = "browser://ready"
# ═══ MISE À JOUR DE LA BARRE D'URL ═══
if hasattr(self, 'navigation_bar') and hasattr(self.navigation_bar, 'url_bar'):
self.navigation_bar.url_bar.setText(initial_url_display)
print(f"🔧 Browser configuré - Mode: {'Mini' if is_mini_mode else 'Normal'}")
def inject_scrollbar_css(self, success):
if success:
main_window = self.window()
if hasattr(main_window, 'is_mini') and main_window.is_mini:
css_code = """
(function() {
var style = document.createElement('style');
style.textContent = `
::-webkit-scrollbar {
width: 4px !important;
height: 8px !important;
}
::-webkit-scrollbar-track {
background: transparent !important;
}
::-webkit-scrollbar-thumb {
background: rgba(255, 100, 100, 0.4) !important; /* ROUGE TRANSPARENT */
border-radius: 2px !important;
}
::-webkit-scrollbar-thumb:hover {
background: rgba(255, 100, 100, 0.8) !important; /* ROUGE PLUS VISIBLE */
}
`;
document.head.appendChild(style);
})();
"""
self.web_view.page().runJavaScript(css_code)
def handle_url_changed(self, qurl):
"""Mise à jour de la barre d'URL quand l'URL change"""
if hasattr(self, 'navigation_bar') and hasattr(self.navigation_bar, 'url_bar'):
# Mettre à jour le texte de la barre d'URL avec l'URL actuelle
self.navigation_bar.url_bar.setText(qurl.toString())
# Propager également le changement au niveau de la fenêtre principale pour l'historique
main_window = self.window()
if main_window and hasattr(main_window, 'update_url'):
main_window.update_url(qurl)
def handle_load_started(self):
self.navigation_bar.progress_bar.setValue(0)
self.navigation_bar.progress_bar.show()
def handle_load_progress(self, progress):
self.navigation_bar.progress_bar.setValue(progress)
def handle_load_finished(self, success):
if success:
self.navigation_bar.progress_bar.setValue(100)
QTimer.singleShot(1000, self.navigation_bar.progress_bar.hide)
else:
self.navigation_bar.progress_bar.setStyleSheet("""
QProgressBar::chunk { background: red; }
""")
def update_url(self, url):
self.navigation_bar.url_bar.setText(url.toString())
class BrowserWindow(QMainWindow):
def __init__(self, is_mini=False, *args, **kwargs):
super().__init__(*args, **kwargs)
self.is_mini = is_mini # Mode mini activé ou non
self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint)
if self.is_mini:
# Taille adaptative selon la résolution d'écran pour le mini browser
screen_height = QDesktopWidget().availableGeometry().height()
if screen_height >= 1080: # Écrans Full HD ou plus
min_browser_height = int(screen_height * 0.25) # 25% de la hauteur d'écran
elif screen_height >= 768: # Écrans HD
min_browser_height = int(screen_height * 0.20) # 20% de la hauteur d'écran
else: # Écrans plus petits
min_browser_height = 200
self.resize(500, min_browser_height)
else:
self.resize(1200, 800)
self.setWindowTitle("Hybrid Browser MA2C")
self.setGeometry(100, 100, 1200, 800)
# === Widget central et layout principal ===
central_widget = QWidget()
self.setCentralWidget(central_widget)
layout = QVBoxLayout(central_widget)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
# === Bannière inférieure ===
self.bottom_banner = BottomBanner(self)
layout.addWidget(self.bottom_banner)
# === Historique de navigation ===
self.history = []
if os.path.exists("history.txt"):
with open("history.txt", "r") as f:
for line in f:
parts = line.strip().split(" | ")
if len(parts) != 2:
continue
timestamp, url = parts
self.history.append({"timestamp": timestamp, "url": url})
# === Système d'onglets ===
self.tab_widget = QTabWidget()
if not self.is_mini:
self.tab_widget.setTabsClosable(True)
self.tab_widget.tabCloseRequested.connect(self.close_tab)
add_tab_button = QPushButton("+")
add_tab_button.setMinimumWidth(20)
add_tab_button.setFixedSize(30, 20)
add_tab_button.setFont(QFont("Arial", 10, QFont.Bold))
add_tab_button.clicked.connect(self.add_tab)
tab_bar = self.tab_widget.tabBar()
tab_bar_layout = QHBoxLayout(tab_bar)
tab_bar_layout.setContentsMargins(0, 0, 0, 0)
tab_bar_layout.setSpacing(0)
tab_bar_layout.addStretch()
tab_bar_layout.addWidget(add_tab_button)
tab_bar.setStyleSheet("""
QTabBar::tab {
padding: 5px 10px;
margin: 2px;
background: lightgray;
border: 1px solid darkgray;
border-radius: 4px;
}
QPushButton {
margin-left: 4px;
padding: 2px 10px;
background: #3498db;
color: white;
border-radius: 5px;
font-weight: bold;
}
QPushButton:hover {
background: #2980b9;
}
QPushButton:pressed {
background: #2573a7;
}
""")
else:
self.tab_widget.setTabsClosable(False)
self.tab_widget.setDocumentMode(True)
self.tab_widget.setStyleSheet("""
QTabWidget::tab-bar {
height: 0px;
width: 0px;
margin: 0px;
padding: 0px;
border: none;
visibility: hidden;
}
QTabBar {
height: 0px;
width: 0px;
margin: 0px;
padding: 0px;
border: none;
background: transparent;
visibility: hidden;
}
QTabBar::tab {
height: 0px;
width: 0px;
margin: 0px;
padding: 0px;
border: none;
background: transparent;
visibility: hidden;
max-height: 0px;
max-width: 0px;
}
QTabWidget::pane {
border: none;
margin: 0px;
padding: 0px;
}
""")
self.tab_widget.setContentsMargins(0, 0, 0, 0)
tab_bar = self.tab_widget.tabBar()
tab_bar.setVisible(False)
tab_bar.setMaximumHeight(0)
self.tab_widget.setTabBarAutoHide(True)
layout.addWidget(self.tab_widget)
# === Créer le premier onglet ===
self.add_tab()
# === Initialiser le zoom navigateur ===
self.initialize_browser_zoom()
def on_load_finished(self, ok):
if ok:
print("✅ Page chargée avec succès")
self.inject_js_fixes() # ✅ Injection JS anti-erreur
else:
print("❌ Échec du chargement de la page")
def add_tab(self, url=None):
# Créer un TabWidget au lieu d'un QWebEngineView directement
tab_widget = TabWidget(self)
# Si une URL est fournie, la charger
if url:
if isinstance(url, str):
# Convertir la string en QUrl si nécessaire
from PyQt5.QtCore import QUrl
qurl = QUrl(url)
else:
qurl = url
tab_widget.web_view.setUrl(qurl)
# Injection JS après chargement
tab_widget.web_view.loadFinished.connect(lambda ok: self.inject_js_fixes() if ok else None)
# Ajouter l'onglet avec un titre par défaut
tab_index = self.tab_widget.addTab(tab_widget, "Nouvel Onglet")
self.tab_widget.setCurrentIndex(tab_index)
def inject_js_fixes(self):
js_code = """
(function() {
try {
// === SYSTÈME DE CORRECTION DYNAMIQUE DES ERREURS ===
// 1. Gestionnaire d'erreurs global avec auto-correction
window.addEventListener('error', function(e) {
const error = e.error || e;
const message = error.message || e.message || '';
const source = e.filename || '';
// Auto-corrections basées sur des patterns
if (message.includes('is not defined')) {
const varName = message.match(/(.+?) is not defined/)?.[1];
if (varName) {
// Créer automatiquement la variable/fonction manquante
if (varName.includes('Interval')) {
window[varName] = setInterval;
} else if (varName.includes('Timeout')) {
window[varName] = setTimeout;
} else if (varName.includes('Element') || varName.includes('Container')) {
window[varName] = function() { return document.createElement('div'); };
} else {
// Fonction générique par défaut
window[varName] = function() {
console.info("🔧 Auto-polyfill créé pour :", varName);
return {};
};
}
console.info("✅ Variable manquante auto-corrigée :", varName);
e.preventDefault();
return false;
}
}
// Masquer les erreurs non-critiques
const nonCriticalErrors = [
'Mixed Content',
'SameSite',
'Content Security Policy',
'cross-site',
'chrome-extension',
'Graph container element not found',
'Network request failed'
];
if (nonCriticalErrors.some(pattern => message.includes(pattern))) {
console.info("🔇 Erreur non-critique masquée :", message.substring(0, 100));
e.preventDefault();
return false;
}
return true;
});
// 2. Proxy universel pour les objets manquants
const createUniversalProxy = (name) => {
return new Proxy({}, {
get: function(target, property) {
if (!(property in target)) {
if (typeof property === 'string' && property !== 'then') {
target[property] = createUniversalProxy(name + '.' + property);
}
}
return target[property];
},
set: function(target, property, value) {
target[property] = value;
return true;
}
});
};
// 3. Intercepteur universel de propriétés manquantes
const originalGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
Object.getOwnPropertyDescriptor = function(obj, prop) {
const desc = originalGetOwnPropertyDescriptor(obj, prop);
if (!desc && typeof prop === 'string') {
// Créer une propriété par défaut
return {
value: createUniversalProxy(prop),
writable: true,
enumerable: true,
configurable: true
};
}
return desc;
};
// 4. Auto-correction des URLs HTTP vers HTTPS
const autoHttpsCorrection = () => {
document.querySelectorAll('script[src^="http://"], link[href^="http://"], img[src^="http://"]').forEach(el => {
const attr = el.src ? 'src' : 'href';
const oldUrl = el.getAttribute(attr);
const newUrl = oldUrl.replace('http://', 'https://');
el.setAttribute(attr, newUrl);
console.info("🔒 Auto-correction HTTP→HTTPS :", oldUrl.substring(0, 50));
});
};
// 5. Observer pour auto-corrections continues
const universalObserver = new MutationObserver(function(mutations) {
mutations.forEach(function(mutation) {
mutation.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
// Auto-correction immédiate des nouveaux éléments
if (node.src && node.src.startsWith('http://')) {
node.src = node.src.replace('http://', 'https://');
}
if (node.href && node.href.startsWith('http://')) {
node.href = node.href.replace('http://', 'https://');
}
// Créer des IDs manquants pour les graphiques
if (node.className && node.className.includes('chart')) {
if (!node.id) node.id = 'auto-chart-' + Date.now();
}
}
});
});
// Exécuter les corrections périodiques
autoHttpsCorrection();
});
// 6. Polyfills universels basés sur des patterns
const universalPolyfills = {
// Fonctions de timing
setInterval2: setInterval,
setInterval3: setInterval,
setTimeout2: setTimeout,
setTimeout3: setTimeout,
// Fonctions jQuery alternatives
$: function(selector) {
return document.querySelector(selector) || {
ready: function(fn) { if (document.readyState !== 'loading') fn(); else document.addEventListener('DOMContentLoaded', fn); },
on: function() { return this; },
hide: function() { return this; },
show: function() { return this; },
fadeIn: function() { return this; },
fadeOut: function() { return this; }
};
},
// APIs manquantes communes
Morris: { Line: function() { return { render: function() {} }; } },
Chart: { Line: function() { return { render: function() {} }; } },
gtag: function() { console.info("🔧 gtag polyfill"); },
ga: function() { console.info("🔧 Google Analytics polyfill"); }
};
// Appliquer les polyfills
Object.keys(universalPolyfills).forEach(key => {
if (typeof window[key] === 'undefined') {
window[key] = universalPolyfills[key];
console.info("🔧 Polyfill appliqué :", key);
}
});
// 7. Gestionnaire de cookies universels
const originalCookieDescriptor = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
Object.defineProperty(document, 'cookie', {
get: originalCookieDescriptor.get,
set: function(value) {
let correctedValue = value;
// Auto-correction SameSite
if (!/SameSite=/i.test(value)) {
correctedValue += '; SameSite=None';
}
// Auto-correction Secure pour HTTPS
if (location.protocol === 'https:' && !/Secure/i.test(correctedValue)) {
correctedValue += '; Secure';
}
return originalCookieDescriptor.set.call(this, correctedValue);
}
});
// 8. Masquage intelligent des erreurs de console
const originalConsoleError = console.error;
const originalConsoleWarn = console.warn;
console.error = function(...args) {
const message = args.join(' ');
const ignoredPatterns = [
'Mixed Content',
'SameSite',
'chrome-extension',
'Content Security Policy',
'cross-site resource'
];
if (!ignoredPatterns.some(pattern => message.includes(pattern))) {
return originalConsoleError.apply(console, args);
}
};
console.warn = function(...args) {
const message = args.join(' ');
if (!message.includes('SameSite') && !message.includes('cross-site')) {
return originalConsoleWarn.apply(console, args);
}
};
// 9. Démarrer l'observation continue
if (document.body) {
universalObserver.observe(document.body, {
childList: true,
subtree: true,
attributes: true,
attributeFilter: ['src', 'href']
});
}
// 10. Corrections initiales
autoHttpsCorrection();
console.info("🚀 Système de correction dynamique activé");
} catch(e) {
console.error("Erreur dans le système de correction :", e);
}
})();
"""
web_view = self.get_current_web_view()
if web_view:
web_view.page().runJavaScript(js_code)
def update_banner_position(self, position):
layout = self.centralWidget().layout()
layout.removeWidget(self.bottom_banner)
if position == "disabled":
self.bottom_banner.hide()
else:
self.bottom_banner.show()
if position == "top":
layout.insertWidget(0, self.bottom_banner)
else:
layout.addWidget(self.bottom_banner)
def build_banner_text(self, subject: str) -> str:
if hasattr(self, 'tab_widget'):
tab_count = self.tab_widget.count()
current_index = self.tab_widget.currentIndex() + 1 # Les onglets commencent à 0
return f"Onglets : 1-{tab_count} (actif: {current_index}) / {subject}"
else:
return f"Onglet unique / {subject}"
def update_page_time(self, display_label, start_timer=True):
print(f"update_page_time called with: {display_label}, start_timer={start_timer}")
if hasattr(self, 'console_header') and self.console_header:
self.console_header.update_page_time(display_label, start_timer=start_timer)
def initialize_browser_zoom(self):
"""Initialise le navigateur avec le zoom sauvegardé"""
current_tab = self.get_current_tab()
if current_tab and hasattr(current_tab, 'web_view'):
try:
import os
# Chemin du fichier de configuration
zoom_file = os.path.join(r"C:\AUTOLOOK", "miniview.json")
# Valeur de zoom par défaut
saved_zoom = 0.4 # 40% par défaut
# Charger la configuration si elle existe
if os.path.exists(zoom_file):
try:
with open(zoom_file, 'r') as f:
content = f.read().strip()
if content:
saved_zoom = float(content)
logger.info(f"Zoom chargé: {saved_zoom * 100:.0f}% depuis {zoom_file}")
except Exception as e:
logger.error(f"Erreur lors du chargement du zoom: {str(e)}")
else:
logger.info(f"Fichier de zoom non trouvé: {zoom_file}, utilisation du zoom par défaut (40%)")
# Appliquer le zoom
current_tab.web_view.setZoomFactor(saved_zoom)
except Exception as e:
logger.error(f"Erreur lors de l'initialisation du zoom: {str(e)}")
# En cas d'erreur, utiliser la valeur par défaut
if current_tab and hasattr(current_tab, 'web_view'):
current_tab.web_view.setZoomFactor(0.4)
def showEvent(self, event):
"""Appelé lorsque la fenêtre est affichée - pour maintenir le masquage en mode mini"""
super().showEvent(event)
# ═══ MASQUAGE FORCÉ NAVIGATION MINI ═══
if self.is_mini and hasattr(self, 'tab_widget'):
tab_bar = self.tab_widget.tabBar()
tab_bar.setVisible(False)
tab_bar.setMaximumHeight(0)
# S'assurer que tous les onglets ont leur navigation_bar masquée DÉFINITIVEMENT
for i in range(self.tab_widget.count()):
tab = self.tab_widget.widget(i)
if hasattr(tab, 'navigation_bar'):
# Masquage complet et irréversible
tab.navigation_bar.setVisible(False)
tab.navigation_bar.setMaximumHeight(0)
tab.navigation_bar.setMinimumHeight(0)
# Désactiver tous les widgets enfants
for child in tab.navigation_bar.findChildren(QWidget):
child.setVisible(False)
child.setMaximumHeight(0)
# Retirer du layout si possible
if tab.navigation_bar.parent():
layout = tab.navigation_bar.parent().layout()
if layout:
layout.removeWidget(tab.navigation_bar)
# ═══ FIN MASQUAGE FORCÉ ═══
def setup_ui(self):
layout = QHBoxLayout()
button_style = "background-color: #3498db; color: white; padding: 5px;"
# Bouton Console (toujours présent)
self.console_button = QPushButton("Console")
self.console_button.setStyleSheet(button_style)
self.console_button.clicked.connect(self.toggle_console)
layout.addWidget(self.console_button)
# Ajouter les autres boutons seulement si ce n'est pas en mode mini
if not self.is_mini:
self.timer_button = QPushButton("Timer")
self.timer_button.setStyleSheet(button_style)
self.timer_button.clicked.connect(self.toggle_timer)
layout.addWidget(self.timer_button)
self.switch_button = QPushButton("Switch")
self.switch_button.setStyleSheet(button_style)
self.switch_button.clicked.connect(self.toggle_browser_view)
layout.addWidget(self.switch_button)
# Appliquer le layout au widget principal
header_widget = QWidget()
header_widget.setLayout(layout)
self.setCentralWidget(header_widget)
def setup_browser(self):
profile = QWebEngineProfile.defaultProfile()
web_view = self.get_current_web_view()
if not web_view:
return
settings = web_view.settings()
# Configuration des paramètres du navigateur
settings.setAttribute(QWebEngineSettings.JavascriptEnabled, True)
settings.setAttribute(QWebEngineSettings.LocalStorageEnabled, True)
settings.setAttribute(QWebEngineSettings.PluginsEnabled, True)
settings.setAttribute(QWebEngineSettings.AutoLoadImages, True)
# Connexion des signaux
web_view.loadStarted.connect(self.handle_load_started)
web_view.loadProgress.connect(self.handle_load_progress)
web_view.loadFinished.connect(self.handle_load_finished)
web_view.urlChanged.connect(self.update_url)
# Chargement de la page initiale
web_view.setUrl(QUrl("https://www.snoown2klabs.com"))
def close_tab(self, index):
"""Ferme l'onglet à l'index spécifié"""
if self.tab_widget.count() > 1:
self.tab_widget.removeTab(index)
else:
# Si c'est le dernier onglet, créer un nouvel onglet avant de le fermer
self.add_tab()
self.tab_widget.removeTab(index)
def get_current_tab(self):
"""Retourne le TabWidget actif"""
return self.tab_widget.currentWidget()
def load_url(self, url):
"""Charge une URL dans l'onglet actif"""
if not url:
return
# S'assurer que l'URL a un schéma (http/https)
if not isinstance(url, QUrl):
if not url.startswith(('http://', 'https://')):
url = 'https://' + url
qurl = QUrl.fromUserInput(url)
else:
qurl = url
# Obtenir l'onglet actif et charger l'URL
current_tab = self.get_current_tab()
if current_tab and hasattr(current_tab, 'web_view'):
# Charger l'URL dans la vue web
current_tab.web_view.setUrl(qurl)
# S'assurer que la barre d'URL est mise à jour immédiatement
if hasattr(current_tab, 'navigation_bar') and hasattr(current_tab.navigation_bar, 'url_bar'):
current_tab.navigation_bar.url_bar.setText(qurl.toString())
def update_url(self, url):
"""
Met à jour l'historique avec la nouvelle URL et met à jour la barre d'URL.
"""
try:
# CORRECTION 10: Mettre à jour la barre d'URL de l'onglet actif
current_tab = self.get_current_tab()
if current_tab and hasattr(current_tab, 'navigation_bar') and hasattr(current_tab.navigation_bar,
'url_bar'):
current_tab.navigation_bar.url_bar.setText(url.toString())
# Vérifier les doublons avant d'ajouter à l'historique
url_string = url.toString()
if not self.history or self.history[-1]["url"] != url_string:
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
self.history.append({"url": url_string, "timestamp": timestamp})
# Sauvegarder dans un fichier
with open("history.txt", "a") as f:
f.write(f"{timestamp} | {url_string}\n")
logger.info(f"URL ajoutée à l'historique : {url_string}")
except Exception as e:
logger.error(f"Erreur lors de la mise à jour de l'URL : {e}")
def handle_load_started(self):
self.navigation_bar.progress_bar.setValue(0)
self.navigation_bar.progress_bar.show()
def handle_load_progress(self, progress):
self.navigation_bar.progress_bar.setValue(progress)
def handle_load_finished(self, success):
if success:
self.navigation_bar.progress_bar.setValue(100)
QTimer.singleShot(1000, self.navigation_bar.progress_bar.hide)
else:
self.navigation_bar.progress_bar.setStyleSheet("""
QProgressBar::chunk {
background: red;
}
""")
def get_current_web_view(self):
"""Retourne le QWebEngineView de l'onglet actif"""
current_tab = self.get_current_tab()
if current_tab and hasattr(current_tab, 'web_view'):
return current_tab.web_view
return None
def clear_browser(self):
web_view = self.get_current_web_view()
if web_view:
web_view.setUrl(QUrl("about:blank"))
self.console_header.page_time = 0.0
self.console_header.timer_label.setText("----")
def hide_browser(self):
"""Cache le navigateur PyQt et tous ses composants"""
self.tab_widget.hide()
self.hide()
def show_browser(self):
"""Affiche le navigateur PyQt et tous ses composants"""
self.show()
self.tab_widget.show()
class BottomBanner(QFrame):
def __init__(self, parent=None):
super().__init__(parent)
self.setFixedHeight(40)
self.setStyleSheet("background-color: rgba(0, 0, 0, 120); border-radius: 6px;")
self.setContentsMargins(10, 0, 10, 0)
self.setVisible(False)
layout = QHBoxLayout(self)
self.label = QLabel("...")
self.label.setStyleSheet("color: white; font-size: 8pt;")
layout.addWidget(self.label)
self.animation_timer = QTimer()
self.animation_timer.timeout.connect(self.scroll_text)
self.full_text = ""
self.offset = 0
def show_banner(self, text):
self.full_text = text
self.offset = 0
self.label.setText(text)
self.setVisible(True)
if len(text) > 50: # Valeur à ajuster selon la largeur du navigateur
self.animation_timer.start(150)
else:
self.animation_timer.stop()
def scroll_text(self):
visible_chars = 50
if len(self.full_text) <= visible_chars:
return
start = self.offset % len(self.full_text)
scrolled = self.full_text[start:] + " • " + self.full_text[:start]
self.label.setText(scrolled[:visible_chars])
self.offset += 1
def hide_banner(self):
self.setVisible(False)
self.animation_timer.stop()
stop_trace()
if __name__ == "__main__":
# ═══ CONFIGURATION POUR RÉUTILISER LES PROCESSUS ═══
import os
import sys
# Configuration critique pour réutiliser les processus
os.environ['QTWEBENGINE_CHROMIUM_FLAGS'] = (
'--single-process ' # FORCE un seul processus
'--no-sandbox '
'--disable-web-security '
'--disable-features=VizDisplayCompositor '
'--process-per-site '
'--max_old_space_size=50 '
'--max-active-webgl-contexts=1'
)
# Force le modèle single-process
os.environ['QTWEBENGINE_PROCESS_MODEL'] = 'single-process'
# Limite le cache pour éviter l'accumulation
os.environ['QTWEBENGINE_DISK_CACHE_SIZE'] = '10485760' # 10MB
print("🔧 Configuration single-process WebEngine appliquée")
# ═══ FIN CONFIGURATION ═══
app = QApplication(sys.argv)
window = BrowserWindow()
window.show()
sys.exit(app.exec_())