CN113608645A - Innovative technology for switching full-screen or window display and default full-screen browser at blank position of webpage by double-clicking of mouse - Google Patents

Abstract

The mouse double-click webpage blank switching full-screen or window display and default full-screen browser innovation technology the traditional browser has hundreds of functions, consumes a large amount of hardware resources, and has three major disadvantages: 1. the non-default full screen display is carried out, and the full screen is inconvenient to switch by pressing an F11 key; 2. lack of intelligent footprint functionality; 3. windows platforms have advertising concerns; therefore, on Linux, a Python 3.7 language, PyQt5 and QtWebEngine are adopted, a Linux direct Win default full-screen browser is invented, all webpages are displayed in a full screen by default, a main menu and function buttons are omitted, and a right-click menu is reserved; adopting Esc or blank space or left mouse button to double click the blank of the web page or right click the left upper corner to switch the full screen and window display at will, pressing the minus sign or closing the menu can close the web page, the time for the second opening is about 0.1 second; the intelligent track has the functions of intelligent footprint, audio and video playing, downloading, direct access to Win hard disk files and removal of Windows pop-up window advertisements; integrating screenshots, print pictures, network volume, and print settings.

Description

Innovative technology for switching full-screen or window display and default full-screen browser at blank position of webpage by double-clicking of mouse

Technical Field

The technical field of browser software.

Background

In 1994, the first browser in the world was launched by netscape corporation, 27 years ago. Traditional professional browsers have: google, 360, fire fox, IE, Edge, QQ and search for the dog etc. their is multiple functional, consume a large amount of hardware resources, possess nearly hundred kinds of functions, cover: basic operation of webpage, system setting, plug-in and security setting, wherein: plug-ins and security settings are rarely used, whereas system settings are used occasionally, with the common functions being: the mouse wheel moves up and down to browse the web page, clicks a hyperlink to open a new web page, advances, retreats, refreshes, saves pictures and other basic operations. The traditional browser has three disadvantages except fussy functions and low speed: 1. the webpage is displayed in a non-default full screen mode, full screen display is required to be switched according to an uncommon F11 function key, and the method is inconvenient and not popular; 2. the intelligent footprint function is lacked, and the historical footprint is in a third-level menu, so that the operation is inconvenient; 3. windows version of the browser often has popup advertisements, a large amount of E-commerce advertisement interference is encountered after long-term use of Windows (figures 1 and 2), most of the popup advertisements cannot be closed, and a user presses a closing button to forcibly install rogue software. Therefore, aiming at quiet internet access, common public fast internet access requirements and full screen visual enjoyment, the invention of the intelligent extremely-fast default full screen browser of the non-Windows version, which is free of popup advertisements, simple in interface, fast in browsing and directly communicated with a Windows hard disk, is urgently needed.

The language in which the browser was developed gradually shifted from the original C/C + + to Python, because Python has the most voluminous third party ecosphere. The PyQt developer is Riverbank Computing, Inc. of UK, who uses the Qt graphical interface development module of Digia, Finland. PyQt is the product of the combination of Qt and Python, and is a wrapper that exploits the Qt's functionality to Python. PyQt5 is version 5.x, consisting of three major software modules: PyQt5-sip, PyQt5 and PyQt5-tools, PyQt5-sip is a tool for generating C + + interface codes by Python, and can realize automatic conversion between standard Python and C/C + + data types; PyQt5 provides Python modules supporting various classes of Qt5, and the modules are placed in a Lib \ site-packages \ PyQt5 directory under a Python directory; PyQt5-tools provides a UI interface design. Qt is a cross-platform C + + graphical interface program framework; qt5 is version 5 of Qt. Qt is divided into eight modules: 1. the QtCore module contains core non-GUI functions; 2. the QtGui module contains the graphic components and the associated classes; 3. the QtNetwork module contains a class of network programming; 4. QtXml contains classes that use XML files; 5. the QtSvg module provides scalable vector graphics; 6. the QtOpenGL module renders 3D and 2D graphics using an OpenGL library; the QtSql module provides a class of a database interface; 8. the QtWebEngine module provides a simple Web browser kernel that can more easily embed Web content into Qt applications. The Qt WebEngine architecture is shown in figure 3.

The functionality of Qt WebEngine is divided into the following modules:

qt WebEngine Widgets module (see fig. 4): for creating a Widget-based web application.

Qt WebEngine Module: for creating a Qt Quick-based web application.

Qt WebEngine Core Module: interact with the chromosome kernel.

