ok... this project is really exciting and can really be a nice one if you are serious about it. There are a couple of things that you should ask yourself about this project before starting it.
First of all, the Windows API is going to be the challenge. Most of the code of your IDE you will have to write yourself, the Win32 API will just help you to make it exist as a usable program.... For example on the Amiga in the early days, writing a file requester with Intuition was a real pain. Later we had the Requester library that helped a lot.. but still the challenge was really elsewhere.
Then you have to think about what you start with. Microsoft's IDEs have a layer of abstraction (just like EMACS has) for parsing source code files and formatting the text on screen. In other words parsing the source code is one of the major tasks. If plan to write your own assembler, then you need to plan your components properly, because the IDE and the assembler will eventually need those common components. For example, a good IDE can use math expressions for the debugger, breakpoints, etc. Just as in the source code.
After that you have to think about the mechanism to format the text on screen. The Win32 API provides you with some components to create quickly some basic text editors. The first one is the basic multiline text editor (just what Notepad.exe is), the second component is a RTF (rich text format) editor. The RTF component allows you to have different fonts, colors, etc existing in the same display. Both are painful to use because they are really not meant to edit source code. Also because of the common components I mentioned above, chances are that you will have a "dual" existence of the source code in memory... which is not good. Besides that they have memory limits for the text buffers. So I clearly suggest that you write your own display engine.
Writing your own rich text display means that you are able to parse the source code and look for keywords, etc in a dictionary that will hold the color of the text, etc. This capability is also required in the assembler. So again you need to plan your work correctly.
So my first advice is to forget a bit about the Windows API and answer the following questions:
1) are you going to use some already existing assembler or write your own? If you plan to write your own (which is the best sollution for the future IDE), then I suggest that you start with a desassembler first
2) do you have the knowledge about how to write a stream handler? you will need this to access the source code data down to the character level and have the ability to move back and forth in the stream. You also need to keep track of some positions in the stream. I can help with info on how to write a good one. You need to have this in order to have an abstraction between the source code (stream of characters) and the actual storage (file or memory buffer, or a mix).
3) you you have the knowledge about how to write a lexical scanner? you will need this to identify the keywords, etc
4) well... when you answer these 3 questions, we can move forward.
5) what about starting a thread here so we can all help and monitor the work? This is really an exciting project.
Let us know..
