Mixed development table editor development method, equipment, medium and product

Abstract

The invention discloses a mixed development table editor development method and device, a medium and a product, and relates to the technical field of software, the method comprises the following steps: adding a custom column type to an open source GridControl project to obtain a customized project; integrating the customized project into a Winform application program, and calling an interface function provided by the customized project through C # to obtain a called control; loading an HTML (Hypertext Markup Language) page by utilizing a WebView2 control and integrating an ECharts chart function to obtain a chart function control; integrating the called control and the chart function control; and performing data processing and interaction between the post-calling control and the chart function control through the C # to obtain a table editor. According to the method, through reasonable step setting, the high performance of C + +, the development efficiency of C # and the visualization capability of the Web technology are fully exerted, and the low-cost and high-performance table editing and visualization functions are achieved.

Description

Technical Field

[0001] The present application relates to the field of software technology, and in particular to a hybrid development table editor development method, device, medium and product. Background Art

[0002] With the rapid development of computer technology, data spreadsheet editors have become indispensable tools in fields such as engineering simulation and data analysis. This is particularly true in specialized fields like Modelica simulation, which require processing large amounts of structured data, placing higher demands on the performance and functionality of spreadsheet editors. While traditional spreadsheet processing tools like Excel or Notepad can accomplish basic data editing tasks, they lack the ability to handle complex data structures, achieve high-performance computing, and support specialized data formats.

[0003] In existing technologies, table editors are primarily implemented in three ways: high-performance table controls developed purely in C++, WinForms table controls based on the .NET framework, and table components based on Web technologies. Each of these solutions has the following limitations: 1. Table controls developed purely in C++, while offering excellent performance, suffer from low development efficiency and a poor user experience; 2. Table controls based on the .NET framework offer high development efficiency but relatively low performance, making them difficult to process large amounts of data; 3. Table components implemented using Web technologies offer rich visualization capabilities, but inefficient data interaction and difficulty integrating deeply with desktop applications. Summary of the Invention

[0004] The purpose of this application is to provide a hybrid development table editor development method, equipment, medium and product that can achieve low-cost, high-performance table editing and visualization functions.

[0005] To achieve the above objectives, this application provides the following solutions:

[0006] In a first aspect, the present application provides a hybrid development table editor development method, comprising:

[0007] Adding a custom column type to an open source GridControl project to obtain a customized project; the open source GridControl project is developed using C++;

[0008] Integrate the customized project into a WinForm application, and call the interface function provided by the customized project through C# to obtain the called control;

[0009] Use the WebView2 control to load the HTML page and integrate the ECharts chart function to obtain the chart function control;

[0010] Utilize Winform application program to integrate the post-call control and the chart function control;

[0011] The data processing and interaction between the post-call control and the chart function control are performed through C# to obtain a table editor.

[0012] Optionally, adding a custom column type to the open source GridControl project to obtain a customized project specifically includes:

[0013] Add custom column types to the open source GridControl project and get the added items;

[0014] Optimizing the data loading speed of the added project to obtain an optimized project;

[0015] The optimized project is encapsulated into an OCX control format to obtain a customized project.

[0016] Optionally, the customized project is integrated into a WinForm application, and an interface function provided by the customized project is called through C# to obtain a post-call control, specifically including:

[0017] Create a WinForm application project;

[0018] Add the customized project to the toolbox of Visual Studio of the WinForm application project through a registration command, and set properties and event handlers to obtain the set project;

[0019] The interface function provided by the project after setting is called through C# to obtain the called control; the interface function is used to realize the creation, assignment, style setting and row and column operation functions of the table.

[0020] Optionally, use the WebView2 control to load the HTML page and integrate the ECharts chart function to obtain a chart function control, specifically including:

[0021] Get the WebView2 control and use NuGet to load its dependencies.

[0022] Write an HTML static page and load the ECharts library into the HTML static page to obtain a page loading project;

[0023] The page loading project is loaded using the WebView2 control, and the chart type and interactive function are configured using the JavaScript API of ECharts to obtain a chart function control.

[0024] Optionally, integrating the post-call control and the chart function control using a WinForm application specifically includes:

[0025] Placing the post-call control and the chart function control on the Winform main form;

[0026] Coordinate and set the post-call control and the chart function control;

[0027] The communication interaction between the post-call control and the chart function control is performed through the front-end and back-end interaction interfaces of the WebView2 control.

[0028] Optionally, data processing and interaction between the post-call control and the chart function control are performed through C# to obtain a table editor, specifically including:

[0029] Using C# program to monitor the changes of table data in the control after the call;

[0030] When the table data changes, the table data is converted into json format to obtain format conversion data;

[0031] The format conversion data is transmitted to the corresponding function code of the front end through WebView2, and the format conversion data is converted into the format of the ECharts interface to present the ECharts chart view.

[0032] Optionally, after performing the data processing and interaction between the call control and the chart function control through C# to obtain the table editor, the method further includes:

[0033] Performing functional testing on the table editor;

