Как сделать заставку для программы в делфи

Наверно, каждый программист на Дельфи хоть раз хотел создать к какой-нибудь своей программе заставку. В этой статье мы рассмотрим создание заставок в Дельфи. Тому кто умеет работать более чем с одной формой в приложении, будет очень легко это понять. Чтобы не вдаваться в теорию, начнем сразу с практики.

Откройте какое-нибудь свое приложение, к которому вы хотите добавить заставку, или создайте новое (на чистом проще разбираться). Теперь необходимо добавить в наш проект еще одну форму, которая будет заставкой. Для этого нажмите File->New Form и Дельфи создаст вам новую форму. Измените ее размеры как вам хочется.

Потом установите свойство Border Style вашей формы в bsNone (у формы не будет заголовка и системных кнопок), установите свойство Visible в false. Свойтсво Position должно быть poScreenCenter — это значит, что форма появится по центру экрана. И чтобы не перепутать эту форму ни с какой другой задайте ей имя Logo .

Настройка формы заставки произведена, теперь необходимо сделать, чтобы по щелчку мышкой по этой форме или после нажатия клавиши или по истечении 5 секунд форма-заставка закрывалась. Для этого установите на форму Timer, его свойству Interval задайте значение 5000 (форма будет закрываться через 5 секунд). В обработчик события OnTimer напишите всего одно слово: Close;

Создание прозрачной анимированной заставки в delphi

В обработчик события OnClick для формы-заставки напишите тоже самое. Установите свойство формы KeyPreview в true (это делается для того, чтобы при нажатии любой клавиши вначале реагировала форма, а затем тот элемент, который был в фокусе в момент нажатия). А в обработчик события OnKeyPress (для формы-заставки конечно же) опять-таки напишите close;

Форма-заставка готова полностью и теперь необходимо, чтобы она запускалась перед главной формой. Для этого сделайте активной вашу главную форму, перейдите на вкладку Events в Object Inspector’e и выберите событие OnShow. В обработчике этого события надо написать следующее:

Меня иногда спрашивают, чем отличаются процедуры show и showmodal. У них только одно принципиальное различие: если форма открылась методом Showmodal, то пока она не закроется пользователь не сможет взаимодействовать с остальными формами приложения. А если форма была открыта методом Show, то пользователь легко может перейти к любой форме приложения.

Итак, форма-заставка готова. Теперь мы слегка ее усовершенствуем. Добавим такую же штуку, как в формах-заставках Microsoft Office, а именно на форме будет показываться имя пользователя и организация. Для этого разместите на форме-заставке две метки (Label). Первую назовите UserName, а вторую — Organization. Чтобы это сделать мы воспользуемся реестром (тас вообще очень много интересного можно найти).

Теперь откройте обработчик события OnCreate для формы-заставки и объявите там переменную R типа TRegistry, а в раздел Uses всей программы добавьте Registry. Теперь нам нужно создать объект R :

R:=TRegistry.Create;
R.RootKey:=HKEY_LOCAL_MACHINE;

Создание базы данных сотрудники в Delphi — Урок 4 ( Заставка и форма авторизации)

R.OpenKey(‘SOFTWAREMicrosoftWindowsCurrentVersion’, False); //именно здесь эта информация хранится

Теперь необходимо прочитать нужные строки из этого раздела реестра и присвоить их соответствующим меткам:

UserName.Caption:=r.readstring(‘RegisteredOwner’);
Organization.Caption:=r.readstring(‘RegisteredOrganization’);
r.Free; //надо уничтожить этот объект, так как он нам больше не нужен

Таким образом весь этот обработчик должен иметь примерно такой вид:

procedure TLogo.FormCreate(Sender: TObject);
var R:Tregistry;
begin
R:=TRegistry.Create;
R.RootKey:=HKEY_LOCAL_MACHINE;
R.OpenKey(‘SOFTWAREMicrosoftWindowsCurrentVersion’, False);
UserName.Caption:=r.readstring(‘RegisteredOwner’);
Organization.Caption:=r.readstring(‘RegisteredOrganization’);
r.Free;
end;

Ну вот собственно и все что я хотел вам рассказать о заставках. Теперь ваши программы будут выг

