Example #1
0
        IColumnSorter GetColumnSorter(ColumnDataType_t dataType)
        {
            IColumnSorter sorter;

            if (!m_colSorters.TryGetValue(dataType , out sorter))
            {
                switch (dataType)
                {
                    case ColumnDataType_t.Text:
                    sorter = new TextColumnSorter();
                    break;

                    case ColumnDataType_t.Integer:
                    sorter = new IntegerColumnSorter();
                    break;

                    case ColumnDataType_t.Float:
                    sorter = new FloatColumnSorter();
                    break;

                    case ColumnDataType_t.Time:
                    sorter = new TimeColumnSorter();
                    break;

                    default:
                    Assert(false);
                    break;
                }

                m_colSorters[dataType] = sorter;
            }


            return sorter;
        }
Example #2
0
        void InsertColumns()
        {
            Assert(!InvokeRequired);

            IDataColumn[]  colHeader = m_dataProvider.DataSource.Columns;
            ColumnHeader[] columns   = new ColumnHeader[colHeader.Length];

            for (int i = 0; i < columns.Length; ++i)
            {
                columns[i] = new ColumnHeader()
                {
                    Text      = colHeader[i].Caption,
                    TextAlign = HorizontalAlignment.Center,
                    Tag       = colHeader[i].DataType,
                }
            }
            ;

            m_lvData.Columns.AddRange(columns);
        }

        void InsertItems(ListViewEntry[] items)
        {
            Assert(!InvokeRequired);

            m_lvData.Items.AddRange(items);

            TextLogger.Info("\nNbre d'enregistrements {0}.", m_dataProvider.Count);
        }

        void LoadDataAsync()
        {
            Func <ListViewEntry[]> loadData = () =>
            {
                ConnectProvider();
                return(LoadItems());
            };


            var waitClue = new Waits.WaitClue(this);

            Action <Task <ListViewEntry[]> > onError = t =>
            {
                Exception ex = t.Exception.InnerException;
                TextLogger.Error(ex.Message);

                waitClue.LeaveWaitMode();


                if (ex is CorruptedStreamException == false)
                {
                    ex = new CorruptedStreamException(innerException: ex);
                }

                throw ex;
            };


            Action <Task <ListViewEntry[]> > onSuccess = t =>
            {
                InsertColumns();

                ListViewEntry[] items = t.Result;
                InsertItems(items);
                waitClue.LeaveWaitMode();

                m_tslblStatus.Text = $"Nombre d'neregistrements: {m_lvData.Items.Count}";
            };


            waitClue.EnterWaitMode();

            var loading = new Task <ListViewEntry[]>(loadData, TaskCreationOptions.LongRunning);

            loading.ContinueWith(onSuccess,
                                 CancellationToken.None,
                                 TaskContinuationOptions.OnlyOnRanToCompletion,
                                 TaskScheduler.FromCurrentSynchronizationContext());

            loading.ContinueWith(onError, CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted,
                                 TaskScheduler.FromCurrentSynchronizationContext());

            loading.Start();
        }

        IColumnSorter SorterFactory(int ndxColumn)
        {
            var           dataType = (ColumnDataType_t)m_lvData.Columns[ndxColumn].Tag;
            IColumnSorter sorter   = null;

            switch (dataType)
            {
            case ColumnDataType_t.Text:
                sorter = new TextColumnSorter(ndxColumn);
                break;

            case ColumnDataType_t.Integer:
                sorter = new IntegerColumnSorter(ndxColumn);
                break;

            case ColumnDataType_t.Float:
                sorter = new FloatColumnSorter(ndxColumn);
                break;

            case ColumnDataType_t.Time:
                sorter = new TimeColumnSorter(ndxColumn);
                break;
            }

            Assert(sorter != null);

            return(sorter);
        }