Method, device and equipment for synchronizing input content in MacOS synchronizer and medium

Abstract

The invention provides a method, a device and equipment for synchronizing input contents in a MacOS synchronizer and a medium. The method comprises the following steps: setting a main window dynamic library and a slave window dynamic library; target programs needing to be synchronized are selected, at least two target programs are started, one target program is set as a master control window, and the other target programs are set as slave control windows; injecting the master window dynamic library into a master control window, and injecting the slave window dynamic library into a slave control window; the master window dynamic library starts a message transfer center, and the slave window dynamic libraries are registered to the message transfer center; the main window dynamic library captures a keyboard event of the main control window; each slave window dynamic library controls the corresponding slave window to execute corresponding operation according to the received keyboard event, automatic synchronization of multiple input methods is achieved, the method is suitable for a multi-language environment, and the cross-language input requirement of a user is met.

Description

Technical Field

[0001] The present invention relates to the field of data processing technology, and in particular to a method, device, equipment and medium for synchronizing input content in a MacOS synchronizer. Background Art

[0002] In macOS, there are situations where a synchronizer is needed. In MacOS, multiple operation windows of the same software are opened, and then the same operation is performed through the synchronizer. Currently, content input needs to be entered through an input method. If the input is in English, the synchronizer can synchronize directly; if the input is in Chinese, the synchronizer needs to be operated through a set input interface. After entering the text, it is synchronized to multiple operation windows respectively. This method greatly reduces the convenience of user operation, and if a part of the content in a paragraph needs to be modified, the user needs to re-enter, which greatly reduces work efficiency. Summary of the invention

[0003] The technical problem to be solved by the present invention is to provide a method, device, equipment and medium for synchronizing input content in a MacOS synchronizer, which can automatically synchronize multiple input methods and is suitable for a multi-language environment to meet the user's cross-language input needs.

[0004] In a first aspect, the present invention provides a method for synchronizing input content in a MacOS synchronizer, comprising the following steps:

[0005] Step 1, set the main window dynamic library and the slave window dynamic library;

[0006] Step 2, select the target program to be synchronized, start at least two target programs, set one of the target programs as the master control window, and set the other target programs as slave control windows; inject the main window dynamic library into the master control window, and inject the slave window dynamic library into the slave control window;

[0007] Step 3, the main window dynamic library starts a message transfer center, and the slave window dynamic libraries are all registered to the message transfer center;

[0008] Step 4, the main window dynamic library captures the keyboard event of the main control window; if the keyboard event is an NSEventTypeKeyDown event and an NSEventTypeKeyDown event, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event are sent to the event queue of the message transfer center;

[0009] Step 5. If the message transfer center receives the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are deleted and not sent; after the insertText method is triggered, the text parameter received in the insertText method is sent to the message transfer center, and the message transfer center sends the text parameter to each slave window dynamic library, and each of the slave window dynamic libraries fills the text parameter into the corresponding slave control window;

[0010] If the message transfer center does not receive the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are sent to each slave window dynamic library after delaying the first set time. Each slave window dynamic library controls the corresponding slave control window to perform corresponding operations according to the received keyboard event.

[0011] In a second aspect, the present invention provides a device for synchronizing input content in a MacOS synchronizer, comprising:

[0012] Set the dynamic library module, set the main window dynamic library and the slave window dynamic library;

[0013] Inject the dynamic library module, select the target program to be synchronized, start at least two target programs, set one of the target programs as the main control window, and set the other target programs as slave control windows; inject the main window dynamic library into the main control window, and inject the slave window dynamic library into the slave control window;

[0014] The registration module is started, the main window dynamic library starts a message transfer center, and the slave window dynamic libraries are all registered to the message transfer center;

[0015] A keyboard event module, wherein the main window dynamic library captures the keyboard events of the main control window; if the keyboard events are NSEventTypeKeyDown events and NSEventTypeKeyDown events, the NSEventTypeKeyDown events and NSEventTypeKeyDown events are sent to the event queue of the message transfer center;

[0016] Synchronous event module, if the message transfer center receives the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are deleted and not sent; after the insertText method is triggered, the text parameter received in the insertText method is sent to the message transfer center, and the message transfer center sends the text parameter to each slave window dynamic library, and each of the slave window dynamic libraries fills the text parameter into the corresponding slave control window;

