Project Description

Simple HexControl (HexView) is a classic Windows Forms control. It implements a hexadecimal view of bytes with grouping. It's blazing fast, renders only visible frame of a window and support of painting the individual groups of bytes without the total window redraw.

 

Links

https://sourceforge.net/projects/hexviewcontrol/

Features

- Supports vertical and horizontal scrolling
- Supports auto-scroll / auto hide scroll bars
- Renders only visible window frame
- Can update individual byte change
- Supports any type of fonts
- Less intense calculations due to bytes block measurement / rendering

Documentation

HexControl is scrollable composite Windows Forms control. Control logic is divided into presentation logic, model, and some simple code to reflect model changes to presentation control (M-V pattern), skipping controller logic totally, because controller part (events, subscriptions, updates) will be taken totally by the .NET Framework.

Usage scenarios

You can change grouping of the bytes by setting HexControl properties in Appearance section:

- BytesPerColumn
- ColumnPerRow

Screenshots

Hi! Anyone want to have fun with cool math calculator demo at  Expressions.Compilerhome page [http://expressionscompiler.codeplex.com/]?

Expressions.Compiler is a lightweight expression compiler and generic parser framework. It is designed to support out-of-the-box propotyping, expressions evaluation & code generation.

Summary

This is a lightweight (~ 20 KB) easy to use framework library. for prototyping of the LL(1) (top-down left-most derivation) parser and PEG parser invented by Bryan Ford in 2004.
This framework can be easily switched between table-based and recursive descent parser implementation. Also it can be used to generate adaptive grammar parser, as it's shown in provided example in the project source tree.
Version history
v1.0.3.0

Added generic classes. All of new generic classes exists in simple form for all public classes and interfaces, which is actually an algorithmic form of conversion function for char as input and double as evaluation of AST as output.

Added brand functionality: a universal generalized parser of stream of type T, returning an AST tree of type U, which can be evaluated to anything special. Tests have been updated to reflect code changes, have been found several hidden errors in tests. At the moment, valid grammar on null input set cannot produce positive parsing results even on any grammar rules set.

All non-generic code not changed for the compatibility with older code. Finally switched code and tests to trace build, debug build and release build. Release build does not have extra code evaluation due to classes-to-string conversion to readable format. All test results produce classes-to-string self descripting readable output only on trace build project configuration.

Math sample updated for the new generic classes.

Version history

v1.0.3.0

Added generic classes. All of new generic classes exists in simple form for all public classes and interfaces, which is actually an algorithmic form of conversion function for char as input and double as evaluation of AST as output.

Added brand functionality: a universal generalized parser of stream of type T, returning an AST tree of type U, which can be evaluated to anything special. Tests have been updated to reflect code changes, have been found several hidden errors in tests. At the moment, valid grammar on null input set cannot produce positive parsing results even on any grammar rules set.

All non-generic code not changed for the compatibility with older code. Finally switched code and tests to trace build, debug build and release build. Release build does not have extra code evaluation due to classes-to-string conversion to readable format. All test results produce classes-to-string self descripting readable output only on trace build project configuration.

Math sample updated for the new generic classes.

v1.0.2.1

Removed depedencies on generic type wrapper for T, core library simplifications, weakened interface dependencies on base classes.

Removed interfaces: 
- IExpression<T>, 
- IExpression, 
- IExpressionTreeInternal.

Expression<T> now supports generic type. Samples & sources can be downloadede through changesets or from download page.

Please, visit  Expressions.Compiler home page at http://expressionscompiler.codeplex.com/

Ubuntu said:

fknight said:

*snip*

Microsoft could GPL every bit of code they've ever written and renounce all patents and people would still say not to use it because "they still might sue you" or claim it's some kind of trick.

M$ has the opportunity to settle this issue once and for all by sending their .net patents to /dev/null but they CHOOSE not to - instead they give a promise not to sue you similar to the promise not to sue you for using the ribbon in your apps. Now why do they do that? To keep their options open. Patents are the reason why a horizontal ribbon shouldn't be ever implemented in OpenOffice and why this is a serious danger, and only fools would ignore it until the day it actually happens. Of course M$ apologists like you defend these M$ 'good will' promises the following argument: since M$ couldn't satisfy everybody no matter what it did then it can just as well screw everybody which is what it has always done.

You can use this oppotuniky just like Microsoft - do not stuck with license agreements. Do better than Microsoft does ... (insert anything you want from list below) !

-parallel extensions

-serialization

-plugins

-user experience

As an example, you can write your own, better Ribbon (by the way ,who said that Ribbon's usablility is not just a marketing trick from the same sucky Microsoft guys but the really useful thing? No one, I repeat, no one who saw and use it for a day or two in offices around said that Ribbon is NOT a suxx, because you even need to remember MORE combinations than ever, since EVERY user can CUSTOMIZE it, so, just for example, if it is was hard to find some functionality in old versions of office it will be almost impossible to struggle it aganst in new, "ribonned" version. Search the web, I'm not the only bird on a sky. I think it will be the hell for a tech support (-"...you need go to bookmarked toolbar, and press umibigous number of ungrouped controls in different tabs to enable single user feature you desired", -"sorry, i have no visible toolbars ever...")

 I'm trying to create framework to achieve this goals. See it on my web

http://plugins.codeplex.com

And i have plans to port it to Mono

stevo_ said:

The challenge is to make a powerful abstraction thats simple.. (balanced) its easy to make a simple abstraction thats simple.. you should try and find something more unique (and perhaps more simple (simple != useless) because MEF and concurrency / threading are big tasks to take on).

I've found naturally the things I've ended up building are things that have caused me the biggest development friction (this is natural), and I'm certainly not having friction points with ioc/di frameworks.. or at least if I want more from them, would require a sizable dev effort.

Actually, yes

PaoloM said:

hack2roothotmai said:

*snip*

Proper spelling would be a wonderful starting point.

If you are thinking you are smart enouth, please help me spell anything you found incorrect. Show me you point, exactly.

Bass said:

I use Mono.Addins

 

Well, I'm happy to read it. Actually, I'm planning to make my project to be Mono compatible, AND use Mono.Addins for Unix and AppDomain itself for Windows.

joechung said:

Could you state clearly why you are writing alternatives to MEF, ParallelFx, and XML serialization?  Not that it matters for you, since self-edification is a worthwhile goal, but for others to be interested, you need incentive.

Ok, i'm willing to be sequential.

1st point: Full source code access.

2st point: Framework size.

3st point: It challenging to do the better product as do the guys at Microsoft.

In your opinion, why Linus Torvalds stated his own project formerly known as Linux Project, even he knows that Unix/Windows/QNX etc. OS-es already exists?

If you are asking me, why I'n doing so. I have the answer.

I'm tired, because nobody hires me, nobody supports me, nobody follows me. Do you really think that big fat cats in Microsoft will ever give me a chance to do the best i can do? No. Misrosoft is a suxx as a work place, because people like me are eaten for the breakfast by the corporate approach, so I'm smart enouth mice to understand it. Too many guys tries to be a one-man-at-the-top. Probably, I'm going to continue to develop software while working as system administrator in no-one-knows-it-company for the end of my life. On the other hand I can do better than Microsoft Teams and I will.

So, if you can't challenge the best of Microsoft teams for your own, give me chance to do this for you.

If you are from one ot the teams you mention it earlier (ParallelFx, MEF, etc), just be ready to know what i'm thinking about you.

I'm trying to prove that you can create by YOUR own code which can do the parallelization in several assemblies with 4-8K size, and it will work BETTER that in .NET FW 4.0 or ParallelFx. YOU can do better. YOU can make use of it. YOU. Just learn what is incapsulation, interfaces, inheritance, factory pattern, etc, exploring my code. It is a prove that YOU can do better.

Wht I cant GOTO TO OROFILE PAGE, Bacuse of error: Server error ./ is not a valid path name?

Why it is so stupid that 12-yrs experienced .NET can do NOTHING about it?

Why I'm stuck with this LOGIN problems?

Why I CANT CHANGE MY LOGIN, if it is errornnous, AT LEAST?

P.S.

If you think i have not tried, Saferi, WinXPSP2, coffehouse, Even IPhone, you are wrong, I TRIED ALL THE STUFF....

Why channel9 sucks? I do not want it to be so user UNFRIENDLY!!!!

Server Error in '/' Application.

---

The resource cannot be found.

Screenshots:

Object-Oriented State Machine sample. It show how to use Abstract State Machine idiom to safely enumerate throught file & direcory states.

Pi.Window sample. It show how easily to imlement the window state manegement solution. As well as how to store and load windows between application UI sessions.

Pi.UI sample. It shows how to create multi-threaded parallel work items, how to sync it with UI, how to use parallelism in applications using framework library approach.

Screenshots:

Object-Oriented State Machine sample. It show how to use Abstract State Machine idiom to safely enumerate throught file & direcory states.

Pi.Window sample. It show how easily to imlement the window state manegement solution. As well as how to store and load windows between application UI sessions.

Pi.UI sample. It shows how to create multi-threaded parallel work items, how to sync it with UI, how to use parallelism in applications using framework library approach.

littleguru said:

hack2roothotmai said:

*snip*

Sure, but you could write a thin wrapper or a wrapper that adds a lot of logic. Your's is more like a thin wrapper (that does not add much on their own) and theirs is a wrapper that adds a lot of logic and algorithms.

You are right! i prefer Keep It Stupid Simple. Frameworkers goes far from this idiom nowadays, that means, that i nedd to spend time trying to deal with comlicated APIs, more time when things are not going the right way you want it to, more time waiting for a next .NET version (just because nobody understands it better) tips and tricks, and so on.

In m opinion, if i can do complicated thing using things as simple as pissible, i.e. thin wrappers - this is a best, just because you can understang what beneath API is going on by simply lookin under the hood .

KISS

littleguru said:

hack2roothotmai said:

*snip*

Keep up the work! Try to evaluate on each piece of code that it really adds more than just a wrapper. Your multithreading stuff is a nice idea but the Parallel FX adds a lot more than just a wrapper around the ThreadPool!

I don't know if you have seen these two videos. They explain some of the ideas that have been implemented in the Parallel FX:

http://channel9.msdn.com/shows/Going+Deep/Inside-Parallel-Extensions-for-NET-2008-CTP-Part-1/
http://channel9.msdn.com/shows/Going+Deep/Inside-Parallel-Extensions-for-NET-2008-CTP-Part-2/

Phankx, but, you know, all we (me, alone, and aall boys and girls form Parallel extensions) are doing well -

is just to write simple wrappers on wrappers for Win32 threads!!!

At least we are all frameworkers

blowdart said:

hack2roothotmai said:

*snip*

So what you've go is a wrapper around the thread pool. And this replaces MEF how exactly?

Does anybody can look into my profile?

I've go these:

<html>

blowdart said:

hack2roothotmai said:

*snip*

So what you've go is a wrapper around the thread pool. And this replaces MEF how exactly?

Due to the luck of free scree space i can not post whole sources from http://plugins.codeplex.com

Other stuff like dynamic domain loading / unloading, calling code form another domain etc. there.

I'm working on examples

stevo_ said:

YAY! just what I wanted..

I;m preparing samples (just like futures .NET 4.0)

I can nave you a boost //So i'm currently working on a Pi calculation example.

In a lighting sample, you can take use of parallelism in programs like below (working sudoku generator):

    public abstract class PluginBaseWorkItem<T>
    {
        private static object _sync = new object();
        private T _item;
        public T Item { get { return _item; } }
        public void Run()
        {
            List<WaitHandle> _waitHandles = new List<WaitHandle>();
            for (int i = 0; i < TaskCount; i++)
            {
                _waitHandles.Add(new AutoResetEvent(false));
            }
            for (int i = 0; i < TaskCount; i++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessHandle), _waitHandles[i]);
            }
            WaitHandle.WaitAll(_waitHandles.ToArray());
        }
        protected abstract void ProcessItem();
        protected void SetValue(T item)
        {
            _item = item;
        }
        protected T GetValue()
        {
            return _item;
        }
        protected virtual int TaskCount { get { return Environment.ProcessorCount; } }
        private void Process()
        {
            ProcessItem();
        }
        private void ProcessHandle(object sync)
        {
            AutoResetEvent waitHandle = (AutoResetEvent)sync;
            Process();
            waitHandle.Set();
        }
    }
 
         private class WorkItem : PluginBaseWorkItem<Puzzle>
        {
            protected override void ProcessItem()
            {
                DlxEngine engine = new DlxEngine();
                Puzzle value = engine.Generate(20);
                lock (this)
                {
                    Puzzle item = GetValue();
                    if (item == null || value.Rating > item.Rating)
                    {
                        SetValue(value);
                    }
                }
            }
        }
 
        public static IPuzzle Create()
        {
            WorkItem workItem = new WorkItem();
            workItem.Run();
            IPuzzle puzzle = workItem.Item;
            return Create(puzzle.Text, puzzle.Seed);
        }

