gitktools.c

Go to the documentation of this file.

#define GITK_LIB_C
#define GITK_TOOLS_C

#include "gitkincludes.h"


static void gitk_dialog_dump_walker(xmlNodePtr cur,const gint level) {
  gint i;
  xmlChar *elem,*attr;
  xmlNsPtr nsptr;

  while(cur != NULL) {
    if(xmlNodeIsText(cur)) {
      //-- dump node contents
      if(!xmlIsBlankNode(cur)) {
        if((elem=xmlNodeGetContent(cur))) {
          print_ansi(ANSI_COLOR_DARKGRAY);for(i=0;i<level;i++) gitk_dump("..");
          gitk_dump1(ANSI_COLOR_LIGHTBLUE"%s"ANSI_COLOR_LIGHTGRAY"\n",elem);
          xmlFree(elem);
        }
      }
    }
    else {
      //-- dump node name
      print_ansi(ANSI_COLOR_DARKGRAY);for(i=0;i<level;i++) gitk_dump("..");
      nsptr=cur->ns;
      if(nsptr && (nsptr->prefix)) {
        gitk_dump2(ANSI_COLOR_WHITE"%s:%s",(xmlChar *)nsptr->prefix,cur->name);
      }
      else {
        gitk_dump1(ANSI_COLOR_WHITE"%s",cur->name);
      }
      /*
      if(!strncasecmp(cur->name,"dialog",8)) {
        if((attr=xmlGetProp(cur,"focus"))) {
          gitk_dump1(ANSI_COLOR_LIGHTRED" focus=\"%s\"",attr);
          xmlFree(attr);
        }
      }
      */
      if(!strncasecmp(cur->name,"widget",7)) {
        if((attr=xmlGetProp(cur,"id"))) {
          gitk_dump1(ANSI_COLOR_LIGHTRED" id=\"%s\"",attr);
          xmlFree(attr);
        }
        if((attr=xmlGetProp(cur,"type"))) {
          gitk_dump1(ANSI_COLOR_LIGHTRED" type=\"%s\"",attr);
          xmlFree(attr);
        }
        if((attr=xmlGetProp(cur,"hasFocus"))) {
          gitk_dump1(ANSI_COLOR_LIGHTRED" hasFocus=\"%s\"",attr);
          xmlFree(attr);
        }
      }
      gitk_dump(ANSI_COLOR_LIGHTGRAY"\n");
    }
    //-- recurse into node childen
    if(cur->children!=NULL) gitk_dialog_dump_walker(cur->children,level+1);
    cur = cur->next;
  }
}


void gitk_dialog_dump(xmlDocPtr const  doc) {
  if( (doc!=NULL)) {
    gitk_dialog_dump_walker(xmlDocGetRootElement(doc),0);
    print_ansi(ANSI_COLOR_LIGHTGRAY);
  }
  else if(doc==NULL) gitk_log("doc is empty");
}


xmlXPathObjectPtr gitk_xpath_type_filter(xmlXPathObjectPtr xpath_optr,const xmlXPathObjectType type) {
  if(xpath_optr && (xpath_optr->type!=type)) {
    gitk_err2("xpath expr does not returned the expected type: ist=%ld <-> soll=%ld",(unsigned long)xpath_optr->type,(unsigned long)type);
    xmlXPathFreeObject(xpath_optr);
    xpath_optr=NULL;
  }
  return(xpath_optr);
}


xmlXPathObjectPtr gitk__cxpath_get_object(GitkDialogPtr const dialog,GitkDialogAccessType access_type,xmlXPathCompExprPtr const xpath_comp_expression, xmlNodePtr const root_node) {
  xmlXPathObjectPtr result=NULL;
  xmlXPathContextPtr ctxt;
  xmlDocPtr doc;

  g_assert(dialog!=NULL);

  //gitk_log_intro();
  
  if((doc=gitk__dialog_get_doc(dialog,access_type))) {
    if((ctxt=xmlXPathNewContext(doc))) {
      if(root_node) ctxt->node=root_node;
      else ctxt->node=xmlDocGetRootElement(doc);
      if((!xmlXPathRegisterNs(ctxt,GITK_NS_PREFIX,GITK_NS_URL))
      && (!xmlXPathRegisterNs(ctxt,"dc","http://purl.org/dc/elements/1.1/"))) {
        result=xmlXPathCompiledEval(xpath_comp_expression,ctxt);
        xmlXPathRegisteredNsCleanup(ctxt);
      }
      else gitk_err("failed to register \"giml\" or \"dc\" namespace");
      xmlXPathFreeContext(ctxt);
    }
    else gitk_err("failed to get xpath context");
  }
  else gitk_err("failed to get dst doc");
  //gitk_log_outro();
  return(result);
}