Remarking: the Qt WebEngine Core is based on Chrome but has no other services or plug-ins that contain or use any Chrome browser, and can look at the Chrome project source code library for the difference between Chrome and Chrome. The Qt WebEngine Process is a separate executable program for rendering web pages and executing JavaScript, which alleviates security issues and isolates crashes caused by particular content. A QWebEngineView instance has a QWebEnginePage, each of which belongs to a QWebEngineProfile having a Page settings QWebEngineSettings. The application may load the page to WebEngineView using the URL and HTML strings. QtWebEngine integrates the Web functionality of Chromium into Qt, the latest version of which is based on Chromium 73.

Disclosure of Invention

The inventor selects a Linux operating system (based on popular CentOS 7.7 version) consistent with 99% of supercomputers, and invents an intelligent extremely-high-speed Linux default full-screen browser (default full-screen browser for short) directly connected with a Windows hard disk by adopting the most popular third-party development kit of Python 3.7 version language, PyQt5 and PyQtWebEngine. The default full screen browser is characterized in that: the method has the advantages of program refining, high speed, concise interface, no popup advertisement, high intelligence, direct connection to a Windows hard disk, full screen display of all webpages as defaults, time consumption of about 0.1 second when the webpages are opened for the second time, and lag of 1-2 seconds when the large pictures are updated. The default full-screen browser can display all web pages (fig. 5 and 6) in full screen by default, and the browser enters full screen time without adding parameters to start the full screen or pressing an F11 key to enter the full screen; the default full screen browser omits the main menu and function buttons (fig. 7), and only retains the mouse right click menu (fig. 8 and 9); the famous navigation page hao123.com is taken as a home page, all commonly used websites and hundred-degree search are provided, and website input is reduced as much as possible for netizens.

For the sake of safety, the W3C world Wide Web alliance stipulates that the web page itself can not self-define the keyboard processing function, therefore, the invention defaults that the web page father window automatically captures the keyboard input and enters the 'full screen switchable mode', then self-defines the keyboard processing function, and satisfies the following three-key switching function, and the full screen or window display can be switched freely by pressing the Esc key, the blank space or the Alt key.

The default full-screen browser also supports the switching of full-screen or window display at any blank position of a left mouse button double-click page in order to meet the mouse control operation habit, is limited by the international standard of a browser kernel at present, needs to be switched from a tab window, and can not limit the tab window to start double-click switching after the international standard is modified. The invention also supports the mouse to right click on the 60x160 pixel area at the upper left corner of the webpage to switch full-screen or window display, and the technology can be expanded to right click on the four corners of the webpage to switch full-screen or window display.

The reserved window display has two purposes of 1, inputting a website to browse a webpage and 2, switching different tab pages to browse. The page can be closed by pressing the function of closing the small keyboard minus or the mouse right click menu. The default method for the full-screen browser to enable the webpage parent window to exit from the keyboard capture state (full-screen switchable mode) is as follows: double-clicking a space or inputting non-space non-reduced ASCII printed characters, such as: inputting k characters in the text box can enable the webpage parent window to exit from keyboard capture and enter a default normal keyboard processing program, and display the characters in the text box, and seamlessly interface the text box for inputting so as to meet the operation requirements of normal input of the text box and other independent software; upon exiting the custom keyboard capture state, the text box may enter any characters including a space and a minus sign; clicking any web page hyperlink or right clicking a pop-up menu by a mouse or closing a non-final page can enable the web page parent window to recapture the keyboard to enter a full-screen switchable mode, and the requirement of full-screen or window switching display is met.

The full-screen browser is defaulted to adopt an intelligent footprint function instead of a webpage browsing forward and backward, so that the problem that the conventional browser cannot span tabs when moving forward and backward is solved, the search blindness is reduced, and the operation efficiency is improved; the "intelligent footprint" stores four elements of each browsed website: page icons, web addresses, short titles and long titles, wherein the long titles are used as prompts; the intelligent footprint adopts a menu type window to be displayed at the middle of the top, has high sensitivity, can prevent cervical spondylosis, automatically positions a cursor at the first row, saves time, and can automatically display menu items hovered by a mouse by using a dark highlight background; the newly browsed network addresses are reserved at most, the network addresses are displayed in three rows at most according to the time reverse order, the self-metabolism function is realized, redundant old network addresses are automatically deleted, and the newly browsed network addresses are placed at the forefront, so that the network addresses are conveniently opened again; the 'browsing history' or 'browsing footprint' function of the traditional browser is placed in a third-level menu, so that the operation is inconvenient, the 'intelligent footprint' function is promoted to a first-level menu, a 'tree view window' is changed into a highly sensitive 'menu window', and the user internet surfing experience is improved.

