Beispiel #1
0
 private static object[] GetMessageArgs(ObjectType objectType, string objectName, string propertyName, params string[] arguments)
 {
     object[] array = new object[3 + ((arguments != null) ? arguments.Length : 0)];
     array[0] = ErrorContext.GetLocalizedObjectTypeString(objectType);
     array[1] = ErrorContext.GetLocalizedObjectNameString(objectType, objectName);
     array[2] = ErrorContext.GetLocalizedPropertyNameString(propertyName);
     if (arguments != null)
     {
         for (int i = 0; i < arguments.Length; i++)
         {
             array[3 + i] = arguments[i];
         }
     }
     return(array);
 }
        private void RegisterOverlappingItems(InitializationContext context, int count, SortedReportItemIndexList sortedTop, bool isSortedVertically)
        {
            Hashtable hashtable = new Hashtable(count);

            for (int i = 0; i < count - 1; i++)
            {
                int    num  = sortedTop[i];
                double num2 = isSortedVertically ? this.m_entries[num].AbsoluteBottomValue : this.m_entries[num].AbsoluteRightValue;
                bool   flag = true;
                for (int j = i + 1; j < count; j++)
                {
                    if (!flag)
                    {
                        break;
                    }
                    int num3 = sortedTop[j];
                    Global.Tracer.Assert(num != num3, "(currentIndex != peerIndex)");
                    double num4 = isSortedVertically ? this.m_entries[num3].AbsoluteTopValue : this.m_entries[num3].AbsoluteLeftValue;
                    if (num2 > num4)
                    {
                        int     num5    = Math.Min(num, num3);
                        int     num6    = Math.Max(num, num3);
                        IntList intList = hashtable[num5] as IntList;
                        if (intList == null)
                        {
                            intList         = new IntList();
                            hashtable[num5] = intList;
                        }
                        intList.Add(num6);
                    }
                    else
                    {
                        flag = false;
                    }
                }
            }
            foreach (int key in hashtable.Keys)
            {
                IntList intList2 = hashtable[key] as IntList;
                double  num8     = isSortedVertically ? this.m_entries[key].AbsoluteLeftValue : this.m_entries[key].AbsoluteTopValue;
                double  num9     = isSortedVertically ? this.m_entries[key].AbsoluteRightValue : this.m_entries[key].AbsoluteBottomValue;
                for (int k = 0; k < intList2.Count; k++)
                {
                    int    index = intList2[k];
                    double num10 = isSortedVertically ? this.m_entries[index].AbsoluteLeftValue : this.m_entries[index].AbsoluteTopValue;
                    double num11 = isSortedVertically ? this.m_entries[index].AbsoluteRightValue : this.m_entries[index].AbsoluteBottomValue;
                    if (num10 > num8 && num10 < num9)
                    {
                        goto IL_023a;
                    }
                    if (num11 > num8 && num11 < num9)
                    {
                        goto IL_023a;
                    }
                    if (num10 <= num8 && num9 <= num11)
                    {
                        goto IL_023a;
                    }
                    if (num8 <= num10 && num11 <= num9)
                    {
                        goto IL_023a;
                    }
                    continue;
IL_023a:
                    context.ErrorContext.Register(ProcessingErrorCode.rsOverlappingReportItems, Severity.Warning, this.m_entries[key].ObjectType, this.m_entries[key].Name, null, ErrorContext.GetLocalizedObjectTypeString(this.m_entries[index].ObjectType), this.m_entries[index].Name);
                }
            }
        }