gitkrlayout.c

Go to the documentation of this file.

#define GITK_RENDERER_C
#define GITKR_LAYOUT_C

#include "gitkrincludes.h"

#define giml_ctrl_text N_("Previous");
#undef giml_ctrl_text
#define giml_ctrl_text N_("Next");
#undef giml_ctrl_text

void gitkr_dialog_generate_layout(GitkDialogPtr dialog) {
  GitkrTextLayoutPtr layout;
  xmlNodePtr node;

  gitk_log("gitkr_dialog_generate_layout() beg");
  gitk_log2("terminal dimensions %d x %d",LINES,COLS);// LINES, COLS are terminal lines and columns
  g_assert(dialog!=NULL);

  //-- free old layout
  gitkr_dialog_free_layout(dialog);

  //-- and generate a new empty one
  layout=gitkr_dialog_new_layout(dialog);
  dialog->layout=(GitkLayoutPtr)layout;
  
  //-- get root node (where all widgetgroups and widgets are below
  //if((node=gitk_xpath_get_node(dialog,"/"GITK_NS_PREFIX":giml/"GITK_NS_PREFIX":dialog/"GITK_NS_PREFIX":widgetgroup",NULL))) {
  if((node=gitk_xpath_get_node(dialog,"/"GITK_NS_PREFIX":giml/"GITK_NS_PREFIX":dialog",NULL))) {
    gchar *fg_color,*bg_color;

    //node=xmlXPathNodeSetItem(ns,0);

    fg_color=xmlGetProp(node,"fgcolor");
    bg_color=xmlGetProp(node,"bgcolor");
    layout->bg_color=color_name_to_code(bg_color,COLOR_BLACK);
    layout->fg_color=color_name_to_code(fg_color,COLOR_WHITE);
    layout->dim_bold=color_name_to_attr(fg_color,FALSE);
    xmlFree(fg_color);
    xmlFree(bg_color);

    gitkr_dialog_generate_dialog_widgets(dialog);
    // debug
    //xmlSaveFormatFile("/tmp/gitk.xml",gitk_dialog_get_dst(dialog),TRUE);
    // debug
    gitk_log("starting recursion ...");
    gitkr_dialog_generate_sequential_layout(dialog,node);
    //gitkr_dialog_generate_hierarchical_layout(dialog,node);
    gitk_log("finished recursion ...");
  }
  else { gitk_err("failed to get root widgetgroup"); }
}

GitkrTextLayoutPtr gitkr_dialog_new_layout(GitkDialogPtr dialog) {
  GitkrTextLayoutPtr layout=g_new(GitkrTextLayout,1);

  //-- set default layout parameter
  layout->focus=GITK_FOCUS_TYPE_CTRL;
  layout->currentPage=0;
  layout->currentWidget=0;
  layout->maxWidgetsPerPage=LINES-GITK_LINE_OFFSET; /* title line + one spacer line + one spacer line + footer line */
  layout->pages=NULL;
  layout->title=gitkr_cxpath_get_string(dialog,xpath_get_dialog_name,NULL);
  //-- allocate memory for the ctrl widgets
  layout->ctrl.widgets=g_new0(GitkrTextWidget,1);
  return(layout);
}

void gitkr_dialog_generate_dialog_widgets(GitkDialogPtr dialog) {
  GitkrTextLayoutPtr layout=(GitkrTextLayoutPtr)dialog->layout;
  xmlNodePtr node;

  if((node=gitk_xpath_get_node(dialog,"/"GITK_NS_PREFIX":giml/"GITK_NS_PREFIX":dialog/"GITK_NS_PREFIX":dialogwidgets/"GITK_NS_PREFIX":widget",NULL))) {
    if(!xmlNodeIsText(node)) {
      if(!strncasecmp(node->name,"widget",7)) {
        GitkrTextWidgetPtr widget;
        widget=&layout->ctrl.widgets[0];
        gitkr_widget_optionchoice_new(widget,dialog,node);
        //-- allocate  and attach type specific widget data
        //gitkr_widget_optionchoice_new(widget,"__ctrl",dialog,NULL);
        gitk_log3("  dialogwidget 0x%08x <%s id=\"%s\">",(gint)widget,node->name,widget->id);
        layout->ctrl.widgetsPerPage=1;
        gitk_log1("  => %d",layout->ctrl.widgetsPerPage);
      }
      else gitk_err1("expecting 'widget' node, got '%s'",node->name);
    }
    else gitk_err("unexpected textnode in dialog definition");
  }
  else gitk_err("failed to get dialog widgets");
}

