Esempio n. 1
0
            /// <summary>
            /// Add a field array to the List of field array in the table.
            /// </summary>
            /// <param name="fieldArray">The Field array to add.</param>
            /// <returns>A CCFieldArray when successfull, null when failed.</returns>
            public virtual CCFieldArray AddFieldArray(CCFieldArray fieldArray)
            {
                try
                {
                    if (fieldArrays == null)
                    {
                        fieldArrays = new List <CCFieldArray>();
                    }

                    //-- Find or Add a new field array --\\
                    foreach (CCFieldArray cfa in fieldArrays)
                    {
                        if (String.Compare(cfa.Name, fieldArray.Name, true) == 0)
                        {
                            return(cfa);
                        }
                    }

                    this.SetParents();
                    return(fieldArray);
                }
                catch (Exception ex)
                {
                    ILog.LogError(ex, false);
                    throw ex;
                }
            }
Esempio n. 2
0
            /// <summary>
            /// Add a field to the groups' List of fields.
            /// </summary>
            /// <param name="fieldName">The name of the Field to create.</param>
            /// <returns>A CCField when successfull, null when failed.</returns>
            public virtual CCField AddField(ITisFieldParams field, TIS_RECT fieldRect)
            {
                try
                {
                    if (fields == null)
                    {
                        fields = new List <CCField>();
                    }

                    //-- Add a new field --\\
                    foreach (CCField cf in fields)
                    {
                        if (String.Compare(cf.Name, field.Name, true) == 0)
                        {
                            return(cf);
                        }
                    }

                    if (field.ParentFieldTableExists)
                    {
                        // TODO: finish testing here.
                        //\\ bool createTable = true;
                        // CCTable = this.tables.IndexOf(
                        foreach (CCTable tbl in this.tables)
                        {
                            if (String.Compare(tbl.Name, field.ParentFieldTable.Name, true) == 0)
                            {
                                CCFieldArray cfa = tbl.AddFieldArray(field.Name);
                                cfa.AddField(field, fieldRect);
                            }
                        }
                    }
                    else
                    {
                        fields.Add(new CCField(this.ParentCreator, field.Name, String.Empty, 0, fieldRect, null, null, null));
                    }

                    fields[fields.Count - 1].CCParent = this;

                    this.SetParents();
                    return(fields[fields.Count - 1]);
                }
                catch (Exception ex)
                {
                    ILog.LogError(ex, false);
                    throw ex;
                }
            }
Esempio n. 3
0
            public CCPage(CCreator parent, ITisPageParams page, String page_id)
#endif
                : base(parent, page != null? page.Name:String.Empty, null, null)
            {
                try
                {
                    if (groups == null)
                    {
                        groups = new List <CCGroup>();
                    }
                    else
                    {
                        groups.Clear();
                    }

                    this.EflowOwner  = page;
                    this.PageID      = page_id;
                    this.NamedParent = page.ParentForm.Name;
                    bool           hasEfi = false;
                    CCGroup        grp    = null;
                    List <CCTable> tables = new List <CCTable>();

                    if (!String.IsNullOrEmpty(page_id))
                    {
                        //-- Get matched EFI --\\
                        ITisEFIParams efi = page.get_LinkedEFI(page_id);
                        hasEfi = efi != null;
                        if (hasEfi)
                        {
                            //-- Get all fields and field-groups that has ROIs --\\
                            foreach (ITisROIParams roi in efi.ROIs)
                            {
                                if (roi.Miscellaneous.OrderInField == 1)
                                {
                                    ITisFieldParams fp = page.get_LinkedField(roi.Miscellaneous.FieldName);

                                    if (fp != null)
                                    {
                                        if (fp.ParentFieldGroupExists)
                                        {
                                            //-- A standard field --\\
                                            grp = GetGroup(fp.ParentFieldGroup.Name);
                                            if (grp == null)
                                            {
                                                grp = new CCGroup(parent, fp.ParentFieldGroup, false);
                                                groups.Add(grp);
                                            }

                                            CCField cf = grp.GetField(fp.Name);

                                            //-- Create field and join sll ROIs --\\
                                            if (cf == null)
                                            {
                                                cf = grp.AddField(fp.Name, String.Empty, 0, CCUtils.MergerRoisRect(CCUtils.GetLinkedRois(efi, fp.Name)));
                                            }
                                            else
                                            {
                                                cf.Rect = new FieldRect(CCUtils.MergerRoisRect(CCUtils.GetLinkedRois(efi, fp.Name)));
                                            }

                                            grp.AddField(cf);
                                        }
                                        else if (fp.ParentFieldTableExists)
                                        {
                                            //-- A table field --\\
                                            grp = AddGroup(fp.ParentFieldTable.ParentFieldGroup.Name);
                                            CCTable tbl = grp.AddTable(fp.ParentFieldTable.Name);

                                            if (!tables.Contains(tbl))
                                            {
                                                tables.Add(tbl);
                                            }
                                            CCFieldArray fldArr = tbl.AddFieldArray(fp.Name);
                                            fldArr.AddField(fp, CCUtils.MergerRoisRect(CCUtils.GetLinkedRois(efi, fp.Name)));
                                            //CCField cf = fldArr.AddField(fldArr.fp.Name);

                                            ////-- Create field and join sll ROIs --\\
                                            //if (cf == null) cf = grp.AddField(fp.Name, String.Empty, 0, CCUtils.MergerRoisRect(CCUtils.GetLinkedRois(efi, fp.Name)));
                                            //else cf.Rect = new FieldRect(CCUtils.MergerRoisRect(CCUtils.GetLinkedRois(efi, fp.Name)));

                                            //CCFieldArray cfAr = tbl.AddFieldArray(fp.Name);

                                            //cfAr.AddField(cf);
                                        }
                                    }
                                }
                            }

                            //-- Add rows if KeepEmptyRows is marked --\\
                            if (tables != null && tables.Count > 0)
                            {
                                foreach (CCTable tbl in tables)
                                {
                                    ITisFieldTableParams efTable = page.get_LinkedFieldTable(tbl.Name);
                                    if (efTable != null && efTable.Table.KeepEmptyRows && efTable.Table.NumberOfRows > tbl.NumberOfRows)
                                    {
                                        tbl.AddRow();
                                    }
                                }
                            }
                        }
                    }

                    if (!hasEfi)
                    {
                        foreach (ITisFieldParams fld in page.LinkedFields)
                        {
                            if (fld.ParentFieldGroupExists)
                            {
                                grp = GetGroup(fld.ParentFieldGroup.Name);
                                if (grp == null)
                                {
                                    grp = new CCGroup(parent, fld.ParentFieldGroup, false);
                                    groups.Add(grp);
                                }
                            }
                            else if (fld.ParentFieldTableExists)
                            {
                                grp = GetGroup(fld.ParentFieldTable.ParentFieldGroup.Name);
                                if (grp == null)
                                {
                                    grp = new CCGroup(parent, fld.ParentFieldTable.ParentFieldGroup, false);
                                    groups.Add(grp);
                                }
                            }
                        }

                        foreach (ITisFieldTableParams fldTbl in page.LinkedFieldTables)
                        {
                            grp = GetGroup(fldTbl.ParentFieldGroup.Name);
                            if (grp == null)
                            {
                                grp = new CCGroup(parent, fldTbl.ParentFieldGroup, false);
                                groups.Add(grp);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    ILog.LogError(ex);
                }
            }