C1FlexGrid - Merge()

 

셀 병합

   : 다른 병합 방법이 있지만... 새로 만들어본 병합 코드이다. 

   : 각 셀에 index를 가지고 인접한 셀에 값이 같은지 확인하고 같으면 같은 영역으로 몰아주기를 진행한다. 

   : 소스에서 보듯이 각 행마다 오른쪽(컬럼이동)으로 먼저 확인하고 같은 셀들을 몰아주기

   : 다음 각 컬럼마다 아래쪽(행이동)으로 확인하면서 같은 셀들을 몰아준다. 

   * 진행 순서에 따라 열이 먼저 병합될지 행이 먼저 병합될지를 결정한다. 

   * 소량의 데이타를 가지고 해볼 수 있는 간단한 소스이다. 

   각 셀의 갯수만큼 CR을 생성하여 인접한 셀로 몰아주기 처리를 하기 때문에 데이타가 너무 많으면... 장담 못한다. 

   데이타 갯수는 따로 해보진 않아서... 모르겠고...

   * 개발하면서 떠올린 생각 : 뿌요뿌요.... 

        private void Merge()
        {
            C1FlexGrid grd = c1FlexGrid1;
            List<CR> merges = new List<CR>();
            for (int rIdx = grd.Rows.Fixed; rIdx < grd.Rows.Count; rIdx++)
            {
                for (int cIdx = grd.Cols.Fixed; cIdx < grd.Cols.Count; cIdx++)
                {
                    int r = rIdx - grd.Rows.Fixed;
                    int c = cIdx - grd.Cols.Fixed;
                    merges.Add(new CR() {
                        idx = (r * (grd.Cols.Count- grd.Cols.Fixed)) + c
                      , r1 = rIdx, r2 = rIdx, c1 = cIdx, c2 = cIdx
                      , Text = $"{grd[rIdx, cIdx]}" 
                    });
                }
            }

            for (int rIdx = grd.Rows.Fixed; rIdx < grd.Rows.Count; rIdx++)
            {
                int r = rIdx - grd.Rows.Fixed;
                int cHold = -1;
                for (int cIdx = grd.Cols.Fixed; cIdx < grd.Cols.Count; cIdx++)
                {
                    // 옆으로...
                    int c = cIdx - grd.Cols.Fixed;
                    if (cHold == -1) cHold = c; 
                    int idx = (r * (grd.Cols.Count - grd.Cols.Fixed)) + cHold;
                    CR cr = merges[idx];
                    int nidx = (r * (grd.Cols.Count - grd.Cols.Fixed)) + c+1;
                    if (nidx < merges.Count)
                    {
                        CR ncr = merges[nidx];
                         
                        if (cr.Text == ncr.Text && ncr.Merged == false)
                        {
                            cr.c2 = ncr.c2;
                            ncr.Merged = true;
                        }

                        if (cr.Text != ncr.Text) cHold = -1;
                    }
                } 
            }

            for (int cIdx = grd.Cols.Fixed; cIdx < grd.Cols.Count; cIdx++)
            {
                // 아래로
                int c = cIdx - grd.Cols.Fixed;
                int rHold = -1;
                for (int rIdx = grd.Rows.Fixed; rIdx < grd.Rows.Count; rIdx++)
                {
                    int r = rIdx - grd.Rows.Fixed;
                    if( rHold == -1) rHold = r;

                    int idx = (rHold * (grd.Cols.Count - grd.Cols.Fixed)) + c;
                    CR cr = merges[idx];
                    int nidx = ((r+1) * (grd.Cols.Count - grd.Cols.Fixed)) + c;
                    if (nidx < merges.Count)
                    {
                        CR ncr = merges[nidx];
                        if (cr.Text == ncr.Text && ncr.Merged == false)
                        {
                            cr.r2 = ncr.r2;
                            ncr.Merged = true;
                        }

                        if (cr.Text != ncr.Text)
                        {
                            rHold = -1;
                        }
                    }
                }
            }

            List<CR> Mrgs = merges.Where(cell => cell.Merged == false).ToList();

            grd.AllowMerging = AllowMergingEnum.Custom;
            foreach (var mr in Mrgs)
            {
                grd.MergedRanges.Add(mr.r1, mr.c1, mr.r2, mr.c2);               
            }
        }