void gitkr_dialog_generate_sequential_layout(GitkDialogPtr dialog,xmlNodePtr root) {
  GitkrTextLayoutPtr layout;
  xmlXPathCompExprPtr xpath_get_pages,xpath_get_widgets;

  g_assert(dialog!=NULL);
  g_assert(dialog->layout!=NULL);
  
  gitk_log("gitkr_dialog_generate_sequential_layout() beg");

  layout=(GitkrTextLayoutPtr)dialog->layout;
  if((xpath_get_pages=xmlXPathCompile("./"GITK_NS_PREFIX":widgetgroup/"GITK_NS_PREFIX":*/parent::*"))
    && (xpath_get_widgets=xmlXPathCompile("./"GITK_NS_PREFIX":widget"))) {

    //-- get number of pages (widgetgroups which are not empty)
    xmlXPathObjectPtr pages_xpoptr;
    if((pages_xpoptr=gitk_xpath_type_filter(
        gitk_cxpath_get_object(dialog,xpath_get_pages,root),
        XPATH_NODESET))) {
      gint i,pageIx;
      xmlNodeSetPtr pages=(xmlNodeSetPtr)pages_xpoptr->nodesetval;
      gint pages_len=xmlXPathNodeSetGetLength(pages);
      //-- count pages
      layout->numberOfPages=gitkr_dialog_generate_sequential_layout_count_pages(dialog,root,pages,xpath_get_widgets);
      //-- allocate memory for the widgets
      layout->pages=g_new0(GitkrTextLayoutPage,layout->numberOfPages);
      for(i=0;i<layout->numberOfPages;i++) {
        layout->pages[i].widgets=g_new0(GitkrTextWidget,layout->maxWidgetsPerPage);
      }
      //-- build pages
      pageIx=0;
      pageIx=gitkr_dialog_generate_sequential_layout_build_page(dialog,root,xpath_get_widgets,pageIx);
      for(i=0;i<pages_len;i++) {
        pageIx=gitkr_dialog_generate_sequential_layout_build_page(dialog,xmlXPathNodeSetItem(pages,i),xpath_get_widgets,pageIx);
      }
      xmlXPathFreeObject(pages_xpoptr);
    }
    xmlXPathFreeCompExpr(xpath_get_pages);
    xmlXPathFreeCompExpr(xpath_get_widgets);
  
    gitk_log1("layout->maxWidgetsPerPage : %d",layout->maxWidgetsPerPage);
    gitk_log1("layout->numberOfPages : %d",layout->numberOfPages);
    gitk_log1("layout->title : \"%s\"",layout->title);
  }
  else { gitk_err("failed to compile xpath expression (get_pages, get_widgets)"); }
}

