# data[].attributes.body
Think:create a new qml file in the assets folder and define the properties.Then using the two methods of accessing inner properties (alias or creating a data type) we assign a variable to each of the property of the respective UI. We then use it in the main QML file.

PAIR:1. Custom components  for blackberry
2. some content is same as my neighbours.
3. Process is little different for creation by changing the properties by creating an alias in custom components   1:(d )

2:(d)
3:(b) 4:a

# data[].attributes.body
Think:
A custom component can be created by first creating a new qml file name FILENAMEView.qml and after then start with that page with a container and NOT a page.
Then multiple core UI's can be created. After making the qml file you can call it in the main.qml by simply calling it in the page like we call any other core UI.
We can change its property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change.
Then you can call it in the main.qml file and it will change the property accordingly
Pair
1.Core components can be created by extending core controls.
2.They can be accessed by creating instances of them.
Share:
1 C
2 D
3 B
4 A

# data[].attributes.body
THINK :
Desired  custom components can be created by first creating a new qml file by naming it XView.qml and then starting with same page with a container and not a page. Then you can create multiple core UI's inside that custom qml file. After you are done making it, call it in the main.qml by calling it in the page like we call any other core UI.

This finally gives a preferred exemption from mistaken call and attains a proper call by name for property inheritance.

PAIR :
QML record is supposed to be contained in another QML document that embeds after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder.

An example

Container{

property alias text: txt1.text

Label{

id: txt1

}

We define the alias and access by the id property.We Also define the alias and access by the id property.

SHARE:
Answers:
1. D
2. D
3. A
4. A

# data[].attributes.body
Think:
You can create a custom components by first creating a new qml file by naming it SOMETHINGView.qml and then start with that page with a container and not a page. You can create multiple core UI's inside that custom qml file. After making it, you can call it in the main.qml by simply calling it in the page like we call any other core UI. We can change its property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change. Then you can call it in the main.qml file and it will change the property accordingly.

Pair:
When we create custom components, we can access the core UIs in it by using the
'property alias type' syntax. Each of these components can be given a different variable name, eg: text1, text2 (for text fields), if we have to access same type of UIs which are more than 1 in number. The properties of these elements can be changed, in Main.qml, using the reference we make (property alias type) from the qml file.

SHARE:
Ans 1.( B)
Ans 2.( D )
Ans 3.( B )
Ans 4.( A )

# data[].attributes.body
THINK:
You can make a custom segments by first naming so as to make another qml document it SOMETHINGView.qml and afterward begin with that page with a holder and not a page. At that point you can make numerous center UI's inside that custom qml document. After you are done making it, you can call it in the main.qml by just calling it in the page like we call whatever other center UI.

PAIR:

a.QML record ought to be contained in another QML document that takes after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder.

Answers:
1. A
2. D
3. A
4. TRUE

# data[].attributes.body
Think: start with a capital letter
And with suffix view
Top level object in qml file must be a container
Qml file should be in the same directory as any other qml
Pair: top level qml file cannot be a page.

1 B

2 D
3 B
4 A

# data[].attributes.body
Think :

Desired  custom components can be created by first creating a new qml file by naming it XView.qml and then starting with same page with a container and not a page. Then you can create multiple core UI's inside that custom qml file. After you are done making it, call it in the main.qml by calling it in the page like we call any other core UI.
This finally gives a preferred exemption from mistaken calls and attains a proper call by name for property inheritance.

PAIR :

QML record is supposed to be contained in another QML document that embeds after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder.
An example

Container{

property alias text: txt1.text

Label{

id: txt1

}

We define the alias and access by the id property.We Also define the alias and access by the id property.

SHARE:
Answers:
1. D
2. D
3. B
4. A

# data[].attributes.body
THINK:
QML's filename should start with a capital letter
And with suffix 'View'
Top level object in the QML file must be a container
QML file should be placed in the same directory as any other QML that will be referencing it.
It should be named as somethingView.qml
Then you can create multiple core UIs

PAIR:
QML record ought to be contained in another QML document that takes after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder.

SHARE:
1-B
2-D
3-B
4-A

# data[].attributes.body
THINK:

PAIR:
SHARE:

# data[].attributes.body
Think
Q. Explain the process creating multiple same type of core UIs in custom components and changing its properties in main qml
Conditions for QML file creation:-
1]QML’s  filename must start with a capital letter
2]Top level object in the QML file must be a container

