Evoke Glossary

Evoke is the software product, from BlueFinity, that you download to your PC and login to with personal user account details. Evoke is a rapid App development product that provide quick and easy, design and development of an app design, which can then be generated into a deployable mobile, desktop and/or web app that fully integrates and synchronises with existing back-end systems and databases.

Please review the basics of using Evoke to create powerful business apps
App Design
When using Evoke you create an App Design. When you use Evoke you can choose to either start a new app design or continue an existing App design. Evoke saves your app designs to a secure account area on Microsoft Azure and then uses the design to generate the code for your deployable web or native app.
Evoke apps fully integrate with your MultiValue or SQL databases. Evoke generates the app design into a full and complete Visual Studio and/or VS-Xamarin solution with all the respective projects and final app source code is delivered directly to your local computer. This allows you to either add some specific unique customisation if you wish OR simply build and deploy your app.
When you have used Evoke to create an App Design, you can use Evoke to Generate the App design into a deployable Native or Web app. Evoke generates the app design into a full and complete Visual Studio and/or VS-Xamarin solution with all the respective projects and all of the final app source code is delivered directly to your local computer. Your deployable app will either be, for Native apps, an executable file that is deployed to app stores or, for web apps, your web folder that is copied to a web server and accesed via a URL.
App Version
The App designs that you create with Evoke can have multiple versions, each autonomous. These can be duplicated from an existing App Version or created as new apps. You can maintain as many App Versions in your Evoke Account as you wish keeping test, live, development and other versions.
Repositories are the actual, physical, back end databases that will be accessed and used by your App. You can access (connect to) any flavour of SQL or MultiValue Database from your App and you can even have multiple databases accessed so that some tables/files can come from one database and some can come from another.
Repositories are defined by their ID, technology (e.g. SQL or MultiValue), Platform (specific flavour of SQL/MultiValue), the connection method (These may be via direct access, via stored procedures or through an intermediate API, it is entirely up to you.) and any specific connection string/security requirement.
Evoke Entities allow you to define and set up the data structure that you will use in the User Interface (UI) in your App. This is often a subset of the data structures in the databases that you use in your backend products/database.

