Writing Data CDs

출처 : http://www.vbaccelerator.com/home/net/code/Libraries/Writing_CDs/Writing_Data_CDs/article.asp

This article demonstrates how to use the IMAPI wrapper to burn data CDs (also known as "Joliet" format CDs). Sample code is provided in both C# and VB.

Writing Data CDs

Before you begin, note that this sample uses the IMAPI Wrapper for the CD burning functions. To run the sample, you will need to have acclImapiWrapper.DLL registered in the Global Assembly cache (GAC). If you place the DLL next to the executable in your Debug or Release directory then you will also be able to run (but you may need to change the project references to run in VS.NET).

Recording a data CD using IMAPI involves performing the following steps:

1. Initialise the library by obtaining a DiscMaster instance, setting the active mastering format to Joliet to obtain a JolietDiscMaster instance to build up the staging image that will be burnt to disc, and setting the active recorder.
2. Constructing a JolietDiscMasterStorage hierarchy to represent the files you want to burn to disc, and their filenames on disc.
3. Instructing JolietDiscMaster to copy the files from the JolietDiscMasterStorage to the disc image, and then burning the CD.

During the last step, the DiscMaster will raise a number of events describing progress as the disc is staged or burnt, and also allows the burn to be cancelled.

I'll describe these steps briefly with VB.NET code examples. The C# code is very similar; refer to the downloads for details.

1. Initialising the Library

The only directly instantiable class in the IMAPI Wrapper is the DiscMaster object, from which all other classes can be obtained. This can be declared WithEvents in VB because you'll want to catch the progress and cancel events. Next, the recording mode is set by obtaining a JolietDiscMaster object. A reference to the returned object is kept as this is needed to stage the image (calling the JolietDiscMaster() again will result in a new instance being returned). Having done that, the list of recorders is populated into a ComboBox and the selected index set.

    Private WithEvents discMaster As discMaster = Nothing    Private jolietDiscMaster As JolietDiscMaster = Nothing    Private Sub GetRecorders()        Dim ex As Exception        Try            discMaster = New DiscMaster()            jolietDiscMaster = discMaster.JolietDiscMaster()            Dim recorder As DiscRecorder            For Each recorder In discMaster.DiscRecorders                cboRecorder.Items.Add( _                 New ComboRecorderWrapper(recorder))            Next            If (cboRecorder.Items.Count > 0) Then                cboRecorder.SelectedIndex = 0            End If        Catch ex            MessageBox.Show( _                Me, String.Format("Unable to initialise the IMAPI library {0}", ex), _                Text, MessageBoxButtons.OK, MessageBoxIcon.Stop)            If Not (discMaster Is Nothing) Then                discMaster.Dispose()            End If        End Try    End Sub    Private Sub cboRecorder_SelectedIndexChanged( _            ByVal sender As Object, _            ByVal e As System.EventArgs _        ) Handles cboRecorder.SelectedIndexChanged        If (cboRecorder.SelectedIndex > -1) Then            Dim wrapper As ComboRecorderWrapper = cboRecorder.SelectedItem            discMaster.DiscRecorders.ActiveDiscRecorder = wrapper.DiscRecorder        End If    End Sub

As noted in the IMAPI Wrapper article, you must ensure that the Dispose method is called on the DiscMaster instance before ending your application. Failure to do this will result in any subsequent attempt to access the library failing with a "Stash In Use" error. To ensure this occurs, I've included an Application ThreadException handler, which is called in the unfortunate event of an untrapped exception in the code:

    Public Sub New()	' ...         'Add any initialization after the InitializeComponent() call        AddHandler Application.ThreadException,             AddressOf application_ThreadException              Show()        Refresh()        GetRecorders()    End Sub    Private Sub application_ThreadException( _        ByVal sender As Object, _        ByVal e As ThreadExceptionEventArgs)        MessageBox.Show(Me, _           String.Format("An untrapped exception occurred: {0}.", _             e.Exception), _             Text, MessageBoxButtons.OK, MessageBoxIcon.Error)        Close()    End Sub    Protected Overrides Sub OnClosing( _        ByVal e As System.ComponentModel.CancelEventArgs)        ' ....        '// Clear up:        MyBase.OnClosing(e)        Cursor.Current = Cursors.WaitCursor        sbrMain.Text = "Closing IMAPI interface..."        jolietDiscMaster.Dispose()        discMaster.Dispose()        Cursor.Current = Cursors.Default    End Sub

In this sample I'm exposing the stack trace of the exception directly; in a real application this would be bad practice and really the exception should be logged and a more descriptive message shown.

2. Constructing a JolietDiscMasterStorage hierarchy