лядеть более солидно. Но помните, что при создании небольших, вспомогательных программ, объем которых не превышает килобайт 100-150 заставки лучше не использовать.

Удачи в программировании.

Источник: www.helloworld.ru

Уроки Delphi

Как уже упоминалось в первых уроках, основой Delphi есть язык программирования Object Pascal. В своей основе он содержит так знакомый всему миру и очень популярный язык Pascal. Разумеется, для того, чтобы довольно быстро и без особых проблем изучить Delphi, необходимо знать этот язык. Для начинающих рекомендуется ознакомиться с ним. Потребуется знание элементарных понятий синтаксиса, типов данных, структур модулей программ.

Для непосвященных в азы программирования на Паскале постараюсь в нескольких уроках выдать кратко те самые основы.

Итак, основой любого языка программирования есть команда присваивания и выглядит как двоеточие и знак равенства :=

Здесь сразу нужно оговориться, что знак присваивания указывает на внесение указанной переменной некоторого значения, например:

Где x — переменная.

Переменная это указатель в память, где хранятся данные определенного формата.

Каждый оконный проект в Delphi имеет один текст программы и как минимум один модуль.

Что же такое программа. Она храниться на диске с названием заголовка программы и расширением DPR. Вот ее архитектура:

uses
Forms,
Unit1 in ‘Unit1.pas’ ;

Список подключаемых модулей

Поключаемые файлы ресурсов

Файл программы состоит из заголовка и блока программы. Блок программы включает объявление подключаемых модулей (частей программы), подключаемые ресурсные файлы (иконки, указатели мыши, рисунки), текст программы (создание окон, запуск приложения на выполнение).

Вызвать файл программы на редактирование можно из меню «Project» пунктом «View Source». Во избежание появления ошибок, некорректной работы программы настоятельно не рекомендуется самостоятельно вручную редактировать этот файл. Все необходимые изменения производятся в Delphi автоматически.

Для того, чтобы разбить программу на несколько отдельных задач, которые можно редактировать по отдельности и применяются модули. В Delphi каждое отдельное проектируемое окно имеет свой модуль. Но их в программе может быть гораздо больше.

interface

uses
Windows, SysUtils, Forms;

type
TForm1 = class(TForm)
private
< Private declarations >
public
< Public declarations >
end;

var
Form1: TForm1;

implementation

Заголовки доступных свойств

скрытый раздел свойств

открытый раздел свойств

Подключаемые файлы ресурсов

Вся ваша ручная работа сводится в написание программного кода в автоматически создаваемых процедурах внутри раздела implementation. Весь текст модуля автоматически изменяется при соответствующем изменении состояния проекта. Например, если вы добавили или удалили из проектируемой формы кнопку или переименовываете свойство NAME для любого компонента.

Если переименовать форму Form1 в MainForm, добавить в не компонент Memo1, и задействовать событие OnChange (изменение текста внутри этого компонента) то программный код изменится следующим образом:

unit Unit1;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type
TMainForm = class(TForm) // изменяется описание класса этой формы
Memo1: TMemo; // добавляется компонент Memo1 из класса TMemo
procedure Memo1Change(Sender: TObject); // заголовок процедуры
private
< Private declarations >
public
< Public declarations >
end;

var
MainForm: TMainForm; // задание переменной формы

// из объявленного класса

implementation

procedure TMainForm.Memo1Change(Sender: TObject);
begin
// здесь следует текст реакции на событие изменения текста

// в компоненте Memo1
end;

end.

Примечание: после двойной дроби // следует комментарий.

Как правило программист не выходит за области implementation раздела, а тут самостоятельно не создает процедуры.
Программная оболочка делает это автоматически по мере необходимости и ликвидирует пустые лишние заголовки процедур при сохранении файла модуля.

Для этого сначала отображаем проектируемую форму ChildForm на экран.
Для этого нажимаем комбинацию клавиш Shift+F12 или выбираем пункт «Forms. » в меню «View». В появившемся окне выбираем эту самую форму и нажимаем Ok.