3]QML’s filename should end with the suffix ‘View’

4]QML file should be placed in the same directory as any other QML that will be referencing it

Pair -

Custom Component for Blackberry
Start by creating a .qml file called
Note.qml in  the assets folder of your project.
Right-click the assets folder and click New > Other, then expand
BlackBerry and select QML File.
In the Template drop-down list, click
Container and click Finish.

Share-
ans 1 (B)
ans 2 (D)
ans 3 (B)
ans 4(A)

# data[].attributes.body
Think:
A custom component can be created by first creating a new qml file name FILENAMEView.qml and after then start with that page with a container and NOT a page.
Then multiple core UI's can be created. After making the qml file you can call it in the main.qml by simply calling it in the page like we call any other core UI.
We can change its property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change.
Then you can call it in the main.qml file and it will change the property accordingly.

Example
Container{
property alias text: example.text
Label{
id: txt1
}
}

Pair:
test{

id: txt1

property string myValue: "exam"

title: "Home"

description: home.myValue

dataModel: XmlDataModel {

source: "home.xml"

}// end of dataModel

}/

Share:

1(D.)
2(D.)
3(B.)
4(A.)

# data[].attributes.body
Think :

1]QML’s  filename must start with a capital letter

2]Top level object in the QML file must be a container

3]QML’s filename should end with the suffix ‘View’

4]QML file should be placed in the same directory as any other QML that will be referencing it
Start by creating a .qml file called
Note.qml in  the assets folder of your project.
Right-click the assets folder            and click New > Other, then expand             BlackBerry and select QML File.            In the Template drop-down list, click  Container and click Finish.

PAIR: a.QML record ought to be contained in another QML document that takes after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder.

1 B

2 D

3  B

4 A

# data[].attributes.body
Think: we can extend core components to create custom components. Custom components can be created in a separate qml file that must be located in same directory as main.qml file. These custom components can be accessed by creating their instances. Properties of core components can be accessed either by Alisa or their respective properties.                            Pair: qml file name must start with capital letter.   Top level component must be a container. Qml file must end with suffix VIEW. When we define a property for a custom component, a new memory is allocated for the value. To avoid allocation of new memory, we use alias to point to inner property of core  components.                                 Share:                                                       1(D) 2(D) 3( ) 4(true)

# data[].attributes.body
Think  :
You can create a custom components by first creating a new qml file by naming it SOMETHINGView.qml and then start with that page with a container and not a page. Then you can create multiple core UI's inside that custom qml file. After you are done making it, you can call it in the main.qml by simply calling it in the page
Pair :  we can extend core components to create custom components. Custom components can be created in a separate qml file that must be located in same directory as main.qml file. These custom components can be accessed by creating their instances.
1 : C
2 :  D
3 :  A
4 :   A

# data[].attributes.body
Think
Create custom components by making qml files in seperate component and add container inside which you can add different layouts like stackLayout
Qml file should start with capital and in new .qml file
Top level objects in qml. Must be container
Name must have suffix view
All qml files must be in the same directory

Pair
Qml record must be in contained in another qml document after embeding the rules
Custom component include:
Create qml files in assets folder
Right click on assets folder and click new> other,  then
expand bb select qml
In template drop down click container then finish

Share
Q.1 B
Q.2 D
Q.3 B
Q.4 A

# data[].attributes.body
Think :

A new QML file is created to create a custom component with name format Name.qml , for creating multiple UI's, name must start with capital letter, layout can be provided as stack layout, directory must be same as another QML.                           Pair:                                                           Start page with container and not page                                                          Property can be changed by creating alias.                                                          1. D.                                                         2. D                                                            3. B                                                            4. A

# data[].attributes.body
Think:
You can create a custom component by first creating a new qml file by giving it an appropriate name such as View.qml and then start with that page with a container and not a page. Then you can create multiple core UI's inside that custom qml file.

Pair:
]QML’s  filename must start with a capital letter

2]Top level object in the QML file must be a container

3]QML’s filename should end with the suffix ‘View’

4]QML file should be placed in the same directory as any other QML that will be referencing it
Start by creating a .qml file called
Note.qml in  the assets folder of your project.
Right-click the assets folder and click New > Other, then expand BlackBerry and select QML File.
In the Template drop-down list, click
Container and click Finish.

