diff options
Diffstat (limited to 'src')
88 files changed, 9853 insertions, 185 deletions
diff --git a/src/html/Makefile b/src/html/Makefile index 5226b53..c98ce9a 100644 --- a/src/html/Makefile +++ b/src/html/Makefile @@ -3,24 +3,23 @@ DIR_SOURCES := \ html_document.c html_collection.c html_options_collection.c \ html_element.c html_html_element.c html_head_element.c \ html_link_element.c html_title_element.c html_meta_element.c \ - html_base_element.c html_isindex_element.c html_style_element.c \ + html_base_element.c html_style_element.c \ html_body_element.c html_form_element.c html_select_element.c \ html_button_element.c html_input_element.c html_text_area_element.c \ - html_opt_group_element.c html_option_element.c html_hr_element.c + html_opt_group_element.c html_option_element.c html_hr_element.c \ + html_dlist_element.c html_directory_element.c html_menu_element.c \ + html_fieldset_element.c html_legend_element.c html_div_element.c \ + html_paragraph_element.c html_heading_element.c html_quote_element.c \ + html_pre_element.c html_br_element.c html_label_element.c \ + html_ulist_element.c html_olist_element.c html_li_element.c \ + html_font_element.c html_mod_element.c html_anchor_element.c \ + html_basefont_element.c html_image_element.c html_object_element.c \ + html_param_element.c html_applet_element.c html_area_element.c \ + html_map_element.c html_script_element.c html_tablecaption_element.c \ + html_tablecell_element.c html_tablecol_element.c html_tablesection_element.c \ + html_table_element.c html_tablerow_element.c html_frameset_element.c \ + html_frame_element.c html_iframe_element.c html_isindex_element.c \ UNINMPLEMENTED_SOURCES := \ - html_label_element.c html_fieldset_element.c \ - html_legend_element.c html_ulist_element.c html_olist_element.c \ - html_dlist_element.c html_directory_element.c html_menu_element.c \ - html_li_element.c html_div_element.c html_paragraph_element.c \ - html_heading_element.c html_quote_element.c html_pre_element.c \ - html_br_element.c html_basefont_element.c html_font_element.c \ - html_mod_element.c html_anchor_element.c \ - html_image_element.c html_object_element.c html_param_element.c \ - html_applet_element.c html_map_element.c html_area_element.c \ - html_script_element.c html_table_element.c html_tablecaption_element.c \ - html_tablecol_element.c html_tablesection_element.c html_tablerow_element.c \ - html_tablecell_element.c html_frameset_element.c html_frame_element.c \ - html_iframe_element.c include $(NSBUILD)/Makefile.subdir diff --git a/src/html/TODO b/src/html/TODO index 37ade2c..b55a6d7 100644 --- a/src/html/TODO +++ b/src/html/TODO @@ -4,54 +4,54 @@ as far as the test suite is concerned. HTMLElement html_element DONE HTMLHtmlElement html_html_element DONE HTMLHeadElement html_head_element DONE -HTMLLinkElement html_link_element MISSING +HTMLLinkElement html_link_element DONE HTMLTitleElement html_title_element DONE -HTMLMetaElement html_meta_element MISSING -HTMLBaseElement html_base_element MISSING +HTMLMetaElement html_meta_element DONE +HTMLBaseElement html_base_element DONE HTMLIsIndexElement html_isindex_element MISSING -HTMLStyleElement html_style_element MISSING -HTMLBodyElement html_body_element MISSING +HTMLStyleElement html_style_element DONE +HTMLBodyElement html_body_element DONE HTMLFormElement html_form_element DONE -HTMLSelectElement html_select_element MISSING -HTMLOptGroupElement html_optgroup_element MISSING -HTMLOptionElement html_option_element MISSING -HTMLInputElement html_input_element MISSING -HTMLTextAreaElement html_textarea_element MISSING -HTMLButtonElement html_button_element MISSING -HTMLLabelElement html_label_element MISSING -HTMLFieldSetElement html_fieldset_element MISSING -HTMLLegendElement html_legend_element MISSING -HTMLUListElement html_ulist_element MISSING -HTMLOListElement html_olist_element MISSING -HTMLDListElement html_dlist_element MISSING -HTMLDirectoryElement html_directory_element MISSING -HTMLMenuElement html_menu_element MISSING -HTMLLIElement html_li_element MISSING -HTMLBlockquoteElement html_blockquote_element MISSING -HTMLDivElement html_div_element MISSING -HTMLParagraphElement html_paragraph_element MISSING -HTMLHeadingElement html_heading_element MISSING -HTMLQuoteElement html_quote_element MISSING -HTMLPreElement html_pre_element MISSING -HTMLBRElement html_br_element MISSING -HTMLBaseFontElement html_basefont_element MISSING -HTMLFontElement html_font_element MISSING +HTMLSelectElement html_select_element DONE +HTMLOptGroupElement html_optgroup_element DONE +HTMLOptionElement html_option_element DONE +HTMLInputElement html_input_element DONE +HTMLTextAreaElement html_textarea_element DONE +HTMLButtonElement html_button_element DONE +HTMLLabelElement html_label_element DONE +HTMLFieldSetElement html_fieldset_element DONE +HTMLLegendElement html_legend_element DONE +HTMLUListElement html_ulist_element DONE +HTMLOListElement html_olist_element DONE +HTMLDListElement html_dlist_element DONE +HTMLDirectoryElement html_directory_element DONE +HTMLMenuElement html_menu_element DONE +HTMLLIElement html_li_element DONE +HTMLBlockquoteElement html_blockquote_element DONE +HTMLDivElement html_div_element DONE +HTMLParagraphElement html_paragraph_element DONE +HTMLHeadingElement html_heading_element DONE +HTMLQuoteElement html_quote_element DONE +HTMLPreElement html_pre_element DONE +HTMLBRElement html_br_element DONE +HTMLBaseFontElement html_basefont_element DONE +HTMLFontElement html_font_element DONE HTMLHRElement html_hr_element DONE -HTMLModElement html_mod_element MISSING -HTMLAnchorElement html_anchor_element MISSING -HTMLImageElement html_image_element MISSING -HTMLObjectElement html_object_element MISSING -HTMLParamElement html_param_element MISSING -HTMLAppletElement html_applet_element MISSING -HTMLMapElement html_map_element MISSING -HTMLAreaElement html_area_element MISSING -HTMLScriptElement html_script_element MISSING -HTMLTableElement html_table_element MISSING -HTMLTableCaptionElement html_tablecaption_element MISSING -HTMLTableColElement html_tablecol_element MISSING -HTMLTableSectionElement html_tablesection_element MISSING -HTMLTableRowElement html_tablerow_element MISSING -HTMLTableCellElement html_tablecell_element MISSING +HTMLModElement html_mod_element DONE +HTMLAnchorElement html_anchor_element DONE +HTMLImageElement html_image_element DONE +HTMLObjectElement html_object_element DONE +HTMLParamElement html_param_element DONE +HTMLAppletElement html_applet_element DONE +HTMLMapElement html_map_element DONE +HTMLAreaElement html_area_element DONE +HTMLScriptElement html_script_element DONE +HTMLTableElement html_table_element DONE +HTMLTableCaptionElement html_tablecaption_element DONE +HTMLTableColElement html_tablecol_element DONE +HTMLTableSectionElement html_tablesection_element DONE +HTMLTableRowElement html_tablerow_element DONE +HTMLTableCellElement html_tablecell_element DONE HTMLFrameSetElement html_frameset_element MISSING HTMLFrameElement html_frame_element MISSING HTMLIFrameElement html_iframe_element MISSING diff --git a/src/html/html_anchor_element.c b/src/html/html_anchor_element.c index 2e182d5..77f8cef 100644 --- a/src/html/html_anchor_element.c +++ b/src/html/html_anchor_element.c @@ -3,5 +3,225 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_anchor_element.h> + +#include "html/html_document.h" +#include "html/html_anchor_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_ANCHOR_ELEMENT + }, + DOM_HTML_ANCHOR_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_anchor_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_anchor_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_anchor_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_anchor_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_anchor_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_anchor_element object + * + * \param doc The document object + * \param ele The dom_html_anchor_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_anchor_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_anchor_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_A], + namespace, prefix); +} + +/** + * Finalise a dom_html_anchor_element object + * + * \param ele The dom_html_anchor_element object + */ +void _dom_html_anchor_element_finalise(struct dom_html_anchor_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_anchor_element object + * + * \param ele The dom_html_anchor_element object + */ +void _dom_html_anchor_element_destroy(struct dom_html_anchor_element *ele) +{ + _dom_html_anchor_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_anchor_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_anchor_element_destroy(dom_node_internal *node) +{ + _dom_html_anchor_element_destroy((struct dom_html_anchor_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_anchor_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_anchor_element_get_##attr( \ + dom_html_anchor_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_anchor_element_set_##attr( \ + dom_html_anchor_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(access_key); +SIMPLE_GET_SET(charset); +SIMPLE_GET_SET(coords); +SIMPLE_GET_SET(href); +SIMPLE_GET_SET(hreflang); +SIMPLE_GET_SET(name); +SIMPLE_GET_SET(rel); +SIMPLE_GET_SET(rev); +SIMPLE_GET_SET(shape); +SIMPLE_GET_SET(target); +SIMPLE_GET_SET(type); + +dom_exception dom_html_anchor_element_get_tab_index( + dom_html_anchor_element *anchor, int32_t *tab_index) +{ + return dom_html_element_get_int32_t_property(&anchor->base, "tabindex", + SLEN("tabindex"), tab_index); +} + +dom_exception dom_html_anchor_element_set_tab_index( + dom_html_anchor_element *anchor, uint32_t tab_index) +{ + return dom_html_element_set_int32_t_property(&anchor->base, "tabindex", + SLEN("tabindex"), tab_index); +} + + +/** + * Blur this control + * + * \param ele The form object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_anchor_element_blur(dom_html_anchor_element *ele) +{ + struct dom_html_document *doc = + (dom_html_document *) dom_node_get_owner(ele); + bool success = false; + assert(doc != NULL); + + /* This event does not bubble & is non-cancelable. Mentioned in w3 specs. More research is needed to prove why. */ + return _dom_dispatch_generic_event((dom_document *) doc, + (dom_event_target *) ele, + doc->memoised[hds_blur], false, + false, &success); +} + +/** + * Focus this control + * + * \param ele The form object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_anchor_element_focus(dom_html_anchor_element *ele) +{ + struct dom_html_document *doc = + (dom_html_document *) dom_node_get_owner(ele); + bool success = false; + assert(doc != NULL); + + /* This event does not bubble & is non-cancelable. Mentioned in w3 specs. More research is needed to prove why. */ + return _dom_dispatch_generic_event((dom_document *)doc, + (dom_event_target *) ele, + doc->memoised[hds_focus], false, + false, &success); +} + diff --git a/src/html/html_anchor_element.h b/src/html/html_anchor_element.h index 2e182d5..a9f5b5b 100644 --- a/src/html/html_anchor_element.h +++ b/src/html/html_anchor_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_anchor_element_h_ +#define dom_internal_html_anchor_element_h_ + +#include <dom/html/html_anchor_element.h> + +#include "html/html_element.h" + +struct dom_html_anchor_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_anchor_element object */ +dom_exception _dom_html_anchor_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_anchor_element **ele); + +/* Initialise a dom_html_anchor_element object */ +dom_exception _dom_html_anchor_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_anchor_element *ele); + +/* Finalise a dom_html_anchor_element object */ +void _dom_html_anchor_element_finalise(struct dom_html_anchor_element *ele); + +/* Destroy a dom_html_anchor_element object */ +void _dom_html_anchor_element_destroy(struct dom_html_anchor_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_anchor_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_anchor_element_destroy(dom_node_internal *node); +dom_exception _dom_html_anchor_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_ANCHOR_ELEMENT_PROTECT_VTABLE \ + _dom_html_anchor_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_ANCHOR_ELEMENT \ + _dom_virtual_html_anchor_element_destroy, \ + _dom_html_anchor_element_copy + +#endif diff --git a/src/html/html_applet_element.c b/src/html/html_applet_element.c index 2e182d5..9f6c16f 100644 --- a/src/html/html_applet_element.c +++ b/src/html/html_applet_element.c @@ -3,5 +3,196 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_applet_element.h> + +#include "html/html_document.h" +#include "html/html_applet_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_APPLET_ELEMENT + }, + DOM_HTML_APPLET_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_applet_element applet + * + * \param doc The document applet + * \param ele The returned element applet + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_applet_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_applet_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_applet_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_applet_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_applet_element applet + * + * \param doc The document applet + * \param ele The dom_html_applet_element applet + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_applet_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_applet_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_APPLET], + namespace, prefix); +} + +/** + * Finalise a dom_html_applet_element applet + * + * \param ele The dom_html_applet_element applet + */ +void _dom_html_applet_element_finalise(struct dom_html_applet_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_applet_element applet + * + * \param ele The dom_html_applet_element applet + */ +void _dom_html_applet_element_destroy(struct dom_html_applet_element *ele) +{ + _dom_html_applet_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_applet_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_applet_element_destroy(dom_node_internal *node) +{ + _dom_html_applet_element_destroy((struct dom_html_applet_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_applet_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_applet_element_get_##attr( \ + dom_html_applet_element *element, \ + dom_string **attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} +#define SIMPLE_SET(attr) \ + dom_exception dom_html_applet_element_set_##attr( \ + dom_html_applet_element *element, \ + dom_string *attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(alt); +SIMPLE_GET_SET(archive); +SIMPLE_GET_SET(code); +SIMPLE_GET_SET(code_base); +SIMPLE_GET_SET(height); +SIMPLE_GET_SET(name); +SIMPLE_GET_SET(object); +SIMPLE_GET_SET(width); + +dom_exception dom_html_applet_element_get_hspace( + dom_html_applet_element *applet, int32_t *hspace) +{ + return dom_html_element_get_int32_t_property(&applet->base, "hspace", + SLEN("hspace"), hspace); +} + +dom_exception dom_html_applet_element_set_hspace( + dom_html_applet_element *applet, uint32_t hspace) +{ + return dom_html_element_set_int32_t_property(&applet->base, "hspace", + SLEN("hspace"), hspace); +} + +dom_exception dom_html_applet_element_get_vspace( + dom_html_applet_element *applet, int32_t *vspace) +{ + return dom_html_element_get_int32_t_property(&applet->base, "vspace", + SLEN("vspace"), vspace); +} + +dom_exception dom_html_applet_element_set_vspace( + dom_html_applet_element *applet, uint32_t vspace) +{ + return dom_html_element_set_int32_t_property(&applet->base, "vspace", + SLEN("vspace"), vspace); +} + diff --git a/src/html/html_applet_element.h b/src/html/html_applet_element.h index 2e182d5..21e6d7a 100644 --- a/src/html/html_applet_element.h +++ b/src/html/html_applet_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_applet_element_h_ +#define dom_internal_html_applet_element_h_ + +#include <dom/html/html_applet_element.h> +#include "html/html_element.h" + + +struct dom_html_applet_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_applet_element object */ +dom_exception _dom_html_applet_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_applet_element **ele); + +/* Initialise a dom_html_applet_element object */ +dom_exception _dom_html_applet_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_applet_element *ele); + +/* Finalise a dom_html_applet_element object */ +void _dom_html_applet_element_finalise(struct dom_html_applet_element *ele); + +/* Destroy a dom_html_applet_element object */ +void _dom_html_applet_element_destroy(struct dom_html_applet_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_applet_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_applet_element_destroy(dom_node_internal *node); +dom_exception _dom_html_applet_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_APPLET_ELEMENT_PROTECT_VTABLE \ + _dom_html_applet_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_APPLET_ELEMENT \ + _dom_virtual_html_applet_element_destroy, \ + _dom_html_applet_element_copy + +#endif diff --git a/src/html/html_area_element.c b/src/html/html_area_element.c index 2e182d5..85a2a3e 100644 --- a/src/html/html_area_element.c +++ b/src/html/html_area_element.c @@ -3,5 +3,220 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_area_element.h> + +#include "html/html_document.h" +#include "html/html_area_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_AREA_ELEMENT + }, + DOM_HTML_AREA_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_area_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_area_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_area_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_area_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_area_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_area_element object + * + * \param doc The document object + * \param ele The dom_html_area_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_area_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_area_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_AREA], + namespace, prefix); +} + +/** + * Finalise a dom_html_area_element object + * + * \param ele The dom_html_area_element object + */ +void _dom_html_area_element_finalise(struct dom_html_area_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_area_element object + * + * \param ele The dom_html_area_element object + */ +void _dom_html_area_element_destroy(struct dom_html_area_element *ele) +{ + _dom_html_area_element_finalise(ele); + free(ele); +} + +/** + * Get the no_href property + * + * \param ele The dom_html_area_element object + * \param no_href The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_area_element_get_no_href(dom_html_area_element *ele, + bool *no_href) +{ + return dom_html_element_get_bool_property(&ele->base, "nohref", + SLEN("nohref"), no_href); +} + +/** + * Set the no_href property + * + * \param ele The dom_html_area_element object + * \param no_href The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_area_element_set_no_href(dom_html_area_element *ele, + bool no_href) +{ + return dom_html_element_set_bool_property(&ele->base, "nohref", + SLEN("nohref"), no_href); +} + +/** + * Set the tab_index property + * + * \param ele The dom_html_area_element object + * \param no_href The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_area_element_get_tab_index( + dom_html_area_element *area, int32_t *tab_index) +{ + return dom_html_element_get_int32_t_property(&area->base, "tabindex", + SLEN("tabindex"), tab_index); +} + +/** + * Set the tab_index property + * + * \param ele The dom_html_area_element object + * \param no_href The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_area_element_set_tab_index( + dom_html_area_element *area, uint32_t tab_index) +{ + return dom_html_element_set_int32_t_property(&area->base, "tabindex", + SLEN("tabindex"), tab_index); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_area_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_area_element_destroy(dom_node_internal *node) +{ + _dom_html_area_element_destroy((struct dom_html_area_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_area_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_area_element_get_##attr( \ + dom_html_area_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_area_element_set_##attr( \ + dom_html_area_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(access_key); +SIMPLE_GET_SET(alt); +SIMPLE_GET_SET(coords); +SIMPLE_GET_SET(href); +SIMPLE_GET_SET(shape); +SIMPLE_GET_SET(target); diff --git a/src/html/html_area_element.h b/src/html/html_area_element.h index 2e182d5..a45d1df 100644 --- a/src/html/html_area_element.h +++ b/src/html/html_area_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_area_element_h_ +#define dom_internal_html_area_element_h_ + +#include <dom/html/html_area_element.h> +#include "html/html_element.h" + + +struct dom_html_area_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_area_element object */ +dom_exception _dom_html_area_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_area_element **ele); + +/* Initialise a dom_html_area_element object */ +dom_exception _dom_html_area_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_area_element *ele); + +/* Finalise a dom_html_area_element object */ +void _dom_html_area_element_finalise(struct dom_html_area_element *ele); + +/* Destroy a dom_html_area_element object */ +void _dom_html_area_element_destroy(struct dom_html_area_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_area_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_area_element_destroy(dom_node_internal *node); +dom_exception _dom_html_area_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_AREA_ELEMENT_PROTECT_VTABLE \ + _dom_html_area_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_AREA_ELEMENT \ + _dom_virtual_html_area_element_destroy, \ + _dom_html_area_element_copy + +#endif diff --git a/src/html/html_base_element.c b/src/html/html_base_element.c index 150ef37..6be8e3a 100644 --- a/src/html/html_base_element.c +++ b/src/html/html_base_element.c @@ -7,6 +7,7 @@ #include <stdlib.h> +#include "html/html_document.h" #include "html/html_base_element.h" #include "core/node.h" @@ -118,3 +119,45 @@ dom_exception _dom_html_base_element_copy(dom_node_internal *old, return _dom_html_element_copy(old, copy); } +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_base_element_get_##attr( \ + dom_html_base_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_base_element_set_##attr( \ + dom_html_base_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(href); +SIMPLE_GET_SET(target); diff --git a/src/html/html_basefont_element.c b/src/html/html_basefont_element.c index 2e182d5..7aa20a0 100644 --- a/src/html/html_basefont_element.c +++ b/src/html/html_basefont_element.c @@ -3,5 +3,182 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> +#include <dom/html/html_basefont_element.h> + +#include "html/html_document.h" +#include "html/html_basefont_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_BASE_FONT_ELEMENT + }, + DOM_HTML_BASE_FONT_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_base_font_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_base_font_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_base_font_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_base_font_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_base_font_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_base_font_element object + * + * \param doc The document object + * \param ele The dom_html_base_font_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_base_font_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_base_font_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_BASEFONT], + namespace, prefix); +} + +/** + * Finalise a dom_html_base_font_element object + * + * \param ele The dom_html_base_font_element object + */ +void _dom_html_base_font_element_finalise(struct dom_html_base_font_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_base_font_element object + * + * \param ele The dom_html_base_font_element object + */ +void _dom_html_base_font_element_destroy(struct dom_html_base_font_element *ele) +{ + _dom_html_base_font_element_finalise(ele); + free(ele); +} + +/** + * Get the width Property + * + * \param base_font The dom_html_base_font_element object + */ +dom_exception dom_html_base_font_element_get_size( + dom_html_base_font_element *base_font, int32_t *size) +{ + return dom_html_element_get_int32_t_property(&base_font->base, "size", + SLEN("size"), size); +} + +/** + * Set the width Property + * + * \param base_font The dom_html_base_font_element object + */ +dom_exception dom_html_base_font_element_set_size( + dom_html_base_font_element *base_font, uint32_t size) +{ + return dom_html_element_set_int32_t_property(&base_font->base, "size", + SLEN("size"), size); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_base_font_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_base_font_element_destroy(dom_node_internal *node) +{ + _dom_html_base_font_element_destroy((struct dom_html_base_font_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_base_font_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_base_font_element_get_##attr( \ + dom_html_base_font_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ + dom_exception dom_html_base_font_element_set_##attr( \ + dom_html_base_font_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(color); +SIMPLE_GET_SET(face); diff --git a/src/html/html_basefont_element.h b/src/html/html_basefont_element.h index 2e182d5..e6427ec 100644 --- a/src/html/html_basefont_element.h +++ b/src/html/html_basefont_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_basefont_element_h_ +#define dom_internal_html_basefont_element_h_ + +#include <dom/html/html_basefont_element.h> +#include "html/html_element.h" + + +struct dom_html_base_font_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_base_font_element object */ +dom_exception _dom_html_base_font_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_base_font_element **ele); + +/* Initialise a dom_html_base_font_element object */ +dom_exception _dom_html_base_font_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_base_font_element *ele); + +/* Finalise a dom_html_base_font_element object */ +void _dom_html_base_font_element_finalise(struct dom_html_base_font_element *ele); + +/* Destroy a dom_html_base_font_element object */ +void _dom_html_base_font_element_destroy(struct dom_html_base_font_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_base_font_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_base_font_element_destroy(dom_node_internal *node); +dom_exception _dom_html_base_font_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_BASE_FONT_ELEMENT_PROTECT_VTABLE \ + _dom_html_base_font_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_BASE_FONT_ELEMENT \ + _dom_virtual_html_base_font_element_destroy, \ + _dom_html_base_font_element_copy + +#endif diff --git a/src/html/html_br_element.c b/src/html/html_br_element.c index 2e182d5..fbc133e 100644 --- a/src/html/html_br_element.c +++ b/src/html/html_br_element.c @@ -3,5 +3,160 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_br_element.h> + +#include "html/html_document.h" +#include "html/html_br_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_BR_ELEMENT + }, + DOM_HTML_BR_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_br_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_br_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_br_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_br_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_br_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_br_element object + * + * \param doc The document object + * \param ele The dom_html_br_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_br_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_br_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_BR], + namespace, prefix); +} + +/** + * Finalise a dom_html_br_element object + * + * \param ele The dom_html_br_element object + */ +void _dom_html_br_element_finalise(struct dom_html_br_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_br_element object + * + * \param ele The dom_html_br_element object + */ +void _dom_html_br_element_destroy(struct dom_html_br_element *ele) +{ + _dom_html_br_element_finalise(ele); + free(ele); +} + + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_br_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_br_element_destroy(dom_node_internal *node) +{ + _dom_html_br_element_destroy((struct dom_html_br_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_br_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_br_element_get_##attr( \ + dom_html_br_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_br_element_set_##attr( \ + dom_html_br_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(clear); diff --git a/src/html/html_br_element.h b/src/html/html_br_element.h index 2e182d5..ff2df3d 100644 --- a/src/html/html_br_element.h +++ b/src/html/html_br_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_br_element_h_ +#define dom_internal_html_br_element_h_ + +#include <dom/html/html_br_element.h> +#include "html/html_element.h" + + +struct dom_html_br_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_br_element object */ +dom_exception _dom_html_br_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_br_element **ele); + +/* Initialise a dom_html_br_element object */ +dom_exception _dom_html_br_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_br_element *ele); + +/* Finalise a dom_html_br_element object */ +void _dom_html_br_element_finalise(struct dom_html_br_element *ele); + +/* Destroy a dom_html_br_element object */ +void _dom_html_br_element_destroy(struct dom_html_br_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_br_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_br_element_destroy(dom_node_internal *node); +dom_exception _dom_html_br_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_BR_ELEMENT_PROTECT_VTABLE \ + _dom_html_br_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_BR_ELEMENT \ + _dom_virtual_html_br_element_destroy, \ + _dom_html_br_element_copy + +#endif diff --git a/src/html/html_collection.c b/src/html/html_collection.c index a99297f..43a26c5 100644 --- a/src/html/html_collection.c +++ b/src/html/html_collection.c @@ -11,6 +11,7 @@ #include <libwapcaplet/libwapcaplet.h> #include "html/html_collection.h" +#include "html/html_document.h" #include "core/node.h" #include "core/element.h" @@ -25,7 +26,7 @@ * \param doc The document * \param root The root element of the collection * \param ic The callback function used to determin whether certain node - * beint32_ts to the collection + * belongs to the collection * \param col The result collection object * \return DOM_NO_ERR on success, appropriate dom_exception on failure. */ @@ -132,7 +133,7 @@ dom_exception dom_html_collection_get_length(dom_html_collection *col, /* No children and siblings */ struct dom_node_internal *parent = node->parent; - while (parent != col->root && + while (node != col->root && node == parent->last_child) { node = parent; parent = parent->parent; @@ -182,7 +183,7 @@ dom_exception dom_html_collection_item(dom_html_collection *col, /* No children and siblings */ struct dom_node_internal *parent = n->parent; - while (parent != col->root && + while (n != col->root && n == parent->last_child) { n = parent; parent = parent->parent; @@ -212,8 +213,8 @@ dom_exception dom_html_collection_named_item(dom_html_collection *col, dom_string *name, struct dom_node **node) { struct dom_node_internal *n = col->root; + dom_html_document *doc = (dom_html_document *)dom_node_get_owner(n); dom_exception err; - while (n != NULL) { if (n->type == DOM_ELEMENT_NODE && col->ic(n, col->ctx) == true) { @@ -235,6 +236,22 @@ dom_exception dom_html_collection_named_item(dom_html_collection *col, if (id != NULL) dom_string_unref(id); + + /* Check for Name attr if id not matched/found */ + dom_string *id_name = NULL; + err = _dom_element_get_attribute((dom_element *)n, + doc->memoised[hds_name], &id_name); + if(err != DOM_NO_ERR) { + return err; + } + if (id_name != NULL && dom_string_isequal(name, id_name)) { + *node = (struct dom_node *) n; + dom_node_ref(n); + dom_string_unref(id_name); + + return DOM_NO_ERR; + } + } /* Depth first iterating */ @@ -246,13 +263,13 @@ dom_exception dom_html_collection_named_item(dom_html_collection *col, /* No children and siblings */ struct dom_node_internal *parent = n->parent; - while (parent != col->root && + while (n != col->root && n == parent->last_child) { n = parent; parent = parent->parent; } - if (parent == col->root) + if (n == col->root) n = NULL; else n = n->next; diff --git a/src/html/html_directory_element.c b/src/html/html_directory_element.c index 2e182d5..4e0d9e0 100644 --- a/src/html/html_directory_element.c +++ b/src/html/html_directory_element.c @@ -3,5 +3,145 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_directory_element.h> + +#include "html/html_document.h" +#include "html/html_directory_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_DIRECTORY_ELEMENT + }, + DOM_HTML_DIRECTORY_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_directory_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_directory_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_directory_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_directory_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_directory_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_directory_element object + * + * \param doc The document object + * \param ele The dom_html_directory_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_directory_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_directory_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_DIRECTORY], + namespace, prefix); +} + +/** + * Finalise a dom_html_directory_element object + * + * \param ele The dom_html_directory_element object + */ +void _dom_html_directory_element_finalise(struct dom_html_directory_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_directory_element object + * + * \param ele The dom_html_directory_element object + */ +void _dom_html_directory_element_destroy(struct dom_html_directory_element *ele) +{ + _dom_html_directory_element_finalise(ele); + free(ele); +} + +/** + * Get the compact property + * + * \param ele The dom_html_directory_element object + * \param compact The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_directory_element_get_compact(dom_html_directory_element *ele, + bool *compact) +{ + return dom_html_element_get_bool_property(&ele->base, "compact", + SLEN("compact"), compact); +} + +/** + * Set the compact property + * + * \param ele The dom_html_directory_element object + * \param compact The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_directory_element_set_compact(dom_html_directory_element *ele, + bool compact) +{ + return dom_html_element_set_bool_property(&ele->base, "compact", + SLEN("compact"), compact); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_directory_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_directory_element_destroy(dom_node_internal *node) +{ + _dom_html_directory_element_destroy((struct dom_html_directory_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_directory_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} diff --git a/src/html/html_directory_element.h b/src/html/html_directory_element.h index 2e182d5..9f3fe2b 100644 --- a/src/html/html_directory_element.h +++ b/src/html/html_directory_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_directory_element_h_ +#define dom_internal_html_directory_element_h_ + +#include <dom/html/html_directory_element.h> +#include "html/html_element.h" + + +struct dom_html_directory_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_directory_element object */ +dom_exception _dom_html_directory_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_directory_element **ele); + +/* Initialise a dom_html_directory_element object */ +dom_exception _dom_html_directory_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_directory_element *ele); + +/* Finalise a dom_html_directory_element object */ +void _dom_html_directory_element_finalise(struct dom_html_directory_element *ele); + +/* Destroy a dom_html_directory_element object */ +void _dom_html_directory_element_destroy(struct dom_html_directory_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_directory_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_directory_element_destroy(dom_node_internal *node); +dom_exception _dom_html_directory_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_DIRECTORY_ELEMENT_PROTECT_VTABLE \ + _dom_html_directory_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_DIRECTORY_ELEMENT \ + _dom_virtual_html_directory_element_destroy, \ + _dom_html_directory_element_copy + +#endif diff --git a/src/html/html_div_element.c b/src/html/html_div_element.c index 2e182d5..0c689d6 100644 --- a/src/html/html_div_element.c +++ b/src/html/html_div_element.c @@ -3,5 +3,159 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_div_element.h> + +#include "html/html_document.h" +#include "html/html_div_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_DIV_ELEMENT + }, + DOM_HTML_DIV_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_div_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_div_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_div_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_div_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_div_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_div_element object + * + * \param doc The document object + * \param ele The dom_html_div_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_div_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_div_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_DIV], + namespace, prefix); +} + +/** + * Finalise a dom_html_div_element object + * + * \param ele The dom_html_div_element object + */ +void _dom_html_div_element_finalise(struct dom_html_div_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_div_element object + * + * \param ele The dom_html_div_element object + */ +void _dom_html_div_element_destroy(struct dom_html_div_element *ele) +{ + _dom_html_div_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_div_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_div_element_destroy(dom_node_internal *node) +{ + _dom_html_div_element_destroy((struct dom_html_div_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_div_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_div_element_get_##attr( \ + dom_html_div_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_div_element_set_##attr( \ + dom_html_div_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(align); diff --git a/src/html/html_div_element.h b/src/html/html_div_element.h index 2e182d5..62d1c3f 100644 --- a/src/html/html_div_element.h +++ b/src/html/html_div_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_div_element_h_ +#define dom_internal_html_div_element_h_ + +#include <dom/html/html_div_element.h> +#include "html/html_element.h" + + +struct dom_html_div_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_div_element object */ +dom_exception _dom_html_div_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_div_element **ele); + +/* Initialise a dom_html_div_element object */ +dom_exception _dom_html_div_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_div_element *ele); + +/* Finalise a dom_html_div_element object */ +void _dom_html_div_element_finalise(struct dom_html_div_element *ele); + +/* Destroy a dom_html_div_element object */ +void _dom_html_div_element_destroy(struct dom_html_div_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_div_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_div_element_destroy(dom_node_internal *node); +dom_exception _dom_html_div_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_DIV_ELEMENT_PROTECT_VTABLE \ + _dom_html_div_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_DIV_ELEMENT \ + _dom_virtual_html_div_element_destroy, \ + _dom_html_div_element_copy + +#endif diff --git a/src/html/html_dlist_element.c b/src/html/html_dlist_element.c index 2e182d5..f63accc 100644 --- a/src/html/html_dlist_element.c +++ b/src/html/html_dlist_element.c @@ -3,5 +3,145 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_dlist_element.h> + +#include "html/html_document.h" +#include "html/html_dlist_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_DL_ELEMENT + }, + DOM_HTML_DL_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_d_list_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_d_list_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_d_list_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_d_list_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_d_list_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_d_list_element object + * + * \param doc The document object + * \param ele The dom_html_d_list_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_d_list_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_d_list_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_DL], + namespace, prefix); +} + +/** + * Finalise a dom_html_d_list_element object + * + * \param ele The dom_html_d_list_element object + */ +void _dom_html_d_list_element_finalise(struct dom_html_d_list_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_d_list_element object + * + * \param ele The dom_html_d_list_element object + */ +void _dom_html_d_list_element_destroy(struct dom_html_d_list_element *ele) +{ + _dom_html_d_list_element_finalise(ele); + free(ele); +} + +/** + * Get the compact property + * + * \param ele The dom_html_d_list_element object + * \param compact The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_d_list_element_get_compact(dom_html_d_list_element *ele, + bool *compact) +{ + return dom_html_element_get_bool_property(&ele->base, "compact", + SLEN("compact"), compact); +} + +/** + * Set the compact property + * + * \param ele The dom_html_d_list_element object + * \param compact The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_d_list_element_set_compact(dom_html_d_list_element *ele, + bool compact) +{ + return dom_html_element_set_bool_property(&ele->base, "compact", + SLEN("compact"), compact); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_d_list_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_d_list_element_destroy(dom_node_internal *node) +{ + _dom_html_d_list_element_destroy((struct dom_html_d_list_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_d_list_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} diff --git a/src/html/html_dlist_element.h b/src/html/html_dlist_element.h index 2e182d5..8e40dca 100644 --- a/src/html/html_dlist_element.h +++ b/src/html/html_dlist_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_d_list_element_h_ +#define dom_internal_html_d_list_element_h_ + +#include <dom/html/html_dlist_element.h> +#include "html/html_element.h" + + +struct dom_html_d_list_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_d_list_element object */ +dom_exception _dom_html_d_list_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_d_list_element **ele); + +/* Initialise a dom_html_d_list_element object */ +dom_exception _dom_html_d_list_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_d_list_element *ele); + +/* Finalise a dom_html_d_list_element object */ +void _dom_html_d_list_element_finalise(struct dom_html_d_list_element *ele); + +/* Destroy a dom_html_d_list_element object */ +void _dom_html_d_list_element_destroy(struct dom_html_d_list_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_d_list_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_d_list_element_destroy(dom_node_internal *node); +dom_exception _dom_html_d_list_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_DL_ELEMENT_PROTECT_VTABLE \ + _dom_html_d_list_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_DL_ELEMENT \ + _dom_virtual_html_d_list_element_destroy, \ + _dom_html_d_list_element_copy + +#endif diff --git a/src/html/html_document.c b/src/html/html_document.c index 0da16bb..6adfedd 100644 --- a/src/html/html_document.c +++ b/src/html/html_document.c @@ -25,6 +25,42 @@ #include "html/html_option_element.h" #include "html/html_select_element.h" #include "html/html_hr_element.h" +#include "html/html_dlist_element.h" +#include "html/html_directory_element.h" +#include "html/html_menu_element.h" +#include "html/html_fieldset_element.h" +#include "html/html_legend_element.h" +#include "html/html_paragraph_element.h" +#include "html/html_heading_element.h" +#include "html/html_quote_element.h" +#include "html/html_pre_element.h" +#include "html/html_br_element.h" +#include "html/html_label_element.h" +#include "html/html_ulist_element.h" +#include "html/html_olist_element.h" +#include "html/html_li_element.h" +#include "html/html_font_element.h" +#include "html/html_mod_element.h" +#include "html/html_anchor_element.h" +#include "html/html_basefont_element.h" +#include "html/html_image_element.h" +#include "html/html_object_element.h" +#include "html/html_param_element.h" +#include "html/html_applet_element.h" +#include "html/html_map_element.h" +#include "html/html_area_element.h" +#include "html/html_script_element.h" +#include "html/html_tablecaption_element.h" +#include "html/html_tablecell_element.h" +#include "html/html_tablecol_element.h" +#include "html/html_tablesection_element.h" +#include "html/html_table_element.h" +#include "html/html_tablerow_element.h" +#include "html/html_style_element.h" +#include "html/html_frameset_element.h" +#include "html/html_frame_element.h" +#include "html/html_iframe_element.h" +#include "html/html_isindex_element.h" #include "core/attr.h" #include "core/string.h" @@ -91,16 +127,17 @@ dom_exception _dom_html_document_initialise(dom_html_document *doc, doc->domain = NULL; doc->url = NULL; doc->cookie = NULL; - + doc->body = NULL; + doc->memoised = calloc(sizeof(dom_string *), hds_COUNT); if (doc->memoised == NULL) { error = DOM_NO_MEM_ERR; goto out; } - + #define HTML_DOCUMENT_STRINGS_ACTION(attr,str) \ error = dom_string_create_interned((const uint8_t *) #str, \ - SLEN(#str), &doc->memoised[hds_##attr]); \ + SLEN(#str), &doc->memoised[hds_##attr]); \ if (error != DOM_NO_ERR) { \ goto out; \ } @@ -224,6 +261,127 @@ _dom_html_document_create_element_internal(dom_html_document *html, } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_HR])) { exc = _dom_html_hr_element_create(html, namespace, prefix, (dom_html_hr_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_DL])) { + exc = _dom_html_d_list_element_create(html, namespace, prefix, + (dom_html_d_list_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_DIRECTORY])) { + exc = _dom_html_directory_element_create(html, namespace, prefix, + (dom_html_directory_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_MENU])) { + exc = _dom_html_menu_element_create(html, namespace, prefix, + (dom_html_menu_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_FIELDSET])) { + exc = _dom_html_field_set_element_create(html, namespace, prefix, + (dom_html_field_set_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_LEGEND])) { + exc = _dom_html_legend_element_create(html, namespace, prefix, + (dom_html_legend_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_P])) { + exc = _dom_html_paragraph_element_create(html, namespace, prefix, + (dom_html_paragraph_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_H1]) || + dom_string_caseless_isequal(tag_name, html->memoised[hds_H2]) || + dom_string_caseless_isequal(tag_name, html->memoised[hds_H3]) || + dom_string_caseless_isequal(tag_name, html->memoised[hds_H4]) || + dom_string_caseless_isequal(tag_name, html->memoised[hds_H5]) || + dom_string_caseless_isequal(tag_name, html->memoised[hds_H6]) + ) { + exc = _dom_html_heading_element_create(html, tag_name, namespace, prefix, + (dom_html_heading_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_Q])) { + exc = _dom_html_quote_element_create(html, namespace, prefix, + (dom_html_quote_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_PRE])) { + exc = _dom_html_pre_element_create(html, namespace, prefix, + (dom_html_pre_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_BR])) { + exc = _dom_html_br_element_create(html, namespace, prefix, + (dom_html_br_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_LABEL])) { + exc = _dom_html_label_element_create(html, namespace, prefix, + (dom_html_label_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_UL])) { + exc = _dom_html_u_list_element_create(html, namespace, prefix, + (dom_html_u_list_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_OL])) { + exc = _dom_html_o_list_element_create(html, namespace, prefix, + (dom_html_o_list_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_LI])) { + exc = _dom_html_li_element_create(html, namespace, prefix, + (dom_html_li_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_FONT])) { + exc = _dom_html_font_element_create(html, namespace, prefix, + (dom_html_font_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_DEL]) || + dom_string_caseless_isequal(tag_name, html->memoised[hds_INS])) { + exc = _dom_html_mod_element_create(html, tag_name, namespace, + prefix, (dom_html_mod_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_A])) { + exc = _dom_html_anchor_element_create(html, namespace, prefix, + (dom_html_anchor_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_BASEFONT])) { + exc = _dom_html_base_font_element_create(html, namespace, prefix, + (dom_html_base_font_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_IMG])) { + exc = _dom_html_image_element_create(html, namespace, prefix, + (dom_html_image_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_OBJECT])) { + exc = _dom_html_object_element_create(html, namespace, prefix, + (dom_html_object_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_PARAM])) { + exc = _dom_html_param_element_create(html, namespace, prefix, + (dom_html_param_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_APPLET])) { + exc = _dom_html_applet_element_create(html, namespace, prefix, + (dom_html_applet_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_MAP])) { + exc = _dom_html_map_element_create(html, namespace, prefix, + (dom_html_map_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_AREA])) { + exc = _dom_html_area_element_create(html, namespace, prefix, + (dom_html_area_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_SCRIPT])) { + exc = _dom_html_script_element_create(html, namespace, prefix, + (dom_html_script_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_CAPTION])) { + exc = _dom_html_table_caption_element_create(html, namespace, prefix, + (dom_html_table_caption_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_TD]) || + dom_string_caseless_isequal(tag_name, html->memoised[hds_TH]) + ) { + exc = _dom_html_table_cell_element_create(html, tag_name, namespace, prefix, + (dom_html_table_cell_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_COL])|| + dom_string_caseless_isequal(tag_name, html->memoised[hds_COLGROUP]) + ) { + exc = _dom_html_table_col_element_create(html, tag_name, namespace, prefix, + (dom_html_table_col_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_THEAD])|| + dom_string_caseless_isequal(tag_name, html->memoised[hds_TBODY])|| + dom_string_caseless_isequal(tag_name, html->memoised[hds_TFOOT])) { + exc = _dom_html_table_section_element_create(html, tag_name, namespace, prefix, + (dom_html_table_section_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_TABLE])) { + exc = _dom_html_table_element_create(html, namespace, prefix, + (dom_html_table_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_TD])) { + exc = _dom_html_table_row_element_create(html, namespace, prefix, + (dom_html_table_row_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_STYLE])) { + exc = _dom_html_style_element_create(html, + (dom_html_style_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_FRAMESET])) { + exc = _dom_html_frame_set_element_create(html, namespace, prefix, + (dom_html_frame_set_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_FRAME])) { + exc = _dom_html_frame_element_create(html, namespace, prefix, + (dom_html_frame_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_IFRAME])) { + exc = _dom_html_iframe_element_create(html, namespace, prefix, + (dom_html_iframe_element **) result); + } else if (dom_string_caseless_isequal(tag_name, html->memoised[hds_ISINDEX])) { + exc = _dom_html_isindex_element_create(html, namespace, prefix, + (dom_html_isindex_element **) result); } else { exc = _dom_html_element_create(html, tag_name, namespace, prefix, result); @@ -486,57 +644,193 @@ dom_exception _dom_html_document_get_url(dom_html_document *doc, dom_exception _dom_html_document_get_body(dom_html_document *doc, struct dom_html_element **body) { - UNUSED(doc); - UNUSED(body); + dom_exception exc = DOM_NO_ERR; - return DOM_NOT_SUPPORTED_ERR; + if (doc->body != NULL) { + *body = doc->body; + } else { + dom_element *node; + dom_nodelist *nodes; + uint32_t len; + + exc = dom_document_get_elements_by_tag_name(doc, + doc->memoised[hds_BODY], + &nodes); + if (exc != DOM_NO_ERR) { + return exc; + } + + exc = dom_nodelist_get_length(nodes, &len); + if (exc != DOM_NO_ERR) { + dom_nodelist_unref(nodes); + return exc; + } + + if (len == 0) { + exc = dom_document_get_elements_by_tag_name(doc, + doc->memoised[hds_FRAMESET], + &nodes); + if (exc != DOM_NO_ERR) { + return exc; + } + exc = dom_nodelist_get_length(nodes, &len); + if (exc != DOM_NO_ERR) { + dom_nodelist_unref(nodes); + return exc; + } + if(len == 0) { + dom_nodelist_unref(nodes); + return DOM_NO_ERR; + } + } + + exc = dom_nodelist_item(nodes, 0, (void *) &node); + dom_nodelist_unref(nodes); + if (exc != DOM_NO_ERR) { + return exc; + } + + *body = (dom_html_element *)node; + dom_node_unref(node); + } + + return exc; } dom_exception _dom_html_document_set_body(dom_html_document *doc, struct dom_html_element *body) { - UNUSED(doc); - UNUSED(body); + doc->body = body; + return DOM_NO_ERR; +} - return DOM_NOT_SUPPORTED_ERR; +/** + * Callback for creating the images collection + * + * \param node The dom_node_internal object + * \param ctx The dom_html_document object (void *) + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +bool images_callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_IMG])) { + return true; + } + return false; } dom_exception _dom_html_document_get_images(dom_html_document *doc, struct dom_html_collection **col) { - UNUSED(doc); - UNUSED(col); + dom_html_document *root; + dom_exception err; + err = dom_document_get_document_element(doc, &root); + if (err != DOM_NO_ERR) + return err; - return DOM_NOT_SUPPORTED_ERR; + return _dom_html_collection_create(doc, (dom_node_internal *) root, + images_callback, doc, col); +} + +bool applet_callback(struct dom_node_internal * node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_APPLET])) { + return true; + } + return false; +} +/** + * Callback for creating the applets collection + * + * \param node The dom_node_internal object + * \param ctx The dom_html_document object (void *) + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +bool applets_callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_OBJECT])) { + uint32_t len = 0; + dom_html_collection *applets; + _dom_html_collection_create(ctx, node, + applet_callback, ctx, &applets); + + dom_html_collection_get_length(applets, &len); + if(len != 0) + return true; + } + return false; } dom_exception _dom_html_document_get_applets(dom_html_document *doc, struct dom_html_collection **col) { - UNUSED(doc); - UNUSED(col); + dom_html_document *root; + dom_exception err; + err = dom_document_get_document_element(doc, &root); + if (err != DOM_NO_ERR) + return err; - return DOM_NOT_SUPPORTED_ERR; + return _dom_html_collection_create(doc, (dom_node_internal *) root, + applets_callback, doc, col); +} + +/** + * Callback for creating the links collection + * + * \param node The dom_node_internal object + * \param ctx The dom_html_document object (void *) + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +bool links_callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + (dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_A]) || + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_AREA])) + ) { + bool has_value = false; + dom_exception err; + + err = dom_element_has_attribute(node, + ((dom_html_document *)ctx)->memoised[hds_href], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) + return true; + } + return false; } dom_exception _dom_html_document_get_links(dom_html_document *doc, struct dom_html_collection **col) { - UNUSED(doc); - UNUSED(col); + dom_html_document *root; + dom_exception err; + err = dom_document_get_document_element(doc, &root); + if (err != DOM_NO_ERR) + return err; - return DOM_NOT_SUPPORTED_ERR; + return _dom_html_collection_create(doc, (dom_node_internal *) root, + links_callback, doc, col); } static bool __dom_html_document_node_is_form(dom_node_internal *node, - void *ctx) + void *ctx) { dom_html_document *doc = (dom_html_document *)node->owner; - + UNUSED(ctx); - + return dom_string_caseless_isequal(node->name, - doc->memoised[hds_FORM]); + doc->memoised[hds_FORM]); } dom_exception _dom_html_document_get_forms(dom_html_document *doc, @@ -564,13 +858,43 @@ dom_exception _dom_html_document_get_forms(dom_html_document *doc, return DOM_NO_ERR; } +/** + * Callback for creating the anchors collection + * + * \param node The dom_node_internal object + * \param ctx The dom_html_document object (void *) + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +bool anchors_callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_A])) { + bool has_value = false; + dom_exception err; + + err = dom_element_has_attribute(node, + ((dom_html_document *)ctx)->memoised[hds_name], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) + return true; + } + return false; +} + dom_exception _dom_html_document_get_anchors(dom_html_document *doc, struct dom_html_collection **col) { - UNUSED(doc); - UNUSED(col); + dom_html_document *root; + dom_exception err; + err = dom_document_get_document_element(doc, &root); + if (err != DOM_NO_ERR) + return err; - return DOM_NOT_SUPPORTED_ERR; + return _dom_html_collection_create(doc, (dom_node_internal *) root, + anchors_callback, doc, col); } dom_exception _dom_html_document_get_cookie(dom_html_document *doc, @@ -578,7 +902,7 @@ dom_exception _dom_html_document_get_cookie(dom_html_document *doc, { UNUSED(doc); UNUSED(cookie); - + /*todo implement this after updating client interface */ return DOM_NOT_SUPPORTED_ERR; } @@ -588,6 +912,7 @@ dom_exception _dom_html_document_set_cookie(dom_html_document *doc, UNUSED(doc); UNUSED(cookie); + /*todo implement this after updating client interface */ return DOM_NOT_SUPPORTED_ERR; } @@ -595,13 +920,14 @@ dom_exception _dom_html_document_open(dom_html_document *doc) { UNUSED(doc); + /*todo implement this after updating client interface */ return DOM_NOT_SUPPORTED_ERR; } dom_exception _dom_html_document_close(dom_html_document *doc) { UNUSED(doc); - + /*todo implement this after updating client interface */ return DOM_NOT_SUPPORTED_ERR; } @@ -611,6 +937,7 @@ dom_exception _dom_html_document_write(dom_html_document *doc, UNUSED(doc); UNUSED(text); + /*todo implement this after updating client interface */ return DOM_NOT_SUPPORTED_ERR; } @@ -620,6 +947,7 @@ dom_exception _dom_html_document_writeln(dom_html_document *doc, UNUSED(doc); UNUSED(text); + /*todo implement this after _dom_html_document_write */ return DOM_NOT_SUPPORTED_ERR; } @@ -629,7 +957,7 @@ dom_exception _dom_html_document_get_elements_by_name(dom_html_document *doc, UNUSED(doc); UNUSED(name); UNUSED(list); - + /*todo implement after updating core nodelist interface */ return DOM_NOT_SUPPORTED_ERR; } diff --git a/src/html/html_document.h b/src/html/html_document.h index 67250f5..c00529b 100644 --- a/src/html/html_document.h +++ b/src/html/html_document.h @@ -9,6 +9,7 @@ #define dom_internal_html_document_h_ #include <dom/html/html_document.h> +#include <dom/html/html_element.h> #include "core/document.h" @@ -23,6 +24,7 @@ struct dom_html_document { dom_string *domain; /**< HTML document domain */ dom_string *url; /**< HTML document URL */ dom_string *cookie; /**< HTML document cookie */ + dom_html_element *body; /**< HTML BodyElement */ /** Cached strings for html objects to use */ dom_string **memoised; @@ -126,6 +128,11 @@ dom_exception _dom_html_document_create_attribute(dom_document *doc, dom_exception _dom_html_document_create_attribute_ns(dom_document *doc, dom_string *namespace, dom_string *qname, dom_attr **result); +bool images_callback(struct dom_node_internal *node, void *ctx); +bool applets_callback(struct dom_node_internal *node, void *ctx); +bool applet_callback(struct dom_node_internal *node, void *ctx); +bool links_callback(struct dom_node_internal *node, void *ctx); +bool anchors_callback(struct dom_node_internal *node, void *ctx); #define DOM_DOCUMENT_VTABLE_HTML \ _dom_document_get_doctype, \ diff --git a/src/html/html_document_strings.h b/src/html/html_document_strings.h index 8e9d79e..35fca73 100644 --- a/src/html/html_document_strings.h +++ b/src/html/html_document_strings.h @@ -65,6 +65,8 @@ HTML_DOCUMENT_STRINGS_ACTION1(method) /* HTML_DOCUMENT_STRINGS_ACTION1(target) */ /* Useful attributes used by HTMLButtonElement */ HTML_DOCUMENT_STRINGS_ACTION(access_key,accesskey) +/* Useful attributes used by HTMLBrElement */ +HTML_DOCUMENT_STRINGS_ACTION1(clear) /* HTML_DOCUMENT_STRINGS_ACTION1(name) */ /* HTML_DOCUMENT_STRINGS_ACTION1(type) */ HTML_DOCUMENT_STRINGS_ACTION1(value) @@ -81,7 +83,47 @@ HTML_DOCUMENT_STRINGS_ACTION(read_only,readonly) HTML_DOCUMENT_STRINGS_ACTION1(size) HTML_DOCUMENT_STRINGS_ACTION1(src) HTML_DOCUMENT_STRINGS_ACTION1(width) +HTML_DOCUMENT_STRINGS_ACTION1(compact) +HTML_DOCUMENT_STRINGS_ACTION1(cite) +HTML_DOCUMENT_STRINGS_ACTION1(color) +HTML_DOCUMENT_STRINGS_ACTION1(face) +HTML_DOCUMENT_STRINGS_ACTION1(coords) +HTML_DOCUMENT_STRINGS_ACTION1(shape) +HTML_DOCUMENT_STRINGS_ACTION1(border) +HTML_DOCUMENT_STRINGS_ACTION1(code) +HTML_DOCUMENT_STRINGS_ACTION1(archive) +HTML_DOCUMENT_STRINGS_ACTION1(data) +HTML_DOCUMENT_STRINGS_ACTION1(height) +HTML_DOCUMENT_STRINGS_ACTION1(standby) +HTML_DOCUMENT_STRINGS_ACTION1(object) +HTML_DOCUMENT_STRINGS_ACTION1(event) +HTML_DOCUMENT_STRINGS_ACTION1(defer) +HTML_DOCUMENT_STRINGS_ACTION1(abbr) +HTML_DOCUMENT_STRINGS_ACTION1(axis) +HTML_DOCUMENT_STRINGS_ACTION1(headers) +HTML_DOCUMENT_STRINGS_ACTION1(scope) +HTML_DOCUMENT_STRINGS_ACTION1(frame) +HTML_DOCUMENT_STRINGS_ACTION1(rules) +HTML_DOCUMENT_STRINGS_ACTION1(summary) +HTML_DOCUMENT_STRINGS_ACTION1(prompt) +HTML_DOCUMENT_STRINGS_ACTION1(rows) +HTML_DOCUMENT_STRINGS_ACTION1(cols) +HTML_DOCUMENT_STRINGS_ACTION1(scrolling) HTML_DOCUMENT_STRINGS_ACTION(tab_index,tabindex) +HTML_DOCUMENT_STRINGS_ACTION(html_for,for) +HTML_DOCUMENT_STRINGS_ACTION(date_time,datetime) +HTML_DOCUMENT_STRINGS_ACTION(long_desc,longdesc) +HTML_DOCUMENT_STRINGS_ACTION(code_base,codebase) +HTML_DOCUMENT_STRINGS_ACTION(code_type,codetype) +HTML_DOCUMENT_STRINGS_ACTION(value_type,valuetype) +HTML_DOCUMENT_STRINGS_ACTION(v_align,valign) +HTML_DOCUMENT_STRINGS_ACTION(ch,char) +HTML_DOCUMENT_STRINGS_ACTION(ch_off,charoff) +HTML_DOCUMENT_STRINGS_ACTION(cell_padding,cellpadding) +HTML_DOCUMENT_STRINGS_ACTION(cell_spacing,cellspacing) +HTML_DOCUMENT_STRINGS_ACTION(frame_border,frameborder) +HTML_DOCUMENT_STRINGS_ACTION(margin_height,marginheight) +HTML_DOCUMENT_STRINGS_ACTION(margin_width,marginwidth) /* HTML_DOCUMENT_STRINGS_ACTION1(type) */ HTML_DOCUMENT_STRINGS_ACTION(use_map,usemap) /* HTML_DOCUMENT_STRINGS_ACTION1(value) */ @@ -126,7 +168,7 @@ HTML_DOCUMENT_STRINGS_ACTION1(LEGEND) HTML_DOCUMENT_STRINGS_ACTION1(UL) HTML_DOCUMENT_STRINGS_ACTION1(OL) HTML_DOCUMENT_STRINGS_ACTION1(DL) -HTML_DOCUMENT_STRINGS_ACTION1(DIR) +HTML_DOCUMENT_STRINGS_ACTION1(DIRECTORY) HTML_DOCUMENT_STRINGS_ACTION1(MENU) HTML_DOCUMENT_STRINGS_ACTION1(LI) HTML_DOCUMENT_STRINGS_ACTION1(BLOCKQUOTE) diff --git a/src/html/html_fieldset_element.c b/src/html/html_fieldset_element.c index 2e182d5..2ab873e 100644 --- a/src/html/html_fieldset_element.c +++ b/src/html/html_fieldset_element.c @@ -3,5 +3,151 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_fieldset_element.h> + +#include "html/html_document.h" +#include "html/html_fieldset_element.h" + +#include "core/node.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_FIELDSET_ELEMENT + }, + DOM_HTML_FIELDSET_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_field_set_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_field_set_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_field_set_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_field_set_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_field_set_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_field_set_element object + * + * \param doc The document object + * \param ele The dom_html_field_set_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_field_set_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_field_set_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_FIELDSET], + namespace, prefix); +} + +/** + * Finalise a dom_html_field_set_element object + * + * \param ele The dom_html_field_set_element object + */ +void _dom_html_field_set_element_finalise(struct dom_html_field_set_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_field_set_element object + * + * \param ele The dom_html_field_set_element object + */ +void _dom_html_field_set_element_destroy(struct dom_html_field_set_element *ele) +{ + _dom_html_field_set_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_field_set_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_field_set_element_destroy(dom_node_internal *node) +{ + _dom_html_field_set_element_destroy((struct dom_html_field_set_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_field_set_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/** + * Get the dom_html_form_element object + * + * \param field_set The dom_html_legend_element object + * \param form The returned dom_html_form_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ + +dom_exception dom_html_field_set_element_get_form( + dom_html_field_set_element *field_set, dom_html_form_element **form) +{ + dom_html_document *doc = + (dom_html_document *) ((dom_node_internal *) field_set)->owner; + dom_node_internal *form_tmp = ((dom_node_internal *) field_set)->parent; + + /* Search ancestor chain for FIELDSET element */ + while (form_tmp != NULL) { + if (form_tmp->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(form_tmp->name, + doc->memoised[hds_FORM])) + break; + + form_tmp = form_tmp->parent; + } + + if (form_tmp != NULL) { + *form = (dom_html_form_element *) form_tmp; + return DOM_NO_ERR; + } + + *form = NULL; + + return DOM_NO_ERR; +} diff --git a/src/html/html_fieldset_element.h b/src/html/html_fieldset_element.h index 2e182d5..8ae1d59 100644 --- a/src/html/html_fieldset_element.h +++ b/src/html/html_fieldset_element.h @@ -3,5 +3,51 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_field_set_element_h_ +#define dom_internal_html_field_set_element_h_ + +#include <dom/html/html_fieldset_element.h> + +#include "html/html_element.h" + +struct dom_html_field_set_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_field_set_element object */ +dom_exception _dom_html_field_set_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_field_set_element **ele); + +/* Initialise a dom_html_field_set_element object */ +dom_exception _dom_html_field_set_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_field_set_element *ele); + +/* Finalise a dom_html_field_set_element object */ +void _dom_html_field_set_element_finalise(struct dom_html_field_set_element *ele); + +/* Destroy a dom_html_field_set_element object */ +void _dom_html_field_set_element_destroy(struct dom_html_field_set_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_field_set_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_field_set_element_destroy(dom_node_internal *node); +dom_exception _dom_html_field_set_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_FIELDSET_ELEMENT_PROTECT_VTABLE \ + _dom_html_field_set_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_FIELDSET_ELEMENT \ + _dom_virtual_html_field_set_element_destroy, \ + _dom_html_field_set_element_copy + +#endif + diff --git a/src/html/html_font_element.c b/src/html/html_font_element.c index 2e182d5..aadcb22 100644 --- a/src/html/html_font_element.c +++ b/src/html/html_font_element.c @@ -3,5 +3,162 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_font_element.h> + +#include "html/html_document.h" +#include "html/html_font_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_FONT_ELEMENT + }, + DOM_HTML_FONT_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_font_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_font_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_font_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_font_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_font_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_font_element object + * + * \param doc The document object + * \param ele The dom_html_font_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_font_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_font_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_FONT], + namespace, prefix); +} + +/** + * Finalise a dom_html_font_element object + * + * \param ele The dom_html_font_element object + */ +void _dom_html_font_element_finalise(struct dom_html_font_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_font_element object + * + * \param ele The dom_html_font_element object + */ +void _dom_html_font_element_destroy(struct dom_html_font_element *ele) +{ + _dom_html_font_element_finalise(ele); + free(ele); +} + + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_font_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_font_element_destroy(dom_node_internal *node) +{ + _dom_html_font_element_destroy((struct dom_html_font_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_font_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_font_element_get_##attr( \ + dom_html_font_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_font_element_set_##attr( \ + dom_html_font_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(color); +SIMPLE_GET_SET(face); +SIMPLE_GET_SET(size); diff --git a/src/html/html_font_element.h b/src/html/html_font_element.h index 2e182d5..42a2ec4 100644 --- a/src/html/html_font_element.h +++ b/src/html/html_font_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_font_element_h_ +#define dom_internal_html_font_element_h_ + +#include <dom/html/html_font_element.h> +#include "html/html_element.h" + + +struct dom_html_font_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_font_element object */ +dom_exception _dom_html_font_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_font_element **ele); + +/* Initialise a dom_html_font_element object */ +dom_exception _dom_html_font_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_font_element *ele); + +/* Finalise a dom_html_font_element object */ +void _dom_html_font_element_finalise(struct dom_html_font_element *ele); + +/* Destroy a dom_html_font_element object */ +void _dom_html_font_element_destroy(struct dom_html_font_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_font_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_font_element_destroy(dom_node_internal *node); +dom_exception _dom_html_font_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_FONT_ELEMENT_PROTECT_VTABLE \ + _dom_html_font_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_FONT_ELEMENT \ + _dom_virtual_html_font_element_destroy, \ + _dom_html_font_element_copy + +#endif diff --git a/src/html/html_form_element.c b/src/html/html_form_element.c index 333cf74..0606ba6 100644 --- a/src/html/html_form_element.c +++ b/src/html/html_form_element.c @@ -281,7 +281,7 @@ static bool _dom_is_form_control(struct dom_node_internal *node, void *ctx) assert(node->type == DOM_ELEMENT_NODE); - /* Form controls are INPUT TEXTAREA SELECT and BUTTON */ + /* Form controls are INPUT TEXTAREA SELECT and BUTTON*/ if (dom_string_caseless_isequal(node->name, doc->memoised[hds_INPUT])) return ((dom_html_input_element *)node)->form == form; diff --git a/src/html/html_frame_element.c b/src/html/html_frame_element.c index 2e182d5..16534b5 100644 --- a/src/html/html_frame_element.c +++ b/src/html/html_frame_element.c @@ -3,5 +3,285 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_frame_element.h> + +#include "html/html_document.h" +#include "html/html_frame_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_FRAME_ELEMENT + }, + DOM_HTML_FRAME_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_frame_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_frame_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_frame_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_frame_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_frame_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_frame_element object + * + * \param doc The document object + * \param ele The dom_html_frame_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_frame_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_frame_element *ele) +{ + dom_string *scrolling_default = NULL; + dom_exception err; + err = dom_string_create((const uint8_t *) "auto", SLEN("auto"), &scrolling_default); + if (err != DOM_NO_ERR) + return err; + + + dom_string *frame_border_default = NULL; + err = dom_string_create((const uint8_t *) "1", SLEN("1"), &frame_border_default); + if (err != DOM_NO_ERR) + return err; + + err = _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_FRAME], + namespace, prefix); + + ele->scrolling_default = scrolling_default; + ele->frame_border_default = frame_border_default; + + return err; +} + +/** + * Finalise a dom_html_frame_element object + * + * \param ele The dom_html_frame_element object + */ +void _dom_html_frame_element_finalise(struct dom_html_frame_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_frame_element object + * + * \param ele The dom_html_frame_element object + */ +void _dom_html_frame_element_destroy(struct dom_html_frame_element *ele) +{ + _dom_html_frame_element_finalise(ele); + free(ele); +} + +/** + * Get the no_resize property + * + * \param ele The dom_html_frame_element object + * \param no_resize The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_frame_element_get_no_resize(dom_html_frame_element *ele, + bool *no_resize) +{ + return dom_html_element_get_bool_property(&ele->base, "noresize", + SLEN("noresize"), no_resize); +} + +/** + * Set the no_resize property + * + * \param ele The dom_html_frame_element object + * \param no_resize The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_frame_element_set_no_resize(dom_html_frame_element *ele, + bool no_resize) +{ + return dom_html_element_set_bool_property(&ele->base, "noresize", + SLEN("noresize"), no_resize); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_frame_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_frame_element_destroy(dom_node_internal *node) +{ + _dom_html_frame_element_destroy((struct dom_html_frame_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_frame_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_frame_element_get_##attr( \ + dom_html_frame_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_frame_element_set_##attr( \ + dom_html_frame_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(long_desc); +SIMPLE_GET_SET(name); +SIMPLE_GET_SET(src); +SIMPLE_SET(frame_border); +SIMPLE_GET_SET(margin_width); +SIMPLE_GET_SET(margin_height); +SIMPLE_SET(scrolling); + + +/** + * Get the frame_border property + * + * \param ele The dom_html_frame_element object + * \param frame_border The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_frame_element_get_frame_border( + dom_html_frame_element *ele, + dom_string **frame_border) +{ + dom_html_document *doc; + bool has_value = false; + dom_exception err; + + doc = (dom_html_document *) ((dom_node_internal *) ele)->owner; + + err = dom_element_has_attribute(ele, + doc->memoised[hds_frame_border], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) { + return dom_element_get_attribute(ele, + doc->memoised[hds_frame_border], frame_border); + } + + *frame_border = ele->frame_border_default; + if (*frame_border != NULL) + dom_string_ref(*frame_border); + return DOM_NO_ERR; +} + +/** + * Get the frame_border property + * + * \param ele The dom_html_frame_element object + * \param scrolling The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_frame_element_get_scrolling( + dom_html_frame_element *ele, + dom_string **scrolling) +{ + dom_html_document *doc; + bool has_value = false; + dom_exception err; + + doc = (dom_html_document *) ((dom_node_internal *) ele)->owner; + + err = dom_element_has_attribute(ele, + doc->memoised[hds_scrolling], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) { + return dom_element_get_attribute(ele, + doc->memoised[hds_scrolling], scrolling); + } + + *scrolling = ele->scrolling_default; + if (*scrolling != NULL) + dom_string_ref(*scrolling); + return DOM_NO_ERR; +} + +dom_exception dom_html_frame_element_get_content_document( + dom_html_frame_element *ele, + dom_document **content_document) +{ + *content_document = dom_node_get_owner(ele); + return DOM_NO_ERR; +} diff --git a/src/html/html_frame_element.h b/src/html/html_frame_element.h index 2e182d5..c313cbc 100644 --- a/src/html/html_frame_element.h +++ b/src/html/html_frame_element.h @@ -3,5 +3,52 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_frame_element_h_ +#define dom_internal_html_frame_element_h_ + +#include <dom/html/html_frame_element.h> +#include "html/html_element.h" + + +struct dom_html_frame_element { + struct dom_html_element base; + /**< The base class */ + dom_string *scrolling_default; + dom_string *frame_border_default; +}; + +/* Create a dom_html_frame_element object */ +dom_exception _dom_html_frame_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_frame_element **ele); + +/* Initialise a dom_html_frame_element object */ +dom_exception _dom_html_frame_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_frame_element *ele); + +/* Finalise a dom_html_frame_element object */ +void _dom_html_frame_element_finalise(struct dom_html_frame_element *ele); + +/* Destroy a dom_html_frame_element object */ +void _dom_html_frame_element_destroy(struct dom_html_frame_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_frame_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_frame_element_destroy(dom_node_internal *node); +dom_exception _dom_html_frame_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_FRAME_ELEMENT_PROTECT_VTABLE \ + _dom_html_frame_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_FRAME_ELEMENT \ + _dom_virtual_html_frame_element_destroy, \ + _dom_html_frame_element_copy + +#endif diff --git a/src/html/html_frameset_element.c b/src/html/html_frameset_element.c index 2e182d5..b096156 100644 --- a/src/html/html_frameset_element.c +++ b/src/html/html_frameset_element.c @@ -3,5 +3,234 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> +#include <dom/html/html_frameset_element.h> + +#include "html/html_document.h" +#include "html/html_frameset_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_FRAME_SET_ELEMENT + }, + DOM_HTML_FRAME_SET_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_frame_set_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_frame_set_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_frame_set_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_frame_set_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_frame_set_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_frame_set_element object + * + * \param doc The document object + * \param ele The dom_html_frame_set_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_frame_set_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_frame_set_element *ele) +{ + dom_string *cols_rows_default = NULL; + dom_exception err; + err = dom_string_create((const uint8_t *) "100%", SLEN("100%"), &cols_rows_default); + if (err != DOM_NO_ERR) + return err; + + err = _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_FRAMESET], + namespace, prefix); + ele->cols_rows_default = cols_rows_default; + return err; +} + +/** + * Finalise a dom_html_frame_set_element object + * + * \param ele The dom_html_frame_set_element object + */ +void _dom_html_frame_set_element_finalise(struct dom_html_frame_set_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_frame_set_element object + * + * \param ele The dom_html_frame_set_element object + */ +void _dom_html_frame_set_element_destroy(struct dom_html_frame_set_element *ele) +{ + _dom_html_frame_set_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_frame_set_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_frame_set_element_destroy(dom_node_internal *node) +{ + _dom_html_frame_set_element_destroy((struct dom_html_frame_set_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_frame_set_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_frame_set_element_get_##attr( \ + dom_html_frame_set_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_frame_set_element_set_##attr( \ + dom_html_frame_set_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_SET(rows); +SIMPLE_SET(cols); + +/** + * Get the rows property + * + * \param ele The dom_html_frame_set_element object + * \param rows The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_frame_set_element_get_rows( + dom_html_frame_set_element *ele, + dom_string **rows) +{ + dom_html_document *doc; + bool has_value = false; + dom_exception err; + + doc = (dom_html_document *) ((dom_node_internal *) ele)->owner; + + err = dom_element_has_attribute(ele, + doc->memoised[hds_rows], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) { + return dom_element_get_attribute(ele, + doc->memoised[hds_rows], rows); + } + + *rows = ele->cols_rows_default; + if (*rows != NULL) + dom_string_ref(*rows); + + return DOM_NO_ERR; +} + +/** + * Get the cols property + * + * \param ele The dom_html_frame_set_element object + * \param cols The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_frame_set_element_get_cols( + dom_html_frame_set_element *ele, + dom_string **cols) +{ + dom_html_document *doc; + bool has_value = false; + dom_exception err; + + doc = (dom_html_document *) ((dom_node_internal *) ele)->owner; + + err = dom_element_has_attribute(ele, + doc->memoised[hds_cols], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) { + return dom_element_get_attribute(ele, + doc->memoised[hds_cols], cols); + } + + *cols = ele->cols_rows_default; + if (*cols != NULL) + dom_string_ref(*cols); + return DOM_NO_ERR; +} diff --git a/src/html/html_frameset_element.h b/src/html/html_frameset_element.h index 2e182d5..fd1c255 100644 --- a/src/html/html_frameset_element.h +++ b/src/html/html_frameset_element.h @@ -3,5 +3,51 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_frame_set_element_h_ +#define dom_internal_html_frame_set_element_h_ + +#include <dom/html/html_frameset_element.h> +#include "html/html_element.h" + + +struct dom_html_frame_set_element { + struct dom_html_element base; + /**< The base class */ + dom_string *cols_rows_default; +}; + +/* Create a dom_html_frame_set_element object */ +dom_exception _dom_html_frame_set_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_frame_set_element **ele); + +/* Initialise a dom_html_frame_set_element object */ +dom_exception _dom_html_frame_set_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_frame_set_element *ele); + +/* Finalise a dom_html_frame_set_element object */ +void _dom_html_frame_set_element_finalise(struct dom_html_frame_set_element *ele); + +/* Destroy a dom_html_frame_set_element object */ +void _dom_html_frame_set_element_destroy(struct dom_html_frame_set_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_frame_set_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_frame_set_element_destroy(dom_node_internal *node); +dom_exception _dom_html_frame_set_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_FRAME_SET_ELEMENT_PROTECT_VTABLE \ + _dom_html_frame_set_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_FRAME_SET_ELEMENT \ + _dom_virtual_html_frame_set_element_destroy, \ + _dom_html_frame_set_element_copy + +#endif diff --git a/src/html/html_heading_element.c b/src/html/html_heading_element.c index 2e182d5..ba2842f 100644 --- a/src/html/html_heading_element.c +++ b/src/html/html_heading_element.c @@ -3,5 +3,161 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_heading_element.h> + +#include "html/html_document.h" +#include "html/html_heading_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_HEADING_ELEMENT + }, + DOM_HTML_HEADING_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_heading_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_heading_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, + dom_string *prefix, struct dom_html_heading_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_heading_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_heading_element_initialise(doc, + tag_name, namespace, + prefix, *ele); +} + +/** + * Initialise a dom_html_heading_element object + * + * \param doc The document object + * \param ele The dom_html_heading_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_heading_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, + dom_string *prefix, struct dom_html_heading_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + tag_name, namespace, + prefix); +} + +/** + * Finalise a dom_html_heading_element object + * + * \param ele The dom_html_heading_element object + */ +void _dom_html_heading_element_finalise(struct dom_html_heading_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_heading_element object + * + * \param ele The dom_html_heading_element object + */ +void _dom_html_heading_element_destroy(struct dom_html_heading_element *ele) +{ + _dom_html_heading_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_heading_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_heading_element_destroy(dom_node_internal *node) +{ + _dom_html_heading_element_destroy((struct dom_html_heading_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_heading_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_heading_element_get_##attr( \ + dom_html_heading_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_heading_element_set_##attr( \ + dom_html_heading_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(align); diff --git a/src/html/html_heading_element.h b/src/html/html_heading_element.h index 2e182d5..fdd1c25 100644 --- a/src/html/html_heading_element.h +++ b/src/html/html_heading_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_heading_element_h_ +#define dom_internal_html_heading_element_h_ + +#include <dom/html/html_heading_element.h> +#include "html/html_element.h" + + +struct dom_html_heading_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_heading_element object */ +dom_exception _dom_html_heading_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, + dom_string *prefix, struct dom_html_heading_element **ele); + +/* Initialise a dom_html_heading_element object */ +dom_exception _dom_html_heading_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, + dom_string *prefix, struct dom_html_heading_element *ele); + +/* Finalise a dom_html_heading_element object */ +void _dom_html_heading_element_finalise(struct dom_html_heading_element *ele); + +/* Destroy a dom_html_heading_element object */ +void _dom_html_heading_element_destroy(struct dom_html_heading_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_heading_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_heading_element_destroy(dom_node_internal *node); +dom_exception _dom_html_heading_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_HEADING_ELEMENT_PROTECT_VTABLE \ + _dom_html_heading_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_HEADING_ELEMENT \ + _dom_virtual_html_heading_element_destroy, \ + _dom_html_heading_element_copy + +#endif diff --git a/src/html/html_iframe_element.c b/src/html/html_iframe_element.c index 2e182d5..6f15b3e 100644 --- a/src/html/html_iframe_element.c +++ b/src/html/html_iframe_element.c @@ -3,5 +3,267 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_iframe_element.h> + +#include "html/html_document.h" +#include "html/html_iframe_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_IFRAME_ELEMENT + }, + DOM_HTML_IFRAME_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_iframe_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_iframe_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_iframe_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_iframe_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_iframe_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_iframe_element object + * + * \param doc The document object + * \param ele The dom_html_iframe_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_iframe_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_iframe_element *ele) +{ + dom_string *scrolling_default = NULL; + dom_exception err; + err = dom_string_create((const uint8_t *) "auto", SLEN("auto"), &scrolling_default); + if (err != DOM_NO_ERR) + return err; + + + dom_string *frame_border_default = NULL; + err = dom_string_create((const uint8_t *) "1", SLEN("1"), &frame_border_default); + if (err != DOM_NO_ERR) + return err; + + err = _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_IFRAME], + namespace, prefix); + + ele->scrolling_default = scrolling_default; + ele->frame_border_default = frame_border_default; + + return err; +} + +/** + * Finalise a dom_html_iframe_element object + * + * \param ele The dom_html_iframe_element object + */ +void _dom_html_iframe_element_finalise(struct dom_html_iframe_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_iframe_element object + * + * \param ele The dom_html_iframe_element object + */ +void _dom_html_iframe_element_destroy(struct dom_html_iframe_element *ele) +{ + _dom_html_iframe_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_iframe_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_iframe_element_destroy(dom_node_internal *node) +{ + _dom_html_iframe_element_destroy((struct dom_html_iframe_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_iframe_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_iframe_element_get_##attr( \ + dom_html_iframe_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_iframe_element_set_##attr( \ + dom_html_iframe_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(long_desc); +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(name); +SIMPLE_GET_SET(src); +SIMPLE_GET_SET(margin_width); +SIMPLE_GET_SET(margin_height); +SIMPLE_SET(scrolling); +SIMPLE_SET(frame_border); +SIMPLE_GET_SET(width); +SIMPLE_GET_SET(height); + + +/** + * Get the frame_border property + * + * \param ele The dom_html_iframe_element object + * \param iframe_border The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_iframe_element_get_frame_border( + dom_html_iframe_element *ele, + dom_string **frame_border) +{ + dom_html_document *doc; + bool has_value = false; + dom_exception err; + + doc = (dom_html_document *) ((dom_node_internal *) ele)->owner; + + err = dom_element_has_attribute(ele, + doc->memoised[hds_frame_border], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) { + return dom_element_get_attribute(ele, + doc->memoised[hds_frame_border], frame_border); + } + + *frame_border = ele->frame_border_default; + if (*frame_border != NULL) + dom_string_ref(*frame_border); + return DOM_NO_ERR; +} + +/** + * Get the frame_border property + * + * \param ele The dom_html_iframe_element object + * \param scrolling The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_iframe_element_get_scrolling( + dom_html_iframe_element *ele, + dom_string **scrolling) +{ + dom_html_document *doc; + bool has_value = false; + dom_exception err; + + doc = (dom_html_document *) ((dom_node_internal *) ele)->owner; + + err = dom_element_has_attribute(ele, + doc->memoised[hds_scrolling], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) { + return dom_element_get_attribute(ele, + doc->memoised[hds_scrolling], scrolling); + } + + *scrolling = ele->scrolling_default; + if (*scrolling != NULL) + dom_string_ref(*scrolling); + return DOM_NO_ERR; +} + +/** + * Get the frame_border property + * + * \param ele The dom_html_iframe_element object + * \param content_document The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_iframe_element_get_content_document( + dom_html_iframe_element *ele, + dom_document **content_document) +{ + *content_document = dom_node_get_owner(ele); + return DOM_NO_ERR; +} diff --git a/src/html/html_iframe_element.h b/src/html/html_iframe_element.h index 2e182d5..dafc9e1 100644 --- a/src/html/html_iframe_element.h +++ b/src/html/html_iframe_element.h @@ -3,5 +3,53 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_iframe_element_h_ +#define dom_internal_html_iframe_element_h_ + +#include <dom/html/html_iframe_element.h> +#include "html/html_element.h" + + +struct dom_html_iframe_element { + struct dom_html_element base; + /**< The base class */ + dom_string *scrolling_default; + dom_string *frame_border_default; +}; + +/* Create a dom_html_iframe_element object */ +dom_exception _dom_html_iframe_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_iframe_element **ele); + +/* Initialise a dom_html_iframe_element object */ +dom_exception _dom_html_iframe_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_iframe_element *ele); + +/* Finalise a dom_html_iframe_element object */ +void _dom_html_iframe_element_finalise(struct dom_html_iframe_element *ele); + +/* Destroy a dom_html_iframe_element object */ +void _dom_html_iframe_element_destroy(struct dom_html_iframe_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_iframe_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_iframe_element_destroy(dom_node_internal *node); +dom_exception _dom_html_iframe_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_IFRAME_ELEMENT_PROTECT_VTABLE \ + _dom_html_iframe_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_IFRAME_ELEMENT \ + _dom_virtual_html_iframe_element_destroy, \ + _dom_html_iframe_element_copy + +#endif + diff --git a/src/html/html_image_element.c b/src/html/html_image_element.c index 2e182d5..77bdd27 100644 --- a/src/html/html_image_element.c +++ b/src/html/html_image_element.c @@ -3,5 +3,250 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_image_element.h> + +#include "html/html_document.h" +#include "html/html_image_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_IMAGE_ELEMENT + }, + DOM_HTML_IMAGE_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_image_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_image_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_image_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_image_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_image_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_image_element object + * + * \param doc The document object + * \param ele The dom_html_image_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_image_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_image_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_IMG], + namespace, prefix); +} + +/** + * Finalise a dom_html_image_element object + * + * \param ele The dom_html_image_element object + */ +void _dom_html_image_element_finalise(struct dom_html_image_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_image_element object + * + * \param ele The dom_html_image_element object + */ +void _dom_html_image_element_destroy(struct dom_html_image_element *ele) +{ + _dom_html_image_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_image_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_image_element_destroy(dom_node_internal *node) +{ + _dom_html_image_element_destroy((struct dom_html_image_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_image_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_image_element_get_##attr( \ + dom_html_image_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_image_element_set_##attr( \ + dom_html_image_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(name); +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(alt); +SIMPLE_GET_SET(border); +SIMPLE_GET_SET(long_desc); +SIMPLE_GET_SET(src); +SIMPLE_GET_SET(use_map); + +dom_exception dom_html_image_element_get_height( + dom_html_image_element *image, int32_t *height) +{ + return dom_html_element_get_int32_t_property(&image->base, "height", + SLEN("height"), height); +} + +dom_exception dom_html_image_element_set_height( + dom_html_image_element *image, uint32_t height) +{ + return dom_html_element_set_int32_t_property(&image->base, "height", + SLEN("height"), height); +} + +dom_exception dom_html_image_element_get_hspace( + dom_html_image_element *image, int32_t *hspace) +{ + return dom_html_element_get_int32_t_property(&image->base, "hspace", + SLEN("hspace"), hspace); +} + +dom_exception dom_html_image_element_set_hspace( + dom_html_image_element *image, uint32_t hspace) +{ + return dom_html_element_set_int32_t_property(&image->base, "hspace", + SLEN("hspace"), hspace); +} + +dom_exception dom_html_image_element_get_vspace( + dom_html_image_element *image, int32_t *vspace) +{ + return dom_html_element_get_int32_t_property(&image->base, "vspace", + SLEN("cspace"), vspace); +} + +dom_exception dom_html_image_element_set_vspace( + dom_html_image_element *image, uint32_t vspace) +{ + return dom_html_element_set_int32_t_property(&image->base, "vspace", + SLEN("vsapce"), vspace); +} + +dom_exception dom_html_image_element_get_width( + dom_html_image_element *image, int32_t *width) +{ + return dom_html_element_get_int32_t_property(&image->base, "width", + SLEN("width"), width); +} + +dom_exception dom_html_image_element_set_width( + dom_html_image_element *image, uint32_t width) +{ + return dom_html_element_set_int32_t_property(&image->base, "width", + SLEN("width"), width); +} + +/** + * Get the is_map property + * + * \param ele The dom_html_image_element object + * \param is_map The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_image_element_get_is_map(dom_html_image_element *ele, + bool *is_map) +{ + return dom_html_element_get_bool_property(&ele->base, "ismap", + SLEN("ismap"), is_map); +} + +/** + * Set the is_map property + * + * \param ele The dom_html_image_element object + * \param is_map The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_image_element_set_is_map(dom_html_image_element *ele, + bool is_map) +{ + return dom_html_element_set_bool_property(&ele->base, "ismap", + SLEN("ismap"), is_map); +} + diff --git a/src/html/html_image_element.h b/src/html/html_image_element.h index 2e182d5..ac73a1b 100644 --- a/src/html/html_image_element.h +++ b/src/html/html_image_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_image_element_h_ +#define dom_internal_html_image_element_h_ + +#include <dom/html/html_image_element.h> + +#include "html/html_element.h" + +struct dom_html_image_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_image_element object */ +dom_exception _dom_html_image_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_image_element **ele); + +/* Initialise a dom_html_image_element object */ +dom_exception _dom_html_image_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_image_element *ele); + +/* Finalise a dom_html_image_element object */ +void _dom_html_image_element_finalise(struct dom_html_image_element *ele); + +/* Destroy a dom_html_image_element object */ +void _dom_html_image_element_destroy(struct dom_html_image_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_image_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_image_element_destroy(dom_node_internal *node); +dom_exception _dom_html_image_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_IMAGE_ELEMENT_PROTECT_VTABLE \ + _dom_html_image_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_IMAGE_ELEMENT \ + _dom_virtual_html_image_element_destroy, \ + _dom_html_image_element_copy + +#endif diff --git a/src/html/html_input_element.c b/src/html/html_input_element.c index bab79f2..84079f7 100644 --- a/src/html/html_input_element.c +++ b/src/html/html_input_element.c @@ -65,6 +65,8 @@ dom_exception _dom_html_input_element_initialise(struct dom_html_document *doc, ele->default_checked_set = false; ele->default_value = NULL; ele->default_value_set = false; + ele->checked = false; + ele->checked_set = false; return _dom_html_element_initialise(doc, &ele->base, doc->memoised[hds_INPUT], @@ -166,6 +168,11 @@ dom_exception dom_html_input_element_set_read_only(dom_html_input_element *ele, dom_exception dom_html_input_element_get_checked(dom_html_input_element *ele, bool *checked) { + if(ele->checked_set) { + *checked = ele->checked; + return DOM_NO_ERR; + } + return dom_html_element_get_bool_property(&ele->base, "checked", SLEN("checked"), checked); } @@ -349,12 +356,24 @@ SIMPLE_GET_SET(access_key); SIMPLE_GET_SET(align); SIMPLE_GET_SET(alt); SIMPLE_GET_SET(name); -SIMPLE_GET_SET(size); SIMPLE_GET_SET(src); SIMPLE_GET(type); SIMPLE_GET_SET(use_map); SIMPLE_GET_SET(value); +dom_exception dom_html_input_element_get_size( + dom_html_input_element *input, int32_t *size) +{ + return dom_html_element_get_int32_t_property(&input->base, "size", + SLEN("size"), size); +} + +dom_exception dom_html_input_element_set_size( + dom_html_input_element *input, uint32_t size) +{ + return dom_html_element_set_int32_t_property(&input->base, "size", + SLEN("size"), size); +} dom_exception dom_html_input_element_get_tab_index( dom_html_input_element *input, int32_t *tab_index) { @@ -435,11 +454,11 @@ dom_exception dom_html_input_element_focus(dom_html_input_element *ele) bool success = false; assert(doc != NULL); - /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ + /** \this event doesnt bubble and is non-cancelable src:wikipedia*/ return _dom_dispatch_generic_event((dom_document *)doc, (dom_event_target *) ele, - doc->memoised[hds_focus], true, - true, &success); + doc->memoised[hds_focus], false, + false, &success); } /** @@ -455,11 +474,11 @@ dom_exception dom_html_input_element_select(dom_html_input_element *ele) bool success = false; assert(doc != NULL); - /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ + /** \this event bubbles and non-cancelable src:wikipedia*/ return _dom_dispatch_generic_event((dom_document *)doc, (dom_event_target *) ele, doc->memoised[hds_select], true, - true, &success); + false, &success); } /** @@ -473,13 +492,21 @@ dom_exception dom_html_input_element_click(dom_html_input_element *ele) struct dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); bool success = false; + dom_exception err; assert(doc != NULL); - /** \todo Is this is meant to check/uncheck boxes, radios etc */ - /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ - return _dom_dispatch_generic_event((dom_document *)doc, + + /** \This event bubbles & is cancelable src:Wikipedia*/ + err = _dom_dispatch_generic_event((dom_document *)doc, (dom_event_target *) ele, doc->memoised[hds_click], true, true, &success); + if(err != DOM_NO_ERR) + return err; + + ele->checked = true; + ele->checked_set = true; + + return DOM_NO_ERR; } diff --git a/src/html/html_input_element.h b/src/html/html_input_element.h index 72c7d51..b818b2e 100644 --- a/src/html/html_input_element.h +++ b/src/html/html_input_element.h @@ -21,6 +21,8 @@ struct dom_html_input_element { bool default_checked_set; /**< Whether default_checked has been set */ dom_string *default_value; /**< Initial value */ bool default_value_set; /**< Whether default_value has been set */ + bool checked; /**< Whether the element has been checked by a click */ + bool checked_set; }; /* Create a dom_html_input_element object */ diff --git a/src/html/html_isindex_element.c b/src/html/html_isindex_element.c index 6dc96b9..e79e011 100644 --- a/src/html/html_isindex_element.c +++ b/src/html/html_isindex_element.c @@ -7,9 +7,13 @@ #include <stdlib.h> +#include <dom/html/html_isindex_element.h> + +#include "html/html_document.h" #include "html/html_isindex_element.h" #include "core/node.h" +#include "core/attr.h" #include "utils/utils.h" static struct dom_element_protected_vtable _protect_vtable = { @@ -22,55 +26,41 @@ static struct dom_element_protected_vtable _protect_vtable = { /** * Create a dom_html_isindex_element object * - * \param doc The document object - * \param form The form element which contains this element - * \param ele The returned element object + * \param doc The document object + * \param ele The returned element object * \return DOM_NO_ERR on success, appropriate dom_exception on failure. */ dom_exception _dom_html_isindex_element_create(struct dom_html_document *doc, - struct dom_html_form_element *form, + dom_string *namespace, dom_string *prefix, struct dom_html_isindex_element **ele) { struct dom_node_internal *node; - *ele = malloc(sizeof(dom_html_isindex_element)); if (*ele == NULL) return DOM_NO_MEM_ERR; - + /* Set up vtables */ node = (struct dom_node_internal *) *ele; node->base.vtable = &_dom_html_element_vtable; node->vtable = &_protect_vtable; - return _dom_html_isindex_element_initialise(doc, form, *ele); + return _dom_html_isindex_element_initialise(doc, namespace, prefix, *ele); } /** * Initialise a dom_html_isindex_element object * - * \param doc The document object - * \param form The form element which contains this element - * \param ele The dom_html_isindex_element object + * \param doc The document object + * \param ele The dom_html_isindex_element object * \return DOM_NO_ERR on success, appropriate dom_exception on failure. */ dom_exception _dom_html_isindex_element_initialise(struct dom_html_document *doc, - struct dom_html_form_element *form, + dom_string *namespace, dom_string *prefix, struct dom_html_isindex_element *ele) { - dom_string *name = NULL; - dom_exception err; - - UNUSED(form); - - err = dom_string_create((const uint8_t *) "ISINDEX", SLEN("ISINDEX"), - &name); - if (err != DOM_NO_ERR) - return err; - - err = _dom_html_element_initialise(doc, &ele->base, name, NULL, NULL); - dom_string_unref(name); - - return err; + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_ISINDEX], + namespace, prefix); } /** @@ -125,7 +115,46 @@ dom_exception _dom_html_isindex_element_copy(dom_node_internal *old, return _dom_html_element_copy(old, copy); } - +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_isindex_element_get_##attr( \ + dom_html_isindex_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_isindex_element_set_##attr( \ + dom_html_isindex_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(prompt); /*-----------------------------------------------------------------------*/ /* Public APIs */ diff --git a/src/html/html_isindex_element.h b/src/html/html_isindex_element.h index 12ad26e..a39170b 100644 --- a/src/html/html_isindex_element.h +++ b/src/html/html_isindex_element.h @@ -19,12 +19,12 @@ struct dom_html_isindex_element { /* Create a dom_html_isindex_element object */ dom_exception _dom_html_isindex_element_create(struct dom_html_document *doc, - struct dom_html_form_element *form, + dom_string *namespace, dom_string *prefix, struct dom_html_isindex_element **ele); /* Initialise a dom_html_isindex_element object */ dom_exception _dom_html_isindex_element_initialise(struct dom_html_document *doc, - struct dom_html_form_element *form, + dom_string *namespace, dom_string *prefix, struct dom_html_isindex_element *ele); /* Finalise a dom_html_isindex_element object */ diff --git a/src/html/html_label_element.c b/src/html/html_label_element.c index 2e182d5..1ffbf71 100644 --- a/src/html/html_label_element.c +++ b/src/html/html_label_element.c @@ -3,5 +3,192 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include "html/html_document.h" +#include "html/html_label_element.h" + +#include "core/node.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_LABEL_ELEMENT + }, + DOM_HTML_LABEL_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_label_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_label_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_label_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_label_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_label_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_label_element object + * + * \param doc The document object + * \param ele The dom_html_label_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_label_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_label_element *ele) +{ + ele->form = NULL; + + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_LABEL], + namespace, prefix); +} + +/** + * Finalise a dom_html_label_element object + * + * \param ele The dom_html_label_element object + */ +void _dom_html_label_element_finalise(struct dom_html_label_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_label_element object + * + * \param ele The dom_html_label_element object + */ +void _dom_html_label_element_destroy(struct dom_html_label_element *ele) +{ + _dom_html_label_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_label_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_label_element_destroy(dom_node_internal *node) +{ + _dom_html_label_element_destroy((struct dom_html_label_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_label_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/** + * Get the dom_html_form_element object + * + * \param label The dom_html_label_element object + * \param form The returned dom_htmlform_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_label_element_get_form( + dom_html_label_element *label, dom_html_form_element **form) +{ + dom_html_document *doc + = (dom_html_document *) ((dom_node_internal *) label)->owner; + dom_node_internal *form_tmp = ((dom_node_internal *) label)->parent; + + /* Search ancestor chain for FIELDSET element */ + while (form_tmp != NULL) { + if (form_tmp->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(form_tmp->name, + doc->memoised[hds_FORM])) + break; + + form_tmp = form_tmp->parent; + } + + if (form_tmp != NULL) { + *form = (dom_html_form_element *) form_tmp; + return DOM_NO_ERR; + } + + *form = NULL; + + return DOM_NO_ERR; +} +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_label_element_get_##attr( \ + dom_html_label_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_label_element_set_##attr( \ + dom_html_label_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(access_key); +SIMPLE_GET_SET(html_for); + diff --git a/src/html/html_label_element.h b/src/html/html_label_element.h index 2e182d5..e28b453 100644 --- a/src/html/html_label_element.h +++ b/src/html/html_label_element.h @@ -3,5 +3,52 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_label_element_h_ +#define dom_internal_html_label_element_h_ + +#include <dom/html/html_label_element.h> +#include "html/html_element.h" + + +struct dom_html_label_element { + struct dom_html_element base; + /**< The base class */ + dom_html_form_element *form; + /**< The form associated with label */ +}; + +/* Create a dom_html_label_element object */ +dom_exception _dom_html_label_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_label_element **ele); + +/* Initialise a dom_html_label_element object */ +dom_exception _dom_html_label_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_label_element *ele); + +/* Finalise a dom_html_label_element object */ +void _dom_html_label_element_finalise(struct dom_html_label_element *ele); + +/* Destroy a dom_html_label_element object */ +void _dom_html_label_element_destroy(struct dom_html_label_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_label_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_label_element_destroy(dom_node_internal *node); +dom_exception _dom_html_label_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_LABEL_ELEMENT_PROTECT_VTABLE \ + _dom_html_label_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_LABEL_ELEMENT \ + _dom_virtual_html_label_element_destroy, \ + _dom_html_label_element_copy + +#endif diff --git a/src/html/html_legend_element.c b/src/html/html_legend_element.c index 2e182d5..2d0e939 100644 --- a/src/html/html_legend_element.c +++ b/src/html/html_legend_element.c @@ -3,5 +3,213 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_legend_element.h> +#include <dom/html/html_fieldset_element.h> + +#include "html/html_document.h" +#include "html/html_legend_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_LEGEND_ELEMENT + }, + DOM_HTML_LEGEND_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_legend_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_legend_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_legend_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_legend_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_legend_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_legend_element object + * + * \param doc The document object + * \param ele The dom_html_legend_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_legend_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_legend_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_LEGEND], + namespace, prefix); +} + +/** + * Finalise a dom_html_legend_element object + * + * \param ele The dom_html_legend_element object + */ +void _dom_html_legend_element_finalise(struct dom_html_legend_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_legend_element object + * + * \param ele The dom_html_legend_element object + */ +void _dom_html_legend_element_destroy(struct dom_html_legend_element *ele) +{ + _dom_html_legend_element_finalise(ele); + free(ele); +} + +/** + * Get the dom_html_form_element object + * + * \param legend The dom_html_legend_element object + * \param form The returned dom_html_form_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_legend_element_get_form( + dom_html_legend_element *legend, dom_html_form_element **form) +{ + dom_html_document *doc + = (dom_html_document *) ((dom_node_internal *) legend)->owner; + dom_node_internal *field_set = ((dom_node_internal *) legend)->parent; + + /* Search ancestor chain for FIELDSET element */ + while (field_set != NULL) { + if (field_set->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(field_set->name, + doc->memoised[hds_FIELDSET])) + break; + + field_set = field_set->parent; + } + + if (field_set != NULL) { + return dom_html_field_set_element_get_form((dom_html_field_set_element *) field_set, + form); + } + + *form = NULL; + + return DOM_NO_ERR; +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_legend_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_legend_element_destroy(dom_node_internal *node) +{ + _dom_html_legend_element_destroy((struct dom_html_legend_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_legend_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_legend_element_get_##attr( \ + dom_html_legend_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_legend_element_set_##attr( \ + dom_html_legend_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(access_key); +SIMPLE_SET(align); + +dom_exception dom_html_legend_element_get_align( + dom_html_legend_element *legend, dom_string **align) +{ + dom_exception err; + dom_html_document *doc = (dom_html_document *) + ((dom_node_internal *)legend)->owner; + err = dom_element_get_attribute(legend, + doc->memoised[hds_align], align); + if (err != DOM_NO_ERR) + return err; + + if (*align == NULL) { + err = dom_string_create((const uint8_t *) "none", SLEN("none"), align); + } + + return err; +} + diff --git a/src/html/html_legend_element.h b/src/html/html_legend_element.h index 2e182d5..a656ae4 100644 --- a/src/html/html_legend_element.h +++ b/src/html/html_legend_element.h @@ -3,5 +3,51 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_legend_element_h_ +#define dom_internal_html_legend_element_h_ + +#include <dom/html/html_legend_element.h> +#include "html/html_element.h" + + +struct dom_html_legend_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_legend_element object */ +dom_exception _dom_html_legend_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_legend_element **ele); + +/* Initialise a dom_html_legend_element object */ +dom_exception _dom_html_legend_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_legend_element *ele); + +/* Finalise a dom_html_legend_element object */ +void _dom_html_legend_element_finalise(struct dom_html_legend_element *ele); + +/* Destroy a dom_html_legend_element object */ +void _dom_html_legend_element_destroy(struct dom_html_legend_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_legend_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_legend_element_destroy(dom_node_internal *node); +dom_exception _dom_html_legend_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_LEGEND_ELEMENT_PROTECT_VTABLE \ + _dom_html_legend_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_LEGEND_ELEMENT \ + _dom_virtual_html_legend_element_destroy, \ + _dom_html_legend_element_copy + +#endif + diff --git a/src/html/html_li_element.c b/src/html/html_li_element.c index 2e182d5..ca265ae 100644 --- a/src/html/html_li_element.c +++ b/src/html/html_li_element.c @@ -3,5 +3,182 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> +#include <dom/html/html_li_element.h> + +#include "html/html_document.h" +#include "html/html_li_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_LI_ELEMENT + }, + DOM_HTML_LI_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_li_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_li_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *lifix, + struct dom_html_li_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_li_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_li_element_initialise(doc, namespace, lifix, *ele); +} + +/** + * Initialise a dom_html_li_element object + * + * \param doc The document object + * \param ele The dom_html_li_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_li_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *lifix, + struct dom_html_li_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_LI], + namespace, lifix); +} + +/** + * Finalise a dom_html_li_element object + * + * \param ele The dom_html_li_element object + */ +void _dom_html_li_element_finalise(struct dom_html_li_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_li_element object + * + * \param ele The dom_html_li_element object + */ +void _dom_html_li_element_destroy(struct dom_html_li_element *ele) +{ + _dom_html_li_element_finalise(ele); + free(ele); +} + +/** + * Get the value Property + * + * \param li The dom_html_li_element object + */ +dom_exception dom_html_li_element_get_value( + dom_html_li_element *li, int32_t *value) +{ + return dom_html_element_get_int32_t_property(&li->base, "value", + SLEN("value"), value); +} + +/** + * Set the value Property + * + * \param li The dom_html_li_element object + */ +dom_exception dom_html_li_element_set_value( + dom_html_li_element *li, uint32_t value) +{ + return dom_html_element_set_int32_t_property(&li->base, "value", + SLEN("value"), value); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_li_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_li_element_destroy(dom_node_internal *node) +{ + _dom_html_li_element_destroy((struct dom_html_li_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_li_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_li_element_get_##attr( \ + dom_html_li_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ + dom_exception dom_html_li_element_set_##attr( \ + dom_html_li_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(type); diff --git a/src/html/html_li_element.h b/src/html/html_li_element.h index 2e182d5..c50a2db 100644 --- a/src/html/html_li_element.h +++ b/src/html/html_li_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_li_element_h_ +#define dom_internal_html_li_element_h_ + +#include <dom/html/html_li_element.h> +#include "html/html_element.h" + + +struct dom_html_li_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_li_element object */ +dom_exception _dom_html_li_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *lifix, + struct dom_html_li_element **ele); + +/* Initialise a dom_html_li_element object */ +dom_exception _dom_html_li_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *lifix, + struct dom_html_li_element *ele); + +/* Finalise a dom_html_li_element object */ +void _dom_html_li_element_finalise(struct dom_html_li_element *ele); + +/* Destroy a dom_html_li_element object */ +void _dom_html_li_element_destroy(struct dom_html_li_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_li_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_li_element_destroy(dom_node_internal *node); +dom_exception _dom_html_li_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_LI_ELEMENT_PROTECT_VTABLE \ + _dom_html_li_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_LI_ELEMENT \ + _dom_virtual_html_li_element_destroy, \ + _dom_html_li_element_copy + +#endif diff --git a/src/html/html_map_element.c b/src/html/html_map_element.c index 2e182d5..cf0fe5e 100644 --- a/src/html/html_map_element.c +++ b/src/html/html_map_element.c @@ -3,5 +3,193 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> +#include <dom/html/html_map_element.h> + +#include "html/html_document.h" +#include "html/html_map_element.h" + +#include "html/html_collection.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_MAP_ELEMENT + }, + DOM_HTML_MAP_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_map_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_map_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_map_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_map_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_map_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_map_element object + * + * \param doc The document object + * \param ele The dom_html_map_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_map_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_map_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_MAP], + namespace, prefix); +} + +/** + * Finalise a dom_html_map_element object + * + * \param ele The dom_html_map_element object + */ +void _dom_html_map_element_finalise(struct dom_html_map_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_map_element object + * + * \param ele The dom_html_map_element object + */ +void _dom_html_map_element_destroy(struct dom_html_map_element *ele) +{ + _dom_html_map_element_finalise(ele); + free(ele); +} + + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_map_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_map_element_destroy(dom_node_internal *node) +{ + _dom_html_map_element_destroy((struct dom_html_map_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_map_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_map_element_get_##attr( \ + dom_html_map_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_map_element_set_##attr( \ + dom_html_map_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(name); + +/* The callback function for _dom_html_collection_create*/ +bool callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_AREA])) + { + return true; + } + + return false; +} + +/** + * Get the areas property + * + * \param ele The dom_html_map_element object + * \param areas The returned dom_html_collection object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ + +dom_exception dom_html_map_element_get_areas( + dom_html_map_element *ele, dom_html_collection **areas) +{ + dom_html_document *doc + = (dom_html_document *) ((dom_node_internal *) ele)->owner; + + /*doc is passed as a parameter to callback to avoid repeated calculations */ + return _dom_html_collection_create(doc, (dom_node_internal *) ele, + callback, (void *) doc, areas); +} diff --git a/src/html/html_map_element.h b/src/html/html_map_element.h index 2e182d5..0230808 100644 --- a/src/html/html_map_element.h +++ b/src/html/html_map_element.h @@ -3,5 +3,52 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_map_element_h_ +#define dom_internal_html_map_element_h_ + +#include <dom/html/html_map_element.h> +#include "html/html_element.h" + + +struct dom_html_map_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_map_element object */ +dom_exception _dom_html_map_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_map_element **ele); + +/* Initialise a dom_html_map_element object */ +dom_exception _dom_html_map_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_map_element *ele); + +/* Finalise a dom_html_map_element object */ +void _dom_html_map_element_finalise(struct dom_html_map_element *ele); + +/* Destroy a dom_html_map_element object */ +void _dom_html_map_element_destroy(struct dom_html_map_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_map_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_map_element_destroy(dom_node_internal *node); +dom_exception _dom_html_map_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_MAP_ELEMENT_PROTECT_VTABLE \ + _dom_html_map_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_MAP_ELEMENT \ + _dom_virtual_html_map_element_destroy, \ + _dom_html_map_element_copy + +#endif + +bool callback(struct dom_node_internal *node, void *ctx); diff --git a/src/html/html_menu_element.c b/src/html/html_menu_element.c index 2e182d5..af0f34c 100644 --- a/src/html/html_menu_element.c +++ b/src/html/html_menu_element.c @@ -3,5 +3,145 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_menu_element.h> + +#include "html/html_document.h" +#include "html/html_menu_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_MENU_ELEMENT + }, + DOM_HTML_MENU_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_menu_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_menu_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_menu_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_menu_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_menu_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_menu_element object + * + * \param doc The document object + * \param ele The dom_html_menu_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_menu_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_menu_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_MENU], + namespace, prefix); +} + +/** + * Finalise a dom_html_menu_element object + * + * \param ele The dom_html_menu_element object + */ +void _dom_html_menu_element_finalise(struct dom_html_menu_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_menu_element object + * + * \param ele The dom_html_menu_element object + */ +void _dom_html_menu_element_destroy(struct dom_html_menu_element *ele) +{ + _dom_html_menu_element_finalise(ele); + free(ele); +} + +/** + * Get the compact property + * + * \param ele The dom_html_menu_element object + * \param compact The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_menu_element_get_compact(dom_html_menu_element *ele, + bool *compact) +{ + return dom_html_element_get_bool_property(&ele->base, "compact", + SLEN("compact"), compact); +} + +/** + * Set the compact property + * + * \param ele The dom_html_menu_element object + * \param compact The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_menu_element_set_compact(dom_html_menu_element *ele, + bool compact) +{ + return dom_html_element_set_bool_property(&ele->base, "compact", + SLEN("compact"), compact); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_menu_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_menu_element_destroy(dom_node_internal *node) +{ + _dom_html_menu_element_destroy((struct dom_html_menu_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_menu_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} diff --git a/src/html/html_menu_element.h b/src/html/html_menu_element.h index 2e182d5..cb84e3d 100644 --- a/src/html/html_menu_element.h +++ b/src/html/html_menu_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_menu_element_h_ +#define dom_internal_html_menu_element_h_ + +#include <dom/html/html_menu_element.h> +#include "html/html_element.h" + + +struct dom_html_menu_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_menu_element object */ +dom_exception _dom_html_menu_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_menu_element **ele); + +/* Initialise a dom_html_menu_element object */ +dom_exception _dom_html_menu_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_menu_element *ele); + +/* Finalise a dom_html_menu_element object */ +void _dom_html_menu_element_finalise(struct dom_html_menu_element *ele); + +/* Destroy a dom_html_menu_element object */ +void _dom_html_menu_element_destroy(struct dom_html_menu_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_menu_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_menu_element_destroy(dom_node_internal *node); +dom_exception _dom_html_menu_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_MENU_ELEMENT_PROTECT_VTABLE \ + _dom_html_menu_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_MENU_ELEMENT \ + _dom_virtual_html_menu_element_destroy, \ + _dom_html_menu_element_copy + +#endif diff --git a/src/html/html_mod_element.c b/src/html/html_mod_element.c index 2e182d5..f20a994 100644 --- a/src/html/html_mod_element.c +++ b/src/html/html_mod_element.c @@ -3,5 +3,161 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_mod_element.h> + +#include "html/html_document.h" +#include "html/html_mod_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_MOD_ELEMENT + }, + DOM_HTML_MOD_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_mod_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_mod_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, + dom_string *prefix, struct dom_html_mod_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_mod_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_mod_element_initialise(doc, tag_name, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_mod_element object + * + * \param doc The document object + * \param ele The dom_html_mod_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_mod_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, + dom_string *prefix, struct dom_html_mod_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + tag_name, + namespace, prefix); +} + +/** + * Finalise a dom_html_mod_element object + * + * \param ele The dom_html_mod_element object + */ +void _dom_html_mod_element_finalise(struct dom_html_mod_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_mod_element object + * + * \param ele The dom_html_mod_element object + */ +void _dom_html_mod_element_destroy(struct dom_html_mod_element *ele) +{ + _dom_html_mod_element_finalise(ele); + free(ele); +} + + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_mod_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_mod_element_destroy(dom_node_internal *node) +{ + _dom_html_mod_element_destroy((struct dom_html_mod_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_mod_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_mod_element_get_##attr( \ + dom_html_mod_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_mod_element_set_##attr( \ + dom_html_mod_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(cite); +SIMPLE_GET_SET(date_time); diff --git a/src/html/html_mod_element.h b/src/html/html_mod_element.h index 2e182d5..9df07d5 100644 --- a/src/html/html_mod_element.h +++ b/src/html/html_mod_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_mod_element_h_ +#define dom_internal_html_mod_element_h_ + +#include <dom/html/html_mod_element.h> +#include "html/html_element.h" + + +struct dom_html_mod_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_mod_element object */ +dom_exception _dom_html_mod_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, + dom_string *prefix, struct dom_html_mod_element **ele); + +/* Initialise a dom_html_mod_element object */ +dom_exception _dom_html_mod_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_mod_element *ele); + +/* Finalise a dom_html_mod_element object */ +void _dom_html_mod_element_finalise(struct dom_html_mod_element *ele); + +/* Destroy a dom_html_mod_element object */ +void _dom_html_mod_element_destroy(struct dom_html_mod_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_mod_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_mod_element_destroy(dom_node_internal *node); +dom_exception _dom_html_mod_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_MOD_ELEMENT_PROTECT_VTABLE \ + _dom_html_mod_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_MOD_ELEMENT \ + _dom_virtual_html_mod_element_destroy, \ + _dom_html_mod_element_copy + +#endif diff --git a/src/html/html_object_element.c b/src/html/html_object_element.c index 2e182d5..7da4567 100644 --- a/src/html/html_object_element.c +++ b/src/html/html_object_element.c @@ -3,5 +3,264 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_object_element.h> + +#include "html/html_document.h" +#include "html/html_object_element.h" + +#include "html/html_form_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_OBJECT_ELEMENT + }, + DOM_HTML_OBJECT_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_object_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_object_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_object_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_object_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_object_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_object_element object + * + * \param doc The document object + * \param ele The dom_html_object_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_object_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_object_element *ele) +{ + ele->form = NULL; + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_OBJECT], + namespace, prefix); +} + +/** + * Finalise a dom_html_object_element object + * + * \param ele The dom_html_object_element object + */ +void _dom_html_object_element_finalise(struct dom_html_object_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_object_element object + * + * \param ele The dom_html_object_element object + */ +void _dom_html_object_element_destroy(struct dom_html_object_element *ele) +{ + _dom_html_object_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_object_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_object_element_destroy(dom_node_internal *node) +{ + _dom_html_object_element_destroy((struct dom_html_object_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_object_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_object_element_get_##attr( \ + dom_html_object_element *element, \ + dom_string **attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} +#define SIMPLE_SET(attr) \ + dom_exception dom_html_object_element_set_##attr( \ + dom_html_object_element *element, \ + dom_string *attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(code); +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(archive); +SIMPLE_GET_SET(border); +SIMPLE_GET_SET(code_base); +SIMPLE_GET_SET(code_type); +SIMPLE_GET_SET(data); +SIMPLE_GET_SET(height); +SIMPLE_GET_SET(name); +SIMPLE_GET_SET(standby); +SIMPLE_GET_SET(type); +SIMPLE_GET_SET(use_map); +SIMPLE_GET_SET(width); + +dom_exception dom_html_object_element_get_hspace( + dom_html_object_element *object, int32_t *hspace) +{ + return dom_html_element_get_int32_t_property(&object->base, "hspace", + SLEN("hspace"), hspace); +} + +dom_exception dom_html_object_element_set_hspace( + dom_html_object_element *object, uint32_t hspace) +{ + return dom_html_element_set_int32_t_property(&object->base, "hspace", + SLEN("hspace"), hspace); +} + +dom_exception dom_html_object_element_get_vspace( + dom_html_object_element *object, int32_t *vspace) +{ + return dom_html_element_get_int32_t_property(&object->base, "vspace", + SLEN("vspace"), vspace); +} + +dom_exception dom_html_object_element_set_vspace( + dom_html_object_element *object, uint32_t vspace) +{ + return dom_html_element_set_int32_t_property(&object->base, "vspace", + SLEN("vspace"), vspace); +} + +dom_exception dom_html_object_element_get_tab_index( + dom_html_object_element *object, int32_t *tab_index) +{ + return dom_html_element_get_int32_t_property(&object->base, "tabindex", + SLEN("tabindex"), tab_index); +} + +dom_exception dom_html_object_element_set_tab_index( + dom_html_object_element *object, uint32_t tab_index) +{ + return dom_html_element_set_int32_t_property(&object->base, "tabindex", + SLEN("tabindex"), tab_index); +} + +dom_exception dom_html_object_element_get_declare(dom_html_object_element *ele, + bool *declare) +{ + return dom_html_element_get_bool_property(&ele->base, "declare", + SLEN("declare"), declare); +} + +dom_exception dom_html_object_element_set_declare(dom_html_object_element *ele, + bool declare) +{ + return dom_html_element_set_bool_property(&ele->base, "declare", + SLEN("declare"), declare); +} + +dom_exception dom_html_object_element_get_form( + dom_html_object_element *object, dom_html_form_element **form) +{ + dom_html_document *doc + = (dom_html_document *) ((dom_node_internal *) object)->owner; + dom_node_internal *form_tmp = ((dom_node_internal *) object)->parent; + + while (form_tmp != NULL) { + if (form_tmp->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(form_tmp->name, + doc->memoised[hds_FORM])) + break; + + form_tmp = form_tmp->parent; + } + + if (form_tmp != NULL) { + *form = (dom_html_form_element *) form_tmp; + return DOM_NO_ERR; + } + + *form = NULL; + + return DOM_NO_ERR; +} + +dom_exception dom_html_object_element_get_content_document( + dom_html_object_element *object, dom_document **content_document) +{ + *content_document = (((dom_node_internal *) object)->owner); + return DOM_NO_ERR; +} + diff --git a/src/html/html_object_element.h b/src/html/html_object_element.h index 2e182d5..83512d6 100644 --- a/src/html/html_object_element.h +++ b/src/html/html_object_element.h @@ -3,5 +3,54 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_object_element_h_ +#define dom_internal_html_object_element_h_ + +#include <dom/html/html_object_element.h> + +#include "html/html_element.h" + +struct dom_html_object_element { + struct dom_html_element base; + /**< The base class */ + dom_html_form_element *form; + /**< The form associated with object */ +}; + +/* Create a dom_html_object_element object */ +dom_exception _dom_html_object_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_object_element **ele); + +/* Initialise a dom_html_object_element object */ +dom_exception _dom_html_object_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_object_element *ele); + +/* Finalise a dom_html_object_element object */ +void _dom_html_object_element_finalise(struct dom_html_object_element *ele); + +/* Destroy a dom_html_object_element object */ +void _dom_html_object_element_destroy(struct dom_html_object_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_object_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); + +void _dom_virtual_html_object_element_destroy(dom_node_internal *node); +dom_exception _dom_html_object_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_OBJECT_ELEMENT_PROTECT_VTABLE \ + _dom_html_object_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_OBJECT_ELEMENT \ + _dom_virtual_html_object_element_destroy, \ + _dom_html_object_element_copy + +#endif + diff --git a/src/html/html_olist_element.c b/src/html/html_olist_element.c index 2e182d5..16b8763 100644 --- a/src/html/html_olist_element.c +++ b/src/html/html_olist_element.c @@ -3,5 +3,206 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> +#include <dom/html/html_olist_element.h> + +#include "html/html_document.h" +#include "html/html_olist_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_O_LIST_ELEMENT + }, + DOM_HTML_O_LIST_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_o_list_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_o_list_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *o_listfix, + struct dom_html_o_list_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_o_list_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_o_list_element_initialise(doc, namespace, o_listfix, *ele); +} + +/** + * Initialise a dom_html_o_list_element object + * + * \param doc The document object + * \param ele The dom_html_o_list_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_o_list_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *o_listfix, + struct dom_html_o_list_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_OL], + namespace, o_listfix); +} + +/** + * Finalise a dom_html_o_list_element object + * + * \param ele The dom_html_o_list_element object + */ +void _dom_html_o_list_element_finalise(struct dom_html_o_list_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_o_list_element object + * + * \param ele The dom_html_o_list_element object + */ +void _dom_html_o_list_element_destroy(struct dom_html_o_list_element *ele) +{ + _dom_html_o_list_element_finalise(ele); + free(ele); +} + +/** + * Get the compact Property + * + * \param o_list The dom_html_o_list_element object + */ +dom_exception dom_html_o_list_element_get_compact( + dom_html_o_list_element *o_list, bool *compact) +{ + return dom_html_element_get_bool_property(&o_list->base, "compact", + SLEN("compact"), compact); +} + +/** + * Set the compact Property + * + * \param o_list The dom_html_o_list_element object + */ +dom_exception dom_html_o_list_element_set_compact( + dom_html_o_list_element *o_list, bool compact) +{ + return dom_html_element_set_bool_property(&o_list->base, "compact", + SLEN("compact"), compact); +} + +/** + * Get the start Property + * + * \param o_list The dom_html_o_list_element object + */ +dom_exception dom_html_o_list_element_get_start( + dom_html_o_list_element *o_list, int32_t *start) +{ + return dom_html_element_get_int32_t_property(&o_list->base, "start", + SLEN("start"), start); +} + +/** + * Set the start Property + * + * \param o_list The dom_html_o_list_element object + */ +dom_exception dom_html_o_list_element_set_start( + dom_html_o_list_element *o_list, uint32_t start) +{ + return dom_html_element_set_int32_t_property(&o_list->base, "start", + SLEN("start"), start); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_o_list_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_o_list_element_destroy(dom_node_internal *node) +{ + _dom_html_o_list_element_destroy((struct dom_html_o_list_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_o_list_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_o_list_element_get_##attr( \ + dom_html_o_list_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ + dom_exception dom_html_o_list_element_set_##attr( \ + dom_html_o_list_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(type); diff --git a/src/html/html_olist_element.h b/src/html/html_olist_element.h index 2e182d5..301d8ac 100644 --- a/src/html/html_olist_element.h +++ b/src/html/html_olist_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_o_list_element_h_ +#define dom_internal_html_o_list_element_h_ + +#include <dom/html/html_olist_element.h> +#include "html/html_element.h" + + +struct dom_html_o_list_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_o_list_element object */ +dom_exception _dom_html_o_list_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *o_listfix, + struct dom_html_o_list_element **ele); + +/* Initialise a dom_html_o_list_element object */ +dom_exception _dom_html_o_list_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *o_listfix, + struct dom_html_o_list_element *ele); + +/* Finalise a dom_html_o_list_element object */ +void _dom_html_o_list_element_finalise(struct dom_html_o_list_element *ele); + +/* Destroy a dom_html_o_list_element object */ +void _dom_html_o_list_element_destroy(struct dom_html_o_list_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_o_list_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_o_list_element_destroy(dom_node_internal *node); +dom_exception _dom_html_o_list_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_O_LIST_ELEMENT_PROTECT_VTABLE \ + _dom_html_o_list_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_O_LIST_ELEMENT \ + _dom_virtual_html_o_list_element_destroy, \ + _dom_html_o_list_element_copy + +#endif diff --git a/src/html/html_option_element.c b/src/html/html_option_element.c index b133deb..b777c5f 100644 --- a/src/html/html_option_element.c +++ b/src/html/html_option_element.c @@ -255,13 +255,22 @@ dom_exception dom_html_option_element_get_text( * \return DOM_NO_ERR on success, appropriate error otherwise. */ dom_exception dom_html_option_element_get_index( - dom_html_option_element *option, unsigned long *index) + dom_html_option_element *option, int32_t *index) { - UNUSED(option); - UNUSED(index); + dom_html_document *doc = (dom_html_document *) dom_node_get_owner(option); + int32_t idx = 0; + dom_node_internal *n = ((dom_node_internal *)option)->parent; - /** \todo Implement */ - return DOM_NOT_SUPPORTED_ERR; + for(n = n->first_child;n != NULL; n = n->next) { + if((dom_node_internal *)option == n) { + *index = idx; + break; + } else if(dom_string_caseless_isequal(n->name,doc->memoised[hds_OPTION])) { + idx += 1; + } + } + + return DOM_NO_ERR; } /** diff --git a/src/html/html_options_collection.c b/src/html/html_options_collection.c index 85001ad..3e06915 100644 --- a/src/html/html_options_collection.c +++ b/src/html/html_options_collection.c @@ -190,13 +190,13 @@ dom_exception dom_html_options_collection_named_item(dom_html_options_collection /* No children and siblings */ struct dom_node_internal *parent = n->parent; - while (parent != col->base.root && + while (n != col->base.root && n == parent->last_child) { n = parent; parent = parent->parent; } - if (parent == col->base.root) + if (n == col->base.root) n = NULL; else n = n->next; diff --git a/src/html/html_paragraph_element.c b/src/html/html_paragraph_element.c index 2e182d5..20a6c28 100644 --- a/src/html/html_paragraph_element.c +++ b/src/html/html_paragraph_element.c @@ -3,5 +3,159 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_paragraph_element.h> + +#include "html/html_document.h" +#include "html/html_paragraph_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_P_ELEMENT + }, + DOM_HTML_P_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_paragraph_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_paragraph_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_paragraph_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_paragraph_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_paragraph_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_paragraph_element object + * + * \param doc The document object + * \param ele The dom_html_paragraph_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_paragraph_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_paragraph_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_P], + namespace, prefix); +} + +/** + * Finalise a dom_html_paragraph_element object + * + * \param ele The dom_html_paragraph_element object + */ +void _dom_html_paragraph_element_finalise(struct dom_html_paragraph_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_paragraph_element object + * + * \param ele The dom_html_paragraph_element object + */ +void _dom_html_paragraph_element_destroy(struct dom_html_paragraph_element *ele) +{ + _dom_html_paragraph_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_paragraph_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_paragraph_element_destroy(dom_node_internal *node) +{ + _dom_html_paragraph_element_destroy((struct dom_html_paragraph_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_paragraph_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_paragraph_element_get_##attr( \ + dom_html_paragraph_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_paragraph_element_set_##attr( \ + dom_html_paragraph_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(align); diff --git a/src/html/html_paragraph_element.h b/src/html/html_paragraph_element.h index 2e182d5..b6627dd 100644 --- a/src/html/html_paragraph_element.h +++ b/src/html/html_paragraph_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_paragraph_element_h_ +#define dom_internal_html_paragraph_element_h_ + +#include <dom/html/html_paragraph_element.h> +#include "html/html_element.h" + + +struct dom_html_paragraph_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_paragraph_element object */ +dom_exception _dom_html_paragraph_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_paragraph_element **ele); + +/* Initialise a dom_html_paragraph_element object */ +dom_exception _dom_html_paragraph_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_paragraph_element *ele); + +/* Finalise a dom_html_paragraph_element object */ +void _dom_html_paragraph_element_finalise(struct dom_html_paragraph_element *ele); + +/* Destroy a dom_html_paragraph_element object */ +void _dom_html_paragraph_element_destroy(struct dom_html_paragraph_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_paragraph_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_paragraph_element_destroy(dom_node_internal *node); +dom_exception _dom_html_paragraph_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_P_ELEMENT_PROTECT_VTABLE \ + _dom_html_paragraph_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_P_ELEMENT \ + _dom_virtual_html_paragraph_element_destroy, \ + _dom_html_paragraph_element_copy + +#endif diff --git a/src/html/html_param_element.c b/src/html/html_param_element.c index 2e182d5..6bda015 100644 --- a/src/html/html_param_element.c +++ b/src/html/html_param_element.c @@ -3,5 +3,160 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> +#include <dom/html/html_param_element.h> + +#include "html/html_document.h" +#include "html/html_param_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_PARAM_ELEMENT + }, + DOM_HTML_PARAM_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_param_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_param_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_param_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_param_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_param_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_param_element object + * + * \param doc The document object + * \param ele The dom_html_param_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_param_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_param_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_PARAM], + namespace, prefix); +} + +/** + * Finalise a dom_html_param_element object + * + * \param ele The dom_html_param_element object + */ +void _dom_html_param_element_finalise(struct dom_html_param_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_param_element object + * + * \param ele The dom_html_param_element object + */ +void _dom_html_param_element_destroy(struct dom_html_param_element *ele) +{ + _dom_html_param_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_param_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_param_element_destroy(dom_node_internal *node) +{ + _dom_html_param_element_destroy((struct dom_html_param_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_param_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_param_element_get_##attr( \ + dom_html_param_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ + dom_exception dom_html_param_element_set_##attr( \ + dom_html_param_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(name); +SIMPLE_GET_SET(type); +SIMPLE_GET_SET(value); +SIMPLE_GET_SET(value_type); diff --git a/src/html/html_param_element.h b/src/html/html_param_element.h index 2e182d5..2cd8150 100644 --- a/src/html/html_param_element.h +++ b/src/html/html_param_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_param_element_h_ +#define dom_internal_html_param_element_h_ + +#include <dom/html/html_param_element.h> +#include "html/html_element.h" + + +struct dom_html_param_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_param_element object */ +dom_exception _dom_html_param_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_param_element **ele); + +/* Initialise a dom_html_param_element object */ +dom_exception _dom_html_param_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_param_element *ele); + +/* Finalise a dom_html_param_element object */ +void _dom_html_param_element_finalise(struct dom_html_param_element *ele); + +/* Destroy a dom_html_param_element object */ +void _dom_html_param_element_destroy(struct dom_html_param_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_param_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_param_element_destroy(dom_node_internal *node); +dom_exception _dom_html_param_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_PARAM_ELEMENT_PROTECT_VTABLE \ + _dom_html_param_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_PARAM_ELEMENT \ + _dom_virtual_html_param_element_destroy, \ + _dom_html_param_element_copy + +#endif diff --git a/src/html/html_pre_element.c b/src/html/html_pre_element.c index 2e182d5..1d220fd 100644 --- a/src/html/html_pre_element.c +++ b/src/html/html_pre_element.c @@ -3,5 +3,141 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_pre_element.h> + +#include "html/html_document.h" +#include "html/html_pre_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_PRE_ELEMENT + }, + DOM_HTML_PRE_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_pre_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_pre_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_pre_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_pre_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_pre_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_pre_element object + * + * \param doc The document object + * \param ele The dom_html_pre_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_pre_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_pre_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_PRE], + namespace, prefix); +} + +/** + * Finalise a dom_html_pre_element object + * + * \param ele The dom_html_pre_element object + */ +void _dom_html_pre_element_finalise(struct dom_html_pre_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_pre_element object + * + * \param ele The dom_html_pre_element object + */ +void _dom_html_pre_element_destroy(struct dom_html_pre_element *ele) +{ + _dom_html_pre_element_finalise(ele); + free(ele); +} + +/** + * Get the width Property + * + * \param pre The dom_html_pre_element object + */ +dom_exception dom_html_pre_element_get_width( + dom_html_pre_element *pre, int32_t *width) +{ + return dom_html_element_get_int32_t_property(&pre->base, "width", + SLEN("width"), width); +} + +/** + * Set the width Property + * + * \param pre The dom_html_pre_element object + */ +dom_exception dom_html_pre_element_set_width( + dom_html_pre_element *pre, uint32_t width) +{ + return dom_html_element_set_int32_t_property(&pre->base, "width", + SLEN("width"), width); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_pre_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_pre_element_destroy(dom_node_internal *node) +{ + _dom_html_pre_element_destroy((struct dom_html_pre_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_pre_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} diff --git a/src/html/html_pre_element.h b/src/html/html_pre_element.h index 2e182d5..75d8df8 100644 --- a/src/html/html_pre_element.h +++ b/src/html/html_pre_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_pre_element_h_ +#define dom_internal_html_pre_element_h_ + +#include <dom/html/html_pre_element.h> +#include "html/html_element.h" + + +struct dom_html_pre_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_pre_element object */ +dom_exception _dom_html_pre_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_pre_element **ele); + +/* Initialise a dom_html_pre_element object */ +dom_exception _dom_html_pre_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_pre_element *ele); + +/* Finalise a dom_html_pre_element object */ +void _dom_html_pre_element_finalise(struct dom_html_pre_element *ele); + +/* Destroy a dom_html_pre_element object */ +void _dom_html_pre_element_destroy(struct dom_html_pre_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_pre_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_pre_element_destroy(dom_node_internal *node); +dom_exception _dom_html_pre_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_PRE_ELEMENT_PROTECT_VTABLE \ + _dom_html_pre_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_PRE_ELEMENT \ + _dom_virtual_html_pre_element_destroy, \ + _dom_html_pre_element_copy + +#endif diff --git a/src/html/html_quote_element.c b/src/html/html_quote_element.c index 2e182d5..d16bad8 100644 --- a/src/html/html_quote_element.c +++ b/src/html/html_quote_element.c @@ -3,5 +3,159 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_quote_element.h> + +#include "html/html_document.h" +#include "html/html_quote_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_QUOTE_ELEMENT + }, + DOM_HTML_QUOTE_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_quote_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_quote_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_quote_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_quote_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_quote_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_quote_element object + * + * \param doc The document object + * \param ele The dom_html_quote_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_quote_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_quote_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_Q], + namespace, prefix); +} + +/** + * Finalise a dom_html_quote_element object + * + * \param ele The dom_html_quote_element object + */ +void _dom_html_quote_element_finalise(struct dom_html_quote_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_quote_element object + * + * \param ele The dom_html_quote_element object + */ +void _dom_html_quote_element_destroy(struct dom_html_quote_element *ele) +{ + _dom_html_quote_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_quote_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_quote_element_destroy(dom_node_internal *node) +{ + _dom_html_quote_element_destroy((struct dom_html_quote_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_quote_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_quote_element_get_##attr( \ + dom_html_quote_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_quote_element_set_##attr( \ + dom_html_quote_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(cite); diff --git a/src/html/html_quote_element.h b/src/html/html_quote_element.h index 2e182d5..a8bfbb2 100644 --- a/src/html/html_quote_element.h +++ b/src/html/html_quote_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_quote_element_h_ +#define dom_internal_html_quote_element_h_ + +#include <dom/html/html_quote_element.h> +#include "html/html_element.h" + + +struct dom_html_quote_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_quote_element object */ +dom_exception _dom_html_quote_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_quote_element **ele); + +/* Initialise a dom_html_quote_element object */ +dom_exception _dom_html_quote_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_quote_element *ele); + +/* Finalise a dom_html_quote_element object */ +void _dom_html_quote_element_finalise(struct dom_html_quote_element *ele); + +/* Destroy a dom_html_quote_element object */ +void _dom_html_quote_element_destroy(struct dom_html_quote_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_quote_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_quote_element_destroy(dom_node_internal *node); +dom_exception _dom_html_quote_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_QUOTE_ELEMENT_PROTECT_VTABLE \ + _dom_html_quote_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_QUOTE_ELEMENT \ + _dom_virtual_html_quote_element_destroy, \ + _dom_html_quote_element_copy + +#endif diff --git a/src/html/html_script_element.c b/src/html/html_script_element.c index 2e182d5..f107d45 100644 --- a/src/html/html_script_element.c +++ b/src/html/html_script_element.c @@ -3,5 +3,218 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> +#include <dom/html/html_script_element.h> + +#include "html/html_document.h" +#include "html/html_script_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_SCRIPT_ELEMENT + }, + DOM_HTML_SCRIPT_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_script_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_script_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_script_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_script_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_script_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_script_element object + * + * \param doc The document object + * \param ele The dom_html_script_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_script_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_script_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_SCRIPT], + namespace, prefix); +} + +/** + * Finalise a dom_html_script_element object + * + * \param ele The dom_html_script_element object + */ +void _dom_html_script_element_finalise(struct dom_html_script_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_script_element object + * + * \param ele The dom_html_script_element object + */ +void _dom_html_script_element_destroy(struct dom_html_script_element *ele) +{ + _dom_html_script_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_script_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_script_element_destroy(dom_node_internal *node) +{ + _dom_html_script_element_destroy((struct dom_html_script_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_script_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_script_element_get_##attr( \ + dom_html_script_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_script_element_set_##attr( \ + dom_html_script_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(html_for); +SIMPLE_GET_SET(event); +SIMPLE_GET_SET(charset); +SIMPLE_GET_SET(src); +SIMPLE_GET_SET(type); + +/** + * Get the defer property + * + * \param ele The dom_html_script_element object + * \param defer The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_script_element_get_defer(dom_html_script_element *ele, + bool *defer) +{ + return dom_html_element_get_bool_property(&ele->base, "defer", + SLEN("defer"), defer); +} + +/** + * Set the defer property + * + * \param ele The dom_html_script_element object + * \param defer The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_script_element_set_defer(dom_html_script_element *ele, + bool defer) +{ + return dom_html_element_set_bool_property(&ele->base, "defer", + SLEN("defer"), defer); +} + +/** + * Get the text property + * + * \param ele The dom_html_script_element object + * \param text The returned dom_string object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_script_element_get_text( + dom_html_script_element *ele, + dom_string **text) +{ + return _dom_node_get_text_content((dom_node_internal *)ele, text); +} + +/** + * Set the text property + * + * \param ele The dom_html_script_element object + * \param text The dom_string value to be set + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_script_element_set_text( + dom_html_script_element *ele, + dom_string *text) +{ + return _dom_node_set_text_content((dom_node_internal *)ele, text); +} diff --git a/src/html/html_script_element.h b/src/html/html_script_element.h index 2e182d5..dcb7b72 100644 --- a/src/html/html_script_element.h +++ b/src/html/html_script_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_script_element_h_ +#define dom_internal_html_script_element_h_ + +#include <dom/html/html_script_element.h> +#include "html/html_element.h" + + +struct dom_html_script_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_script_element object */ +dom_exception _dom_html_script_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_script_element **ele); + +/* Initialise a dom_html_script_element object */ +dom_exception _dom_html_script_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_script_element *ele); + +/* Finalise a dom_html_script_element object */ +void _dom_html_script_element_finalise(struct dom_html_script_element *ele); + +/* Destroy a dom_html_script_element object */ +void _dom_html_script_element_destroy(struct dom_html_script_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_script_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_script_element_destroy(dom_node_internal *node); +dom_exception _dom_html_script_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_SCRIPT_ELEMENT_PROTECT_VTABLE \ + _dom_html_script_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_SCRIPT_ELEMENT \ + _dom_virtual_html_script_element_destroy, \ + _dom_html_script_element_copy + +#endif diff --git a/src/html/html_select_element.c b/src/html/html_select_element.c index c02f0bd..7a5e84e 100644 --- a/src/html/html_select_element.c +++ b/src/html/html_select_element.c @@ -65,8 +65,8 @@ dom_exception _dom_html_select_element_initialise(struct dom_html_document *doc, ele->form = NULL; return _dom_html_element_initialise(doc, &ele->base, - doc->memoised[hds_SELECT], - namespace, prefix); + doc->memoised[hds_SELECT], + namespace, prefix); } /** @@ -125,16 +125,16 @@ dom_exception _dom_html_select_element_copy(dom_node_internal *old, /* Public APIs */ static dom_exception _dom_html_select_element_make_collection( - dom_html_select_element *ele, - dom_html_options_collection **col) + dom_html_select_element *ele, + dom_html_options_collection **col) { dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); assert(doc != NULL); return _dom_html_options_collection_create(doc, - (dom_node_internal *) ele, - is_option, ele, col); + (dom_node_internal *) ele, + is_option, ele, col); } /** @@ -174,11 +174,11 @@ dom_exception dom_html_select_element_get_selected_index( dom_html_select_element *ele, int32_t *index) { dom_exception err; - uint32_t idx, len; + uint32_t idx,len; dom_node *option; bool selected; dom_html_options_collection *col; - + err = _dom_html_select_element_make_collection(ele, &col); err = dom_html_options_collection_get_length(col, &len); @@ -194,7 +194,7 @@ dom_exception dom_html_select_element_get_selected_index( dom_html_options_collection_unref(col); return err; } - + err = dom_html_option_element_get_selected( (dom_html_option_element *) option, &selected); @@ -204,7 +204,7 @@ dom_exception dom_html_select_element_get_selected_index( dom_html_options_collection_unref(col); return err; } - + if (selected) { *index = idx; dom_html_options_collection_unref(col); @@ -228,11 +228,30 @@ dom_exception dom_html_select_element_get_selected_index( dom_exception dom_html_select_element_set_selected_index( dom_html_select_element *ele, int32_t index) { - UNUSED(ele); - UNUSED(index); + dom_exception err; + dom_node *option; + dom_html_options_collection *col; - /** \todo Implement */ - return DOM_NOT_SUPPORTED_ERR; + err = _dom_html_select_element_make_collection(ele, &col); + + err = dom_html_options_collection_item(col, + index, &option); + if (err != DOM_NO_ERR) { + dom_html_options_collection_unref(col); + return err; + } + + err = dom_html_option_element_set_selected( + (dom_html_option_element *) option, true); + + dom_node_unref(option); + + dom_html_options_collection_unref(col); + if (err != DOM_NO_ERR) { + return err; + } + + return DOM_NO_ERR; } /** @@ -250,7 +269,7 @@ dom_exception dom_html_select_element_get_value( dom_node *option; bool selected; dom_html_options_collection *col; - + err = _dom_html_select_element_make_collection(ele, &col); if (err != DOM_NO_ERR) return err; @@ -291,7 +310,7 @@ dom_exception dom_html_select_element_get_value( *value = NULL; dom_html_options_collection_unref(col); - + return DOM_NO_ERR; } @@ -305,11 +324,54 @@ dom_exception dom_html_select_element_get_value( dom_exception dom_html_select_element_set_value( dom_html_select_element *ele, dom_string *value) { - UNUSED(ele); - UNUSED(value); + dom_exception err; + uint32_t idx, len; + dom_node *option; + bool selected; + dom_html_options_collection *col; + + err = _dom_html_select_element_make_collection(ele, &col); + if (err != DOM_NO_ERR) + return err; + + err = dom_html_select_element_get_length(ele, &len); + if (err != DOM_NO_ERR) { + dom_html_options_collection_unref(col); + return err; + } + + for (idx = 0; idx < len; idx++) { + err = dom_html_options_collection_item(col, + idx, &option); + if (err != DOM_NO_ERR) { + dom_html_options_collection_unref(col); + return err; + } + + err = dom_html_option_element_get_selected( + (dom_html_option_element *) option, &selected); + if (err != DOM_NO_ERR) { + dom_html_options_collection_unref(col); + dom_node_unref(option); + return err; + } + + if (selected) { + err = dom_html_option_element_set_value( + (dom_html_option_element *) option, + value); + + dom_html_options_collection_unref(col); + dom_node_unref(option); + + return err; + } + } + + dom_html_options_collection_unref(col); + + return DOM_NO_ERR; - /** \todo Implement */ - return DOM_NOT_SUPPORTED_ERR; } /** @@ -362,7 +424,7 @@ dom_exception dom_html_select_element_set_length( * \return DOM_NO_ERR on success, appropriate error otherwise. */ dom_exception dom_html_select_element_get_form( - dom_html_select_element *select, dom_html_form_element **form) + dom_html_select_element *select, dom_html_form_element **form) { *form = select->form; @@ -536,12 +598,12 @@ dom_exception dom_html_select_element_set_tab_index( dom_exception dom__html_select_element_add(dom_html_select_element *select, struct dom_html_element *ele, struct dom_html_element *before) { - UNUSED(select); - UNUSED(ele); - UNUSED(before); - /** \todo Implement */ - return DOM_NOT_SUPPORTED_ERR; + return _dom_node_insert_before((dom_node_internal *)select, + (dom_node_internal *)ele, (dom_node_internal *)before, + (dom_node_internal **)&ele); + + } dom_exception dom_html_select_element_remove(dom_html_select_element *ele, @@ -549,17 +611,31 @@ dom_exception dom_html_select_element_remove(dom_html_select_element *ele, { dom_exception err; uint32_t len; + dom_node *option; err = dom_html_select_element_get_length(ele, &len); if (err != DOM_NO_ERR) return err; /* Ensure index is in range */ - if (index < 0 || (uint32_t)index >= len) + if (index < 0 || index >= (int32_t)len) return DOM_NO_ERR; + dom_html_options_collection *col; - /** \todo What does remove mean? Remove option from tree and destroy it? */ - return DOM_NOT_SUPPORTED_ERR; + err = _dom_html_select_element_make_collection(ele, &col); + if (err != DOM_NO_ERR) + return err; + + err = dom_html_options_collection_item(col, + index, &option); + + if (err != DOM_NO_ERR) { + dom_html_options_collection_unref(col); + return err; + } + return _dom_node_remove_child(((dom_node_internal *)option)->parent, + (dom_node_internal *)option, + (dom_node_internal **)&option); } /** @@ -577,9 +653,9 @@ dom_exception dom_html_select_element_blur(struct dom_html_select_element *ele) /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ return _dom_dispatch_generic_event((dom_document *) doc, - (dom_event_target *) ele, - doc->memoised[hds_blur], true, - true, &success); + (dom_event_target *) ele, + doc->memoised[hds_blur], true, + true, &success); } /** @@ -597,9 +673,9 @@ dom_exception dom_html_select_element_focus(struct dom_html_select_element *ele) /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ return _dom_dispatch_generic_event((dom_document *) doc, - (dom_event_target *) ele, - doc->memoised[hds_focus], true, - true, &success); + (dom_event_target *) ele, + doc->memoised[hds_focus], true, + true, &success); } @@ -611,7 +687,7 @@ bool is_option(struct dom_node_internal *node, void *ctx) { dom_html_select_element *ele = ctx; dom_html_document *doc = (dom_html_document *) dom_node_get_owner(ele); - + if (dom_string_isequal(node->name, doc->memoised[hds_OPTION])) return true; @@ -619,7 +695,7 @@ bool is_option(struct dom_node_internal *node, void *ctx) } dom_exception _dom_html_select_element_set_form( - dom_html_select_element *select, dom_html_form_element *form) + dom_html_select_element *select, dom_html_form_element *form) { select->form = form; diff --git a/src/html/html_style_element.c b/src/html/html_style_element.c index 98eb79b..681f0b8 100644 --- a/src/html/html_style_element.c +++ b/src/html/html_style_element.c @@ -8,6 +8,7 @@ #include <stdlib.h> #include "html/html_style_element.h" +#include "html/html_document.h" #include "core/node.h" #include "utils/utils.h" @@ -34,7 +35,7 @@ dom_exception _dom_html_style_element_create(struct dom_html_document *doc, *ele = malloc(sizeof(dom_html_style_element)); if (*ele == NULL) return DOM_NO_MEM_ERR; - + /* Set up vtables */ node = (struct dom_node_internal *) *ele; node->base.vtable = &_dom_html_element_vtable; @@ -54,13 +55,20 @@ dom_exception _dom_html_style_element_initialise(struct dom_html_document *doc, struct dom_html_style_element *ele) { dom_string *name = NULL; + dom_string *media_default = NULL; dom_exception err; err = dom_string_create((const uint8_t *) "STYLE", SLEN("STYLE"), &name); if (err != DOM_NO_ERR) return err; + + err = dom_string_create((const uint8_t *) "screen", SLEN("screen"), + &media_default); + if (err != DOM_NO_ERR) + return err; + ele->media = media_default; err = _dom_html_element_initialise(doc, &ele->base, name, NULL, NULL); dom_string_unref(name); @@ -119,9 +127,49 @@ dom_exception _dom_html_style_element_copy(dom_node_internal *old, return _dom_html_element_copy(old, copy); } + /*-----------------------------------------------------------------------*/ /* Public APIs */ +#define SIMPLE_GET(attr) \ + dom_exception dom_html_style_element_get_##attr( \ + dom_html_style_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ +dom_exception dom_html_style_element_set_##attr( \ + dom_html_style_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(type); +SIMPLE_SET(media); + /** * Get the disabled property * @@ -150,3 +198,36 @@ dom_exception dom_html_style_element_set_disabled(dom_html_style_element *ele, SLEN("disabled"), disabled); } +/** + * Get the media property + * + * \param ele The dom_html_style_element object + * \param media The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_style_element_get_media(dom_html_style_element *ele, + dom_string **media) +{ + dom_html_document *doc; + bool has_value = false; + dom_exception err; + + doc = (dom_html_document *) ((dom_node_internal *) ele)->owner; + + err = dom_element_has_attribute(ele, + doc->memoised[hds_media], &has_value); + if(err !=DOM_NO_ERR) + return err; + + if(has_value) { + return dom_element_get_attribute(ele, + doc->memoised[hds_media], media); + } + + *media = ele->media; + if (*media != NULL) + dom_string_ref(*media); + return DOM_NO_ERR; + +} + diff --git a/src/html/html_style_element.h b/src/html/html_style_element.h index e7a47e5..285da94 100644 --- a/src/html/html_style_element.h +++ b/src/html/html_style_element.h @@ -15,6 +15,8 @@ struct dom_html_style_element { struct dom_html_element base; /**< The base class */ + dom_string *media; + /**< The default string value for the media attribute*/ }; /* Create a dom_html_style_element object */ diff --git a/src/html/html_table_element.c b/src/html/html_table_element.c index 2e182d5..0f27fd3 100644 --- a/src/html/html_table_element.c +++ b/src/html/html_table_element.c @@ -3,5 +3,745 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_table_element.h> + +#include "html/html_document.h" +#include "html/html_table_element.h" +#include "html/html_tablecaption_element.h" +#include "html/html_tablesection_element.h" +#include "html/html_tablerow_element.h" +#include "html/html_collection.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_TABLE_ELEMENT + }, + DOM_HTML_TABLE_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_table_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_table_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_table_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_table_element object + * + * \param doc The document object + * \param ele The dom_html_table_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_element *ele) +{ + ele->caption = NULL; + ele->t_head = NULL; + ele->t_foot = NULL; + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_TABLE], + namespace, prefix); +} + +/** + * Finalise a dom_html_table_element object + * + * \param ele The dom_html_table_element object + */ +void _dom_html_table_element_finalise(struct dom_html_table_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_table_element object + * + * \param ele The dom_html_table_element object + */ +void _dom_html_table_element_destroy(struct dom_html_table_element *ele) +{ + _dom_html_table_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_table_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_table_element_destroy(dom_node_internal *node) +{ + _dom_html_table_element_destroy((struct dom_html_table_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_table_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_table_element_get_##attr( \ + dom_html_table_element *element, \ + dom_string **attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} +#define SIMPLE_SET(attr) \ + dom_exception dom_html_table_element_set_##attr( \ + dom_html_table_element *element, \ + dom_string *attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(bg_color); +SIMPLE_GET_SET(border); +SIMPLE_GET_SET(cell_padding); +SIMPLE_GET_SET(cell_spacing); +SIMPLE_GET_SET(frame); +SIMPLE_GET_SET(rules); +SIMPLE_GET_SET(summary); +SIMPLE_GET_SET(width); + +/** + * Get the caption Attribute + * + * \param table The dom_html_table_element object + */ +dom_exception dom_html_table_element_get_caption( + dom_html_table_element *table, dom_html_table_caption_element **caption) +{ + dom_node_internal *node_tmp = ((dom_node_internal *)table); + dom_html_document *doc = (dom_html_document *)(node_tmp->owner); + + if(table->caption == NULL) { + for (node_tmp = node_tmp->first_child; node_tmp != NULL; node_tmp = node_tmp->next) { + if((node_tmp->type == DOM_ELEMENT_NODE) && + dom_string_caseless_isequal(doc->memoised[hds_CAPTION],node_tmp->name)) { + break; + } + } + table->caption = (dom_html_table_caption_element *)node_tmp; + } + *caption = (table->caption); + return DOM_NO_ERR; +} + +/** + * Set the caption Attribute + * + * \param table The dom_html_table_element object + * \param table The dom_html_table_element object + */ +dom_exception dom_html_table_element_set_caption( + dom_html_table_element *table, dom_html_table_caption_element *caption) +{ + dom_node_internal *check_node = ((dom_node_internal *)caption); + dom_html_document *doc = (dom_html_document *)(((dom_node_internal *)table)->owner); + if(check_node == NULL) { + return DOM_HIERARCHY_REQUEST_ERR; + } + if(!dom_string_caseless_isequal(doc->memoised[hds_CAPTION],check_node->name)) { + return DOM_HIERARCHY_REQUEST_ERR; + } + table->caption = caption; + return DOM_NO_ERR; +} + +/** + * Get the t_head Attribute + * + * \param table The dom_html_table_element object + */ +dom_exception dom_html_table_element_get_t_head( + dom_html_table_element *table, dom_html_table_section_element **t_head) +{ + dom_node_internal *node_tmp = ((dom_node_internal *)table); + dom_html_document *doc = (dom_html_document *)(node_tmp->owner); + + if(table->t_head == NULL) { + for (node_tmp = node_tmp->first_child; node_tmp != NULL; node_tmp = node_tmp->next) { + if((node_tmp->type == DOM_ELEMENT_NODE) && + dom_string_caseless_isequal(doc->memoised[hds_THEAD],node_tmp->name)) { + break; + } + } + table->t_head = (dom_html_table_section_element *)node_tmp; + } + *t_head = table->t_head; + return DOM_NO_ERR; +} + +/** + * Set the t_head Attribute + * + * \param table The dom_html_table_element object + * \param table The dom_html_table_element object + */ +dom_exception dom_html_table_element_set_t_head( + dom_html_table_element *table, dom_html_table_section_element *t_head) +{ + dom_node_internal *check_node = ((dom_node_internal *)t_head); + dom_html_document *doc = (dom_html_document *)(((dom_node_internal *)table)->owner); + if(check_node == NULL) { + return DOM_HIERARCHY_REQUEST_ERR; + } + if(!dom_string_caseless_isequal(doc->memoised[hds_CAPTION],check_node->name)) { + return DOM_HIERARCHY_REQUEST_ERR; + } + table->t_head = t_head; + return DOM_NO_ERR; +} + +/** + * Get the t_foot Attribute + * + * \param table The dom_html_table_element object + */ +dom_exception dom_html_table_element_get_t_foot( + dom_html_table_element *table, dom_html_table_section_element **t_foot) +{ + dom_node_internal *node_tmp = ((dom_node_internal *)table); + dom_html_document *doc = (dom_html_document *)(node_tmp->owner); + + if(table->t_foot == NULL) { + for (node_tmp = node_tmp->first_child; node_tmp != NULL; node_tmp = node_tmp->next) { + if((node_tmp->type == DOM_ELEMENT_NODE) && + dom_string_caseless_isequal(doc->memoised[hds_TFOOT],node_tmp->name)) { + break; + } + } + table->t_foot = (dom_html_table_section_element *)node_tmp; + } + *t_foot = (table->t_foot); + return DOM_NO_ERR; +} + +/** + * Set the t_foot Attribute + * + * \param table The dom_html_table_element object + */ +dom_exception dom_html_table_element_set_t_foot( + dom_html_table_element *table, dom_html_table_section_element *t_foot) +{ + dom_node_internal *check_node = ((dom_node_internal *)t_foot); /*< temporary node to check for raised exceptions */ + dom_html_document *doc = (dom_html_document *)(((dom_node_internal *)table)->owner); + if(check_node == NULL) { + return DOM_HIERARCHY_REQUEST_ERR; + } + if(!dom_string_caseless_isequal(doc->memoised[hds_TFOOT],check_node->name)) { + return DOM_HIERARCHY_REQUEST_ERR; + } + table->t_foot = t_foot; + return DOM_NO_ERR; +} + +/** + * Callback for creating the rows collection + * + * \param node The dom_html_table_element object + * \param ctx The dom_html_document object (void *) + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +bool table_rows_callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_TR])) { + return true; + } + return false; +} + +/** + * Get the rows collection + * + * \param element The dom_html_table_element object + * \param rows The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_get_rows( + dom_html_table_element *element, + dom_html_collection **rows) +{ + dom_html_document *doc = (dom_html_document *) ((dom_node_internal *) element)->owner; + return _dom_html_collection_create(doc, (dom_node_internal *)element, + table_rows_callback, (void *)doc, rows); +} + +/** + * Callback for creating the tbodies collection + * + * \param node The dom_html_table_element object + * \param ctx The dom_html_document object (void *) + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +bool table_t_bodies_callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_TBODY])) { + return true; + } + return false; +} + +/** + * Get the tBodies collection + * + * \param element The dom_html_table_element object + * \param t_bodies The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_get_t_bodies( + dom_html_table_element *element, + dom_html_collection **t_bodies) +{ + dom_html_document *doc = (dom_html_document *) ((dom_node_internal *) element)->owner; + return _dom_html_collection_create(doc, (dom_node_internal *)element, + table_t_bodies_callback, (void *)doc, t_bodies); +} + +/** + * Get or Create the table caption + * + * \param element The dom_html_table_element object + * \param caption The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_create_caption( + dom_html_table_element *element, + dom_html_element **caption) +{ + dom_exception exp; + if((exp = dom_html_table_element_get_caption(element, + (dom_html_table_caption_element **)caption)) != DOM_NO_ERR) { + return exp; + } + if((*caption) == NULL) { + dom_html_document *doc = (dom_html_document *) + ((dom_node_internal *) element)->owner; + exp = _dom_html_table_caption_element_create(doc, + ((dom_node_internal *)element)->namespace, + ((dom_node_internal *)element)->prefix, + (dom_html_table_caption_element **)caption); + if(exp != DOM_NO_ERR) { + return exp; + } + _dom_node_append_child((dom_node_internal *)element, + (dom_node_internal *)*caption, + (dom_node_internal **)caption); + element->caption = (dom_html_table_caption_element *)*caption; + + } + return DOM_NO_ERR; +} + +/** + * Delete the table caption, if one exists + * + * \param element The dom_html_table_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_delete_caption( + dom_html_table_element *element) +{ + dom_html_table_caption_element *caption; + dom_html_table_element_get_caption(element, &caption); + _dom_node_remove_child((dom_node_internal *)element, + (dom_node_internal *)caption, + (dom_node_internal **)&caption); + element->caption = NULL; + return DOM_NO_ERR; +} + +/** + * Get or Create the table Foot + * + * \param element The dom_html_table_element object + * \param t_foot The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_create_t_foot( + dom_html_table_element *element, + dom_html_element **t_foot) +{ + dom_exception exp; + exp = dom_html_table_element_get_t_foot(element, + (dom_html_table_section_element **)t_foot); + if(exp !=DOM_NO_ERR) { + return exp; + } + if((*t_foot) == NULL) { + dom_html_document *doc = (dom_html_document *) + ((dom_node_internal *) element)->owner; + exp = _dom_html_table_section_element_create(doc, + doc->memoised[hds_TFOOT], + ((dom_node_internal *)element)->namespace, + ((dom_node_internal *)element)->prefix, + (dom_html_table_section_element **)t_foot); + if(exp != DOM_NO_ERR) { + return exp; + } + _dom_node_append_child((dom_node_internal *)element, + (dom_node_internal *)*t_foot, + (dom_node_internal **)t_foot); + element->t_foot = (dom_html_table_section_element *)*t_foot; + + } + return DOM_NO_ERR; +} + +/** + * Delete the table Foot, if one exists + * + * \param element The dom_html_table_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_delete_t_foot( + dom_html_table_element *element) +{ + dom_html_table_section_element *t_foot; + dom_html_table_element_get_t_foot(element, &t_foot); + _dom_node_remove_child((dom_node_internal *)element, + (dom_node_internal *)t_foot, + (dom_node_internal **)&t_foot); + element->t_foot = NULL; + return DOM_NO_ERR; +} + +/** + * Get or Create the table Head + * + * \param element The dom_html_table_element object + * \param t_head The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_create_t_head( + dom_html_table_element *element, + dom_html_element **t_head) +{ + dom_html_table_element_get_t_head(element, + (dom_html_table_section_element **)t_head); + if((*t_head) == NULL) { + dom_exception exp; + dom_html_document *doc = (dom_html_document *) + ((dom_node_internal *) element)->owner; + exp = _dom_html_table_section_element_create(doc, + doc->memoised[hds_THEAD], + ((dom_node_internal *)element)->namespace, + ((dom_node_internal *)element)->prefix, + (dom_html_table_section_element **)t_head); + if(exp != DOM_NO_ERR) { + return exp; + } + _dom_node_append_child((dom_node_internal *)element, + (dom_node_internal *)*t_head, + (dom_node_internal **)t_head); + element->t_head = (dom_html_table_section_element *)*t_head; + + } + return DOM_NO_ERR; +} + +/** + * Delete the table Head, if one exists + * + * \param element The dom_html_table_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_delete_t_head( + dom_html_table_element *element) +{ + dom_html_table_section_element *t_head; + dom_html_table_element_get_t_head(element, &t_head); + _dom_node_remove_child((dom_node_internal *)element, + (dom_node_internal *)t_head, + (dom_node_internal **)&t_head); + element->t_head = NULL; + return DOM_NO_ERR; +} + +/** + * Get or Create the table Body + * + * \param element The dom_html_table_element object + * \param t_head The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_create_t_body( + dom_html_table_element *element, + dom_html_table_section_element **t_body) +{ + dom_html_collection *t_bodies; + uint32_t len; + dom_html_table_element_get_t_bodies(element, + &t_bodies); + dom_html_collection_get_length(t_bodies, + &len); + + if(len == 0) { + dom_exception exp; + dom_html_document *doc = (dom_html_document *) + ((dom_node_internal *) element)->owner; + exp = _dom_html_table_section_element_create(doc, + doc->memoised[hds_TBODY], + ((dom_node_internal *)element)->namespace, + ((dom_node_internal *)element)->prefix, + t_body); + if(exp != DOM_NO_ERR) { + return exp; + } + return _dom_node_append_child((dom_node_internal *)element, + (dom_node_internal *)*t_body, + (dom_node_internal **)t_body); + + } else { + return dom_html_collection_item(t_bodies, + 0, (dom_node **)t_body); + } + return DOM_NO_ERR; +} +/** + * Insert a new Row into the table + * + * \param element The dom_html_table_element object + * \param index The Index to insert the Row + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_insert_row( + dom_html_table_element *element, + int32_t index, + dom_html_element **row) +{ + dom_exception exp; + dom_html_collection* rows; + uint32_t len; + dom_html_document *doc = (dom_html_document *) + ((dom_node_internal *) element)->owner; + + exp = dom_html_table_element_get_rows(element, + &rows); + if(exp != DOM_NO_ERR) { + return exp; + } + exp = dom_html_collection_get_length(rows, + &len); + + exp = _dom_html_table_row_element_create(doc, + ((dom_node_internal *)element)->namespace, + ((dom_node_internal *)element)->prefix, + (dom_html_table_row_element **)row); + if(exp != DOM_NO_ERR) { + return exp; + } + + if(index > (int32_t)len || index < -1) { + return DOM_INDEX_SIZE_ERR; + } else if(len == 0) { + dom_html_table_section_element *new_body; + exp = dom_html_table_element_create_t_body(element, + &new_body); + if(exp != DOM_NO_ERR) { + return exp; + } + + return _dom_node_append_child((dom_node_internal *)new_body, + (dom_node_internal *)*row, + (dom_node_internal **)row); + + } else { + if(index ==-1) { + index = (int32_t)len; + } + + dom_html_collection* rows; + dom_html_table_section_element *t_head; + dom_html_table_section_element *t_foot; + uint32_t window_len = 0, section_len; + + dom_html_table_element_get_t_head(element, &t_head); + dom_html_table_section_element_get_rows(t_head, &rows); + dom_html_collection_get_length(rows, §ion_len); + + if(window_len + section_len > (uint32_t)index || + window_len + section_len == len) { + return dom_html_table_section_element_insert_row(t_head, + index-window_len, row); + } + + window_len += section_len; + + dom_node_internal *n = (dom_node_internal *)element; + + for (n = n->first_child; n != NULL; n = n->next) { + if((n->type == DOM_ELEMENT_NODE) && + dom_string_caseless_isequal(doc->memoised[hds_TBODY],n->name)) { + + dom_html_table_section_element_get_rows((dom_html_table_section_element *)n, &rows); + dom_html_collection_get_length(rows, §ion_len); + + if(window_len + section_len > (uint32_t)index || + window_len + section_len == len) { + return dom_html_table_section_element_insert_row( + (dom_html_table_section_element *)n, + index-window_len, row); + } + + window_len += section_len; + } + } + dom_html_table_element_get_t_foot(element, &t_foot); + dom_html_table_section_element_get_rows(t_foot, &rows); + dom_html_collection_get_length(rows, §ion_len); + if(window_len + section_len > (uint32_t)index || + window_len +section_len == len) { + return dom_html_table_section_element_insert_row(t_foot, + index-window_len, row); + } + return DOM_INDEX_SIZE_ERR; + } +} +/** + * Delete the table Head, if one exists + * + * \param element The dom_html_table_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_element_delete_row( + dom_html_table_element *element, + int32_t index) +{ + dom_exception exp; + dom_html_collection* rows; + uint32_t len; + dom_html_document *doc = (dom_html_document *) + ((dom_node_internal *) element)->owner; + + exp = dom_html_table_element_get_rows(element, + &rows); + if(exp != DOM_NO_ERR) { + return exp; + } + exp = dom_html_collection_get_length(rows, + &len); + + if(exp != DOM_NO_ERR) { + return exp; + } + + if(index >= (int32_t)len || index < -1 || len ==0) { + return DOM_INDEX_SIZE_ERR; + } else { + if(index ==-1) { + index = (int32_t)len-1; + } + dom_html_collection* rows; + dom_html_table_section_element *t_head; + dom_html_table_section_element *t_foot; + uint32_t window_len = 0, section_len; + dom_html_table_element_get_t_head(element, &t_head); + dom_html_table_section_element_get_rows(t_head, &rows); + dom_html_collection_get_length(rows, §ion_len); + if(window_len + section_len > (uint32_t)index) { + return dom_html_table_section_element_delete_row(t_head, + index-window_len); + } + window_len += section_len; + dom_node_internal *n = (dom_node_internal *)element; + for (n = n->first_child; n != NULL; n = n->next) { + if((n->type == DOM_ELEMENT_NODE) && + dom_string_caseless_isequal(doc->memoised[hds_TBODY],n->name)) { + dom_html_table_section_element_get_rows((dom_html_table_section_element *)n, &rows); + dom_html_collection_get_length(rows, §ion_len); + if(window_len + section_len > (uint32_t)index) { + return dom_html_table_section_element_delete_row( + (dom_html_table_section_element *)n, + index-window_len); + } + window_len += section_len; + } + } + exp = dom_html_table_element_get_t_foot(element, &t_foot); + dom_html_table_section_element_get_rows(t_foot, &rows); + dom_html_collection_get_length(rows, §ion_len); + if(window_len + section_len > (uint32_t)index) { + return dom_html_table_section_element_delete_row(t_foot, + index-window_len); + } + return DOM_INDEX_SIZE_ERR; + } + +} diff --git a/src/html/html_table_element.h b/src/html/html_table_element.h index 2e182d5..caabbe8 100644 --- a/src/html/html_table_element.h +++ b/src/html/html_table_element.h @@ -3,5 +3,61 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_table_element_h_ +#define dom_internal_html_table_element_h_ + +#include <dom/html/html_table_element.h> +#include "html/html_element.h" + +struct dom_html_table_element { + struct dom_html_element base; + /**< The base class */ + dom_html_table_caption_element* caption; + /**< The caption associated with the table*/ + dom_html_table_section_element* t_head; + /**< The thead element associated with the table*/ + dom_html_table_section_element* t_foot; + /**< The tfoot element associated with the table*/ +}; + +/* Create a dom_html_table_element object */ +dom_exception _dom_html_table_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_element **ele); + +/* Initialise a dom_html_table_element object */ +dom_exception _dom_html_table_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_element *ele); + +/* Finalise a dom_html_table_element object */ +void _dom_html_table_element_finalise(struct dom_html_table_element *ele); + +/* Destroy a dom_html_table_element object */ +void _dom_html_table_element_destroy(struct dom_html_table_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_table_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_table_element_destroy(dom_node_internal *node); +dom_exception _dom_html_table_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_TABLE_ELEMENT_PROTECT_VTABLE \ + _dom_html_table_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_TABLE_ELEMENT \ + _dom_virtual_html_table_element_destroy, \ + _dom_html_table_element_copy + +#endif + +bool table_rows_callback(struct dom_node_internal *node, void *ctx); +bool table_t_bodies_callback(struct dom_node_internal *node, void *ctx); +dom_exception dom_html_table_element_create_t_body( + dom_html_table_element *element, + dom_html_table_section_element **t_body); diff --git a/src/html/html_tablecaption_element.c b/src/html/html_tablecaption_element.c index 2e182d5..d2c3fc6 100644 --- a/src/html/html_tablecaption_element.c +++ b/src/html/html_tablecaption_element.c @@ -3,5 +3,158 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_tablecaption_element.h> + +#include "html/html_document.h" +#include "html/html_tablecaption_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_TABLE_CAPTION_ELEMENT + }, + DOM_HTML_TABLE_CAPTION_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_table_caption_element object + * + * \table_caption doc The document object + * \table_caption ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_caption_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_caption_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_table_caption_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_table_caption_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_table_caption_element object + * + * \table_caption doc The document object + * \table_caption ele The dom_html_table_caption_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_caption_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_caption_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_CAPTION], + namespace, prefix); +} + +/** + * Finalise a dom_html_table_caption_element object + * + * \table_caption ele The dom_html_table_caption_element object + */ +void _dom_html_table_caption_element_finalise(struct dom_html_table_caption_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_table_caption_element object + * + * \table_caption ele The dom_html_table_caption_element object + */ +void _dom_html_table_caption_element_destroy(struct dom_html_table_caption_element *ele) +{ + _dom_html_table_caption_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_table_caption_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_table_caption_element_destroy(dom_node_internal *node) +{ + _dom_html_table_caption_element_destroy((struct dom_html_table_caption_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_table_caption_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_table_caption_element_get_##attr( \ + dom_html_table_caption_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ + dom_exception dom_html_table_caption_element_set_##attr( \ + dom_html_table_caption_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(align); diff --git a/src/html/html_tablecaption_element.h b/src/html/html_tablecaption_element.h index 2e182d5..b1cfd3b 100644 --- a/src/html/html_tablecaption_element.h +++ b/src/html/html_tablecaption_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_table_caption_element_h_ +#define dom_internal_html_table_caption_element_h_ + +#include <dom/html/html_tablecaption_element.h> +#include "html/html_element.h" + + +struct dom_html_table_caption_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_table_caption_element object */ +dom_exception _dom_html_table_caption_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_caption_element **ele); + +/* Initialise a dom_html_table_caption_element object */ +dom_exception _dom_html_table_caption_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_caption_element *ele); + +/* Finalise a dom_html_table_caption_element object */ +void _dom_html_table_caption_element_finalise(struct dom_html_table_caption_element *ele); + +/* Destroy a dom_html_table_caption_element object */ +void _dom_html_table_caption_element_destroy(struct dom_html_table_caption_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_table_caption_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_table_caption_element_destroy(dom_node_internal *node); +dom_exception _dom_html_table_caption_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_TABLE_CAPTION_ELEMENT_PROTECT_VTABLE \ + _dom_html_table_caption_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_TABLE_CAPTION_ELEMENT \ + _dom_virtual_html_table_caption_element_destroy, \ + _dom_html_table_caption_element_copy + +#endif diff --git a/src/html/html_tablecell_element.c b/src/html/html_tablecell_element.c index 2e182d5..cc596c1 100644 --- a/src/html/html_tablecell_element.c +++ b/src/html/html_tablecell_element.c @@ -3,5 +3,311 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_tablecell_element.h> + +#include "html/html_document.h" +#include "html/html_tablecell_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_TABLE_CELL_ELEMENT + }, + DOM_HTML_TABLE_CELL_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_table_cell_element table_cell + * + * \param doc The document table_cell + * \param ele The returned element table_cell + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_cell_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_cell_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_table_cell_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_table_cell_element_initialise(doc, tag_name, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_table_cell_element table_cell + * + * \param doc The document table_cell + * \param ele The dom_html_table_cell_element table_cell + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_cell_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_cell_element *ele) +{ + ele->id = -1; + return _dom_html_element_initialise(doc, &ele->base, + tag_name, + namespace, prefix); +} + +/** + * Finalise a dom_html_table_cell_element table_cell + * + * \param ele The dom_html_table_cell_element table_cell + */ +void _dom_html_table_cell_element_finalise(struct dom_html_table_cell_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_table_cell_element table_cell + * + * \param ele The dom_html_table_cell_element table_cell + */ +void _dom_html_table_cell_element_destroy(struct dom_html_table_cell_element *ele) +{ + _dom_html_table_cell_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_table_cell_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_table_cell_element_destroy(dom_node_internal *node) +{ + _dom_html_table_cell_element_destroy((struct dom_html_table_cell_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_table_cell_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_table_cell_element_get_##attr( \ + dom_html_table_cell_element *element, \ + dom_string **attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} +#define SIMPLE_SET(attr) \ + dom_exception dom_html_table_cell_element_set_##attr( \ + dom_html_table_cell_element *element, \ + dom_string *attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(abbr); +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(axis); +SIMPLE_GET_SET(bg_color); +SIMPLE_GET_SET(ch); +SIMPLE_GET_SET(ch_off); +SIMPLE_GET_SET(headers); +SIMPLE_GET_SET(height); +SIMPLE_GET_SET(scope); +SIMPLE_GET_SET(v_align); +SIMPLE_GET_SET(width); + +/** + * Get the cell_index property + * + * \param table_cell The dom_html_table_cell_element object + * \param cell_index The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_cell_element_get_cell_index( + dom_html_table_cell_element *table_cell, int32_t *cell_index) +{ + if(table_cell->id == -1) { + dom_node_internal *n = ((dom_node_internal *)table_cell)->parent; + dom_html_document *doc = (dom_html_document *)(n->owner); + int32_t cnt = 0; + while(n != NULL) { + if(dom_string_caseless_isequal(doc->memoised[hds_TR],n->name)) { + break; + } + n = n->parent; + } + dom_node_internal *root = n; + while(n != NULL) { + if(n == (dom_node_internal *)table_cell) { + break; + } else if((n->type == DOM_ELEMENT_NODE) && + (dom_string_caseless_isequal(doc->memoised[hds_TD],n->name) || + dom_string_caseless_isequal(doc->memoised[hds_TH],n->name))) { + ((dom_html_table_cell_element *)n)->id = cnt; + cnt += 1; + } + if(n->first_child != NULL) { + n = n->first_child; + } else if(n->next != NULL) { + n = n->next; + } else { + /* No children and siblings */ + struct dom_node_internal *parent = n->parent; + while (n == parent->last_child && + n != root) { + n = parent; + parent = parent->parent; + } + + if(n == root) { + n = NULL; + } else { + n = n->next; + } + } + } + table_cell->id = cnt; + } + *cell_index = table_cell->id; + return DOM_NO_ERR; +} + +/** + * Get the col_span property + * + * \param table_cell The dom_html_table_cell_element object + * \param no_wrap The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_cell_element_get_col_span( + dom_html_table_cell_element *table_cell, int32_t *col_span) +{ + return dom_html_element_get_int32_t_property(&table_cell->base, "colspan", + SLEN("colspan"), col_span); +} + +/** + * Set the col_span property + * + * \param table_cell The dom_html_table_cell_element object + * \param no_wrap The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_cell_element_set_col_span( + dom_html_table_cell_element *table_cell, uint32_t col_span) +{ + return dom_html_element_set_int32_t_property(&table_cell->base, "colspan", + SLEN("colspan"), col_span); +} + +/** + * Get the row_span property + * + * \param table_cell The dom_html_table_cell_element object + * \param no_wrap The returned status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_cell_element_get_row_span( + dom_html_table_cell_element *table_cell, int32_t *row_span) +{ + return dom_html_element_get_int32_t_property(&table_cell->base, "rowspan", + SLEN("rowspan"), row_span); +} + +/** + * Set the row_span property + * + * \param table_cell The dom_html_table_cell_element object + * \param no_wrap The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_cell_element_set_row_span( + dom_html_table_cell_element *table_cell, uint32_t row_span) +{ + return dom_html_element_set_int32_t_property(&table_cell->base, "rowspan", + SLEN("rowspan"), row_span); +} + +/** + * Get the no_wrap property + * + * \param ele The dom_html_table_cell_element object + * \param no_wrap The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_cell_element_get_no_wrap(dom_html_table_cell_element *ele, + bool *no_wrap) +{ + return dom_html_element_get_bool_property(&ele->base, "nowrap", + SLEN("nowrap"), no_wrap); +} + +/** + * Set the no_wrap property + * + * \param ele The dom_html_table_cell_element object + * \param no_wrap The status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_cell_element_set_no_wrap(dom_html_table_cell_element *ele, + bool no_wrap) +{ + return dom_html_element_set_bool_property(&ele->base, "nowrap", + SLEN("nowrap"), no_wrap); +} + diff --git a/src/html/html_tablecell_element.h b/src/html/html_tablecell_element.h index 2e182d5..801c3c0 100644 --- a/src/html/html_tablecell_element.h +++ b/src/html/html_tablecell_element.h @@ -3,5 +3,52 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_table_cell_element_h_ +#define dom_internal_html_table_cell_element_h_ + +#include <dom/html/html_tablecell_element.h> +#include "html/html_element.h" + + +struct dom_html_table_cell_element { + struct dom_html_element base; + /**< The base class */ + int32_t id; + /**< The Index Associated with the cell*/ +}; + +/* Create a dom_html_table_cell_element object */ +dom_exception _dom_html_table_cell_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_cell_element **ele); + +/* Initialise a dom_html_table_cell_element object */ +dom_exception _dom_html_table_cell_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_cell_element *ele); + +/* Finalise a dom_html_table_cell_element object */ +void _dom_html_table_cell_element_finalise(struct dom_html_table_cell_element *ele); + +/* Destroy a dom_html_table_cell_element object */ +void _dom_html_table_cell_element_destroy(struct dom_html_table_cell_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_table_cell_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_table_cell_element_destroy(dom_node_internal *node); +dom_exception _dom_html_table_cell_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_TABLE_CELL_ELEMENT_PROTECT_VTABLE \ + _dom_html_table_cell_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_TABLE_CELL_ELEMENT \ + _dom_virtual_html_table_cell_element_destroy, \ + _dom_html_table_cell_element_copy + +#endif diff --git a/src/html/html_tablecol_element.c b/src/html/html_tablecol_element.c index 2e182d5..cf21a24 100644 --- a/src/html/html_tablecol_element.c +++ b/src/html/html_tablecol_element.c @@ -3,5 +3,186 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_tablecol_element.h> + +#include "html/html_document.h" +#include "html/html_tablecol_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_TABLE_COL_ELEMENT + }, + DOM_HTML_TABLE_COL_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_table_col_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_col_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_col_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_table_col_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_table_col_element_initialise(doc, tag_name, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_table_col_element object + * + * \param doc The document object + * \param ele The dom_html_table_col_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_col_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_col_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + tag_name, + namespace, prefix); +} + +/** + * Finalise a dom_html_table_col_element object + * + * \param ele The dom_html_table_col_element object + */ +void _dom_html_table_col_element_finalise(struct dom_html_table_col_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_table_col_element object + * + * \param ele The dom_html_table_col_element object + */ +void _dom_html_table_col_element_destroy(struct dom_html_table_col_element *ele) +{ + _dom_html_table_col_element_finalise(ele); + free(ele); +} + +/** + * Get the width Property + * + * \param table_col The dom_html_table_col_element object + */ +dom_exception dom_html_table_col_element_get_span( + dom_html_table_col_element *table_col, int32_t *span) +{ + return dom_html_element_get_int32_t_property(&table_col->base, "span", + SLEN("span"), span); +} + +/** + * Set the width Property + * + * \param table_col The dom_html_table_col_element object + */ +dom_exception dom_html_table_col_element_set_span( + dom_html_table_col_element *table_col, uint32_t span) +{ + return dom_html_element_set_int32_t_property(&table_col->base, "span", + SLEN("span"), span); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_table_col_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_table_col_element_destroy(dom_node_internal *node) +{ + _dom_html_table_col_element_destroy((struct dom_html_table_col_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_table_col_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_table_col_element_get_##attr( \ + dom_html_table_col_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ + dom_exception dom_html_table_col_element_set_##attr( \ + dom_html_table_col_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(ch); +SIMPLE_GET_SET(ch_off); +SIMPLE_GET_SET(v_align); +SIMPLE_GET_SET(width); diff --git a/src/html/html_tablecol_element.h b/src/html/html_tablecol_element.h index 2e182d5..a8e6fa7 100644 --- a/src/html/html_tablecol_element.h +++ b/src/html/html_tablecol_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_table_col_element_h_ +#define dom_internal_html_table_col_element_h_ + +#include <dom/html/html_tablecol_element.h> +#include "html/html_element.h" + + +struct dom_html_table_col_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_table_col_element object */ +dom_exception _dom_html_table_col_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_col_element **ele); + +/* Initialise a dom_html_table_col_element object */ +dom_exception _dom_html_table_col_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_col_element *ele); + +/* Finalise a dom_html_table_col_element object */ +void _dom_html_table_col_element_finalise(struct dom_html_table_col_element *ele); + +/* Destroy a dom_html_table_col_element object */ +void _dom_html_table_col_element_destroy(struct dom_html_table_col_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_table_col_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_table_col_element_destroy(dom_node_internal *node); +dom_exception _dom_html_table_col_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_TABLE_COL_ELEMENT_PROTECT_VTABLE \ + _dom_html_table_col_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_TABLE_COL_ELEMENT \ + _dom_virtual_html_table_col_element_destroy, \ + _dom_html_table_col_element_copy + +#endif diff --git a/src/html/html_tablerow_element.c b/src/html/html_tablerow_element.c index 2e182d5..fb3e27b 100644 --- a/src/html/html_tablerow_element.c +++ b/src/html/html_tablerow_element.c @@ -3,5 +3,373 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_tablerow_element.h> +#include <dom/html/html_table_element.h> + +#include "html/html_document.h" +#include "html/html_tablerow_element.h" +#include "html/html_collection.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_TABLE_ROW_ELEMENT + }, + DOM_HTML_TABLE_ROW_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_table_row_element table_row + * + * \param doc The document table_row + * \param ele The returned element table_row + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_row_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_row_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_table_row_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_table_row_element_initialise(doc, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_table_row_element table_row + * + * \param doc The document table_row + * \param ele The dom_html_table_row_element table_row + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_row_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_row_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_TR], + namespace, prefix); +} + +/** + * Finalise a dom_html_table_row_element table_row + * + * \param ele The dom_html_table_row_element table_row + */ +void _dom_html_table_row_element_finalise(struct dom_html_table_row_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_table_row_element table_row + * + * \param ele The dom_html_table_row_element table_row + */ +void _dom_html_table_row_element_destroy(struct dom_html_table_row_element *ele) +{ + _dom_html_table_row_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_table_row_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_table_row_element_destroy(dom_node_internal *node) +{ + _dom_html_table_row_element_destroy((struct dom_html_table_row_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_table_row_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_table_row_element_get_##attr( \ + dom_html_table_row_element *element, \ + dom_string **attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} +#define SIMPLE_SET(attr) \ + dom_exception dom_html_table_row_element_set_##attr( \ + dom_html_table_row_element *element, \ + dom_string *attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(bg_color); +SIMPLE_GET_SET(ch); +SIMPLE_GET_SET(ch_off); +SIMPLE_GET_SET(v_align); + +/** + * Get the index of the Row in logical order + * + * \param element The dom_html_table_row_element object + * \param index The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_row_element_get_row_index( + dom_html_table_row_element *table_row, int32_t *row_index) +{ + dom_node_internal *n = ((dom_node_internal *)table_row)->parent; + dom_node_internal *parent = n; + dom_html_document *doc = (dom_html_document *) ((dom_node_internal *) table_row)->owner; + uint32_t count = 0; + for(n = n->first_child; n != (dom_node_internal *)table_row; + n = n->next) { + if(n->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(n->name,doc->memoised[hds_TR])) { + count += 1; + } + } + + if(dom_string_caseless_isequal((parent->parent)->name, doc->memoised[hds_TABLE]) && + dom_string_caseless_isequal(parent->name, doc->memoised[hds_THEAD]) + ) { + *row_index = count; + }else if(dom_string_caseless_isequal((parent->parent)->name, doc->memoised[hds_TABLE]) && + (dom_string_caseless_isequal(parent->name, doc->memoised[hds_TBODY]) || + dom_string_caseless_isequal(parent->name, doc->memoised[hds_TFOOT]))) { + uint32_t len; + n = parent->parent; + dom_html_table_section_element *t_head; + dom_html_collection *rows; + dom_html_table_element_get_t_head( + (dom_html_table_element *)(parent->parent), + &t_head); + dom_html_table_section_element_get_rows(t_head, + &rows); + dom_html_collection_get_length(rows, + &len); + count += len; + for(n = n->first_child;n != parent && n != NULL; + n = n->next) { + if(dom_string_caseless_isequal(n->name, doc->memoised[hds_TBODY])) { + dom_html_table_section_element_get_rows( + (dom_html_table_section_element *)n, + &rows); + dom_html_collection_get_length(rows, &len); + count += len; + } + } + *row_index = (int32_t)count; + + } else { + return DOM_HIERARCHY_REQUEST_ERR; + } + return DOM_NO_ERR; +} + +/** + * Get the index of a row within its Section + * + * \param element The dom_html_table_row_element object + * \param index The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_row_element_get_section_row_index( + dom_html_table_row_element *table_row, int32_t *section_row_index) +{ + dom_node_internal *n = ((dom_node_internal *)table_row)->parent; + dom_html_document *doc = (dom_html_document *) ((dom_node_internal *) table_row)->owner; + int32_t count = 0; + for(n = n->first_child; n != (dom_node_internal *)table_row; + n = n->next) { + if(n->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(n->name, doc->memoised[hds_TR])) { + count += 1; + } + } + *section_row_index = count; + return DOM_NO_ERR; +} + +/** + * Callback for creating the Cells collection + * + * \param node The dom_node_internal object + * \param ctx The dom_html_document object (void *) + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +bool table_cells_callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_TD])) { + return true; + } + return false; +} + +/** + * Get the Cells collection + * + * \param element The dom_html_table_element object + * \param t_bodies The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_row_element_get_cells( + dom_html_table_row_element *element, + dom_html_collection **cells) +{ + dom_html_document *doc = (dom_html_document *) ((dom_node_internal *) element)->owner; + return _dom_html_collection_create(doc, (dom_node_internal *)element, + table_cells_callback, (void *)doc, cells); +} + +/** + * Insert Cell before the given Index + * + * \param element The dom_html_table_row_element object + * \param index The Index of the Cell node to be inserted + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_row_element_insert_cell( + dom_html_table_row_element *element, + int32_t index, dom_html_element **cell) { + dom_html_document *doc = (dom_html_document *) ((dom_node_internal *) element)->owner; + + dom_node *node; /*< The node at the (index)th position*/ + + dom_html_collection *cells; /*< The collection of cells in input table_row_element*/ + uint32_t len; /*< The size of the cell collection */ + dom_exception exp; /*< Variable for getting the exceptions*/ + exp = _dom_html_element_create(doc, doc->memoised[hds_TD], + ((dom_node_internal *)element)->namespace, + ((dom_node_internal *)element)->prefix, + cell); + if(exp != DOM_NO_ERR) + return exp; + + exp = dom_html_table_row_element_get_cells(element, &cells); + if(exp != DOM_NO_ERR) + return exp; + + exp = dom_html_collection_get_length(cells, &len); + if(exp != DOM_NO_ERR) + return exp; + + if(index < -1 || index > (int32_t)len) { + /* Check for index validity */ + return DOM_INDEX_SIZE_ERR; + } else if(index == -1 || index == (int32_t)len) { + return _dom_node_append_child((dom_node_internal *)element, + (dom_node_internal *)*cell, + (dom_node_internal **)cell); + } else { + dom_html_collection_item(cells, + index, &node); + return _dom_node_insert_before((dom_node_internal *)element, + (dom_node_internal *)*cell, (dom_node_internal *)node, + (dom_node_internal **)cell); + } +} + +/** + * Delete Cell at given Index + * + * \param element The dom_html_table_row_element object + * \param index The Index of the Cell node to be deleted + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_row_element_delete_cell( + dom_html_table_row_element *element, + int32_t index) { + dom_node *node; /*< The node at the (index)th position*/ + + dom_html_collection *cells; /*< The collection of rows in input table_row_element*/ + uint32_t len; /*< The size of the row collection */ + + dom_exception exp; /*< Temporary variable to store & check the exceptions*/ + + exp = dom_html_table_row_element_get_cells(element, &cells); + if(exp != DOM_NO_ERR) { + return exp; + } + + exp = dom_html_collection_get_length(cells, &len); + if(exp != DOM_NO_ERR) { + return exp; + } + + if(index < -1 || index >= (int32_t)len || len ==0) { + /* Check for index validity */ + return DOM_INDEX_SIZE_ERR; + } else if(index == -1) { + exp = dom_html_collection_item(cells, + len-1, &node); + } else { + exp = dom_html_collection_item(cells, + index, &node); + } + return _dom_node_remove_child((dom_node_internal *)element, + (dom_node_internal *)node, + (dom_node_internal **)&node); + +} + diff --git a/src/html/html_tablerow_element.h b/src/html/html_tablerow_element.h index 2e182d5..2401790 100644 --- a/src/html/html_tablerow_element.h +++ b/src/html/html_tablerow_element.h @@ -3,5 +3,51 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_table_row_element_h_ +#define dom_internal_html_table_row_element_h_ + +#include <dom/html/html_tablerow_element.h> +#include "html/html_element.h" + +struct dom_html_table_row_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_table_row_element object */ +dom_exception _dom_html_table_row_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_row_element **ele); + +/* Initialise a dom_html_table_row_element object */ +dom_exception _dom_html_table_row_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_table_row_element *ele); + +/* Finalise a dom_html_table_row_element object */ +void _dom_html_table_row_element_finalise(struct dom_html_table_row_element *ele); + +/* Destroy a dom_html_table_row_element object */ +void _dom_html_table_row_element_destroy(struct dom_html_table_row_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_table_row_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_table_row_element_destroy(dom_node_internal *node); +dom_exception _dom_html_table_row_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_TABLE_ROW_ELEMENT_PROTECT_VTABLE \ + _dom_html_table_row_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_TABLE_ROW_ELEMENT \ + _dom_virtual_html_table_row_element_destroy, \ + _dom_html_table_row_element_copy + +#endif +bool table_cells_callback(struct dom_node_internal *node, void *ctx); + diff --git a/src/html/html_tablesection_element.c b/src/html/html_tablesection_element.c index 2e182d5..b35cfb4 100644 --- a/src/html/html_tablesection_element.c +++ b/src/html/html_tablesection_element.c @@ -3,5 +3,284 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> + +#include <dom/html/html_tablesection_element.h> + +#include "html/html_document.h" +#include "html/html_tablesection_element.h" +#include "html/html_tablerow_element.h" + +#include "html/html_collection.h" +#include "html/html_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_TABLE_SECTION_ELEMENT + }, + DOM_HTML_TABLE_SECTION_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_table_section_element object + * + * \table_section doc The document object + * \table_section ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_section_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_section_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_table_section_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_table_section_element_initialise(doc, tag_name, namespace, prefix, *ele); +} + +/** + * Initialise a dom_html_table_section_element object + * + * \table_section doc The document object + * \table_section ele The dom_html_table_section_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_table_section_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_section_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + tag_name, + namespace, prefix); +} + +/** + * Finalise a dom_html_table_section_element object + * + * \table_section ele The dom_html_table_section_element object + */ +void _dom_html_table_section_element_finalise(struct dom_html_table_section_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_table_section_element object + * + * \table_section ele The dom_html_table_section_element object + */ +void _dom_html_table_section_element_destroy(struct dom_html_table_section_element *ele) +{ + _dom_html_table_section_element_finalise(ele); + free(ele); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_table_section_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_table_section_element_destroy(dom_node_internal *node) +{ + _dom_html_table_section_element_destroy((struct dom_html_table_section_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_table_section_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_table_section_element_get_##attr( \ + dom_html_table_section_element *element, \ + dom_string **attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} +#define SIMPLE_SET(attr) \ + dom_exception dom_html_table_section_element_set_##attr( \ + dom_html_table_section_element *element, \ + dom_string *attr) \ +{ \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)-> \ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ +} + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) +SIMPLE_GET_SET(align); +SIMPLE_GET_SET(ch); +SIMPLE_GET_SET(ch_off); +SIMPLE_GET_SET(v_align); + +/* The callback function for _dom_html_collection_create*/ +bool table_section_callback(struct dom_node_internal *node, void *ctx) +{ + if(node->type == DOM_ELEMENT_NODE && + dom_string_caseless_isequal(node->name, + ((dom_html_document *)ctx)->memoised[hds_TR])) { + return true; + } + return false; +} + +/** + * Get the rows collection + * + * \param element The dom_html_table_section_element object + * \param rows The Status + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_section_element_get_rows( + dom_html_table_section_element *element, + dom_html_collection **rows) +{ + dom_html_document *doc = (dom_html_document *) ((dom_node_internal *) element)->owner; + return _dom_html_collection_create(doc, (dom_node_internal *)element, + table_section_callback, (void *)doc, rows); +} + +/** + * Insert Row before the given Index + * + * \param element The dom_html_table_section_element object + * \param index The Index of the Row node to be inserted + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_section_element_insert_row( + dom_html_table_section_element *element, + int32_t index, dom_html_element **new_row) { + dom_html_document *doc = (dom_html_document *) ((dom_node_internal *) element)->owner; + + dom_node *node; /*< The node at the (index)th position*/ + + dom_html_collection *rows; /*< The collection of rows in input table_section_element*/ + uint32_t len; /*< The size of the row collection */ + dom_exception exp; /*< Variable for getting the exceptions*/ + exp = _dom_html_table_row_element_create(doc, + ((dom_node_internal *)element)->namespace, + ((dom_node_internal *)element)->prefix, + (dom_html_table_row_element **)new_row); + if(exp != DOM_NO_ERR) + return exp; + + exp = dom_html_table_section_element_get_rows(element, &rows); + if(exp != DOM_NO_ERR) + return exp; + + exp = dom_html_collection_get_length(rows, &len); + if(exp != DOM_NO_ERR) + return exp; + + if(index < -1 || index > (int32_t)len) { + /* Check for index validity */ + return DOM_INDEX_SIZE_ERR; + } else if(index == -1 || index == (int32_t)len) { + return _dom_node_append_child((dom_node_internal *)element, + (dom_node_internal *)*new_row, + (dom_node_internal **)new_row); + } else { + dom_html_collection_item(rows, + index, &node); + return _dom_node_insert_before((dom_node_internal *)element, + (dom_node_internal *)*new_row, (dom_node_internal *)node, + (dom_node_internal **)new_row); + } +} + +/** + * Delete Row at given Index + * + * \param element The dom_html_table_section_element object + * \param index The Index of the Row node to be deleted + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception dom_html_table_section_element_delete_row( + dom_html_table_section_element *element, + int32_t index) { + dom_node *node; /*< The node at the (index)th position*/ + + dom_html_collection *rows; /*< The collection of rows in input table_section_element*/ + uint32_t len; /*< The size of the row collection */ + + dom_exception exp; /*< Temporary variable to store & check the exceptions*/ + + exp = dom_html_table_section_element_get_rows(element, &rows); + if(exp != DOM_NO_ERR) { + return exp; + } + + exp = dom_html_collection_get_length(rows, &len); + if(exp != DOM_NO_ERR) { + return exp; + } + + if(index < -1 || index >= (int32_t)len) { + /* Check for index validity */ + return DOM_INDEX_SIZE_ERR; + } else if(index == -1) { + exp = dom_html_collection_item(rows, + len-1, &node); + } else { + exp = dom_html_collection_item(rows, + index, &node); + } + exp = _dom_node_remove_child((dom_node_internal *)element, + (dom_node_internal *)node, + (dom_node_internal **)&node); + + return DOM_NO_ERR; +} diff --git a/src/html/html_tablesection_element.h b/src/html/html_tablesection_element.h index 2e182d5..387882a 100644 --- a/src/html/html_tablesection_element.h +++ b/src/html/html_tablesection_element.h @@ -3,5 +3,52 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_table_section_element_h_ +#define dom_internal_html_table_section_element_h_ + +#include <dom/html/html_tablesection_element.h> + +#include "html/html_element.h" + +struct dom_html_table_section_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_table_section_element object */ +dom_exception _dom_html_table_section_element_create(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_section_element **ele); + +/* Initialise a dom_html_table_section_element object */ +dom_exception _dom_html_table_section_element_initialise(struct dom_html_document *doc, + dom_string *tag_name, dom_string *namespace, dom_string *prefix, + struct dom_html_table_section_element *ele); + +/* Finalise a dom_html_table_section_element object */ +void _dom_html_table_section_element_finalise(struct dom_html_table_section_element *ele); + +/* Destroy a dom_html_table_section_element object */ +void _dom_html_table_section_element_destroy(struct dom_html_table_section_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_table_section_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_table_section_element_destroy(dom_node_internal *node); +dom_exception _dom_html_table_section_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_TABLE_SECTION_ELEMENT_PROTECT_VTABLE \ + _dom_html_table_section_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_TABLE_SECTION_ELEMENT \ + _dom_virtual_html_table_section_element_destroy, \ + _dom_html_table_section_element_copy + +#endif +bool table_section_callback(struct dom_node_internal *node, void *ctx); + diff --git a/src/html/html_text_area_element.c b/src/html/html_text_area_element.c index eea5b4e..ac90a76 100644 --- a/src/html/html_text_area_element.c +++ b/src/html/html_text_area_element.c @@ -438,11 +438,11 @@ dom_exception dom_html_text_area_element_blur(dom_html_text_area_element *ele) bool success = false; assert(doc != NULL); - /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ + /* This event does not bubble & is Non-cancellable. Mentioned in w3 specs. More research is needed to prove why. */ return _dom_dispatch_generic_event((dom_document *) doc, (dom_event_target *) ele, - doc->memoised[hds_blur], true, - true, &success); + doc->memoised[hds_blur], false, + false, &success); } /** @@ -458,11 +458,11 @@ dom_exception dom_html_text_area_element_focus(dom_html_text_area_element *ele) bool success = false; assert(doc != NULL); - /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ + /* This event does not bubble & is Non-cancellable. Mentioned in w3 specs. More research is needed to prove why. */ return _dom_dispatch_generic_event((dom_document *)doc, (dom_event_target *) ele, - doc->memoised[hds_focus], true, - true, &success); + doc->memoised[hds_focus], false, + false, &success); } /** @@ -478,9 +478,9 @@ dom_exception dom_html_text_area_element_select(dom_html_text_area_element *ele) bool success = false; assert(doc != NULL); - /** \todo Is this event (a) default (b) bubbling and (c) cancelable? */ + /* This event bubbles & is non-cancelable. Mentioned in w3 specs. More research is needed to prove why. */ return _dom_dispatch_generic_event((dom_document *)doc, (dom_event_target *) ele, doc->memoised[hds_select], true, - true, &success); + false, &success); } diff --git a/src/html/html_ulist_element.c b/src/html/html_ulist_element.c index 2e182d5..e7f8bb3 100644 --- a/src/html/html_ulist_element.c +++ b/src/html/html_ulist_element.c @@ -3,5 +3,182 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar<rsk1coder99@gmail.com> */ +#include <assert.h> +#include <stdlib.h> +#include <dom/html/html_ulist_element.h> + +#include "html/html_document.h" +#include "html/html_ulist_element.h" + +#include "core/node.h" +#include "core/attr.h" +#include "utils/utils.h" + +static struct dom_element_protected_vtable _protect_vtable = { + { + DOM_NODE_PROTECT_VTABLE_HTML_U_LIST_ELEMENT + }, + DOM_HTML_U_LIST_ELEMENT_PROTECT_VTABLE +}; + +/** + * Create a dom_html_u_list_element object + * + * \param doc The document object + * \param ele The returned element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_u_list_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *u_listfix, + struct dom_html_u_list_element **ele) +{ + struct dom_node_internal *node; + + *ele = malloc(sizeof(dom_html_u_list_element)); + if (*ele == NULL) + return DOM_NO_MEM_ERR; + + /* Set up vtables */ + node = (struct dom_node_internal *) *ele; + node->base.vtable = &_dom_html_element_vtable; + node->vtable = &_protect_vtable; + + return _dom_html_u_list_element_initialise(doc, namespace, u_listfix, *ele); +} + +/** + * Initialise a dom_html_u_list_element object + * + * \param doc The document object + * \param ele The dom_html_u_list_element object + * \return DOM_NO_ERR on success, appropriate dom_exception on failure. + */ +dom_exception _dom_html_u_list_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *u_listfix, + struct dom_html_u_list_element *ele) +{ + return _dom_html_element_initialise(doc, &ele->base, + doc->memoised[hds_UL], + namespace, u_listfix); +} + +/** + * Finalise a dom_html_u_list_element object + * + * \param ele The dom_html_u_list_element object + */ +void _dom_html_u_list_element_finalise(struct dom_html_u_list_element *ele) +{ + _dom_html_element_finalise(&ele->base); +} + +/** + * Destroy a dom_html_u_list_element object + * + * \param ele The dom_html_u_list_element object + */ +void _dom_html_u_list_element_destroy(struct dom_html_u_list_element *ele) +{ + _dom_html_u_list_element_finalise(ele); + free(ele); +} + +/** + * Get the compact Property + * + * \param u_list The dom_html_u_list_element object + */ +dom_exception dom_html_u_list_element_get_compact( + dom_html_u_list_element *u_list, bool *compact) +{ + return dom_html_element_get_bool_property(&u_list->base, "compact", + SLEN("compact"), compact); +} + +/** + * Set the compact Property + * + * \param u_list The dom_html_u_list_element object + */ +dom_exception dom_html_u_list_element_set_compact( + dom_html_u_list_element *u_list, bool compact) +{ + return dom_html_element_set_bool_property(&u_list->base, "compact", + SLEN("compact"), compact); +} + +/*------------------------------------------------------------------------*/ +/* The protected virtual functions */ + +/* The virtual function used to parse attribute value, see src/core/element.c + * for detail */ +dom_exception _dom_html_u_list_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed) +{ + UNUSED(ele); + UNUSED(name); + + dom_string_ref(value); + *parsed = value; + + return DOM_NO_ERR; +} + +/* The virtual destroy function, see src/core/node.c for detail */ +void _dom_virtual_html_u_list_element_destroy(dom_node_internal *node) +{ + _dom_html_u_list_element_destroy((struct dom_html_u_list_element *) node); +} + +/* The virtual copy function, see src/core/node.c for detail */ +dom_exception _dom_html_u_list_element_copy(dom_node_internal *old, + dom_node_internal **copy) +{ + return _dom_html_element_copy(old, copy); +} + +/*-----------------------------------------------------------------------*/ +/* API functions */ + +#define SIMPLE_GET(attr) \ + dom_exception dom_html_u_list_element_get_##attr( \ + dom_html_u_list_element *element, \ + dom_string **attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_get_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } +#define SIMPLE_SET(attr) \ + dom_exception dom_html_u_list_element_set_##attr( \ + dom_html_u_list_element *element, \ + dom_string *attr) \ + { \ + dom_exception ret; \ + dom_string *_memo_##attr; \ + \ + _memo_##attr = \ + ((struct dom_html_document *) \ + ((struct dom_node_internal *)element)->owner)->\ + memoised[hds_##attr]; \ + \ + ret = dom_element_set_attribute(element, _memo_##attr, attr); \ + \ + return ret; \ + } + +#define SIMPLE_GET_SET(attr) SIMPLE_GET(attr) SIMPLE_SET(attr) + +SIMPLE_GET_SET(type); diff --git a/src/html/html_ulist_element.h b/src/html/html_ulist_element.h index 2e182d5..7e03f47 100644 --- a/src/html/html_ulist_element.h +++ b/src/html/html_ulist_element.h @@ -3,5 +3,50 @@ * Licensed under the MIT License, * http://www.opensource.org/licenses/mit-license.php * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com> + * Copyright 2014 Rupinder Singh Khokhar <rsk1coder99@gmail.com> */ +#ifndef dom_internal_html_u_list_element_h_ +#define dom_internal_html_u_list_element_h_ + +#include <dom/html/html_ulist_element.h> +#include "html/html_element.h" + + +struct dom_html_u_list_element { + struct dom_html_element base; + /**< The base class */ +}; + +/* Create a dom_html_u_list_element object */ +dom_exception _dom_html_u_list_element_create(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_u_list_element **ele); + +/* Initialise a dom_html_u_list_element object */ +dom_exception _dom_html_u_list_element_initialise(struct dom_html_document *doc, + dom_string *namespace, dom_string *prefix, + struct dom_html_u_list_element *ele); + +/* Finalise a dom_html_u_list_element object */ +void _dom_html_u_list_element_finalise(struct dom_html_u_list_element *ele); + +/* Destroy a dom_html_u_list_element object */ +void _dom_html_u_list_element_destroy(struct dom_html_u_list_element *ele); + +/* The protected virtual functions */ +dom_exception _dom_html_u_list_element_parse_attribute(dom_element *ele, + dom_string *name, dom_string *value, + dom_string **parsed); +void _dom_virtual_html_u_list_element_destroy(dom_node_internal *node); +dom_exception _dom_html_u_list_element_copy(dom_node_internal *old, + dom_node_internal **copy); + +#define DOM_HTML_U_LIST_ELEMENT_PROTECT_VTABLE \ + _dom_html_u_list_element_parse_attribute + +#define DOM_NODE_PROTECT_VTABLE_HTML_U_LIST_ELEMENT \ + _dom_virtual_html_u_list_element_destroy, \ + _dom_html_u_list_element_copy + +#endif |