KR100983773B1 - Apparatus and method for treating vector data using open vector graphics - Google Patents

Apparatus and method for treating vector data using open vector graphics Download PDF

Info

Publication number
KR100983773B1
KR100983773B1 KR1020080035627A KR20080035627A KR100983773B1 KR 100983773 B1 KR100983773 B1 KR 100983773B1 KR 1020080035627 A KR1020080035627 A KR 1020080035627A KR 20080035627 A KR20080035627 A KR 20080035627A KR 100983773 B1 KR100983773 B1 KR 100983773B1
Authority
KR
South Korea
Prior art keywords
vector
openvg
element
data
vector graphics
Prior art date
Application number
KR1020080035627A
Other languages
Korean (ko)
Other versions
KR20090110046A (en
Inventor
김영옥
Original Assignee
주식회사 코아로직
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by 주식회사 코아로직 filed Critical 주식회사 코아로직
Priority to KR1020080035627A priority Critical patent/KR100983773B1/en
Priority claimed from US12/426,176 external-priority patent/US20090273604A1/en
Publication of KR20090110046A publication Critical patent/KR20090110046A/en
Application granted granted Critical
Publication of KR100983773B1 publication Critical patent/KR100983773B1/en

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06TIMAGE DATA PROCESSING OR GENERATION, IN GENERAL
    • G06T1/00General purpose image data processing
    • G06T1/20Processor architectures; Processor configuration, e.g. pipelining

Abstract

The vector data processing apparatus using the open vector graphics engine according to the present invention is configured to parse a vector element of an application for processing vector graphics content and to generate and output an object corresponding to the parsed vector element using an OpenVG engine. A browser API unit for extracting vector elements by parsing each element constituting a web page including the vector elements according to a property by calling a parser corresponding to the data of the web page; A pre-processing unit converting the extracted vector element data into a corresponding OpenVG type vector element data and classifying and transmitting the extracted vector element data according to characteristics; An OpenVG transform generation unit configured to generate an OpenVG vector object by performing an operation corresponding to the OpenVG type vector element data classified and input by the preprocessor; And an OpenVG renderer that renders the OpenVG vector object.
According to the present invention, the vector graphics content optimized in a mobile environment by operating an operation such as a browser by embedding an OpenVG engine or the like in a mobile browser application that can effectively perform hardware acceleration processing of the vector element Create an effect that can be realized.

Description

Apparatus and method for vector data processing using open vector graphics engine {APPARATUS AND METHOD FOR TREATING VECTOR DATA USING OPEN VECTOR GRAPHICS}

The present invention relates to a vector data processing apparatus implemented in a mobile communication, that is, a mobile environment, and more particularly, by embedding an open vector graphics engine in a mobile browser and driving it in conjunction with a browser to efficiently execute vector content included in a web page. An apparatus and method for processing the vector data using an embedded OpenVG that can be processed.

Vector graphics mean creating digital images through a series of commands or mathematical expressions in the form of lines or shapes in a given two-dimensional or three-dimensional space. A vector is a component of a physical concept that has both size and direction, as is well known, and a vector graphic is a concept used to create and store a graphic file that is a result of a user's creative activity in the form of a series of the above vector statements. .

For example, a vector graphic file does not store the information of each bit to represent a line, but rather contains information about the position of a series of points to be connected, as opposed to having all of the direct line shape information. Since only the location information such as start point, end point, etc. for expressing lines, such as information, is reduced in file size, the image itself can be modified by changing only the location information, which is easier to modify than raster image files. .

Raster graphics are equivalent to bitmap graphics, and they are often used for photographic work because they have sophisticated color expression.They are represented by a large combination of pixels, so the more pixels, the more precisely the color is expressed. You lose.

In addition, when an image composed of an existing bitmap is expanded or changed, a so-called stair phenomenon occurs in the outer shape of the image, so that the realistic or pictorial expression may be limited, but the image implemented as a vector may be enlarged or reduced. By using a matrix that is a mathematical operator, there is an advantage that the above problems can be overcome and naturally expressed.

Vector graphics include scalable vector graphics (SVG), a web graphics standard established by the W3C that performs graphics processing of images, such as extensible markup language (XML) applications. Because many functions are handled by software, it can be said that they are only used within a limited range due to low computational speed due to the characteristics of a mobile environment in which a transmission channel or a hardware resource is limited.

There are also flashes of macro media that drive content utilizing vector graphics, but the flash program itself is quite large and takes up too much memory when it is running. Since the operation process is required, the efficiency is low compared to the implementation function.

On the other hand, the mobile communication browser has been transformed into a full browsing form for the third generation capable of processing various vector graphics and dynamic HTML beyond the existing HTML web page through the first and second generations. In the first and second generation browsing methods, since content is provided for each content provider, content using a conventional browser is limited in its use.

In addition, the third-generation browser processes the vector content by using an engine capable of processing vector graphics to process the vector included in a web document, etc. in software, but the processing speed is not supported. In the mobile system of the vector-related content that requires a lot of operations, such as vector games are not yet fully functional.

In other words, the retrievability of the various information and the instantaneous retrieval of the Internet is an essential characteristic of the Internet, but with the graphic driving technique of the current mobile, such an Internet environment can be realized in the mobile terminal, and the market of the mobile terminal. The need for a mobile terminal capable of satisfying the user's demand for high specification of the content graphic environment is gradually increasing so as to further enhance the competitiveness.

SUMMARY OF THE INVENTION The present invention has been made to overcome the above-mentioned problems, and it is possible to express an effective vector graphic element even with simple operation and use of small resources, and based on this, a vector data processing apparatus using a more user-oriented open vector graphics engine and The purpose is to provide a method.

 Another object of the present invention is to provide a recording medium on which a computer-readable program is executed so as to implement the method in a computer.

Other objects and advantages of the present invention will be described below and will be appreciated by the embodiments of the present invention. In addition, the objects and advantages of the present invention can be realized by the configuration and combination of configurations shown in the claims.

The vector data processing apparatus using the open vector graphics engine of the present invention for achieving the above object, parses the vector element of the application processing the vector graphics content and generates an object corresponding to the parsed vector element using the OpenVG engine. Is configured to output.

In addition, the application is a mobile browser for browsing a web page, more preferably, by calling a parser corresponding to the data of the web page to parse each element constituting the web page including the vector element according to the characteristics A browser API unit for extracting vector elements; A pre-processing unit converting the extracted vector element data into a corresponding OpenVG type vector element data and classifying and transmitting the extracted vector element data according to characteristics; An OpenVG transform generation unit configured to generate an OpenVG vector object by performing an operation corresponding to the OpenVG type vector element data classified and input by the preprocessor; And an OpenVG renderer that renders the OpenVG vector object.

According to the vector data processing apparatus using the open vector graphics engine according to the present invention, the following effects can be created.

First, a device or a browser equipped with a vector processing engine capable of satisfying the high demands of the user for a graphic environment by configuring the vector content to be implemented at a higher processing speed even with a small hardware resource of a mobile terminal to be mobile. Can be provided.

Second, the OpenVG engine is built in a browser to interoperate with each other, so that various web pages and other data input through the browser can be effectively processed and managed. And waste of manpower for work can be greatly reduced.

Third, the UI of the vector type terminal which can produce various effects by interacting with vector content processed using a browser with other pure objects (HTML, JavaScript, etc.) can be implemented.

Fourth, in order to efficiently process vector graphics contents in the mobile browser, the process of cooperating with the browser, processing each data, and driving events of the user is optimized, and data collection using the open vector graphics engine is used as a rendering method. A preprocessing apparatus and method for processing an object can be provided.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings. Prior to this, terms or words used in the specification and claims should not be construed as having a conventional or dictionary meaning, and the inventors should properly explain the concept of terms in order to best explain their own invention. Based on the principle that can be defined, it should be interpreted as meaning and concept corresponding to the technical idea of the present invention.

Therefore, the embodiments described in the specification and the drawings shown in the drawings are only the most preferred embodiment of the present invention and do not represent all of the technical idea of the present invention, various modifications that can be replaced at the time of the present application It should be understood that there may be equivalents and variations.

The vector data processing apparatus using the open vector graphics engine of the present invention is configured to parse a vector element of an application for processing vector graphics content and to generate and output an object corresponding to the parsed vector element using an OpenVG engine. The application may consist of a mobile browser for browsing web pages.

The present invention analyzes and detects a vector element by parsing variously expressed vector content or graphic elements through tag information included in the web page, and generates an object corresponding to the parsed vector element using an OpenVG engine. Is configured to output.

The OpenVG (OpenVector Graphics) is composed of a finite state machine (FSM) in which a vector rendering processing part is a hardware suitable form, so that the pipeline can implement higher speed than a rendering engine processed by a conventional software method. It consists of a set of standard APIs (Applicaiton Programming Interfaces) for constructing structures and vectors, so that the hardware engines conforming to the OpenVG specification can be mapped 1: 1 with the software rendering engine, enabling hardware accelerators to be supported without any porting work.

Conventional technology, which is driven by integrating and compiling a vector graphics engine into software for driving a mobile phone, should support UI content services and produce UI content by coding the APIs in the standard specification one by one.

On the other hand, the present invention is already provided universally on the wire and parses * .xml and * .svg contents in a form that supports vectors through a browser so that the parsed result can be expressed as a vector object in connection with the OpenVG engine. By doing so, it is possible to provide higher usability and economy in terms of time and effort for producing content.

In other words, by receiving the parsed data of the web page from the API provided in the mobile browser and performing the preprocessing process of converting each parsed result data into the corresponding OpenVG type data, the mobile browser and the OpenVG vector object are generated and rendered. By effectively mediating the OpenVG engine, it is possible to efficiently perform the organic linkage operation between the mobile browser and the OpenVG engine.

The detailed configuration and driving method for the mobile browser in which the OpenVG engine is built according to the present invention will be described in detail with reference to FIGS. 1 to 6 as follows.

As shown in FIGS. 1 and 2, the vector data processing apparatus 10 using the open vector graphics engine according to the present invention is a browser API 100, a preprocessor 130, a transform generator 140, and an OpenVG rendering. It may be configured to include a unit 150, the UI signal processing unit 160 or Java script 170 may be additionally included according to the application example of the embodiment.

The browser API 100 extracts a vector element by calling a parser corresponding to the data of the web page by parsing each element constituting the web page including the vector element according to a characteristic (S200).

The browser API 100 receives the web data input to the mobile communication terminal, analyzes each element constituting the web data, and calls each parser corresponding to the interpreted element to drive the analyzed element. It comprises a web page analysis unit 110 and various parsers 120 that can parse various elements included in the web data.

The parser is an element that can be variously provided according to a specification or an embodiment of a browser or a terminal. As shown in FIG. 2, an image date processor 120-1, a style system 120-2, and a CSS parser 120 are illustrated. -3), XML Parser 120-4, HTML Parser 120-5, and the like, and each parser shown in FIG. 2 and a configuration linked thereto are described to refer to one embodiment of the present invention. This utilized embodiment is, of course, limited to the parser and the like shown in Figure 1 can not be interpreted.