[0017] If the message transfer center does not receive the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are sent to each slave window dynamic library after delaying the first set time. Each slave window dynamic library controls the corresponding slave control window to perform corresponding operations according to the received keyboard event.

[0018] In a third aspect, the present invention provides an electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the method described in the first aspect when executing the program.

[0019] In a fourth aspect, the present invention provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the method described in the first aspect.

[0020] One or more technical solutions provided by the present invention have at least the following technical effects or advantages:

[0021] Multi-language input method synchronization: supports automatic synchronization of multiple Asian language input methods such as Chinese, Korean, Japanese, etc., suitable for multi-language environments, and meets users' cross-language input needs.

[0022] Cross-application synchronization: It can automatically synchronize the input method status between windows of different applications. Users do not need to manually adjust the input method when switching between different windows, which greatly simplifies the operation process.

[0023] Reduce misoperation: Automatically synchronize input method status to avoid misoperation caused by manual switching of input methods. It is especially suitable for multi-window and multi-language input environments.

[0024] Efficient and convenient: Users only need to set the input method in the main window, and other passive windows can automatically apply the same input method status, effectively improving the operating efficiency in a multi-tasking environment.

[0025] Through this solution, MacOS users can achieve seamless synchronization of multi-language input methods between multiple windows, which is suitable for various scenarios such as multi-language file editing and cross-application data processing, providing users with an efficient and convenient multi-tasking multi-language input experience.

[0026] The above description is only an overview of the technical solution of the present invention. In order to more clearly understand the technical means of the present invention, it can be implemented according to the contents of the specification. In order to make the above and other purposes, features and advantages of the present invention more obvious and easy to understand, the specific implementation methods of the present invention are listed below. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] The present invention will be further described below in conjunction with embodiments with reference to the accompanying drawings.

[0028] Figure 1 is a flow chart of the method in Embodiment 1 of the present invention;

[0029] Figure 2 It is a schematic diagram of the structure of the device in the second embodiment of the present invention. DETAILED DESCRIPTION

[0030] The technical solution in the embodiment of the present application has the following general idea:

[0031] Step 1: Select the target program The user selects the target program for which input method synchronization is required. The synchronizer starts the target program and automatically injects the dynamic library into it to capture and synchronize the input method status.

[0032] Step 2: Dynamic library injection When the target program is started, the dynamic library is injected into the program's running environment. The dynamic library is responsible for detecting and managing the input method status of the main window and the passive window.

[0033] Step 3: Detect the window status The dynamic library monitors the window status of the target program in real time, including the focus changes of the main window and all passive windows, and identifies the current main window to capture the changes in the input method status.

[0034] Step 4: Capture the input method status of the main window. The dynamic library monitors the input method type (Chinese, Korean, Japanese, etc.) selected by the user in the main window and records the current input method status.

[0035] Step 5: Synchronize input method to passive window The dynamic library synchronizes the input method status of the main window to all passive windows, so that when switching to a passive window, you can use the language input method consistent with the main window without manually changing the input method.

[0036] Step 6: Synchronization status feedback The synchronizer interface displays the input method synchronization icon or prompt to help users confirm whether the current input method status is synchronized successfully; in case of abnormality, the synchronizer will prompt the user to restart the target program or re-inject the dynamic library.

[0037] Embodiment 1

[0038] like Figure 1 As shown, this embodiment provides a method for synchronizing input content in a MacOS synchronizer, comprising the following steps:

[0039] Step 1, set the main window dynamic library and the slave window dynamic library;

[0040] Step 2, select the target program to be synchronized, start at least two target programs, set one of the target programs as the master control window, and set the other target programs as slave control windows; inject the main window dynamic library into the master control window, and inject the slave window dynamic library into the slave control window;

[0041] Step 3, the main window dynamic library starts a message transfer center, and the slave window dynamic libraries are all registered to the message transfer center;

[0042] Step 4, the main window dynamic library captures the keyboard event of the main control window; if the keyboard event is an NSEventTypeKeyDown event and an NSEventTypeKeyDown event, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event are sent to the event queue of the message transfer center;

[0043] Step 5. If the message transfer center receives the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are deleted and not sent; after the insertText method is triggered, the text parameter received in the insertText method is sent to the message transfer center, and the message transfer center sends the text parameter to each slave window dynamic library, and each of the slave window dynamic libraries fills the text parameter into the corresponding slave control window;

