CN111859227A - Browser value-added technology for switching full screen or normal display of webpage at will by Esc key - Google Patents
Browser value-added technology for switching full screen or normal display of webpage at will by Esc key Download PDFInfo
- Publication number
- CN111859227A CN111859227A CN202010787334.3A CN202010787334A CN111859227A CN 111859227 A CN111859227 A CN 111859227A CN 202010787334 A CN202010787334 A CN 202010787334A CN 111859227 A CN111859227 A CN 111859227A
- Authority
- CN
- China
- Prior art keywords
- key
- esc
- self
- tab
- full screen
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/95—Retrieval from the web
- G06F16/957—Browsing optimisation, e.g. caching or content distillation
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/01—Input arrangements or combined input and output arrangements for interaction between user and computer
- G06F3/02—Input arrangements using manually operated switches, e.g. using keyboards or dials
- G06F3/023—Arrangements for converting discrete items of information into a coded form, e.g. arrangements for interpreting keyboard generated codes as alphanumeric codes, operand codes or instruction codes
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/315—Object-oriented languages
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/01—Protocols
- H04L67/02—Protocols based on web technology, e.g. hypertext transfer protocol [HTTP]
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Databases & Information Systems (AREA)
- Data Mining & Analysis (AREA)
- Computer Networks & Wireless Communication (AREA)
- Signal Processing (AREA)
- Computing Systems (AREA)
- Human Computer Interaction (AREA)
- User Interface Of Digital Computer (AREA)
Abstract
Currently, all browsers use the function key F11 to trigger full screen or normal display of a web page. F11 is a cold key, so that full-screen display of the webpage cannot be popularized, and refreshing experience of a user is affected. The invention has the characteristics that: the webpage is opened, and when the browser tab is normally displayed, the Esc key is pressed, the webpage is displayed in a full screen mode, and the user has good refreshing experience of an interface; and then pressing down an Esc key, and displaying the webpage normally in a tab mode and switching randomly. The Esc key full screen function is mainly realized by code rewriting of a keyboard processing function; other keys disable the Esc full screen in order not to affect normal input and other software operations within the web page. The left side of the address bar is added with an "Esc control full screen" button, which takes effect by default (grayed out). When deactivated, the Esc button is clickable. Programmed with Python, debugged through in a self-owned browser (not commercially available).
Description
Technical Field
The value-added technology of the full screen display of the computer browser software is also suitable for the full screen display of a common computer window.
Background
By 8/7/2020, all browsers (including but not limited to Google browsers, IE browsers, 360 browsers, Fix browsers, dog search browsers and QQ browsers) in the world all adopt F11 function keys to realize full-screen or normal tab display of web pages, so that the function keys are not popularized in netizens, the internet surfing experience of 50 hundred million netizens in the world is influenced, and particularly, on first-class or second-class association computers sold in the world, the function keys need to press two keys Fn + F11 at the same time, which is really troublesome. Displaying the web page full screen does give the user a good and crisp experience, but the F11 key is not commonly used and good functions cannot be achieved. The invention is provided under the background, the use frequency of the Esc key is hundreds of times or even thousands of times higher than that of the F11 key, and the Esc key is adopted to switch full screen or normal display, so that the Esc key can be rapidly popularized among netizens, and the internet surfing experience of netizens all over the world is improved. A good internet experience multiplied by 50 billion net citizens would be immeasurable economic value.
Disclosure of Invention
The invention has the technical characteristics that: when any webpage is opened by the browser, the Esc key is pressed, the webpage browsed by the user is displayed in a full-screen mode (figure 1), the user has a refreshing good experience of an interface, and then the Esc key is pressed, the webpage is normally displayed in a tab mode (figure 2), and the switching can be carried out randomly; when the Esc key is captured, strict judgment and ingenious processing are required by browser software to achieve the purpose of not influencing normal keyboard input, which is the technical difficulty of the invention. The technology of the invention is also suitable for free switching of full screen or normal display of a common computer window. Mainly depending on the keyboard capture technology, processing Esc full screen or normal display in a keyboard processing function; in order not to influence the normal input and functional operation in the webpage, a user can press a space key or a Backspace key or a Ctrl key or a Shift key or a Ctrl/Alt/Shift triple key combination or a Ctrl/Alt/Shift/letter or number four-key combination or any ASCII key to disable the Backspace key or the Backspace key; clicking the separately designed "Esc control full screen" button can reactivate the Esc key full screen display function.
The left side of the address bar is added with an 'Esc control full screen' button (the position of the button is not limited to a selection), the Esc key full screen and normal display switching function is effective when the function is started by default, the button is grayed (not clickable), and a user can press a space key or a Backspace grid reversing key or a Ctrl key or an Alt key or a Shift key or a Ctrl/Alt/Shift triple key combination or a Ctrl/Alt/Shift/letter or number four-key combination or any ASCII key to disable the function, so that the normal input in a browser page sign window and the operation requirements of other functions of the software or the use of other independent software are met. When the Esc button is disabled by a user, the Esc button is in a clickable state, and after the Esc button is clicked, the switching function of the full screen and normal display of the Esc button is immediately effective. Before operating other software except the browser, the Esc control full screen is disabled, namely the button is in a release state (or a clickable state), otherwise, the keyboard operation of other software is influenced.
The Python language is currently the most popular computer development language, which has the largest third party software ecosphere, and thus companies that have not turned to the Python language will do so sooner or later. The Firefox browser is originally developed based on C + + language, and is developed by gradually turning to Python language two years ago. The technical basis of the invention is software development, programming codes are provided in Python language, enabled third-party software development kits are Qt and PyQt, and the codes are debugged through (not in commercial use) in a company self-production browser represented by an applicant. The programming principles of the Python language are equally applicable to the C + + and JAVA languages or other high-level computer languages.
Drawings
FIG. 1, full Screen display screenshot of a Web Page
FIG. 2, web page normal display screenshot.
Detailed Description
The code for switching the full screen or normal display of the webpage randomly by using the Esc key is as follows by adopting Python language:
from pynput.keyboard import Controller, Key
a # import keyboard control module is placed at the forefront of a main control program of the browser;
self._tab_widget.grabKeyboard()
# self _ tab _ widget is a tab control, and each time a new tab control is created, the tab control is required to capture a keyboard at the Class initialization stage and is placed at any position of a tab initialization code segment of a main program of the browser master control, and the grabKeyboard () is a keyboard capture function;
the function for processing keyboard keys should be put in the general control program of the browser, except the ini initialization module, the line at the beginning of # is a comment line, which explains the function of the last line of codes, and the whole set of codes is as follows:
def keyPressEvent(self, QKeyEvent):
# is invoked when a key of the keyboard is pressed while Esc full screen function is active.
if self._addres_line_edit.hasFocus():
# when the web site bar gets the current focus, the following code is executed.
self.release_keyboard()
And # calls release _ keyboard () function to release keyboard capture, so as to meet the normal input of the website bar.
key= QKeyEvent.key()
# get key.
if key<256:
# judges whether or not the ASCII code is pressed, yes, the following code is executed.
keyboard = Controller()
# calls the simulated keyboard built-in function.
keyboard.press(chr(key))
# analog presses the ASCII key to avoid repeated user input.
keyboard.release(chr(key))
The # simulation releases an ASCII key to avoid repeated input by a user.
elif QKeyEvent.key() == Qt.Key_Escape:
# judges whether the Esc key is pressed, yes, the following code is executed.
self._tab_widget.web_engine_view2 = self._tab_widget.web_engine_view
And recording the content of the currently browsed webpage view by using self
self._tab_widget.num_webpage2 = len(self._tab_widget._webengineviews)
# adopts self _ tab _ widget. num _ webpage2 to record the total number of views of the web page currently viewed
if self._tab_widget.request2 == 'normal_screen':
# judges whether the request status of the current tab is: normal display of normal _ screen is to switch to full screen display
self._tab_widget.title2=BookmarkWidget.short_title(self._tab_widget./
/web_engine_view2.page().title())
Title2 records tab short title with self, tab _ widget, and first two lines of codes combined into one, and/is connector
self._tab_widget.index2=self._tab_widget._index_of_page(/
/self._tab_widget.web_engine_view2.page())
# adopts self _ tab _ widget _ index2 to record the tab index number, two lines of codes are combined into one, and/is a connector
self._tab_widget.icon2 = self._tab_widget.tabIcon(self._tab_widget.index2)
# uses self _ tab _ widget. icon2 to record tab icon
self._tab_widget.web_engine_view2.setParent(None)
# Place the view of the Web page in the tab at the topmost end of the screen
self._tab_widget.web_engine_view2.showFullScreen()
# displays the topmost view of the screen full-screen, and the showFullScreen () function is described later
self._tab_widget.request2 = 'full_screen'
Request2 records full screen display state full _ screen with memory variable self
else:
# judges whether the request status of the current tab is: normal display of normal _ screen, no, normal display is switched
try:
self._tab_widget.insertTab(self._tab_widget.index2,/
/self._tab_widget.web_engine_view2, self._tab_widget.title2)
Since the original webpage view in the tab is moved to the topmost end in the full screen state, the return to normal display needs
The original tab view is re-inserted at the original position, the first two lines of codes are combined into one, and the/is a connector
self._tab_widget.setCurrentIndex(self._tab_widget.index2)
# setting the newly inserted tab as the Current tab
self._tab_widget.request2 = 'normal_screen'
Request2 records normal display state normal _ screen with memory variable self
except:
pass
The reason why the error-tolerant mode of try … … except … … code is adopted is to increase the robustness of the code,
# is not essential
elif QKeyEvent.modifiers()==Qt.ControlModifier | Qt.ShiftModifier |Qt.AltModifier:
# judges whether or not the Ctrl + Shift + Alt key has been pressed
self.release_keyboard()
# calls release _ keyboard () function to release keyboard capture to satisfy normal input or keyboard operation in web page
elif QKeyEvent.modifiers() == Qt.ControlModifier |Qt.ShiftModifier:
# judges whether or not the Ctrl + Shift key has been pressed
self.release_keyboard()
# calls release _ keyboard () function to release keyboard capture to satisfy normal input or keyboard operation in web page
elif QKeyEvent.modifiers() == Qt.ControlModifier:
# judges whether or not Ctrl key has been pressed
self.release_keyboard()
# calls release _ keyboard () function to release keyboard capture to satisfy normal input or keyboard operation in web page
elif QKeyEvent.modifiers() == Qt.AltModifier:
# judges whether the Alt Key is pressed
self.release_keyboard()
# calls release _ keyboard () function to release keyboard capture to satisfy normal input or keyboard operation in web page
elif QKeyEvent.modifiers() == Qt.ShiftModifier:
# judges whether the shift key has been pressed
self.release_keyboard()
# calls release _ keyboard () function to release keyboard capture to satisfy normal input or keyboard operation in web page
elif QKeyEvent.key() == 32:
# judges whether the space key has been pressed
self.release_keyboard()
# calls release _ keyboard () function to release keyboard capture to satisfy normal input or keyboard operation in web page
elif QKeyEvent.key() == Qt.Key_Backspace:
# judging whether the Backspace Backspace key was pressed
self.release_keyboard()
# calls release _ keyboard () function to release keyboard capture to satisfy normal input or keyboard operation in web page
else:
# judges whether or not another key has been pressed
key= QKeyEvent.key()
# get Key
if key<256:
# judges whether or not the ASCII code is pressed, if so, executes the following code
self.release_keyboard()
# Call Release _ keyboard () to release keyboard Capture to satisfy Normal input or keyboard operation in Web Page
keyboard = Controller()
# Call simulation keyboard built-in function
keyboard.press(chr(key))
# analog pressing of ASCII key to avoid repeated user input
keyboard.release(chr(key))
# simulation loosens ASCII key to avoid repeated user input
def release_keyboard(self):
# Release keyboard Capture function, placed in Master control program of browser
self._tab_widget.releaseKeyboard()
# let current tab release keyboard Capture
self._tab_widget.request2 = 'no grabKeyboard'
Request2 records that the current request is no grabKeyboard
self.Esc_action.setEnabled(True)
'Esc control full screen' button is set to be clickable state
def _Esc(self):
The # Esc controls the full screen button service function, which is placed in the main control program of the browser
if self._tab_widget.request2 == 'no grabKeyboard':
# judges whether the request status is keyboard release: no grabKeyboard, the following code is executed
self._tab_widget.grabKeyboard()
# Capture keyboard
self.Esc_action.setEnabled(False)
# sets "Esc control full screen" graying, i.e. not clickable, Esc full screen function takes effect
self._tab_widget.request2 = 'normal_screen'
# set request State is Normal display
Esc _ action = QAction (QIcon ("img/Esc. jpg"), "Esc full screen toggle", self, triggered = self. _ Esc)
# defines the actions of the Esc button, and is placed in the main control program of the browser
self._actions['Esc']= self.Esc_action
# the Esc button actions are placed in the total display cycle, the buttons are displayed, and the buttons are placed in the main control program of the browser
self.Esc_action.setEnabled(False)
# sets the default value of Esc actions as invalid (graying), the default Esc takes effect in full screen, and places the Esc in the main control program of the browser
def _wps_word(self):
Example # for calling WPS word processing of external program by browser, placing it in main control program of browser
self.release_keyboard()
# first Release keyboard Capture
Popen(["/root/opt/kingsoft/wps-office/office6/wps"])
# actual invocation of external program WPS word processing
def _QQ(self):
Example # in which the browser calls the external program QQ to chat and is placed in the main control program of the browser
Release _ keyboard () # first releases keyboard capture
Popen ([ "/usr/local/bin/QQ" ]) # actually calls the external program QQ chat
The above is the code related to Esc full screen display for the browser main control program
------------------------------------------------------------------------------------------------------------------------
The following code related to Esc full screen display by the New Page Class definition Module
self.index2, self.num_webpage2, self.tab_Clicked = -1, -1, 0
In the new tab Class, three variables are added to record the full screen page index, the total tab number and the tab click mark respectively and are initialized to-1, -1 and 0 respectively
def printPDF_Finished_preview(self):
# in the new tab Class, the robustness of the PDF completion flag setting function of the web page preview is increased,
the # Unannotated line is full-screen independent of Esc
try:
# to adapt to Esc Key to switch web pages to full screen or normal display at will, program is added by try … … except … …
# robustness
self._webengineviews_PDF_Finished[self.currentIndex()]= 1
except:
pass
def _current_changed(self, index):
# in New Page Label Class, modify the Current Page Label Change function to accommodate Esc Key full Screen function, unannotated line and
# Esc full Screen not related
if self.request2 == 'full_screen' and self.num_webpage2<len(self._webengineviews):
# clicking hyperlink in full screen mode opens new page in new tab and executes following code
self.insertTab(self.index2, self.web_engine_view2, self.title2)
# full screen display page returns to normal display in original position
self.request2 = 'normal_screen'
Request2 shows normal _ screen
pdf_file1 = "%s.pdf" % index
try:
self._webengineviews_PDF_Finished[index]= 0
if not os.path.exists(pdf_file1):
self._webengineviews[index].page().printToPdf('pdf/' +pdf_file1, self.layout)
self._webengineviews_PDF_Finished[index]= 1
except:
self._webengineviews_PDF_Finished.append(0)
self._update_actions(index)
self.url_changed.emit(self.url())
if self.num_webpage2<len(self._webengineviews) or self.tab_Clicked ==1:
# the following code would be triggered when Esc clicks hyperlink or switches tab in full screen mode
if self.tab_Clicked ==1:
# Normal tab click switch
self.tab_Clicked = 0
self.setCurrentIndex(index)
else:
If # a new page is opened in a new tab by clicking a hyperlink in an Esc full-screen mode, the following codes are triggered
self.setCurrentIndex(len(self._webengineviews)-1)
# sets the current tab to the last newly added tab
def _tabBarClicked(self,index):
In the new tab Class, # modifies the current tab change function to adapt to the Esc key full screen function,
the # Unannotated line is full-screen independent of Esc
self.web_engine_view = self._webengineviews[index]
self.tab_Clicked = 1
Tab _ Clicked = 1 # user clicks tab
self.web_engine_view.page().fullScreenRequested.connect(self._fullScreenRequested)
In the tab view of the New Tab Class, # full Screen button trigger function is defined
def _fullScreenRequested(self,request):
In the new tab Class, the specific code of the full screen button trigger function is as follows, which is the trigger code for video full screen,
# is correlated with a common page full screen display
request.accept()
# accept full screen request
self.web_engine_view2 = self.web_engine_view
Web _ engine _ view2 variable records current tab view
self.num_webpage2 = len(self._webengineviews)
Num _ webpage2 variable records the total tab number
if str(self.request2)=='normal' or request.toggleOn():
If the common web page or video is in the normal display state, the full screen display is switched
self.title2 = BookmarkWidget.short_title(self.web_engine_view2.page().title())
Title2 records the short title of the current tab
self.index2 = self._index_of_page(self.web_engine_view2.page())
Index2 records the index number of the current tab by self
self.icon2 = self.tabIcon(self.index2)
Icon for recording current tab by self. icon2
self.web_engine_view2.setParent(None)
# set the video view of the current tab to the top
self.web_engine_view2.showFullScreen()
# displays the video of the current tab full screen
self.request2 = 'full_screen'
Request2 = ' full _ screen ' full screen ' set request variable self
else:
# in the state of full-screen display of the video, executing the following code to resume normal display
self.insertTab(self.index2, self.web_engine_view2,self.title2)
Inserting a normal video tab in the original position according to the content attribute of the original tab
self.setCurrentIndex(self.index2)
Indext2. the original index number self saved when the current index is set to be equal to the full screen
self.request2 = 'normal_screen'
Request2 = 'normal _ screen' normally displays.
Claims (4)
- And 1, switching full screen and normal display of a browser tab window by an Esc key at will to achieve smooth switching.
- And 2, enabling the Esc key to be effective when the full-screen and normal display switching function is started by default, and disabling the Esc key or the Backspace inverted grid key or the Ctrl key or the Alt key or the Shift key or the Ctrl/Alt/Shift triple key combination or the Ctrl/Alt/Shift/letter or number four-key combination or any ASCII key so as to meet the normal input in the browser tab window and the operation requirements of other functions of the software or the use of other independent software.
- 3. Designing a single Esc button, graying (not clicking) by default, and indicating that the Esc button full-screen and normal display switching function is in an effective state; when the user disables the Esc button according to claim 2, the Esc button is in a clickable state, and when the button is clicked, the Esc button full-screen and normal display switching function is immediately activated.
- 4, Esc key switches the full screen and normal display technology of browser tab window at will, also suitable for the free switch of full screen and normal display of the ordinary computer window.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010787334.3A CN111859227A (en) | 2020-08-07 | 2020-08-07 | Browser value-added technology for switching full screen or normal display of webpage at will by Esc key |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010787334.3A CN111859227A (en) | 2020-08-07 | 2020-08-07 | Browser value-added technology for switching full screen or normal display of webpage at will by Esc key |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111859227A true CN111859227A (en) | 2020-10-30 |
Family
ID=72972277
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010787334.3A Pending CN111859227A (en) | 2020-08-07 | 2020-08-07 | Browser value-added technology for switching full screen or normal display of webpage at will by Esc key |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111859227A (en) |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112287277A (en) * | 2020-11-27 | 2021-01-29 | 深圳市哈哈丫丫互联网有限公司 | New generation browsing technology for default full screen and Esc batch normal display of webpage |
| CN112416502A (en) * | 2020-12-04 | 2021-02-26 | 深圳市哈哈丫丫互联网有限公司 | New technology for closing webpage by pressing-number or right-clicking menu in full-screen display mode |
| CN112487340A (en) * | 2020-12-23 | 2021-03-12 | 深圳市哈哈丫丫互联网有限公司 | Innovative technology of extremely-fast simple anti-theft Linux full-screen browser |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101403947A (en) * | 2008-11-19 | 2009-04-08 | 黄庆传 | Computer word input method, its keyboard and mouse |
| US20160231884A1 (en) * | 2014-03-31 | 2016-08-11 | Yandex Europe Ag | System and method for managing a web resource in a browser application |
-
2020
- 2020-08-07 CN CN202010787334.3A patent/CN111859227A/en active Pending
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101403947A (en) * | 2008-11-19 | 2009-04-08 | 黄庆传 | Computer word input method, its keyboard and mouse |
| US20160231884A1 (en) * | 2014-03-31 | 2016-08-11 | Yandex Europe Ag | System and method for managing a web resource in a browser application |
Non-Patent Citations (1)
| Title |
|---|
| 颜小洋: "《中文Word 95使用指南》", 31 January 1998, 北京工业大学出版社 * |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112287277A (en) * | 2020-11-27 | 2021-01-29 | 深圳市哈哈丫丫互联网有限公司 | New generation browsing technology for default full screen and Esc batch normal display of webpage |
| CN112416502A (en) * | 2020-12-04 | 2021-02-26 | 深圳市哈哈丫丫互联网有限公司 | New technology for closing webpage by pressing-number or right-clicking menu in full-screen display mode |
| CN112487340A (en) * | 2020-12-23 | 2021-03-12 | 深圳市哈哈丫丫互联网有限公司 | Innovative technology of extremely-fast simple anti-theft Linux full-screen browser |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10248294B2 (en) | Modal-less interface enhancements | |
| RU2554395C2 (en) | System and method for selecting tabs within tabbed browser | |
| US8125457B2 (en) | Switching display mode of electronic device | |
| CN111859227A (en) | Browser value-added technology for switching full screen or normal display of webpage at will by Esc key | |
| CN203366247U (en) | Multifunctional mouse with reused keys | |
| KR101580003B1 (en) | Graphical user interface for non mouse-based activation of links | |
| WO2012141183A1 (en) | Content providing apparatus compatible with various terminal devices | |
| CN102298492A (en) | Information processing apparatus, information processing method, and program | |
| JP5222717B2 (en) | Display window selection method, display window selection program, and terminal device | |
| WO2024140118A1 (en) | Favorites processing method, apparatus and device, and storage medium | |
| CN106855885B (en) | A browser page processing method and terminal | |
| CN114579903B (en) | Full keyboard browser operation method, device, equipment and storage medium | |
| CN112487340A (en) | Innovative technology of extremely-fast simple anti-theft Linux full-screen browser | |
| CN113807057B (en) | Text editing method and device | |
| CN108052212A (en) | A kind of method, terminal and computer-readable medium for inputting word | |
| JP6175682B2 (en) | Realization of efficient cascade operation | |
| KR100885523B1 (en) | Display Modules, Devices, Computer Software Products and Methods for User Interface Views | |
| CN117742506B (en) | Operation method and device for enhanced keyboard and related components | |
| KR100477577B1 (en) | Program execution system and method using simultaneous click of mouse double button | |
| CN116820319A (en) | Method and system for controlling browser interface return in iOS application through gestures | |
| KR20000049575A (en) | Key input method and apparatus using mouse device | |
| CN112287277A (en) | New generation browsing technology for default full screen and Esc batch normal display of webpage | |
| CN116301399A (en) | Control method, system, terminal and medium for user-defined keyboard function keys | |
| CN113608645A (en) | Innovative technology for switching full-screen or window display and default full-screen browser at blank position of webpage by double-clicking of mouse | |
| US20070143708A1 (en) | Overloaded hyperlink |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |