[bu][de] - Added method for creating ApiComplexForm objects.

Feature/oform

.gitignore

@@ -0,0 +1 @@
+.idea/

LICENSE.txt

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.

api.js

@@ -34,7 +34,6 @@
 (function(window, document) {
     window['Asc']['Addons'] = window['Asc']['Addons'] || {};
 	window['Asc']['Addons']['forms'] = true; // register addon
-	
 	window['Asc']['asc_docs_api'].prototype['asc_AddContentControlCheckBox'] = window['Asc']['asc_docs_api'].prototype.asc_AddContentControlCheckBox = function(oPr, oFormPr, oCommonPr)
 	{
 		var oLogicDocument = this.private_GetLogicDocument();
@@ -75,27 +74,79 @@
 			isLoadFonts = true;
 			AscFonts.FontPickerByCharacter.getFontBySymbol(nUncheckedSymbol);
 		}
+
+		function private_ApplyPrToCheckBox(oCC)
+		{
+			if (!oCC)
+				return;
+
+			if (oFormPr)
+			{
+				oCC.SetFormPr(oFormPr);
+				oCC.UpdatePlaceHolderTextPrForForm();
+				private_CheckFormKey(oCC, oLogicDocument);
+			}
+
+			if (oCommonPr)
+				oCC.SetContentControlPr(oCommonPr);
+		}
 		
 		function private_PerformAddCheckBox()
 		{
-			oLogicDocument.RemoveTextSelection();
-			if (!oLogicDocument.IsSelectionLocked(AscCommon.changestype_Paragraph_Content))
-			{
-				oLogicDocument.StartAction(AscDFH.historydescription_Document_AddContentControlCheckBox);
 
-				var oCC = oLogicDocument.AddContentControlCheckBox(oPr);
-				if (oCC && oFormPr)
+			if (oLogicDocument.IsTextSelectionUse())
+			{
+				let arrSelectedParagraphs = oLogicDocument.GetSelectedParagraphs();
+
+				// Select entire paragraphs so that after the action all added checkboxes are included in the selection
+				let nSelectDirection = oLogicDocument.GetSelectDirection();
+				for (let nIndex = 0, nCount = arrSelectedParagraphs.length; nIndex < nCount; ++nIndex)
 				{
-					oCC.SetFormPr(oFormPr);
-					oCC.UpdatePlaceHolderTextPrForForm();
+					arrSelectedParagraphs[nIndex].SelectAll(nSelectDirection);
 				}
 
-				if (oCC && oCommonPr)
-					oCC.SetContentControlPr(oCommonPr);
+				let oState = oLogicDocument.SaveDocumentState(false);
 
-				oLogicDocument.UpdateInterface();
-				oLogicDocument.Recalculate();
-				oLogicDocument.FinalizeAction();
+				if (arrSelectedParagraphs.length > 0
+					&& !oLogicDocument.IsSelectionLocked(AscCommon.changestype_None, {
+					Type      : AscCommon.changestype_2_ElementsArray_and_Type,
+					Elements  : arrSelectedParagraphs,
+					CheckType : AscCommon.changestype_Paragraph_Content
+				}))
+				{
+					oLogicDocument.StartAction(AscDFH.historydescription_Document_AddContentControlCheckBox);
+					oLogicDocument.RemoveSelection();
+
+					for (let nIndex = 0, nCount = arrSelectedParagraphs.length; nIndex < nCount; ++nIndex)
+					{
+						let oCC = arrSelectedParagraphs[nIndex].AddCheckBoxToStartPos(oPr);
+						private_ApplyPrToCheckBox(oCC);
+					}
+
+					oLogicDocument.LoadDocumentState(oState);
+					oLogicDocument.UpdateInterface();
+					oLogicDocument.Recalculate();
+					oLogicDocument.FinalizeAction();
+				}
+				else
+				{
+					oLogicDocument.LoadDocumentState(oState);
+				}
+			}
+			else
+			{
+				oLogicDocument.RemoveTextSelection();
+				if (!oLogicDocument.IsSelectionLocked(AscCommon.changestype_Paragraph_Content))
+				{
+					oLogicDocument.StartAction(AscDFH.historydescription_Document_AddContentControlCheckBox);
+
+					var oCC = oLogicDocument.AddContentControlCheckBox(oPr);
+					private_ApplyPrToCheckBox(oCC);
+
+					oLogicDocument.UpdateInterface();
+					oLogicDocument.Recalculate();
+					oLogicDocument.FinalizeAction();
+				}
 			}
 		}
 		
@@ -124,12 +175,66 @@
 			oLogicDocument.StartAction(AscDFH.historydescription_Document_AddContentControlPicture);
 
 			var oCC = oLogicDocument.AddContentControlPicture();
+			let oFormParaDrawing = null;
 			if (oCC && oFormPr)
 			{
 				oCC.SetFormPr(oFormPr);
 				oCC.UpdatePlaceHolderTextPrForForm();
-				oCC.ConvertFormToFixed();
+				private_CheckFormKey(oCC, oLogicDocument);
+
+				oFormParaDrawing = oCC.ConvertFormToFixed();
 				oCC.SetPictureFormPr(new AscCommon.CSdtPictureFormPr());
+				var aDrawings = oCC.GetAllDrawingObjects();
+				for(var nDrawing = 0; nDrawing < aDrawings.length; ++nDrawing)
+				{
+					var oDrawing = aDrawings[nDrawing];
+					var oGraphic = oDrawing.GraphicObj;
+					if(oGraphic && oGraphic.getObjectType() === AscDFH.historyitem_type_ImageShape)
+					{
+						var oSpPr = oGraphic.spPr;
+						if(oSpPr)
+						{
+							if(oSpPr.Fill)
+							{
+								oSpPr.setFill(null);
+							}
+							if(oSpPr.ln)
+							{
+								oSpPr.setLn(null);
+							}
+							if(oSpPr.geometry)
+							{
+								oSpPr.setGeometry(null);
+							}
+							var oXfrm = oSpPr.xfrm;
+							if(oXfrm)
+							{
+								if(!AscFormat.fApproxEqual(oXfrm.rot, 0.0))
+								{
+									oXfrm.setRot(0);
+								}
+								if(oXfrm.flipH)
+								{
+									oXfrm.setFlipH(false);
+								}
+								if(oXfrm.flipH)
+								{
+									oXfrm.setFlipH(false);
+								}
+								if(oXfrm.flipV)
+								{
+									oXfrm.setFlipV(false);
+								}
+							}
+						}
+					}
+				}
+
+				if (!oCC.IsPlaceHolder())
+				{
+					oLogicDocument.Recalculate(true);
+					oCC.UpdatePictureFormLayout();
+				}
 			}
 
 			if (oCC && oCommonPr)
@@ -137,7 +242,15 @@
 
 			oLogicDocument.UpdateInterface();
 			oLogicDocument.Recalculate();
-			oLogicDocument.FinalizeAction();
+			if(oFormParaDrawing)
+			{
+				let oFormShape = oFormParaDrawing.GraphicObj;
+				if(oFormShape)
+				{
+					oFormShape.Set_CurrentElement(true, null, true);
+				}
+			}
+ 			oLogicDocument.FinalizeAction();
 		}
 	};
 	window['Asc']['asc_docs_api'].prototype['asc_AddContentControlList'] = window['Asc']['asc_docs_api'].prototype.asc_AddContentControlList = function(isComboBox, oPr, oFormPr, oCommonPr)
@@ -161,6 +274,7 @@
 			{
 				oCC.SetFormPr(oFormPr);
 				oCC.UpdatePlaceHolderTextPrForForm();
+				private_CheckFormKey(oCC, oLogicDocument);
 			}
 
 			if (oCC && oCommonPr)
@@ -193,21 +307,32 @@
 			oLogicDocument.FinalizeAction();
 		}
 	};
-	window['Asc']['asc_docs_api'].prototype['asc_AddContentControlTextForm'] = window['Asc']['asc_docs_api'].prototype.asc_AddContentControlTextForm = function(oPr, oFormPr)
+	window['Asc']['asc_docs_api'].prototype['asc_AddContentControlTextForm'] = window['Asc']['asc_docs_api'].prototype.asc_AddContentControlTextForm = function(contentControlPr)
 	{
 		var oLogicDocument = this.private_GetLogicDocument();
 		if (!oLogicDocument)
 			return;
 
+		let textFormPr      = contentControlPr ? contentControlPr.TextFormPr : null;
+		let formPr          = contentControlPr ? contentControlPr.FormPr : null;
+		let placeholderText = contentControlPr ? contentControlPr.PlaceholderText : "";
+
 		if (!oLogicDocument.IsSelectionLocked(AscCommon.changestype_Paragraph_Content))
 		{
 			oLogicDocument.StartAction(AscDFH.historydescription_Document_AddContentControlTextForm);
 
-			var oCC = oLogicDocument.AddContentControlTextForm(oPr);
-			if (oCC && oFormPr)
+			var oCC = oLogicDocument.AddContentControlTextForm(textFormPr);
+			if (oCC)
 			{
-				oCC.SetFormPr(oFormPr);
-				oCC.UpdatePlaceHolderTextPrForForm();
+				if (placeholderText)
+					oCC.SetPlaceholderText(placeholderText);
+
+				if (formPr)
+				{
+					oCC.SetFormPr(formPr);
+					oCC.UpdatePlaceHolderTextPrForForm();
+					private_CheckFormKey(oCC, oLogicDocument);
+				}
 			}
 
 			oLogicDocument.UpdateInterface();
@@ -215,5 +340,89 @@
 			oLogicDocument.FinalizeAction();
 		}
 	};
+	window['Asc']['asc_docs_api'].prototype['asc_AddComplexForm'] = window['Asc']['asc_docs_api'].prototype.asc_AddComplexForm = function(json, formPr)
+	{
+		let logicDocument = this.private_GetLogicDocument();
+		if (!logicDocument)
+			return;
+
+		function AddComplexForm()
+		{
+			if (!logicDocument.IsSelectionLocked(AscCommon.changestype_Paragraph_Content))
+			{
+				logicDocument.StartAction(AscDFH.historydescription_Document_AddComplexForm);
+
+				let complexForm = logicDocument.AddComplexForm(new AscWord.CSdtComplexFormPr(), formPr);
+				private_CheckFormKey(complexForm, logicDocument);
+
+				if (json)
+					AscWord.JsonToForm(json, complexForm);
+
+				logicDocument.UpdateInterface();
+				logicDocument.Recalculate();
+				logicDocument.FinalizeAction();
+			}
+		}
+
+		if (json)
+		{
+			AscFonts.FontPickerByCharacter.checkText(AscWord.GetUnicodesFromJsonToForm(), this, function() {
+				AddComplexForm();
+			}, true);
+		}
+		else
+		{
+			AddComplexForm();
+		}
+	};
+	window['Asc']['asc_docs_api'].prototype['asc_GetCurrentComplexForm'] = window['Asc']['asc_docs_api'].prototype.asc_GetCurrentComplexForm = function()
+	{
+		let logicDocument = this.private_GetLogicDocument();
+		if (!logicDocument)
+			return null;
+
+		let form = logicDocument.GetContentControl();
+		if (!form || !form.IsForm())
+			return null;
+
+		let mainForm = form.GetMainForm();
+
+		return (mainForm.IsComplexForm() ? mainForm : null);
+	};
+	window['Asc']['asc_docs_api'].prototype['asc_ConvertFormToJson'] = window['Asc']['asc_docs_api'].prototype.asc_ConvertFormToJson = function(form)
+	{
+		let logicDocument = this.private_GetLogicDocument();
+		if (!logicDocument)
+			return null;
+
+		if (typeof (form) === "string")
+			form = AscCommon.g_oTableId.Get_ById(form);
+
+		if (!form || !(form instanceof AscWord.CInlineLevelSdt) || !form.IsForm())
+			return null;
+
+		return AscWord.FormToJson(form);
+	};
+
+	function private_CheckFormKey(form, logicDocument)
+	{
+		if (!form || !form.IsForm() || !logicDocument)
+			return;
+
+		let key = form.GetFormKey();
+		if (key && "" !== key.trim())
+			return;
+
+		let formManager  = logicDocument.GetFormsManager();
+		let keyGenerator = formManager.GetKeyGenerator();
+
+		let formPr = form.GetFormPr().Copy();
+		if (!formPr)
+			return;
+
+		key = keyGenerator.GetNewKey(form);
+		formPr.SetKey(key);
+		form.SetFormPr(formPr);
+	}
 
 })(window, window.document);

apiBuilder.js

