Click here to Skip to main content
12,072,392 members (58,191 online)
Click here to Skip to main content

Stats

14K views
154 downloads
14 bookmarked
Posted

My Experience with the Windows Marketplace for Mobile and Windows Mobile 6

, 22 Mar 2010 CPOL
My experience with the Windows Marketplace for Mobile for 6.x devices and the certification process.
SpeedTracker.zip
SpeedTracker
Screenshots
Screen01.png
Screen02.png
Screen03.png
Screen04.png
Screen05.png
Screen06.png
Screen07.png
Screen08.png
Screen09.png
Screen10.png
ScreenShot.jpg
ScreenShot.png
ScreenShot1.Jpeg
ScreenShot2.Jpeg
ScreenShot3.Jpeg
speed.png
SpeedTracker36x36.png
SpeedTracker45x45.png
SpeedTracker60x60.png
SpeedTracker64x64.png
SpeedTracker90x90.png
SpeedTracker
bin
Debug
SpeedTracker.Common.dll
SpeedTracker.exe
Release
SpeedTracker.Common.dll
SpeedTracker.exe
Controls
Converters
Gps
Properties
SpeedTracker.csproj.user
SpeedTracker.ico
SpeedTracker.4.5.resharper.user
SpeedTracker.Common
bin
Release
SpeedTracker.Common.dll
Properties
SpeedTracker.Common.csproj.user
SpeedTracker.ico
SpeedTracker.jpg
SpeedTracker.png
SpeedTrackerInstaller
Release
CabWiz.log
SpeedTrackerInstaller.CAB
SpeedTrackerInstaller.inf
SpeedTrackerInstaller.vddproj
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace SpeedTracker
{
    public partial class LedDigit : Control, IDisposable
    {

        public enum PaletteIndex:int
        {
            Background=0,
            Foreground=1,
            DecimalForeground=2
        }

        Point[] segmentPointList = new Point[22];
        private int _value;
        private bool _enabled = true;
        private float _horizontalThicknessFactor = 0.25f;
        private float _verticalThicknessFactor = 0.2f;
        private bool _isDecimalDigit = false;

        private SolidBrush[] ColorPalette = null;

        class Polygon
        {
            public  Point[] PointList;
            public int ColorIndex;
            public void Initialize(int[] vertexList, Point[] segmentSource)
            {
                if((PointList==null)||(vertexList.Length!=PointList.Length))
                    PointList = new Point[vertexList.Length];
                for(var i=0;i<vertexList.Length;++i)
                {
                    var vertextIndex = vertexList[i];
                    PointList[i] = new Point(segmentSource[vertextIndex].X, segmentSource[vertextIndex].Y);
                }
            }
        }

        static readonly int[][] EdgeList = new int[][]
                               {
                                   new [] {0,1,13}, 
                                   new []{1,14,13}, 
                                   new []{1,2,15,14}, 
                                   new []{2,4,15}, 
                                   new []{2,3,4},
                                   new []{13,14,17,12}, 
                                   new []{15,4,5,16}, 
                                   new []{12,17,18},
                                   new []{17,16,19,18},
                                   new []{16,5,19},
                                   new []{12,18,21,11}, 
                                   new[]{19,5,6,20},
                                   new[]{9,10,11},
                                   new[]{11,21,9},//13
                                   new[]{21,20,8,9},//14
                                   new[]{20,6,8},
                                   new[]{6,7,8}
    };

        static readonly int[][] DigitSegmentList = new int[][]
                                       {
                                           new int[]{1,2,3,5,6,7,9,0xa, 0xb, 0xd, 0xe, 0xf}, 
                                           new int[]{3, 6, 9, 0xb, 0xF, 0x10}, 
                                           new int[]{1,2,3,6,7,8,9,0xa, 0xd, 0xe, 0xf}, 
                                           new int[]{1,2,3,6,8,9,0xb,0xd,0xe,0xf}, 

                                           new int[]{1,3,4,5,6,7,8,9,0xb,0xf,0x10}, 
                                           new int[]{1,2,3,5,7,8,9,0xb,0xd,0xe,0xf}, 
                                           new int[]{1,2,3,5,7,8,9,0xa,0xb,0xd,0xe,0xf}, 
                                           new int[]{1,2,3,6,9,0xB,0xF,0x10}, 

                                           new int[]{1,2,3,5,6,7,8,9,0xa,0xb,0xd,0xe, 0xf}, 
                                           new int[]{1,2,3,5,6,7,8,9,0xB,0xd,0xe,0xf}, 
                                           new int[]{1,2,3,5,6,7,8,9,0xa,0xb,0xc,0xd,0xf}, 
                                           new int[]{0,1,2,3,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf},
 
                                           new int[]{}, 
                                           new int[]{}, 
                                           new int[]{}, 
                                           new int[]{}
    };

        private Polygon[] _shapeList;


        public int Value
        {
            get
            {
                return _value;
            }
            set
            {
                _value = value%10;
                UpdateSegmentColorIndex();
                Invalidate();
            }
        }

        public float HorizontalThicknessFactor
        {
            get { return _horizontalThicknessFactor;  }
            set
            {
                _horizontalThicknessFactor = value;
                InitPolygonList();
            }
        }

        public float VerticalThicknessFactor
        {
            get { return _verticalThicknessFactor;  }
            set
            {
                _verticalThicknessFactor = value;
                InitPolygonList();
            }
        }

        public bool Enabled
        {
            get { return _enabled;  }
            set
            {
                _enabled = value;
                UpdateSegmentColorIndex();
            }
        }

        void UpdateSegmentColorIndex()
        {
            if ((_shapeList != null)&&(DigitSegmentList!=null))
            {
                for (var i = 0; i < _shapeList.Length; ++i)
                {
                    _shapeList[i].ColorIndex = 0;
                }
                var activationList = DigitSegmentList[_value];
                if (Enabled)
                {
                    for (var i = 0; i < activationList.Length; ++i)
                    {
                        _shapeList[activationList[i]].ColorIndex = (int)((IsDecimalDigit)?PaletteIndex.Foreground:PaletteIndex.DecimalForeground);
                    }
                }
            }
        }

        void DestroyBackBuffer()
        {
            if (_offBitmap != null)
            {
                _offBitmap.Dispose();
                _offBitmap = null;
            }            
        }
        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            DestroyBackBuffer();
            this.Invalidate();
        }

        void InitPolygonList()
        {
            if((_shapeList==null)||(_shapeList.Length!=EdgeList.Length))
                _shapeList = new Polygon[EdgeList.Length];
            for(var i=0;i<EdgeList.Length;++i)
            {
                _shapeList[i] = new Polygon();
                _shapeList[i].Initialize(EdgeList[i],segmentPointList);
            }
            UpdateSegmentColorIndex();
        }

        private int _margin;

        bool VisualSettingsChanged { get; set; }

        public LedDigit()
        {
            InitializeComponent();
            ColorPalette = new SolidBrush[]{new SolidBrush(Color.WhiteSmoke),new SolidBrush(Color.Red), new SolidBrush(Color.DarkViolet),   };
            Resize+=LedDigit_Resize;
        }

        public void SetColor(PaletteIndex index, Color c)
        {
            SolidBrush oldBrush = ColorPalette[(int)index];
            ColorPalette[(int)index]=new SolidBrush(c);
            oldBrush.Dispose();
            if(PaletteIndex.Background==index)
                BackColor = c;
        }



        void  LedDigit_Resize(object sender, EventArgs e)
        {
            VisualSettingsChanged = true;
        }

        void SetLayoutChanged()
        {
            VisualSettingsChanged = true;
        }
        public int Margin
        {
            get { return _margin; }
            set
            {
                _margin = value;
                SetLayoutChanged();
            }
        }

        public bool IsDecimalDigit
        {
            get { return _isDecimalDigit; }
            set
            {
                _isDecimalDigit = value;
                VisualSettingsChanged=true;
            }
        }


        void RefreshPointList()
        {                        
            int realWidth = Width - Margin*2;
            int realHeight = Height - Margin*2;

            int x1 = Margin;
            int x2 = Margin + (int)((realWidth) * HorizontalThicknessFactor);
            int x3 = Margin + (int)(realWidth - (realWidth * HorizontalThicknessFactor));
            int x4 = Margin + (int)realWidth;

            int y1 = Margin;
            int y2 = Margin + (int)(realHeight * VerticalThicknessFactor );
            int y3 = Margin + (int)(realHeight * 0.5 - (realHeight * VerticalThicknessFactor * 0.5) );
            int y4 = Margin + (int) (realHeight*0.5);
            int y5 = Margin + (int)(realHeight * 0.5 + (realHeight * VerticalThicknessFactor * 0.5) );
            int y6 = Margin + (int)(realHeight - (realHeight * VerticalThicknessFactor));
            int y7 = Margin + realHeight;

            #region Populate Point Coordinates
            segmentPointList[0].X = x1;
            segmentPointList[0].Y = y1;

            segmentPointList[1].X = x2;
            segmentPointList[1].Y = y1;

            segmentPointList[2].X = x3;
            segmentPointList[2].Y = y1;

            segmentPointList[3].X = x4;
            segmentPointList[3].Y = y1;

            segmentPointList[4].X = x4;
            segmentPointList[4].Y = y2;

            segmentPointList[5].X = x4;
            segmentPointList[5].Y = y4;

            segmentPointList[6].X = x4;
            segmentPointList[6].Y = y6;

            segmentPointList[7].X = x4;
            segmentPointList[7].Y = y7;

            segmentPointList[8].X = x3;
            segmentPointList[8].Y = y7;

            segmentPointList[9].X = x2;
            segmentPointList[9].Y = y7;

            segmentPointList[10].X = x1;
            segmentPointList[10].Y = y7;

            segmentPointList[11].X = x1;
            segmentPointList[11].Y = y6;

            segmentPointList[12].X = x1;
            segmentPointList[12].Y = y4;

            segmentPointList[13].X = x1;
            segmentPointList[13].Y = y2;

            segmentPointList[14].X = x2;
            segmentPointList[14].Y = y2;

            segmentPointList[15].X = x3;
            segmentPointList[15].Y = y2;

            segmentPointList[16].X = x3;
            segmentPointList[16].Y = y3;

            segmentPointList[17].X = x2;
            segmentPointList[17].Y = y3;

            segmentPointList[18].X = x2;
            segmentPointList[18].Y = y5;

            segmentPointList[19].X = x3;
            segmentPointList[19].Y = y5;

            segmentPointList[20].X = x3;
            segmentPointList[20].Y = y6;

            segmentPointList[21].X = x2;
            segmentPointList[21].Y = y6;
            #endregion

            InitPolygonList();

        }

        protected override void OnPaintBackground(PaintEventArgs e)
        {
            
        }

        private Bitmap _offBitmap = null;

        protected override void OnPaint(PaintEventArgs pe)
        {
            //base.OnPaint(pe);
            if (_offBitmap == null)
            {
                _offBitmap = new Bitmap(ClientSize.Width, ClientSize.Height);
            }
            var gOff = Graphics.FromImage(_offBitmap);


            gOff.Clear(BackColor);
            if(VisualSettingsChanged)
            {
                RefreshPointList();
            }     

            for(var i=0;i<_shapeList.Length;++i)
                gOff.FillPolygon(ColorPalette[_shapeList[i].ColorIndex],_shapeList[i].PointList);
            pe.Graphics.DrawImage(_offBitmap,0,0);

        }



        #region IDisposable Members

        void IDisposable.Dispose()
        {
            if(ColorPalette!=null)
            {
                for(var i=0;i<ColorPalette.Length;++i)
                {
                    ColorPalette[i].Dispose();
                }
            }
        }

        #endregion
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Joel Ivory Johnson
Software Developer Razorfish
United States United States
I attended Southern Polytechnic State University and earned a Bachelors of Science in Computer Science and later returned to earn a Masters of Science in Software Engineering.

For the past few years I've been providing solutions to clients using Microsoft technologies for web and Windows applications.

While most of my CodeProject.com articles are centered around Windows Phone it is only one of the areas in which I work and one of my interests. I also have interest in mobile development on Android and iPhone. Professionally I work with several Microsoft technologies including SQL Server technologies, Silverlight/WPF, ASP.Net and others. My recreational development interest are centered around Artificial Inteligence especially in the area of machine vision.

Twitter:@J2iNet

You may also be interested in...

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.160208.1 | Last Updated 22 Mar 2010
Article Copyright 2010 by Joel Ivory Johnson
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid