API tools faq
paste
Advertisement
socrtwo

gedcom2wiki

socrtwo
Nov 12th, 2011
119
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 38.25 KB | None | 0 0
raw download clone embed print report
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml">
  3. <head>
  4. <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  5. <title>converted</title>
  6. </head>
  7. <body>
  8. <strong>result :</strong>
  9. <br>
  10. <textarea name="textarea" id="textarea" cols="10000" rows="32">
  11. <?php
  12. $gdFile= $_FILES["userfile"]["name"];
  13. $gdFileVal= $_FILES["userfile"]["tmp_name"];
  14. if (is_uploaded_file($gdFileVal))
  15. {
  16.     $gdFileStr = file_get_contents($gdFileVal);
  17. }
  18. else
  19. {
  20.     die("bad file upload");
  21. }
  22.  
  23. $tagVal= ")=)=)";
  24. $i_null = "";
  25. $i_otherchar = "";
  26. $i_non_at = "a-z|A-Z|0-9|\x20|\x21|\x22|\x23|\x24-\x2F|\x3A-\x3F|\x5B|\x5C|\x5D|\x5E|\x60|\x7B-\x7E|\x80-\xFE";
  27. $gd_line_delim = "(\r)+|(\n)+|(\r\n)+(\n\r)+";
  28. $gd_delim = "(\x20)";
  29. $gd_pointer = "(\x20(\x40){1}(a-z|A-Z|0-9|.){1}(".$i_non_at."|.)*(\x40){1}\x20)";
  30. $gd_level = "\x20(0){1}|(1-9){1}(0-9)*\x20";
  31.  
  32. $c_lr = -ord("~");
  33. $c_ud = -ord(":");
  34. $c_lu = -ord("J");
  35. $c_ld = -ord("7");
  36. $c_ru = -ord("L");
  37. $c_rd = -ord("F");
  38. $c_lru = -ord("A");
  39. $c_lrd = -ord("V");
  40. $c_udl = -ord("C");
  41. $c_udr = -ord("D");
  42. $c_lrud = -ord("%");
  43. $c_C = -ord(" ");
  44.  
  45. $c_LR = -ord("-");
  46. $c_UD = -ord("!");
  47. $c_LU = -ord("'");
  48. $c_LD = -ord(".");
  49. $c_RU = -ord("`");
  50. $c_RD = -ord(",");
  51. $c_LRU = -ord("^");
  52. $c_LRD = -ord("v");
  53. $c_UDL = -ord("(");
  54. $c_UDR = -ord(")");
  55. $c_LRUD = -ord("+");
  56. $c_C = -ord(" ");
  57.  
  58. $c_LRud = -ord("*");
  59. $c_Lud = -ord("{");
  60. $c_Rud = -ord("}");
  61. $c_Ulr = -ord("h");
  62. $c_Dlr = -ord("y");
  63. $c_UDl = -ord("[");
  64. $c_UDr = -ord("]");
  65. $c_UDlr = -ord("#");
  66.  
  67. $foundIndex = -1;
  68.  
  69. class subRec
  70. {
  71.     var $i = -1;
  72.     var $iVal = "";
  73.     var $iFrom = 0;
  74.     var $iFromR = 0;
  75.     var $iBoxC = 0;
  76.     var $iBoxCR = 0;
  77.     var $iBoxL = 0;
  78.     var $iBoxR = 0;
  79.     var $iArr = array();
  80. }
  81. class gdRec
  82. {
  83.     var $i = -1;
  84.     var $iLevel = -1;
  85.     var $iArrLevel = -1;
  86.     var $iRef = "";
  87.     var $iTag = "";
  88.     var $iVal = "";
  89.     var $iText = "";
  90.     var $iBoxText = "";
  91.     var $iBoxLine = -1;
  92.     var $iBoxC = 0;
  93.     var $iBoxL = 0;
  94.     var $iBoxR = 0;
  95.     var $iBoxLen = 0;
  96.     var $iChilds = array();
  97.     var $iSubF = array();
  98.     var $iUpF = array();
  99.     var $iSubLine = 0;
  100.     var $iArrSub = array();
  101.     var $iAdded = -1;
  102. }
  103.  
  104. class gdLine
  105. {
  106.     var $iIsBox = FALSE;
  107.     var $iFs = array();
  108.     var $iFChars = array();
  109.     var $iRChars = array();
  110.     var $iReChars = array();
  111.     var $iChars = array();
  112.     var $iRecs = array();
  113.     var $iReStr = "";
  114.     var $iChStr = "";
  115.     var $iChBStr = "";
  116.     var $iStr = "";
  117.     var $iRStr = "";
  118.     var $iLStr = "";
  119.     function gdLine()
  120.     {
  121.     }
  122.     function funcStr($fin, $n)
  123.     {
  124.         global $c_ud;
  125.         global $c_UD;
  126.         $s = "";
  127.         $rs = "";
  128.         $cs = "";
  129.         $crs = "";
  130.         $bs = "";
  131.         $brs = "";
  132.         $c = count($this->iChars);
  133.         for ($k = 0; $k <= $c-1; $k++)
  134.         {
  135.             $ch = $this->iChars[$k];
  136.             $fch = $this->getFChar($k);
  137.             $rch = $this->getRChar($k);
  138.             if ($fin)
  139.             {
  140.                 $s =$s.(($ch == 0) ? " ":chr(abs($ch)));    
  141.                 $cs =$cs.(($fch == -2) ? chr($rch) : (($ch == 0) ? " ":chr(abs($ch))));    
  142.                 $bs =$bs.(($fch == -2 && $this->getFChar($k+1) == -2) ? " " :"|");  
  143.                 // UTD $bs =$bs.(($fch == -2 && $this->getFChar($k+1) == -2) ? " " :"|");              
  144.             }
  145.             else
  146.             {
  147.                 $s =$s.(($ch == 0) ? " ":($this->iIsBox ? "#":(($ch == $c_ud || $ch == $c_UD) ? "|":"=")));    
  148.                 //$s =$s.(($ch == 0) ? " ":($this->iIsBox ? "#":(($ch == $c_ud || $ch == $c_UD) ? "|":"=")));    
  149.             }
  150.         }
  151.         $c = count($this->iReChars);
  152.         for ($k = 0; $k <= $c-1; $k++)
  153.         {
  154.             $ch = $this->iReChars[$k];
  155.             $fch = $this->getFChar(-$k-1);
  156.             $rch = $this->getRChar(-$k-1);
  157.             if ($fin)
  158.             {
  159.                 $rs =$rs.(($ch == 0) ? " ":chr(abs($ch)));    
  160.                 $crs =$crs.(($fch == -2) ? chr($rch) : (($ch == 0) ? " ":chr(abs($ch))));    
  161.                 $brs =$brs.(($fch == -2 && $this->getFChar(-$k) == -2) ? " " :"|");  
  162.                 //$brs =$brs.(($fch == -2 && $this->getFChar(-$k) == -2) ? " " :"|");                  
  163.             }
  164.             else
  165.             {
  166.                 //$rs =$rs.(($ch == 0) ? " ":($this->iIsBox ? "#":(($ch == $c_ud || $ch == $c_UD) ? "|":"=")));    
  167.                 $rs =$rs.(($ch == 0) ? " ":($this->iIsBox ? "#":(($ch == $c_ud || $ch == $c_UD) ? "|":"=")));    
  168.             }
  169.         }
  170.         if ($n > -1)
  171.         {
  172.             if ($n > $c)
  173.             {
  174.                 $rs =$rs.str_repeat(" ", $n-$c);    
  175.                 $crs =$crs.str_repeat(" ", $n-$c);    
  176.                 $brs =$brs.str_repeat(" ", $n-$c);    
  177.             }
  178.             else
  179.             {
  180.                 $rs =substr($rs, 0, $n);    
  181.                 $crs =substr($crs, 0, $n);    
  182.                 $brs =substr($brs, 0, $n);    
  183.             }
  184.         }
  185.         $this->iLStr = $rs;
  186.         $this->iRStr = $s;
  187.         $this->iStr = strrev($rs).$s;
  188.         $this->iReStr = strrev($this->iStr);
  189.         $this->iChStr = strrev($crs).$cs;
  190.         $this->iChBStr = strrev($brs).$bs;
  191.     }
  192.     function funcSubStr($fin, $n, $i, $ii)
  193.     {
  194.         $this->funcStr($fin, $n);
  195.         if ($i == $ii)
  196.         {
  197.             return("");
  198.         }
  199.         if ($i >= 0)
  200.         {
  201.             return(substr($this->iRStr, $i, $ii-$i+1));
  202.         }
  203.         if ($ii < 0)
  204.         {
  205.             return(strrev(substr($this->iLStr, -$ii-1, $ii-$i+1)));
  206.         }
  207.         return(strrev(substr($this->iLStr, 0, -$i)).substr($this->iRStr, 0, $ii+1));
  208.     }
  209.     function getRChar($n)
  210.     {
  211.         if (in_array($n, $this->iFs))
  212.         {
  213.             $arr=array_keys($this->iFs, $n);
  214.             return($this->iRChars[$arr[0]]);
  215.         }
  216.         else
  217.         {
  218.             return(-1);
  219.         }
  220.     }
  221.     function getFChar($n)
  222.     {
  223.         if (in_array($n, $this->iFs))
  224.         {
  225.             $arr=array_keys($this->iFs, $n);
  226.             return($this->iFChars[$arr[0]]);
  227.         }
  228.         else
  229.         {
  230.             return(-1);
  231.         }
  232.     }
  233.     function setFChar($n, $s, $r)
  234.     {
  235.         if (in_array($n, $this->iFs))
  236.         {
  237.             $arr=array_keys($this->iFs, $n);
  238.             $this->iFChars[$arr[0]]=$s;
  239.             $this->iRChars[$arr[0]]=$r;
  240.         }
  241.         else
  242.         {
  243.             array_push($this->iFs, $n);    
  244.             array_push($this->iFChars, $s);    
  245.             array_push($this->iRChars, $r);    
  246.         }
  247.     }
  248.     function getGDChar($n)
  249.     {
  250.         if ($n>=0)
  251.         {
  252.             if ($n<count($this->iChars))
  253.             {
  254.                 return($this->iChars[$n]);
  255.             }
  256.             else
  257.             {
  258.                 return(0);
  259.             }
  260.         }
  261.         else
  262.         {
  263.             if (-$n-1<count($this->iReChars))
  264.             {
  265.                 return($this->iReChars[-$n-1]);
  266.             }
  267.             else
  268.             {
  269.                 return(0);
  270.             }
  271.         }
  272.     }
  273.     function setGDChar($n, $s)
  274.     {
  275.         if ($n>=0)
  276.         {
  277.             $c = count($this->iChars);
  278.             if ($n>$c)
  279.             {
  280.                 for ($k = $c; $k <= $n+54; $k++)
  281.                 {
  282.                     array_push($this->iChars, 0);    
  283.                 }
  284.             }
  285.             $this->iChars[$n]=$s;
  286.         }
  287.         else
  288.         {
  289.             $c = count($this->iReChars);
  290.             if (-$n-1>$c)
  291.             {
  292.                 for ($k = $c; $k <= -$n-1+54; $k++)
  293.                 {
  294.                     array_push($this->iReChars, 0);    
  295.                 }
  296.             }
  297.             $this->iReChars[-$n-1]=$s;
  298.         }
  299.     }
  300.     function addBox($n,$s,$en)
  301.     {
  302.         global $c_RD;
  303.         global $c_LD;
  304.         global $c_LR;
  305.         global $c_RU;
  306.         global $c_LU;
  307.         global $c_LRD;
  308.         $c = strlen($s);
  309.         $cc = floor($c/2);
  310.         for ($k = 0; $k <= $c-1; $k++)
  311.         {
  312.             $ch = substr($s, $k, 1);
  313.             $rch = $c_LR;
  314.             if ($k == 0)
  315.             {
  316.                 $rch = $c_RU;
  317.             }
  318.             elseif ($k == $c-1)
  319.             {
  320.                 $rch = $c_LU;
  321.             }
  322.             elseif ($k == $cc)
  323.             {
  324.                 if ($en)
  325.                 {
  326.                     $rch = $c_LRD;///
  327.                 }
  328.             }
  329.             $this->setGDChar($n+$k, $rch);    
  330.             $this->setFChar($n+$k, -2, ord($ch));    
  331.         }
  332.     }
  333. }
  334. function trace($s)
  335. {
  336.     print_r($s);///
  337.     print_r("<br>");///
  338. }
  339.  
  340. function funcreg($s)
  341. {
  342.     return(" ".$s." ");
  343. }
  344. function traceR($i)
  345. {
  346.     global $arrGDRecs;
  347.     global $gc;
  348.     trace("");///
  349.     for ($rk = 0; $rk <= $gc-1; $rk++)
  350.     {
  351.         $rec = $arrGDRecs[$rk];
  352.         if ($rec->iTag == "INDI" || !$i)
  353.         {
  354.             trace($rec);///
  355.         }
  356.     }
  357.     trace("");///
  358. }
  359. function traceLines($fin)
  360. {
  361.     global $arrLines;
  362.     global $tagVal;
  363.     $n = 0;
  364.     $cnt = count($arrLines);
  365.     for ($k = 0; $k <= $cnt-1; $k++)
  366.     {
  367.         $arrLines[$k]->funcStr($fin, -1);
  368.         $ss = rtrim($arrLines[$k]->iLStr);
  369.         $c = strlen($ss);
  370.         if ($c > $n)
  371.         {
  372.             $n = $c;
  373.         }
  374.     }
  375.     $m = $n;
  376.     for ($k = 0; $k <= $cnt-1; $k++)
  377.     {
  378.         $arrLines[$k]->funcStr($fin, $m);
  379.         $ss = rtrim($arrLines[$k]->iStr);
  380.         $c = strlen($ss);
  381.         if ($c > $n)
  382.         {
  383.             $n = $c;
  384.         }
  385.     }
  386.     $s = "{{familytree/start}}"."\n";
  387.     $ts = "{{familytree/start}}"."\n";
  388.     for ($k = 0; $k <= $cnt-1; $k++)
  389.     {
  390.         $ss = rtrim($arrLines[$k]->iStr);
  391.         $rss = rtrim($arrLines[$k]->iChStr);
  392.         $bss = rtrim($arrLines[$k]->iChBStr);
  393.         $c = strlen($rss);
  394.         if ($n > $c)
  395.         {
  396.             $rss = $rss.str_repeat(" ", $n-$c);    
  397.         }
  398.         else
  399.         {
  400.             $rss = substr($rss, 0, $n);    
  401.         }
  402.         $c = strlen($bss);
  403.         if ($n > $c)
  404.         {
  405.             $bss = $bss.str_repeat(" ", $n-$c);    
  406.         }
  407.         else
  408.         {
  409.             $bss = substr($bss, 0, $n);    
  410.         }
  411.         $c = strlen($ss);
  412.         if ($n > $c)
  413.         {
  414.             $ss = $ss.str_repeat(" ", $n-$c);    
  415.         }
  416.         else
  417.         {
  418.             $ss = substr($ss, 0, $n);    
  419.         }
  420.         $sss = "";
  421.         $ssss = "";
  422.         $c = strlen($ss);
  423.         for ($j = 0; $j <= $c-1; $j++)
  424.         {
  425.             $ch = substr($ss, $j, 1);    
  426.             $rch = substr($rss, $j, 1);    
  427.             $bch =substr($bss, $j, 1);    
  428.             $sss = $sss.$rch.(($j < $c-1) ? trim($bch) : "");    
  429.             $ssss = $ssss.$rch.(($j < $c-1) ? $bch : "");    
  430.         }
  431.         $s = $s."{{familytree |".$sss."}}"."\n";
  432.         $ts = $ts."{{familytree |".$ssss."}}"."\n";
  433.     }
  434.     $s = $s."{{familytree/end}}"."\n";
  435.     $ts = $ts."{{familytree/end}}"."\n";
  436.     return $s;///
  437.     ///print_r($tagVal.$s.$tagVal);
  438.     ///$fp = fopen("tree.txt", "w");
  439.     ///fwrite($fp, $s);
  440.     ///fclose($fp);
  441.     ///$fp = fopen("treeTemp.txt", "w");
  442.     ///fwrite($fp, $ts);
  443.     ///fclose($fp);
  444. }
  445. function traceFinal()
  446. {
  447.     global $arrFinal;
  448.     global $tagVal;
  449.     $n = 0;
  450.     $fin = TRUE;
  451.     $cnt = count($arrFinal)-1;
  452.     for ($k = 0; $k <= $cnt-1; $k++)
  453.     {
  454.         $arrFinal[$k]->funcStr($fin, -1);
  455.         $ss = rtrim($arrFinal[$k]->iLStr);
  456.         $c = strlen($ss);
  457.         if ($c > $n)
  458.         {
  459.             $n = $c;
  460.         }
  461.     }
  462.     $m = $n;
  463.     for ($k = 0; $k <= $cnt-1; $k++)
  464.     {
  465.         $arrFinal[$k]->funcStr($fin, $m);
  466.         $ss = rtrim($arrFinal[$k]->iStr);
  467.         $c = strlen($ss);
  468.         if ($c > $n)
  469.         {
  470.             $n = $c;
  471.         }
  472.     }
  473.     $s = "";
  474.     for ($k = 0; $k <= $cnt-1; $k++)
  475.     {
  476.         $ss = rtrim($arrFinal[$k]->iStr);
  477.         $c = strlen($ss);
  478.         if ($n > $c)
  479.         {
  480.             $ss = $ss.str_repeat(" ", $n-$c);    
  481.         }
  482.         else
  483.         {
  484.             $ss = substr($ss, 0, $n);    
  485.         }
  486.         $s = $s.$ss."\n";
  487.     }
  488.     print_r($tagVal.$s.$tagVal);///
  489.     $s = str_replace(" ", ".", $s);;
  490.     $fp = fopen("treeChars.txt", "w");
  491.     fwrite($fp, $s);
  492.     fclose($fp);
  493. }
  494. function clearTags()
  495. {
  496.     global $arrGDRecs;
  497.     global $gc;
  498.     for ($rk = 0; $rk <= $gc-1; $rk++)
  499.     {
  500.          $arrGDRecs[$rk]->iAdded = -1;
  501.     }
  502. }
  503. function findLevel($n)
  504. {
  505.     global $arrGDRecs;
  506.     global $gc;
  507.     global $maxLevel;
  508.     $rec = $arrGDRecs[$n];
  509.     if ($rec->iArrLevel != -1)
  510.     {
  511.         return($rec->iArrLevel);
  512.     }
  513.     if (count($rec->iUpF) == 0)
  514.     {
  515.         $arrGDRecs[$n]->iArrLevel=0;
  516.         return($arrGDRecs[$n]->iArrLevel);
  517.     }
  518.     for ($k = 0; $k <= $gc-1; $k++)
  519.     {
  520.         $prec = $arrGDRecs[$k];
  521.         if (findInArr($rec->iUpF,$prec->iSubF))
  522.         {
  523.             $arrGDRecs[$n]->iArrLevel=max($arrGDRecs[$n]->iArrLevel,findLevel($k)+1);
  524.             if ($arrGDRecs[$n]->iArrLevel > $maxLevel)
  525.             {
  526.                 $maxLevel = $arrGDRecs[$n]->iArrLevel;
  527.             }
  528.         }
  529.     }
  530.     return($arrGDRecs[$n]->iArrLevel);
  531. }
  532. function findChilds($n)
  533. {
  534.     global $arrGDRecs;
  535.     global $gc;
  536.     global $arrGD;
  537.     $rec = $arrGDRecs[$n];
  538.     if (count($rec->iUpF) == 0)
  539.     {
  540.         return;
  541.     }
  542.     $arr = array();
  543.     for ($k = 0; $k <= $gc-1; $k++)
  544.     {
  545.         $prec = $arrGDRecs[$k];
  546.         if (findInArr($rec->iUpF,$prec->iSubF))
  547.         {
  548.             array_push($arr, $rec);    
  549.         }
  550.     }
  551.     $arrGDRecs[$n]->iArrSub = $arr;
  552. }
  553. function findInArr($arr,$arrf)
  554. {
  555.     global $foundIndex;
  556.     for ($k = 0; $k <= count($arr)-1; $k++)
  557.     {
  558.         if (in_array($arr[$k], $arrf))
  559.         {
  560.             $foundIndex = $k;
  561.             return(TRUE);
  562.         }
  563.     }
  564.     $foundIndex = -1;
  565.     return(FALSE);
  566. }
  567. function findByRef($s)
  568. {
  569.     global $arrGDRecs;
  570.     global $gc;
  571.     if ($s == "")
  572.     {
  573.         return(-1);
  574.     }
  575.     for ($k = 0; $k <= $gc-1; $k++)
  576.     {
  577.         $rec = $arrGDRecs[$k];
  578.         if ($rec->iRef == $s)
  579.         {
  580.             return($k);
  581.         }
  582.     }
  583.     return(-1);
  584. }
  585. function addBox($sn,$dr)
  586. {
  587.     global $arrGDRecs;
  588.     global $currGDRec;
  589.     global $arrLines;
  590.     global $currLine;
  591.     global $arrLineGDRecs;
  592.     global $arrTempLineGDRecs;
  593.     $s = $currGDRec->iBoxText;
  594.     $c = strlen($s) + 1;
  595.     $n = $sn + strlen($currLine->iReStr);
  596.     $ss = strrev($currLine->iReStr) . $currLine->iStr;
  597.     $nn = strlen($ss);
  598.     if ($dr >= 0)
  599.     {
  600.         $fnd = FALSE;
  601.         $i = $n-2;
  602.         $cnt = 0;
  603.         for ($k = $n; !$fnd ; $k++)
  604.         {
  605.             if ($k <= $nn-1)
  606.             {
  607.                 $ch = substr($ss, $k, 1);
  608.                 if ($ch == " ")
  609.                 {
  610.                     $cnt++;  
  611.                 }
  612.                 else
  613.                 {
  614.                     $i = $k;
  615.                     $cnt = 0;
  616.                 }
  617.                 if ($cnt >= $c)
  618.                 {
  619.                     $fnd = TRUE;
  620.                     break;
  621.                 }
  622.             }
  623.             else
  624.             {
  625.                 $fnd = TRUE;
  626.                 break;
  627.             }
  628.         }
  629.         $i = $i + 2 - strlen($currLine->iReStr);
  630.     }
  631.     if ($dr <= 0)
  632.     {
  633.         $fnd = FALSE;
  634.         $ii = $n+2;
  635.         $cnt = 0;
  636.         for ($k = $n; !$fnd ; $k--)
  637.         {
  638.             if ($k >= 0 && $k <= $nn-1)
  639.             {
  640.                 $ch = substr($ss, $k, 1);
  641.                 if ($ch == " ")
  642.                 {
  643.                     $cnt++;  
  644.                 }
  645.                 else
  646.                 {
  647.                     $ii = $k;
  648.                     $cnt = 0;
  649.                 }
  650.                 if ($cnt >= $c)
  651.                 {
  652.                     $fnd = TRUE;
  653.                     break;
  654.                 }
  655.             }
  656.             else
  657.             {
  658.                 $fnd = TRUE;
  659.                 break;
  660.             }
  661.         }
  662.         $ii = $ii - 2 - strlen($currLine->iReStr);
  663.     }
  664.     if ($dr > 0)
  665.     {
  666.         $ii = $i + $c;
  667.     }
  668.     elseif ($dr < 0)
  669.     {
  670.         $i = $ii - $c;
  671.     }
  672.     else
  673.     {
  674.         if (abs($sn-$i) > abs($sn-$ii))
  675.         {
  676.             $i = $ii - $c;
  677.         }
  678.         else
  679.         {
  680.             $ii = $i + $c;
  681.         }
  682.     }
  683.     $currLine->addBox($i,$s,$currGDRec->iSubLine>=1);
  684.     $currLine->iRecs[$i]=$currGDRec->i;
  685.     $arrGDRecs[$currGDRec->i]->iBoxC=$i + round(($c-1)/2-.3);
  686.     $arrGDRecs[$currGDRec->i]->iBoxL=$i;
  687.     $arrGDRecs[$currGDRec->i]->iBoxR=$i + $c;
  688.     array_push($arrTempLineGDRecs , $currGDRec->i);  
  689.     array_push($arrLineGDRecs , $currGDRec->i);  
  690.     return($i);
  691. }
  692. function getSubC($i , $ii , $fn)
  693. {
  694.     global $lastLine;
  695.     global $c_RD;
  696.     global $c_LD;
  697.     global $c_UD;
  698.     global $c_LRD;
  699.     global $c_ud;
  700.     global $c_lrd;
  701.     global $c_LRud;
  702.     global $c_Dlr;
  703.     global $c_UDlr;
  704.     if ($i == $ii)
  705.     {
  706.         return($i);
  707.     }
  708.     $c = round(($i + $ii)/2+.3);
  709.     $j = -1;
  710.     $n = -1;
  711.     for ($k = $i; $k <= $ii; $k++)
  712.     {
  713.         $ch = $lastLine->getFChar($k);
  714.         if ($ch < 0)
  715.         {
  716.             if ($n == -1 || abs($c-$k)<$n)
  717.             {
  718.                 $j = $k;
  719.                 $n = abs($c-$k);
  720.             }
  721.         }
  722.     }
  723.     return($j);
  724. }
  725. function addLine($r , $b)
  726. {
  727.     global $addedLine;
  728.     global $arrLines;
  729.     global $c_RD;
  730.     global $c_LD;
  731.     global $c_UD;
  732.     global $c_LRD;
  733.     global $c_ud;
  734.     global $c_ld;
  735.     global $c_rd;
  736.     global $c_udl;
  737.     global $c_udr;
  738.     global $c_lrd;
  739.     global $c_LRud;
  740.     global $c_Dlr;
  741.     global $c_UDlr;
  742.     global $c_UDl;
  743.     global $c_UDr;
  744.     $addedLine = new gdLine();
  745.     $addedLine->iIsBox = $b;  
  746.     if (count($arrLines)>0)
  747.     {
  748.         $prec = $arrLines[count($arrLines)-1];
  749.         for ($rk = 0; $rk <= 1; $rk++)
  750.         {
  751.             if ($rk == 0)
  752.             {
  753.                 $arr = $prec->iReChars;
  754.             }
  755.             else
  756.             {
  757.                 $arr = $prec->iChars;
  758.             }
  759.             $cnt = count($arr);
  760.             for ($k = 0; $k <= $cnt-1; $k++)
  761.             {
  762.                 $pch = $arr[$k];
  763.                 $fn = $prec->getFChar($k);
  764.                 $ch = 0;
  765.                 if ($pch <= 0)
  766.                 {
  767.                     if ($pch == $c_ud || $pch == $c_ld  || $pch == $c_rd  || $pch == $c_lrd || $pch == $c_udl || $pch == $c_udr || $pch == $c_LRud)
  768.                     {
  769.                         $ch = $c_ud;
  770.                     }
  771.                     if ($pch == $c_UD || $pch == $c_LRD || $pch == $c_LD || $pch == $c_RD || $pch == $c_Dlr || $pch == $c_UDl || $pch == $c_UDr || $pch == $c_UDlr)
  772.                     {
  773.                         $ch = $c_UD;
  774.                     }
  775.                     if ($fn == -2 && $pch == $c_LRD)
  776.                     {
  777.                         $ch = $c_ud;
  778.                     }
  779.                 }
  780.                 if ($fn >= 0)
  781.                 {
  782.                     $addedLine->setFChar($k , $fn ,$prec->getRChar($k));  
  783.                 }
  784.                 if ($rk == 0)
  785.                 {
  786.                     array_push($addedLine->iReChars , $ch);  
  787.                 }
  788.                 else
  789.                 {
  790.                     array_push($addedLine->iChars , $ch);  
  791.                 }
  792.             }
  793.         }
  794.     }
  795.     if ($r)
  796.     {
  797.         array_push($arrLines , $addedLine);  
  798.     }
  799. }
  800. function copyLine()
  801. {
  802.     global $currLine;
  803.     global $addedLine;
  804.     $addedLine = new gdLine();
  805.     $addedLine->iIsBox = $currLine->iIsBox;
  806.     $arr = $currLine->iReChars;
  807.     $cnt = count($arr);
  808.     for ($k = 0; $k <= $cnt-1; $k++)
  809.     {
  810.         array_push($addedLine->iReChars , $arr[$k]);  
  811.     }
  812.     $arr = $currLine->iChars;
  813.     $cnt = count($arr);
  814.     for ($k = 0; $k <= $cnt-1; $k++)
  815.     {
  816.         array_push($addedLine->iChars , $arr[$k]);  
  817.     }
  818. }
  819. function addSubLines($n,$i,$ii,$r,$rr,$en,$enn,$fn)
  820. {
  821.     global $arrLines;
  822.     global $arrGDRecs;
  823.     global $gc;
  824.     global $c_lu;
  825.     global $c_ru;
  826.     global $c_ud;
  827.     global $c_lr;
  828.     global $c_lrd;
  829.     global $c_udl;
  830.     global $c_udr;
  831.     global $c_UD;
  832.     $c = -1;
  833.     for ($k = $n; $k <= count($arrLines)-1; $k++)
  834.     {
  835.         $rec = $arrLines[$k];
  836.         $s = $rec->funcStr($i,$ii);
  837.         $s = str_replace(chr(-$c_ud), "", $s);
  838.         $s = str_replace(chr(-$c_UD), "", $s);
  839.         $s = str_replace(" ", "", $s);
  840.         if ($s = "")
  841.         {
  842.             $c = $k;
  843.             break;
  844.         }
  845.     }
  846.     if ($c == -1)
  847.     {
  848.         addLine(TRUE, FALSE);  
  849.         $c = count($arrLines)-1;
  850.     }
  851.     for ($k = $i; $k <= $ii; $k++)
  852.     {
  853.         $pch = $arrLines[$c]->getGDChar($k);
  854.         $ch = $pch;
  855.         if ($pch == 0)
  856.         {
  857.             $ch = $c_lr;
  858.         }
  859.         elseif ($pch == $c_lrd)
  860.         {
  861.         }
  862.         if ($k == $i)
  863.         {
  864.             $ch = $en ? $c_udr : $c_ru;
  865.         }
  866.         if ($k == $ii)
  867.         {
  868.             $ch = $enn ? $c_udl : $c_lu;
  869.         }
  870.         $arrLines[$c]->setGDChar($k, $ch);
  871.     }
  872.     for ($rk = 0; $rk <= 1; $rk++)
  873.     {
  874.         $j = ($rk == 0) ? $i : $ii;
  875.         $nr = ($rk == 0) ? $r : $rr;
  876.         for ($k = $c-1; $k > $nr ; $k--)
  877.         {
  878.             $pch = $arrLines[$k]->getGDChar($j);
  879.             $ch = $pch;
  880.             if ($pch == 0)
  881.             {
  882.                 $ch = $c_ud;
  883.             }
  884.             elseif ($pch == $c_lrd)
  885.             {
  886.             }
  887.             $arrLines[$k]->setGDChar($j, $ch);
  888.         }
  889.     }
  890.     $fndc = FALSE;
  891.     for ($k = 0; $k <= $gc-1; $k++)
  892.     {
  893.         $rec = $arrGDRecs[$k];
  894.         if (in_array($fn, $rec->iUpF))
  895.         {
  896.             $fndc = TRUE;
  897.             break;
  898.         }
  899.     }
  900.     if ($fndc)
  901.     {
  902.         $cc = round(($i + $ii)/2+.3);
  903.         $fnd = FALSE;
  904.         for ($k = 0; !$fnd; $k++)
  905.         {
  906.             for ($rk = 0; $rk <= 1; $rk++)
  907.             {
  908.                 $n = ($rk == 0) ? $cc+$k : $cc-$k;
  909.                 $pch = $arrLines[$c]->getGDChar($n);
  910.                 $ch = $pch;
  911.                 if ($pch == $c_lr || $pch == $c_ru || $pch == $c_udr || $pch == $c_lu || $pch == $c_udl || $pch == 0)
  912.                 {
  913.                     $arrLines[$c]->setFChar($n , $fn ,$c);  
  914.                     $fnd = TRUE;
  915.                     break;
  916.                 }
  917.             }
  918.         }
  919.     }
  920. }
  921. function addSubLine($n,$i,$r,$en,$fn)
  922. {
  923.     global $arrLines;
  924.     global $arrGDRecs;
  925.     global $gc;
  926.     global $c_lu;
  927.     global $c_ru;
  928.     global $c_ud;
  929.     global $c_lr;
  930.     global $c_lrd;
  931.     global $c_udl;
  932.     global $c_udr;
  933.     global $c_UD;
  934.     $c = $n;
  935.     $fndc = FALSE;
  936.     for ($k = 0; $k <= $gc-1; $k++)
  937.     {
  938.         $rec = $arrGDRecs[$k];
  939.         if (in_array($fn, $rec->iUpF))
  940.         {
  941.             $fndc = TRUE;
  942.             break;
  943.         }
  944.     }
  945.     if ($fndc)
  946.     {
  947.         $arrLines[$c]->setFChar($i , $fn ,$c);  
  948.     }
  949. }
  950. function addCLine($rei,$reii,$r,$fn)
  951. {
  952.     global $arrLines;
  953.     global $c_RD;
  954.     global $c_LD;
  955.     global $c_UD;
  956.     global $c_LR;
  957.     global $c_LRD;
  958.     global $c_ud;
  959.     global $c_lr;
  960.     global $c_lrd;
  961.     global $c_Dlr;
  962.     if ($rei < $reii)
  963.     {
  964.         $i = $rei;
  965.         $ii = $reii;
  966.     }
  967.     else
  968.     {
  969.         $i = $reii;
  970.         $ii = $rei;
  971.     }
  972.     if ($i != $ii)
  973.     {
  974.         $c = -1;
  975.         for ($k = $r; $k <= count($arrLines)-1; $k++)
  976.         {
  977.             $rec = $arrLines[$k];
  978.             $s = $rec->funcStr($i,$ii);
  979.             $s = str_replace(chr(-$c_ud), "", $s);;
  980.             $s = str_replace(chr(-$c_UD), "", $s);;
  981.             $s = str_replace(" ", "", $s);;
  982.             if ($s = "")
  983.             {
  984.                 $c = $k;
  985.                 break;
  986.             }
  987.         }
  988.         if ($c == -1)
  989.         {
  990.             addLine(TRUE, FALSE);  
  991.             $c = count($arrLines)-1;
  992.         }
  993.         for ($j = $i; $j <= $ii; $j++)
  994.         {
  995.             $pch = $arrLines[$c]->getGDChar($j);
  996.             $ch = $pch;
  997.             if ($pch == 0)
  998.             {
  999.                 $ch = $c_LR;
  1000.             }
  1001.             elseif ($pch == $c_lrd)
  1002.             {
  1003.             }
  1004.             $arrLines[$c]->setGDChar($j, $ch);
  1005.         }
  1006.     }
  1007.     else
  1008.     {
  1009.         $c = $r;
  1010.     }
  1011.     $j = $rei;
  1012.     for ($k = $c-1; $k > $r ; $k--)
  1013.     {
  1014.         $pch = $arrLines[$k]->getGDChar($j);
  1015.         $ch = $pch;
  1016.         if ($pch == 0)
  1017.         {
  1018.             $ch = $c_UD;
  1019.         }
  1020.         elseif ($pch == $c_lrd)
  1021.         {
  1022.         }
  1023.         $arrLines[$k]->setGDChar($j, $ch);
  1024.     }
  1025.     $pch = $arrLines[$r]->getGDChar($j);
  1026.     if ($pch == $c_lr)
  1027.     {
  1028.         $arrLines[$r]->setGDChar($j, $c_Dlr);
  1029.     }
  1030.     return($c);
  1031. }
  1032. function addSideLine($n,$i,$ii,$r,$rr,$en,$enn,$fn)
  1033. {
  1034.     global $arrLines;
  1035.     global $arrGDRecs;
  1036.     global $gc;
  1037.     global $c_lu;
  1038.     global $c_ru;
  1039.     global $c_ud;
  1040.     global $c_lr;
  1041.     global $c_lrd;
  1042.     global $c_udl;
  1043.     global $c_udr;
  1044.     global $c_UD;
  1045.     $c = -1;
  1046.     return(FALSE);
  1047.     for ($k = $n; $k <= count($arrLines)-1; $k++)
  1048.     {
  1049.         $rec = $arrLines[$k];
  1050.         $s = $rec->funcStr($i,$ii);
  1051.         $s = str_replace(chr(-$c_ud), "", $s);
  1052.         $s = str_replace(chr(-$c_UD), "", $s);
  1053.         $s = str_replace(" ", "", $s);
  1054.         if ($s = "")
  1055.         {
  1056.             $c = $k;
  1057.             break;
  1058.         }
  1059.     }
  1060.     if ($c == -1)
  1061.     {
  1062.         addLine(TRUE, FALSE);  
  1063.         $c = count($arrLines)-1;
  1064.     }
  1065.     for ($k = $i; $k <= $ii; $k++)
  1066.     {
  1067.         $pch = $arrLines[$c]->getGDChar($k);
  1068.         $ch = $pch;
  1069.         if ($pch == 0)
  1070.         {
  1071.             $ch = $c_lr;
  1072.         }
  1073.         elseif ($pch == $c_lrd)
  1074.         {
  1075.         }
  1076.         if ($k == $i)
  1077.         {
  1078.             $ch = $en ? $c_udr : $c_ru;
  1079.         }
  1080.         if ($k == $ii)
  1081.         {
  1082.             $ch = $enn ? $c_udl : $c_lu;
  1083.         }
  1084.         $arrLines[$c]->setGDChar($k, $ch);
  1085.     }
  1086.     for ($rk = 0; $rk <= 1; $rk++)
  1087.     {
  1088.         $j = ($rk == 0) ? $i : $ii;
  1089.         $nr = ($rk == 0) ? $r : $rr;
  1090.         for ($k = $c-1; $k > $nr ; $k--)
  1091.         {
  1092.             $pch = $arrLines[$k]->getGDChar($j);
  1093.             $ch = $pch;
  1094.             if ($pch == 0)
  1095.             {
  1096.                 $ch = $c_ud;
  1097.             }
  1098.             elseif ($pch == $c_lrd)
  1099.             {
  1100.             }
  1101.             $arrLines[$k]->setGDChar($j, $ch);
  1102.         }
  1103.     }
  1104.     $fndc = FALSE;
  1105.     for ($k = 0; $k <= $gc-1; $k++)
  1106.     {
  1107.         $rec = $arrGDRecs[$k];
  1108.         if (in_array($fn, $rec->iUpF))
  1109.         {
  1110.             $fndc = TRUE;
  1111.             break;
  1112.         }
  1113.     }
  1114.     if ($fndc)
  1115.     {
  1116.         $cc = round(($i + $ii)/2+.3);
  1117.         $fnd = FALSE;
  1118.         for ($k = 0; !$fnd; $k++)
  1119.         {
  1120.             for ($rk = 0; $rk <= 1; $rk++)
  1121.             {
  1122.                 $n = ($rk == 0) ? $cc+$k : $cc-$k;
  1123.                 $pch = $arrLines[$c]->getGDChar($n);
  1124.                 $ch = $pch;
  1125.                 if ($pch == $c_lr || $pch == $c_ru || $pch == $c_udr || $pch == $c_lu || $pch == $c_udl || $pch == 0)
  1126.                 {
  1127.                     $arrLines[$c]->setFChar($n , $fn ,$c);  
  1128.                     $fnd = TRUE;
  1129.                     break;
  1130.                 }
  1131.             }
  1132.         }
  1133.     }
  1134. }
  1135. function addUpLine($i,$ii,$iii,$iiii,$arr,$r)
  1136. {
  1137.     global $arrLines;
  1138.     global $c_RD;
  1139.     global $c_LD;
  1140.     global $c_RU;
  1141.     global $c_LU;
  1142.     global $c_UD;
  1143.     global $c_LR;
  1144.     global $c_LRU;
  1145.     global $c_LRD;
  1146.     global $c_ud;
  1147.     global $c_ld;
  1148.     global $c_lu;
  1149.     global $c_rd;
  1150.     global $c_lr;
  1151.     global $c_lrd;
  1152.     global $c_lru;
  1153.     $c = count($arrLines)-1;
  1154.     ///$arrLines[$c]->setFChar($i , -1 ,-1);  
  1155.     if ($iii != $iiii)
  1156.     {
  1157.         for ($j = $iii; $j <= $iiii; $j++)
  1158.         {
  1159.             $pch = $arrLines[$c]->getGDChar($j);
  1160.             $ch = $pch;
  1161.             if ($pch == 0)
  1162.             {
  1163.                 $ch = $c_LR;
  1164.             }
  1165.             elseif ($pch == $c_lrd)
  1166.             {
  1167.                 $ch = $c_LR;
  1168.             }
  1169.             $arrLines[$c]->setGDChar($j, $ch);
  1170.         }
  1171.     }
  1172.     $rr = count($arrLines);
  1173.     for ($kk = 0; $kk <= count($arr)-1; $kk++)
  1174.     {
  1175.         $k = $arr[$kk];
  1176.         if ($iii != $iiii)
  1177.         {
  1178.             $arrLines[$c]->setGDChar($k, $c_LRD);
  1179.         }
  1180.         else
  1181.         {
  1182.             $arrLines[$c]->setGDChar($k, $c_UD);
  1183.         }
  1184.         for ($j = $c+1; $j < $rr ; $j++)
  1185.         {
  1186.             $pch = $arrLines[$j]->getGDChar($k);
  1187.             $ch = $pch;
  1188.             if ($pch == 0)
  1189.             {
  1190.                 $ch = $c_UD;
  1191.             }
  1192.             elseif ($pch == $c_lrd)
  1193.             {
  1194.                 $ch = $c_LRD;
  1195.             }
  1196.             $arrLines[$j]->setGDChar($k, $ch);///
  1197.         }
  1198.     }
  1199.     $j =  $ii;
  1200.     for ($k = $c-1; $k > $r ; $k--)
  1201.     {
  1202.         $pch = $arrLines[$k]->getGDChar($j);
  1203.         $ch = $pch;
  1204.         if ($pch == 0)
  1205.         {
  1206.             $ch = $c_UD;
  1207.         }
  1208.         elseif ($pch == $c_lrd)
  1209.         {
  1210.             $ch = $c_UD;
  1211.         }
  1212.         $arrLines[$k]->setGDChar($j, $ch);///
  1213.     }
  1214.     if ($i != $ii)
  1215.     {
  1216.         $arrLines[$r]->setGDChar($i, (($i > $ii) ? $c_LU : $c_RU));
  1217.         $arrLines[$r]->setGDChar($ii, (($i > $ii) ? $c_RD : $c_LD));
  1218.     }  
  1219.     if ($iii != $iiii)
  1220.     {
  1221.         if (count($arr)>1)
  1222.         {
  1223.             $arrLines[$c]->setGDChar($ii, $c_LRU);///
  1224.         }  
  1225.         $arrLines[$c]->setGDChar($iii, $c_RD);
  1226.         $arrLines[$c]->setGDChar($iiii, $c_LD);
  1227.     }  
  1228.     return;
  1229. }
  1230. ///---------------------------------------------------------------------------------------------
  1231. ///---------------------------------------------------------------------------------------------
  1232. ///---------------------------------------------------------------------------------------------
  1233. ///---------------------------------------------------------------------------------------------
  1234. ///---------------------------------------------------------------------------------------------
  1235. ///---------------------------------------------------------------------------------------------
  1236. ///---------------------------------------------------------------------------------------------
  1237. $arrGDRecs = array();
  1238. $narrow =array();
  1239. $gc = 0;
  1240. $arrFileRecs = split($gd_line_delim, $gdFileStr);
  1241. $cnt = count($arrFileRecs);
  1242. for ($i = 0; $i <= $cnt-1; $i++)
  1243. {
  1244.     $s = trim($arrFileRecs[$i]);
  1245.     if ($s=="")
  1246.     {
  1247.         continue;
  1248.     }
  1249.     $arrLineRecs = split($gd_delim, $s);
  1250.     $c = count($arrLineRecs);
  1251.     $rec = new gdRec();
  1252.     $j = 0;
  1253.     ///-------------------------------
  1254.     if ($c>0)
  1255.     {
  1256.         $s = trim($arrLineRecs[0]);
  1257.         while ($c > 0 && $s == "")
  1258.         {
  1259.             $s = trim(array_shift($arrLineRecs));$c--;
  1260.             $s = trim($arrLineRecs[0]);
  1261.         }
  1262.     }
  1263.     ///----
  1264.     if ($c>0)
  1265.     {
  1266.         $s = trim(array_shift($arrLineRecs));$c--;
  1267.         if (!ereg($gd_level,funcreg($s)))
  1268.         {
  1269.             ///continue;
  1270.         }
  1271.         $rec->iLevel = (int) $s;
  1272.     }
  1273.     ///-------------------------------
  1274.     if ($c>0)
  1275.     {
  1276.         $s = trim($arrLineRecs[0]);
  1277.         while ($c > 0 && $s == "")
  1278.         {
  1279.             $s = trim(array_shift($arrLineRecs));$c--;
  1280.             $s = trim($arrLineRecs[0]);
  1281.         }
  1282.     }
  1283.     ///----
  1284.     if ($c>0)
  1285.     {
  1286.         $s = trim($arrLineRecs[0]);
  1287.         if (ereg($gd_pointer," ".$s." "))
  1288.         {
  1289.             $s = trim(array_shift($arrLineRecs));$c--;
  1290.             $rec->iRef = $s;
  1291.         }
  1292.         else
  1293.         {
  1294.         }
  1295.     }
  1296.     ///-------------------------------
  1297.     if ($c>0)
  1298.     {
  1299.         $s = trim($arrLineRecs[0]);
  1300.         while ($c > 0 && $s == "")
  1301.         {
  1302.             $s = trim(array_shift($arrLineRecs));$c--;
  1303.             $s = trim($arrLineRecs[0]);
  1304.         }
  1305.     }
  1306.     ///----
  1307.     if ($c>0)
  1308.     {
  1309.         $s = trim(array_shift($arrLineRecs));$c--;
  1310.         $rec->iTag = $s;
  1311.     }
  1312.     ///-------------------------------
  1313.     if ($c>0)
  1314.     {
  1315.         $s = join(" ", $arrLineRecs);
  1316.         $rec->iVal = ltrim($s);
  1317.     }
  1318.     ///-------------------------------
  1319.     array_push($arrGDRecs, $rec);    
  1320.     $gc++;
  1321. }
  1322. for ($rk = 0; $rk <= $gc-1; $rk++)
  1323. {
  1324.      $arrGDRecs[$rk]->i = $rk;
  1325. }
  1326. $naid=0;
  1327. for ($k = 0; $k <= $gc-1; $k++)
  1328. {
  1329.     $rec = $arrGDRecs[$k];
  1330.     $arr = array();
  1331.    
  1332.     for ($n = $k+1 ; $n <= $gc-1; $n++)
  1333.     {
  1334.         $crec = $arrGDRecs[$n];
  1335.         if ($crec->iLevel <= $rec->iLevel )
  1336.         {
  1337.             break;
  1338.         }
  1339.         if ($crec->iTag == "NAME")
  1340.         {
  1341.             $arrGDRecs[$k]->iText = $crec->iVal;
  1342.             $s="".$arrGDRecs[$k]->iText."";
  1343.  
  1344.             $naid++;
  1345.             $nasid="".$naid;
  1346.             $nalen=strlen($nasid);
  1347.             $nast='NA'.(substr('000'.$naid,$nalen,3));         
  1348.             $narrow[$naid].="$s";          
  1349.             $s=$nast;
  1350.             //$sle=strlen($s)/2;
  1351.             //$spc=substr('                                          ',0,$sle);
  1352.             //$s=$spc.$s.$spc;
  1353.             $c = strlen($s);
  1354.             if ($c > 20 )
  1355.             {
  1356.                 $s=substr($s, 0, 20);
  1357.             }
  1358.             $c = strlen($s);
  1359.             if ($c%2 == 0)
  1360.             {
  1361.                 $s=$s." ";
  1362.             }
  1363.             $s=" ".$s." ";
  1364.             $arrGDRecs[$k]->iBoxText=$s;
  1365.             $arrGDRecs[$k]->iBoxLen=(strlen($s)*2);
  1366.         }
  1367.         if ($crec->iLevel == $rec->iLevel+1 )
  1368.         {
  1369.             array_push($arr , $n);    
  1370.         }
  1371.     }
  1372.     $arrGDRecs[$k]->iChilds = $arr;
  1373. }
  1374. for ($k = 0; $k <= $gc-1; $k++)
  1375. {
  1376.     $rec = $arrGDRecs[$k];
  1377.     if ($rec->iTag == "FAM")
  1378.     {
  1379.         $arr = $rec->iChilds;
  1380.         $cnt = count($arr);
  1381.         for ($n = 0; $n <= $cnt-1; $n++)
  1382.         {
  1383.             $crec = $arrGDRecs[$arr[$n]];
  1384.             if ($crec->iTag == "HUSB" || $crec->iTag == "WIFE")
  1385.             {
  1386.                 $i=findByRef($crec->iVal);
  1387.                 if ($i>= 0)
  1388.                 {
  1389.                     $arrGDRecs[$i]->iSubLine++;
  1390.                     array_push($arrGDRecs[$i]->iSubF , $k);    
  1391.                 }
  1392.             }
  1393.             if ($crec->iTag == "CHIL")
  1394.             {
  1395.                 $i=findByRef($crec->iVal);
  1396.                 if ($i>= 0)
  1397.                 {
  1398.                     array_push($arrGDRecs[$i]->iUpF , $k);    
  1399.                 }
  1400.             }
  1401.         }
  1402.     }
  1403. }
  1404. for ($k = 0; $k <= $gc-1; $k++)
  1405. {
  1406.     $rec = $arrGDRecs[$k];
  1407.     if ($rec->iTag == "INDI")
  1408.     {
  1409.         findChilds($n);
  1410.     }
  1411. }
  1412. $maxLevel = 0;
  1413. for ($k = 0; $k <= $gc-1; $k++)
  1414. {
  1415.     $rec = $arrGDRecs[$k];
  1416.     if ($rec->iTag == "INDI")
  1417.     {
  1418.         findLevel($k);
  1419.     }
  1420. }
  1421. clearTags();
  1422. $arrGDLevels = array();
  1423. for ($n = 0; $n <= $maxLevel; $n++)
  1424. {
  1425.     $arr = array();
  1426.     if ($n > 0)
  1427.     {
  1428.         for ($rk = 0; $rk <= count($arrp)-1; $rk++)
  1429.         {
  1430.             $prec = $arrGDRecs[$arrp[$rk]];
  1431.             for ($k = 0; $k <= count($prec->iArrSub)-1; $k++)
  1432.             {
  1433.                 $c = $prec->iArrSub[$k];
  1434.                 $rec = $arrGDRecs[$c];
  1435.                 if ($rec->iTag == "INDI")
  1436.                 {
  1437.                     if ($rec->iAdded == -1 && $rec->iArrLevel == $n)
  1438.                     {
  1439.                         $arrGDRecs[$c]->iAdded = 4;
  1440.                         array_push($arr , $c);  
  1441.                     }
  1442.                 }
  1443.             }
  1444.         }
  1445.     }
  1446.     for ($k = 0; $k <= $gc-1; $k++)
  1447.     {
  1448.         $rec = $arrGDRecs[$k];
  1449.         if ($rec->iTag == "INDI")
  1450.         {
  1451.             if ($rec->iAdded == -1 && $rec->iArrLevel == $n)
  1452.             {
  1453.                 array_push($arr , $k);  
  1454.             }
  1455.         }
  1456.     }
  1457.     array_push($arrGDLevels , $arr);  
  1458.     $arrp = $arr;
  1459. }
  1460. $addedLine = new gdLine();
  1461. $arrLines = array();
  1462. addLine(TRUE ,FALSE);
  1463. $arrLineGDRecs = array();
  1464. for ($rk = 0; $rk <= count($arrGDLevels)-1; $rk++)
  1465. {
  1466.     $arrTempLineGDRecs = array();
  1467.     $arrp = $arrGDLevels[$rk];
  1468.     $cnt = count($arrp);
  1469.     addLine(FALSE ,TRUE);
  1470.     $currLine = $addedLine;
  1471.     clearTags();
  1472.     if ($rk == 0)
  1473.     {
  1474.         $sn = 0;
  1475.         for ($k = 0; $k <= $cnt-1; $k++)
  1476.         {
  1477.             $currGDRec = $arrGDRecs[$arrp[$k]];
  1478.             $sn = addBox($sn , 1);
  1479.             $currLine->funcStr(FALSE, -1);
  1480.         }
  1481.     }
  1482.     else
  1483.     {
  1484.         $arr = array();
  1485.         $lastLine = $arrLines[count($arrLines)-1];
  1486.         $fc = count($arrFs);
  1487.         $dr = 1;
  1488.         $lsn = 0;
  1489.         $rsn = 0;
  1490.         for ($fkk = 0; $fkk <= $fc-1; $fkk++)
  1491.         {
  1492.             $dr *= -1;
  1493.             $fk = $arrFs[$fkk];
  1494.             $fn = $lastLine->getFChar($fk);
  1495.             $r = $lastLine->getRChar($fk);
  1496.             $srec = new subRec();
  1497.             $srec->iVal = $fn;
  1498.             $srec->iFrom = $fk;
  1499.             $srec->iFromR = $r;
  1500.             for ($j = 0; $j <= $cnt-1; $j++)
  1501.             {
  1502.                 $jj = $arrp[$j];
  1503.                 $currGDRec = $arrGDRecs[$jj];
  1504.                 if ($currGDRec->iAdded == -1 && in_array($fn, $currGDRec->iUpF))
  1505.                 {
  1506.                     $arrGDRecs[$jj]->iAdded = $fn;
  1507.                     array_push($srec->iArr , $jj);  
  1508.                 }
  1509.                
  1510.             }  
  1511.             if ($fkk == 0)
  1512.             {
  1513.                 $idr = 1;
  1514.                 for ($j = 0; $j <= count($srec->iArr)-1; $j++)
  1515.                 {
  1516.                     $idr *= -1;
  1517.                     $jj = $srec->iArr[$j];
  1518.                     $currGDRec = $arrGDRecs[$jj];
  1519.                     if ($j == 0)
  1520.                     {
  1521.                         if (count($srec->iArr) % 2 == 0)
  1522.                         {
  1523.                             $csn = $fk+1;
  1524.                             $idr = 1;
  1525.                         }
  1526.                         else
  1527.                         {
  1528.                             $csn = $fk-floor(strlen($currGDRec->iBoxText)/2);  //  /2 kiszedve
  1529.                             $idr = -1;
  1530.                         }
  1531.                         $sn = addBox($csn,0);
  1532.                         $rsn = $sn + strlen($currGDRec->iBoxText);
  1533.                         $lsn = $sn;
  1534.                     }
  1535.                     elseif ($idr > 0)
  1536.                     {
  1537.                         $rsn = addBox($rsn,$idr) + strlen($currGDRec->iBoxText); //  +
  1538.                     }
  1539.                     else
  1540.                     {
  1541.                         $lsn = addBox($lsn,$idr)-1;
  1542.                     }
  1543.                     $ce = $arrGDRecs[$jj]->iBoxC;
  1544.                     $srec->iArr[$j] = $ce;  
  1545.                     if ($j == 0)
  1546.                     {
  1547.                         $i = $ce;
  1548.                         $ii = $ce;
  1549.                     }
  1550.                     $i = min($i , $ce) ;
  1551.                     $ii = max($ii , $ce);
  1552.                 }
  1553.             }  
  1554.             else
  1555.             {
  1556.                 for ($j = 0; $j <= count($srec->iArr)-1; $j++)
  1557.                 {
  1558.                     $jj = $srec->iArr[$j];
  1559.                     $currGDRec = $arrGDRecs[$jj];
  1560.                     if ($dr > 0)
  1561.                     {
  1562.                         $rsn = addBox($rsn,$dr) + strlen($currGDRec->iBoxText);
  1563.                     }
  1564.                     else
  1565.                     {
  1566.                         $lsn = addBox($lsn,$dr)-1;
  1567.                     }
  1568.                     $ce = $arrGDRecs[$jj]->iBoxC;
  1569.                     $srec->iArr[$j] = $ce;  
  1570.                     if ($j == 0)
  1571.                     {
  1572.                         $i = $ce;
  1573.                         $ii = $ce;
  1574.                     }
  1575.                     $i = min($i , $ce) ;
  1576.                     $ii = max($ii , $ce);
  1577.                 }
  1578.             }
  1579.             if (count($srec->iArr) > 0)
  1580.             {
  1581.                 $srec->iBoxL = $i;
  1582.                 $srec->iBoxR = $ii;
  1583.                 $srec->iBoxC = getSubC($i , $ii , $fn);
  1584. ///trace("      {       {       {");
  1585. ///trace($i);
  1586. ///trace($ii);
  1587.                 $srec->iBoxCR = addCLine($fk,$srec->iBoxC,$r,$fn);
  1588.             }
  1589.             array_push($arr , $srec);  
  1590.         }
  1591.         addLine(TRUE ,FALSE);
  1592.         $fndarr = FALSE;
  1593.         for ($k = 0; $k <= count($arr)-1; $k++)
  1594.         {
  1595.             $srec = $arr[$k];
  1596.             if (count($srec->iArr) > 0)
  1597.             {
  1598.                 $fndarr = $fndarr || (count($srec->iArr) > 1);
  1599.                 addUpLine($srec->iFrom,$srec->iBoxC,$srec->iBoxL,$srec->iBoxR,$srec->iArr,$srec->iBoxCR);
  1600.             }
  1601.         }
  1602.         if ($fndarr)
  1603.         {
  1604.             addLine(TRUE ,FALSE);
  1605.         }
  1606.     }
  1607.     for ($j = 0; $j <= $cnt-1; $j++)
  1608.     {
  1609.         $jj = $arrp[$j];
  1610.         $currGDRec = $arrGDRecs[$jj];
  1611.         $arrGDRecs[$currGDRec->i]->iBoxLine=count($arrLines);
  1612.     }  
  1613.     array_push($arrLines , $currLine);  
  1614.     addLine(TRUE, FALSE);
  1615.     for ($k = 0; $k <= count($arrTempLineGDRecs)-1; $k++)
  1616.     {
  1617.         $rec = $arrGDRecs[$arrTempLineGDRecs[$k]];
  1618.         for ($kk = 0; $kk <= count($arrLineGDRecs)-(count($arrTempLineGDRecs)-$k)-1; $kk++)
  1619.         {
  1620.             $prec = $arrGDRecs[$arrLineGDRecs[$kk]];
  1621.             if ($rec->i != $prec->i)
  1622.             {
  1623.                 if (findInArr($rec->iSubF,$prec->iSubF))
  1624.                 {
  1625.                     $fn = $rec->iSubF[$foundIndex];
  1626.                     if ($rec->iBoxC > $prec->iBoxC)
  1627.                     {
  1628.                         $fnd = addSideLine(max($prec->iBoxLine,$rec->iBoxLine)+1,$prec->iBoxC,$rec->iBoxC,$prec->iBoxLine,$rec->iBoxLine,$prec->iSubLine>1,$rec->iSubLine>1,$fn);
  1629.                     }
  1630.                     else
  1631.                     {
  1632.                         $fnd = addSideLine(max($rec->iBoxLine,$prec->iBoxLine)+1,$rec->iBoxC,$prec->iBoxC,$rec->iBoxLine,$prec->iBoxLine,$rec->iSubLine>1,$prec->iSubLine>1,$fn);
  1633.                     }
  1634.                     if (!$fnd)
  1635.                     {
  1636.                         if ($rec->iBoxC > $prec->iBoxC)
  1637.                         {
  1638.                             addSubLines(max($prec->iBoxLine,$rec->iBoxLine)+1,$prec->iBoxC,$rec->iBoxC,$prec->iBoxLine,$rec->iBoxLine,$arrGDRecs[$prec->i]->iSubLine>1,$arrGDRecs[$rec->i]->iSubLine>1,$fn);
  1639.                         }
  1640.                         else
  1641.                         {
  1642.                             addSubLines(max($rec->iBoxLine,$prec->iBoxLine)+1,$rec->iBoxC,$prec->iBoxC,$rec->iBoxLine,$prec->iBoxLine,$arrGDRecs[$rec->i]->iSubLine>1,$arrGDRecs[$prec->i]->iSubLine>1,$fn);
  1643.                         }
  1644.                     }
  1645.                     $arrGDRecs[$rec->i]->iSubLine--;
  1646.                     $arrGDRecs[$prec->i]->iSubLine--;
  1647.                 }
  1648.             }
  1649.         }
  1650.         for ($kk = 0; $kk <= count($rec->iSubF)-1; $kk++)
  1651.         {
  1652.             if ($arrGDRecs[$rec->i]->iSubLine <= 0)
  1653.             {
  1654.                 ///break;
  1655.             }
  1656.             $fn = $rec->iSubF[$kk];
  1657.             $fnd = FALSE;
  1658.             for ($kkk = 0; $kkk <= $gc-1; $kkk++)
  1659.             {
  1660.                 if ($kkk != $rec->i)
  1661.                 {
  1662.                     $prec = $arrGDRecs[$kkk];
  1663.                     if (in_array($fn, $prec->iSubF))
  1664.                     {
  1665.                         $fnd = TRUE;
  1666.                         break;
  1667.                     }
  1668.                 }
  1669.             }
  1670.             if (!$fnd)
  1671.             {
  1672.                 addSubLine($rec->iBoxLine+1,$rec->iBoxC,$rec->iBoxLine,$arrGDRecs[$rec->i]->iSubLine>1,$fn);
  1673.                 $arrGDRecs[$rec->i]->iSubLine--;
  1674.             }
  1675.         }
  1676.     }
  1677.     $currLine = $arrLines[count($arrLines)-1];
  1678.     $i = -count($currLine->iReChars) ;
  1679.     $ii = count($currLine->iChars)-1 ;
  1680.     $cnt = 0;
  1681.     for ($k = $i; $k <= $ii; $k++)
  1682.     {
  1683.         if ($currLine->getFChar($k) >= 0)
  1684.         {
  1685.             $cnt ++;
  1686.         }
  1687.     }
  1688.     $c = 0;
  1689.     for ($k = $i; $k <= $ii; $k++)
  1690.     {
  1691.         if ($currLine->getFChar($k) >= 0)
  1692.         {
  1693.             $n = $k;
  1694.             if ($c == round($cnt/2-.3))
  1695.             {
  1696.                 break;
  1697.             }
  1698.             $c ++;
  1699.         }
  1700.     }
  1701.     $arrFs = array();
  1702.     for ($k = 0; $k <= $cnt-1; $k++)
  1703.     {
  1704.         array_push($arrFs , -1);  
  1705.     }
  1706.     $arrFs[0] = $n;
  1707.     $c = 0;
  1708.     for ($k = $n+1; $k <= $ii; $k++)
  1709.     {
  1710.         if ($currLine->getFChar($k) >= 0)
  1711.         {
  1712.             $arrFs[$c*2+1] = $k;
  1713.             $c ++;
  1714.         }
  1715.     }
  1716.     $c = 0;
  1717.     for ($k = $n-1; $k >= $i; $k--)
  1718.     {
  1719.         if ($currLine->getFChar($k) >= 0)
  1720.         {
  1721.             $arrFs[$c*2+2] = $k;
  1722.             $c ++;
  1723.         }
  1724.     }
  1725.  
  1726. }
  1727. addLine(TRUE ,FALSE);
  1728. $arrFinal = array();
  1729. for ($rk = 0; $rk <= count($arrLines)-1; $rk++)
  1730. {
  1731.     $currLine = $arrLines[$rk];
  1732.     if ($currLine->iIsBox)
  1733.     {
  1734.         for ($j = 0; $j <= 2; $j++)
  1735.         {
  1736.             copyLine();
  1737.             $i = -count($currLine->iReChars) ;
  1738.             $ii = count($currLine->iChars) ;
  1739.             for ($k = $i; $k <= $ii-1; $k++)
  1740.             {
  1741.                 $ch = $currLine->getGDChar($k);
  1742.                 $fch = $currLine->getFChar($k);
  1743.                 $rch = $currLine->getRChar($k);
  1744.                 if ($fch == -2)
  1745.                 {
  1746.                     $nch = $rch;
  1747.                     if ($j == 0)
  1748.                     {
  1749.                         $pch = $arrLines[$rk-1]->getGDChar($k);
  1750.                         if ($ch == $c_RU)
  1751.                         {
  1752.                             $nch = $c_RD;
  1753.                         }
  1754.                         elseif ($ch == $c_LU)
  1755.                         {
  1756.                             $nch = $c_LD;
  1757.                         }
  1758.                         elseif ($ch <= 0)
  1759.                         {
  1760.                             if ($pch == $c_UD || $pch == $c_LRD || $pch == $c_LD || $pch == $c_RD)
  1761.                             {
  1762.                                 $nch = $c_LRU;
  1763.                             }
  1764.                             else
  1765.                             {
  1766.                                 $nch = $c_LR;
  1767.                             }
  1768.                         }
  1769.                     }
  1770.                     elseif ($j == 1)
  1771.                     {
  1772.                         ksort($currLine->iRecs);
  1773.                         $arrv = array_values($currLine->iRecs);
  1774.                         for ($rv = 0; $rv <= count($arrv)-1; $rv++)
  1775.                         {
  1776.                         }
  1777.                         if ($ch == $c_RU || $ch == $c_LU)
  1778.                         {
  1779.                             $nch = $c_UD;
  1780.                         }
  1781.                         else
  1782.                         {
  1783.                         }
  1784.                     }
  1785.                     else
  1786.                     {
  1787.                         $pch = $arrLines[$rk+1]->getGDChar($k);
  1788.                         if ($ch == $c_RU)
  1789.                         {
  1790.                             $nch = $c_RU;
  1791.                         }
  1792.                         elseif ($ch == $c_LU)
  1793.                         {
  1794.                             $nch = $c_LU;
  1795.                         }
  1796.                         elseif ($ch <= 0)
  1797.                         {
  1798.                             if ($pch == $c_ud || $pch == $c_lrd || $pch == $c_ld || $pch == $c_rd)
  1799.                             {
  1800.                                 $nch = $c_LRD;
  1801.                             }
  1802.                             else
  1803.                             {
  1804.                                 $nch = $c_LR;
  1805.                             }
  1806.                         }
  1807.                     }
  1808.                     $addedLine->setGDChar($k , $nch);
  1809.                 }
  1810.             }
  1811.             array_push($arrFinal , $addedLine);  
  1812.         }
  1813.     }
  1814.     else
  1815.     {
  1816.         copyLine();
  1817.         array_push($arrFinal , $addedLine);  
  1818.     }
  1819. }
  1820. array_shift($arrLines);    
  1821. array_pop($arrLines);  
  1822. array_pop($arrLines);  
  1823. $txt=traceLines(TRUE);///
  1824.  
  1825. $stxt="";
  1826. //$stxt=str_replace("  "," |",$txt);
  1827. $srows=split("\n", $txt);
  1828. $k=0;
  1829. foreach ($srows as $srow)
  1830. {
  1831.     $k++;
  1832.     $psrow="";
  1833.     $pend=strlen($srow);
  1834.     $pos=0;
  1835.     while($pos<$pend)
  1836.     {      
  1837.         $ca=substr($srow,$pos,2);
  1838.         $pos=$pos+2;
  1839.         if ($ca=="  ") $ca=" |";
  1840.         if ($ca=="- ") $ca="-|";
  1841.         if ($ca==" -") $ca="-|";
  1842.         if ($ca=="! ") $ca="!|";
  1843.         if ($ca==" !") $ca="!|";
  1844.         if ($ca==": ") $ca=":|";
  1845.         if ($ca==" :") $ca=":|";
  1846.         if ($ca=="~:") $ca=":~";
  1847.         if ($ca=="-:") $ca=":-";
  1848.         if ($ca=="~J") $ca="J|";
  1849.         if ($ca==" ,") $ca=",-";
  1850.         if ($ca==" L")
  1851.         {  
  1852.             if (  substr($srow,$pos,1)=='~' )
  1853.                 $ca="L~";
  1854.         }
  1855.         if ($ca=="-v") $ca="v-";
  1856.         if ($ca=="~y") $ca="y~";
  1857.         if ($ca=="-^") $ca="^-";
  1858.         if ($ca=="-'") $ca="'|";
  1859.         if ($ca=="-.") $ca=".|";
  1860.         if ($ca==". ") $ca=".|";
  1861.         if ($ca=="' ") $ca="'|";
  1862.         if ($ca=="--") $ca="-|";
  1863.         if ($ca=="~~") $ca="~|";
  1864.         if ($ca=="y~") $ca="y|";
  1865.         if ($ca=="L~") $ca="L|";
  1866.         if ($ca==",-") $ca=",|";
  1867.         if ($ca=="v-") $ca="v|";
  1868.         if ($ca=="`-") $ca="`|";
  1869.         if ($ca==":-") $ca=":|";
  1870.         if ($ca==":~") $ca=":|";
  1871.         if ($ca=="J ") $ca="J|";
  1872.         if ($ca=="^-") $ca="^|";
  1873.         $psrow.=$ca;       
  1874.     }
  1875.     $psrow=str_replace(' |!:','!|:|',$psrow);
  1876.     $psrow=str_replace('--.:','.|:|',$psrow);  
  1877.     $namese="|";
  1878.     for ($cikl=1;$cikl<=count($narrow);$cikl++)
  1879.     {
  1880.         $nasid="".$cikl;
  1881.         $nalen=strlen($nasid);
  1882.         $nast='NA'.(substr('000'.$cikl,$nalen,3));
  1883.         if (strpos($psrow,$nast)>0)
  1884.         {
  1885.             if (strpos($psrow," ".$nast)>0)
  1886.                 $psrow=str_replace(" ".$nast," | |".$nast."| |",$psrow);
  1887.             else
  1888.                 $psrow=str_replace("|".$nast,"| | |".$nast."| |",$psrow);
  1889.             if ($namese!="|") $namese.="|";
  1890.             $namese.=$nast."=[[".$narrow[$cikl]."]]";
  1891.         }
  1892.     }
  1893.     $namese.="}}";
  1894.     if ($k>1) $psrow=str_replace("}}",$namese,$psrow);
  1895.     $srows[$k-1]=$psrow;
  1896.    
  1897. }
  1898. $k=0;
  1899. foreach ($srows as $srow)
  1900. {
  1901.     $k++;
  1902.     $pos=0;$pend=strlen($srow);
  1903.     while($pos<$pend)
  1904.     {  
  1905.         $pos++;
  1906.         if (substr($srow,$pos,1)==":")
  1907.         {                  
  1908.             if (substr($srows[$k],$pos,1)==" ")
  1909.             {  
  1910.                 $srows[$k]=substr_replace($srows[$k],":",$pos,1);
  1911.             }
  1912.        
  1913.         }
  1914.     }
  1915.     $stxt.=$srows[$k-1]."\n";
  1916. }
  1917. print_r($stxt);
  1918. ///trace("converted :   [".$gdFile."]  =>   [tree.txt] , [treeTemp.txt] and [treeChars.txt]");
  1919. ///array_shift($arrFinal);  
  1920. ///array_pop($arrFinal);    
  1921. ///traceFinal();
  1922. ?>
  1923. </textarea>
  1924. </body>
  1925. </html>
  1926.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!