Clomosy Docs - User contributions [en]

Odd

2025-01-08T11:56:48Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Odd(X: Integer): Boolean;
</div>

The Odd function returns true if the given Number is odd (remainder of 1 when divided by 2).

<b>Example</b><br>

<pre>
var
i : Integer;

{

for (i = 1 to 9)
if (Odd(i)) ShowMessage('Odd number :'+IntToStr(i));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Odd number : 1<br>
Odd number : 3<br>
Odd number : 5<br>
Odd number : 7<br>
Odd number : 9
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Odd Using in Clomosy - Clomosy Docs}}
{{#seo:|description=The Odd function in Clomosy determines whether a given number is odd, providing a simple and efficient way to handle such checks in your application.}}

TclLabel

2025-01-08T11:55:25Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewLabel(AComponent: TCLComponent; xName, xCaption: string): TclLabel;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined label should be written.<br>

<span style="color:blue"><b>xCaption</b></span> : You can enter the chart title here.<br>

It creates a text label used to provide explanations or information in the user interface. TclLabel is preferred for labeling other components on the form or providing information to the user. For example, explanations such as "Username" or "Password" can be displayed next to an input field.<br>

The features and usage are provided in the table below.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclLabel || Label1 : TclLabel; || A variable belonging to the TclLabel class is created.
|-
|AddNewLabel || Label1 = MyForm.AddNewLabel(MyForm,'Label1','Test Label Caption'); || A new TclLabel is added to the form.
|-
|Width || Label1.Width = 150; ||Allows adjusting the width of the label.
|-
|Height || Label1.Height = 50; ||Allows adjusting the height of the label.
|-
|Align || Label1.Align = alTop; ||With the Align parameter, you can specify where you want our component to be aligned in the form. This parameter has multiple positioning properties. See the [[Object_Properties#Align | page]] to learn about these features.
|-
|Margins || Label1.Margins.Left = 50; // Right, Top, Bottom ||With the Margins parameter, you can give margins at any scale from the right, left, bottom, top.<br>[[File:TclLabelMargins.png|frameless|200px]]<br><br>
|-
|TextSettings || Label1.StyledSettings = ssFamily;<br>Label1.TextSettings.FontColor = clAlphaColor.clHexToColor('#8a067c');<br>Label1.TextSettings.Font.Size = 20;<br>Label1.TextSettings.Font.Style = [fsItalic]; //[fsItalic,fsUnderline] || Text formatting is performed in the component. To see the usage, see [https://www.docs.clomosy.com/index.php/Object_Properties#Text_Settings page].
|-
|Text || Label1.Text = 'Label's Text'; || It represents the text within the component. The text entered by the user or set by the program is managed through this property.
|-
|Caption ||Label1.Caption = 'Button Caption'; || It represents the text displayed on the component. The Caption specifies the textual label that the component presents to the user.
|}
</div>

<b>Example</b><br>
<pre>
var
MyForm:TclForm;
testLabel : TclLabel;

{
MyForm = TclForm.Create(Self);
testLabel= MyForm.AddNewLabel(MyForm,'testLabel','Test Label Caption');
testLabel.StyledSettings = ssFamily;
testLabel.TextSettings.Font.Size=20;
testLabel.Align = alCenter;
testLabel.Margins.Left= 50;
testLabel.Margins.Top= 10;
testLabel.Height = 50;
testLabel.Width = 150;

MyForm.Run;
}
</pre>

<b>Output:</b><br>
[[File:Label.png|frameless|450px]]<br>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclLabel Using in Clomosy- Clomosy Docs}}
{{#seo:|description=TclLabel creates text labels for UI, perfect for labeling components or displaying information like 'Username' or 'Password' near input fields.}}

Ask

2025-01-08T11:54:06Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Clomosy.Ask(var AskMessage:String): Boolean;
</div>

The "Ask" function is commonly used in Clomosy programming to display a dialog box where you can request user confirmation. You can use this function to ask a question or present options to the user.<br>

By using "Clomosy.Ask," you can input a specific question. If the "Yes" button is clicked, the function returns a value of true. Otherwise, it returns false, allowing you to perform the desired operations.<br>

<div class="alert alert-danger" role="alert" data-bs-theme="light">
Ask Method Supported Only For Windows. You can use [[AskAndCall | AskAndCall]].
</div>

<b>Example</b><br>

<pre>
{
if Clomosy.Ask('Do you like Clomosy?')
ShowMessage('Yes');
else
ShowMessage('No');
}
</pre>

<h2> See Also </h2>
* [[System_Library#Input-Output_Functions | Input Output Functions]]
{{#seo:|title=Ask Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Clomosy.Ask shows a confirmation dialog, returning true if 'Yes' is clicked, otherwise false. For cross-platform use, switch to AskAndCall.}}

Code Examples

2025-01-08T11:49:45Z

ClomosyAdmin:

{{#seo:|description=Practical, ready-to-use snippets to accelerate your mobile app development. Explore Code Examples in Clomosy Docs!}}

InputQuery

2025-01-08T11:49:16Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function InputQuery(const Caption, Prompt: string; var UserValue: string):Boolean;
</div>

The InputQuery function displays a simple dialog with the Caption and Prompt message provided. Prompts the user to enter data in a text box in the dialog. If the user presses OK, the entered data is stored in the UserValue variable and the return value is True. If the user cancels the dialog, the return value is False and all entered data is lost.<br>

Use to prompt the user for simple data such as name.<br>

<div class="alert alert-danger" role="alert" data-bs-theme="light">
It is used on Windows and iOS operating systems.
</div>

<b>Example</b><br>

<pre>
var
valueName : string;
{
repeat
if not InputQuery('Project', 'Please type your name', valueName)
ShowMessage('User cancelled the dialog');
until valueName <> '';

ShowMessage('Hello '+valueName);
}
</pre>

<b>Output:</b><br>
[[File:InputQueryExample.png|frameless|400px]]

<h2> See Also </h2>
* [[System_Library#Input-Output_Functions | Input Output Functions]]
{{#seo:|title=InputQuery Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the InputQuery function in Clomosy to display a dialog box for user input, storing the response in a variable for simple data collection.}}

ClStrToLan

2024-12-24T15:17:11Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function clStrToLan(const S:String):String;
</div>

The clStrToLan function operates based on the language setting of the device where the application is being used. It processes by using the vertical bar '|' as a separator. The sentence on the left side of the separator is defined in English, while the one on the right side is defined in Turkish.<br>

<b>Example</b><br>
<pre>
var
S : String;

{
S = clStrToLan('Ok|Tamam');
ShowMessage(S);
}
</pre>

<b>Output:</b><br>
If the device's language is Turkish;<br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Tamam
</div>
If the device's language is English;<br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Ok
</div>

<h2> See Also </h2>
* [[System_Library#Cl_Utilities_Functions | Cl Utilities Functions]]
{{#seo:|title=ClStrToLan Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how the clStrToLan function in Clomosy adapts text to the device's language settings, supporting English and Turkish localization.}}

StrToDateTime

2024-12-24T15:16:45Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function StrToDateTime(const S: string):TclDateTime;
</div>

The StrToDateTime function attempts to convert a date plus time as a string S into a TclDateTime value. The first, date part of the string must adhere to the format of the ShortDateFormat value, and use the DateSeparator character to separate the day, month and year values.<br>

The second, time part, separated by a blank from the date must adhere to the format of the LongTimeFormat value, and use the TimeSeparator character to separate the hour, minute and second values.<br>

The default format is day.month.year hour:minute:second, where :

:The day must be 1..31 (depending on month/year)
:The month must be 1..12
:The year must be 0..9999 (optional)
:The hour must be 0..23
:The minute must be 0..59 (optional)
:The second must be 0..59 (optional)

<b>Example</b><br>
{{#seo:|description=Learn how the StrToDateTime function converts date and time strings into TclDateTime format in Clomosy, with customizable formats and practical examples.}}
<pre>
var
myDateTime : TclDateTime;

{

myDateTime = StrToDateTime('23.02.75 12');
ShowMessage('23.02.75 12 = '+DateTimeToStr(myDateTime));

myDateTime = Now;
ShowMessage('Now = '+DateTimeToStr(myDateTime));

}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
23.02.75 12 = 23.02.1975 12:00:00<br>
Now = 28.02.2023 14:50:56
</div>

<h2> See Also </h2>
* [[System_Library#Type_Conversion_Functions | Type Conversion Functions]]
{{#seo:|title=StrToDateTime Using in Clomosy - Clomosy Docs}}

Chr

2024-12-24T15:16:23Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Chr(X: Byte) : Char;
</div>

Returns the character for a specified ASCII value.<br>

Chr returns the character with the ordinal value (ASCII value) of the byte-type expression, X. The Byte parameter is an unsigned integer value large enough to represent a character. Word or UInt16 is also appropriate, because now that the string type is Unicode, a character is represented by two bytes. <br>

<b>Example</b><br>
<pre>
var
tab : char;
crlf : string;

{
// Show the use of Chr
tab = Chr(124);
crlf = Chr(13)+Chr(10);
ShowMessage('Hello '+tab+' World');
ShowMessage('Hello'+crlf+'World');
}
</pre>

<b>Output:</b>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Hello | World<br>
Hello<br>
World
</div>

<h2> See Also </h2>
* [[System_Library#String_Functions | String Functions]]
{{#seo:|title=Chr Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Explore the Chr function in Clomosy to convert ASCII values into characters, with examples demonstrating its use in string manipulation and formatting.}}

TclEdit

2024-12-24T15:15:59Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewEdit(AComponent: TCLComponent; xName, xPromptText: string): TclEdit;
</div>

<span style="color:blue"><b>AComponent</b></span> : The parent object of the defined component must be specified.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined TclEdit object must be written.<br>

<span style="color:blue"><b>xPromptText</b></span> : A hint or message to be displayed when the Text property is empty.<br>

The TclEdit component is a text box used to allow users to enter or edit text on a form. When placed on the form, the TclEdit component creates an area where users can input the required information. For example, it can be used as a field for entering a username or password.<br>

The features and usage are provided in the table below.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclEdit || Edit1 : TclEdit; || A variable belonging to the TclEdit class is created.
|-
|AddNewEdit ||Edit1 = Form1.AddNewEdit(Form1,'Edit1','Test Edit Message'); || A new Edit component is added to the form.
|-
|Width || Edit1.Width = 150; ||Allows adjusting the width of the edit component.
|-
|Height || Edit1.Height = 50; ||Allows adjusting the height of the edit component.
|-
|Align || Edit1.Align = alTop; ||With the Align parameter, you can specify where you want our component to be aligned in the form. This parameter has multiple positioning properties. See the [[Object_Properties#Align | page]] to learn about these features.
|-
|Margins || Edit1.Margins.Left= 100; // Right, Top, Bottom ||With the Margins parameter, you can give margins at any scale from the right, left, bottom, top.<br>[[File:TclEditMargins.png|frameless|200px]]
|-
|StyledSettings || Edit1.StyledSettings = ssFamily; || You may want to change the appearance of the text on the label. In order to make these changes, it is necessary to activate the feature.
|-
|Size ||Edit1.TextSettings.Font.Size = 20; || It is used to adjust the text size.
|-
|FontColor || Edit1.TextSettings.FontColor = clAlphaColor.clHexToColor('#8a067c'); || It is used to set the text color.
|-
|HorzAlign || Edit1.TextSettings.HorzAlign = 1; || The property controls the horizontal alignment of text. The possible values for HorzAlign are:<br>
* 0: Aligns the text to the center.
* 1: Aligns the text to the left.
* 2: Aligns the text to the right.
|-
|VertAlign|| Edit1.TextSettings.VertAlign = 1; || The property controls the vertical alignment of text. The possible values for VertAlign are:<br>
* 0: Aligns the text to the center.
* 1: Aligns the text to the top.
* 2: Aligns the text to the bottom.
|-
|clTypeOfField || Edit1.clTypeOfField = taFloat; (taString) ||When you click Edit, you can type all the characters (such as numbers, symbols, letters) you want in a text. You can restrict the characters you can write in the text. You can do this with the "clTypeOfField" command. You can define this command as "taFloat - taString".
taFloat; Only numbers and comma characters can be written. taString; All characters can be written. (numbers, symbols, letters)
|-
|ReadOnly ||Edit1.ReadOnly = True; || It can be used if you want to prevent writing on the edit component.
|-
|Password ||Edit1.Password = False; || It is used to hide the text entered by the user.
|-
| MaxLength ||Edit1.MaxLength = 5; || To allow the user to restrict the character input for an edit component, you can use the MaxLength property. In the example, only 5 characters can be entered into the component.
|}
</div>

<b>Example</b><br>
<pre>
var
MyForm:TclForm;
testEdit : TclEdit;

{
MyForm = TclForm.Create(Self);
testEdit= MyForm.AddNewEdit(MyForm,'testEdit','Write something');
testEdit.TextSettings.Font.Size=70;
testEdit.Align = alTop;
testEdit.Margins.Top= 10;
testEdit.Height = 50;
testEdit.Width = 150;

MyForm.Run;

}
</pre>

<b>Output:</b><br>
[[File:Edit.png|frameless|450px]]<br>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
{{#seo:|title=TclEdit in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover TclEdit in Clomosy for customizable text input fields with adjustable alignment, font, and input restrictions.}}

Sin

2024-12-24T15:15:29Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Sin(const X: Extended): Extended;
</div>

The Sin function is a mathematical function giving the Sine value of a number value given radians.<br>

<b>Example</b><br>

<pre>
const
PI = 3.14;

var
floatValue : float;

{

floatValue = Sin(PI/6);
ShowMessage('Sin(PI/6) = '+FloatToStr(floatValue));

}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Sin(PI/6) = 0,499770102643102
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Sin Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the Sin function in Clomosy to calculate the sine of a given angle in radians, with examples demonstrating its mathematical applications.}}

GenerateRandom

2024-12-24T15:15:07Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
clMath.GenerateRandom(value1,value2:Integer):Integer
</div>

This function is a custom function used on the Clomosy platform. It is employed to generate a random number between two numerical values. The randomly generated number within the function is inclusive of the first parameter but exclusive of the last parameter.<br>

<b>Example</b><br>
In the example, when the program is executed, a random number between 10 and 20 will be generated.<br>

<pre>
var
NumberOfPredictions : Integer;

{
NumberOfPredictions = clMath.GenerateRandom(10,20);
ShowMessage('The generated number: '+IntToStr(NumberOfPredictions));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
The generated number: 10
</div>

<h2> See Also </h2>
* [[ClMath | ClMath]]
{{#seo:|title=GenerateRandom in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn to generate random numbers using the clMath.GenerateRandom function in Clomosy.}}

AssignFile

2024-12-24T15:14:30Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
procedure AssignFile(var FileHandle TextFile; const FileName string);
</div>

It is used to associate a file variable with a file name, enabling the program to interact with a specific file.<br>
The `AssignFile` function creates a file variable and associates it with the specified file name.<br>
The function takes two parameters: the first parameter is the variable corresponding to the created `TextFile` object, and the second parameter is the name of the file to be created.<br>

In both cases, when the file is opened by Append, Reset or ReWrite, it is assumed to be in the current directory.

<div class="alert alert-warning" role="alert" data-bs-theme="light">
In the Clomosy Learn application, the file path should be specified as follows for saving files within the project directory.<br>
AssignFile(FileHandle, <b>Clomosy.AppFilesPath</b>+'TaskList.txt');
</div>

<b>Example</b><br>
<pre>
var
myFile : TextFile;

{
// Try to open the Test.txt file for writing to
AssignFile(myFile, Clomosy.AppFilesPath+'TaskList.txt');
ReWrite(myFile);

ShowMessage('The file is added to the directory where the exe is located.');

// Write a couple of well known words to this file
WriteLn(myFile, 'Task 1');
WriteLn(myFile, 'Task 2');
ShowMessage('Lines have been added to the file.');
// Close the file
CloseFile(myFile);
}
</pre>

<b>Output:</b><br>
After the file has been saved, it appears as follows.<br>

[[File:AssignFileExample.png|frameless|500px]]<br>

<h2> See Also </h2>
* [[File_Handling | File Handling]]
{{#seo:|title=AssignFile in Clomosy - Clomosy Docs}}

Abs

2024-12-24T15:13:50Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Abs(X: Integer): Integer; overload;<br>
function Abs(X: Real): Real; overload;
</div>

Returns an absolute value.<br>
Abs returns the absolute value of the argument, X.<br>
X is an integer-type or real-type expression.

<b>Example</b><br>
<pre>
var
i : Integer;

{
i = -1235;
ShowMessage('Before: '+ IntToStr(i));
//The absolute value of i is taken and put back to i.
i = Abs(i);
ShowMessage('After: '+IntToStr(i));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Before: -1235<br>
After: 1235
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Abs Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the Abs function in Clomosy to find the absolute value of integers and real numbers, with examples and practical usage tips.}}

TclProPanel

2024-12-24T15:13:23Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewProPanel(AComponent: TCLComponent; xName: string): TclProPanel;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined panel should be written.<br>

Used to group and manage other components within a specific area on the form, TclProPanel allows developers to allocate a distinct section in the user interface where other components (such as buttons, text boxes, labels, etc.) can be placed. This makes it easier to control the layout and appearance of components on the form.<br>

<div class="alert alert-info" role="alert" data-bs-theme="light">
Refer to the [[TclPanel]] page for standard panel usage.
</div>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclProPanel || ProPanel1 : TclProPanel; || A variable belonging to the TclPanel class is created.
|-
|AddNewProPanel ||ProPanel1 = Form1.AddNewProPanel(Form1,'ProPanel1'); || A new TclProPanel is added to the form.
|}
</div>

In addition to the features of a standard panel, TclProPanel offers new and advanced features, which we will explain in detail below.<br>

<div class="row">
<div class="col-lg-6">
<div class="card d-flex flex-column justify-content-start gap-1 mb-3 h-100" style="padding: 3;">
<div style="font-size: 16px;font-weight: bold;text-align:left;">
clProSettings Properties
</div>
<div style="font-size: 14px;font-weight: normal;text-align:justify; max-width: 350px;">
<li>BorderColor</li>
<li>BorderWidth</li>
<li>BackgroundColor</li>
<li>IsTransparent</li>
<li>IsFill</li>
<li>IsRound</li>
<li>RoundHeight</li>
<li>RoundWidth</li>
</div>
</div>
</div>
<div class="col-lg-6">
<div class="card d-flex flex-column justify-content-start gap-1 mb-3 h-100" style="padding: 3;">
<div style="font-size: 16px;font-weight: bold;text-align:left;">
SetupComponent Properties
</div>
<div style="font-size: 14px;font-weight: normal;text-align:justify; max-width: 350px;">
<li>Width</li>
<li>Height</li>
<li>PositionX</li>
<li>PositionY</li>
<li>Align</li>
<li>BackgroundColor</li>
<li>MarginTop</li>
<li>MarginBottom</li>
<li>MarginRight</li>
<li>MarginLeft</li>
<li>RoundHeight</li>
<li>RoundWidth</li>
<li>BorderColor</li>
<li>BorderWidth</li>
</div>
</div>
</div>
</div>
<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
To learn the purpose and usage of the <b>SetupComponent</b> and <b>clProSettings</b> properties, please refer to [[Pro Object Properties| the page]].
</div>

<b>Example</b><br>

For clProSettings:<br>
<pre>
Var
Form1:TclForm;
ProPanel1 : TclProPanel;

{
Form1=TclForm.Create(self);
ProPanel1=Form1.AddNewProPanel(Form1,'ProPanel1');
ProPanel1.Align = alCenter;
ProPanel1.Width = 200;
ProPanel1.Height = 280;
ProPanel1.clProSettings.BorderColor = clAlphaColor.clHexToColor('#fabd2');
ProPanel1.clProSettings.RoundHeight = 10;
ProPanel1.clProSettings.RoundWidth = 10;
ProPanel1.clProSettings.BorderWidth = 2;
ProPanel1.clProSettings.IsFill = True;
ProPanel1.clProSettings.IsRound = True;
ProPanel1.SetclProSettings(ProPanel1.clProSettings);

Form1.Run;
}
</pre>

For SetupComponent:<br>
<pre>
Var
Form1:TclForm;
ProPanel1 : TclProPanel;
{
Form1=TclForm.Create(self);
ProPanel1=Form1.AddNewProPanel(Form1,'ProPanel1');

clComponent.SetupComponent(ProPanel1,'{
"Align" : "Center",
"Width":200,
"Height":280,
"BorderWidth":2,
"BorderColor":"#fabd2",
"RoundHeight":10,
"RoundWidth":10
}');
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Pro Object Properties]]
* [[Object Properties]]
{{#seo:|title=TclProPanel Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover TclProPanel in Clomosy for advanced UI grouping, customization, and flexible layouts.}}

TclGameForm

2024-12-24T15:12:39Z

ClomosyAdmin:

TclGameForm is a customized game form. Unlike the TclForm class, it has the following features:<br>

* Animation
* Sound effects

Before using these features, the form must be initialized.<br>
An object of the TclGameForm class should be defined.
<pre>
var
GameForm1:TclGameForm;
</pre>

The defined object must be created using the "Create" function.<br>
<pre>
{
GameForm1 = TCLGameForm.Create(Self);
GameForm1.Run;
}
</pre>

<div class="alert alert-ligth border border-3 border-warning rounded-5 p-4 shadow-sm" role="alert">
<strong>NOTE : AddGameAssetFromUrl</strong><br> It is a function used to download an asset from a URL and include it in your application. This function is used to download a file (for example, an image or a sound file(.wav)) from the internet and save it to the file system of the project being used.
<div class="alert alert-warning" role="alert" data-bs-theme="light">
NOTE: To check if the image has been saved to the file, you can write Clomosy.AppFilesPath in the project to learn the file path extension. (Check the file on Windows.)
</div>
<b> Use of:</b>
<pre>
GameForm1.AddGameAssetFromUrl('https://www.clomosy.com/game/assets/Tank.png');
</pre>
After adding the images, these images can be transferred to a component (TclProImage, TclImage). The transfer method is as follows:<br>
<pre>
Image1.clSetImage('Tank.png'); //Image1:TclIamge
</pre>
</div>

<h2> Animation </h2>
It is an effect created by displaying animated images and stationary objects as if they were moving. Essentially, a motion effect is created by quickly displaying a series of image or object frames.<br>

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
<strong>NOTE:</strong><br>
You can find the details of advanced animation features [[TclBitmapListAnimation|here]].
</div>

The features and usage are provided in the table below.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|AnimationWidth ||GameForm1.AnimationWidth = 75; || The width of the animation is adjusted.
|-
|AnimationHeight ||GameForm1.AnimationHeight = 75; || The height of the animation is adjusted.
|-
|AnimationCount ||GameForm1.clAnimateBitmap.AnimationCount = 9; || The number of animations is specified by the number of parts into which the visual is divided.
|-
|AnimationRowCount ||GameForm1.clAnimateBitmap.AnimationRowCount = 3; || The number of animation rows is specified by the number of rows into which the visual is divided.
|-
|Delay ||GameForm1.clAnimateBitmap.Delay = 10; || The transition time between visuals is specified.
|-
|Duration ||GameForm1.clAnimateBitmap.Duration = 2; || The animation duration is adjusted.
|-
|clAnimation ||GameForm1.clAnimation(Random() * MyGameForm.clWidth, Random() * MyGameForm.clHeight, 20, 'Explosion.png'); || It is used to activate the animation on the screen. This property takes 4 parameters. The 1st parameter specifies the x position, the 2nd parameter specifies the y position, the 3rd parameter specifies the rotation angle, and the 4th parameter represents the animation image.<br>
In the example, Random() is used to determine a random position.
|}
</div>

<b>Example</b><br>
<pre>
var
MyGameForm:TclGameForm;
BtnRandomFire:TclButton;

void BtnRandomFireClick;
var
i:Integer;
{
MyGameForm.AnimationWidth = 75;
MyGameForm.AnimationHeight = 75;
MyGameForm.clAnimateBitmap.AnimationCount =9;
MyGameForm.clAnimateBitmap.AnimationRowCount=3;
MyGameForm.clAnimateBitmap.Delay = 10;
MyGameForm.clAnimateBitmap.Duration = 2;
For (i = 0 to 5)
{
MyGameForm.clAnimateBitmap.Delay = Random()*10;
MyGameForm.clAnimation(Random() * MyGameForm.clWidth, Random() * MyGameForm.clHeight, 20, 'Explosion.png');
}
}

{
MyGameForm = TclGameForm.Create(Self);
MyGameForm.AddGameAssetFromUrl('https://www.clomosy.com/game/assets/Explosion.png');

BtnRandomFire= MyGameForm.AddNewButton(MyGameForm,'BtnRandomFire','RANDOM FIRE');
MyGameForm.AddNewEvent(BtnRandomFire,tbeOnClick,'BtnRandomFireClick');
BtnRandomFire.Align = alBottom;

MyGameForm.Run;
}
</pre>

<h2> Sound Effects </h2>

It is used when you want to trigger an event, alert messages, or anywhere you want to use sound in your applications.<br>
To use the desired sound, it must be included in the project.<br>

The features and usage are provided in the table below.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|RegisterSound ||SoundFile = GameForm1.RegisterSound('https://www.clomosy.com/game/assets/Fire.wav'); //soundFile:Integer;|| The audio file obtained from the URL should be saved to a variable.
|-
|SoundIsActive || GameForm1.SoundIsActive = True; || It is used to activate the sound effect.
|-
|PlayGameSound || GameForm1.PlayGameSound(SoundFile); || The sound activated on the application is made available for use.
|}
</div>

<b>Example</b><br>
<pre>
var
soundForm:TclGameForm;
btnSound:TclButton;
soundFile:Integer;

void BtnSoundOnClick;
{
soundForm.PlayGameSound(soundFile);
}

{
soundForm = TclGameForm.Create(Self);
soundForm.AddGameAssetFromUrl('https://www.clomosy.com/game/assets/Fire.wav');

soundFile = soundForm.RegisterSound('Fire.wav');
soundForm.SoundIsActive=True;

btnSound= soundForm.AddNewButton(soundForm,'btnSound','PLAY SOUND');
soundForm.AddNewEvent(btnSound,tbeOnClick,'BtnSoundOnClick');
btnSound.Align = alBottom;
soundForm.Run;
}
</pre>

<h2> See Also </h2>
* [[Virtual Keyboard]]
* [[TclForm]]
{{#seo:|title=TclGameForm in Clomosy - Clomosy Docs}}
{{#seo:|description=Explore TclGameForm in Clomosy for creating interactive game forms with animations, sound effects, and asset management for enhanced gaming experiences.}}

TclPageControl

2024-12-24T15:11:46Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewPageControl(AComponent: TCLComponent; xName: string): TclPageControl;
</div>

<span style="color:blue"><b> AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b> xName</b></span> : The name of the defined page control should be written.<br>
<br>
TclPageControl is a set of pages used to create a multi-page dialog box. It allows users to switch between multiple pages.

For example, it is used to create a multi-page dialog box or a tabbed notebook. TclPageControl displays multiple overlapping pages. The user selects a page by clicking on the page tab that appears at the top of the control.

<div class="alert alert-ligth border border-3 border-warning rounded-5 p-4 shadow-sm" role="alert">
<strong>Notice:</strong><br>
To add a new page to a TclPageControl object at design time, pages are created with <b>TClPageControlContainer</b>.<br>

When the TCLPageControl object is created, it automatically assigns a default page. It adds as many pages as are created with the TClPageControlContainer object.<br>
In the example below, we created 3 pages, but since there is a default page, it will appear as 4 pages.
</div>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclPageControl || PageControl1:TCLPageControl; || A variable belonging to the TclPageControl class is created.
|-
|AddNewPageControl || PageControl1= MyForm.AddNewPageControl(MyForm,'PageControl1'); || A new TclPageControl component is added to the form.
|-
|TClPageControlContainer ||PageControlContainer1 : TClPageControlContainer; || To create a new page, an object must be defined.
|-
|AddContainer ||PageControlContainer1 = PageControl1.AddContainer; || A new page is created through the defined object belonging to the TClPageControlContainer class.
|-
|ActivePage || PageControl1.ActivePage.Text = 'ACTİVE PAGE'; || TCLPageControl object represents the page that comes active when created. It is used by accessing different properties such as the text property as shown in the example.
|-
|Pages || PageControl1.Pages[1].Text = 'Registration page'; || The TclPageControl object represents a collection containing all the pages created on it. This property is used to access a specific page or perform a certain operation on a page. In the example, the text of the second page is being changed.
|-
|Mode ||PageControl1.Tabsize.Mode = tsmAutoTabSize;//tsmAutoSize - tsmFixedSize - tsmFixedSizeAutoShrink - tsmAutoTabSize (default) || The property controls how the size of the tabs will be determined. Here are the possible values and their descriptions:

:<b>tsmAutoSize</b>: Tabs are automatically resized equally.
:<b>tsmFixedSize</b>: The size of tabs is fixed, all tabs are of the same size. Left and right arrow buttons are provided for navigation between pages.
:<b>tsmFixedSizeAutoShrink</b>: Tabs are automatically resized equally.
:<b>tsmAutoTabSize (default)</b>: The size of tabs is adjusted according to the text inside them. This mode considers the length of the text to determine the width of the tabs. Left and right arrow buttons are provided for navigation between pages.
|-
|Height ||PageControl1.Tabsize.Height = 200; || Sets the height of the component's tabs.
|-
|Width ||PageControl1.Tabsize.Width = 200; || Sets the width of the component's tabs.
|-
|spacing ||PageControl1.Tabsize.spacing = 2; || Sets the spacing between the tabs of the component.
|-
|Position ||PageControl1.Layout.Position = 3; //0:Left,1:Top,2:bottom,3:Right ||Displays the tabs at the left, top, right or bottom position. In the example, the tabs are set to appear on the right.
|-
|Multiline ||PageControl1.Layout.Multiline = 2;//0:None,1:Unabled,2:UnabledActiveTab ||Displays the tabs on multiple lines instead of a single scrollable line.
|}
</div>

<h2>Example 1</h2><br>
<pre>
var
Form1:TCLForm;
clPageControl:TCLPageControl;
clPageControlContainer:TClPageControlContainer;
{
Form1 = TCLForm.Create(Self);

clPageControl = Form1.AddNewPageControl(Form1,'clPageControl');
clPageControl.Align = alClient;

clPageControlContainer = clPageControl.AddContainer; // Creates a new page using clPageControl.
clPageControlContainer = clPageControl.AddContainer;
clPageControlContainer = clPageControl.AddContainer;

Form1.Run;
}
</pre>

<b>Output:</b><br>
[[File:TclPageControl.png|frameless|450px]]<br>

<h2>Example 2</h2><br>
<pre>
var
MyForm:TCLForm;
clPageControl:TCLPageControl;
clPageControlContainer:TClPageControlContainer;
lblPage1,lblPage2,lblPage3,lblPage4 : TClProLabel;
{
MyForm = TCLForm.Create(Self);
clPageControl = MyForm.AddNewPageControl(MyForm,'clPageControl');
clPageControl.Align = alClient;
clPageControl.Layout.Position = 1;

clPageControlContainer = clPageControl.AddContainer;
clPageControlContainer = clPageControl.AddContainer;
clPageControlContainer = clPageControl.AddContainer;
clPageControl.TabSize.Margins.Top = 2;

clPageControl.ActivePage.Text = 'ACTİVE PAGE';

clPageControl.Pages[1].Text = 'Login Page';
clPageControl.Pages[2].Text = 'Profile page';
clPageControl.Pages[3].Text = 'Settings page';

clPageControl.Tabsize.Mode = tsmAutoTabSize;
clPageControl.Tabsize.spacing = 2;

lblPage1 = MyForm.AddNewProLabel(clPageControl.PageContainers[0],'lblPage1','ACTİVE PAGE');
lblPage1.Align = alCenter;
lblPage1.Height = 100;
lblPage1.Width = 150;

lblPage2 = MyForm.AddNewProLabel(clPageControl.PageContainers[1],'lblPage2','Login Page');
lblPage2.Align = alCenter;
lblPage2.Height = 100;
lblPage2.Width = 150;

lblPage3 = MyForm.AddNewProLabel(clPageControl.PageContainers[2],'lblPage3','Profile page');
lblPage3.Align = alCenter;
lblPage3.Height = 100;
lblPage3.Width = 150;

lblPage4 = MyForm.AddNewProLabel(clPageControl.PageContainers[3],'lblPage4','Settings page');
lblPage4.Align = alCenter;
lblPage4.Height = 100;
lblPage4.Width = 150;

MyForm.Run;
}
</pre>

<b>Output:</b><br>
[[File:TclPageControlExampleScreen.png|frameless|450px]]<br>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclPageControl in Clomosy - Clomosy Docs}}
{{#seo:|description=Explore TclPageControl in Clomosy to create multi-page dialog boxes with customizable tabs, layouts, and advanced features for user-friendly navigation.}}

TclImage

2024-12-24T15:10:53Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewImage(AComponent: TCLComponent; xName: string): TclImage;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined image should be written.<br>

TclImage is used to add an image to a form. Adding visuals to an application makes it more attractive and user-friendly. For example, it can be used to display an application's logo or an explanatory graphic.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclImage || Image1 : TclImage; || A variable belonging to the TclImage class is created.
|-
|AddNewImage ||Image1 = Form1.AddNewImage(Form1,'Image1'); || A new Image is added to the form.
|-
|setImage ||Form1.setImage(Image1,'https://clomosy.com/demos/bg.png'); ||It is used if you want to add an image to the Image object.
|-
|Clear ||Image1.MultiResBitmap.Clear; ||The Clear method clears images at all resolution levels within a MultiResBitmap property. So, when this method is called, all the images in the MultiResBitmap are deleted and rendered to an empty state.
|-
|Width || Image1.Width = 150; ||Allows adjusting the width of the image.
|-
|Height || Image1.Height = 50; ||Allows adjusting the height of the image.
|-
|Align ||Image1.Align = alTop; ||With the Align parameter, you can specify where you want our component to be aligned in the form. This parameter has multiple positioning properties. See the [[Object_Properties#Align | page]] to learn about these features.
|-
|Margins ||Image1.Margins.Left = 50; // Right, Top, Bottom ||With the Margins parameter, you can give margins at any scale from the right, left, bottom, top.<br>[[File:TclImageMargins.png|frameless|200px]]
|-
| LoadFromFile ||Image1.Bitmap.LoadFromFile('C:\Users\Administrator\Desktop\logo.png') || The LoadFromFile method in Clomosy is used to load an image file and transfer it to a bitmap object. In the example, the expression Image1.Bitmap.LoadFromFile loads an image from a file path into the Bitmap property of a component named Image1.
|-
|SaveToStream || Image1.Bitmap.SaveToStream(FileStream); //FileStream:TCLFileStream; || Bitmap image (TclImage) transfer to TCLFileStream. See the [[TclFileStream | page]] to learn about these features.
|-
|LoadFromStream || Image1.Bitmap.LoadFromStream(FileStream); //FileStream:TCLFileStream; || Transferring TCLFileStream data to bitmap image (TclImage). See the [[TclFileStream | page]] to learn about these features.
|}
</div>

<h2>Example 1 </h2><br>
<pre>
var
MyForm:TclForm;
testImg : TclImage;

{
MyForm = TclForm.Create(Self);
testImg= MyForm.AddNewImage(MyForm,'testImg');
testImg.Align = alCenter;
testImg.Height = 250;
testImg.Width = 300;

MyForm.setImage(testImg,'https://clomosy.com/demos/bg.png');
MyForm.AddNewEvent(testImg,tbeOnClick,'ShowMessage(''Picture clicked.'');');
MyForm.Run;

}
</pre>

<b>Output:</b><br>
[[File:Image.png|frameless|450px]]<br>

<h2>Example 2 (LoadFromFile):</h2><br>
In the example, a TclForm form is created and an image is downloaded from the internet to display on this form. First, a new TclForm instance named Form1 is created. The Form1.AddAssetFromUrl method is used to download an image from the specified URL to the project’s file directory. Then, a new TclImage instance is added to the form and configured to cover the entire form. The path of the downloaded image file is obtained using Clomosy.AppFilesPath and the Image1.Bitmap.LoadFromFile method is used to load the image.<br>

<pre>
var
Form1: TclForm;
Image1: TclImage;

{
Form1 = TclForm.Create(self);
Form1.AddAssetFromUrl('https://clomosy.com/educa/bg2.png');
try
Image1 = Form1.AddNewImage(Form1,'Image1');
Image1.Align = alClient;
Image1.Bitmap.LoadFromFile(Clomosy.AppFilesPath+'bg2.png'); // Load image from file
Form1.Run;
except
ShowMessage('An error was encountered while uploading the file.');
}
}
</pre>

<h2>Example 3 (Save image to file):</h2><br>
The example creates a form (TclForm) and an image component (TclImage) and implements a function to load an image from a specific URL and save it to a file. First, Form1 and Image1 objects are created, and the image component is added to the form. The Image1 component is updated with a background image from the specified URL (https://clomosy.com/educa/bg2.png). The SaveFile procedure uses TCLMemoryStream to save the bitmap of Image1 to a memory stream and writes this data to a file (newImgBG.png) in Base64 format. The SaveFile procedure is linked to the click event of Image1, so when the form is run and the user clicks the image, the image is saved to the file. If any errors occur, an error message is displayed.<br>

<pre>
var
Form1: TclForm;
Image1: TclImage;
MemStream: TCLMemoryStream;

void SaveFile;
{
try
MemStream = TCLMemoryStream.Create;
Image1.Bitmap.SaveToStream(MemStream);
// Save image to file
Clomosy.Base64ToFile(clPathCombine('newImgBG.png',Clomosy.AppFilesPath),MemStream.AsBase64);
except
ShowMessage('Exception Class: '+LastExceptionClassName+' Exception Message: '+LastExceptionMessage);
}
}
{
Form1 = TclForm.Create(self);

Image1 = Form1.AddNewImage(Form1,'Image1');
Image1.Align = alClient;
Form1.SetImage(Image1,'https://clomosy.com/educa/bg2.png');
Form1.AddNewEvent(Image1,tbeOnClick,'SaveFile');

Form1.Run;
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclImage Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use TclImage in Clomosy to add and manage images with features like alignment, margins, loading, and saving, enhancing application visuals.}}

Div

2024-12-24T15:10:28Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
keyword Div
</div>

The Div keyword gives the whole number result of dividing the Dividend by the Divisor. Any remainder is discarded.<br>

<b>Example</b><br>

<pre>
var
intValue : Integer;

{
// Divide a primary integer by 2 - it discards the remainder
intValue = 27 Div 2;

ShowMessage('27 div 2 = '+IntToStr(intValue));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
27 div 2 = 13
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]

{{#seo:|title=Div Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the Div keyword in Clomosy to perform integer division, discarding remainders for precise whole-number results.}}

Ln

2024-12-24T15:10:02Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Ln(const X: Extended): Extended;
</div>

The Ln function takes an integer or floating point Number and gives the natural logarithm of that number. This is only used for mathematical processing.<br>

Ln has the opposite effect to Exp - the exponent of a number.<br>

<b>Example</b><br>

<pre>
var
float,number : float;

{

number = 2.14;
float = Ln(number);
ShowMessage('Ln('+FloatToStr(number)+') = '+FloatToStr(float));

float = Exp(float);
ShowMessage('Exp(Ln('+FloatToStr(float)+')) = '+FloatToStr(float));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Ln(2,14) = 0,76080582903376<br>
Exp(Ln(2,14)) = 2,14
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Ln Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the Ln function in Clomosy for calculating the natural logarithm of a number, essential for advanced mathematical processing.}}

QuotedStr

2024-12-24T15:09:39Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function QuotedStr(const S: string): string;
</div>

<br>
It encloses a string in single quotes (') and escapes any existing single quotes within the string by doubling them. This is particularly useful when a string is to be used as a constant in an SQL query or another language, ensuring that the string is safely quoted.<br>

Usage:<br>

* QuotedStr takes a string and surrounds it with single quotes.
* If the string already contains single quotes, they are doubled, making it a valid constant in languages like SQL.

<b>Example</b><br>

<pre>
var
originalStr, quotedStr: string;
{
originalStr = 'O''Reilly'; // O'Reilly is a common example with an apostrophe
quotedStr = QuotedStr(originalStr);
ShowMessage(quotedStr); // Output: 'O''Reilly'
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
<nowiki>'O''Reilly'</nowiki>
</div>

<h2> Usage in SQL Structure </h2>
It is also used in cases where string expressions need to be added while writing sql code blocks in Clomosy application. An example code snippet is shown below.<br>

<b>Example</b><br>

<pre>
LocalQ = Clomosy.DBSQLServerQueryWith(' SELECT '+ QuotedStr('Product Name: ') +'+productName AS MAINVIEW_TEXT ,'+ QuotedStr('Product Price: ') +'+ CAST(CAST(productPrice AS int)AS varchar(10)) AS MAINVİEW_CENTERTEXT FROM Products ');
</pre>

<h2> See Also </h2>
* [[System_Library#String_Functions | String Functions]]
{{#seo:|title=QuotedStr Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the QuotedStr function in Clomosy to securely format strings for SQL queries and other applications.}}

AppPlatform

2024-12-24T15:09:10Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Clomosy.AppPlatform :Integer;
</div>
The platform on which the project is opened is returned. A return value of 0 indicates Windows, 1 indicates MacOS, 2 indicates iOS, 3 indicates Android, 4 indicates WinRT, and 5 indicates Linux.<br>

<b>Example</b><br>
<pre>
var
platformStatus : Integer;
{
platformStatus = Clomosy.AppPlatform;
case platformStatus of
{
0 : ShowMessage('Windows');
1 : ShowMessage('MacOS');
2 : ShowMessage('IOS');
3 : ShowMessage('Android');
4 : ShowMessage('WinRT');
5 : ShowMessage('Linux');
}
}
</pre>

<h2> See Also </h2>
* [[Clomosy_Class#System_Function | System Functions]]
{{#seo:|title=AppPlatform in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn to use the Clomosy.AppPlatform function to identify the platform your project runs on, with predefined values for different operating systems.}}

RunUnit

2024-12-24T15:08:46Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
Clomosy.RunUnit(unitName: String);
</div>

It is a method used to run or redirect to a specific unit. This allows for the dynamic loading and utilization of units.<br>

Its purpose is to activate the functionality of a specific unit and to interact with that unit. By running the unit, the code, functions, and procedures within it become accessible.<br>

It is typically called in response to user interactions or specific events to open or execute units. For example, a unit can be run when a user clicks a button.<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
If you are new to using the RunUnit feature, try the application shown in Example 1.
</div>

<b>Example 1</b><br>
<div class="alert alert-danger" role="alert" data-bs-theme="light">
In this example, it is necessary to create a new unit when using the RunUnit feature. Before using the example code, a unit named "uLogin" should be created in your application. Otherwise, an error will occur.
</div>

Main Code:
<pre>
Clomosy.RunUnit('uLogin');
</pre>

uLogin:
<pre>
ShowMessage('Hello, you have been redirected from the main code to the uLogin unit.');
</pre>

<b>Example 2</b><br>
In the example above, the "uLogin" unit was created. In this example, components have been added to both the "Main Code" and "uLogin" pages. Here, when a button in the "Main Code" is pressed, it navigates to the "uLogin" unit, and when the page within this unit is clicked, it returns to the "Main Code" page.<br>

Main Code:
<pre>
var
Form1:TCLForm;
buton1 : TclButton;
void goToLogin;
{
Clomosy.RunUnit('uLogin');
}
{
Form1 = TCLForm.Create(Self);

buton1 = Form1.AddNewButton(Form1,'buton1','Go to uLogin');
buton1.Width = 150;
Form1.AddNewEvent(buton1,tbeOnClick,'goToLogin');

Form1.Run;
}
</pre>

uLogin:
<pre>
var
formLogin:TCLForm;
btnLogin : TclButton;
void goToMainCode;
{
formLogin.clHide;
}
{
formLogin = TCLForm.Create(Self);

btnLogin = formLogin.AddNewButton(formLogin,'btnLogin','Go to Main Code');
btnLogin.Width = 150;
formLogin.AddNewEvent(btnLogin,tbeOnClick,'goToMainCode');

formLogin.Run;
}
</pre>

<h2> See Also </h2>
* [[Units | Units ]]
* [[TclUnit | TclUnit]]
{{#seo:|title=RunUnit in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the Clomosy.Run Unit method to dynamically load and execute specific units in your application, enabling seamles navigation.}}

ClSenderKey

2024-12-24T15:08:20Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
Form1.clSenderKey: Integer;
</div>

The clSenderKey feature captures the codes of keys on the keyboard that have special functions, excluding standard character keys (a-z, 0-9, etc.), and performs specific actions based on them.<br>

These types of keys are generally referred to as "control keys" or "special keys." These control keys on the keyboard include arrow keys, function keys (F1-F12), Ctrl, Alt, Shift, Escape, Enter, Backspace, and other similar keys.<br>

To detect these keys, the tbeOnKeyDown or tbeOnKeyUp events are used, as these events use virtual key codes and can capture keys that do not represent characters. For example, they can be used to move an image (TclImage) on the screen using the arrow keys.<br>

Below is a table of control keys.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Key Code !!style="background-color: #c3d7e0"| Key
|-
|8 || Backspace
|-
|9 || Tab
|-
|13 || Enter
|-
|16 || Shift
|-
|17 || Ctrl
|-
|18 || Alt
|-
|19 || Pause
|-
|20 || CapsLock
|-
|27 || Escape
|-
|33 || PageUp
|-
|34 || PageDown
|-
|35 || End
|-
|36 || Home
|-
|37 || ArrowLeft
|-
|38 || ArrowUp
|-
|39 || ArrowRight
|-
|40 || ArrowDown
|-
|45 || Insert
|-
|46 || Delete
|-
|91 || Windows Key
|-
|93 || ContextMenu/ Windows Menu
|-
|112 || F1
|-
|113 || F2
|-
|114 || F3
|-
|115 || F4
|-
|116 || F5
|-
|117 || F6
|-
|118 || F7
|-
|119 || F8
|-
|120 || F9
|-
|121 || F10
|-
|122 || F11
|-
|123 || F12
|-
|144 || NumLock
|-
|145 || ScrollLock
|}
</div>

<div class="alert alert-danger" role="alert" data-bs-theme="light">
<b>NOTE:</b> You should run and test Example 1 on Windows.
</div>

<b>Example 1</b><br>
In the following example, a form is created with an image that can be moved around the screen using the arrow keys. The SetMotion procedure checks the key code captured by clSenderKey. When the left arrow key (37) is pressed, the image rotates 180 degrees and moves left by 5 units unless it has reached the left edge of the form. When the right arrow key (39) is pressed, the image rotates back to 0 degrees and moves right by 5 units unless it has reached the right edge. When the up arrow key (38) is pressed, the image rotates 270 degrees and moves up by 5 units unless it has reached the top edge. When the down arrow key (40) is pressed, the image rotates 90 degrees and moves down by 5 units unless it has reached the bottom edge. If any other keys are pressed, a message prompts the user to use only the arrow keys. The form is created, an image is added and centered, and an event handler is set up to call the SetMotion procedure on key down.<br>

<pre>
var
Form1:TCLForm;
Image1 : TclImage;

void SetMotion;
{
if(Form1.clSenderKey == 37) //LEFT ok tuşu 37
{
Image1.RotationAngle = 180;
if(Image1.Position.X <= 0)
ShowMessage('Can''t Go Any Further Left');
else
Image1.Position.X = Image1.Position.X - 5;
}
else if(Form1.clSenderKey == 39) //RIGHT ok tuşu 39
{
Image1.RotationAngle = 0;
if(Image1.Position.X >= Form1.clWidth)
ShowMessage('Can''t Go Any Further Right');
else
Image1.Position.X = Image1.Position.X + 5;
}
else if(Form1.clSenderKey == 38) //yukarı ok tuşu 38
{
Image1.RotationAngle = 270;
if(Image1.Position.Y <= 0)
ShowMessage('Can''t Go Any Further Higher');
else
Image1.Position.Y = Image1.Position.Y - 5;
}
else if(Form1.clSenderKey == 40) //aşağı ok tuşu 40
{
Image1.RotationAngle = 90;
if(Image1.Position.Y >= Form1.clHeight)
ShowMessage('Can''t Go Any Further Lower');
else
Image1.Position.Y = Image1.Position.Y + 5;
}
else
{
ShowMessage('Please use only directional arrow keys..');
}
}

{
Form1 = TCLForm.Create(Self);
Image1 = Form1.AddNewImage(Form1,'Image1');
Image1.Align = AlNone;
Image1.Position.X = Form1.clWidth / 2;
Image1.Position.Y = Form1.clHeight / 2;
Image1.Width = 100;
Image1.Height = 100;
Form1.setImage(Image1,'https://clomosy.com/demos/circled-right.png');

Form1.AddNewEvent(Form1,tbeOnKeyDown,'SetMotion');
Form1.Run;
}
</pre>

<b>Example 2</b><br>
The example contains a series of procedures for controlling and altering a character's size and position. For instance, the SetZoomIn procedure is used to enlarge the character, but it includes various checks to ensure that the enlargement does not exceed the movement area boundaries. The SetZoomOut procedure reduces the character's size, similarly checking for boundary limits. Additionally, procedures such as SetGoUp, SetGoDown, SetGoLeft, and SetGoRight are used to move the character up, down, left, and right, respectively. These movement and size adjustment operations are carried out with animations to provide visual feedback to the user.<br>
The initial setup of the form and button placement is designed to differ for mobile and desktop platforms. For mobile platforms, buttons are added to provide access to movement and size adjustment functions, while desktop platforms use keyboard shortcuts. This approach ensures that the user interface is designed to support user interaction across different platforms.<br>

<pre>
var
Form1: TclForm;
pnlMotionConsole, motionPanel: TCLPanel;
ImgCharacter: TCLImage;
btnUp,btnDown,btnRight,btnLeft,btnZoomIn,btnZoomOut: TClButton;
incomingValue, BottomPosX,x,intermediateValue: Integer
lbltopBar : TclProLabel;

void SetZoomIn
var
rightPosX,BottomPosX,aradeger:Integer
{
rightPosX=ImgCharacter.Position.X+ImgCharacter.Width
BottomPosX=ImgCharacter.Position.Y+ImgCharacter.Height
if(((incomingValue>200-ImgCharacter.Height) && (200-ImgCharacter.Height>0)) || ((incomingValue>200-ImgCharacter.Width) && (200-ImgCharacter.Width>0)) )
{
x=200-ImgCharacter.Height;
intermediateValue=200-ImgCharacter.Width;
clAnimateFloat(ImgCharacter,'Height',200,1,1,0);
clAnimateFloat(ImgCharacter,'Width',200,1,1,0);
clAnimateFloat(ImgCharacter,'Position.X',ImgCharacter.Position.X - intermediateValue / 2,1,1,0);
clAnimateFloat(ImgCharacter,'Position.Y',ImgCharacter.Position.y - x / 2,1,1,0);
}
else if((ImgCharacter.Height+incomingValue>200) || (ImgCharacter.Width+incomingValue>200))
{
ShowMessage('You Have Reached Your Magnification Limit!');
}
else if((ImgCharacter.Position.X<incomingValue) || (rightPosX+20>motionPanel.Width))
{
ShowMessage('You Can''t Exceed the Limits!');
}
else if((ImgCharacter.Position.Y<incomingValue) || (BottomPosX+20>motionPanel.Height))
{
ShowMessage('You Can''t Exceed the Limits!');
}
else
{
clAnimateFloat(ImgCharacter,'Height',ImgCharacter.Height+incomingValue,1,1,0);
clAnimateFloat(ImgCharacter,'Width',ImgCharacter.Width+incomingValue,1,1,0);
clAnimateFloat(ImgCharacter,'Position.X',ImgCharacter.Position.X - incomingValue / 2,1,1,0);
clAnimateFloat(ImgCharacter,'Position.Y',ImgCharacter.Position.Y - incomingValue / 2,1,1,0);
}
}

void SetZoomOut
var
rightPosX,BottomPosX:Integer
{
rightPosX=ImgCharacter.Position.X+ImgCharacter.Width
BottomPosX=ImgCharacter.Position.Y+ImgCharacter.Height
if((ImgCharacter.Width<=20) || (ImgCharacter.Height<=20))
{
ShowMessage('You Can''t Shrink Any More!');
}
else if(((incomingValue>ImgCharacter.Height-20)&&(ImgCharacter.Height-20>0)) || ((incomingValue>ImgCharacter.Width-20)&&(ImgCharacter.Width-20>0)))
{
x=ImgCharacter.Height-20
intermediateValue=ImgCharacter.Width-20
clAnimateFloat(ImgCharacter,'Width',20,1,1,0);
clAnimateFloat(ImgCharacter,'Height',20,1,1,0);
clAnimateFloat(ImgCharacter,'Position.X',ImgCharacter.Position.X + incomingValue / 2,1,1,0)
clAnimateFloat(ImgCharacter,'Position.Y',ImgCharacter.Position.Y + incomingValue / 2,1,1,0)
}
else
{
clAnimateFloat(ImgCharacter,'Width',ImgCharacter.Width-incomingValue,1,1,0);
clAnimateFloat(ImgCharacter,'Height',ImgCharacter.Height-incomingValue,1,1,0);
clAnimateFloat(ImgCharacter,'Position.X',ImgCharacter.Position.X + incomingValue / 2,1,1,0)
clAnimateFloat(ImgCharacter,'Position.Y',ImgCharacter.Position.Y + incomingValue / 2,1,1,0)
}
}

void SetGoUp
{
if(ImgCharacter.Position.Y<=0)
{
ShowMessage('You Can''t Go Any Higher!');
}
else if(ImgCharacter.Position.Y<incomingValue)
{
clAnimateFloat(ImgCharacter,'Position.Y',0,1,1,0)
}
else
{
clAnimateFloat(ImgCharacter,'Position.Y',ImgCharacter.Position.Y-incomingValue,1,1,0)
}
}

void SetGoDown
var
BottomPosX: Integer
{
BottomPosX=ImgCharacter.Position.Y+ImgCharacter.Height
if(BottomPosX>=motionPanel.Height)
{
ShowMessage('You Can''t Go Any Lower!');
}
else if(motionPanel.Height-BottomPosX<incomingValue)
{
clAnimateFloat(ImgCharacter,'Position.Y',motionPanel.Height - ImgCharacter.Height,1,1,0)
}
else
{
clAnimateFloat(ImgCharacter,'Position.Y',ImgCharacter.Position.Y + incomingValue,1,1,0)
}
}

void SetGoLeft
{
if(ImgCharacter.Position.X<=0)
{
ShowMessage('You Can''t Go Any Left!');
}
else if(ImgCharacter.Position.X < incomingValue)
{
clAnimateFloat(ImgCharacter,'Position.X',0,1,1,0)
}
else
{
clAnimateFloat(ImgCharacter,'Position.X',ImgCharacter.Position.X - incomingValue,1,1,0)
}
}

void SetGoRight
var
rightPosX: Integer
{
rightPosX=ImgCharacter.Position.X+ImgCharacter.Width
if(rightPosX>=motionPanel.Width)
{
ShowMessage('You can''t go any further to the right');
}
else if(motionPanel.Width-rightPosX<incomingValue)
{
clAnimateFloat(ImgCharacter,'Position.X',motionPanel.Width - ImgCharacter.Width,1,1,0)
}
else
{
clAnimateFloat(ImgCharacter,'Position.X',ImgCharacter.Position.X + incomingValue,1,1,0)
}
}

void SetMotion
{
if(Form1.clSenderKey == 37)
{
SetGoLeft;
}
else if(Form1.clSenderKey == 39)
{
SetGoRight;
}
else if(Form1.clSenderKey == 38)
{
SetGoUp;
}
else if(Form1.clSenderKey == 40)
{
SetGoDown;
}
else if((Form1.clSenderKeyChar == 43) || (Form1.clSenderKeyChar == 98) || (Form1.clSenderKeyChar == 66))
{
SetZoomIn;
}
else if((Form1.clSenderKeyChar == 45) || (Form1.clSenderKeyChar == 107) || (Form1.clSenderKeyChar == 75))
{
SetZoomOut;
}
else
{
ShowMessage('Please Use the Buttons Below'#13'To Move: Arrow Keys'#13'To Enlarge: B or + (numpad)'#13'To Reduce : K or - (numpad)');
}
}

{
incomingValue=20
Form1= TclForm.Create(Self);
Form1.SetFormColor('#f3afaf', '', clGNone);
TclButton(Form1.clFindComponent('BtnFormMenu')).Visible = False;
TclButton(Form1.clFindComponent('BtnGoBack')).Visible = False;

lbltopBar= Form1.AddNewProLabel(Form1,'lbltopBar','Move with the arrow keys. ''+'' and ''-'''#13'You can make the character smaller with the buttons..');
lbltopBar.Align=alTop;
lbltopBar.Height= Form1.clHeight / 9;
lbltopBar.clProSettings.FontColor = clAlphaColor.clHexToColor('#030303');
lbltopBar.clProSettings.FontSize = 14;
lbltopBar.clProSettings.FontVertAlign = palcenter;
lbltopBar.clProSettings.FontHorzAlign = palcenter;
lbltopBar.clProSettings.TextSettings.Font.Style = [fsBold,fsItalic];
lbltopBar.clProSettings.BorderColor = clAlphaColor.clHexToColor('#d55353');
lbltopBar.clProSettings.BorderWidth = 5;
lbltopBar.clProSettings.BackgroundColor = clAlphaColor.clHexToColor('#d17a7a');
lbltopBar.clProSettings.IsRound = True;
lbltopBar.clProSettings.RoundHeight = 20;
lbltopBar.clProSettings.RoundWidth = 20;
lbltopBar.SetclProSettings(lbltopBar.clProSettings);

motionPanel= Form1.AddNewPanel(Form1,'motionPanel')
motionPanel.Align=AlClient;
motionPanel.Margins.Top = 10;
motionPanel.Margins.Bottom = 10;
motionPanel.Margins.Left = 10;
motionPanel.Margins.Right = 10;

ImgCharacter= Form1.AddNewImage(motionPanel,'ImgCharacter');
Form1.SetImage(ImgCharacter,'https://clomosy.com/educa/ufo.png');
ImgCharacter.Align=alNone;
ImgCharacter.Position.X= Form1.clWidth / 2 - ImgCharacter.Width / 2;
ImgCharacter.Position.Y= motionPanel.Height / 2 - ImgCharacter.Height / 2;
ImgCharacter.Height= 50;
ImgCharacter.Width= 50;

Form1.Run;

if(Clomosy.PlatformIsMobile)
{
pnlMotionConsole= Form1.AddNewPanel(Form1,'pnlMotionConsole');
pnlMotionConsole.Align= AlBottom;
pnlMotionConsole.Margins.Bottom=20;
pnlMotionConsole.Height=200;

btnLeft= Form1.AddNewButton(pnlMotionConsole, 'btnLeft', 'LEFT');
btnLeft.Align=alLeft;
btnLeft.Width=100;
btnLeft.Margins.Top=20;
btnLeft.Margins.Bottom=20;
Form1.AddNewEvent(btnLeft,tbeOnClick,'SetGoLeft');

btnRight= Form1.AddNewButton(pnlMotionConsole, 'btnRight', 'RIGHT');
btnRight.Align=alRight;
btnRight.Width=100;
btnRight.Margins.Top=20;
btnRight.Margins.Bottom=20;
Form1.AddNewEvent(btnRight,tbeOnClick,'SetGoRight')

btnUp= Form1.AddNewButton(pnlMotionConsole, 'btnUp', 'UP');
btnUp.Align=alTop;
btnUp.Width=100;
btnUp.Margins.Top=10;
btnUp.Height=40;
Form1.AddNewEvent(btnUp,tbeOnClick,'SetGoUp');

btnDown= Form1.AddNewButton(pnlMotionConsole, 'btnDown', 'DOWN');
btnDown.Align=alBottom;
btnDown.Width=100;
btnDown.Margins.Bottom=10;
btnDown.Height=40;
Form1.AddNewEvent(btnDown,tbeOnClick,'SetGoDown');

btnZoomIn= Form1.AddNewButton(pnlMotionConsole, 'btnZoomIn', '+')
btnZoomIn.Align=alLeft;
btnZoomIn.Margins.Top=20;
btnZoomIn.Margins.Bottom=20;
btnZoomIn.Margins.Left=5;
Form1.AddNewEvent(btnZoomIn,tbeOnClick,'SetZoomIn');

btnZoomOut= Form1.AddNewButton(pnlMotionConsole, 'btnZoomOut', '-')
btnZoomOut.Align=alRight;
btnZoomOut.Margins.Top=20;
btnZoomOut.Margins.Bottom=20;
btnZoomOut.Margins.Right=5;
Form1.AddNewEvent(btnZoomOut,tbeOnClick,'SetZoomOut');
}
else
Form1.AddNewEvent(Form1,tbeOnKeyDown,'SetMotion');
}
</pre>

<h2> See Also </h2>
* [[System_Library#Cl_Utilities_Functions | Cl Utilities Functions]]
{{#seo:|title=ClSenderKey in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn to use the clSenderKey property in Clomosy to detect special keyboard keys and control custom actions like moving images.}}

Frac

2024-12-24T15:06:22Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Frac(const X: Extended): Extended;
</div>

The Frac function returns the fractional part of a floating point number.

<b>Example</b><br>

<pre>
var
numberValue : Integer;

{
numberValue = 12.75;
ShowMessage(' Frac(12.75) = '+FloatToStr(Frac(numberValue)));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Frac(12.75) = 0,75
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Frac in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the Frac function in Clomosy to extract the fractional part of a floating-point number for precise calculations.}}

DateToStr

2024-12-24T15:05:55Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function DateToStr(const DateTime: TclDateTime):string;
</div>

Converts a TclDateTime value into a string.<br>
Use DateToStr to obtain a string representation of a date value that can be used for display purposes.

<b>Example</b><br>

<pre>
var
myDate : TclDateTime;
{
myDate = StrToDate('27.02.2023');
ShowMessage('myDate = '+DateToStr(myDate));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
myDate = 27.02.2023
</div>

<h2> See Also </h2>
* [[System_Library#Type_Conversion_Functions | Type Conversion Functions]]
{{#seo:|title=DateToStr Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the DateToStr function in Clomosy to convert TclDateTime values into easily readable date strings for display.}}

TclRectangle

2024-12-24T15:05:30Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewRectangle(AComponent: TCLComponent; xName: string): TclRectangle;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined component should be written.<br>

The TclRectangle component represents a rectangle and is commonly used in interface designs as a background or region. Additionally, its appearance and properties can be customized using style properties.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclRectangle|| Rectangle1 : TclRectangle; || A variable belonging to the TclCircle class is created.
|-
|AddNewRectangle || Rectangle1 = Form1.AddNewRectangle(Form1,'Rectangle1'); || A new TclRectangle is added to the form.
|-
|Fill.Kind || Rectangle1.Fill.Kind = fbkSolid; || It is used to fill the inside of the object. This property determines how the interior fill of the object is applied. The following options can be used:<br>
*<b>fbkNone</b>: Does not fill the inside.
*<b>fbkSolid</b>: Fills the inside with a single color.
*<b>fbkGradient</b>: Fills the inside with a color gradient.
*<b>fbkBitmap</b>: Fills the inside with a bitmap image.
*<b>fbkResource</b>: Fills with a resource file (usually includes image files, text files, database connections, or similar things).
|-
|Fill.Bitmap.WrapMode || Rectangle1.Fill.Bitmap.WrapMode = fbwmTileOriginal; || It is used to specify a bitmap when filling the inside of the component and to control how this bitmap will be tiled. It determines how the bitmap will be placed and overlapped on a specific area. The following options can be used:<br>
*<b>fbwmTile</b>: The bitmap is tiled to completely fit the area to be filled.
*<b>fbwmTileOriginal</b>: The bitmap is tiled according to its original size, and if it exceeds the boundaries of the area to be filled, it repeats the pattern.
*<b>fbwmTileStretch</b>: The bitmap is stretched to fit the area to be filled and is placed fully within the area.
|-
|Stroke.Thickness || Rectangle1.Stroke.Thickness = 3; || It is used to set the thickness of the object's border. A value of 0 disables the border.
|-
|Sides ||Rectangle1.Sides = SetOf([sdLeft, sdTop, sdRight, sdBottom]); || The Sides property is used to customize the width adjustments for each side of the object. By using SetOf, the dimensions of all four sides are defined. As shown above, the parameters are provided sequentially for the left, top, right, and bottom sides. For sides where no frame is desired, the corresponding parameter is removed.
|}
</div>

<b>Example</b><br>
<pre>
var
anaForm:TclGameForm;
Rectangle1: TclRectangle;
{
anaForm = TclGameForm.Create(Self);

Rectangle1 = anaForm.AddNewRectangle(anaForm, 'Rectangle1');
Rectangle1.Fill.Kind = fbkBitmap;
Rectangle1.Fill.Bitmap.WrapMode = fbwmTile;
Rectangle1.Width = 200;
Rectangle1.Height = 200;
Rectangle1.Stroke.Thickness = 3;
Rectangle1.Sides = SetOf([sdLeft, sdTop, sdBottom]);
anaForm.Run;
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclRectangle Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn to use TclRectangle in Clomosy for customizable rectangles, ideal for backgrounds or regions, with flexible styling options.}}

TclBlobField

2024-12-24T15:05:09Z

ClomosyAdmin:

TclBlobField represents a field that holds a reference to a binary large object (BLOB - Binary Large Object) in the dataset.<br>

TclBlobField encapsulates the basic behavior common to binary large object (BLOB - Binary Large Object) fields. BLOB fields are database fields that contain raw binary data of arbitrary length. BLOB fields can represent different, optionally large data types. These data types are distinguished in the header of the binary data.<br>

BLOB fields allow for the storage of large binary data such as text, images, audio, or video.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclBlobField|| BlobField : TclBlobField; || A variable belonging to the TclBlobField class is created.
|-
|Assigning to object || BlobField = qry.FieldByName('DOCUMENT_FILE') as TclBlobField; || Assigning to a TclBlobField object
|-
|SaveToStream ||BlobField.SaveToStream(BlobStream); || Saves BLOB data to a TclMemoryStream or TclFileStream object.
|}
</div>

<b>Example</b><br>

This code connects to a SQL Server database, executes a query on a table, and loads image data from a BLOB (Binary Large Object) field. It saves the loaded image data into a stream (TclMemoryStream), then loads this data into a visual component (TclImage) and displays it. Additionally, it copies the image data in Base64 format to the clipboard (setClipBoard).<br>

<pre>
var
Server, User, Password,DB: String;
Port: Integer;
Form1:TCLForm;
qry : TClSqlQuery;
BlobStream: TclMemoryStream;
BlobField: TclBlobField;
Img1 : TclImage;
Base64String: string;

void MainForm;
{
Form1 = TCLForm.Create(Self);
Img1 = Form1.AddNewImage(Form1,'Img1');
Img1.Align = alClient;

qry = TClSqlQuery.Create(Nil);
try
try
qry.Connection = Clomosy.DBSQLServerConnection;
qry.Sql.Text = 'SELECT TOP(1) DOC_FILE FROM ATBLDOCS';
qry.Open;
if (qry.Found)
{
BlobField = qry.FieldByName('DOC_FILE') as TclBlobField;
BlobStream = TclMemoryStream.Create;
BlobField.SaveToStream(BlobStream); // Load BLOB data into the stream
BlobStream.Position = 0;
Base64String = Clomosy.StreamToBase64(BlobStream);
Clomosy.setClipBoard(Base64String);//FOR TEST PURPOSE COPIES BASE64

Img1.Bitmap.LoadFromStream(BlobStream); // Load the image from the stream
BlobStream.Free;
}
except
ShowMessage('[019] Exception Class: '+LastExceptionClassName+' Exception Message: '+LastExceptionMessage);
}
finally
qry.Free;
}
Form1.Run;
}

{
try
Server = '192.168.5.13';
User = 'sa';
Password = 'aaaa';
DB = 'ATK23';
Port = 1433;
Clomosy.EventLog = True;
if not (Clomosy.DBSQLServerConnect('SQL Server', Server, User, Password, DB, Port))
{
ShowMessage('DATABASE CONNECT ERROR');
Exit;
}
MainForm;
except
ShowMessage('Connection Error '+'Exception Class: '+LastExceptionClassName+' Exception Message: '+LastExceptionMessage);
}
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[TclFileStream]]
* [[TclMemoryStream]]
* [[StreamToBase64]]
* [[FileToStream]]
* [[FileToBase64]]
* [[Base64ToFile]]
* [[Base64ToStream]]
{{#seo:|title=TclBlobField Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use TclBlobField in Clomosy to handle and manage BLOB data like images, audio, and video from a database, with practical examples.}}

Keywords

2024-12-24T15:04:45Z

ClomosyAdmin:

This page contains commonly used keywords and directives in the programming language. Keywords form the fundamental building blocks of a programming language and are used to perform specific tasks. Acting as commands, these words manage the control flow, data structures, and other essential operations within a program. The correct use of keywords during programming is crucial for building error-free and efficient code.<br>

Below is a list of the main keywords used in the programming language. Understanding these keywords will help you grasp the structure of the language and use the correct syntax when developing software.<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
NOTE: A keyword should not be used as a variable name.
</div>

<h2> <b>var</b> </h2>
The var keyword is used for defining variables. To create a variable, var is used to specify the name and type of the variable. This keyword allocates memory in the program to store a specific data type.<br>

<b>Example:</b><br>

<pre>
Var
appName : String;
year : Integer;
{
appName = 'Clomosy';
year = 2023;

ShowMessage('appName = '+appName );
ShowMessage('Year = '+IntToStr(year));
}
</pre>

<h2> <b>Xor</b> </h2>
As a logical operator, xor combines two or more conditions and checks whether only one of them is true. If only one of the conditions combined with xor is true, the result will be true; however, if both conditions are true or both are false, the result will be false. This operator is useful for expressing the logic of "either one or the other" between conditions.<br>

<b>Example</b><br>
<pre>
var
num1, num2, num3 : Integer;
letter : Char;

{
num1 = $25;
num2 = $10;
letter = 'G';

if ((num1 > 0) Xor (letter == 'G'))
ShowMessage('Both values are true')
else ShowMessage('None or only one true value');

num3 = num1 Xor num2;

ShowMessage('25 And 32 = '+ IntToStr(num3));
}
</pre>

<h2> <b>Not</b> </h2>
It is used as a logical operator to negate a condition; that is, the not operator evaluates a condition as false if it is true, and as true if it is false. This way, it is useful for altering the logical states of conditions.<br>

<b>Example</b><br>

<pre>
var
num1, num2 : Word;

{
num1 = $2C; // Binary value : 0000 0000 0010 1100
// Not'ed value : 1111 1111 1101 0011 = $FFD3

// And used to return a Boolean value
if Not (num1 > 0)
ShowMessage('num1 <= 0')
else ShowMessage('num1 > 0');

// And used to perform a mathematical NOT operation
num2 = Not num1;

// Display the result
ShowMessage('Not $2C = $'+IntToHex(num2,2));
}
</pre>

<h2> <b>Array</b> </h2>
The Array provides single and multi dimensional arrays (indexable sequences) of data. Dynamic arrays have no preallocated storage. When defined, only a pointer is created. For detailed information, visit the [[Arrays | page]].

<h2> <b>As</b> </h2>
The as keyword is used for type casting. It is particularly useful in object-oriented programming when a object needs to be converted from one type to another. This operation should only be performed between compatible types; otherwise, an error will occur.

<h2> <b>Case</b> </h2>
The Case keyword provides a structured equivalent to a sequence of if statements on the same variable. The case statement is more elegant, more efficient, and easier to maintain than multiple if nestings.The brief definition is as follows.

<b>Example</b><br>

<pre>
var
day: Integer;
dayName: String;
{
day = 3; // Example day number

case day of
{
1: dayName = 'Monday';
2: dayName = 'Tuesday';
3: dayName = 'Wednesday';
4: dayName = 'Thursday';
5: dayName = 'Friday';
6: dayName = 'Saturday';
7: dayName = 'Sunday';
else
dayName = 'Invalid day'; // If the given day number is not between 1-7
}

ShowMessage('Day: ' + dayName);
}
</pre>

<h2> <b>Const</b> </h2>
The const keyword is used to define constant values. Constants are values that remain unchanged during the execution of the program. A constant defined with const takes a value of a specific type, and this value cannot be altered after its declaration. This feature enhances the reliability and readability of the code.<br>

<pre>
const
pi = 3.14;
</pre>

<h2> <b>Div</b> </h2>
The Div keyword gives the whole number result of dividing the Dividend by the Divisor. Any remainder is discarded.
Dividend div divisor

For detailed information, see the [[Div |page]].

<h2> <b>downto</b> </h2>

It is used to indicate that the count in a loop should be done in decreasing order. The loop variable progresses from a specified starting value to an end value by decreasing.<br>

<b>Example</b><br>

<pre>
var
i: Integer;
{
// Counting down from 5 to 1
for (i = 5 downto 1)
{
ShowMessage('i = ' + IntToStr(i));
}
}
</pre>

<h2> <b>Else</b> </h2>

The Else keyword is part of the If and Case statements. It is used to start the section of code executed when earlier conditions are not satisfied.<br>

<b> If for; </b><br>
<pre>
var
score: Integer;
{
score = 75;

if (score >= 50)
ShowMessage('Passed')
else
ShowMessage('Failed');
}
</pre>

<b> Case for; </b><br>
<pre>
var
choice: Integer;
{
choice = 1;

case choice of
{
0: ShowMessage('Choice 0');
else
ShowMessage('Invalid choice');
}
}
</pre>

<h2> <b>Try</b> </h2>
It is used for error handling and management. The try block ensures the safe execution of a specific piece of code. If an error occurs within the try block, the error can be caught and handled by the <b>except or finally</b> blocks.<br>

<b>Example</b><br>

<pre>
var
number, zero : Integer;
{
number = -1;
Try
zero = 0;
number = 1 div zero;
ShowMessage('number / zero = '+IntToStr(number));
finally
ShowMessage('Number was not assigned a value - using default');
}
}
</pre>

<h2> <b>Except</b> </h2>

The Except keyword is used to mark the start of a block of statements that handle an exception in a Try clause. If the Except block can handle the exception, then the program is not terminated.<br>
For more detailed information, see the [[Error Trapping| page]].

<h2> <b>Finally</b> </h2>
Regardless of whether an error occurs in the try block, the code in the finally block always executes. This is useful to ensure that important tasks, such as resource deallocation or cleanup operations, are always carried out.<br>
For more detailed information, see the [[Error Trapping| page]].

<h2> <b>Repeat</b> </h2>
The repeat keyword allows a block of code to be repeated until a specific condition is met. It is used in conjunction with the until keyword to check the loop condition. This structure ensures that the code within the loop is executed at least once.<br>

<h2> <b>Until</b> </h2>
The until keyword is used in conjunction with the repeat statement to define the condition that terminates the loop. The loop continues to execute until the specified condition evaluates to true. This means that the block of code will keep running until the condition becomes true, making it useful for scenarios where you want the code to execute at least once before checking the condition.<br>

<b>Example</b><br>

<pre>
var
counter: Integer;
{
counter = 1;
repeat
ShowMessage('Counter: ' + IntToStr(counter));
counter = counter + 1;
until counter > 5;
}
</pre>

<h2> <b>For</b> </h2>
The for structure is a control structure used to create a loop under a specific condition. It is ideal for performing a certain number of repetitions or iterating over an array. A for loop typically starts with a variable at a beginning value and progresses to an end value, with a specific increment or decrement on each iteration.<br>

<b>Example</b><br>

<pre>
var
i : Integer;
{
For (i = 1 to 6)
ShowMessage('i = '+IntToStr(i));
}
</pre>

<h2> <b>While</b> </h2>
The while keyword is a control structure used to repeatedly execute a block of code as long as a specific condition is met. This loop continues to run as long as the condition evaluates to true. Due to the fact that the condition is evaluated before entering the loop, it guarantees that the code within the loop may not execute at all if the condition is not satisfied. This is useful for avoiding infinite loops and ensuring a specific state is achieved.<br>

<b>Example</b><br>

<pre>
var
count: Integer;
{
count = 0;
while (count < 5)
{
ShowMessage('Count: ' + IntToStr(count));
count = count + 1;
}
}
</pre>

<h2> <b>With</b> </h2>
The With keyword is a convenience provided by Clomosy for referencing elements of a complex variable, such as a record or object.

It simplifies the code by removing the need to prefix each referenced element with the complex variable name.
See the [[TRObject_Language#With_Statements | With]] keyword for full details.

<h2> <b>Function</b> </h2>

The Function keyword is used to define a function that performs a specific operation and returns a value in a programming language. Functions allow code to be modular, providing the ability to reuse the same operation in different places. See [[TRObject_Language#Function_Declarations | page]] for detailed information.

<h2> <b>Void</b> </h2>
It is used to define a procedure in a programming language that performs a specific task and does not return a value. See the [[TRObject_Language#Procedures]] tutorial for details on using void.

<h2> <b>If</b> </h2>
The If keyword is used to control the flow of code depending on the logical result of the given condition. See [[TRObject_Language#If_Statements | page]] for detailed information.

<h2> <b>Mod</b> </h2>
The Mod keyword gives the remainder from dividing the Dividend by the Divisor. The whole number result of the division is ignored.
See [[Mod | page]] for detailed information.<br><br>

<div class="alert alert-success" role="alert" data-bs-theme="light">
For more detailed information, please refer to the [[TRObject Language | TRObject Language]] page.
</div>
{{#seo:|title=Keywords Found in Clomosy - Clomosy Docs}}
{{#seo:|description=Explore essential keywords in Clomosy to manage control flow, data structures, and operations, ensuring efficient and error-free application development.}}

FormatDateTime

2024-12-24T15:04:10Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function FormatDateTime(const Format: string; DateTime: TclDateTime):string;
</div>

The FormatDateTime function provides rich formatting of a TclDateTime value DateTime into a string. Formatting is defined by the Format string. The Format string can comprise a mix of ordinary characters (that are passed unchanged to the result string), and data formatting characters. This formatting is best explained by the example code.<br>

The following (non-Asian) formatting character strings can be used in the Formatting string:<br>

:<b>y</b> = Year last 2 digits
:<b>yy</b> = Year last 2 digits
:<b>yyyy</b> = Year as 4 digits

:<b>m</b> = Month number no-leading 0
:<b>mm</b> = Month number as 2 digits
:<b>mmm</b> = Month using ShortDayNames (Jan)
:<b>mmmm</b> = Month using LongDayNames (January)

:<b>d</b> = Day number no-leading 0
:<b>dd</b> = Day number as 2 digits
:<b>ddd</b> = Day using ShortDayNames (Sun)
:<b>dddd</b> = Day using LongDayNames (Sunday)
:<b>ddddd</b> = Day in ShortDateFormat
:<b>dddddd</b> = Day in LongDateFormat

:<b>c</b> = Use ShortDateFormat + LongTimeFormat
:<b>h</b> = Hour number no-leading 0
:<b>hh</b> = Hour number as 2 digits
:<b>n</b> = Minute number no-leading 0
:<b>nn</b> = Minute number as 2 digits
:<b>s</b> = Second number no-leading 0
:<b>ss</b> = Second number as 2 digits
:<b>z</b> = Milli-sec number no-leading 0s
:<b>zzz</b> = Milli-sec number as 3 digits
:<b>t</b> = Use ShortTimeFormat
:<b>tt</b> = Use LongTimeFormat

:<b>am/pm</b> = Use after h : gives 12 hours + am/pm
:<b>a/p</b> = Use after h : gives 12 hours + a/p
:<b>ampm</b> = As a/p but TimeAMString,TimePMString
:<b>/</b> = Substituted by DateSeparator value
:<b>:</b> = Substituted by TimeSeparator value

<b>Example</b><br>

<pre>
var
myDate : TDateTime;

{
myDate = '20.02.2023 12:24:26';

ShowMessage('d.m.y = '+FormatDateTime('d.m.y', myDate));
ShowMessage('dd.mm.yy = '+FormatDateTime('dd.mm.yy', myDate));
// Use short names for the day, month, and add freeform text ('of')
ShowMessage('ddd d of mmm yyyy = '+FormatDateTime('ddd d of mmm yyyy', myDate));

// Use long names for the day and month
ShowMessage('dddd d of mmmm yyyy = '+FormatDateTime('dddd d of mmmm yyyy', myDate));

// Use the ShortDateFormat settings only
ShowMessage('ddddd = '+FormatDateTime('ddddd', myDate));

// Use the LongDateFormat settings only
ShowMessage('dddddd = '+FormatDateTime('dddddd', myDate));

ShowMessage('c = '+FormatDateTime('c', myDate));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
d.m.y = 20.2.23<br>
dd.mm.yy = 20.02.23<br>
ddd d of mmm yyyy = Mon 20 of Feb 2023<br>
dddd d of mmmm yyyy = Monday 20 of February 2023<br>
ddddd = 20.02.2023<br>
dddddd = 20 February 2023 Monday<br>
c = 20.02.2023 12:24:26
</div>

<h2> See Also </h2>
* [[System_Library#Date_and_Time_Functions | Date and Time Functions]]
{{#seo:|title=FormatDateTime Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the FormatDateTime function in Clomosy to format TclDateTime values into customized date and time strings for display or processing.}}

Inc

2024-12-24T15:03:09Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
procedure Inc(var X: Integer); overload;
</div>

The Inc procedure increments the ordinal variable parameter passed to it.

<b>Example</b><br>

<pre>
var
Number : Integer;

{
Number = 23;
ShowMessage('Number : '+IntToStr(Number));
Inc(Number);
ShowMessage('Number+1 : '+IntToStr(Number));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Number : 23<br>
Number+1 : 24
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Using Inc in Clomosy - Clomosy Docs}}
{{#seo:|description=Use the Inc procedure in Clomosy to increment an integer variable by one.}}

TclCircle

2024-12-24T15:02:46Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewCircle(AComponent: TCLComponent; xName: string): TclCircle;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined component should be written.<br>

TclCircle represents a graphic element in the shape of a circle or ellipse. It can be used in applications to add various visual effects and features in user interface design.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclCircle|| Circle1 : TclCircle; || A variable belonging to the TclCircle class is created.
|-
|AddNewCircle|| Circle1 = Form1.AddNewCircle(Form1,'Circle1'); || A new TclCircle is added to the form.
|-
|Fill.Kind || Circle1.Fill.Kind = fbkSolid; || It is used to fill the inside of the object. This property determines how the interior fill of the object is applied. The following options can be used:<br>
*<b>fbkNone</b>: Does not fill the inside.
*<b>fbkSolid</b>: Fills the inside with a single color.
*<b>fbkGradient</b>: Fills the inside with a color gradient.
*<b>fbkBitmap</b>: Fills the inside with a bitmap image.
*<b>fbkResource</b>: Fills with a resource file (usually includes image files, text files, database connections, or similar things).
|-
|Fill.Bitmap.WrapMode || Circle1.Fill.Bitmap.WrapMode = fbwmTileOriginal; || It is used to specify a bitmap when filling the inside of the component and to control how this bitmap will be tiled. It determines how the bitmap will be placed and overlapped on a specific area. The following options can be used:<br>
*<b>fbwmTile</b>: The bitmap is tiled to completely fit the area to be filled.
*<b>fbwmTileOriginal</b>: The bitmap is tiled according to its original size, and if it exceeds the boundaries of the area to be filled, it repeats the pattern.
*<b>fbwmTileStretch</b>: The bitmap is stretched to fit the area to be filled and is placed fully within the area.
|-
|Stroke.Thickness || Circle1.Stroke.Thickness = 3; || It is used to set the thickness of the object's border. A value of 0 disables the border.
|}
</div>

<b>Example</b><br>
<pre>
var
Form1:TclGameForm;
Circle1: TclCircle;
{
Form1 = TCLGameForm.Create(Self);

Circle1 = Form1.AddNewCircle(Form1, 'Circle1');
Circle1.Fill.Kind = fbkBitmap;
Circle1.Fill.Bitmap.WrapMode = fbwmTileOriginal;
Circle1.Width = 200;
Circle1.Height = 200;
Circle1.Stroke.Thickness = 3;

Form1.Run;
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclCircle in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the TclCircle component in Clomosy to create customizable circular or elliptical graphics for enhancing user interface designs.}}

LowerCase

2024-12-24T15:02:21Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function LowerCase(const S: string):string;
</div>

Creates a copy of string with all letters converted to lower case.<br>

<b>Example</b><br>

<pre>
var
SimpleString : String;

{
SimpleString = LowerCase('I am learning CLOMOSY.');
ShowMessage(SimpleString);
}
</pre>

<b>Output:</b>
<div class="alert alert-success" role="alert" data-bs-theme="light">
i am learning clomosy.
</div>

<h2> See Also </h2>
* [[System_Library#String_Functions | String Functions]]
{{#seo:|title=LowerCase Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Use the LowerCase function in Clomosy to convert all letters in a string to lowercase, ensuring uniform text formatting.}}

ClMath

2024-12-24T15:01:58Z

ClomosyAdmin:

Performs a specific mathematical or numerical operation.

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"|Definition
|-
|GenerateRandom ||clMath.GenerateRandom(0,500) || It is used to generate random numbers in a specified range. In the example, it generates random numbers between 0 and 500. See [[GenerateRandom | page]] for details.
|}
</div>

<h2> See Also </h2>
* [[System_Library#Cl_Utilities_Functions | Cl Utilities Functions]]
{{#seo:|title=ClMath in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover ClMath in Clomosy, designed to perform precise mathematical and numerical operations effortlessly.}}

Dec

2024-12-24T15:01:33Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
procedure Dec(var X: Integer); overload;
</div>

The Dec procedure decrements the ordinal Variable parameter passed to it.<br>

<b>Example</b><br>

<pre>
var
Number : Integer;

{
Number = 23;
ShowMessage('Number : '+IntToStr(Number));
Dec(Number);
ShowMessage('Number-1 : '+IntToStr(Number));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Number : 23<br>
Number-1 : 22
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Dec Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover the Dec procedure in Clomosy, which decrements the ordinal variable parameter passed to it by one for efficient decrement operations.}}

Copy

2024-12-24T15:01:10Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Copy(S: String; Index: Integer; Count: Integer): string;
</div>

Returns a substring of a string or a segment of a dynamic array.<br>

:<b>S:</b> An expression of a string or dynamic-array type.
:<b>Index and Count:</b> Integer-type expressions.
Copy returns a substring or subarray containing Count characters or elements starting at S[Index]. The substring or subarray is a unique copy (that is, it does not share memory with S; if the elements of the array are pointers or objects, these are not copied). If Index is larger than the length of S, Copy returns an empty string or array.<br>
If Count specifies more characters or array elements than are available, only the characters or elements from S[Index] to the end of S are returned.<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
<b>Notes:</b> Copy uses one-based array indexing even on platforms where strings are zero-based. When S is a dynamic array, you can omit the Index and Count parameters, and Copy copies the entire array.
</div>

<b>Example</b><br>

<pre>
var
Source, Target : string;

{
Source = '12345678';
Target = Copy(Source, 3, 4);
ShowMessage('Target : '+Target);
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Target : 3456
</div>

<h2> See Also </h2>
* [[System_Library#String_Functions | String Functions]]
{{#seo:|title=Copy in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the Copy function in Clomosy to extract a substring or segment of a dynamic array, starting at a specific index with a defined count.}}

Send Email

2024-12-24T15:00:45Z

ClomosyAdmin:

<div class="alert alert-danger" role="alert" data-bs-theme="light">
Only premium accounts can use this.
</div>

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function SendMailNoReplay(TitleStr, BodyStr, UserGUID :String):Boolean;
</div>

SendMailNoReply is used to send an email to the desired email address. When sending the email, the "TitleStr" parameter is used to specify the subject of the email, the "BodyStr" parameter is for the email content, and the final parameter is the recipient's email address.<br>

<b>Example</b><br>

<pre>
var
bodyStr, titleStr,email:string;
{
titleStr = 'Clomosy Information';
bodyStr ='Hello, a personalized email has been sent to you via the Clomosy application.';
email = 'xx@gmail.com';
if Clomosy.SendMailNoReplay(titleStr,bodyStr,email)
ShowMessage('Mail sent.')
else
ShowMessage('Mail could not be sent.');
}
</pre>

<b>Output:</b><br>
[[File:SendMailOutputV1.0.png|frameless|400px]]<br>

<h2> See Also </h2>
* [[Clomosy_Class#Notification_&_Messaging_System | Notification & Messaging System]]
{{#seo:|title=Send Email in Clomosy - Clomosy Docs}}
{{#seo:|description=Use the SendMailNoReplay function in Clomosy to send emails, specifying the subject, content, and recipient email address (available for premium accounts).}}

InputQuery

2024-12-24T15:00:16Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function InputQuery(const Caption, Prompt: string; var UserValue: string):Boolean;
</div>

The InputQuery function displays a simple dialog with the Caption and Prompt message provided. Prompts the user to enter data in a text box in the dialog. If the user presses OK, the entered data is stored in the UserValue variable and the return value is True. If the user cancels the dialog, the return value is False and all entered data is lost.<br>

Use to prompt the user for simple data such as name.<br>

<div class="alert alert-danger" role="alert" data-bs-theme="light">
It is used on Windows and iOS operating systems.
</div>

<b>Example</b><br>

<pre>
var
valueName : string;
{
repeat
if not InputQuery('Project', 'Please type your name', valueName)
ShowMessage('User cancelled the dialog');
until valueName <> '';

ShowMessage('Hello '+valueName);
}
</pre>

<b>Output:</b><br>
[[File:InputQueryExample.png|frameless|400px]]

<h2> See Also </h2>
* [[System_Library#Input-Output_Functions | Input Output Functions]]
{{#seo:|title=Sqr Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the InputQuery function in Clomosy to display a dialog box for user input, storing the response in a variable for simple data collection.}}

Sqr

2024-12-24T14:59:36Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Sqr (Number Integer):Integer;<br>
function Sqr (Number Int64):Int64;<br>
function Sqr (Number Extended):Extended;
</div>

The sqr function returns the square of a number. The number may be an integer or floating point type.<br>

<b>Example</b><br>
In practice, a float variable is squared.<br>

<pre>
var
I,sqrI : float;

{

I = 4.5;
sqrI= Sqr(I);
ShowMessage('Sqr ('+FloatToStr(I)+'):'+FloatToStr(sqrI));

}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Sqr(4,5):20,25
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Sqr Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Use the Sqr function in Clomosy to calculate the square of a number, whether it's an integer, Int64, or a floating-point value.}}

ClTagInt

2024-12-24T14:59:08Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
TCLComponent.ClTagInt :Integer;
</div>

The ClTagInt property is used to store an integer value for any object. It is typically used to carry additional information or identification details specific to the object.

<b>Example</b><br>

<pre>
Var
MyForm:TclForm;
testPanel : TclProPanel;
testBtn : TClProButton;
i : Integer;

void BtnOnClick;
{
ShowMessage(TClProButton(Myform.Clsender).clTagInt);
}

{
MyForm=TclForm.Create(self);
testPanel=MyForm.AddNewProPanel(MyForm,'testPanel');
testPanel.Align = AlCenter;
testPanel.Width = 200;
testPanel.Height = 300;
testPanel.clProSettings.IsRound = True;
testPanel.clProSettings.RoundHeight = 10;
testPanel.clProSettings.RoundWidth = 10;
testPanel.clProSettings.BorderColor = clAlphaColor.clHexToColor('#3a32a8');
testPanel.clProSettings.BorderWidth = 2;
testPanel.SetclProSettings(testPanel.clProSettings);

for (i = 0 to 4)
{
testBtn = MyForm.AddNewProButton(testPanel,'testBtn'+IntToStr(i+1),'');
testBtn.Align = AlTop;
testBtn.caption = 'testBtn'+IntToStr(i+1);
testBtn.Margins.Right = 5;
testBtn.Margins.Left = 5;
testBtn.Margins.Top = 5;
testBtn.Height = 50;
MyForm.SetImage(testBtn,'https://clomosy.com/demos/foodInformationBox.png');

testBtn.clTagInt = i+1;
MyForm.AddNewEvent(testBtn,tbeOnClick,'BtnOnClick');
}

MyForm.Run;
}
</pre>

<h2> See Also </h2>
* [[System_Library#Cl_Utilities_Functions | Cl Utilities Functions]]
{{#seo:|title=ClTagInt Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Use ClTagInt in Clomosy to store integer values for object identification or extra data.}}

ClomosyID

2024-12-24T14:58:17Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Clomosy.ClomosyID :Integer;
</div>

There are two different mobile applications for Clomosy: Clomosy CRM and Clomosy Learn. This feature is used to determine which application you are using. A return value of 0 means that the project was accessed through Clomosy CRM, while a value of 1 indicates that the project was accessed through Clomosy LEARN.<br>

<b>Example</b><br>

<pre>
var
appState : Integer;
{
appState = Clomosy.ClomosyID;
case appState of
{
0 : ShowMessage('Clomosy CRM');
1 : ShowMessage('Clomosy Learn');
}
}
</pre>

<h2> See Also </h2>
* [[Clomosy_Class#System_Function | System Functions]]
{{#seo:|title=ClomosyID in Clomosy - Clomosy Docs }}
{{#seo:|description=Use ClomosyID in Clomosy to identify whether the project is accessed via Clomosy CRM or Clomosy Learn.}}

TclExpander

2024-12-24T14:57:39Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewExpander(AComponent: TCLComponent; xName, xCaption: string): TclExpander;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined component should be written.<br>

<span style="color:blue"><b>xCaption</b></span> : You can add a title.<br>

Included in Clomosy's library, TclExpander is an extensible panel component. TclExpander offers a panel that can hide or open its contents with the click of a title bar by the user. It is also referred to as the accordion content structure.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclExpander || Expander1 :TclExpander; || A variable belonging to the TclExpander class is created.
|-
|AddNewExpander || Expander1 = Form1.AddNewExpander(Form1,'Expander1','Test'); || A new TclExpander is added to the form.
|-
|Width || Expander1.Width = 150; ||Allows adjusting the width of the expander.
|-
|Height || Expander1.Height = 50; ||Allows adjusting the height of the expander.
|-
|Align || Expander1.Align = alTop; ||With the Align parameter, you can specify where you want our component to be aligned in the form. This parameter has multiple positioning properties. See the [[Object_Properties#Align | page]] to learn about these features.
|-
|IsExpanded ||Expander1.IsExpanded = True; || If the application is to be displayed as a drop-down menu when it is run, the IsExpanded property is set to true as follows.
|}
</div>

<b>Example</b><br>
<pre>
var
MyForm:TclStyleForm;
BtnSample:TclButton;
MyVertBox:TClVertScrollBox;
MyExpander1,MyExpander2:TclExpander;
MyLayout1, MyLayout2:TclLayout;
MyLabel1, MyLabel2:TclLabel;

void BtnSampleClick;
{
MyExpander1.IsExpanded = Not MyExpander1.IsExpanded;
MyExpander2.IsExpanded = Not MyExpander2.IsExpanded;
}

void MyExpanderClick;
var
senderExpander:TclExpander;
{
senderExpander = TclExpander(MyForm.clSender);
ShowMessage(senderExpander.Text);
senderExpander.IsExpanded = Not senderExpander.IsExpanded;
}

{
MyForm = TclStyleForm.Create(Self);
MyForm.clSetStyle(MyForm.LightSB);
BtnSample= MyForm.AddNewButton(MyForm,'BtnSample','Add');
BtnSample.Align = alTop;
MyForm.AddNewEvent(BtnSample,tbeOnClick,'BtnSampleClick');

MyVertBox= MyForm.AddNewVertScrollBox(MyForm,'MyVertBox');
MyVertBox.Align = alClient;

MyExpander1= MyForm.AddNewExpander(MyVertBox,'MyExpander1','');
MyExpander1.Align = alTop;
MyExpander1.Height = 100;
MyForm.AddNewEvent(MyExpander1,tbeOnClick,'MyExpanderClick');

MyLayout1= MyForm.AddNewLayout(MyExpander1,'MyLayout1');
MyLayout1.Align = alClient;

MyLabel1= MyForm.AddNewLabel(MyLayout1,'MyLabel1','My Expander Label Caption');
MyLabel1.Align = alTop;

MyExpander2= MyForm.AddNewExpander(MyVertBox,'MyExpander2','');
MyExpander2.Align = alTop;
MyExpander2.Height = 100;
MyForm.AddNewEvent(MyExpander2,tbeOnClick,'MyExpanderClick');

MyLayout2= MyForm.AddNewLayout(MyExpander2,'MyLayout2');
MyLayout2.Align = alClient;

MyLabel2= MyForm.AddNewLabel(MyLayout2,'MyLabel2','My Expander Label Caption 2');
MyLabel2.Align = alTop;

MyForm.Run;

}
</pre>

<b>Output:</b><br>
[[File:TclExpanderScreen.png|frameless|350px]]<br>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclExpander Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover TclExpander in Clomosy, a collapsible panel component for creating toggleable content, perfect for accordion-style interfaces.}}

TclWebBrowser

2024-12-24T14:56:53Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewWebBrowser(AComponent: TCLComponent; xName: string): TclWebBrowser;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined component should be written.<br>

To integrate a web browser using Clomosy, you can use the TclWebBrowser component.<br>

To use it, you should create a form and create a Web Browser inside it.<br>

<pre>
WebBrowser1 = Form1.AddNewWebBrowser(Form1,'WebBrowser1');
</pre>

The 'Navigate' method is used to navigate the browser to the specified URL. This method is used when you want to load a specific web page.<br>

<pre>
WebBrowser1.Navigate('www.google.com');
</pre>

The URL property is used to determine which URL the browser is navigating to. This property returns the URL of the currently loaded page in the browser as a string value.

<pre>
UrlStr = WebBrowser1.URL //UrlStr : String;
</pre>

Using the "goForward" function refers to going to a page in a web browser's history. That means returning to the previous page from an undone step in the browser.<br>

<pre>
WebBrowser1.goForward;
</pre>

It is used to go back from one page. Example: You searched on Google and want to return to the home page.<br>

<pre>
WebBrowser1.goBack;
</pre>

The CanGoBack feature specifies the browser's ability to go backwards. This property returns True if it is possible to go back one page; otherwise it returns False.<br>

<pre>
WebBrowser1.CanGoBack;
</pre>

<b>Example</b><br>
<pre>
Var
MyForm:TclForm;
xWeb:TclWebBrowser;
xBtn,xBtn2 : TCLButton;
xLyt : TclLayout;

void goForwardClick;
{
xWeb.goForward;
}

void goBackClick;
{
if (xWeb.CanGoBack)
ShowMessage('You can return to the page.')
else
ShowMessage('There is no page to go back to.');
xWeb.goBack;
}

{
MyForm = TclForm.Create(Self);

xLyt = MyForm.AddNewLayout(MyForm,'xLyt');
xLyt.Align = alTop;
xLyt.Height = 45;

xBtn2 = MyForm.AddNewButton(xLyt,'xBtn2','goBack');
xBtn2.Align = alLeft;
xBtn2.Width = 70;
MyForm.AddNewEvent(xBtn2,tbeOnClick,'goBackClick');

xBtn = MyForm.AddNewButton(xLyt,'xBtn','goForward');
xBtn.Align = alLeft;
xBtn.Width = 70;
MyForm.AddNewEvent(xBtn,tbeOnClick,'goForwardClick');

xWeb= MyForm.AddNewWebBrowser(MyForm,'xWeb');
xWeb.Align = alClient;
xWeb.Navigate('www.google.com');

MyForm.Run;
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclWebBrowser Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Use TclWebBrowser in Clomosy to integrate a web browser into your app, enabling navigation, forward/backward history, and dynamic URL loading.}}

TclCheckBox

2024-12-24T14:48:53Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewCheckBox(AComponent: TCLComponent; xName, xCaption: string): TclCheckBox;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined chechbox should be written.<br>

<span style="color:blue"><b>xCaption</b></span> : You can add a title.<br>

CheckBox represents a TclCheckBox style checkbox that can be open (selected) or closed (cleared). The CheckBox component gives you a choice. Select the box to turn the option on or clear the box to turn the option off.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclCheckBox || CheckBox1 : TclCheckBox; || A variable belonging to the TclCheckBox class is created.
|-
|AddNewCheckBox || CheckBox1 = Form1.AddNewCheckBox(Form1,'CheckBox1','Test CheckBox Caption'); || A new TclCheckBox is added to the form.
|-
|Width || CheckBox1.Width = 150; ||Allows adjusting the width of the checkbox.
|-
|Height || CheckBox1.Height = 50; ||Allows adjusting the height of the checkbox.
|-
|Align || CheckBox1.Align = alTop; ||With the Align parameter, you can specify where you want our component to be aligned in the form. This parameter has multiple positioning properties. See the [[Object_Properties#Align | page]] to learn about these features.
|-
|Margins || CheckBox1.Margins.Left = 50; // Right, Top, Bottom ||With the Margins parameter, you can give margins at any scale from the right, left, bottom, top.<br>[[File:TclCheckBoxMargins.png|frameless|200px]]<br><br>
|-
|TextSettings || CheckBox1.StyledSettings = ssFamily;<br><br>CheckBox1.TextSettings.FontColor = clAlphaColor.clHexToColor('#8a067c');<br><br>CheckBox1.TextSettings.Font.Size = 20;<br><br>CheckBox1.TextSettings.Font.Style = [fsItalic]; //[fsItalic,fsUnderline] || Text formatting is performed in the component. To see the usage, see [https://www.docs.clomosy.com/index.php/Object_Properties#Text_Settings page].
|-
|Text ||CheckBox1.Text = 'CheckBox''s Text'; || It represents the text within the component. The text entered by the user or set by the program is managed through this property.
|-
|isChecked ||CheckBox1.isChecked = True; || Assign the value True or False to the Checked property to change the checkBox's visual state. As soon as it is correct, it will come selected.
|}
</div>

<h2>Example 1</h2><br>
<pre>
var
MyForm:TclForm;
testButton : TclButton;
testLabel : TclLabel;
testCheckBox,testCheckBox2 : TClCheckBox;

void ButtonClicked;
{
testCheckBox.isChecked = not testCheckBox.isChecked;
testCheckBox2.isChecked = not testCheckBox2.isChecked;
}

{
MyForm = TclForm.Create(Self);
testButton= MyForm.AddNewButton(MyForm,'testButton','Click');
testButton.TextSettings.Font.Size=50;
testButton.Align = alCenter;
testButton.Height = 50;
testButton.Width = 100;

testLabel = MyForm.AddNewLabel(MyForm,'testLabel','Your hobbies?');
testLabel.StyledSettings = ssFamily;
testLabel.TextSettings.Font.Size=25;
testLabel.TextSettings.FontColor = clAlphaColor.clHexToColor('#4a08ff');
testLabel.Align = alMostTop;
testLabel.Height = 30;

testCheckBox = MyForm.AddNewCheckBox(MyForm,'testCheckBox','Reading book');
testCheckBox.StyledSettings = ssFamily;
testCheckBox.TextSettings.Font.Size=15;
testCheckBox.TextSettings.FontColor = clAlphaColor.clHexToColor('#272643');
testCheckBox.Align = alTop;
testCheckBox.Height = 30;

testCheckBox2 = MyForm.AddNewCheckBox(MyForm,'testCheckBox2','Watching movie');
testCheckBox2.StyledSettings = ssFamily;
testCheckBox2.TextSettings.Font.Size=15;
testCheckBox2.TextSettings.FontColor = clAlphaColor.clHexToColor('#272643');
testCheckBox2.Align = alTop;
testCheckBox2.Height = 30;

MyForm.AddNewEvent(testButton,tbeOnClick,'ButtonClicked');

MyForm.Run;
}
</pre>

<b>Output:</b><br>
[[File:CheckBox.png|frameless|450px]]<br>

<h2>Example 2</h2><br>
Here is an example similar to the first one. It only involves the clicking of a checkbox component.<br>

<pre>
var
Form1:TclForm;
Label1 : TclLabel;
CheckBox1,CheckBox2 : TClCheckBox;

void CheckBoxClicked;
var
senderCheckBox:TClCheckBox;
{
senderCheckBox = TClCheckBox(Form1.Clsender);
if senderCheckBox.clTagInt == 1 //CheckBox1 kontrol
CheckBox2.isChecked = senderCheckBox.isChecked
else if senderCheckBox.clTagInt == 2 //CheckBox1 kontrol
CheckBox1.isChecked = senderCheckBox.isChecked
}

{
Form1 = TclForm.Create(Self);

Label1 = Form1.AddNewLabel(Form1,'Label1','Your hobbies?');
Label1.StyledSettings = ssFamily;
Label1.TextSettings.Font.Size=25;
Label1.TextSettings.FontColor = clAlphaColor.clHexToColor('#4a08ff');
Label1.Align = alMostTop;
Label1.Height = 30;

CheckBox1 = Form1.AddNewCheckBox(Form1,'CheckBox1','Reading book');
CheckBox1.StyledSettings = ssFamily;
CheckBox1.TextSettings.Font.Size=15;
CheckBox1.TextSettings.FontColor = clAlphaColor.clHexToColor('#272643');
CheckBox1.Align = alTop;
CheckBox1.Height = 30;
CheckBox1.clTagInt = 1;

CheckBox2 = Form1.AddNewCheckBox(Form1,'CheckBox2','Watching movie');
CheckBox2.StyledSettings = ssFamily;
CheckBox2.TextSettings.Font.Size=15;
CheckBox2.TextSettings.FontColor = clAlphaColor.clHexToColor('#272643');
CheckBox2.Align = alTop;
CheckBox2.Height = 30;
CheckBox2.clTagInt = 2;
Form1.AddNewEvent(CheckBox2,tbeOnClick,'CheckBoxClicked');
Form1.AddNewEvent(CheckBox1,tbeOnClick,'CheckBoxClicked');

Form1.Run;
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclCheckBox Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover TclCheckBox in Clomosy, a customizable checkbox component allowing selection or deselection, ideal for user choices in forms and interfaces.}}

TclProImage

2024-12-24T14:46:40Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewProImage(AComponent: TCLComponent; xName: string): TClProImage;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined image should be written.<br>

TclProImage is used to add an image to a form. Adding visuals to an application makes it more attractive and user-friendly.<br>
All of the TclImage features are available. Apart from this, border color, rounding borders, image stretching and fitting features are available. <br>

<div class="alert alert-info" role="alert" data-bs-theme="light">
Refer to the [[TclImage]] page for standard image usage.
</div>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclProImage || ProImage1 : TclProImage; || A variable belonging to the TclProImage class is created.
|-
|AddNewProImage || ProImage1 = Form1.AddNewProImage(Form1,'ProImage1'); || A new image is added to the form.
|}
</div>

In addition to the features of a standard image, TclProImage offers new and advanced features, which we will explain in detail below.<br>

<div class="row">
<div class="col-lg-6">
<div class="card d-flex flex-column justify-content-start gap-1 mb-3 h-100" style="padding: 3;">
<div style="font-size: 16px;font-weight: bold;text-align:left;">
clProSettings Properties
</div>
<div style="font-size: 14px;font-weight: normal;text-align:justify; max-width: 350px;">
<li>BorderColor</li>
<li>BorderWidth</li>
<li>BackgroundColor</li>
<li>IsTransparent</li>
<li>IsFill</li>
<li>IsRound</li>
<li>RoundHeight</li>
<li>RoundWidth</li>
<li>PictureAutoFit</li>
<li>PictureStretch</li>
<li>PictureSource</li>
</div>
</div>
</div>
<div class="col-lg-6">
<div class="card d-flex flex-column justify-content-start gap-1 mb-3 h-100" style="padding: 3;">
<div style="font-size: 16px;font-weight: bold;text-align:left;">
SetupComponent Properties
</div>
<div style="font-size: 14px;font-weight: normal;text-align:justify; max-width: 350px;">
<li>Width</li>
<li>Height</li>
<li>PositionX</li>
<li>PositionY</li>
<li>Align</li>
<li>BackgroundColor</li>
<li>MarginTop</li>
<li>MarginBottom</li>
<li>MarginRight</li>
<li>MarginLeft</li>
<li>RoundHeight</li>
<li>RoundWidth</li>
<li>BorderColor</li>
<li>BorderWidth</li>
<li>ImgFit</li>
<li>ImgStretch</li>
<li>ImgUrl</li>
</div>
</div>
</div>
</div>
<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
To learn the purpose and usage of the <b>SetupComponent</b> and <b>clProSettings</b> properties, please refer to [[Pro Object Properties| the page]].
</div>

<b>Example</b><br>

For clProSettings:<br>
<pre>
Var
Form1:TclForm;
ProImg1: TClProImage;

void SetImage;
{
ProImg1 = Form1.AddNewProImage(Form1,'ProImg1');
ProImg1.Align = alCenter;
ProImg1.Width = 150;
ProImg1.Height = 150;
ProImg1.clProSettings.BorderColor = clAlphaColor.clHexToColor('#fabd2');
ProImg1.clProSettings.RoundHeight = 10;
ProImg1.clProSettings.RoundWidth = 10;
ProImg1.clProSettings.BorderWidth = 2;
ProImg1.clProSettings.IsFill = True;
ProImg1.clProSettings.IsRound = True;
ProImg1.clProSettings.PictureSource = 'https://clomosy.com/demos/computerNetwork.png';
ProImg1.clProSettings.PictureAutoFit = True;
ProImg1.SetclProSettings(ProImg1.clProSettings);
}

{
Form1 = TclForm.Create(Self);
SetImage;
Form1.Run;
}
</pre>

For SetupComponent:<br>
<pre>
Var
Form1:TclForm;
ProImg1: TClProImage;

void SetImage;
{
ProImg1 = Form1.AddNewProImage(Form1,'ProImg1');
clComponent.SetupComponent(ProImg1,'{
"Align" : "Center",
"Width":150,
"Height":150,
"BorderColor":"#fabd2",
"BorderWidth":2,
"RoundHeight":10,
"RoundWidth":10,
"ImgUrl":"https://clomosy.com/demos/computerNetwork.png",
"ImgFit":"yes"
}');
}

{
Form1 = TclForm.Create(Self);
SetImage;
Form1.Run;
}
</pre>

<b>Output:</b><br>
[[File:ProImage.png|frameless|450px]]<br>

<h2> See Also </h2>
* [[Components]]
* [[Pro Object Properties]]
* [[Object Properties]]
{{#seo:|title=TclProImage Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover TclProImage in Clomosy, a versatile image component with advanced features like border customization, rounded edges, and image fitting options.}}

Random

2024-12-24T14:45:39Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Random: Extended;
</div>

The random function generates random numbers. These can be floating-point numbers in the following range:<br>
0 <= Number < 1.0 <br>

It can be used by calling as follows. This call will generate a decimal random number value between 0 and 1.<br>
x = Random();

If you want to get an integer value, define it as follows. Here it will return a random value between 0 and 100. After that, you can get values as you want.<br>
x = Random() * 100;

<b>Example</b><br>

<pre>
var
randomNumber,randomNumber2 : Integer;

{
randomNumber = Random();
randomNumber2 = Random() * 100;
ShowMessage(randomNumber);
ShowMessage(randomNumber2);
}
</pre>

<div class="alert alert-danger" role="alert" data-bs-theme="light">
It assigns a different value with each execution. The output will not be the same.
</div>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
To generate a random number where you can specify the start and end values, visit the [[GenerateRandom|GenerateRandom]] page.
</div>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
0,197623564163223<br>
52,8056032489985
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Random Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Use the Random function in Clomosy to generate floating-point random numbers between 0 and 1, or scale it for custom ranges like integers.}}

TclMemo

2024-12-24T14:44:43Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewMemo(AComponent: TCLComponent; xName,xCaption: string): TclMemo;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined TclMemo should be written.<br>

<span style="color:blue"><b>xCaption</b></span> : A hint or message to be displayed when the Text property is empty.<br>

TclMemo is a multiline text editing control, providing text scrolling. Use TclMemo to place a standard multiline edit control on a form. Multiline edit boxes allow the user to enter more than one line of text. They are appropriate for representing large amounts of text. The text in the memo control can be edited as a whole or line by line.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclMemo || Memo1 : TclMemo; || A variable belonging to the TclMemo class is created.
|-
|AddNewMemo || Memo1 = Form1.AddNewMemo(Form1,'Memo1','Test Memo Message'); || A new TclMemo is added to the form.
|-
|Width || Memo1.Width = 150; ||Allows adjusting the width of the memo.
|-
|Height || Memo1.Height = 50; ||Allows adjusting the height of the memo.
|-
|Align || Memo1.Align = alTop; ||With the Align parameter, you can specify where you want our component to be aligned in the form. This parameter has multiple positioning properties. See the [[Object_Properties#Align | page]] to learn about these features.
|-
|Margins || Memo1.Margins.Left = 50; // Right, Top, Bottom ||With the Margins parameter, you can give margins at any scale from the right, left, bottom, top.<br>[[File:TclEditMargins.png|frameless|200px]]<br><br>
|-
|TextSettings || Memo1.StyledSettings = ssFamily;<br>Memo1.TextSettings.FontColor = clAlphaColor.clHexToColor('#8a067c');<br>Memo1.TextSettings.Font.Size = 20;<br>Memo1.TextSettings.Font.Style = [fsItalic]; //[fsItalic,fsUnderline] || Text formatting is performed in the component. To see the usage, see [https://www.docs.clomosy.com/index.php/Object_Properties#Text_Settings page].
|-
|Text || Memo1.Text = 'TclMemo is a multiline text editing control, providing text scrolling. Use TclMemo to place a standard multiline edit control on a form. Multiline edit boxes allow the user to enter more than one line of text. They are appropriate for representing large amounts of text. The text in the memo control can be edited as a whole or line by line.'; || It is used to enter single line text in TclMemo.
|-
|ReadOnly ||Memo1.ReadOnly = True; || If the value of the component is set to true, it makes the component read-only.
|-
|Add ||Memo1.Lines.Add('New row'); || 'Add' is used to add data to new row in TclMemo.
|-
|Count ||integerValue = Memo1.Lines.Count; || 'Count' is used to get the number of rows in TclMemo.
|-
|Delete ||Memo1.Lines.Delete(i); //i : number of rows to be deleted || Used to delete a line in TclMemo. You must specify the number of rows as a parameter in the delete command.
|-
|WordWrap || Memo1.TextSettings.WordWrap = True; || When a very long text is typed in TclMemo, the line scrolls sideways. It is used to prevent this, that is, to move to the bottom row when the end of the row is reached.
|-
|SelStart ||Memo1.SelStart = Length(Memo1.Text); || It positions the cursor at the end of the text by setting the length of the text within the TclMemo.
|-
| LoadFromFile ||Memo1.lines.LoadFromFile(MyFileStr,0); //MyFileStr: specifies the file path || Using the Lines property of the TclMemo component in Clomosy, text can be loaded from a file. The LoadFromFile method loads the text from the specified file path into the TclMemo component, and this text is then displayed within the component.
|-
|SavetoFile ||Memo1.Lines.SavetoFile(MyFileStr,0); || Using the Lines property of the TclMemo component in Clomosy, text can be saved to a file. The SaveToFile method writes the lines of text from the TclMemo component to the specified file path. Passing 0 as the second parameter indicates that the operation will be performed with default options.
|}
</div>

<h2>Example 1</h2><br>
In the example, a text is entered into a TclProEdit. This text is added to TclMemo via the button. We have implemented a simple application for the use of TclMemo. You can improve this application.<br>

<pre>
var
MyForm:TclForm;
topLyt, btnLyt, bottomLyt : TclLayout;
noteEdt : TclProEdit;
addBtn : TclProButton;
noteAddLbl, notesLbl :TclProLabel;
mainPanel : TclProPanel;
noteMemo : TclMemo;

void BtnOnClick;
{
noteMemo.Lines.Add('* '+noteEdt.Text);
noteEdt.Text = '';
}

{
MyForm = TclForm.Create(Self);

mainPanel=MyForm.AddNewProPanel(MyForm,'mainPanel');
mainPanel.Align = AlClient;
mainPanel.Margins.Right = 5;
mainPanel.Margins.Left = 5;
mainPanel.Margins.Bottom = 5;
mainPanel.Margins.Top = 5;
mainPanel.clProSettings.IsRound = True;
mainPanel.clProSettings.RoundHeight = 60;
mainPanel.clProSettings.BorderColor = clAlphaColor.clHexToColor('#3bf5c0');
mainPanel.clProSettings.BorderWidth = 1;
mainPanel.SetclProSettings(mainPanel.clProSettings);

topLyt = MyForm.AddNewLayout(mainPanel,'topLyt');
topLyt.Align=ALMostTop;
topLyt.Height = 150;

noteAddLbl = MyForm.AddNewProLabel(topLyt,'noteAddLbl','Add Note');
noteAddLbl.Align = AlMostTop;
noteAddLbl.Width = 150;
noteAddLbl.Height = 20;
noteAddLbl.Margins.Left = 10;
noteAddLbl.Margins.Top = 20;
noteAddLbl.clProSettings.FontColor = clAlphaColor.clHexToColor('#030303');
noteAddLbl.clProSettings.FontSize = 15;
noteAddLbl.clProSettings.FontVertAlign = palcenter;
noteAddLbl.clProSettings.FontHorzAlign = palLeading;
noteAddLbl.clProSettings.TextSettings.Font.Style = [fsBold];
noteAddLbl.SetclProSettings(noteAddLbl.clProSettings);

noteEdt = MyForm.AddNewProEdit(topLyt,'noteEdt','Enter your note...');
noteEdt.Align = AlTop;
noteEdt.Height = 45;
noteEdt.Margins.Right = 10;
noteEdt.Margins.Left = 10;
noteEdt.Margins.Top = 10;
noteEdt.clProSettings.IsRound = True;
noteEdt.clProSettings.RoundHeight = 10;
noteEdt.clProSettings.RoundWidth = 10;
noteEdt.clProSettings.BorderColor = clAlphaColor.clHexToColor('#3bf5c0');
noteEdt.clProSettings.BorderWidth = 1;
noteEdt.SetclProSettings(noteEdt.clProSettings);

btnLyt = MyForm.AddNewLayout(topLyt,'btnLyt');
btnLyt.Align=ALBottom;
btnLyt.Height = 50;

addBtn = MyForm.AddNewProButton(btnLyt,'addBtn','');
addBtn.Align = AlRight;
addBtn.Width = 70;
addBtn.Margins.Right = 10;
addBtn.clProSettings.PictureSource = 'https://clomosy.com/demos/add-list.png';
addBtn.SetclProSettings(addBtn.clProSettings);
MyForm.AddNewEvent(addBtn,tbeOnClick,'BtnOnClick');

bottomLyt = MyForm.AddNewLayout(mainPanel,'bottomLyt');
bottomLyt.Align=ALTop;
bottomLyt.Height = 100;
bottomLyt.Margins.Top = 20;

notesLbl = MyForm.AddNewProLabel(bottomLyt,'notesLbl','My Notes');
notesLbl.Align = AlMostTop;
notesLbl.Width = 150;
notesLbl.Height = 20;
notesLbl.Margins.Left = 10;
notesLbl.Margins.Top = 20;
notesLbl.clProSettings.FontColor = clAlphaColor.clHexToColor('#030303');
notesLbl.clProSettings.FontSize = 15;
notesLbl.clProSettings.FontVertAlign = palcenter;
notesLbl.clProSettings.FontHorzAlign = palLeading;
notesLbl.clProSettings.TextSettings.Font.Style = [fsBold];
notesLbl.SetclProSettings(notesLbl.clProSettings);

noteMemo = MyForm.AddNewMemo(bottomLyt,'noteMemo','');
noteMemo.Align = alTop;
noteMemo.Height = 200;
noteMemo.Width = 150;
noteMemo.Margins.Left= 10;
noteMemo.Margins.Right= 10;
noteMemo.Margins.Top= 10;
noteMemo.ReadOnly = True;
noteMemo.TextSettings.WordWrap = True;

MyForm.Run;
}
</pre>

<b>Output:</b><br>
[[File:TclMemoExampleScreen.png|frameless|500px]]<br>

<h2>Example 2 (LoadFromFile):</h2><br>
The example creates a form (TclForm) and a memo component (TclMemo), and adds data to a text file at a specified file path, then loads this data into the memo component. First, the Form1 and Memo1 objects are created, and the memo component is added to the form. The SaveFileAndAddData procedure opens or rewrites the file.txt file at the specified file path, adds two lines of text, and then closes the file. In the main program block, if the file.txt file does not exist, the SaveFileAndAddData procedure is called to create the file. Then, the contents of the file.txt file are loaded into the Memo1 component using LoadFromFile.<br>

<pre>
var
Form1 : TclForm;
Memo1: TclMemo;
MyFileStr: string;

void SaveFileAndAddData;
var
myFile : TextFile;
{
AssignFile(myFile, Clomosy.AppFilesPath+'file.txt');
ReWrite(myFile);
WriteLn(myFile, 'Task 1');
WriteLn(myFile, 'Task 2');
ShowMessage('Lines have been added to the file.');
CloseFile(myFile);
}

{
Form1 = TclForm.Create(self);
Memo1 = Form1.AddNewMemo(Form1,'Memo1', '--');
Memo1.Align = alCenter;
Memo1.Height = Form1.clHeight/2;
Memo1.Width = 300;
try
If not (clFileExists('file.txt',Clomosy.AppFilesPath))
SaveFileAndAddData;

MyFileStr = Clomosy.AppFilesPath+'file.txt';

// Upload file to Memo1
Memo1.Lines.LoadFromFile(MyFileStr, 0);

except
ShowMessage('Exception Class: '+LastExceptionClassName+' Exception Message: '+LastExceptionMessage);
}

Form1.Run;
}
</pre>

<h2>Example 3 (SaveToFile):</h2><br>
The example creates a form (TclForm) and a memo component (TclMemo), and writes text to a file at a specified path, then saves this text to the memo component. First, the Form1 and Memo1 objects are created, and the memo component is added to the form. The MyFileStr variable specifies the path to the text file. The program opens the file with AssignFile if it does not already exist, and adds three lines of text to the Memo1 component. Then, the SaveToFile method is used to save this text to the saveFile.txt file.<br>

<pre>
var
Form1 : TclForm;
Memo1: TclMemo;
MyFileStr: string;
myFile : TextFile;

{
Form1 = TclForm.Create(self);
Memo1 = Form1.AddNewMemo(Form1,'Memo1', '---');
Memo1.Align = alCenter;
Memo1.Height = Form1.clHeight/2;
Memo1.Width = 300;

MyFileStr = Clomosy.AppFilesPath+'saveFile.txt';
try
If not (clFileExists('saveFile.txt',Clomosy.AppFilesPath))
AssignFile(myFile, Clomosy.AppFilesPath+'saveFile.txt');

Memo1.Lines.Add('Row 1');
Memo1.Lines.Add('Row 2');
Memo1.Lines.Add('Row 3');
// Upload saveFile to Memo1
Memo1.Lines.SaveToFile(MyFileStr, 0);

except
ShowMessage('Exception Class: '+LastExceptionClassName+' Exception Message: '+LastExceptionMessage);
}

Form1.Run;
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclMemo Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Explore TclMemo in Clomosy, a multiline text editor for large text, with features like formatting, word wrap, and file load/save capabilities.}}

TclLayout

2024-12-24T14:43:08Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewLayout(AComponent: TCLComponent; xName: string): TclLayout;
</div>
<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined layout should be written.<br>

It is used to arrange other components on the form. Simply put, it is used to organize buttons, labels, and other visual elements in a specific layout on a form. This layout automatically adjusts the size and position of the components, making the form appear more organized and aesthetically pleasing. TclLayout is particularly useful when creating dynamic user interfaces and adapting to different screen sizes.<br>

The features and usage are provided in the table below.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TclLayout || Layout1 : TclLayout; || A variable belonging to the TclLayout class is created.
|-
|AddNewLayout || Layout1 = Form1.AddNewLayout(Form1,'Layout1'); || A new TclLayout is added to the form.
|-
|Width || Layout1.Width = 150; ||Allows adjusting the width of the layout.
|-
|Height || Layout1.Height = 50; ||Allows adjusting the height of the layout.
|-
|Align || Layout1.Align = alTop; ||With the Align parameter, you can specify where you want our component to be aligned in the form. This parameter has multiple positioning properties. See the [[Object_Properties#Align | page]] to learn about these features.
|-
|Margins || Layout1.Margins.Left = 50; // Right, Top, Bottom ||With the Margins parameter, you can give margins at any scale from the right, left, bottom, top.<br>[[File:PanelAppearance.png|frameless|200px]]<br><br>
|}
</div>

<b>Example</b><br>
<pre>
Var
MyForm:TclForm;
Panel1 : TclPanel;
Layout1 : TclLayout;
Edit1 : TclEdit;

{

MyForm=TclForm.Create(self);

Panel1=MyForm.AddNewPanel(MyForm,'Panel1');
Panel1.Align=ALTop;
Panel1.Height=100;

Layout1 = MyForm.AddNewLayout(Panel1,'Layout1');
Layout1.Align=ALCenter;
Layout1.Height = 50;

Edit1 = MyForm.AddNewEdit(Layout1,'Edit1','Write something...');
Edit1.Align=aLLeft;
Edit1.Width = 150;

MyForm.Run;

}
</pre>

<b>Output:</b><br>
[[File:Layout.png|frameless|450px]]<br>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclLayout Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover TclLayout in Clomosy, a component used to organize buttons, labels, and visuals, ensuring dynamic and responsive user interface design.}}

StrToInt

2024-12-24T14:36:04Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function StrToInt(const S: string):Integer;
</div>

The StrToInt, it converts a string data (S) to an integer value.<br>

<b>Example</b><br>

<pre>
var
firstNumber,secondNumber,result : Integer;

{

firstNumber = StrToInt('100');
secondNumber = StrToInt('200');
result = firstNumber + secondNumber;

ShowMessage('Result : '+IntToStr(result));

}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Result : 300
</div>

<h2> See Also </h2>
* [[System_Library#Type_Conversion_Functions | Type Conversion Functions]]
{{#seo:|title=StrToInt Using in Clomsy - Clomosy Docs}}
{{#seo:|description=Use the StrToInt function in Clomosy to convert string data into an integer, enabling arithmetic operations with ease.}}

Cos

2024-12-24T14:34:25Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function Cos(const X: Extended): Extended;
</div>

Calculates the cosine of an angle.<br>
In Clomosy code, Cos returns the cosine of the angle X.<br>
X is a real-type expression that represents an angle in radians.<br>
PI radians = 180 degrees<br>

<b>Example</b><br>

<pre>
var
floatValue : single;

const
PI = 3.14;

{
// The Sine of 60 degrees = 0.5
floatValue = Cos(PI/3); // = 180/3 = 60 degrees
ShowMessage('Cos(PI/3) = '+FloatToStr(floatValue));
}
</pre>

<b>Output:</b><br>
<div class="alert alert-success" role="alert" data-bs-theme="light">
Cos(PI/3) = 0,500459689008206
</div>

<h2> See Also </h2>
* [[System_Library#Math_Functions | Math Functions]]
{{#seo:|title=Cos Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Use the Cos function in Clomosy to calculate the cosine of an angle in radians, essential for trigonometric operations.}}

TclButton

2024-12-24T14:32:36Z

ClomosyAdmin:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewButton(AComponent: TCLComponent; xName, xCaption: string): TclButton;
</div>

<span style="color:blue"><b>AComponent</b></span> : Specifies the parent of the object to be defined.<br>

<span style="color:blue"><b>xName</b></span> : The name of the defined button should be written.<br>

<span style="color:blue"><b>xCaption</b></span> : You can add a title.<br>

It is a component used to perform a specific action in the user interface. When a button is placed on the form, it allows the user to trigger a particular function by clicking it. For example, a "Save" button can be added to allow data to be saved.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Feature !!style="background-color: #c3d7e0"| Use of !!style="background-color: #c3d7e0"| Definition
|-
|TClButton || Button1 : TclButton; || A variable belonging to the TclButton class is created.
|-
|AddNewButton || Button1 = Form1.AddNewButton(Form1,'Button1','Test Button Caption'); || A new TclButton is added to the form.
|-
|Width || Button1.Width = 150; ||Allows adjusting the width of the button.
|-
|Height || Button1.Height = 50; ||Allows adjusting the height of the button.
|-
|Align || Button1.Align = alTop; ||With the Align parameter, you can specify where you want our component to be aligned in the form. This parameter has multiple positioning properties. See the [[Object_Properties#Align | page]] to learn about these features.
|-
|Margins || Button1.Margins.Left = 50; // Right, Top, Bottom ||With the Margins parameter, you can give margins at any scale from the right, left, bottom, top.<br>[[File:TclButtonMargins.png|frameless|200px]]<br><br>
|-
|Caption || Button1.Caption = 'Button Caption'; || It represents the text displayed on the component. The Caption specifies the textual label that the component presents to the user.
|-
|Text || Button1.Text = 'Button's Text'; || It represents the text within the component. The text entered by the user or set by the program is managed through this property.
|-
|TextSettings || Button1.StyledSettings = ssFamily;<br><br>Button1.TextSettings.FontColor = clAlphaColor.clHexToColor('#8a067c');<br><br>Button1.TextSettings.Font.Size = 20;<br><br>Button1.TextSettings.Font.Style = [fsItalic]; //[fsItalic,fsUnderline] || Text formatting is performed in the component. To see the usage, see [https://www.docs.clomosy.com/index.php/Object_Properties#Text_Settings page].
|}
</div>

<b>Example</b><br>
<pre>
var
MyForm:TclForm;
testButton : TclButton;

{
MyForm = TclForm.Create(Self);
testButton= MyForm.AddNewButton(MyForm,'testButton','Click');
testButton.TextSettings.Font.Size=50;
testButton.Align = alCenter;
testButton.Height = 50;
testButton.Width = 100;

MyForm.AddNewEvent(testButton,tbeOnClick,'ShowMessage(''Hello'');');

MyForm.Run;

}
</pre>

<b>Output:</b><br>
[[File:Button.png|frameless|450px]]<br>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclButton Using in Clomosy - Clomosy Docs}}
{{#seo:|description=Discover TclButton in Clomosy, a versatile component for triggering actions in the UI, with customizable size, alignment, margins, and text formatting.}}