text:
History of Spain/Spain Divided

Islamic rule
In 711, Muslim Moors, mainly North African Berber soldiers with some Arabs, crossed the Strait of Gibraltar and began their conquest of the Christian Visigothic Kingdom of Hispania. After their conquest of the Visigothic kingdom's Iberian territories, the Muslims crossed the Pyrenees and took control of Septimania in 719, the last province of the Visigothic kingdom to be occupied. From their stronghold of Narbonne, they launched raids into the Duchy of Aquitaine. At no point did the invading Islamic armies exceed 60,000 men. However, those armies established an Islamic rule that would last hundreds of years in much of the Iberian Peninsula and 781 years in Granada.

After the establishment of a local Emirate, Caliph Al-Walid I, ruler of the Umayyad caliphate, removed many of the successful Muslim commanders. Tariq ibn Ziyad, the first governor of the newly conquered province of Al-Andalus, was recalled to Damascus and replaced with Musa bin Nusair, who had been his former superior. Musa's son, Abd al-Aziz ibn Musa, apparently married Egilona, Roderic's widow, and established his regional government in Seville. He was suspected of being under the influence of his wife, accused of wanting to convert to Christianity, and of planning a secessionist rebellion. Apparently a concerned Al-Walid I ordered Abd al-Aziz's assassination. Caliph Al-Walid I died in 715 and was succeeded by his brother Sulayman ibn Abd al-Malik. Sulayman seems to have punished the surviving Musa bin Nusair, who very soon died during a pilgrimage in 716. In the end Abd al-Aziz ibn Musa's cousin, Ayyub ibn Habib al-Lakhmi became the emir of Al-Andalus. The conquering generals were necessarily acting very independently, due to methods of communication available. Successful generals in the field and in a very distant province would also gain the personal loyalty of their officers and warriors and their ambitions were probably always watched by certain circles of the distant government with a certain degree of concern and suspicion. Old rivalries and perhaps even full-fledged conspiracies between rival generals may have had influence over this development. In the end, the old successful generals were replaced by a younger generation considered more loyal by the government in Damascus. A serious weakness amongst the Muslim conquerors was the ethnic tension between Berbers and Arabs. The Berbers were indigenous inhabitants of North Africa who only recently had been converted to Islam; they had provided most of the soldiery of the invading Islamic armies but sensed Arab discrimination against them. This latent internal conflict jeopardized Muslim unity. After the Islamic Moorish conquest of nearly all of the Iberian Peninsula in 711-718 and the establishment of the emirate of Al-Andalus, an Umayyad expedition suffered a major defeat at the Battle of Toulouse and were halted for a while on their way north. Odo of Aquitaine had married his daughter to Uthman ibn Naissa, a rebel Berber and lord of Cerdanya (maybe of all current Catalonia too), in an attempt to secure his southern borders in order to fend off Charles Martel´s attacks on the north. However, a major punitive expedition led by Abdul Rahman Al Ghafiqi, the latest emir of Al-Andalus, defeated and killed Uthman, and the Muslim governor mustered an expedition north across the western Pyrenees, looted areas up to Bordeaux and defeated Odo in the Battle of the River Garonne in 732. A desperate Odo turned to his archrival Charles Martel for help, who led the Frankish and leftover Aquitanian armies against the Muslims and beat them at the Battle of Tours in 732, killing Abdul Rahman Al Ghafiqi; this proved to be the high-water mark of the Islamic conquests in western Europe and of the expansion of Al-Andalus. Moorish rule began to recede, but it would remain in parts of the Iberian peninsula for another 760 years.

The beginning of the Reconquista
The year 722 saw the first Asturian victory against the Muslims. In late summer, a Muslim army overran much of Pelayo's territory, forcing him to retreat deep into the mountains. Pelayo and a few hundred men retired into a narrow valley at Covadonga. There, they could defend against a broad frontal attack. From here, Pelayo's forces routed the Muslim army, inspiring local villagers to take up arms. Despite further attempts, the Muslims were unable to conquer Pelayo's mountain stronghold. Pelayo's victory at Covadonga is hailed as the beginning of the Reconquista.

A drastic increase of taxes by the new emir Anbasa ibn Suhaym Al-Kalbi had provoked several rebellions in Al-Andalus, which a series of succeeding weak emirs were unable to suppress. Around 722 a military expedition was sent into the north to suppress Pelayo's rebellion, but his forces prevailed in the Battle of Covadonga. This battle was considered by the Muslims as little more than a skirmish, while the Battle of Toulouse (721), with at death toll of maybe tens of thousands, was mourned for centuries as a large scale tragedy by the Iberian Muslims. However for Pelayo, the Christian victory secured his independent rule. The precise date and circumstances of this battle are unclear. Among the possibilities is that Pelayo's rebellion was successful because the greater part of the Muslim forces were gathering for an invasion of the Frankish empire.

During the first decades, Asturian control over the different areas of the kingdom was still weak, and for this reason it had to be continually strengthened through matrimonial alliances with other powerful families from the north of the Iberian Peninsula. Thus, "Ermesinda, Pelayo's daughter, was married to Alfonso, Peter of Cantabria's son. Alphonse's children, Froila and Adosinda, married Munia, a Basque from Alava, and Silo, a local chief from the area of Pravia, respectively." After Pelayo's death in 737, his son Fafila was elected king. Fafila, according to the chronicles, was killed by a bear during a trial of courage. Pelayo's dynasty in Asturias survived and gradually expanded the kingdom's boundaries until all of northwest Iberia was included by roughly 775. However, credit is due not to him but to his successors. Alfonso I (king from 739-757) rallied Galician support when driving the Moorish army out of Galicia and an area of that was to become Leon. The reign of Alfonso II from (791-842) saw further expansion of the northwest kingdom towards the south and, for a short time, it almost reached Lisbon. It was not until Alfonso II that the kingdom was firmly established with Alfonso's recognition as king of Asturias by Charlemagne and the Pope. During his reign, the holy bones of St. James the Great were declared to have been found in Galicia, at Santiago de Compostela. Pilgrims from all over Europe opened a channel of communication between the isolated Asturias and the Carolingian lands and beyond. The emirate's greatest failing was its inability to eradicate Christian resistance in the Basque country and the Cantabrian mountains. The two resistances, Basque Navarre and Cantabrian Asturias, despite their small size,demonstrated an ability to maintain their independence. The resistance in the Cantabrian mountains soon spread to Galicia in the north-west, where the occupying Moorish army was expelled and the territory was incorporated into Asturias. Because the Umayyad rulers based in Córdoba were unable to extend their power into Frankish territory, they decided to consolidate their power within the Iberian peninsula. Muslim forces made periodic incursions deep into Asturias but failed to make any lasting gains against the strengthened Christian kingdom.

Fall of the Caliphate
The 9th century saw the Berbers return to Africa in the aftermath of their revolts. During this period, many governors of large cities distant from the capital (Córdoba) planned to establish their independence. Then, in 929 the Emir of Córdoba (Abd-ar-Rahman III), the leader of the Umayyad dynasty, declared himself Caliph, independent from the Abbasids in Baghdad. He took all the military, religious and political power and reorganised the army and the bureaucracy. After regaining control over the dissident governors, Abd-ar-Rahman III tried to conquer the remaining Christian kingdoms of the Iberian peninsula, attacking them several times and forcing them back beyond the Cantabric range. His Christian subjects were largely left in peace, however. Christian political forces then accused Abd-ar-Rahman III of pederasty with a Christian boy who was later canonized Saint Pelagius of Cordova for his refusal of Abd-ar-Rahman's advances. As part of a pattern of portraying Islamic morality as inferior, the story provided political strength and popular support to the Reconquista for centuries.

Later Abd-ar-Rahman's grandson became a puppet in the hands of the great Vizier Almanzor (al-Mansur, "the victorious"). Almanzor waged several campaigns attacking and sacking Burgos, Leon, Pamplona, Barcelona and Santiago de Compostela before his death in 1002. Between Almanzor's death and 1031, Al-Andalus suffered many civil wars which ended in the appearance of the Taifa Kingdoms. The taifas were small kingdoms, established by the city governors establishing their long wished-for independence. The result was many (up to 34) small kingdoms each centered upon their capital, and the governors, not subscribing to any larger-scale vision of the Moorish presence, had no qualms about attacking their neighbouring kingdoms whenever they could gain advantage by doing so. This split into the taifa states caused Islamic presence to be greatly weakened in the face of the strengthening Christian kingdoms to the north. When Alfonso VI brought Toledo under his authority in 1085. Mortified by the concept of being surrounded by the enemy taifa rulers sent a desperate appeal to the Berber chieftain Yusuf b. Tashufin leader of the Almoravids.

Almoravids
The Almoravids were a Muslim militia, their ranks mainly composed of Berber and African Moors, and unlike the previous Muslim rulers, they were not so tolerant towards Christians and Jews. Their armies entered the Iberian peninsula on several occasions (1086, 1088, 1093) and defeated King Alfonso at the Battle of Sagrajas in 1086, but initially their purpose was to unite all the Taifas into a single Almoravid Caliphate. Their actions halted the southward expansion of the Christian kingdoms. Their only defeat came at Valencia in 1094, due to the actions of El Cid. Meanwhile, Navarre lost all importance under King Sancho IV, for he lost Rioja to Sancho II of Castile, and nearly became the vassal of Aragon. At his death, the Navarrese chose as their king Sancho Ramirez, King of Aragon, who thus became Sancho V of Navarre and I of Aragon. Sancho Ramírez gained international recognition for Aragon, uniting it with Navarre, expanding the borders south, conquering Wasqat Huesca deep in the valleys in 1096 and building a fort, El Castellar, 25 km away from Saraqustat Zaragoza. Catalonia came under intense pressure from the taifas of Zaragoza and Lérida, and also from internal disputes, as Barcelona suffered a dynastic crisis which led to open war among the smaller counties; but by the 1080s, the situation calmed, and the dominion of Barcelona over the smaller counties was restored.

