699 lines
30 KiB
Python
699 lines
30 KiB
Python
# -*- Config : UTF-8 -*-
|
|
# Project Name: Termination Generally Use Cyber Virus Puppet Weapons - TLUI/UIThread
|
|
# Version: 4.2.0
|
|
# Build Version: ./TConfig/version.ini
|
|
# Author: Veyra
|
|
# Description:
|
|
|
|
# Local Web Process
|
|
|
|
|
|
from TLib import *
|
|
from TLib.T_imports import *
|
|
import TLib.T_Hardcoded as T_Hardcoded
|
|
import TLib.T_Tools as T_Tools
|
|
from . import UI_Hardcoded
|
|
|
|
|
|
|
|
|
|
class MEMZMistakes(T_Process.TProcess):
|
|
def Run(self, master: 'Termination4.Termination', Step: int = 200, SleepTime: float = 0.01):
|
|
self.desc: str = "UI: MEMZMistakes"
|
|
hwnd: int = win32gui.GetDesktopWindow()
|
|
hdc: int = win32gui.GetWindowDC(hwnd)
|
|
IconNames: list[int] = [win32con.IDI_ERROR, win32con.IDI_WARNING]
|
|
images: list[int] = []
|
|
for IconName in IconNames:
|
|
images.append(win32gui.LoadIcon(0, IconName))
|
|
def DrawIconDesktopThread(hdc: int, images: list):
|
|
DesktopSize = pyautogui.size()
|
|
for i in range(Step):
|
|
win32gui.DrawIcon(hdc,
|
|
random.randint(0, DesktopSize[0]),
|
|
random.randint(0, DesktopSize[1]),
|
|
images[random.randint(0, 1)])
|
|
time.sleep(SleepTime)
|
|
threading.Thread(target = DrawIconDesktopThread, args = (hdc, images)).start()
|
|
for i in range(Step):
|
|
win32gui.DrawIcon(hdc,
|
|
pyautogui.position()[0],
|
|
pyautogui.position()[1],
|
|
images[0])
|
|
time.sleep(SleepTime)
|
|
|
|
class MEMZInvertDesktop(T_Process.TProcess):
|
|
def Run(self, master: 'Termination4.Termination', Step: int = 200, SleepTime: float = 0.01):
|
|
self.desc: str = "UI: InvertDesktop"
|
|
hWnd: int = win32gui.GetDesktopWindow()
|
|
hdc: int = win32gui.GetWindowDC(hWnd)
|
|
rect: tuple[int, int, int, int] = win32gui.GetWindowRect(hWnd)
|
|
for i in range(Step):
|
|
win32gui.BitBlt(hdc, 0, 0, rect[2], rect[3], hdc, rect[0], rect[1], win32con.DSTINVERT)
|
|
time.sleep(SleepTime)
|
|
|
|
class MEMZReverseTitle(T_Process.TProcess):
|
|
def Run(self, master: 'Termination4.Termination'):
|
|
self.desc: str = "UI: ReverseTitle"
|
|
hwnds: list[int] = []
|
|
win32gui.EnumWindows(lambda h, p: p.append(h), hwnds)
|
|
for h in hwnds:
|
|
self.rev(h)
|
|
children: list[int] = []
|
|
win32gui.EnumChildWindows(h, lambda ch, p: p.append(ch), children)
|
|
for ch in children:
|
|
self.rev(ch)
|
|
def rev(self, hwnd):
|
|
t: list[str] = list(win32gui.GetWindowText(hwnd))
|
|
t.reverse()
|
|
win32gui.SetWindowText(hwnd, "".join(t))
|
|
|
|
|
|
|
|
class Thread_SpaceTunnelEffect(T_Process.TProcess):
|
|
def Run(self, master: 'Termination4.Termination', Step: int = 200, SleepTime: float = 0.01):
|
|
self.desc: str = "UI: SpaceTunnelEffect"
|
|
hdesktop: int = win32gui.GetDesktopWindow()
|
|
DesktopDC: int = win32gui.GetWindowDC(hdesktop)
|
|
MonitorRect: tuple[int, int, int, int] = win32gui.GetWindowRect(hdesktop)
|
|
MonitorWidth: int = MonitorRect[2] - MonitorRect[0]
|
|
MonitorHeight: int = MonitorRect[3] - MonitorRect[1]
|
|
DC: win32ui.CDC = win32ui.CreateDCFromHandle(DesktopDC)
|
|
MemDC: win32ui.CDC = DC.CreateCompatibleDC()
|
|
Bmp = win32ui.CreateBitmap()
|
|
Bmp.CreateCompatibleBitmap(DC, MonitorWidth, MonitorHeight)
|
|
MemDC.SelectObject(Bmp)
|
|
Scale = 1.0
|
|
ScaleSpeed = 0.95
|
|
try:
|
|
for _ in range(Step):
|
|
MemDC.BitBlt((0, 0), (MonitorWidth, MonitorHeight), DC, (0, 0), win32con.SRCCOPY)
|
|
Scale *= ScaleSpeed
|
|
if Scale < 0.1 or Scale > 1.0:
|
|
ScaleSpeed = 1.0 / ScaleSpeed
|
|
Scale = max(0.1, min(1.0, Scale))
|
|
ScaledWidth = int(MonitorWidth * Scale)
|
|
ScaledHeight = int(MonitorHeight * Scale)
|
|
XPos = (MonitorWidth - ScaledWidth) // 2
|
|
YPos = (MonitorHeight - ScaledHeight) // 2
|
|
DC.StretchBlt(
|
|
(XPos, YPos), (ScaledWidth, ScaledHeight),
|
|
MemDC, (0, 0), (MonitorWidth, MonitorHeight),
|
|
win32con.SRCCOPY
|
|
)
|
|
time.sleep(SleepTime)
|
|
finally:
|
|
MemDC.DeleteDC()
|
|
DC.DeleteDC()
|
|
# Bmp.DeleteObject()
|
|
|
|
|
|
class Thread_CountDown(T_Process.TProcess):
|
|
def Run(self, master: 'Termination4.Termination', Seconds: int = 10, Text: str = "", Bg: str = 'red', Fg: str = 'white', CallBack: typing.Callable = None):
|
|
self.desc = "UI: Count Down"
|
|
self.Seconds: int = Seconds
|
|
self.Bg: str = Bg
|
|
self.Fg: str = Fg
|
|
self.CallBack: typing.Callable = CallBack if CallBack else self._Handle_Stop
|
|
self.EndTime: int = 0
|
|
self.Running: bool = False
|
|
self.Root = tkinter.Tk()
|
|
self.Root.title("Countdown")
|
|
self.Root.attributes('-fullscreen', True)
|
|
self.Root.wm_attributes('-topmost', True)
|
|
self.Root.configure(bg = self.Bg)
|
|
tkinter.Label(self.Root, text = "", font = ('Arial', 300, 'bold'), bg = self.Bg, fg = self.Fg).pack()
|
|
self.Label: tkinter.Label = tkinter.Label(
|
|
self.Root,
|
|
text = "",
|
|
font = ('Arial', 60, 'bold'),
|
|
bg = self.Bg,
|
|
fg = self.Fg
|
|
)
|
|
self.Label.pack()
|
|
self.TextLabel: tkinter.Label = tkinter.Label(
|
|
self.Root,
|
|
text = Text,
|
|
font = ('Arial', 30, 'bold'),
|
|
bg = self.Bg,
|
|
fg = self.Fg
|
|
)
|
|
self.TextLabel.pack(anchor='center')
|
|
self.Root.bind('<Escape>', lambda e: self.Root.attributes('-fullscreen', False))
|
|
if issubclass(type(self.Seconds), str):
|
|
self.EndTime: int = time.mktime(time.strptime(self.Seconds, "%Y-%m-%d %H:%M:%S"))
|
|
if issubclass(type(self.Seconds), int):
|
|
self.EndTime: int = time.time() + self.Seconds
|
|
self.Running: bool = True
|
|
self.UpdateCount()
|
|
self.Root.mainloop()
|
|
def UpdateCount(self):
|
|
if not self.Running: return
|
|
Remaining: int = self.EndTime - time.time()
|
|
if Remaining <= 0:
|
|
self.Label.config(text="0000-00-00 00-00-00-0000")
|
|
self.Running = False
|
|
if self.CallBack: self.CallBack()
|
|
return
|
|
Millis: int = int((Remaining % 1) * 1000)
|
|
Seconds: int = int(Remaining) % 60
|
|
Minutes: int = int(Remaining / 60) % 60
|
|
Hours: int = int(Remaining / 3600) % 24
|
|
Days: int = int(Remaining / 86400) % 30
|
|
Months: int = int(Remaining / (86400 * 30)) % 12
|
|
Years: int = int(Remaining / (86400 * 365))
|
|
TimeStr: str = (f"{Years:04d}-{Months:02d}-{Days:02d} "
|
|
f"{Hours:02d}-{Minutes:02d}-{Seconds:02d}-{Millis:04d}"
|
|
)
|
|
self.Label.config(text = TimeStr)
|
|
self.Root.after(1, self.UpdateCount)
|
|
def stop(self):
|
|
self.Running: bool = False
|
|
def _Handle_Stop(self):
|
|
if self.Root.winfo_exists():
|
|
self.Running: bool = False
|
|
self.Label.config(text="0000-00-00 00-00-00-0000")
|
|
self.UpdateCount()
|
|
time.sleep(1)
|
|
self.Root.withdraw()
|
|
self.Root.destroy()
|
|
|
|
|
|
|
|
|
|
class Thread_TypingMessage(T_Process.TProcess):
|
|
def Run(self,
|
|
master: 'Termination4.Termination',
|
|
Static_TTF: str = "./System.tff",
|
|
ChineseFontSize: int = 36,
|
|
EnglishFontSize: int = 24,
|
|
TerminationTitleSize: int = 48,
|
|
TerminationSubtitleSize: int = 20,
|
|
CursorVisible: bool = True,
|
|
CurrentLine: int = 0,
|
|
TypingSpeed: int = 50,
|
|
TextPairs: list[tuple] = [],
|
|
TerminationTexts: list[str] = []
|
|
):
|
|
self.desc: str = "UI: Typing Message"
|
|
T_Tools.InstallFont(Static_TTF)
|
|
self.Root: tkinter.Tk = tkinter.Tk()
|
|
self.Root.attributes('-fullscreen', True)
|
|
self.Root.config(bg='black')
|
|
|
|
self.ChineseFontSize: int = ChineseFontSize
|
|
self.EnglishFontSize: int = EnglishFontSize
|
|
self.TerminationTitleSize: int = TerminationTitleSize
|
|
self.TerminationSubtitleSize: int = TerminationSubtitleSize
|
|
|
|
self.Canvas: tkinter.Canvas = tkinter.Canvas(self.Root, bg='black', highlightthickness=0)
|
|
self.Canvas.pack(fill=tkinter.BOTH, expand=True)
|
|
|
|
try:
|
|
self.ChineseFont: tkinter.font.Font = tkinter.font.Font(family = "ipix_12px", size = self.ChineseFontSize)
|
|
self.EnglishFont: tkinter.font.Font = tkinter.font.Font(family = "ipix_12px", size = self.EnglishFontSize)
|
|
except:
|
|
self.ChineseFont: tkinter.font.Font = tkinter.font.Font(size = self.ChineseFontSize)
|
|
self.EnglishFont: tkinter.font.Font = tkinter.font.Font(size = self.EnglishFontSize)
|
|
|
|
self.TextPairs: list[tuple] = TextPairs
|
|
self.TerminationTexts: list[str] = TerminationTexts
|
|
self.CursorVisible: bool = CursorVisible
|
|
self.CursorID: int | None = None
|
|
self.ChineseCursorID: int | None = None
|
|
self.CurrentLine: int = CurrentLine
|
|
self.DisplayingText: str = ""
|
|
self.Deleting: bool = False
|
|
self.TypingSpeed: int = TypingSpeed
|
|
|
|
self.Root.update()
|
|
self.StartTypingEffect()
|
|
self.Root.mainloop()
|
|
|
|
def StartTypingEffect(self):
|
|
if self.CurrentLine < len(self.TextPairs):
|
|
ChineseText: str
|
|
EnglishText: str
|
|
ChineseText, EnglishText = self.TextPairs[self.CurrentLine]
|
|
self.DisplayText(ChineseText, EnglishText)
|
|
else:
|
|
self.ShowTerminationTexts()
|
|
|
|
def DisplayText(self, ChineseText, EnglishText):
|
|
self.Canvas.delete("all")
|
|
ScreenWidth: int = self.Root.winfo_screenwidth()
|
|
ScreenHeight: int = self.Root.winfo_screenheight()
|
|
|
|
self.ChineseTextID: int = self.Canvas.create_text(
|
|
ScreenWidth // 2,
|
|
ScreenHeight // 2 - self.ChineseFontSize,
|
|
text = "",
|
|
font = self.ChineseFont,
|
|
fill = "red",
|
|
anchor=tkinter.CENTER
|
|
)
|
|
self.EnglishTextID: int = self.Canvas.create_text(
|
|
ScreenWidth // 2,
|
|
ScreenHeight // 2 + self.EnglishFontSize,
|
|
text = "",
|
|
font = self.EnglishFont,
|
|
fill = "red",
|
|
anchor = tkinter.CENTER
|
|
)
|
|
|
|
self.DisplayingText: str = ""
|
|
self.Deleting: bool = False
|
|
self.TypeNextChar(ChineseText, EnglishText)
|
|
|
|
def TypeNextChar(self, ChineseText, EnglishText):
|
|
if len(self.DisplayingText) < len(ChineseText):
|
|
self.DisplayingText = ChineseText[:len(self.DisplayingText)+1]
|
|
self.Canvas.itemconfig(self.ChineseTextID, text=self.DisplayingText)
|
|
EnglishDisplayLength = int(len(self.DisplayingText) * len(EnglishText) / len(ChineseText))
|
|
EnglishDisplay = EnglishText[:EnglishDisplayLength]
|
|
self.Canvas.itemconfig(self.EnglishTextID, text = EnglishDisplay)
|
|
self.UpdateCursorPositions()
|
|
self.Root.after(self.TypingSpeed, lambda: self.TypeNextChar(ChineseText, EnglishText))
|
|
else:
|
|
self.Root.after(1000, lambda: self.StartDeletingEffect(ChineseText, EnglishText))
|
|
|
|
def UpdateCursorPositions(self):
|
|
if self.CursorID: self.Canvas.delete(self.CursorID)
|
|
if self.ChineseCursorID: self.Canvas.delete(self.ChineseCursorID)
|
|
|
|
ChineseBBOX: tuple[int, int, int, int] = self.Canvas.bbox(self.ChineseTextID)
|
|
if ChineseBBOX:
|
|
ChineseCursorX = ChineseBBOX[2] + 5
|
|
ChineseCursorY = (ChineseBBOX[1] + ChineseBBOX[3]) / 2
|
|
self.ChineseCursorID = self.Canvas.create_text(
|
|
ChineseCursorX,
|
|
ChineseCursorY,
|
|
text = "|" if self.CursorVisible else "",
|
|
font = self.ChineseFont,
|
|
fill = "red",
|
|
anchor=tkinter.W
|
|
)
|
|
EnglishBBOX: tuple[int, int, int, int] = self.Canvas.bbox(self.EnglishTextID)
|
|
if EnglishBBOX:
|
|
EnglishCursorX = EnglishBBOX[2] + 5
|
|
EnglishCursorY = (EnglishBBOX[1] + EnglishBBOX[3]) / 2
|
|
self.CursorID = self.Canvas.create_text(
|
|
EnglishCursorX,
|
|
EnglishCursorY,
|
|
text = "|" if self.CursorVisible else "",
|
|
font = self.EnglishFont,
|
|
fill = "red",
|
|
anchor = tkinter.W
|
|
)
|
|
|
|
self.Root.after(500, self.ToggleCursor)
|
|
|
|
def ToggleCursor(self):
|
|
if self.Deleting: return
|
|
self.CursorVisible = not self.CursorVisible
|
|
if self.ChineseCursorID: self.Canvas.itemconfig(self.ChineseCursorID, text = "I" if self.CursorVisible else "")
|
|
if self.CursorID: self.Canvas.itemconfig(self.CursorID, text = "I" if self.CursorVisible else "")
|
|
self.Root.after(500, self.ToggleCursor)
|
|
|
|
def StartDeletingEffect(self, ChineseText, EnglishText):
|
|
self.Deleting = True
|
|
self.HideCursor()
|
|
self.DeleteNextChar(ChineseText, EnglishText)
|
|
|
|
def DeleteNextChar(self, ChineseText, EnglishText):
|
|
if len(self.DisplayingText) > 0:
|
|
self.DisplayingText = self.DisplayingText[:-1]
|
|
self.Canvas.itemconfig(self.ChineseTextID, text=self.DisplayingText)
|
|
EnglishDisplayLength: int = int(len(self.DisplayingText) * len(EnglishText) / len(ChineseText))
|
|
EnglishDisplay: str = EnglishText[:EnglishDisplayLength]
|
|
self.Canvas.itemconfig(self.EnglishTextID, text=EnglishDisplay)
|
|
self.UpdateCursorPositions()
|
|
self.Root.after(self.TypingSpeed // 2, lambda: self.DeleteNextChar(ChineseText, EnglishText))
|
|
else:
|
|
self.HideCursor()
|
|
self.CurrentLine += 1
|
|
self.Root.after(500, self.StartTypingEffect)
|
|
|
|
def HideCursor(self):
|
|
if self.CursorID: self.Canvas.itemconfig(self.CursorID, text="")
|
|
if self.ChineseCursorID: self.Canvas.itemconfig(self.ChineseCursorID, text="")
|
|
self.CursorVisible: bool = False
|
|
|
|
def ShowTerminationTexts(self):
|
|
self.Canvas.delete("all")
|
|
ScreenWidth: int = self.Root.winfo_screenwidth()
|
|
ScreenHeight: int = self.Root.winfo_screenheight()
|
|
self.TerminationIDs: list[int] = []
|
|
for i, text in enumerate(self.TerminationTexts):
|
|
FontSize: int = self.TerminationTitleSize if i == 0 else self.TerminationSubtitleSize
|
|
TextID: int = self.Canvas.create_text(
|
|
ScreenWidth // 2,
|
|
ScreenHeight // 2 - 60 + i * 70,
|
|
text = text,
|
|
font = ("ipix_12px", FontSize, "bold"),
|
|
fill = "red",
|
|
anchor = tkinter.CENTER
|
|
)
|
|
self.TerminationIDs.append(TextID)
|
|
self.FadeAlpha: int = 0
|
|
self.FadeIn()
|
|
|
|
def FadeIn(self):
|
|
if self.FadeAlpha < 255:
|
|
self.FadeAlpha += 5
|
|
if self.FadeAlpha > 255:
|
|
self.FadeAlpha: int = 255
|
|
for TextID in self.TerminationIDs:
|
|
self.Canvas.itemconfig(TextID, fill = "#%02x0000" % self.FadeAlpha)
|
|
self.Root.after(20, self.FadeIn)
|
|
else:
|
|
self.Root.after(3000, self.FadeOut)
|
|
|
|
def FadeOut(self):
|
|
if self.FadeAlpha > 0:
|
|
self.FadeAlpha -= 5
|
|
if self.FadeAlpha < 0:
|
|
self.FadeAlpha: int = 0
|
|
for text_id in self.TerminationIDs:
|
|
self.Canvas.itemconfig(text_id, fill = "#%02x0000" % self.FadeAlpha)
|
|
self.Root.after(50, self.FadeOut)
|
|
else:
|
|
self.Root.destroy()
|
|
|
|
def _Handle_Stop(self):
|
|
if self.Root.winfo_exists():
|
|
self.Root.withdraw()
|
|
self.Root.destroy()
|
|
|
|
|
|
|
|
|
|
# QrPhoto1 = base64.b64decode(UI_Hardcoded.QR)
|
|
# QrdataStream = io.BytesIO(QrPhoto1)
|
|
# pilImage = Image.open(QrdataStream)
|
|
# photo = pilImage.resize((110, 110))
|
|
|
|
|
|
class Thread_BlueScreen(T_Process.TProcess):
|
|
def Run(self, master: 'Termination4.Termination', AllowClose = True):
|
|
self.desc = "UI: Blue Screen"
|
|
self.Root = tkinter.Tk()
|
|
self.Root.attributes('-transparentcolor','#f0f0f0')
|
|
self.Root.title('Windows')
|
|
self.Root.overrideredirect(True)
|
|
self.Root.wm_attributes('-topmost', 1)
|
|
self.Root.state("zoomed")
|
|
if AllowClose:
|
|
self.Root.bind("<Key>", self.HandleKeyPress)
|
|
self.Root.bind("<Button-1>", lambda x: self._Handle_Stop())
|
|
else:
|
|
self.Root.protocol("WM_DELETE_WINDOW", lambda: None)
|
|
self.Canvas = tkinter.Canvas(self.Root, highlightthickness=0)
|
|
self.Canvas.pack(fill=tkinter.BOTH, expand=True)
|
|
self.SetupCanvas()
|
|
self.Root.update()
|
|
self.Root.mainloop()
|
|
def SetupCanvas(self):
|
|
self.Canvas.config(bg="#0078D7")
|
|
LeftPadding = self.Root.winfo_screenwidth() * 0.1
|
|
FaceX = LeftPadding + 200
|
|
FaceY = self.Root.winfo_screenheight() * 0.2
|
|
self.FaceSize = 110
|
|
|
|
self.Face1 = self.Canvas.create_text(
|
|
FaceX, FaceY, text=":",
|
|
font = ("微软雅黑", int(self.FaceSize)),
|
|
fill = 'white', anchor=tkinter.NW
|
|
)
|
|
self.Face2 = self.Canvas.create_text(
|
|
FaceX + 50, FaceY + 10, text="(",
|
|
font = ("微软雅黑", int(self.FaceSize)),
|
|
fill = 'white', anchor=tkinter.NW
|
|
)
|
|
|
|
BigTextX = FaceX
|
|
BigTextY = FaceY + self.FaceSize * 2
|
|
self.BigText = self.Canvas.create_text(
|
|
BigTextX, BigTextY, anchor=tkinter.NW,
|
|
font = ("微软雅黑", 25), fill='white',
|
|
width = self.Root.winfo_screenwidth() * 0.9
|
|
)
|
|
|
|
QrX = FaceX + self.FaceSize * 0.2
|
|
QrY = BigTextY + self.Root.winfo_screenheight() * 0.2
|
|
self.QrCode = self.Canvas.create_image(QrX, QrY, anchor = tkinter.NW) # , image=ImageTk.PhotoImage(photo)
|
|
|
|
smallTextX = QrX + 200
|
|
smallTextY = QrY
|
|
self.SmallText = self.Canvas.create_text(
|
|
smallTextX, smallTextY, anchor = tkinter.NW,
|
|
font = ("微软雅黑", 15), fill='white',
|
|
width = self.Root.winfo_screenwidth() * 0.5
|
|
)
|
|
self.DisplayInitialText()
|
|
def DisplayInitialText(self):
|
|
self.Canvas.itemconfig(self.BigText,
|
|
text ="你的电脑遇到问题，需要重新启动。\n我们只收集某些错误信息，然后为你重新启动。\n0%完成")
|
|
self.Canvas.itemconfig(self.SmallText,
|
|
text = "有关此问题的详细信息和可能的解决方法，请访问 http://windows/stopcode\n如果致电支持人员，请向他们提供一下信息\n终止代码：SYSTEM_SERVICE_EXCEPTION")
|
|
def DisplayAlternateText(self):
|
|
self.Canvas.itemconfig(self.BigText,
|
|
text = "你的电脑遇到问题，需要重新启动。\n我们不只收集某些错误信息，还有一些其它信息，然后可能会重新启动。\n0%完成")
|
|
self.Canvas.itemconfig(self.SmallText,
|
|
text = "有关此问题的详细信息和可能的解决方法，请访问 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n如果致电GVS人员，请向他们提供一下信息\n终止代码：TERMINATION_BLUE_EXCEPTION")
|
|
def HandleKeyPress(self, event):
|
|
if event.keycode == 27:
|
|
self.Root.destroy()
|
|
def ChangeToRedTheme(self):
|
|
self.Canvas.config(bg="#000")
|
|
self.Canvas.itemconfig(self.Face1, fill = "red", font = ("ipix_12px", int(self.FaceSize)))
|
|
self.Canvas.itemconfig(self.Face2, fill = "red", font = ("ipix_12px", int(self.FaceSize)))
|
|
self.Canvas.move(self.Face2, 30, 0)
|
|
self.Canvas.itemconfig(self.BigText, fill = "red", font = ("ipix_12px", 25))
|
|
self.Canvas.itemconfig(self.SmallText, fill = "red", font = ("ipix_12px", 15))
|
|
self.Canvas.itemconfig(self.QrCode, image = "")
|
|
self.Root.update()
|
|
def _Handle_Stop(self):
|
|
if self.Root.winfo_exists():
|
|
self.Root.withdraw()
|
|
self.Root.destroy()
|
|
|
|
|
|
class Thread_HAHA(T_Process.TProcess):
|
|
def Run(self, master: 'Termination4.Termination', fontPath: str, soundPath: str):
|
|
self.desc = "UI: HAHA"
|
|
T_Tools.HideCursor()
|
|
ctypes.windll.user32.BlockInput(True)
|
|
self.FontPath = fontPath
|
|
self.SoundPath = soundPath
|
|
self.ProgressPercentage = 1
|
|
self.YPosition = 0
|
|
self.LineIndex = 0
|
|
|
|
T_Tools.InstallFont(self.FontPath)
|
|
|
|
self.Root = tkinter.Tk()
|
|
self.Root.attributes('-transparentcolor','#f0f0f0')
|
|
self.Root.title('Windows')
|
|
self.Root.overrideredirect(True)
|
|
self.Root.wm_attributes('-topmost', 1)
|
|
self.Root.state("zoomed")
|
|
self.Root.bind("<Key>", self.HandleKeyPress)
|
|
self.Root.protocol("WM_DELETE_WINDOW", lambda: None)
|
|
|
|
self.Sentences = UI_Hardcoded.Sentence
|
|
|
|
self.Root.update()
|
|
self.Root.after(1, self.Animation1)
|
|
self.Root.mainloop()
|
|
|
|
def SetupCanvas(self):
|
|
self.Canvas.config(bg = "#0078D7")
|
|
LeftPadding = self.Root.winfo_screenwidth() * 0.1
|
|
FaceX = LeftPadding + 200
|
|
FaceY = self.Root.winfo_screenheight() * 0.2
|
|
self.FaceSize = 110
|
|
|
|
self.Face1 = self.Canvas.create_text(
|
|
FaceX, FaceY, text=":",
|
|
font = ("微软雅黑", int(self.FaceSize)),
|
|
fill = 'white', anchor = tkinter.NW
|
|
)
|
|
self.Face2 = self.Canvas.create_text(
|
|
FaceX + 50, FaceY + 10, text="(",
|
|
font = ("微软雅黑", int(self.FaceSize)),
|
|
fill = 'white', anchor = tkinter.NW
|
|
)
|
|
|
|
BigTextX = FaceX
|
|
BigTextY = FaceY + self.FaceSize * 2
|
|
self.BigText = self.Canvas.create_text(
|
|
BigTextX, BigTextY, anchor = tkinter.NW,
|
|
font = ("微软雅黑", 25), fill = 'white',
|
|
width = self.Root.winfo_screenwidth() * 0.9
|
|
)
|
|
# 创建QR码
|
|
QrX = FaceX + self.FaceSize * 0.2
|
|
QrY = BigTextY + self.Root.winfo_screenheight() * 0.2
|
|
self.QrCode = self.Canvas.create_image(QrX, QrY, anchor = tkinter.NW)
|
|
# 创建小段文字
|
|
smallTextX = QrX + 200
|
|
smallTextY = QrY
|
|
self.SmallText = self.Canvas.create_text(
|
|
smallTextX, smallTextY, anchor = tkinter.NW,
|
|
font = ("微软雅黑", 15), fill = 'white',
|
|
width = self.Root.winfo_screenwidth() * 0.5
|
|
)
|
|
self.DisplayInitialText()
|
|
def DisplayInitialText(self):
|
|
self.Canvas.itemconfig(self.BigText,
|
|
text = "你的电脑遇到问题，需要重新启动。\n我们只收集某些错误信息，然后为你重新启动。\n0%完成")
|
|
self.Canvas.itemconfig(self.SmallText,
|
|
text = "有关此问题的详细信息和可能的解决方法，请访问 http://windows/stopcode\n如果致电支持人员，请向他们提供一下信息\n终止代码：SYSTEM_SERVICE_EXCEPTION")
|
|
def DisplayAlternateText(self):
|
|
self.Canvas.itemconfig(self.BigText,
|
|
text = "你的电脑遇到问题，需要重新启动。\n我们不只收集某些错误信息，还有一些其它信息，然后可能会重新启动。\n0%完成")
|
|
self.Canvas.itemconfig(self.SmallText,
|
|
text = "有关此问题的详细信息和可能的解决方法，请访问 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n如果致电GVS人员，请向他们提供一下信息\n终止代码：TERMINATION_BLUE_EXCEPTION")
|
|
def HandleKeyPress(self, event):
|
|
if event.keycode == 27:
|
|
self.Root.destroy()
|
|
def ChangeToRedTheme(self):
|
|
self.Canvas.config(bg="#000")
|
|
self.Canvas.itemconfig(self.Face1, fill = "red", font=("ipix_12px", int(self.FaceSize)))
|
|
self.Canvas.itemconfig(self.Face2, fill = "red", font=("ipix_12px", int(self.FaceSize)))
|
|
self.Canvas.move(self.Face2, 30, 0)
|
|
self.Canvas.itemconfig(self.BigText, fill = "red", font=("ipix_12px", 25))
|
|
self.Canvas.itemconfig(self.SmallText, fill = "red", font=("ipix_12px", 15))
|
|
self.Canvas.itemconfig(self.QrCode, image="")
|
|
self.Root.update()
|
|
def ShowTextAnimation(self):
|
|
if self.LineIndex < 2 or self.LineIndex > 30: text = "HA " * 50
|
|
else: text = "".join(random.choice(self.Sentences) for _ in range(5))
|
|
self.Canvas.create_text(
|
|
10, self.YPosition, text = text,
|
|
fill = "red", font=("ipix_12px", 30),
|
|
anchor = tkinter.NW
|
|
)
|
|
self.YPosition += 30
|
|
self.LineIndex += 1
|
|
if self.LineIndex > self.Canvas.winfo_height() // 15:
|
|
self.Canvas.delete("all")
|
|
self.SetupCanvas()
|
|
self.ChangeToRedTheme()
|
|
self.YPosition = 0
|
|
self.LineIndex = 0
|
|
self.Canvas.update()
|
|
self.Root.update()
|
|
self.Root.after(1, self.ShowTextAnimation)
|
|
def Animation3(self):
|
|
self.ChangeToRedTheme()
|
|
self.Root.after(3500, self.ShowTextAnimation)
|
|
self.Root.after(3500+16500, self._Handle_Stop)
|
|
threading.Thread(target=lambda: playsound.playsound(self.SoundPath)).start()
|
|
|
|
def DrawLine(self, x1, y1, x2, y2, color):
|
|
self.Canvas.create_line(x1, y1, x2, y2, fill =color)
|
|
def Animation2(self):
|
|
self.Canvas = tkinter.Canvas(self.Root, highlightthickness=0)
|
|
self.Canvas.pack(fill = tkinter.BOTH, expand = True)
|
|
sw=self.Root.winfo_screenwidth()
|
|
self.SetLines(sw)
|
|
self.Root.update()
|
|
time.sleep(3)
|
|
self.Root.attributes('-transparentcolor','#f0f0f0')
|
|
self.Canvas.delete("all")
|
|
self.SetupCanvas()
|
|
self.Root.after(5000, self.Animation3)
|
|
|
|
def SetLines(self, sw):
|
|
for y in range(0, random.randint(300,400)):
|
|
color = f"#{random.randint(0, 0xFFFFFF):06x}"
|
|
self.DrawLine(y, 1, y, sw, color)
|
|
for y in range(random.randint(500,600), 600):
|
|
color = f"#{random.randint(0, 0xFFFFFF):06x}"
|
|
self.DrawLine(y, 1, y, sw, color)
|
|
for y in range(800, 1000):
|
|
color = f"#{random.randint(0, 0xFFFFFF):06x}"
|
|
self.DrawLine(y, 1, y, sw, color)
|
|
for y in range(1200, 1500):
|
|
color = f"#{random.randint(0, 0xFFFFFF):06x}"
|
|
self.DrawLine(y, 1, y, sw, color)
|
|
for y in range(2000, 3000):
|
|
color = f"#{random.randint(0, 0xFFFFFF):06x}"
|
|
self.DrawLine(y, 1, y, sw, color)
|
|
for y in range(3500, 4000):
|
|
color = f"#{random.randint(0, 0xFFFFFF):06x}"
|
|
self.DrawLine(y, 1, y, sw, color)
|
|
for y in range(4200, 10000):
|
|
color = f"#{random.randint(0, 0xFFFFFF):06x}"
|
|
self.DrawLine(y, 1, y, sw, color)
|
|
|
|
def Text(self, text, fg="#FFF", bg="#000"):
|
|
tkinter.Label(self.A1Frame, text = text,fg = fg,bg = bg,font = ("ipix_12px",15)).pack(anchor = "sw")
|
|
def FText(self):
|
|
tkinter.Label(self.A1Frame, text = "").pack(anchor = "sw")
|
|
|
|
def Animation1(self):
|
|
self.A1Frame = tkinter.Frame(self.Root, bd=0)
|
|
self.A1Frame.pack(fill = tkinter.BOTH, expand = True)
|
|
self.Root.update()
|
|
self.Text("Please contact the Voodoo Kernel Dev-Team with a photo of the Information printed below,")
|
|
self.Text("Along With a description of your system configuration and what you were doing at the time that")
|
|
self.Text("the kernel panic occurred. We appologize for the lnconvenience")
|
|
self.FText()
|
|
self.Root.update()
|
|
time.sleep(1)
|
|
self.Text('Panic(CPU 0 Caller 0x001AC05E): "Windows Teacher Error"')
|
|
self.Text("Debugger Called: <Panic>")
|
|
self.Text("Backtrace (CPU 0),Frame : Return Address (4 potential ponies on stack)")
|
|
self.Root.update()
|
|
time.sleep(0.2)
|
|
self.Text("0x14e1ffce68 : 0x12b08c (0xfffffffff 0xfffffffff 0xfffffffff)")
|
|
self.Text("0x14e1ffce69 : 0x12b07c (0xfffffffff 0xfffffffff 0xfffffffff)")
|
|
self.Text("0x14e1ffce70 : 0x12b05c (0xfffffffff 0xfffffffff 0xfffffffff)")
|
|
self.Text("0x14e1ffce23 : 0x12b0cc (0xfffffffff 0xfffffffff 0xfffffffff)")
|
|
self.Text("0x14e1ffcf35 : 0x12b0fc (0xfffffffff 0xfffffffff 0xfffffffff)")
|
|
self.Text("0x14e1ffcf90 : 0x12b0ac (0xfffffffff 0xfffffffff 0xfffffffff)")
|
|
self.Root.update()
|
|
time.sleep(0.2)
|
|
self.Text("Backtrace terminated-invalid frame pointer 0")
|
|
self.FText()
|
|
self.Text("BSD process name corresponding to current thread: Unknown")
|
|
self.FText()
|
|
self.Root.update()
|
|
time.sleep(1)
|
|
self.Text("Windows version:")
|
|
self.Text("Win 32/Run")
|
|
self.FText()
|
|
self.Text("Kernel version:")
|
|
self.Text("Win32 Kernel V3.2.5 / EFI Boot System V7")
|
|
self.FText()
|
|
self.Root.update()
|
|
time.sleep(1)
|
|
self.Text("Try automatic repair...")
|
|
self.Root.update()
|
|
time.sleep(1)
|
|
self.Text("0x14e1ffce61 : 0x12b08c (0xfffffffff 0xfffffffff 0xfffffffff)")
|
|
self.Text("0x14e1ffce62 : 0x12b07c (0xfffffffff 0xfffffffff 0xfffffffff)")
|
|
self.FText()
|
|
self.Root.update()
|
|
time.sleep(1)
|
|
self.Text("WARNING", "yellow", "red")
|
|
self.Text("We now advise you to understand that by stopping the operation of your computer,", "yellow", "red")
|
|
self.Text("your computer is suspected to be infected with a virus that modifies the BIOS,", "yellow", "red")
|
|
self.Text("as we have an error while verifying the BIOS file, therefore,", "yellow", "red")
|
|
self.Text("please shut down this computer immediately, otherwise,", "yellow", "red")
|
|
self.Text("the manufacturer should not be responsible for any consequences", "yellow", "red")
|
|
self.Root.update()
|
|
time.sleep(3)
|
|
self.A1Frame.destroy()
|
|
self.Root.after(1, self.Animation2)
|
|
|
|
def _Handle_Stop(self):
|
|
if self.Root.winfo_exists():
|
|
self.Root.withdraw()
|
|
self.Root.destroy()
|
|
T_Tools.ShowCursor()
|
|
win32api.ShowCursor(True)
|