Each parser is used to analyze the HTML, XML, CSS, etc. in the browser and to process the style through the CSS parser in the browser, and to implement the browser according to the present invention as it is an API provided basically in a mobile communication terminal. Function as a dictionary API Tag data, first filtered through the parser of each element, first extracts each matrix value of g tags for path data having two-dimensional elements and image data and geometric calculation processing.

As described above, the vector element data extracted as a result of parsing through each parser is transferred to the preprocessor 130 of the present invention (S210), and the preprocessor 130 analyzes the extracted vector element data. The data is converted into OpenVG data corresponding to each data and classified according to its characteristics (S220).

That is, before performing the step of generating the corresponding OpenVG vector object to process each of the various data corresponding to the vector element by the OpenVG engine, each vector element is converted into OpenVG type vector element data, grouped, classified and classified. The data is selectively transmitted to the OpenVG transform generation unit 140 capable of processing data corresponding to the vector element (S230).

In more detail, the preprocessor 130 includes a database unit 135 storing attribute information defining OpenVG vector elements. When the extracted vector element data is input, the preprocessor 130 reads the attribute information. It is preferable to determine whether the input vector element data is suitable for the OpenVG vector element or conforms to the specification and, if applicable, converts the vector element data into OpenVG type vector element data, classifies and transmits the same. .