http://plugins.codeplex.com/">http://plugins.codeplex.com

    public class PluginWorkItem<T> : IPluginWorkItem

    {

        private volatile bool _isRunning;

        private List<PluginThreadSafeStack<T>> _data;

        private volatile int _dataCount = 0;

        private BackgroundWorker _mainThread;

        protected void PushData(T item, int threadID)

        {

            lock (this)

            {

                if (_dataCount > 0)

                {

                    _dataCount--;

                }

                _data[threadID].Push(item);

            }

        }

        protected T PopData(int threadID)

        {

            lock (this)

            {

                return _data[threadID].Pop();

            }

        }

        protected void PushData(T item)

        {

            lock (this)

            {

                if (_dataCount > 0)

                {

                    _dataCount--;

                }

                _data[GetMinIndex(GetThreadCount())].Push(item);

            }

        }

        protected int GetDataCount()

        {

            lock (this)

            {

                return _dataCount;

            }

        }

        protected T PopData()

        {

            lock (this)

            {

                return _data[GetMaxIndex(GetThreadCount())].Pop();

            }

        }

        private int GetThreadCount()

        {

            if (ThreadCount > 0 && ThreadCount < 64)

            {

                int threadCount = ThreadCount > Environment.ProcessorCount ? Environment.ProcessorCount : ThreadCount;

                return threadCount;

            }

            return 1;

        }

        protected virtual int ThreadCount { get { return Environment.ProcessorCount; } }

        protected virtual int DataCount { get { return 0; } }

        protected virtual void ProcessItem(int threadID)

        {

            int threadCount = GetThreadCount();

            bool useDataCount = DataCount > 0;

            T item;

            do

            {

                if (!IsRunning) return;

                item = PopData();

                if (item != null)

                {

                    if (!IsRunning) return;

                    ProcessData(item/*, threadID*/);

                }

            } while (!object.Equals(item, default(T)));

        }

        protected virtual void ProcessData(T item/*, int threadID*/) { }

        protected virtual void InitializeData() { }

        protected void InitializeThreadPoolData()

        {

            int threadCount = GetThreadCount();

            this._waitHandles = new WaitHandle[threadCount];

            for (int i = 0; i < threadCount; i++)

            {

                _waitHandles[i] = new AutoResetEvent(false);

            }

            this._data = new List<PluginThreadSafeStack<T>>(threadCount);

            for (int i = 0; i < threadCount; i++)

            {

                _data.Add(new PluginThreadSafeStack<T>());

            }

            _dataCount = DataCount;

            InitializeData();

            T item = default(T); //PopData();

            //if (item != null)

            //{

            //    ProcessData(item/*, 0*/);

            //}

            if (threadCount > 1)

            {

                int count = threadCount;

                int loop = 0;

                for (; loop < count; )

                {

                    while (_data[loop].Count == 0 && count > 1)

                    {

                        count--;

                    }

                    loop++;

                }

                if (count < threadCount)

                {

                    item = PopData(0);

                    for (int i = 0; (i + 1) < threadCount && !object.Equals(item, default(T)); )

                    {

                        int offset = 0;

                        do

                        {

                            ProcessData(item/*, i + offset + 1*/);

                            item = PopData(GetMaxIndex(i + offset + 2));

                            offset++;

                        }

                        while ((i + offset + 1) < threadCount && !object.Equals(item, default(T)));

                        count = i + offset + 1;

                        loop = 0;

                        for (; loop < count; )

                        {

                            while (_data[loop].Count == 0 && count > 1)

                            {

                                _data.RemoveAt(loop);

                                _data.Add(new PluginThreadSafeStack<T>());

                                count--;

                            }

                            loop++;

                        }

                        if (count == threadCount)

                        {

                            break;

                        }

                        item = PopData(GetMaxIndex(loop));

                        i = count - 1;

                    }

                }

            }

            for (int i = 0; i < threadCount - 1; i++)

            {

                if (_data[i + 1].Count > 0 && _data[i].Count == 0)

                {

                    throw new InvalidProgramException();

                }

            }

        }

        protected void Run()

        {

            int threadCount = GetThreadCount();

            for (int i = 0; i < threadCount; i++)

            {

                ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessHandle), i);

            }

        }

        private int GetMaxIndex(int index)

        {

            int max = 0;

            int maxIndex = 0;

            for (int i = 0; i < index; i++)

            {

                if (_data[i].Count > max)

                {

                    max = _data[i].Count;

                    maxIndex = i;

                }

            }

            return maxIndex;

        }

        private int GetMinIndex(int index)

        {

            int min = int.MaxValue;

            int minIndex = 0;

            for (int i = 0; i < index; i++)

            {

                if (_data[i].Count < min)

                {

                    min = _data[i].Count;

                    minIndex = i;

                }

            }

            return minIndex;

        }

        private void ProcessHandle(object sync)

        {

            int threadID = (int)sync;

            AutoResetEvent waitHandle = (AutoResetEvent)_waitHandles[threadID];

            if (IsRunning)

            {

                ProcessItem(threadID);

            }

            waitHandle.Set();

            //MessageBox.Show(DateTime.Now.ToString());

        }

        protected bool IsRunning

        {

            get

            {

                return _isRunning;

            }

        }

        #region IWorkItem Members

        private WaitHandle[] _waitHandles;

        protected virtual void Initialize()

        {

        }

        protected virtual void Terminate()

        {

        }

        void IPluginWorkItem.Run()

        {

            lock (this)

            {

                if (_mainThread == null)

                {

                    _isRunning = true;

                    _mainThread = new BackgroundWorker();

                    _mainThread.DoWork += (object sender, DoWorkEventArgs e) =>

                    {

                        Initialize();

                        InitializeThreadPoolData();

                        Run();

                        WaitHandle.WaitAll(_waitHandles);

                        lock (this)

                        {

                            Terminate();

                            if (_mainThread != null)

                            {

                                _mainThread = null;

                                _isRunning = false;

                            }

                        }

                    };

                    _mainThread.WorkerSupportsCancellation = true;

                    _mainThread.RunWorkerAsync();

                }

            }

        }

        bool IPluginWorkItem.IsRunning

        {

            get

            {

                return _isRunning;

            }

        }

        void IPluginWorkItem.Terminate()

        {

            lock (this)

            {

                Terminate();

                if (_mainThread != null)

                {

                    _mainThread.CancelAsync();

                    _mainThread = null;

                    _isRunning = false;

                }

            }

        }

        #endregion

    }