xmlXPathObjectPtr gitk__xpath_get_object(GitkDialogPtr const dialog,GitkDialogAccessType access_type,gchar * const xpath_expression, xmlNodePtr const root_node) {
  xmlXPathObjectPtr result=NULL;
  xmlXPathCompExprPtr xpath_comp_expression;

  g_assert(dialog!=NULL);

  //-- compile xpath expression
  if((xpath_comp_expression=xmlXPathCompile(xpath_expression))) {
    result=gitk__cxpath_get_object(dialog,access_type,xpath_comp_expression,root_node);
  }
  else { gitk_err1("failed to compile xpath expression \"%s\"",xpath_expression); }
  return(result);
}


gchar *gitk__cxpath_get_string(GitkDialogPtr const dialog,GitkDialogAccessType access_type,xmlXPathCompExprPtr const xpath_comp_expression, xmlNodePtr const root_node) {
  gchar *result=NULL;
  xmlXPathObjectPtr xpath_optr;

  //-- evaluate xpath expression
  if((xpath_optr=gitk__cxpath_get_object(dialog,access_type,xpath_comp_expression,root_node))) {
    xpath_optr=xmlXPathConvertString(xpath_optr);
    //gitk_log2("stringval=0x%08lx \"%s\"",(unsigned long)xpath_optr->stringval,xpath_optr->stringval);
    result=strdup(xmlXPathCastToString(xpath_optr));
    xmlXPathFreeObject(xpath_optr);
  }
  else gitk_err("failed to eval xpath expr");
  return(result);
}


gchar *gitk__xpath_get_string(GitkDialogPtr const dialog,GitkDialogAccessType access_type,gchar * const xpath_expression, xmlNodePtr const root_node) {
  gchar *result=NULL;
  xmlXPathCompExprPtr xpath_comp_expression;

  //-- compile xpath expression
  if((xpath_comp_expression=xmlXPathCompile(xpath_expression))) {
    result=gitk__cxpath_get_string(dialog,access_type,xpath_comp_expression,root_node);
    xmlXPathFreeCompExpr(xpath_comp_expression);
  }
  else { gitk_err1("failed to compile xpath expression \"%s\"",xpath_expression); }
  return(result);
}


xmlNodePtr gitk__cxpath_get_node(GitkDialogPtr const dialog,GitkDialogAccessType access_type,xmlXPathCompExprPtr const xpath_comp_expression, xmlNodePtr const root_node) {
  xmlNodePtr node=NULL;
  xmlXPathObjectPtr xpath_optr;

  //gitk_log_intro();

  //-- evaluate xpath expression
  if((xpath_optr=gitk_xpath_type_filter(
      gitk__cxpath_get_object(dialog,access_type,xpath_comp_expression,root_node),
      XPATH_NODESET))) {
    const xmlNodeSetPtr ns=(xmlNodeSetPtr)xpath_optr->nodesetval;
    //-- has it exactly one child
    if(xmlXPathNodeSetGetLength(ns)==1) {
      node=xmlXPathNodeSetItem(ns,0);
    }
    else { gitk_log1("nodeset should contain exactly one node (but has %d nodes)",xmlXPathNodeSetGetLength(ns)); }
    xmlXPathFreeObject(xpath_optr);
  }
  else { gitk_err("failed to eval xpath expr"); }
  //gitk_log_outro();
  return(node);
}


xmlNodePtr gitk__xpath_get_node(GitkDialogPtr const dialog,GitkDialogAccessType access_type,gchar * const xpath_expression, xmlNodePtr const root_node) {
  xmlXPathCompExprPtr xpath_comp_expression;
  xmlNodePtr node=NULL;
  
  //-- compile xpath expression
  if((xpath_comp_expression=xmlXPathCompile(xpath_expression))) {
    node=gitk__cxpath_get_node(dialog,access_type,xpath_comp_expression,root_node);
    xmlXPathFreeCompExpr(xpath_comp_expression);
  }
  else { gitk_err1("failed to compile xpath expression \"%s\"",xpath_expression); }
  return(node);
}