[0034] Generate an operation manual and help file for the table editor.

[0035] In a second aspect, the present application provides a computer device comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement any one of the hybrid development table editor development methods described above.

[0036] In a third aspect, the present application provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements any one of the above-described hybrid development table editor development methods.

[0037] In a fourth aspect, the present application provides a computer program product, including a computer program, which, when executed by a processor, implements any one of the above-mentioned hybrid development table editor development methods.

[0038] According to the specific embodiments provided in this application, this application discloses the following technical effects:

[0039] The present application provides a hybrid development table editor development method, device, medium and product, the method comprising: adding a custom column type to an open source GridControl project to obtain a customized project; the open source GridControl project is developed using C++; the customized project is integrated into a Winform application, and the interface function provided by the customized project is called through C# to obtain a called control; the HTML page is loaded using a WebView2 control and the ECharts chart function is integrated to obtain a chart function control; the Winform application is used to integrate the called control and the chart function control; data processing and interaction between the called control and the chart function control are performed through C# to obtain a table editor. The present application combines C++, C# and Web technology for hybrid development through reasonable step settings, giving full play to the high performance of C++ (for OCX control development), the development efficiency of C# and the rich visualization capabilities of Web technology (through WebView2 and ECharts), realizing low-cost, high-performance table editing and visualization functions, meeting the complex needs of professional fields such as engineering simulation and data analysis, and having significant technical advantages and broad application prospects. BRIEF DESCRIPTION OF THE DRAWINGS

[0040] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0041] Figure 1 A flowchart of a hybrid development table editor development method provided in one embodiment of the present application.

[0042] Figure 2 A schematic diagram of the structure of a computer device provided in one embodiment of the present application. DETAILED DESCRIPTION

[0043] The following will be combined with the drawings in the embodiments of this application to clearly and completely describe the technical solutions in the embodiments of this application. Obviously, the embodiments described are only part of the embodiments of this application, not all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0044] The current table editor technology mainly has the following technical problems:

[0045] 1. The contradiction between performance and development efficiency: High-performance C++ table controls have a long development cycle and high costs, while .NET controls with high development efficiency cannot meet the needs of large-scale data processing.

[0046] 2. Weak visualization capabilities: Traditional desktop spreadsheet editors lack flexible data visualization capabilities and are unable to meet complex data chart display requirements.

[0047] 3. Difficulty in cross-technology integration: Existing solutions struggle to organically combine the advantages of different technology stacks, such as the high performance of C++, the development efficiency of C#, and the rich visualization capabilities of Web technology.

[0048] 4. Insufficient support for professional data formats: For professional simulation data formats such as Modelica, general table editors lack targeted optimization and support, resulting in low data processing efficiency.

[0049] This application aims to give full play to the advantages of their respective platforms, handing over the table rendering part that is most likely to affect performance to C++, handing over the business logic to C#, and handing over the two-dimensional / three-dimensional view part to the Web (html+JavaScript) with the best presentation effect. Through a main client (C#Winform), add a browser plug-in (WebView2) to load static pages, and add the encapsulated c++ocx as a Winform client control to the client window. After that, the corresponding business development work can be carried out.

[0050] In order to make the above-mentioned purposes, features and advantages of the present application more obvious and easy to understand, the present application is further described in detail below with reference to the accompanying drawings and specific implementation methods.

[0051] In an exemplary embodiment, Figure 1 As shown, a hybrid development table editor development method is provided, which includes the following steps S1 to S5 in the embodiment of the present application.

[0052] S1. Add a custom column type to an open source GridControl project to obtain a customized project; the open source GridControl project is developed using C++.

[0053] In this embodiment, the open source GridControl project is redeveloped and encapsulated as an OCX control.

[0054] GridControl is an open source grid control project that provides basic grid display and operation functions. OCX control is Microsoft's ActiveX control technology, a reusable software component that can be embedded in different applications.

[0055] The computer system first obtains the open source code of the GridControl project and analyzes its core functions and data structure. The system uses development tools to expand and optimize the functions of the GridControl, including adding custom column types (adding the names / remarks of each coordinate axis through the table property window) and optimizing data loading speed. The system then uses the tools provided by the .NET Framework to encapsulate the customized GridControl into an OCX control format to ensure that the control can be correctly registered and used in the target environment. A test program is created and unit tests are written to verify whether the various functions of the OCX control are normal, such as whether an n*m table can be created normally, whether rows and columns can be added to the table, and whether table cells can be assigned colors and set.

[0056] Specifically, in this embodiment, the specific steps of secondary development of the open source GridControl project and packaging it into an OCX control (customized project) include:

[0057] Step 1. Select a development environment based on pre-defined standards and import the source code for the open-source GridControl project. A development environment is an integrated development environment (IDE) used for software development, including tools such as a code editor, compiler, and debugger. Pre-defined standards refer to technical specifications and requirements predetermined based on project needs.