Выделяем компонент Memo1 в проектируемой форме одинарным щелчком мышки. В инспекторе объектов находим свойство этого компонента Lines.
Изменяем это свойство, нажав на кнопку с троеточием в поле с TStrings. Появляется окно String List Editor, в котором надо убрать все буквы, оставив его пустым. Далее нажимаем Ok.

Теперь мы видим в проектировщике формы ChildForm, что компонент Memo1 не содержит никаких строк.

Дальше сделаем дочернее окно нормально-закрываемым. Для этого необходимо выделить компонент ChildForm (саму проектируемую форму). Но поскольку на этой форме расположен компонент Memo1, который имеет размер всей рабочей области формы, сделать визуально нам это не удастся. Поэтому выбираем прямо из инспектора объектов.

В верхней части Object Inspector есть ниспадающий список, в котором нужно выбрать ChildForm. Далее переходим на вкладку событий Events. Находим событие OnClose (закрытие окна) и дважды щелкаем по пустому полю правее. Создается готовый каркас процедуры закрытия окна с заголовком:

procedure TChildForm.FormClose(Sender: TObject; var Action: TCloseAction);

Здесь вносимый в процедуру параметр Action определяет поведение данной формы при закрытии. Он может принимать следующие значения:

caNone — форма не предпринимает никаких действий.

caHide — форма причется от глаз пользователя, но не уничтожается из памяти. Поскольку мы с вами «вручную» (программно) создаем дочернюю форму, то нам нужно ее при закрытии уничтожить из памяти.
caFree — форма закрывается и уничтожается из памяти.
caMinimize — форма минимизируется. Это значение для MDI-дочерних окон установлено по умолчанию.

Пишем внутри созданной процедуры:

Теперь запустите приложение на выполнение (F9) и посмотрите на ее работу.

Дальше организуем довольно сложный на первый взгляд процесс загрузки текстового файла. На самом деле сама загрузка файла делается одной строкой. Немного сложнее организовать выбор этого файла.

Итак, открывается файл при выборе пункта меню «Открыть», которое находится в главной форме. Отображаем проектируемую форму MainForm поверх всех окон (Shift+F12). Устанавливаем в форму компонент OpenDialog. Он находится на палитре компонентов на странице Dialogs.

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

Выделяем его и в инспекторе объектов устанавливаем следующие свойства:

Свойство Title устанавливает заголовок такого окна. Заносим в это свойство строку «Открыть текстовый файл».

Свойство Filter фильтрует список по расширению в названиях файлов. Нажимаем на троеточие в этом свойстве. На экран выводится окно Filter Editor, в котором можно легко задать все возможные маски файлов. В левой части Filter Name пишется отображаемое в фильтре название. В правой части Filter сам фильтр.

Пишем так, как указано на рисунке. Нажимаем на Ok.

Дальше напишем процедуру открытия файла. При выборе соответствующего пункта меню сначала открывается диалоговое окно выбора файла и при успешном выборе создается форма ChildForm, в которой в компонент Memo1 загружается этот файл.

Выбираем пункт меню «Файл» в форме MainForm и выбираем пункт «Открыть». Создается пустая процедура реакции на событие выбора этого меню. В ней пишем:

if OpenDialog1.Execute then // если файл выбран, то выполнять следующее
begin
ChildForm := TChildForm.Create(Self); // создать дочернее окно
ChildForm.Memo1.Lines.LoadFromFile(OpenDialog1.FileName); // загрузить в Memo1 выбранный файл
ChildForm.Caption := OpenDialog1.FileName; // установить заголовок дочернего окна в название файла
end;

Как говорилось выше, знак // и последующий текст набирать необязательно. Он означает комментарий в тексте программы, который никаким образом не влияет на выполнение программы а полезен только для программиста. Комментарий в программе можно отделить либо двумя знаками деления (тогда отделяется только строка от этих знаков до конца) либо фигурными скобками <> (тогда отделяется в комментарий весь текст между ними).

Поскольку команды создания окна, задания заголовка считаются сложным материалом для начинающего программиста, то пока рассматривать подробно их не буду.

Функция Execute для компонента OpenDialog1 вызывает диалоговое окно открытия файла и возвращает значение исхода выбора. Если значение равно true (истинно), то файл был выбран и false (ложно) — пользователь нажал на «Отмена».