Example
Container{
property alias text: example.text
Label{
id: txt1
}
}

Share:
1. (B)
2. (D)
3. (B)
4. (A)

# data[].attributes.body
Think
Soln :
1.Qml file must start with capital letter.
Top level must be a container not the page.
Qml file must be placed in same directory
We can create a custom components by first creating a new qml file by naming it exampleview.qml and then start with not page instead page with a container. Then we can create multiple core UI's inside that custom qml file.
Then multiple core UI's can be created.
After making the qml file you can call it in the main.qml
by simply calling it in the page like we call any other core UI.
We can change the property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change.
Then you can call it in the main.qml file and it will change the property accordingly.
Pair
1. Custom components  for blackberry
2. some content is same as my neighbours.
3. Process is little different for creation by changing the properties by creating an alias in custom components

Share:
1.(B)
2.(D)
3.(B)
4.(A)

# data[].attributes.body
Think :
Custom component is created in a separate qml file with a container as root element -inside which you provide the layout as stacklayout and insert the components one after the other.
Define the property as alias or variable in the custom component and assign the corresponding ui

Use this just as a core ui in the main.qml

Pair :
Break down the UI in multiple QML components instead of designing it as a single monolithic bloc. This will save us major headaches when we need to selectively update UI parts. Indeed, the ability to extend QML with our own custom components is a major advantage that we should leverage as much as possible.

Share :
Q1 - B - Data model
Q2 - D
Q3 - B
Q4 -  A True

# data[].attributes.body
Think:1.QML file should be contained in a new QML file that follows these guidelines

2.QML’s filename must start with a capital letter

3.Top level object in the QML file must be a container

4.QML’s filename should end with the suffix ‘View’

5.QML file should be placed in the same directory as any other QML that will be referencing it

PAIR:You can create a custom components by first creating a new QML file by naming it SOMETHINGView.qml and then start with that page with a container and not a page. Then you can create multiple core UI's inside that custom qml file. After you are done making it, you can call it in the main.qml by simply calling it in the page

SHARE:
1-  C
2-  D
3-  B
4-  A

# data[].attributes.body
THINK
Explain the process of creating multiple same type of core UIs in custom components and changing its properties in main.qml ?
Ans:
You can create a custom components by first creating a new qml file by naming it SOMETHINGView.qml and then start with that page with a container and not a page then make some changes  (give id to it). Then you can create multiple core UI's inside that custom qml file. After you are done making it, you can call it in the main.qml by simply calling it in the page. Then change its property by creating an alias in the custom component qml file and referencing it by the property you want to change.

PAIR
a .qml record ought to be contained in another QML document that takes after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder.

Container{
property alias text: txt1.text
Label{
id: txt1
}

SHARE

1. (A)
2. (D)
3. (A)
4. (A)

# data[].attributes.body
THINK :
step 1) we create a custom components by first creating a new qml file by naming it SOMETHING like View.qml and then start with that page with a container and not a page.
step 2)  next , you can create multiple core UI's inside that custom qml file.
This makes custom components by creating new qml files where we can name the files <XYZ>View.qml and start with that page within a container.Multiple coreUIs can be created like this.
1.QML file should be contained in a new QML file that follows these guidelines

2.QML’s filename must start with a capital letter

3.Top level object in the QML file must be a container

4.QML’s filename should end with the suffix ‘View’

5.QML file should be placed in the same directory as any other QML that will be referencing it.

PAIR :
An example
Container{
property alias text: txt1.text
Label{
id: txt1
}

QML record ought to be contained in another QML document that takes after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder.

We define the alias and access by the id property.We Also define the alias and access by the id property.

SHARE:
1 ( B)
2( d)
3 ( B )
4(A )

# data[].attributes.body
Think:You can make a custom segments by first naming so as to make another qml document it View.qml and afterward begin with that page with a holder and not a page. At that point you can make numerous center UI's inside that custom qml document. After you are done making it, you can call it in the main.qml by just calling it in the page like we call  other center UI.

1]QML’s  filename must start with a capital letter

2]Top level object in the QML file must be a container

3]QML’s filename should end with the suffix ‘View’