[0058] The computer first selects a development environment that meets pre-defined standards based on the project requirements, such as an IDE like Visual Studio. It then downloads the open-source GridControl project source code from a code repository and imports it into the selected development environment. The computer then verifies that the development environment configuration meets the project compilation and runtime requirements, ensuring that the environment is correctly set up.

[0059] Step 2. Analyze the core functions and data structure of the open-source GridControl project. Core functions refer to the most critical and fundamental functional modules in a software system. Data structure refers to the organization, management, and storage format of data in a computer.

[0060] The computer performs static analysis and dynamic debugging on the imported GridControl source code, identifying the core code modules that implement table editing functionality. The computer also parses the project's data structure definitions, understanding the logical relationships between data storage and processing. It also generates function module call diagrams and data flow diagrams, providing a foundation for subsequent functional expansion.

[0061] Step 3. Expand or optimize the functionality of the open-source GridControl project. Functional expansion refers to adding new features to existing functionality. Functional optimization refers to improving the performance or user experience of existing functionality.

[0062] The computer modified the GridControl source code based on the requirements document, adding new features such as custom column types and data validation. The computer restructured the data processing algorithm to optimize table rendering performance for large data volumes. The computer also adjusted the user interaction logic to enhance the responsiveness of operations like sorting and filtering.

[0063] Step 4. Design and encapsulate the interface functions of the OCX control. Interface functions are public methods that are provided to external programs for calling. Encapsulation refers to packaging functional modules into independently usable components.

[0064] The computer defines the public interface that the OCX control needs to expose, including methods for table operations and data retrieval. The computer writes the interface implementation code, ensuring that each interface function correctly calls internal functions. The computer also adds necessary parameter validation and error handling mechanisms to the interface.

[0065] Step 5. Encapsulate the customized GridControl into the OCX control using a tool specified by a preset standard. The encapsulation tool refers to a software development kit (SDK) for creating an OCX control.

[0066] Detailed explanation of the steps: The computer uses the ActiveX template or ATL tools provided by the .NET Framework to create the OCX project framework. The computer integrates the modified GridControl code into the OCX project and configures the necessary compilation options. The computer then compiles the code to generate a binary file that conforms to the OCX specification.

[0067] Step 6. Test the registration and call functions of the OCX control in the target environment. The target environment refers to the computer system environment where the OCX control will run. Registration refers to writing the control information into the system registry.

[0068] The computer uses the regsvr32 command to register the OCX control in the system registry. The computer creates a test application to verify that the control can be loaded and initialized correctly. The computer calls various interface functions to check the correctness of the function implementation and performance indicators.

[0069] By systematically implementing the above steps, the computer can efficiently convert the open-source GridControl project into a fully functional OCX control. This process ensures the preservation and expansion of core grid functionality while providing standardized interface specifications. The resulting OCX control possesses high-performance data processing capabilities and can be seamlessly integrated into various Windows applications, laying a solid foundation for subsequent grid editor development.

[0070] S2. Integrate the customized project into a Winform application, and call the interface function provided by the customized project through C# to obtain a post-call control.

[0071] In this embodiment, the OCX control (customized project) is integrated into the Winform application to implement the table editing function.

[0072] Winform is the abbreviation of Microsoft Windows Forms, which is a graphical user interface framework provided by .NET Framework for creating Windows desktop applications.

[0073] The computer system creates a WinForms application project and adds the OCX control generated in step S1 to the Visual Studio toolbox using the register command. In the WinForms form designer, the system drags and drops the OCX control onto the form and sets its properties and event handlers (the development interface in Visual Studio opens the properties window by right-clicking and setting various properties). The system calls the interface functions provided by the OCX control through C# to implement table creation, value assignment, style setting, and row and column manipulation, completing the integration of the table editor's core functions.

[0074] In this embodiment, the specific steps of integrating the customized project into the WinForm application to implement the table editing function include:

[0075] These steps describe the complete process for integrating a customized project (OCX control) into a WinForms application to implement table editing functionality. First, you need to create the application and register the control. Then, you need to add the control to the application. Then, you need to use the control's interface functions to gradually implement table creation, value assignment, styling, and row and column manipulation. These steps are arranged in order, from building the basic environment to implementing specific functionality, with clear dependencies.

[0076] Step 1: Create the WinForm application and register the OCX control

[0077] Winform applications are Windows Forms applications based on the .NET Framework, which provides a framework for developing graphical user interfaces (GUIs). OCX controls are ActiveX controls, reusable software components that can be embedded in applications to provide specific functionality.

[0078] The system first creates a new Windows Forms project using the Visual Studio development environment, setting the project name and storage location. The system then registers the OCX control with the Windows operating system using the regsvr32 command or programmatically, enabling Windows Forms applications to recognize and use the control. The registration process involves writing the OCX control's information to the system registry and ensuring that all necessary dependencies are correctly installed and configured.

[0079] Step 2: Add the OCX control to the WinForm application through a toolbox specified by a preset standard.