gint gitkr_dialog_generate_sequential_layout_count_pages(GitkDialogPtr dialog,xmlNodePtr root,xmlNodeSetPtr pages,xmlXPathCompExprPtr xpath_get_widgets) {
  GitkrTextLayoutPtr layout;
  xmlXPathObjectPtr widgets_xpoptr;
  gint pages_len=xmlXPathNodeSetGetLength(pages);
  gint numberOfPages=pages_len;
  gint i;

  g_assert(dialog!=NULL);
  g_assert(dialog->layout!=NULL);

  gitk_log_intro();

  layout=(GitkrTextLayoutPtr)dialog->layout;

  gitk_log1("  initial numberOfPages %d",numberOfPages);
  //-- first check root widgetgroup ...
  if((widgets_xpoptr=gitk_xpath_type_filter(
      gitk_cxpath_get_object(dialog,xpath_get_widgets,root),
      XPATH_NODESET))) {
    //-- if root page is not empty, add at least one page 
    if(xmlXPathNodeSetGetLength((xmlNodeSetPtr)widgets_xpoptr->nodesetval)) numberOfPages++;
    //-- if number of widgets is larger than layout->maxWidgetsPerPages correct numberOfPages
    numberOfPages+=xmlXPathNodeSetGetLength((xmlNodeSetPtr)widgets_xpoptr->nodesetval)/layout->maxWidgetsPerPage;
    gitk_log1("  numberOfPages[r] %d",numberOfPages);
    xmlXPathFreeObject(widgets_xpoptr);
  }
  //-- now check for each widgetgroup ...
  for(i=0;i<pages_len;i++) {
    if((widgets_xpoptr=gitk_xpath_type_filter(
        gitk_cxpath_get_object(dialog,xpath_get_widgets,xmlXPathNodeSetItem(pages,i)),
        XPATH_NODESET))) {
      //-- if number of widgets is larger than layout->maxWidgetsPerPages correct numberOfPages
      numberOfPages+=xmlXPathNodeSetGetLength((xmlNodeSetPtr)widgets_xpoptr->nodesetval)/layout->maxWidgetsPerPage;
      gitk_log2("  numberOfPages[%d] %d",i,numberOfPages);
      xmlXPathFreeObject(widgets_xpoptr);
    }
  }
  gitk_log1("  final numberOfPages %d",numberOfPages);
  gitk_log_outro();
  return(numberOfPages);
}

gint gitkr_dialog_generate_sequential_layout_build_page(GitkDialogPtr dialog,xmlNodePtr root,xmlXPathCompExprPtr xpath_get_widgets,gint pageIx) {
  GitkrTextLayoutPtr layout;
  xmlXPathObjectPtr widgets_xpoptr;
  gchar *title;

  gitk_log("gitkr_dialog_generate_sequential_layout_build_page() beg");
  
  g_assert(dialog!=NULL);
  g_assert(dialog->layout!=NULL);
  layout=(GitkrTextLayoutPtr)dialog->layout;
  g_assert(layout->pages!=NULL);

  //-- get widgetgroup title
  title=gitkr_cxpath_get_string(dialog,xpath_get_label,root);
  gitk_log1("====> widgetgroup title \"%s\"",title);

  if((widgets_xpoptr=gitk_xpath_type_filter(
      gitk_cxpath_get_object(dialog,xpath_get_widgets,root),
      XPATH_NODESET))) {
    gint j;
    xmlNodeSetPtr widgets=(xmlNodeSetPtr)widgets_xpoptr->nodesetval;
    gint widgets_len=xmlXPathNodeSetGetLength(widgets);
    xmlNodePtr node;
    gint widgetIx;
    GitkrTextWidgetPtr widget;
    gchar *focus;

    //-- do not add empty pages
    if(widgets_len) {
      //-- now add widgets
      g_assert(layout->pages[pageIx].widgets!=NULL);
      widgetIx=0;
      gitk_log2("====> starting at page %2d  with %2d widgets",pageIx,widgets_len);
      for(j=0;j<widgets_len;j++) {
        node=xmlXPathNodeSetItem(widgets,j);
        //-- add new widget
        if(!xmlNodeIsText(node)) {
          //-- check if this widget has the focus
          if(focus=xmlGetProp(node,"hasFocus")) {
            if(!strncmp(focus,"true\0",5)) {
              layout->currentPage=pageIx;
              layout->currentWidget=widgetIx;
              layout->focus=GITK_FOCUS_TYPE_MAIN;
            }
            xmlFree(focus);
          }
          //-- get widget data
          widget=&layout->pages[pageIx].widgets[widgetIx];
          //-- allocate  and attach type specific widget data
          switch(gitk_widget_get_type(node)) {
            case GITK_WIDGET_TYPE_ACTION:
              gitkr_widget_action_new(widget,dialog,node);
              break;
            case GITK_WIDGET_TYPE_CHARACTERINPUT:
              gitkr_widget_characterinput_new(widget,dialog,node);
              break;
            case GITK_WIDGET_TYPE_CHARACTERINPUT_ALPHABETIC:
              gitkr_widget_characterinput_alphabetic_new(widget,dialog,node);
              break;
            case GITK_WIDGET_TYPE_OPTIONCHOICE:
            case GITK_WIDGET_TYPE_OPTIONCHOICE_SINGLE:
            case GITK_WIDGET_TYPE_OPTIONCHOICE_SINGLE_COMPACT:
              gitkr_widget_optionchoice_new(widget,dialog,node);
              break;
            case GITK_WIDGET_TYPE_OPTIONCHOICE_BOOLEAN:
              gitkr_widget_optionchoice_boolean_new(widget,dialog,node);
              break;
            case GITK_WIDGET_TYPE_LABEL:
              gitkr_widget_label_new(widget,dialog,node);
              break;
            case GITK_WIDGET_TYPE_UNDEF:
            default:
              gitk_log("widget type not yet implemented");
              gitkr_widget_new(widget,dialog,node);
          }
          gitk_log1("   widget=0x%08lx",(unsigned long)widget);
          gitk_log1("       id=\"%s\"" ,widget->id);
          gitk_log1("    label=\"%s\"" ,widget->label);
          gitk_log2("    color=%d/%d" ,widget->fg_color,widget->bg_color);
          widgetIx++;
        }
        else { gitk_err("unexpected textnode in dialog definition"); }
        //-- if page is full do next page
        if(widgetIx==layout->maxWidgetsPerPage){
          layout->pages[pageIx].title=title;
          layout->pages[pageIx].widgetsPerPage=widgetIx;
          gitk_log2("  widgetsPerPages[%2d]=%2d",pageIx,layout->pages[pageIx].widgetsPerPage);
          pageIx++;
          g_assert(layout->pages[pageIx].widgets!=NULL);
          widgetIx=0;
        }
      }
      layout->pages[pageIx].title=title;
      layout->pages[pageIx].widgetsPerPage=widgetIx;
      gitk_log2("  widgetsPerPages[%2d]=%2d",pageIx,layout->pages[pageIx].widgetsPerPage);
      pageIx++;
    }
    xmlXPathFreeObject(widgets_xpoptr);
  }

  gitk_log("gitkr_dialog_generate_sequential_layout_build_page() end");

  return(pageIx);
}