gchar *gitk_get_widget_xpath_expression(const gchar * const widget_id) {
  static gchar qstr[100+GITK_CONTROL_ID_MAXLEN];
  gint sl;
   
  sl=strlen(widget_id);
  snprintf(qstr,99+GITK_CONTROL_ID_MAXLEN,"//"GITK_NS_PREFIX":widget[@id=\"%s\"]",widget_id);
  return(qstr);
}


gchar *gitk_get_widget_child_xpath_expression(const gchar * const widget_id,const gchar * const widget_value) {
  static gchar qstr[100+GITK_CONTROL_ID_MAXLEN];
  gint sl;

  sl=strlen(widget_id)+strlen(widget_value);
  snprintf(qstr,99+GITK_CONTROL_ID_MAXLEN,"//"GITK_NS_PREFIX":widget[@id=\"%s\"]/"GITK_NS_PREFIX":%s",widget_id,widget_value);
  return(qstr);
}


void gitk_dialog_safe_new_child(xmlNsPtr const ns,xmlNodePtr const parent,gchar * const name,gchar * const content) {
  xmlNodePtr cur;
  gboolean already_exists=FALSE;

  if((cur=parent->children)!=NULL) {
    while(cur) {
      if(!xmlNodeIsText(cur) && !strcasecmp(cur->name,name)) {
        already_exists=TRUE;
        break;
      }
      cur=cur->next;
    }
  }
  if(!already_exists) {
    xmlNewChild(parent,ns,name,content);
  }
}


char *parse_commandline_arg(guint * const argc, gchar *** const argv, guint * const i, gchar * const argn) {
  gchar *arg;
  gchar *argn2;
  guint argn2l;

  gitk_log2("%s(\"%s\") beg",__FUNCTION__,argn);
  
  g_assert(argc!=NULL);
  g_assert(argv!=NULL);
  g_assert(i!=NULL);
  g_assert(argn!=NULL);
  g_assert(((*argv)[*i])!=NULL);

  argn2l=strlen(argn);
  argn2=alloca(argn2l+2);
  strcpy(argn2,argn);
  strcat(argn2,"=");

  if(!strcmp(argn,(*argv)[*i]) || !strncmp(argn2,(*argv)[*i],argn2l+1)) {
    gitk_log("  matches, now extract arg");
    arg=(*argv)[*i]+argn2l;
      
    if(*arg=='=') arg++;      // there is an '=' or '\0'
    else if((*i)+1<*argc) {
      (*argv)[*i] = NULL;
      (*i)++;
      arg=(*argv)[*i];
    }
    else {
      gitk_log1("%s()=null end",__FUNCTION__);
      return(NULL);
    }
    gitk_log("  discarding parameter");
    (*argv)[*i]=NULL;
    gitk_log("  found something");
    if(arg && *arg) {
      gitk_log1("%s()=arg end",__FUNCTION__);
      return(arg);
    }
  }
  gitk_log1("%s()=null end",__FUNCTION__);
  return(NULL);
}


void cleanup_commandline_args(guint * const argc, gchar *** const argv) {
  guint i,j,k;

  for (i = 1; i < *argc; i++) {
    for (k = i; k < *argc; k++) {
      if ((*argv)[k] != NULL) break;
    }
    if (k > i) {
      k -= i;
      for (j = i + k; j < *argc; j++) {
        (*argv)[j-k] = (*argv)[j];
      }
      *argc -= k;
    }
  }
}

int gitk_puts(const char *utf8) {
  gchar *loc,*cs;
  int res;

  #ifdef ENABLE_NLS
    cs=nl_langinfo(CODESET);
  #else
    cs="ISO-8859-1";
  #endif
  loc=g_convert(utf8,-1,cs,"UTF-8",NULL,NULL,NULL);
  res=puts(loc);
  g_free(loc);
  return(res);
}

int gitk_printf(const char *utf8,...) {
  gchar *loc,*cs;
  va_list args;
  int res;
  
  #ifdef ENABLE_NLS
    cs=nl_langinfo(CODESET);
  #else
    cs="ISO-8859-1";
  #endif
  loc=g_convert(utf8,-1,cs,"UTF-8",NULL,NULL,NULL);
  va_start(args,utf8);
  res=vprintf(loc,args);
  va_end(args);
  g_free(loc);
  return(res);
}

---