CN116521039B

CN116521039B - Method and device for moving covered view, electronic equipment and readable storage medium

Info

Publication number: CN116521039B
Application number: CN202310480147.4A
Authority: CN
Inventors: 陈裕聪; 唐如意; 叶松林
Original assignee: Chongqing Selis Phoenix Intelligent Innovation Technology Co ltd
Current assignee: Chongqing Selis Phoenix Intelligent Innovation Technology Co ltd
Priority date: 2023-04-28
Filing date: 2023-04-28
Publication date: 2024-04-02
Anticipated expiration: 2043-04-28
Also published as: CN116521039A

Abstract

The application provides a moving method and device of an overlaid view, electronic equipment and a readable storage medium. The method comprises the following steps: when a view of a current page is popped up and the current business requirement meets a preset first condition, performing screen capturing operation on a covered view behind the popped-up view to obtain a screen capturing with the same size as the covered view; after the screenshot is added into the first parent control, acquiring a first position offset of the first parent control according to the position data of the designated display area; judging whether the edge leakage condition of the first parent control relative to the current page exists or not according to the first position offset and the expansion and contraction operation aiming at the covered view; if the edge leakage condition exists, adding the first parent control into the second parent control, and acquiring a second position offset of the second parent control according to the position data so as to move the second parent control according to the second position offset. The technical scheme of the method and the device can solve the problem that the pop-up view covers the original view content.

Description

Method and device for moving covered view, electronic equipment and readable storage medium

Technical Field

The present disclosure relates to the field of computer technologies, and in particular, to a method and apparatus for moving a covered view, an electronic device, and a readable storage medium.

Background

In the development of iOS mobile operating systems, the problem of popup views overlaying the original view content after a view popup may be encountered.

When the pop-up view covers the original view content, the whole layout of the original view can be in an instance of UISCROL View, after the view pops up, the existing offset of the instance of UISCROL View is stored, the needed offset is calculated, and then the related offset attribute is set as the needed offset. In addition, the whole layout of the original view can be added into a UITableView instance or a sub-instance thereof, and a hidden input box control is added. In addition, the frame (frame) attribute of a certain parent view can also be adjusted.

The above solutions have various drawbacks, such as large and complex workload, complex calculation process, narrow application range, and no practical effect of view movement, so that the solutions for the problem that the pop-up view covers the original view content are not simple and efficient.

Disclosure of Invention

In view of this, embodiments of the present application provide a method, an apparatus, an electronic device, and a computer readable storage medium for moving an overlaid view, so as to solve the problem that a pop-up view overlays original view content.

In a first aspect of an embodiment of the present application, there is provided a method for moving an overlaid view, including: when a current page is popped up and the current business requirement meets a preset first condition, performing screen capturing operation on a covered view behind the popped up view to obtain a screen capturing with the same size as the covered view, wherein the first condition comprises: the current business requirements specify a specified display area of the overlaid view and the overlaid view is not movable by the user; after the screenshot is added into a first parent control, acquiring a first position offset of the first parent control according to position data of a designated display area in current service requirements; judging whether the edge leakage condition exists in the first parent control relative to the current page or not according to the first position offset and the expansion and contraction operation aiming at the covered view in the current service demand; if the edge leakage condition exists, adding the first parent control into the second parent control, and acquiring a second position offset of the second parent control according to the position data of the designated display area so as to move the second parent control according to the second position offset.

In a second aspect of embodiments of the present application, there is provided a mobile device for an overlaid view, the device comprising: the screen capturing module is used for carrying out screen capturing operation on the covered view behind the pop-up view when the current page is popped up in a view mode and the current service requirement meets a preset first condition, and obtaining a screen capturing with the same size as the covered view, wherein the first condition comprises the following steps: the current business requirements specify a specified display area of the overlaid view and the overlaid view is not movable by the user; the acquisition module is used for acquiring a first position offset of the first parent control according to the position data of the designated display area in the current service demand after the screenshot is added into the first parent control; the judging module is used for judging whether the edge leakage condition exists in the first parent control relative to the current page according to the first position offset and the expansion and contraction operation aiming at the covered view in the current service demand; and the moving module is used for adding the first parent control into the second parent control when the edge leakage condition exists, and acquiring a second position offset of the second parent control according to the position data of the designated display area so as to move the second parent control according to the second position offset.

In a third aspect of the embodiments of the present application, there is provided an electronic device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, the processor implementing the steps of the above method when executing the computer program.

In a fourth aspect of the embodiments of the present application, there is provided a computer readable storage medium storing a computer program which, when executed by a processor, implements the steps of the above method.

Compared with the prior art, the beneficial effects of the embodiment of the application at least comprise: according to the embodiment of the application, the covered view behind the pop-up view is subjected to screen capturing operation, the obtained screen capturing is added to the first parent control, the screen capturing is further added to the second parent control according to the edge leakage condition, and then the second parent control is moved according to the second position offset, so that the movement of the covered view is realized.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the following description will briefly introduce the drawings that are needed in the embodiments or the description of the prior art, it is obvious that the drawings in the following description are only some embodiments of the present application, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.

Fig. 1 is a flow chart of a method for moving an overlaid view according to an embodiment of the present application;

FIG. 2 is a schematic diagram of an edge leakage calculation provided by an embodiment of the present application;

FIG. 3 is a schematic diagram of offset calculation according to an embodiment of the present application;

fig. 4 is a schematic structural diagram of a mobile device with a covered view according to an embodiment of the present application;

fig. 5 is a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

In the following description, for purposes of explanation and not limitation, specific details are set forth, such as particular system configurations, techniques, etc. in order to provide a thorough understanding of the embodiments of the present application. It will be apparent, however, to one skilled in the art that the present application may be practiced in other embodiments that depart from these specific details. In other instances, detailed descriptions of well-known systems, devices, circuits, and methods are omitted so as not to obscure the description of the present application with unnecessary detail.

In the related art, when the pop-up view covers the original view content, the entire layout of the original view can be in an instance of uiscollolview (scroll view), after the view pops up, the existing offset of the uiscolview instance is stored, the required offset is calculated, then the related offset attribute is set as the required offset, and after the view disappears, the existing offsets of the attributes are restored. This approach may require a large number of view level transitions, is labor intensive and complex, and is prone to errors. Furthermore, conversion between a plurality of coordinate systems is involved, and the calculation process is complicated.

When the pop-up view covers the original view content, the whole layout of the original view can be further added with a hidden input frame control in a UITabaleView instance or a sub-instance thereof. On the system level, if an input box control is placed in a certain table of UITableView, after clicking the input box control, the keyboard pops up, and the TableView automatically shifts, so that the content of the table is displayed. The method has a narrow application range, only supports certain offsets when the UITableView is popped up by the keyboard, and only supports offset specified by the system and offset in the vertical direction.

The frame (frame) attribute of a certain parent view may also be adjusted when the pop-up view overlays the original view content. However, under automatic layout, the frames of a certain parent view may be refreshed, and then the frames may follow the rules of the automatic layout again, so that the views return to the original positions after shaking, and are not actually effective. Furthermore, adjusting the frame attribute involves a transformation between multiple coordinate systems, which is computationally complex.

When the pop-up view covers the original view content, the three schemes can be combined, the parent view is always searched upwards along the view level tree, the UiscrollView instance is adjusted when the UiscrollView instance exists, and the frame attribute of the root parent view is adjusted when the UiscrollView instance does not exist. In addition to the disadvantages of the three schemes, the method also has the advantages that because the frame of the root parent view is specified by the system, even if the program is temporarily adjusted, once the screen is turned or refreshed, the method can be restored, and the random adjustment of the parent view can cause the view to fail to meet the service requirement.

The above schemes have the common disadvantage that the offset is calculated and the flexibility is poor; and user interaction is not supported, where to display where to manually slide.

In order to solve the above problems, the embodiments of the present application provide a movement scheme of a covered view, which simply and efficiently solves the problem that a pop-up view covers the original view content.

