Clomosy Docs - User contributions [en]

TclScaledLayout

2025-11-26T12:40:08Z

Salih:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewScaledLayout(AComponent: TCLComponent; xName: string): TclScaledLayout;
</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 ScaledLayout should be written.<br>

It is used to arrange and proportionally scale other components on the form. Simply put, it ensures that buttons, labels, and other visual elements maintain their relative size and position when the form is resized.

This layout automatically scales and adjusts its contents, making the interface consistent and visually balanced across different screen resolutions. TCLScaledLayout is particularly useful when designing responsive or resolution-independent user interfaces.
<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
|-
|TclScaledLayout || ScaledLayout1 : TclScaledLayout; || A variable belonging to the TclScaledLayout class is created.
|-
|AddNewScaledLayout || ScaledLayout1 = Form1.AddNewScaledLayout(Form1,'ScaledLayout1'); || A new TclScaledLayout is added to the form.
|-
|OriginalWidth || ScaledLayout1.OriginalWidth = 150; ||Defines the reference (unscaled) width of the layout, used as the base for scaling its child components.
|-
|OriginalHeight || ScaledLayout1.OriginalHeight = 50; ||Defines the reference (unscaled) height of the layout, used as the base for scaling its child components.
|-
|Align || ScaledLayout1.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 || ScaledLayout1.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;
ScaledLayout:TclScaledLayout;
I:Integer;
testButton:TCLButton;
{
MyForm=TclForm.Create(self);

ScaledLayout = MyForm.AddNewScaledLayout(MyForm,'ScaledLayout');
ScaledLayout.Align = alClient;

ScaledLayout.OriginalHeight = 900;
ScaledLayout.OriginalWidth = 400; //Approximately the aspect ratio of a phone screen

for (I = 0 to 1) {
testButton = MyForm.AddNewButton(ScaledLayout,'testButton'+IntToStr(I),'Button'+IntToStr(I));
testButton.Align = alTop;
}

MyForm.Run;
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[TclLayout]]

{{#seo:|title=TclScaledLayout Using in Clomosy - Clomosy Docs}}
{{#seo:|description= Learn how TclScaledLayout automatically scales and arranges visual components, keeping interface proportions consistent across different resolutions.}}

Seminar Demos

2025-11-07T07:31:16Z

Salih:

<div class="alert alert-success" role="alert" data-bs-theme="light">
The examples prepared during the Clomosy seminar event are provided below.<br>
These examples were created to demonstrate the features of the Clomosy platform. As Clomosy developers, you can enhance these examples and utilize the features in other applications.
</div>

<h2> Hello World Example </h2>
Let the first example you do in the Clomosy development environment be the Hello World example.<br>
That way, you get started with the easy step.<br>
In this application, a form and a button are created. When the button is clicked, it triggers a procedure. In this procedure, a loop iterates 6 times. Within this loop, a conditional statement (case) generates different outcomes for each value.<br>

<b>Code:</b><br>
<pre>
var
MyForm:TclForm;
I:integer;
startBtn:TCLButton;

void StartBtnOnClick;
{
for (I = 1 to 6)
{
case I of
{
1:ShowMessage('Hello World');
2:ShowMessage('Number 2');
else
{
ShowMessage('Others=> counter: '+IntToStr(I));
}
}

}
}

{
MyForm = TclForm.Create(Self);

startBtn= MyForm.AddNewButton(MyForm,'startBtn','SHOW');
startBtn.TextSettings.Font.Size=50;
startBtn.Align = alCenter;
startBtn.Height = 50;
startBtn.Width = 100;
MyForm.AddNewEvent(startBtn,tbeOnClick,'StartBtnOnClick');

MyForm.Run;
}
</pre>

<h2> Web Browser App </h2>

The programs used to access internet pages are called browser or web browser. Using Clomosy with the [[TclWebBrowser]] component, we can access any website we want.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/WebBrowser Web Browser App]
<b>Output:</b><br>
[[File:WebBrowserExample.jpg|frameless|300px]]

<h2> Clothing Selection App </h2>
By using color palettes in the application, you can create a combination by selecting the color of the clothes you wear. You can also choose your gender in the application. As you click on the colors, the colors change. If you want to get the code of a color you like, just click on the area where the color code text is located.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/ColorCombination Clothing Selection App]

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

<h2> Body Mass Index (BMI) Calculator App </h2>

In this application, the body mass index is calculated by entering the weight, height and gender of the person and clicking the confirmation button. According to calculations, it gives messages such as weak, normal, overweight and obese. In addition, the picture below changes according to the weight.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/BodyMassIndexApp Body Mass Index (BMI) Calculator App]

<b>Output:</b><br>
[[File:BodyMassIndexCalculatorExample.png|frameless|300px]]

<h2> QR Personnel Attendance Control System Application </h2>
The purpose of this example is to keep track of the arrival and departure times of employees in businesses. Special devices and software are required for these operations. We have made all the work possible with a simple processing through clomosy.<br>
*A tablet produces a changing QR code, preventing any irregularities. We have also solved the problem of reading in different locations by changing the code every 10 seconds. An administrator in the project must be responsible for generating the QR code.
*The personnel can arrive and scan the QR code with their phones.
*The registration process and scanned time of the personnel are recorded on the administrator's screen. (The administrator must log in through Windows.)

<b>Link:</b><br>
: [https://github.com/Clomosy/QR QR Personnel Attendance Control System Application]

<h2> IOT App </h2>
:'''<span style="color:blue">What is IOT?</span>'''
The Internet of Things (IoT) describes the network of physical objects embedded with sensors, software, and other technologies for the purpose of connecting and sharing data with other devices and systems over the Internet. These devices range from ordinary household objects to advanced industrial tools.<br>

We use the MQTT protocol to enable IoT devices to communicate with each other on Clomosy. So what is MQTT, see [[MQTT]] page for detailed information.<br>

In this example, we transmit the code embedded in Raspberry Pi technology to the server with the help of MQTT protocol over Clomosy. By providing communication in this way, we can connect to the Raspberry remotely and turn our led on and off.<br>

Information: It is necessary to write the desired codes into the Raspberry Pi system. For this, we coded in Python and integrated the activation code of our Clomosy project. In this way, we established our connection.

<b>Link:</b><br>
: [https://github.com/Clomosy/iot-demo IOT App]

<b>Output:</b><br>
[[File:IotMqttExample.png|frameless|300px]]

<h2> Messaging App - MQTT </h2>

It is an messaging application made for different devices to communicate with each other with MQTT.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/Mqtt Messaging App]

<b>Output:</b><br>
[[File:MessagingExample.jpg|frameless|300px]]

<h2> Gyroscope Ufo Game </h2>
Before we get into the game, let's understand what a gyroscope is.

:<span style="color:blue"> What is Gyroscope? </span>

The gyroscope sensor is a system that can detect angular velocity. In other words, the rotation direction and speed of a stationary object are determined by comparing the angular ratios in three vertical axes. It processes the data it detects with the help of the processor and converts it into electrical signals. The gyroscope works on the principle of maintaining angular balance, which is used to measure or adjust direction. The basis of gyroscopic motion is based on the laws of physics and the principle of centrifugation. For these reasons, it allows us to perform instant movements faster.<br>

Cell phone, tablet etc. It is integrated in technological devices and is a system that we use a lot in applications, games and 3D software. It is used in applications such as car races, game consoles, camera sensitivity adjustment in photo shoots and navigation that we steer by turning left and right on mobile phones.<br><br>

In the game, we reach x, y location information by directing our device with the gyroscope method. Afterwards, when we bring the UFO to the desired area, the game is over. It is used in 2 different features in the game. These; Device vibration and device sound effect.<br>

A simple game has been developed using the gyroscope feature. In this way, you can develop the games you want.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/jireskop Gyroscope Ufo Game]

<h2> Word Game </h2>

The game is started by pressing the "START" button. Then, questions with 5-letter answers are drawn from the database. In this way, it is tried to find the desired word in the game. There are 3 rights and 1 hint in a game. When these rights expire, you save and the game is reset.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/WordGame Word Game]

<b>Output:</b><br>

[[File:WordGameV1.1.png|frameless|350px]]

<h2> Hangman Game</h2>

The game starts by choosing the word length on the first page. After that, clicking the button at the bottom leads to the game page.<br>

Here, by clicking the "Start Game" button, our question appears on the screen. You have 11 rights in the game. In this way, if you find the word until you are full, you win the game.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/Hangman Hangman Game]

<b>Output:</b><br>
<gallery widths="400px" heights="550px" align="center" mode="nolines">
File: HangmanGameMainPage.png | '' Main Page ''
File: HangmanGamePage.png | ''Game Page''
</gallery>

<h2> Animation and Effects Game </h2>
TclGameForm is used as the form structure in this game. Besides, TclTimer component is also used. Features such as adding animation and sound effects are used on TclGameForm. You can develop applications by looking at the definitions here.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/GameAnimation Animation and Effects Game]

<h2> Artificial Intelligence App </h2>
A conversational AI chat engine specialized in dialogue using the OpenAI engine has been developed within the Clomosy infrastructure, and it has been utilized in this example.<br>