The Almohads
After a brief period of disintegration (second Taifa period), the rising power in North Africa, the Almohads, took over most of Al-Andalus. But they would be decisively defeated at the Battle of Las Navas de Tolosa (1212) by a Christian coalition, losing almost all the remaining lands of Al-Andalus in the following decades. By 1252 only the Kingdom of Granada remained as sovereign Muslim state in the Iberian peninsula.

Emirate of Granada
Ferdinand and Isabella completed the Reconquista with a war against the Emirate of Granada that started in 1482 and ended with Granada's complete annexation in early 1492. The Moors in Castile previously numbered "half a million within the realm." By 1492 some 100,000 had died or been enslaved, 200,000 had emigrated, and 200,000 remained in Castile. Many of the Muslim elite, including Granada's former Emir Muhammad XII, who had been given the area of the Alpujarras mountains as a principality, found life under Christian rule intolerable and emigrated to Tlemcen in North Africa.

title: History of Spain/Spain Divided


text:
Futurebasic/Language/Reference/get preferences

=GET PREFERENCES=

Syntax
GET PREFERENCES prefFileName$, prefRecord

Revised
Feb 2002 (Release 6)

Description
This statement locates the named preference file and loads the contents of the file into the indicated preferences record. If the size of the record and the size of the file are different, the smaller of the two sizes will be used.

A full example of using the new  commands can be found on the   reference page.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text: History of Spain/Introduction

title: History of Spain/Introduction


text: History of Spain/References

title: History of Spain/References


text:
History of Spain/Contributors

The following is a list of all contributors, past and present, to this Wikibook. For a list containing only those contributors who are currently active in its development, please refer to the Infobox.

 * Νεοπτόλεμος ( talk | email | contribs )

title: History of Spain/Contributors


text:
Futurebasic/Language/Reference/page statement

= PAGE =

Description
This statement is identical to the  statement.


text:
Futurebasic/Language/Reference/page lprint

= PAGE =

Description
This statement is identical to the  statement.


text:
Futurebasic/Language/Reference/get window

=GET WINDOW=

Syntax
GET WINDOW [#]wndID, windowPtrVar&

Description
This statement returns a pointer to the window record for the window specified by. The pointer is returned into , which must be a long-integer variable or a   variable. A window record is a data structure which contains information about the window, such as its current visibility status, current background & foreground colors, and much, much more. In addition, you need to specify a window record pointer whenever you call any Toolbox routine that deals with windows. For information about the contents of the window record, see the "http://developer.apple.com/documentation/mac/Toolbox/Toolbox-188.html#HEADING188-0""Window Manager" chapter of "http://developer.apple.com/documentation/macos8/mac8.html"Inside Macintosh: "http://developer.apple.com/documentation/mac/Toolbox/Toolbox-2.html"Macintosh Toolbox Essentials, as well as the descriptions of grafPort and CGrafPort data structures in "http://developer.apple.com/documentation/macos8/mac8.html" "blank"Inside Macintosh: "http://developer.apple.com/documentation/mac/QuickDraw/QuickDraw-2.html" "blank"Imaging with QuickDraw.

FB uses the window record's RefCon field to maintain information about the window, including its class, its modality (modal or not), its ID number, and its type. This information is only valid for windows created using the  statement. You can access this information as follows:

Note: Your program should not dispose of the window record (i.e., don't pass the pointer to ). The system automatically disposes of it when you close the window.


text:
Futurebasic/Language/Reference/peek

Syntax
Shorthand syntax:

Description
The  functions look at the 1, 2 or 4 bytes of data which begin at , and return them as a byte integer, short integer or long integer value, respectively. The  should be a long integer expression, or a   or   variable. The value returned by a  function will be interpreted either as a signed or unsigned value, depending on what type of variable itÕs assigned to. If the value is not assigned to any variable, itÕs usually interpreted as a signed value.

title: Futurebasic/Language/Reference/peek


text:
Futurebasic/Language/Reference/getprocessinfo

= GET PROCESS INFO =

Syntax
GETPROCESSINFO index%, processName$ [PSN]

Revised
May, 2001 (Release 5)

Description
A "Process" is something that is currently running on your computer; this includes, but is not limited to things like applications, control strip extensions, and background applications.

The index parameter in this call indicates which process is to be queried. An index value of -1 means that the front process is used. This is generally the running FB application that you created.

Index values of zero or higher represent running processes. You may climb this list, examining processes as you go, until the process name comes back as a null string. At that point, you have exhausted the system's list of processes and you can quit searching.

The process serial number is an 8 byte value (2 long integers) that holds a unique value which cannot be used by any other concurrent process. You create a process serial number as follows:

The following example shows how to display a list of running processes.

DIM indx& DIM ProcessName$ DIM psn as ProcessSerialNumber


text:
Futurebasic/Language/Reference/globals

= GLOBALS =

Syntax
GLOBALS "filename1" [,"filename2"...]

Description
This statement behaves identically as the  statement. The keyword is maintained for backwards compatibility with earlier versions of FutureBasic. To make your program easier to read, you may typically use the  statement to include files which define global variables, constants, record structures, etc., while using the   statement to include functions, etc. However, the   statement and the   statement are completely interchangeable.

title: Futurebasic/Language/Reference/globals


text:
Futurebasic/Language/Reference/gosub

= GOSUB =

Syntax
GOSUB {lineNumber|"statementLabel"

Description
Executes the subroutine located at the indicated line number or statement label. The subroutine should include a  statement;   causes execution to continue at the statement following the   statement.

is an outdated method for executing routines; it's generally a better idea to encapsulate your routines in a  function. However, there are a couple of possible advantages to using :

 Routines called using  may execute somewhat faster than local functions.

You can create a "private" subroutine inside a local function, and use a  within that local function to call the subroutine. The variables used in the subroutine will have the same scope as the local function. This may be a good way to execute certain repetitive tasks within the local function.

Example: Subroutines can be executed in a "nested" fashion; i.e., one subroutine may call another. FB keeps track of where each  statement should "return" to.

program output:

Note: It is possible for a  statement inside a local function to jump to a subroutine located outside of that function; it's also possible for a   statement in "main" to jump to a subroutine located inside a local function. However, this kind of programming is not recommended, because the resulting switches in variable scope can produce unexpected results.

title: Futurebasic/Language/Reference/gosub


text: History of Spain/Print version

title: History of Spain/Print version


text:
Futurebasic/Language/Reference/goto

= GOTO=

Syntax
GOTO {lineNumber|"statementLabel"

Description
Causes program execution to continue at the statement at the indicated line number or statement label. The target statement must be within the same "scope" as the statement (i.e., they must both be within the "main" part of the program, or they must both be within the same local function). Also, you should never use  to jump into the middle of any "block" statement structures (such as ,  ,  , etc.).

is sometimes useful in the "main" part of the program, to branch around certain structures such as  procedures. However, excessive use of  can lead to code that is difficult to read and maintain. The use of  is generally discouraged; FutureBasic's other branching and looping structures offer a better solution.

title: Futurebasic/Language/Reference/goto


text: User talk:68.255.3.152

title: User talk:68.255.3.152


text:
Using Plasma

Table of Contents

 * 1) /Introduction/
 * 2) /What is Plasma/
 * 3) /First impressions/
 * 4) /Navigating Plasma/
 * 5) /Customize Plasma/
 * 6) /History of Plasma/

title: Using Plasma


text: User talk:66.203.165.146

title: User talk:66.203.165.146


text: User talk:70.116.24.78

title: User talk:70.116.24.78


text:
User:CambridgeBayWeather

 * Cambridge Bay Weather - English Wikipedia, please use this to contact me.

title: User:CambridgeBayWeather


text: User talk:81.145.240.66

title: User talk:81.145.240.66


text:
User talk:DaSkreech

Welcome message
Welcome, DaSkreech!

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally. Webaware talk 03:19, 8 April 2008 (UTC)

title: User talk:DaSkreech


text:
Futurebasic/Language/Reference/cfindex

= CFINDEX.INCL include =

Syntax
Revised: November; 2006 (FB 4, Release 4)

Description
The CFIndex include file is a replacement of the standard set of instructions used to implement all  commands. By including this file, your application instantly takes on the new features, even if you have already programmed things using the old  commands. CFIndex offers several advantages:  Increased speed. Easier localization through the use of CF strings instead of Pascal strings. Improved memory handling. Sorting (See .)  Once you have added the file to your project, either by using the Include command or by dragging and dropping the file into your project window, you may use standard  commands to transparently take advantage of the new features.

title: Futurebasic/Language/Reference/cfindex


text:
Futurebasic/Language/Reference/cfindexsort

= CFINDEXSORT function =

Function
✔ χ Appearance ✔ χ Standard ✔ χ Console

Syntax
Revised: November; 2006 (FB 4, Release 4)

Description
This function is actually easier to implement than it appears. The return value of the function is undefined and therefore ignored. The parameter that you pass to the array is the index number. Pass zero if you are only using one  array. Items in the array are sorted from the least to the greatest.

Note: This only works if you have included the CFIndex.Incl. This only works in CarbonLib v1.0 and later and in MacÊOSÊX v10.0 and later. If you have any expectation of serving older computers, you should block the function so that this sorting routine is not executed.


text:
Futurebasic/Language/Reference/clear index

Clear Index

Syntax
To allocate, increase or decrease memory for  arrays: 1.      2.

To release the memory used by existing  arrays: 3.  4.

Description
Use syntax (1) or (2) to allocate memory for an  string array, and to specify whether the array shall consist of fixed-length or variable-length cells for the strings. Using fixed-length cells provides greater speed but may require more memory. Using variable-length cells provides more efficient use of memory, but processing may be slower. You must use Syntax (1) or (2) to allocate memory for an  array before the array will function.

Use Syntax (1) to specify the total number of bytes to be allocated for a variable-cell-length  array. The  parameter indicates which of the ten available   arrays (numbered 0 through 9) to allocate space for. If you omit this parameter, space will be allocated for  array #0.

Use Syntax (2) to specify the number of elements to be allocated for a fixed-cell-length  array. The  parameter should be in the range (1..256); it fixes the size of the cells. You can store a string of up to characters in such a cell. The  parameter indicates which   array (0 - 9) to allocate space for.