[0080] The toolbox, which is defined by the predefined standards, refers to the toolbox panel in the Visual Studio development environment. It organizes the various available controls into standard categories. After registering an OCX control, it automatically appears in the "COM Component" or "ActiveX Control" category of the toolbox.

[0081] The system opens the design view of the WinForm application in Visual Studio and locates the registered OCX control in the toolbox. The system drags and drops the control onto the WinForm form, automatically generating a control instance and adding it to the form's control collection. The system then sets the control's position and size on the form to ensure its layout meets the design requirements. The system also checks the control's license information to ensure legal use.

[0082] Step 3: Call the interface function of the OCX control to create and assign values ​​to the table.

[0083] Interface functions are a set of public methods that OCX controls expose to external applications, used to control and operate control functions. Table creation and assignment refers to the process of initializing the table data structure and filling it with initial data.

[0084] The system accesses the OCX control's object model through C# and calls the initialization method to create a blank table. The system sets basic properties such as the number of rows and columns, and the title. Then, the data fill method is called to load the content from the external data source into the table. The system handles data type conversion to ensure that different types of data, such as numbers, text, and dates, are displayed correctly. The system also implements data validation logic to prevent invalid data entry.

[0085] Step 4: Set the style of the table through the interface function of the OCX control.

[0086] Table style refers to the visual presentation of a table, including appearance attributes such as fonts, colors, borders, and alignment. Interface functions typically contain a collection of methods specifically for style settings.

[0087] The system uses the style setting methods provided by the OCX control to configure the overall appearance of the table. The system sets the header style, including font size, color, and background. The system defines cell styles, including text alignment, border style, and background color. The system implements conditional formatting, dynamically changing the display style based on cell values. The system also saves style templates, allowing users to customize and reuse common style configurations.

[0088] Step 5: Adding and deleting table rows and columns is achieved through the interface function of the OCX control.

[0089] Table row and column operations refer to editing functions that dynamically adjust the table structure, including inserting, deleting, and moving rows or columns. The interface function provides corresponding methods to perform these structural changes.

[0090] The system calls the row manipulation methods of the OCX control to insert new rows or delete existing rows at a specified location. It also calls column manipulation methods to add new columns or remove unnecessary ones. The system handles events triggered by row and column manipulation, such as data reindexing and interface refreshes. It implements undo / redo functionality and records row and column change history. It also optimizes row and column manipulation performance for large data volumes, reducing interface flicker and latency.

[0091] Through the systematic implementation of the above steps, we achieved efficient integration of the OCX table control within WinForms applications, providing comprehensive table editing functionality. This integration leverages the OCX control's high-performance data processing capabilities and WinForms' flexible interface design, enabling responsive and high-volume table operations. Furthermore, standardized interface calls ensured the stability and maintainability of functional implementation, providing end users with a professional-level table editing experience.

[0092] S3. Use the WebView2 control to load the HTML page and integrate the ECharts chart function to obtain the chart function control.

[0093] This embodiment uses the WebView2 control to load the HTML page and integrate the ECharts chart function.

[0094] WebView2 is a Chromium-based embedded browser control provided by Microsoft, and ECharts is an open source JavaScript visualization chart library.

[0095] The computer system adds the WebView2 control component to the Winform project and configures its version and dependencies. Write HTML page code that includes a reference to the ECharts library and design the layout and style of the chart display. Download the local WebView2 from the official website and store it in the root directory of the program. The local version of WebView2 is read through the software, and the related dependencies of WebViewe2 are loaded through NuGet. The WebView2 browser is then successfully added to the software. Then, write the Html static page chat.html and load the ECharts library in chat.html. The system loads these chat.html pages through the WebView2 control and uses the JavaScriptAPI of ECharts to configure various chart types and interactive functions. The system implements a data transmission mechanism from the back-end to the front-end chart to ensure that the chart can be dynamically updated.

[0096] S4. Utilize a Winform application to integrate the post-call control and the chart function control.

[0097] In this embodiment, the post-call control and the chart function control are integrated into the WinForm application.

[0098] Integration refers to the coordinated combination of multiple functional components to form a complete application.

[0099] The computer system designs the user interface layout in the Winform main form, and reasonably places the post-call controls and chart function controls on the form. The system sets the properties and position relationship of the two controls. Some types of tables only display single table editing, and some tables require dual-table linkage editing. Through control visibility control, position and size control, it ensures that they are displayed in a coordinated manner in the interface. The system implements the communication mechanism between controls. Through the front-end and back-end interaction interface provided by the WebView2 control, the back-end data is combined into json data, which is passed to the front-end chat.html for reception and parsing. The parsed content is then combined into the json format required by the ECharts interface, so that changes in table data can be reflected in the chart in a timely manner. The system will also add necessary interface elements such as menus, toolbars, and status bars to provide a complete user operation experience.

[0100] S5. Data processing and interaction between the post-call control and the chart function control are performed through C# to obtain a table editor.

[0101] This embodiment implements data processing and interaction between the post-call control and the chart function control through C#.