4]QML file should be placed in the same directory as any other QML that will be referencing it
Start by creating a .qml file called
Note.qml in  the assets folder of your project.
Right-click the assets folder and click New > Other, then expand             BlackBerry and select QML File.
In the Template drop-down list, click
Container and click Finish.

Pair:We can change its property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change. Then you can call it in the main.qml file and it will change the property accordingly.

Share:
1.D
2.D
3.B
4.A True

# data[].attributes.body
Think:
A custom component can be created by first creating a new qml file name FILENAMEView.qml and after then start with that page with a container and not a page. Then you can create multiple core UI's
1.QML file should be contained in a new QML file that follows these guidelines
2.QML’s filename must start with a capital letter
3.Top level object in the QML file must be a container
4.QML’s filename should end with the suffix ‘View’
5.QML file should be placed in the same directory as any other QML that will be referencing.
Pair :
1.Core components can be created by extending core controls.
2.They can be accessed by creating instances of them.
Share:
1 D
2 D
3 B
4 A
5

# data[].attributes.body
Think: you can use alias keyword to access properties of custom components. In the main.qml a signal is created that is linked with the slot using handlers. Custom components are called as the same way as core components are called. Multiple custom compo can be created in separate qml file.

Pair: Almost same with an addition of separate ids tht are created in the separate components. The fact about slots and signals not required.

hare:

1) A.
2) D.
3) B.
4) A.

# data[].attributes.body
Think:
For creating multiple UI's, we can create a different qml file for the same UI by naming it  anything.qml and start with a container in that page. Then you can create multiple custom components in that qml file. QML's file name must start with a capital letter and the top level object should be a container. It should end with the suffix 'View'. It should be placed in the same directory as any other qml files will reference it. It should contain only a container and not a page. This makes custom components by creating new qml files anythingView.qml and start with a page within a container.
Pair: Almost same with an addition that multiple core UI's can be created inside that custom qml file.
Share:

1. B
2.D
3.B
4.A

# data[].attributes.body
THINK:

1.QML file should be contained in a new QML file that follows these guidelines

2.QML’s filename must start with a capital letter

3.Top level object in the QML file must be a container

4.QML’s filename should end with the suffix ‘View’

5.QML file should be placed in the same directory as any other QML that will be referencing it

This makes custom components by creating new qml files where we can name the files <XYZ>View.qml and start with that page within a container.Multiple coreUIs can be created like this.

PAIR:
1.Core components can be created by extending core controls.
2.They can be accessed by creating instances of them.
3.The custom component should be created in same directory as main.qml file
5.Properties of core components can be accessed either by using alias or their respective properties. Alias avoids the allocation of new memory.

SHARE:
1(D)
2(D)
3(B)
4(true)

# data[].attributes.body
Think:
Custom component is created in a separate qml file with a container as root element -inside which you provide the layout as stacklayout and insert the components one after the other.
Define the property as alias or variable in the custom component and assign the corresponding inner ui's property to the aliases

Use this just  a core ui in the main.qml

Pair:almost same

1) b) )listview
2)D)title,description, status,Imagesource
3)b)stack grid flow
4) a) true

# data[].attributes.body
THINK :
You can custom component is a seperate qml file with a container inside which you provide the layout as stacklayout and insert the components one after the other.
1. QML file should be in a new QML file that allows guidelines.
2. QML's filename must start with a capital letter.
3. Top level  object  in the QML  file must be container.
4. QML's file name should end with  the suffix "view"
5. QML file must be placed in the same directory as others.

PAIR:
a) QML record ought to be contained in another QML document that takes after these rules
Custom Component for blackberry:
1. Start by creating a .qml file called notes.qml in your assets folder of your project.
2. Right click on the assests folder  and click new >other, then expand blackberry and select qml file
3. In the template drop-down list, click container and click finish.

Q1. B)
Q2. D)
Q3. A)
Q4. A)

# data[].attributes.headline
Akshay Karvir B061 ,mobile application development 

# data[].attributes.subject
Akshay Karvir B061 ,mobile application development 

# data[].attributes.body
Think: Custom Components can be created by creating a new QML file for the component itself . This file has to be called NAMEView.qml  where name is a custom name given to the component itself.
Top Level Object of the QML file has to be a container
The QML File has to be placed in the same folder as all the other QML files thar are coing to reference it
The QML’s  filename must start with a capital letter
Top levelobjects in the qml firlw must be a container
QML's filename should end with the suffix view
QML file should be placed in the same directory as any other QML that will be referencing it.