That is, the elements extracted through the parser or the like as described above are operated by the preprocessing unit 130 to be referred to the attribute information stored in the database unit 135 so that each of the extracted elements is appropriate for the form of open vector graphics. It is configured to verify attribute information or form information about an element.

Subsequently, the OpenVG transform generation unit 140 of the present invention converts the OpenVG vector element data into an OpenVG vector object by performing an operation corresponding to the vector element data input through the preprocessor 130 ( S240).

That is, as shown in FIG. 6, when the * .html type document file 300 showing an example in the browser stage is driven, the syntax corresponding to the document file is interpreted to provide an example in the preprocessing stage of the present invention. The open vector graphics engine is processed by classifying the data into OpenVG type data according to the example 400 shown in the figure, and collecting the data input through the parser and converting the data into a form that is bonded to an application of the open vector graphics engine. It consists of a form 500 for.

As shown in FIG. 2, the OpenVG transform generation unit 140 converts the OpenVG type vector element data input through the preprocessor into path, image, text, animation, ellipse, and the like, to generate the transform of each corresponding vector element. It can be created with at least one OpenVG vector object among line, arc, font, scale, transformation, ratate, shear, gradient, and scissor, and various individual OpenVG transformation generators according to the embodiment of the vector object or the characteristics of the vector element. Of course, 140 may be added or added.