One UIView in the embodiments of the present application has 2 coordinate systems: the coordinate system of the parent view and the coordinate system of itself. The own coordinate system is the "parent view coordinate system" of its child views. The coordinate system of a parent view of the UIView is represented by the frame attribute of the UIView class, the self coordinate system of the UIView is represented by the bounds attribute of the UIView class, and the value of the self center point of the UIView under the coordinate system of the parent view is represented by the center attribute of the UIView class. Wherein the center attribute describes the location of the center point of the current view in its parent view. frame and bounds are combined by center so that conversion between different coordinate systems is free.

The origin of the uiniew's bounds is the origin of its own coordinate system, with both x and y attributes, which defaults to the upper left corner of the view. The origin may be assigned a value, such as (x: 10, y: 10), meaning: "the upper left corner of the view, once (0, 0), but now changed to (10, 10)", the sub-views will be shifted accordingly: move 10 to the left and move 10 upward. Meaning that if a uiniew's origin attribute is positively valued, its child view is shifted left/up based on the original position by the absolute value of the number; if a uiniew's origin attribute is given a negative value, its child view is shifted right/down based on its original position, the offset being the absolute value of the number.

The following is an explanation of nouns in the examples of the present application:

control: individual elements on the page, such as buttons, pictures, rectangular areas, etc.

View: a relatively independent block of controls.

Page: app (application) content of the whole screen is composed of views and controls.

Uikiew: the vast majority of controls and base classes of views. The control and view may be UIView or some subclass thereof.

The following describes in detail a moving method and apparatus of a covered view according to an embodiment of the present application with reference to the accompanying drawings.

The specific implementation steps of the scheme are highly dependent on service requirements and the original view implementation mode of the rear view, and the input-dependent execution logic can be packaged into a device. After the service logic generating device and the configuration file are transmitted into different parameters according to external scenes, different branches are called, and the purpose of different effects under different scenes is achieved.

The specific implementation method of the device is various, 1 public function can be generated, the public function receives the parameters a, b, c and d … …, each parameter corresponds to the requirement of different service requirements, for example, a corresponds to whether a display area needs to be specified, b corresponds to whether interaction of a user is needed, c corresponds to whether the original interaction of a rear view needs to be reserved, wherein the rear view is the covered view. d corresponds to whether this is a pop-up or a retract scene, e corresponds to a setting on some other detail, such as background color … … after the edge leaks out. Different logical branches may be selected for execution depending on the entry. It is also possible to generate 1 common class, which is a single instance, the life cycle is the same as App, and it has attributes a, b, c, d … …, each corresponding to a different requirement of service requirements, the external scene sets these attributes directly/through an access method or an initialization function profile according to its own requirements, and invokes the execution function execution logic of the common class. The execution function reads the value of the attribute and selects to execute different logic branches according to the value.

Further, different parameters transmitted to the device by different external scenes can be preconfigured in a file, and the file can be updated and iterated along with the development of App. For example: the logic corresponding to the page a is that the parameter a=no need of designating a display area, the parameter b=need of interaction of a user, and c=need of retaining original interaction of the rear view. d=pop-up scene. The logic corresponding to the scene b of the page a is that the parameter a=needs to specify the display area, the parameter b=does not need interaction of the user, and c=does not need to reserve the original interaction of the rear view. d=pop-up scene. The logic corresponding to the scene a of the page B is that the parameter a=no need to specify the display area, the parameter b=need to interact by the user, and c=no need to reserve the original interaction of the rear view. d=pop-up scene. The formats of the files include, but are not limited to, files, database files, property list (plist) files, class/method/variable storage in memory, and binary streams. The storage place of the file includes but is not limited to a bundle (bundle), a local memory, a sandbox, a local database and a server side.

In the process of updating the file, in the development stage of the App, the file is placed in an installation package of the App, and meanwhile, one copy of the file is stored in a server. When the App is started for the first time or when the App is updated and started, the file content in the App installation package is read into the memory and copied to the sandbox address, and if the database at the mobile phone end is used, the file content can also be copied to the database. In addition, the server interface can be requested, and after the latest file at the server end is obtained, the file content of the bundle+local memory+sandbox+database of the App is updated. The files at the server end can be updated at any time, so the files are regarded as the latest version, the priority of the files is higher than that of the files at the client end, and the files at the client end are covered in time after the files at the server end are obtained. In addition, when the relation appointed by the service requirement needs to be updated, related fields in the memory can be updated in time and synchronously updated to the bundle+sand box+database+server side.

Taking the implementation of iOS as an example, the specific implementation method is as follows: reading the file content in the App installation package into a memory, accessing the main attribute of the class Bundle, accessing the path (ofType) method of the main, transmitting the parameters of the method into the name of the file in the package to obtain the full path of the file in the App installation package, then calling the initializing method Data (contentsOf) of the class Data, transmitting the parameters of the method into the full path to obtain the binary stream of the file, then calling the json session method, converting the binary stream of the file into a combination of basic Data formats which can be identified by programs, and then converting the combination into a device, thus finishing the memory reading.

The data of the interface pool is converted into an instance of a binary stream NSData by the related data methods of the NSKeyedUnarchiver class and the NSKeyedArchiver class, and then the instance is written into a path corresponding to the sandbox according to the methods of the writeToFile or the writeToURL of the NSData.

When the interface set data in the memory is copied to the database, a library file of the sqlite3 database can be introduced, a C language function sqlite3_open (,) is called to create a database link, a path of a local database format file is transmitted to the function, a data structure in the memory is spliced into SQL (Structured Query Language ) sentences needed by the database, and the database is written by the methods of sqlite 3_preparation_v2 (), sqlite3_final (), and the like.

When the files of the App installation package are copied into the sandbox, the files can be copied into the sandbox by using a copyItem (atPath: toPath:) method of a FileManager, and the path of the sandbox can be obtained by NSSearchPathFormodieisInDomains (:), or can be obtained by a URL (Uniform Resource Locator ) method of URL (for: in: app rinafor: create:).

When the files of the App installation package are copied into the database, the contents of the files can be read out according to the description, the contents of the files are converted into data in the memory, and then the data are assembled into SQL sentences to be written into the database.

In the embodiment of the application, a device class of a mobile device of the covered view can be defined, and the device is introduced into the App item and can be used for realizing the mobile scheme of the covered view of the embodiment of the application. Specifically, the device class should be a single instance, with the same life cycle as the App, that is instantiated at the start of App.

The device can store the popup view instance, store whether the action of the current view is popup or retrace, store the rear view instance needing to be processed, store the appointed display area on the rear view instance needing to be processed and store specific content which is appointed by service requirements, such as: size, location, and rules of display, e.g., if it is desired to zoom in/out the rear view, if not, to preferentially display the top/bottom/left/right/middle/top left of this area, etc. The designated display area refers to the portion of the overlaid view that needs to be fully displayed after it has been moved.

When the view pops up, the stored related information can be acquired, and a corresponding sliding effect, namely logic A, of the rear view instance to be processed, namely the covered view instance, is set according to the service requirement.

When the view is retracted, logic B needs to be executed when retracting. Logic a and logic B may be packaged as a common function or common tool class as they may be called multiple times in App.

Fig. 1 is a flow chart of a method for moving an overlaid view according to an embodiment of the present application. The method provided by the embodiment of the application can be executed by any electronic device with computer processing capability, such as a terminal or a server. As shown in fig. 1, the moving method of the covered view includes:

step S101, when a current page is popped up in a view mode and current service requirements meet a preset first condition, performing screen capturing operation on a covered view behind the popped up view to obtain a screen capturing with the same size as the covered view, wherein the first condition comprises: the current business requirements specify a specified display area of the overlaid view and the overlaid view is not movable by the user.

Step S102, after the screenshot is added to the first parent control, a first position offset of the first parent control is obtained according to position data of a designated display area in the current business requirement.

And step S103, judging whether the edge leakage condition exists in the first parent control relative to the current page according to the first position offset and the expansion and contraction operation aiming at the covered view in the current service demand.

Step S104, if the edge leakage condition exists, adding the first parent control into the second parent control, and acquiring a second position offset of the second parent control according to the position data of the designated display area so as to move the second parent control according to the second position offset.

Since different views have different pop-up notifications, before step S101, the pop-up or retraction timing of any of the following pop-up views may be monitored to determine that the current page has a view to be popped up: the middle part pops up the prompt box, pops up the keyboard, pops up the card at the bottom, and the self-defining pops up the view.