The default full-screen browser can play audio and video, support downloading and directly access Windows hard disk files, but does not support the unusual functions requiring certificates, such as: the internet bank transfer (being replaced by mobile phone code scanning payment) aims to preferentially improve the running speed and meet the requirement of the public on surfing the internet quickly. The default full screen browser keeps the multi-page tab window interface (FIG. 7) and displays in a maximized window; the window interface consists of only five parts from top to bottom: a main window title (browser name), a ladder-shaped multiple tab header, an address bar, a web page display window, and a status bar. The default of the webpage characters is that the minimum characters are displayed as four-number characters, and the character size cannot be zoomed. The right click menu of the mouse is a custom common Chinese menu, and the function which is not common is omitted. The main menu function of right-clicking any blank of the webpage is as follows: close, smart bookmark, smart footprint, bookmark collection, refresh, clock, toolbox menu, and direct Win default full screen browser (fig. 8). The tool box menu has the functions of: smart screenshots, print pictures, printer settings, and network volume settings (see fig. 9).

The default full-screen browser is based on a Linux operating system, the Linux hard disk is in the ext3 format by default, most of users' Windows hard disks are in the ftns format, the Linux system needs to be set to support the ftns hard disk format (command: yum install ntfs), so that the Linux can identify the ftns hard disk (see fig. 10), the Windows browser effect can be achieved, the browsing speed is higher, the trouble of Windows platform popup window advertisement can be avoided, and the Linux operating system is very pure and does not have any rogue software penetration. A single solid state disk is adopted to pre-install a Linux operating system and direct Win default full-screen browser software (see figure 11).

The best mode of the invention is that the W3C world Wide Web alliance revises the international standard of the browser kernel, and referring to the specific implementation mode [0005] of the invention, adopts the default full screen to display all the web pages, double-clicks the left key of the mouse to double-click the blank of the web page or press the space key to switch the full screen or window display, double-clicks the space to exit the 'full screen switchable mode' to facilitate the text box input or operate other software, clicks any hyperlink or right-clicks the pop-up menu of the mouse or closes the non-last page to re-enter the 'full screen switchable mode', proposes to adopt the first item 'close' of the reduced number or right-clicking menu of the keypad to close the web page, and the first item 'open the website on the new page' of the intelligent footprint and website right-clicking menu is also a choice worth considering in W3C.

Drawings

FIG. 1 one of the pop-up advertisements

Figure 2. popup advertisement two

FIG. 3. QtWebEingine architecture

FIG. 4. QtWebEngine Widgets Module

FIG. 5 is a diagram of a default full-screen browsing interface

FIG. 6 is a diagram of a default full-screen browsing interface

FIG. 7 is a diagram of a multi-tab browser window

FIG. 8, right click main menu

FIG. 9, Right click Menu and two level submenus Toolbox "

FIG. 10 shows Linux default full screen browser opening the E-mail box to send the E-mail to add the files of Windows hard disk to the attachment

FIG. 11 is a single solid state disk with a Linux operating system and a Win default full-screen browser software installed in advance.

Detailed Description

The development platform of the invention is a Linux version Pycharm community 2019.3; by adopting Python 3.7 version language, PyQt5 and PyQtWebEngine development kit, the default full-screen browser only 819 lines of codes is very refined, has high speed and simple interface, directly leads to a Win hard disk and default full-screen display webpage, and avoids the trouble of pop-up window advertisement of a Windows platform.

5.1 Default full Screen browser program framework

import ...

Third party development kit for importing data # into

err_msg = ['']

# error information storage variable

valid_day= ['win',20240719,'2024-07-19','4','']

Identification parameters of software version and expiration date

last_key = [0,0]

# records the latest key value and time (seconds since 1970)

download_item_ls = []

# store download task array variable

webview_group = []

# store Web instance array variables

webview_parent_group = []

# store Web Page parent instance array variables

class myQMenu(QMenu):

......

# rewrite QMenu Menu class

class WebView(QWebEngineView):

......

# rewrite Web Page shows QWebEngineView class

class myQLineEdit(QLineEdit):

......

Class # rewrite QLineEdit

class DownloadWidget(QProgressBar):

......

# download DownloadWidget class by definition, inherit QProgensBar class

class BookmarkWidget(myQMenu ):

......

# custom bookmark class, inherit myQMenu class

class Browser(QMainWindow):

......

Self-defining Browser class, # calling web page to display WebView class, inheriting QMainWindow class

class MyBrowser(QMainWindow):

......

Self-defining MyBrowser class, # calling the Browser class, inheriting the QMainWindow class

if __name__ == "__main__":

......

# Main program

5.2 Python program compilation for Default full-screen browser

Under Terminal of pychar development platform, the following commands are run to perform compilation:

/usr/local/python3/bin/pyinstaller --clean -Dw --noconsole --noconfirm –i

/ img/ lanyue2.png lanDefaultWeb.py

note: py is lan defaultweb, img/lanyue2.png is a program icon.

5.3 Main code of Default full Screen browser software

The # Default full Screen browser software's main Python source code, starting with # is the comment line, and/starting with the discount character

Three key software innovation function related codes of # default full screen browser are displayed in bold

import sys,json,os,datetime,warnings,base64