@@ -0,0 +1,412 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+
+"use strict";
+(function(window, builder)
+{
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// Import
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	const AscBuilder         = window["AscBuilder"];
+	const GetStringParameter = AscBuilder.GetStringParameter;
+	const GetBoolParameter   = AscBuilder.GetBoolParameter;
+	const GetNumberParameter = AscBuilder.GetNumberParameter;
+	const GetArrayParameter  = AscBuilder.GetArrayParameter;
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	/**
+	 * Base class
+	 * @global
+	 * @class
+	 * @name Api
+	 */
+	var Api = window["Asc"]["asc_docs_api"] || window["Asc"]["spreadsheet_api"];
+ 
+	/**
+	 * Common form properties.
+	 * @typedef {Object} FormPrBase
+	 * @property {string} key - Form key.
+	 * @property {string} tip - Form tip text.
+	 * @property {boolean} required - Specifies if the form is required or not.
+	 * @property {string} placeholder - Form placeholder text.
+	 */
+
+	/**
+	 * Specific text form properties.
+	 * @typedef {Object} TextFormPrBase
+	 * @property {boolean} comb - Specifies if the text form should be a comb of characters with the same cell width. The maximum number of characters must be set to a positive value.
+	 * @property {number} maxCharacters - The maximum number of characters in the text form.
+	 * @property {number} cellWidth - The cell width for each character measured in millimeters. If this parameter is not specified or equal to 0 or less, then the width will be set automatically.
+	 * @property {boolean} multiLine - Specifies if the current fixed size text form is multiline or not.
+	 * @property {boolean} autoFit - Specifies if the text form content should be autofit, i.e. whether the font size adjusts to the size of the fixed size form.
+	 */
+
+	/**
+	 * Text form properties.
+	 * @typedef {FormPrBase | TextFormPrBase} TextFormPr
+	 */
+	 
+	/**
+	 * Specific checkbox properties.
+	 * @typedef {Object} CheckBoxFormPrBase
+	 * @property {boolean} radio - Specifies if the current checkbox is a radio button. In this case, the key parameter is considered as an identifier for the group of radio buttons.
+	 */
+
+	/**
+	 * Checkbox form properties.
+	 * @typedef {FormPrBase | CheckBoxFormPrBase} CheckBoxFormPr
+	 */
+
+	/**
+	 * Specific combo box properties.
+	 * @typedef {Object} ComboBoxFormPrBase
+	 * @property {boolean} editable - Specifies if the combo box text can be edited.
+	 * @property {boolean} autoFit - Specifies if the combo box form content should be autofit, i.e. whether the font size adjusts to the size of the fixed size form.
+	 * @property {Array.<string | Array.<string>>} items - The combo box items.
+     * This array consists of strings or arrays of two strings where the first string is the displayed value and the second one is its meaning.
+     * If the array consists of single strings, then the displayed value and its meaning are the same.
+     * Example: ["First", ["Second", "2"], ["Third", "3"], "Fourth"].
+
+	 */
+
+	/**
+	 * Combo box form properties.
+	 * @typedef {FormPrBase | ComboBoxFormPrBase} ComboBoxFormPr
+	 */
+
+	/**
+	 * The condition to scale an image in the picture form.
+	 * @typedef {"always" | "never" | "tooBig" | "tooSmall"} ScaleFlag
+	 */
+
+	/**
+	 * Value from 0 to 100.
+	 * @typedef {number} percentage
+	 */
+
+	/**
+	 * Specific picture form properties.
+	 * @typedef {Object} PictureFormPrBase
+	 * @property {ScaleFlag} scaleFlag - The condition to scale an image in the picture form: "always", "never", "tooBig" or "tooSmall".
+	 * @property {boolean} lockAspectRatio - Specifies if the aspect ratio of the picture form is locked or not.
+	 * @property {boolean} respectBorders - Specifies if the form border width is respected or not when scaling the image.
+	 * @property {percentage} shiftX - Horizontal picture position inside the picture form measured in percent:
+	 * * <b>0</b> - the picture is placed on the left;
+	 * * <b>50</b> - the picture is placed in the center;
+	 * * <b>100</b> - the picture is placed on the right.
+	 * @property {percentage} shiftY - Vertical picture position inside the picture form measured in percent:
+	 * * <b>0</b> - the picture is placed on top;
+	 * * <b>50</b> - the picture is placed in the center;
+	 * * <b>100</b> - the picture is placed on the bottom.
+	 */
+
+	/**
+	 * Picture form properties.
+	 * @typedef {FormPrBase | PictureFormPrBase} PictureFormPr
+	 */
+
+	/**
+	 * Creates a text form with the specified text form properties.
+	 * @memberof Api
+	 * @param {TextFormPr} oFormPr - Text form properties.
+	 * @returns {ApiTextForm}
+	 */
+	Api.prototype.CreateTextForm = function(oFormPr)
+	{
+		if (!oFormPr)
+			oFormPr = {};
+
+		let oCC = CreateCommonForm(oFormPr);
+
+		let oPr = new AscCommon.CSdtTextFormPr();
+		oPr.SetComb(GetBoolParameter(oFormPr["comb"], false));
+		oPr.SetMaxCharacters(GetNumberParameter(oFormPr["maxCharacters"], -1));
+		oPr.SetMultiLine(GetBoolParameter(oFormPr["multiLine"], false));
+		oPr.SetAutoFit(GetBoolParameter(oFormPr["autoFit"], false));
+		oPr.SetWidth((GetNumberParameter(oFormPr["cellWidth"], 0) * 72 * 20 / 25.4) | 0);
+
+		oCC.ApplyTextFormPr(oPr);
+		CheckFormKey(oCC);
+		return new AscBuilder.ApiTextForm(oCC);
+	};
+	/**
+	 * Creates a checkbox/radio button form with the specified checkbox/radio button form properties.
+	 * @memberof Api
+	 * @param {CheckBoxFormPr} oFormPr - Checkbox/radio button form properties.
+	 * @returns {ApiCheckBoxForm}
+	 */
+	Api.prototype.CreateCheckBoxForm = function(oFormPr)
+	{
+		if (!oFormPr)
+			oFormPr = {};
+
+		oFormPr["placeholder"] = undefined;
+
+		var oCC;
+		var oCheckboxPr  = new AscCommon.CSdtCheckBoxPr();
+		if (GetBoolParameter(oFormPr["radio"], false))
+		{
+			oCheckboxPr.CheckedSymbol   = 0x25C9;
+			oCheckboxPr.UncheckedSymbol = 0x25CB;
+			oCheckboxPr.GroupKey        = GetStringParameter(oFormPr["key"], "Group1");
+		}
+		else
+		{
+			oCheckboxPr.CheckedSymbol   = 0x2611;
+			oCheckboxPr.UncheckedSymbol = 0x2610;
+		}
+
+		oCheckboxPr.CheckedFont = "Segoe UI Symbol";
+		oCheckboxPr.UncheckedFont = "Segoe UI Symbol";
+
+		var nCheckedSymbol   = oCheckboxPr && oCheckboxPr.CheckedSymbol ? oCheckboxPr.CheckedSymbol : Asc.c_oAscSdtCheckBoxDefaults.CheckedSymbol;
+		var nUncheckedSymbol = oCheckboxPr && oCheckboxPr.UncheckedSymbol ? oCheckboxPr.UncheckedSymbol : Asc.c_oAscSdtCheckBoxDefaults.UncheckedSymbol;
+		var sCheckedFont     = oCheckboxPr && oCheckboxPr.CheckedFont ? oCheckboxPr.CheckedFont : Asc.c_oAscSdtCheckBoxDefaults.CheckedFont;
+		var sUncheckedFont   = oCheckboxPr && oCheckboxPr.UncheckedFont ? oCheckboxPr && oCheckboxPr.UncheckedFont : Asc.c_oAscSdtCheckBoxDefaults.UncheckedFont;
+
+		var isLoadFonts = false;
+		if (!AscCommon.IsAscFontSupport(sCheckedFont, nCheckedSymbol))
+		{
+			isLoadFonts = true;
+			AscFonts.FontPickerByCharacter.getFontBySymbol(nCheckedSymbol);
+		}
+
+		if (!AscCommon.IsAscFontSupport(sUncheckedFont, nUncheckedSymbol))
+		{
+			isLoadFonts = true;
+			AscFonts.FontPickerByCharacter.getFontBySymbol(nUncheckedSymbol);
+		}
+
+		function private_PerformAddCheckBox()
+		{
+			oCC = CreateCommonForm(oFormPr);
+			oCC.ApplyCheckBoxPr(oCheckboxPr);
+		}
+
+		if (isLoadFonts)
+		{
+			var oFonts = {};
+			oFonts[sCheckedFont]   = true;
+			oFonts[sUncheckedFont] = true;
+
+			AscCommon.Check_LoadingDataBeforePrepaste(this, oFonts, {}, private_PerformAddCheckBox);
+		}
+		else
+		{
+			private_PerformAddCheckBox();
+		}
+
+		CheckFormKey(oCC);
+		return new AscBuilder.ApiCheckBoxForm(oCC);
+	};
+	/**
+	 * Creates a combo box/dropdown form with the specified combo box/dropdown form properties.
+	 * @memberof Api
+	 * @param {ComboBoxFormPr} oFormPr - Combo box/dropdown form properties.
+	 * @returns {ApiComboBoxForm}
+	 */
+	Api.prototype.CreateComboBoxForm = function(oFormPr)
+	{
+		if (!oFormPr)
+			oFormPr = {};
+
+		var oPr = new AscCommon.CSdtComboBoxPr();
+		oPr.AddItem(AscCommon.translateManager.getValue("Choose an item"), "");
+
+		var oCC = CreateCommonForm(oFormPr);
+
+		let sPlaceholder = GetStringParameter(oFormPr["placeholder"], undefined);
+
+		let arrList = GetArrayParameter(oFormPr["items"], []);
+		for (let nIndex = 0, nCount = arrList.length; nIndex < nCount; ++nIndex)
+		{
+			let oItem = arrList[nIndex];
+
+			if (GetStringParameter(oItem, null))
+			{
+				oPr.AddItem(oItem, oItem);
+			}
+			else if (GetArrayParameter(oItem, null))
+			{
+				let sDisplay = GetStringParameter(oItem[0], null);
+				let sValue   = GetStringParameter(oItem[1], null);
+				if (null !== sDisplay && null !== sValue)
+					oPr.AddItem(sDisplay, sValue);
+			}
+		}
+		oPr.SetAutoFit(GetBoolParameter(oFormPr["autoFit"], false));
+
+		if (!GetBoolParameter(oFormPr["editable"], false))
+		{
+			if (sPlaceholder)
+			{
+				oCC.ApplyDropDownListPr(oPr);
+			}
+			else
+			{
+				oCC.SetDropDownListPr(oPr);
+				oCC.SelectListItem();
+			}
+		}
+		else
+		{
+			if (sPlaceholder)
+			{
+				oCC.ApplyComboBoxPr(oPr);
+			}
+			else
+			{
+				oCC.SetComboBoxPr(oPr);
+				oCC.SelectListItem();
+			}
+		}
+
+		CheckFormKey(oCC);
+		return new AscBuilder.ApiComboBoxForm(oCC);
+	};
+	/**
+	 * Creates a picture form with the specified picture form properties.
+	 * @memberof Api
+	 * @param {PictureFormPr} oFormPr - Picture form properties.
+	 * @returns {ApiPictureForm}
+	 */
+	Api.prototype.CreatePictureForm = function(oFormPr)
+	{
+		if (!oFormPr)
+			oFormPr = {};
+
+		if (GetStringParameter("placeholder", null))
+			oFormPr["placeholder"] = AscCommon.translateManager.getValue("Click to load image");
+
+		var oCC = CreateCommonForm(oFormPr);
+		oCC.ApplyPicturePr(true);
+		oCC.ConvertFormToFixed();
+
+		let oPr = new AscCommon.CSdtPictureFormPr();
+
+		let sScale = GetStringParameter(oFormPr["scaleFlag"], undefined);
+		switch (sScale)
+		{
+			case "always": oPr.SetScaleFlag(Asc.c_oAscPictureFormScaleFlag.Always); break;
+			case "never": oPr.SetScaleFlag(Asc.c_oAscPictureFormScaleFlag.Never); break;
+			case "tooBig": oPr.SetScaleFlag(Asc.c_oAscPictureFormScaleFlag.Bigger); break;
+			case "tooSmall": oPr.SetScaleFlag(Asc.c_oAscPictureFormScaleFlag.Smaller); break;
+		}
+
+		oPr.SetConstantProportions(GetBoolParameter(oFormPr["lockAspectRatio"], true));
+		oPr.SetRespectBorders(GetBoolParameter(oFormPr["respectBorders"], false));
+		oPr.SetShiftX(Math.max(0, Math.min(100, GetNumberParameter(oFormPr["shiftX"], 50))) / 100);
+		oPr.SetShiftY(Math.max(0, Math.min(100, GetNumberParameter(oFormPr["shiftY"], 50))) / 100);
+
+		oCC.SetPictureFormPr(oPr);
+
+		CheckFormKey(oCC);
+		return new AscBuilder.ApiPictureForm(oCC);
+	};
+
+	/**
+	 * Creates a complex form with the specified base form properties.
+	 * @memberof Api
+	 * @param {FormPrBase} oFormPr - base form property.
+	 * @returns {ApiComplexForm}
+	 */
+	Api.prototype.CreateComplexForm = function(oFormPr)
+	{
+		if (!oFormPr)
+			oFormPr = {};
+
+		let oCC = CreateCommonForm(oFormPr);
+		let oComplexPr = new AscWord.CSdtComplexFormPr();
+
+		oCC.SetComplexFormPr(oComplexPr);
+		CheckFormKey(oCC);
+		return new AscBuilder.ApiComplexForm(oCC);
+	};
+
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// Private area
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	function CreateCommonForm(oFormPr)
+	{
+		if (!oFormPr)
+			oFormPr = {};
+		
+		var oTempFormPr = new AscCommon.CSdtFormPr();
+		oTempFormPr.SetHelpText(GetStringParameter(oFormPr["tip"], undefined));
+		oTempFormPr.SetRequired(GetBoolParameter(oFormPr["required"], false));
+		oTempFormPr.SetKey(GetStringParameter(oFormPr["key"], undefined));
+
+		var oCC = new AscCommonWord.CInlineLevelSdt();
+
+		let sPlaceHolder = GetStringParameter(oFormPr["placeholder"], undefined);
+		if (sPlaceHolder)
+			oCC.SetPlaceholderText(sPlaceHolder);
+		else
+			oCC.SetPlaceholder(c_oAscDefaultPlaceholderName.Text);
+
+		oCC.ReplaceContentWithPlaceHolder(false);
+		oCC.SetFormPr(oTempFormPr);
+		oCC.UpdatePlaceHolderTextPrForForm();
+
+		return oCC;
+	}
+	function CheckFormKey(form)
+	{
+		let logicDocument = editor && editor.WordControl && editor.WordControl.m_oLogicDocument;
+		if (!form || !form.IsForm() || !logicDocument)
+			return;
+
+		let key = form.GetFormKey();
+		if (key && "" !== key.trim())
+			return;
+
+		let formManager  = logicDocument.GetFormsManager();
+		let keyGenerator = formManager.GetKeyGenerator();
+
+		let formPr = form.GetFormPr().Copy();
+		if (!formPr)
+			return;
+
+		key = keyGenerator.GetNewKey(form);
+		formPr.SetKey(key);
+		form.SetFormPr(formPr);
+	}
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	// Export
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	Api.prototype["CreateTextForm"]     = Api.prototype.CreateTextForm;
+	Api.prototype["CreatePictureForm"]  = Api.prototype.CreatePictureForm;
+	Api.prototype["CreateCheckBoxForm"] = Api.prototype.CreateCheckBoxForm;	
+	Api.prototype["CreateComboBoxForm"] = Api.prototype.CreateComboBoxForm;	
+	Api.prototype["CreateComplexForm"]  = Api.prototype.CreateComplexForm;	
+}(window, null));