You can also use Syntax (1) or (2) to increase or decrease the amount of memory allocated for an existing array. This is sometimes useful if you find you need more (or less) memory than you originally allocated. If you increase the memory allocation, none of the existing strings in the array will be affected. If you want to decrease the memory allocation without affecting the existing strings, make sure you don't specify too small a number; you can use the  function to determine how much memory the existing strings occupy.

Use Syntax (3) or (4) to release the memory previously allocated for one or more  arrays. Syntax (3) releases the memory occupied by all existing  arrays. Syntax (4) empties each string in an  array without releasing memory occupied by the array. If you omit the  parameter, then   array #0 is used.


text:
Futurebasic/Language/Reference/clear lprint

CLEAR LPRINT

Statement
✔ Appearance ✔ Standard ✔ Console

Revised
November, 2006 (FB 4, Revision 4)

Description If output has been routed to the printer,  forces the Printing Manager to print the current page, without closing the print job. The other ways to print the current page are to execute  or to exit the program, both of which also cause the print job to be closed.

Example
NEEDS IMG!!!


text:
User:Trent y

Draft outline for PasstheFRACP

This is the first draft of a list of suggested topics for a Wikibook for candidates sitting the Royal Australasian College of Physicians Examination.

title: User:Trent y


text:
User:Trent y/PasstheFRACP Draft

This page is a draft outline for a proposed WikiBook for FRACP exam candidates.

Please feel free to make changes or suggestions as appropriate. Once there is a bit of interest and some more structure, this will be copied over to the main section of Wikibooks.

Please get involved!

Introduction

 * About this book
 * Disclaimers
 * Basic Exam Info
 * Basic & Advanced Training
 * Structure of the Exam
 * Written
 * Clinical

Preparing for the Exam

 * Written
 * What to Read
 * Textbooks
 * Journals
 * Past Exam Papers
 * Clinical
 * When to start
 * Number of Cases
 * Spread of Cases
 * Introduction to the Long Case
 * Introduction to the Short Case

Exam Resources

 * Written
 * Study Guides
 * Worked Trial Exam answers (if this is okay with the college)
 * Hot topics for year x
 * Clinical
 * Long Cases
 * Long Case Template
 * Cards for Common Problems
 * Common Long Cases
 * Short Cases
 * Cards for Common Short Cases

title: User:Trent y/PasstheFRACP Draft


text:
User:Tw3435~enwikibooks

Tw3435's

title: User:Tw3435~enwikibooks


text:
Cookbook:Knife Skills

Cutting is one of the most basic kitchen preparation skills. By far the most common utensil for this is a chef's knife, although a paring knife and others are also used. With practice, cutting food can be safe, fun, and easy, and it is a skill that is well worth developing for anyone who prepares food.

Knife grip
When slicing food by hand, always grip the handle of the knife firmly—a loose grip can lead to accidents. The correct grip provides the maximum degree of control over the knife. It increases one's accuracy and speed, as well as preventing slipping which can cause accidents. The type of grip one uses depends to some extent on the task being performed, as well as the size of the knife. The grip most frequently used for general cutting and slicing is the one illustrated. Grasp the handle in the palm of the hand with the thumb on one side of the blade, the forefinger on the other side, and the middle, ring and small fingers wrapped around the handle. This is commonly referred to as a "pinch grip" and is believed by many food-service professionals to give maximum control. Those without culinary training often grip the handle with all four fingers and the thumb gathered underneath.

Food grip
The food item is held firmly with the other hand, with the fingers curled under so that the side of the blade is against the knuckles. The curling under of the hand holding the food is extremely important and is a safety requirement that must never be disregarded even when the knife is nowhere near one's fingers so as to make it an automatic habit. Many accidents, and indeed the loss of digits, could have been avoided if this technique were always followed. Regrettably, even professionals sometimes disregard their own rules—resist the temptation to do so.

Other

 * When using a mandoline, use the food holder which is supplied with it. If it didn't have one when you bought it, it is quite likely being illegally sold in your jurisdiction which probably requires that they be sold with a holder included.
 * When passing a knife to another person, do so handle first.

Boning
In the culinary language, to bone means to remove all bones from inside an item.

Slicing
Slicing is the cutting of food into thin, relatively broad slices. Slices may be used as they are or processed further to produce other speciality cuts such as chiffonade, rondelles, diagonals, oblique or roll cuts, and lozenges. Slicing may be accomplished by hand or machine. Mechanized slicers include rotary slicers and food processors with a slicing attachment. A mandoline greatly increases both the speed and uniformity of slices produced and are available for both professional and home use.

One of two methods may be used for slicing:

 * Method A: The tip of the knife rests on the cutting board while the food item is held with the other hand. The knife is rocked up and down. On the downward movement, the blade moves down and forward to slice through the item, keeping the tip on the cutting board. If the item is too large to rest the tip on the work surface, the same motion is used but the tip points toward the cutting board while one pushes the knife down and forward through the food in one movement. Do not saw backwards and forwards.
 * Method B: Gripping the item with one's fingers curled under as described, use the wrist as a fulcrum and the second joint of one's index finger as a guide. With the heel of the knife on the cutting board, the tip is lifted and one slices by drawing the knife slightly back toward you and down through the item, using the knuckle of the index finger to adjust the thickness of each cut. The motion of the knife should be almost entirely from the wrist, not from the elbow.

Chiffonade
Chiffonade is a technique in which herbs or leafy green vegetables (such as spinach and basil) are cut into long, thin strips. The term comes from the French language and means "made of rags" referring to the fabric-like strips that result in this technique. It is generally accomplished by stacking leaves, rolling them tightly, then cutting across the rolled leaves with a sharp knife, producing fine ribbons. To chiffonade, place a large stack of basil leaves in your fingertips, largest leaves at the bottom. Roll tightly and place down on a cutting board and cut thinly across, while keeping your knife tip in contact with the board at all times.

Julienning
To julienne a vegetable or other ingredient is to cut it into long thin matchstick-sized strips 1/16–⅛ inch (1.5–3 mm) wide and 2–3 inches (5–7 cm) long. A baton is larger, at almost ¼ inch wide, and is also the starting point for the small dice.

Trimming the ends of the vegetable and the edges to make four straight sides makes it easier to produce a uniform cut; trimmings can be used for stocks, soups, purees, etc. To julienne a carrot, first cut it into cylindrical sections of the desired length. Trim each section so that the sides are straight and right-angled (almost like a cuboid). Slice into flat panels of desired width. Stack these panels and slice evenly into matchsticks.

Chopping
Chopping is used to break food down into smaller pieces with no defined shape. It may be coarse or fine, in which case it should be specified in the recipe (e.g. coarsely-chopped, etc). To chop parsley, for example, grip the handle of a chef's knife. Pinch the part of the blade closest to the handle. With your other hand, if you are chopping something like a chiffonade, hold the target food steady. If doing something like nuts, place your palm in the middle of the blunt end. Rock the knife up and down rapidly, keeping the tip on the work surface, and gradually move the blade sideways over the food item on the chopping board. In order to ensure that all of the product is properly chopped, rearrange the pile from time to time if you are doing nuts or vegetables and continue until you have reached the desired degree of fineness.

Mincing
Mincing is a technique for rendering food into very small pieces, but not as far as a purée. Mincing is for a variety of purposes, such as making minced meat (also just mince, ground beef, etc.), fruit mince, or minced garlic. Mincing can be achieved using a meat grinder or mincer, a food processor, a grater, or a knife and chopping board.

Cubing/Dicing
Cubing refers to cutting an ingredient into cubes, and to dice means to cut into small cubes. The size is often specified in the recipe, and in classical French cooking there are four sizes:

 * Brunoise: ⅛ x ⅛ x ⅛ inch (3x3x3 mm) cubes
 * Small dice: ¼ x ¼ x ¼ inch (6x6x6 mm) cubes
 * Medium dice: ⅜ x ⅜ x ⅜ inch (9x9x9 mm) cubes
 * Large dice: ⅝ x ⅝ x ⅝ inch (1.5 x 1.5 x 1.5 cm) cubes

Other ways of cutting in to small pieces, but not cubes, include:

 * Paysanne: not a cube but within the same category as dice. The dimensions are ½ x ½ x ¼ inches (12 x 12 x 6 mm)

title: Cookbook:Knife Skills


text:
Royal Australasian College of Physicians Examinations

This page is a draft outline for a proposed Wikibook for FRACP exam candidates.

Please feel free to make changes or suggestions as appropriate. Ideally, we'd like as many people contributing to try and get it up to speed. Please get involved!

/Introduction/

 * About this book
 * Disclaimers
 * Basic Exam Info
 * Basic & Advanced Training
 * Structure of the Exam
 * The Written Exam
 * The Clinical Exam

Preparing for the Exam

 * Written
 * What to Read
 * Textbooks
 * Journals
 * Past Exam Papers
 * Clinical
 * When to start
 * Number of Cases
 * Spread of Cases
 * Introduction to the Long Case
 * Introduction to the Short Case

Exam Resources

 * Written
 * Study Guides
 * Worked Trial Exam answers (if this is okay with the college)
 * Hot topics for year x
 * Clinical
 * Long Cases
 * An example template for the Long Case
 * Cards for Common Problems
 * Common Long Cases
 * Short Cases
 * Common Short Case Cards
 * Sample: Neuro Exam of the Lower Limb
 * Draft: The Eye Examination
 * Example Cases
 * 3rd Nerve Palsy
 * Horner's Syndrome
 * Myaesthenia
 * Motor Neurone Disease


text:
User:Trent y/Dislaimer

Important Things to Remember
Wikibooks is a free, non-copyrighted resource. This also means that other people's copyright must be respected.

