gitkdialog.c

Go to the documentation of this file.

#define GITK_LIB_C
#define GITK_DIALOG_C

#include "gitkincludes.h"



GitkDialogPtr gitk_dialog_new_from_file(gchar * const filename) {
  GitkDialogPtr dialog=NULL;
  xmlParserCtxtPtr ctxt;

  g_assert(filename!=NULL);
  g_assert(*filename);

  if((ctxt=xmlCreateFileParserCtxt(filename))) {
    dialog=gitk_dialog_new_from_parser_context(ctxt);
    xmlFreeParserCtxt(ctxt);
  }
  else gitk_err1("failed to create file-parser context for \"%s\"",filename);
  return(dialog);
}


GitkDialogPtr gitk_dialog_new_from_memory(gchar * const buffer, const guint size) {
  GitkDialogPtr dialog=NULL;
  xmlParserCtxtPtr ctxt;

  g_assert(buffer!=NULL);
  g_assert(*buffer);
  g_assert(size);

  if((ctxt=xmlCreateMemoryParserCtxt(buffer,size))) {
    dialog=gitk_dialog_new_from_parser_context(ctxt);
    xmlFreeParserCtxt(ctxt);
  }
  else gitk_err("failed to create memory-parser context");
  return(dialog);
}


GitkDialogPtr gitk_dialog_new_from_string(gchar * const str) {
  GitkDialogPtr dialog=NULL;
  xmlParserCtxtPtr ctxt;

  g_assert(str!=NULL);
  g_assert(*str);

  if((ctxt=xmlCreateMemoryParserCtxt(str,strlen(str)))) {
    dialog=gitk_dialog_new_from_parser_context(ctxt);
    xmlFreeParserCtxt(ctxt);
  }
  else gitk_err("failed to create memory-parser context");
  return(dialog);
}


GitkDialogPtr gitk_dialog_new_from_parser_context(xmlParserCtxtPtr const ctxt) {
  GitkDialogPtr dialog=NULL;

  g_assert(ctxt!=NULL);
  
  //gitk_log1("validation is switched %s ",(ctxt->validate?"on":"off"));
#ifdef USE_DTD_VALIDATION
  ctxt->validate=TRUE;
#else
  ctxt->validate=FALSE;
#endif
  xmlParseDocument(ctxt);
  gitk_log2("parsed document is %s valid and %s well formed",(ctxt->valid?"":"not"),(ctxt->wellFormed?"":"not"));
  if(!ctxt->valid) {
    gitk_set_error(GITK_ERROR_INVALID_DOCUMENT,_("the supplied document is not a XML/GIML document"));
  }
  else if(!ctxt->wellFormed) {
    gitk_set_error(GITK_ERROR_INVALID_DOCUMENT,_("the supplied document is not a wellformed XML document"));
  }
  else dialog=gitk_dialog_new(ctxt->myDoc);
  return(dialog);
}


void gitk_dialog_free(GitkDialogPtr const dialog) {
  if(dialog) {
    //-- iterate over callback list and free all callbacks
    if(dialog->callback_list) {
      GList* node=g_list_first(dialog->callback_list);
      GitkCallbackNodePtr callback_node;
      while(node) {
        callback_node=(GitkCallbackNodePtr)node->data;
        g_free(callback_node->widget_id);
        g_free(callback_node->callback_name);
        g_free(callback_node);
        node=g_list_next(node);
      }
      g_list_free(dialog->callback_list);
    }
    if(dialog->src) xmlFreeDoc(dialog->src);
    if(dialog->dst) xmlFreeDoc(dialog->dst);
    if(dialog->lock) g_mutex_free(dialog->lock);
    g_free(dialog);
  }
}