apiPlugins.js

@@ -0,0 +1,251 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2022
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+"use strict";
+
+(function(window)
+{
+	/**
+	 * Returns information about all the forms that have been added to the document
+	 * @memberof Api
+	 * @typeofeditors ["CDE"]
+	 * @alias GetAllForms
+	 * @returns {[]} - An array of forms
+	 * @example
+	 * window.Asc.plugin.executeMethod("GetAllForms");
+	 */
+	window["asc_docs_api"].prototype["pluginMethod_GetAllForms"] = function()
+	{
+		let oFormsManager = this.private_GetFormsManager();
+		if (!oFormsManager)
+			return [];
+
+		let arrForms  = oFormsManager.GetAllForms();
+		let arrResult = [];
+		for (let nIndex = 0, nCount = arrForms.length; nIndex < nCount; ++nIndex)
+		{
+			arrResult.push(arrForms[nIndex].GetContentControlPr().GetEventObject());
+		}
+		return arrResult;
+	};
+	/**
+	 * Returns information about all the forms that have been added to the document with specified Tag
+	 * @memberof Api
+	 * @typeofeditors ["CDE"]
+	 * @alias GetFormsByTag
+	 * @param {string} tag - Tag of the form
+	 * @returns {[]} - An array of forms
+	 * @example
+	 * window.Asc.plugin.executeMethod("GetFormsByTag");
+	 */
+	window["asc_docs_api"].prototype["pluginMethod_GetFormsByTag"] = function(tag)
+	{
+		let oFormsManager = this.private_GetFormsManager();
+		if (!oFormsManager)
+			return [];
+
+		let arrForms  = oFormsManager.GetAllForms();
+		let arrResult = [];
+		let oForm     = null;
+		for (let nIndex = 0, nCount = arrForms.length; nIndex < nCount; ++nIndex)
+		{
+			oForm = arrForms[nIndex];
+			if (oForm.GetTag() === tag)
+				arrResult.push(oForm.GetContentControlPr().GetEventObject());
+		}
+		return arrResult;
+	};
+	/**
+	 * Set value for specified form
+	 * @memberof Api
+	 * @typeofeditors ["CDE"]
+	 * @alias SetFormValue
+	 * @param {string} internalId - A unique internal identifier of the content control.
+	 * @param {*} value - Depends on the type of a form
+	 * @example
+	 * window.Asc.plugin.executeMethod("SetFormValue");
+	 */
+	window["asc_docs_api"].prototype["pluginMethod_SetFormValue"] = function(internalId, value)
+	{
+		let oLogicDocument = this.private_GetLogicDocument();
+
+		if (!AscCommon.g_oTableId
+			|| !oLogicDocument
+			|| !oLogicDocument.IsDocumentEditor())
+			return;
+
+		let oForm = AscCommon.g_oTableId.GetClass(internalId);
+
+		if (!oForm
+			|| !(oForm instanceof AscWord.CInlineLevelSdt)
+			|| !oForm.IsForm())
+			return;
+
+		let oParagraph = oForm.GetParagraph();
+
+		oForm.SkipSpecialContentControlLock(true);
+		if (!oParagraph
+			|| oLogicDocument.IsSelectionLocked(AscCommon.changestype_None, {
+				Type      : AscCommon.changestype_2_ElementsArray_and_Type,
+				Elements  : [oParagraph],
+				CheckType : AscCommon.changestype_Paragraph_Content
+			}, true, oLogicDocument.IsFillingFormMode()))
+		{
+			oForm.SkipSpecialContentControlLock(false);
+			return;
+		}
+		oForm.SkipSpecialContentControlLock(false);
+
+		oLogicDocument.StartAction(AscDFH.historydescription_Document_FillFormInPlugin);
+
+		let isClear = false;
+		if (null === value)
+		{
+			isClear = true;
+		}
+		else if (oForm.IsTextForm() || oForm.IsComboBox())
+		{
+			let sValue = AscBuilder.GetStringParameter(value, "");
+			if (!value)
+				isClear = true;
+			else
+				oForm.SetInnerText(sValue);
+		}
+		else if (oForm.IsDropDownList())
+		{
+			let sValue = AscBuilder.GetStringParameter(value, "");
+			let oPr    = oForm.GetDropDownListPr();
+			let nIndex = oPr.FindByText(sValue);
+			if (-1 !== nIndex)
+				oForm.SelectListItem(oPr.GetItemValue(nIndex));
+			else
+				isClear = true;
+		}
+		else if (oForm.IsCheckBox())
+		{
+			let isChecked = value === "true" ? true : value === "false" ? false : AscBuilder.GetBoolParameter(value, null);
+			if (null !== isChecked)
+				oForm.SetCheckBoxChecked(isChecked);
+			else
+				isClear = true;
+		}
+		else if (oForm.IsPictureForm())
+		{
+			let sValue = AscBuilder.GetStringParameter(value, "");
+			if (!sValue)
+				return;
+
+			let oImg;
+			let allDrawings = oForm.GetAllDrawingObjects();
+			for (let nDrawing = 0; nDrawing < allDrawings.length; ++nDrawing)
+			{
+				if (allDrawings[nDrawing].IsPicture())
+				{
+					oImg = allDrawings[nDrawing].GraphicObj;
+					break;
+				}
+			}
+
+			if (oImg)
+			{
+				oForm.SetShowingPlcHdr(false);
+				oImg.setBlipFill(AscFormat.CreateBlipFillRasterImageId(sValue));
+			}
+			else
+			{
+				isClear = true;
+			}
+		}
+
+		if (isClear)
+			oForm.ClearContentControlExt();
+
+		oLogicDocument.OnChangeForm(oForm);
+		oLogicDocument.Recalculate();
+		oLogicDocument.UpdateTracks();
+		oLogicDocument.FinalizeAction();
+	};
+	/**
+	 * Get form value
+	 * @memberof Api
+	 * @typeofeditors ["CDE"]
+	 * @alias GetFormValue
+	 * @param {string} internalId - A unique internal identifier of the content control.
+	 * @returns {null | string} Value of the form (null means the form is filled with a placeholder)
+	 * @example
+	 * window.Asc.plugin.executeMethod("GetFormValue");
+	 *
+	 */
+	window["asc_docs_api"].prototype["pluginMethod_GetFormValue"] = function(internalId)
+	{
+		if (!AscCommon.g_oTableId)
+			return "";
+
+		let oForm = AscCommon.g_oTableId.GetClass(internalId);
+
+		if (!oForm
+			|| !(oForm instanceof AscWord.CInlineLevelSdt)
+			|| !oForm.IsForm())
+			return "";
+
+		if (oForm.IsPlaceHolder())
+			return null;
+
+		if (oForm.IsTextForm() || oForm.IsComboBox() || oForm.IsDropDownList())
+		{
+			return oForm.GetInnerText();
+		}
+		else if (oForm.IsCheckBox())
+		{
+			return oForm.IsCheckBoxChecked();
+		}
+		else if (oForm.IsPictureForm())
+		{
+			let oImg;
+			let allDrawings = oForm.GetAllDrawingObjects();
+			for (let nDrawing = 0; nDrawing < allDrawings.length; ++nDrawing)
+			{
+				if (allDrawings[nDrawing].IsPicture())
+				{
+					oImg = allDrawings[nDrawing].GraphicObj;
+					break;
+				}
+			}
+
+			if (oImg)
+				return oImg.getBase64Img();
+		}
+
+		return "";
+	};
+
+})(window);