Дальше речь пойдет об известном многим окне-заставке, которое появляется при загрузке большинства программ. Может кому-то и пригодится.

Итак, зачем же это окно все-таки нужно? Допустим, вы пишите относительно большую программу, и соответственно ее процесс загрузки занимает весьма продолжительное время, в течениии которого пользователь на экране монитора ничего не видит. Сидит и думает, а запустил ли я эту программу или нет, и пробует снова. Это первая причина. Ну, а остальные — это возможность приукрасить внешний вид, придать солидность, марку фирмы (профессиональности) изготовителя.

Что же в себе содержит окно-заставка? Да все, что угодно. От бесполезной информации, до названия программы, версии продукта, лицензии и контактного телефона.
Лучше всего все это дело организовать в прямоугольный рисунок с максимальным размером 640х480 (минимальное экранное разрешение).Такой пример вы видите выше. И этот рисунок надо разместить в отдельной форме.

Рассмотрим пример. Ваша программа имеет название PROJECT1, главное окно проекта называется FORM1, окно с заставкой FORM2.

У окна Form2 устанавливаем свойства Position в poScreenCenter (располагать это окно посередине экрана), свойство BorderStyle в bsNone (окно без заголовка). Дальше размещаем в этом окне компонент TImage. Загружаем в него изображение через свойство Picture и устанавливаем свойство для рисунка и окна AutoSize в true. Все, рисунок имеет размер всего окна, а размер окна автоматически подстраивается под размер рисунка.

Дальше открываем файл проекта DPR на редактирование из меню «Project» пунктом «View Source».

Там мы видим следующие строки:

Application.Initialize; // инициализация приложения
Application.CreateForm(TForm1, Form1); // создать главное окно
Application.CreateForm(TForm2, Form2); // создать окно-заставку

// дальше могут быть создано много окон в приложении
Application.Run; // запустить приложение

Нам необходимо создать и отображать окно-заставку еще до создания главного окна в памяти и продолжать ее отображение по появления главного окна. Но необходимо обмануть приложение, ведь главным окном является то, что было создано первым.

Application.Initialize; // инициализация приложения
Form2 := TForm2.Create(Application); // создать окно-заставку
Form2.Show; // сделать окно видимым
Form2.Update; // перерисовать окно

//(поскольку приложение еще не запущено, это необходимо делать вручную)
Application.CreateForm(TForm1, Form1); // создать главное окно

// дальше создаются все остальные окна в вашей программе
Form2.Close; // закрыть окно-заставку
Application.Run; // запуск приложения

Если у вас программа изначально такая же маленькая, как эта, то окошко заставки мигнет и пользователь ничего не успеет прочитать. Кроме того, в наш век все постоянно увеличивающихся компьютерных скоростей самая навороченная программа может лет так через 10 запускаться за несколько секунд, что тоже может создать некоторое неудобство для программиста.

Для этого делаем так.

Во-первых, убираем строку Form2.Close; из файла проекта. Дальше устанавливаем свойство FormStyle окна Form2 в fsStayOnTop (окно будет всегда отображаться поверх всех, что позволит пользователю любоваться им даже после появления главного окна). Устанавливаем в окно Form2 компонент TTimer. Устанавливаем свойство Interval в минимальный промежуток видимости этого окна. Например 3000 — 3 секунды. Событие срабатывания таймера:

procedure TForm2.Timer1Timer(Sender: TObject);
begin
Timer1.Enabled:=false; // заблокировать дальнейшее применение таймера
if Form1.Visible then Close; // если главное окно уже видно, то закрыть окно-заставку
end;

Эта часть программы имеет пользу только, если прошло три секунды, уже на экране есть главное окно и необходимо закрыть заставку. А если прошло более трех секунд и только тогда появилось главное окно, то заставка закрывается сразу. Для этого событие OnShow для главного окна Form1 содержит только одну строчку:

procedure TForm1.FormShow(Sender: TObject);
begin
if not Form2.Timer1.Enabled then Form2.Close; // если таймер уже отключен, то закрыть

// окно-заставку. Если оно уже закрыто, то ничего не происходит
end;