In addition you can set up, in Entities, data structures that are local to your app and are not stored in your databases, create calculated properties, classifications (static and dynamic drop-down lists) and Selections that will populate data from your database into your app UI to be displayed, updated, deleted, added to and manipulated in other ways before being updated in your database repository. Entity structures can be automatically imported and exported to and from your database.
Properties are the Data Properties (fields) defined within an Entity. Each property many have a datatype of AlphaNumeric, Boolean, Currency, Date, DateTime, Decimal, ImagePath, Integer, Time, Classification, Entity. Some Properties may be UI usage only or calculated Properties.
Data Mappings
Data Mappings in Evoke link the Evoke Entities with the actual database data; providing the link between the Evoke UI entities and the actual Database file. In this section data positions in the actual database file are linked to Entity Properties and specific Selection parameters are included for any Evoke Selections.
Selections are the database selections used to identify specific records/Entities within a database file/table. Selections are the way you tell the database what specific sets of data/records you want read into Evoke for use in the UI or App. The selection may have filter arguments passed to it and is used within Evoke.
Static lists used to populate a field/property of a table in the Evoke UI. e.g. to provide a drop down selection of product names, standard responses to questions, etc
The Navigation Menu area within your Evoke app design is where you manage the menu that will be in your App. This is where you can add menu items, with different captions, to your menu structure that you originally designed in the Apps area. You can include images for different menu items, create sub-menus and a full menu hierarchy, create different security levels so different users see different menu items, change the order of your menus and link each menu item to a "Page Series" (functional area of your app). You can choose the default style of menu that app users will see when starting up the app on a desktop computer screen or when clicking the "hamburger" style menu on a mobile device. Options are a) Normal (the menu name, including icon image if present, in a list format) b) Tiled (the menu name, including icon image if present, in a traditional tile format) c) Minimal (just the menu icon image, without the menu name in words, in a narrow band until the user clicks the "peek" option in the running app which will then temporarily show the "normal" menu d) Unpinned (hidden) the menu is hidden and can be accessed via the "hamburger" icon in exactly the same way as it appears on a mobile device.
Page Series
A Page Series in Evoke is a logical area of your app. This is ususally defined by menu items in your app and is a group of Pages (app screens), including an indication of which is the entry page used when the menu item is clicked, that relate to each menu item defined in the app menu.
The individual screens (Pages) in the resulting app that are defined in your app design. Pages are grouped in a Page Series.
Data Sources are the areas in your app (app design) that are used by the User Interface of your app to hold (for display) and manipulate data items/recordsthat are selected from your database (repository).
DataSources are associated by you with each Page Series for use in the Pages within or a Global DataSources for use through the app.
Refined DataSource
Refined DataSources are a special type of DataSource that allows for advanced searching, sorting and filtering against any DataSource from within Evoke or by the App User. Refined DataSources are linked to a DataSource within each Page Series.
Used within a Data Source definition, a Collection within Evoke defines if a DataSource is multiple (a collection or series of records/information) or just a single record (instance/item) of a data structure/Entity.
Autosaved relates to the DataSources and indicates, as a Boolean value, if the DataSource is able to be saved back from the UI to the backend Repository or not.
Templates in Evoke are the way data/information is structured in the User Interface (UI). A Template is bound with a base Entity type and the properties of this entity may be selected to be part of the UI. There are also multiple "unbound data" properties that can be attached for elements such as buttons or statis text. Each Property of a template can have its own Widget and specific options. Examples of Template use can be found in the demo Apps. Templates also link to the Click Actions that can add powerful additional functionality to each App.
Click Actions
App actions, such as entering a Page for the first time, clicking on a button on a Page, selecting a piece of data, navigating to another part of the App, entering data, etc can all have Evoke click actions associated with them.
Evoke Click Actions are part of Evoke's internal Component Library and are powerful functional commands that can be processed during the normal running of your App. You can use a single Click Action or process multiple Click Actions based on a single event or click. Click Actions can also be accessed/run from Header actions, Navigation Click Actions, Page level Actions and other places through Evoke Apps
Click Actions are powerful functional code inserts that can be bound to Headers, Template Properties and various other App elements to include a series of actions, as required within the App. Please see the Click Actions List for a summary of the current Click Actions that are available.
Segments are the basic building block of the Page UI. Each App page is made up of Segments, which may be including within each other as child Segments and structured as rows of columns. Examples of Segments may be found in the demo Apps.
Widgets are the UI input/display/image control options that can be included within the App being built with Evoke. Used together with Templates, inside Segments, they are fundamental to the App functions. Please refer to the Widget definitions page for a list of all the Widgets available.
Each Segment can optionally have a Header, this is a title bar for each segment. If a header is chosen then Header Actions can be specified allowing standard Click Actions and additional standard actions such as new, delete, nudge, etc.
Adaptations automatically change the look, feel, actions and navigation route in an app based on the screen size of the device that the app is running.
When an app is running on a device (a phone, a desktop, a tablet, etc.) the app knows how much physical screen space is available to it. In devices like phones this will be the entire screen size but on desktops and some tablets it could be a portion of the screen size.
The Adaptations section in Evoke is the area that different display options/actions can be set to various information, Grid, Segments etc depending upon the screen size/device that the app is being used on. Please refer to the Adaptations page for more details of all the Adaptations available.
Widget ID
The Widget ID can be set for every Property in a Template, this identifier is then included in the generated Visual Studio code as a marker (Custom Code Hook) to link custom code onto.
A Datagrid, also referred to as a table, is the multi entity display area in the App UI that holds and displays a list of values e.g. for a list of products this could be the product name, product code, a description and the price. This information is shown on separate lines of the grid (table).
Navigation in Evoke is the area for setting up specific segment header, grid row or grid header navigation through standard app submenus e.g. an ellipsis or greater than sign. Examples may be found in the demo apps
Within Evoke, in front of Page names and Templates there is sometimes a link (multiple pages) symbol. This means the page or template is linked elsewhere in the App. A menu item on the ellipsis helps identify where the page or template is linked. A link means the page or template is used by another Page Series and is a direct copy of this page or template - any change in the original or linked template/page will change the template page in all linked instances of it.
The tooltip, associated with each Property of a Template, is used in conjunction with a cursor, usually a pointer. When a user hovers the pointer over an item in the App, without clicking it, then, if specified in an Evoke Template, a tooltip appears as a small "hover box" with information about the item being hovered over.
The Evoke Generator is the module that creates the Visual Studio or Xamarin Solution and associated projects. The Generator provides the association with a backend database and allows for the generation of the database CRUD layer.
Within Evoke, Web is the area for generating web apps. The generated Visual Studio/Xamarin solution is then used as a web app or combined with the Evoke AppRunner to create an evoke hybrid app.
Within Evoke, Native is the area for generating full native apps. The generated Visual Studio/Xamarin solution includes all the projects necessary to compile/build complete native apps for all platforms.
The Create Read Update Delete layer created by Evoke when an App is Generated. To generate a new standard CRUD entry for an Entity (such as a Selection) there is a Generate Entity CRUD tick box in the Entity Mappings section of the Generator. Two CRUD items are created per Entity/database file; a standard CRUD item with Create, Read, Update, delete functions and Selections generated from the information included in the App design, and a custom CRUD item that is not overwritten when new CRUD is generated. The custom CRUD allows a DBA to create and maintain advanced specific CRUD entries/selections.
The licensing terms of Evoke require that App Designers create a table/file within your database called "EVLU". Additional information regarding the EVLU file is available in Reserved Entities - EVLU section.