CN113934957A - Method and system for generating rendering sketch file from webpage - Google Patents
Method and system for generating rendering sketch file from webpage Download PDFInfo
- Publication number
- CN113934957A CN113934957A CN202111301687.9A CN202111301687A CN113934957A CN 113934957 A CN113934957 A CN 113934957A CN 202111301687 A CN202111301687 A CN 202111301687A CN 113934957 A CN113934957 A CN 113934957A
- Authority
- CN
- China
- Prior art keywords
- file
- sketch
- json
- writing
- elements
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 24
- 238000009877 rendering Methods 0.000 title claims abstract description 21
- 230000000694 effects Effects 0.000 claims description 24
- 239000000126 substance Substances 0.000 claims description 6
- 238000006243 chemical reaction Methods 0.000 claims description 4
- 238000010276 construction Methods 0.000 claims description 3
- 230000003993 interaction Effects 0.000 abstract description 2
- 238000010586 diagram Methods 0.000 description 13
- 238000004590 computer program Methods 0.000 description 7
- 230000008859 change Effects 0.000 description 6
- 230000004048 modification Effects 0.000 description 6
- 238000012986 modification Methods 0.000 description 6
- 230000006870 function Effects 0.000 description 5
- 230000004075 alteration Effects 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000005034 decoration Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000008569 process Effects 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/95—Retrieval from the web
- G06F16/957—Browsing optimisation, e.g. caching or content distillation
- G06F16/9577—Optimising the visualization of content, e.g. distillation of HTML documents
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/95—Retrieval from the web
- G06F16/957—Browsing optimisation, e.g. caching or content distillation
Landscapes
- Engineering & Computer Science (AREA)
- Databases & Information Systems (AREA)
- Theoretical Computer Science (AREA)
- Data Mining & Analysis (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Transfer Between Computers (AREA)
Abstract
The invention discloses a method and a system for generating a render sketch file on a webpage, wherein the method comprises the following steps: analyzing the sketch file into a file with a preselected format; and converting and outputting the file with the pre-selected format into a file which can be analyzed and rendered by HTML. The method simplifies the operation and the steps to a certain extent aiming at the scheme from sketch to HTML, and is not limited by the requirement of installing sketch software. The sketch file is processed in the browser environment, and a corresponding HTML structure is directly output and is delivered to a browser for direct rendering. The user only needs to select the sketch file to be analyzed in a browser through simple interaction, and then the rendering can be completed. The user does not need to install sketch software and does not need to install corresponding plug-ins.
Description
Technical Field
The invention is applied to the technical field of webpage sketch file generation, and particularly relates to a method and a system for generating and rendering sketch files by a webpage.
Background
At present, a plurality of factories on the market in China provide tools with the output capacity from sketch to HTML, but most of the factories use a sketch plug-in form as a carrier, and the files are analyzed in sketch software to output format files of the HTML by depending on the ecology in the sketch software, then the HTML files are opened from a browser to display the effect, and the reduction effect and the editing effect are lost to a certain extent. For example, a user wants to view a sketch file in a browser, needs to install sketch software, and then finds a corresponding plugin in a plugin store corresponding to sketch and downloads the plugin. And then opening the plugin in the sketch software, analyzing the sketch file by using the function of the plugin, finding the generated HTML file in the specified folder directory, and opening the file viewing effect by using a browser. In terms of operation flow, although the scheme in the plug-in form has the effect of restoring the sketch file in the browser, the steps and the operation are relatively complicated, and the sketch software needs to be relied on, and can be installed and used only in the mac operating system at present.
Disclosure of Invention
The invention aims to solve the technical problem of the prior art and provides a method and a system for generating and rendering sketch files on a webpage.
In order to solve the technical problem, the method for generating the sketch file for rendering the webpage comprises the following steps of:
analyzing the sketch file into a file with a preselected format;
and converting and outputting the file with the pre-selected format into a file which can be analyzed and rendered by HTML.
As a possible implementation, further, the preselected format is a json format.
As a possible implementation manner, further, the step of parsing the sketch file into a file with a pre-selected format specifically includes the following sub-steps:
s11, constructing a corresponding json directory and forming a json structure tree;
s12, writing the basic attribute of each element in the source file into a json structure tree;
and S13, respectively carrying out corresponding analysis on each element according to own unique attributes and writing the elements into the json structure tree.
As a possible implementation manner, further, the step of converting the file with the preselected format into the file capable of being rendered by HTML parsing specifically includes the following sub-steps:
s21, inserting the content written into the json structure tree in the step S13 into embedded HTML in an element form, and writing the content corresponding to the style/css standard;
s22, respectively embedding the content of the json structure tree into html, and completing the operation of generating the sketch source file in the html.
As a possible implementation manner, further, the step S11 is specifically: obtaining sketch source files, analyzing according to a preset category sequence, constructing a hierarchical relationship, constructing a corresponding json directory according to the hierarchical relationship, and forming a json structure tree;
wherein the content of the first and second substances,
the preset category sequence is that the granularity is from big to small in sequence: pages, drawing boards, elements;
the elements comprise characters, pictures and figures;
the json structure tree includes the id of the corresponding element and the attribute of the element.
As a possible implementation manner, further, the step S12 is specifically: acquiring the basic attribute of each element in a source file, establishing a basic attribute directory in the constructed json tree, and writing the basic attribute of each element into the corresponding basic attribute directory;
wherein the content of the first and second substances,
the basic attribute of the element at least comprises one of width, height, position coordinates XY, rotation angle, transform, transparency, color, background color, mixed mode and mask.
As a possible implementation manner, further, the step S13 specifically includes:
and (3) carrying out analysis and writing operation on the graphic elements: matching the special attribute on the graphic element by using svg, analyzing the svg code of the graphic according to the attribute corresponding to the source file, and writing the svg into the content field in the json structure tree of the graphic element in a character string mode; wherein the specific attributes on the graphic element include fill effect, border, shadow, inner shadow and path;
and (3) performing analysis and writing operation on the character elements: directly analyzing and matching the special attributes on the character elements and writing the special attributes into a json structure tree directory of the corresponding character elements; wherein the unique attributes on the text elements include: font-size, font-family, font-style, font-weight, line-height, letter-space, Text-align, Vertical-align, Text-decode, writing-mode, auto-adaptive, fill effect, border, shadow, and inner shadow;
and (3) carrying out analysis and writing operation on the picture elements: analyzing and matching the special attributes on the picture elements and writing the attributes into json corresponding to the character elements; wherein the attributes specific on the picture element include: base64 address, fill effect, border, shadow, and inner shadow.
A web page generation rendering sketch file system, comprising: the system comprises an analysis module for analyzing the sketch file into a json format file and a conversion output module for converting and outputting the json format file into a file which can be analyzed and rendered by HTML (hypertext markup language);
wherein the parsing module comprises:
a source file obtaining unit, configured to obtain a sketch source file;
the construction unit is used for constructing a corresponding json catalogue and forming a json structure tree;
a basic attribute writing unit, configured to write the basic attributes of the elements in the source file into a json structure tree;
and the unique attribute writing unit is used for correspondingly analyzing each element according to the unique attribute of the element and writing the element into the json structure tree.
A computer readable storage medium having stored thereon program files which, when executed by a processor, perform a method of web page generation rendering sketch files.
By adopting the technical scheme, the invention has the following beneficial effects: the method simplifies the operation and the steps to a certain extent aiming at the scheme from sketch to HTML, and is not limited by the requirement of installing sketch software. The sketch file is processed in the browser environment, and a corresponding HTML structure is directly output and is delivered to a browser for direct rendering. The user only needs to select the sketch file to be analyzed in a browser through simple interaction, and then the rendering can be completed. The user does not need to install sketch software and does not need to install corresponding plug-ins.
Drawings
The invention is described in further detail below with reference to the following figures and embodiments:
FIG. 1 is a schematic diagram of the principles of the present invention;
FIG. 2 is a schematic view of an operation interface of a first part of the steps in embodiment 2 of the present invention;
FIG. 3 is a schematic view of an operation interface of a second part of the first step in embodiment 2 of the present invention;
FIG. 4 is a schematic diagram of a graphical operation interface of a first part of steps in embodiment 2 of the present invention;
FIG. 5 is a schematic diagram of a third graphical writing interface of a first part of the steps in embodiment 2;
FIG. 6 is a schematic diagram of a third text-writing interface of the first step in embodiment 2;
FIG. 7 is a schematic diagram of a third picture writing interface in a first step according to embodiment 2 of the present invention;
fig. 8 is a schematic view of a second partial SVG operation interface in embodiment 2 of the present invention;
fig. 9 is a schematic view of a second part of the text operation interface in embodiment 2 of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the technical solutions of the embodiments of the present invention will be described in detail and completely with reference to the accompanying drawings.
Example 1
As shown in fig. 1, the present invention provides a method for generating a sketch file for rendering a webpage, which includes the following steps:
analyzing the sketch file into a file with a preselected format;
and converting and outputting the file with the pre-selected format into a file which can be analyzed and rendered by HTML.
As a possible implementation, further, the preselected format is a json format.
As a possible implementation manner, further, the step of parsing the sketch file into a file with a pre-selected format specifically includes the following sub-steps:
s11, constructing a corresponding json directory and forming a json structure tree;
s12, writing the basic attribute of each element in the source file into a json structure tree;
and S13, respectively carrying out corresponding analysis on each element according to own unique attributes and writing the elements into the json structure tree.
As a possible implementation manner, further, the step of converting the file with the preselected format into the file capable of being rendered by HTML parsing specifically includes the following sub-steps:
s21, inserting the content written into the json structure tree in the step S13 into embedded HTML in an element form, and writing the content corresponding to the style/css standard;
s22, respectively embedding the content of the json structure tree into html, and completing the operation of generating the sketch source file in the html.
As a possible implementation manner, further, the step S11 is specifically: obtaining sketch source files, analyzing according to a preset category sequence, constructing a hierarchical relationship, constructing a corresponding json directory according to the hierarchical relationship, and forming a json structure tree;
wherein the content of the first and second substances,
the preset category sequence is that the granularity is from big to small in sequence: pages, drawing boards, elements;
the elements comprise characters, pictures and figures;
the json structure tree includes the id of the corresponding element and the attribute of the element.
As a possible implementation manner, further, the step S12 is specifically: acquiring the basic attribute of each element in a source file, establishing a basic attribute directory in the constructed json tree, and writing the basic attribute of each element into the corresponding basic attribute directory;
wherein the content of the first and second substances,
the basic attribute of the element at least comprises one of width, height, position coordinates XY, rotation angle, transform, transparency, color, background color, mixed mode and mask.
As a possible implementation manner, further, the step S13 specifically includes:
and (3) carrying out analysis and writing operation on the graphic elements: matching the special attribute on the graphic element by using svg, analyzing the svg code of the graphic according to the attribute corresponding to the source file, and writing the svg into the content field in the json structure tree of the graphic element in a character string mode; wherein the specific attributes on the graphic element include fill effect, border, shadow, inner shadow and path;
and (3) performing analysis and writing operation on the character elements: directly analyzing and matching the special attributes on the character elements and writing the special attributes into a json structure tree directory of the corresponding character elements; wherein the unique attributes on the text elements include: font-size, font-family, font-style, font-weight, line-height, letter-space, Text-align, Vertical-align, Text-decode, writing-mode, auto-adaptive, fill effect, border, shadow, and inner shadow;
and (3) carrying out analysis and writing operation on the picture elements: analyzing and matching the special attributes on the picture elements and writing the attributes into json corresponding to the character elements; wherein the attributes specific on the picture element include: base64 address, fill effect, border, shadow, and inner shadow.
A web page generation rendering sketch file system, comprising: the system comprises an analysis module for analyzing the sketch file into a json format file and a conversion output module for converting and outputting the json format file into a file which can be analyzed and rendered by HTML (hypertext markup language);
wherein the parsing module comprises:
a source file obtaining unit, configured to obtain a sketch source file;
the construction unit is used for constructing a corresponding json catalogue and forming a json structure tree;
a basic attribute writing unit, configured to write the basic attributes of the elements in the source file into a json structure tree;
and the unique attribute writing unit is used for correspondingly analyzing each element according to the unique attribute of the element and writing the element into the json structure tree.
A computer readable storage medium having stored thereon program files which, when executed by a processor, perform a method of web page generation rendering sketch files.
Example 2
According to the scheme, the sketch file is processed in the browser environment, and matching and processing of the structure corresponding to the HTML are combined for different elements (such as characters, pictures, figures and the like) in the sketch.
Our conversion step is largely divided into two parts.
The first part parses the sketch file into a specific format (json format in the preferred embodiment).
The second part is converted and output into a file which can be analyzed and rendered by HTML according to the specific format file.
First, look at the first portion.
Step one, obtaining a sketch source file, and analyzing the source file according to a preset category sequence, wherein the method comprises the following steps: parsing the source file into: the granularity of the page- > the drawing board- > elements (groups, characters, pictures and figures) is in the order from large to small. And constructing a hierarchical relationship, wherein the page comprises drawing board elements, the drawing board elements comprise group elements, and the group elements respectively comprise picture elements, character elements and graphic elements. And constructing a corresponding json directory according to the hierarchical relationship and forming a json structure tree, wherein the json structure tree comprises corresponding element ids and element attributes. As shown in fig. 2.
And secondly, acquiring basic attributes (width, height, position coordinates XY, rotation angle, transform, transparency, color, background color, mixed mode, mask and the like) of each element in the source file, establishing a basic attribute directory in the constructed json tree, and writing the basic attributes of each element into the corresponding basic attribute directory, wherein the basic attributes of different elements can be different, not all the elements have all the basic attributes, and writing the basic attributes according to the attributes contained in the source file. As shown in fig. 3.
And step three, after the basic attribute json structure tree is analyzed and constructed, correspondingly analyzing the graphs, the characters and the pictures according to the characteristics of the graphs, the characters and the pictures. This is exemplified by graphic and text elements
First are graphic elements, we use svg (scalable vector graphics, images can be described in code), matching the associated attributes on the graphic elements:
1. filling effect (pure color, linear gradient, radial gradient)
2. Rims (inner rim, middle rim, outer rim, rim node, pure color, linear gradual change, radial gradual change, dotted line, interval, rim width)
3. Shadow (color, coordinate, fuzzy effect)
4. Inner shadow (color, coordinate, fuzzy effect)
5. Route of travel
The svg code for parsing out the graph according to the attribute corresponding to the source file is shown in fig. 4.
And writing the svg into a content field in a json structure tree of the graphic element in a character string mode. As shown in fig. 5.
Analyzing the relevant attributes on the text elements:
1.font-size
2.font-family
3.font-style
4.font-weight
5.line-height
6.letter-space
7.Text-align
8.Vertical-align
9.text-decoration
10.writing-mode
11.auto-adaptive
12. filling effect (pure color, linear gradient, radial gradient)
13. Rims (inner rim, middle rim, outer rim, pure color, linear gradual change, radial gradual change, rim width)
14. Shadow (color, coordinate, fuzzy effect)
15. Inner shadow (color, coordinate, fuzzy effect)
And then written into the json structure tree directory of the corresponding text element. As shown in fig. 6.
Parsing of picture elements
Base64 address
2. Filling effect (pure color, linear gradient, radial gradient)
3. Rims (inner rim, middle rim, outer rim, rim node, pure color, linear gradual change, radial gradual change, dotted line, interval, rim width)
4. Shadow (color, coordinate, fuzzy effect)
5. Inner shadow (color, coordinate, fuzzy effect)
And then written into json of the corresponding text element. As shown in fig. 7.
So far, the step of resolving the sketch file into json is completed
The second part, we need to output HTML according to json. Here we take SVG and text examples
Since HTML5 is SVG-enabled, we directly insert the parsed content fields into the embedded HTML in element form and write the corresponding seat width height according to the style/css standard, as in FIG. 8.
And the text part can be written by aligning the json field with style/css. As shown in fig. 9. Finally, the content of the json structure tree is respectively embedded into the html, the effect of generating the sketch source file in the html is achieved, and a user can directly render and generate the corresponding directory structure in the webpage only by dragging the sketch source file to the browser, so that later-stage editing in the webpage is conveniently achieved.
It will be appreciated by those skilled in the art that embodiments of the present invention may be provided as a method, browser system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
It should be noted that in the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps not listed in a claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The invention may be implemented by means of hardware comprising several distinct elements, and by means of a suitably programmed computer. In the unit claims enumerating several means, several of these means may be embodied by one and the same item of hardware. The usage of the words first, second and third, etcetera do not indicate any ordering. These words may be interpreted as names.
While preferred embodiments of the present invention have been described, additional variations and modifications in those embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including preferred embodiments and all such alterations and modifications as fall within the scope of the invention.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is also intended to include such modifications and variations.
The foregoing is directed to embodiments of the present invention, and equivalents, modifications, substitutions and variations such as will occur to those skilled in the art, which fall within the scope and spirit of the appended claims.
Claims (9)
1. A method for generating a sketch file for rendering a webpage is characterized by comprising the following steps:
analyzing the sketch file into a file with a preselected format;
and converting and outputting the file with the pre-selected format into a file which can be analyzed and rendered by HTML.
2. The method for generating a sketch file for rendering a webpage according to claim 1, wherein: the preselected format is a json format.
3. The method for generating a sketch file for rendering a webpage according to claim 2, wherein: the step of parsing the sketch file into a file with a preselected format specifically comprises the following substeps:
s11, constructing a corresponding json directory and forming a json structure tree;
s12, writing the basic attribute of each element in the source file into a json structure tree;
and S13, respectively carrying out corresponding analysis on each element according to own unique attributes and writing the elements into the json structure tree.
4. The method for generating a sketch file for rendering a webpage according to claim 3, wherein: the step of converting and outputting the file with the preselected format into the file which can be analyzed and rendered by HTML specifically comprises the following substeps:
s21, inserting the content written into the json structure tree in the step S13 into embedded HTML in an element form, and writing the content corresponding to the style/css standard;
s22, respectively embedding the content of the json structure tree into html, and completing the operation of generating the sketch source file in the html.
5. The method for generating a sketch file for rendering a webpage according to claim 3, wherein: the step S11 specifically includes: obtaining sketch source files, analyzing according to a preset category sequence, constructing a hierarchical relationship, constructing a corresponding json directory according to the hierarchical relationship, and forming a json structure tree;
wherein the content of the first and second substances,
the preset category sequence is that the granularity is from big to small in sequence: pages, drawing boards, elements;
the elements comprise characters, pictures and figures;
the json structure tree includes the id of the corresponding element and the attribute of the element.
6. The method for generating a sketch file for rendering a webpage according to claim 5, wherein: the step S12 specifically includes: acquiring the basic attribute of each element in a source file, establishing a basic attribute directory in the constructed json tree, and writing the basic attribute of each element into the corresponding basic attribute directory;
wherein the content of the first and second substances,
the basic attribute of the element at least comprises one of width, height, position coordinates XY, rotation angle, transform, transparency, color, background color, mixed mode and mask.
7. The method for generating a sketch file for rendering a webpage according to claim 6, wherein: the step S13 specifically includes:
and (3) carrying out analysis and writing operation on the graphic elements: matching the special attribute on the graphic element by using svg, analyzing the svg code of the graphic according to the attribute corresponding to the source file, and writing the svg into the content field in the json structure tree of the graphic element in a character string mode; wherein the specific attributes on the graphic element include fill effect, border, shadow, inner shadow and path;
and (3) performing analysis and writing operation on the character elements: directly analyzing and matching the special attributes on the character elements and writing the special attributes into a json structure tree directory of the corresponding character elements; wherein the unique attributes on the text elements include: font-size, font-family, font-style, font-weight, line-height, letter-space, Text-align, Vertical-align, Text-decode, writing-mode, auto-adaptive, fill effect, border, shadow, and inner shadow;
and (3) carrying out analysis and writing operation on the picture elements: analyzing and matching the special attributes on the picture elements and writing the attributes into json corresponding to the character elements; wherein the attributes specific on the picture element include: base64 address, fill effect, border, shadow, and inner shadow.
8. A system for generating a render sketch file for a web page, comprising: the system comprises an analysis module for analyzing the sketch file into a json format file and a conversion output module for converting and outputting the json format file into a file which can be analyzed and rendered by HTML (hypertext markup language);
wherein the parsing module comprises:
a source file obtaining unit, configured to obtain a sketch source file;
the construction unit is used for constructing a corresponding json catalogue and forming a json structure tree;
a basic attribute writing unit, configured to write the basic attributes of the elements in the source file into a json structure tree;
and the unique attribute writing unit is used for correspondingly analyzing each element according to the unique attribute of the element and writing the element into the json structure tree.
9. A computer-readable storage medium, having stored thereon a program file, which, when executed by a processor, performs the method of any one of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111301687.9A CN113934957A (en) | 2021-11-04 | 2021-11-04 | Method and system for generating rendering sketch file from webpage |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111301687.9A CN113934957A (en) | 2021-11-04 | 2021-11-04 | Method and system for generating rendering sketch file from webpage |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113934957A true CN113934957A (en) | 2022-01-14 |
Family
ID=79285769
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111301687.9A Pending CN113934957A (en) | 2021-11-04 | 2021-11-04 | Method and system for generating rendering sketch file from webpage |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113934957A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114841125A (en) * | 2022-04-20 | 2022-08-02 | 厦门稿定股份有限公司 | AI format file processing method, device and storage medium |
| CN114968957A (en) * | 2022-04-19 | 2022-08-30 | 高途教育科技集团有限公司 | File sharing method and device, storage medium and electronic equipment |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120133664A1 (en) * | 2010-11-29 | 2012-05-31 | Lotus Hill Institute For Computer Vision And Information Science | System and method for painterly rendering based on image parsing |
| CN111562919A (en) * | 2020-07-14 | 2020-08-21 | 成都市映潮科技股份有限公司 | Method, system and storage medium for generating front-end webpage code based on PSD file |
| CN113010169A (en) * | 2021-03-08 | 2021-06-22 | 北京房江湖科技有限公司 | Method and apparatus for converting UI diagram into code file |
| CN113032708A (en) * | 2021-04-02 | 2021-06-25 | 广州博恒信息科技有限责任公司 | Code-free Web development system |
-
2021
- 2021-11-04 CN CN202111301687.9A patent/CN113934957A/en active Pending
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120133664A1 (en) * | 2010-11-29 | 2012-05-31 | Lotus Hill Institute For Computer Vision And Information Science | System and method for painterly rendering based on image parsing |
| CN111562919A (en) * | 2020-07-14 | 2020-08-21 | 成都市映潮科技股份有限公司 | Method, system and storage medium for generating front-end webpage code based on PSD file |
| CN113010169A (en) * | 2021-03-08 | 2021-06-22 | 北京房江湖科技有限公司 | Method and apparatus for converting UI diagram into code file |
| CN113032708A (en) * | 2021-04-02 | 2021-06-25 | 广州博恒信息科技有限责任公司 | Code-free Web development system |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114968957A (en) * | 2022-04-19 | 2022-08-30 | 高途教育科技集团有限公司 | File sharing method and device, storage medium and electronic equipment |
| CN114841125A (en) * | 2022-04-20 | 2022-08-02 | 厦门稿定股份有限公司 | AI format file processing method, device and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11182535B2 (en) | Configuring a page for drag and drop arrangement of content artifacts in a page development tool | |
| CN106371844B (en) | A kind of method and system with primary user interface components displayed web page | |
| JP6629848B2 (en) | Page processing for mobile applications | |
| CN108415702B (en) | Dynamic rendering method and device for application interface of mobile terminal | |
| US20130326333A1 (en) | Mobile Content Management System | |
| US20140033010A1 (en) | Method and system for dynamic assembly of form fragments | |
| CN113934957A (en) | Method and system for generating rendering sketch file from webpage | |
| Vyshnavi et al. | Efficient way of web development using python and flask | |
| US20160012147A1 (en) | Asynchronous Initialization of Document Object Model (DOM) Modules | |
| CN113032708A (en) | Code-free Web development system | |
| CN113126990A (en) | Page development method, device, equipment and storage medium | |
| US20180349345A1 (en) | Reducing graphical interface description code | |
| EP3738037A1 (en) | Displaying an indication of changes made to content at a source | |
| WO2016005884A2 (en) | Javascript-based, client-side template driver system | |
| Gottfried et al. | Drawsocket: A browser based system for networked score display | |
| Taivalsaari | Mashware: The future of web applications | |
| CN115268904A (en) | User interface design file generation method, device, equipment and medium | |
| JP7248802B2 (en) | Rendering video with dynamic components | |
| CN111367514A (en) | Page card development method and device, computing device and storage medium | |
| CN116301813B (en) | Low-code platform development method and system | |
| US10198408B1 (en) | System and method for converting and importing web site content | |
| US20160012023A1 (en) | Self-Referencing of Running Script Elements in Asynchronously Loaded DOM Modules | |
| CN117093386A (en) | Page screenshot method, device, computer equipment and storage medium | |
| Bellamy-Royds et al. | Using SVG with CSS3 and HTML5: vector graphics for web design | |
| US9135225B2 (en) | Data description injection |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| RJ01 | Rejection of invention patent application after publication | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20220114 |