Теперь пользователь может наблюдать одно и то же в момент каждого запуска.

Но и этого однообразия тоже можно избежать, загружая необходимый рисунок из файла. Тем более, всегда и всем рекомендую отделять все рисунки от исполняемого EXE файла. Загружаем растровый рисунок в компонент Image1 в момент создания окна.

procedure TForm2.FormCreate(Sender: TObject);
begin
if FileExists(‘splash.gif’) then // если файл с рисунком есть в текущем каталоге
try
Image1.Picture.LoadFromFile(‘splash.gif’); // загрузить рисунок
except
MessageDLG(‘Ошибка загрузки рисунка’,mtError,[mbOk],0); // если загрузка рисунка

// не удалась, то выводится сообщение об ошибке
end;
end;

Далее скажу, что для действительно огромных программ с большим количеством компонентов можно организовать что-то наподобие процесса загрузки Corel, где отображено инициализации приложения, создания ядра системы и т.п. бесполезную информацию. Это освобождает пользователя от немного занудного лицезрения одной и той-же картинки, инстинктивно привлекая внимание к движущейся части. Пользователь как-бы совместно переживает весь процесс загрузки, осмысливается понять такие тяжело доступные понятия, как например «создание контейнера баз данных».

Для этого необходимо установить в форму компонент метки, например TLabel и в нужных местах файла проекта менять ее текст.

Form2.Label1.Caption:=’создание главного окна’;

Application.CreateForm(TForm1, Form1);
Form2.Label1.Caption:=’создание окна Form3′;

Еще можно и ProgressBar привязать. Тогда вы получите действительно живую и изначально, еще до самого запуска, навороченную программу. Но как известно, важна не только обертка, но еще и начинка.

Источник: delphilessons.blogspot.com

DelphiComponent.ru — бесплатно видеоуроки по Delphi, статьи, исходники

Форма-заставка ( splash screen ) часто используется при загрузке больших программ для того, чтобы развлечь пользователя интересной картинкой, сообщить ему полезную информацию о программе, об адресах и сайтах производителя, наконец, призвать к регистрации программы. Вы, конечно, много раз видели такие заставки — они появляются при установке про­грамм и запуске MS Word , Corel Draw , Adobe Photoshop или Delphi.

Вы и сами можете включить в свой проект заставку ничуть не хуже любой «фирменной».

Возьмём за основу нашего проекта познавательную программу, с помощью которой мы успешно вычисляли жирность человеческого тела. Загрузите её в Delphiи скопируйте все файлы в новую папку Plot- на этот раз мы займёмся расчётом плотности человеческого тела (на самом деле — удель­ного веса, но для практических нужд всё едино).

Она близка к плотности воды (1 г на куб. см) и зависит от соотношения количества жира (плотность 0,890 г на куб. см) и мускулов (плотность 1,100 г на куб. см). Формула для подсчёта средней плотности человеческо­го тела такова:

p= (8,90 xzh+ 11 х (100 — zh)) г/см3.

Легко видеть, что в интерфейсе предыдущей программы нужно сделать минимальные изменения:

Свойство Captionформы — Плотность тела Captionметки Label2 — Плотность тела (г/куб.см) =

Name lblZhir — IblPlot,а её Caption — 1.05.

Остальные элементы на форме — те же, что и раньше

Естественно, придётся поработать и с кодом модуля формы. ле private нужно объявить процедуру, вычисляющую плотность тела:

private procedure Plot;

Внимательный читатель должен был заметить, что до этого нужные зна­чения вычислялись в функции и затем возвращались в вызывающую её процедуру. Но ещё более внимательный читатель, безусловно, обратил внимание и на то, что дальше они использовались совершенно одинаково — просто выводились на экран. Приходилось одни и те же действия повто­рять в каждой процедуре. На этом можно сэкономить — будем показывать вычисленное значение там же, где мы его вычисляем. И так как теперь возвращать ничего не нужно, то функцию следует превратить в процеду­ру:

//ВЫЧИСЛИТЬ ПЛОТНОСТЬ ТЕЛА procedureTForml.Plot; var v, zh, p: single; begin //вычислить жирность тела: if RadioGroup1.ItemIndex= 0 then begin //- мужской пол v:= (rost*3 — 450 + age) * 0.25 + 45; zh:= (ves — v) / ves * 100 + 15 end else begin //- женскийпол v:= (rost*3 — 450 + age) * 0.225 + 40.4; zh:= (ves — v) / ves * 100 + 22 end; //скорректировать значения: if zh < 0 then zh:= 0; if zh>100 then zh:= 100; //вычислить плотность тела: p:= 8.90 * zh + 11 * (100 — zh); p:= p / 1000; lblPlot.Caption:= copy(floattostr(p),1,4); end;

Вам нужно только добавить выделенные строки, чтобы получить достой­ный результат. Математике вас, конечно, учить не надо, а касательно по­следней строки можно кое-что сказать: в ней число p преобразуется в строку, из которой выделяются только первые 4 знака, чтобы избавиться от длинной вереницы совершенно бесполезных цифр.

По понятным причинам (беда, если вы их не поняли!) все строчки

//вычислить жирность: lblZhir.Caption:= inttostr(round(zhir))

следует заменить строчками:

//вычислить плотность: Plot

Запускайте на радость ближним своим новое приложение и проверяйте, утонут ли они в воде (пресной), как и подобает культурному человеку, или будут плавать на поверхности — подобно пресловутому батончику Milky Way . Только не удивляйтесь, что никакой заставки вы не увидели — её и нет.

Если жажда новизны ещё не оставила вас, то давайте продолжим мудрить в области программирования. Прежде всего, добавьте к проекту новую пу­стую форму (о том, как это сделать, говорилось уже много раз), назовите ее frmSplash (или как угодно по-другому) и сохраните проект на диске.

У сплаш-формы свойство BorderStyle нужно установить в bsNone , чтобы убрать полосу заголовка вместе с кнопками. Размеры и оформление фор­мы могут быть любыми. Неплохо смотрится подходящая картинка в рам­ке, для которой годится компонент Panel (найдите его в Палитре компо­нентов!) со свойствами:

Align = alClient Bevellnner = bvLowered Color = clSilver

и компонент Bevel (для горизонтальной полоски под рисунком) со стра­ницы Additional :

Left= 0 Height= 2 Style= bsRaised

На панель поместите компонент Image , а в него загрузите заранее приго­товленную картинку. Для прояснения ваших намерений подпишите кар­тинку (компонент Label ). В итоге в окне Конструктора формы вы увидите такую заставку для вашей программы:

Так как большинство ваших программ будет загружаться настолько быст­ро, что заставка успеет только мелькнуть на экране, то нам следует поза­ботиться о продлении её бренного существования. Отмерять срок её жиз­ни удобно с помощью компонента Timer . Щёлкните дважды на его значке:

в Палитре компонентов, и он появится на форме.

Ещё одна особенность форм-заставок состоит в том, что их нужно созда­вать самостоятельно, а не автоматически. Поэтому выполните команду Главного меню Project > Options и в диалоговом окне Project Options , на странице Forms выделите название формы-заставки в левом списке и, нажав кнопку 0, перенесите его в правый список Available Forms.

Ваша форма не будет создаваться автоматически при запуске про­граммы, теперь это ваша забота.

А где вы должны сделать это? При создании главной формы? — Но заставка должна появиться до того! И вот тот редкий случай, когда придётся «лезть» в файл проекта. Выполните команду Главного меню Project > View Source , файл проекта откроется в окне Редактора кода. Допишите в него выделенные строчки:

program Project1; uses Forms, Unitl in ‘Unitl.pas’ , Unit2 in ‘Unit2.pas’ ; begin frmSplash := TfrmSplash.Create(Application); frmSplash.Show; frmSplash.Update; Application.Initialize; Application.CreateForm(TForm1, Form1); frmSplash.Hide; frmSplash.Free; Application.Run; end.

Смысл их действия таков. Создаём форму-заставку и отрисовываем её, чтобы она появилась на экране. Затем выполняем стандартные операции по инициализации приложения и, когда всё готово к его запуску, убираем форму-заставку с экрана и выгружаем её из памяти компьютера (и из сво­ей собственной).