In particular, the OpenVG transform generation unit OpenVG Path transform generation unit 140-1 for generating the input path vector element data as an OpenVG path vector object, OpenVG Image transform generation for generating the input imge vector element data as an OpenVG image vector object An OpenVG Text transformation generation unit 140-3 which generates the input text vector element data as an OpenVG text vector object and an OpenVG Animation transformation generation which generates the input animation vector element data as an OpenVG animation vector object. The configuration including the unit 140-4 is the most preferable form for processing general vector objects.

As described above, the vector elements transformed and generated by the transform generation unit 140 into the OpenVG vector object are transferred to the OpenVG rendering unit 150 of the present invention (S250), and the OpenVG rendering unit 150 is transferred to the OpenVG vector object. Render the object for (S260) and finally output it through the screen display means 200 (S270).

That is, as described above, when the collection, conversion, and transfer of vector data and the like is completed, the OpenVG rendering unit 150 of the present invention finally generates each object of the vector content.

Referring to FIG. 3, which is a block diagram of a specific configuration of the OpenVG rendering unit 150 of the present invention, the OpenVG rendering unit 150 will be described in detail. First, the OpenVG rendering unit 150 includes a rendering unit 151 and a format. The conversion unit 155, the OpenVG driver 153, the storage unit 157, and the controller 158 may be configured to be included.

The rendering unit 151 of the OpenVG rendering unit 150 renders a vector object using the data transferred from the preprocessor 130, and the format conversion unit 155 converts the rendered vector object into a corresponding terminal. When the rendered vector object is output to the screen display means of the actual terminal, when the output format is different from each other, the vector is adapted to match the output format of the screen display means such as the LCD. The object's output format is converted to RGB565, 1444, 8888, RGBA32, BGRA32, and so on.

In addition, the OpenVG rendering unit 150 includes the OpenVG driver 153 corresponding to a driver that drives the hardware accelerator 159 to perform the operation of the vector object by hardware acceleration as described above. It is more preferable to configure the creation of the vector object through a hardware accelerator so as to process the computation faster.

In addition, when the start signal of the event occurring in the mobile is input (S400), the OpenVG rendering unit 150 stores the data until stopping and stopping the rendering process (S410). It may further include a), and when the end signal of the event is input or the restart signal of the browser is input (S420) may be configured to resume the rendering (S430) using the stored data.