from subprocess import Popen

from PyQt5.QtCore import QUrl, Qt, QCoreApplication, pyqtSignal, QDir,

/ QFileInfo, QStandardPaths

from PyQt5.QtWidgets import QApplication, QMainWindow, QLineEdit, QToolBar,

/ QTabWidget, QWidget, QDialog,QPushButton, QProgressBar, QMenu, QLabel,

/ QMessageBox,QAction, QVBoxLayout

from PyQt5.QtGui import QIcon,QDesktopServices,QCursor, QStandardItemModel,QStandardItem

from PyQt5.QtWebEngineWidgets import QWebEngineView,

/ QWebEngineSettings, QWebEngineDownloadItem,QWebEnginePage, QWebEngineScript

from pynput.keyboard import Key, Controller as Keyboard

from pynput.mouse import Button, Controller as Mouse

import http.client,time

Third party development kit for importing data # into

err_msg = ['']

# error information storage variable

valid_day= ['win',20240719,'2024-07-19','4','']

Identification parameters of software version and expiration date

last_key = [0,0]

# store the latest entered key and the number of seconds since 1970

download_item_ls = []

# store download task array variable

webview_group = []

# store Web instance array variables

webview_parent_group = []

# store Web Page parent instance array variables

class myQMenu(QMenu):

Rewriting QMenu menu class # saves non-invention related codes and saves space

……

class WebView(QWebEngineView):

# rewrite Web Page shows QWebEngineView class

@staticmethod

def minimum_zoom_factor():

# method of defining minimum parameter for Window scaling

return 0.25

@staticmethod

def maximum_zoom_factor():

return 5

def __init__(self, mainWin):

super().__init__(mainWin)

self.mainWin = mainWin

def createWindow(self, QWebEnginePage_WebWindowType):

Method for creating webpage window

new_webview = WebView(self.mainWin)

# recursive Call this class

self.mainWin.create_tab(new_webview)

# Create New Page Label

return new_webview

class myQLineEdit(QLineEdit):

The class QLineEdit of the rewriting text editing line realizes double-click clearing and roller restoring, and omits the relevant codes not in the invention

……

class DownloadWidget(QProgressBar):

Self-defined file downloading class, self-integration, popular and easy understanding, omission of relevant codes not in the invention and saving space

……

_default_bookmarks = [

[ 'my bookmark' ],

[ 'http:// www.lanyue.mobi/', 'visit month', 'img/lanyue2.png' ],

[ 'a browsing footprint' ],

]

# Default bookmark

class BookmarkWidget(myQMenu):

The bookmark class is rewritten, the myQMenu class is inherited, the relevant codes which are not the invention are omitted, and the space is saved

……

class Browser(QMainWindow):

The # self-defined Browser class inherits the QMAinWindow class, omits the relevant codes which are not the invention, saves space

def __init__(self, mainWin, webview=None):

super().__init__(mainWin)

self.mainWin,self.webview,self.part = mainWin, webview, ''

Main win, self webview, self part stores the parent instance of full screen play video

self.initUI()

Method for calling initialization interface

def initUI(self):

Method for initializing interface

if self.webview == None:

# is the first page

self.webview = WebView(self)

# tone WebView class instantiation

self.webview.load(QUrl("http://www.hao123.com/"))

# load the Web Page on the navigation Page http:// www.hao123.com

elif self.webview == '':self.webview = WebView(self)

# create blank New Page Label

self.webview.setZoomFactor(1.35)

# enlarge the display font size of the web page by 35%

self.webview.page().titleChanged.connect(self._title_changed)

# associating a Web Page title Change Signal to _ title _ changed method

self.webview.page().iconChanged.connect(self._icon_changed)

# method of associating a Page icon Change Signal to _ icon _ changed

self.initToolbar(self.webview)

Invocation initToolbar method

self.setCentralWidget(self.webview)

# to locate an instance of a Web page in the center of a tab window

self.webview.setContextMenuPolicy(Qt.CustomContextMenu)

# setting Web Page to custom Right-click context Menu

self.webview.customContextMenuRequested.connect(self.context_webmenu_event)

# request association method context _ webmenu _ event for setting webpage custom right-click text menu

webview_group.append(self.webview)

# adding the Web instance to the Web instance array variable

webview_parent_group.append(self.webview.parent())

# adding the parent instance of the Web Page to the array variable of the parent instance of the Web Page

if self.mainWin.INDEX==0:

If it is the first tab, execute the following code, default to full screen display and enter full screen switchable mode

self.webview.setParent(None)

# setting the parent instance of the present Web Page to None

self.webview.showFullScreen()

# maximize display of an instance of the present Page

webview_parent_group[0].grabKeyboard()

# setting the parent instance of the home page as the capture keyboard to enter the full-screen switchable mode