[0044] If the message transfer center does not receive the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are sent to each slave window dynamic library after delaying the first set time. Each slave window dynamic library controls the corresponding slave control window to perform corresponding operations according to the received keyboard event.

[0045] This embodiment preferably further includes step 6, setting a synchronization status chart or animation on the device interface to prompt the user whether the current synchronization operation is successful.

[0046] In this embodiment, preferably, the step 1 is specifically:

[0047] Create a main window dynamic library to monitor keyboard events on MacOS;

[0048] First, register the listener in the static function Load of NSWindow; then, register the system listener through CGEventTapCreate(kCGSessionEventTap, kCGTailAppendEventTap, kCGEvent TapOptionListenOnly, eventMask, eventCallback, NULL) and set the eventMask value; finally, set the callback function eventCallback, which is used to forward keyboard events to the message transfer center;

[0049] Create a slave window dynamic library for receiving the keyboard events;

[0050] First, register with the message transfer center; then, receive the keyboard events forwarded by the message center; finally, execute the keyboard events.

[0051] In this embodiment, preferably, the step 2 is specifically: select the target program to be synchronized, start at least two target programs, set one of the target programs as the master control window, set the other target programs as slave control windows, inject the main window dynamic library into the master control window through DYLD_INSERT_LIBRARIES, and inject the slave window dynamic library into the slave control window through DYLD_INSERT_LIBRARIES;

[0052] The step 3 is specifically as follows: the main window dynamic library starts a message transfer center, the message transfer center listens to the set port through unixsocks and receives socket messages, the slave window dynamic library sends a registration message to the set port, the message transfer center receives the registration message, and the registration from the slave window dynamic library to the message transfer center is completed.

[0053] Based on the same inventive concept, the present application also provides a device corresponding to the method in Example 1, see Example 2 for details.

[0054] Embodiment 2

[0055] like Figure 2As shown, in this embodiment, a device for synchronizing input content in a MacOS synchronizer is provided, including:

[0056] Set the dynamic library module, set the main window dynamic library and the slave window dynamic library;

[0057] Inject the dynamic library module, select the target program to be synchronized, start at least two target programs, set one of the target programs as the main control window, and set the other target programs as slave control windows; inject the main window dynamic library into the main control window, and inject the slave window dynamic library into the slave control window;

[0058] The registration module is started, the main window dynamic library starts a message transfer center, and the slave window dynamic libraries are all registered to the message transfer center;

[0059] A keyboard event module, wherein the main window dynamic library captures the keyboard events of the main control window; if the keyboard events are NSEventTypeKeyDown events and NSEventTypeKeyDown events, the NSEventTypeKeyDown events and NSEventTypeKeyDown events are sent to the event queue of the message transfer center;

[0060] Synchronous event module, if the message transfer center receives the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are deleted and not sent; after the insertText method is triggered, the text parameter received in the insertText method is sent to the message transfer center, and the message transfer center sends the text parameter to each slave window dynamic library, and each of the slave window dynamic libraries fills the text parameter into the corresponding slave control window;

[0061] If the message transfer center does not receive the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are sent to each slave window dynamic library after delaying the first set time. Each slave window dynamic library controls the corresponding slave control window to perform corresponding operations according to the received keyboard event.

[0062] This embodiment preferably also includes a prompt message module, which sets a synchronization status chart or animation on the device interface to prompt the user whether the current synchronization operation is successful.

[0063] In this embodiment, preferably, the setting of the dynamic library module is specifically:

[0064] Create a main window dynamic library to monitor keyboard events on MacOS;

[0065] First, register the listener in the static function Load of NSWindow; then, register the system listener through CGEventTapCreate(kCGSessionEventTap, kCGTailAppendEventTap, kCGEvent TapOptionListenOnly, eventMask, eventCallback, NULL) and set the eventMask value; finally, set the callback function eventCallback, which is used to forward keyboard events to the message transfer center;

[0066] Create a slave window dynamic library for receiving the keyboard events;

[0067] First, register with the message transfer center; then, receive the keyboard events forwarded by the message center; finally, execute the keyboard events.

[0068] In this embodiment, preferably, the dynamic library injection module is specifically as follows: select a target program to be synchronized, start at least two target programs, set one of the target programs as a master control window, set the other target programs as slave control windows, inject the main window dynamic library into the master control window through DYLD_INSERT_LIBRARIES, and inject the slave window dynamic library into the slave control window through DYLD_INSERT_LIBRARIES;