[0102] C# is an object-oriented programming language developed by Microsoft and is commonly used in .NET platform application development.

[0103] The computer system writes C# to monitor table data change events in the OCX control. When the data changes, the system converts the table data into a json format. The processed string containing the json data is then passed in through the ExecuteScriptAsync method provided by WebView2. WebView2 automatically transmits the string to the corresponding function code in the front-end JavaScript based on the content of the string. By parsing the json data again, it converts it into the format of the ECharts interface and completes the presentation of the ECharts chart view. The system also implements reverse data flow, passing the user's interactive operations on the chart to C# through JavaScript callbacks, thereby updating the table data in the OCX control.

[0104] In this embodiment, the steps of loading an HTML page through the WebView2 control and integrating the ECharts chart function specifically include:

[0105] Step 1: Configure the WebView2 control in the WinForm application. This is the first step to integrate WebView2 with ECharts and establish the basic environment for subsequent operations.

[0106] WinForms applications are desktop applications developed based on Windows Forms technology, providing a graphical user interface framework. The WebView2 control is a Chromium-based embedded browser component provided by Microsoft that supports modern web technologies.

[0107] The system creates or opens the target Windows Forms project in the Visual Studio development environment. It adds the Microsoft.Web.WebView2 dependency through the NuGet package manager and automatically downloads the required runtime components. In the form designer, the system drags and drops the WebView2 control to the specified location and sets the CoreWebView2Ready event handler. The system configures the initial properties of WebView2, including parameters such as the default URL, zoom mode, and permission settings.

[0108] Step 2: Write the HTML page and import the preset standard file of ECharts. After completing the control configuration, you need to build the front-end environment that hosts the chart.

[0109] HTML pages are documents written in Hypertext Markup Language (Hypertext Markup Language), which is used to define the structure and content of a webpage. ECharts is Baidu's open-source JavaScript visualization library. The default standard files refer to its core JS library and CSS style files.

[0110] The system creates a new HTML file and sets the basic document structure. It adds the ECharts CDN reference or local resource path, including the echarts.min.js core file and required extensions. It defines a DOM container div element with specific dimensions. It then writes an initialization script, creates an echarts.init() instance, and binds it to the target DOM element.

[0111] Step 3: Configure the ECharts chart parameters. After importing the library file, you need to define the specific presentation method of the chart.

[0112] Chart parameters refer to ECharts configuration objects (options), which include series, xAxis, yAxis and other properties to define chart types and data mapping rules.

[0113] The system constructs an option configuration object that conforms to the ECharts specification. It sets the basic chart types (e.g., line chart, bar chart, etc.) and coordinate system parameters. It defines a dataZoom component to implement zoom functionality and configures tooltip interaction. It adds a visualMap component to handle data-to-color conversion. The system saves the complete option configuration to a JavaScript variable for subsequent use.

[0114] Step 4: Pass the data to the HTML page through the interface of the WebView2 control. Establish a communication channel between the desktop and the Web content to achieve data interaction.

[0115] The WebView2 interface refers to methods such as PostWebMessageAsString or ExecuteScriptAsync provided by the CoreWebView2 class, which are used for cross-environment communication.

[0116] The system constructs a JSON string containing the chart data in C#. It calls the ExecuteScriptAsync method of the WebView2 control to execute the JavaScript function. A two-way communication channel is established through the WebMessageReceived event handler. The system uses the InvokeScript method to inject the serialized data into the front-end window object. The system receives and parses the transmitted data on the front-end using the addEventListener method.

[0117] Step 5: Call the ECharts preset standard method to update the chart. Finally, the processed data is visualized.

[0118] The preset standard methods refer to the core methods such as setOption and resize provided by the ECharts official API, which are used to dynamically update charts.

[0119] The system defines a chart update function, updateChart(data), in the front-end JavaScript. The system converts the received data into a format supported by ECharts and merges it into an option object. The system applies the new configuration via the myChart.setOption() method, triggering a chart redraw. When handling window size changes, the system calls myChart.resize() to maintain a responsive layout. The system implements the dispose method to properly release chart resources when the control is unloaded.

[0120] Overall technical effect:

[0121] This solution achieves deep integration of WinForms desktop applications with Web technologies through the WebView2 control, leveraging the powerful visualization capabilities of ECharts to build a high-performance data presentation solution. The system employs a layered architecture that clearly separates responsibilities for data preparation, transmission protocols, and rendering and presentation, enabling inter-module communication through standardized interfaces. This design retains the performance advantages of native applications while leveraging the flexibility and rich visualization effects of Web technologies. Furthermore, through an automated data pipeline and responsive update mechanism, it significantly improves rendering efficiency and interactive experience in large data volume scenarios.

[0122] In this embodiment, after obtaining the table editor, function testing and optimization are performed.

[0123] Functional testing is the process of verifying whether the software works properly according to the requirements specification, and optimization is the improvement process to improve software performance and user experience.