Specifically, for the middle popup prompt box, the implementation is realized by a system control UIAlertController, and can also be realized by a self-defined uiiviewcontroller. The present (or, an authorized) method of the uiv/iwcontroller class of the iOS system is called when the view pops up, and the distss (or, an authorized) method of the uiv/iwcontroller class of the iOS system is called when the view pops up. Therefore, the API capable of realizing the timing capturing method of the middle pop-up prompt box needs to utilize the iOS method exchange technology to modify the system mechanism, acquire the pop-up function of the pop-up box in the form of present, insert the custom logic A into the function, acquire the recovery function of the pop-up box in the form of present, and insert the custom logic B into the function.

Specifically, an extension can be added to the class of UIViewController, and the first method is written in the extension: custom present (registered:) method, but note that the name of this method must begin with custom strings to distinguish from the system's present (registered:) method name, which in this embodiment may be named: ivy _present (a), authenticated:). This method may be preceded by an @ obj C modifier to be visible to Objective-C, so that the dynamic dispatch mechanism of Objective-C may be used.

In addition, a static method can be customized. Logic exchanged in the write-in mode. Specifically, calling a system function class_getInstanceMethod to obtain the realization of a present (an authorized) function of the system; the system function class_getInstanceMethod is called to obtain the implementation of the step ivy _present (a_authenticated:) method, and the method_exchange implementations () method is called to exchange the implementation of the two methods.

Alternatively, logic A may be described in the implementation of the custom ivy _present (registered:) method, and then the implementation of the custom ivy _present (registered:) method is called again at the end. The method can be switched by the custom static method at the beginning of the program start.

Specifically, for a pop-up keyboard, the iOS system will send two system notifications in succession when the keyboard pops up. The method comprises the following steps of: uiirespoonder.keyboard willshownotification and uiirespoonder.keyboard dieshownotification.

The uiiresponder, keyboard willshownotification is a notification when the keyboard is about to pop up but is not actually displayed on the interface, but is accompanied by information such as the position size of a rectangular area to be drawn by the keyboard. Uiiresponder.keyboard di shownotification is a notification when the keyboard has been ejected and displayed on the interface. When the keyboard is retracted, the system sends two system notifications in succession.

The two system notifications are respectively: uiiresponder.keyboard willhi deNotification and irisponder.keyboard di hideNotification.

The uir response, keyboard willHideNotification is a notification that the keyboard is about to disappear, and the irresponse, keyboard DidHideNotification is a notification that the keyboard is about to disappear.

Thus, the acquire view popup/recycle information API can notify IResponder. KeyBoard WillShowNotification and the two systems according to the service requirement when the keyboard popup

Optionally one of uiiresponder.keyboard didshownotification listens, or both notifications listen together.

The view pop-up/recycle information acquisition API can notify the UIREspoonder, keyBoard WillHideNotification and the UIREspoonder, the keyBoard WillHideNotification and the UIREspoondment, respectively, in two systems according to service requirements when the keyboard is retracted

Optionally one of the IResponder. KeyBoard DidHideNotification listens, or both notifications listen together.

Therefore, the API that can implement the timing acquisition method of popping up the keyboard needs to call logic a in the response function of listening to the keyboard pop-up and call logic B in the response function of listening to the keyboard retract.

Specifically, for bottom pop-up cards, the iOS system may be implemented by a system control UIAlertController, or may be implemented by a custom uiiiewcontroller. The difference between the capturing of the timing of popping up the keyboard and the capturing of the timing of popping up the prompt box in the middle part of the two system controls is the difference between the attribute settings such as the type setting, the animation setting, the position setting and the like of the class. Further, the bottom pop-up card may be a preview card implemented by the uiactigyviewcontroller class.

The three bottom views of the middle pop-up prompt box, the pop-up keyboard and the bottom pop-up card can call the present (closed) method of the UIIViewController class of the iOS system when the views are popped up. When the view is retracted, a method of disis (an updated) of the uiiviewController class of the iOS system is called, so that the method of capturing the opportunity is the same as the method of capturing the opportunity of popping up the prompt box in the middle, and the API of the method needs to modify a system mechanism to acquire the popping up/retracting information of the pop-up box in the form of present.

Specifically, for custom pop-up views, since the pop-up and pop-up functions of the custom view are custom and are known to the program, logic A may be invoked in the pop-up function and logic B may be invoked in the pop-up function.

In the embodiment of the present application, a logic a describing view pop logic and a logic B describing view retract logic are presented. The logic A has different implementation modes according to different service demands, and can select different branches according to the service logic demands of the App.

In the embodiment of the present application, different preset conditions may be formed according to different service requirements. Wherein, in a preset first condition, the current business requirement designates a designated display area of the covered view and the covered view cannot be moved by the user. In this first condition, the overlaid view is not movable by the user, i.e. no user interaction is required on behalf of the view, the user cannot view the view by himself by a gesture such as a swipe or zoom, nor does the original interaction of the original overlaid view be supported.

In a preset second condition, the current business requirement specifies a specified display area of the overlaid view and the overlaid view is movable by the user.

When the first condition is met, according to the service requirement, the logic A is realized by the following steps: first, step S101 is executed to perform a screen capturing operation on the covered view, and a screenshot corresponding to 1 of the original view is obtained.

There are many ways to implement the screenshot in an iOS system, one way is to call

The UIGnetics BeginImageContextWithoptions method opens a picture context; and calling a draw Hierarchy (in: afterScreen updates) method for the rear view, capturing a video, transmitting a first parameter into a bounds attribute value of the rear view, wherein bounds is the size of the whole rear view for capturing a large range, calling Uiggraphic GetImageFromCurentImageContext () to obtain a captured picture Uiimage type example, and calling Uiggraphic EndImageContext () to close a picture context.

Another way is to call the uigitics beginimagecontextwithoptions (a) method and the uigitics endimagecontext () method to get one screenshot can be replaced with the uigitics imagerenderer instance and its method. Specifically, an UIGnetics ImageRenderer instance is generated, an init (size:) method is called, parameters of the method are transferred into the value of the bounds attribute of the rear view, then an image (_:) method of the IGGnetics ImageRenderer instance is called, the parameters of the method are transferred into a function, and the internal logic of the function is as follows: the draw Hierarchy (in: afterScreen updates) method is called for the fixed rear view, and the return value UIIMage class instance of the image (:) method is the screenshot.

Wherein, the drawHierarchy (in: afterScreen updates:) of the two modes can be replaced by a render (in:).

Yet another way is to call the uigeractigics beginimagecontextwithoptions (in:), which is to open a picture context, call the uigeractgermentcontext () to get a picture context, access the layer attribute of the back view to get its presentation layer, call render (in:) to the layer, and parameter transfer to get the picture context; recall

Uighaphicsgetimagefromcurrentimagecontext () obtains a screenshot picture UIImage class instance; and calling UIGnetics EndImageContext () to close the picture context.

Yet another way is to call the uigitics beginimagecontextwidthooptions (a, a) method and the uigitics endimagecontext () method to get one screenshot may be replaced with the uigitics imagerenderer instance and its method. Specifically, an Uiggraphic image renderer example is generated, an init (size:) method is called, parameters of the Uiggraphic image renderer example are transferred into the value of the bound attribute of the rear view, then an image (_:) method of the iggraphic image renderer example is called, the parameters of the function are transferred into a function, the internal logic of the function is that the parameter context of the function is accessed, the cgContext attribute of the function is accessed to obtain a picture context, the layer attribute of the rear view is accessed to obtain a presentation layer of the function, a render (in:) is called for the layer, and a returned value UIImap type example of the image (_:) method is the screen capturing picture.

Yet another way is to invoke an instance method for a rear view

The returned value obtained is a Uiview instance, and the display content of the returned value is a screen capture picture. Wherein invoking the latter instance method may support that the size of the picture may be changed.

After step S101 is performed, step S102 and step S103 may be performed, and the screenshot is added to a parent control to obtain/calculate its offset, and solve the problem of edge leakage. The parent control may be referred to as a first parent control subpaent. When the return value obtained is a uiv instance, the uiv instance is already a subpant.

