Самые основные вещи в языке C# и платформе .NET вцелом.

Чуть более сложные вещи в языке C# и платформе .NET.

Некоторые дополнительные особенности программирования под .net.

Первый столбец - имя параметра, второй - тип, третий - группа, четвертый - значение. Тип параметра может быть почти любым - простые типы данных, включая string, и специальный - коллекция string, а также несколько классов рисования, connection string, и все что угодно через вариант Browse. Единственное условие - тип должен иметь или ToString/FromString функции для TypeConverter, или быть xmlSerializable. Группа может быть или User - настройки сохраняются для каждого пользователя, и могут быть им изменены, или Application - настройки не могут быть изменены пользователем. Смысл группы Application - если нужны константы, которые не могут быть заданы программистом (например, параметры компа или типа того) и задаются при инсталляции программы, чтобы не вычислять параметры при каждом запуске - они записываются в такие вот свойства. Впрочем, в эти свойства можно записать и обычные константы. Основные преимущества - Settings сами отслеживают версию программы и пользователя. Есть встроенные функции сохранения, загрузки и возврата к стандартным настройкам. Можно завязать контролы напрямую на settings. Сами загружаются при запуске, сами сохраняются при закрытии, сами заполняются если связаны с контролом. Основные недостатки - на каждую версию создается свой файл, что изрядно засоряет каталог пользователя, если версии выходят достаточно часто. Кстати, стандартным деинсталлятором настройки не удаляются. Возврат к стандартным настройкам и сохранение - иногда глючат. Связка контролов с параметром - может порождать глюки. Все значения настроек сохраняются либо в текстовом формате, либо через xmlSerializer, что иногда сильно увеличивает объем. Общая схема работы с Settings примерно такая: Если вы не связываете контролы с settings: Задаете свойства в дизайнере, при загрузке формы - загружаете settings и переписываете значения свойств в контролы, при закрытии формы - переписываете значения из контролов в settings и сохраняете их. Это строчка обращения к последним сохраненным settings: namespace.Properties.Settings.Default Вместо "namespace" - подставте тот namespace в котором вы работаете. Загрузка настроек, можно прямо завести поле в форме: namespace.Properties.Settings sets = namespace.Properties.Settings.Default; Переписывание значений в контролы: textBox1.Text = sets.TextFromTextbox1; Переписывание значений из контролов: sets.TextFromTextbox1 = textBox1.Text; Сохранение настроек: sets.Save(); В идеале, если контролы связаны с настройками - можете ничего не делать. Все сделают за вас, но есть несколько моментов, из-за которых до сих пор удобнее расширенные настройки делать вручную. Все контролы должны быть с имплементированным IBindableComponent интерфейсом. Соответственно, если вы пользуетесь своим контролом - интерфейс имплементировать будете сами. Если контрол без интерфейса - переписывание значений и загрузка опять лягут на вас. Некоторые контролы из-за автоматической синхронизации с settings глючат, и их все равно приходится обрабатывать вручную. Для удобства управления есть еще 4 события класса settings: SettingsLoaded - срабатывает, когда загружаются свойства. Рекомендуется использовать для проверки правильности начальных значений. SettingChanged - срабатывает до изменения значения свойства. Рекомендуется для проверки введенного значения на правильность. PropertyChanged - не рекомендовано к использованию, если не требуется проверка введенного свойства в отдельном потоке. SettingsSaved - срабатывает перед записью свойств в файл. Рекомендуется использовать для проверки правильности свойств перед сохранением, и для дополнительной синхронизации значений. Итого, settings хорошо использовать если у вас нет собственных контролов, которые надо связывать, если все контролы, которые вы используете не глючат и если версии вашей программы выходят редко. Тогда это удобно, можно через дизайнер завязать кучу параметров внешнего вида в настройки, и будет у вас клевая прога, которая помнит в каком месте экрана ее закрыли :). Основное на этом заканчивается. Остальное - всякие приколы, а-ля собственные классы для свойств, для обработчика свойств и пр. Глава 2. Сериализация. Сериализация объектов - процесс перевода созданного объекта класса в универсальный поток байт, который может быть потом преобразован обратно в объект, с помощью десериализации. Такое вот общее определение. Поскольку техника универсальная, более конкретно ничего сказать не получиться. Рассмотрим на примере, может так яснее будет: Пример 1. Предположим вы пишете программу для работы с диаграммами, а-ля Visio. Итогом работы пользователя будет изображение - растровое, векторное - не важно. Но промежуточный результат работы - это именно диаграмма, т.е. всякие формы, стрелки, текст, все это имеет параметры типа координат, цвета и пр. Пользователь, разумеется, захочет сохранить свою работу, причем сохранить так, чтобы можно было потом редактировать. Как вы поступите? Ну, скорее всего, создадите свой формат файла и будете туда последовательно выгружать все, что пользователь насоздавал. Вот тут-то вам и понадобиться сериализиция - вы можете выгружать объекты класса, вместе со всеми свойствами автоматически. Соответственно, когда пользователь захочет загрузить работу - вы запускаете десериализацию. Пример 2. Предположим, у вас есть программа, состоящая из двух частей - клиентской и серверной. Пользователь работает на клиенте, а потом сохраняет работу на сервере. Вам надо передать все, что он наработал на сервер... Как именно передавать - не суть важно, в любом случае, передать вы можете только поток байт, значит сначала, надо привести работу пользователя к этому потоку. Сериализация именно для этого и делалась - просто, на сей раз, вы выгружаете работу не в файл, а в сетевой поток. А серверная часть, получив поток, десериализирует его и записывает куда ей надо. Насчет где используется можно считать я сказал. В примерах выше два основных использования техники. В общем виде это звучит как "используется при необходимости передать данные об объекте класса между двумя приложениями, умеющими с этим классом работать". Хотя, это не совсем верно, поскольку можно и не уметь работать с классом, просто тогда не понятно, зачем это надо?.. Как пользоваться Очень просто - любой класс, который имеет аттрибут [Serializable] и функцию GetObjectData, может быть сериализован. Если у класса есть десериализационный конструктор - он может быть десериализован. Большинство классов .net поддерживают сериализацию. Обратите внимание - когда вы смотрите описание класса в msdn - у многих классов есть приписка ISerializable, IXmlSerializable, а перед названием класса стоит [SerializableAttribute] (Например, DataTable). У структур (например, Point) есть только аттрибут. Им интерфейс не нужен. Как сделать свой класс сериализируемым: [Serializable()] [ComVisibleAttribute(false)] public class SerializableClass : ISerializable { public SerializableClass() { dataField = 0; dataField2 = 0.0; } private int dataField; private double dataField2; public virtual void GetObjectData(SerializationInfo info, StreamingContext context) { // добавляем переменные в список на сохранение info.AddValue("dataField", dataField); info.AddValue("dataField2", dataField2); } } Как включить десериализацию - добавить конструктор: public SerializableClass(SerializationInfo info, StreamingContext context) : this() { dataField = info.GetInt32("dataField"); dataField2 = info.GetDouble("dataField2"); } А можно десериализацию сделать универсальной, используя Reflection: public SerializableClass(SerializationInfo info, StreamingContext context) : this() { SerializationInfoEnumerator en = info.GetEnumerator(); en.MoveNext(); for (int i = 0; i ‹ info.MemberCount; i++) { this.GetType().InvokeMember(en.Current.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetProperty, null, this, new object[1] { en.Current.Value }); en.MoveNext(); } } Сериализацию тоже можно сделать универсальной, по сути, если не имплементировать интерфейс - сериализатор будет стараться выгрузить все члены класса... Но, как правило, в классе находиться несколько членов без аттрибута Serializable, и сериализатор выкидывает ошибку. Поэтому, чаще всего, приходиться члены на запись забивать вручную, через GetObjectData. Как запустить сериализацию: Предположим, у нас в классе вся нужная инфорамция храниться в коллекции DataObjects, являющейся коллекцией объектов типа SerializableClass. Также, предположим, у SerializableClass есть event mouseDown. Event'ы не сохраняются, естественно, поэтому при десериализации, надо event опять устанавливать. internal void Serialize(string filename) { Stream stream; IFormatter formatter = new BinaryFormatter(); try { stream = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None); } catch (Exception ex) { throw ex; } try { for (int i = 0; i ‹ DataObjects.Count; i++) { formatter.Serialize(stream, DataObjects[i]); } } catch (Exception ex) { throw ex; } finally { stream.Close(); } } Как запустить десериализацию: internal void DeSerialize(string filename, MouseEventHandler mouseDown) { IFormatter formatter = new BinaryFormatter(); Stream stream; try { stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read); } catch (Exception ex) { throw ex; } object obj; try { while (stream.Position ‹ stream.Length-1) { obj = formatter.Deserialize(stream); // устанавливаем event, если надо ((SerializableClass)obj).MouseDown += mouseDown; // вносим объект в программу DataObjects.Add((SerializableClass)obj); } } catch (Exception ex) { throw ex; } finally { stream.Close(); } } Немного о типах сериализации - есть два основных типа: бинарный и xml. Первый компактнее, второй универсальнее. Лично я никогда xml сериализацией не пользовался, и считаю ее мало нужной вещью... можно спорить, конечно, но на мой взгляд, предлагаемая универсальность довольно мнимая вещь. Помимо этого вы можете сделать свой сериализатор, задача долгая, нудная, но может принести немалые выгоды. Для справки: сериализация Int32 занимает 54 байта, даже в бинарном виде, поскольку 50 байт уходят на название класса. Так что иногда лучше пользоваться своими сериализаторами. Итоги: Основные плюсы сериализации - удобство для программиста. Помимо простоты написания кода, там еще есть механизм отслеживания версий, например. Основные минусы - большие объемы, и необходимость часто вручную перечислять тех, кого надо выгружать. Глава 3. Reflection. Перевод с комментариями статьи с codeproject.com: http://www.codeproject.com/csharp/introreflection.asp. Это не полный перевод статьи, а только пересказ тех мест, которые я счел самыми важными. Введение Reflection - значительное нововведение в .NET. Через Reflection программы собирают и работают со своими метаданными. Это мощный механиз для изучения assembly и разных объектов во время работы программы. Рассматриваемое API находится в System.Reflection namespace. Через Reflection можно получить информацию о классах, методах, свойствах и событиях любого объекта, а также можно вызывать методы. И т.д. Использование Reflection для получения списка используемых assembly using System; using System.Reflection; namespace ReflectionDemoCSharp { class ReferencedAssemblies { [STAThread] static void Main(string[] args) { Assembly[] appAssemblies = System.AppDomain.CurrentDomain.GetAssemblies (); foreach (Assembly assembly in appAssemblies ) { Console.WriteLine (assembly.FullName ); } Console.ReadLine (); } } } Вывод будет таким: mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 ReflectionDemoCSharp, Version=1.0.1882.29904, Culture=neutral, PublicKeyToken=null Класс System.AppDomain class представляет домен приложения, который является некоей изолированной областью, в которой исполняется приложение. Надо пояснить, что это изолированная область памяти, потоков, процессов и прочего. Для каждого приложения создается свой домен, и все необходимые assembly загружаются в домен каждого приложения. Для общения между доменами есть свои особые механизмы. Метод GetAssemblies() возвращает список assembly, загруженных в домен ReflectionDemoCSharp. Исследование assembly и получение списка типов Для начала, динамически загружаем assembly, через Assembly.Load(). public static Assembly.Load(AssemblyName) Передаем MsCorLib.dll. Assembly LoadedAssembly = Assembly.Load("mscorlib.dll"); Когда assembly загружена, можем воспользоваться методом GetTypes(), чтобы получить массив типов. System.Type[] ExistingTypes = LoadedAssembly.GetTypes (); Возвращаемые типы могут представлять классы, интерфейсы или перечисления. using System; using System.Reflection ; namespace ReflectionDemoCSharp { class ReflectedTypes { [STAThread] static void Main(string[] args) { Assembly LoadedAssembly = Assembly.Load ("mscorlib.dll"); System.Type[] ExistingTypes = LoadedAssembly.GetTypes (); foreach(Type type in ExistingTypes) Console.WriteLine (type.ToString ()); Console.WriteLine (ExistingTypes.Length + " Types Discovered in mscorlib.dll"); Console.ReadLine (); } } } Вывод (частичный): System.Object System.ICloneable System.Collections.IEnumerable System.Collections.ICollection System.Collections.IList System.Array System.Array+SorterObjectArray System.Array+SorterGenericArray System.Collections.IEnumerator 1480 Types Discovered in mscorlib.dll Исследование типа Попробуем получить список всех членов конкретного типа. Метод Type.GetType(TypeName) возвращает объект System.Type, соответствующий строке аргумента. Мы запросим тип с помощью метода Type.GetMembers(), чтобы получить массив его членов. Я уже рассказывал, что вместо Type.GetType("System.Int32") можно использовать typeof(int). using System; using System.Reflection ; namespace ReflectionDemoCSharp { class ReflectedTypes { [STAThread] static void Main(string[] args) { Type TypeToReflect = Type.GetType("System.Int32"); System.Reflection.MemberInfo[] Members =type.GetMembers(); Console.WriteLine ("Members of "+TypeToReflect.ToString ()); Console.WriteLine(); foreach (MemberInfo member in Members ) Console.WriteLine(member); Console.ReadLine (); } } } Вывод: Members of System.Int32 Int32 MaxValue Int32 MinValue System.String ToString(System.IFormatProvider) System.TypeCode GetTypeCode() System.String ToString(System.String, System.IFormatProvider) Int32 CompareTo(System.Object) Int32 GetHashCode() Boolean Equals(System.Object) System.String ToString() System.String ToString(System.String) Int32 Parse(System.String) Int32 Parse(System.String, System.Globalization.NumberStyles) Int32 Parse(System.String, System.IFormatProvider) Int32 Parse(System.String, System.Globalization.NumberStyles, System.IFormatProvider) System.Type GetType() * System.Reflection.MemberInfo[] Members =type.GetMembers() - возвращает всех членов типа. * System.Reflection.MethodInfo[] Methods =Type.GetMethods() - возвращает только методы типа. * System.Reflection.FieldInfo[] Fields =Type.GetFields() - возвращает только поля типа. * System.Reflection.PropertyInfo[] Properties = type.GetProperties () - возвращает только свойства. * System.Reflection.EventInfo[] Events = type.GetEvents() - возвращает события типа. * System.Reflection.ConstructorInfo[] Constructors = type.GetConstructors () - возвращает конструкторы типа. * System.Type[] Interfaces = type.GetInterfaces() - возвращает интерфейсы типа. Динамический вызов, используя Type.InvokeMember() Рассмотрим, как динамически вызвать метод, используя type.InvokeMember(). type.InvokeMember() позволяет вызывать методы по их названиям. Аргументы InvokeMember(): 1. Имя вызываемого метода. Передается строкой. 2. Члены перечисления BindingFlags. Перечисление BindingFlags определяет флаги, которые контролируют связывание и способ поиска типов и членов.Например, искать ли среди static методов и т.п. 3. Объект Binder, определяющий свойства и процесс связывания. Может быть null, для использования Binder по умолчанию. Этот параметр позволяет пользователю получить внешний контроль над способом выбора переопределенных функций и методами преобразования аргументов. 4. Объект, для которого надо вызвать метод. 5. Массив аргументов, передаваемых методу. using System; using System.Reflection ; namespace ReflectionDemoCSharp { class ReflectedTypes { [STAThread] static void Main(string[] args) { Type TypeToReflect = Type.GetType("System.String"); object result = null; object[] arguments = {"abc","xyz"}; result = TypeToReflect.InvokeMember ("Equals", BindingFlags.InvokeMethod, null, result, arguments); Console.WriteLine (result.ToString ()); Console.ReadLine (); } } } Вывод будет "false". Дальше в статье рассказывается о технологии Reflection.Emit, которая позволяет создавать assembly на лету... Честно говоря, я этой технологии вижу только одно применение - создание собственных компиляторов. Впрочем, сейчас модно вставлять в программы возможность дописывания своих плагинов прямо из окна программы... а поскольку плагины проще писать на внутреннем языке приложения, то наверное и собственный компилятор может быть полезен. Хотя не знаю, есть же всякие скриптовые компиляторы, уже включенные в состав .net, есть технология VBA, которую многие не любят, но хуже она от этого не становиться и т.д. Глава 4. Самодельные элементы управления 1. Элемент управления - это любой кусок интерфейса, который сажается в окно и как-то реагирует на пользователя. Всякие кнопки, менюшки, списки и прочее. Часто бывает ситуация, когда хочется (или требуется) как-то расширить возможности элемента. Например, хочется сделать другую рисовку пунктов меню, или вместо одного ползунка нужно сделать два - для установки минимума, максимума. В случаях, когда надо изменить рисовку, сначала нужно посмотреть - нельзя ли это сделать с помощью родных методов элемента. Например, все пункты меню, выпадающих списков и подобные им имеют событие DrawItem, в котором можно описывать свою функцию рисования объекта. Рассмотрим на примере. Нам надо сделать выпадающее окно, каждый пункт списка которого состоит из числа, текста и цвета. Класс хранения данных: public class ComboData { public int number; // хранимое число public string text; // текст public Color color; // и цвет public ComboData() { // пустой конструктор number = 0; text = ""; color = Color.Black; } public ComboData(int inNumber, string inText, Color inColor) { // параметрический конструктор number = inNumber; text = inText; color = inColor; } public override string ToString() { // метод для вывода в стандартное выпадающее окно return String.Format("{0}, {1}, {2}", number, text, color); } } Начальные данные: public Form1() { InitializeComponent(); items = new ComboData[5]; items[0] = new ComboData(0, "text1", Color.Red); items[1] = new ComboData(1, "text2", Color.Blue); items[2] = new ComboData(2, "text3", Color.Green); items[3] = new ComboData(3, "text4", Color.Magenta); items[4] = new ComboData(4, "text5", Color.FromArgb(00, 221, 238)); comboBox1.Items.AddRange(items); } public ComboData[] items; В общем-то, можно и так оставить - будет в выпадающем окне такая картина: Но как-то оно не правильно показывать цвет цифрами. Поэтому, задаем comboBox свойcтво DrawMode = OwnerDrawFixed и прописываем событие DrawItem: private void comboBox1_DrawItem(object sender, DrawItemEventArgs e) { SolidBrush br = new SolidBrush(items[e.Index].color); // создаем кисть цвета элемента, который рисуем if (e.State == DrawItemState.Selected) { // если элемент выбран e.Graphics.FillRectangle(br, e.Bounds); // закрашиваем его нашим цветом e.Graphics.DrawString(items[e.Index].ToString(), e.Font, SystemBrushes.HighlightText, e.Bounds.Location); // поверх рисуем текст e.DrawFocusRectangle(); } else { // если элемент не выбран e.DrawBackground(); // рисуем фон e.Graphics.DrawString(items[e.Index].ToString(), e.Font, SystemBrushes.MenuText, e.Bounds.Location); // пишем строку } br.Dispose(); // освобождаем кисть } Теперь это выглядит так: Принцип, я думаю, понятен. Иногда бывает надо сделать набор групп элементов. Можно пойти простым путем, и создавать каждый элемент в отдельности, а можно создать элемент управления Группа и в процессе работы программы создавать его. Рассмотрим на том же примере - надо вывести все значения в виде текстовых окон и панелек цвета. Вариант 1: internal void CreateControls() { // функция создания элементов управления TextBox tb; Panel p; SuspendLayout(); for (int i = 0; i ‹ items.Length; i++) { tb = new TextBox(); // текстовое поле для числа tb.Location = new Point(20, 50 + i * 25); // позиция tb.Size = new Size(50, 20); // размер tb.Text = items[i].number.ToString(); // текст Controls.Add(tb); // добавляем элемент в окно tb = new TextBox(); // текстовое поле для текста tb.Location = new Point(75, 50 + i * 25); tb.Size = new Size(50, 20); tb.Text = items[i].text; Controls.Add(tb); p = new Panel(); // панель для цвета p.Location = new Point(130, 50 + i * 25); p.Size = new Size(50, 20); p.BackColor = items[i].color; // задаем цвет p.Tag = i; // устанавливаем идентификатор p.Click += new EventHandler(p_Click); // устанавливаем событие клик Controls.Add(p); } ResumeLayout(false); } Добавим в Form1() последней строкой запуск функции создания элементов CreateControls(); И пропишем событие клик для панелей: void p_Click(object sender, EventArgs e) { int idx = (int)((Panel)sender).Tag; // номер панели MessageBox.Show(String.Format("color panel of item {0} just has been clicked", idx)); // сообщение } Вот так вот. Вроде все в порядке. С тем же успехом можно сделать свой элемент управления, который будет состоять из двух текстовых полей и одной панельки, и в форму добавлять его. Создаем UserControl, создаем на нем два текстовых поля и панельку. Пишем два конструктора: public UserControl1(ComboData item) { // простой конструктор InitializeComponent(); Num = item.number; Tex = item.text; Col = item.color; } public UserControl1(ComboData item, int panelIdx, EventHandler panelClick) { // конструткор с поддержкой клика InitializeComponent(); Num = item.number; Tex = item.text; Col = item.color; panel1.Tag = panelIdx; panel1.Click += panelClick; } Прописываем поля данных: private int num; // число public int Num { // свойство число get { return num; } set { num = value; textBox1.Text = num.ToString(); // обновление текстового поля } } private string tex; // текст public string Tex { // свойство текст get { return tex; } set { tex = value; textBox2.Text = tex; } } private Color col; // цвет public Color Col { // свойство цвет get { return col; } set { col = value; panel1.BackColor = col; // обновление цвета } } В Form1 пишем функцию создания нашего элемента: internal void CreateUserControls() { UserControl1 uc; SuspendLayout(); for (int i = 0; i ‹ items.Length; i++) { uc = new UserControl1(items[i], i, new EventHandler(p_Click)); uc.Location = new Point(20, 50 + i * 25); uc.Tag = i; Controls.Add(uc); } ResumeLayout(false); } И в Form1() меняем CreateControls() на CreateUserControls(). Все работает так же, но использует самодельную группу управления. Удобство этого подхода в двух моментах: 1. Если вам понадобятся всякие фичи с выделением - в вашем распоряжении событие Paint для всего элемента управления, рамочку там сделать или еще чего. При создании каждого поля в отдельности подобные рамочки будут делаться сложнее, да и скорость упадет заметнее. 2. Если таких элементов управления не 5, а 50, то скорость работы существенно повышается. Система проверяет видимость элемента управления, и если он целиком невиден - она не проверяет его дочерние элементы. Стало быть, если использовать такой метод группировки - система будет проверять 50 элементов на видимость. А если поля приписывать форме напрямую, как в варианте 1, то система будет проверять 150 элементов. Ну и напоследок: стандартный comboBox имеет событие SelectedIndexChanged, но он не сообщает в нем, какой элемент был выбран до смены. Попробуем модифицировать стандартный comboBox так, чтобы он в этом событии сообщал о предыдущем значении. Создаем очередной UserControl и переходим в код, не обращая внимания на дизайнер. Ставим родителем нашего элемента класс ComboBox вместо UserControl: public partial class UserControl3 : System.Windows.Forms.ComboBox Прописываем переменную для хранения предыдущего значения выбранного индекса: private int selectedIndex_prev; В конструктор добавляем инициализацию этой переменной: selectedIndex_prev = -1; И переписываем событие SelectedIndexChanged: protected override void OnSelectedIndexChanged(EventArgs e) { base.OnSelectedIndexChanged(new UserControl2IndexChangedEventArgs(selectedIndex_prev)); // стандартный обработчик, но с нашим классом аргументов события selectedIndex_prev = this.SelectedIndex; // изменить пред. индекс } Создаем отдельный класс для аргументов нашего события: public class UserControl2IndexChangedEventArgs : EventArgs { public UserControl2IndexChangedEventArgs(int prevIdx) { prevSelectedIndex = prevIdx; } public int prevSelectedIndex; } Вот и все. Для проверки добавим в Form1 наш видоизмененный comboBox и пропишем событие SelectedIndexChanged: private void userControl31_SelectedIndexChanged(object sender, EventArgs e) { MessageBox.Show(String.Format("Selected index was changed from {0} to {1}", ((UserControl2IndexChangedEventArgs)e).prevSelectedIndex, userControl31.SelectedIndex)); } Не забываем в конструктор формы добавить заполнение нашего comboBox'a значениями: userControl31.Items.AddRange(items); Каталог проекта для MS Visual Studio 2005 с примером находится в архиве примеров, подкаталог usercontrol1. Архив примеров можно скачать здесь: http://www.robinland.com/csharp-basis/samples.zip. Глава 5. Самодельные элементы управления 2. В предыдущей главе мы рассмотрели ситуации при которых можно комбинировать уже существующие элементы управления, или достаточно просто модифицировать их. Однако, бывают ситуации когда никакой модификацией нужный результат не будет достигнут. Рассмотрим одну такую на примере. Необходимо сделать элемент управления, позволяющий устанавливать два значения в заданном интервале. Для установки одного значения есть родной элемент управления - slider (или TrackBar). Ленивые люди скажут, что нечего тут извращаться, достаточно посадить два слайдера и не морочить голову. :) С другой стороны, сделать свой элемент управления достаточно просто, а интерфейс он может значительно улучшить, ибо чем меньше элементов в окне - тем лучше. Приступим. К проекту присоединяем UserControl и задаем основные свойства: this.MaximumSize = new System.Drawing.Size(3000, 15); // максимальный размер this.MinimumSize = new System.Drawing.Size(50, 15); // минимальный размер this.Size = new System.Drawing.Size(50, 15); // стартовый размер Наш элемент управления, с точки зрения рисования, состоит из вдавленной полоски и двух ползунков. Каждый ползунок может быть в трех состояниях - нормальном, подсвеченном (когда мышка над ним) и активном (когда его тащат). зададим соответствующие флаги. А заодно создадим прямоугольники ползунков, чтобы проще было потом рисовать и отслеживать: private bool slider1drag; // ползунок 1 тащат private bool slider2drag; // ползунок 2 тащат private bool slider1hover; // ползунок 1 подсвечен private bool slider2hover; // ползунок 2 подсвечен private Rectangle slider1; // ползунок 1 private Rectangle slider2; // ползунок 2 Теперь можно попробовать нарисовать. По сути мы будем рисовать три объемных прямоугольника, один утопленный, два выпуклых... создадим отдельную функцию для этого: private void DrawRectangle3D(Graphics gr, int x, int y, int width, int height, bool pushed) { if (pushed) { gr.DrawLine(SystemPens.ControlLightLight, x + 1, y + height, x + width, y + height); gr.DrawLine(SystemPens.ControlLightLight, x + width, y + height, x + width, y + 1); gr.DrawLine(SystemPens.ControlDarkDark, x, y, x + width, y); gr.DrawLine(SystemPens.ControlDarkDark, x, y, x, y + height); } else { gr.DrawLine(SystemPens.ControlDarkDark, x + 1, y + height, x + width, y + height); gr.DrawLine(SystemPens.ControlDarkDark, x + width, y + height, x + width, y + 1); gr.DrawLine(SystemPens.ControlLightLight, x, y, x + width, y); gr.DrawLine(SystemPens.ControlLightLight, x, y, x, y + height); } } Рисуем системными цветами, чтобы не выбиваться из установленного в системе стиля оформления, хотя бы по цвету. И вариант функции для работы с объектом Rectangle: private void DrawRectangle3D(Graphics gr, Rectangle rect, bool pushed) { if (pushed) { gr.DrawLine(SystemPens.ControlLightLight, rect.X + 1, rect.Bottom, rect.Right, rect.Bottom); gr.DrawLine(SystemPens.ControlLightLight, rect.Right, rect.Bottom, rect.Right, rect.Y + 1); gr.DrawLine(SystemPens.ControlDarkDark, rect.X, rect.Y, rect.Right, rect.Y); gr.DrawLine(SystemPens.ControlDarkDark, rect.X, rect.Y, rect.X, rect.Bottom); } else { gr.DrawLine(SystemPens.ControlDarkDark, rect.X + 1, rect.Bottom, rect.Right, rect.Bottom); gr.DrawLine(SystemPens.ControlDarkDark, rect.Right, rect.Bottom, rect.Right, rect.Y + 1); gr.DrawLine(SystemPens.ControlLightLight, rect.X, rect.Y, rect.Right, rect.Y); gr.DrawLine(SystemPens.ControlLightLight, rect.X, rect.Y, rect.X, rect.Bottom); } } Теперь создаем обработчик событие Paint и описываем его: private void UserControl1_Paint(object sender, PaintEventArgs e) { DrawRectangle3D(e.Graphics, 2, Height / 2 - 2, Width - 4, 4, true); // нарисовать утопленную полоску if (e.ClipRectangle.IntersectsWith(slider1)) { // если обновляемый регион пересекает ползунок 1 if (slider1drag) { // если ползунок 1 тащат e.Graphics.FillRectangle(SystemBrushes.ControlDark, slider1); // закрасить его темным цветом } else if (slider1hover) { // если ползунок подсвечен e.Graphics.FillRectangle(SystemBrushes.ButtonHighlight, slider1); // закрасить его цветом подсветки } else { // если просто нарисовать e.Graphics.FillRectangle(SystemBrushes.Control, slider1); // закрасить системным цветом элемента управления } DrawRectangle3D(e.Graphics, slider1, false); // нарисовать объемную выпуклую рамку } if (e.ClipRectangle.IntersectsWith(slider2)) { // то же для ползунка 2 if (slider2drag) { e.Graphics.FillRectangle(SystemBrushes.ControlDark, slider2); } else if (slider2hover) { e.Graphics.FillRectangle(SystemBrushes.ButtonHighlight, slider2); } else { e.Graphics.FillRectangle(SystemBrushes.Control, slider2); } DrawRectangle3D(e.Graphics, slider2, false); } } Теперь надо задать прямоугольники ползунков и все значения на которые они опираются. Сначала необходимые значения: Минимум полоски слайдера: private int minVal; // поле для внутреннего пользования [Browsable(true)] // показывать в дизайнере [RefreshProperties(RefreshProperties.All)] // обновлять остальные свойства при изменении этого public int MinimumValue { // свойство (видимое и в дизайнере) get { return minVal; } set { if (value ›= maxVal) { throw new ArgumentException("minimum value must be ‹ maximum"); } // проверить на меньше максимума minVal = value; // установить значение if (Value2 ‹= minVal) { Value2 = minVal+1; } // поправить значения ползунков если надо if (Value1 ‹ minVal) { Value1 = minVal; } SetPos1(); // поправить прямоугольник ползунка 1 SetPos2();// поправить прямоугольник ползунка 2 } } Аналогично остальные поля: private int maxVal; // максимум полоски слайдера [Browsable(true)] [RefreshProperties(RefreshProperties.All)] public int MaximumValue { get { return maxVal; } set { if (value ‹= minVal) { throw new ArgumentException("maximum value must be › minimum"); } maxVal = value; if (Value1 ›= maxVal) { Value1 = maxVal-1; } if (Value2 › maxVal) { Value2 = maxVal; } SetPos1(); SetPos2(); } } private int val1; // значение ползунка 1 [Browsable(true)] public int Value1 { get { return val1; } set { if (value › maxVal) { throw new ArgumentException("value1 must be between min and max values"); } // меньше максимума if (value ‹ minVal) { throw new ArgumentException("value1 must be between min and max values"); } // больше минимума if (value ›= Value2) { throw new ArgumentException("value1 must be ‹ Value2"); } // меньше ползунка 2 val1 = value; // установить значение SetPos1(); // поправить прямоугольник ползунка 1 } } private int val2; // аналогично ползунок 2 [Browsable(true)] public int Value2 { get { return val2; } set { if (value › maxVal) { throw new ArgumentException("value2 must be between min and max values"); } if (value ‹ minVal) { throw new ArgumentException("value2 must be between min and max values"); } if (value ‹= Value1) { throw new ArgumentException("value2 must be › Value1"); } OnValueChanged(new UserControl1ValueChangedEventArgs(val2, value, 2)); val2 = value; SetPos2(); } } Теперь зададим функции определения прямоугольников ползунков: private void SetPos1() { slider1.X = (int)(((double)val1 - minVal) / (maxVal - minVal) * (Width - 5)); } private void SetPos2() { slider2.X = (int)(((double)val2 - minVal) / (maxVal - minVal) * (Width - 5)); } И добавим инициализацию в конструктор: public UserControl1() { InitializeComponent(); minVal = 0; maxVal = 100; val2 = 100; slider1 = new Rectangle(0, 2, 4, Height - 4); slider2 = new Rectangle(0, 2, 4, Height - 4); SetPos1(); SetPos2(); } Поскольку положение ползунков опирается еще и на размер элемента управления, добавим событие SizeChanged и опишем его: private void UserControl1_SizeChanged(object sender, EventArgs e) { SetPos1(); SetPos2(); } Приступаем к "мышиным" функциям: Создаем события нажатие мышки, отпускание мышки и движение мышки. Нажатие мышки: private void UserControl1_MouseDown(object sender, MouseEventArgs e) { if (slider1.Contains(e.Location)) { // если нажали на ползунок 1 slider1drag = true; // установить флаг ползунок 1 тащат Invalidate(slider1); // обновить рисовку ползунка 1 } else if (slider2.Contains(e.Location)) { // то же для ползунка 2 slider2drag = true; Invalidate(slider2); } } Отпускание мышки: private void UserControl1_MouseUp(object sender, MouseEventArgs e) { if (slider1drag) { // если тащили ползунок 1 slider1drag = false; // снять выделение slider1hover = false; Invalidate(slider1); // перерисовать внутреннюю часть } else if (slider2drag) { // то же для ползунка 2 slider2drag = false; slider2hover = false; Invalidate(slider2); } } Перемещение мышки. Тут нам понадобится возможность обновлять не только сам ползунок, но всю область от предыдущего положения ползунка, до его текущего положения. Иначе будут оставаться полоски при быстром движении. Для этого создадим еще одно поле Rectangle, и пропишем его инициализацию в конструктор: private Rectangle invalidateRect; public UserControl1() { ... invalidateRect = new Rectangle(); } Вот теперь функция перемещения мышки: private void UserControl1_MouseMove(object sender, MouseEventArgs e) { if (slider1drag) { // если ползунок 1 тащат if (e.X ›= 2 e.X ‹= Width - 3 e.X ‹ slider2.Left+1) { // проверить можно ли сюда двигаться invalidateRect = slider1; // запомним старое положение ползунка Value1 = (int)Math.Round(minVal + ((double)(e.X - 2) / (Width - 5)) * (maxVal - minVal)); // установим новое положение по мышке, что обновит положение ползунка invalidateRect = Rectangle.Union(slider1, invalidateRect); // получим прямоугольник объединяющий старое и новое положение Invalidate(Rectangle.Inflate(invalidateRect, 1, 1)); // обновим прямоугольник и прилегающие пиксели } } else if (slider2drag) { // то же для ползунка 2 if (e.X ›= 2 e.X ‹= Width - 3 e.X › slider1.Right-1) { invalidateRect = slider2; Value2 = (int)Math.Round(minVal + ((double)(e.X - 2) / (Width - 5)) * (maxVal - minVal)); invalidateRect = Rectangle.Union(slider2, invalidateRect); Invalidate(Rectangle.Inflate(invalidateRect, 1, 1)); } } else { // если никого не тащат if (slider1.Contains(e.Location)) { // если мышка над первым ползунком if (!slider1hover) { // если флаг подсветки не установлен slider1hover = true; // установить Invalidate(slider1); // перерисовать внутреннюю часть ползунка } } else if (slider2.Contains(e.Location)) { // то же для ползунка 2 //draw hover state if (!slider2hover) { slider2hover = true; Invalidate(slider2); } } else { // если мышка не над ползунками if (slider1hover) { // если ползунок 1 был подсвечен slider1hover = false; // снять подсветку Invalidate(slider1); // перерисовать внутреннюю часть } else if (slider2hover) { // то же для ползунка 2 slider2hover = false; Invalidate(slider2); } } } GC.Collect(); // очистить память } Очистка памяти нужна, потому как функции Rectangle.Union и Rectangle.Inflate создают новые объекты Rectangle, которые после окончания функции уходят в мусор. Добавим еще модификатор класса, чтобы его было нормально видно в дизайнере: [DesignTimeVisible(true)] public partial class UserControl1 : UserControl { Вобщем-то элемент управления работает. Можно создать форму и посадить на нее наш элемент, настроить и посмотреть как работает. Вот только не очень удобно - при изменении значения, он об этом не сообщает. Добавим ему событие изменение значения: [Browsable(true)] // видно в дизайнере public event ValueChangedEventDelegate ValueChanged = null; // событие public delegate void ValueChangedEventDelegate(object sender, UserControl1ValueChangedEventArgs e); // делегат обработчика события protected virtual void OnValueChanged(UserControl1ValueChangedEventArgs e) { // обработчик if (ValueChanged != null) { ValueChanged(this, e); } } Нам понадобится еще класс аргументов события: public class UserControl1ValueChangedEventArgs : EventArgs // аргументы события { public UserControl1ValueChangedEventArgs(int inOldValue, int inNewValue, byte inValue) { // конструктор oldValue = inOldValue; // старое значение newValue = inNewValue; // новое значение value = inValue; // какой ползунок } public int oldValue; public int newValue; /// ‹summary› /// 1 - value 1, 2 - value 2 /// ‹/summary› public byte value; } И введем вызов события при изменении значений: public int Value1 { get { return val1; } set { if (value › maxVal) { throw new ArgumentException("value1 must be between min and max values"); } if (value ‹ minVal) { throw new ArgumentException("value1 must be between min and max values"); } if (value ›= Value2) { throw new ArgumentException("value1 must be ‹ Value2"); } OnValueChanged(new UserControl1ValueChangedEventArgs(val1, value, 1)); // вызов события val1 = value; SetPos1(); } } Аналогичную строчку добавим и для второго значения: OnValueChanged(new UserControl1ValueChangedEventArgs(val2, value, 2)); // вызов события И последний штрих - установим для класса событием по умолчанию - наше событие: [DefaultEvent("ValueChanged")] public partial class UserControl1 : UserControl Вот и все. Можно использовать и в дизайнере и во время работы программы. Сделаем Form1, добавим в нее наш элемент управления, сделаем пару текстовых окошек и пропишем для нашего элемента управления событие ValueChanged: private void userControl11_ValueChanged(object sender, UserControl1ValueChangedEventArgs e) { if (e.value == 1) { // если первый ползунок textBox1.Text = e.newValue.ToString(); // внести новое значение в текстовое поле 1 } else if (e.value == 2) { // аналогично для ползунка 2 textBox2.Text = e.newValue.ToString(); } } Да добавим в конструктор формы такие строчки: textBox1.Text = userControl11.Value1.ToString(); // записать начальное значение ползунка 1 в текстовое поле 1 textBox2.Text = userControl11.Value2.ToString();// аналогично для ползунка 2 Вот все и работает. Не идеально, конечно. Но "дешево, надежно и практично". Каталог проекта для MS Visual Studio 2005 с примером находится в архиве примеров, подкаталог usercontrol2. Архив примеров можно скачать здесь: http://www.robinland.com/csharp-basis/samples.zip.

Основы GDI+.

Примеры программ для решения каких-то конкретных задач. Код с комментариями. К каждому примеру существует файл с архивом проекта для MS Visual Studio 2005, скачать можно здесь: http://www.robinland.com/csharp-basis/samples.zip.

Как это делать думаю пояснять не надо. Добавьте еще OpenFileDialog в него, в котором задайте в свойствах Filter = "Все файлы (*.*)|*.*||".

Теперь описываем все кнопки последовательно (в дизайнере дважды щелкаем на кнопку - создается функция обработки нажатия):

Открыть файл:

Фишки можно менять местами с соседними по вертикали, горизонтали и диагонали, если соседняя того же цвета или той же формы. Вроде все просто. Своеобразные пятнашки получаются.

Приступим. Создаем окно. Нам понадобятся кнопки Новой игры, Настройки и Выхода. Остальное пространство под игровое поле. Поскольку рисовка простая - используем движок GDI+, без подключения OpenGL или DirectX. Рисовать будем на элементе panel.

Сначала задаем нужные нам поля...

#region fields internal GameOptions options; //настройки игры, класс создадим позднее internal Fishka[] fishki; // собственно фишки, класс создадим позднее internal bool IsGame; // флаг что игра идет internal SolidBrush[] brushes; // кисти для закраски фишек internal bool eog; // флаг конца игры private Graphics panelGr; // объект, через который будем рисовать #endregion

У элемента Panel есть свой объект класса Graphics, но его уж очень неудобно использовать. Нам понадобится доступ к графике не только из события Paint, но и из других функций, так что проще создать свой Graphics объект и приписать его к Panel. Это не лучший путь, но в нашем случае он подходит лучшим образом, на мой взгляд.

Дальше проводим инициализацию созданных полей и включаем кнопки.

private void Form1_Load(object sender, EventArgs e) { options = new GameOptions(); // создаем объект настроек с значениями по умолчанию fishki = new Fishka[36]; // создаем фишки brushes = new SolidBrush[6]; // создаем простые кисти InitBrushes(); // инициализируем их //инициализируем фишки for (byte i = 0; i ‹ 6; i++) { for (byte j = 0; j ‹ 6; j++) { fishki[i * 6 + j] = new Fishka(j, i, i, j); // создаем фишки с параметрами. } } panelGr = Graphics.FromHwnd(panel1.Handle); // создаем объект рисования для panel1 NewGame(); // Инициализируем игру } #region buttons private void button1_Click(object sender, EventArgs e) { // кнопка Новая игра NewGame(); } private void button3_Click(object sender, EventArgs e) { // Кнопка Настройка SetOptions(); } private void button2_Click(object sender, EventArgs e) { // Кнопка Выход Close(); } #endregion

Теперь создаем все то, что мы уже упомянули:

internal class GameOptions // класс настроек игры { internal Color[] fishkaColors; // массив выбранных цветов для фишек internal GameOptions() { // конструктор с значениями по умолчанию fishkaColors = new Color[6]; fishkaColors[0] = Color.Red; fishkaColors[1] = Color.LightGreen; fishkaColors[2] = Color.Blue; fishkaColors[3] = Color.Cyan; fishkaColors[4] = Color.Magenta; fishkaColors[5] = Color.Orange; } } internal class Fishka // класс фишек { internal byte shape; // номер формы фишки internal byte color; // номер цвета фишки internal byte col; // столбец internal byte row; // ряд internal Fishka() { // конструктор с значениями по умолчанию shape = 0; color = 0; col = 0; row = 0; } internal Fishka(byte inShape, byte inColor, byte inCol, byte inRow) { // конструктор shape = inShape; color = inColor; col = inCol; row = inRow; } }

Теперь функции:

internal void InitBrushes() { // инициализация кистей for (int i = 0; i ‹ 6; i++) { brushes[i] = new SolidBrush(options.fishkaColors[i]); // создаем кисть с заданным цветом } GC.Collect(); // убираем мусор из памяти. } internal void NewGame() { // инициализация игры //ставим фишки на случайные места Random rnd = new Random(); byte tmpCol, tmpRow; int tmpInt; for (int i = 0; i ‹ 36; i++) { // проводим 36 случайных замен мест tmpCol = fishki[i].col; tmpRow = fishki[i].row; tmpInt = rnd.Next(0, 35); fishki[i].col = fishki[tmpInt].col; fishki[i].row = fishki[tmpInt].row; fishki[tmpInt].col = tmpCol; fishki[tmpInt].row = tmpRow; } eog = false; // снимаем флаг окончания игры IsGame = true; // игра началась panel1.Refresh(); // перерисовываем поле } internal void SetOptions() { //задание настроек IsGame = false; // игру на паузу Form2 settingsForm = new Form2(this); // открываем окно настроек settingsForm.StartPosition = FormStartPosition.CenterParent; // открывать нужно по центру основного окна if (settingsForm.ShowDialog(this) == DialogResult.OK) { // открываем диалог настроек и если нажали ОК InitBrushes(); // переинициализируем кисти } IsGame = true; // снимаем игру с паузы panel1.Refresh(); // перерисовываем поле } private void panel1_Paint(object sender, PaintEventArgs e) { // функция рисования поля if (!IsGame) { return; } // если нет игры - не рисовать for (byte i = 0; i ‹ 36; i++) { DrawFishka(i); // рисуем фишки } }

Теперь собственно рисуем фишки:

internal void DrawFishka(byte i) { int fWidth = 42; // ширина фишки int fHeight = 42; // высота фишки int x = 4 + fishki[i].col * 50; // начало фишки по Х int y = 4 + fishki[i].row * 50; // начало вишки по Y panelGr.FillRectangle(SystemBrushes.Control, x - 1, y - 1, fWidth + 2, fHeight + 2); // закрашиваем поле фишки цветом фона switch (fishki[i].shape) { // рисуем фишки разной формы case 0: panelGr.FillRectangle(brushes[fishki[i].color], x, y, fWidth, fHeight); // квадрат break; case 1: panelGr.FillEllipse(brushes[fishki[i].color], x, y, fWidth, fHeight); // круг break; case 2: panelGr.FillPie(brushes[fishki[i].color], x - fWidth/2, y, fWidth*2, fHeight*2, -120, 60); // сектор break; case 3: panelGr.FillPolygon(brushes[fishki[i].color], new Point[] { new Point(x, y + fHeight), new Point(x + fWidth, y + fHeight), new Point(x + fWidth/2, y) }); // треугольник вверх break; case 4: panelGr.FillPolygon(brushes[fishki[i].color], new Point[] { new Point(x + fWidth, y + fHeight), new Point(x + fWidth, y), new Point(x, y + fHeight/2) }); // треугольник влево break; case 5: panelGr.FillPolygon(brushes[fishki[i].color], new Point[] { new Point(x, y + fHeight), new Point(x, y), new Point(x + fWidth, y + fHeight/2) }); // треугольник вправо break; } }

На этом моменте поле рисуется, но не управляется.

Приступаем к созданию управления. Нам надо, чтобы можно было мышкой выбирать фишку - значит нужно куда записывать выбранную. Дописываем в регион fields такую запись:

internal byte curSelected; // индекс выбранной фишки

А в функцию инициализации (Form1_Load) такую:

curSelected = 255; // никакая не выбрана

Теперь описываем функцию клика мышки, но покольку нам нужны точные координаты клика, возьмем событие MouseUp:

private void panel1_MouseUp(object sender, MouseEventArgs e) { if (eog || !IsGame) { return; } // если игра окончена или на паузе - не обрабатывать byte f = GetFishkaFromCoord(e.X, e.Y); // получить индекс фишки по координатам клика if (f != curSelected) { // если кликнули не на уже выбранную if (f == 255) { // если кликнули вне поля curSelected = f; // никакая не выбрана return; } if (curSelected == 255) { curSelected = f; } // если никто не был выбран, говорим что была выбрана она же else if (CheckAndSwitch(curSelected, f)) { return; } // проверяем надо ли фишки менять местами, если да - возвращаемся curSelected = f; // выбрана новая } else if (f != 255) { // если кликнули на ту же фишку curSelected = 255; // никакая не выбрана } } internal byte GetFishkaFromCoord(int x, int y) { // получить индекс фишки по координатам byte col = (byte)(x / 50); // получить столбец byte row = (byte)(y / 50); // получить ряд for (byte i = 0; i ‹ 36; i++) { //последовательно проверить, кто здесь стоит if (fishki[i].col == col fishki[i].row == row) { return i; } } return 255; // если никто - вернуть никто }

Последовательные перебор - плохое решение, но если в массиве 36 объектов, то на современных компах сойдет. Лучше конечно создать парный массив мест, с постоянно поддерживаемой индексацией какая фишка стоит в i месте.

Теперь функция смены фишек:

internal bool CheckAndSwitch(byte f1, byte f2) { //проверяем соседние ли фишки if (Math.Abs(fishki[f1].col - fishki[f2].col) ‹= 1 Math.Abs(fishki[f1].row - fishki[f2].row) ‹= 1) { //проверяем совпадает цвет или форма if (fishki[f1].color == fishki[f2].color || fishki[f1].shape == fishki[f2].shape) { //меняем местами byte tc = fishki[f1].col; byte tr = fishki[f1].row; fishki[f1].col = fishki[f2].col; fishki[f1].row = fishki[f2].row; fishki[f2].col = tc; fishki[f2].row = tr; //снимаем выбранность curSelected = 255; //перерисовываем DrawFishka(f1); DrawFishka(f2); //проверяем не окончена ли игра eog = true; // смотрим на формы по горизонтали и цвета по вертикали for (int i = 0; i ‹ 6; i++) { for (int j = 0; (j ‹ 5 eog); j++) { if (j != 5 fishki[i * 6 + j].row != fishki[i * 6 + j + 1].row) { eog = false; } if (i != 5 fishki[i * 6 + j].col != fishki[(i + 1) * 6 + j].col) { eog = false; } } } if (eog) { // если ошибок нет DrawEOG(); // рисуем конец игры } else { // если ошибки были - проверяем наоборот eog = true; for (int i = 0; i ‹ 6; i++) { for (int j = 0; (j ‹ 5 eog); j++) { if (j != 5 fishki[i * 6 + j].col != fishki[i * 6 + j + 1].col) { eog = false; } if (i != 5 fishki[i * 6 + j].row != fishki[(i + 1) * 6 + j].row) { eog = false; } } } if (eog) { // ошибок нет DrawEOG(); // конец игры } } return true; // фишки меняли местами } } return false; // фишки не меняли местами }

Осталось последнее - нарисовать конец игры:

internal void DrawEOG() { panelGr.DrawString("Собрано", new Font("Times New Roman", 80, GraphicsUnit.Pixel), Brushes.Black, 0, 100); // рисуем слово Собрано поверх поля }

В общем и целом - игра работает. Другое дело, что она не красивая и не удобная. Настройку цветов мы предусмотрели, но пока не сделали. Да и играть, когда не видно какая фишка выбрана - тяжело. Попробуем немного украсить игру.

Во-первых введем индикацию над какой фишкой находится мышка и будем отрисовывать выбранную фишку, и ту над которой мышка.

Добавим индекс "под-мышечной" фишки:

#region fields internal byte curHovered; //Form1_Load curHovered = 255;

Для контроля опишем функцию движения мышки по полю:

private void panel1_MouseMove(object sender, MouseEventArgs e) { if (eog || !IsGame) { return; } // если игра окончена или на паузе - не реагировать byte f = GetFishkaFromCoord(e.X, e.Y); // получить фишку по координатам if (f == 255 curHovered != 255) { // если мышка вне поля, но какая-то фишка была отмечена - снимаем отметку curHovered = 255; return; } if (f != curHovered) { // если мышка перешла на другую фишку, меняем отметку curHovered = f; } }

Теперь надо отрисовывать выбранность фишек и их реакцию на мышку. А заодно, хорошо бы и рисовать их получше.

Изменим функции реакций на мышку так, чтобы фишки перерисовывались:

#region mouse events private void panel1_MouseMove(object sender, MouseEventArgs e) { // движение мышки по полю if (eog || !IsGame) { return; } byte f = GetFishkaFromCoord(e.X, e.Y); if (f == 255 curHovered != 255) { f = curHovered; // запоминаем какая была отмечена curHovered = 255; // снимаем отметку DrawFishka(f); // перерисовываем фишку, которая была отмечена, чтобы снять отметку return; } if (f != curHovered) { if (curHovered == 255) { curHovered = f; } byte old = curHovered; // запоминаем какая была отмечана curHovered = f; // меняем отметку DrawFishka(old); // перерисовываем струю DrawFishka(curHovered); // и новую } } private void panel1_MouseUp(object sender, MouseEventArgs e) { // клик мышки if (eog || !IsGame) { return; } byte f = GetFishkaFromCoord(e.X, e.Y); if (f != curSelected) { if (f == 255) { f = curSelected; // запоминаем, какая была выбрана curSelected = 255; // снимаем выбранность DrawFishka(f); // перерисовываем старую, чтобы снять выделение return; } if (curSelected == 255) { curSelected = f; } else if (CheckAndSwitch(curSelected, f)) { return; } byte old = curSelected; // запоминаем, какая была выбрана curSelected = f; // меняем отметку DrawFishka(old); // перерисовываем старую DrawFishka(curSelected); // и новую } else if (f != 255) { f = curSelected; // запоминаем какая была выбрана curSelected = 255; // снимаем выделение DrawFishka(f); // перерисовываем старую } } #endregion

Ну и наконец рисование... добавим градиентную заливку к фишкам. А чтобы было проще менять способы заливки - введем создание кистей в функцию рисования. Нерационально, но при столь малом рисовании - почти не заметно. Итак функция InitBrush, все ее упоминания и поле brushes не нужны. А функцию рисования сделаем такой:

internal void DrawFishka(byte i) { int fWidth = 42; int fHeight = 42; int x = 4 + fishki[i].col * 50; int y = 4 + fishki[i].row * 50; panelGr.FillRectangle(SystemBrushes.Control, x - 1, y - 1, fWidth + 2, fHeight + 2); LinearGradientBrush br; // декларируем кисть с градиентом if (curSelected == i) { // если рисуемая фишка - выбрана br = new LinearGradientBrush(new Point(x,y), new Point(x+fWidth, y+fHeight), Color.Gray, options.fishkaColors[fishki[i].color]); // создаем градиент от серого к цвету фишки } else if (curHovered == i) { // если рисуемая фишка под мышкой br = new LinearGradientBrush(new Point(x, y), new Point(x + fWidth, y + fHeight), options.fishkaColors[fishki[i].color], Color.Gray); // создаем градиент от цвета фишки к серому } else { // если это просто фишка br = new LinearGradientBrush(new Point(x, y), new Point(x + fWidth, y + fHeight), options.fishkaColors[fishki[i].color], Color.White); // градиент от цвета фишки к белому } switch (fishki[i].shape) { case 0: panelGr.FillRectangle(br, x, y, fWidth, fHeight); break; case 1: panelGr.FillEllipse(br, x, y, fWidth, fHeight); break; case 2: panelGr.FillPie(br, x - fWidth/2, y, fWidth*2, fHeight*2, -120, 60); break; case 3: panelGr.FillPolygon(br, new Point[] { new Point(x, y + fHeight), new Point(x + fWidth, y + fHeight), new Point(x + fWidth/2, y) }); break; case 4: panelGr.FillPolygon(br, new Point[] { new Point(x + fWidth, y + fHeight), new Point(x + fWidth, y), new Point(x, y + fHeight/2) }); break; case 5: panelGr.FillPolygon(br, new Point[] { new Point(x, y + fHeight), new Point(x, y), new Point(x + fWidth, y + fHeight/2) }); break; } }

Осталось сделать выбор цветов.

Делаем такую форму:

Не забудьте добавить ColorDialog, указать AcceptButton = button7 для формы.

Инициализируем форму:

private Form1 pf; internal Form2(Form1 inFrm) { // конструктор с указанием родительской формы InitializeComponent(); pf = inFrm; // задаем указатель на родительскую форму button1.BackColor = pf.options.fishkaColors[0]; // задаем цвета для кнопок button2.BackColor = pf.options.fishkaColors[1]; button3.BackColor = pf.options.fishkaColors[2]; button4.BackColor = pf.options.fishkaColors[3]; button5.BackColor = pf.options.fishkaColors[4]; button6.BackColor = pf.options.fishkaColors[5]; }

Дальше есть два пути. Первый обычный: для каждой кнопки пишем такую функцию:

private void button1_Click(object sender, EventArgs e) { colorDialog1.Color = button1.BackColor; // устанавливаем цвет фишки в диалоге выбора цвета if (colorDialog1.ShowDialog(this) == DialogResult.OK) { // открываем диалог, и если в нем нажали ОК button1.BackColor = colorDialog1.Color; // устанавливаем выбранный цвет на кнопку pf.options.fishkaColors[0] = colorDialog1.Color; // и на фишку } }

И так 6 раз. Занудно, но просто. Второй путь - задать для каждой кнопки параметр Tag = номеру цвета. Т.е. 0, 1, 2, 3, 4, 5 в порядке создания кнопок. Приписать к каждой один и тот же обработчик события нажатия, например button_Click. Это делается в файле Form2.Designer.cs в регионе Windows Form Designer generated code таким образом:

this.button1.Click += new System.EventHandler(this.button_Click);

И так для каждой из шести кнопок.

И описать этот самый обработчик так:

private void button_Click(object sender, EventArgs e) { int idx = Int32.Parse(((Button)sender).Tag as string); // определяем к какой фишке относится кнопка colorDialog1.Color = ((Button)sender).BackColor; // устанавливаем цвет фишки в диалоге if (colorDialog1.ShowDialog(this) == DialogResult.OK) { // открываем диалог ((Button)sender).BackColor = colorDialog1.Color; // устанавливаем выбранный цвет на кнопку pf.options.fishkaColors[idx] = colorDialog1.Color; // и на фишку } }

Так получается одна функция, но чуть больше другой работы.

Вот теперь можно играть. :)

Желающие могут поэкспериментировать с формами фишек. Мне просто было откровенно лень выписывать всякие тороиды, пятиугольники и прочее. Гораздо интереснее эксперименты с градиентными заливками. Те, кому интересно - посмотрите класс Blend, в котором задаются распределение цветов для множественного градиента.

Каталог проекта для MS Visual Studio 2005 с примером находится в архиве примеров, подкаталог puzzle.

На многих форумах/блогах/сайтах есть ограничения на загружаемые картинки типа таких: "не больше чем 1024 пикселей по стороне и не больше чем 1 Мб". Постановка задачи - надо создать программку для массового уменьшения размеров и объема картинок по заданным параметрам. Будем исходить из того, что картинки с которыми предстоит работать, находятся в формате jpeg или png, впрочем gif, bmp и tiff - тоже подходят. Если формат другой - то придется подключать библиотеку работы с этим форматом, а в худшем случае, писать свою. Перечисленные 5 форматов поддерживаются .NET, так что проблем не будет. Нам понадобится: возможность добавления/удаления файлов/каталогов в список обработки, задание параметров (размера и объема), выбор варианта сохранения и места сохранения. Приступаем - создаем окно, в котором предусматриваем все, что только что перечислили. Добавляем openFileDialog, folderBrowserDialog и заполняем comboBox1 значениями JPEG, PNG, TIFF, BMP, GIF. Для openFileDialog описываем свойство Filter так - "Графические файлы (*.jpg, *.png, *.tiff, *.gif, *.bmp)|*.jpg;*.jpe;*.jpeg;*.png;*.tif;*.tiff;*.bmp;*.gif||", а свойство MultiSelect = true. Для comboBox1 устанавливаем свойство DropDownStyle = DropDownList. Для listBox1 устанавливаем свойство HorizontalScrollbar = true Первое приближение Описываем функцию кнопки Добавить файлы: private void button1_Click(object sender, EventArgs e) { if (openFileDialog1.ShowDialog(this) == DialogResult.OK) { // открыть диалог выбора файлов listBox1.Items.AddRange(openFileDialog1.FileNames); // заполняем listbox именами выбранных файлов } } Запускаем прогу и смотрим что получилось. После выбора файлов видим, что в listbox они пишутся с полным путем... не очень удобно читать. Как бы сделать так, чтобы писались только имена файлов, но запоминались они полностью? Создаем класс, который будет содержать полный путь и только имя файла, и возвращать в listbox только короткое имя: internal class FileListItem { internal string fullFilename; // полное имя файла internal string shortFilename; // короткое имя файла internal FileListItem() { // конструктор fullFilename = ""; shortFilename = ""; } internal FileListItem(string inFull, string inShort) { // конструктор со всеми параметрами fullFilename = inFull; shortFilename = inShort; } internal FileListItem(string inFull) { // конструктор только с полным именем fullFilename = inFull; shortFilename = Path.GetFileName(inFull); } public override string ToString() { // функция, к которой обращается listbox при заполнении списка return shortFilename; } } Теперь изменим функцию обработки нажатия кнопки на такую: for (int i = 0; i ‹ openFileDialog1.FileNames.Length; i++) { // для каждого из выбранных файлов listBox1.Items.Add(new FileListItem(openFileDialog1.FileNames[i])); // добавить в listbox созданный объект FileListItem } Запускаем и смотрим, что получилось. Вроде нормально. Дальше пишем функцию кнопки Добавить каталог: private void button2_Click(object sender, EventArgs e) { if (folderBrowserDialog1.ShowDialog(this) == DialogResult.OK) { // открываем диалог выбора каталога DirectoryInfo di = new DirectoryInfo(folderBrowserDialog1.SelectedPath); // создаем объект информации о выбранном каталоге foreach (FileInfo fi in di.GetFiles("*.jpg")) { // для каждого файла jpg listBox1.Items.Add(new FileListItem(fi.FullName)); // добавить имя файла в список } //аналогичный цикл для каждого расширения } } Можно использовать цикл для каждого файла и внутри цикла проверять расширение файла, напрямую или через Regex: foreach (FileInfo fi in di.GetFiles("*.*")) { // для каждого файла в каталоге if (fi.Extension.Equals(".jpg") || fi.Extension.Equals(".jpe") || fi.Extension.Equals(".jpeg") || fi.Extension.Equals(".png") || fi.Extension.Equals(".tif") || fi.Extension.Equals(".tiff") || fi.Extension.Equals(".gif") || fi.Extension.Equals(".bmp")) { // если расширение нам подходит listBox1.Items.Add(new FileListItem(fi.FullName)); // добавить в список } } Запускаем, проверям. Работает, но программа не просматривает подкаталоги. Надо поправить. Для этого: выносим код добавления файлов в отдельную функцию: internal void AddFilesFromDir(string dir) { DirectoryInfo di = new DirectoryInfo(dir); foreach (FileInfo fi in di.GetFiles("*.*")) { if (fi.Extension.Equals(".jpg") || fi.Extension.Equals(".jpe") || fi.Extension.Equals(".jpeg") || fi.Extension.Equals(".png") || fi.Extension.Equals(".tif") || fi.Extension.Equals(".tiff") || fi.Extension.Equals(".gif") || fi.Extension.Equals(".bmp")) { listBox1.Items.Add(new FileListItem(fi.FullName)); } } } меняем функцию обработки кнопки Добавить каталог: if (folderBrowserDialog1.ShowDialog(this) == DialogResult.OK) { AddFilesFromDir(folderBrowserDialog1.SelectedPath); } и добавляем в функцию добавления файлов рекурсивный код, в конец функции: foreach (DirectoryInfo di2 in di.GetDirectories()) { // для каждого подкаталога в каталоге di AddFilesFromDir(di2.FullName); // добавить файлы из него } Запускаем, проверяем. Вроде работает. Неудобно каждый раз в окне выбора каталога прыгать по длинному дереву... надо бы поправить... В функцию обработки кнопки Добавить каталог добавим первой строчкой: if (folderBrowserDialog1.SelectedPath == "") { folderBrowserDialog1.SelectedPath = @"C:\"; } Ну, путь пишете тот, который вам удобен. Пишем функцию обработки кнопки Убрать выделенное: private void button3_Click(object sender, EventArgs e) { if (listBox1.SelectedIndex != -1) { // если что-то выделенно listBox1.Items.RemoveAt(listBox1.SelectedIndex); // убрать выделенный элемент } } Дальше описываем кнопку Выбрать для каталога сохранения: private void button4_Click(object sender, EventArgs e) { if (folderBrowserDialog1.ShowDialog(this) == DialogResult.OK) { // открываем диалог выбора каталога textBox4.Text = folderBrowserDialog1.SelectedPath; // записываем выбранный путь в текстовое поле } } Запускаем, проверям. Замечаем, что в выпадающем окошке Формат сохранения ничего не выбирается само... непорядок. Создадим обработчик события Form1_Load и впишем туда такой код: comboBox1.SelectedIndex = 0; // выбрать первый в списке элемент Осталось самое главное - написать основные функции. Поскольку в форме хватает параметров, вводимых пользователем, лучше создать отдельную функцию проверки правильности введенных данных. Естественно, функция преобразования картинки тоже должна быть отдельной. Таким образом, обработчик кнопки Уменьшить будет примерно таким: private void button5_Click(object sender, EventArgs e) { if (!CheckInput()) { return; } DoJob(); } Теперь описываем проверку введенных данных. Что надо проверять: наличие файлов проверять не надо, это будет делать функция, которая будет с ними работать, потому что все выбранные файлы существовали на момент выбора, а значит они могут исчезнуть только по ошибке, которая может произойти когда-угодно, и проверять работоспособность файла надо прямо перед (или во время) обращения к нему. Надо проверить введенные числа - чтобы состояли только из цифр, и не были слишком большими/маленькими. А еще надо проверить каталог сохранения - если его нет, надо создать. Заодно, создадим глобальные переменные, в которых будем хранить введенные данные. internal int width; //ширина internal int height; //высота internal int size; // объем в байтах internal string resdir; // каталог для результатов internal int filesErrorCount; // счетчик ошибок internal System.Drawing.Imaging.ImageFormat imageFormat; // выбранный формат файлов internal string imageExt; // расширение выбранного формата internal bool CheckInput() { try { // попробовать width = Int32.Parse(textBox1.Text); // превратить введеное в текстовом поле в целое число if (width ‹= 1) { return false; } // если ширина слишком маленькая - вернуть ошибку } catch { // если что-то не получилось return false; // вернуть ошибку } try { height = Int32.Parse(textBox2.Text); if (height ‹= 1) { return false; } // если высота слишком маленькая - вернуть ошибку } catch { return false; } try { size = Int32.Parse(textBox3.Text); size *= 1024; // переводим в байты if (size == 0) { return false; } // если объем равен 0 - вернуть ошибку } catch { return false; } if (textBox4.Text.Length == 0) { return false; } // если путь не введен - ошибка resdir = textBox4.Text; if (resdir[resdir.Length - 1] != '') { resdir += ""; } // уточняем наличие слеша на конце пути if (!Directory.Exists(resdir)) { // если каталог не существует try { // попробовать resdir = Directory.CreateDirectory(resdir).FullName; // создать каталог, записать полный путь в resdir и добавить слеш } catch { return false; } } switch (comboBox1.SelectedIndex) { // в зависимости от того, что выбрано в окошке Формат case 0: imageFormat = System.Drawing.Imaging.ImageFormat.Jpeg; // установить формат файлов imageExt = ".jpg"; // и расширение break; case 1: imageFormat = System.Drawing.Imaging.ImageFormat.Png; imageExt = ".png"; break; case 2: imageFormat = System.Drawing.Imaging.ImageFormat.Tiff; imageExt = ".tif"; break; case 3: imageFormat = System.Drawing.Imaging.ImageFormat.Bmp; imageExt = ".bmp"; break; case 4: imageFormat = System.Drawing.Imaging.ImageFormat.Gif; imageExt = ".gif"; break; } return true; } Желающие могут перед каждым return false вставить сообщение об ошибке, либо просто: MessageBox.Show(this, "Неправильно введена ширина", "Ошибка"); либо сделать отдельную функцию показа ошибок. Переходим к главному - функции уменьшения. Итак, функция должна открыть файл, посмотреть попадает ли он под введенные параметры. Если да - просто скопировать его, если нет - то пересохранить его. Причем, сначала надо подогнать размеры, определив какая из сторон больше выступает за разрешенное значение, попробовать сохранить, посмотреть объем - и последовательно пропорционально уменьшать размер, пока объем не станет нужным. Желающим экспериментировать со степенью сжатия для изменеия объема, что более разумно во многих случаях, придется пойти чуть другим путем - при сохранении картинки передавать функции Save объект класса EncoderParameters с установленной степенью сжатия. Сделаем одну функцию управляющей, а проверку и все операции вынесем в отдельный функции. internal void DoJob() { filesErrorCount = 0; int imageCheck = 0; for (int i = 0; i ‹ listBox1.Items.Count; i++) { // для каждого элемента списка imageCheck = IsImageOk(((FileListItem)listBox1.Items[i]).fullFilename); // проверяем файл if (imageCheck == 0) { // если ошибок нет File.Copy(((FileListItem)listBox1.Items[i]).fullFilename, resdir + ((FileListItem)listBox1.Items[i]).shortFilename); // скопировать файл continue; } else if (imageCheck == 4) { continue; } // если ошибка открытия файла - пропустить else if (imageCheck == 1) { // если размер и формат в порядке SmallerImage(((FileListItem)listBox1.Items[i]).fullFilename, false); // уменьшить объем } else if (imageCheck == 2) { // если размер больше ResizeImage(((FileListItem)listBox1.Items[i]).fullFilename); // уменьшить картинку } else if (imageCheck == 3) { // если размер в порядке, но формат другой ConvertImage(((FileListItem)listBox1.Items[i]).fullFilename); // изменить формат } } // сообщить сколько файлов прошло, сколько выдали ошибку MessageBox.Show(this, String.Format("Успешно преобразовано {0} файлов.nПроизошли ошибки при работе с {1} файлами.", listBox1.Items.Count-filesErrorCount, filesErrorCount), "Ошибка"); } internal int IsImageOk(string fn) { // проверка файлов Bitmap bmp; try { // попробовать bmp = new Bitmap(fn); // создать картинку из файла } catch { // если не получилось filesErrorCount++; // посчитать ошибку return 4; // вернуть ошибку открытия } if (bmp.Width › width || bmp.Height › height) { return 2; } // если размер больше, вернуть 2 bmp.Dispose(); // убрать картинку из памяти if (!Path.GetExtension(fn).ToLower().Equals(imageExt)) { return 3; } // если расширение не то, которое надо, вернуть 3 FileInfo fi = new FileInfo(fn); // создать объект информации о файле if (fi.Length › size) { return 1; } // если размер файла больше, вернуть 1 return 0; // ошибок нет } internal void ResizeImage(string fn) { int newImageWidth = 0; int newImageHeight = 0; Bitmap bmp; try { bmp = new Bitmap(fn); } catch { filesErrorCount++; return; } if ((double)width / bmp.Width ‹ (double)height / bmp.Height) { { // если ширина больше выступает за границы, чем высота newImageWidth = width; // ширину на максимум newImageHeight = (int)(bmp.Height * ((double)width / bmp.Width)); // высоту пропорционально } else { // если наоборот, высота больше выступает newImageHeight = height; // высоту на максимум newImageWidth = (int)(bmp.Width * ((double)height / bmp.Height)); // ширину пропорционально } bmp = new Bitmap(bmp, newImageWidth, newImageHeight); // создать измененное изображение try { // попробовать bmp.Save(resdir + Path.GetFileNameWithoutExtension(fn) + imageExt, imageFormat); // сохранить в нужном формате } catch { filesErrorCount++; return; } finally { // при любом раскладе bmp.Dispose(); // уничтожить объект картинки } FileInfo fi = new FileInfo(resdir + Path.GetFileNameWithoutExtension(fn) + imageExt); // информация о новом файле if (fi.Length › size) { // если объем больше SmallerImage(resdir + Path.GetFileNameWithoutExtension(fn) + imageExt, true); // уменьшить объем } } В следующей функции вроде все должно быть понятно, все уже было откомментировано. internal void ConvertImage(string fn) { Bitmap bmp; try { bmp = new Bitmap(fn); } catch { filesErrorCount++; return; } try { bmp.Save(resdir + Path.GetFileNameWithoutExtension(fn) + imageExt, imageFormat); } catch { filesErrorCount++; return; } finally { bmp.Dispose(); } FileInfo fi = new FileInfo(resdir + Path.GetFileNameWithoutExtension(fn) + imageExt); if (fi.Length › size) { SmallerImage(resdir + Path.GetFileNameWithoutExtension(fn) + imageExt, true); } } Уменьшаем объем. Я пошел самым простым путем - пустил в цикл уменьшение на 5% по размеру, пока объем не станет нужным. Входящий параметр inplace - показывает что меняем - старый файл с копированием, или новый в своем месте. internal void SmallerImage(string fn, bool inplace) { bool done = false; // флаг правильности объема string resfn; // имя результирующего файла if (inplace) { resfn = fn; } // если на месте - результирующее имя равно исходному else { resfn = resdir + Path.GetFileNameWithoutExtension(fn) + imageExt; } // если нет - создаем результирующее Bitmap bmp, bmp2; while (!done) { // пока размер не подойдет try { bmp = new Bitmap(fn); } catch { filesErrorCount++; return; } bmp2 = new Bitmap(bmp, (int)(bmp.Width * 0.95), (int)(bmp.Height * 0.95)); // создаем новую картинку на 5% меньше bmp.Dispose(); // уничтожаем старую картинку try {// попробовать if (inplace) { // если на месте File.Delete(resfn); // удалить файл, на место которого будем сейчас писать } bmp2.Save(resfn, imageFormat); // сохраняем новую картинку } catch { filesErrorCount++; return; } finally { bmp2.Dispose(); // в любом случае - уничтожаем новую картинку } FileInfo fi = new FileInfo(resfn); // информация о новом файле if (fi.Length ‹= size) { // если размер подходит done = true; // ставим флаг } fn = resfn; // имя файла теперь точно равно результирующему inplace = true; // и работаем дальше на месте GC.Collect(); // очищаем память от мусора. } } Запускаем. Проверяем. Вроде все работает... вот только понять это сложно - кнопку нажали и прога висит, пока не закончит. Надо бы по-аккуратнее сделать, прогресс индикатор, например. Второе приближение - или безопасная мультипоточность Добавим в форму маленький прогресс индикатор и компонент BackgroundWorker, который появился только в .NET 2.0. Это такой специальный работник, который сам себе тихо работает в фоновом режиме, не мешает основной программе выполняться и только сообщает о своем прогрессе, да ждет отмены. Прикольная фича, раньше приходилось то же самое писать лапками, или копировать из проекта в проект, а теперь удобнее стало и безопаснее. :) Для компонента backgroundWorker1 определим все три доступных события: private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) { // запуск работника DoJob(sender); // наша главная функция работы, как аргумент передаем ей указатель на работника } private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) { // изменение прогресса progressBar1.Value = e.ProgressPercentage; // установить значение прогресс индикатора } private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { // завершение работы UseWaitCursor = false; // отменить курсор ожидания (часики) progressBar1.Value = 0; // снять прогресс button5.Enabled = true; // включаем кнопку Уменьшить } Поправим нашу функцию работы, и обработчик события нажатия кнопки Уменьшить: private void button5_Click(object sender, EventArgs e) { if (!CheckInput()) { return; } UseWaitCursor = true; // включаем курсор часики button5.Enabled = false; // выключаем кнопку уменьшить - чтоб не было всяких двойных кликов backgroundWorker1.RunWorkerAsync(); // запускаем работника } internal void DoJob(object worker) { // основная функция теперь с параметром filesErrorCount = 0; int imageCheck = 0; for (int i = 0; i ‹ listBox1.Items.Count; i++) { imageCheck = IsImageOk(((FileListItem)listBox1.Items[i]).fullFilename); if (imageCheck == 0) { File.Copy(((FileListItem)listBox1.Items[i]).fullFilename, resdir + ((FileListItem)listBox1.Items[i]).shortFilename); continue; } else if (imageCheck == 4) { continue; } else if (imageCheck == 1) { SmallerImage(((FileListItem)listBox1.Items[i]).fullFilename, false); } else if (imageCheck == 2) { ResizeImage(((FileListItem)listBox1.Items[i]).fullFilename); } else if (imageCheck == 3) { ConvertImage(((FileListItem)listBox1.Items[i]).fullFilename); } ((BackgroundWorker)worker).ReportProgress((int)Math.Round((double)i * 100/ listBox1.Items.Count)); // уточнить прогресс } // в вызове окна убираем привязку к форме MessageBox.Show(String.Format("Успешно преобразовано {0} файлов.nПроизошли ошибки при работе с {1} файлами.", listBox1.Items.Count-filesErrorCount, filesErrorCount), "Ошибка"); } Вот и все. Конечно, по уму, надо бы еще перед запуском работника выключать все элементы управления и включать их по завершении. А еще можно кнопку Отмена вставить. Каталог проекта для MS Visual Studio 2005 с примером находится в архиве примеров, подкаталог image_resizer. 4. Системный индикатор в заголовке окна. Работал тут с одной глючной прогой и мне понадобился хороший детектор свободного места на харде. А чтобы его было всегда видно и он не мешал работе, я решил его вывести в заголовок активного окна. Теперь решил рассказать, как я это сделал и показать, что еще можно аналогично выводить. Во-первых, создаем пустое, маленькое и невидимое окно. Для этого надо задать следующие свойства созданной формы: ClientSize = new System.Drawing.Size(86, 26); // ширину подберите под размер выводимого текста, высоту будем ставить программно ControlBox = false; // убираем кнопки минимизации и пр. Text = ""; // убираем текст из заголовка, чтобы заголовок пропал DoubleBuffered = true; // двойной буфер - чтоб меньше мерцало при рисовании FormBorderStyle = System.Windows.Forms.FormBorderStyle.None; // убираем границу окна ShowInTaskbar = false; // не показывать в панели задач TopMost = true; // самое верхнее (выше только TaskManager) TransparencyKey = System.Drawing.SystemColors.Control; // делаем окно всегда прозрачным Добавим в форму компонент timer, чтобы контролировать частоту с которой ведется проверка диска, определим события Paint и MouseUp для формы и Tick для таймера. Сделаем функцию, записывающую текущее свободное место на диске в глобальную переменную: internal long space; internal void CheckSize() { try { space = System.IO.DriveInfo.GetDrives()[1].AvailableFreeSpace; // получить свободное место на первом драйве Refresh(); // обновить окно } catch { // если была ошибка timer1.Stop(); // остановить таймер Close(); // выйти } } Диски нумеруются в порядке букв, т.е. в моем случае, 0 - A, 1 - C, 2 - D... Если проверка не удалась - это означает сбой диска, поэтому стоит закрытие программы, чтобы не мучить драйв, с которым что-то случилось. Теперь надо сделать функцию преобразования размера в читаемую строку. Размер возвращается в байтах, меня он интересует до сотой мегабайта, так что я сделал так: internal string MakeReadableSize(long size) { double ret = (double)size / 1024; // приводим к килобайтам size /= 1024; if (size == 0) { // если целых килобайт 0 - вернуть строку в килобайтах до сотой return String.Format("{0:f2}Kb", ret); } ret = (double)size / 1024; // приводим к мегабайтам return String.Format("{0:f2}Mb", ret); // вернуть в мегабайтах до сотой } Теперь можно сделать функцию рисования: private void Form1_Paint(object sender, PaintEventArgs e) { e.Graphics.DrawString(MakeReadableSize(space), myFont, myBrush, 0, 0); // рисуем строку в окне } Надо бы определить и задать кисть и шрифт, которым пользуемся для написания строки, да и высоту окна надо бы поставить. Пишем все это в инициализацию окна: internal Font myFont; internal SolidBrush myBrush; public Form1() { InitializeComponent(); myBrush = new SolidBrush(SystemColors.ActiveCaptionText); // кисть цвета текста заголовка активного окна myFont = SystemFonts.CaptionFont; // шрифт - такой же Height = SystemInformation.CaptionHeight; // задать высоту окна раную высоте заголовка окна timer1.Start(); // запустить таймер } Сделаем еще закрытие по правому щелчку: private void Form1_MouseUp(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Right) { // если правая кнопка timer1.Stop(); // остановить таймер Close(); // закрыть окно } } Теперь функция таймера. Если мы хотим проверять состояние диска каждые 50 миллисекунд, а положение окна (чтобы оно всегда оставалось в заголовке) каждые 10, надо сделать примерно так - задать интервал таймера 10 и написать такую функцию Tick: internal int ticks; private void timer1_Tick(object sender, EventArgs e) { ticks++; CheckLocation(); // проверить положение окна if (ticks == 5) { // если 5 тиков прошло (50 миллисекунд) ticks = 0; // обнулить счетчик CheckSize(); // проверить диск } } Осталось самое сложное - научиться определять положение нашего окна, чтобы оно попадало на заголовок активного окна. Для этого нам надо определять текущее активное окно, его размеры, видимо оно или скрыто, а также надо определять окно десктопа и его размеры - на случай, если активного окна нет. Для всего этого есть функции в Windows API, в библиотеке user32.dll. Прописываем их вызовы: [DllImport("user32.dll", CharSet = CharSet.Auto)] public static extern IntPtr GetDesktopWindow(); // получить указатель на окно десктопа [DllImport("user32.dll", CharSet = CharSet.Auto)] public static extern IntPtr GetForegroundWindow(); // получить указатель на активное окно [DllImport("user32.dll", CharSet = CharSet.Auto)] public static extern bool GetWindowRect(IntPtr lpHwnd, ref Rectangle lpRect); // получить размер окна по указателю [DllImport("user32.dll", CharSet = CharSet.Auto)] public static extern IntPtr GetWindow(IntPtr lpHwnd, uint wCmd); // получить окно (следующее, предыдущее, дочернее...) [DllImport("user32.dll", CharSet = CharSet.Auto)] public static extern bool IsWindowVisible(IntPtr lpHwnd); // видимо ли окно? Не забываем добавить в начале кода using System.Runtime.InteropServices; И пишем функцию проверки и корректировки положения: internal void CheckLocation() { Rectangle rect = new Rectangle(); // размер окна IntPtr desktop_hWnd = GetDesktopWindow(); // указатель на дектоп if (desktop_hWnd == IntPtr.Zero) { return; } // если дектоп не определен - вернуться IntPtr hWnd = GetForegroundWindow(); // указатель на активное окно while (!IsWindowVisible(hWnd) hWnd != IntPtr.Zero) { // если оно не видимо hWnd = GetWindow(hWnd, 2); // проверять дочерние окна, пока не надйем видимое или пока они не кончаться } if (hWnd == IntPtr.Zero || hWnd == this.Handle) { // если окно не найдено, или активное окно - наша программа if (GetWindowRect(desktop_hWnd, ref rect)) { // определить размер десктопа Left = rect.Width - Width; // расположить справа Top = rect.Height - Height-50; // внизу, над панелью задач } } else if (GetWindowRect(hWnd, ref rect)) { // получить размер активного if (rect.Left == rect.Width) { // если окно нулевой ширины if (GetWindowRect(desktop_hWnd, ref rect)) { Left = rect.Width - Width; Top = rect.Height - Height - 50; } } Left = rect.Width -Width - 46; // установить справа, минус кнопки закрытия Top = rect.Top+5; // 5 пикселей ниже границы } } Обратите внимание, что rect.Width - это на самом деле положение правой стороны окна, а вовсе не ширина. Почему так происходит - не знаю. Может я чего не так сделал в вызове функций, а может это ошибка преобразователя Microsoft из struct rect в class Rectangle. Вот и все с программой. Желающие вывести что-то другое в заголовок могут изменить функцию CheckSize и MakeReadableSize соответственно. Ну, например, свободная физическая память: надо декларировать структуру информации о памяти и функцию API: [DllImport("kernel32")] static extern void GlobalMemoryStatus(ref MEMORYSTATUS buf); [StructLayout(LayoutKind.Sequential)] public struct MEMORYSTATUS { public uint dwLength; public uint dwMemoryLoad; public uint dwTotalPhys; public uint dwAvailPhys; public uint dwTotalPageFile; public uint dwAvailPageFile; public uint dwTotalVirtual; public uint dwAvailVirtual; } И изменить функцию CheckSize: MEMORYSTATUS memSt = new MEMORYSTATUS(); GlobalMemoryStatus(ref memSt); space = memSt.dwAvailPhys; Менять MakeReadableSize не нужно - память в ммегабайтах вполне читабельна :) Мой подход - проверка состояния по таймеру не совсем верен, ибо более ресурсоемок, нежели подлючение к сообщениям Windows об изменении состояния окон и дисков. Другое дело, что даже моя прога жрет мало, а подключение к системным сообщениям дело более трудное и долгое. Итого - программа висит в заголовке активного окна, если он есть. Если нет - по разному. Иногда повисает в правом нижнем углу экрана, иногда прячется где-то. Каталог проекта для MS Visual Studio 2005 с примером находится в архиве примеров, подкаталог hdd_in_caption. 5. "Ошкуривание" программы. Методов "ошкуривания" множество, начиная от обычных тем и заканчивая конструкторами внешнего вида. Рассмотрим два приема - самый простой и самый сложный, остальные методы, в общем, похожи на рассматриваемые. Немножко по другому устроены стили Windows, хотя по сути они тоже шкурка, просто чуть иначе сделанная. В общем и целом, любая шкурка состоит из набора графических файлов и файлов описаний. Формат графических файлов может быть любым, в пределах легко доступных для чтения. В частных случаях выбор графического формата может быть ограничен необходимостью сохранять значения цветов неискаженными, что исключает jpeg. Формат файла описания может быть также любым - хоть текстовым, хоть xml. Что касается способов хранения шкурок на диске - тут свобода полная. Самый простой вариант - создать каталог для шкурок, в котором для каждой шкурки создавать свой подкаталог, и писать в него файлы. Файл описания сохранять в текстовом формате. Именно таким способом буду пользоваться я в примерах. Желающие могут вместо подкаталогов для шкурок использовать архив-файлы или xml файлы или все-что-угодно свое. Метод первый Не совсем шкурки, скорее темы для своей программы. Создается обычное приложение, без поддержки Windows стилей, но используемые цвета и фоновые картинки для всех элементов управления берутся из файлов. Так, или примерно так, сделаны темы FlashGet. Пример: обычное приложение из трех кнопок. Одна кнопка включает стиль 1, другая стиль 2, третья - выход. в Program.cs в функции Main комментарим строчку //Application.EnableVisualStyles(); если она есть (в Visual Studio 2005 она прописывается автоматически, в 2003 - нет) Создаем класс для хранения темы: internal class SkinDesc1 { internal Image bgButton1; // фоновая картинка для кнопки 1 internal Image bgButton2;// фоновая картинка для кнопки 2 internal Image bgButton3;// фоновая картинка для кнопки 3 internal Image bgForm; // фоновая картинка для формы internal Color colButton1; // цвет фона для кнопки 1 internal Color colButton2;// цвет фона для кнопки 2 internal Color colButton3;// цвет фона для кнопки 3 internal Color colForm;// цвет фона для формы } Разумеется, вы можете в класс прописать любые графические свойства объектов - цвет шрифта, шрифт, стиль шрифта, размер бордюра и прочее. В классе формы описываем нажатия кнопок, и добавляем в конструктор загрузку тем и их применение: public Form1() { InitializeComponent(); LoadSkins1(); // загрузить темы ApplySkin1(0); // применить тему 1 } private void button1_Click(object sender, EventArgs e) { // кнопка Стиль 1 ApplySkin1(0); // применить стиль 1 } private void button2_Click(object sender, EventArgs e) { // кнопка Стиль 2 ApplySkin1(1); // применить стиль 2 } private void button3_Click(object sender, EventArgs e) { // кнопка Выход Close(); // закрыть } В нашем случае файлов шкурки будет 5 - фоновые картинки для каждой кнопки и для формы, и текстовый файл в котором записаны цвета. Цвета записаны в таком виде: 255,0,0, по одному на строчку. Теперь функция загрузки тем: internal void LoadSkins1() { DirectoryInfo di = new DirectoryInfo(@"../../skins/"); // каталог со шкурками skins = new SkinDesc1[di.GetDirectories().Length]; // количество шкурок = количеству подкаталогов int i = 0; string colStr = ""; string[] tsa; foreach (DirectoryInfo di2 in di.GetDirectories()) { // для каждого подкаталога skins[i] = new SkinDesc1(); // создать шкурку StreamReader sr = new StreamReader(di2.FullName + "\\colors.txt"); // открыть файл цветов try { try { // считываем цвета colStr = sr.ReadLine(); // строчка цвета tsa = colStr.Split(','); // разбить по запятым на значения RGB skins[i].colButton1 = Color.FromArgb(Int32.Parse(tsa[0]), Int32.Parse(tsa[1]), Int32.Parse(tsa[2])); // создать цвет colStr = sr.ReadLine(); tsa = colStr.Split(','); skins[i].colButton2 = Color.FromArgb(Int32.Parse(tsa[0]), Int32.Parse(tsa[1]), Int32.Parse(tsa[2])); colStr = sr.ReadLine(); tsa = colStr.Split(','); skins[i].colButton3 = Color.FromArgb(Int32.Parse(tsa[0]), Int32.Parse(tsa[1]), Int32.Parse(tsa[2])); colStr = sr.ReadLine(); tsa = colStr.Split(','); skins[i].colForm = Color.FromArgb(Int32.Parse(tsa[0]), Int32.Parse(tsa[1]), Int32.Parse(tsa[2])); } catch { } try { skins[i].bgButton1 = new Bitmap(di2.FullName + "\\button1.jpg"); } // загрузить картинку, если есть catch { skins[i].bgButton1 = null; } // если нет - поставить null try { skins[i].bgButton2 = new Bitmap(di2.FullName + "\\button2.jpg"); } catch { skins[i].bgButton1 = null; } try { skins[i].bgButton3 = new Bitmap(di2.FullName + "\\button3.jpg"); } catch { skins[i].bgButton1 = null; } try { skins[i].bgForm = new Bitmap(di2.FullName + "\\form.jpg"); } catch { skins[i].bgButton1 = null; } } catch { } finally { sr.Close(); } i++; } } И функция применения тем: internal void ApplySkin1(int idx) { button1.BackColor = skins[idx].colButton1; // установить цвет button2.BackColor = skins[idx].colButton2; button3.BackColor = skins[idx].colButton3; BackColor = skins[idx].colForm; if (skins[idx].bgButton1 != null) { button1.BackgroundImage = skins[idx].bgButton1; } // если картинка загружена - установить else { button1.BackgroundImage = null; } // если нет - снять if (skins[idx].bgButton2 != null) { button2.BackgroundImage = skins[idx].bgButton2; } else { button2.BackgroundImage = null; } if (skins[idx].bgButton3 != null) { button3.BackgroundImage = skins[idx].bgButton3; } else { button3.BackgroundImage = null; } if (skins[idx].bgForm != null) { BackgroundImage = skins[idx].bgForm; } else { BackgroundImage = null; } } Запускаем, проверяем: Метод второй Уже не шкурка, скорее конструктор внешнего вида. В файл описания шкурки входят не только графические параметры, но и размер и положение элемента в форме. Для каждого элемента имеется поддержка трех положений - обычного, подсвеченного и нажатого, плюс ко всему, включена прозрачность. Так, или примерно так, сделаны шкурки WinAmp modern и BSPlayer. Прозрачность в Windows лучше всего подключать так, как это делает Microsoft - подключаемые картинки хранятся в формате bmp (или любом другом не искажающем значения цветов при сохранении), а прозрачным объявляется один из цветов. Альфа-канал в картинках не используется. Структура шкурки примерно такая: в текстовом файле описаны все параметры формы (размер формы и цвет, объявленный прозрачным) и все элементы управления, которые должны быть нарисованы. Для каждого элемента управления задаются следующие параметры - тип, размер, положение в форме, цвет фона, цвет шрифта, шрифт, имена файлов для трех положений, текст. Тип элемента управления задает не только что это в принципе (кнопка, ползунок и пр.), но и что это конкретно (какая именно кнопка). В нашем случае в программе всего 3 разных кнопки, поэтому типов элемента управления будет 4: по одному на кнопку и еще один для pictureBox. который будет основным наполнителем графического содержания формы. Пример: Создаем форму и задаем следующие свойства: FormBorderStyle = None; ControlBox = false; Text = ""; Создаем класс хранения шкурки: internal class SkinDesc1 { internal Color transparentKey; // цвет объявленный прозрачным internal Size formSize; // размер формы internal ArrayList controls; // коллекция описаний элементов управления internal SkinDesc1() { // конструктор controls = new ArrayList(); } } и класс описания элемента управления: internal class MyControl { internal byte type; // тип internal Point Location; // положение internal Size Size; // размер internal Image normal; // картинка нормального состояния internal Image highlighted; // картинка подсвеченного состояния internal Image pressed; // картинка нажатого состояния internal Color bgColor; // цвет фона internal Color fgColor; // цвет шрифта internal Font font; // шрифт internal string Text; // текст } Теперь в форме создаем поля хранения шкурки: internal SkinDesc1[] skins; // описания шкурок internal int currentSkin=-1; // текущая шкурка и нажатия кнопок: private void button1_Click(object sender, EventArgs e) { // кнопка 1 ApplySkin1(0); // применить стиль 1 } private void button2_Click(object sender, EventArgs e) { // кнопка 2 ApplySkin1(1); // применить стиль 2 } private void button3_Click(object sender, EventArgs e) { // кнопка 3 Close(); // выход } Обратите внимание - создаем только функции нажатия, самих кнопок не создаем. Также в форме надо описать функции перетаскивания окна, поскольку заголовок мы отключили. Перетаскивать можно будет за любую видимую часть формы, кроме кнопок, т.е. в нашем случае за любой pictureBox. internal bool dragging; // флаг тащат или нет internal Point dragStart; // точка начала перетаскивания private void drag_mouseDown(object sender, MouseEventArgs e) { // мышь нажата dragging = true; // включить перетаскивание dragStart = e.Location; // запомнить где нажали } private void drag_mouseUp(object sender, MouseEventArgs e) { // мышь отпущена dragging = false; // выключить перетаскивание } private void drag_mouseMove(object sender, MouseEventArgs e) { // мышь подвинули if (dragging) { // если тащат Left = PointToScreen(e.Location).X - dragStart.X; // переместить окно Top = PointToScreen(e.Location).Y - dragStart.Y; } } Ну и надо описать функции изменения остояния кнопок - подсветку и нажатие: private void mouseEnter(object sender, EventArgs e) { // мышь над элементом управления if (currentSkin == -1) { return; } // если шкурка выбрана int idx = (int)((Control)sender).Tag; // получить индекс элемента управления в коллекции MyControl mc = ((MyControl)skins[currentSkin].controls[idx]); // указатель на описание элемента управления if (mc.highlighted != null) { // если картинка подсвеченного состояния есть if (mc.type == 0) { // если мышь над pictureBox ((PictureBox)sender).Image = mc.highlighted; // установить картинку подсветки } else { // если над кнопкой ((Button)sender).Image = mc.highlighted; // установить картинку подсветки } } } private void mouseLeave(object sender, EventArgs e) { // аналогично - мышь ушла с элемента if (currentSkin == -1) { return; } int idx = (int)((Control)sender).Tag; MyControl mc = ((MyControl)skins[currentSkin].controls[idx]); if (mc.normal != null) { // проверка на тип элемента - при смене шкурки событие будет идти от элемента из другой шкурки // что вызовет ошибку, поэтому проверяем не только в коллекции, но и реально if (mc.type == 0 sender.GetType().Equals(typeof(PictureBox))) { ((PictureBox)sender).Image = mc.normal; } else if ((mc.type == 1 || mc.type == 2 || mc.type == 3) sender.GetType().Equals(typeof(Button))) { ((Button)sender).Image = mc.normal; } } } private void mouseDown(object sender, MouseEventArgs e) { // аналогично мышь нажата if (currentSkin == -1) { return; } int idx = (int)((Control)sender).Tag; MyControl mc = ((MyControl)skins[currentSkin].controls[idx]); if (mc.pressed != null) { if (mc.type == 0) { ((PictureBox)sender).Image = mc.pressed; } else { ((Button)sender).Image = mc.pressed; } } } private void mouseUp(object sender, MouseEventArgs e) { // аналогично мышь отпущена if (currentSkin == -1) { return; } int idx = (int)((Control)sender).Tag; MyControl mc = ((MyControl)skins[currentSkin].controls[idx]); if (mc.normal != null) { if (mc.type == 0 sender.GetType().Equals(typeof(PictureBox))) { ((PictureBox)sender).Image = mc.normal; } else if ((mc.type == 1 || mc.type == 2 || mc.type == 3) sender.GetType().Equals(typeof(Button))) { ((Button)sender).Image = mc.normal; } } } Теперь самое главное - функции загрузки шкурки: internal void LoadSkins1() { DirectoryInfo di = new DirectoryInfo(@"../../skins/"); // каталог с шкурками skins = new SkinDesc1[di.GetDirectories().Length]; // количество шкурок = количеству подкаталогов int i = 0; // счетчик string colStr = ""; // строчка string[] tsa, tsa2; // массив строковых параметров foreach (DirectoryInfo di2 in di.GetDirectories()) { // для каждого подкаталога skins[i] = new SkinDesc1(); // создать шкурку StreamReader sr = new StreamReader(di2.FullName + "\\skin.txt", System.Text.Encoding.GetEncoding(1251)); // открыть файл описания try { colStr = sr.ReadLine(); // считать строчку tsa = colStr.Split(','); // разбить по запятым на RGB skins[i].transparentKey = Color.FromArgb(Int32.Parse(tsa[0]), Int32.Parse(tsa[1]), Int32.Parse(tsa[2])); // записать цвет прозрачности colStr = sr.ReadLine(); tsa = colStr.Split(','); skins[i].formSize = new Size(Int32.Parse(tsa[0]), Int32.Parse(tsa[1])); // записать размер формы MyControl mc; // объект описания элемента управления while ((colStr = sr.ReadLine()) != "") { // пока строчки не кончаться tsa = colStr.Split(';'); // разбить строку по точке с запятой mc = new MyControl(); // новый объект описания mc.type = Byte.Parse(tsa[0]); // записать тип tsa2 = tsa[1].Split(','); mc.Location = new Point(Int32.Parse(tsa2[0]), Int32.Parse(tsa2[1])); // записать положение tsa2 = tsa[2].Split(','); mc.Size = new Size(Int32.Parse(tsa2[0]), Int32.Parse(tsa2[1])); // записать размер tsa2 = tsa[3].Split(','); mc.bgColor = Color.FromArgb(Int32.Parse(tsa2[0]), Int32.Parse(tsa2[1]), Int32.Parse(tsa2[2])); // записать цвет фона tsa2 = tsa[4].Split(','); mc.fgColor = Color.FromArgb(Int32.Parse(tsa2[0]), Int32.Parse(tsa2[1]), Int32.Parse(tsa2[2])); // записать цвет шрифта try { mc.normal = new Bitmap(di2.FullName + "\" + tsa[5]); } // загрузить картинку нормального состояния catch { mc.normal = null; } // если не получилось - установить null try { mc.highlighted = new Bitmap(di2.FullName + "\" + tsa[6]); } // то же для подсвеченного catch { mc.highlighted = null; } try { mc.pressed = new Bitmap(di2.FullName + "\" + tsa[7]); } // то же для нажатого catch { mc.pressed = null; } tsa2 = tsa[8].Split(','); mc.font = new Font(tsa2[0], float.Parse(tsa2[1]), (FontStyle)Int32.Parse(tsa2[2])); // создать шрифт по параметрам mc.Text = tsa[9]; // записать текст skins[i].controls.Add(mc); // добавить объект описания в коллекцию } } catch { } finally { sr.Close(); } i++; } } и применения: internal void ApplySkin1(int idx) { Controls.Clear(); // убрать все элементы управления с формы TransparencyKey = skins[idx].transparentKey; // установить цвет прозрачности BackColor = TransparencyKey; // фон формы = прозрачности Size = skins[idx].formSize; // установить размер формы for (int i = 0; i ‹ skins[idx].controls.Count; i++) { // для каждого элемента управления из коллекции if (((MyControl)skins[idx].controls[i]).type == 0) { // если элемент - pictureBox PictureBox p = new PictureBox(); // создать p.Margin = new Padding(0); // установить поля = 0 p.BorderStyle = BorderStyle.None; // бордюра нет p.Location = ((MyControl)skins[idx].controls[i]).Location; // установить положение p.Size = ((MyControl)skins[idx].controls[i]).Size; // размер p.BackColor = ((MyControl)skins[idx].controls[i]).bgColor; // фон p.Image = ((MyControl)skins[idx].controls[i]).normal; // картинку p.MouseDown += new MouseEventHandler(drag_mouseDown); // события перетаскивания p.MouseUp += new MouseEventHandler(drag_mouseUp); p.MouseMove += new MouseEventHandler(drag_mouseMove); p.Tag = i; // индекс в коллекции Controls.Add(p); // добавить к форме } else { // если кнопка (любая из трех) Button b = new Button(); // создать b.FlatStyle = FlatStyle.Flat; // сделать плоской b.FlatAppearance.BorderSize = 0; // без бордюра b.FlatAppearance.MouseOverBackColor = skins[idx].transparentKey; // с прозрачным бордюром b.FlatAppearance.MouseDownBackColor = skins[idx].transparentKey; // во всех состояниях b.Margin = new Padding(0); // без полей b.Location = ((MyControl)skins[idx].controls[i]).Location; // расположить b.Size = ((MyControl)skins[idx].controls[i]).Size; // задать размер b.BackColor = ((MyControl)skins[idx].controls[i]).bgColor; // установить цвет фона b.ForeColor = ((MyControl)skins[idx].controls[i]).fgColor; // цвет шрифта b.Font = ((MyControl)skins[idx].controls[i]).font; // шрифт b.TextAlign = ContentAlignment.MiddleCenter; // выравнивание текста b.Image = ((MyControl)skins[idx].controls[i]).normal; // картинку if (((MyControl)skins[idx].controls[i]).type == 1) { // если кнопка 1 b.Click += new EventHandler(button1_Click); // установить нажатие = нажатие кнопки 1 } else if (((MyControl)skins[idx].controls[i]).type == 2) { // аналогично кнопка 2 b.Click += new EventHandler(button2_Click); } else if (((MyControl)skins[idx].controls[i]).type == 3) { // аналогично кнопка 3 b.Click += new EventHandler(button3_Click); } b.Text = ((MyControl)skins[idx].controls[i]).Text; // установить текст b.MouseDown += new MouseEventHandler(mouseDown); // события b.MouseUp += new MouseEventHandler(mouseUp); // смены b.MouseEnter += new EventHandler(mouseEnter); // картинок b.MouseLeave += new EventHandler(mouseLeave); b.Tag = i; // индекс в коллекции Controls.Add(b); // добавить к форме } } currentSkin = idx; // сменить индекс текущей шкурки } Добавим в конструктор вызов этих двух функций: public Form1() { InitializeComponent(); LoadSkins1(); // загрузить шкурки ApplySkin1(0); // применить первую } Запускаем, проверяем: Рыжие кружочки нажимаются и подсвечиваются, за морковные линии можно перетаскивать. Девушка вся перетаскивается, крылышки приподнимаются при наведении. При нажатии на крылышки - программа выходит. Можно было конечно добавить возможность установки фонового изображения для формы, и не маятся с pictureBox, но с таким подходом возможностей чуть больше. Каталог проекта для MS Visual Studio 2005 с примером находится в архиве примеров, подкаталог skins1 для первого метода и skins2 для второго. 6. Перехватчик всех ошибок. В современных программах стало модно делать окошки которые настоятельно рекомендуют отправить отчет, предлагают сохранить работу и перезапустить программу после закрытия. Такое окно появляется во всех приложениях Microsoft, сделанных после 2002 года и еще в очень многих. Если вы хотите сделать что-то подобное, то это делается примерно так: Сначала создадим форму, с одной кнопкой - чтобы только имитировать ошибку: Теперь на кнопку сажаем такой код: private void button1_Click(object sender, EventArgs e) { throw new ArgumentException("Неправильное значение параметра", "index"); } При нажатии - кинуть ошибку о том что параметр index принял недопустимое значение. Теперь идем в файл Program.cs, туда, где функция Main, и переписываем ее: static void Main() { Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException); //отлавливать все ошибки, вышедшие из программы Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Form1 f1 = new Form1(); Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);// задать обработчик ошибок Application.Run(f1); } Теперь опишем функцию обработки ошибок. Будем исходить из того, что у нас будет форма для показа информации об ошибке: static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e) { ApplicationCrashForm cf = new ApplicationCrashForm(); // форма показа информации об ошибке cf.FillData(e.Exception); // заполнить форму информацией if (cf.ShowDialog() == DialogResult.OK) { // если нажали сохранить ((Form1)Application.OpenForms["Form1"]).SaveAs(); // сохранить работу } if (cf.checkBox1.Checked) Application.Restart(); // если галочка перезапустить установлена - перезапустить программу else Application.Exit(); // если нет - просто выйти } Ну собственно, осталось только создать форму показа ошибок: Не забудьте поставить для checkBox1 Modifiers=internal. Теперь опишем код формы: internal void FillData(Exception ex) { StringBuilder sb = new StringBuilder(); FillExceptionInfo(ex, sb); textBox1.Text = sb.ToString(); textBox1.SelectionLength = 0; } private void FillExceptionInfo(Exception ex, StringBuilder sb) { sb.AppendFormat("Произошла ошибка типа {0}\r\n", ex.GetType()); sb.AppendFormat("Объект вызвавший ошибку: {0}\r\n", ex.Source); sb.AppendFormat("Ошибка произошла в методе {0}\r\n", ex.TargetSite); sb.AppendFormat("Основная информация об ошибке: {0}\r\n", ex.Message); sb.AppendFormat("Стек вызова: {0}\r\n\r\n", ex.StackTrace); if (ex.InnerException != null) FillExceptionInfo(ex.InnerException, sb); } Думаю тут все понятно. Последние штрихи - функции нажатия на линки в форме ошибки: private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) { Process.Start("http://www.domain.com/techsupport_forum.cgi"); } private void linkLabel2_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) { StringBuilder sb = new StringBuilder(); sb.Append("mailto:techsupport@domain.com?subject=Program_Bugbody="); string ts = textBox1.Text.Replace("\r\n", "‹br›"); string amp = Uri.HexEscape(''); ts = ts.Replace("", amp); sb.Append(ts); Process.Start(sb.ToString()); } И функцию сохранения работы SaveAs() для Form1 не забудьте сделать. Вот и все. Каталог проекта для MS Visual Studio 2005 с примером находится в архиве примеров, подкаталог exception. 7. Самодельный бекапер. У меня однажды на повестке дня встал вопрос о программе-бекапере, которая будет делать следующие вещи: 1. Копировать все файлы из указанных каталогов, чья дата последнего изменения позднее заданной даты (дня, когда я пересел на ноут). 2. Для уже скопированных файлов - копировать файлы, только если дата изменения позднее, чем у скопированной копии. 3. Каталог для сохранения должно быть можно выбрать и в локальной сети. В очередной раз напоролся: работы было много и я решил что быстрее найду, чем напишу сам... поискал - нашел с три десятка подобных программ. Попробовал одну - не делает всего, что надо, другую - не поддерживает сеть, третью - хочет денег, хотя на сайте сказано "бесплатно"... короче, потеряв час, я решил что быстрее все-таки написать самому. Итак, создаем примерно такое окно. То, что внизу - это progressBar. Дополняем окно backgroundWorker и folderBrowserCatalog. Установим progressBar.Visible = false; Теперь создадим настройки программы. Нам надо будет помнить - каталоги, которые надо спасать; каталог, куда надо спасать; дату, после которой надо спасать. Открываем Settings проекта (Project Properties -› Settings) и создаем такое вот: DirsToSave - это System.Collections.Specialized.StringCollection SinceWhen - System.DateTime Значения пишите любые, но действительные и не оставляйте поля пустыми. Переходим к коду программы. Для начала создадим объект settings: SynchroSaver.Properties.Settings sets; Теперь опишем код загрузки формы - инициализировать backgroundWorker и загрузить настройки. private void Form1_Load(object sender, EventArgs e) { // загрузка формы sets = SynchroSaver.Properties.Settings.Default; // загружаем настройки for (int i = 0; i ‹ sets.DirsToSave.Count; i++) { // для каждого каталога на сохранение listBox1.Items.Add(sets.DirsToSave[i]); // добавить в listBox } textBox1.Text = sets.BackupDir; // написать каталог куда сохранять dateTimePicker1.Value = sets.SinceWhen; // установить дату } Как следствие - пропишем и закрытие формы: private void Form1_FormClosing(object sender, FormClosingEventArgs e) { if (e.CloseReason == CloseReason.WindowsShutDown) { // если Windows закрывается if (backgroundWorker1.IsBusy) { // если программа работает backgroundWorker1.CancelAsync(); // послать отмену } else { // если не работает sets.Save(); // сохранить текущие настройки } } else { // если прогу закрывает не система if (backgroundWorker1.IsBusy) { // если работает e.Cancel = true; // отменить закрытие return; } else { // если не работает sets.Save(); // сохранить настройки } } } Теперь опишем кнопки: Добавить каталог: private void button1_Click(object sender, EventArgs e) { if (folderBrowserDialog1.ShowDialog() == DialogResult.OK) { // если каталог выбрали listBox1.Items.Add(folderBrowserDialog1.SelectedPath); // добавить в listBox } } Убрать каталог: private void button2_Click(object sender, EventArgs e) { if (listBox1.SelectedIndex != -1) { // если каталог выделен listBox1.Items.RemoveAt(listBox1.SelectedIndex); // убрать его из списка } } Обзор... для каталога сохранения: private void button3_Click(object sender, EventArgs e) { if (folderBrowserDialog1.ShowDialog() == DialogResult.OK) { // если каталог выбрали textBox1.Text = folderBrowserDialog1.SelectedPath; // прописать в textBox } } Запуск: проверяем ввод, отключаем элементы управления, подготавливаем к запуску и запускаем... Эта же кнопка будет кнопкой Отмена, если прога уже работает private void button4_Click(object sender, EventArgs e) { if (!backgroundWorker1.IsBusy) { // если прога не работает if (listBox1.Items.Count == 0) { // если каталогов нет return; // вернуться } if (!Directory.Exists(textBox1.Text)) return; // если каталог куда спасать не существует - вернуться DisableControls(); // отключить элементы управления backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork); // назначить event начала работы backgroundWorker1.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged); // назначить event изменения прогресса backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted); // назначить event окончания работы sets.SinceWhen = dateTimePicker1.Value; // изменить дату в настройках на введенную sets.BackupDir = textBox1.Text; // каталог куда спасать тоже sets.DirsToSave.Clear(); // очистить список каталогов for (int i = 0; i ‹ listBox1.Items.Count; i++) { // поштучно sets.DirsToSave.Add(listBox1.Items[i].ToString()); // добавить каталоги в настройки } backgroundWorker1.RunWorkerAsync(); // запустить работника } else { // если прога работает backgroundWorker1.CancelAsync(); // послать отмену } } Ну теперь опишем заданные события для backgroundWorker: Начать работу: void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) { backgroundWorker1.ReportProgress(0); // установить прогресс 0 for (int i = 0; i ‹ sets.DirsToSave.Count; i++) { // для каждого каталога для сохранения BackupDir(sets.DirsToSave[i].ToString(), i * 100 / sets.DirsToSave.Count, 100 / sets.DirsToSave.Count); // спасти каталог if (backgroundWorker1.CancellationPending) { // если послали отмену break; } } backgroundWorker1.ReportProgress(100); // установить прогресс 100 } Изменился прогресс: void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) { progressBar1.Value = e.ProgressPercentage; // установить значение progressBar = прогрессу работника } Работа завершена: void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { EnableControls(); // включить элементы управления } Отключение элементов: отключаем все, кроме кнопки запуск, которую меняем на Отмену private void DisableControls() { button1.Enabled = false; button2.Enabled = false; button3.Enabled = false; progressBar1.Visible = true; listBox1.Enabled = false; textBox1.Enabled = false; dateTimePicker1.Enabled = false; button4.Text = "Cancel"; } Включение элементов: private void EnableControls() { button1.Enabled = true; button2.Enabled = true; button3.Enabled = true; progressBar1.Visible = false; listBox1.Enabled = true; textBox1.Enabled = true; dateTimePicker1.Enabled = true; button4.Text = "RUN"; } Теперь самое главное: Бекап каталога: Поскольку сохранение каталогов требует рекурсии, эта функция будет запускаться для каталогов всех уровней. Для этого и созданы парамеры progrStart - начальный прогресс и progr - доля этого каталога в общем прогрессе: private void BackupDir(string dir, float progrStart, float progr) { DirectoryInfo mdi = new DirectoryInfo(dir); // информация о каталоге DirectoryInfo[] dis = mdi.GetDirectories(); // вложенные папки for (int i = 0; i ‹ dis.Length; i++) { // для каждой вложенной папки BackupDir(dis[i].FullName, progrStart + i * progr / dis.Length, progr / dis.Length); // спасти } FileInfo[] fis = mdi.GetFiles(); // файлы в каталоге for (int i = 0; i ‹ fis.Length; i++) { // для каждого файла if (fis[i].LastWriteTime › sets.SinceWhen) { // если последнее изменение позднее указанной даты if (NeedToCopy(fis[i].FullName)) { // сравнить с бекап версией и если надо копировать CopyFile(fis[i].FullName); // скопировать файл } } } backgroundWorker1.ReportProgress((int)(progrStart + progr)); // отчитаться о прогрессе } Проверка на необходимость копирования: private bool NeedToCopy(string fn) { string fnr = fn; for (int i = 0; i ‹ sets.DirsToSave.Count; i++) { // для каждого каталога на спасение if (fnr.Contains(sets.DirsToSave[i].ToString())) { // если путь файла содержит имя каталога fnr = fnr.Replace(sets.DirsToSave[i].ToString(), sets.BackupDir); // заменить каталог откуда на каталог куда break; // прервать цикл } } if (File.Exists(fnr)) { // если файл существует, т.е. уже скопирован FileInfo fi = new FileInfo(fn); // информация о рабочем файле FileInfo fi2 = new FileInfo(fnr); // информация о спасенном файле if (fi.LastWriteTime › fi2.LastWriteTime) { // если файл был изменен после спасения return true; // вернуть правду } else { // если нет return false; // вернуть ложь } } else return true; // если файл не существует - вернуть правду } Копирование: private void CopyFile(string fn) { string fnr = fn; for (int i = 0; i ‹ sets.DirsToSave.Count; i++) { // то же, что и пред. функция if (fnr.Contains(sets.DirsToSave[i].ToString())) { fnr = fnr.Replace(sets.DirsToSave[i].ToString(), sets.BackupDir); break; } } if (!Directory.Exists(Path.GetDirectoryName(fnr))) { // если каталог не существует Directory.CreateDirectory(Path.GetDirectoryName(fnr)); // создать } File.Copy(fn, fnr, true); // скопировать, с перезаписью } Вот собственно и все. Что сделано неправильно, с точки зрения коммерческого продукта - отмена работает только когда программа переходит от одного главного каталога к другому главному. Что неправильно, с точки зрения "грамотной" программы - имена каталогов не передаются функциям, а те простым перебором находят нужный. Каталог проекта для MS Visual Studio 2005 с примером находится в архиве примеров, подкаталог SynchroSaver.