void gitkr_dialog_generate_hierarchical_layout(GitkDialogPtr dialog,xmlNodePtr root) {
  GitkrTextLayoutPtr layout;
  //xmlXPathCompExprPtr xpath_get_pages;
  
  g_assert(dialog!=NULL);
  g_assert(dialog->layout!=NULL);

  gitk_log("gitkr_dialog_generate_hierarchical_layout() beg");

  layout=(GitkrTextLayoutPtr)dialog->layout;
}

void gitkr_dialog_output_layout(GitkDialogPtr dialog) {
  GitkrTextLayoutPtr layout;
  GitkrTextWidgetPtr page;

  g_assert(dialog!=NULL);
  g_assert(dialog->layout!=NULL);

  gitk_log("gitkr_layout_output() beg");
  // LINES, COLS are terminal lines and columns
  gitk_log2("terminal dimensions %d x %d",LINES,COLS);

  layout=(GitkrTextLayoutPtr)dialog->layout;
  g_assert(layout->pages!=NULL);
  g_assert((&layout->pages[layout->currentPage])!=NULL);
  g_assert(layout->currentPage<layout->numberOfPages);
  
  if((page=layout->pages[layout->currentPage].widgets)) {
    GitkrTextWidgetPtr widget;
    guint j;
    guint color_index=1,display_attrs;

    gitk_log("starting output");

    init_pair(color_index,layout->fg_color,layout->bg_color);
    display_attrs=COLOR_PAIR(color_index++)|(layout->dim_bold?A_BOLD:A_DIM);
    attrset(display_attrs);bkgdset(display_attrs);
    //-- clear the screen
    erase();/*clearok(stdscr,TRUE);*/
  
    //-- display the title line
    if((layout->title) || (layout->pages[layout->currentPage].title)) {
      gchar fmt[10];
      gchar *title;
      gboolean newtitle=FALSE;
      
      if((layout->title) && (layout->pages[layout->currentPage].title)) {
        guint len=strlen(layout->title)+strlen(layout->pages[layout->currentPage].title)+4;
        title=g_new(gchar,len);newtitle=TRUE;
        snprintf(title,len,"%s / %s",layout->title,layout->pages[layout->currentPage].title);
      }
      else if(layout->title) {
        title=layout->title;
      }
      else {
        title=layout->pages[layout->currentPage].title;
      }
      
      if(strlen(title)<=(COLS-(7+2))) {
        sprintf(fmt,"= %%-%ds",COLS-(7+2));
      }
      else {
        sprintf(fmt,"= %%-%ds...",COLS-(7+5));
      }
      // @todo see http://sourceforge.net/tracker/index.php?func=detail&aid=955749&group_id=29795&atid=397305
      //gitk_log2("fmt=\"%s\", title=\"%s\"",fmt,title);
      attron(A_REVERSE);
      mvprintw(0,0,fmt,title);
      attroff(A_REVERSE);
      
      if(newtitle) g_free(title);
    }
    attron(A_REVERSE);
    mvprintw(0,COLS-7, "[%2d/%2d]",(layout->currentPage+1),layout->numberOfPages);
    attroff(A_REVERSE);

    gitk_log1("before widgets : %d",layout->pages[layout->currentPage].widgetsPerPage);

    //-- display the widgets
    for(j=0;j<layout->pages[layout->currentPage].widgetsPerPage;j++) {
      widget=&page[j];
      if(widget && widget->id && widget->output) {
        gitk_log2("    color=%d/%d" ,widget->fg_color,widget->bg_color);
        init_pair(color_index,widget->fg_color,widget->bg_color);
        widget->display_attrs=COLOR_PAIR(color_index++)|(widget->dim_bold?A_BOLD:A_DIM);
        widget->output(widget,GITK_LINE_OFFSET+j,(layout->currentWidget==j));
      }
    }
  
    //-- display the navigation line
    if(layout->ctrl.widgetsPerPage==1) {
      GitkrTextWidgetPtr widget=&layout->ctrl.widgets[0];
      /* order is ["help"], "okay","cancel" */
      /* order is ["help"], "apply","okay","cancel" */
      /* order is ["help"], "try","revert","okay","cancel" */
      gitk_log("displaying dialogwidgets");
      move(LINES-1,0);
      if(widget && widget->id && widget->output) {
        gitk_log2("    color=%d/%d" ,widget->fg_color,widget->bg_color);
        init_pair(color_index,widget->fg_color,widget->bg_color);
        widget->display_attrs=COLOR_PAIR(color_index++)|(widget->dim_bold?A_BOLD:A_DIM);
        widget->output(widget,LINES-1,(layout->currentWidget==GITKR_TEXT_NAVIGATION));
      }
    }
    //-- now set the cursor to the active widget
    move(GITK_LINE_OFFSET+layout->currentWidget,0);
    //-- now refresh curses screen
    refresh();
  }
}