This means:
 * No wholesale reproduction of other texts (Talley & O'Connor springs to mind)
 * No College Past papers
 * Remembered questions are a grey area and best avoided
 * No scanning of diagrams from other books (try checking Wikipedia fist - it's surprisingly comprehensive)

Of course, medical knowledge is subject to change, so no guarantee is made that:
 * The information here will be accurate
 * Information given will be current for the year you do the exam
 * The standard medical internet disclaimer that you should not use this as medical advice applies.

title: User:Trent y/Dislaimer


text:
Royal Australasian College of Physicians Examinations/Introduction/About this book

This project was started in April 2008, to try and replace the no-longer-updated site Pass the FRACP. It is intended to be a reference for candidates for the written and clinical examinations, and provide a source of:
 * Exam wisdom from those that have gone before
 * Resources for candidates (study notes etc).

Before adding anything, please read the Disclaimers, but other than that - jump right in.


text:
Royal Australasian College of Physicians Examinations/Introduction/Disclaimers

Wikibooks works as a free repository for non-copyright material. Copyright material should not be included here - specifically:

 * No wholesale reproduction of other texts (eg Talley & O'Connor's various books)
 * No College Copyright material (this includes past exam papers)
 * Remembered questions are a grey area and best avoided.

Also, standard disclaimers about medical information on the internet apply - a good version is here on Ganfyd - the medical wiki.


text: User:Wordsthink~enwikibooks/sandbox

title: User:Wordsthink~enwikibooks/sandbox


text: User talk:Wordsthink~enwikibooks/sandbox


text:
User talk:87.120.239.76

Join Us!
--Webaware talk 07:28, 8 April 2008 (UTC)

title: User talk:87.120.239.76


text:
User talk:Trent y

Welcome message
Welcome, Trent y!

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally. Webaware talk 07:39, 8 April 2008 (UTC)

Lost pages
G'day, you seem to have lost a page... I've moved it, making it a sub-page of your User page if you need to retrieve any text: I've also deleted the About This Book page that you started and blanked. To have a page deleted, please place a delete tag at the top - - and an admin will come along and delete it at some point. To make links to sub-pages, you can use some link shortcuts that will make your life easier. See Help:Editing for more information. I've edited the main page of your book to reflect this, if you'd like to take a look. You can probably find a good range of images for direct inclusion in your Wikibook by looking on the Wiki Commons. All images on Commons can be used in your wikibook without uploading them to Wikibooks, as if they were local images. Webaware talk 07:53, 8 April 2008 (UTC)
 * User:Trent y/Dislaimer

title: User talk:Trent y


text:
MediaWiki User Guide

This is a user guide to MediaWiki, the software that runs Wikipedia, Wikibooks and other Wikimedia projects. The book focuses on reading and editing wikis that are running MediaWiki, including the MediaWiki markup. Topics out of scope of the book include administration and development of MediaWiki.

Contents

 * 1) /Introduction/
 * 2) User Interface
 * 3) /Search/
 * 4) Markup
 * 5) /Text Formatting/
 * 6) /Hyperlinks/
 * 7) /Sections and Headings/
 * 8) /Lists/
 * 9) /Tables/
 * 10) /Images/
 * 11) /Sound files/
 * 12) /Categories/
 * 13) /Templates/
 * 14) /References/
 * 15) /Mathematics/
 * 16) /Namespaces/
 * 17) /Graphs/
 * 18) /Extensions/
 * 19) /Index/
 * 20) /Glossary/
 * 21) /Links/

Related books

 * Help:Contents
 * Editing Wikitext
 * MediaWiki Developer's Handbook
 * MediaWiki Administrator's Handbook

მედიავიკი (მომხმარებლის სახელმძღვანელო)

title: MediaWiki User Guide


text:
User talk:Tw3435~enwikibooks

Welcome message
G'day, I'm not quite sure what your intentions are here, but I would appreciate it if you could read What is Wikibooks to ensure that Wikibooks is the right place for it. Now, here's our standard welcome message:

Welcome, Tw3435!

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally. Webaware talk 08:03, 8 April 2008 (UTC)

Your account will be renamed
Hello,

The developer team at Wikimedia is making some changes to how accounts work, as part of our on-going efforts to provide new and better tools for our users like cross-wiki notifications. These changes will mean you have the same account name everywhere. This will let us give you new features that will help you edit and discuss better, and allow more flexible user permissions for tools. One of the side-effects of this is that user accounts will now have to be unique across all 900 Wikimedia wikis. See the announcement for more information.

Unfortunately, your account clashes with another account also called Tw3435. To make sure that both of you can use all Wikimedia projects in future, we have reserved the name Tw3435~enwikibooks that only you will have. If you like it, you don't have to do anything. If you do not like it, you can pick out a different name.

Your account will still work as before, and you will be credited for all your edits made so far, but you will have to use the new account name when you log in.

Sorry for the inconvenience.

Yours, Keegan Peterzell Community Liaison, Wikimedia Foundation 23:48, 17 March 2015 (UTC)

Renamed
 This account has been renamed as part of single-user login finalisation. If you own this account you can |log in using your previous username and password for more information. If you do not like this account's new name, you can choose your own using this form after logging in: . -- Keegan (WMF) (talk) 05:36, 19 April 2015 (UTC)

title: User talk:Tw3435~enwikibooks


text:
A-level Physics (Advancing Physics)/Diffraction

We have already seen why fringes are visible when light passes through multiple slits. However, this does not explain why, when light is only passing through 1 slit, a pattern such as the one on the right is visible on the screen.

The answer to this lies in phasors. We already know that the phasor arrows add up to give a resultant phasor. By considering the phasor arrows from many paths which light takes through a slit, we can explain why light and dark fringes occur.

At the normal line, where the brightest fringe is shown, all the phasor arrows are pointing in the same direction, and so add up to create the greatest amplitude: a bright fringe.

At other fringes, we can use the same formulæ as for diffraction gratings, as we are effectively treating the single slit as a row of beams of light, coming from a row of slits.

Now consider the central beam of light. By trigonometry:

$$\sin{\theta} = \frac{W}{L}$$,

where θ = beam angle (radians), W = beam width and L = distance from slit to screen. Since θ is small, we can approximate sin θ as θ, so:

$$\theta \approx \frac{W}{L}$$

and since λ = d sin θ:

$$\theta \approx \frac{\lambda}{d}$$

Questions
1. What is the width of the central bright fringe on a screen placed 5m from a single slit, where the slit is 0.01m wide and the wavelength is 500 nm?

And that's all there is to it ... maybe.

/Worked Solutions/


text:
A-level Physics (Advancing Physics)/Diffraction/Worked Solutions

1. What is the width of the central bright fringe on a screen placed 5m from a single slit, where the slit is 0.01m wide and the wavelength is 500 nm?

$$\frac{W}{L} \approx \frac{\lambda}{d}$$

$$\frac{W}{5} \approx \frac{500 \times 10^{-9}}{0.01}$$

W = 250μm, but since this is only half the beam, the beam is 500μm wide.


text:
User:Cysiro

My name is Michael.

I'm a newly-registered Wikibookian and currently contribute to the Muggles' Guide to Harry Potter — come help us out there!

Here are some things you can do at the Muggles' Guide:

 * Italicise all occurrences of spell incantations but not their other names, especially at the title of templates on spell pages and on the Magic page. (e.g. Avada Kedavra is the Killing Curse)
 * Write all occurrences of book names in full and italicise them. (e.g. Harry Potter and the Goblet of Fire)

Contact...
 * Go to my talk page
 * [mailto:michael.1@live.co.za Email me]

title: User:Cysiro


text:
User talk:66.16.223.30

Blocked
Νεοπτόλεμος ( talk | email | contribs ) 13:50, 8 April 2008 (UTC)

title: User talk:66.16.223.30


text:
User talk:152.20.237.118

Welcome!
Welcome to Wikibooks, a collection of open-content textbooks! You don't have to log in to read or edit articles on Wikibooks, but creating an account is quick, free and non-intrusive, requires no personal information, and gives you many benefits, including:
 * The use of a username of your choice
 * The ability to view all your contributions via a "My contributions" link
 * Your own user page
 * Your own talk page which, if you choose, also allows users to send you messages without knowing your e-mail address
 * The use of your own personal watchlist to which you can add articles that interest you
 * The ability to rename pages.
 * The ability to upload images
 * The ability to customize the appearance and behavior of the website
 * The eligibility to become an administrator
 * The right to be heard in votes and elections
 * Your IP address will no longer be visible to other users.

We hope that you choose to become a Wikibookian and create an account. Feel free to ask me any questions you may have on my talk page. By the way, make sure to sign your posts and comments with four tildes (~~~~), which will let others know who left it.

Νεοπτόλεμος ( talk | email | contribs ) 14:48, 8 April 2008 (UTC)

title: User talk:152.20.237.118


text:
Editing Wikitext/Making Templates A101

Introduction This book chapter should be viewed as an introductory text on the making of Wiki templates, and an overview of what templates do is provided in this first section. First lets get some basic terminology:
 * TEMPLATES are just blocks of saved text that have been given names.  Some are ordinary text paragraphs and some contain wikitext to make headings, indents, tables, and the like.   In a simple case, by typing a template's name in the work, an entire block of text is added to the page with all of its formats and other parts, just as if it had been typed by the user.   This behavior can be repeated at any point that the user wants, and almost any work that is found on a wiki page could be placed within a template to do this.  The main effort as you might suppose, lies in its initial design.

 * NAMES of templates are assigned when they are first saved. The name must be unique, and it is used when a template is called for use.  Sometimes other text is also used along with the name; it can include any options and parameters.

 * OPTIONS allow the user to vary the template's usual behavior..  The usual behavior  suits most situations but the designer builds-in ways of changing things just in case.  Option values are usually limited to a short list so these are described in a template's documentation.  For example, option values for an option called align might include only left, right, or center, and no others.   Templates do not always need options, since their default behavior is often enough.

 * DEFAULTS are the values used by a template when the user did not say.  Default values are specified in design, and they could apply to formats or to user text inputs.   For example, in the alignment example above, if the align option was not used, the template could  use left, provided that left had been specified in design as its default.   In the same way if the user forgets to type a text input, the template could use a pre-planned default input instead of the missing parameter; sometimes just a code to say something was forgotten.

 * PARAMETERS are usually bits of text that a user enters for a template to process.  For example, if a template makes text red, it still needs to know the text to color; this text is called a parameter, and the text is included by the user when the template is called for use.   Sometimes parameters contain text like code to insert an image, or even a gallery or a table; it just depends what the template is designed for.   A template can even be the parameter of another template; for example, a template to insert a test paragraph might occupy the parameter space of a template to make a text box.   The new paragraph would then appear in a new text box.

 * MORE GENERALLY, templates let us do much of the preparation in advance of making a page, and let us insert a block of typing, be it code to make tables, boxes, and other structures, or just a paragraph of text that is used a lot. The remainder of this introduction gives a  few examples to show what templates do on the page, and in the sections that follow will be found what is needed to modify and make new templates for use in writing Wikibooks.