[0069] The startup registration module is specifically as follows: the main window dynamic library starts a message transfer center, the message transfer center listens to the set port through unixsocks and receives socket messages, the slave window dynamic library sends a registration message to the set port, the message transfer center receives the registration message, and the registration from the slave window dynamic library to the message transfer center is completed.

[0070] Since the device introduced in the second embodiment of the present invention is a device used to implement the method of the first embodiment of the present invention, those skilled in the art can understand the specific structure and deformation of the device based on the method introduced in the first embodiment of the present invention, so it is not described here in detail. All devices used in the method of the first embodiment of the present invention belong to the scope of protection of the present invention.

[0071] Based on the same inventive concept, the present application provides an electronic device embodiment corresponding to the first embodiment, see the third embodiment for details.

[0072] Embodiment 3

[0073] This embodiment provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, any implementation method in the first embodiment can be implemented.

[0074] Since the electronic device introduced in this embodiment is a device used to implement the method in the first embodiment of the present application, based on the method introduced in the first embodiment of the present application, a person skilled in the art can understand the specific implementation of the electronic device of the present embodiment and its various variations, so how the electronic device implements the method in the embodiment of the present application is not described in detail here. As long as a person skilled in the art implements the device used by the method in the embodiment of the present application, it belongs to the scope of protection of the present application.

[0075] Based on the same inventive concept, the present application provides a storage medium corresponding to the first embodiment, see the fourth embodiment for details.

[0076] Embodiment 4

[0077] This embodiment provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, any implementation method in the first embodiment can be implemented.

[0078] Those skilled in the art will appreciate that embodiments of the present invention may be provided as methods, systems, or computer program products. Therefore, the present invention may take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, the present invention may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0079] The present invention is described with reference to flowcharts and / or block diagrams of methods, devices (systems), and computer program products according to embodiments of the present invention. It should be understood that each process and / or block in the flowchart and / or block diagram, as well as the combination of processes and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0080] These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 A process or multiple processes and / or boxes Figure 1 A function specified in one or more boxes.

[0081] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing instructions for implementing the process. Figure 1 A process or multiple processes and / or boxes Figure 1 The steps for the functions specified in one or more boxes.

[0082] Although the specific implementation modes of the present invention are described above, those skilled in the art should understand that the specific implementation modes described are only illustrative and are not intended to limit the scope of the present invention. Equivalent modifications and changes made by those skilled in the art in accordance with the spirit of the present invention should be included in the scope of protection of the claims of the present invention.

Claims

1. A method for synchronizing input content in a MacOS synchronizer, characterized in that: The steps include: Step 1, set the main window dynamic library and the slave window dynamic library; Step 2, select the target program to be synchronized, start at least two target programs, set one of the target programs as the master control window, and set the other target programs as slave control windows; inject the main window dynamic library into the master control window, and inject the slave window dynamic library into the slave control window; Step 3, the main window dynamic library starts a message transfer center, and the slave window dynamic libraries are all registered to the message transfer center; Step 4, the main window dynamic library captures the keyboard events of the main control window; If the keyboard event is an NSEventTypeKeyDown event and an NSEventTypeKeyDown event, send the NSEventTypeKeyDown event and the NSEventTypeKeyDown event to the event queue of the message transfer center; Step 5. If the message transfer center receives the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are deleted and not sent; after the insertText method is triggered, the text parameter received in the insertText method is sent to the message transfer center, and the message transfer center sends the text parameter to each slave window dynamic library, and each of the slave window dynamic libraries fills the text parameter into the corresponding slave control window; If the message transfer center does not receive the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are sent to each slave window dynamic library after delaying the first set time. Each slave window dynamic library controls the corresponding slave control window to perform corresponding operations according to the received keyboard event.

2. The method for synchronizing input content in a MacOS synchronizer according to claim 1, characterized in that: The method also includes step 6, setting a synchronization status chart or animation on the device interface to prompt the user whether the current synchronization operation is successful.