The JolietDiscMaster instance exposes a RootStorage property, which returns a JolietDiscMasterStorage instance representing the root directory of the CD. You can add files and/or sub-directories to this object; sub-directories are also represented as JolietDiscMasterStorage objects. When adding a file, you specify the path of the file to copy from on disc and the name of the file in the directory to write it out to. Sub-directories just have a name. For the purposes of the sample, I just allow a directory to be added and optionally recursed:

    ''' <summary>    ''' Adds a directory to the storage, optionally including    ''' any subdirectories.    ''' </summary>    ''' <param name="path">Path to the directory to add</param>    ''' <param name="recurse"><c>true</c> to include subdirectories,    ''' <c>false</c> otherwise.</param>    Public Sub AddDirectory(ByVal path As String, ByVal recurse As Boolean)        Dim storage As JolietDiscMasterStorage = jolietDiscMaster.RootStorage        AddFilesToStorage(storage, path, recurse)    End Sub    Private Sub AddFilesToStorage( _        ByVal storage As JolietDiscMasterStorage, _        ByVal startPath As String, _        ByVal recurse As Boolean)        If (recurse) Then            Dim dir As String            For Each dir In Directory.GetDirectories(startPath)                Dim subStorage As JolietDiscMasterStorage = _                    storage.CreateSubFolder(Path.GetFileName(dir))                AddFilesToStorage(subStorage, dir, recurse)                        Next        End If        Dim file As String        For Each file In Directory.GetFiles(startPath)            storage.AddFile(file, Path.GetFileName(file))        Next    End Sub

Burning the Disc

With that done, creating the disc is easy: firstly any existing content in the image is cleared, then data is added using the AddData method of JolietDiscMaster and finally the disc is recorded using the DiscMasterRecordDisc method:

    ''' <summary>    ''' Creates a data CD from the specified files    ''' </summary>    ''' <param name="simulate">Simulate CD burning</param>    ''' <param name="ejectWhenComplete"><c>true</c> to eject the CD    ''' tray when the burn is complete, <c>false</c> otherwise</param>    ''' <param name="overwrite"><c>true</c> to overwrite existing files    ''' on CDRW media, <c>false</c> otherwise</param>    Public Sub CreateCD( _              ByVal simulate As Boolean, _              ByVal ejectWhenComplete As Boolean, _              ByVal overwrite As Boolean        )        '// Ensure we don't have anything in the stage        discMaster.ClearFormatContent()        '// Stage the content        jolietDiscMaster.AddData(overwrite)        '// burn the disc        discMaster.RecordDisc(simulate, ejectWhenComplete)        '// Easy!    End Sub

Whilst burning is in progress, there are six events to respond to:

1. AddProgress - raised as files are added to the image.
2. PreparingBurn - raised once the image has been created and the CD is about to burnt.
3. BlockProgress - raised as blocks are burnt to disc (a block is 2048 bytes).
4. ClosingDisc - raised once the burn has completed and the CD (or session) is about to be closed.
5. Complete - raised when the burn has completed.
6. QueryCancel - raised whilst data is added to the image or burning is in progress. Setting the Cancel property of the event arguments will cancel the operation.

That is really all you need to do to create the disc; however, if you want to be able to respond to cancellations, or to show progress you will need to write your application so the burn runs on a background thread. The construction of the wrapper makes this very easy to do using BeginInvoke.

Using BeginInvoke for a Smooth User Experience

Buring a CD is typically a long operation. If you invoke a burn operation on the user-interface thread, then the application will appear to be locked up whilst the burn occurs. Under XP and above, a feature was added which allows the caption and border of the window to be unfrozen if XP detects that the application has been locked up for a significant length of time. After this point in .NET Framework applications, calls to update controls and so forth no longer have any effect.

Therefore we want a way to invoke the CD burn on a background thread. Since the IMAPI wrapper makes a call to check whether the burn is cancelled at frequent intervals, and this is done through an event, there is also a safe way to cancel a burn operation at any time.

Any method in a class can be invoked asynchronously in .NET by creating a delegate for it. Once you have done this, the compiler is responsible for automatically creating three methods for the delegate:

1. The Invoke method, which has the same parameters and return value as the delegate and allows the method to be called synchronously.
2. The BeginInvoke method, which is the same as Invoke except it adds two more parameters: an AsyncCallback delegate and an object to hold state.
3. The EndInvoke method, which the same return value as the delegate, any ref or out parameters and an extra parameter holding an IAsyncResult object.

This makes asynchronous invocation easy. There are four coding steps:

1. Declare a delegate for the method you want to call asynchronously.
2. Write a completion event handler for the method you want to call, which will be called when the method completes.
3. Create an AsyncCallback handler and connect it to your completion event handler.
4. Invoke the delegate's method asynchronously using BeginInvoke.

Here's the code for doing this in VB and C#. Unsurprisingly the code is very similar; the only real difference being VB's odd use of AddressOf to refer to delegates. In this case the method I want to call is the CreateCD method implemented in my DataCDCreator class. This method takes three boolean parameters (for simulate burn, eject when complete and overwrite) and has no return value:

VB Code for Asynchronous Invocation

''' <summary>''' Delegate representing the CreateCD method''' </summary>Public Delegate Sub CreateCDDelegate( _    ByVal simulate As Boolean, _    ByVal ejectWhenComplete As Boolean, _    ByVal overwrite As Boolean)

    Private creator As DataCDCreator = Nothing    Private createCDHandler As CreateCDDelegate = Nothing        ' Asynchronously invoke the creator        creator = New DataCDCreator(discMaster, jolietDiscMaster)        creator.AddDirectory(txtFolder.Text, True)        createCDHandler = AddressOf creator.CreateCD        Dim callback As AsyncCallback = AddressOf createCD_Complete        Dim ar As IAsyncResult = createCDHandler.BeginInvoke( _            simulate, ejectWhenComplete, overwrite, callback, Nothing)    ''' <summary>    ''' Called when CD creation completes    ''' </summary>    ''' <param name="ar">Result of method call (none)</param>    Private Sub createCD_Complete(ByVal ar As IAsyncResult)        ' NB should surround with try - catch - end try        SetApplicationMode(False)        createCDHandler.EndInvoke(ar)    End Sub

C# Code for Asynchronous Invocation

   /// <summary>   /// Delegate representing the CreateCD method   /// </summary>   public delegate void CreateCDDelegate(       bool simulate,        bool ejectWhenComplete,        bool overwrite);

      private DataCDCreator creator = null;      private CreateCDDelegate createCDHandler = null;        // Asynchronously invoke the creator        creator = new DataCDCreator(discMaster, jolietDiscMaster);        creator.AddDirectory(txtFolder.Text, true);                       createCDHandler = new CreateCDDelegate(creator.CreateCD);        AsyncCallback callback = new AsyncCallback(createCD_Complete);        IAsyncResult ar = createCDHandler.BeginInvoke(            simulate, ejectWhenComplete, overwrite, callback, null);      /// <summary>      /// Called when CD creation completes      /// </summary>      /// <param name="ar">Result of method call (none)</param>      private void createCD_Complete(IAsyncResult ar)      {         // NB should surround with try-catch         SetApplicationMode(false);         createCDHandler.EndInvoke(ar);      }

More Ideas

The sample application here is rather trivial, in that all it allows you to do is to copy an existing directory to the CD. However, that's not an actual limitation, since when you create the storage you can specify that any file is mapped to a different path and or file on the destination CD. A more complete application would allow you to drag files from any location to the CD, and rename them if possible.

You could use this code to create an almost unattended CD writer (the only thing you need to do is to ensure suitable media is available in the drive) rather than having a UI.

Conclusion

This article demonstrates how to create Data CDs from VB or C# using the IMAPI Wrapper. Although the sample has a simple UI it performs all of the major operations you'll need to perform and should be easy to extend.

The source file include class files, so this is a Flash MX 2004 movie. Otherwise, it can be done by Flash MX.

Evaluate the equation object

I have discussed in previous session how to parse a string and get the value of an equation. At the end, I also discussed how to handle an equation string with variables. So, it is not difficult to get the value of "sin(x)" when we set x=0.3;

When we draw equation graph, we need to sample many x values and get the result of the equation before we plot those data out. We can accomplish this by repeated setting x and parsing the equation to get a new result.

However, to parse an equation string, we need to screen each character for existance of parenthesis and existance of any operator in the operatorSet array. It is time consuming.

Since what gets changed is the variable value only, the existence and position of the operators and parenthesis are the same as before , repeated parsing is not necessary. We can store down the operators and parenthesis. That is what my EquationObject class serves.

By this algorithm, to handle 100 sample x and get 100 y value is not a hard job any more. My evaluator does not evaluate the equation string. It evaluate the instance of EquationObject.

In this movie, about 400 x values are sampled. This is faster and more efficient.

The fit of Y range

Here is the scenario. We set x and y range from 0 to 8. We plot the equation "sin(x)". Well, half of the y points fall into the negative region. That means half of the curve is out of the lower bound of the canvas. Besides, the curve is located low and occupies only one-eighth of the canvas leaving a large blank area in the upper half. This is ugly and stupid.

To correct this, we need to calculate the Y range of the curve. We walk through each y value in the y Array and pick the maximal value and minimal value. Calculate the y range by yMax-yMin so that we can plot and fit our curve to the canvas.The highest point of the curve should fall on the top edge of the canvas and the lowest point of the curve should fall on the bottom edge of the canvas.

Unfortunately, the policy is not always possible. There are bugs. Lets try to remove the bug.

P.S. in my source file, if we set yMin, yMax then the automatic fit function is disabled. This is necessary in some condition, such as doing a comparison between two equations.

The infinity - range too big

Check this scenario. How to plot the equation "1/x" with x ranging from -1 to 1 ?

When x=0, the value is infinity. Even worse, when x is near the x, the value 1/x is very very large. If we accept that y value, then the y range is very large. The curve is very ugly.

Can you guess what it had looked like ? Well, the graph shows a max point at the upper edge and all other points fall at the lower edge of the canvas. Yes, since the y range is very large, all values are zoomed out as if those values are nearly 0 except the max point.

To correct this, I have to skip off those infinity values or values that are un-acceptably large compared with other values. The algorithm should not be too complex. Flash can easily hang out for complex algorithm.

I write a simple script. I calculate the slope of the curve. When the curve is curving upward or downward too sharply, I take that point as infinity and skip it off. Mathematically, this algorithm may not be so reasonable, but it does serve our goal.

So, if we plot the equation "1/x" from -1 to 1, we see the points near the x=0 zone are missing.　

The flat line - range too small

Scenario: How to plot the equation "sin(x)^2+cos(x)^2" with whatever x range ?

Well, for any x value, the result theoretically is always 1. So we expect to see a flat line on our canvas. No ?

My script would try to put the maximum value at the upper edge and minimum value at the lower edge of the canvas. If the "curve" is a flat horizontal line, how could it possibly do this ?

Can you guess how this equation had been plot ? Well, the result is a bizzare up and down spike.

Flash has limitation in calculation of float point. Besides, the sin and cos functions are just giving estimated values. In fact, when Flash calculate sin(x)^2+cos(x)^2, it gives a value "almost" 1 but not just 1. So, the result of the plot is still a curve with minute up and down not just a flat line. Since the difference between y max and y min is minute, the range is minute and the zoom-in effect is large. The end result is magnification of the up and down of the curve.

To correct this, we add some script to rule out such condition. When y range is too small, we add 5 as its maximum value and subtract 5 as its minimum value.

make the grid scales

Scenario: If I my bottom value is 10.1 and top value is 90, I want to draw grid lines at position where it represent 20- 40- 60- 80 - that counts 4 grid lines. If the top value is 55, I would draw grid lines at 20-30-40-50- total 4 lines. If the top value is 30, then I draw lines at 15 - 20 - 25 -30 total 4 lines.

Principle 1 : I want to keep the number of grid lines around 4 lines, 3 or 5 are acceptable.

Principle 2 : I want the grid line position "rounded" to 0 or 5 if possible. Positions such as 53- 76 -99 -122 should be avoid. In stead, I would hope it to be 50 - 75 -100 -125, although it may be one line more or less.

Well, it is more difficult than I had expected. So, I can not but use a brutal way.

First, I estimate what is the power of 10 for the space. Is it 0.01, or 0.1, or 1 or 10, or 100, or 1000 ? This is done through the log10. The script is like this : Math.floor(Math.log(dx)/Math.LN10);

For a result such as 10, then I test 2, 5, 10, 20, 50 and see how many lines I need to draw, if it counts less than 5, accept it.

If anyone knows a better way, please email me. I would appreciate sincerely.

Sampling limitation

Here is scenario: Plot a graph on to a canvas of 300-pixel-wide for equation "y=sin(x)", with x=-300 to 300.

The result is very ugly and useless because we plot it with in-adequate x sampling. Not every "peak" of the sin wave gets caught. So, not only the straight lines replace the curves, the repeated peaks in the graph do not sit at the same height as we expected.

Lets go back to that scenario. How about plot is with x range 0 to 8. The result is a beautiful curve. Is this beautiful sin wave plot accurate enough ? Here we see two peaks. Are they at the same height ? No. Not exactly.

The peak should occurr when x=(Math.PI)/2 , around half of 3.14159..... I dont think we pick that point exactly.

Theoretically, the peak when x=PI/2 should be at height of 1. No, in our graph, no single Y value is exactly 1.

How many sampling is "enough" ? I dont think there is an easy answer.　

The equation grapher

download source fla

ericlin@ms1.hinet.net

http://ericlin2.tripod.com/math2/graphQuizt.html

Pixel Color UnderMouse

private struct POINT{ public uint X; public uint Y;}[DllImport("gdi32")]private static extern int GetPixel(int hdc, int nXPos,int nYPos);[DllImport("user32")]private static extern int GetWindowDC(int hwnd);[DllImport("user32")]private static extern int GetCursorPos(out POINTAPI lpPoint);[DllImport("user32")]private static extern int ReleaseDC(int hWnd, int hDC);

private static SolidColorBrush GetPixelColor(Point point){    int lDC = GetWindowDC( 0 );    int intColor = GetPixel( lDC, (int)point.X, (int)point.Y );    //    // Release the DC after getting the Color.    ReleaseDC( 0, lDC );    //byte a = (byte)( ( intColor >> 0x18 ) & 0xffL );    byte b = (byte)( ( intColor >> 0x10 ) & 0xffL );    byte g = (byte)( ( intColor >> 8 ) & 0xffL );    byte r = (byte)( intColor & 0xffL );    Color color = Color.FromRgb( r, g, b );    return new SolidColorBrush( color );}

 protected override void OnMouseMove(MouseEventArgs e)

 {

 POINT point;

 GetCursorPos( out point );

 Point pos = new Point( point.X, point.Y );

 this.StrokeBrush = GetPixelColor( pos );

 }

EVC 4.0 프로그래밍의 준비

출처: www.propoz.co.kr

안녕하세요. Lucy입니다.

예전에 투데이스피피시에서 간단한 개발 강좌를 부탁하시기에 어떤 것을 가지고 강좌를 할까 고민을 하다가, 그래도 도움이 되는 것을 해보자해서 Windows Mobile 2003과 2003 SE를 위한 공용 텍스트 리더 어플리케이션을 단계별로 만드는 작업을 진행하면서 중요한 부분을 체크해 가는 방식으로 간단히 강좌를 진행하다가, 개인적인 사정으로 중단된 바가 있습니다.

그래서 이곳에서 다시 해당 강좌를 연재하려고 합니다.

먼저 많은 분들이 질문하시는 것들 중에 하나가 PC에서는 Visual Basic, Visual C++, Delphi 등 다양한 개발 도구들이 있는데, Pocket PC에서는 어떤 개발 도구를 쓰느냐 하는 질문입니다.

이 질문에 대한 답변이 첫 회의 주된 내용이 될 듯 하네요.

Pocket PC에서는 다양하다고는 할 수 없지만, 몇몇 개발 도구들이 있습니다. 주로 PC에서 개발해서 Pocket PC에서 실행하는 것이 정석입니다만, 간혹 Pocket C#와 같이 Pocket PC 상에서 직접 작성해서 컴파일하는 도구들도 준비되어 있습니다. 그러나 이런 도구들은 본격적인 개발을 위한 것이라기 보다는 간단한 테스트를 위한 목적으로 많이 사용됩니다.

이 강좌에서는 가장 많이 사용되는 도구인 Microsoft eMbedded Visual C++ 4.0 Service Pack 4 + Microsoft Windows Mobile 2003 SDK + Developer Resources for Windows Mobile 2003 Second Edition을 사용하여 개발을 진행하도록 하겠습니다.

물론 .NET Compact Framework를 이용하여 Managed Code로 작업할 수도 있겠지만, 이 강좌에서는 Native Code로 진행할 예정입니다.

개발을 진행하기 전에 이 강좌를 보시려면 다음의 조건이 어느 정도는 충족되어 있어야 합니다.

1. 개발에 관심이 있어서 관련 서적을 사서 보거나 빌려볼 수 있을 정도의 열정

아래 조건은 필수 조건은 아닙니다만, 없으면 귀찮아지는 것들입니다.

1. 개발에 필요한 수준의 영어 실력 (ㅡ_ㅡ 개발 문서가 전부 영문입니다.)
2. C++에 대한 기본적인 이해 (심층 분석까지 갈 필요는 없습니다.)
3. MFC/API에 대한 기본적인 이해 (심층 분석까지 갈 필요는 없습니다.)
4. Windows 시스템에 대한 기본적인 이해

1. 개발 도구 준비하기

Pocket PC 어플리케이션 개발을 진행하기 위해서 먼저 개발 도구를 준비하셔야 겠지요. Pocket PC는 작지만, 그 위에서 동작하는 어플리케이션을 개발하기 위해서는 많은 준비가 필요합니다.

먼저 PC의 운영 체제는 Windows 2000 Service Pack 2 이상, 혹은 Windows XP Service Pack 1 이상이어야만 합니다. Windows Server 2003에서도 개발을 진행할 수는 있습니다만, 상대적으로 귀찮은 부분이 많이 존재합니다.

그 중에서 권하는 것은 Windows XP Professional Service Pack 2입니다. (Service Pack 2는 굳이 없어도 되겠지만요.)

운영 체제의 요건이 충족된다면 개발 도구를 준비하셔야 합니다.

Pocket PC의 개발 도구는 VS.NET에 연동되어 있는 SDE(Smart Device Extension)를 제외하면 모두 무료로 배포되며, 마이크로소프트의 Pocket PC 개발자 사이트에서 다운로드하실 수 있습니다.

한글 환경에 맞추어 개발하기 위해 필요한 도구들은 다음과 같습니다.

1. Microsoft eMbedded Visual C++ 4.0 (다운로드 페이지) - 영문 버전

CD Key는 다음과 같습니다.

TRT7H-KD36T-FRH8D-6QH8P-VFJHQ

2. Microsft eMbedded Visual C++ 4.0 SP4 (다운로드 페이지) - 영문 버전

3. Microsoft SDK for Windows Mobile 2003-based Pocket PCs (다운로드 페이지) - 영문 버전

4. Developer Resources for Windows Mobile 2003 Second Edition (다운로드 페이지)

5. 한글 Pocket PC 2003 Emulator Image (다운로드)

6. 영문 Pocket PC 2003 SE Emulator Image (다운로드 페이지)

7. 한글 Pocket PC 2003 SE Emulator Image (다운로드)

8. Run-time Type Information Library for the Windows Mobile-based Pocket PC 2003 SDK (다운로드)

위의 항목들을 순서대로 설치하셔야 합니다. 자세한 설치 방법과 설정 방법은 2회에서 다루도록 하겠습니다.

지루한 글 읽어 주셔서 감사합니다.

첫 번째 강좌를 올려드린 이후에 바쁜 일정으로 인해 꽤 오랫동안 강좌를 못한 점 진심으로 사과 드립니다. 이번에는 지난 시간에 이어 설치 부분을 계속 진행하기로 하겠습니다.

개발 도구라는 특성 상 단순히 설치 만으로 설정이 종료되지 않는다는 점 때문에 처음에 설치에 대해 많은 시간을 할애하여 설명하고 있습니다. 하지만 이 강좌의 설정 부분만 잘 숙지하시면 보다 쾌적한 개발 환경을 만끽하실 수 있습니다. 이 강좌의 내용대로 설정을 진행하시면 다음의 환경에 맞는 개발이 가능하게 됩니다.

- 영문 Pocket PC 2003
- 한글 Pocket PC 2003
- 영문 Pocket PC 2003 Second Edition
- 한글 Pocket PC 2003 Second Edition

물론 이를 응용하시면 중국어, 일본어, 독일어 등의 시스템에 맞는 개발도 진행하실 수 있습니다. 전체적으로 귀찮은 설정 작업을 해야한다는 점만 제외하면 어려운 것은 아니므로, 순서대로만 따라하시면 무리없이 설정을 끝내실 수 있습니다.

1. eMbedded Visual C++ 4.0 설치

eMbedded Visual C++ 4.0(이하 eVC4)의 설치는 일반적인 어플리케이션 설치와 같은 방식으로 설치가 진행되며, 마법사 형식(Next 버튼을 눌러서 다음 단계로 진행하는 방식)으로 설치가 진행됩니다.

일반적으로 CD를 가지고 있지 않으신 분들은 Microsoft 사이트에서 다운로드한 압축 자동 해제 파일 형태로 가지고 계실 텐데, 처음 설치 경로는 여러분의 계정 아래의 임시 폴더로 지정되어 있습니다. 반드시 경로를 C:setupevc 등으로 바뀌주시기 바랍니다. 그러지 않으면 설치 파일과 임시 파일들이 한데 섞여 설치가 곤란하게 됩니다. 압축을 다 푸셨으면 C:setupevcsetup.exe 파일을 실행하셔서 설치를 진행하시면 됩니다.

설치 프로그램은 eVC를 설치하기 전에 Platform Builder 4.0을 설치하게 되는데, 아주 특별한 경우를 제외하면 재부팅을 요구하게 됩니다. 이 때 재부팅을 하지 않으면 설치가 더 이상 진행되지 않으므로 반드시 재부팅을 해 주시기 바랍니다. 재부팅 후 설치 프로그램인 setup.exe를 다시 실행하시면 설치가 그 이후부터 계속 진행됩니다.

설치를 진행하다 보면 설치할 항목을 선택하게 되는데, Standard SDK는 설치하실 필요가 없기 때문에 해당 선택 상자를 지워주시면 됩니다.

설치가 끝나면 아까 생성되었던 C:setupevc 폴더는 삭제하셔도 관계 없습니다.

2. eMbedded Visual C++ 4.0 Service Pack 4 설치

eMbedded Visual C++ 4.0 Service Pack 4(이하 SP4)의 설치는 eVC와 비슷하지만 훨씬 간단하게 구성되어 있습니다. 설치 방법은 마찬가지로 압축 해제를 통해 진행하게 되는데, 이 경우에도 가능하면 별도의 폴더를 만들어 설치하도록 하는 것이 좋습니다. 단, SP4는 압축이 풀린 후에 자동으로 설치가 진행되므로 이 점만 유의하시면 됩니다.

3. Microsoft SDK for Windows Mobile 2003-based Pocket PCs 설치

Microsoft SDK for Windows Mobile 2003-based Pocket PCs(이하 PPC2003 SDK)의 설치는 Microsoft Installer(이하 MSI)를 이용하여 설치가 이루어지며, 별도의 설정 변경 없이 설치를 진행하시면 됩니다.

4. Developer Resources for Windows Mobile 2003 Second Edition 설치

Developer Resources for Windows Mobile 2003 Second Edition(이하 DevResSE)의 설치 역시 MSI를 이용한 설치 작업을 진행하시면 됩니다.

설치 후 설정 작업을 해 주어야 하지만, 이 부분은 제일 마지막 단계에서 한꺼번에 설정을 하도록 하겠습니다.

5. 한글 Pocket PC 2003 Emulator Image 외의 에뮬레이터 이미지들 설치

에뮬레이터 이미지들 역시 MSI로 되어 있으므로 일반적인 어플리케이션과 같이 설치를 진행하시면 됩니다.

설치 후 설정 작업을 해 주어야 하지만, 이 부분은 제일 마지막 단계에서 한꺼번에 설정을 하도록 하겠습니다.

6. Run-time Type Information Library for the Windows Mobile-based Pocket PC 2003 SDK 설치

Run-time Type Information Library for the Windows Mobile-based Pocket PC 2003 SDK(이하 RTTI)는 eVC에서 try=catch를 정상적으로 사용할 수 있도록 해 주는 라이브러리입니다.

설치 위치를 C:RTTI로 지정하신 후 압축을 해제하시면 됩니다.

7. 설정하기

지금부터 지루한 설정 작업이 진행됩니다.

7-1. 폴더 지정하기

먼저 eVC를 실행합니다. 시작-프로그램-Microsoft eMbedded Visual C++ 4.0-eMbedded Visual C++ 4.0을 클릭하면 됩니다.

eVC가 실행되면, 먼저 Tools-Options를 선택합니다. Options 대화 상자가 나타나면 Directories 탭을 선택합니다.

Platform은 POCKET PC 2003을 지정하고, CPUs에서 Win32 (WCE emulator)를 지정하고, Show Directories에서 Include files를 선택합니다.

리스트의 제일 아래 빈 박스 부분을 더블 클릭하면 새 폴더를 지정할 수 있는데, ... 버튼을 눌러 폴더 선택 대화 상자를 엽니다. C:PROGRAM FILESDEVELOPER RESOURCES FOR WINDOWS MOBILE 2003 SECOND EDITIONINCPOCKET PC 폴더를 선택하신 후, 해당 라인을 제일 위로 올립니다. 위로 올릴 때는 위쪽 화살표 아이콘을 눌러주면 됩니다.

이제 다시 Show Directories에서 Library files를 선택하고, 마찬가지로 C:PROGRAM FILESDEVELOPER RESOURCES FOR WINDOWS MOBILE 2003 SECOND EDITIONLIBPOCKET PCX86를 추가하고 제일 위로 올립니다.

이제 CPUs를 Win32 (WCE ARMV4)로 변경하신 후 Include files에는 C:PROGRAM FILESDEVELOPER RESOURCES FOR WINDOWS MOBILE 2003 SECOND EDITIONINCPOCKET PC 폴더를 추가하시고, Library files에는 C:PROGRAM FILESDEVELOPER RESOURCES FOR WINDOWS MOBILE 2003 SECOND EDITIONLIBPOCKET PCARM을 추가합니다.

7-2. 에뮬레이터 등록하기

기본적으로 여기까지 진행하시면 영문 Pocket PC 2003 에뮬레이터와 디바이스만 등록이 되어 있는 상태입니다. 한글 Pocket PC 2003과 SE 에뮬레이터를 사용하려면 추가적인 설정이 필요합니다.

eVC가 실행된 상태에서 Tools-Configure Platform Manager를 선택합니다. POCKET PC 2003 아래에 POCKET PC 2003 Device와 Pocket PC 2003 Emulator가 등록된 것을 확인할 수 있습니다. 새로운 디바이스를 등록하기 위해 Add Device 버튼을 클릭합니다. 그러면 New Device 항목이 생성되는데, 이름은 나중에 지정해도 되니 일단 그대로 놔둡니다.

New Device가 선택된 상태에서 Properties 버튼을 클릭하면 디바이스 프로퍼티 대화 상자가 나타나는데, Transport는 TCP/IP Transport for Windows CE를 선택합니다. Startup Server는 Emulator Startup Server를 선택합니다.

Startup Server의 옆에 있는 Configure 버튼을 클릭하면 Emulation Configuration Settings 대화 상자가 나타납니다. Device의 Image에서는 연결할 에뮬레이터 이미지를 지정합니다. 한글판 Pocket PC 2003을 선택하기 위해 KOR POCKET PC 2003을 선택합니다. 이 항목이 없다면 5. 의 에뮬레이터가 정상적으로 설치되지 않은 것이므로 다시 확인을 하셔야 합니다. 나머지 부분은 건드리실 필요가 없으며, OK 버튼을 클릭하면 1차적으로 이미지 지정이 끝납니다.

이미지의 지정이 끝났다면 하단의 Test 버튼을 클릭해 봅니다. 에뮬레이터가 실행되고, 한글판 Pocket PC가 나타난다면 정상적으로 지정이 된 것입니다. OK 버튼을 눌러 설정을 완료합니다. 테스트를 하지 않았다면 테스트를 하지 않았다는 경고 대화 상자가 나타나므로 가급적이면 테스트를 거칠 것을 권합니다.

New Device의 이름을 변경하려면 해당 이름 위에서 클릭을 두 번 해주면 됩니다. 더블 클릭을 하면 설정 대화 상자가 열리므로 더블 클릭을 하면 안 됩니다. 이름은 POCKET PC 2003 Kor Emulator 정도로 바꿔줍니다. Korean Pocket PC 2003 Emulator로 할 수는 있지만, 나중에 에뮬레이터를 선택할 때 정신이 없으므로 가능하면 형태를 기본과 맞춰 주는 것이 좋습니다.

추가적으로 SE의 에뮬레이터도 지정을 해 주면 됩니다. Radio 관련 에뮬레이터는 일반적인 경우 지정할 필요가 없으며, SE는 언어별로 다음의 4가지 이미지만 설정하면 됩니다. (영문/한글을 지정할 경우 4 X 2 = 8개의 이미지를 지정해야 합니다.)

SE Emulator - 240x320 모드
SE Landscape Emulator - 320x240 모드
SE VGA Emulator - 480x640 모드
SE Landscape Emulator - 640x480 모드

7-3. RTTI 설정하기

eVC4를 종료하고, 아까 RTTI를 설치했던 폴더(C:RTTI)로 갑니다. 안에는 Armv4 폴더와 emulator 폴더의 파일들, 그리고 EULA.txt 파일이 있습니다. 해당 파일과 폴더들을 전부 선택한 후 (폴더대로 선택해야 합니다.) C:Program FilesWindows CE Toolswce420POCKET PC 2003Lib 폴더에 복사하거나 옮깁니다.

Lib 폴더 안에도 Armv4 폴더와 emulator 폴더가 있으며, 각각의 파일들이 올바른 폴더 안에 들어가야 합니다.

이로서 개발 도구의 설치가 끝났습니다. 전부 다 마치면 대략 2시간 정도 걸립니다.

감사합니다.

Introduction to Programming with Managed DirectX 9.0

The industry standard 3D API, OpenGL, is not the only 3D API that you can use on the .NET platform in the Microsoft Windows environment. Another choice is DirectX, which has been steadily increasing its functionality, stability, and market share among developers writing all sorts of Windows multimedia software, games, and other applications that make use of 2D and 3D graphics. While earlier versions of DirectX often left a lot to be desired, its latest incarnation, DirectX 9.0, is a serious product worth a longer look, especially if you want to target multiple Microsoft platforms: Microsoft Windows, PocketPC, or X-Box.

With DirectX 9.0, you have a choice of two 3D APIs on the Microsoft Windows platform, but that doesn't mean that it must be one or the other. Even if you stay with the OpenGL for 3D API (it's an industry standard after all, and there's a lot of information and talent to draw upon) you may still need DirectX's other components that you will simply not find in OpenGL. Direct3DX is only a part of the DirectX puzzle, and other pieces are equally interesting. If you have never considered using DirectX before, the following summary will give you a better view of what's in store:

• Direct3D Graphics: The DirectX 3D API. You will use it for 3D graphics and animation programming.
• DirectDraw: Direct, fast, low-level access to display the hardware's memory, blitter, overlays, etc. Essential in game programming, where timing is everything.
• DirectInput: Support for various input devices (keyboard, mice, joysticks, paddles, steering wheels, pedals, etc.), including devices with force feedback.
• DirectSound: Advanced sound playback and recording, including support for three-dimensional sound and sound effects. Works with WAV files; for more playback options, use DirectMusic.
• DirectMusic: Handles dynamic sound tracks, 3D sound positioning, and hardware acceleration. Uses MIDI, WAV, and DirectMusic Producer tracks. You can think of DirectMusic as the playback side of DirectSound on steroids.
• DirectPlay: Support for networked gaming, including support for real-time voice conferencing. This could have applications that go beyond gaming.
• DirectShow: Playback and capture of audio and video streams. This author's favorite feature is support for TV cards.
• DirectSetup: Simple API for setting up DirectX on user's machines.

Just like OpenGL, DirectX too used to be aimed at developers coding in C/C++. That's natural, because compiled C/C++ code is faster than interpreted Visual Basic. However, Microsoft knows that in order to make .NET a success, they need to attract as many developers as they can. To do that, all of their crucial APIs must be available in managed form, so they can be easily incorporated into applications written in C#, Visual Basic .NET, and other .NET languages.

The recently released DirectX 9.0 SDK is a clear sign that Microsoft wants to broaden the use of DirectX among developers who do not speak C++ and MFC programmers. The official release of the DirectX 9.0 SDK is available in three forms:

• DirectX 9.0 SDK: The whole package for C/C++, C#, Visual Basic .NET, and other languages available on the .NET platform.
• DirectX 9.0 SDK for C#: A cut-down, managed version of the DirectX 9.0 SDK for programmers writing C# code.
• DirectX 9.0 SDK for Visual Basic .NET: A cut-down, managed version of the DirectX 9.0 SDK for programmers writing Visual Basic .NET code.

The managed versions (for C# or VB.NET) can also be used in Visual C++ (when writing managed code), and JScript .NET applications. Other languages available for the .NET platform ought to be able to make use of them, as well. This lowers the barrier of entry for those programmers who code in C# or VB .NET for a living, and could potentially lead to some interesting software titles appearing on the market.

Starting managed DirectX 9.0 development is quite inexpensive; if you do not need the visual tools, you can get by with the free SDKs. But you would really be doing yourself a disservice if you did not use the Visual development products, as they really help developers manage their work better and work more efficiently.

Here's the list of tools you need to start coding with DirectX 9.0:

• A fast PC (think at least 1GHz).
• A decent video card with a GPU (for programming shaders), which means a recently manufactured card with the latest chips from ATI or nVidia. Older cards, like the TNT, will also work, but you will not be able to explore the joys of writing shaders, which is the latest craze in 3D graphics programming.
• A copy of either the Microsoft Windows 2000 or XP operating system with the latest patches installed before you install other components.
• A copy of one of the Visual Studio development environments: Microsoft Visual Studio, Microsoft Visual C++, Microsoft Visual C#, or Microsoft Visual Basic .NET. If you cannot afford them, you can try to get by with the command-line C# and VB.NET compilers that you can find in the .NET Framework SDK, but you will lose all of the handy features that these environments offer.
• A copy of the .NET Framework 1.1 SDK (after you install it, run Windows Update to check for the latest patches).
• A copy of the .NET Framework 1.1 Redistributable (if you plan to distribute applications for the .NET Framework 1.1).
• A copy of the DirectX 9.0 SDK for C# or VB.NET, if you want to save space on disk, but even if you don't plan to use the full SDK, you might want to install it anyway, because sometimes reading C++ code can help you understand the things that are not explained well enough in the SDK d0cumentation. Again, after you install this component, check for updates.
• A copy of the DirectX 9.0 Redistributable if you plan to distribute your applications.

Despite their best efforts to provide managed versions of the whole of DirectX, Microsoft does not (yet) provide managed versions of DirectMusic, DirectShow, or DirectSetup. One additional component that you will find is a basic support for audio and video playback.

Installing the DirectX 9.0 SDK

While all components listed earlier in this article behave quite reasonably during installation, DirectX 9.0 SDK is a bit temperamental and may waste some of your time, if you let it. The following tips should help you avoid wasting time.

If you haven't already done so, update your Windows system with the latest patches from Microsoft. Next, download the latest release of the .NET Framework SDK, install it, and check for updates with Windows Update and manually, in MSDN's .NET Framework section. Now you can download your choice of the DirectX 9.0 SDK versions (full, C#, or VB.NET) and double-click on it to unpack the installation files to a temporary directory.

When you run setup, it will ask you for a path to install the SDK. There is a bug in the installer that, in some cases, does not accept the path you choose when you click on the Browse button. If the problem persists and you cannot force the installer to obey you, the solution to this problem is to quit the setup, remove temporary files, unpack the archive again, and then, when the installer asks for the path, change C:\DXSDK to a different path (e.g., E:\DXSDK) manually, by typing it into the Path text field.

Another strange thing that you might run into is a problem with DLL locations. The DirectX DLLs are put into the C:\WINDOWS\assembly\GAC directory, where they are essentially inaccessible to your development environment, be it Visual C# or Visual Basic .NET. It doesn't always happen, but if you open a sample project from the DirectX 9.0 SDK and you see exclamation marks in the References list next to Microsoft.DirectX libraries, then that's the sign of this particular installer misbehavior. Fortunately, it is very easy to fix this problem. Simply open the command line (console) window and type:

cd c:\windows\assembly\gacdir

and you should see this:

Microsoft.DirectXMicrosoft.DirectX.AudioVideoPlaybackMicrosoft.DirectX.DiagnosticsMicrosoft.DirectX.Direct3DMicrosoft.DirectX.Direct3DXMicrosoft.DirectX.DirectDrawMicrosoft.DirectX.DirectInputMicrosoft.DirectX.DirectPlayMicrosoft.DirectX.DirectSound

The DLLs we are looking for are located in subdirectories with long names like:

Microsoft.DirectX.Direct3D\1.0.900.31bf3856ad364e35\    Microsoft.DirectX.Direct3D.dll

Create a normal folder in your chosen location and copy each DLL to it. Then, update the References in your project and Build a sample application. Everything should work fine now.

Note: If you downloaded the DirectX 9.0 Redistributable, do not install it, but keep it on CD-R until you have your application ready for distribution. It contains files that Microsoft lets developers distribute to end users, and is of not much use to programmers. It's the same story with the NET Framework Redistributable.

Where now?

Programming with Managed DirectX 9.0 is currently a somewhat unexplored territory, and you will need a good guide to help you along. Your first resource will be various places on the Web and the C/C++ code in the SDK itself. Good books on this subject are yet to appear, but that should not be the case for too long.

Note that programming with Managed DirectX 9.0 is something that you should attempt after you master programming C# or VB.NET, or you will find it a frustrating experience. O'Reilly has published very good books on this subject: .NET Framework Essentials, .NET Windows Forms in a Nutshell, C# Essentials, and VB.NET Language in a Nutshell ought to be your essential reading if you are new to .NET.

To get a better understanding of computer graphics, get a copy of Computer Graphics: Principles and Practice in C or Computer Graphics. Also, the Cg Tutorial is an excellent introduction to the world of real-time shader programming techniques.

If you want to get deep into the subject, consider SIGGRAPH membership. It is an inexpensive way to gain access to a vast library of SIGGRAPH proceedings, which are a goldmine of ideas.

Happy coding!

Jacek Artymiak started his adventure with computers in 1986 with Sinclair ZX Spectrum. He's been using various commercial and Open Source Unix systems since 1991. Today, Jacek runs devGuide.net, writes and teaches about Open Source software and security, and tries to make things happen.

Return to ONDotnet.com

Are you using GDI+ or DirectX for your 3D drawing projects?
You must be logged in to the O'Reilly Network to post a talkback.

Showing messages 1 through 3 of 3.

• disappointed
  2008-03-27 19:37:35 derrick.simpson [Reply | View]
  
  
  I was expecting much more. This is hardly an intro to programming Managed DirectX.

• Managed Game Programming
  2004-12-13 08:58:21 cissmjgMikeG [Reply | View]
  
  
  I sincerely hope the folks at Ximian code up the MONO runtimes so I can port my Win32 based GDI game to other platforms by simply using ILASM. That would be SWEET.
  
  If not then I hope that Manager DirectX will (someday) allow me port my app using nothing more than ILASM.
  
  

• Book URLs
  2003-06-12 03:21:15 Jacek Artymiak | [Reply | View]
  
  
  Here are correct URLs to Computer Graphics: Principles and Practice in C, 2nd edition and 3D Computer Graphics mentioned in this article.
  
  Jacek