configs/word.json

@@ -1,9 +1,14 @@
 {
   "sdk": {
     "min": [
-      "api.js"
-    ],
+      "api.js",
+	  "apiPlugins.js"
+	],
     "common": [      
+	  "apiBuilder.js",
+	  "oform/Main.js",
+	  "oform/Field.js",
+	  "oform/User.js"
     ]
   }
 }

oform/Field.js

@@ -0,0 +1,416 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+"use strict";
+
+(function(window, undefined) {
+
+	const CBaseFormatObject = AscFormat.CBaseFormatObject;
+	const InitClass = AscFormat.InitClass;
+	const CChangesString = AscDFH.CChangesDrawingsString;
+	const CChangesObject = AscDFH.CChangesDrawingsObject;
+	const CChangesContent = AscDFH.CChangesDrawingsContent;
+
+	AscDFH.changesFactory[AscDFH.historyitem_FormFieldMaster_FieldId] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_FormFieldMaster_User] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_FormFieldMaster_Field] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_FormFieldMaster_SignRequest] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_FormField_Content] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_FormField_EncryptedData] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_FormField_FieldMaster] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_SignRequest_User] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_EncryptedData_Method] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_EncryptedData_Value] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_EncryptedData_KeyInfo] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_KeyInfo_User] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_KeyInfo_Value] = CChangesObject;
+
+
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormFieldMaster_FieldId] = function(oClass, value) {oClass.FieldId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormFieldMaster_Field] = function(oClass, value) {oClass.Field = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormFieldMaster_SignRequest] = function(oClass, value) {oClass.SignRequest = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormField_Content] = function(oClass, value) {oClass.FieldContent = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormField_FieldMaster] = function(oClass, value) {oClass.FieldMaster = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_EncryptedData_Method] = function(oClass, value) {oClass.EncryptedMethod = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_EncryptedData_Value] = function(oClass, value) {oClass.EncryptedValue = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_EncryptedData_KeyInfo] = function(oClass, value) {oClass.KeyInfo = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_KeyInfo_User] = function(oClass, value) {oClass.FieldId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_KeyInfo_Value] = function(oClass, value) {oClass.FieldId = value;};
+
+
+	AscDFH.drawingContentChanges[AscDFH.historyitem_FormFieldMaster_User] = function (oClass) {return oClass.Users;};
+	AscDFH.drawingContentChanges[AscDFH.historyitem_SignRequest_User] = function (oClass) {return oClass.Users;};
+	AscDFH.drawingContentChanges[AscDFH.historyitem_FormField_EncryptedData] = function (oClass) {return oClass.EndcriptedData;};
+
+
+	function CFieldMaster() {
+		CBaseFormatObject.call(this);
+		this.FieldId = null;
+		this.Users = [];
+		this.Field = null;
+		this.SignRequest = null;
+	}
+	InitClass(CFieldMaster, CBaseFormatObject, AscDFH.historyitem_type_FormFieldMaster);
+	CFieldMaster.prototype.setFieldId = function(sFieldId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FormFieldMaster_FieldId, this.FieldId, sFieldId));
+		this.FieldId = sFieldId;
+	};
+	CFieldMaster.prototype.addUser = function(oUser) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_FormFieldMaster_User, this.Users.length, [oUser], true));
+		this.Users.push(oUser);
+	};
+	CFieldMaster.prototype.setField = function(oField) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_FormFieldMaster_Field, this.Field, oField));
+		this.Field = oField;
+		if(oField) {
+			oField.setFieldMaster(this);
+		}
+	};
+	CFieldMaster.prototype.setSignRequest = function(oSignRequest) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_FormFieldMaster_SignRequest, this.SignRequest, oSignRequest));
+		this.SignRequest = oSignRequest;
+	};
+	CFieldMaster.prototype.readAttrXml = function(name, reader) {
+		switch (name) {
+			case "id": {
+				this.setFieldId(reader.GetValue());
+				break;
+			}
+		}
+	};
+	CFieldMaster.prototype.readChildXml = function (name, reader) {
+		let oThis = this;
+		switch (name) {
+			case "Users": {
+				let oUsersNode = new CT_XmlNode(function (reader, name){
+					if(name === "User") {
+						let oUserNode = new CT_XmlNode();
+						oUserNode.fromXml(reader);
+						let sId = oUserNode.attributes["id"];
+						let oRel = reader.rels.getRelationshipById(sId);
+						reader.context.addFieldMasterRelation(oThis, oRel.targetFullName)
+					}
+					return true;
+				});
+				oUsersNode.fromXml(reader);
+				break;
+			}
+			case "SignRequest": {
+				let oSignRequest = new CSignRequest();
+				oSignRequest.fromXml(reader);
+				this.setSignRequest(oSignRequest);
+				break;
+			}
+		}
+	};
+	CFieldMaster.prototype.toXml = function (writer) {
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("FieldMaster");
+		writer.WriteXmlAttributeString("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships");
+		writer.WriteXmlNullableAttributeString("id", this.FieldId);
+		writer.WriteXmlAttributesEnd();
+
+		writer.WriteXmlNodeStart("Users");
+		writer.WriteXmlAttributesEnd();
+		let oContext = writer.context;
+		let oUserMasterPartMap = oContext.userMasterPartMap;
+		let oUsersIdMap = {};
+		for(let nUser = 0; nUser < this.Users.length; ++nUser) {
+			let oUser = this.Users[nUser];
+			let oPart = oUserMasterPartMap[oUser.Id];
+			if(!oPart) {
+				oPart = writer.context.part.addPart(AscCommon.openXml.Types.userMaster);
+				let oUserMemory = new AscCommon.CMemory();
+				oUserMemory.context = writer.context;
+				oPart.part.setDataXml(oUser, oUserMemory);
+				oUserMasterPartMap[oUser.Id] = oPart;
+			}
+			let oNode = new CT_XmlNode();
+			let sRId = oContext.part.addRelationship(AscCommon.openXml.Types.userMaster.relationType, oPart.uri);
+			oNode.attributes["r:id"] = sRId
+			oUsersIdMap[oUser.Id] = sRId;
+			oNode.toXml(writer, "User");
+
+		}
+		writer.WriteXmlNodeEnd("Users");
+		if(this.SignRequest) {
+			this.SignRequest.toXml(writer, oUsersIdMap);
+		}
+		writer.WriteXmlNodeEnd("FieldMaster");
+		if(writer.context.fileType === Asc.c_oAscFileType.OFORM) {
+			if(this.Field) {
+				let oPart = writer.context.docPart.part.addPartWithoutRels(AscCommon.openXml.Types.field);
+				let oMemory = new AscCommon.CMemory();
+				oMemory.context = writer.context;
+				oPart.setDataXml(this.Field, oMemory);
+				oMemory.Seek(0);
+				oPart.addRelationship(AscCommon.openXml.Types.fieldMaster.relationType, oContext.part.uri)
+			}
+		}
+	};
+
+	function CSignRequest() {
+		CBaseFormatObject.call(this);
+		this.Users = [];
+	}
+	InitClass(CSignRequest, CBaseFormatObject, AscDFH.historyitem_type_SignRequest);
+	CSignRequest.prototype.addUser = function(oUser) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_SignRequest_User, this.Users.length, [oUser], true));
+		this.Users.push(oUser);
+	};
+	CSignRequest.prototype.readChildXml = function (name, reader) {
+		CFieldMaster.prototype.readChildXml.call(this, name, reader);
+	};
+	CSignRequest.prototype.toXml = function (writer, oUsersIdMap) {
+		writer.WriteXmlNodeStart("SignRequest");
+		writer.WriteXmlAttributesEnd();
+
+		writer.WriteXmlNodeStart("Users");
+		writer.WriteXmlAttributesEnd();
+		for(let nUser = 0; nUser < this.Users.length; ++nUser) {
+			let oUser = this.Users[nUser];
+			let oNode = new CT_XmlNode();
+			let sRId = oUsersIdMap[oUser.Id];
+			if(sRId) {
+				oNode.attributes["r:id"] = sRId
+				oUsersIdMap[oUser.Id] = sRId;
+				oNode.toXml(writer, "User");
+			}
+
+		}
+		writer.WriteXmlNodeEnd("Users");
+		writer.WriteXmlNodeEnd("SignRequest");
+	};
+
+	function CFieldContent() {
+		CParagraphContentWithParagraphLikeContent.call(this);
+	}
+	InitClass(CFieldContent, CParagraphContentWithParagraphLikeContent, 0);
+	CFieldContent.prototype.Add_ToContent = function(Pos, Item, UpdatePosition)
+	{
+		AscCommon.History.Add(new CChangesFormFieldAddItem(this, Pos, [Item]));
+		CParagraphContentWithParagraphLikeContent.prototype.Add_ToContent.apply(this, arguments);
+	};
+
+	CFieldContent.prototype.Remove_FromContent = function(Pos, Count, UpdatePosition)
+	{
+		let DeletedItems = this.Content.slice( Pos, Pos + Count );
+		AscCommon.History.Add(new CChangesFormFieldRemoveItem(this, Pos, DeletedItems));
+		CParagraphContentWithParagraphLikeContent.prototype.Remove_FromContent.apply(this, arguments);
+	};
+	CFieldContent.prototype.fromXml = function (reader) {
+		CParagraphContentWithParagraphLikeContent.prototype.fromXml.call(this, reader);
+	};
+	CFieldContent.prototype.toXml = function (writer) {
+		writer.WriteXmlNodeStart("w:sdtContent");
+		writer.WriteXmlAttributesEnd();
+		CParagraphContentWithParagraphLikeContent.prototype.toXml.call(this, writer);
+		writer.WriteXmlNodeEnd("w:sdtContent");
+	};
+
+	function CField() {
+		CBaseFormatObject.call(this);
+		this.EndcriptedData = [];
+		this.FieldContent = null;
+	}
+	InitClass(CField, CBaseFormatObject, AscDFH.historyitem_type_FormField);
+	CField.prototype.setFieldContent = function(oFieldContent) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FormField_Content, this.FieldContent, oFieldContent));
+		this.FieldContent = oFieldContent;
+	};
+	CField.prototype.addEncryptedData = function(oEncryptedData) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_FormField_EncryptedData, this.EndcriptedData.length, [oEncryptedData], true));
+		this.EndcriptedData.push(oEncryptedData);
+	};
+	CField.prototype.setFieldMaster = function(oFieldMaster) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_FormField_FieldMaster, this.FieldMaster, oFieldMaster));
+		this.FieldMaster = oFieldMaster;
+	};
+	CField.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "EncryptedData": {
+				let oEncryptedData = new CEncryptedData();
+				oEncryptedData.fromXml(reader);
+				this.addEncryptedData(oEncryptedData);
+				break;
+			}
+			case "Body": {
+				let oFieldContent = null;
+				let oNode = new CT_XmlNode(function (reader, name) {
+					if(name === "sdtContent") {
+						oFieldContent = new CFieldContent();
+						oFieldContent.fromXml(reader);
+						return oFieldContent;
+					}
+					return null;
+				});
+				oNode.fromXml(reader);
+				if(oFieldContent) {
+					this.setFieldContent(oFieldContent);
+				}
+				break;
+			}
+		}
+	};
+	CField.prototype.toXml = function(writer) {
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("Field");
+		writer.WriteXmlAttributesEnd();
+		if(this.FieldContent) {
+			writer.WriteXmlNodeStart("Body");
+			writer.WriteXmlString(AscCommonWord.g_sXmlDocumentNamespaces);
+			writer.WriteXmlAttributesEnd();
+			this.FieldContent.toXml(writer);
+			writer.WriteXmlNodeEnd("Body");
+		}
+		for(let nData = 0; nData < this.EndcriptedData.length; ++nData) {
+			this.EndcriptedData[nData].toXml(writer);
+		}
+		writer.WriteXmlNodeEnd("Field");
+	};
+
+	function CEncryptedData() {
+		CBaseFormatObject.call(this);
+		this.EncryptedMethod = null;
+		this.EncryptedValue = null;
+		this.KeyInfo = null;
+	}
+	InitClass(CEncryptedData, CBaseFormatObject, AscDFH.historyitem_type_EncryptedData);
+	CEncryptedData.prototype.setEncryptedMethod = function (sEncryptedMethod) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_EncryptedData_Method, this.EncryptedMethod, sEncryptedMethod));
+		this.EncryptedMethod = sEncryptedMethod;
+	};
+	CEncryptedData.prototype.setEncryptedValue = function (sEncryptedValue) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_EncryptedData_Value, this.EncryptedValue, sEncryptedValue));
+		this.EncryptedValue = sEncryptedValue;
+	};
+	CEncryptedData.prototype.setKeyInfo = function (oKeyInfo) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_EncryptedData_KeyInfo, this.KeyInfo, oKeyInfo));
+		this.KeyInfo = oKeyInfo;
+	};
+	CEncryptedData.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "EncryptedMethod": {
+				let oMethod =  new CT_XmlNode();
+				oMethod.fromXml(reader);
+				let sAlgorithm = oMethod.attributes["Algorithm"];
+				if(sAlgorithm) {
+					this.setEncryptedMethod(sAlgorithm)
+				}
+				break;
+			}
+			case "EncryptedValue": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setEncryptedValue(oNode.text);
+				break;
+			}
+			case "KeyInfo": {
+				let oKeyInfo = new CKeyInfo();
+				oKeyInfo.fromXml(reader);
+				this.setKeyInfo(oKeyInfo)
+				break;
+			}
+		}
+	};
+	CEncryptedData.prototype.toXml = function(writer) {
+		writer.WriteXmlNodeStart("EncryptedData");
+		writer.WriteXmlAttributesEnd();
+		if(this.EncryptedMethod) {
+			let oMethod =  new CT_XmlNode();
+			oMethod.attributes["Algorithm"] = this.EncryptedMethod;
+			oMethod.toXml(writer, "EncryptedMethod");
+		}
+		if(this.EncryptedValue) {
+			let oValue =  new CT_XmlNode();
+			oValue.text = this.EncryptedValue;
+			oValue.toXml(writer, "EncryptedValue");
+		}
+		if(this.KeyInfo) {
+			this.KeyInfo.toXml(writer);
+		}
+		writer.WriteXmlNodeEnd("EncryptedData");
+	};
+
+	function CKeyInfo() {
+		CBaseFormatObject.call(this);
+		this.UserId = null;
+		this.Value = null;
+	}
+	InitClass(CKeyInfo, CBaseFormatObject, AscDFH.historyitem_type_KeyInfo);
+	CKeyInfo.prototype.setUserId = function (sUserId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_KeyInfo_User, this.UserId, sUserId));
+		this.UserId = sUserId;
+	};
+	CKeyInfo.prototype.setValue = function (sValue) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_KeyInfo_Value, this.Value, sValue));
+		this.Value = sValue;
+	};
+	CKeyInfo.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "User": {
+				let oNode =  new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setUserId(oNode.attributes["id"]);
+				break;
+			}
+			case "Value": {
+				let oNode =  new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setValue(oNode.text);
+				break;
+			}
+		}
+	};
+	CKeyInfo.prototype.toXml = function(writer) {
+		writer.WriteXmlNodeStart("KeyInfo");
+		writer.WriteXmlAttributesEnd();
+		if(this.UserId) {
+			let oNode = new CT_XmlNode();
+			oNode.attributes["id"] = this.UserId;
+			oNode.toXml(writer, "User");
+		}
+		if(this.Value) {
+			let oValue =  new CT_XmlNode();
+			oValue.text = this.Value;
+			oValue.toXml(writer, "Value");
+		}
+		writer.WriteXmlNodeEnd("KeyInfo");
+	};
+
+	AscWord.CFieldContent = CFieldContent;
+	AscWord.CFieldMaster = CFieldMaster;
+	AscWord.CField = CField;
+	AscWord.CEncryptedData = CEncryptedData;
+	AscWord.CKeyInfo = CKeyInfo;
+	AscWord.CSignRequest = CSignRequest;
+})(window);