static gboolean gitk_dialog_validate(GitkDialogPtr const dialog) {
  xmlNodePtr cur;
  gboolean result=TRUE;

  /* It is possible to validate documents which had not been validated at
  ** initial parsing time or documents which have been built from scratch using the API.
  ** Use the xmlValidateDtd()  function.
  **    http://xmlsoft.org/html/libxml-valid.html#xmlValidateDtd
  ** It is also possible to simply add a DTD to an existing document:
  **   xmlDocPtr doc; // your existing document
  **   xmlDtdPtr dtd = xmlParseDTD(NULL, filename_of_dtd); // parse the DTD
  **
  **   dtd->name = xmlStrDup((xmlChar*)"root_name"); // use the given root
  **   doc->intSubset = dtd;
  **   if (doc->children == NULL) xmlAddChild((xmlNodePtr)doc, (xmlNodePtr)dtd);
  **   else xmlAddPrevSibling(doc->children, (xmlNodePtr)dtd);
  */

  if(!dialog->src) {
    gitk_log("xmlDoc src is null");
    gitk_set_error(GITK_ERROR_EMPTY_DOCUMENT,_("an empty document has been supplied"));
    result=FALSE;
  }
  else if((cur=xmlDocGetRootElement(dialog->src))==NULL) {
    gitk_log("xmlDoc src is empty");
    gitk_set_error(GITK_ERROR_EMPTY_DOCUMENT,_("an empty document has been supplied"));
    result=FALSE;
  }
  else if((dialog->ns=xmlSearchNsByHref(dialog->src,cur,(const xmlChar *)GITK_NS_URL))==NULL) {
    gitk_log("no namespace found in xmlDoc src");
    gitk_set_error(GITK_ERROR_WRONG_DOCTYPE_NAMESPACE,_("a document with a wrong document type namespace has been supplied"));
    result=FALSE;
  }
  else if(xmlStrcmp(cur->name,(const xmlChar *)"giml")) {
    gitk_log("wrong document type root node in xmlDoc src");
    gitk_set_error(GITK_ERROR_WRONG_DOCTYPE_ROOTNODE,_("a document with a wrong document type root node has been supplied"));
    result=FALSE;
  }
  if(result) {
    if(dialog->ns) {
      gitk_log2("namespace is \"%s\" at \"%s\"",gitk_save_get_string(dialog->ns->prefix),gitk_save_get_string(dialog->ns->href));
    }
    else {
      gitk_log("namespace is empty");
    }
  }
  return(result);
}


GitkDialogPtr gitk_dialog_new(xmlDocPtr const doc) {
  GitkDialogPtr dialog;

  g_assert(doc!=NULL);
  
  dialog=g_new0(GitkDialog,1);
  dialog->src=doc;
  dialog->dst=NULL;
#ifdef G_THREADS_ENABLED
  if(!g_thread_supported()) g_thread_init(NULL);
  dialog->lock=g_mutex_new();
#endif
  gitk_log1("dialog=0x%08lx",(unsigned long)dialog);
  gitk_log1("doc=0x%08lx",(unsigned long)dialog->src);
  if(gitk_dialog_validate(dialog)) {
    gitk_log("after loading");
    gitk_dialog_dump(dialog->src);

    if(gitk_dialog_trans_initial(dialog)) {
      gitk_log("after initial transformations");
      gitk_dialog_dump(dialog->src);
    }
    else {
      gitk_dialog_free(dialog);
      dialog=NULL;
    }
  }
  else {
    gitk_dialog_free(dialog);
    dialog=NULL;
  }
  return(dialog);
}


xmlDocPtr gitk_dialog_get_src(GitkDialogPtr const dialog) {
  return(dialog->src);
}


xmlDocPtr gitk_dialog_get_dst(GitkDialogPtr const dialog) {
  if(!(dialog->dst)) {
    if(gitk_dialog_trans(dialog)) {
      gitk_log("after transformations");
      gitk_dialog_dump(dialog->dst);
    }
    else {
      gitk_log("error during transformation");
    }
  }
  return(dialog->dst);
}

xmlDocPtr gitk__dialog_get_doc(GitkDialogPtr const dialog,GitkDialogAccessType access_type) {
  switch(access_type) {
    case GITK_DIALOG_ACCESS_RENDERER: return(gitk_dialog_get_dst(dialog));
    case GITK_DIALOG_ACCESS_CLIENT: return(gitk_dialog_get_src(dialog));
  }
  return(NULL);
}


void gitk_dialog_invalidate(GitkDialogPtr const dialog) {
  dialog->changed=TRUE;
  if(dialog->dst) {
    xmlFreeDoc(dialog->dst);
    dialog->dst=NULL;
  }
}


static GitkDialogAccessType gitk_toggle_access_type(GitkDialogAccessType access_type) {
  return((GitkDialogAccessType)(1-(guint)access_type));
}