We start by .qml in  the assets folder of your project.
Right-click the assets folder and click New > Other, then expand             BlackBerry and select QML File.
In the Template drop-down list, click
Container and click Finish.

This WML file can later be easily Referenced by other QML files in the same directory.

Pair: Desired  custom components can be created by first creating a new qml file by naming it XView.qml and then starting with same page with a container and not a page. Then you can create multiple core UI's inside that custom qml file. After you are done making it, call it in the main.qml by calling it in the page like we call any other core UI.

This finally gives a preferred exemption from mistaken calls and attains a proper call by name for property inheritance.

Share:
1.(B)
2.(D)
3.(B)
4.(A)

# data[].attributes.body
THINK
Custom Components can be created by creating a new QML file for the component itself . This file has to be called NAMEView.qml  where name is a custom name given to the component itself.
Top Level Object of the QML file has to be a container
The QML File has to be placed in the same folder as all the other QML files that are going to reference it
The QML’s  filename must start with a capital letter

We start by creating the QML file in  the assets folder of the project.We then Right-click the assets folder and click New > Other, then expand  BlackBerry and select QML File.In the Template drop-down list, click Container and click Finish.

This QML file can later be easily Referenced by other QML files in the same directory.
After we are done making it, we can call it in the main.qml by simply calling it in the page like we call any other core UI.

PAIR with Rishi Raj Gupta
A.QML record should be contained in another QML report that takes after these standards ,QML's filename must start with a capital letter,top level article in the QML archive must be a container.

Custom segments can be made by first naming so as to make another qml document it SOMETHINGView.qml and afterward begin with that page with a container and not a page. At that point numerous center UI's can be made inside that custom qml document. After you are done making it, you can call it in the main.qml by just calling it in the page like we call whatever other center UI.

SHARE

Q1.  B
Q2.  D
Q3   B
Q4   A

# data[].attributes.body
ans 1)Think: Custom Components can be created by creating a new QML file for the component itself . This file has to be called "name"View.qml  where name is a custom name given to the component itself.make sure that QML’s  filename must start with a capital letter

1]Top level object in the QML file must be a container

2]QML file should be placed in the same directory as any other QML that will be referencing it
and then we can create multiple core uis inside the custom qml file.
Then you can create multiple core UI's After you are done making it, you can call it in the main.qml by simply calling it in the page like we call any other core UI. We can change its property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change.

Then you can call it in the main.qml file and it will change the property accordingly.

Pair: same as above.
Ans 2) Think:
1(D)
2(D)
3(B)
4(A)

pair: same as above

# data[].attributes.body
Think:  One of the best ways to to this will be create a custom component which has the various core UI and giving each one a unique id of the core UI.
Making a new main.qml file we can change its properties by creating an ALIAS.we then can refer the UI using there unique id and set it's properties.
These properties,  must define new properties at the root of your custom component and bind them to the inner properties that you want to expose.

Pair: Same as above

Share:

1. (b)
2.(d)
3.(b)
4.(a)

# data[].attributes.body
Think:
You can create a custom components by first creating a new qml file by naming it SOMETHINGView.qml and then start with that page with a container and not a page. Then you can create multiple core UI's inside that custom qml file. After you are done making it, you can call it in the main.qml by simply calling it in the page like we call any other core UI. We can change its property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change. Then you can call it in the main.qml file and it will change the property accordingly.

An example
Container{
property alias text: txt1.text
Label{
id: txt1
}

Pair:
Same as above
Share:

1: D
2: D
3: B
4: A

# data[].attributes.body
Think : QML record ought to be contained in another QML document that takes after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder

Pair with Deepak Dewani : You can make a custom segments by first naming so as to make another qml document it SOMETHINGView.qml and afterward begin with that page with a container and not a page. At that point you can make numerous center UI's inside that custom qml document. After you are done making it, you can call it in the main.qml by just calling it in the page like we call whatever other center UI.
Example :
Container{
property alias text: txt2.text
Label{
id: txt2
}

1. B
2. D
3. B
4. A - True

# data[].attributes.body
Think: A custom component can be created by first creating a new qml file name Note.qml and after then start with that page with a container and NOT a page. Then you can create multiple core UI's inside that custom qml file.
We can change the properties it later.

Pair: Qml should end with suffix view.
qml must be saved in the same directory.
top level article must be a container.

Share:

1) B
2) D
3) B
4) A

# data[].attributes.body
Think : we can create a custom component by creating a new qml file by naming it indexview.qml or anything just make sure that the name has a suffix view.qml.
and then start with that page with a container
make sure that QML’s  filename must start with a capital letter

1]Top level object in the QML file must be a container

2]QML file should be placed in the same directory as any other QML that will be referencing it
and then we can create multiple core uis inside the custom qml file.
Pair: with Akul gupta ,i think we have covered all the points which are important
QML record ought to be contained in another QML document that takes after these rules ,QML's filename must begin with a capital letter,top level article in the QML document must be a container,QML's filename ought to end with the postfix "Perspective"QML record should be placed in the same catalog as whatever other QML that will be referencing it .This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a container.
main points
Qml should end with suffix view.
qml must be saved in the same directory.
top level article must be a container.
Share :
1( B )
2(  D)
3(  B)
4( True )

# data[].attributes.body
Think: You can create a custom components by first creating a new qml file by naming it whatever.qml and then start with that page with a container and not a page. Then you can create multiple core UI's After you are done making it, you can call it in the main.qml by simply calling it in the page like we call any other core UI. We can change its property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change.                     Pair:

you can call it in the main.qml file and it will change the property accordingly.                                                Share: 1( B) 2(D)  3(B) 4(A)

# data[].attributes.body
Think:
You can create a custom components by first creating a new qml file by naming it somethingView.qml (the qml's filename must end with the suffix 'view') and then start with that page with a container and not a page.
Then you can create multiple core UI's inside that custom qml file.
After you are done making it, you can call it in the main.qml by simply calling it in the page like we call any other core UI.
These custom components can be accessed by creating their instances. Properties of core components can be accessed either by Alisa or their respective properties. Then you can call it in the main.qml file and it will change the property accordingly.

Pair:
QML record ought to be contained in another QML document that takes after these rules .
This makes custom segments by making new qml documents we can name the records <XYZ>View.qml and begin with that page inside of a holder.
Also an example can be given to show this.

Answers:
1) D
2) D
3) B
4) A

# data[].attributes.body
THINK:   You can create a custom components by first creating a new qml file by naming it AnYthing.qml and then start with that page with a container and not a page. Then you can create multiple core UI's inside that custom qml file. The custom components. Then you can call it in main.qml and change its properties.

PAIR: Qml must be saved in the same directory as the main file.
The top level  article must be container.

SHARE:
1 - B
2- D
3- B
4- A

# data[].attributes.body
Think :
Q. Explain the process creting multiple same type of core UIs in custom components and changing its properties in main qml
Ans:
1]QML’s  filename must start with a capital letter

2]Top level object in the QML file must be a container

3]QML’s filename should end with the suffix ‘View’

4]QML file should be placed in the same directory as any other QML that will be referencing it
Start by creating a .qml file called
Note.qml in  the assets folder of your project.
Right-click the assets folder and click New > Other, then expand             BlackBerry and select QML File.
In the Template drop-down list, click
Container and click Finish.

Pair :
Example
Container{
property alias text: example.text
Label{
id: txt1
}
}

Share :
MCQ's:
Q.1. B.
Q.2. D.
Q.3. B.
Q.4. A.

# data[].attributes.body
{
"Think" : "Multiple CoreUIs in custom components can be created using a separate QML file which defines a container. The core UI's can then be used inside of this container and then be utilized in main.qml just as builtin components. This would require defining an alias for the component's children to be accessible through main.qml.",

"Pair" : "We define the alias and access by the id property.",

"1" : "D",
"2" : "D",
"3" : "B",
"4" : "A"

}

# data[].attributes.body
THINK: After you create a new View.qml file and then call it in the main file. Inside the new qml file you create multiple Core UIs .You can call it in the main file just like any other Core UIs. We can change its property by creating an alias in the custom component QML file and referencing it by the id of the property you want to change. Then you can call it in the main.qml file and it will change the property accordingly.
QML’s  filename must start with a capital letter.

PAIR:
Top level object in the QML file must be a container
qml file must be saved in the same directory as the main file