The offset is the first position offset. The first position offset may be set directly by the service requirement, or may be obtained by simple calculation according to the service requirement. The manner of calculating the offset is different depending on the view to be moved. In step S102, a starting position and a target position of a specified display area in the current service requirement may be acquired; and acquiring a first position offset according to the position of the pop-up view, the starting position and the target position.

For example, the business requirement may directly set the offset (x: 100, y: 100), or may set the position of the designated display area as follows: there is a (x: 50, y: 50) separation from the origin of the pop-up view. In the second case, the first positional shift amount needs to be calculated. The specific process is as follows:

for the x-axis, the specified display area x-present value = origin x-value of the pop-up view +50, the offset on the x-axis = specified display area x-present value-specified display area home position x-value.

For the y-axis, the designated display area y present value = origin y value of pop-up view +50, the offset on the y-axis = designated display area y present value-designated display area home position y value.

In addition, the business requirement may set the location of the designated display area as: above the pop-up view, the size of the display (x: 80, y: 80) of the display area needs to be specified, and if not, the area above the specified display area is preferentially displayed.

In this case, the specific procedure for calculating the first positional deviation amount is:

calculating the size of the partial remaining area on the screen after popup view: the remaining area size on the y-axis = screen height-pop-up view upper edge coordinate y-value, determine if it is less than 80. If less than 80, since the upper side of the designated display area is preferentially displayed, the present value of the designated display area y=0 is obtained. If the value is larger than 80, the current value of the designated display area y=the size of the remaining area on the y axis-the height of the designated display area is obtained, and the offset value on the y axis=the current value of the designated display area y-the original position y value of the designated display area is obtained.

In step S103, when the edge leakage condition is judged, if the offset makes the edge of the screenshot visible to the user, the distance between the edge and the screen edge must be subjected to extension processing: to be set to a blank with no content. In terms of color, the color can be set to be the same as the background color of the rear view according to business requirements; or to the same color as the parent view background color of the rear view.

In particular, if the screenshot obtained in step S101 is an UIImage class instance, it needs to be added to a control to be shown on the page. The control is a first father control, and can be a UIView type instance or a CALayer type instance. If the screen shot obtained in step S101 is a uiiview class instance, it may be directly used, and may be displayed on the page.

If the first parent control subParent is a UIView class and its sub-class instance, a UIView class and its sub-class instance may be created to carry the screenshot.

For example, a UIImageView instance may be created, which is a sub-class of uikiew, dedicated to picture presentation. The attribute image may be assigned to the UIImage class instance described above. The subpaent is the UIImageView class instance.

In addition, a UIView class instance may be created, the layer attribute of the instance accessed, and an addSubLayer (a) invoked thereto, then a new layer is added thereto. Specifically, a new layer may be created, and the attribute content of the layer may be set to the CGImage attribute of the UIImage class instance described above. The new layer is passed as a parameter into the addSubLayer method. subParent is the instance of the UIView class.

In addition, a UIVIEw class instance can be created, a drawing (in) method is rewritten, the UIGnetics GetCurrentContext () method is called to acquire the current context of the picture in the drawing (in) method, and the drawing (at) or drawing (in) method of the UIImage class instance is called to draw the picture.

In the embodiment of the application, the designated display area on the covered view example to be processed and whether the covered view needs to be reduced/enlarged for display and the corresponding scaling ratio can be obtained according to the parameters of the logic A. If the overlaid view needs to be zoomed out/zoomed in, the actual size of the UIImageView instance zoomed out/zoomed in is calculated and given back the size (size) attribute that characterizes the position and size attribute in its own coordinate system. New size = original size scaling ratio. This step is skipped if there is no need to zoom in/out the overlaid view.

In step S103, if it is determined whether or not there is an edge leak based on the first positional displacement amount, if there is no reduction/enlargement, only a simple displacement is used to confirm the edge leak. If there is a shrink, the edges must leak out. If there is amplification, it is necessary to confirm after calculation if there is edge leakage.

As shown in FIG. 2, in an example of a UIImageView example enlargement, it is calculated whether there is edge leakage on the X axis. First, the maximum x value of the instance 203 amplified by the UIImageView instance 202 in the page 201 is calculated simply as: xMax. The maximum x value of the shifted example is: xmaxnew=xmax-offset delta, the original maximum x of UIImageView instance is obtained from the parameter storage popup view instance of logic a, and whether the edge leaks out is judged: and judging whether xMaxNew-original maximum x is more than 0. If the value is greater than 0, there is no edge leakage, and if the value is less than 0, there is edge leakage. The calculation method on the Y axis is similar to that on the x axis, and is not repeated.

If there is no edge leakage, there are two alternatives. In one scheme, subParent adds an instance of UISProliview class as its sub-view, which can be called as a parenView, the size of which is consistent with the size of the rear view, and adds the parenView to the existing view hierarchy, which is located at the upper layer of the rear view, but does not obstruct the pop-up view.

In particular implementations, a UISCROLView class instance (or sub-class thereof) may be created as the parenView, with the subpaent instance added to the parenView. Specifically, the addsubView (:) can be called for the parenView, parameters are transmitted into the subpaent, the parenView is added to the parent view of the rear view, the addsubView (:) is called for the instance of the parent view class of the rear view, and the parameters are transmitted into the parenView, so that the purpose of covering the rear view is realized. In addition, an insert sub view (a: aboveubview:) method can be called for the parent view of the rear view, the first parameter is transmitted into the paretview, the second parameter is transmitted into the rear view, and the purpose of covering the rear view can be achieved.

In another scheme, subpaent is directly added into the existing view hierarchy and is positioned at the upper layer of the rear view, but the pop-up view is not blocked. In particular implementations, subpaent is added to the parent view of the rear view, addsubpaview is called to the parent view, and parameters are passed to subpaent. I.e. the purpose of covering the rear view is achieved. In addition, an insert view method can be called for the parent view, the first parameter is transmitted to the subpart, the second parameter is transmitted to the rear view, and the purpose of covering the rear view is achieved.

After step S104, the color of the leakage edge may be changed according to the color setting of the leakage edge in the current business requirement. In particular, if there is edge leakage, two solutions can be provided according to the traffic demand. For example, the business requirements may be: the edge is required to be set to the same color as the background color of the rear view or the edge is required to be set to the same color as the background color of the parent view of the rear view.

When the business requirement requires that the edge be set to the same color as the background color of the rear view, a UIView class instance, called parentView, may be created, invoking its addsubsview (i) method, turning subspartent into a sub-view of the parentView. Setting the background color attribute backgroupcolor of the pantview as the background color of the rear view, wherein the size of the pantview is the same as that of the rear view. If the rear view background color is transparent: the UIColor.clearColor also needs to hide the rear view, acquire the parent view of the rear view, call its addSubView (:) method, and add the panetView to the parent view.

There are two implementations when business requirements require that the edges be set to the same color as the parent view background color of the rear view. One approach is to add subpaent directly to the existing view hierarchy, to be located at the top of the rear view, and to hide the rear view. Because the rear view is hidden, the background color of its parent view is revealed. Another approach is to add subpaent to an instance of the uisprolview class, which may be referred to as parenview, which is now the parent view of subpaent. The size of the pantview is consistent with the size of the rear view. And adding the UiscrolView class instance into the existing view hierarchy, wherein the UiscrolView class instance is positioned at the upper layer of the rear view, but the popup view is not blocked. The background color of the uiiscollview class instance may be set to transparent and subpaent to the original color of the rear view so that the background color of its parent view may appear.

In the embodiment of the present application, if the first parent control SubParent is implemented by using a layer class and its child instances, a layer instance may be created, and its attribute content is assigned as the UIImage class instance described above. This example of a layer is subpart. Further, the designated display area on the covered view instance to be processed and whether the covered view needs to be zoomed out/zoomed out and the corresponding zoom ratio may be obtained according to the parameters of logic a. If the overlaid view needs to be zoomed out/zoomed in, the actual size of the UIImageView instance zoomed out/zoomed in is calculated and given back the size (size) attribute that characterizes the position and size attribute in its own coordinate system. New size = original size scaling ratio. This step is skipped if there is no need to zoom in/out the overlaid view. Further, it may be determined whether there is an edge leak based on the first positional deviation amount.