void gitkr_dialog_free_layout(GitkDialogPtr dialog) {
  g_assert(dialog!=NULL);

  gitk_log("gitkr_dialog_layout_free() beg");

  if(dialog->layout) {
    GitkrTextLayoutPtr layout=(GitkrTextLayoutPtr)dialog->layout;
  
    if(layout->pages) {
      GitkrTextWidgetPtr page;
      GitkrTextWidgetPtr widget;
      gint i;
  
      for(i=0;i<layout->numberOfPages;i++) {
        if(layout->pages[i].widgets) {
          gint j;
          page=layout->pages[i].widgets;
          for(j=0;j<layout->maxWidgetsPerPage;j++) {
            widget=&page[j];
            xmlFree(widget->id);
            xmlFree(widget->label);
          }
          g_free(page); 
        }
      }
      g_free(layout->pages);
    }
    g_free(layout->ctrl.widgets);
    xmlFree(layout->title);
    g_free(layout);
    dialog->layout=NULL;
  }
}

GitkrTextWidgetPtr gitkr_layout_get_current_widget(GitkrTextLayoutPtr layout) {
  GitkrTextWidgetPtr page;

  if((page=layout->pages[layout->currentPage].widgets)) {
    return(&page[layout->currentWidget]);
  }
  return(NULL);
}

gint gitkr_layout_get_current_widget_line(GitkrTextLayoutPtr layout) {
  return(GITK_LINE_OFFSET+layout->currentWidget);
}

---