<b>Link:</b><br>
: [https://github.com/Clomosy/AI Artificial Intelligence App]

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

<h2> Raffle Application </h2>
This project includes a Raffle Application where users can participate and determine the winners. The application provides real-time communication and the ability to share the results of the draw via MQTT.

<b>Link:</b><br>
: [https://github.com/Clomosy/raffle-game Raffle Application]

<h2> Clomosy Notification Sender </h2>
This project includes the Clomosy Notification Sender application. Users or administrators can send a specific message or announcement to all users as notifications. The application provides customized user interfaces for different user profiles.

<b>Link:</b><br>
: [https://github.com/Clomosy/Notif-Sender Clomosy Notification Sender]

<h2> Find the Difference Game </h2>
This project includes a find the difference game where users try to identify the differences between two images. The game consists of a total of 4 levels. The goal of the game is to detect the specified differences to advance to the next level.

<b>Link:</b><br>
: [https://github.com/Clomosy/spot-difference-game Find the Difference Game]
<b>Output:</b><br>
[[File:FindTheDifference.png|frameless|350px]]
<h2> Drawing Form Application </h2>
This project includes a drawing form application where users can create and edit images using various drawing tools. The project provides a first-class drawing experience.

<b>Link:</b><br>
: [https://github.com/Clomosy/draw-form Drawing Form Application]
<b>Output:</b><br>
[[File:DrawForm.png|frameless|350px]]
<h2> Online Quiz Application </h2>

This project involves an online quiz application where users can answer questions and view results through graphs. The project is a dual-platform application designed for both mobile and desktop use.

<b>Link:</b><br>
: [https://github.com/Clomosy/question-sender Online Quiz Application]

<h2> Toothpick Collection Game </h2>
This project represents a fun game where you control an object using motion sensors.

<b>Link:</b><br>
: [https://github.com/Clomosy/stick-collector-game Toothpick Collection Game]

<h2> "Explain It to Me" Application </h2>
This project includes a lottery and word game application. The aim of the project is to enable users to participate in the raffle and other players try to explain the word to the person who won the raffle. The player who wins the draw collects points as he guesses.

<b>Link:</b><br>
: [https://github.com/Clomosy/tellme-game Explain It to Me" Application]

<h2> Balloon Popping </h2>
This project includes a balloon popping game where computers and mobile devices work simultaneously. The draw is held and whoever won the draw tries to know the question without popping the balloon.

<b>Link:</b><br>
: [https://github.com/Clomosy/balloon-game Balloon Popping]

<h2> Asteroid Game </h2>
This project involves an asteroid escape application.

<b>Link:</b><br>
: [https://github.com/Clomosy/astroid-game Asteroid Game]

<h2> Fruit Collect Game </h2>
In this project, we are collecting food falling from the sky. If we collect healthy foods, our score increases, and if we collect unhealthy foods, our score decreases. Players are listed according to their scores.

<b>Link:</b><br>
: [https://github.com/Clomosy/fruit-collect Fruit Collect Game]
{{#seo:|title=Event and Seminar Demos - Clomosy Docs}}
{{#seo:|description=Access hands-on examples and practical applications showcased in our workshops and events.}}

File:DrawForm.png

2025-11-07T07:27:20Z

Salih:

File:FindTheDifference.png

2025-11-07T07:04:25Z

Salih:

TclMenuFrame

2025-11-06T15:27:05Z

Salih:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewMenuFrame(AComponent: TCLComponent; xName: string): TclMenuFrame;
</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>

"TclMenuFrame" is a component frame type in Clomosy. This frame can be used as a menu component and helps create menu options in the application.<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
|-
|TClMenuFrame || MenuFrame1 : TClMenuFrame; || A variable belonging to the TclMenuFrame class is created.
|-
|AddNewMenuFrame ||MenuFrame1 = Form1.AddNewMenuFrame(Form1,'MenuFrame1'); ||A new Menu Frame is added to the form.
|-
|Align ||MenuFrame1.Align = alContents; ||Alignment adjustment is made.
|-
|MenuBar ||MenuFrame1.MenuBar.Width = 250; MenuFrame1.MenuBar.Height = 250; || It defines the main menu of the application and provides users with access to application functions. With this, adjustments such as height and width can be made.
|-
|Visible ||MenuFrame1.Visible = False; ||Visibility settings can be adjusted. If it is true it is visible, if it is false it is not visible.
|-
|ClMenuPosition ||MenuFrame1.ClMenuPosition = clLeft;||Menu Frame position is set.(Default => clRight)
|-
|VertScrollBox ||MenuFrame1.VertScrollBox || The MenuFrame provides an area with a vertical scrollbar within. This allows objects placed inside it to be created and displayed vertically one below the other.
|}
</div>

<b>Example</b><br>
<pre>
Var
MyForm : TclForm;
TstSideMenu : TClMenuFrame;
ShowBtn,menuBtn: TClProButton;
MenuItem1, MenuItem2: TClProButton;

void showMenuFrame;
{
TstSideMenu.Visible = True;
clRTMethod(TstSideMenu, 'BringTofront');
}

void showShowBtn;
{
TstSideMenu.Visible = False;
clRTMethod(menuBtn, 'BringTofront');
}

{
MyForm = TclForm.Create(Self);
TstSideMenu = MyForm.AddNewMenuFrame(MyForm,'TstSideMenu');
TstSideMenu.Align = alContents;
TstSideMenu.MenuBar.Width = 250;
TstSideMenu.Visible = False;
TstSideMenu.ClMenuPosition = clLeft;

menuBtn= MyForm.AddNewProButton(MyForm,'menuBtn','menu');
menuBtn.Align = AlLeft;
menuBtn.Width = 60;
menuBtn.clProSettings.BackgroundColor = clAlphaColor.clHexToColor('#A5C9CA');
menuBtn.clProSettings.FontColor = clAlphaColor.clHexToColor('#2E4F4F');
menuBtn.clProSettings.TextSettings.Font.Style = [fsBold];
menuBtn.clProSettings.IsRound = True;
menuBtn.clProSettings.RoundHeight = 10;
menuBtn.clProSettings.RoundWidth = 10;
menuBtn.clProSettings.BorderColor = clAlphaColor.clHexToColor('#C7D8D8');
menuBtn.clProSettings.BorderWidth = 2;
menuBtn.SetclProSettings(menuBtn.clProSettings);
MyForm.AddNewEvent(menuBtn,tbeOnClick,'showMenuFrame');

ShowBtn= MyForm.AddNewProButton(TstSideMenu.VertScrollBox,'ShowBtn','Close');
ShowBtn.Align = AlTop;
ShowBtn.Height = 40;
ShowBtn.Margins.Top = 10;
ShowBtn.clProSettings.FontHorzAlign = palCenter;
ShowBtn.clProSettings.BackgroundColor = clAlphaColor.clHexToColor('#E7D4B5');
ShowBtn.clProSettings.BorderColor = clAlphaColor.clHexToColor('#FFFFFF');
ShowBtn.clProSettings.TextSettings.Font.Style = [fsBold];
ShowBtn.clProSettings.IsRound = True;
ShowBtn.clProSettings.RoundHeight = 10;
ShowBtn.clProSettings.RoundWidth = 10;
ShowBtn.clProSettings.BorderWidth = 2;
ShowBtn.SetclProSettings(ShowBtn.clProSettings);
MyForm.AddNewEvent(ShowBtn,tbeOnClick,'showShowBtn');

MenuItem1 = MyForm.AddNewProButton(TstSideMenu.VertScrollBox,'MenuItem1','Main Page');
MenuItem1.Align = AlTop;
MenuItem1.Height = 40;
MenuItem1.Margins.Top = 15;
MenuItem1.clProSettings.BackgroundColor = clAlphaColor.clHexToColor('#D2E9E9');
MenuItem1.clProSettings.FontColor = clAlphaColor.clHexToColor('#2E4F4F');
MenuItem1.clProSettings.IsRound = True;
MenuItem1.clProSettings.RoundHeight = 8;
MenuItem1.clProSettings.RoundWidth = 8;
MenuItem1.clProSettings.BorderColor = clAlphaColor.clHexToColor('#C7D8D8');
MenuItem1.SetclProSettings(MenuItem1.clProSettings);

MenuItem2 = MyForm.AddNewProButton(TstSideMenu.VertScrollBox,'MenuItem2','Settings');
MenuItem2.Align = AlTop;
MenuItem2.Height = 40;
MenuItem2.Margins.Top = 10;
MenuItem2.clProSettings.BackgroundColor = clAlphaColor.clHexToColor('#F6EACB');
MenuItem2.clProSettings.FontColor = clAlphaColor.clHexToColor('#2E4F4F');
MenuItem2.clProSettings.IsRound = True;
MenuItem2.clProSettings.RoundHeight = 8;
MenuItem2.clProSettings.RoundWidth = 8;
MenuItem2.clProSettings.BorderColor = clAlphaColor.clHexToColor('#EAD7BB');
MenuItem2.SetclProSettings(MenuItem2.clProSettings);

MyForm.Run;
}

</pre>

<b>Output</b><br>

[[File:TclMenuFrame.gif|frameless|thumb|600px]]

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|title=TclMenuFrame Using - Clomosy Docs}}
{{#seo:|description=Explore TclMenuFrame on Clomosy. Learn about its structure, functionality, and integration for building efficient menu-driven applications.}}

File:TclMenuFrame.gif

2025-11-06T15:26:31Z

Salih:

TclArray

2025-11-06T15:05:03Z

Salih:

Array means many variables of the same data type. Array variables are like a list with a sequence number. Items belonging to this list are also accessed by their sequence number. Another structure that enables the use of Array on Clomosy is the TclArray structure.
There are different definitions according to the data type. These;

<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
|-
| TclArrayInteger || arrayInteger : TclArrayInteger; || Array definition indexed by integers.
|-
| TclArrayString || arrayString : TclArrayString; || Array definition indexed by string.
|-
| TclArrayDouble || arrayDouble : TclArrayDouble; || Array definition indexed by double.
|-
| TclArrayBoolean || arrayBoolean : TclArrayBoolean; || Array definition indexed by boolean.
|-
| TclArraySingle || arraySingle : TclArraySingle; || Array definition indexed by single.
|-
| TclArrayWord || arrayWord : TclArrayWord; || Array definition indexed by words.
|-
| TClArrayExtended || arrayExtended : TClArrayExtended; || Array definition indexed by extanded.
|-
| Create || array1 = TClArrayInteger.Create; || An object is created in the form.
|-
| Count || array1.Count; || The size of the array is taken.
|-
| Add || array1.Add(50); || The value 50 is added to the array.
|-
| GetItem || array1 (50 , 100, 70, 12, 3) array1.GetItem(1) || Used to access the items of the array. This will return the requested item one by one, no matter how many items are in the array. I want to get the data in the 2nd element of the sample array.
|-
| SetItem || array1.SetItem(1,25) //array1:TclArrayInteger || Value assignment is performed to the array element in the array used. The first parameter represents the index number, the second parameter represents the value assigned to the selected index number.
|-
| RemoveAll || array1.RemoveAll; || It is used to delete the entire directory.
|-
| RemoveAt || array1.RemoveAt(5); || "RemoveAt" is used if you want to delete data in an index of the array. The return value of this operation is returned as boolean. The return value is "True" if data deletion has been performed. If this index does not exist in the array and cannot be deleted, it returns "False".
|-
|Destroy || array1.Destroy; || It is used to delete an object from memory and free the memory.
|}
</div>

<b>Example</b><br>

<pre>
var
Form1: TclForm;
Edit1: TclProEdit;
Button1: TclProButton;
BtnTemizle: TclProButton;
gOgrenciListesi: TclArrayString;
gGuncelIndex: Integer;

void GetFirstIndex
{
if (gOgrenciListesi.Count > 0)
{
Edit1.Text = gOgrenciListesi.GetItem(gGuncelIndex);
}
}

void Button1OnClick;
{
if (gOgrenciListesi.Count == 0)
{
ShowMessage('Liste boş. Önce bir eleman ekleyin.');
}

gOgrenciListesi.SetItem(gGuncelIndex, Edit1.Text);
gGuncelIndex = gGuncelIndex + 1;

if (gGuncelIndex >= gOgrenciListesi.Count)
{
gGuncelIndex = 0;
}

Edit1.Text = gOgrenciListesi.GetItem(gGuncelIndex);
ShowMessage('Kayıt güncellendi. Şimdi ' + IntToStr(gGuncelIndex) + '. index gösteriliyor.');
}

void BtnTemizleOnClick;
{
if (gOgrenciListesi.Count > 0)
{
gOgrenciListesi.RemoveAll;
gGuncelIndex = 0;
Edit1.Text = 'Liste Temizlendi';
ShowMessage('Tüm öğrenciler listeden silindi (RemoveAll).');
}
else
{
ShowMessage('Liste zaten boş.');
}
}

{
Form1 = TclForm.Create(Self);

Edit1 = Form1.AddNewProEdit(Form1, 'Edit1', 'Öğrenci Adı');
Edit1.Align = alTop;
Edit1.Margins.Top = 20;
Edit1.Margins.Left = 20;
Edit1.Margins.Right = 20;

Button1 = Form1.AddNewProButton(Form1, 'Button1', 'Güncelle ve Sonrakini Göster');
Button1.Align = alTop;
Button1.Margins.Top = 10;
Button1.Margins.Left = 20;
Button1.Margins.Right = 20;
Button1.OnClick = 'Button1OnClick';

BtnTemizle = Form1.AddNewProButton(Form1, 'BtnTemizle', 'Tüm Listeyi SİL (RemoveAll)');
BtnTemizle.Align = alTop;
BtnTemizle.Margins.Top = 10;
BtnTemizle.Margins.Left = 20;
BtnTemizle.Margins.Right = 20;
BtnTemizle.OnClick = 'BtnTemizleOnClick';
BtnTemizle.clProSettings.BackgroundColor = clAlphaColor.clHexToColor('#dc3545');
BtnTemizle.clProSettings.FontColor = clAlphaColor.clHexToColor('#FFFFFF');
BtnTemizle.SetclProSettings(BtnTemizle.clProSettings);

gGuncelIndex = 0;
gOgrenciListesi = TclArrayString.Create;

gOgrenciListesi.Add('Ahmet Yılmaz');
gOgrenciListesi.Add('Ayşe Kaya');
gOgrenciListesi.Add('Mehmet Demir');

GetFirstIndex;
Form1.Run;
}
</pre>

<h2> See Also </h2>
* [[TRObject_Language#Arrays | Arrays]]
* [[Sorting Algorithms]]
* [[System Library]]

{{#seo:|title=TclArray Documentation - Clomosy Docs}}
{{#seo:|description=Learn how to manage arrays effectively with TclArray! Comprehensive examples and detailed documentation for developers.}}

TclProWebBrowser

2025-11-05T12:34:22Z

Salih:

The <b>TCLProWebBrowser</b> class provides a fully integrated web rendering component for displaying and interacting with web content directly inside Clomosy forms.
It supports standard web navigation, HTML rendering, JavaScript execution, caching control, and developer debugging tools.
TCLProWebBrowser allows you to embed modern web experiences within your Clomosy applications while maintaining control through the native component interface.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: Integrated Web Rendering
|-
| The TclProWebBrowser component enables loading of remote or local HTML content, executing JavaScript code, and managing browser history within Clomosy UI forms.
|-
| Example: <code>ProWebBrowser.Navigate('https://cms.clomosy.com')</code>
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TclProWebBrowser''' || ProWebBrowser : TclProWebBrowser;|| A variable belonging to the TclProWebBrowser class is created.
|-
| '''AddNewProWebBrowser''' ||ProWebBrowser = MyForm.AddNewProWebBrowser(MyForm, 'ProWebBrowser');|| A new Pro Web Browser component is added to the form.
|-
| '''Navigate''' || ProWebBrowser.Navigate('https://cms.clomosy.com'); || Loads a web page from the specified URL into the browser.
|-
| '''LoadHTML''' || ProWebBrowser.LoadHTML('<h1>Hello World</h1>'); || Loads and renders raw HTML content directly without requiring a remote source.
|-
| '''LoadFile''' || ProWebBrowser.LoadFile('path/to/localfile.html'); || Opens and displays a local HTML file from the device storage.
|-
| '''ExecuteJavaScriptSync''' ||ProWebBrowser.ExecuteJavaScriptSync('document.title;');|| Executes a JavaScript command synchronously within the loaded page context.
|-
| '''Reload''' || ProWebBrowser.Reload; || Reloads the current web page content.
|-
| '''GoBack''' || ProWebBrowser.GoBack; || Navigates to the previous page in the browser history.
|-
| '''GoForward''' || ProWebBrowser.GoForward; || Navigates to the next page in the browser history.
|-
| '''ClearCache''' || ProWebBrowser.ClearCache; || Clears the browser cache to ensure fresh content loading.
|-
| '''ShowDebugConsole''' || ProWebBrowser.ShowDebugConsole; || Opens the browser’s built-in developer tools console for debugging.
|-
| '''UserAgent''' || ProWebBrowser.UserAgent = 'Mozilla/5.0...'; || Allows customizing the browser’s user-agent string for compatibility testing.
|-
| '''AutoClearCache''' || ProWebBrowser.AutoClearCache = True; || Automatically clears cache on new page loads.
|-
| '''Url''' || ProWebBrowser.Url = 'https://example.com'; || Specifies or retrieves the currently loaded URL.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: JavaScript Execution Context
|-
| Use <code>ExecuteJavaScriptSync</code> for immediate script evaluation and UI updates.
For non-blocking operations, asynchronous execution may be preferred in performance-critical workflows.
|}
</div>

<div class="alert alert-info shadow-sm rounded-4 p-3" style="border-left:6px solid #0d6efd;">
<h4 class="mb-2">Important Notes</h4>
<ul style="margin-left:10px;">
<li><code>TCLProWebBrowser</code> supports both local and remote HTML sources.</li>
<li><code>ExecuteJavaScriptSync</code> blocks until the command is executed; avoid heavy scripts in UI threads.</li>
<li>When debugging, use <code>ShowDebugConsole</code> to inspect DOM and JavaScript logs.</li>
<li>For performance, enable <code>AutoClearCache</code> only when necessary.</li>
<li>Always ensure valid HTTPS URLs for secure web content.</li>
</ul>
</div>

=== Example: TCLProWebBrowser in Use ===
<pre>
var
MyForm: TCLForm;
ConnectBtn,ReloadBtn: TCLButton;
ProWebBrowser: TCLProWebBrowser;

void ConnectBtnOnClick;
{
ProWebBrowser.Url = 'https://docs.clomosy.com';

//load custom HTML dynamically
//ProWebBrowser.LoadHTML('<h1 style="color:#ff00ff">Hello World</h1>');

// You can also use:
// ProWebBrowser.GoBack;
// ProWebBrowser.ClearCache;

}

void ReloadBtnOnClick;
{
ProWebBrowser.Reload;
}

{
MyForm = TCLForm.Create(Self);

// Add a test button
ConnectBtn = MyForm.AddNewButton(MyForm, 'ConnectBtn', 'Connect');
ConnectBtn.Align = alTop;
MyForm.AddNewEvent(ConnectBtn, tbeOnClick, 'ConnectBtnOnClick');

ReloadBtn = MyForm.AddNewButton(MyForm, 'ReloadBtn', 'Reload');
ReloadBtn.Align = alTop;
MyForm.AddNewEvent(ReloadBtn, tbeOnClick, 'ReloadBtnOnClick');

// Add a web browser
ProWebBrowser = MyForm.AddNewProWebBrowser(MyForm, 'ProWebBrowser');
ProWebBrowser.Align = alClient;
ProWebBrowser.Margins.Top = 25;
ProWebBrowser.Margins.Left = 25;
ProWebBrowser.Margins.Right = 25;
ProWebBrowser.Margins.Bottom = 25;

MyForm.Run;
}

</pre>

Output:

[[File:ProWebBrowser.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclWebBrowser]]

{{#seo:|title=TCLProWebBrowser Class - Clomosy Docs}}
{{#seo:|description=Documentation of TCLProWebBrowser class, including navigation, JavaScript execution, caching, and UI embedding features for web rendering within Clomosy applications.}}

TclProWebBrowser

2025-11-04T06:19:07Z

Salih: Created page with "The <b>TCLProWebBrowser</b> class provides a fully integrated web rendering component for displaying and interacting with web content directly inside Clomosy forms. It supports standard web navigation, HTML rendering, JavaScript execution, caching control, and developer debugging tools. TCLProWebBrowser allows you to embed modern web experiences within your Clomosy applications while maintaining control through the native component interface. <div style="margin-bott..."

The <b>TCLProWebBrowser</b> class provides a fully integrated web rendering component for displaying and interacting with web content directly inside Clomosy forms.
It supports standard web navigation, HTML rendering, JavaScript execution, caching control, and developer debugging tools.
TCLProWebBrowser allows you to embed modern web experiences within your Clomosy applications while maintaining control through the native component interface.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: Integrated Web Rendering
|-
| The TclProWebBrowser component enables loading of remote or local HTML content, executing JavaScript code, and managing browser history within Clomosy UI forms.
|-
| Example: <code>ProWebBrowser.Navigate('https://cms.clomosy.com')</code>
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TclProWebBrowser''' || ProWebBrowser : TclProWebBrowser;|| A variable belonging to the TclProWebBrowser class is created.
|-
| '''AddNewProWebBrowser''' ||ProWebBrowser = MyForm.AddNewProWebBrowser(MyForm, 'ProWebBrowser');|| A new Pro Web Browser component is added to the form.
|-
| '''Navigate''' || ProWebBrowser.Navigate('https://cms.clomosy.com'); || Loads a web page from the specified URL into the browser.
|-
| '''LoadHTML''' || ProWebBrowser.LoadHTML('<h1>Hello World</h1>'); || Loads and renders raw HTML content directly without requiring a remote source.
|-
| '''LoadFile''' || ProWebBrowser.LoadFile('path/to/localfile.html'); || Opens and displays a local HTML file from the device storage.
|-
| '''ExecuteJavaScriptSync''' || ProWebBrowser.ExecuteJavaScriptSync('alert(''Hi!'')'); || Executes a JavaScript command synchronously within the loaded page context.
|-
| '''Reload''' || ProWebBrowser.Reload; || Reloads the current web page content.
|-
| '''GoBack''' || ProWebBrowser.GoBack; || Navigates to the previous page in the browser history.
|-
| '''GoForward''' || ProWebBrowser.GoForward; || Navigates to the next page in the browser history.
|-
| '''ClearCache''' || ProWebBrowser.ClearCache; || Clears the browser cache to ensure fresh content loading.
|-
| '''ShowDebugConsole''' || ProWebBrowser.ShowDebugConsole; || Opens the browser’s built-in developer tools console for debugging.
|-
| '''UserAgent''' || ProWebBrowser.UserAgent = 'Mozilla/5.0...'; || Allows customizing the browser’s user-agent string for compatibility testing.
|-
| '''AutoClearCache''' || ProWebBrowser.AutoClearCache = True; || Automatically clears cache on new page loads.
|-
| '''Url''' || ProWebBrowser.Url = 'https://example.com'; || Specifies or retrieves the currently loaded URL.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: JavaScript Execution Context
|-
| Use <code>ExecuteJavaScriptSync</code> for immediate script evaluation and UI updates.
For non-blocking operations, asynchronous execution may be preferred in performance-critical workflows.
|}
</div>

<div class="alert alert-info shadow-sm rounded-4 p-3" style="border-left:6px solid #0d6efd;">
<h4 class="mb-2">Important Notes</h4>
<ul style="margin-left:10px;">
<li><code>TCLProWebBrowser</code> supports both local and remote HTML sources.</li>
<li><code>ExecuteJavaScriptSync</code> blocks until the command is executed; avoid heavy scripts in UI threads.</li>
<li>When debugging, use <code>ShowDebugConsole</code> to inspect DOM and JavaScript logs.</li>
<li>For performance, enable <code>AutoClearCache</code> only when necessary.</li>
<li>Always ensure valid HTTPS URLs for secure web content.</li>
</ul>
</div>

=== Example: TCLProWebBrowser in Use ===
<pre>
var
MyForm: TCLForm;
ConnectBtn,ReloadBtn: TCLButton;
ProWebBrowser: TCLProWebBrowser;

void ConnectBtnOnClick;
{
ProWebBrowser.Url = 'https://docs.clomosy.com';

//load custom HTML dynamically
//ProWebBrowser.LoadHTML('<h1 style="color:#ff00ff">Hello World</h1>');

// You can also use:
// ProWebBrowser.GoBack;
// ProWebBrowser.ClearCache;

}

void ReloadBtnOnClick;
{
ProWebBrowser.Reload;
}

{
MyForm = TCLForm.Create(Self);

// Add a test button
ConnectBtn = MyForm.AddNewButton(MyForm, 'ConnectBtn', 'Connect');
ConnectBtn.Align = alTop;
MyForm.AddNewEvent(ConnectBtn, tbeOnClick, 'ConnectBtnOnClick');

ReloadBtn = MyForm.AddNewButton(MyForm, 'ReloadBtn', 'Reload');
ReloadBtn.Align = alTop;
MyForm.AddNewEvent(ReloadBtn, tbeOnClick, 'ReloadBtnOnClick');

// Add a web browser
ProWebBrowser = MyForm.AddNewProWebBrowser(MyForm, 'ProWebBrowser');
ProWebBrowser.Align = alClient;
ProWebBrowser.Margins.Top = 25;
ProWebBrowser.Margins.Left = 25;
ProWebBrowser.Margins.Right = 25;
ProWebBrowser.Margins.Bottom = 25;

MyForm.Run;
}

</pre>

Output:

[[File:ProWebBrowser.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclWebBrowser]]

{{#seo:|title=TCLProWebBrowser Class - Clomosy Docs}}
{{#seo:|description=Documentation of TCLProWebBrowser class, including navigation, JavaScript execution, caching, and UI embedding features for web rendering within Clomosy applications.}}

File:ProWebBrowser.png

2025-11-04T06:16:23Z

Salih:

With Do

2025-11-03T12:41:53Z

Salih: Salih moved page With&Do to With Do

The <b>with & do</b> statement in Clomosy is used to simplify object member access by allowing multiple property or method assignments to be made within a single context block.<br>

This structure is particularly useful when working with complex objects, as it eliminates the need to repeatedly specify the object name.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Statement !!style="background-color: #c3d7e0"| Description
|-
|with ... do || Creates a scoped block that allows direct access to the specified object’s members without repeating its reference name.
|}
</div>
<br>

<pre>
var
MyForm : TclForm;
ProPanelTop: TCLProPanel;
TitleLabel: TCLProLabel;
{
MyForm = TclForm.Create(Self);

ProPanelTop = MyForm.AddNewProPanel(MyForm, 'ProPanelTop');

with ProPanelTop do
{
Align = alMostTop;
Height = 80;
clProSettings.BorderColor = clAlphaColor.clHexToColor('#890410');
clProSettings.RoundHeight = 10;
clProSettings.RoundWidth = 10;
clProSettings.BorderWidth = 2;
clProSettings.IsFill = True;
clProSettings.IsRound = True;
SetclProSettings(clProSettings);

TitleLabel = MyForm.AddNewProLabel(ProPanelTop, 'TitleLabel', 'Welcome to Clomosy!');
with TitleLabel do
{
Align = alCenter;
Width = 200;
clProSettings.FontSize = 16;
clProSettings.TextSettings.Font.Style = [fsBold];
SetclProSettings(clProSettings);

}
}
MyForm.Run;
}

</pre>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
<b>Note:</b> Avoid using multiple nested <b>with & do</b> blocks whenever possible, as they can reduce readability and complicate debugging.
</div>

{{#seo:|title=With & Do Statement in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the with & do statement in Clomosy to simplify object property access and improve code readability.}}

With Do

2025-11-03T12:38:43Z

Salih: Created page with "The <b>with & do</b> statement in Clomosy is used to simplify object member access by allowing multiple property or method assignments to be made within a single context block.<br> This structure is particularly useful when working with complex objects, as it eliminates the need to repeatedly specify the object name.<br> <div class="table-responsive"> {| class="wikitable" style="border: 2px solid #c3d7e0" ! style="background-color: #c3d7e0"| Statement !!style="backgrou..."

TclShareService

2025-11-03T11:44:42Z

Salih:

The <b>TclShareService</b> class allows you to share files, images, or text content directly using the native sharing features of the device.
It provides a simple way to integrate content sharing functions (such as sharing a document, CSV file, or text) in Clomosy applications with full Android and iOS support. <br>

<span style="color:blue"><b>TclShareService</b></span> : A component that enables sharing of files, images, or text through the system's default share dialog.<br>
<br>

<div class="alert alert-info" role="alert" data-bs-theme="light">
<b>Note:</b> TclShareService is available on <b>Android</b> and <b>iOS</b> platforms.
On both systems, it uses the native share dialog to ensure a seamless user experience.
</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
|-
|TclShareService ||ShareService : TclShareService; ||A variable belonging to the TclShareService class is created.
|-
|Create ||ShareService = TclShareService.Create; ||Creates a new instance of the share service.
|-
|Destroy ||ShareService.Destroy; ||Releases the share service object from memory.
|-
|AddFile ||ShareService.AddFile(Clomosy.AppFilesPath + DocName);||Adds a file to the sharing queue.
|-
|AddImage ||ShareService.AddImage(Image1.Bitmap);
||Adds an image to be shared.
|-
|AddText ||ShareService.AddText('This is a shared message'); ||Adds plain text content to be shared.
|-
|Share ||ShareService.Share; ||Opens the native device share dialog to perform the sharing action.
|}
</div>

The <b>TclShareService</b> is typically used after generating or downloading a file (such as a PDF or CSV), or when you want to share text or images with other applications.
You can add multiple items (files, images, or text) before calling the <code>Share</code> method. Once <code>Share()</code> is executed, the system’s default share interface appears, allowing the user to select how to share the content.<br>

<div class="alert alert-danger" role="alert" data-bs-theme="light">
<b>Note:</b> When using the <b>AddImage</b> property, you must provide a <b>Bitmap</b> instance instead of a file path or URL.
</div>

<b>Example</b><br>

<pre>
var
Form1 : TclForm;
BtnShare : TclProButton;
ShareService : TclShareService;

void OnShareBtnClick;
var filePath, CSVText: string;
{
filePath = Clomosy.AppFilesPath + 'demo_export.csv';

// Example CSV content
CSVText = 'Name;Age;City' + #13#10 +
'Alice;24;London' + #13#10 +
'Bob;29;Paris';

// Save file to app directory
clSaveToFile(filePath, CSVText);

// Initialize share service and share the file
ShareService = TclShareService.Create;
ShareService.AddFile(filePath);
ShareService.Share;
}

void SetFormComponents;
{
BtnShare = Form1.AddNewProButton(Form1, 'BtnShare', 'Share File');
BtnShare.Align = alCenter;
BtnShare.Width = 160;
BtnShare.Height = 50;
BtnShare.clProSettings.FontSize = 14;
BtnShare.clProSettings.IsRound = True;
BtnShare.clProSettings.RoundHeight = 15;
BtnShare.clProSettings.RoundWidth = 15;
BtnShare.clProSettings.BackgroundColor = clAlphaColor.clHexToColor('#565bad');
BtnShare.clProSettings.FontColor = clAlphaColor.clHexToColor('#FFFFFF');
BtnShare.SetclProSettings(BtnShare.clProSettings);
BtnShare.OnClick = 'OnShareBtnClick';
}

{
Form1 = TclForm.Create(Self);
SetFormComponents;
Form1.Run;
}

</pre>

{{#seo:|title=TclShareService Usage in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the TclShareService class in Clomosy to share files, text, or images through native device sharing options.}}

TclShareService

2025-11-03T11:21:54Z

Salih: Created page with " The <b>TclShareService</b> class allows you to share files, images, or text content directly using the native sharing features of the device. It provides a simple way to integrate content sharing functions (such as sharing a document, CSV file, or text) in Clomosy applications with full Android and iOS support. <br> <span style="color:blue"><b>TclShareService</b></span> : A component that enables sharing of files, images, or text through the system's default share di..."

The <b>TclShareService</b> class allows you to share files, images, or text content directly using the native sharing features of the device.
It provides a simple way to integrate content sharing functions (such as sharing a document, CSV file, or text) in Clomosy applications with full Android and iOS support. <br>

<span style="color:blue"><b>TclShareService</b></span> : A component that enables sharing of files, images, or text through the system's default share dialog.<br>
<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
|-
|TclShareService ||ShareService : TclShareService; ||A variable belonging to the TclShareService class is created.
|-
|Create ||ShareService = TclShareService.Create; ||Creates a new instance of the share service.
|-
|Destroy ||ShareService.Destroy; ||Releases the share service object from memory.
|-
|AddFile ||ShareService.AddFile(Clomosy.AppFilesPath + DocName);||Adds a file to the sharing queue.
|-
|AddImage ||ShareService.AddImage(Clomosy.AppFilesPath + 'image.png'); ||Adds an image to be shared.
|-
|AddText ||ShareService.AddText('This is a shared message'); ||Adds plain text content to be shared.
|-
|Share ||ShareService.Share; ||Opens the native device share dialog to perform the sharing action.
|}
</div>

The <b>TclShareService</b> is typically used after generating or downloading a file (such as a PDF or CSV), or when you want to share text or images with other applications.
You can add multiple items (files, images, or text) before calling the <code>Share</code> method. Once <code>Share()</code> is executed, the system’s default share interface appears, allowing the user to select how to share the content.<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
<b>Note:</b> TclShareService is available on <b>Android</b> and <b>iOS</b> platforms.
On both systems, it uses the native share dialog to ensure a seamless user experience.
</div>

<b>Example</b><br>

<pre>
var
Form1 : TclForm;
BtnShare : TclProButton;
ShareService : TclShareService;

void OnShareBtnClick;
var filePath, CSVText: string;
{
filePath = Clomosy.AppFilesPath + 'demo_export.csv';

// Example CSV content
CSVText = 'Name;Age;City' + #13#10 +
'Alice;24;London' + #13#10 +
'Bob;29;Paris';

// Save file to app directory
clSaveToFile(filePath, CSVText);

// Initialize share service and share the file
ShareService = TclShareService.Create;
ShareService.AddFile(filePath);
ShareService.Share;
}

void SetFormComponents;
{
BtnShare = Form1.AddNewProButton(Form1, 'BtnShare', 'Share File');
BtnShare.Align = alCenter;
BtnShare.Width = 160;
BtnShare.Height = 50;
BtnShare.clProSettings.FontSize = 14;
BtnShare.clProSettings.IsRound = True;
BtnShare.clProSettings.RoundHeight = 15;
BtnShare.clProSettings.RoundWidth = 15;
BtnShare.clProSettings.BackgroundColor = clAlphaColor.clHexToColor('#565bad');
BtnShare.clProSettings.FontColor = clAlphaColor.clHexToColor('#FFFFFF');
BtnShare.SetclProSettings(BtnShare.clProSettings);
BtnShare.OnClick = 'OnShareBtnClick';
}

{
Form1 = TclForm.Create(Self);
SetFormComponents;
Form1.Run;
}

</pre>

{{#seo:|title=TclShareService Usage in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn how to use the TclShareService class in Clomosy to share files, text, or images through native device sharing options.}}

TclJSONPair

2025-10-23T07:37:26Z

Salih:

<b>TCLJSONPair</b> represents a single key–value association within a JSON object.
It functions as the fundamental element of TCLJSONObject, encapsulating both the property name <b>(key)</b> and its corresponding <b>TCLJSONValue</b> (value).

This class provides a structured interface for examining, modifying, and transferring key/value pairs.
It is primarily utilized when accessing individual object members, iterating through object data, or transferring property definitions between JSON structures.

'''TCLJSONPair''' ensures that each key and its associated value maintain valid JSON syntax and data type integrity.
It forms the basis for key/value management within the '''TCLJSON''' framework, supporting consistent and predictable JSON object manipulation.

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''AddJsonPair''' || obj.AddJsonPair(pair); || Allows manual insertion of a predefined key/value pair into a TCLJSONObject. Useful when dynamically constructing or reusing pairs.
|-
| '''GetValueAsPair''' || pair = obj.GetValueAsPair(0); || Returns a TCLJSONPair reference representing both the key and value of a JSON property. Can be used to inspect or modify elements sequentially.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important!
|-
|Modifying a '''TCLJSONPair''' directly does not automatically update the parent '''TCLJSONObject''' unless you reassign the modified pair back.
|}
</div>

=== Example: TCLJSONPair in Use ===
<pre>
var
Form1: TClForm;
ShowPairsBtn: TClProButton;
OutputMemo: TClMemo;
Obj: TCLJSONObject;
Pair: TCLJSONPair;
i: Integer;

void CreateJSONObject;
{
Obj = TCLJSONObject.Create;

Obj.AddPair('Username', TCLJSONValue.Str('ClomosyUser'));
Obj.AddPair('Age', TCLJSONValue.Int(26));
Obj.AddPair('Active', TCLJSONValue.Bool(True));
Obj.AddPair('Role', TCLJSONValue.Str('Editor'));

OutputMemo.Lines.Text = 'Object created with 4 pairs.';
}

void ShowPairs;
var
valStr: string;
{
OutputMemo.Lines.Clear;

for (i = 0 to Obj.Count - 1)
{
Pair = Obj.GetValueAsPair(i);

if (Pair.Value.IsString)
valStr = Pair.Value.AsString;
else if (Pair.Value.IsNumber)
valStr = FloatToStr(Pair.Value.AsFloat);
else if (Pair.Value.IsBoolean)
{
if (Pair.Value.AsBoolean)
valStr = 'True';
else
valStr = 'False';
}
else
valStr = '(Unknown Type)';

OutputMemo.Lines.Add(Pair.Key + ' = ' + valStr);
}
}

{
Form1 = TClForm.Create(Self);

OutputMemo = Form1.AddNewMemo(Form1, 'OutputMemo', 'Pairs Output');
OutputMemo.Align = alClient;
OutputMemo.Margins.Top = 10;
OutputMemo.Margins.Right = 10;
OutputMemo.Margins.Left = 10;
OutputMemo.Margins.Bottom = 10;

ShowPairsBtn = Form1.AddNewProButton(Form1, 'ShowPairsBtn', 'Show Pairs');
ShowPairsBtn.Align = alBottom;
ShowPairsBtn.Margins.Top = 10;
ShowPairsBtn.Margins.Left = 10;
ShowPairsBtn.Margins.Right = 10;
ShowPairsBtn.Margins.Bottom = 10;
ShowPairsBtn.OnClick = 'ShowPairs';

CreateJSONObject;
Form1.Run;
}

</pre>

Output:

[[File:TclJSONPair.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclJSONValue]]
* [[TclJSONObject]]
* [[TclJSONArray]]
* [[TclJSON]]

{{#seo:|title=TCLJSONPair Class - Clomosy Docs}}
{{#seo:|description=Comprehensive documentation of the TCLJSONPair class, detailing its structure, purpose, and methods for managing key-value pairs within JSON objects in the TCLJSON framework.}}

TclJSONPair

2025-10-23T07:36:03Z

Salih: Created page with "'''TCLJSONPair''' represents a single key–value association within a JSON object. It functions as the fundamental element of TCLJSONObject, encapsulating both the property name '''(key)''' and its corresponding '''TCLJSONValue''' (value). This class provides a structured interface for examining, modifying, and transferring key/value pairs. It is primarily utilized when accessing individual object members, iterating through object data, or transferring property definit..."

'''TCLJSONPair''' represents a single key–value association within a JSON object.
It functions as the fundamental element of TCLJSONObject, encapsulating both the property name '''(key)''' and its corresponding '''TCLJSONValue''' (value).

This class provides a structured interface for examining, modifying, and transferring key/value pairs.
It is primarily utilized when accessing individual object members, iterating through object data, or transferring property definitions between JSON structures.

'''TCLJSONPair''' ensures that each key and its associated value maintain valid JSON syntax and data type integrity.
It forms the basis for key/value management within the '''TCLJSON''' framework, supporting consistent and predictable JSON object manipulation.

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''AddJsonPair''' || obj.AddJsonPair(pair); || Allows manual insertion of a predefined key/value pair into a TCLJSONObject. Useful when dynamically constructing or reusing pairs.
|-
| '''GetValueAsPair''' || pair = obj.GetValueAsPair(0); || Returns a TCLJSONPair reference representing both the key and value of a JSON property. Can be used to inspect or modify elements sequentially.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important!
|-
|Modifying a '''TCLJSONPair''' directly does not automatically update the parent '''TCLJSONObject''' unless you reassign the modified pair back.
|}
</div>

=== Example: TCLJSONPair in Use ===
<pre>
var
Form1: TClForm;
ShowPairsBtn: TClProButton;
OutputMemo: TClMemo;
Obj: TCLJSONObject;
Pair: TCLJSONPair;
i: Integer;

void CreateJSONObject;
{
Obj = TCLJSONObject.Create;

Obj.AddPair('Username', TCLJSONValue.Str('ClomosyUser'));
Obj.AddPair('Age', TCLJSONValue.Int(26));
Obj.AddPair('Active', TCLJSONValue.Bool(True));
Obj.AddPair('Role', TCLJSONValue.Str('Editor'));

OutputMemo.Lines.Text = 'Object created with 4 pairs.';
}

void ShowPairs;
var
valStr: string;
{
OutputMemo.Lines.Clear;

for (i = 0 to Obj.Count - 1)
{
Pair = Obj.GetValueAsPair(i);

if (Pair.Value.IsString)
valStr = Pair.Value.AsString;
else if (Pair.Value.IsNumber)
valStr = FloatToStr(Pair.Value.AsFloat);
else if (Pair.Value.IsBoolean)
{
if (Pair.Value.AsBoolean)
valStr = 'True';
else
valStr = 'False';
}
else
valStr = '(Unknown Type)';

OutputMemo.Lines.Add(Pair.Key + ' = ' + valStr);
}
}

{
Form1 = TClForm.Create(Self);

OutputMemo = Form1.AddNewMemo(Form1, 'OutputMemo', 'Pairs Output');
OutputMemo.Align = alClient;
OutputMemo.Margins.Top = 10;
OutputMemo.Margins.Right = 10;
OutputMemo.Margins.Left = 10;
OutputMemo.Margins.Bottom = 10;

ShowPairsBtn = Form1.AddNewProButton(Form1, 'ShowPairsBtn', 'Show Pairs');
ShowPairsBtn.Align = alBottom;
ShowPairsBtn.Margins.Top = 10;
ShowPairsBtn.Margins.Left = 10;
ShowPairsBtn.Margins.Right = 10;
ShowPairsBtn.Margins.Bottom = 10;
ShowPairsBtn.OnClick = 'ShowPairs';

CreateJSONObject;
Form1.Run;
}

</pre>

Output:

[[File:TclJSONPair.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclJSONValue]]
* [[TclJSONObject]]
* [[TclJSONArray]]
* [[TclJSON]]

{{#seo:|title=TCLJSONPair Class - Clomosy Docs}}
{{#seo:|description=Comprehensive documentation of the TCLJSONPair class, detailing its structure, purpose, and methods for managing key-value pairs within JSON objects in the TCLJSON framework.}}

File:TclJSONPair.png

2025-10-23T07:03:07Z

Salih:

TclJSONArray

2025-10-22T15:17:04Z

Salih: Created page with "The <b>TCLJSONArray</b> represents a JSON array within the <b>TCLJSON</b> library. It is a strongly typed container that can hold multiple JSON values, objects, or even other arrays, allowing developers to build hierarchical and complex JSON structures. <div class="table-responsive" style="margin-bottom: 20px;"> {| class="wikitable" style="border: 2px solid #c3d7e0; width:100%" ! style="background-color: #c3d7e0"| Feature ! style="background-color: #c3d7e0"| Use of ! s..."

The <b>TCLJSONArray</b> represents a JSON array within the <b>TCLJSON</b> library.
It is a strongly typed container that can hold multiple JSON values, objects, or even other arrays, allowing developers to build hierarchical and complex JSON structures.

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''Create''' || Arr = TCLJSONArray.Create; || Creates a new, empty JSON array instance.
|-
| '''CreateFromJSON(const AJSON: string)''' || Arr = TCLJSONArray.CreateFromJSON('[{"Name":"Item1"}]'); || Parses a JSON string and initializes the array with its content.
|-
| '''AddValue''' || Arr.AddValue(TCLJSONValue.Str('Hello')); || Adds a single JSON value to the end of the array.
|-
| '''GetItem''' || val = Arr.GetItem(0); || Retrieves the value at the specified index in the array.
|-
| '''Count''' || n = Arr.Count; || Returns the number of elements in the array.
|-
| '''AddObject''' || Arr.AddObject(obj); || Adds a JSON object to the array as a new element.
|-
| '''AddArray''' || Arr.AddArray(subArray); || Adds another JSON array as an element within this array.
|-
| '''Remove''' || Arr.Remove(Arr.Count - 1); || Removes the element at the specified index from the array.
|-
| '''RemoveValue''' || Arr.RemoveValue(val); || Removes the first occurrence of the specified JSON value from the array.
|-
| '''Clone''' || copyArr = Arr.Clone; || Creates a deep copy of the array and all its elements.
|-
| '''Merge''' || Arr.Merge(otherArr); || Appends all elements from another array into this array.
|-
| '''ToJSONString''' || jsonText = Arr.ToJSONString; || Returns the JSON-formatted string representation of the array.
|-
| '''Clear''' || Arr.Clear; || Removes all elements from the array, leaving it empty.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Hint!
|-
| Use '''GetItem''' and '''Count''' to safely iterate over the array without causing out-of-bounds errors.
|}
</div>

=== Example: TCLJSONArray in Use ===
<pre>
var
Form1: TClForm;
AddBtn, RemoveBtn, ShowBtn: TClProButton;
InputEdt: TClProEdit;
ItemsMemo: TClMemo;
Arr: TCLJSONArray;

void CreateControls;
{
InputEdt = Form1.AddNewProEdit(Form1, 'InputEdt', 'Enter item name...');
InputEdt.Align = alTop;
InputEdt.Height = 35;
InputEdt.Margins.Top = 10;

AddBtn = Form1.AddNewProButton(Form1, 'AddBtn', 'Add Item');
AddBtn.Align = alTop;
AddBtn.Margins.Top = 10;
AddBtn.OnClick = 'AddItem';

RemoveBtn = Form1.AddNewProButton(Form1, 'RemoveBtn', 'Remove Last');
RemoveBtn.Align = alTop;
RemoveBtn.Margins.Top = 10;
RemoveBtn.OnClick = 'RemoveItem';

ShowBtn = Form1.AddNewProButton(Form1, 'ShowBtn', 'Show JSON');
ShowBtn.Align = alTop;
ShowBtn.Margins.Top = 10;
ShowBtn.OnClick = 'ShowJSON';

ItemsMemo = Form1.AddNewMemo(Form1, 'ItemsMemo','');
ItemsMemo.Align = alClient;
ItemsMemo.Margins.Top = 10;
ItemsMemo.ReadOnly = True;
}

void RefreshMemo;
var
i: Integer;
item: TCLJSONObject;
lineStr: string;
{
ItemsMemo.Lines.Clear;

for (i = 0 to Arr.Count - 1)
{
item = Arr.GetItem(i);
lineStr = item.GetValueByPath('Name').AsString + ' (' + item.GetValueByPath('CreatedAt').AsString + ')';
ItemsMemo.Lines.Add(lineStr);
}
}

void AddItem;
var
nameStr: string;
ItemObj: TCLJSONObject;
{
nameStr = InputEdt.Text;

if (nameStr == '')
{
ShowMessage('Please enter an item name.');
exit;
}

ItemObj = TCLJSONObject.Create;
ItemObj.AddPair('Name', TCLJSONValue.Str(nameStr));
ItemObj.AddPair('CreatedAt', TCLJSONValue.Str(DateTimeToStr(Now)));

Arr.AddObject(ItemObj);
RefreshMemo;

InputEdt.Text = '';
}

void RemoveItem;
{
if (Arr.Count > 0)
{
Arr.Remove(Arr.Count - 1);
RefreshMemo;
}
else
ShowMessage('Array is empty.');
}

void ShowJSON;
{
ShowMessage('Current JSON:' + #13#10 + Arr.ToJSONString);
}

{
Form1 = TClForm.Create(Self);
Arr = TCLJSONArray.Create;

CreateControls;
Form1.Run;
}

</pre>

Output:

[[File:TclJSONArray.gif|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclJSONValue]]
* [[TclJSONObject]]
* [[TclJSONPair]]
* [[TclJSON]]

{{#seo:|title=TCLJSONArray Class - Clomosy Docs}}
{{#seo:|description=Detailed documentation of TCLJSONArray class, including features, methods, Types, and practical examples for JSON Array's.}}

File:TclJSONArray.gif

2025-10-22T15:04:18Z

Salih:

TclJSONValue

2025-10-22T14:40:38Z

Salih: Created page with " The <b>TCLJSONValue</b> represents the fundamental data element within the TCLJSON library. It serves as a strongly typed container for all supported JSON data types, including <b>string, number, boolean, null, and datetime.</b> <div class="table-responsive" style="margin-bottom: 20px;"> {| class="wikitable" style="border: 2px solid #c3d7e0; width:100%" ! style="background-color: #c3d7e0"| Feature ! style="background-color: #c3d7e0"| Use of ! style="background-color:..."

The <b>TCLJSONValue</b> represents the fundamental data element within the TCLJSON library.
It serves as a strongly typed container for all supported JSON data types, including <b>string, number, boolean, null, and datetime.</b>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''Create(AValue: TJSONValue)''' || val = TCLJSONValue.Create(SomeJSONValue); || Initializes a TCLJSONValue instance by wrapping an existing TJSONValue reference.
|-
| '''AsString''' || text = val.AsString; || Returns the stored value as a string if its type is string-compatible.
|-
| '''AsInteger''' || num = val.AsInteger; || Converts and retrieves the value as an integer type.
|-
| '''AsFloat''' || fnum = val.AsFloat; || Retrieves the numeric value as a floating-point number.
|-
| '''AsBoolean''' || flag = val.AsBoolean; || Returns the stored value as a boolean (True or False).
|-
| '''AsDateTime''' || dt = val.AsDateTime; || Retrieves the stored value as a TDateTime object if it represents a date/time.
|-
| '''IsNull''' || val.IsNull || Checks whether the current value is null.
|-
| '''IsString''' || val.IsString || Returns True if the value is a string type.
|-
| '''IsNumber''' ||val.IsNumber|| Returns True if the value is numeric (integer or float).
|-
| '''IsBoolean''' || val.IsBoolean || Returns True if the value represents a boolean type.
|-
| '''IsDateTime''' || val.IsDateTime || Returns True if the stored value is a date/time type.
|-
| '''ToString''' || jsonText = val.ToString; || Converts the internal value to its JSON-compatible string representation.
|-
| '''GetValueByPath''' || childVal = val.GetValueByPath('data.user.name'); || Retrieves a nested JSON value using dot notation within a hierarchical structure.
|-
| '''Str''' || val = TCLJSONValue.Str('Hello'); || Creates a TCLJSONValue instance representing a string type.
|-
| '''Num''' || val = TCLJSONValue.Num(25.75); || Creates a TCLJSONValue instance containing a floating-point number.
|-
| '''Int''' || val = TCLJSONValue.Int(100); || Creates a TCLJSONValue instance representing an integer number.
|-
| '''Bool''' || val = TCLJSONValue.Bool(True); || Creates a TCLJSONValue instance representing a boolean value.
|-
| '''DT''' || val = TCLJSONValue.DT(Now); || Creates a TCLJSONValue instance containing a TDateTime value.
|-
| '''Null''' || val = TCLJSONValue.Null; || Creates a TCLJSONValue instance representing a null JSON value.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Data Type
|-
| Avoid mixing data types when reading or writing JSON values; each accessor ('''AsString''', '''AsFloat''') must correspond to the original type.
|}
</div>

=== Example: TCLJSONValue in Use ===
<pre>
var
MyForm: TClForm;
InputEdt: TClProEdit;
StrBtn, NumBtn, BoolBtn, CheckBtn, ClearBtn: TClProButton;
OutputMemo: TClMemo;
JVal: TCLJSONValue;

void CreateStringValue
{
JVal = TCLJSONValue.Str(InputEdt.Text);
OutputMemo.Lines.Text = 'String Value: ' + JVal.AsString;
}

void CreateNumberValue
{

JVal = TCLJSONValue.Num(StrToFloat(InputEdt.Text));
OutputMemo.Lines.Text = 'Number Value: ' + FloatToStr(JVal.AsFloat);
}

void CreateBooleanValue
var
inputLower: string;
{
inputLower = LowerCase(Trim(InputEdt.Text));
if ((inputLower == 'true') || (inputLower == '1') || (inputLower == 'yes'))
JVal = TCLJSONValue.Bool(True)
else
JVal = TCLJSONValue.Bool(False);

if (JVal.AsBoolean)
OutputMemo.Lines.Text = 'Boolean Value: True'
else
OutputMemo.Lines.Text = 'Boolean Value: False';
}

void CheckValueType
var
info: string;
{
if (JVal.IsNull)
info = 'Type: Null'
else if (JVal.IsNumber)
info = 'Type: Number'
else if (JVal.IsString)
info = 'Type: String'
else if (JVal.IsBoolean)
info = 'Type: Boolean'
else if (JVal.IsDateTime)
info = 'Type: DateTime'
else
info = 'Unknown type';

ShowMessage(info);
}

void ClearValue
{
JVal = TCLJSONValue.Null;
OutputMemo.Lines.Text = 'Value cleared (Null)';
}

{
MyForm = TClForm.Create(Self);

InputEdt = MyForm.AddNewProEdit(MyForm, 'InputEdt', 'Enter a value...');
InputEdt.Align = alTop;
InputEdt.Height = 35;
InputEdt.Margins.Left = 10;
InputEdt.Margins.Right = 10;

OutputMemo = MyForm.AddNewMemo(MyForm, 'OutputMemo', 'Output');
OutputMemo.Align = alClient;
OutputMemo.Height = 150;
OutputMemo.Margins.Left = 10;
OutputMemo.Margins.Right = 10;
OutputMemo.TextSettings.WordWrap = True;

StrBtn = MyForm.AddNewProButton(MyForm, 'StrBtn', 'Create String Value');
StrBtn.Align = alBottom;
StrBtn.OnClick = 'CreateStringValue';

NumBtn = MyForm.AddNewProButton(MyForm, 'NumBtn', 'Create Number Value');
NumBtn.Align = alBottom;
NumBtn.OnClick = 'CreateNumberValue';

BoolBtn = MyForm.AddNewProButton(MyForm, 'BoolBtn', 'Create Boolean Value');
BoolBtn.Align = alBottom;
BoolBtn.OnClick = 'CreateBooleanValue';

CheckBtn = MyForm.AddNewProButton(MyForm, 'CheckBtn', 'Check Value Type');
CheckBtn.Align = alBottom;
CheckBtn.OnClick = 'CheckValueType';

ClearBtn = MyForm.AddNewProButton(MyForm, 'ClearBtn', 'Clear Value');
ClearBtn.Align = alBottom;
ClearBtn.OnClick = 'ClearValue';

MyForm.Run;
}

</pre>

Output:

[[File:TclJSONValue.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclJSONArray]]
* [[TclJSONObject]]
* [[TclJSONPair]]
* [[TclJSON]]

{{#seo:|title=TCLJSONValue Class - Clomosy Docs}}
{{#seo:|description=Detailed documentation of TCLJSONValue class, including features, methods, Types, and practical examples for JSON Value control.}}

File:TclJSONValue.png

2025-10-22T13:59:28Z

Salih:

TclJSONObject

2025-10-22T13:01:27Z

Salih:

The <b>TCLJSONObject</b> class represents a JSON object composed of key–value pairs.
It provides structured methods to add, remove, clone, merge, and retrieve data.
Objects can contain nested objects or arrays, allowing hierarchical and deeply structured JSON representations.
TCLJSONObject ensures type safety by operating with <b>TCLJSONValue</b>, preventing data inconsistency during serialization and deserialization.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: JSON Object Structure
|-
| A JSON object is an unordered collection of name–value pairs, where each name is a string and the value may be a string, number, boolean, array, or another object.
|-
| Example: {"name":"Alice","age":25,"active":true}
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''AddPair''' || obj.AddPair('name', TCLJSONValue.Str('John')); || Adds a new key–value pair to the JSON object. Updates the value if the key already exists.
|-
| '''AddObject''' || obj.AddObject('address', childObj); || Adds a new JSON object under the specified key, enabling nested structures.
|-
| '''AddArray''' || obj.AddArray('items', arr); || Stores a JSON array under the specified key, supporting complex data structures.
|-
| '''RemovePair''' || obj.RemovePair('age'); || Removes the key–value pair with the specified key name from the JSON object.
|-
| '''GetValue''' || val = obj.GetValue('name'); || Returns the value for the specified key. Returns nil if the key does not exist.
|-
| '''SetValue''' || obj.SetValue('active', TCLJSONValue.Bool(False)); || Updates the value of an existing key or adds the key if it doesn’t exist.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('address.city'); || Provides direct access to nested values using dot notation, e.g., "address.city".
|-
| '''GetValueAsPair''' || pair = obj.GetValueAsPair(0); || Returns the key–value pair at the specified index. Useful for iteration.
|-
| '''HasKey''' || obj.HasKey('status'); || Checks whether the specified key exists in the JSON object.
|-
| '''Clone''' || copyObj = obj.Clone; || Creates a deep copy of the JSON object, completely independent of the original.
|-
| '''Merge''' || obj.Merge(extraObj); || Merges all key–value pairs from another JSON object into the current one. Overwrites existing keys.
|-
| '''ToJSONString''' || jsonStr = obj.ToJSONString; || Converts the object to a formatted JSON string for file saving or data transmission.
|-
| '''Count''' || count = obj.Count; || Returns the total number of key–value pairs in the JSON object.
|-
| '''Clear''' || obj.Clear; || Completely clears the object, removing all stored data.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Nested Object Access
|-
| Use <code>GetValueByPath</code> to access deeply nested elements.
Example: <code>user.GetValueByPath('account.details.email')</code> returns the email value from a nested JSON structure.
|}
</div>

<div class="alert alert-info shadow-sm rounded-4 p-3" style="border-left:6px solid #0d6efd;">
<h4 class="mb-2">Important Notes</h4>
<ul style="margin-left:10px;">
<li>All key names in <code>TCLJSONObject</code> are case-sensitive.</li>
<li>Nested paths must use dot notation.</li>
<li>When merging objects, existing keys are overwritten by the new object’s values.</li>
<li>Use <code>Clone</code> for duplication instead of manual re-construction to preserve data integrity.</li>
<li>Always free JSON objects after use to avoid memory leaks.</li>
</ul>
</div>

=== Example: TCLJSONObject in Use ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt, CityEdt: TClProEdit;
ActiveChk: TClCheckBox;
CreateBtn, MergeBtn, ShowBtn: TClProButton;
OutputMemo: TClMemo;
Obj, Child, Extra: TCLJSONObject;
Val: TCLJSONValue;

void CreateJSONObject
{
Obj = TCLJSONObject.Create;
Child = TCLJSONObject.Create;
Extra = TCLJSONObject.Create;

// User input values
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToIntDef(AgeEdt.Text, 0)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.IsChecked));

// Nested object (address)
Child.AddPair('city', TCLJSONValue.Str(CityEdt.Text));
Obj.AddObject('address', Child);

// Merge with extra info
Extra.AddPair('status', TCLJSONValue.Str('OK'));
Obj.Merge(Extra);

// Show final JSON
OutputMemo.Lines.Text = Obj.ToJSONString;
}

void ShowNestedValue
{
Val = Obj.GetValueByPath('address.city');
ShowMessage('City: ' + Val.AsString);
}

void MergeExample
var
NewObj: TCLJSONObject;
{
NewObj = TCLJSONObject.Create;
NewObj.AddPair('role', TCLJSONValue.Str('Admin'));
Obj.Merge(NewObj);
OutputMemo.Lines.Text = Obj.ToJSONString;
}

{
MyForm = TClForm.Create(Self);

// Input fields
NameEdt = MyForm.AddNewProEdit(MyForm, 'NameEdt', 'Enter name...');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Top = 10;
NameEdt.Margins.Left = 10;
NameEdt.Margins.Bottom = 10;
NameEdt.Margins.Right = 10;

AgeEdt = MyForm.AddNewProEdit(MyForm, 'AgeEdt', 'Enter age...');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Top = 10;
AgeEdt.Margins.Right = 10;
AgeEdt.Margins.Left = 10;
AgeEdt.Margins.Bottom = 10;

CityEdt = MyForm.AddNewProEdit(MyForm, 'CityEdt', 'Enter city...');
CityEdt.Align = alTop;
CityEdt.Height = 35;
CityEdt.Margins.Top = 10;
CityEdt.Margins.Right = 10;
CityEdt.Margins.Left = 10;
CityEdt.Margins.Bottom = 10;

ActiveChk = MyForm.AddNewCheckBox(MyForm, 'ActiveChk', 'Is Active?');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 10;

// Output area
OutputMemo = MyForm.AddNewMemo(MyForm, 'OutputMemo', 'JSON Output');
OutputMemo.Align = alClient;
OutputMemo.Height = 180;
OutputMemo.Margins.Left = 10;
OutputMemo.Margins.Right = 10;
OutputMemo.TextSettings.WordWrap = True;

// Buttons
CreateBtn = MyForm.AddNewProButton(MyForm, 'CreateBtn', 'Create JSON Object');
CreateBtn.Align = alBottom;
CreateBtn.OnClick = 'CreateJSONObject';

ShowBtn = MyForm.AddNewProButton(MyForm, 'ShowBtn', 'Show Nested Value');
ShowBtn.Align = alBottom;
ShowBtn.OnClick = 'ShowNestedValue';

MergeBtn = MyForm.AddNewProButton(MyForm, 'MergeBtn', 'Merge Extra Object');
MergeBtn.Align = alBottom;
MergeBtn.OnClick = 'MergeExample';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONObject.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclJSONArray]]
* [[TclJSONValue]]
* [[TclJSONPair]]
* [[TclJSON]]

{{#seo:|title=TCLJSONObject Class - Clomosy Docs}}
{{#seo:|description=Detailed documentation of TCLJSONObject class, including features, methods, nested path access, and practical examples for JSON object manipulation.}}

File:TCLJSONObject.png

2025-10-22T12:57:57Z

Salih: Salih uploaded a new version of File:TCLJSONObject.png

File:TCLJSONExample2.png

2025-10-22T12:33:50Z

Salih:

TclJSON

2025-10-22T12:31:29Z

Salih:

TCLJSON is a structured and type-safe JSON processing library designed to facilitate the creation, manipulation, and validation of JSON data. It enables the definition of objects, arrays, and values representing standard JSON types, including strings, numbers, booleans, and null elements.

The library provides mechanisms for constructing hierarchical data models, performing key-value pair operations, merging multiple JSON structures, and retrieving nested elements through deep path access. TCLJSON ensures strict compliance with JSON syntax rules, offering validation methods to verify data integrity during parsing and serialization.

In addition to in-memory operations, TCLJSON supports persistent data handling through file-based loading and saving of JSON content. Its strongly typed architecture promotes reliability, consistency, and maintainability in applications that require structured data representation, configuration management, or data exchange using the JSON format.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: What is TCLJSON?
|-
| style="padding-top: 5px;" | TCLJSON allows you to create, manipulate, and serialize JSON data structures. It supports nested objects, arrays, type-safe values, deep path access, merging, cloning, and file operations.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="width:100%"
! Class !! Description
|-
| [[TclJSONArray]] || Represents a JSON array with ordered values. Supports adding/removing values or objects, merging, cloning, and enumeration.
|-
| [[TclJSONObject]] || Represents a JSON object with key-value pairs. Provides methods for adding, removing, merging, cloning, and deep path access.
|-
| [[TclJSONPair]] || Represents a single key-value pair inside a JSON object.
|-
| [[TclJSONValue]] || Encapsulates a JSON value (string, integer, number, boolean, datetime, or null) and provides type-safe methods.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Dont Forget!
|-
| When working with nested objects or arrays, always free created JSON instances ('''Obj.Free;''', '''Arr.Free;''') after use to prevent memory leaks.

Also, ensure all JSON strings are '''UTF-8''' encoded before parsing to avoid character mismatches during validation.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''ParseToJSONObject''' || obj = TCLJSON.ParseToJSONObject(jsonStr); || Parses a JSON string into a TCLJSONObject.
|-
| '''ParseObjectToString''' || jsonStr = TCLJSON.ParseObjectToString(obj); || Converts a TCLJSONObject to a JSON string.
|-
| '''ParseToJSONArray''' || arr = TCLJSON.ParseToJSONArray(jsonStr); || Parses a JSON string into a TCLJSONArray.
|-
| '''ParseArrayToString''' || jsonStr = TCLJSON.ParseArrayToString(arr); || Converts a TCLJSONArray to a JSON string.
|-
| '''LoadObjectFromFile''' || obj = TCLJSON.LoadObjectFromFile('data.json'); || Loads a JSON object from a file.
|-
| '''SaveObjectToFile''' || TCLJSON.SaveObjectToFile(obj, 'data.json'); || Saves a TCLJSONObject to a file.
|-
| '''IsValidJSON''' || valid = TCLJSON.IsValidJSON(jsonStr); || Checks whether a string is valid JSON.
|}
</div>

=== Example: TCLJSON in Action ===
<pre>
var
MyForm: TClForm;
LoadBtn, SaveBtn, ParseBtn: TClProButton;
InputMemo, OutputMemo: TClMemo;
Obj: TCLJSONObject;
Arr: TCLJSONArray;
JsonStr: string;
Valid: Boolean;

void LoadJSONFromFile
{
Obj = TCLJSON.LoadObjectFromFile('data.json');
OutputMemo.Lines.Text = Obj.ToJSONString;
}

void SaveJSONToFile
{
if Obj <> nil
{
TCLJSON.SaveObjectToFile(Obj, 'output.json');
ShowMessage('JSON saved to output.json');
}
else
ShowMessage('No JSON object to save.');
}

void ParseJSON
{
try
JsonStr = InputMemo.Text;
Valid = TCLJSON.IsValidJSON(JsonStr);

if not Valid
{
ShowMessage('Invalid JSON format!');
exit;
}

// Parse string to object
Obj = TCLJSON.ParseToJSONObject(JsonStr);
ShowMessage('Parsed Object Key Count: ' + IntToStr(Obj.Count));

// Convert object back to string
JsonStr = TCLJSON.ParseObjectToString(Obj);
OutputMemo.Lines.Text = JsonStr;

// Create sample array and show conversion
Arr = TCLJSONArray.Create;
Arr.AddValue(TCLJSONValue.Str('Item1'));
Arr.AddValue(TCLJSONValue.Str('Item2'));
OutputMemo.Lines.Add('');
OutputMemo.Lines.Add('Array JSON:');
OutputMemo.Lines.Add(TCLJSON.ParseArrayToString(Arr));

except
ShowMessage('Error: ' + LastExceptionMessage);
}
}

{
MyForm = TClForm.Create(Self);

InputMemo = MyForm.AddNewMemo(MyForm, 'InputMemo', 'Enter JSON Text');
InputMemo.Align = alTop;
InputMemo.Height = 150;

OutputMemo = MyForm.AddNewMemo(MyForm, 'OutputMemo', 'Output');
OutputMemo.Align = alClient;

ParseBtn = MyForm.AddNewProButton(MyForm, 'ParseBtn', 'Parse JSON');
ParseBtn.Align = alBottom;
ParseBtn.OnClick = 'ParseJSON';

LoadBtn = MyForm.AddNewProButton(MyForm, 'LoadBtn', 'Load from File');
LoadBtn.Align = alBottom;
LoadBtn.OnClick = 'LoadJSONFromFile';

SaveBtn = MyForm.AddNewProButton(MyForm, 'SaveBtn', 'Save to File');
SaveBtn.Align = alBottom;
SaveBtn.OnClick = 'SaveJSONToFile';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONExample2.png|frameless|700px]]<br>

<h2> See Also </h2>
* [[TclJSONArray]]
* [[TclJSONObject]]
* [[TclJSONPair]]
* [[TclJSONValue]]

{{#seo:|title=TCLJSON Library Overview - Clomosy Docs}}
{{#seo:|description=Learn how to create, manipulate, validate, and save JSON objects and arrays using TCLJSON, with examples and type-safe value handling.}}

File:TCLJSONExample.png

2025-10-22T12:30:03Z

Salih: Salih uploaded a new version of File:TCLJSONExample.png

TclJSON

2025-10-22T12:29:30Z

Salih:

TCLJSON is a structured and type-safe JSON processing library designed to facilitate the creation, manipulation, and validation of JSON data. It enables the definition of objects, arrays, and values representing standard JSON types, including strings, numbers, booleans, and null elements.

The library provides mechanisms for constructing hierarchical data models, performing key-value pair operations, merging multiple JSON structures, and retrieving nested elements through deep path access. TCLJSON ensures strict compliance with JSON syntax rules, offering validation methods to verify data integrity during parsing and serialization.

In addition to in-memory operations, TCLJSON supports persistent data handling through file-based loading and saving of JSON content. Its strongly typed architecture promotes reliability, consistency, and maintainability in applications that require structured data representation, configuration management, or data exchange using the JSON format.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: What is TCLJSON?
|-
| style="padding-top: 5px;" | TCLJSON allows you to create, manipulate, and serialize JSON data structures. It supports nested objects, arrays, type-safe values, deep path access, merging, cloning, and file operations.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="width:100%"
! Class !! Description
|-
| [[TclJSONArray]] || Represents a JSON array with ordered values. Supports adding/removing values or objects, merging, cloning, and enumeration.
|-
| [[TclJSONObject]] || Represents a JSON object with key-value pairs. Provides methods for adding, removing, merging, cloning, and deep path access.
|-
| [[TclJSONPair]] || Represents a single key-value pair inside a JSON object.
|-
| [[TclJSONValue]] || Encapsulates a JSON value (string, integer, number, boolean, datetime, or null) and provides type-safe methods.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Dont Forget!
|-
| When working with nested objects or arrays, always free created JSON instances ('''Obj.Free;''', '''Arr.Free;''') after use to prevent memory leaks.

Also, ensure all JSON strings are '''UTF-8''' encoded before parsing to avoid character mismatches during validation.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''ParseToJSONObject''' || obj = TCLJSON.ParseToJSONObject(jsonStr); || Parses a JSON string into a TCLJSONObject.
|-
| '''ParseObjectToString''' || jsonStr = TCLJSON.ParseObjectToString(obj); || Converts a TCLJSONObject to a JSON string.
|-
| '''ParseToJSONArray''' || arr = TCLJSON.ParseToJSONArray(jsonStr); || Parses a JSON string into a TCLJSONArray.
|-
| '''ParseArrayToString''' || jsonStr = TCLJSON.ParseArrayToString(arr); || Converts a TCLJSONArray to a JSON string.
|-
| '''LoadObjectFromFile''' || obj = TCLJSON.LoadObjectFromFile('data.json'); || Loads a JSON object from a file.
|-
| '''SaveObjectToFile''' || TCLJSON.SaveObjectToFile(obj, 'data.json'); || Saves a TCLJSONObject to a file.
|-
| '''IsValidJSON''' || valid = TCLJSON.IsValidJSON(jsonStr); || Checks whether a string is valid JSON.
|}
</div>

=== Example: TCLJSON in Action ===
<pre>
var
MyForm: TClForm;
LoadBtn, SaveBtn, ParseBtn: TClProButton;
InputMemo, OutputMemo: TClMemo;
Obj: TCLJSONObject;
Arr: TCLJSONArray;
JsonStr: string;
Valid: Boolean;

void LoadJSONFromFile
{
Obj = TCLJSON.LoadObjectFromFile('data.json');
OutputMemo.Lines.Text = Obj.ToJSONString;
}

void SaveJSONToFile
{
if Obj <> nil
{
TCLJSON.SaveObjectToFile(Obj, 'output.json');
ShowMessage('JSON saved to output.json');
}
else
ShowMessage('No JSON object to save.');
}

void ParseJSON
{
try
JsonStr = InputMemo.Text;
Valid = TCLJSON.IsValidJSON(JsonStr);

if not Valid
{
ShowMessage('Invalid JSON format!');
exit;
}

// Parse string to object
Obj = TCLJSON.ParseToJSONObject(JsonStr);
ShowMessage('Parsed Object Key Count: ' + IntToStr(Obj.Count));

// Convert object back to string
JsonStr = TCLJSON.ParseObjectToString(Obj);
OutputMemo.Lines.Text = JsonStr;

// Create sample array and show conversion
Arr = TCLJSONArray.Create;
Arr.AddValue(TCLJSONValue.Str('Item1'));
Arr.AddValue(TCLJSONValue.Str('Item2'));
OutputMemo.Lines.Add('');
OutputMemo.Lines.Add('Array JSON:');
OutputMemo.Lines.Add(TCLJSON.ParseArrayToString(Arr));

except
ShowMessage('Error: ' + LastExceptionMessage);
}
}

{
MyForm = TClForm.Create(Self);

InputMemo = MyForm.AddNewMemo(MyForm, 'InputMemo', 'Enter JSON Text');
InputMemo.Align = alTop;
InputMemo.Height = 150;

OutputMemo = MyForm.AddNewMemo(MyForm, 'OutputMemo', 'Output');
OutputMemo.Align = alClient;

ParseBtn = MyForm.AddNewProButton(MyForm, 'ParseBtn', 'Parse JSON');
ParseBtn.Align = alBottom;
ParseBtn.OnClick = 'ParseJSON';

LoadBtn = MyForm.AddNewProButton(MyForm, 'LoadBtn', 'Load from File');
LoadBtn.Align = alBottom;
LoadBtn.OnClick = 'LoadJSONFromFile';

SaveBtn = MyForm.AddNewProButton(MyForm, 'SaveBtn', 'Save to File');
SaveBtn.Align = alBottom;
SaveBtn.OnClick = 'SaveJSONToFile';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONExample.png|frameless|700px]]<br>

<h2> See Also </h2>
* [[TclJSONArray]]
* [[TclJSONObject]]
* [[TclJSONPair]]
* [[TclJSONValue]]

{{#seo:|title=TCLJSON Library Overview - Clomosy Docs}}
{{#seo:|description=Learn how to create, manipulate, validate, and save JSON objects and arrays using TCLJSON, with examples and type-safe value handling.}}

TclJSONObject

2025-10-22T11:18:02Z

Salih:

The <b>TCLJSONObject</b> class represents a JSON object composed of key–value pairs.
It provides structured methods to add, remove, clone, merge, and retrieve data.
Objects can contain nested objects or arrays, allowing hierarchical and deeply structured JSON representations.
TCLJSONObject ensures type safety by operating with <b>TCLJSONValue</b>, preventing data inconsistency during serialization and deserialization.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: JSON Object Structure
|-
| A JSON object is an unordered collection of name–value pairs, where each name is a string and the value may be a string, number, boolean, array, or another object.
|-
| Example: {"name":"Alice","age":25,"active":true}
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TCLJSONObject''' || obj : TCLJSONObject; || Creates a variable for JSON object.
|-
| '''Create''' || obj = TCLJSONObject.Create; || Initializes a new empty JSON object instance.
|-
| '''CreateFromJSON''' || obj = TCLJSONObject.CreateFromJSON(jsonStr); || Creates a JSON object from a JSON string.
|-
| '''AddPair''' || obj.AddPair('name', TCLJSONValue.Str('Alice')); || Adds a key–value pair to the object.
|-
| '''SetValue''' || obj.SetValue('age', TCLJSONValue.Int(25)); || Updates an existing key’s value or adds it if not present.
|-
| '''RemovePair''' || obj.RemovePair('age'); || Removes a key and its corresponding value.
|-
| '''AddObject''' || obj.AddObject('address', ChildObj); || Adds a nested JSON object as a child.
|-
| '''AddArray''' || obj.AddArray('scores', Arr); || Adds a JSON array under a key.
|-
| '''HasKey''' || obj.HasKey('active'); || Checks whether the specified key exists.
|-
| '''GetValue''' || val = obj.GetValue('name'); || Retrieves the value of a given key as a TCLJSONValue.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('user.profile.name'); || Retrieves a value using dot notation for nested structures.
|-
| '''Merge''' || obj.Merge(ExtraObj); || Merges another object’s pairs into the current object.
|-
| '''Clone''' || copy = obj.Clone; || Creates a deep copy of the object, including all nested items.
|-
| '''ToJSONString''' || obj.ToJSONString; || Serializes the object into a JSON string format.
|-
| '''Clear''' || obj.Clear; || Removes all key–value pairs from the object.
|-
| '''Count''' || obj.Count; || Returns the number of key–value pairs within the object.
|-
| '''IsEmpty''' || obj.IsEmpty; || Returns True if the object contains no pairs.
|-
| '''SaveToFile''' || TCLJSON.SaveObjectToFile(obj, 'data.json'); || Saves the current object to a file.
|-
| '''LoadFromFile''' || obj = TCLJSON.LoadObjectFromFile('data.json'); || Loads a JSON object from a file.
|-
| '''IsValidJSON''' || TCLJSON.IsValidJSON(jsonStr); || Checks if the string is a valid JSON format.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Nested Object Access
|-
| Use <code>GetValueByPath</code> to access deeply nested elements.
Example: <code>user.GetValueByPath('account.details.email')</code> returns the email value from a nested JSON structure.
|}
</div>

<div class="alert alert-info shadow-sm rounded-4 p-3" style="border-left:6px solid #0d6efd;">
<h4 class="mb-2">Important Notes</h4>
<ul style="margin-left:10px;">
<li>All key names in <code>TCLJSONObject</code> are case-sensitive.</li>
<li>Nested paths must use dot notation.</li>
<li>When merging objects, existing keys are overwritten by the new object’s values.</li>
<li>Use <code>Clone</code> for duplication instead of manual re-construction to preserve data integrity.</li>
<li>Always free JSON objects after use to avoid memory leaks.</li>
</ul>
</div>

=== Example: TCLJSONObject in Use ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt, CityEdt: TClProEdit;
ActiveChk: TClCheckBox;
CreateBtn: TClProButton;
ResultMemo: TClMemo;

void GenerateJSONObject
var
Obj, Child, Extra: TCLJSONObject;
Val: TCLJSONValue;
{
try
Obj = TCLJSONObject.Create;
Child = TCLJSONObject.Create;
Extra = TCLJSONObject.Create;
try
// Key-value pairs
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToIntDef(AgeEdt.Text, 0)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.IsChecked));

// Nested object
Child.AddPair('city', TCLJSONValue.Str(CityEdt.Text));
Obj.AddObject('address', Child);

// Additional info (merge)
Extra.AddPair('status', TCLJSONValue.Str('OK'));
Obj.Merge(Extra);

// Retrieve deep value
Val = Obj.GetValueByPath('address.city');
ShowMessage('City: ' + Val.AsString);

// Show JSON output
ResultMemo.Lines.Text = Obj.ToJSONString;

except
ShowMessage('An error occurred while creating JSON: ' + LastExceptionMessage);
}
finally
Obj.Free;
Child.Free;
Extra.Free;
}
}

{
MyForm = TClForm.Create(Self);

NameEdt = MyForm.AddNewProEdit(MyForm, 'NameEdt', 'Name');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Left = 25;
NameEdt.Margins.Bottom = 25;
NameEdt.Margins.Right = 25;

AgeEdt = MyForm.AddNewProEdit(MyForm, 'AgeEdt', 'Age');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Left = 25;
AgeEdt.Margins.Bottom = 25;
AgeEdt.Margins.Right = 25;

CityEdt = MyForm.AddNewProEdit(MyForm, 'CityEdt', 'City');
CityEdt.Align = alTop;
CityEdt.Height = 35;
CityEdt.Margins.Left = 25;
CityEdt.Margins.Bottom = 25;
CityEdt.Margins.Right = 25;

ActiveChk = MyForm.AddNewCheckBox(MyForm, 'ActiveChk', 'Is Active?');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 15;
ActiveChk.Margins.Top = 10;

ResultMemo = MyForm.AddNewMemo(MyForm, 'ResultMemo', 'JSON Output');
ResultMemo.Align = alClient;
ResultMemo.Height = 200;
ResultMemo.TextSettings.WordWrap = True;

CreateBtn = MyForm.AddNewProButton(MyForm, 'CreateBtn', 'Generate JSON');
CreateBtn.Align = alBottom;
CreateBtn.Margins.Left = 15;
CreateBtn.Margins.Right = 15;
CreateBtn.Margins.Bottom = 10;
CreateBtn.OnClick = 'GenerateJSONObject';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONObject.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclJSONArray]]
* [[TclJSONValue]]
* [[TclJSONPair]]
* [[TclJSON]]

{{#seo:|title=TCLJSONObject Class - Clomosy Docs}}
{{#seo:|description=Detailed documentation of TCLJSONObject class, including features, methods, nested path access, and practical examples for JSON object manipulation.}}

TclJSON

2025-10-22T06:25:31Z

Salih:

TCLJSON is a structured and type-safe JSON processing library designed to facilitate the creation, manipulation, and validation of JSON data. It enables the definition of objects, arrays, and values representing standard JSON types, including strings, numbers, booleans, and null elements.

The library provides mechanisms for constructing hierarchical data models, performing key-value pair operations, merging multiple JSON structures, and retrieving nested elements through deep path access. TCLJSON ensures strict compliance with JSON syntax rules, offering validation methods to verify data integrity during parsing and serialization.

In addition to in-memory operations, TCLJSON supports persistent data handling through file-based loading and saving of JSON content. Its strongly typed architecture promotes reliability, consistency, and maintainability in applications that require structured data representation, configuration management, or data exchange using the JSON format.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: What is TCLJSON?
|-
| style="padding-top: 5px;" | TCLJSON allows you to create, manipulate, and serialize JSON data structures. It supports nested objects, arrays, type-safe values, deep path access, merging, cloning, and file operations.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="width:100%"
! Class !! Description
|-
| [[TclJSONArray]] || Represents a JSON array with ordered values. Supports adding/removing values or objects, merging, cloning, and enumeration.
|-
| [[TclJSONObject]] || Represents a JSON object with key-value pairs. Provides methods for adding, removing, merging, cloning, and deep path access.
|-
| [[TclJSONPair]] || Represents a single key-value pair inside a JSON object.
|-
| [[TclJSONValue]] || Encapsulates a JSON value (string, integer, number, boolean, datetime, or null) and provides type-safe methods.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Type-Safe JSON Values
|-
| TCLJSONValue provides class functions like '''Str''', '''Int''', '''Bool''', '''Num''', '''DT''', and '''Null''' to safely create JSON values without manual conversion.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TCLJSONObject''' || obj : TCLJSONObject; || Creates a variable for JSON object.
|-
| '''TCLJSONArray''' || arr : TCLJSONArray; || Creates a variable for JSON array.
|-
| '''AddPair''' || obj.AddPair('key', TCLJSONValue.Str('value')); || Adds a key-value pair to JSON object.
|-
| '''AddObject''' || obj.AddObject('child', ChildObj); || Adds a nested JSON object.
|-
| '''AddArray''' || obj.AddArray('letters', Arr); || Adds a JSON array inside object.
|-
| '''Merge''' || obj.Merge(ExtraObj); || Merges another object into current.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('level1.level2'); || Retrieves a value from nested path.
|-
| '''ToJSONString''' || obj.ToJSONString; || Converts object/array to JSON string.
|-
| '''IsValidJSON''' || TCLJSON.IsValidJSON(str); || Checks if string is valid JSON.
|-
| '''SaveObjectToFile''' || TCLJSON.SaveObjectToFile(obj, 'file.json'); || Saves JSON object to file.
|}
</div>

=== Example: TCLJSON in Action ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt: TClProEdit;
ActiveChk: TClCheckBox;
ShowBtn: TClProButton;
ResultMemo: TClMemo;

void GenerateJSON
var
Obj, Child, Extra: TCLJSONObject;
Arr: TCLJSONArray;
Val: TCLJSONValue;
{
try
// Main JSON object
Obj = TCLJSONObject.Create;
try
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToInt(AgeEdt.Text)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.isChecked));

// Nested object
Child = TCLJSONObject.Create;
Child.AddPair('ChildLevel', TCLJSONValue.Str('This is a deep value'));
Obj.AddObject('ParentLevel', Child);

// Array
Arr = TCLJSONArray.Create;
Arr.AddValue(TCLJSONValue.Str('X'));
Arr.AddValue(TCLJSONValue.Str('Y'));
Arr.AddValue(TCLJSONValue.Str('Z'));
Obj.AddArray('letters', Arr);

// Merge object
Extra = TCLJSONObject.Create;
Extra.AddPair('status', TCLJSONValue.Str('ok'));
Obj.Merge(Extra);

// Deep value access (Optional)
Val = Obj.GetValueByPath('ParentLevel.ChildLevel');

// Add JSON to Memo
ResultMemo.Lines.Text = Obj.ToJSONString;

// Deep value shown (Optional)
ShowMessage('Deep value: ' + Val.AsString);

except
ShowMessage('Error: ' + LastExceptionMessage);
}
except
ShowMessage('Unexpected Error: ' + LastExceptionMessage);
}
}

{
MyForm = TClForm.Create(Self);

NameEdt = MyForm.AddNewProEdit(MyForm,'NameEdt','Name');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Left = 25;
NameEdt.Margins.Bottom = 25;
NameEdt.Margins.Right = 25;

AgeEdt = MyForm.AddNewProEdit(MyForm,'AgeEdt','Age');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Left = 25;
AgeEdt.Margins.Bottom = 25;
AgeEdt.Margins.Right = 25;

ActiveChk = MyForm.AddNewCheckBox(MyForm,'ActiveChk','Active');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 15;
ActiveChk.Margins.Top = 10;

ResultMemo = MyForm.AddNewMemo(MyForm,'ResultMemo','JSON Output');
ResultMemo.Align = alClient;
ResultMemo.Height = 200;
ResultMemo.StyledSettings = ssFamily;
ResultMemo.TextSettings.WordWrap = True;

ShowBtn = MyForm.AddNewProButton(MyForm,'ShowBtn','Show JSON');
ShowBtn.Align = alBottom;
ShowBtn.Margins.Left = 15;
ShowBtn.Margins.Right = 15;
ShowBtn.Margins.Bottom = 10;
ShowBtn.OnClick = 'GenerateJSON';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONExample.png|frameless|700px]]<br>

<h2> See Also </h2>
* [[TclJSONObject]]
* [[TclJSONArray]]
* [[TclJSONValue]]
* [[TclJSONPair]]

{{#seo:|title=TCLJSON Library Overview - Clomosy Docs}}
{{#seo:|description=Learn how to create, manipulate, validate, and save JSON objects and arrays using TCLJSON, with examples and type-safe value handling.}}

TclJSONObject

2025-10-22T06:24:07Z

Salih:

The <b>TCLJSONObject</b> class represents a JSON object composed of key–value pairs.
It provides structured methods to add, remove, clone, merge, and retrieve data.
Objects can contain nested objects or arrays, allowing hierarchical and deeply structured JSON representations.
TCLJSONObject ensures type safety by operating with <b>TCLJSONValue</b>, preventing data inconsistency during serialization and deserialization.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: JSON Object Structure
|-
| A JSON object is an unordered collection of name–value pairs, where each name is a string and the value may be a string, number, boolean, array, or another object.
|-
| Example: {"name":"Alice","age":25,"active":true}
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TCLJSONObject''' || obj : TCLJSONObject; || Creates a variable for JSON object.
|-
| '''Create''' || obj = TCLJSONObject.Create; || Initializes a new empty JSON object instance.
|-
| '''CreateFromJSON''' || obj = TCLJSONObject.CreateFromJSON(jsonStr); || Creates a JSON object from a JSON string.
|-
| '''AddPair''' || obj.AddPair('name', TCLJSONValue.Str('Alice')); || Adds a key–value pair to the object.
|-
| '''SetValue''' || obj.SetValue('age', TCLJSONValue.Int(25)); || Updates an existing key’s value or adds it if not present.
|-
| '''RemovePair''' || obj.RemovePair('age'); || Removes a key and its corresponding value.
|-
| '''AddObject''' || obj.AddObject('address', ChildObj); || Adds a nested JSON object as a child.
|-
| '''AddArray''' || obj.AddArray('scores', Arr); || Adds a JSON array under a key.
|-
| '''HasKey''' || obj.HasKey('active'); || Checks whether the specified key exists.
|-
| '''GetValue''' || val = obj.GetValue('name'); || Retrieves the value of a given key as a TCLJSONValue.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('user.profile.name'); || Retrieves a value using dot notation for nested structures.
|-
| '''Merge''' || obj.Merge(ExtraObj); || Merges another object’s pairs into the current object.
|-
| '''Clone''' || copy = obj.Clone; || Creates a deep copy of the object, including all nested items.
|-
| '''ToJSONString''' || obj.ToJSONString; || Serializes the object into a JSON string format.
|-
| '''FromJSONString''' || obj.FromJSONString(jsonStr); || Replaces current data with the content of a JSON string.
|-
| '''Clear''' || obj.Clear; || Removes all key–value pairs from the object.
|-
| '''Count''' || obj.Count; || Returns the number of key–value pairs within the object.
|-
| '''IsEmpty''' || obj.IsEmpty; || Returns True if the object contains no pairs.
|-
| '''SaveToFile''' || TCLJSON.SaveObjectToFile(obj, 'data.json'); || Saves the current object to a file.
|-
| '''LoadFromFile''' || obj = TCLJSON.LoadObjectFromFile('data.json'); || Loads a JSON object from a file.
|-
| '''IsValidJSON''' || TCLJSON.IsValidJSON(jsonStr); || Checks if the string is a valid JSON format.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Nested Object Access
|-
| Use <code>GetValueByPath</code> to access deeply nested elements.
Example: <code>user.GetValueByPath('account.details.email')</code> returns the email value from a nested JSON structure.
|}
</div>

<div class="alert alert-info shadow-sm rounded-4 p-3" style="border-left:6px solid #0d6efd;">
<h4 class="mb-2">Important Notes</h4>
<ul style="margin-left:10px;">
<li>All key names in <code>TCLJSONObject</code> are case-sensitive.</li>
<li>Nested paths must use dot notation.</li>
<li>When merging objects, existing keys are overwritten by the new object’s values.</li>
<li>Use <code>Clone</code> for duplication instead of manual re-construction to preserve data integrity.</li>
<li>Always free JSON objects after use to avoid memory leaks.</li>
</ul>
</div>

=== Example: TCLJSONObject in Use ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt, CityEdt: TClProEdit;
ActiveChk: TClCheckBox;
CreateBtn: TClProButton;
ResultMemo: TClMemo;

void GenerateJSONObject
var
Obj, Child, Extra: TCLJSONObject;
Val: TCLJSONValue;
{
try
Obj = TCLJSONObject.Create;
Child = TCLJSONObject.Create;
Extra = TCLJSONObject.Create;
try
// Key-value pairs
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToIntDef(AgeEdt.Text, 0)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.IsChecked));

// Nested object
Child.AddPair('city', TCLJSONValue.Str(CityEdt.Text));
Obj.AddObject('address', Child);

// Additional info (merge)
Extra.AddPair('status', TCLJSONValue.Str('OK'));
Obj.Merge(Extra);

// Retrieve deep value
Val = Obj.GetValueByPath('address.city');
ShowMessage('City: ' + Val.AsString);

// Show JSON output
ResultMemo.Lines.Text = Obj.ToJSONString;

except
ShowMessage('An error occurred while creating JSON: ' + LastExceptionMessage);
}
finally
Obj.Free;
Child.Free;
Extra.Free;
}
}

{
MyForm = TClForm.Create(Self);

NameEdt = MyForm.AddNewProEdit(MyForm, 'NameEdt', 'Name');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Left = 25;
NameEdt.Margins.Bottom = 25;
NameEdt.Margins.Right = 25;

AgeEdt = MyForm.AddNewProEdit(MyForm, 'AgeEdt', 'Age');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Left = 25;
AgeEdt.Margins.Bottom = 25;
AgeEdt.Margins.Right = 25;

CityEdt = MyForm.AddNewProEdit(MyForm, 'CityEdt', 'City');
CityEdt.Align = alTop;
CityEdt.Height = 35;
CityEdt.Margins.Left = 25;
CityEdt.Margins.Bottom = 25;
CityEdt.Margins.Right = 25;

ActiveChk = MyForm.AddNewCheckBox(MyForm, 'ActiveChk', 'Is Active?');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 15;
ActiveChk.Margins.Top = 10;

ResultMemo = MyForm.AddNewMemo(MyForm, 'ResultMemo', 'JSON Output');
ResultMemo.Align = alClient;
ResultMemo.Height = 200;
ResultMemo.TextSettings.WordWrap = True;

CreateBtn = MyForm.AddNewProButton(MyForm, 'CreateBtn', 'Generate JSON');
CreateBtn.Align = alBottom;
CreateBtn.Margins.Left = 15;
CreateBtn.Margins.Right = 15;
CreateBtn.Margins.Bottom = 10;
CreateBtn.OnClick = 'GenerateJSONObject';

MyForm.Run;
}

</pre>

Output:
[[File:TCLJSONObject.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TclJSONArray]]
* [[TclJSONValue]]
* [[TclJSONPair]]
* [[TclJSON]]

{{#seo:|title=TCLJSONObject Class - Clomosy Docs}}
{{#seo:|description=Detailed documentation of TCLJSONObject class, including features, methods, nested path access, and practical examples for JSON object manipulation.}}

File:TCLJSONObject.png

2025-10-22T06:20:20Z

Salih:

TclJSON

2025-10-21T12:59:28Z

Salih:

TCLJSON is a structured and type-safe JSON processing library designed to facilitate the creation, manipulation, and validation of JSON data. It enables the definition of objects, arrays, and values representing standard JSON types, including strings, numbers, booleans, and null elements.

The library provides mechanisms for constructing hierarchical data models, performing key-value pair operations, merging multiple JSON structures, and retrieving nested elements through deep path access. TCLJSON ensures strict compliance with JSON syntax rules, offering validation methods to verify data integrity during parsing and serialization.

In addition to in-memory operations, TCLJSON supports persistent data handling through file-based loading and saving of JSON content. Its strongly typed architecture promotes reliability, consistency, and maintainability in applications that require structured data representation, configuration management, or data exchange using the JSON format.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: What is TCLJSON?
|-
| style="padding-top: 5px;" | TCLJSON allows you to create, manipulate, and serialize JSON data structures. It supports nested objects, arrays, type-safe values, deep path access, merging, cloning, and file operations.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="width:100%"
! Class !! Description
|-
| [[TclJSONArray]] || Represents a JSON array with ordered values. Supports adding/removing values or objects, merging, cloning, and enumeration.
|-
| [[TclJSONObject]] || Represents a JSON object with key-value pairs. Provides methods for adding, removing, merging, cloning, and deep path access.
|-
| [[TclJSONPair]] || Represents a single key-value pair inside a JSON object.
|-
| [[TclJSONValue]] || Encapsulates a JSON value (string, integer, number, boolean, datetime, or null) and provides type-safe methods.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Type-Safe JSON Values
|-
| TCLJSONValue provides class functions like '''Str''', '''Int''', '''Bool''', '''Num''', '''DT''', and '''Null''' to safely create JSON values without manual conversion.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TCLJSONObject''' || obj : TCLJSONObject; || Creates a variable for JSON object.
|-
| '''TCLJSONArray''' || arr : TCLJSONArray; || Creates a variable for JSON array.
|-
| '''AddPair''' || obj.AddPair('key', TCLJSONValue.Str('value')); || Adds a key-value pair to JSON object.
|-
| '''AddObject''' || obj.AddObject('child', ChildObj); || Adds a nested JSON object.
|-
| '''AddArray''' || obj.AddArray('letters', Arr); || Adds a JSON array inside object.
|-
| '''Merge''' || obj.Merge(ExtraObj); || Merges another object into current.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('level1.level2'); || Retrieves a value from nested path.
|-
| '''ToJSONString''' || obj.ToJSONString; || Converts object/array to JSON string.
|-
| '''IsValidJSON''' || TCLJSON.IsValidJSON(str); || Checks if string is valid JSON.
|-
| '''SaveObjectToFile''' || TCLJSON.SaveObjectToFile(obj, 'file.json'); || Saves JSON object to file.
|}
</div>

=== Example: TCLJSON in Action ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt: TClProEdit;
ActiveChk: TClCheckBox;
ShowBtn: TClProButton;
ResultMemo: TClMemo;

void GenerateJSON
var
Obj, Child, Extra: TCLJSONObject;
Arr: TCLJSONArray;
Val: TCLJSONValue;
{
try
// Main JSON object
Obj = TCLJSONObject.Create;
try
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToInt(AgeEdt.Text)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.isChecked));

// Nested object
Child = TCLJSONObject.Create;
Child.AddPair('ChildLevel', TCLJSONValue.Str('This is a deep value'));
Obj.AddObject('ParentLevel', Child);

// Array
Arr = TCLJSONArray.Create;
Arr.AddValue(TCLJSONValue.Str('X'));
Arr.AddValue(TCLJSONValue.Str('Y'));
Arr.AddValue(TCLJSONValue.Str('Z'));
Obj.AddArray('letters', Arr);

// Merge object
Extra = TCLJSONObject.Create;
Extra.AddPair('status', TCLJSONValue.Str('ok'));
Obj.Merge(Extra);

// Deep value access (Optional)
Val = Obj.GetValueByPath('ParentLevel.ChildLevel');

// Add JSON to Memo
ResultMemo.Lines.Text = Obj.ToJSONString;

// Deep value shown (Optional)
ShowMessage('Deep value: ' + Val.AsString);

except
ShowMessage('Error: ' + LastExceptionMessage);
}
except
ShowMessage('Unexpected Error: ' + LastExceptionMessage);
}
}

{
MyForm = TClForm.Create(Self);

NameEdt = MyForm.AddNewProEdit(MyForm,'NameEdt','Name');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Left = 25;
NameEdt.Margins.Bottom = 25;
NameEdt.Margins.Right = 25;

AgeEdt = MyForm.AddNewProEdit(MyForm,'AgeEdt','Age');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Left = 25;
AgeEdt.Margins.Bottom = 25;
AgeEdt.Margins.Right = 25;

ActiveChk = MyForm.AddNewCheckBox(MyForm,'ActiveChk','Active');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 15;
ActiveChk.Margins.Top = 10;

ResultMemo = MyForm.AddNewMemo(MyForm,'ResultMemo','JSON Output');
ResultMemo.Align = alClient;
ResultMemo.Height = 200;
ResultMemo.StyledSettings = ssFamily;
ResultMemo.TextSettings.WordWrap = True;

ShowBtn = MyForm.AddNewProButton(MyForm,'ShowBtn','Show JSON');
ShowBtn.Align = alBottom;
ShowBtn.Margins.Left = 15;
ShowBtn.Margins.Right = 15;
ShowBtn.Margins.Bottom = 10;
ShowBtn.OnClick = 'GenerateJSON';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONExample.png|frameless|700px]]<br>

<h2> See Also </h2>
* [[TCLJSONObject]]
* [[TCLJSONArray]]
* [[TCLJSONValue]]
* [[TCLJSONPair]]

{{#seo:|title=TCLJSON Library Overview - Clomosy Docs}}
{{#seo:|description=Learn how to create, manipulate, validate, and save JSON objects and arrays using TCLJSON, with examples and type-safe value handling.}}

TclJSONObject

2025-10-21T12:58:07Z

Salih: Created page with "<div class="alert alert-light border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert"> class <b>TCLJSONObject</b> </div> The <b>TCLJSONObject</b> class represents a JSON object composed of key–value pairs. It provides structured methods to add, remove, clone, merge, and retrieve data. Objects can contain nested objects or arrays, allowing hierarchical and deeply structured JSON representations. TCLJSONObject ensures type safety by operating w..."

<div class="alert alert-light border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
class <b>TCLJSONObject</b>
</div>

The <b>TCLJSONObject</b> class represents a JSON object composed of key–value pairs.
It provides structured methods to add, remove, clone, merge, and retrieve data.
Objects can contain nested objects or arrays, allowing hierarchical and deeply structured JSON representations.
TCLJSONObject ensures type safety by operating with <b>TCLJSONValue</b>, preventing data inconsistency during serialization and deserialization.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: JSON Object Structure
|-
| A JSON object is an unordered collection of name–value pairs, where each name is a string and the value may be a string, number, boolean, array, or another object.
|-
| Example: {"name":"Alice","age":25,"active":true}
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TCLJSONObject''' || obj : TCLJSONObject; || Creates a variable for JSON object.
|-
| '''Create''' || obj = TCLJSONObject.Create; || Initializes a new empty JSON object instance.
|-
| '''CreateFromJSON''' || obj = TCLJSONObject.CreateFromJSON(jsonStr); || Creates a JSON object from a JSON string.
|-
| '''AddPair''' || obj.AddPair('name', TCLJSONValue.Str('Alice')); || Adds a key–value pair to the object.
|-
| '''SetValue''' || obj.SetValue('age', TCLJSONValue.Int(25)); || Updates an existing key’s value or adds it if not present.
|-
| '''RemovePair''' || obj.RemovePair('age'); || Removes a key and its corresponding value.
|-
| '''AddObject''' || obj.AddObject('address', ChildObj); || Adds a nested JSON object as a child.
|-
| '''AddArray''' || obj.AddArray('scores', Arr); || Adds a JSON array under a key.
|-
| '''HasKey''' || obj.HasKey('active'); || Checks whether the specified key exists.
|-
| '''GetValue''' || val = obj.GetValue('name'); || Retrieves the value of a given key as a TCLJSONValue.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('user.profile.name'); || Retrieves a value using dot notation for nested structures.
|-
| '''Merge''' || obj.Merge(ExtraObj); || Merges another object’s pairs into the current object.
|-
| '''Clone''' || copy = obj.Clone; || Creates a deep copy of the object, including all nested items.
|-
| '''ToJSONString''' || obj.ToJSONString; || Serializes the object into a JSON string format.
|-
| '''FromJSONString''' || obj.FromJSONString(jsonStr); || Replaces current data with the content of a JSON string.
|-
| '''Clear''' || obj.Clear; || Removes all key–value pairs from the object.
|-
| '''Count''' || obj.Count; || Returns the number of key–value pairs within the object.
|-
| '''IsEmpty''' || obj.IsEmpty; || Returns True if the object contains no pairs.
|-
| '''SaveToFile''' || TCLJSON.SaveObjectToFile(obj, 'data.json'); || Saves the current object to a file.
|-
| '''LoadFromFile''' || obj = TCLJSON.LoadObjectFromFile('data.json'); || Loads a JSON object from a file.
|-
| '''IsValidJSON''' || TCLJSON.IsValidJSON(jsonStr); || Checks if the string is a valid JSON format.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Nested Object Access
|-
| Use <code>GetValueByPath</code> to access deeply nested elements.
Example: <code>user.GetValueByPath('account.details.email')</code> returns the email value from a nested JSON structure.
|}
</div>

=== Example: TCLJSONObject in Use ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt, CityEdt: TClProEdit;
ActiveChk: TClCheckBox;
CreateBtn: TClProButton;
ResultMemo: TClMemo;

void GenerateJSONObject
var
Obj, Child, Extra: TCLJSONObject;
Val: TCLJSONValue;
{
try
Obj = TCLJSONObject.Create;
Child = TCLJSONObject.Create;
Extra = TCLJSONObject.Create;
try
// Key-value pairs
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToIntDef(AgeEdt.Text, 0)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.IsChecked));

// Nested object
Child.AddPair('city', TCLJSONValue.Str(CityEdt.Text));
Obj.AddObject('address', Child);

// Additional info (merge)
Extra.AddPair('status', TCLJSONValue.Str('OK'));
Obj.Merge(Extra);

// Retrieve deep value
Val = Obj.GetValueByPath('address.city');
ShowMessage('City: ' + Val.AsString);

// Show JSON output
ResultMemo.Lines.Text = Obj.ToJSONString;

except
ShowMessage('An error occurred while creating JSON: ' + LastExceptionMessage);
}
finally
Obj.Free;
Child.Free;
Extra.Free;
}
}

{
MyForm = TClForm.Create(Self);

NameEdt = MyForm.AddNewProEdit(MyForm, 'NameEdt', 'Name');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Left = 25;
NameEdt.Margins.Bottom = 25;
NameEdt.Margins.Right = 25;

AgeEdt = MyForm.AddNewProEdit(MyForm, 'AgeEdt', 'Age');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Left = 25;
AgeEdt.Margins.Bottom = 25;
AgeEdt.Margins.Right = 25;

CityEdt = MyForm.AddNewProEdit(MyForm, 'CityEdt', 'City');
CityEdt.Align = alTop;
CityEdt.Height = 35;
CityEdt.Margins.Left = 25;
CityEdt.Margins.Bottom = 25;
CityEdt.Margins.Right = 25;

ActiveChk = MyForm.AddNewCheckBox(MyForm, 'ActiveChk', 'Is Active?');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 15;
ActiveChk.Margins.Top = 10;

ResultMemo = MyForm.AddNewMemo(MyForm, 'ResultMemo', 'JSON Output');
ResultMemo.Align = alClient;
ResultMemo.Height = 200;
ResultMemo.TextSettings.WordWrap = True;

CreateBtn = MyForm.AddNewProButton(MyForm, 'CreateBtn', 'Generate JSON');
CreateBtn.Align = alBottom;
CreateBtn.Margins.Left = 15;
CreateBtn.Margins.Right = 15;
CreateBtn.Margins.Bottom = 10;
CreateBtn.OnClick = 'GenerateJSONObject';

MyForm.Run;
}

</pre>

Output:
[[File:TCLJSONObjectExample.png|frameless|600px]]<br>

=== Notes ===
* All key names in TCLJSONObject are case-sensitive.
* Nested paths must use dot notation.
* When merging objects, existing keys are overwritten by the new object’s values.
* Use <code>Clone</code> for duplication instead of manual re-construction to preserve data integrity.
* Always free JSON objects after use to avoid memory leaks.

<h2> See Also </h2>
* [[TCLJSONArray]]
* [[TCLJSONValue]]
* [[TCLJSONPair]]
* [[TCLJSON]]

{{#seo:|title=TCLJSONObject Class - Clomosy Docs}}
{{#seo:|description=Detailed documentation of TCLJSONObject class, including features, methods, nested path access, and practical examples for JSON object manipulation.}}

TclJSON

2025-10-21T12:43:11Z

Salih:

TCLJSON is a structured and type-safe JSON processing library designed to facilitate the creation, manipulation, and validation of JSON data. It enables the definition of objects, arrays, and values representing standard JSON types, including strings, numbers, booleans, and null elements.

The library provides mechanisms for constructing hierarchical data models, performing key-value pair operations, merging multiple JSON structures, and retrieving nested elements through deep path access. TCLJSON ensures strict compliance with JSON syntax rules, offering validation methods to verify data integrity during parsing and serialization.

In addition to in-memory operations, TCLJSON supports persistent data handling through file-based loading and saving of JSON content. Its strongly typed architecture promotes reliability, consistency, and maintainability in applications that require structured data representation, configuration management, or data exchange using the JSON format.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: What is TCLJSON?
|-
| style="padding-top: 5px;" | TCLJSON allows you to create, manipulate, and serialize JSON data structures. It supports nested objects, arrays, type-safe values, deep path access, merging, cloning, and file operations.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="width:100%"
! Class !! Description
|-
| [[TCLJSONArray]] || Represents a JSON array with ordered values. Supports adding/removing values or objects, merging, cloning, and enumeration.
|-
| [[TCLJSONObject]] || Represents a JSON object with key-value pairs. Provides methods for adding, removing, merging, cloning, and deep path access.
|-
| [[TCLJSONPair]] || Represents a single key-value pair inside a JSON object.
|-
| [[TCLJSONValue]] || Encapsulates a JSON value (string, integer, number, boolean, datetime, or null) and provides type-safe methods.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Type-Safe JSON Values
|-
| TCLJSONValue provides class functions like '''Str''', '''Int''', '''Bool''', '''Num''', '''DT''', and '''Null''' to safely create JSON values without manual conversion.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TCLJSONObject''' || obj : TCLJSONObject; || Creates a variable for JSON object.
|-
| '''TCLJSONArray''' || arr : TCLJSONArray; || Creates a variable for JSON array.
|-
| '''AddPair''' || obj.AddPair('key', TCLJSONValue.Str('value')); || Adds a key-value pair to JSON object.
|-
| '''AddObject''' || obj.AddObject('child', ChildObj); || Adds a nested JSON object.
|-
| '''AddArray''' || obj.AddArray('letters', Arr); || Adds a JSON array inside object.
|-
| '''Merge''' || obj.Merge(ExtraObj); || Merges another object into current.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('level1.level2'); || Retrieves a value from nested path.
|-
| '''ToJSONString''' || obj.ToJSONString; || Converts object/array to JSON string.
|-
| '''IsValidJSON''' || TCLJSON.IsValidJSON(str); || Checks if string is valid JSON.
|-
| '''SaveObjectToFile''' || TCLJSON.SaveObjectToFile(obj, 'file.json'); || Saves JSON object to file.
|}
</div>

=== Example: TCLJSON in Action ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt: TClProEdit;
ActiveChk: TClCheckBox;
ShowBtn: TClProButton;
ResultMemo: TClMemo;

void GenerateJSON
var
Obj, Child, Extra: TCLJSONObject;
Arr: TCLJSONArray;
Val: TCLJSONValue;
{
try
// Main JSON object
Obj = TCLJSONObject.Create;
try
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToInt(AgeEdt.Text)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.isChecked));

// Nested object
Child = TCLJSONObject.Create;
Child.AddPair('ChildLevel', TCLJSONValue.Str('This is a deep value'));
Obj.AddObject('ParentLevel', Child);

// Array
Arr = TCLJSONArray.Create;
Arr.AddValue(TCLJSONValue.Str('X'));
Arr.AddValue(TCLJSONValue.Str('Y'));
Arr.AddValue(TCLJSONValue.Str('Z'));
Obj.AddArray('letters', Arr);

// Merge object
Extra = TCLJSONObject.Create;
Extra.AddPair('status', TCLJSONValue.Str('ok'));
Obj.Merge(Extra);

// Deep value access (Optional)
Val = Obj.GetValueByPath('ParentLevel.ChildLevel');

// Add JSON to Memo
ResultMemo.Lines.Text = Obj.ToJSONString;

// Deep value shown (Optional)
ShowMessage('Deep value: ' + Val.AsString);

except
ShowMessage('Error: ' + LastExceptionMessage);
}
except
ShowMessage('Unexpected Error: ' + LastExceptionMessage);
}
}

{
MyForm = TClForm.Create(Self);

NameEdt = MyForm.AddNewProEdit(MyForm,'NameEdt','Name');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Left = 25;
NameEdt.Margins.Bottom = 25;
NameEdt.Margins.Right = 25;

AgeEdt = MyForm.AddNewProEdit(MyForm,'AgeEdt','Age');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Left = 25;
AgeEdt.Margins.Bottom = 25;
AgeEdt.Margins.Right = 25;

ActiveChk = MyForm.AddNewCheckBox(MyForm,'ActiveChk','Active');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 15;
ActiveChk.Margins.Top = 10;

ResultMemo = MyForm.AddNewMemo(MyForm,'ResultMemo','JSON Output');
ResultMemo.Align = alClient;
ResultMemo.Height = 200;
ResultMemo.StyledSettings = ssFamily;
ResultMemo.TextSettings.WordWrap = True;

ShowBtn = MyForm.AddNewProButton(MyForm,'ShowBtn','Show JSON');
ShowBtn.Align = alBottom;
ShowBtn.Margins.Left = 15;
ShowBtn.Margins.Right = 15;
ShowBtn.Margins.Bottom = 10;
ShowBtn.OnClick = 'GenerateJSON';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONExample.png|frameless|700px]]<br>

<h2> See Also </h2>
* [[TCLJSONObject]]
* [[TCLJSONArray]]
* [[TCLJSONValue]]
* [[TCLJSONPair]]

{{#seo:|title=TCLJSON Library Overview - Clomosy Docs}}
{{#seo:|description=Learn how to create, manipulate, validate, and save JSON objects and arrays using TCLJSON, with examples and type-safe value handling.}}

TclJSON

2025-10-21T12:36:05Z

Salih:

TCLJSON is a structured and type-safe JSON processing library designed to facilitate the creation, manipulation, and validation of JSON data. It enables the definition of objects, arrays, and values representing standard JSON types, including strings, numbers, booleans, and null elements.

The library provides mechanisms for constructing hierarchical data models, performing key-value pair operations, merging multiple JSON structures, and retrieving nested elements through deep path access. TCLJSON ensures strict compliance with JSON syntax rules, offering validation methods to verify data integrity during parsing and serialization.

In addition to in-memory operations, TCLJSON supports persistent data handling through file-based loading and saving of JSON content. Its strongly typed architecture promotes reliability, consistency, and maintainability in applications that require structured data representation, configuration management, or data exchange using the JSON format.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: What is TCLJSON?
|-
| style="padding-top: 5px;" | TCLJSON allows you to create, manipulate, and serialize JSON data structures. It supports nested objects, arrays, type-safe values, deep path access, merging, cloning, and file operations.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="width:100%"
! Class !! Description
|-
| [[TCLJSONObject]] || Represents a JSON object with key-value pairs. Provides methods for adding, removing, merging, cloning, and deep path access.
|-
| [[TCLJSONArray]] || Represents a JSON array with ordered values. Supports adding/removing values or objects, merging, cloning, and enumeration.
|-
| [[TCLJSONValue]] || Encapsulates a JSON value (string, integer, number, boolean, datetime, or null) and provides type-safe methods.
|-
| [[TCLJSONPair]] || Represents a single key-value pair inside a JSON object.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Type-Safe JSON Values
|-
| TCLJSONValue provides class functions like '''Str''', '''Int''', '''Bool''', '''Num''', '''DT''', and '''Null''' to safely create JSON values without manual conversion.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TCLJSONObject''' || obj : TCLJSONObject; || Creates a variable for JSON object.
|-
| '''TCLJSONArray''' || arr : TCLJSONArray; || Creates a variable for JSON array.
|-
| '''AddPair''' || obj.AddPair('key', TCLJSONValue.Str('value')); || Adds a key-value pair to JSON object.
|-
| '''AddObject''' || obj.AddObject('child', ChildObj); || Adds a nested JSON object.
|-
| '''AddArray''' || obj.AddArray('letters', Arr); || Adds a JSON array inside object.
|-
| '''Merge''' || obj.Merge(ExtraObj); || Merges another object into current.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('level1.level2'); || Retrieves a value from nested path.
|-
| '''ToJSONString''' || obj.ToJSONString; || Converts object/array to JSON string.
|-
| '''IsValidJSON''' || TCLJSON.IsValidJSON(str); || Checks if string is valid JSON.
|-
| '''SaveObjectToFile''' || TCLJSON.SaveObjectToFile(obj, 'file.json'); || Saves JSON object to file.
|}
</div>

=== Example: TCLJSON in Action ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt: TClProEdit;
ActiveChk: TClCheckBox;
ShowBtn: TClProButton;
ResultMemo: TClMemo;

void GenerateJSON
var
Obj, Child, Extra: TCLJSONObject;
Arr: TCLJSONArray;
Val: TCLJSONValue;
{
try
// Main JSON object
Obj = TCLJSONObject.Create;
try
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToInt(AgeEdt.Text)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.isChecked));

// Nested object
Child = TCLJSONObject.Create;
Child.AddPair('ChildLevel', TCLJSONValue.Str('This is a deep value'));
Obj.AddObject('ParentLevel', Child);

// Array
Arr = TCLJSONArray.Create;
Arr.AddValue(TCLJSONValue.Str('X'));
Arr.AddValue(TCLJSONValue.Str('Y'));
Arr.AddValue(TCLJSONValue.Str('Z'));
Obj.AddArray('letters', Arr);

// Merge object
Extra = TCLJSONObject.Create;
Extra.AddPair('status', TCLJSONValue.Str('ok'));
Obj.Merge(Extra);

// Deep value access (Optional)
Val = Obj.GetValueByPath('ParentLevel.ChildLevel');

// Add JSON to Memo
ResultMemo.Lines.Text = Obj.ToJSONString;

// Deep value shown (Optional)
ShowMessage('Deep value: ' + Val.AsString);

except
ShowMessage('Error: ' + LastExceptionMessage);
}
except
ShowMessage('Unexpected Error: ' + LastExceptionMessage);
}
}

{
MyForm = TClForm.Create(Self);

NameEdt = MyForm.AddNewProEdit(MyForm,'NameEdt','Name');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Left = 25;
NameEdt.Margins.Bottom = 25;
NameEdt.Margins.Right = 25;

AgeEdt = MyForm.AddNewProEdit(MyForm,'AgeEdt','Age');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Left = 25;
AgeEdt.Margins.Bottom = 25;
AgeEdt.Margins.Right = 25;

ActiveChk = MyForm.AddNewCheckBox(MyForm,'ActiveChk','Active');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 15;
ActiveChk.Margins.Top = 10;

ResultMemo = MyForm.AddNewMemo(MyForm,'ResultMemo','JSON Output');
ResultMemo.Align = alClient;
ResultMemo.Height = 200;
ResultMemo.StyledSettings = ssFamily;
ResultMemo.TextSettings.WordWrap = True;

ShowBtn = MyForm.AddNewProButton(MyForm,'ShowBtn','Show JSON');
ShowBtn.Align = alBottom;
ShowBtn.Margins.Left = 15;
ShowBtn.Margins.Right = 15;
ShowBtn.Margins.Bottom = 10;
ShowBtn.OnClick = 'GenerateJSON';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONExample.png|frameless|700px]]<br>

<h2> See Also </h2>
* [[TCLJSONObject]]
* [[TCLJSONArray]]
* [[TCLJSONValue]]
* [[TCLJSONPair]]

{{#seo:|title=TCLJSON Library Overview - Clomosy Docs}}
{{#seo:|description=Learn how to create, manipulate, validate, and save JSON objects and arrays using TCLJSON, with examples and type-safe value handling.}}

File:TCLJSONExample.png

2025-10-21T12:34:36Z

Salih: Salih uploaded a new version of File:TCLJSONExample.png

TclJSON

2025-10-21T11:30:21Z

Salih: Created page with "TCLJSON is a structured and type-safe JSON processing library designed to facilitate the creation, manipulation, and validation of JSON data. It enables the definition of objects, arrays, and values representing standard JSON types, including strings, numbers, booleans, and null elements. The library provides mechanisms for constructing hierarchical data models, performing key-value pair operations, merging multiple JSON structures, and retrieving nested elements throug..."

TCLJSON is a structured and type-safe JSON processing library designed to facilitate the creation, manipulation, and validation of JSON data. It enables the definition of objects, arrays, and values representing standard JSON types, including strings, numbers, booleans, and null elements.

The library provides mechanisms for constructing hierarchical data models, performing key-value pair operations, merging multiple JSON structures, and retrieving nested elements through deep path access. TCLJSON ensures strict compliance with JSON syntax rules, offering validation methods to verify data integrity during parsing and serialization.

In addition to in-memory operations, TCLJSON supports persistent data handling through file-based loading and saving of JSON content. Its strongly typed architecture promotes reliability, consistency, and maintainability in applications that require structured data representation, configuration management, or data exchange using the JSON format.

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #007bff; background-color: #e6f7ff; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #007bff; padding-bottom: 5px;" | Information: What is TCLJSON?
|-
| style="padding-top: 5px;" | TCLJSON allows you to create, manipulate, and serialize JSON data structures. It supports nested objects, arrays, type-safe values, deep path access, merging, cloning, and file operations.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="width:100%"
! Class !! Description
|-
| [[TCLJSONObject]] || Represents a JSON object with key-value pairs. Provides methods for adding, removing, merging, cloning, and deep path access.
|-
| [[TCLJSONArray]] || Represents a JSON array with ordered values. Supports adding/removing values or objects, merging, cloning, and enumeration.
|-
| [[TCLJSONValue]] || Encapsulates a JSON value (string, integer, number, boolean, datetime, or null) and provides type-safe methods.
|-
| [[TCLJSONPair]] || Represents a single key-value pair inside a JSON object.
|}
</div>

<div style="margin-bottom: 20px;">
{| class="infobox" style="width: 100%; border: 1px solid #28a745; background-color: #d4edda; border-radius: 5px; padding: 15px; border-collapse: separate;"
| style="font-weight: bold; color: #28a745; padding-bottom: 5px;" | Important: Type-Safe JSON Values
|-
| TCLJSONValue provides class functions like '''Str''', '''Int''', '''Bool''', '''Num''', '''DT''', and '''Null''' to safely create JSON values without manual conversion.
|}
</div>

<div class="table-responsive" style="margin-bottom: 20px;">
{| class="wikitable" style="border: 2px solid #c3d7e0; width:100%"
! style="background-color: #c3d7e0"| Feature
! style="background-color: #c3d7e0"| Use of
! style="background-color: #c3d7e0"| Definition
|-
| '''TCLJSONObject''' || obj : TCLJSONObject; || Creates a variable for JSON object.
|-
| '''TCLJSONArray''' || arr : TCLJSONArray; || Creates a variable for JSON array.
|-
| '''AddPair''' || obj.AddPair('key', TCLJSONValue.Str('value')); || Adds a key-value pair to JSON object.
|-
| '''AddObject''' || obj.AddObject('child', ChildObj); || Adds a nested JSON object.
|-
| '''AddArray''' || obj.AddArray('letters', Arr); || Adds a JSON array inside object.
|-
| '''Merge''' || obj.Merge(ExtraObj); || Merges another object into current.
|-
| '''GetValueByPath''' || val = obj.GetValueByPath('level1.level2'); || Retrieves a value from nested path.
|-
| '''ToJSONString''' || obj.ToJSONString; || Converts object/array to JSON string.
|-
| '''IsValidJSON''' || TCLJSON.IsValidJSON(str); || Checks if string is valid JSON.
|-
| '''SaveObjectToFile''' || TCLJSON.SaveObjectToFile(obj, 'file.json'); || Saves JSON object to file.
|}
</div>

=== Example: TCLJSON in Action ===
<pre>
var
MyForm: TClForm;
NameEdt, AgeEdt: TClProEdit;
ActiveChk: TClCheckBox;
ShowBtn: TClProButton;
ResultMemo: TClMemo;

void GenerateJSON
var
Obj, Child, Extra: TCLJSONObject;
Arr: TCLJSONArray;
Val: TCLJSONValue;
{
try
// Main JSON object
Obj = TCLJSONObject.Create;
try
Obj.AddPair('name', TCLJSONValue.Str(NameEdt.Text));
Obj.AddPair('age', TCLJSONValue.Int(StrToInt(AgeEdt.Text)));
Obj.AddPair('active', TCLJSONValue.Bool(ActiveChk.isChecked));

// Nested object
Child = TCLJSONObject.Create;
Child.AddPair('ChildLevel', TCLJSONValue.Str('This is a deep value'));
Obj.AddObject('ParentLevel', Child);

// Array
Arr = TCLJSONArray.Create;
Arr.AddValue(TCLJSONValue.Str('X'));
Arr.AddValue(TCLJSONValue.Str('Y'));
Arr.AddValue(TCLJSONValue.Str('Z'));
Obj.AddArray('letters', Arr);

// Merge object
Extra = TCLJSONObject.Create;
Extra.AddPair('status', TCLJSONValue.Str('ok'));
Obj.Merge(Extra);

// Deep value access (Optional)
Val = Obj.GetValueByPath('ParentLevel.ChildLevel');

// Add JSON to Memo
ResultMemo.Lines.Text = Obj.ToJSONString;

// Deep value shown (Optional)
ShowMessage('Deep value: ' + Val.AsString);

except
ShowMessage('Error: ' + LastExceptionMessage);
}
except
ShowMessage('Unexpected Error: ' + LastExceptionMessage);
}
}

{
MyForm = TClForm.Create(Self);

NameEdt = MyForm.AddNewProEdit(MyForm,'NameEdt','Name');
NameEdt.Align = alTop;
NameEdt.Height = 35;
NameEdt.Margins.Left = 25;
NameEdt.Margins.Bottom = 25;
NameEdt.Margins.Right = 25;

AgeEdt = MyForm.AddNewProEdit(MyForm,'AgeEdt','Age');
AgeEdt.Align = alTop;
AgeEdt.Height = 35;
AgeEdt.Margins.Left = 25;
AgeEdt.Margins.Bottom = 25;
AgeEdt.Margins.Right = 25;

ActiveChk = MyForm.AddNewCheckBox(MyForm,'ActiveChk','Active');
ActiveChk.Align = alTop;
ActiveChk.Margins.Left = 15;
ActiveChk.Margins.Top = 10;

ResultMemo = MyForm.AddNewMemo(MyForm,'ResultMemo','JSON Output');
ResultMemo.Align = alClient;
ResultMemo.Height = 200;
ResultMemo.StyledSettings = ssFamily;
ResultMemo.TextSettings.WordWrap = True;

ShowBtn = MyForm.AddNewProButton(MyForm,'ShowBtn','Show JSON');
ShowBtn.Align = alBottom;
ShowBtn.Margins.Left = 15;
ShowBtn.Margins.Right = 15;
ShowBtn.Margins.Bottom = 10;
ShowBtn.OnClick = 'GenerateJSON';

MyForm.Run;
}

</pre>

Output:

[[File:TCLJSONExample.png|frameless|600px]]<br>

<h2> See Also </h2>
* [[TCLJSONObject]]
* [[TCLJSONArray]]
* [[TCLJSONValue]]
* [[TCLJSONPair]]

{{#seo:|title=TCLJSON Library Overview - Clomosy Docs}}
{{#seo:|description=Learn how to create, manipulate, validate, and save JSON objects and arrays using TCLJSON, with examples and type-safe value handling.}}

File:TCLJSONExample.png

2025-10-21T11:28:41Z

Salih:

TclGridLayout

2025-10-21T09:02:30Z

Salih:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewGridLayout(AComponent: TCLComponent; xName: string): TclGridLayout;
</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 GridLayout should be written.<br>

It is used to arrange components on the form within a fixed grid structure. Simply put, it automatically places buttons, labels, and other visual elements into rows and columns based on predefined item width and height values. When the current row or column becomes full, the layout automatically continues placing elements in the next one.

This layout ensures that all components are aligned and sized uniformly, creating a clean and balanced interface. TCLGridLayout is particularly useful when you need a consistent, grid-like arrangement of elements — for example, in dashboards, icon views, or uniform control layouts that must maintain equal spacing and proportions.
<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
|-
|TclGridLayout || GridLayout1 : TclGridLayout; || A variable belonging to the TclGridLayout class is created.
|-
|AddNewGridLayout || GridLayout1 = Form1.AddNewGridLayout(Form1,'GridLayout1'); || A new TclGridLayout is added to the form.
|-
|Align || GridLayout1.Align = alTop; || Specifies how the GridLayout is aligned within its parent container. Multiple alignment options are available. See the [[Object_Properties#Align | page]] for more details.
|-
|ItemHeight || GridLayout1.ItemHeight = 50; || Defines the height of each item (child control) within the grid layout.
|-
|ItemWidth || GridLayout1.ItemWidth = 100; || Defines the width of each item (child control) within the grid layout.
|-
|Margins || GridLayout1.Margins.Left = 50; // Right, Top, Bottom || Allows setting margins around the GridLayout container.<br>[[File:PanelAppearance.png|frameless|200px]]<br><br>
|}
</div>

<b>Example</b><br>
<pre>
var
MyForm:TclForm;
GridLayout:TCLGridLayout;
testButton : TclButton;
I:integer;
NewHeightEdit,NewWidthEdit : TCLLabel;
ChangeSizeButton : TclButton;

void ChangeSize{

GridLayout.ItemHeight = NewHeightEdit.Text;
GridLayout.ItemWidth = NewWidthEdit.Text;
}

{
MyForm=TclForm.Create(self);

GridLayout = MyForm.AddNewGridLayout(MyForm,'GridLayout');
GridLayout.Align = alClient;
GridLayout.ItemHeight = 50;
GridLayout.ItemWidth = 50;

for (I = 0 to 10) {
testButton = MyForm.AddNewButton(GridLayout,'testButton'+IntToStr(I),'Button'+IntToStr(I));
}

NewWidthEdit = MyForm.AddNewEdit(MyForm,'NewWidthEdit', 'New Width');
NewWidthEdit.Align = alTop;

NewHeightEdit = MyForm.AddNewEdit(MyForm,'NewHeightEdit', 'New Height');
NewHeightEdit.Align = alTop;

ChangeSizeButton = MyForm.AddNewButton(MyForm,'ChangeSizeButton','Change');
ChangeSizeButton.Align = alTop;
ChangeSizeButton.Margins.Top = 20;
ChangeSizeButton.Margins.Bottom = 20;
MyForm.AddNewEvent(ChangeSizeButton,tbeOnClick,'ChangeSize');
MyForm.Run;
}

</pre>
Output:

[[File:GridLayout.gif|frameless|thumb|600px]]

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[TclLayout]]

{{#seo:|title=TclScaledLayout Using in Clomosy - Clomosy Docs}}
{{#seo:|description= Learn how TclScaledLayout automatically scales and arranges visual components, keeping interface proportions consistent across different resolutions.}}

Components

2025-10-21T08:36:02Z

Salih:

In software development, components are reusable objects used to perform specific functions. Components can serve a wide range of tasks, from user interface elements to more technical functions like data access or network communication.<br>
Clomosy components are object-oriented and derived from the TCLComponent class, which allows them to be categorized as either visual (interacting with the user interface) or non-visual (working in the background) elements.<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
To use component properties, please visit the <b>[[Object Properties]]</b> page.
</div>

<h2> Visual Components </h2>
Visual components are elements that appear in the user interface and interact directly with users. These components allow users to easily access specific functions within the screens provided by the software.<br>
Examples of visual components include buttons, text boxes, lists, and image boxes. Users can interact with these components by clicking, entering data, or making selections to engage with the program.

<h3> Standard Components </h3>
Standard components are commonly used to provide basic user interface and application functionality. These components form the foundation of an application's core functions and are typically available by default in most development environments.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Component Name !!style="background-color: #c3d7e0"| Explanation
|-
| [[TclPanel]] || A basic panel component that acts as a container for organizing other components.
|-
| [[TclLayout]] || A layout component used to arrange, group, and maintain a specific order for control elements.
|-
| [[TclScaledLayout]] || A layout component used to arrange, group, and maintain a specific order of control elements while preserving their original aspect ratios.
|-
| [[TclFlowLayout]] || A layout component that arranges controls in a flow, moving items to the next line when space runs out.
|-
| [[TclGridLayout]] || A layout component that arranges controls in a uniform grid based on fixed item Width and Heigth, moving items to the next row when space runs out.
|-
| [[TclLabel]] || A label component used to display fixed text.
|-
| [[TclEdit]] || An input box that allows the user to enter short text.
|-
| [[TclMemo]] || A text box providing multi-line text entry and display.
|-
| [[TclButton]] || A button component used to initiate actions when clicked by the user.
|-
| [[TclImage]] || An image component used to display visual elements on the screen.
|-
| [[TclChart]] || A chart component used to visualize data in the form of graphs.
|-
| [[TclVertScrollBox]] || A box that displays content within a vertically scrollable area.
|-
| [[TclHorzScrollBox]] || A box that displays content within a horizontally scrollable area.
|-
| [[TclFramedScrollBox]] || A box that displays content within a scrollable framed area.
|-
| [[TclRadioButton]] || A component used to allow the user to select only one option within a group of choices.
|-
| [[TclCheckBox]] || A checkbox that allows selection among multiple options.
|-
| [[TclComboBox]] || A drop-down menu component that allows the user to choose one of the options.
|-
| [[TclExpander]] || An expander component used to create areas that can be opened or closed when clicked.
|-
| [[TclQRCodeGenerator]] || A component used to generate QR codes.
|-
| [[TclListView]] || A listing component used to display data in list format.
|-
| [[TclMenuFrame]] || A frame component used for organizing menu structures.
|-
| [[TclStringGrid]] || A grid component displaying data in a tabular format with cells.
|-
| [[TclWebBrowser]] || A browser component for displaying web pages within the application.
|-
| [[TclSearchBox]] || A search box used to enable users to perform search actions.
|-
| [[TClNumberBox]] || A component used exclusively for numeric data entry.
|-
| [[TclPageControl]] || A tabbed interface component that allows displaying content on different pages.
|-
| [[TclSwitch]] || A toggle component that allows switching between on and off states.
|-
| [[TclBitmapListAnimation]] || It is a component used to create animations.
|-
| [[TclCircle]] || TclCircle represents a graphic element in the shape of a circle or ellipse.
|-
| [[TclRectangle]] || The TclRectangle component represents a rectangle and is commonly used in interface designs as a background or region.
|-
| [[TclRadioGroup]] || A RadioGroup is a component used to allow the selection of only one option from multiple choices.
|}
</div>

<h4> Advanced Technology Components </h4>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Component Name !!style="background-color: #c3d7e0"| Explanation
|-
| [[Camera Access]] || A component that provides access to the device's camera for capturing photos or videos.
|}
</div>

<h3> Professional Components </h3>
Pro components offer more advanced features and functionality, going beyond standard components. Pro components are used for more complex user interactions or special requirements and often provide additional features.<br>

For example, a TclProListViewDesignerPanel enables advanced list editing or data display. These components are especially preferred in professional and specialized applications where more functionality and customizability are needed.<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
You can use these features over the json structure. Visit the [[Pro Object Properties]] page to learn about the available parameters and how to use them.
</div>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Component Name !!style="background-color: #c3d7e0"| Explanation
|-
| [[TclProPanel]] || A professional panel component used to organize advanced components.
|-
| [[TclProLabel]] || A professional label component with enhanced features for displaying fixed text.
|-
| [[TClProEdit]] || A professional input box that allows short text entry.
|-
| [[TClProDateEdit]] || A professional date picker component that facilitates date entry.
|-
| [[TClProSearchEdit]] || A professional component with search functionality, allowing text input.
|-
| [[TClProButton]] || A professional button component used to initiate advanced actions.
|-
| [[TclProImage]] || A professional image component offering enhanced image display features.
|-
| [[TClProListView]] || A professional list component that displays data in list format with advanced features.
|-
| [[TClProListViewDesignerPanel]] || A professional list design panel used for organizing and customizing lists.
|-
| [[TclProGrid]] || A professional grid component for displaying data in tabular format with advanced editing and viewing features.
|}
</div>

<h2> Non-Visual Components </h2>
Non-visual components are components that are not visible in the user interface but perform specific functions in the background. These components are used for tasks such as data processing, timers, database connections, or file operations, and they do not interact directly with the user.<br>
For example, a TclTimer component can perform specific actions at set intervals.

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Component Name !!style="background-color: #c3d7e0"| Explanation
|-
| [[TClTimer]] || A timer component used to trigger processes at specified intervals.
|-
| [[TclOpenAIEngine]] || A component used to integrate OpenAI's artificial intelligence services.
|-
| [[TclDeviceManager]] || A component used for device management and accessing device features.
|-
| [[TclMediaPlayer]] || A media player component that supports audio playback functions.
|-
| [[TclHttp]] || A component used for data communication over the HTTP protocol.
|-
| [[TclRest]] || A component that facilitates data exchange with RESTful services.
|-
| [[TclMQTT]] || A component enabling messaging and data communication between devices using the MQTT protocol.
|-
| [[TclMQTTClient]] || A Component for connecting to an MQTT Broker, used for publishing and subscribing to real-time topics.
|-
| [[TclBlobField]] || A BLOB field used to store and manage large data pieces (images, videos, files).
|-
| [[TclFileStream]] || A component used to manage file streams and access files.
|-
| [[TclMemoryStream]] || A component used to manage data streams within memory.
|-
| [[TclGameEngine]] || It is a game engine component used to develop word-based games.
|}
</div>

<div class="alert alert-success" role="alert" data-bs-theme="light">
<h2 class="alert-heading">Events</h2>
<p>It is a function or action triggered when a specific event occurs, such as user interaction (e.g., clicking a button, mouse movement) or system status (e.g., completion of a file or network connection loss).</p>
<hr>
<br>
<div class ="green-learn-more" >
[[Events|Learn More]]
</div>
</div>

<h2> See Also </h2>
* [[TRObject Language]]
* [[Object Properties]]
* [[Pro Object Properties]]
* [[Sensor Structures]]
{{#seo:|title=Components in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn about Components in Clomosy. A guide to understanding and using various components to build powerful mobile apps with ease.}}

TclGridLayout

2025-10-21T08:31:10Z

Salih: Created page with "<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert"> function AddNewGridLayout(AComponent: TCLComponent; xName: string): TclFlowLayout; </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 GridLayout should be written.<br> It is used to arrange components on the form within a fixed gri..."

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewGridLayout(AComponent: TCLComponent; xName: string): TclFlowLayout;
</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 GridLayout should be written.<br>

It is used to arrange components on the form within a fixed grid structure. Simply put, it automatically places buttons, labels, and other visual elements into rows and columns based on predefined item width and height values. When the current row or column becomes full, the layout automatically continues placing elements in the next one.

This layout ensures that all components are aligned and sized uniformly, creating a clean and balanced interface. TCLGridLayout is particularly useful when you need a consistent, grid-like arrangement of elements — for example, in dashboards, icon views, or uniform control layouts that must maintain equal spacing and proportions.
<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
|-
|TclGridLayout || GridLayout1 : TclGridLayout; || A variable belonging to the TclGridLayout class is created.
|-
|AddNewGridLayout || GridLayout1 = Form1.AddNewGridLayout(Form1,'GridLayout1'); || A new TclGridLayout is added to the form.
|-
|Align || GridLayout1.Align = alTop; || Specifies how the GridLayout is aligned within its parent container. Multiple alignment options are available. See the [[Object_Properties#Align | page]] for more details.
|-
|ItemHeight || GridLayout1.ItemHeight = 50; || Defines the height of each item (child control) within the grid layout.
|-
|ItemWidth || GridLayout1.ItemWidth = 100; || Defines the width of each item (child control) within the grid layout.
|-
|Margins || GridLayout1.Margins.Left = 50; // Right, Top, Bottom || Allows setting margins around the GridLayout container.<br>[[File:PanelAppearance.png|frameless|200px]]<br><br>
|}
</div>

<b>Example</b><br>
<pre>
var
MyForm:TclForm;
GridLayout:TCLGridLayout;
testButton : TclButton;
I:integer;
NewHeightEdit,NewWidthEdit : TCLLabel;
ChangeSizeButton : TclButton;

void ChangeSize{

GridLayout.ItemHeight = NewHeightEdit.Text;
GridLayout.ItemWidth = NewWidthEdit.Text;
}

{
MyForm=TclForm.Create(self);

GridLayout = MyForm.AddNewGridLayout(MyForm,'GridLayout');
GridLayout.Align = alClient;
GridLayout.ItemHeight = 50;
GridLayout.ItemWidth = 50;

for (I = 0 to 10) {
testButton = MyForm.AddNewButton(GridLayout,'testButton'+IntToStr(I),'Button'+IntToStr(I));
}

NewWidthEdit = MyForm.AddNewEdit(MyForm,'NewWidthEdit', 'New Width');
NewWidthEdit.Align = alTop;

NewHeightEdit = MyForm.AddNewEdit(MyForm,'NewHeightEdit', 'New Height');
NewHeightEdit.Align = alTop;

ChangeSizeButton = MyForm.AddNewButton(MyForm,'ChangeSizeButton','Change');
ChangeSizeButton.Align = alTop;
ChangeSizeButton.Margins.Top = 20;
ChangeSizeButton.Margins.Bottom = 20;
MyForm.AddNewEvent(ChangeSizeButton,tbeOnClick,'ChangeSize');
MyForm.Run;
}

</pre>
Output:

[[File:GridLayout.gif|frameless|thumb|600px]]

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[TclLayout]]

{{#seo:|title=TclScaledLayout Using in Clomosy - Clomosy Docs}}
{{#seo:|description= Learn how TclScaledLayout automatically scales and arranges visual components, keeping interface proportions consistent across different resolutions.}}

File:GridLayout.gif

2025-10-21T08:26:35Z

Salih:

TclFramedScrollBox

2025-10-21T07:35:20Z

Salih: Created page with "<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert"> function AddNewFramedScrollBox(AComponent: TCLComponent; xName: string): TclFramedScrollBox; </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 framedscrollbox should be written.<br> AddNewFramedScrollBox (TClFramedScrollBox) creat..."

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewFramedScrollBox(AComponent: TCLComponent; xName: string): TclFramedScrollBox;
</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 framedscrollbox should be written.<br>

AddNewFramedScrollBox (TClFramedScrollBox) creates scrollable areas within a framed and styled container. It functions similarly to a standard scroll box but includes additional visual framing and design enhancements, making it suitable for organized and visually distinct content sections. Applications can use TclFramedScrollBox to display scrollable information while maintaining a clean, bordered layout that separates it from other interface elements.<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
|-
|TclFramedScrollBox || FramedScrollBox1: TclFramedScrollBox; || A variable belonging to the TclFramedScrollBox class is created.
|-
|AddNewFramedScrollBox || FramedScrollBox1 = Form1.AddNewFramedScrollBox(Form1,'FramedScrollBox1'); || A new TclFramedScrollBox is added to the form.
|-
|ScrollBy(DeltaX,DeltaY: Integer); || FramedScrollBox1.ScrollBy(0,-100); || To scroll the contents within the control, call ScrollBy.<br>
The DeltaX parameter is the change in pixels along the X-axis.<br>
A positive DeltaX value scrolls the content to the left; a negative value scrolls the content to the right.<br>
The DeltaY parameter is the change in pixels along the Y-axis.<br>
A positive DeltaY value scrolls the content upward; a negative value scrolls the content downward.
|-
|ScrollTo(X,Y: Integer); || FramedScrollBox1.ScrollTo(0,-100); || To scroll the contents within the control, call ScrollTo.<br>
The X parameter is the change in pixels along the X-axis.<br>
A positive X value scrolls the content to the left; a negative value scrolls the content to the right.<br>
The Y parameter is the change in pixels along the Y-axis.<br>
A positive Y value scrolls the content upward; a negative value scrolls the content downward.
|-
|Width || FramedScrollBox1.Width = 150; ||Allows adjusting the width of the scrollBox.
|-
|Height || FramedScrollBox1.Height = 50; ||Allows adjusting the height of the scrollBox.
|-
|Align || FramedScrollBox1.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 || FramedScrollBox1.Margins.Left = 50; // Right, Top, Bottom ||With the Margins parameter, you can give margins at any scale from the right, left, bottom, top.<br>
|}
</div>

<b>Example</b><br>

<pre>
var
MyForm:TclForm;
FramedScrollBox:TClFramedScrollBox;
ScrollButton : TclButton;
I:integer;
testLabel,testLabel2 : TclLabel;

void ScrollDown{
FramedScrollBox.ScrollBy(0,-150);
}

{
MyForm=TclForm.Create(self);

FramedScrollBox = MyForm.AddNewFramedScrollBox(MyForm,'FramedScrollBox');
FramedScrollBox.Align = alTop;
FramedScrollBox.Width = 225;
FramedScrollBox.Height = 250;

testLabel= MyForm.AddNewLabel(FramedScrollBox,'testLabel','Hi ClomosyUser');
testLabel.StyledSettings = ssFamily;
testLabel.TextSettings.Font.Size=40;
testLabel.Align = alTop;
testLabel.Margins.Left= 50;
testLabel.Margins.Top= 10;
testLabel.Height = 100;
testLabel.Width = 400;

testLabel2= MyForm.AddNewLabel(FramedScrollBox,'testLabel2','You scrolled here');
testLabel2.StyledSettings = ssFamily;
testLabel2.TextSettings.Font.Size=40;
testLabel2.Align = alTop;
testLabel2.Margins.Left= 50;
testLabel2.Margins.Top= 150;
testLabel2.Height = 100;
testLabel2.Width = 400;

ScrollButton = MyForm.AddNewButton(MyForm,'ScrollButton','Scroll!');
ScrollButton.Align = alTop;
ScrollButton.Margins.Top = 20;
ScrollButton.OnClick ='ScrollDown';

MyForm.Run;
}
</pre>

<b>Output:</b><br>
[[File:FramedScrollBox.gif|frameless|thumb|600px]]

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[AddNewEvent]]
{{#seo:|description=Explore TclFramedScrollBox in Clomosy! Implement seamless scrolling for efficient content navigation in mobile applications.}}

File:FramedScrollBox.gif

2025-10-21T07:33:12Z

Salih:

Components

2025-10-20T15:13:04Z

Salih:

In software development, components are reusable objects used to perform specific functions. Components can serve a wide range of tasks, from user interface elements to more technical functions like data access or network communication.<br>
Clomosy components are object-oriented and derived from the TCLComponent class, which allows them to be categorized as either visual (interacting with the user interface) or non-visual (working in the background) elements.<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
To use component properties, please visit the <b>[[Object Properties]]</b> page.
</div>

<h2> Visual Components </h2>
Visual components are elements that appear in the user interface and interact directly with users. These components allow users to easily access specific functions within the screens provided by the software.<br>
Examples of visual components include buttons, text boxes, lists, and image boxes. Users can interact with these components by clicking, entering data, or making selections to engage with the program.

<h3> Standard Components </h3>
Standard components are commonly used to provide basic user interface and application functionality. These components form the foundation of an application's core functions and are typically available by default in most development environments.<br>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Component Name !!style="background-color: #c3d7e0"| Explanation
|-
| [[TclPanel]] || A basic panel component that acts as a container for organizing other components.
|-
| [[TclLayout]] || A layout component used to arrange, group, and maintain a specific order for control elements.
|-
| [[TclScaledLayout]] || A layout component used to arrange, group, and maintain a specific order of control elements while preserving their original aspect ratios.
|-
| [[TclFlowLayout]] || A layout component that arranges controls in a flow, moving items to the next line when space runs out.
|-
| [[TclLabel]] || A label component used to display fixed text.
|-
| [[TclEdit]] || An input box that allows the user to enter short text.
|-
| [[TclMemo]] || A text box providing multi-line text entry and display.
|-
| [[TclButton]] || A button component used to initiate actions when clicked by the user.
|-
| [[TclImage]] || An image component used to display visual elements on the screen.
|-
| [[TclChart]] || A chart component used to visualize data in the form of graphs.
|-
| [[TclVertScrollBox]] || A box that displays content within a vertically scrollable area.
|-
| [[TclHorzScrollBox]] || A box that displays content within a horizontally scrollable area.
|-
| [[TclRadioButton]] || A component used to allow the user to select only one option within a group of choices.
|-
| [[TclCheckBox]] || A checkbox that allows selection among multiple options.
|-
| [[TclComboBox]] || A drop-down menu component that allows the user to choose one of the options.
|-
| [[TclExpander]] || An expander component used to create areas that can be opened or closed when clicked.
|-
| [[TclQRCodeGenerator]] || A component used to generate QR codes.
|-
| [[TclListView]] || A listing component used to display data in list format.
|-
| [[TclMenuFrame]] || A frame component used for organizing menu structures.
|-
| [[TclStringGrid]] || A grid component displaying data in a tabular format with cells.
|-
| [[TclWebBrowser]] || A browser component for displaying web pages within the application.
|-
| [[TclSearchBox]] || A search box used to enable users to perform search actions.
|-
| [[TClNumberBox]] || A component used exclusively for numeric data entry.
|-
| [[TclPageControl]] || A tabbed interface component that allows displaying content on different pages.
|-
| [[TclSwitch]] || A toggle component that allows switching between on and off states.
|-
| [[TclBitmapListAnimation]] || It is a component used to create animations.
|-
| [[TclCircle]] || TclCircle represents a graphic element in the shape of a circle or ellipse.
|-
| [[TclRectangle]] || The TclRectangle component represents a rectangle and is commonly used in interface designs as a background or region.
|-
| [[TclRadioGroup]] || A RadioGroup is a component used to allow the selection of only one option from multiple choices.
|}
</div>

<h4> Advanced Technology Components </h4>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Component Name !!style="background-color: #c3d7e0"| Explanation
|-
| [[Camera Access]] || A component that provides access to the device's camera for capturing photos or videos.
|}
</div>

<h3> Professional Components </h3>
Pro components offer more advanced features and functionality, going beyond standard components. Pro components are used for more complex user interactions or special requirements and often provide additional features.<br>

For example, a TclProListViewDesignerPanel enables advanced list editing or data display. These components are especially preferred in professional and specialized applications where more functionality and customizability are needed.<br>

<div class="alert alert-warning" role="alert" data-bs-theme="light">
You can use these features over the json structure. Visit the [[Pro Object Properties]] page to learn about the available parameters and how to use them.
</div>

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Component Name !!style="background-color: #c3d7e0"| Explanation
|-
| [[TclProPanel]] || A professional panel component used to organize advanced components.
|-
| [[TclProLabel]] || A professional label component with enhanced features for displaying fixed text.
|-
| [[TClProEdit]] || A professional input box that allows short text entry.
|-
| [[TClProDateEdit]] || A professional date picker component that facilitates date entry.
|-
| [[TClProSearchEdit]] || A professional component with search functionality, allowing text input.
|-
| [[TClProButton]] || A professional button component used to initiate advanced actions.
|-
| [[TclProImage]] || A professional image component offering enhanced image display features.
|-
| [[TClProListView]] || A professional list component that displays data in list format with advanced features.
|-
| [[TClProListViewDesignerPanel]] || A professional list design panel used for organizing and customizing lists.
|-
| [[TclProGrid]] || A professional grid component for displaying data in tabular format with advanced editing and viewing features.
|}
</div>

<h2> Non-Visual Components </h2>
Non-visual components are components that are not visible in the user interface but perform specific functions in the background. These components are used for tasks such as data processing, timers, database connections, or file operations, and they do not interact directly with the user.<br>
For example, a TclTimer component can perform specific actions at set intervals.

<div class="table-responsive">
{| class="wikitable" style="border: 2px solid #c3d7e0"
! style="background-color: #c3d7e0"| Component Name !!style="background-color: #c3d7e0"| Explanation
|-
| [[TClTimer]] || A timer component used to trigger processes at specified intervals.
|-
| [[TclOpenAIEngine]] || A component used to integrate OpenAI's artificial intelligence services.
|-
| [[TclDeviceManager]] || A component used for device management and accessing device features.
|-
| [[TclMediaPlayer]] || A media player component that supports audio playback functions.
|-
| [[TclHttp]] || A component used for data communication over the HTTP protocol.
|-
| [[TclRest]] || A component that facilitates data exchange with RESTful services.
|-
| [[TclMQTT]] || A component enabling messaging and data communication between devices using the MQTT protocol.
|-
| [[TclMQTTClient]] || A Component for connecting to an MQTT Broker, used for publishing and subscribing to real-time topics.
|-
| [[TclBlobField]] || A BLOB field used to store and manage large data pieces (images, videos, files).
|-
| [[TclFileStream]] || A component used to manage file streams and access files.
|-
| [[TclMemoryStream]] || A component used to manage data streams within memory.
|-
| [[TclGameEngine]] || It is a game engine component used to develop word-based games.
|}
</div>

<div class="alert alert-success" role="alert" data-bs-theme="light">
<h2 class="alert-heading">Events</h2>
<p>It is a function or action triggered when a specific event occurs, such as user interaction (e.g., clicking a button, mouse movement) or system status (e.g., completion of a file or network connection loss).</p>
<hr>
<br>
<div class ="green-learn-more" >
[[Events|Learn More]]
</div>
</div>

<h2> See Also </h2>
* [[TRObject Language]]
* [[Object Properties]]
* [[Pro Object Properties]]
* [[Sensor Structures]]
{{#seo:|title=Components in Clomosy - Clomosy Docs}}
{{#seo:|description=Learn about Components in Clomosy. A guide to understanding and using various components to build powerful mobile apps with ease.}}

TclFlowLayout

2025-10-20T15:08:34Z

Salih:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewFlowLayout(AComponent: TCLComponent; xName: string): TclFlowLayout;
</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 FlowLayout should be written.<br>

It is used to arrange components on the form in a sequential flow. Simply put, it automatically places buttons, labels, and other visual elements in a row or column, and moves them to the next line or column when space runs out.

This layout ensures that the interface elements are organized neatly, maintaining proper spacing and order even when the container is resized. TCLFlowLayout is particularly useful when creating dynamic user interfaces with variable numbers of controls or when the layout needs to adapt fluidly 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
|-
|TclFlowLayout || FlowLayout1 : TclFlowLayout; || A variable belonging to the TclFlowLayout class is created.
|-
|AddNewFlowLayout || FlowLayout1 = Form1.AddNewFlowLayout(Form1,'FlowLayout1'); || A new TclFlowLayout is added to the form.
|-
|Align || FlowLayout1.Align = alTop; || Specifies how the FlowLayout is aligned within its parent container. Multiple alignment options are available. See the [[Object_Properties#Align | page]] for more details.
|-
|FlowDirectionText || FlowLayout1.FlowDirectionText = 'RightToLeft'; || Determines the direction in which child controls flow: LeftToRight or RightToLeft (aliases: LTR/RTL).
|-
|JustifyText || FlowLayout1.JustifyText = 'Justify'; || Specifies the horizontal alignment of controls within each line: Left, Right, Center, or Justify (aliases: L/R/C, Full/Justified).
|-
|JustifyLastLineText || FlowLayout1.JustifyLastLineText = 'Center'; || Specifies the alignment of controls in the last line: Left, Right, Center, or Justify.
|-
|HorizontalGap || FlowLayout1.HorizontalGap = 7; || Sets the horizontal spacing (gap) between controls.
|-
|VerticalGap || FlowLayout1.VerticalGap = 5; || Sets the vertical spacing (gap) between lines of controls.
|-
|Margins || FlowLayout1.Margins.Left = 50; // Right, Top, Bottom || Allows setting margins around the FlowLayout container.<br>[[File:PanelAppearance.png|frameless|200px]]<br><br>
|}
</div>

<b>Example</b><br>
<pre>
var
MyForm:TclForm;
FlowLayout:TclFlowLayout;
testButton:TCLButton;
I:Integer;
{
MyForm=TclForm.Create(self);

FlowLayout = MyForm.AddNewFlowLayout(MyForm,'FlowLayout');
FlowLayout.Align = alClient;
FlowLayout.JustifyText='Justify';// Left, Right, Center, or Justify (aliases: L/R/C, Full/Justified)
FlowLayout.JustifyLastLineText='center';// Left, Right, Center, or Justify (aliases: L/R/C, Full/Justified)
FlowLayout.FlowDirectionText='RightToLeft';//LeftToRight or RightToLeft (aliases: LTR/RTL)
FlowLayout.HorizontalGap = 7;
FlowLayout.VerticalGap = 5;

for (I = 0 to 10) {
testButton = MyForm.AddNewButton(FlowLayout,'testButton'+IntToStr(I),'Button'+IntToStr(I));
}

MyForm.Run;
}
</pre>
Output:

[[File:FlowLayout.gif|frameless|thumb|600px]]

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[TclLayout]]

{{#seo:|title=TclScaledLayout Using in Clomosy - Clomosy Docs}}
{{#seo:|description= Learn how TclScaledLayout automatically scales and arranges visual components, keeping interface proportions consistent across different resolutions.}}

File:FlowLayout.gif

2025-10-20T15:06:58Z

Salih: Salih uploaded a new version of File:FlowLayout.gif

TclFlowLayout

2025-10-20T15:01:32Z

Salih: Created page with "<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert"> function AddNewFlowLayout(AComponent: TCLComponent; xName: string): TclFlowLayout; </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 FlowLayout should be written.<br> It is used to arrange components on the form in a sequential fl..."

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewFlowLayout(AComponent: TCLComponent; xName: string): TclFlowLayout;
</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 FlowLayout should be written.<br>

It is used to arrange components on the form in a sequential flow. Simply put, it automatically places buttons, labels, and other visual elements in a row or column, and moves them to the next line or column when space runs out.

This layout ensures that the interface elements are organized neatly, maintaining proper spacing and order even when the container is resized. TCLFlowLayout is particularly useful when creating dynamic user interfaces with variable numbers of controls or when the layout needs to adapt fluidly 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
|-
|TclFlowLayout || FlowLayout1 : TclFlowLayout; || A variable belonging to the TclFlowLayout class is created.
|-
|AddNewFlowLayout || FlowLayout1 = Form1.AddNewFlowLayout(Form1,'FlowLayout1'); || A new TclFlowLayout is added to the form.
|-
|Align || FlowLayout1.Align = alTop; || Specifies how the FlowLayout is aligned within its parent container. Multiple alignment options are available. See the [[Object_Properties#Align | page]] for more details.
|-
|FlowDirectionText || FlowLayout1.FlowDirectionText = 'RightToLeft'; || Determines the direction in which child controls flow: LeftToRight or RightToLeft (aliases: LTR/RTL).
|-
|JustifyText || FlowLayout1.JustifyText = 'Justify'; || Specifies the horizontal alignment of controls within each line: Left, Right, Center, or Justify (aliases: L/R/C, Full/Justified).
|-
|JustifyLastLineText || FlowLayout1.JustifyLastLineText = 'Center'; || Specifies the alignment of controls in the last line: Left, Right, Center, or Justify.
|-
|HorizontalGap || FlowLayout1.HorizontalGap = 7; || Sets the horizontal spacing (gap) between controls.
|-
|VerticalGap || FlowLayout1.VerticalGap = 5; || Sets the vertical spacing (gap) between lines of controls.
|-
|Margins || FlowLayout1.Margins.Left = 50; // Right, Top, Bottom || Allows setting margins around the FlowLayout container.<br>[[File:PanelAppearance.png|frameless|200px]]<br><br>
|}
</div>

<b>Example</b><br>
<pre>
var
MyForm:TclForm;
FlowLayout:TclFlowLayout;
testButton:TCLButton;
I:Integer;
{
MyForm=TclForm.Create(self);

FlowLayout = MyForm.AddNewFlowLayout(MyForm,'FlowLayout');
FlowLayout.Align = alClient;
FlowLayout.JustifyText='Justify';// Left, Right, Center, or Justify (aliases: L/R/C, Full/Justified)
FlowLayout.JustifyLastLineText='center';// Left, Right, Center, or Justify (aliases: L/R/C, Full/Justified)
FlowLayout.FlowDirectionText='RightToLeft';//LeftToRight or RightToLeft (aliases: LTR/RTL)
FlowLayout.HorizontalGap = 7;
FlowLayout.VerticalGap = 5;

for (I = 0 to 10) {
testButton = MyForm.AddNewButton(FlowLayout,'testButton'+IntToStr(I),'Button'+IntToStr(I));
}

MyForm.Run;
}
</pre>
Output:

[[File:FlowLayout.gif|frameless|200px]]

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[TclLayout]]

{{#seo:|title=TclScaledLayout Using in Clomosy - Clomosy Docs}}
{{#seo:|description= Learn how TclScaledLayout automatically scales and arranges visual components, keeping interface proportions consistent across different resolutions.}}

File:FlowLayout.gif

2025-10-20T14:59:52Z

Salih:

TclScaledLayout

2025-10-20T13:30:54Z

Salih:

<div class="alert alert-ligth border border-3 border-primary-subtle rounded-5 p-4 shadow-sm" role="alert">
function AddNewScaledLayout(AComponent: TCLComponent; xName: string): TclScaledLayout;
</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 ScaledLayout should be written.<br>

It is used to arrange and proportionally scale other components on the form. Simply put, it ensures that buttons, labels, and other visual elements maintain their relative size and position when the form is resized.

This layout automatically scales and adjusts its contents, making the interface consistent and visually balanced across different screen resolutions. TCLScaledLayout is particularly useful when designing responsive or resolution-independent user interfaces.
<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
|-
|TclScaledLayout || ScaledLayout1 : TclScaledLayout; || A variable belonging to the TclScaledLayout class is created.
|-
|AddNewScaledLayout || ScaledLayout1 = Form1.AddNewScaledLayout(Form1,'ScaledLayout1'); || A new TclScaledLayout is added to the form.
|-
|OriginalWidth || ScaledLayout1.OriginalWidth = 150; ||Defines the reference (unscaled) width of the layout, used as the base for scaling its child components.
|-
|OriginalHeight || ScaledLayout1.OriginalHeight = 50; ||Defines the reference (unscaled) height of the layout, used as the base for scaling its child components.
|-
|Align || ScaledLayout1.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 || ScaledLayout1.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;
ScaledLayout:TclScaledLayout;
Edit1:TclEdit;
I:Integer;
testButton:TCLButton;
{
MyForm=TclForm.Create(self);

ScaledLayout = MyForm.AddNewScaledLayout(MyForm,'ScaledLayout');
ScaledLayout.Align = alClient;

ScaledLayout.OriginalHeight = 900;
ScaledLayout.OriginalWidth = 400; //Approximately the aspect ratio of a phone screen

for (I = 0 to 1) {
testButton = MyForm.AddNewButton(ScaledLayout,'testButton'+IntToStr(I),'Button'+IntToStr(I));
testButton.Align = alTop;
}

MyForm.Run;
}
</pre>

<h2> See Also </h2>
* [[Components]]
* [[Object Properties]]
* [[TclLayout]]

{{#seo:|title=TclScaledLayout Using in Clomosy - Clomosy Docs}}
{{#seo:|description= Learn how TclScaledLayout automatically scales and arranges visual components, keeping interface proportions consistent across different resolutions.}}