If there is no edge leakage, there are two alternatives. One approach is to add subpaent to a casrollayer class instance, which may be referred to as pantview, which is uniform in size with the rear view. And adding the pantView into the existing view hierarchy, wherein the pantView is positioned at the upper layer of the rear view, but does not shade the popup view. In particular, a CAScrollLayer class instance may be created as a parentView, and subpaent may be added to the parentView: an addsubtlayer is called for the parenView, parameters are passed into the subpaent, and the parenView is added to the rear view parent view: an addSubLayer (a) is called for the rear view parent view class instance, and parameters are passed into the paretView. I.e. the purpose of covering the rear view is achieved. In addition, an insert sub layer (at) method can be called for the parent view of the rear view, the first parameter is input into the parentView, the second parameter is input into the hierarchical index +1 of the parent view, and the purpose of covering the rear view can be achieved.

In another approach, subpaent may be added directly to the existing view hierarchy, at the top of the rear view, but without obscuring the pop-up view. In particular, the subpaent is added to the parent view of the rear view, the addsubpayer (a) is called for the parent view, and the parameter is transmitted into the subpaent. The purpose of covering the rear view is realized, an insert Sublayer (a: above) method can be called for the father view, the first parameter is transmitted into the subpant, and the second parameter is transmitted into the layer attribute of the rear view, and the purpose of covering the rear view is also realized. In addition, an insert Sublayer (at) method can be called for the parent view, the first parameter is input into the subpant, the second parameter is input into the hierarchical index +1 of the parent view, and the purpose of covering the rear view can be achieved.

Specifically, if there is edge leakage, the following two solutions can be provided according to the traffic demand: when the service requirement requires that the edge be set to the same color as the background color of the rear view, a CALayer class instance, which can be called ParentLayer, is created, the addSubLayer (:) method is called, subParent is changed into the sub-view, and the background color attribute background color of ParentLayer is set as the background color of the rear view. If the rear view background color is transparent: the uiccolor.clearcolor.cgcolor also requires hiding the rear view and adding the ParentLayer to the parent view of the rear view.

When the business requirement requires that the edge be set to the same color as the background color of the parent view of the rear view, there can be three methods, one is to directly add subpaent to the existing view hierarchy, and to locate at the upper layer of the rear view, and to hide the rear view, and the background color of the parent view can be revealed. In the concrete implementation, the subpaent is added to the father view of the rear view, addsubpayer (a) is called for the father view, and the parameter is transmitted into the subpaent, so that the purpose of covering the rear view can be realized. The second method is to call an insert Sublayer (above) method to the parent view, the first parameter is transmitted to the subpart, and the second parameter is transmitted to the layer attribute of the rear view, so that the purpose of covering the rear view can be achieved. The third method is that an insert Sublayer (at) method can be called for the father view, the first parameter is transmitted into the subpant, the second parameter is transmitted into the back view to be at the level index +1 of the father view, and the purpose of covering the back view can be achieved. There are various ways to set the hidden rear view, for example: the value of the alpha attribute of the rear view is set to 0.0.

In the embodiment of the present application, if the first parent control subParent is implemented by using a CAScrolllayer class instance, the subParent may be added to a CAScrolllayer class instance, which may be referred to as parentView, where the size of the parentView is consistent with the size of the rear view. And adding the pantView into the existing view hierarchy, wherein the pantView is positioned at the upper layer of the rear view, but does not shade the popup view. The background color of the pantview instance is set to transparent, and subpaent is set to the original color of the rear view, so that the background color of the parent view can be revealed. In particular, a CAScrollLayer class instance may be created as a parrentView, and subpaent may be added to the parrentView instance: an addsubtlayer is called for the parenView, parameters are passed into the subpaent, and the parenView is added to the rear view parent view: an addSubLayer (a) is called for the rear view parent view class instance, and parameters are passed into the paretView. I.e. the purpose of covering the rear view can be achieved. In addition, an insert sub layer (at) method can be called for the parent view of the rear view, the first parameter is transmitted into the parentView, and the second parameter is transmitted into the hierarchy index +1 of the parent view, so that the purpose of covering the rear view can be achieved.

In step S104, there are various alternatives for setting the offset of the control. The second parent control may be moved according to the second position offset and a type of the second parent control, where the type of the second parent control may be any of: the uiiview class instance, uikrollview and its sub-class instances, cakrolllayer and its sub-class instances, are not limited thereto.

In this embodiment of the present application, after determining whether an edge leakage condition exists in the first parent control with respect to the current page according to the first position offset and the scaling operation for the covered view in the current service requirement, when the edge leakage condition does not exist, the position attribute of the first parent control in the self coordinate system may be modified according to the first position offset.

Specifically, if the parent control is not continuously encapsulated by the subpaent outer layer, the origin attribute of the parent attribute of subpaent can be directly set as an offset, and the negative value of the origin attribute is required. Such as: the offset is (x: 100, y: 100), representing that the rear view needs to be offset 100 in the x-axis and 100 in the y-axis. The origin attribute of the bounds attribute of subpart is set to (x: -100, y: -100).

If the second parent control is a uiiview instance, the position attribute of the second parent control in the self coordinate system can be modified according to the second position offset. That is, the origin attribute of the parent attribute is set directly as the offset, instead of the parent of the subpart, and note that the positive and negative values are: if moving up to the left, a positive value is taken, if moving down to the right, a negative value is taken. Because the parent control pantview functions primarily to handle edge leakage, including the area covering the edge and the color of the designated edge. The second effect is to move the subpaent as the parent window of subpaent when there is no edge leak. Therefore, the sub view, i.e., the sub part, of the orgin attribute of the parent attribute of the pantview is changed at this time to move toward the corresponding direction.

If the second parent control is uircollview and its child instance, the sliding position attribute of the second parent control may be modified according to the second position offset or the second parent control may be moved using a method of scrolling to a specified position.

Specifically, the contentOffset attribute of the pantView may be set as the calculated offset, or a scrollRectToViable (a: authorized) method of the pantView may be called, where the parameter one is the location information of the designated display area, and the type is CGRect.

As shown in fig. 3, in the page 301, a contentOffset attribute of the partyview, i.e., the second parent control 302, may be set as the calculated offset. Wherein the contentOffset attribute of UICRolView is the coordinates of the upper left corner of the current content of UICRolView under the coordinate system of UICRolView. After the offset of the specified display area is known, it may also be converted into a value required for contentOffset, where,

contentoffset. X=contentoffset x+ offset of current partetview.

contentoffset. Y=contentoffset y+ offset of current partetview.

Specifically, a scrollRectToViable method of the pantView can be called, wherein the parameter I is the position information of the fixed display area, and the type is CGRect.

If the position information specifying the display area is known, for example, the origin coordinate origin attribute of the display area position may be specified as (x: 30, y: 40) and the size as (width: 100, height: 100); directly transmitting the region information into a parameter one of a scrollRecttToViable (a: an authorized:) method; the second parameter is whether animation is required, where false can be entered.

In the embodiment of the application, if the position information of the designated display area is not determined, the position information of the designated display area can be obtained by simply converting the amount of the required offset of the designated display area.

For example, the business requirement setting specifies the location of the display area as: with a distance (x: 50, y: 50) from the origin of the pop-up view, the following can be calculated: for the origin position calculation on the x-axis, a display area x present value=origin x value of the pop-up view +50 is specified, and for the origin position calculation on the y-axis, a display area y present value=origin y value of the pop-up view +50 is specified.

Further, a method parameter-SCROLLRectToViable (: authenticated:) is entered into CGRec.

If the second parent control is CAScrollLayer and its child instance, the method of scrolling to the specified coordinate or scrolling to the specified position of the first parent control is used to modify the position attribute of the second parent control in the self coordinate system according to the second position offset, or the method of scrolling to the specified coordinate of the second parent control is used to modify the position attribute of the second parent control in the self coordinate system according to the second position offset.

Specifically, a scroll (to:) method of the pantview may be invoked, with the parameter being to set the origin of the bound of the control to a certain point. A variant of the parentView script (to:) method may also be invoked, whose parameters accept a CGRect type, i.e., a display area, and the parentView automatically adjusts the origin of its bounds to cause this area to be displayed. Therefore, the region to be displayed in the parameters of the logic A can be directly transmitted.

