{
name = "Array",
- description = "A storage container allowing for dynamic resizing of allocated space at run time. The data type of the data stored in this container as a typecast at the time of declaration.",
- usage = "Initially declared in the declaration section of code. The resulting array of data is later accessed through the [] syntax: nameOfArray[arrayElement] = arbitraryValue.\n"
- "\n"
- "Be certain that when you instantiate an Array that you have a matching delete statement for it, otherwise potential memory leaks could become a problem.",
- example = "void Test()\n"
- "{\n"
- " Array<int> points { size = 10 };\n"
- " points[0] = { 10, 10 };\n"
- " points.size = 20;\n"
- " points[19] = { 5, 5 };\n"
- " delete points;\n"
- "}",
- remarks = "Similar to a C++ Vector. The Array class does come with inevitable overhead required for the purposes of dynamically allocating storage. So if it is not required to have dynamic allocation of storage, it would be recommended to use standard arrays: ie) int thisArray[10];",
+ description = "A dynamically resizable array template",
+ usage = "The array object can be indexed with the [ ] operator.<br><br>Elements of the array individually allocated on the heap are not freed unless Free() is invoked.<br><br>The array itself is must be instantiated and deleted as it is a ckass type.",
+ example = "void test()<br>{<br> Array points { size = 10 };<br> points[0] = { 10, 10 };<br> points.size = 20;<br> points[19] = { 5, 5 };<br> delete points;<br>}",
+ remarks = "The Array container class (like all containr classes) comes with some level of overhead, including an implied extra reference level and the overhead of multiple re-allocations. If dynamic reallocation is not required, stick to regular C arrays (e.g. int array[10]).",
also = "Container",
fields = [
{
"array",
{
- description = "The actual allocated storage for the Array."
+ description = "Pointer to the storage for the array"
}
},
{
"count",
{
- description = "The overall size of the Array."
- }
- },
- {
- "minAllocSize",
- {
- description = "The minimum amount of allocated storage for the Array before a reallocation would be necessary."
+ description = "The number of elements in the array. Setting this value does NOT allocat storage. Be careful setting this and using Add() on the same Array."
}
}
],
{
"minAllocSize",
{
- description = "The property to enable manual changes to the minAllocSize."
+ description = "Minimum number of elements for which storage is allocated in the array"
}
},
{
"size",
{
- description = "The property to enable manual changes to the size of the Array."
+ description = "Set this property to allocate storage for the array"
}
}
]
name = "Color",
description = "A 32 bit bit class representing Red, Green and Blue from 0..255, with Blue stored in LSB.",
usage = "Used in the declaration section of code.",
- example = "Color red = { r = 255 }; // High intensity red.\n"
+ example = "Color red = { r = 255 }; // High intensity red.<br>"
"Color yellow = { 0xFFFF00 }; // High intensity yellow. r = 0xFF(255), g = 0xFF(255), b = 0x00(0)",
also = "Color444, Color555, Color565, ColorAlpha, ColorCMYK, ColorHSV, ColorKey, ColorLab, ColorRGB, ColorRGBA, DefinedColor, PixelFormat, SystemColor",
fields = [
{
description = "The Grab method is used to copy pixel data from a given rectangular area in the current window display to a bitmap instance.",
usage = "Grab is typically called on the display property of a Window instance to grab the content of the window.",
- example = "void GrabWindowToBitmapFile(Window window, char * filePath, char * format)\n"
- "{\n"
- " Bitmap bitmap { };\n"
- " window.display.Grab(bitmap, 0, 0, window.size.w, window.size.h);\n"
- " bitmap.Save(filePath, format, null);\n"
- " delete bitmap;\n"
+ example = "void GrabWindowToBitmapFile(Window window, char * filePath, char * format)<br>"
+ "{<br>"
+ " Bitmap bitmap { };<br>"
+ " window.display.Grab(bitmap, 0, 0, window.size.w, window.size.h);<br>"
+ " bitmap.Save(filePath, format, null);<br>"
+ " delete bitmap;<br>"
"}",
remarks = "When no memory has been allocated in the bitmap instance to contain the pixel data, Grab will automatically allocate memory according to the size of the rectangular area being copied and to the pixel format of the display. When memory has been pre-allocated, Grab will use the bitmap if it satisfies the required size and pixel format. If the pre-allocated bitmap is not sufficient, Grab will enlarge the allocated memory and change the pixel format appropriately.",
also = "Bitmap::Save",
name = "Anchor",
description = "Defines the position of a Window/Control based on its top, left, bottom, right, middle horizontal, and middle vertical points relative to the parents client area, rather than just the top left corner.",
usage = "Specified as a property of a GUI element. Each individual property of the Anchor class can be set with an absolute value in pixels, or a relative value in percentages.",
- example = "Window { anchor = { right = 16, bottom = 32 } };// This sets the window to appear with its right side being 16 pixels from the right side of the Parents client area, and 32 pixels from the bottom.\n"
- "Window { anchor = { horz = 100, vert = 100 } };// This sets the window to appear with its center being 100 pixels from the left of the parents client area, and 100 pixels from the top.\n"
+ example = "Window { anchor = { right = 16, bottom = 32 } };// This sets the window to appear with its right side being 16 pixels from the right side of the Parents client area, and 32 pixels from the bottom.<br>"
+ "Window { anchor = { horz = 100, vert = 100 } };// This sets the window to appear with its center being 100 pixels from the left of the parents client area, and 100 pixels from the top.<br>"
"Window { anchor = { horz = 0.5, vert = 0.5 } }; // This sets the window to appear with it's center being at 50% of the parents client area width, and 50% of the client area height.",
remarks = "This is particularly useful if you want to ensure that a particular control remains a specific distance from any one side of its parent.",
also = "Window",
name = "Timer",
description = "A Timer object useful for performing actions based on a particular time delay.",
usage = "A Timer object is defined in the declaration section of code, with it's functionality being declared at initialization time.",
- example = "class Form1 : Window\n"
- "{\n"
- " Timer timer\n"
- " {\n"
- " this; // the Timer object belongs to the Form1 class.\n"
- " delay = 0.01; // the time to wait is 0.01 seconds.\n"
- " bool DelayExpired() // Override the virtual function to tell the Timer what to do.\n"
- " {\n"
- " Update(null); // redraw the entire window.\n"
- " return true; // tell the program that everything went ok.\n"
- " }\n"
- " }; // terminate the initialization of timer.\n"
+ example = "class Form1 : Window<br>"
+ "{<br>"
+ " Timer timer<br>"
+ " {<br>"
+ " this; // the Timer object belongs to the Form1 class.<br>"
+ " delay = 0.01; // the time to wait is 0.01 seconds.<br>"
+ " bool DelayExpired() // Override the virtual function to tell the Timer what to do.<br>"
+ " {<br>"
+ " Update(null); // redraw the entire window.<br>"
+ " return true; // tell the program that everything went ok.<br>"
+ " }<br>"
+ " }; // terminate the initialization of timer.<br>"
"}",
remarks = "This is an excellent, simple way to refresh the current window at particular intervals without requiring user input.",
also = "GetTime(), Time",
{
"clientSize",
{
- description = "Sets the size of the interior of the Window; the Client Area.\n"
+ description = "Sets the size of the interior of the Window; the Client Area.<br>"
"Example: clientSize = { 190, 290 };"
}
},
{
"foreground",
{
- description = "The Color of the text in the Client Area.\n"
+ description = "The Color of the text in the Client Area.<br>"
"Example: foreground = { r = 0, g = 0, b = 0 };"
}
},
{
"hotKey",
{
- description = "The key associated with a particular Window or Control. Pressing this key, or key combination will automatically activate the associated Window or Control.\n"
+ description = "The key associated with a particular Window or Control. Pressing this key, or key combination will automatically activate the associated Window or Control.<br>"
"Note: If the tabCycle property of the parent is not true, then hotKey will not work unless the parent is active."
}
},
{
"isDocument",
{
- description = "When true, this Window/Control would be treated as a document, enabling things like having the path show up in the Title Bar. \n"
+ description = "When true, this Window/Control would be treated as a document, enabling things like having the path show up in the Title Bar. <br>"
"Note: For best results, set this property true on a Window rather than on a Control."
}
},
{
"maxClientSize",
{
- description = "The Maximum allowable size for the Client Area within the window.\n"
+ description = "The Maximum allowable size for the Client Area within the window.<br>"
"Example: maxClientSize = { 120, 400 };"
}
},
{
"minClientSize",
{
- description = "The Minimum allowable size for the Client Area within the window.\n"
+ description = "The Minimum allowable size for the Client Area within the window.<br>"
"Example: minClientSize = { 50, 50 };"
}
},
{
"position",
{
- description = "The position of a Window/Control relative to the top left client area of the Parent. \n"
+ description = "The position of a Window/Control relative to the top left client area of the Parent. <br>"
"Example: position = { 10, 10 };"
}
},
{
"size",
{
- description = "Sets the size of the Window, including all the decorations.\n"
+ description = "Sets the size of the Window, including all the decorations.<br>"
"Example: size = { 200, 300 };"
}
},
{
"state",
{
- description = "Sets the state of the Window, either Normal, Minimized, or Maximized.\n"
+ description = "Sets the state of the Window, either Normal, Minimized, or Maximized.<br>"
"state = Normal;"
}
},
{
description = "Destroys the current Window/Control.",
usage = "Used in the statement section of the source code.",
- example = "Window\n"
- "{\n"
- " text = \"Destroy Example\";\n"
- " Button \n"
- " {\n"
+ example = "Window<br>"
+ "{<br>"
+ " text = \"Destroy Example\";<br>"
+ " Button <br>"
+ " {<br>"
" text = \"Destroy this Window!\";",
parameters = [
{
{
description = "This method is called anytime the Window is redrawn. Usually when it is resized or moved, however can also be called manually by calling Update() to redraw the contents of the window.",
usage = "Use this method by overriding it in your own code, within the Window class that it belongs to.",
- example = "class Form1 : Window\n"
- "{\n"
- " void OnRedraw(Surface surface)\n"
- " {\n"
- " surface.blit( image, xdest, ydest, sourceX, sourceY, sourceW, sourceH );\n"
- " }\n"
+ example = "class Form1 : Window<br>"
+ "{<br>"
+ " void OnRedraw(Surface surface)<br>"
+ " {<br>"
+ " surface.blit( image, xdest, ydest, sourceX, sourceY, sourceW, sourceH );<br>"
+ " }<br>"
"}",
remarks = "Typically this method is responsible for the actual drawing of all the graphics for your program.",
also = "OnApplyGraphics(), OnLoadGraphics(), OnResize(), OnResizing(), Update(), Window",
{
description = "Causes the OnRedraw() method of the Window to be called.",
usage = "Used in the statement section of the code.",
- example = "class Form1 : Window\n"
- "{\n"
- " Update( null ); // update the entire window\n"
- " Update( { 0, 0, 50, 50 } ); // update the region from 0 to 50 on the x axis, and 0 to 50 on the y axis.\n"
+ example = "class Form1 : Window<br>"
+ "{<br>"
+ " Update( null ); // update the entire window<br>"
+ " Update( { 0, 0, 50, 50 } ); // update the region from 0 to 50 on the x axis, and 0 to 50 on the y axis.<br>"
"} ",
remarks = "One should only update the necessary areas when possible, as updating the entire window indiscriminately can hog precious CPU cycles.",
also = "UpdateDisplay(), OnRedraw()",
{
"maxShown",
{
- description = "The number of items to show in the drop down list.\n"
+ description = "The number of items to show in the drop down list.<br>"
"Example: DropBox dropBox1 { this, maxShown = 2 };"
}
},
{
"rowHeight",
{
- description = "The height of each row of the drop down list. One item is listed per row.\n"
+ description = "The height of each row of the drop down list. One item is listed per row.<br>"
"Example: DropBox dropBox1 { this, rowHeight = 16 };"
}
},
{
"contents",
{
- description = "The contents of the Edit Box.\n"
+ description = "The contents of the Edit Box.<br>"
"Example: char * contentsOfEditBox = editBox1.contents;"
}
},
{
"maxLineSize",
{
- description = "The maximum number of characters that a line can hold.\n"
+ description = "The maximum number of characters that a line can hold.<br>"
"Example: maxLineSize = 30;"
}
},
{
"maxNumLines",
{
- description = "The maximum number of lines that the Edit Box contains.\n"
+ description = "The maximum number of lines that the Edit Box contains.<br>"
"Example: maxNumLines = 5;"
}
},
{
"textHorzScroll",
{
- description = "When true, the text will scroll to the left while it is being entered, so that the caret is always visible. This also enables the user to manually scroll left and right on the line using the left and right arrows.\n"
+ description = "When true, the text will scroll to the left while it is being entered, so that the caret is always visible. This also enables the user to manually scroll left and right on the line using the left and right arrows.<br>"
"When false, it is not possible to type past the width of the control."
}
},
{
"textVertScroll",
{
- description = "When true, the text can be scrolled vertically using the up and down arrows. For this to work, multiLine must also be true.\n"
+ description = "When true, the text can be scrolled vertically using the up and down arrows. For this to work, multiLine must also be true.<br>"
"When false, it is not possible to type past the bottom of the control."
}
},
{
description = "Loads a file into the EditBox.",
usage = "Used in the statements section of code. Once an instantiation of the EditBox control has been made, then Load() would be accessed through the . operator.",
- example = "File f = FileOpen(\"C:/fun.txt\", read);\n"
- "if(f)\n"
- "{\n"
- " myEditBox.Load(f);\n"
- " delete(f);\n"
+ example = "File f = FileOpen(\"C:/fun.txt\", read);<br>"
+ "if(f)<br>"
+ "{<br>"
+ " myEditBox.Load(f);<br>"
+ " delete(f);<br>"
"}",
parameters = [
{
{
name = "Label",
description = "Static text, used to provide information to the user.",
- usage = "Can be dragged from the toolbox directly to the source, or into the form editor.\n"
- "\n"
- "Otherwise, can be manually entered in to the statements section of code, in the definition of it's parent.\n"
- "\n"
- "Label inherits qualities defined in the Window class.\n"
- "\n"
- "All of Label's qualities can be defined in its instantiation. Note, that the first quality that should be set in the instantiation is the Parent. If this is not set, then Label is constructed as a free object rather than a child. This would result in Label not being closed when the program was closed. Most commonly the parent is the this object, as they are defined within the parent class.\n"
- "\n"
- "Some of the most commonly overridden qualities are:\n"
- " font: Specifies the font to be used for the Label, and it's properties.\n"
- " position: Specifies the top left corner of the Label in relation to the top left corner of the parent.\n"
- " size: Specifies the size of the Label and/or the GroupBox\n"
+ usage = "Can be dragged from the toolbox directly to the source, or into the form editor.<br>"
+ "<br>"
+ "Otherwise, can be manually entered in to the statements section of code, in the definition of it's parent.<br>"
+ "<br>"
+ "Label inherits qualities defined in the Window class.<br>"
+ "<br>"
+ "All of Label's qualities can be defined in its instantiation. Note, that the first quality that should be set in the instantiation is the Parent. If this is not set, then Label is constructed as a free object rather than a child. This would result in Label not being closed when the program was closed. Most commonly the parent is the this object, as they are defined within the parent class.<br>"
+ "<br>"
+ "Some of the most commonly overridden qualities are:<br>"
+ " font: Specifies the font to be used for the Label, and it's properties.<br>"
+ " position: Specifies the top left corner of the Label in relation to the top left corner of the parent.<br>"
+ " size: Specifies the size of the Label and/or the GroupBox<br>"
" text: Specifies the text to be seen on the Label.",
- example = "class Form1 : Window\n"
- "{\n"
- " Label label1 { this, text = \"This is a label\", position = { 10, 10 } };\n"
- " Label label2 { this, text = \"This is a bold label\", font = \"Tahoma\", 8.25f, bold = true, position = { 10, 40 } };\n"
- " Label test { this, text = \"This is a label!\", inactive = false, size = { 108, 44 }, position = { 56, 72 }, labeledWindow = editBox1, true };\n"
- " Label groupBox { this, text = \"This is a Group Box\", size = { 100, 100 }, isGroupBox = true };\n"
- "}\n"
+ example = "class Form1 : Window<br>"
+ "{<br>"
+ " Label label1 { this, text = \"This is a label\", position = { 10, 10 } };<br>"
+ " Label label2 { this, text = \"This is a bold label\", font = \"Tahoma\", 8.25f, bold = true, position = { 10, 40 } };<br>"
+ " Label test { this, text = \"This is a label!\", inactive = false, size = { 108, 44 }, position = { 56, 72 }, labeledWindow = editBox1, true };<br>"
+ " Label groupBox { this, text = \"This is a Group Box\", size = { 100, 100 }, isGroupBox = true };<br>"
+ "}<br>"
"Form1 form1 {};",
remarks = "Label is exempt from the usual tabCycle process, because it's inactive property is by default set to true. However, when isGroupBox is true, then inactive by default is set to false, since it would be desired to have the children of the GroupBox as part of the tabCycling.",
- also = "Label Properties from the Window class:\n"
- "Appearance: \n"
- "background, borderStyle, cursor, font, foreground, opacity, text.\n"
- "Behaviour:\n"
- "clickThrough, disabled, displayDriver, dontHideScroll, dontScrollHorz, dontScrollVert, hotKey, inactive, interim, isActiveClient, isDefault, isModal, isRemote, master, modifyVirtualArea, noCycle, scroll, scrollArea, snapHorzScroll, snapVertScroll, state, tabCycle, visible.\n"
- "Data:\n"
- "id\n"
- "Design:\n"
- "name\n"
- "Document:\n"
- "fileName, isDocument, modifiedDocument.\n"
- "Layout:\n"
- "anchor, clientSize, is3D, maxClientSize, minClientSize, nonClient, parent, position, size, sizeAnchor.\n"
- "Misc:\n"
- "alphaBlend, autoCreate, closing, creationActivation, fullRender, icon, moveable, useSharedMemory.\n"
- "Window Style:\n"
- "drawBehind, hasClose, hasHorzScroll, hasMaximize, hasMenuBar, hasMinimize, hasStatusBar, hasVertScroll, menu, mergeMenus, showInTaskBar, stayOnTop\n"
+ also = "Label Properties from the Window class:<br>"
+ "Appearance: <br>"
+ "background, borderStyle, cursor, font, foreground, opacity, text.<br>"
+ "Behaviour:<br>"
+ "clickThrough, disabled, displayDriver, dontHideScroll, dontScrollHorz, dontScrollVert, hotKey, inactive, interim, isActiveClient, isDefault, isModal, isRemote, master, modifyVirtualArea, noCycle, scroll, scrollArea, snapHorzScroll, snapVertScroll, state, tabCycle, visible.<br>"
+ "Data:<br>"
+ "id<br>"
+ "Design:<br>"
+ "name<br>"
+ "Document:<br>"
+ "fileName, isDocument, modifiedDocument.<br>"
+ "Layout:<br>"
+ "anchor, clientSize, is3D, maxClientSize, minClientSize, nonClient, parent, position, size, sizeAnchor.<br>"
+ "Misc:<br>"
+ "alphaBlend, autoCreate, closing, creationActivation, fullRender, icon, moveable, useSharedMemory.<br>"
+ "Window Style:<br>"
+ "drawBehind, hasClose, hasHorzScroll, hasMaximize, hasMenuBar, hasMinimize, hasStatusBar, hasVertScroll, menu, mergeMenus, showInTaskBar, stayOnTop<br>"
"",
properties = [
{
{
"labeledWindow",
{
- description = "Enables the Label to be attached to another control of Window class, or derived from the Window class, as a \"Window Label.\" \n"
+ description = "Enables the Label to be attached to another control of Window class, or derived from the Window class, as a \"Window Label.\" <br>"
"*Developer Note: Currently, there is a bug which prevents this from working properly in the Form Editor, however it can be coded directly into the source."
}
}
{
description = "Returns a random integer from lo to hi inclusive.",
usage = "Returns a random integer, based on the Random Seed. If no Random Seed is set with RandomSeed(), then GetRandom() returns lo.",
- example = " int Rand;\n"
- " RandomSeed((uint)(GetTime() * 1000));\n"
- " Rand = GetRandom(1, 10);\n"
- " printf(\"%d\\n\", Rand); ",
+ example = " int Rand;<br>"
+ " RandomSeed((uint)(GetTime() * 1000));<br>"
+ " Rand = GetRandom(1, 10);<br>"
+ " printf(\"%d\<br>\", Rand); ",
also = "GetTime(), RandomSeed()"
}
},
"GetTime",
{
description = "Returns the current system time as a Time object.",
- example = " int Rand;\n"
- " RandomSeed((uint)(GetTime() * 1000));\n"
- " Rand = GetRandom(1, 10);\n"
- " printf(\"%d\\n\", Rand); ",
+ example = " int Rand;<br>"
+ " RandomSeed((uint)(GetTime() * 1000));<br>"
+ " Rand = GetRandom(1, 10);<br>"
+ " printf(\"%d\<br>\", Rand); ",
also = "RandomSeed()"
}
},
{
description = "This method seeds the random number generator.",
usage = "This method needs to be called before any call to GetRandom(), otherwise GetRandom will not retrieve a random number. The seed can be any unsigned integer, however any constant value will produce predictable results each time. For closer to true results, try using GetTime() as the seed.",
- example = " int Rand;\n"
- " RandomSeed((uint)(GetTime() * 1000));\n"
- " Rand = GetRandom(1, 10);\n"
- " printf(\"%d\\n\", Rand); ",
+ example = " int Rand;<br>"
+ " RandomSeed((uint)(GetTime() * 1000));<br>"
+ " Rand = GetRandom(1, 10);<br>"
+ " printf(\"%d\<br>\", Rand); ",
also = "GetRandom(), GetTime()"
}
}
name = "bool",
description = "Boolean value (true or false) stored as a 32 bit unsigned integer",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "bool thisBool; // A stand alone declaration of a bool.\n"
- "bool a, b; // Declaring two bools at the same time.\n"
+ example = "bool thisBool; // A stand alone declaration of a bool.<br>"
+ "bool a, b; // Declaring two bools at the same time.<br>"
"bool c = true, d = false; // Declaring two bools, and initializing them both at the same time.",
- remarks = "A bool type describes a boolean type variable and can only store a true or false value.\n"
- "\n"
+ remarks = "A bool type describes a boolean type variable and can only store a true or false value.<br>"
+ "<br>"
"bool is equivalent to a bool in C.",
also = "byte, char, char *, double, enum, float, int, int64, uint, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()",
values = [
name = "byte",
description = "An unsigned integer data type representing a single byte of data (equivalent to C 'unsigned char' and expected to be equivalent to C99 'uint8_t'). A byte can range from 0 to 255. Often used to allocate and address memory.",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "byte a = 3; // binary form: 00000011\n"
- "byte b = 6; // binary form: 00000110\n"
- "byte c;\n"
- "c = a & b; // c will be 2 (00000010)\n"
- "c = a | b; // c will be 7 (00000111)\n"
- "c = a ^ b; // c will be 5 (00000101)\n"
+ example = "byte a = 3; // binary form: 00000011<br>"
+ "byte b = 6; // binary form: 00000110<br>"
+ "byte c;<br>"
+ "c = a & b; // c will be 2 (00000010)<br>"
+ "c = a | b; // c will be 7 (00000111)<br>"
+ "c = a ^ b; // c will be 5 (00000101)<br>"
"c = ~b; // c will be 249(11111001)",
- remarks = "Unlike other languages the byte data type is actually a class.\n"
- "\n"
+ remarks = "Unlike other languages the byte data type is actually a class.<br>"
+ "<br>"
"byte is equivalent to an unsigned char in C.",
also = "bool, char, char *, double, enum, float, int, int64, uint, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
{
name = "char *",
description = "Core C 'char *' data type, mostly equivalent to the String data type. Ecere APIs taking a String or char * representing text expect UTF-8 encoding.",
- usage = "Used in the declaration section of code, which is before any statements. \n"
- "\n"
- "A variable declared as being a char * can be assigned any literal string which is enclosed between double quotation marks (\" \").\n"
- "\n"
+ usage = "Used in the declaration section of code, which is before any statements. <br>"
+ "<br>"
+ "A variable declared as being a char * can be assigned any literal string which is enclosed between double quotation marks (\" \").<br>"
+ "<br>"
"A key thing to remember is that the * is attached to the name of the variable, not the type.",
- example = "char * thisString; // A stand alone declaration of a char *.\n"
- "char * aString, * bString; // Declaring two char *s at the same time.\n"
- "char * cString = \"Hello\", char * dString = \"World\"; // Declaring and initializing two chars and initializing them at the same time.\n"
- "________________________________________\n"
- "\n"
- "class Hello : Application\n"
- "{\n"
- " void Main()\n"
- " {\n"
- " char * helloString = \"Hello, World!\";\n"
- " printf(\"%s\\n\", helloString);\n"
- " }\n"
- "}\n"
- "\n"
- "\n"
- "\n"
- "Output:\n"
+ example = "char * thisString; // A stand alone declaration of a char *.<br>"
+ "char * aString, * bString; // Declaring two char *s at the same time.<br>"
+ "char * cString = \"Hello\", char * dString = \"World\"; // Declaring and initializing two chars and initializing them at the same time.<br>"
+ "________________________________________<br>"
+ "<br>"
+ "class Hello : Application<br>"
+ "{<br>"
+ " void Main()<br>"
+ " {<br>"
+ " char * helloString = \"Hello, World!\";<br>"
+ " printf(\"%s\<br>\", helloString);<br>"
+ " }<br>"
+ "}<br>"
+ "<br>"
+ "<br>"
+ "<br>"
+ "Output:<br>"
"Hello, World!",
remarks = "char * is equivalent to char * in C.",
also = "bool, byte, char, double, enum, float, int, int64, uint, uint16, uint32, uint64"
{
name = "char",
description = "Core C data type representing a single ASCII character (equivalent to C 'char' and expected to be signed and occupy 8 bits / 1 byte). A signed char can range from -127 to 127. On some platforms -128 is a valid value.",
- usage = "Used in the declaration section of code, which is before any statements.\n"
- "\n"
+ usage = "Used in the declaration section of code, which is before any statements.<br>"
+ "<br>"
"A variable declared as being a char can be assigned any single character enclosed between two single quotes (' '), or an integer which is then translated to the ASCII character corresponding to that value, at output.",
- example = "char thisChar; // A stand alone declaration of a char.\n"
- "char a, b; // Declaring two chars at the same time.\n"
+ example = "char thisChar; // A stand alone declaration of a char.<br>"
+ "char a, b; // Declaring two chars at the same time.<br>"
"char c = 'a', d = 98; // Declaring two chars and initializing them at the same time. The 98 is the same as 'b'.",
- remarks = "Technically, this is an integer data type. Unlike other languages, the char data type is actually a class.\n"
- "\n"
+ remarks = "Technically, this is an integer data type. Unlike other languages, the char data type is actually a class.<br>"
+ "<br>"
"char is equivalent to a char in C.",
also = "bool, byte, char *, double, enum, float, int, int64, uint, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
name = "double",
description = "Core C double precision floating-point real number data type. A double ranges from 2.2250738585072014e-308 to 1.7976931348623158e+308.",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "double aDouble; // A stand alone declaration of a double.\n"
- "double a, b; // Declaring two doubles at the same time.\n"
+ example = "double aDouble; // A stand alone declaration of a double.<br>"
+ "double a, b; // Declaring two doubles at the same time.<br>"
"double c = 12.1234567899; // Declaring and initializing a double at the same time.",
- remarks = "Unlike other languages, the double data type is actually a class.\n"
- "\n"
+ remarks = "Unlike other languages, the double data type is actually a class.<br>"
+ "<br>"
"double is equivalent to a double in C.",
also = "bool, byte, char, char *, enum, float, int, int64, uint, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
name = "float",
description = "Core C single precision floating-point real number data type. A float ranges from 1.17549435082228750e-38 to 3.40282346638528860e+38.",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "float aFloat; // A stand alone declaration of a float.\n"
- "float a, b; // Declaring two floats at the same time.\n"
+ example = "float aFloat; // A stand alone declaration of a float.<br>"
+ "float a, b; // Declaring two floats at the same time.<br>"
"float c = 12.123456; // Declaring and initializing a float at the same time.",
- remarks = "Unlike other languages, the float data type is actually a class.\n"
- "\n"
+ remarks = "Unlike other languages, the float data type is actually a class.<br>"
+ "<br>"
"float is equivalent to a float in C.",
also = "bool, byte, char, char *, double, enum, int, int64, uint, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
name = "int",
description = "Core C signed integer data type (expected to be equivalent to C99 'int32_t'). A signed 32 bit integer ranges from (-2,147,483,647 to 2,147,483,647. One some platform a negative value one less is valid.",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "int thisInt; // A stand alone declaration of an int.\n"
- "int a, b; // Declaring two ints at the same time.\n"
- "int c = 64000, d = -10; // Declaring two ints, and initializing them both at the same time.\n"
+ example = "int thisInt; // A stand alone declaration of an int.<br>"
+ "int a, b; // Declaring two ints at the same time.<br>"
+ "int c = 64000, d = -10; // Declaring two ints, and initializing them both at the same time.<br>"
"int anotherInt = 0x54DA; //Declaring and initializing an int with a hexadecimal value.",
- remarks = "Unlike C or C++ where the int memory space can be either 16 or 32 bits depending on the platform, the eC int is guaranteed to be 32 bits on all platforms. Additionally, unlike other languages the int data type is actually a class.\n"
- "\n"
+ remarks = "Unlike C or C++ where the int memory space can be either 16 or 32 bits depending on the platform, the eC int is guaranteed to be 32 bits on all platforms. Additionally, unlike other languages the int data type is actually a class.<br>"
+ "<br>"
"int is otherwise equivalent to an int in C.",
also = "bool, byte, char, char *, double, enum, float, int64, uint, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
name = "int64",
description = "64 bit signed integer data type (equivalent of C99 'int64_t'). A 64 bit signed integer can range from - 2^63-1 to 2^63-1 (-9,223,372,036,854,775,807 to 9,223,372,036,854,775,807). On some platform a negative value on less is valid.",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "int64 thisInt; // A stand alone declaration of an int64.\n"
- "int64 a, b; // Declaring two int64s at the same time.\n"
- "int64 c = 4294967296, d = -300; // Declaring two int64s, and initializing them both at the same time.\n"
+ example = "int64 thisInt; // A stand alone declaration of an int64.<br>"
+ "int64 a, b; // Declaring two int64s at the same time.<br>"
+ "int64 c = 4294967296, d = -300; // Declaring two int64s, and initializing them both at the same time.<br>"
"int64 anotherInt = 040000000000; // Declaring and initializing an int64 with an octal value.",
- remarks = "Unlike other languages, the int64 data type is actually a class..\n"
- "\n"
+ remarks = "Unlike other languages, the int64 data type is actually a class..<br>"
+ "<br>"
"int64 is equivalent to a long long in C.",
also = "bool, byte, char, char *, double, enum, int, uint, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
name = "uint",
description = "Unsigned integer data type (expected to be equivalent to C99 'uint32_t'). A 32 bit unsigned itger can range from 0 to 0xFFFFFFFF (4,294,967,295).",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "uint aUint; // A stand alone declaration of a uint.\n"
- "uint a, b; // Declaring two uints at the same time.\n"
+ example = "uint aUint; // A stand alone declaration of a uint.<br>"
+ "uint a, b; // Declaring two uints at the same time.<br>"
"uint c = 64000, d = 10; // Declaring two uints, and initializing them both at the same time.",
- remarks = "Unlike other languages the uint data type is actually a class.\n"
- "\n"
+ remarks = "Unlike other languages the uint data type is actually a class.<br>"
+ "<br>"
"uint is equivalent to an unsigned int in C.",
also = "bool, byte, char, char *, double, enum, float, int, int64, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
name = "uint16",
description = "16 bit unsigned integer data type (equivalent of C99 'uint16_t'). A 16 bit unsigned integer can range from 0 to 0xFFFF (65,535).",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "uint16 aUint16; // A standalone declaration of a uint16\n"
- "uint16 a, b; // Declaring two uint16s at the same time.\n"
- "uint16 c = 64000, d = 10; // Declaring two unit16s, and initializing them both at the same time.\n"
+ example = "uint16 aUint16; // A standalone declaration of a uint16<br>"
+ "uint16 a, b; // Declaring two uint16s at the same time.<br>"
+ "uint16 c = 64000, d = 10; // Declaring two unit16s, and initializing them both at the same time.<br>"
"uint16 hexNumber = 0x1C42; // Declaring a uint16, and initializing it with the hex value 7,234.",
- remarks = "Unlike other languages the uint16 data type is actually a class.\n"
- "\n"
+ remarks = "Unlike other languages the uint16 data type is actually a class.<br>"
+ "<br>"
"uint16 is equivalent to an unsigned short in C.",
also = "bool, byte, char, char *, double, enum, int, int64, uint, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
name = "uint32",
description = "32 bit unsigned integer data type (equivalent of C99 'uint32_t'). A 32 bit unsigned integer can range from 0 to 0xFFFFFFFF (4,294,967,295).",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "uint32 aUint32; // A stand alone declaration of a uint32.\n"
- "uint32 a, b; // Declaring two uint32s at the same time.\n"
+ example = "uint32 aUint32; // A stand alone declaration of a uint32.<br>"
+ "uint32 a, b; // Declaring two uint32s at the same time.<br>"
"uint32 c = 64000, d = 10; // Declaring two uint32s, and initializing them both at the same time.",
- remarks = "Unlike other languages the uint32 data type is actually a class.\n"
- "\n"
+ remarks = "Unlike other languages the uint32 data type is actually a class.<br>"
+ "<br>"
"uint32 is equivalent to an unsigned int in C.",
also = "bool, byte, char, char *, double, enum, float, int, int64, uint16, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
name = "uint64",
description = "64 bit unsigned integer data type (equivalent of C99 'uint64_t'). A 64 bit unsigned integer can range from 0 to 0xFFFFFFFFFFFFFFFF (18,446,744,073,709,551,615).",
usage = "Used in the declaration section of code, which is before any statements.",
- example = "uint64 aUint64; // A stand alone declaration of a uint64.\n"
- "uint64 a, b; // Declaring two uint64s at the same time.\n"
+ example = "uint64 aUint64; // A stand alone declaration of a uint64.<br>"
+ "uint64 a, b; // Declaring two uint64s at the same time.<br>"
"uint64 c = 64000, d = 10; // Declaring two uint64s, and initializing them both at the same time.",
- remarks = "Unlike other languages, the uint64 data type is actually a class.\n"
- "\n"
+ remarks = "Unlike other languages, the uint64 data type is actually a class.<br>"
+ "<br>"
"uint64 is equivalent to an unsigned long long in C.",
also = "bool, byte, char, char *, double, enum, float, int, int64, uint16, uint32, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
{
name = "unsigned int",
description = "Core C unsigned integer data type (expected to be equivalent to C99 'uint32_t'). A 32 bit unsigned intger can range from 0 to 0xFFFFFFFF (4,294,967,295).",
- usage = "Used in the declaration section of code, which is before any statements.\n"
- "\n"
+ usage = "Used in the declaration section of code, which is before any statements.<br>"
+ "<br>"
"Declared as a standard int, but with the unsigned keyword in front to denote an unsigned integer value.",
- example = "unsigned int aUint; // A stand alone declaration of an unsigned int.\n"
- "unsigned int a, b; // Declaring two unsigned ints at the same time.\n"
+ example = "unsigned int aUint; // A stand alone declaration of an unsigned int.<br>"
+ "unsigned int a, b; // Declaring two unsigned ints at the same time.<br>"
"unsigned int c = 64000, d = 10; // Declaring two unsigned ints, and initializing them both at the same time.",
- remarks = "Unlike other languages the unsigned int data type is actually a class.\n"
- "\n"
+ remarks = "Unlike other languages the unsigned int data type is actually a class.<br>"
+ "<br>"
"unsigned int is equivalent to an unsigned int in C, and is in fact only part of eC to maintain backwards compatibility with C. In all ways, the unsigned int is also equivalent to the shorter and preferred uint syntax.",
also = "bool, byte, char, char *, double, enum, float, int, int64, uint, uint16, uint32, uint64, OnCompare(), OnCopy(), OnDisplay(), OnEdit(), OnFree(), OnGetDataFromString(), OnGetString(), OnSaveEdit(), OnSerialize(), OnUnserialize()"
}
Ecere Software / sdk / commitdiff