[0124] The computer system executes automated test scripts and manual test cases to verify the proper functioning of table editing and chart display functions. The system also tests performance under large data volumes and optimizes data loading and rendering algorithms. The system collects test results, fixes any defects, and adjusts interface layout and interaction flows. The system also analyzes memory usage and performance to eliminate potential resource leaks and performance bottlenecks.

[0125] Finally, a user document is generated to support the user in operating the table editor.

[0126] User documentation is explanatory material that helps users understand and use software products, including operation manuals, help files, etc.

[0127] The computer system automatically generates the document framework and basic content based on the application's functions and operational processes. It extracts comments from the code and descriptions of interface elements and integrates them into the document. It also generates screenshots of the steps and sample data to create a user guide with both pictures and text. The system outputs the document in multiple formats (such as PDF and HTML) for easy access. The system also creates an index and search function for the document, making it more efficient for users to find information.

[0128] The above steps together constitute a hybrid development approach for high-performance table editors. This approach combines the high-performance C++ OCX control with the modern web technology of WebView2 to achieve efficient table editing and rich charting capabilities within the WinForms framework. The system leverages the strengths of each technology stack: C++ provides high-performance data processing, web technology provides flexible visualization capabilities, and C acts as an intermediary layer to coordinate the interaction between the two. Compared to single-technology solutions, this approach offers better performance, lower development costs, and richer functionality, meeting complex data editing and visualization requirements.

[0129] Based on the same inventive concept, the embodiment of the present application also provides a hybrid development table editor development method, the specific steps of which are as follows:

[0130] The open source GridControl project is redeveloped and encapsulated as an OCX control.

[0131] The OCX control is integrated into the Winform application to realize the table editing function.

[0132] Load HTML pages through the WebView2 control and integrate ECharts chart functions.

[0133] Integrate the OCX control and the WebView2 control into the Winform application.

[0134] Data processing and interaction between the OCX control and the WebView2 control are implemented through C# code.

[0135] Perform functional testing and optimization on the Winform application.

[0136] Generate user documentation to support users in operating the table editor.

[0137] The steps of secondary developing the open source GridControl project and packaging it into an OCX control include:

[0138] Select the development environment specified by the preset standard and import the source code of the open source GridControl project.

[0139] Analyze the core functions and data structure of the open source GridControl project.

[0140] Expand or optimize the functionality of the open source GridControl project.

[0141] Design and encapsulate the interface function of the OCX control.

[0142] The customized GridControl is encapsulated as the OCX control using tools specified by a preset standard.

[0143] Test the registration and calling functions of the OCX control in the target environment.

[0144] The step of integrating the OCX control into the WinForm application to implement the table editing function includes:

[0145] Create the WinForm application and register the OCX control.

[0146] The OCX control is added to the WinForm application through a toolbox specified by a preset standard.

[0147] The interface function of the OCX control is called to realize the creation and assignment of the table.

[0148] The style of the table is set through the interface function of the OCX control.

[0149] The addition and deletion of table rows and columns are realized through the interface function of the OCX control.

[0150] The steps of loading the HTML page through the WebView2 control and integrating the ECharts chart function include:

[0151] Configure the WebView2 control in the Winform application.

[0152] Write the HTML page and introduce the preset standard specification file of ECharts.

[0153] Configure the ECharts chart parameters.

[0154] The data is transferred to the HTML page through the interface of the WebView2 control.

[0155] Call the preset standard method of the ECharts to update the chart.

[0156] The step of integrating the OCX control and the WebView2 control into the Winform application includes:

[0157] Design the user interface of the Winform application.

[0158] The OCX control and the WebView2 control are embedded into the user interface.

[0159] Configure the display properties of the OCX control and the WebView2 control.

[0160] The layout of the user interface is adjusted to optimize the operating experience.

[0161] The step of implementing data processing and interaction between the OCX control and the WebView2 control through C# code includes:

[0162] The table data is read and processed by the C# code.

[0163] The table data is operated through the interface function of the OCX control.

[0164] The table data is transferred to the HTML page through the interface function of the WebView2 control.

[0165] The ECharts chart is updated through the JavaScript function in the HTML page.

[0166] The step of performing functional testing and optimization on the WinForm application includes:

[0167] Test the table operation function of the OCX control.

[0168] Test the chart display function of the WebView2 control.

[0169] Test the data interaction function between the OCX control and the WebView2 control.

[0170] Optimize the performance of the WinForm application based on the test results.

[0171] In order to implement the above method, this embodiment further provides a hybrid development high-performance table editor development device, the hybrid development high-performance table editor development device comprising:

[0172] The OCX control encapsulation module is used to perform secondary development on the open source GridControl project and encapsulate it as an OCX control.

[0173] The table function realization module is used to integrate the OCX control in the Winform application to realize the table editing function.

[0174] Chart function implementation module, used to load HTML pages through WebView2 control and integrate ECharts chart function.

[0175] An integration module is used to integrate the OCX control and the WebView2 control into the Winform application.