The subspecies' scroll (to:) method may be invoked and the parenView automatically adjusts the origin of its own bounds to cause the point at which the parameters of this method are located to be displayed. Therefore, according to the service requirement, a certain point of the parameters of the logic A, which needs to be displayed, is transmitted into the parameters.

The subpart's scroll RectToViable method may be called and the parentView automatically adjusts the origin of its bounds to cause the area CGRect where the parameters of this method are located to be displayed. Therefore, a certain area needing to be displayed of the parameters of the logic A can be transmitted into the parameters according to the service requirement.

When the second condition is satisfied, different preset conditions can be formed according to different service requirements. Wherein in a preset second condition, the current business requirement requires that the overlaid view be movable by the user. In this second condition, the current business requirement may or may not set a designated display area, and the covered view may be moved by the user, i.e., the user may view the view by itself through gestures such as sliding or zooming on behalf of the user, and the user may or may not support the original interaction of the original covered view.

The current business needs may or may not set the designated display area, meaning that the initially designated display area may not be designated, as the user may now be free to view any area of the rear view through interaction, so the initially designated display area may not be. In this case, the rear view does not slide to a certain area by default at the instant when the pop-up view appears. If there is a designated display area, the rear view will slide to an area by default at the instant the pop-up view appears.

When the second condition is met, when the covered view is moved, screen capturing operation can be carried out on the rear view, screen capturing of 1 to 1 of the original view is obtained, an initial designated display area is set or not set according to the actual condition of the second condition, and measures are respectively taken according to the technical scheme when the first condition is met and the initial designated display area is set or not set according to the technical scheme.

Further, a user interaction gesture may be added to the outermost parent control where the screen capture is located. If the outermost parent control where the screen capturing is located is a parentView, adding a user interaction gesture on the outermost parent control; if the outermost parent control where the screen capture is located is subpaent, that is, only one layer of control wraps the screen capture picture, a parent control needs to be added to subpaent to form a panetView. Because this layer of controls cannot move pictures.

In addition, the subpaent, if implemented in layers and its subclasses, cannot add user gesture interactions. Because the iOS layer can only show that interaction cannot be performed, this subpaent can be added to a UIView and its sub-class instance, and then gestures can be added to the UIView instance. There are a number of implementations that add this subpaent to a UIView and its sub-class instance.

For example, the layer of subpaent may be used as a layer default to uixiew, write a subclass inheriting from uixiew, and overwrite its overridden class varlayerclass: the AnyClass method returns to subpaent. The layer of the subpaent can also be added into the layer of the UIView, a UIView is instantiated, the layer attribute is accessed, an addsubpayer method is called for the layer, and parameters are transmitted into the subpaent.

When adding user interaction gestures, required gestures can be added according to business requirements. Gestures are iOS-provided functions. The system provides a number of simple default gestures: such as: click, long press, zoom, rotate, swipe, move, screen edge gestures, etc. These gestures can be freely combined directly, and the programmer can also fully customize any gesture that can be imagined.

For example, the user may view any area of the rear view through a swipe gesture of one finger. The increment of the point movement of the user's touch screen is the increment of movement of the rear view. For example: the user moves to the left and the content of the rear view moves to the left a corresponding distance. The specific implementation of the sliding gesture may be: an instance of the UIPaneGestureRecognizer class, abbreviated as taggettube, is created, and both an initialization method init (target: action) and an instance method addTarget (action) can be used for adding a response class and a callback method when a gesture is triggered. The first parameter is a response class and the second parameter action is a callback method. And calling an example method addGestureRecognizer (_) of the parenView, and transmitting parameters into the taggefuture to realize the adding gesture. There is also a parameter in the callback method, namely the gesture tagestur. The track curve of the user can be obtained by obtaining the current state of the gesture, so that the offset is obtained and set.

And calling the state attribute of the gesture to obtain the value, and if the value is belan, setting the offset variable of the x axis and the y axis to be 0. And calling the state attribute of the gesture to obtain the value of the state attribute, and if the state attribute is changed, obtaining the point position of the current finger of the user: the transfer function of the gesture is called, the parameter of the function is required to be the view of the gesture, so that the return value of the incoming pantView function is the increment of the displacement of the gesture, and the increment is added to the offset variable of the x axis and the y axis, namely the offset value.

When the offset of the content of the father control at the outermost layer is set, the method for setting the offset is different according to different specific types of the father control at the outermost layer. If the outermost parent control is a common UIView instance or a common CALayer instance, the origin attribute of the parent control is set. If the outermost parent control is UISPROLView and its child instance, setting according to the technical scheme that the first parent control in the technical scheme is UISPROLView and its child instance.

In summary, when the current page has a view popped up and the current service requirement meets a preset second condition, a screen capturing operation can be performed on the covered view behind the popped up view to obtain a screen capturing with the same size as the covered view, where the second condition includes: the current business requirements specify a specified display area of the overlaid view and the overlaid view is movable by the user; after the screenshot is added into a first parent control, acquiring a first position offset of the first parent control according to position data of a designated display area in current service requirements; judging whether the edge leakage condition exists in the first parent control relative to the current page or not according to the first position offset and the expansion and contraction operation aiming at the covered view in the current service demand; if the edge leakage condition exists, adding the first parent control into the second parent control, and adding a command gesture for the second parent control; and when a command gesture signal generated when the user performs command gesture operation on the second parent control is received, acquiring a third position offset according to the command gesture signal, and moving the second parent control according to the third position offset.

Further, when the current page has a view popped up and the current service requirement meets a preset third condition, a screen capturing operation can be performed on the covered view behind the popped up view to obtain a screen capturing with the same size as the covered view, wherein the third condition includes: the current business requirements do not specify a specified display area of the overlaid view and the overlaid view is movable by the user; adding the screenshot into a first parent control, and adding a command gesture for the first parent control; when a command gesture signal generated when a user performs command gesture operation on the first parent control is received, acquiring a fourth position offset according to the command gesture signal, and moving the first parent control according to the fourth position offset.

In some solutions in the embodiments of the present application, when the current service requirement meets a preset second or third condition, the original gesture of the rear view and the sub-view thereof may be masked. In the mechanism of the iOS system, when a user interacts with the screen, all gestures that contain this interaction point will respond throughout the view hierarchy. Therefore, the original gestures of the rear view and the sub-views thereof may collide with newly added gestures/events, and in order to solve the collision, all the original gestures need to be disabled, and only the added gestures in the embodiment of the application are responded.

Specifically, the sub view attribute of the rear view can be traversed, which is the first layer sub view, and the sub view of the sub view can be obtained by continuously traversing the sub view attribute of each sub view; this process loops until all descendant views of the rear view are referenced, prohibiting their gesture+UIControl event for each node. The forbidden gesture can be implemented by accessing the postureRecognizers attribute of the node, namely, all the gestures added on the node, circularly accessing the gesture array, assigning the isEnabled of each gesture as false, and forbidden gestures. It rewrites the geturerecognsizersholdbegin method for each node, returning the false value. The other is to prohibit its UIControl event: and judging whether the type of the node is UIControl type or not by using the is keyword. If so, the isenable attribute for the node is set to false and the iseserinteractionEnabled attribute for the rear view is set to false.

Alternatively, the original gesture may not be masked. Under this scheme, the original gestures of the rear view and its sub-views may collide with newly added gestures/events. iOS also provides a wide variety of solutions between several gestures for conflicts if they are, which is a conventional means for iOS to resolve conflicts.

For example, gesture a superimposed on the rear view, gesture B superimposed on a sub-view of the rear view, where a and B conflict, a priority between two gestures may be set: when a user interaction occurs, firstly enabling A to be recognized, if the user interaction succeeds, enabling B to be recognized again if the user interaction succeeds, and calling a requiring (toFail:) method for B, wherein parameters are transmitted into the A. Alternatively, the proxy method of A or B, gelfureRecognizer (: shouldRequireFailureof:) or gelfureRecognizer (: shouldBeRequiredTiloFailBy:), may be implemented with the same effect.

