public void addVersion(VersionInfo version)
            {
                if (PointFromVersion.ContainsKey(version.versionName))
                {
                    return;
                }

                int colNum = -1;
                int row = calcRow(version.versionName);
                string g = DeCostaNumbers.GetMother(version.versionName);
                List<VersionInfo> CallBe = new List<VersionInfo>();

                while (PointFromVersion.ContainsKey(g) == false && version.versionName.Equals("0") == false && g.Equals("0") == false)
                {
                    CallBe.Add(new VersionInfo(g));
                    g = DeCostaNumbers.GetMother(g);
                }
                if (CallBe.Count > 0)
                {
                    CallBe.Reverse();
                    addVersion(CallBe);
                }

                if (DaughtersFrom.ContainsKey(g) == false)
                {
                    DaughtersFrom[g] = new List<string>();
                }
                DaughtersFrom[g].Add(version.versionName);
                List<Column> ColList;
                int potentColm;
                int potentCols;
                if (row > rowMax)
                {
                    rowMax = row;
                }
                foreach (KeyValuePair<int, List<Column>> k in ColumnListFromColumnNumber)
                {
                    foreach (Column c in k.Value)
                    {
                        //will reject the add and return false
                        // if version is not a first daugher
                        //decendant in this column
                        if (c.AddVersion(version))
                        {
                            colNum = k.Key;
                            break;
                        }
                    }
                    if (colNum != -1)
                    {
                        break;
                    }
                }

                if (colNum == -1)
                {
                    Column c = new Column(this.PointFromVersion);
                    c.AddVersion(version);
                    int start = NumberOfDot(version.versionName);
                    potentColm = -1;
                    potentCols = -1;

                    string moth = DeCostaNumbers.GetMother(version.versionName);
                    string sis = DeCostaNumbers.GetBigSister(version.versionName);

                    int mothR = calcRow(moth);
                    int sisR = -1;
                    if (sis != DeCostaNumbers.AUNT && sis != DeCostaNumbers.NONE)
                    {
                        sisR = calcRow(sis);
                    }

                    if (ColumnListFromColumnNumber.ContainsKey(start) == false)
                    {
                        ColumnListFromColumnNumber[start] = new List<Column>();
                        if (start > largestColumnNumber)
                        {
                            largestColumnNumber = start;
                        }
                    }

                    VersionInfo vers;
                    //
                    for (int i = start, cols = 0; cols < ColumnListFromColumnNumber.Count & i <= largestColumnNumber; i++)
                    {
                        if(ColumnListFromColumnNumber.ContainsKey(i) == true)
                        {
                            cols++;
                            foreach (Column co in ColumnListFromColumnNumber[i])
                            {
                                if (sis != DeCostaNumbers.AUNT && sis != DeCostaNumbers.NONE)
                                {
                                    if (co.TryGetValue(sisR, out vers))
                                    {
                                        if (vers.versionName.Equals(sis))
                                        {
                                            potentCols = i + 1;
                                            break;

                                        }
                                    }
                                }

                                if (co.TryGetValue(mothR, out vers))
                                {
                                    if (vers.versionName.Equals(moth))
                                    {
                                        potentColm = i + 1;

                                    }
                                }
                            }
                        }
                        if (potentCols != -1)
                        {
                            break;
                        }
                    }

                    if (potentColm == -1 && potentCols == -1)
                    {
                        potentColm = start;
                    }
                    else if (potentCols != -1)
                    {
                        potentColm = potentCols;
                    }

                    if (ColumnListFromColumnNumber.TryGetValue(potentColm, out ColList) == false)
                    {
                        ColumnListFromColumnNumber[potentColm] = new List<Column>();
                        ColList = ColumnListFromColumnNumber[potentColm];
                        if (potentColm > largestColumnNumber)
                        {
                            largestColumnNumber = potentColm;
                        }
                    }

                    ColList.Add(c);
                    colNum = potentColm;
                    c.Col = colNum;
                }
                PointFromVersion[version.versionName].col = colNum;
                CheckColumn(colNum);
            }