def common_actions(self,context_menu,refresh_action,close_action):

The public calling method of the # webpage right-click menu omits the relevant codes which are not the invention, saves space

……

def context_webmenu_event(self, point):

Method for processing # webpage right click menu

if point.x()<=60 and point.y()<=160:

The 60x160 pixel area at the upper left corner of the # mouse right click webpage can be switched to full-screen or window display at will

if not webview_group[self.mainWin.INDEX].isFullScreen():

If not, switching to full-screen display

webview_group[self.mainWin.INDEX].setParent(None)

webview_group[self.mainWin.INDEX].showFullScreen()

else, if the # is full screen display, switching to the tab window for normal display

for i in range(0,len(webview_group)):

webview_group[i].showNormal()

webview_parent_group[i].setCentralWidget(webview_group[i])

elif self.webview == self.sender():

webview_parent_group[self.mainWin.INDEX].grabKeyboard()

Let the current window capture the keyboard and enter the full screen switchable mode

linkUrl = self.webview.page().contextMenuData().linkUrl().toString()

Url for # obtaining web page

editable= self.webview.page().contextMenuData().isContentEditable()

# get edit status of Web Page

mediaType = self.webview.page().contextMenuData().mediaType()

Type of # get control

context_menu = QMenu()

# construct mouse Right click Menu

close _ action = context _ menu.addaction (QIcon ('img/close.jpg'), "close")

context_menu.addAction(QAction(QIcon('img/bookmark_toolbar.jpg')

V. "smart bookmark", self, trigger = self. mainwin. toolbar _ bookmarks))