void gitk_dialog_set_content(GitkDialogPtr const dialog,GitkDialogAccessType const access_type,xmlXPathCompExprPtr cxpath_expr,gchar * const xpath_expr,const gchar * const new_value) {
  xmlNodePtr node;
  
  g_assert(dialog);

  gitk_log("gitk_dialog_set_content() beg");

  // if no compiled xpath expression has been supplied compile one
  if(!cxpath_expr) {
    g_assert(xpath_expr);
    cxpath_expr=xmlXPathCompile(xpath_expr);
  }
  // now we should have a compiled xpath expression
  if(cxpath_expr) {
    // get one element node
    if((node=gitk__cxpath_get_node(dialog,access_type,cxpath_expr,NULL))) {
      if(!xmlNodeIsText(node)) {
        xmlChar *other_xpath_expr;
        // we currently do not yet produce sync nodes from xslt 
        if((other_xpath_expr=xmlGetProp(node,"sync"))) {
          gitk_log1("[sych] param found : \"%s\"",other_xpath_expr);
          cxpath_expr=xmlXPathCompile(other_xpath_expr);
          xmlFree(other_xpath_expr);
        }
        // set new content in one xmldoc-tree
        xmlNodeSetContent(node,new_value);
        gitk_log("primary content stored");
        // if node has a sych element then read the xpath expression from it
        // get other element node
        if((node=gitk__cxpath_get_node(dialog,gitk_toggle_access_type(access_type),cxpath_expr,NULL))) {
          if(!xmlNodeIsText(node)) {
            // set new content in other xmldoc-tree
            xmlNodeSetContent(node,new_value);
            gitk_log("secondary content stored");
          }
          else { gitk_err("unexpected text-node"); }
        }
        else { gitk_log("failed to get node for xpath expression"); }
      }
      else { gitk_err("unexpected text-node"); }
    }
    else { gitk_err("failed to get node for xpath expression"); }
  }
  else  { gitk_err("compiled xpath expr is NULL"); }
  gitk_log("gitk_dialog_set_content() end");
}


xmlNodePtr gitk__dialog_get_widget(GitkDialogPtr const dialog,GitkDialogAccessType const access_type,gchar * const widget_id) {
  xmlNodePtr node;

  g_assert(dialog);
  g_assert(widget_id);

  //gitk_log1("gitk_dialog_get_widget(\"%s\")",widget_id);

  node=gitk__xpath_get_node(dialog,access_type,gitk_get_widget_xpath_expression(widget_id),NULL);
  //gitk_log1("gitk_dialog_get_widget()=0x%08lx",(unsigned long)node);
  return(node);
}


void gitk__dialog_set_title(GitkDialogPtr const dialog,GitkDialogAccessType const access_type,gchar * const new_title) {  
  g_assert(dialog);
  g_assert(new_title);

  gitk_log1("gitk_dialog_set_title(\"%s\")",new_title);

  gitk_dialog_set_content(dialog,access_type,xpath_get_dialog_name,NULL,new_title);
}


void gitk_dialog_move_focus(GitkWidgetPtr old_widget, GitkWidgetPtr new_widget) {
  xmlNodePtr node;
  
  if(old_widget) {
    if((node=gitk__dialog_get_widget(old_widget->dialog,GITK_DIALOG_ACCESS_RENDERER,old_widget->id))) {
      if(!xmlNodeIsText(node)) xmlSetProp(node,"hasFocus","false");
    }
    if((node=gitk__dialog_get_widget(old_widget->dialog,GITK_DIALOG_ACCESS_CLIENT,old_widget->id))) {
      if(!xmlNodeIsText(node)) xmlSetProp(node,"hasFocus","false");
    }
  }
  if(new_widget) {
    if((node=gitk__dialog_get_widget(new_widget->dialog,GITK_DIALOG_ACCESS_RENDERER,new_widget->id))) {
      if(!xmlNodeIsText(node)) xmlSetProp(node,"hasFocus","true");
    }
    if((node=gitk__dialog_get_widget(new_widget->dialog,GITK_DIALOG_ACCESS_CLIENT,new_widget->id))) {
      if(!xmlNodeIsText(node)) xmlSetProp(node,"hasFocus","true");
    }
  }
}

---