oform/Main.js

@@ -0,0 +1,316 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+"use strict";
+
+(function(window, undefined) {
+
+	const CBaseFormatObject = AscFormat.CBaseFormatObject;
+	const InitClass = AscFormat.InitClass;
+	const CChangesString = AscDFH.CChangesDrawingsString;
+	const CChangesObject = AscDFH.CChangesDrawingsObject;
+	const CChangesContent = AscDFH.CChangesDrawingsContent;
+	const CChangesLong = AscDFH.CChangesDrawingsLong;
+
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Author] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Date] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Description] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Type] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Application] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_DocumentId] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_FieldsGroups] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_User] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_FormDate_Format] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_FormDate_Value] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_FieldsGroup_Id] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_FieldsGroup_Weight] = CChangesLong;
+	AscDFH.changesFactory[AscDFH.historyitem_FieldsGroup_Field] = CChangesContent;
+
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Author] = function (oClass, value) {oClass.Author = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Date] = function (oClass, value) {oClass.Date = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Description] = function (oClass, value) {oClass.Description = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Type] = function (oClass, value) {oClass.Type = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Application] = function (oClass, value) {oClass.Application = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_DocumentId] = function (oClass, value) {oClass.DocumentId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormDate_Format] = function (oClass, value) {oClass.Format = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormDate_Value] = function (oClass, value) {oClass.Value = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FieldsGroup_Id] = function (oClass, value) {oClass.GroupId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FieldsGroup_Weight] = function (oClass, value) {oClass.Weight = value;};
+
+	AscDFH.drawingContentChanges[AscDFH.historyitem_MainDocument_FieldsGroups] = function (oClass) {return oClass.FieldsGroups;};
+	AscDFH.drawingContentChanges[AscDFH.historyitem_MainDocument_User] = function (oClass) {return oClass.Users;};
+	AscDFH.drawingContentChanges[AscDFH.historyitem_FieldsGroup_Field] = function (oClass) {return oClass.Fields;};
+
+
+	function CMainDocument() {
+		CBaseFormatObject.call(this);
+		this.Author = null;
+		this.Date = null;
+		this.Description = null;
+		this.Type = null;
+		this.Application = null;
+		this.DocumentId = null;
+		this.FieldsGroups = [];
+
+		this.Users = [];
+	}
+	InitClass(CMainDocument, CBaseFormatObject, AscDFH.historyitem_type_MainDocument);
+	CMainDocument.prototype.setAuthor = function (sAuthor) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_Author, this.Author, sAuthor));
+		this.Author = sAuthor;
+	};
+	CMainDocument.prototype.setDate = function (oDate) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_MainDocument_Date, this.Date, oDate));
+		this.Date = oDate;
+	};
+	CMainDocument.prototype.setDescription = function (sDescription) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_Description, this.Description, sDescription));
+		this.Description = sDescription;
+	};
+	CMainDocument.prototype.setType = function (sType) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_Type, this.Type, sType));
+		this.Type = sType;
+	};
+	CMainDocument.prototype.setApplication = function (sApplication) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_Application, this.Application, sApplication));
+		this.Application = sApplication;
+	};
+	CMainDocument.prototype.setDocumentId = function (sDocumentId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_DocumentId, this.DocumentId, sDocumentId));
+		this.DocumentId = sDocumentId;
+	};
+	CMainDocument.prototype.addFieldsGroups = function(oFieldsGroup) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_MainDocument_FieldsGroups, this.FieldsGroups.length, [oFieldsGroup], true));
+		this.FieldsGroups.push(oFieldsGroup);
+	};
+	CMainDocument.prototype.addUser = function(oUser) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_MainDocument_User, this.FieldsGroups.length, [oUser], true));
+		this.Users.push(oUser);
+	};
+	CMainDocument.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "Author": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				let sAuthor = oNode.attributes["id"];
+				if(sAuthor) {
+					this.setAuthor(sAuthor);
+				}
+				break;
+			}
+			case "Date": {
+				let oDate = new CFormDate();
+				oDate.fromXml(reader);
+				this.setDate(oDate);
+				break;
+			}
+			case "Description": {
+
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setDescription(oNode.text);
+				break;
+			}
+			case "Type": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setType(oNode.text);
+				break;
+			}
+			case "Application": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setApplication(oNode.text);
+				break;
+			}
+			case "Id": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setDocumentId(oNode.text);
+				break;
+			}
+			case "FieldsGroup": {
+				let oFieldsGroup = new CFieldsGroup();
+				oFieldsGroup.fromXml(reader);
+				this.addFieldsGroups(oFieldsGroup);
+				break;
+			}
+		}
+	};
+	CMainDocument.prototype.toXml = function(writer) {
+
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("Document");
+		writer.WriteXmlAttributeString("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships");
+		writer.WriteXmlAttributesEnd();
+		if(this.Author) {
+			let oNode = new CT_XmlNode();
+			oNode.attributes["id"] = this.Author;
+			oNode.toXml(writer, "Author");
+		}
+		if(this.Date) {
+			this.Date.toXml(writer);
+		}
+		let oDescriptionNode = new CT_XmlNode();
+		oDescriptionNode.text = this.Description;
+		oDescriptionNode.toXml(writer, "Description");
+
+		let oTypeNode = new CT_XmlNode();
+		oTypeNode.text = this.Type;
+		oTypeNode.toXml(writer, "Type");
+
+		let oAppNode = new CT_XmlNode();
+		oAppNode.text = this.Application;
+		oAppNode.toXml(writer, "Application");
+
+		let oIdNode = new CT_XmlNode();
+		oIdNode.text = this.DocumentId;
+		oIdNode.toXml(writer, "Id");
+		for(let nFG = 0; nFG < this.FieldsGroups.length; ++nFG) {
+			this.FieldsGroups[nFG].toXml(writer);
+		}
+		writer.WriteXmlNodeEnd("Document");
+	};
+
+	function CFormDate() {
+		CBaseFormatObject.call(this);
+		this.Format = null;
+		this.Value = null;
+	}
+	InitClass(CFormDate, CBaseFormatObject, AscDFH.historyitem_type_FormDate);
+	CFormDate.prototype.setFormat = function(sFormat) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FormDate_Format, this.Format, sFormat));
+		this.Format = sFormat;
+	};
+	CFormDate.prototype.setValue = function(sValue) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FormDate_Value, this.Value, sValue));
+		this.Value = sValue;
+	};
+	CFormDate.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "Format": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setFormat(oNode.text);
+				break;
+			}
+			case "Value": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setValue(oNode.text);
+				break;
+			}
+		}
+	};
+	CFormDate.prototype.toXml = function (writer) {
+		writer.WriteXmlNodeStart("Date");
+		writer.WriteXmlAttributesEnd();
+
+		let oFormatNode = new CT_XmlNode();
+		oFormatNode.text = this.Format;
+		oFormatNode.toXml(writer, "Format");
+
+		let oValueNode = new CT_XmlNode();
+		oValueNode.text = this.Value;
+		oValueNode.toXml(writer, "Value");
+
+		writer.WriteXmlNodeEnd("Date");
+	};
+
+	function CFieldsGroup() {
+		CBaseFormatObject.call(this);
+		this.GroupId = null;
+		this.Weight = null;
+		this.Fields = [];
+	}
+	InitClass(CFieldsGroup, CBaseFormatObject, AscDFH.historyitem_type_FieldsGroup);
+	CFieldsGroup.prototype.setGroupId = function (sGroupId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FieldsGroup_Id, this.GroupId, sGroupId));
+		this.GroupId = sGroupId;
+	};
+	CFieldsGroup.prototype.setWeight = function (nWeight) {
+		AscCommon.History.Add(new CChangesLong(this, AscDFH.historyitem_FieldsGroup_Weight, this.Weight, nWeight));
+		this.Weight = nWeight;
+	};
+	CFieldsGroup.prototype.addField = function (oField) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_FieldsGroup_Field, this.Fields.length, [oField], true));
+		this.Fields.push(oField);
+	};
+	CFieldsGroup.prototype.readAttrXml = function(name, reader) {
+		switch (name) {
+			case "id": {
+				this.setGroupId(reader.GetValue());
+				break;
+			}
+			case "weight": {
+				this.setWeight(reader.GetValueInt());
+				break;
+			}
+		}
+	};
+	CFieldsGroup.prototype.readChildXml = function(name, reader) {
+		switch (name) {
+			case "Field": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				let sId = oNode.attributes["id"];
+				let oRel = reader.rels.getRelationshipById(sId);
+				reader.context.addFieldGroupRelation(this, oRel.targetFullName);
+				break;
+			}
+		}
+	};
+	CFieldsGroup.prototype.toXml = function (writer) {
+		writer.WriteXmlNodeStart("FieldsGroup");
+		writer.WriteXmlNullableAttributeString("id", this.GroupId);
+		writer.WriteXmlNullableAttributeInt("weight", this.Weight);
+		writer.WriteXmlAttributesEnd();
+
+		let oContext = writer.context;
+		let oFldMasterPartMap = oContext.fieldMastersPartMap;
+		for(let nFldMaster = 0; nFldMaster < this.Fields.length; ++nFldMaster) {
+			let oFieldMaster = this.Fields[nFldMaster];
+			let oPart = oFldMasterPartMap[oFieldMaster.Id];
+			if(oPart) {
+				let oNode = new CT_XmlNode();
+				oNode.attributes["r:id"] = oContext.part.addRelationship(AscCommon.openXml.Types.fieldMaster.relationType, oPart.part.uri);
+				oNode.toXml(writer, "Field");
+			}
+		}
+
+		writer.WriteXmlNodeEnd("FieldsGroup");
+	};
+
+	AscWord.CMainDocument = CMainDocument;
+	AscWord.CFieldsGroup = CFieldsGroup;
+	AscWord.CFormDate = CFormDate;
+})(window);