In the first example, the template Caption is used. It has two text parameters and no options at all.

This is the code to call the template for use;

The result of doing so is to produce the text:

Notice that the template has formatted the text, and that each parameter was handled differently. This template is used to make consistently formatted image captions. The source code for the template Caption features little more than text formatting.

In the second example, the template Drop is used. It has one text parameter and several options, none of which are needed here.

This is the code to call the template for use;

The result of doing so can be seen in the paragraph below.

otice that the template has inserted a drop capital from the single character used as a parameter. This template can be used to start sections within certain body text. Again, the source code for the template Drop is largely text formatting.

The third example uses template Dropimage to make a drop-box with an image in it. This template has many options, but only two were needed; the width option, and the align option. The other options use the defaults. There are two parameters; the top caption Press to View and the contents, in this case the Wikitext code for an image. The contents in the example can be viewed by clicking the arrow on the box.

This is the code to call the template; The result of doing so is:

The template for this example consists of code to build the box structure, and the image code is strictly its parameter, i.e., the item that it processes.

Whereas the detailed study of this subject is complex, it should become clear that using and making templates like those mentioned above is well within the abilities of most wiki writers. Sadly, it is often the case that a writer sees the advantages of templates only when his work is nearly done, and a bit of effort in recognizing repetitive routine early in the work could save much time. Whenever a routine is repeated often, there is a job for a template.

It is true to say that most templates in the wiki family of projects consist of either the formatting of text paragraphs or the making of boxes of some kind. With this in mind the text below explains the process of template-making for text, boxes, and drop-controls. As preparation, those who intend to make box templates of any kind would benefit from an elementary knowledge of tables, and this knowledge is quickly available in the first few sections of the page Tables, where an introduction to CSS styles is also to be had.

Finding and Using Templates
There are already several thousands of templates within the WikiBooks templates namespace. That is another way of saying that the templates list is already long. At first sight, this may seem to avoid the need for template-making, but things are not so simple.

If the name of the template is known, then it can be found easily, but if the name is not known, it can take a long time to find a template similar to the one that you are looking for. Templates have their functions described on their own pages but many do not include notes, so the task of knowing which is which, and what they do even when they are found, becomes doubly difficult.

Templates made in Wikipedia and Wikibooks are not interchangeable, since they exist on separate servers. Although the code to make them is identical, this description applies to finding things in Wikibooks.

 * To view lists of templates listed alphabetically within WikiBooks, follow the link to the All Templates Namespace.
 * To find templates listed in various template categories, for example, drop-control templates, follow the link to the page Category:Templates.
 * If you know a template's name, then find the template page by using the search box on any Wiki page. For example, to find Dropimage just type;

then enter.

When a template page is found, the code to make the template can be seen by viewing its editing window. Many pages have their documentation on the same page as the template code, isolated from it with tags.

If after searching, you still need to make a template, as many no doubt do, then read on.

Put it on the Page
Templates are called for use in pages by typing a line of Wikitext, and so the user needs to know the correct spelling of the template's name, options, and parameters. Even when these are known it is all too easy to disrupt a page with a template error, especially during trials, so consider using the sandbox for testing. Some templates have all of the documentation and details on the same page and this makes them easy to use. See templates Plainlist, and  Codebits as examples.

To call up any template for use in a page, the code is typed within double curly brackets. – .    Included within the curly brackets is the template name, then, if required, a sequence of options, followed by a sequence of parameters. All entries are separated by pipe symbols. ( | ).  For example, the general form to use for a template with two options and one parameter is as follows:

and a typical example of its use is:

The above code has only one parameter; it is numbered 1 by default. Parameters are given numbers or names to identify them in their design code, and examples will be seen in the sections that follow. The template-call in the example uses a so-called unnamed parameter, because it is not preceded by a term like 1= (numbered parameter), or content= (typical named parameter). When templates have several parameters then the parameter numbers or names help to make clear to the template which is which. Alternatively, the template can manage with unnamed and unnumbered parameter entries provided that they are in any case listed in their correct number sequence. When in doubt, use names or numbers. At times, especially when the first character of a parameter is a symbol, the use of named or numbered parameters avoids the corruption that would otherwise result with the unnamed entry.

The sequence of options is unimportant, since all options must be named in any case. Using named values just means adding the name of the option and an equals sign before the option's value. This of course requires a knowledge of the template's details.

Template names are sensitive to case except for the first letter, so a useful convention is to use lower case for template name, parameters, and options all of the time; that way you will never be in doubt.

Parameter names are quite sensitive to case in every way, so a capital letter makes all the difference. As a general rule, do not mix unnamed and named parameters in a template call, since the method used by the program to interpret their meaning becomes confused. Either use all unnamed with special attention to their sequence, or all named in any order that you like.

Find Details from Code
Let us assume that a template made by others has been found but that its details are unclear. Even without much knowledge of mark-up, it is usually possible to discern the options and parameters of a template by inspection of its coding. To see how this can be done follow the reasoning below.

The coding and anything else on a template page can be displayed in the sandbox by typing a special code there. The template does not do anything when this is done; it just reveals the text of the template page. That is, it reveals the coding and any documentation. As an example the template code for say, the template Tocbox, can be viewed in the Sandbox by typing:

To save the reader the trouble of doing so here, the template code for Tocbox is given below.

Code for the Template Tocbox

The template page itself has a good description for its use, but assume for a moment that the descriptive material was absent. The code at the top of a template page is always the template source code; consider the example given above. Although it looks complicated, the object here is not to understand it, but to find the options and parameters from the code itself.

Note that the end of the code is marked with a tag, to make sure that any text that follows it is not used as a part of the template. In this example, there are two parameters; they can be recognized as the items with the form:

These entries identify parameters one and two respectively. It is clear, even without much understanding, that the first parameter is the heading text and the second parameter is the content text, and these terms in addition to the numbers could be used as their names. In the event that a user forgets to enter the parameter for say, content, a  will be displayed on the page as a reminder of what is missing.

All of the options within this template are recognized from the typical form;

This extract states that there is an option called align that has the default value of left. The idea of this default is that the value left would be used for align if the user does not use that option in the template call. The option could have almost any name; in fact it has been given the same name as the HTML attribute associated with it, (the part before the equals sign in the main code block). There are several properties within this code but only two of them have been coded as options; align and width, and both options have similar bracket formats to that of the above example.

With the options and parameters now understood, test the template on a page as follows:

This is the code:

The result is:

It should by now be clear that despite having no specification for the template in the first instance, it has been possible to obtain information from the coding for its use.

Modifying a Template
Assume for a moment that a template has been found that is nearly right, but not quite. Say for example that the background color was the only part that was wrong. The source code for such a template could be changed, by adding a term to modify its background color. Then, the modified version could be saved as a new template, with a different name. Note that if the modified template were saved with the same name as before, the existing users who depended on the original colors would experience unwelcome changes in their work.

There is another way that allows the new user to choose colors while the existing users can continue to enjoy the default colors that their work displays. The template can keep the old name if the background property is made into an option, and the original background color made its default. Then, since the old users would not bother to specify the background color, perhaps not even knowing that they now could, they would get the usual color as the default value and would be happy with it. The new users who need a different color, could simply specify it as an option value when they call the template for use. In this way both parties would be content.

The modifying of a template approaches the difficulty of making a new one at times, and this process is covered in other sections below. For the background-change case, a suitable modified Tocbox code module would look like this. The code is:

In the above code the background property has been made into an option. In addition, the original background color, #f9f9f9;, (light gray), has been used for the default. To labor the point, if the user does not bother to specify the background color, he will still get the gray color as before. Note again that the added option need not have been called background but could, for example, have been called bgc or some other name. In that event the template's option code would look like  background: , and another color would then be called using say,  bcg=papayawhip  on the page.

The real template Tocbox has not been modified here, though this example provides a reliable demonstration of the method to use for doing so. After the modification above the template could be called by the new users as follows:

A knowledge of CSS property values allows considerable variation in a template's appearance. Luckily, the subject is well documented. See the external W3 site's CSS Reference List for a comprehensive listing of values and properties. Although the examples on the referenced page are designed for style sheets, the syntax found there is also that used for modifying styles within templates and other in-line styles. In addition, a useful color reference can also be had at Web Colors. A drop-box with many of the CSS properties for tables has been provided in the box-making section below. If time is short it could be noted that most of the template work done so far in this project, (WikiBooks that is), could have made do with little more that the CSS properties of text and tables. Study of these two areas is thus rewarding.

CSS reference sources are useful, though styles can also be changed with HTML attributes, (the styles like align with the equals signs). Such attributes can be seen in HTML reference texts as opposed to CSS texts, and in the aforementioned drop-box below. It may be of interest to know that some HTML attributes are the only ways to accomplish certain tasks;  examples include colspan (to span table columns), rowspan (to span table rows), and align, (to align tables to center, something that the CSS float property cannot do).

Making Templates
There are many template types, but those used for inserting and modifying text are the most numerous. Boxes feature next; whether they are information boxes, so-called user boxes, or simple text boxes, they all have common constructs. Some templates have dynamic functions, like drop-controls, though once their basic outlines are clear, they can be shaped for many purposes. At least one example of each will be considered.

Template making consists of writing functional code, Wikitext or HTML, or sometimes a mixture of both. The method is to test the code in the Sandbox, until the function works well. Then the options and the parameters can be assigned to the code. These are tested again, and if all is well, the block of code can be saved as a template.