SHARE:

ANS 1 - D

ANS 2 - D

ANS 3 -B

ANS 4 True A

# data[].attributes.body
THINK

One can create a custom component by creating a new qml file and then by naming it with AbcView.qml and start the page consisting of a container. Further create multiple core UI's inside the same custom qml file. Then call it in the main qml by calling it in the page like other core UI.

PAIR
Top level object file in a qml must be a container.
Qml filename must begin with capital letters.
QMl file must be placed in the same directory as any other QML that will be referencing it. We can change its properties by creating an alias in the custom components.

SHARE
1(C)
2(D)
3(B)
4(A)

# data[].attributes.body
Think: We can create custom components by first creating a new qml file and giving it a name like  XYZView.qml and start the page with a container and not a page. Multiple core UIs in the custom qml file can then be created.
After making it we can call it in the main qml by simply calling it in the page like any other core UI.
Top level object file in a qml must be a container.

Pair: Qml filename must always begin with capital letters.
Qml file shold be placed in the same directory as any other Qml that will be referencing it.
We can change the its poeperties by creating an alias in the custom components.

Share:

Q1  (C)
Q2  (D)
Q3  (B)
Q4  (A)

# data[].attributes.body
THINK: QML file name must start with a capital name. Core UIs can be accessed by using property alias type. Different variable names can be given to each component.
eg  text1, etc. If we have to access same UIs, properties can be changed using reference of property alias type. Custom component can be declared with container as root element with stack layout.
PAIR:  New qml file can be created using name like ABCname.qml
Properties can be changed by creating alias.
SHARE:

MCQs
1.) D
2.) D
3) B
4) A

# data[].attributes.body
Think - Process of creating multiple same type of core UIs in custom components and changing the properties in the main UI.

Think : You can create a custom components by first creating a new qml file by naming it SOMETHINGView.qml and then start with that page with a container and not a page. Then you can create multiple core UI's inside that custom qml file.
Each of these components can be given a different variable name, eg: text1, text2 (for text fields), if we have to access same type of UIs which are more than 1 in number.
After you are done making it, you can call it in the main.qml by just calling it in the page like we call whatever other center UI.

Pair -  Following points should be kept in mind while creating a QML file -

1]QML’s  filename must start with a capital letter

2]Top level object in the QML file must be a container

3]QML’s filename should end with the suffix ‘View’

4]QML file should be placed in the same directory as any other QML that will be referencing it
Start by creating a .qml file called

Example
Container{
property alias text: example.text
Label{
id: txt1
}
}

Q1 (B)
Q2 (D)
Q3 (B)
Q4 (A)

# data[].attributes.body
Think: We can create a custom component by creating a new qml file and then by naming it with AbcView.qml and start the oage consisting of a container. We then create core UIinside the same custom qml file. Further we call it in the main wml by calling it in the page  like ither core UI.

Pair:Top level object file in a qml must be a container. Qml file must begin with capital letters. Qml file must be placed in the same directory as any other Qml  that will be referencing it.We can change it's properties by creating anal alias in the custom components.

1.D
2.D
3.B
4.A

Share:

# data[].attributes.body
THINK:
When we create custom components, we can access the core UIs in it by using the
'property alias type' syntax. Each of these components can be given a different variable name, eg: text1, text2 (for text fields), if we have to access same type of UIs which are more than 1 in number. The properties of these elements can be changed, in Main.qml, using the reference we make (property alias type) from the qml file.

PAIR:
I did not mention an example.

SHARE:

QUESTIONS:
1. D
2. D
3. B
4. A

# data[].attributes.body
1 Marks for your ans for correct choice
1 Mark for your think phase
1 mark for your share, not be counted if you have not written share phase.

# data[].attributes.body
Start your padlet with your name, roll no. and subject.

# data[].attributes.body
Think (3 mins)  : Explain the process of creating multiple same type of Core UIs in Custom Components and changing its properties in main.qml?

uPair (4 mins)  :Discuss with your neighbor and find out the more suitable points, if you missed?

Share (6 mins)  : Share with colleagues!  D~�s7*

Think: Think individually and write the answer.
Pair: Discuss with your neighbours and write the answer under pair heading, try to include the items that you left in think phase, give feedback to your neighbours.
Share: Share the answer with your class mates and discuss on the best possible solution.