In another example of resolving conflicts, a and B conflicts, a priority between two gestures may be set: when a user interaction occurs, firstly, the A is recognized and completed, the B can be continuously recognized, and finally, two gestures can be executed: and (3) rewriting the gelsemiRecognizer (_: shouldbecognitzesimultaneslywidth) method for the proxy delete class of B or A, and returning to true.

In yet another example of resolving conflicts, a and B conflicts, a priority between two gestures may be set: when a user interaction occurs, firstly enabling the A to be identified, if the A identification result is successful, enabling the B to be identified again: the proxy delete class of B is rewritten with the funcestureRecognizer ShoutBegin (g: UIGstureRecognizer) - > Bool method, and if the state of A is. Posable or. Failed, return to false, meaning: the gesture A is not recognized successfully yet, and the gesture B cannot be started to be recognized; if the state of A is other, return true, meaning: the gesture a has been successfully recognized and the gesture B can begin to recognize. And (3) rewriting the gelsturerecognizer (: shouldregnsizeimultaneous slyWith) method in the proxy delete class of B, and returning to true.

In some schemes in the embodiments of the present application, when the current service requirement meets the preset second or third condition, a rear view may be modified or installed into an UIScrollView and its sub-class instance. If the rear view is implemented with UISCROLView and its subclasses, the purpose may be achieved by setting some properties. If the rear view is not implemented by UISPROLView and its sub-class, but only ordinary UIView and its sub-class, the rear view can be fetched from the view hierarchy, loaded into a UISPROLView and its sub-class, and the parent UISPROLView is put back into the hierarchy where the rear view was originally located. Some properties of this instance are set again for this purpose. Specifically, an instance of uiiscollview and its subclasses, called parent, may be created. The parent calls addsubtview (a), parameters pass into the rear view. After adding the rear view to the parent, the parent of the rear view calls addsubtview, the parameters are passed into the parent, and the parent is now placed in the hierarchy where the rear view was originally located.

In the case that the user can view the rear content by himself/herself through a gesture such as sliding, zooming, etc., if only the gesture is sliding or zooming, UIScrollView and its subclasses have satisfied the requirements; if other gestures are made, an add gesture is made to UISCROLView and its subclasses. For a swipe gesture, the contentSize of uircollview may be set larger than the rear view to facilitate user swipe. The specific value of how large is specified by the business requirements.

For example, when the service requirement only requires horizontal sliding, then the vertical size does not have to be adjusted: the height of the contentSize does not need to be adjusted, or adjusted to < = height of the rear view.

When the service requirement requires horizontal vertical sliding, both the height and width of the content size may be set to be larger than those of the rear view, specifically, to be more or less specified by the service requirement. For example: to be slidable to 2 times the rear view, the height and width of the content size are set to be both greater than 2 times the height and width of the rear view.

There are many ways to set contentSize on iOS implementations. For example, the contentSize attribute of uiiscrolview and its subclasses may be set to a desired value. Under the automatic constraint, the constraint layout of the sub-views of the UISCROLView and the sub-views thereof is set, so that the width and the height of the UISCROLView content are set from inside to outside. The widthatchechor attribute and the weightAnchor attribute of the frameLayoutGuide are set to the required values.

For a zoom gesture, setting a minimum zoom ratio minimum zoom scale attribute and a maximum zoom ratio maximum zoom scale attribute of UiscrolView and sub-class examples thereof according to service requirements, and realizing a view form zoom method in an agent thereof, wherein the return value of the method is as follows: specifying which sub-view zooms when the user zooms. Typically, a rear view is just entered. The interaction processing of the user can be performed not only by gestures in the iOS, but also by comparing the event responses of the bottom layers: the method of rewriting the UIResponder's touchBegan (with:), touchmoved (with:), touchEnded (with:), touchenhanced (with:), and the like achieves the purpose of processing interaction. The technical solution of the embodiment of the present application is exemplified by gestures, but is not limited to this in practical application.

In the embodiment of the present application, when the view retraction logic B is specifically implemented, the corresponding retraction logic B may be formulated according to the specific logic during ejection. The main idea of logic B is: modifications to the view level made by logic a are restored at minimal cost. The method specifically comprises the following steps: when the pop-up view is retracted, the state of the covered view is subjected to recovery processing, and the recovery processing comprises any one of the following steps: if the covered view is hidden, setting a covered view display; if the view level of the covered view is changed, restoring the original view level of the covered view; if the position attribute of the covered view in the self coordinate system is changed, recovering the original position attribute of the covered view in the self coordinate system; if the covered view is UISCROLView and its sub-class examples, the attribute of the covered view is changed, and the original attribute of the covered view is restored.

For example, if the rear view is hidden, the isHidden attribute of the rear view is set to true. If the view level of the rear view is altered, the original view level is restored. The method is specifically implemented by calling removeFromSuperView for UiscrolView and its sub-instance, removing it from view level, and adding original rear view into its parent view: the addSubView is called for the parent view and the parameters are passed into the rear view. If the original attribute of the bounds of the rear view is changed, it is sufficient to restore to the previous value. If the rear view is UISCROLView and its sub-class instance, its properties are changed and restored to the previous values.

The technical scheme of the embodiment of the application designs a scheme implementation method for solving the problem of view coverage based on the iOS system. The implementation method is obviously different from the scheme in the prior art in terms of underlying logic, and particularly, the implementation method has wide coverage; the functions are expanded, and the support of user interaction according to the service requirements is realized; the method can be suitable for various pop-up view coverage problems, has no limitation, and does not change the view hierarchy and structure of the existing page.

According to the method for moving the covered view, screen capturing operation is performed on the covered view behind the pop-up view, the obtained screen capturing is added to the first parent control, the screen capturing is further added to the second parent control according to the edge leakage condition, and then movement of the second parent control is performed according to the second position offset, so that movement of the covered view is achieved.

The following are device embodiments of the present application, which may be used to perform method embodiments of the present application. The moving device of the covered view described below and the moving method of the covered view described above may be referred to correspondingly to each other. For details not disclosed in the device embodiments of the present application, please refer to the method embodiments of the present application.

Fig. 4 is a schematic diagram of a mobile device with an overlay view according to an embodiment of the present application. As shown in fig. 4, a mobile device of an overlaid view in an embodiment of the present application includes:

the screen capturing module 401 is configured to perform a screen capturing operation on a covered view behind the pop-up view when the current page has a view that is popped up and the current service requirement meets a preset first condition, so as to obtain a screen capturing with the same size as the covered view, where the first condition includes: the current business requirements specify a specified display area of the overlaid view and the overlaid view is not movable by the user.

And the obtaining module 402 is configured to obtain a first position offset of the first parent control according to the position data of the specified display area in the current service requirement after adding the screenshot to the first parent control.

The judging module 403 is configured to judge whether an edge leakage condition exists in the first parent control relative to the current page according to the first position offset and the scaling operation for the covered view in the current service requirement.

And the moving module 404 is configured to add the first parent control to the second parent control when the edge leakage condition exists, and obtain a second position offset of the second parent control according to the position data of the designated display area, so as to move the second parent control according to the second position offset.

Since each functional module of the covered view moving device in the exemplary embodiment of the present application corresponds to a step of the above-mentioned exemplary embodiment of the covered view moving method, for details not disclosed in the embodiment of the apparatus of the present application, please refer to the above-mentioned embodiment of the covered view moving method of the present application.

According to the mobile device of the covered view, screen capturing operation is performed on the covered view behind the pop-up view, the obtained screen capturing is added into the first parent control, the obtained screen capturing is further added into the second parent control according to the edge leakage condition, and then the second parent control is moved according to the second position offset, so that the movement of the covered view is achieved.

Fig. 5 is a schematic diagram of an electronic device 5 provided in an embodiment of the present application. As shown in fig. 5, the electronic apparatus 5 of this embodiment includes: a processor 501, a memory 502 and a computer program 503 stored in the memory 502 and executable on the processor 501. The steps of the various method embodiments described above are implemented by processor 501 when executing computer program 503. Alternatively, the processor 501, when executing the computer program 503, performs the functions of the modules in the above-described apparatus embodiments.

