Archivi tag: c#

Star Wars Credits Control [C# porting]

Sulle esempio di Pablo van der Meer, ho fatto il porting del suo codice c++ in c#.

E’ stato fatto un porting molto basilare, può essere sicuramente migliorato.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace WindowsApplication3
{
    public partial class AboutScrollText : Control
    {
        private int m_Active = 0;
        const int NUM_STARS = 100;
        private Random r = new Random();
        private int m_nStarsSpeed = 30;
        private int m_nScrollSpeed = 2;
        private int m_nScrollPos;
        private Timer m_Timer;

        CStar[] m_StarArray;
        String[] m_TextLines;

        private struct CStar
        {
            public int x;
            public int y;
            public int z;
        };

        public AboutScrollText()
        {
            InitializeComponent();

            this.SetStyle(ControlStyles.DoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);

            m_StarArray = new CStar[NUM_STARS];

            m_Timer = new Timer();
            m_Timer.Interval = 75;
            m_Timer.Tick += new EventHandler(m_Timer_Tick);

            m_TextLines = new string[8];
            m_TextLines[0] = "A long time ago";
            m_TextLines[1] = "";
            m_TextLines[2] = "in a galaxy far far away";
            m_TextLines[3] = "";
            m_TextLines[4] = "this application";
            m_TextLines[5] = "was programmed by";
            m_TextLines[6] = "";
            m_TextLines[7] = "...?...";
            // initialize stars
            for (int i = 0; i < NUM_STARS; i++)
            {
                m_StarArray[i].x = r.Next(0, 1024);
                m_StarArray[i].x -= 512;
                m_StarArray[i].y = r.Next(0, 1024);
                m_StarArray[i].y -= 512;
                m_StarArray[i].z = r.Next(0, 512);
                m_StarArray[i].z -= 256;
            }

            m_nScrollSpeed = 2; // (m_nScrollSpeed * 100) / 50;
        }

        void m_Timer_Tick(object sender, EventArgs e)
        {
            if (m_Active == 0)
            {
                m_Active = 1;
                this.Invalidate();
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            if (this.DesignMode)
            {
                base.OnPaint(e);
            }
            else
            {
                Graphics g = e.Graphics;
                DoStars(g);
                DoScrollText(g);
                m_Active = 0;
            }
        }

        void DoScrollText(Graphics g)
        {
            int nPosX = 0;
            int nPosY = 0;
            Bitmap b = new Bitmap(this.Width, this.Height);
            Graphics bitmap = Graphics.FromImage(b);

            // black
            Font f = new Font("Tahoma", 24, FontStyle.Regular);
            // draw Credits on the hidden Picture
            for (int i = 0; i < m_TextLines.Length; i++)
            {
                // set position for this line
                SizeF size = bitmap.MeasureString(m_TextLines[i], f);
                nPosY = m_nScrollPos + (i * (int)size.Height);

                if ((nPosY) > 0)
                {
                    nPosX = (this.Width / 2) - ((int)size.Width / 2);

                    if (nPosY > 255)
                    {
                        bitmap.DrawString(m_TextLines[i], f, new SolidBrush(Color.FromArgb(255, 255, 255)), nPosX, nPosY);
                    }
                    else
                    {
                        // set fade color
                        bitmap.DrawString(m_TextLines[i], f, new SolidBrush(Color.FromArgb(nPosY, nPosY, nPosY)), nPosX, nPosY);
                    }
                }
                else
                {
                    // start all over ...
                    if (i == (m_TextLines.Length - 1))
                    {
                        m_nScrollPos = this.Height;
                    }
                }
            }

            int nWidth = this.Width;
            int nHeight = this.Height;

            //MemoryStream memStream = new MemoryStream();
            //bitmap.Save(memStream, ImageFormat.Gif);
            //bitmap.Flush();

            double nScale;
            int nOffset;
            // shrink text from bottom to top to create Star Wars effect
            Rectangle rDest = new Rectangle();
            Rectangle rSrc = new Rectangle();
            Bitmap s = new Bitmap(this.Width, this.Height);
            Graphics sbitmap = Graphics.FromImage(s);

            for (int y = 0; y < nHeight; y += 3)
            {
                nScale = (double)y / (double)nHeight;
                nOffset = (int)(nWidth - nWidth * nScale) / 2;
                rDest.X = nOffset;
                rDest.Y = y;
                rDest.Width = (int)(nWidth * nScale);
                rDest.Height = 3;

                rSrc.X = 0;
                rSrc.Y = y;
                rSrc.Width = nWidth;
                rSrc.Height = 3;

                sbitmap.DrawImage(b, rDest, rSrc, GraphicsUnit.Pixel);
            }

            g.DrawImageUnscaled(s, 0, 0);
            // move text up one pixel
            m_nScrollPos = m_nScrollPos - m_nScrollSpeed;
        }

        void DoStars(Graphics g)
        {
            g.Clear(Color.Black);

            int nFunFactor = 100;
            int x, y, z;
            for (int i = 0; i < NUM_STARS; i++)
            {
                m_StarArray[i].z = m_StarArray[i].z - m_nStarsSpeed;
                if (m_StarArray[i].z > 255)
                {
                    m_StarArray[i].z = -255;
                }
                if (m_StarArray[i].z < -255)
                {
                    m_StarArray[i].z = 255;
                }

                z = m_StarArray[i].z + 256;
                x = (m_StarArray[i].x * nFunFactor / z) + (this.Width / 2);
                y = (m_StarArray[i].y * nFunFactor / z) + (this.Height / 2);

                // create a white pen which luminosity depends on the z position (for 3D effect!)
                int nColor = 255 - m_StarArray[i].z;
                if (nColor < 0) nColor = 0;
                if (nColor > 255) nColor = 255;
                g.DrawEllipse(new Pen(Color.FromArgb(nColor, nColor, nColor), 1), x, y, 2, 2);
            }
        }

        public void Start()
        {
            m_nScrollPos = this.Height;
            m_Timer.Enabled = true;
        }

        public void Stop()
        {
            m_Timer.Enabled = false;
        }

    }
}

Un esempio in c++ che usa Win32 OpenGL Framework lo trovate qui.

Fletto i muscoli e sono nel vuoto.

Catturare lo stato del tasto SHIFT durante il click del mouse

E’ possibile conoscere lo stato del tasto shift (e non solo) utilizzando la funzione

[DllImport(“user32.dll”)]
static extern short GetKeyState(VirtualKeyStates nVirtKey);

Grazie a questa funzione possiamo conoscere lo stato di uno dei seguenti tasti:

public enum VirtualKeyStates : int
{
VK_LBUTTON = 0x01,
VK_RBUTTON = 0x02,
VK_CANCEL = 0x03,
VK_MBUTTON = 0x04,
//
VK_XBUTTON1 = 0x05,
VK_XBUTTON2 = 0x06,
//
VK_BACK = 0x08,
VK_TAB = 0x09,
//
VK_CLEAR = 0x0C,
VK_RETURN = 0x0D,
//
VK_SHIFT = 0x10,
VK_CONTROL = 0x11,
VK_MENU = 0x12,
VK_PAUSE = 0x13,
VK_CAPITAL = 0x14,
//
VK_KANA = 0x15,
VK_HANGEUL = 0x15,
/* old name – should be here for compatibility */
VK_HANGUL = 0x15,
VK_JUNJA = 0x17,
VK_FINAL = 0x18,
VK_HANJA = 0x19,
VK_KANJI = 0x19,
//
VK_ESCAPE = 0x1B,
//
VK_CONVERT = 0x1C,
VK_NONCONVERT = 0x1D,
VK_ACCEPT = 0x1E,
VK_MODECHANGE = 0x1F,
//
VK_SPACE = 0x20,
VK_PRIOR = 0x21,
VK_NEXT = 0x22,
VK_END = 0x23,
VK_HOME = 0x24,
VK_LEFT = 0x25,
VK_UP = 0x26,
VK_RIGHT = 0x27,
VK_DOWN = 0x28,
VK_SELECT = 0x29,
VK_PRINT = 0x2A,
VK_EXECUTE = 0x2B,
VK_SNAPSHOT = 0x2C,
VK_INSERT = 0x2D,
VK_DELETE = 0x2E,
VK_HELP = 0x2F,
//
VK_LWIN = 0x5B,
VK_RWIN = 0x5C,
VK_APPS = 0x5D,
//
VK_SLEEP = 0x5F,
//
VK_NUMPAD0 = 0x60,
VK_NUMPAD1 = 0x61,
VK_NUMPAD2 = 0x62,
VK_NUMPAD3 = 0x63,
VK_NUMPAD4 = 0x64,
VK_NUMPAD5 = 0x65,
VK_NUMPAD6 = 0x66,
VK_NUMPAD7 = 0x67,
VK_NUMPAD8 = 0x68,
VK_NUMPAD9 = 0x69,
VK_MULTIPLY = 0x6A,
VK_ADD = 0x6B,
VK_SEPARATOR = 0x6C,
VK_SUBTRACT = 0x6D,
VK_DECIMAL = 0x6E,
VK_DIVIDE = 0x6F,
VK_F1 = 0x70,
VK_F2 = 0x71,
VK_F3 = 0x72,
VK_F4 = 0x73,
VK_F5 = 0x74,
VK_F6 = 0x75,
VK_F7 = 0x76,
VK_F8 = 0x77,
VK_F9 = 0x78,
VK_F10 = 0x79,
VK_F11 = 0x7A,
VK_F12 = 0x7B,
VK_F13 = 0x7C,
VK_F14 = 0x7D,
VK_F15 = 0x7E,
VK_F16 = 0x7F,
VK_F17 = 0x80,
VK_F18 = 0x81,
VK_F19 = 0x82,
VK_F20 = 0x83,
VK_F21 = 0x84,
VK_F22 = 0x85,
VK_F23 = 0x86,
VK_F24 = 0x87,
//
VK_NUMLOCK = 0x90,
VK_SCROLL = 0x91,
//
VK_OEM_NEC_EQUAL = 0x92, // ‘=’ key on numpad
//
VK_OEM_FJ_JISHO = 0x92, // ‘Dictionary’ key
VK_OEM_FJ_MASSHOU = 0x93, // ‘Unregister word’ key
VK_OEM_FJ_TOUROKU = 0x94, // ‘Register word’ key
VK_OEM_FJ_LOYA = 0x95, // ‘Left OYAYUBI’ key
VK_OEM_FJ_ROYA = 0x96, // ‘Right OYAYUBI’ key
//
VK_LSHIFT = 0xA0,
VK_RSHIFT = 0xA1,
VK_LCONTROL = 0xA2,
VK_RCONTROL = 0xA3,
VK_LMENU = 0xA4,
VK_RMENU = 0xA5,
//
VK_BROWSER_BACK = 0xA6,
VK_BROWSER_FORWARD = 0xA7,
VK_BROWSER_REFRESH = 0xA8,
VK_BROWSER_STOP = 0xA9,
VK_BROWSER_SEARCH = 0xAA,
VK_BROWSER_FAVORITES = 0xAB,
VK_BROWSER_HOME = 0xAC,
//
VK_VOLUME_MUTE = 0xAD,
VK_VOLUME_DOWN = 0xAE,
VK_VOLUME_UP = 0xAF,
VK_MEDIA_NEXT_TRACK = 0xB0,
VK_MEDIA_PREV_TRACK = 0xB1,
VK_MEDIA_STOP = 0xB2,
VK_MEDIA_PLAY_PAUSE = 0xB3,
VK_LAUNCH_MAIL = 0xB4,
VK_LAUNCH_MEDIA_SELECT = 0xB5,
VK_LAUNCH_APP1 = 0xB6,
VK_LAUNCH_APP2 = 0xB7,
//
VK_OEM_1 = 0xBA, // ‘;:’ for US
VK_OEM_PLUS = 0xBB, // ‘+’ any country
VK_OEM_COMMA = 0xBC, // ‘,’ any country
VK_OEM_MINUS = 0xBD, // ‘-‘ any country
VK_OEM_PERIOD = 0xBE, // ‘.’ any country
VK_OEM_2 = 0xBF, // ‘/?’ for US
VK_OEM_3 = 0xC0, // ‘`~’ for US
//
VK_OEM_4 = 0xDB, // ‘[{‘ for US
VK_OEM_5 = 0xDC, // ‘\|’ for US
VK_OEM_6 = 0xDD, // ‘]}’ for US
VK_OEM_7 = 0xDE, // ””‘ for US
VK_OEM_8 = 0xDF,
//
VK_OEM_AX = 0xE1, // ‘AX’ key on Japanese AX kbd
VK_OEM_102 = 0xE2, // “<>” or “\|” on RT 102-key kbd.
VK_ICO_HELP = 0xE3, // Help key on ICO
VK_ICO_00 = 0xE4, // 00 key on ICO
//
VK_PROCESSKEY = 0xE5,
//
VK_ICO_CLEAR = 0xE6,
//
VK_PACKET = 0xE7,
//
VK_OEM_RESET = 0xE9,
VK_OEM_JUMP = 0xEA,
VK_OEM_PA1 = 0xEB,
VK_OEM_PA2 = 0xEC,
VK_OEM_PA3 = 0xED,
VK_OEM_WSCTRL = 0xEE,
VK_OEM_CUSEL = 0xEF,
VK_OEM_ATTN = 0xF0,
VK_OEM_FINISH = 0xF1,
VK_OEM_COPY = 0xF2,
VK_OEM_AUTO = 0xF3,
VK_OEM_ENLW = 0xF4,
VK_OEM_BACKTAB = 0xF5,
//
VK_ATTN = 0xF6,
VK_CRSEL = 0xF7,
VK_EXSEL = 0xF8,
VK_EREOF = 0xF9,
VK_PLAY = 0xFA,
VK_ZOOM = 0xFB,
VK_NONAME = 0xFC,
VK_PA1 = 0xFD,
VK_OEM_CLEAR = 0xFE
}

Lo stato del tasto può essere: up, down oppure toggled. Infatti, la funzione ritorna:

Рstato up, se il primo bit (high-bit) ̬ uguale a 1, stato down altrimenti.

– stato toggled on, se l’ultimo bit (lower-bit) è uguale a 1, toggle off altrimenti. Questo stato è usato per i pulsanti come CAPS LOCK, ed indica se attivo o meno.

Il seguente esempio permette di conoscere lo stato SHIFT, lo stato del tasto R-SHIFT e lo stato del tasto L-SHIFT.

//
// Vero se L-SHIFT è premuto
//
bool lshift = ((GetKeyState(VirtualKeyStates.VK_LSHIFT) & 256)==256);
//
// Vero se R-SHIFT è premuto
//
bool rshift = ((GetKeyState(VirtualKeyStates.VK_RSHIFT) & 256)==256); short x = GetKeyState(VirtualKeyStates.VK_SHIFT); if ((x & 0x80) != 0)
{
// E’ stato premuto uno shift
}
else
{
// Non è stato premuto uno shift
}
//

Fletto i muscoli e sono nel vuoto.

Controllare gli eventi di sistema

Potrebbe capitavi di dover controllare gli eventi di sistema come (la disconnessione o la sospensione della sessione) per evitare perdite di dati.

Per C# qui trovate un ottimo articolo per la loro gestione

Fletto i muscoli e sono nel vuoto.

Custom MessageBox

Due ottime librerie per i propri custom messagebox:

MessageBoxManager

MessageBoxEx

powered by IMHO 1.3

A Floating Popup Control

Un articolo su come utilizzare i popup control nelle vostre applicazioni dotnet.

http://www.codeproject.com/useritems/Floating_Popup_Control.asp

Fletto i muscoli e sono nel vuoto.

Tree Diagram Control By NetronProject

Un ottimo esempio di controllo per la visualizzazione di Tree Diagram. Da notare… l’uso del Visitor Pattern.

http://www.codeproject.com/cs/miscctrl/TreeDiagrams.asp

Fletto i muscoli e sono nel vuoto.

powered by IMHO 1.3

XPTable – ListView .NET

Ecco un bel esempio di utlizzo delle listview in .Net.

http://www.codeproject.com/cs/miscctrl/XPTable.asp

Fletto i muscoli e sono nel vuoto.