That is, it is preferable that the OpenVG rendering unit 150 is configured to render an object of a vector form and analyze an event of a terminal in real time, which is a state in which a process of generating and processing vector object data is temporarily stopped ( For example, it is intended to be configured to replace organically in various situations of a browser generated in the terminal, such as a call, SMS, MMS, etc. are received when performing the content.

When a signal is input that terminates an event such as restarting of a browser or an interruption state, the data stored in the storage unit 157 may be read and the final data may be restored more quickly when restarting. .

The controller 158 of the OpenVG rendering unit 150 receives the event generated in the mobile browser or the terminal in real time so that the rendering can be dynamically linked with the mobile browser. To control.

In describing the present invention, each component of the vector data processing apparatus using the open vector graphics engine according to the present invention should be understood as logically divided components rather than physically divided components.

That is, each configuration corresponds to a logical component in order to realize the technical idea of the present invention, so that even if each component is integrated or separated, if the function performed by the logical configuration of the present invention can be realized, It should be construed that it is within the scope, and that components that perform the same or similar functions should be construed as being within the scope of the present invention regardless of whether their names are consistent.

The mobile browser driving method incorporating the OpenVG engine according to the present invention described above may be embodied as computer readable codes on a computer readable recording medium. The computer-readable recording medium includes all kinds of recording devices in which data that can be read by a computer system is stored. Examples of computer-readable recording media include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage, and the like, and may also be implemented in the form of a carrier wave (for example, transmission over the Internet). Include. The computer readable recording medium can also be distributed over network coupled computer systems so that the computer readable code is stored and executed in a distributed fashion. In addition, functional programs, codes, and code segments for implementing the mobile browser driving method in which the OpenVG engine is embedded may be easily inferred by programmers in the art to which the present invention belongs.

Although the present invention has been described above by means of limited embodiments and drawings, the present invention is not limited thereto and will be described below by the person skilled in the art to which the present invention pertains. Of course, various modifications and variations are possible within the scope of the claims.

The following drawings, which are attached to this specification, illustrate exemplary embodiments of the present invention, and together with the detailed description of the present invention serve to further understand the technical spirit of the present invention, the present invention includes matters described in such drawings. It should not be construed as limited to.

1 is a block diagram showing the configuration of a vector data processing apparatus using an open vector graphics engine according to the present invention;

2 is a block diagram showing a specific configuration of a vector data processing apparatus using an open vector graphics engine according to a preferred embodiment of the present invention;

3 is a block diagram showing a specific configuration of an OpenVG rendering unit according to a preferred embodiment of the present invention;

4 is a flowchart illustrating a process of processing a vector element using an open vector graphics engine according to the present invention;

5 is a flowchart illustrating a rendering process according to an embodiment of the present invention;

6 is a diagram illustrating a specific embodiment of a vector element generation process by analyzing tag information of a browser application of the present invention.

Claims (23)

  1. A preprocessor configured to receive vector element data parsed from contents processed by an application and generate vector graphics elements for OpenVG (OpenVG) processing;
    A transformation generator for converting the vector graphics element into the OpenVG-based vector graphics object; And
    A rendering unit for rendering the converted vector graphics object,
    And the preprocessor determines whether the vector element data is a suitable element for the vector element of the OpenVG, and if the element is a suitable element, generates the vector graphics element based on the OpenVG.
  2. The vector graphics processing apparatus of claim 1, further comprising an application API unit configured to parse the data of the content and extract the vector element data.
  3. The method of claim 2, wherein the application API unit,
    An HTML parser for analyzing HTML (HyperText Markup Language) of the content;
    An XML parser for analyzing an XML (eXtensible Markup Language) of the content; And
    And at least one of a CSS parser for analyzing a cascading style sheet (CSS) of the content.
  4. The vector graphics processing apparatus of claim 2, wherein the preprocessor converts the vector element data extracted by the application API unit into vector element data of a corresponding OpenVG type, and classifies the vector element data according to characteristics.
  5. delete
  6. The apparatus of claim 1, wherein the preprocessor comprises a database unit having attribute information defining each vector graphics element.
    And comparing the vector element data with the attribute information to determine whether the element is suitable for the vector element of the OpenVG.
  7. The method of claim 1, wherein the application is a mobile browser for browsing a web page,
    The pre-processing unit receives the parsed element data of the web page from the API of the mobile browser, and generates the vector graphics element.
  8. The vector graphics processing apparatus of claim 1, further comprising a format converter configured to convert the rendered vector graphics object into an output format of a corresponding terminal.
  9. The vector graphics processing apparatus of claim 1, further comprising a driver configured to drive a hardware accelerator for rendering the vector graphics object.
  10. delete
  11. The method of claim 1, wherein the transformation generator comprises at least one vector of path, image, text, animation, ellipse, line, arc, font, scale, transformation, shear, gradient, and scissor. A vector graphics processing device, characterized in that it is generated as a graphics object.
  12. The method of claim 11, wherein the conversion generation unit,
    An OpenVG path conversion generator for generating input path vector element data into an OpenVG path vector object;
    An OpenVG Image conversion generator for generating input image vector element data into an OpenVG image vector object;
    An OpenVG Text transformation generator for generating input text vector element data into an OpenVG text vector object; And
    And at least one of an OpenVG Animation transformation generator for generating input animation vector element data into an OpenVG animation vector object.
  13. The method of claim 1, further comprising: a storage unit which, upon receiving a start signal of a mobile-related event from a terminal or the application, stops the rendering process and stores data until it is stopped.
    When the end signal of the mobile-related event is input or the restart signal of the application is input, the vector graphics processing device, characterized in that to perform the rendering using the stored data.
  14. Receiving parsed vector element data from content processed by the application;
    Confirming whether the vector element data is suitable for a vector element of OpenVG;
    Generating the vector graphics element based on the OpenVG if the vector element data is suitable for the vector element of the OpenVG;
    Converting the generated vector graphics element into the OpenVG based vector graphics object; And
    Rendering the converted vector graphics object.
  15. delete
  16. delete
  17. 15. The vector graphics processing method of claim 14, further comprising converting the rendered vector graphics object into an output format of a corresponding terminal.
  18. delete
  19. delete
  20. delete
  21. delete
  22. delete
  23. delete
KR1020080035627A 2008-04-17 2008-04-17 Apparatus and method for treating vector data using open vector graphics KR100983773B1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
KR1020080035627A KR100983773B1 (en) 2008-04-17 2008-04-17 Apparatus and method for treating vector data using open vector graphics

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
KR1020080035627A KR100983773B1 (en) 2008-04-17 2008-04-17 Apparatus and method for treating vector data using open vector graphics
US12/426,176 US20090273604A1 (en) 2008-04-17 2009-04-17 Processing Vector Graphics

Publications (2)

Publication Number Publication Date
KR20090110046A KR20090110046A (en) 2009-10-21
KR100983773B1 true KR100983773B1 (en) 2010-09-27

Family

ID=41537928

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020080035627A KR100983773B1 (en) 2008-04-17 2008-04-17 Apparatus and method for treating vector data using open vector graphics

Country Status (1)

Country Link
KR (1) KR100983773B1 (en)

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR100957531B1 (en) * 2008-04-17 2010-05-11 주식회사 코아로직 APPARATUS AND METHOD FOR DRIVING MOBILE BROWSER WITH BUILT-IN OpenVG ENGINE

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR100803166B1 (en) 2006-09-07 2008-02-14 한국전자통신연구원 Method and apparatus for controlling vector graphic in mobile phone
KR100803947B1 (en) 2006-12-01 2008-02-15 주식회사 코아로직 Apparatus and method for open vector graphic application program interface translation, mobiile terminal, and record medium on which the method is recorded

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR100803166B1 (en) 2006-09-07 2008-02-14 한국전자통신연구원 Method and apparatus for controlling vector graphic in mobile phone
KR100803947B1 (en) 2006-12-01 2008-02-15 주식회사 코아로직 Apparatus and method for open vector graphic application program interface translation, mobiile terminal, and record medium on which the method is recorded

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
Khronos OpenVG 1.0 벡터 그래픽 표준 API 구현, 한국컴퓨터그래픽스학회, 컴퓨터그래픽스학회논문지, vol. 12, no. 3, page 7-11, 2006.*

Also Published As

Publication number Publication date
KR20090110046A (en) 2009-10-21

Similar Documents

Publication Publication Date Title
US9542163B2 (en) Systems and methods for processing analytics on mobile devices
US8423953B2 (en) System and method for creating target byte code
US8972933B2 (en) Non-literal representation of programming language code
US8327328B2 (en) System and method for creating target byte code
Jones et al. Parallelizing the web browser
KR100661393B1 (en) Web site management system and method applying web programming environment
JP5010551B2 (en) Server-side code generation from dynamic web page content files
US6986101B2 (en) Method and apparatus for converting programs and source code files written in a programming language to equivalent markup language files
US7694284B2 (en) Shareable, bidirectional mechanism for conversion between object model and XML
JP4162209B2 (en) Active ALT tags in HTML documents to improve accessibility for users with audiovisual disabilities
JP3857663B2 (en) Structured document editing apparatus, structured document editing method and program
US8484626B2 (en) Generic XML screen scraping
US8156471B2 (en) Multi-language execution method
US5987256A (en) System and process for object rendering on thin client platforms
JP5209051B2 (en) Data system and method
US5875331A (en) System and method for generating target language code utilizing an object oriented code generator
US6085120A (en) Data system processing and method for creating application extension
KR100799019B1 (en) Digital document processing
JP4306991B2 (en) Data processing apparatus and method, computer program, and storage medium
US20140053064A1 (en) Predicting the usage of document resources
RU2371758C2 (en) Programming interface for computer platform
JP4179553B2 (en) Display control information generation method, computer for generating display control information, and program
KR101099272B1 (en) Web page rendering mechanism using external programmatic themes
US7721254B2 (en) Programming interface for a computer platform
AU2004286677B2 (en) Method and system for reversible design tree transformations

Legal Events

Date Code Title Description
A201 Request for examination
A302 Request for accelerated examination
E902 Notification of reason for refusal
E701 Decision to grant or registration of patent right
GRNT Written decision to grant
FPAY Annual fee payment

Payment date: 20130703

Year of fee payment: 4

LAPS Lapse due to unpaid annual fee