In saving the template it as well to check whether or not there is an existing template of that name already. The simplest way to save a template is as follows. First, make sure that you are logged-on in a page of WikiBooks, to avoid making a template in the wrong project. Go to the search box at the left of the WikiBooks page, and enter the wording to find the as-yet unmade template. Assume here that the intended name is to be Caption. The line to type in the search window is just:

If the template is found, then the name is already taken, and another is needed. Assuming that the name is not found, then the search results window will state that it was not found and ask whether or not you want to make the page. Click the link to make the page.

The link opens a template editing page with the name of the template already listed as its address. Copy the code from your work in the sandbox, then paste it into the empty template page. In the line immediately following the last line in the code block, add the tags  . All text not intended to be a part of the template code, must be placed between these tags, as is the case for the template's description.

Finally, save the page by pressing the Save page button at the bottom of the page. The template is now made, and can be called into use with its given name. Go to the sandbox and test the features of the template.

Text Paragraphs
The code for a template need not start with any special character or symbol. The main consideration is that the code performs the required action, just as if it were typed directly onto the page. At the 'end of the code block, be sure to add the   tags as mentioned above.

All of the existing Wikitext and HTML code that can be used in a page can be used for a text template. The user of a page does not have access to the parts associated with styles, namely the heading of the web page and their style sheets. As a result, users are limited to modifying the parts of the page that are available, the text within the body of the page. Those familiar with web page design will know that the only remaining available method is to modify the page's text with in-line styles. Working methods use the     tags and the      tags, thanks to a feature of Wikitext that allows the use of HTML coding within it. CSS, (Cascading Style Sheet), properties and values are used within these tags to modify the text styles that would otherwise apply.

It is as well to point out here the difference in use for  span  and  div  in text templates.  Span  should be used to format text only, noting that any formats applied to the text will not extend beyond the last text character;  div , on the other hand, will apply its formats to a rectangular block of text that extends across the page. the significance of this is that  div  is neater for changing background colors on the page. A comparative example can be seen in the Classes and Styles in Tags section of Class and Style Notes.

The Simplest Case
Before doing any formatting, consider the method for making a template from a simple block of text. Type a block of text, with all of its formats and page layout in place, then save the block as a template. It is as simple as that. Such blocks of text find use for test text, such as Lorem Ipsum, a well-known text block of fictitious content used by printers and others in laying out their work. To use such a template just type:

at any convenient place on a page to produce the text block. This block of text is not pre formatted with hard breaks, so it will wrap within the space where it is typed, and with the default text styles of the page.

Adding Styles
To modify text styles, for example, for the text This is the text, we first place the text within  tags, like this:

Then we construct a style statement within the first tag. This example makes the font Garamond, 20 points, colored red. It looks like this: and the result will be:

This is the text

Notice that there is still a closing arrow for the first tag; it is located at the end of the style statement.

Notice also that there are three style rules in the statement, separated by semi-colons; these are font-family:Garamond to set the face of the font, font-size:20pt to set the size of the font, and color:red to set the color of the text.

The style statement starts with the term style=, and the right hand side of the statement is entirely within double quotes.

The individual style rules consist of a property; the left part, and a value; the right part. The two parts are separated by a full colon. The format of a style statement is strict. If the format has an error within it then the whole statement could fail. Note that Wikitext could have been used on the text itself; for example, to produce italics, (double quotes), or text that is bold, (triple quotes). Wikitext acts in addition to the CSS styles, provided that there are no obvious conflicts. Several spans and style statements can be applied to produce quite complex results.

These tag sets can be nested; that is, one set of tags within another set. Beware of nested span tags, since there can be unexpected results. Say that an overall style is applied to several paragraphs using span tags. Within these paragraphs another span set is used to format one of the paragraphs differently. When this is viewed, at the point where the inside span closes, the styles will have reverted to the body text styles described by the style sheet, and not the intended outside style definition. This is perhaps because the first closing tag was wrongly interpreted as the end tag. The problem is avoided by using div tags for both, or at most by using span tags for only one of the formats.

Many properties exist to modify text. They consist of all of the text styles found in style sheets, namely those for fonts, padding, alignment, margins, borders, text colors, and backgrounds. CSS property lists and other material on Fonts and Text provide the source material for all such work. Although CSS properties and examples are listed primarily for style sheets, the properties and values themselves can be used on the page and in templates. The Study Work drop-box contains a useful code module for studying text properties. It contains most of the useful text entries and can be copied for study into the sandbox.

Parameters
Now, continue to make use of the red-text example. Although the code could be saved as a template just as it is, it would not be very useful since it consists only of fixed text. To introduce the notion of variable text chosen by the user, we need to make the text position in the code into a parameter.

Assuming that the basic code works correctly, the parameter brackets can be added. In the above text example there is only one parameter, the content to be formatted. Starting with the code above, just replace the text part so that the code line now looks like this: Notice that the original text has now been replaced with: The digit identifies the parameter as number one. It is also the name of the parameter. The word content is just a convenient label, though either the number or the label can be used for named parameters. If the user forgets to write any text in a parameter position, then the number of the parameter will appear on the page to remind of it. If the template had more than one parameter, a similar process could be applied, with a sequence of digits 2,3,4 etc., and adding a suitable label in place of content for each.

Saving it in the usual way completes such a template. Assuming that the template were to be saved with the name BigText then the entry to call it for use would be just:

Note that when a template has several parameters, the ones used can either be entered as named parameters, using the number or label with an equals sign, or as unnamed parameters, by omitting the added names and just entering the text directly. The parameters should be all unnamed or all named but not a mixture of the two. If they are unnamed, the correct sequence must be maintained, and if they are named, then any sequence can be used. Number names and label names can be mixed without difficulty in a template call.

Although virtually any tags can be modified by adding a style statement to the leading tag, it is not to say that the work can always be made into a template. There is at least one exception that exists when it comes to making such a template. The <pre></pre> tags by their very definition cause a template's parameter code to be disregarded, and a different approach is needed. Instead of attempting to make a modified pre-formatted text template consider the use of Prettypre for a ready-made fancy version of these tags.

That is to say, it is possible to modify the <pre></pre> tags with inline styles, to make more interesting pre-formatted text, and it is possible to add the tags to text used as a template's parameter, but making a template from text bounded by pre-formatting tags will prove more difficult.

Options
For completeness, we can also add options to our basic red-text template example. Say we want to change the color of the text from time to time in our work. We could make another complete template for the new color or we could just add an option to the text coloring code. The new code looks like this:

Note that the entire property value (applies also to an attribute value), must be enclosed in triple curly brackets. Additionally, the value should be replaced with an option name / default value combination. In this case, if the user does not specify the color of text, it will be red in any case. If it is specified, (see the example below), it can be changed to any color using the option tint= within the template call. Assuming that this template's name were BigText the template call for purple text would be, say:

Other options could be made in the same way, and similar techniques could be used regardless of the tags used for the template.

A knowledge of the different tags and access to lists of CSS properties allows considerable scope in template design.

Making Boxes
The following sections make box or table templates from Wikitext. They can also be made with HTML tables in the same way. When it comes to making such a template, wikitext is fine but when a table is needed to go into a template as its parameter, or part of its parameter, an HTML table should be used instead. The WikiBooks text Making Tables touches on HTML table structures, and explains how to use styles. It is assumed that the reader is familiar with these concepts in the text that follows.

The Box Structure
Boxes are essentially tables, in fact table cells. The CSS property list to format tables is extensive. Simple boxes make use of the table container, and one or two cells within it.

Apart from the table container, the other structures of a table include its rows, and cells. In the case below there are two rows, each with only one cell in them. Each part of a table has properties that affect it, and an example of typical table coding can be seen in the listing below.

Running this code in the sandbox produces the following:

If necessary, refer to the WikiBooks text Making Tables or the Wikipedia text Help-Table for detailed advice on making tables. Refer also to the drop-down box below for a listing of the commonly used table properties and their meanings.

For now, it will suffice to note only that:
 * A table is enclosed in these symbols:  {| |}
 * A caption placed above the table starts with a  |+ .
 * A heading cell within the table starts with a  !
 * A new row is created with the symbols:  |-
 * A data cell within a row is created with the symbol:  |
 * Style statements can exist at the table, row, or cell levels.
 * An additional pipe symbol separates a cell's styles from its text. |
 * Starting tables, rows and cells on new lines avoids many problems in templates.

Follow the reasoning in this description from the code.

The table container has background, width, margin, and border properties, and the align attribute assigned.
 * Background;sets the background color for the whole table.
 * Width; sets the overall width of the table.
 * Margin; removes margins of the table.
 * Border: Sets the thickness, type, and color of the table border, all in one.
 * Align: Permits the box to be placed on the page at left, right, or center.

The cell in the first row has text-align,padding, and a form of heading text.
 * Text-align;positions the cell text horizontally at the center.
 * Padding; sets the padding within the first cell for the box heading text.
 * The Heading Text; is made bold with Wiki mark-up.

The next row has text-align. This property applies style to all of the cells in the row at once, though not all properties can do this.
 * Text-align;justifies text in the bottom cell - the main content.

The content cell has padding, and the content text. Other properties could be specified for this text box, for example, for the details of the fonts to use, but there is enough here for this example.
 * Padding;sets the spacing around the content text.
 * The content text; is the main text for the box template.

Parameters and Options
It is intended to provide three options along with the two parameters. The options are to be background,width, and align. The parameter names are to be 1 and 2, with the labels heading and content.

The options and parameters have been added to the code below:

Parameters have been made in place of the heading and content text. The formats for parameters one and two are:

Each parameter format consists of a parameter label,( heading or content), a pipe, symbol, | , and the true name of the parameter, (1 or 2). In each case, both the parameter name and the entire parameter expression are enclosed in triple curly brackets.  { – } .

Options have been made for the properties background, width, and align. The formats are :

Notice that the format of the bracketing is similar to the examples given in the making of text templates, and that the same strict format is used to identify the options and parameters.

A parameter can use the option format too. When a parameter does so, it must use the named parameter style in the template call. The advantage of such a parameter is that it can have any default value, including an image. The disadvantage of using the option format for a parameter is that the highly conspicuous numbered reminder is lost. You will recall that the more formal parameter style gives a parameter number as the default.