The electronic device 5 may be a desktop computer, a notebook computer, a palm computer, a cloud server, or the like. The electronic device 5 may include, but is not limited to, a processor 501 and a memory 502. It will be appreciated by those skilled in the art that fig. 5 is merely an example of the electronic device 5 and is not limiting of the electronic device 5 and may include more or fewer components than shown, or different components.

The processor 501 may be a central processing unit (Central Processing Unit, CPU) or other general purpose processor, digital signal processor (Digital Signal Processor, DSP), application specific integrated circuit (Application Specific Integrated Circuit, ASIC), field programmable gate array (Field-Programmable Gate Array, FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components, or the like.

The memory 502 may be an internal storage unit of the electronic device 5, for example, a hard disk or a memory of the electronic device 5. The memory 502 may also be an external storage device of the electronic device 5, for example, a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash Card (Flash Card) or the like, which are provided on the electronic device 5. Memory 502 may also include both internal storage units and external storage devices of electronic device 5. The memory 502 is used to store computer programs and other programs and data required by the electronic device.

It will be apparent to those skilled in the art that, for convenience and brevity of description, only the above-described division of the functional units and modules is illustrated, and in practical application, the above-described functional distribution may be performed by different functional units and modules according to needs, i.e. the internal structure of the apparatus is divided into different functional units or modules to perform all or part of the above-described functions. The functional units and modules in the embodiment may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit, where the integrated units may be implemented in a form of hardware or a form of a software functional unit.

The integrated modules, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the present application implements all or part of the flow in the methods of the above embodiments, or may be implemented by a computer program to instruct related hardware, and the computer program may be stored in a computer readable storage medium, where the computer program may implement the steps of the respective method embodiments described above when executed by a processor. The computer program may comprise computer program code, which may be in source code form, object code form, executable file or in some intermediate form, etc. The computer readable medium may include: any entity or device capable of carrying computer program code, a recording medium, a U disk, a removable hard disk, a magnetic disk, an optical disk, a computer Memory, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), an electrical carrier signal, a telecommunications signal, a software distribution medium, and so forth. It should be noted that the content of the computer readable medium can be appropriately increased or decreased according to the requirements of the jurisdiction's jurisdiction and the patent practice, for example, in some jurisdictions, the computer readable medium does not include electrical carrier signals and telecommunication signals according to the jurisdiction and the patent practice.

The above embodiments are only for illustrating the technical solution of the present application, and are not limiting thereof; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some technical features thereof can be replaced by equivalents; such modifications and substitutions do not depart from the spirit and scope of the technical solutions of the embodiments of the present application, and are intended to be included in the scope of the present application.

Claims

1. A method of moving an overlaid view, the method comprising:

when a current page is popped up and a current service requirement meets a preset first condition, performing screen capturing operation on a covered view behind the popped up view to obtain a screen capturing with the same size as the covered view, wherein the first condition comprises: the current business requirement specifies a specified display area of the overlaid view and the overlaid view is not movable by a user;

after the screenshot is added into a first parent control, acquiring a first position offset of the first parent control according to the position data of the appointed display area in the current business requirement, wherein the first parent control is a UIView instance or a CALayer instance;

Judging whether the first parent control has an edge leakage condition relative to the current page according to the first position offset and the expanding and shrinking operation aiming at the covered view in the current service demand;

if the edge leakage condition exists, adding the first parent control into a second parent control, and acquiring a second position offset of the second parent control according to the position data of the appointed display region so as to move the second parent control according to the second position offset;

wherein the moving the second parent control according to the second position offset includes:

moving the second parent control according to the second position offset and the type of the second parent control, wherein the type of the second parent control comprises any one of the following: uiniew class instance, uikrollview and its sub-class instance, cakrolllayer and its sub-class instance.

2. The method of claim 1, wherein obtaining a first position offset for the first parent control based on the position data for the specified display area in the current business need comprises:

acquiring a starting position and a target position of the appointed display region in the current service demand;

And acquiring the first position offset according to the position of the pop-up view, the starting position and the target position.

3. The method of claim 1, wherein after determining whether an edge leak condition exists for the first parent control with respect to the current page according to the first position offset and a scaling operation for the overlaid view in the current business requirement, the method further comprises:

and if the edge leakage condition does not exist, modifying the position attribute of the first parent control in the self coordinate system according to the first position offset.

4. The method of claim 1, wherein moving the second parent control according to the second position offset and the type of the second parent control comprises:

if the second parent control is the UIView class instance, modifying the position attribute of the second parent control in the self coordinate system according to a second position offset;

if the second parent control is UISCULView and a child instance thereof, modifying the sliding position attribute of the second parent control according to a second position offset or moving the second parent control by using a method of scrolling to a designated position;

5. The method of claim 1, wherein when a current page has a view popped up and a current business requirement meets a preset second condition, performing a screen capturing operation on an overlaid view behind the popped up view to obtain a screen capturing with the same size as the overlaid view, wherein the second condition includes: the current business requirement designates a designated display area of the overlaid view and the overlaid view is movable by a user;

after the screenshot is added into a first parent control, acquiring a first position offset of the first parent control according to the position data of the designated display area in the current business requirement;

If the edge leakage condition exists, adding the first parent control into a second parent control, and adding command gestures for the second parent control;

when a command gesture signal generated when a user performs command gesture operation on the second parent control is received, a third position offset is obtained according to the command gesture signal, and the second parent control is moved according to the third position offset.

6. The method of claim 1, wherein when a current page has a view popped up and a current business requirement meets a preset third condition, performing a screen capturing operation on an overlaid view behind the popped up view to obtain a screen capturing with the same size as the overlaid view, wherein the third condition includes: the current business requirement does not specify a specified display area of the overlaid view and the overlaid view is movable by a user;

adding the screenshot into a first parent control, and adding a command gesture to the first parent control;

when a command gesture signal generated when a user performs command gesture operation on the first parent control is received, acquiring a fourth position offset according to the command gesture signal, and moving the first parent control according to the fourth position offset.

7. The method of claim 1, wherein after moving the second parent control according to the second position offset, the method further comprises:

and when the popup view is retracted, carrying out recovery processing on the state of the covered view, wherein the recovery processing comprises any one of the following steps:

if the covered view is hidden, setting the covered view for display;

if the view level of the covered view is changed, restoring the original view level of the covered view;

if the position attribute of the covered view in the self coordinate system is changed, recovering the original position attribute of the covered view in the self coordinate system;

and if the covered view is UISCROLView and a sub-class instance thereof, modifying the attribute of the covered view, and recovering the original attribute of the covered view.

8. The method of claim 1, wherein prior to the screen capture operation of the overlaid view behind the pop-up view, the method further comprises: monitoring the ejection or retraction time of any one of the following ejection views, and determining that the current page has a view to be ejected:

the middle part pops up the prompt box, pops up the keyboard, pops up the card at the bottom, and the self-defining pops up the view.

9. The method of claim 1, wherein after adding the first parent control to a second parent control, the method further comprises:

and changing the color of the leakage edge according to the color setting of the leakage edge in the current service demand.

10. A mobile device for an overlaid view, the device comprising:

the screen capturing module is used for carrying out screen capturing operation on the covered view behind the pop-up view when the current page is popped up in a view mode and the current service requirement meets a preset first condition, and obtaining a screen capturing with the same size as the covered view, wherein the first condition comprises: the current business requirement specifies a specified display area of the overlaid view and the overlaid view is not movable by a user;

the acquisition module is used for acquiring a first position offset of a first parent control according to the position data of the appointed display area in the current service demand after the screenshot is added into the first parent control, wherein the first parent control is a UIView instance or a CALayer instance;

the judging module is used for judging whether the first parent control has an edge leakage condition relative to the current page according to the first position offset and the expanding and shrinking operation aiming at the covered view in the current service demand;

The mobile module is used for adding the first parent control into a second parent control when the edge leakage condition exists, and acquiring a second position offset of the second parent control according to the position data of the appointed display area so as to move the second parent control according to the second position offset;

11. An electronic device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, characterized in that the processor implements the steps of the method according to any one of claims 1 to 9 when the computer program is executed.

12. A computer readable storage medium storing a computer program, characterized in that the computer program when executed by a processor implements the steps of the method according to any one of claims 1 to 9.