context_menu.addAction(QAction(QIcon('img/view_history.jpg'),"

Smart footprint ", self, triggered = self

context_menu.addAction(QAction(QIcon('img/bookmark_save_

Jpg'), "favorite bookmark", self, triggered = self

refresh _ action = context _ menu.addaction (QIcon ('img/refresh.jpg'), "refresh")

current_item = self.webview.url().toString()

refresh_action.setEnabled(current_item != 'about:blank')

if mediaType ==1:

If the control of right click is the picture, the following codes are executed, the codes which are not related to the invention are omitted, and the space is saved

……

elif self.webview.page().hasSelection() and not editable:

If the control of right-click is selected, the following codes are executed, the codes which are not related to the invention are omitted, and the space is saved

……

elif linkUrl=='' and not editable:

If the right click is blank, the following codes are executed, the codes which are not related to the invention are omitted, and the space is saved

……

elif not editable:

If # is right-clicked, non-blank and non-editing area, such as: hyperlink, then execute the following code

self.common_actions(context_menu, refresh_action, close_action)

elif editable:

If right-clicking on the text editing area, executing the following codes, omitting the codes which are not related to the invention, and saving space

……

def keyPressEvent(self, QKeyEvent):

# custom keyboard handler, full screen switchable mode entry and exit

key = QKeyEvent.key()

# get Key

now1 = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

time1 = datetime.datetime.strptime(now1, "%Y-%m-%d %H:%M:%S")

secondsFrom1970 = time.mktime(time1.timetuple())

# obtains the time to press the key (seconds since 1970), and counts double-click spaces by clicking the spaces within 1 second

if key == Qt.Key_Escape or (key == Qt.Key_Space and (last_key[0] !=32 or

/ (last_key[0] ==32 and secondsFrom1970-last_key[1]>1)))

/ or QKeyEvent.modifiers() == Qt.AltModifier:

If Esc or space or Alt key is pressed and space is not double-clicked, the mode is full screen switchable, and the following codes are executed

if not webview_group[self.mainWin.INDEX].isFullScreen():

If not, switching to full-screen display

webview_group[self.mainWin.INDEX].setParent(None)

webview_group[self.mainWin.INDEX].showFullScreen()

else, if the # is full screen display, switching to tab window display

for i in range(0,len(webview_group)):

webview_group[i].showNormal()

webview_parent_group[i].setCentralWidget(webview_group[i])

elif key == Qt.Key_Shift and webview_group[self.mainWin.INDEX].isFullScreen():

If the shift key is pressed and the whole screen display is performed, displaying a dog searching assistant toolbar on the lower part of the page, juxtaposing the top,

# satisfies the normal display of the input box of the dog search, omits the relevant codes not of the invention, saves space

……

elif key == Qt.Key_Minus:self.mainWin.close_Tab(self.mainWin.INDEX)

If the minus sign is pressed, the close _ Tab method is called to close the Tab window

else, # other Key, executing the following code

self.release_keyboard()

# Release keyboard Capture for Web parent Window, resume default keyboard handler

keyboard = Controller()

if key == Qt.Key_Backspace:

The # inverted lattice key is replaced by a left cursor key and a delete key, and the system does not allow the analog input of the inverted lattice key

self.key_common(keyboard, Key.left)

self.key_common(keyboard, Key.delete)

elif key>32 and key<=126 and key !=45:

The # input can print ASCII key except space and minus number, and then the input is simulated once again, thus avoiding repeated input of user

if key > = 65 and key < = 90: key + = 32 # upper-case letters input by website column are converted into lower-case letters

self.key_common(keyboard,chr(key))

last_key[0],last_key[1]=key,secondsFrom1970

# in last _ key array variable, time to hold the latest key and key (seconds since 1970)

def key_common(self,keyboard,key):

# keys of analog input keyboard

keyboard.press(key)

keyboard.release(key)

def release_keyboard(self):

Method for releasing all keyboards in # webpage parent window

for i in range(0, len(webview_parent_group)):

webview_parent_group[i].releaseKeyboard()

def _icon_changed(self, icon):

The processing method for # webpage icon change omits the non-related codes of the invention, saves space

……

def _title_changed(self, title):

The processing method for changing the title of the # webpage omits the relevant codes which are not the invention, saves space

……

def update_bookmarks(self):

Item (0, 0) update bookmark variable, omit the relevant code of the invention, save the space

……

def initToolbar(self, webview):

# initialize Main Window toolbar

self.mainWin.urlbar.returnPressed.connect(self.navigate_to_url)

self.mainWin.urlbar.setContextMenuPolicy(Qt.CustomContextMenu)

self.mainWin.urlbar.customContextMenuRequested.connect(self.context_address_event)

# Right click on Website field, call context _ address _ event method, pop-up menu

if self.mainWin.INDEX==0:

# first Page, bookmark variable to be updated

self.update_bookmarks()

self.mainWin.bookmark_widget.changed.connect(self.update_bookmarks)

webview.urlChanged.connect(self.renew_urlbar)

webview.settings().setAttribute(QWebEngineSettings.FullScreenSupportEnabled, True)

# setting page supports full-screen playing video

webview.page().fullScreenRequested.connect(self._fullScreenRequested)

# sets the full-screen video playback signal associated with _ fullscreenrequest so as not to be confused with full-screen display of a web page

webview.page().profile().downloadRequested.connect(self._download_requested_action)

Method for setting download signal association _ download _ requested _ action

script = QWebEngineScript()

# instantiates the javascript class, the following is the js code and let the web page run the js code to realize the left mouse button

The # double-click webpage can switch the full screen and window functions at any blank position, is limited by the international standard of the browser kernel at present and needs to be switched from

The # tab window starts to switch, and after the international standard is modified, the tab window can be switched without limitation.

js_content ='''

document.ondblclick=function(e) {

if (window.outerHeight != window.screen.height ||

/ window.outerWidth != window.screen.width) {

var el = document.documentElement,rfs =

/ el.requestFullScreen || el.webkitRequestFullScreen ||

/ el.mozRequestFullScreen || el.msRequestFullScreen;

if (typeof rfs != "undefined" && rfs)

rfs.call(el);

} else {

var el = document, cfs = el.cancelFullScreen || el.webkitCancelFullScreen ||

/ el.mozCancelFullScreen || el.exitFullScreen || el.msExitFullscreen;

if (typeof cfs != "undefined" && cfs)

cfs.call(el);

}

}

'''

script.setSourceCode(js_content)

script.setName("doubleClick.js")

script.setWorldId(QWebEngineScript.MainWorld)

script.setInjectionPoint(QWebEngineScript.DocumentReady)

webview.page().profile().scripts().insert(script)

# load the current webpage and run the js code above, realize the double-click blank switch full screen or window display

def context_address_event(self, point):

The method for displaying and processing the mouse right click menu in the # website bar omits the relevant codes which are not the invention, saves space

……

def _download_requested_action(self, item):

The file downloading method for processing the downloading signal omits the relevant codes not of the invention, saves space

……

def _remove_download_requested(self):

Method for deleting download progress bar in status bar, omitting non-related codes of the invention and saving space

……

def _fullScreenRequested(self,request):

The method for # processing video full screen playing or switching normal window omits the relevant codes not of the invention, saves space

……

def navigate_to_url(self):

# method for updating web pages according to addresses of web site bar, omits non-invention related codes, saves space

……

def renew_urlbar(self, q):

Method for synchronously updating address of website bar when page label switching is carried out

self.mainWin.urlbar.setText(q.toString())

def create_tab(self, webview):

Method for creating new tab when # clicks hyperlink, default display new web page

self.mainWin.add_Tab()

web_view=Browser(self.mainWin, webview=webview)

# recursive Call instance of the Current class

self.mainWin.Layout.addWidget(web_view)

webview.setParent(None)

The parent instance of the # setup page is None

webview.showFullScreen()

# Default full Screen display of opened Web Page

web_view.grabKeyboard()

# setting the Capture keyboard of the parent Window of the Web Page, customizing the keyboard function, allowing Esc, space, or Alt Key switching

class MyBrowser(QMainWindow):

# custom MyBrowser Main Window class, inherit QMainWindow class

def __init__(self):

super().__init__()

self.initWinTab()

# initialization Main Window and tab

self.newTab()

# creation of the first New Page tab

def initWinTab(self):

Method for initializing main window and tab

setWindowTitle (' Lanyue direct Win edition default full screen browser 1.6 (validity period to: +)

/valid _ day [2] + ') number' + valid _ day [3] + 'four digits after the hard disk serial number' + valid _ day [4])

self.setWindowFlags(Qt.WindowCloseButtonHint)

# setting Main Window Only closing button, No zoom and minimize buttons, always maximized, satisfying visual enjoyment

self.setWindowIcon(QIcon('img/lanyue2.png'))

self.sougou_tool_bar = QToolBar('')

# activating a toolbar for displaying a dog search input method, with empty contents, and auxiliary uses

self.tabWidget = QTabWidget()

self.tabWidget.setTabShape(QTabWidget.Triangular)

The style of the # setting tab is trapezoidal

self.tabWidget.setTabsClosable(True)

# settings tab closeable

self.tabWidget.tabCloseRequested.connect(self.close_Tab)

The # setup Tab close method is close _ Tab

self.tabWidget.currentChanged.connect(self.changeTab)

self.tabWidget.tabBarClicked.connect(self.clickTab)

self.setCentralWidget(self.tabWidget)

self.bookmark_widget = BookmarkWidget()

The # bookmark class is instantiated, relevant codes which are not the invention are omitted, and space is saved

……

Method for associating context _ toolbar _ event with # bookmark window right-click menu

self.bookmark_toolbar.setToolTipsVisible(True)

self.showMaximized()

# Main Window maximization display

year1, month1, day1 = self.get_webtime()

Invoking get _ webtime method to obtain three data of the year, month and day of the current date of the Internet

The following are network detection and product validity period check, which omit the relevant codes not of the invention and save space

……

def _read_SSD(self, numb, model, cmd):

Method for reading hard disk parameters, omitting non-related codes of the invention and saving space

……

def _lion(self):

The comprehensive method for detecting the serial number and the recording state of the hard disk omits the relevant codes which are not the invention, saves space

……

def get_webtime(self):

The method for acquiring the internet date of the hundred-degree website omits the relevant codes which are not the invention, saves space

……

def write_bookmarks(self):

The method for saving the intelligent bookmark and the intelligent footprint omits the relevant codes which are not the invention, saves space

……

def load_url(self, url):

The method for loading the new web address on the current web page and the newly added web page omits the relevant codes which are not the invention, saves space

……

def load_url_in_new_tab(self, url):

Method for loading website on new page label

self.add_Tab()

self.Layout.addWidget(Browser(self,''))

webview_group[self.INDEX].setUrl(url)

webview_group[self.INDEX].setParent(None)

webview_group[self.INDEX].showFullScreen()

# Default Web Page full Screen display

webview_parent_group[self.INDEX].grabKeyboard()

Setting a webpage parent window capturing keyboard, and entering a full screen switchable mode

def trigger(self, action):

# method of performing a web page built-in action, such as: refreshing

webview_group[self.INDEX].page().triggerAction(action)

def show_browsing_history(self):

# method for displaying browsing footprint, omitting non-related codes of the invention, saving space

……

def add_tool_bar_bookmark(self):

The method for collecting bookmarks omits the relevant codes not in the invention and saves space

……

def toolbar_bookmarks(self):

The # bookmark window display method omits the relevant codes which are not the invention, saves space

……

def bookmark_footprint_common(self,src_model,myQmenu):

The common method for displaying # bookmark and browsing footprint omits the relevant codes not of the invention, saves space

……

def context_toolbar_event(self, point):

The method for deleting the # bookmark menu right click omits the relevant codes which are not the invention, saves space

……

def common_UI(self,title,pic,win_w,win_h):

The title, icon and other public methods of the dialog box window are displayed, the relevant codes which are not the invention are omitted, and the space is saved

……

def about_msg(self):

# method of product introduction

self.load_url_in_new_tab(QUrl("http://www.lanyue.mobi/default_lanyue.html"))

def clock(self):

# method of displaying Current time

self.load_url_in_new_tab(QUrl("http://www.lanyue.mobi/clock1_lanyue.html"))

def popen_common(self, program1, para1):

The common method for executing the third-party program omits the relevant codes which are not the invention, saves space

for i in range(0,len(webview_parent_group)):

webview_parent_group[i].releaseKeyboard()

# keyboard Capture releasing all tab windows, Exit full Screen switchable mode

……

def screen_shot(self):

Method for executing screenshot program

self.popen_common("gnome-screenshot","--interactive")

def printing_picture(self):

Method for executing printing picture

Pop _ common ("eog", "/root/picture")

def printer_setting(self):

Method for executing printer setting

self.popen_common("system-config-printer", "")

def common_passUI(self,lab1,lab1_x,lab1_y, default_pass, lab1_w,func_def):

The common method for setting the password of the administrator or the password login omits the relevant codes which are not the invention, saves space

……

def wifi_volume(self):

Method for executing network and volume setting, omitting codes not related to the invention and saving space

……

def message_flash(self, title, txt):

The method for displaying short messages in a flashing way stays for 7 seconds, omits the relevant codes which are not the invention and saves space

……

def change_pass(self):

The method for setting the new password of the administrator omits the relevant codes which are not the invention, saves space

……

def ok_new_pass(self):

The method for saving the new password of the administrator omits the relevant codes which are not the invention, saves space

……

def ok_wifi_volume(self):

The method for setting network password or modifying administrator password omits the relevant codes not of the invention, saves space

……

def add_Tab(self):

Common method for adding new tab, omitting non-invention related code and saving space

……

def newTab(self):

# method for creating new tab, omitting non-related codes of the invention, saving space

……

def close_Tab(self, index):

# closed tab processing method

self.webview2 = webview_group[index]

self.webview2.page().setAudioMuted(True)

# Sound to close Web Page

self.tabWidget.removeTab(index)

# delete Page Label

self.webview2.close()

# close Web Page

webview_group.remove(self.webview2)

# delete Web instance from array variable webview _ group

webview_parent_group.remove(webview_parent_group[index])

# delete parent instance of Web Page from array variable webview _ parent _ group

if self.tabWidget.count() == 0:

# last tab, close the dog searching toolbar and main window, omit non-invention related codes, save space

……

else:webview_parent_group[index-1].grabKeyboard()

If other tabs are closed, the remaining last tab parent window is allowed to capture the keyboard, and the full-screen switchable mode is entered

def changeTab(self, index):

# switching tab processing method

self.INDEX = index

def clickTab(self, index):

# clicking tab processing method

self.INDEX = index

if __name__ == "__main__":

# Main program

argvs = sys.argv

argvs.append("--no-sandbox")

QCoreApplication.setAttribute(Qt.AA_UseSoftwareOpenGL)

app = QApplication(argvs)

window = MyBrowser()

# instantiating the Main Window and Loading the Home Page

window.show()

# display Main Window

sys.exit(app.exec_())

Above # is the default full screen browser software main source program, the whole set has 819 lines of Python codes, except the comment line.

Claims (5)

1. The default full-screen browser can display all web pages in full screen by default, and the browser does not need to add parameters to start the full screen or press an F11 key to enter the full screen when entering the full screen era; the default full-screen browser omits a main menu and a function button, only a right-click mouse menu is reserved, and the interface is very concise; the famous navigation page is used as a home page, all commonly used websites and hundred-degree search are provided, and website input is reduced as much as possible for netizens.

2. The method comprises the steps that a full-screen browser is defaulted to support the switching of full-screen or window display at any blank position of a left mouse button double-click page in order to meet the operation habit of mouse control, the switching is started from a tab window under the current international standard of a browser kernel, and the switching of the tab window can be started without limitation after the international standard is modified; it is proposed that the W3C web standardization organization absorb the international standard of mouse left-click and space-switch full-screen or window display, and default full-screen display into the next generation browser kernel.

3. The default full-screen browser also supports that a mouse right clicks 60x160 pixel areas at the upper left corner of a webpage to switch full-screen or window display, and the technology can be expanded to that the mouse right clicks four corners of the webpage to switch full-screen or window display; the Linux platform is pure and is not penetrated by rogue software, so that the Linux default full-screen browser can automatically avoid popup advertisements of the Windows platform.

4. The default full-screen browser automatically enables a webpage parent window to capture a keyboard, and self-defines a keyboard processing program to meet the requirement of switching full-screen or window display by Esc or a space bar; the method for enabling the webpage parent window to exit the keyboard custom capture state comprises the following steps: double-clicking a space or inputting non-space non-reduced ASCII printed characters, such as: inputting k characters in the text box can enable the parent window of the webpage to exit from keyboard capture and enter a default keyboard processing program, and display the characters in the text box, and seamlessly interface the text box for inputting, so that the normal input of the text box and the operation requirements of other independent software are met.

5. The default full-screen browser is invented by adopting Python 3.7 language, PyQt5 and QtWebEngine on a Linux operating system, but the claims 1-4 are applicable to browser software under various operating systems and are also applicable to various computer programming languages; the technology of randomly switching the full screen and window display of the web page at the blank position by double-clicking the mouse is also suitable for common computer application software.

Images