The template can be saved in the usual way. Assuming that the template were saved with the name Textbox, then it could be called for use by typing the following: The variations in boxes are considerable. By adjusting the table structure, it is possible to add images and other effects. Most of the information boxes within Wikipedia and WikiBooks have a table basis for their construction.

Making Drop Controls
Drop-boxes save space on the page and can be used for both text and for images. Within Wikibooks these boxes are dynamic, and clicking the link on the heading of such a box drops it box to show the entire contents section. Clicking the link again restores it to its closed state.

Drop-boxes can be created in two ways. In the past, the way to make them was to use the classes NavFrame, NavHead, and NavContent. These days, the collapsible class can be used for both tables and div boxes, and its simplicity has made it a clear choice. The first section describes briefly the layout for collapsible divs. The remainder of the section is devoted to the version based on the collapsible table; this method is the basis of the ready-made drop-control template Dropimage.

A ready-made template exists for a quite adaptable drop-box; it is Dropimage, though for those who want the details, they are to be had at Sorting and Hiding.

Collapsible Boxes
The basic code for drop-boxes is just:

The above code produces a drop-box that is extended across the whole width of the page. collapsible contains the other two sections, title refers to the panel with the link, and body refers to the text box within the drop box itself.

By default, the contents are hidden when the page is loaded; that is to say, the box is closed when the page first opens. To have the contents shown by default, the user adds "selected" to the class declaration. CSS styles could also be added as shown below and the option-brackets and parameter-brackets for template-making have been shown, as was explained in the previous section:

Changes in layout is obtained by changing styles in any of the sections, but the preferred method, using collapsible tables, is described in the next section.

Collapsible Tables
(currently being rewritten to update for collapsible tables) The panel below shows the HTML and Wikitext code versions of a fairly basic drop-box based on the collapsible box class. The two versions are equivalent, though users who intend to make a template should use the HTML version, since it can have a table as its content without any instability. Nesting tables in Wikitext is problematic.

If, instead of the collapsed state, the selected state is needed on opening the page, then just add the class selected as in the line class="collapsible selected" . The default state is collapsed which need not be added.

The width style in the table line sets the initial width of the table on the page, and with the exception of un-formatted text, the table will expand on opening to accommodate the contents.

The float and align attributes should be avoided for tables because browsers may not support table alignment. Tables can be aligned in a way compatible with most browsers by setting the initial width of the table to 100%, and by wrapping the table inside a div box with its width set to the desired width. For left and right alignment use float on the div box. For center alignment use a margin of auto on the div.

Parameters and Options
The parameter and option brackets are shown in the panel below for an HTML version of the drop-box template, and it will be noted that the method is similar to that used for simple tables in an earlier section. It may be of interest to note that the outermost table is there simply to allow centering of the entire structure, since the collapsible class does not support it.

The above HTML block of code has been saved as the template dropthing, Dropthing, and it can be called for use on a page by typing something along the lines of the following:

The drop-box that is produced with this template call is this:

A more complex ready-made template called Dropimage exists for those who need it. It has a large set of individual options, and the facility to add more properties and classes, the coding for which is described next.

Advanced Options
Although the user is always limited by the original template's design, he has some latitude afforded by the pre-planned options. There is a way, however, that allows the user to add classes and CSS properties not considered in the original design. For this method to work the designer of the template must anticipate the possible future need for such a change, and add a few extra keystrokes. It is explained below.

Perhaps surprisingly, both class and style declarations are themselves HTML attributes, in the same way as align, cellpadding, and others. As such, these terms can be specified in the same way as other options, with default values of classes and styles. The user can then specify the list of styles or classes that he wants the template to use, or by doing nothing of the kind, the default values of each would apply. Clearly, if the usual values of an existing template were made to be such defaults, it would allow changes without affecting the original users. The example below allows the class selected to be used for a template whose original author uses only the class called collapsible.

Add Classes
To allow user-changes to the classes for the above drop-table template, the class declaration (expression) line needs to modified as follows:

This has the effect of making a new option named as class that has a default value of collapsible; that is, if no class option is written by the user the default will apply. Now, having modified the class-declaration, the user could add the class selected or any other suitable class with which he is familiar, (while others still make normal use of the template), as follows:

The box produced in this way is just:

The template, for this box only, will be displayed in its open state, since the class selected has been added as an option. Notice that the intended classes all need to be declared, and that the quotes were not needed. This entry entirely replaces the default class declaration. Similarly, other classes could be used, though the set of classes available for the automatic formatting of tables could do with some extension.

More Style Options
To modify the template to add user-written style expressions, the template's existing style expression in the table line would be replaced as follows:

Notice that the entire CSS style expression, (but not the attributes that followed it)), are now the default value of the mystyleT option.  When this option is used in a template call the quotes for the value expression should not be used.

The typical template call, introducing new properties might then become:

and the result of making this template call is just:

Notice that the intended new style statement must be rewritten in its entirety, and that now a new CSS property (color of text), not included in the original design, has been added within the option statement.

If the mystyleT option were not used, the individual options could still be used. If both the expression and the individual values are changed, it would be as well to study the possibility that one will override the other.

The template Dropimage has been modified to include user modification of class and style.

Endpiece
The three example types given in the above sections will hopefully introduce the reader to the making of templates. Bear in mind that there are many aspects of templates not discussed here; for example, the notions of conditional behavior, loops, and defaults that themselves run as templates. Further reading about templates can be found in the links below.

Above all, learn how to use CSS styles in making your templates, and experiment with their effects.

title: Editing Wikitext/Making Templates A101


text:
Parrot Virtual Machine/Built-In PMCs

Built-in PMCs
Parrot ships with a number of PMC data types built in. This means that these standard types are always available. This page is going to serve as a reference to these PMC types. We will not attempt to cover all the PMC types that are added specifically for other HLLs, libraries, or programs. (For information on using these PMC types, and on defining new PMC types, see the Parrot Virtual Machine/Polymorphic Containers (PMCs) chapter).

The entries in this list should (A) contain a link to the relevant PMC documentation, and (B) provide a brief overview of the PMC and it's methods.

AddrRegistry

 * http://docs.parrot.org/parrot/latest/html/src/pmc/addrregistry.pmc.html

Array

 * http://www.parrotcode.org/docs/pmc/pmc/array.html

A simple array class, serves as the base class for other array PMCs. This type of PMC is rarely used directly. Instead, more versatile array PMC types, such as ResizablePMCArray are used. Array specifies an interface that all other Array classes must share. It also provides a number of defaults that other array-like PMCs may default to.

BigInt

 * http://docs.parrot.org/parrot/latest/html/src/pmc/bignum.pmc.html

A PMC type for storing an arbitrarily large number, or a number with arbitrary precision. Not currently implemented.

Boolean

 * http://docs.parrot.org/parrot/latest/html/src/pmc/boolean.pmc.html

A boolean True/False PMC.

Bound_NCI

 * http://www.parrotcode.org/docs/pmc/pmc/bound_nci.html

Capture

 * http://docs.parrot.org/parrot/latest/html/src/pmc/capture.pmc.html

Closure

 * http://www.parrotcode.org/docs/pmc/pmc/closure.html

Compiler

 * http://www.parrotcode.org/docs/pmc/pmc/compiler.html

A Compiler PMC for a particular language. Can be used to convert an HLL into PIR and eventually into Parrot Bytecode.

Complex

 * http://www.parrotcode.org/docs/pmc/pmc/complex.html

A PMC for Complex numbers.

Continuation

 * http://www.parrotcode.org/docs/pmc/pmc/continuation.html

A Continuation PMC allows Parrot to take a snapshot of the current state of the system to return to later.

Coroutine

 * http://www.parrotcode.org/docs/pmc/pmc/coroutine.html

A sub-like PMC that implements a coroutine.

Default

 * http://www.parrotcode.org/docs/pmc/pmc/default.html

Deleg_PMC

 * http://www.parrotcode.org/docs/pmc/pmc/deleg_pmc.html

Delegate

 * http://www.parrotcode.org/docs/pmc/pmc/delegate .html

Enumerate

 * http://www.parrotcode.org/docs/pmc/pmc/enumerate.html

Env

 * http://www.parrotcode.org/docs/pmc/pmc/env.html

Allows access to the system's environment variables, as a hash.

Eval

 * http://www.parrotcode.org/docs/pmc/pmc/eval.html

Exception

 * http://www.parrotcode.org/docs/pmc/pmc/exception.html

An Exception PMC holds information about system errors for recovery.

Exception_Handler

 * http://www.parrotcode.org/docs/pmc/pmc/exception_handler.html

A sub-like routine that catches and resolves exceptions

Exporter

 * http://www.parrotcode.org/docs/pmc/pmc/exporter.html

File

 * http://docs.parrot.org/parrot/latest/html/src/dynpmc/file.pmc.html

A read/write interface for files

FixedBooleanArray

 * http://www.parrotcode.org/docs/pmc/pmc/fixedbooleanarray.html

An array of fixed size of Boolean values.

FixedFloatArray

 * http://www.parrotcode.org/docs/pmc/pmc/fixedfloatarray.html

An array of fixed size for FLOATVAL floating point numbers

FixedPMCArray

 * http://www.parrotcode.org/docs/pmc/pmc/fixedpmcarray.html

An array of fixed size for PMC values

FixedStringArray

 * http://www.parrotcode.org/docs/pmc/pmc/fixedstringarray.html

An array of fixed size for STRING values

Float

 * http://www.parrotcode.org/docs/pmc/pmc/float.html

A floating point number PMC. Used similarly to a FLOATVAL, except has methods and vtable methods. FLOATVALs become Float PMCs when they are promoted to become a PMC.

Hash

 * http://www.parrotcode.org/docs/pmc/pmc/hash.html

A hash, also known as a "dictionary" or an "associative array". Like an array but indexed with strings instead of integers

Integer

 * http://www.parrotcode.org/docs/pmc/pmc/integer.html

A basic integer number PMC. Used similarly to an INTVAL, but with methods and vtable methods. INTVALS become Integer PMCs when they are promoted to become a PMC.

IntList

 * http://www.parrotcode.org/docs/pmc/pmc/intlist.html