[0176] The data processing module is used to implement data processing and interaction between the OCX control and the WebView2 control through C# code.

[0177] The test optimization module is used to perform functional testing and optimization on the Winform application.

[0178] The document generation module is used to generate user documents to support the user to operate the table editor.

[0179] This application focuses on the field of software technology. To address a series of problems existing in existing spreadsheet editors, it proposes an innovative technical solution for hybrid development of a high-performance spreadsheet editor, covering development methods, devices, computer equipment, and computer-readable storage media.

[0180] In terms of development methodology, we conducted secondary development on the open-source GridControl project. We imported its source code into a pre-defined development environment, conducted in-depth analysis of its core functionality and data structure, and expanded or optimized its functionality based on actual needs, such as adding custom column types and optimizing data loading speed. We also designed and encapsulated the OCX control's interface functions according to specifications. Using tools that met pre-defined standards, we packaged the customized GridControl as an OCX control, and rigorously tested its registration and call functionality in the target environment.

[0181] Integrate an OCX control into a WinForm application to implement table editing. When creating a WinForm application, register the OCX control according to the standard and add it to the application using a pre-defined toolbox. Use C# code to call the OCX control's interface functions to create tables, assign values, set styles, and add and delete rows and columns. During operation, attention is paid to data type conversion and validation to ensure data accuracy and stability. Styling supports multiple formats to meet the visual needs of different users. Row and column operations utilize efficient algorithms to reduce latency when working with large amounts of data.

[0182] Use the WebView2 control to load HTML pages and integrate ECharts charting functionality. Configure the WebView2 control in a WinForm application, write an HTML page, and import ECharts' pre-defined standard specification files. Configure ECharts chart parameters based on data visualization requirements, pass data to the HTML page through the WebView2 control's interface, and use JavaScript functions in the HTML page to call ECharts' pre-defined standard specification methods to update the chart, enabling the display and interaction of multiple chart types.

[0183] Integrate OCX and WebView2 controls into a WinForms application. Carefully design the WinForms user interface, strategically planning the layout of components such as the table area, chart area, toolbar, and menu bar. Embed the two controls into the user interface and configure their display properties, including size, position, and visibility. Optimize the user experience by adjusting the layout and setting related properties, such as using the layout panel to organize control positions and setting anchoring properties to achieve adaptive display.

[0184] Use C# code to implement data processing and interaction between the OCX control and the WebView2 control. The C# code reads and processes table data, calls the OCX control's interface functions to manipulate the table data, and then passes the data to the HTML page through the WebView2 control's interface functions. Finally, the JavaScript function in the HTML page updates the ECharts chart, ensuring real-time synchronization and visualization of data between the two controls.

[0185] Comprehensive functional testing and optimization of WinForms applications. We tested the table manipulation functionality of the OCX control, the chart display functionality of the WebView2 control, and the data interaction between them. We used a combination of automated test scripts and manual test cases to ensure functional accuracy and stability. Based on the test results, we optimized the application's performance, such as optimizing data loading and rendering algorithms, adjusting the interface layout and interaction flow, and improving overall system performance.

[0186] Generate detailed user documentation to support table editor operations. Based on the application's functionality and operational flow, automatically generate a document framework and foundational content, extracting code comments and interface element descriptions and integrating them into the documentation. Add screenshots and sample data for step-by-step instructions to create a comprehensive, illustrated guide. Export the guide to various formats, and establish indexing and search functionality for easy access.

[0187] The hybrid development high-performance table editor development device involved in this application consists of multiple functional modules. The OCX control encapsulation module is responsible for secondary development of the open source GridControl project and OCX control encapsulation; the table function implementation module is used to integrate OCX controls in Winform applications and implement table editing functions; the chart function implementation module is responsible for the integration and function implementation of WebView2 controls and ECharts charts; the integration module integrates OCX controls and WebView2 controls into Winform applications; the data processing module implements data processing and interaction between the two controls through C# code; the test optimization module conducts comprehensive testing and performance optimization of the application; and the document generation module is responsible for generating user documents. Each module works together to ensure the efficiency of the development process and the quality of the software.

[0188] In summary, this invention effectively addresses the performance, visualization, cross-technology integration, and specialized data format support issues inherent in existing table editors. Through hybrid development, it leverages the high performance of C++ (for OCX control development), the development efficiency of C#, and the rich visualization capabilities of Web technologies (via WebView2 and ECharts), achieving low-cost, high-performance table editing and visualization capabilities that meet the complex needs of specialized fields like engineering simulation and data analysis. This approach offers significant technical advantages and broad application prospects.

[0189] In an exemplary embodiment, a computer device is provided. The computer device may be a server or a terminal. The internal structure diagram thereof may be as follows: Figure 2 As shown. The computer device includes a processor, a memory, an input / output interface (Input / Output, abbreviated as I / O) and a communication interface. The processor, memory and input / output interface are connected through a system bus, and the communication interface is connected to the system bus through the input / output interface. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program and a database. The internal memory provides an environment for the operation of the operating system and computer program in the non-volatile storage medium. The input / output interface of the computer device is used to exchange information between the processor and an external device. The communication interface of the computer device is used to communicate with an external terminal through a network connection. When the computer program is executed by the processor, a hybrid development table editor development method is implemented.