oform/User.js

@@ -0,0 +1,306 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+"use strict";
+
+(function(window, undefined) {
+	const CBaseFormatObject = AscFormat.CBaseFormatObject;
+	const InitClass = AscFormat.InitClass;
+	const CChangesString = AscDFH.CChangesDrawingsString;
+	const CChangesObject = AscDFH.CChangesDrawingsObject;
+	const CChangesContent = AscDFH.CChangesDrawingsContent;
+
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterUserId] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterSignInfo] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterCipherInfo] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterRole] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_UserEmail] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_UserTelephone] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterUser] = CChangesContent;
+
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterUserId] = function(oClass, value) {oClass.UserId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterSignInfo] = function(oClass, value) {oClass.SignInfo = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterCipherInfo] = function(oClass, value) {oClass.CipherInfo = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterRole] = function(oClass, value) {oClass.Role = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserEmail] = function(oClass, value) {oClass.Email = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserTelephone] = function(oClass, value) {oClass.Telephone = value;};
+
+	AscDFH.drawingContentChanges[AscDFH.historyitem_UserMasterUser] = function(oClass) {return oClass.Users;};
+
+
+
+	function CUserMaster() {
+		CBaseFormatObject.call(this);
+		this.UserId = null;
+		this.SignInfo = null;
+		this.CipherInfo = null;
+		this.Role = null;
+
+		this.Users = [];
+	}
+	InitClass(CUserMaster, CBaseFormatObject, AscDFH.historyitem_type_UserMaster);
+	CUserMaster.prototype.setUserId = function (sUserId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserMasterUserId, this.UserId, sUserId));
+		this.UserId = sUserId;
+	};
+	CUserMaster.prototype.setSignInfo = function (oSignInfo) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_UserMasterSignInfo, this.SignInfo, oSignInfo));
+		this.SignInfo = oSignInfo;
+
+	};
+	CUserMaster.prototype.setCipherInfo = function (oCipherInfo) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_UserMasterCipherInfo, this.CipherInfo, oCipherInfo));
+		this.CipherInfo = oCipherInfo;
+	};
+	CUserMaster.prototype.setRole = function (sRole) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserMasterRole, this.Role, sRole));
+		this.Role = sRole;
+	};
+	CUserMaster.prototype.addUser = function (oUser) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_UserMasterUser, this.Users.length, [oUser], true));
+		this.Users.push(oUser);
+	};
+	CUserMaster.prototype.readChildXml = function (name, reader) {
+		let bRead = false;
+		switch (name) {
+			case "Id": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setUserId(oNode.text);
+				bRead = true;
+				break;
+			}
+			case "SignInfo": {
+				let oSignInfo = new CSignInfo();
+				oSignInfo.fromXml(reader);
+				this.setSignInfo(oSignInfo);
+				bRead = true;
+				break;
+			}
+			case "CipherInfo": {
+				let oCipherInfo = new CCipherInfo();
+				oCipherInfo.fromXml(reader);
+				this.setCipherInfo(oCipherInfo);
+				bRead = true;
+				break;
+			}
+			case "Role": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setRole(oNode.text);
+				bRead = true;
+				break;
+			}
+		}
+		return bRead;
+	};
+	CUserMaster.prototype.writeChildren = function(writer) {
+		let oIdNode = new CT_XmlNode();
+		oIdNode.text = this.UserId;
+		oIdNode.toXml(writer, "Id");
+		if(this.SignInfo) {
+			this.SignInfo.toXml(writer);
+		}
+		if(this.CipherInfo) {
+			this.CipherInfo.toXml(writer);
+		}
+		let oRoleNode = new CT_XmlNode();
+		oRoleNode.text = this.Role;
+		oRoleNode.toXml(writer, "Role");
+	}
+	CUserMaster.prototype.toXml = function (writer) {
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("UserMaster");
+		writer.WriteXmlAttributesEnd();
+		this.writeChildren(writer);
+		writer.WriteXmlNodeEnd("UserMaster");
+	};
+
+	function CUser() {
+		CUserMaster.call(this);
+		this.Email = null;
+		this.Telephone = null;
+	}
+	InitClass(CUser, CUserMaster, AscDFH.historyitem_type_User);
+	CUser.prototype.setEmail = function (sEmail) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserEmail, this.Email, sEmail));
+		this.Email = sEmail;
+	};
+	CUser.prototype.setTelephone = function (sTelephone) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserTelephone, this.Telephone, sTelephone));
+		this.Telephone = sTelephone;
+	};
+	CUser.prototype.readChildXml = function (name, reader) {
+		if(CUserMaster.prototype.readChildXml.call(this, name, reader)) {
+			return true;
+		}
+		let bRead = false;
+		switch (name) {
+			case "Email": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setEmail(oNode.text);
+				bRead = true;
+				break;
+			}
+			case "Telephone": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setTelephone(oNode.text);
+				bRead = true;
+				break;
+			}
+		}
+		return bRead;
+	};
+	CUser.prototype.toXml = function (writer) {
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("User");
+		writer.WriteXmlAttributesEnd();
+		let oEmailNode = new CT_XmlNode();
+		oEmailNode.text = this.Email;
+		oEmailNode.toXml(writer, "Email");
+
+		let oTelephoneNode = new CT_XmlNode();
+		oTelephoneNode.text = this.Telephone;
+		oTelephoneNode.toXml(writer, "Telephone");
+		this.writeChildren(writer);
+		writer.WriteXmlNodeEnd("User");
+	};
+
+	function CSignInfo() {
+		CBaseFormatObject.call(this);
+		this.PublicKey = null;
+		this.X509 = null;
+		this.ImageValid = null;
+		this.ImageInvalid = null;
+	}
+	InitClass(CSignInfo, CBaseFormatObject, AscDFH.historyitem_type_SignInfo);
+	CSignInfo.prototype.setPublicKey = function (sPublicKey) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_SignInfo_PublicKey, this.PublicKey, sPublicKey));
+		this.PublicKey = sPublicKey;
+	};
+	CSignInfo.prototype.setX509 = function (sX509) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_SignInfo_X509, this.X509, sX509));
+		this.X509 = sX509;
+	};
+	CSignInfo.prototype.setImageValid = function (sImageValid) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_SignInfo_ImageValid, this.ImageValid, sImageValid));
+		this.ImageValid = sImageValid;
+	};
+	CSignInfo.prototype.setImageInvalid = function (sImageInvalid) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_SignInfo_ImageInvalid, this.ImageInvalid, sImageInvalid));
+		this.ImageInvalid = sImageInvalid;
+	};
+	CSignInfo.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "PublicKey": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setPublicKey(oNode.text);
+				break;
+			}
+			case "X509": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setX509(oNode.text);
+				break;
+			}
+			case "ImageValid": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setImageValid(oNode.text);
+				break;
+			}
+			case "ImageInvalid": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setImageInvalid(oNode.text);
+				break;
+			}
+		}
+	};
+	CSignInfo.prototype.toXml = function(writer) {
+		writer.WriteXmlNodeStart("SignInfo");
+		writer.WriteXmlAttributesEnd();
+		let oPublicKeyNode = new CT_XmlNode();
+		oPublicKeyNode.text = this.PublicKey;
+		oPublicKeyNode.toXml(writer, "PublicKey");
+
+		let oX509Node = new CT_XmlNode();
+		oX509Node.text = this.X509;
+		oX509Node.toXml(writer, "X509");
+
+		let oImageValidNode = new CT_XmlNode();
+		oImageValidNode.text = this.ImageValid;
+		oImageValidNode.toXml(writer, "ImageValid");
+
+		let oImageInvalidNode = new CT_XmlNode();
+		oImageInvalidNode.text = this.ImageInvalid;
+		oImageInvalidNode.toXml(writer, "ImageInvalid");
+
+		writer.WriteXmlNodeEnd("SignInfo");
+	};
+
+	function CCipherInfo() {
+		CBaseFormatObject.call(this);
+		this.PublicKey = null;
+	}
+	InitClass(CCipherInfo, CBaseFormatObject, AscDFH.historyitem_type_CipherInfo);
+	CCipherInfo.prototype.setPublicKey = function (sPublicKey) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_CipherInfo_PublicKey, this.PublicKey, sPublicKey));
+		this.PublicKey = sPublicKey;
+	};
+	CCipherInfo.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "PublicKey": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setPublicKey(oNode.text);
+				break;
+			}
+		}
+	};
+	CCipherInfo.prototype.toXml = function(writer) {
+		writer.WriteXmlNodeStart("CipherInfo");
+		writer.WriteXmlAttributesEnd();
+		let oPublicKeyNode = new CT_XmlNode();
+		oPublicKeyNode.text = this.PublicKey;
+		oPublicKeyNode.toXml(writer, "PublicKey");
+		writer.WriteXmlNodeEnd("CipherInfo");
+	};
+
+	AscWord.CUserMaster = CUserMaster;
+	AscWord.CUser = CUser;
+	AscWord.CSignInfo = CSignInfo;
+	AscWord.CCipherInfo = CCipherInfo;
+})(window);