3. The method for synchronizing input content in a MacOS synchronizer according to claim 1, characterized in that: The step 1 is specifically as follows: Create a main window dynamic library to monitor keyboard events on MacOS; First, register the listener in the static function Load of NSWindow; then, register the system listener through CGEventTapCreate(kCGSessionEventTap, kCGTailAppendEventTap, kCGEvent TapOptionListenOnly, eventMask, eventCallback, NULL) and set the eventMask value; finally, set the callback function eventCallback, which is used to forward keyboard events to the message transfer center; Create a slave window dynamic library for receiving the keyboard events; First, register with the message transfer center; then, receive the keyboard events forwarded by the message center; finally, execute the keyboard events.

4. The method for synchronizing input content in a MacOS synchronizer according to claim 1, characterized in that: The step 2 specifically includes: selecting a target program to be synchronized, starting at least two target programs, setting one of the target programs as a master control window, and setting the other target programs as slave control windows, injecting the main window dynamic library into the master control window through DYLD_INSERT_LIBRARIES, and injecting the slave window dynamic library into the slave control window through DYLD_INSERT_LIBRARIES; The step 3 is specifically as follows: the main window dynamic library starts a message transfer center, the message transfer center listens to the set port through unixsocks and receives socket messages, the slave window dynamic library sends a registration message to the set port, the message transfer center receives the registration message, and the registration from the slave window dynamic library to the message transfer center is completed.

5. A device for synchronizing input content in a MacOS synchronizer, characterized in that: include: Set the dynamic library module, set the main window dynamic library and the slave window dynamic library; Inject the dynamic library module, select the target program to be synchronized, start at least two target programs, set one of the target programs as the main control window, and set the other target programs as slave control windows; inject the main window dynamic library into the main control window, and inject the slave window dynamic library into the slave control window; The registration module is started, the main window dynamic library starts a message transfer center, and the slave window dynamic libraries are all registered to the message transfer center; A keyboard event module, wherein the main window dynamic library captures keyboard events of the main control window; If the keyboard event is an NSEventTypeKeyDown event and an NSEventTypeKeyDown event, sending the NSEventTypeKeyDown event and the NSEventTypeKeyDown event to the event queue of the message transfer center; Synchronous event module, if the message transfer center receives the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are deleted and not sent; after the insertText method is triggered, the text parameter received in the insertText method is sent to the message transfer center, and the message transfer center sends the text parameter to each slave window dynamic library, and each of the slave window dynamic libraries fills the text parameter into the corresponding slave control window; If the message transfer center does not receive the setupMarkText event within the second set time, the NSEventTypeKeyDown event and the NSEventTypeKeyDown event in the event queue are sent to each slave window dynamic library after delaying the first set time. Each slave window dynamic library controls the corresponding slave control window to perform corresponding operations according to the received keyboard event.

6. The device for synchronizing input content in a MacOS synchronizer according to claim 5, characterized in that: It also includes a prompt message module, which sets a synchronization status chart or animation on the device interface to prompt the user whether the current synchronization operation is successful.

7. The device for synchronizing input content in a MacOS synchronizer according to claim 5, characterized in that: The specific setting of the dynamic library module is: Create a main window dynamic library to monitor keyboard events on MacOS; First, register the listener in the static function Load of NSWindow; then, register the system listener through CGEventTapCreate(kCGSessionEventTap, kCGTailAppendEventTap, kCGEvent TapOptionListenOnly, eventMask, eventCallback, NULL) and set the eventMask value; finally, set the callback function eventCallback, which is used to forward keyboard events to the message transfer center; Create a slave window dynamic library for receiving the keyboard events; First, register with the message transfer center; then, receive the keyboard events forwarded by the message center; finally, execute the keyboard events.

8. The device for synchronizing input content in a MacOS synchronizer according to claim 5, characterized in that: The dynamic library injection module specifically includes: selecting a target program to be synchronized, starting at least two target programs, setting one of the target programs as a master control window, and setting the other target programs as slave control windows, injecting the main window dynamic library into the master control window through DYLD_INSERT_LIBRARIES, and injecting the slave window dynamic library into the slave control window through DYLD_INSERT_LIBRARIES; The startup registration module is specifically as follows: the main window dynamic library starts a message transfer center, the message transfer center listens to the set port through unixsocks and receives socket messages, the slave window dynamic library sends a registration message to the set port, the message transfer center receives the registration message, and the registration from the slave window dynamic library to the message transfer center is completed.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the program, the method according to any one of claims 1 to 4 is implemented.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the program is executed by a processor, the method according to any one of claims 1 to 4 is implemented.

Images