[0190] Those skilled in the art will understand that Figure 2The structure shown in the figure is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than shown in the figure, or combine certain components, or have a different component arrangement.

[0191] In an exemplary embodiment, a computer device is further provided, including a memory and a processor. The memory stores a computer program, and the processor implements the steps in the above method embodiments when executing the computer program.

[0192] In an exemplary embodiment, a computer-readable storage medium is provided, storing a computer program. When the computer program is executed by a processor, the steps in the above-mentioned method embodiments are implemented.

[0193] In an exemplary embodiment, a computer program product is provided, including a computer program. When the computer program is executed by a processor, the steps in the above method embodiments are implemented.

[0194] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with relevant regulations.

[0195] Those skilled in the art will understand that all or part of the processes in the above-mentioned embodiment methods can be implemented by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, database or other media used in the embodiments provided in this application may include at least one of non-volatile and volatile memory. Non-volatile memory may include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory may include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM may be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM).

[0196] The databases involved in the various embodiments provided herein may include at least one of a relational database and a non-relational database. Non-relational databases may include, but are not limited to, distributed databases based on blockchains. The processors involved in the various embodiments provided herein may include, but are not limited to, general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic units, data processing logic units based on quantum computing, and the like.

[0197] The technical features of the above embodiments can be combined arbitrarily. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0198] This document uses specific examples to illustrate the principles and implementation methods of this application. The description of the above examples is only intended to help understand the method and core concept of this application. At the same time, for those skilled in the art, based on the concept of this application, there may be changes in the specific implementation methods and application scope. In summary, the content of this specification should not be understood as limiting this application.

Claims

1. A hybrid development table editor development method, characterized in that: include: Add custom column types to the open source GridControl project to get the customized project; The open source GridControl project is developed using C++; Integrate the customized project into a WinForm application, and call the interface function provided by the customized project through C# to obtain the called control; Use the WebView2 control to load the HTML page and integrate the ECharts chart function to obtain the chart function control; Utilize Winform application program to integrate the post-call control and the chart function control; The data processing and interaction between the post-call control and the chart function control are performed through C# to obtain a table editor.

2. The hybrid development table editor development method according to claim 1, characterized in that: The custom column type is added to the open source GridControl project to obtain a customized project, specifically including: Add custom column types to the open source GridControl project and get the added items; Optimizing the data loading speed of the added project to obtain an optimized project; The optimized project is encapsulated into an OCX control format to obtain a customized project.

3. The hybrid development table editor development method according to claim 1, characterized in that: Integrate the customized project into the WinForm application, and call the interface function provided by the customized project through C# to obtain the called control, specifically including: Create a WinForm application project; Adding the customized project to the Visual Studio toolbox of the WinForm application project through a registration command, and setting properties and event handlers to obtain the set project; The interface function provided by the project after setting is called through C# to obtain the called control; the interface function is used to realize the creation, assignment, style setting and row and column operation functions of the table.

4. The hybrid development table editor development method according to claim 1, characterized in that: Use the WebView2 control to load the HTML page and integrate the ECharts chart function to obtain the chart function control, which includes: Get the WebView2 control and use NuGet to load its dependencies. Write an HTML static page and load the ECharts library into the HTML static page to obtain a page loading project; The page loading project is loaded using the WebView2 control, and the chart type and interactive function are configured using the JavaScript API of ECharts to obtain a chart function control.

5. The hybrid development table editor development method according to claim 1, characterized in that: The Winform application is used to integrate the post-call control and the chart function control, specifically including: Placing the post-call control and the chart function control on the Winform main form; Coordinate and set the post-call control and the chart function control; The communication interaction between the post-call control and the chart function control is performed through the front-end and back-end interaction interfaces of the WebView2 control.

6. The hybrid development table editor development method according to claim 1, characterized in that: The data processing and interaction between the post-call control and the chart function control are performed through C# to obtain a table editor, which specifically includes: Using C# program to monitor the changes of table data in the control after the call; When the table data changes, the table data is converted into json format to obtain format conversion data; The format conversion data is transmitted to the corresponding function code of the front end through WebView2, and the format conversion data is converted into the format of the ECharts interface to present the ECharts chart view.

7. The hybrid development table editor development method according to claim 1, characterized in that: After the data processing and interaction between the post-call control and the chart function control are performed through C# to obtain the table editor, the following steps are further included: Performing functional testing on the table editor; Generate an operation manual and help file for the table editor.

8. A computer device comprising: A memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the hybrid development table editor development method according to any one of claims 1 to 7.

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

10. A computer program product comprising a computer program, characterized in that When the computer program is executed by a processor, the hybrid development table editor development method according to any one of claims 1 to 7 is implemented.

Images