A simple list, or array, of integers.

Iterator

 * http://www.parrotcode.org/docs/pmc/pmc/iterator.html

An Iterator PMC provides a stateful counter that enables you to iterate over the items in one of the array classes, one at a time.

Key

 * http://www.parrotcode.org/docs/pmc/pmc/key.html

A value, typically a string, which is used to look up values in a hash.

LexInfo

 * http://www.parrotcode.org/docs/pmc/pmc/lexinfo.html

LexPad

 * http://www.parrotcode.org/docs/pmc/pmc/lexpad.html

ManagedStruct

 * http://www.parrotcode.org/docs/pmc/pmc/managedstruct.html

A low-level structure whose memory is allocated and automatically deallocated by Parrot. Extends UnManagedStruct, but adds automatic memory collection.

MultiArray

 * http://www.parrotcode.org/docs/pmc/pmc/multiarray.html

MultiSub

 * http://www.parrotcode.org/docs/pmc/pmc/multisub.html

A collection of subroutines with the same name. In Multiple Method Dispatch (MMD) the parameters of the function called determine which subroutine from the collection to call.

Namespace

 * http://www.parrotcode.org/docs/pmc/pmc/namespace.html

Implements a Parrot namespace. Contains information about variables, subroutines, coroutines, and MultiSubs that are stored in that namespace.

NCI

 * http://www.parrotcode.org/docs/pmc/pmc/nci.html

A native call function PMC. Stores interface information to a function which has been written in C.

Null

 * http://www.parrotcode.org/docs/pmc/pmc/null.html

A PMC with a NUL value

Object

 * http://www.parrotcode.org/docs/pmc/pmc/object.html

OrderedHash

 * http://www.parrotcode.org/docs/pmc/pmc/orderedhash.html

OS

 * http://www.parrotcode.org/docs/pmc/pmc/os.html

Pair

 * http://www.parrotcode.org/docs/pmc/pmc/pair.html

An association of a Key PMC with a PMC value. Hashes are typically implemented as an array of Pair PMCs

ParrotClass

 * http://www.parrotcode.org/docs/pmc/pmc/parrotclass.html

ParrotInterpreter

 * http://www.parrotcode.org/docs/pmc/pmc/parrotinterpreter.html

An interface to the interpreter structure.

ParrotIO

 * http://www.parrotcode.org/docs/pmc/pmc/parrotio.html

A read/write interface to the console

ParrotLibrary

 * http://www.parrotcode.org/docs/pmc/pmc/parrotlibrary.html

A dynamically-loaded library object.

ParrotObject

 * http://www.parrotcode.org/docs/pmc/pmc/parrotobject.html

ParrotRunningThread

 * http://www.parrotcode.org/docs/pmc/pmc/parrotrunningthread.html

ParrotThread

 * http://www.parrotcode.org/docs/pmc/pmc/parrotthread.html

A PMC that stores information about a thread

Pmethod_test

 * http://www.parrotcode.org/docs/pmc/pmc/pmethod_test.html

Pointer

 * http://www.parrotcode.org/docs/pmc/pmc/pointer.html

Random

 * http://www.parrotcode.org/docs/pmc/pmc/random.html

Ref

 * http://www.parrotcode.org/docs/pmc/pmc/ref.html

ResizableBooleanArray

 * http://www.parrotcode.org/docs/pmc/pmc/resizablebooleanarray.html

A resizable array to store Boolean values

ResizableFloatArray

 * http://www.parrotcode.org/docs/pmc/pmc/resizablefloatarray.html

A resizable array to store floating point values.

ResizableIntegerArray

 * http://www.parrotcode.org/docs/pmc/pmc/resizableintegerarray.html

A resizable array to store integer values

ResizablePMCArray

 * http://www.parrotcode.org/docs/pmc/pmc/resizablepmcarray.html

A resizable array to store PMC values

ResizableStringArray

 * http://www.parrotcode.org/docs/pmc/pmc/resizablestringarray.html

A resizable array to store Strings

RetContinuation

 * http://www.parrotcode.org/docs/pmc/pmc/retcontinuation.html

A return continuation. Like a regular Continuation PMC, but can only be used once. Can be promoted to a Continuation using the Clone vtable method.

Role

 * http://www.parrotcode.org/docs/pmc/pmc/role.html

An abstract role, or interface, for a class. Specifies actions and properties of a class, but cannot be instantiated

SArray

 * http://www.parrotcode.org/docs/pmc/pmc/sarray.html

SharedRef

 * http://www.parrotcode.org/docs/pmc/pmc/sharedref.html

Slice

 * http://www.parrotcode.org/docs/pmc/pmc/slice.html

SMOP_Attribute

 * http://www.parrotcode.org/docs/pmc/pmc/smop_attribute.html

SMOP_Class

 * http://www.parrotcode.org/docs/pmc/pmc/smop_class.html

STMLog

 * http://www.parrotcode.org/docs/pmc/pmc/stmlog.html

STMRef

 * http://www.parrotcode.org/docs/pmc/pmc/stmref.html

STMVar

 * http://www.parrotcode.org/docs/pmc/pmc/stmvar.html

String

 * http://www.parrotcode.org/docs/pmc/pmc/string.html

A PMC to contain a string value. Like a STRING value, but has methods and vtable methods. STRINGS become String PMCs when they are promoted to PMCs.

Sub

 * http://www.parrotcode.org/docs/pmc/pmc/sub.html

A Parrot subroutine. Implements a basic subroutine (using the sub command in PIR), but also serves as a base class for more intricate sub-like classes

Super

 * http://www.parrotcode.org/docs/pmc/pmc/super.html

A parent PMC class, to support multiple inheritance.

Timer

 * http://www.parrotcode.org/docs/pmc/pmc/timer.html

TQueue

 * http://www.parrotcode.org/docs/pmc/pmc/tqueue.html

Undef

 * http://www.parrotcode.org/docs/pmc/pmc/undef.html

An undefined PMC with no usable type.

UnamangedStruct

 * http://www.parrotcode.org/docs/pmc/pmc/unamangedstruct.html

A low-level structure which the programmer must manage manually. Parrot does not automatically collect memory allocated for the struct.

Version

 * http://www.parrotcode.org/docs/pmc/pmc/version.html

title: Parrot Virtual Machine/Built-In PMCs


text:
Ancient History/Iran

<<Return to Front Page
 * * Content in this section is copied from the Wikibook on Iranian History.

title: Ancient History/Iran


text:
Talk:Iranian History/Ancient pre-historic Iran

Mesopotamia
Is such a detailed discussion of Mesopotamia needed, in a textbook on Iran? Νεοπτόλεμος ( talk | email | contribs ) 16:47, 8 April 2008 (UTC)

Copyright infringement?
Certain sections seem to be the same as an article in Iran Review. (or Iran Daily) i.e.
 * First untitled paragraph.
 * Old Stone Age or Paleolithic Age (most of this section)
 * New Stone Age or Neolithic Age (first 2 paragraphs)
 * The Rise of Mesopotamia (whole section)
 * Uruk (whole section)
 * Early dynastic Sumer (whole section)
 * Akkad (whole section)
 * Mittani and the Hittites (first halves of paragraphs 1 & 3, all of para 2)
 * Assyria and Neo-Babylonia (whole section)
 * The Zayandeh-Rud Civilization (first 2 paragraphs)
 * Jiroft Civilization (first and last paragraphs)

(although from the date of the Iran Review article, Nov 2009, the copying may have been from Wikibooks.)

Recently added sections seem copied from various sites, i.e.

 * Atlantis Online dated March 15 2006
 * Jiroft (first para)

 * David Cortright dated January 2008.
 * Jiroft (2nd para)

 * Saudi Aramco World dated September/October 2004.
 * Jiroft (last para)

 * Science magazine dated 7th November 2003]
 * BRONZE AGE FIND (full text not available, but whole section is suspect)

Recent Runes (talk) 11:50, 12 June 2010 (UTC)


text: Template:User History

title: Template:User History


text: User talk:203.199.175.6

title: User talk:203.199.175.6


text:
Wikibooks:WikiProject History

Featured History Wikibooks

 * European History
 * New Zealand History
 * US History
 * Wikijunior:Kings and Queens of England

To do

 * Organize History bookshelf Yes check.svg Done
 * Organize Category:History Yes check.svg Done

Nuvola_apps_kuser.png Participants
This is a list of Wikibookians involved in Project. If you’re interested in helping, feel free to join by adding your name to the list below. If you wish, comment about your special interests on this project followed by your signature with or four titles ~. You can also show your interest in history by adding to your user page.
 * Νεοπτόλεμος ( talk | email | contribs ) 17:36, 8 April 2008 (UTC)
 * SunCreator (talk) 19:26, 8 April 2008 (UTC) - interested in learning and helping out with this project.
 * Ravichandar My coffee shop 15:00, 13 November 2008 (UTC)
 * LuinIthryn (discuss • contribs) 03:13, 4 February 2018 (UTC)

Categories

 * Category:Subject:History - parent category for all books on Subject:History. See also Category:Subject:History/all books.  The subject has replaced the old History bookshelf.
 * Category:Subject:History by continent - for books focusing on certain places, such as European History or New Zealand History.
 * Category:History by topic - for books focusing on certain topics, such as the History of Rail Transport.

Similar Projects
WikiProject History

title: Wikibooks:WikiProject History


text: Category:Wikibooks History participants

title: Category:Wikibooks History participants


text:
Talk:Ido/Lesson II3

Untitled
This page is to be the Lesson 3. Please do not delete.

title: Talk:Ido/Lesson II3


text: Category:Book:Canadian History

title: Category:Book:Canadian History


text: Category:Book:Confederate States Government


text: Category:Book:English History

title: Category:Book:English History


text: Category:Book:Ethiopian History

title: Category:Book:Ethiopian History


text: Category:Book:When It Hits the Fan

title: Category:Book:When It Hits the Fan


text: Category:Book:History of Embrun

title: Category:Book:History of Embrun


text: Category:Book:History of Literature

title: Category:Book:History of Literature


text: Category:Book:History of Technology

title: Category:Book:History of Technology