Class
HSWidgetCombinedAdditionalOptionsAndPreferencesViewController
A combined additional options and preference list controller that can be shared for additional options and settings accessory.
Declaration
@interface HSWidgetCombinedAdditionalOptionsAndPreferencesViewController : HSWidgetPreferencesListController <HSWidgetAdditionalOptions>
Description
The class Inherits from HSWidgetPreferencesListController so we can take advantage of all of the benefits provided by the preferences framework (specifiers, list controllers, etc). it also conforms to HSWidgetAdditionalOptions so we can use it for both additional options and settings accessory.
Topics
Add Widget
-
- addWidget
Add widget configured during additional options view to the page.
Cancel Addition
-
- cancelAdditionalOptions
Cancel widget addition, dismissing add widget view.
Checking Space Availability
-
- containsSpaceForGridPositions:
Return whether there is enough space available for grid positions.
-
- containsSpaceForWidgetSize:
Return whether there is enough space available for widget of specified size.
Related Links
Preference List Controller
-
HSWidgetPreferencesListController
A preference list controller subclass for easily managing/applying widget preferences.


To make working with databases easier, and to ensure a consistent set of tools when saving and moving data, Mojo uses models to define validation and data structures, and then uses these to set up how data will look in the database.
Currently, Mojo only supports MongoDB, but we are hoping to add support for Redis and CouchDB soon. We actively encourage contributors, so anyone feeling the urge to help us write a new backend for their favourite datastore can drop us a line in our Google Group.
For anyone familiar with Django, Mojo Models will seem very similar, and take heavy influence from the framework. Models are a way for you to organise and structure your data as python objects so you can transparently use them (without a data store) in your application.
Models are very simple - they are a defined class, with a series of fields that you can use to represent your data and the various validation methods you would like run against those fields before the object is written to the database.
Because our first database to support was MongoDB, it became apparent that what was really missing was a good way to enforce structure and a certain degree of validation on stored data. Being Schema-less, it becomes very easy to not validate stored input due to the extra burden of writing the validation code, as well as not manging schema evolutions as schemas change over the lifecycle of your project.
Models make this process easiewr by pre-defining data types, relations and object properties prior to saving, while exposing all the benefits of having a neat python object to represent your data set without resporting to direct database access.
Not at all, you can completely ignore the ORM and model structure in your project and directly access your database using your favourite driver.
To implement a model for your app, simply define it in the models.py file in your app directory:
from Mojo.ObjectMapper.ModelPrototype import Model
from Mojo.ObjectMapper.Fields import *
import datetime
#This is a non-database class, not stored in the DB but embedded in the BlogPost class below
#the key difference is the lack of an _id field
class Tag(Model):
tag_name = StringField()
#a simple model to hold blog posts
class BlogPost(Model):
_id = ObjectIDField()
title = StringField(allow_empty=False)
slug = StringField(allow_empty=False)
post_intro = StringField()
post_body = StringField()
date_published = DateTimeField(default=datetime.datetime.now())
tags = ListField(of=Tag)
visible = BooleanField(default=True)
In the above example we’ve defined two models, the first Tag model is a straightforward class that is not a database object the key distinction here is the lack of the _id field (this is only relevant to the MongoDB backend as it requires an ID to be explicitly defined).
The second model BlogPost is the real model, and lists a series of fields to represent data types, fields can be anything, so long as they subclass the Mojo.ObjectMapper.FieldPrototype.Field object.
You can access the above model quite easily in your code:
new_minimal_post = BlogPost({
'title':u'a new post',
'slug' : 'newpost'
})
#access some properties
print new_minimal_post.title
> a new post
#save it (assuming synchronous DB backend):
thispost = new_minimal_post.save()
print thispost._id
> 50571e5f3d941cdc4487bdf1
Models can be assigned data in dictionary format as part of their initialisation, or empty and then using dot-notation for each of their properties. So, in the example above, the following would work just as well:
new_minimal_post = BlogPost()
new_minimal_post.title = u'a new post'
new_minimal_post.slug = 'newpost'
#access some properties
print new_minimal_post.title
> a new post
#save it (assuming synchronous DB backend):
thispost = new_minimal_post.save()
print thispost._id
> 50571e5f3d941cdc4487bdf1
Model objects are dictionaries, so if you print out or access them in any way, they should behave in the same way as a stamdard python dict object.
Saving is very straightforward in mojo, and as can be seen from the example above, can easily be accomplished with the save() instance method.
The main read/write operations of a model are as follows:
Both the find() and find_one() operations take MongoDB style dict objects as request parameters and follow the pymongo style of queries.
One of the most appealing aspects of Tornado is it’s ability to work asynchronously, and Mojo takes that to heart, ensuring taht you can just as well use the asynchronous style of development with the ORM and Models.
To use the Asynchronous driver, make sure that you have changed it in your settings.py file:
DATABASE = {
'backend': 'Mojo.Backends.AsyncmongoBackend.asyncmongo_backend',
'name': 'YOUR_DB_NAME',
'host': '<IP_ADDRESS>',
'port': 27017
}
To start using it in your code, all models make an _async version of all operations available, that can be used with traditional callback-style async handling or Tornado’s gen module style (for more readable code):
class myRequestHandler(MojoRequestHandler):
@gen.engine
@tornado.web.asynchronous
def get(self):
from bson.objectid import ObjectId
thisPost = yield gen.Task(BlogPost.find_one_async, {'_id':ObjectId('5059fb6b3d941cdc4487bdff')})
self.render('template.html', post=thisPost)
If you want to use callback-style development:
class myRequestHandler(MojoRequestHandler):
def callback(value):
self.render('template.html', post=value)
@gen.engine
@tornado.web.asynchronous
def get(self):
from bson.objectid import ObjectId
yield gen.Task(BlogPost.find_one_async, {'_id':ObjectId('5059fb6b3d941cdc4487bdff')}, callback=self.callback)
NOTE: The ORM and Models modules are still in very early stage development, please report any bugs to the developer on the source-control page on BitBucket.


Fill out the registration form on the side with the correct data. All the fields that exist in this form must be filled


With us you will receive support even after the original implementation.
Only 110% is acceptable and we aim to give our clients nothing but the best.
Always happy, fun filled and great company. Select us to be your partner...


Camila Cabello Gushes Over Her Beau Following Big AMAs Win: ‘I Love You Shawn Mendes’
by Aynslee DarmonCamila Cabello is all about her beau Shawn Mendes, especially after Sunday’s big win at the American Music Awards.
The pair, who collaborated on one of the summer’s biggest hits “Señorita”, took home Collaboration of the Year at the AMAs and thanked their fans along the way.
But in a new message to Mendes, the “Havana” singer, 22, shared a sweet shout-out, thanking him for “being there.”
“I love you Shawn Mendes,” she wrote, captioning a few behind-the-scenes shots from the show. “Thank you for being so there for me yesterday and every other day. You have the most caring and beautiful heart in the world!”
She added, “Thanks to all our fans for voting, we love and appreciate you guys so much and are so thankful for you ❤.”
Cabello took the stage three times Sunday night to perform. She first joined Mendes for a steamy rendition of “Señorita”, before wowing the crowd with a performance of her new single “Living Proof” and joining longtime pal Taylor Swift on stage for “Shake It Off”.


Print an Address Label
With a Dymo LabelWriter
Print label
Clear
Loading
×
Printer information
Environment
Browser supported:
Dymo framework installed:
Dymo webservice ready:
Printer
Name:
Connected:
Label
Acquired:


Jupyter notebooks demonstrating accessing NASA-NAVO data resources are available on Github.
Statically rendered versions of the notebooks are available below:
| Rendered Notebook | Description |
|---|---|
| Basic Tasks | |
| QuickReference.ipynb | Quick reference for common search tasks |
| CS_Catalog_Queries.ipynb | Accessing astronomical catalogs |
| CS_Image_Access.ipynb | Searching for and retrieving images |
| CS_Spectral_Access.ipynb | Retrieve spectra using Simple Spectral Access protocol |
| CS_UCDs.ipynb | Using Unified Content Descriptors (UCDs) to understand columns in heterogeneous tables |
| CS_VO_Tables.ipynb | Creating a VO Table from a CSV file |
| Science Use Cases | |
| UseCase_I.ipynb | Inspecting a Candidate List |
| UseCase_II.ipynb | Proposal Preparation |


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
See:
Description
| Packages | |
|---|---|
| de.ovgu.dke.teaching.ml.tictactoe | Main classes for playing a Match or Tournament. |
| de.ovgu.dke.teaching.ml.tictactoe.api | Common interfaces for a TicTacToe board, player and move. |
| de.ovgu.dke.teaching.ml.tictactoe.game | Game logic, rules and a tournament class. |
| de.ovgu.dke.teaching.ml.tictactoe.player | Player classes, e.g a Random Player or Keyboard Player. |
| de.ovgu.dke.teaching.ml.tictactoe.util | Utility stuff |
This document describes the source code of the "TicTacToe Environment".
This TicTacToe environment allows to play a match of TicTacToe on a 3-dimensional board. All
required classes are located in the lib
directory. Configuration is done using Java
Property files in the config
directory. New players can be implemented in the
src
directory.
Everything should be quite self-explanatory. If not, contact me ;)
Author: Thomas Low<EMAIL_ADDRESS>v1.3.0 (Oct-22-2013)
v1.2.1 (Oct-29-2012)
v1.2.0 (Oct-22-2012)
v1.1.0 (Nov-01-2011)
In order to configure this TicTacToe game, you can edit the file
config/tictactoe.properties
and change its values. It contains references to classes
of players which play in a match or tournament. You can also define the size of
the board and the number of rounds in a tournament.
There are three players available:
In order to choose a player, the property player
has to be modified, e.g.:
player=KeyboardPlayer:RandomPlayer
Each player is identified by its class name and the package it resides in (separated by colon).
For example, a player that is implemented by a class called MyPlayer
located in package
mypackage
can be referenced as mypackage.MyPlayer
. For tournaments, more than
two players can be specified, e.g.:
player=mypackage.MyPlayer:yourpackage.YourPlayer:SmartPlayer:RandomPlayer
Starting a simple match between two players is easy. Simply add two ore more players to the configuration file (already done by me) and execute the PlayMatch class. In Linux this can be done using this command:
java -cp "config:src:lib/*" de.ovgu.dke.teaching.ml.tictactoe.PlayMatch
In Windows classpaths are separated by a semicolon. You might need to substitute ":" with ";", e.g.:
java -cp "config;src;lib/*" de.ovgu.dke.teaching.ml.tictactoe.PlayMatch
Starting a tournament between a set of players is very similar. Add all players to the configuration file and execute:
java -cp "config:src:lib/*" de.ovgu.dke.teaching.ml.tictactoe.PlayTournament
Again, in Windows you probably need to write:
java -cp "config;src;lib/*" de.ovgu.dke.teaching.ml.tictactoe.PlayTournament
In order to develop your own player, your class needs to implement the
IPlayer
interface. Check
out src/NewPlayer.java
for an example.
When your are ready, compile your player by executing:
javac -cp "lib/*" src/NewPlayer.java
Then you can start a match or tournament, after adding your new player class to the configuration
file. For example, edit tictactoe.properties
like this:
player=NewPlayer:RandomPlayer
For development, you might want to test certain board scenarios. The easiest
way to do this, is to play against KeyboardPlayer
, which can be controlled
with your keyboard.
Don't forget to give your player a unique name. That's it. Have fun!
Simply ask your classmates to send you their player classes and add them to the configuration file.
You might also want to play against SmartPlayer
. He's quite good.
This project uses Apache Maven for dependency management. Logging is done using SLF4J and Log4J.
References:
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


When creating your own controller, you must subclass
GenControlClass
. You must also follow the steps outlined below (each is described in more detail throughout this section):
MSG_GEN_CONTROL_GET_INFO
Every controller
must
handle this message and return critical information about the controller, its features, and its tools. This is the most involved step of creating a controller. See Mandatory Message Handling
.
GenControlClass
messages
GenControlClass
messages depending on how much additional functionality they require. Most controllers will intercept
MSG_GEN_CONTROL_UPDATE_UI
.E very controller must have a definition of all its features and tools. This definition typically resides in the controller class header file (in this case, psCtrl.goh ). Applications that use the controller must be able to turn on and off individual tools and features. These definitions take the form of records in which each bit represents a particular feature or tool. No controller may have more than sixteen features or tools; the controller has just one word representing which features and tools are "on."
To define the feature set of your controller class, define a record type of type
WordFlags
and one flag for each feature. The record type you define may be named anything; typically, however, its name will consist of the acronym of the controller class with the suffix "Features." For example, the features type and flags of
PointSizeControlClass
are shown below:
typedef WordFlags PSCFeatures; #define PSCF_10 0x0400 #define PSCF_12 0x0200 #define PSCF_14 0x0100 #define PSCF_18 0x0080 #define PSCF_24 0x0040 #define PSCF_36 0x0020 #define PSCF_54 0x0010 #define PSCF_72 0x0008 #define PSCF_SMALLER 0x0004 #define PSCF_LARGER 0x0002 #define PSCF_CUSTOM_SIZE 0x0001
Each of the flags represents one feature of the controller. For example, the PSCF_10 flag represents the "10 Point" trigger in the Sizes menu, and the PSCF_SMALLER flag represents the "Smaller" trigger. When a flag is set, the feature it represents is turned on; when clear, its feature is off.
Each controller class must create a similar record type and flags for its tool set. Because the tools are independent of the default features, two different sets of flags must be defined. An example (the
PSCToolboxFeatures
record of
PointSizeControlClass
) follows.
typedef WordFlags PSCToolboxFeatures;
#define PSCTF_9 0x0400 #define PSCTF_10 0x0200 #define PSCTF_12 0x0100 #define PSCTF_14 0x0080 #define PSCTF_18 0x0040 #define PSCTF_24 0x0020 #define PSCTF_36 0x0010 #define PSCTF_54 0x0008 #define PSCTF_72 0x0004 #define PSCTF_SMALLER 0x0002 #define PSCTF_LARGER 0x0001
After you have defined your controller class' feature and tool sets, you should define the controller's default feature and tool sets. The definitions for
PointSizeControlClass
are shown below:
#define PSC_DEFAULT_FEATURES (PSCF_9 | PSCF_10 | PSCF_12 | PSCF_14 | PSCF_18 | PSCF_24 | PSCF_36 | PSCF_72 | PSCF_CUSTOM_SIZE | PSCF_SMALLER | PSCF_LARGER)
#define PSC_DEFAULT_TOOLBOX_FEATURES (PSCTF_9 | PSCTF_10 | PSCTF_12 | PSCTF_14 | PSCTF_18 | PSCTF_24 | PSCTF_36 | PSCTF_72 | PSCTF_SMALLER | PSCTF_LARGER)
These values and flags will be used in your handler for the controller message
MSG_GEN_CONTROL_GET_INFO
.
After you have determined which features and tools your controller class will support, you must create the UI objects that correspond to them. To do this, declare two separate resource segments--one to contain the feature objects and the other to contain the tool objects. Then declare a third that contains just chunks with text strings in it.
Both resources should be defined
notDetachable
, meaning that the feature and tool objects will not be saved to a state file. In the global parameters file for your controller, each resource must be declared with the
ui-object
,
read-only
, and
shared
flags as below:
resource SIZECTRLUI ui-object read-only shared resource SIZECTRLTOOLUI ui-object read-only shared resource CONTROLSTRINGS lmem read-only shared
The UI resources typically contain list objects and their corresponding items. As an alternative, they can contain triggers and dialogs. These objects are declared as a standard object resource with generic objects, as shown in Controller UI Resources . All these objects must be set not usable (~GS_USABLE).
Code Display 12-7 Controller UI Resources
/* This display contains only code that appears in the psCtrl.goc file. The first * elements of the file are other included files, followed by a class declaration * statement. The two UI resources are shown after that, simplified somewhat; * Only redundant objects are left out of the display. */
/* Include the controller class definition and declare the class structure. */ @include <psCtrl.goh> @classdecl PointSizeControlClass;
@start SizeCtrlUI, notDetachable;
/* Define the features UI resource. This resource can contain any objects that may * typically appear in a menu (e.g. GenInteractions, GenTriggers, and list * objects). This example shows a single list object and a few of its entries. */
@object GenItemGroupClass SizesList = { GI_states = @default & ~GS_USABLE; /* Set the list not usable */ /* The children of the list are defined below. Each entry in the * list will appear as a single menu item. */ GI_comp = @Size10Entry, @Size12Entry, @Size14Entry, @Size18Entry, @Size24Entry, @Size36Entry, @Size54Entry, @Size72Entry; /* The "apply" message will be sent to the destination specified * in the GIGI_destination field. */ GIGI_applyMsg = MSG_PSC_SET_POINT_SIZE_FROM_LIST; /* The destination is defined as the TravelOption TO_OBJ_BLOCK_OUTPUT. * This will send the apply message to the controller's output object. */ GIGI_destination = (TO_OBJ_BLOCK_OUTPUT); }
/* An example of a GenItem for the above list. all the other children are similar * with different monikers and identifiers. The identifiers in this case are * equivalent to the point size setting for the feature. */ @object GenItemClass Size10Entry = { GI_visMoniker = `1', "1. 10 point"; GII_identifier = 10; }
/* A GenTrigger. Shown below is the "Smaller" menu entry of the Point Size * controller. Another trigger ("Larger") and a GenInteraction (the "Custom * Size" entry) are also declared. These objects do not have to be declared * as children of any object; they will automatically, like the list above, * be designated as children of the controller when it is initialized. * Note that all of these objects must also be set not usable. */ @object GenTriggerClass SmallerTrigger = { GI_states = @default & ~GS_USABLE; GI_visMoniker = `S', "Smaller"; GI_kbdAccelerator = control `9'; GTI_actionMsg = MSG_PSC_SMALLER_POINT_SIZE; GTI_destination = (TO_OBJ_BLOCK_OUTPUT); }
@end SizeCtrlUI
/* Define the Tools UI resource. This follows exactly the same rules as the * Features UI resource above, but it represents the UI gadgetry that will appear * in the controller's tool boxes rather than its default menus. */
@start SizeCtrlToolUI, notDetachable;
@object GenItemGroupClass SizesToolList = { /* Same as SizesList above, but with the following hints applied: */ HINT_ITEM_GROUP_MINIMIZE_SIZE; HINT_ITEM_GROUP_DISPLAY_CURRENT_SELECTION; }
/* The list entry items have the exact configuration as above but different * names that reflect their tool usage. * The only objects allowed as tools for the Point Size controller are the * point size list entries, the larger trigger, and the smaller trigger. The * "Custom Size" entry is not allowed in the tool box as a matter of style. */
@object GenTriggerClass SmallerToolTrigger = { GI_states = @default & ~GS_USABLE; GI_visMoniker = "S"; /* The moniker of a tool is typically a graphic. The moniker * specified here is text for simplicity. */ GTI_actionMsg = MSG_PSC_SMALLER_POINT_SIZE; GTI_destination = TO_OBJ_BLOCK_OUTPUT; }
@end SizeCtrlToolUI
@start ControlStrings;
/* In addition to the above two resources, you must also create a third that * contains name strings for the various tools and features. These name strings * will be used by the GenToolControl to identify the feature type in its * dialog box. */ @chunk char PSCName[] = "Point Size"; @chunk char Size10Name[] = "10 Point"; @chunk char Size12Name[] = "12 Point"; /* The rest of the point sizes are similar */ @chunk char SmallerName[] = "Smaller Point Size"; @chunk char LargerName[] = "Larger Point Size"; @chunk char CustomSizeName[] = "Custom Point Size";
@end ControlStrings
MSG_GEN_CONTROL_GET_INFO, GenControlBuildInfo
Every controller must handle
MSG_GEN_CONTROL_GET_INFO
. This message is sent to the controller in several circumstances, and it must return critical information about the controller's state and configuration.
It takes a pointer to an empty
GenControlBuildInfo
structure and must fill in all the structure's fields before returning. This structure is shown in MSG_GEN_CONTROL_GET_INFO Handler
with a description of each of its fields following.
Code Display 12-8 The GenControlBuildInfo Structure
/* This structure must be filled and returned by the controller class. It details * general information as well as specific information about the controller, the * controller's features, and the controller's tools. */
typedef struct { GenControlBuildFlags GCBI_flags; const char *GCBI_initFileKey; const GCNListType *GCBI_gcnList; word GCBI_gcnCount; const NotificationType *GCBI_notificationList; word GCBI_notificationCount; optr GCBI_controllerName;
MemHandle GCBI_dupBlock; const GenControlChildInfo *GCBI_childList; word GCBI_childCount; const GenControlFeaturesInfo *GCBI_featuresList; word GCBI_featuresCount; WordFlags GCBI_features;
MemHandle GCBI_toolBlock; const GenControlChildInfo *GCBI_toolList; word GCBI_toolCount; const GenControlFeaturesInfo *GCBI_toolFeaturesList; word GCBI_toolFeaturesCount; WordFlags GCBI_toolFeatures;
char *GCBI_helpContext; byte GCBI_reserved[8]; } GenControlBuildInfo;
The following fields define general information about the controller.
GCBI_flags
GenControlBuildFlags
. These flags affect several UI-related and object storage related functions, and they are detailed on GenControlBuildFlags
.
GCBI_initFileKey
GCBI_gcnList
GCBI_gcnCount
The length of the list pointed to by
GCBI_gcnList
above. This length should be the number of lists specified.
GCBI_notificationList
A pointer to a list of notification types supported by the controller.
GCBI_notificationCount
GCBI_notificationList
above.
GCBI_controllerName
The following fields define information about the controller's features. These fields will be filled dependent on the features set in the object's instance data and the UI level of the controller.
GCBI_dupBlock
SizeCtrlUI
resource.
GCBI_childList
GenControlChildInfo
structures; each of these structures details which features are set and which should always be set for each of the controller's children. This structure is shown below:typedef struct { ChunkHandle GCCI_object; WordFlags GCCI_featureMask; GenControlChildFlags GCCI_flags; } GenControlChildInfo;
GCBI_childCount
GCBI_childList
above.
GCBI_featuresList
GenControlFeaturesInfo
structures, one for each child. These structures define the following:typedef struct { ChunkHandle GCFI_object; optr GCFI_name; GenControlFeatureFlags GCFI_flags; } GenControlFeaturesInfo;
GenControlFeatureFlags
. This structure and its fields are described more fully on GenControlFeaturesInfo
.
GCBI_featuresCount
GenControlFeaturesInfo
structures listed in
GCBI_featuresList
above.
GCBI_features
GAI_appFeatures
field.The following fields describe information about the controller's tools and their configuration.
GCBI_toolBlock
SizeCtrlToolUI
resource.
GCBI_toolList
GenControlChildInfo
structures; each of these structures details which tools are set and which should always be set for each of the controller's children. This structure is shown below:typedef struct { ChunkHandle GCCI_object; WordFlags GCCI_featureMask; GenControlChildFlags GCCI_flags; } GenControlChildInfo;
GCBI_toolCount
GCBI_toolList
above.
GCBI_toolFeaturesList
GenControlFeaturesInfo
structures, one for each child. These structures define the following:typedef struct { ChunkHandle GCFI_object; optr GCFI_name; byte GCFI_flags; /* GenControlFeatureFlags */ } GenControlFeaturesInfo;
GenControlFeatureFlags
. This structure and its fields are described more fully on GenControlFeaturesInfo
.
GCBI_toolFeaturesCount
GenControlFeaturesInfo
structures in the list pointed to by
GCBI_toolFeaturesList
above.
GCBI_toolFeatures
GAI_appFeatures
field.The following field is used by controllers that offer their own help files and help text.
GCBI_helpContext
ATTR_GEN_HELP_CONTEXT
to itself with the specified string.
The structure also has eight bytes that are reserved for the use of GenControlClass, in the
GCBI_reserved
field.
This flags record defines several UI-related things about the controller object. Set them appropriate to your controller. The flags are
MSG_META_SUSPEND
to be sent on feature activation and
MSG_META_UNSUSPEND
afterward. This is often set by controllers.
LMemFree()
. Not often set by controllers.
The
GenControlChildInfo
structure defines the features or tools appropriate to each object in a controller's UI resources. It has the following structure, and its fields are described below:
typedef struct { ChunkHandle GCCI_object; WordFlags GCCI_featureMask; GenControlChildFlags GCCI_flags; } GenControlChildInfo;
GCCI_object
GCCI_featureMask
GCCI_flags
GenControlChildFlags
, the flags of which are described below.
The
GenControlChildFlags
flags are
MSG_GEN_CONTROL_NOTIFY_ADDING_FEATURE
.
The
GenControlFeaturesInfo
structure describes each UI feature's name and certain flags. The structure is defined below, and its fields are described following:
typedef struct { ChunkHandle GCFI_object; optr GCFI_name; GenControlFeatureFlags GCFI_flags; } GenControlFeaturesInfo;
GCFI_object
GCFI_name
GCFI_flags
GenControlFeatureFlags
, reserved.void MSG_GEN_CONTROL_GET_INFO( GenControlBuildInfo *info);
This message must be handled by all controllers. It takes an empty
GenControlBuildInfo
structure and fills it; this message is called in several circumstances by different objects and controller methods.
Source: Unrestricted--typically generated in
GenControlClass
methods.
Destination: Any controller object.
Parameters:
info
A pointer to an empty
GenControlBuildInfo
structure.
Return: The
GenControlBuildInfo
structure filled with the appropriate controller information.
Interception: Every controller class must intercept this message. There is no need to call the superclass anywhere in the handler.
Code Display 12-9 MSG_GEN_CONTROL_GET_INFO Handler
/* This method is a sample of how to handle MSG_GEN_CONTROL_GET_INFO. It is * specific to UICTextStyleControlClass. To handle this message, it is easiest to * set up a number of static local variables with the base information and set * the structure to these variables. */
/* Handler for MSG_GEN_CONTROL_GET_INFO * void (GenControlBuildInfo *info); */
@method UICTextStyleControlClass, MSG_GEN_CONTROL_GET_INFO {
/* General information constants */
static const char TSC_IniFileKey[] = "textStyleControl";
static const GCNListType TSC_gcnList[] = { {MANUFACTURER_ID_GEOWORKS, GAGCNLT_APP_TARGET_NOTIFY_TEXT_CHAR_ATTR_CHANGE} };
static const NotificationType TSC_notifyTypeList[] = { {MANUFACTURER_ID_GEOWORKS, GWNT_TEXT_CHAR_ATTR_CHANGE} };
/* Features information constants */
static const GenControlChildInfo TSC_childList[] = { {@PlainTextList, TSCF_PLAIN, GCCF_IS_DIRECTLY_A_FEATURE}, {@TextStyleList, TSCF_BOLD|TSCF_ITALIC|TSCF_UNDERLINE|TSCF_STRIKE_THRU| TSCF_SUBSCRIPT|TSCF_SUPERSCRIPT, 0}
};
/* The order of this list is actually backwards from the * record it reflects. */ static const GenControlFeaturesInfo TSC_featuresList[] = { {@SuperscriptEntry, @SuperscriptName, 0}, {@SubscriptEntry, @SubscriptName, 0}, {@StrikeThruEntry, @StrikeThruName, 0}, {@UnderlineEntry, @UnderlineName, 0}, {@ItalicEntry, @ItalicName, 0}, {@BoldEntry, @BoldName, 0}, {@PlainTextList, @PlainTextName, 0} };
/* Tools information constants */
static const GenControlChildInfo TSC_toolList[] = { {@PlainTextToolList, TSCTF_PLAIN, GCCF_IS_DIRECTLY_A_FEATURE}, {@TextStyleToolList, TSCTF_BOLD|TSCTF_ITALIC|TSCTF_UNDERLINE| TSCTF_STRIKE_THRU|TSCTF_SUBSCRIPT|TSCTF_SUPERSCRIPT, 0} }; };
static const GenControlFeaturesInfo TSC_toolFeaturesList[] = { {@SuperscriptToolEntry, @SuperscriptName, 0}, {@SubscriptToolEntry, @SubscriptName, 0}, {@StrikeThruToolEntry, @StrikeThruName, 0}, {@UnderlineToolEntry, @UnderlineName, 0}, {@ItalicToolEntry, @ItalicName, 0}, {@BoldToolEntry, @BoldName, 0}, {@PlainTextToolList, @PlainTextName, 0} };
/* Our constant for the GenControlBuildInfo structure. * Fields with a marker to the left of their names are * filled in dynamically by the handler following the * constant definition. */ static const GenControlBuildInfo TSC_dupInfo = { GCBF_SUSPEND_ON_APPLY, /* GCBI_flags */ TSC_IniFileKey, /* GCBI_initFileKey */ TSC_gcnList, /* GCBI_gcnList */ ARRAY_LEN(TSC_gcnList,GCNListType), /* GCBI_gcnCount */ TSC_notifyTypeList, /* GCBI_notificationList */ ARRAY_LEN(TSC_notifyTypeList, NotificationType), /* GCBI_notificationCount */ @TSCName, /* GCBI_controllerName */ /* ## */ NullHandle, /* GCBI_dupBlock */ TSC_childList, /* GCBI_childList */ ARRAY_LEN(TSC_childList, GenControlChildInfo), /* GCBI_childCount */ TSC_featuresList, /* GCBI_featuresList */ ARRAY_LEN(TSC_featuresList, GenControlFeaturesInfo), /* GCBI_featuresCount */ TSC_DEFAULT_FEATURES, /* GCBI_features */ /* ## */ NullHandle, /* GCBI_toolBlock */ TSC_toolList, /* GCBI_toolList */ ARRAY_LEN(TSC_toolList, GenControlChildInfo), /* GCBI_toolCount */ TSC_toolFeaturesList, /* GCBI_toolFeaturesList */ ARRAY_LEN(TSC_toolFeaturesList, GenControlFeaturesInfo), /* GCBI_toolFeaturesCount */ TSC_DEFAULT_TOOLBOX_FEATURES /* GCBI_toolFeatures */ };
/* Here is the code that fills in the above missing fields and * returns the proper structure. */
/* Copy the structure containing most of the correct information. */ memcpy(info, MemLockFixedOrMovable(&TSC_dupInfo), sizeof(GenControlBuildInfo)); MemUnlockFixedOrMovable(&TSC_dupInfo);
/* Fill the remaining fields in manually. */ info->GCBI_dupBlock = HandleOf(@PlainTextList); info->GCBI_toolBlock = HandleOf(@PlainTextToolList); }


FAITHLESS ---------
When Marianne (Lena Endre, "Kristin Lavransdotter") takes her and her husband's best friend David (Krister Henriksson) as a lover, she never anticipates the tragic events which will follow in writer Ingmar Bergman and director Liv Ullmann's "Faithless."
On a remote island, a writer named Bergman (Erland Josephson, "Scenes From a Marriage") sifts through the contents of a desk drawer, trying to draw inspiration from memories. (Bergman purportedly wrote this script based on an incident from earlier in his life that's continued to haunt him, although he gave Ullmann complete control over the film.) Marianne comes to him and begins to recount her painful story under his gentle prodding.
Marianne is a successful actress with a happy marriage to a world-reknowned composer/conducter Markus (Thomas Hanzon, "Private Confessions"). They have a 9 year old daughter Isabelle (Michelle Gylemo). Their friend, David, a film director with a messy life, frequently joins them for dinner and acts as an uncle to their daughter. When Marianne encounters David drunk and distraught one day, she brings him home. He suggests they sleep together. She laughs it off, proclaiming their relationship like that of brother and sister, but the idea takes root. Marianne, who's won a scholarship to study in Paris while Markus is away on a U.S. tour, talks David into a 'happenstance' meeting on the continent.
Trouble rears its head almost immediately, when Marianne discovers David's childish behavior coupled with intense jealousy. When an initial incident is smoothed over, their emotional bond becomes stronger - what Marianne had convinced herself she was doing for 'fun' has become hurtful. When she leaves their Parisian hotel room, David pulls a red bedspread over his head and Ullman cuts to Isabelle with a white and red bedspread over her head. This connects David to the child as well as pointing out Isabelle as the next victim of Marianne's hurt.
Marianne can't keep herself from David when they return. As his actors in 'A Dream Play' rebel, a distraught David asks Marianne to 'come look at your idiot,' appealing to her vanity. Markus discovers the lovers and promises Marianne he will make her hurt, demanding custody of Isabelle. That's just the beginning of the hellish descent Marianne continues to agonize over with Bergman, accusing him of laziness while allowing her, an actress, to shape his drama out of her real memories.
This bleak and talky Swedish drama is like watching a train wreck. Lena Endre's expressive face (beautifully lit by cinematographer Jorgen Persson, "Smilla's Sense of Snow") keeps our attention whether she's telling her story or admidst the action of flashback. Ullmann's deliberate pacing allows a sickening, gut-wrenching sense of dread to build. Her staging of Bergman and Marianne suggest a mentor/student relationship which flows in both directions. Again she uses duality as she shows Marianne and her reflection in a mirror, suddenly separated by the ghostly appearance of Isabelle. Ullmann's direction is strong although Bergman's presence is always evident. Lena Endre's performance is devastating.
"Faithless" is an open wound of a film, yet its humanity brings a heartfelt message. When Marianne tells Bergman that talking about love is painful, one can't help but think that this film will make it far more difficult to ever take love for granted.
A-
For more Reeling reviews visit www.reelingreviews.com
<EMAIL_ADDRESS><EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Registrations for SAT
Name :
Date of Birth :
Gender :
Male
Female
Photo :
Submit
Reset
Click Here to go to the home page.


>
Empro Ltda - Extension<PHONE_NUMBER>22
Home
Dashboard
Components
Navbar
Cards
Example Pages
Login Page
Registration Page
Forgot Password Page
Blank Page
Menu Levels
Second Level Item
Second Level Item
Second Level Item
Third Level
Third Level Item
Third Level Item
Third Level Item
Link
Messages
12 New
New Messages:
David Miller
11:21 AM
Hey there! This new version of SB Admin is pretty awesome! These messages clip off when they reach the end of the box so they don't overflow over to the sides!
Jane Smith
11:21 AM
I was wondering if you could meet for an appointment at 3:00 instead of 4:00. Thanks!
John Doe
11:21 AM
I've sent the final files over to you for review. When you're able to sign off of them let me know and we can discuss distribution.
View all messages
Alerts
6 New
New Alerts:
Status Update
11:21 AM
This is an automated server response message. All systems are online.
Status Update
11:21 AM
This is an automated server response message. All systems are online.
Status Update
11:21 AM
This is an automated server response message. All systems are online.
View all alerts
Logout
EMPRO LTDA
Sign-in with Google
admin section
dist section
Firebase sign-in status:
Unknown
Usuario actual
nombre
sdasda
Firebase auth
currentUser
object value:
null
null
-->


EasyDoc v1 old version English Document
EasyDoc, Easy
to generate Documents
.
EasyDoc pronunciation [ˈiziˈdɑk] sound file
Communication
- GitHub: https://github.com/wuyumin/easydoc Welcome star it
Software Download
link to download software (Compressed package need to extract the software file.)
Only one software file, do not install, not to rely on others, support to Microsoft system computer, Apple system computer, Linux system computer.
EasyDoc is developed by Go language, open source software, you can use the source code to compile. In fact, you do not have to do that, we have compiled and optimized software for download.
Command Line to Use
Ensure that easydoc software file can executable!
software file in the current directory:
Windows system $ easydoc -version
Unix-like system (such as Mac, Linux. Note that in front of ./ ) $ ./easydoc -version
You can put easydoc software file in the global environment directory(recommended use this), directly using the $ easydoc -version
.
EasyDoc Currently Supported Command:
-init
Init the document structure
-build
Build the document
-server
Start web server(used[or not] with the port -port
and the path-path
, the default port is 80, the default path is dist directory)
-emptydist
Empty dist directory
-help
Help about EasyDoc
-version
Print the version number of EasyDoc
Static documents which Generated by EasyDoc are placed in the dist
directory, use or copy this directory directly as a site directory.
Source Directory Basic Structure
Use -init
command automatically generate
├─dist //release directory
├─src //store .md source files and template files(required, support to store in this directory and its subdirectories)
│ ├─static //Static file directory, this directory will be completely copied to the release directory
│ ├─theme
│ │ ├─template
│ │ │ ├─doc.tpl //document template file (not required, if not, use the software default template)
│ ├─index.md //Home(not required, but recommended)
│ ├─SUMMARY.md //use to generate menu(required)
├─easydoc.exe //software file(Recommended put it on the global environment directory)
- It is recommended that
.md source file only in src directory
to avoid forgetting to modify the template, web link is error. - Source file using Markdown syntax.
Contribution
GitHub: https://github.com/wuyumin/easydoc Welcome star it
Suggest or help us to improve: submit an issue to us or pull request to us.
Who Use EasyDoc
Welcome to provide “Who Use EasyDoc”.


Endless Plains [ak69], plain, in Imperia, peasants: 104
Last updated Turn #94
Endless Plains [ak69], plain, in Imperia, peasants: 104
------------------------------------------------------------------------
9: Pack of wolves [fy5l], wolves, number: 6, went north.
9: Wild men [bt0o], savages, number: 33, went west.
9: Stack of nazgul [he9j], nazgul, number: 3, arrived from the west.
9: Dolf [x2b], refugee, with one riding horse, arrived from the west.
11: Stack of nazgul [he9j], nazgul, number: 3, went east.
11: Dolf [x2b], refugee, with one riding horse, went east.
19: Pack of wolves [au1z], wolves, number: 7, arrived from the west.
19: Stack of nazgul [ga2i], nazgul, arrived from the north.
21: Stack of nazgul [ga2i], nazgul, went south.
25: Horde of rats [db2e], rats, number: 27, arrived from the north.
27: Horde of rats [db2e], rats, number: 27, went south.
29: Pack of wolves [au1z], wolves, number: 8, went east.
29: Stack of nazgul [ga2i], nazgul, arrived from the south.
30: The population grows by one peasant.
Routes leaving Endless Plains:
North, plain, to Endless Plains [aj69], 7 days
East, plain, to Endless Plains [ak70], 7 days
South, plain, to Endless Plains [al69], 7 days
West, plain, to Endless Plains [ak68], 7 days
Seen here:
Stack of nazgul [cp5f], nazgul, number: 3
Pack of wolves [au1z], wolves, number: 8
Horde of rats [db2e], rats, number: 26


{% extends "base.html" %} {% block title %}Edit User: {{ user.username }}{% endblock %} {% block content %}
This will immediately delete {{ user.displayname }}'s account from the LDAP directory.
Note: Their home directory will not be deleted.


The silence of memories
Do you want to talk to me?
Say hello!
Linkedin
My linkedin page
Back to home


This is a short, fast and analogy-free introduction to Haskell monads derived from a categorical perspective. This assumes you are familiar with Haskell and basic category theory.
If you aren’t already comfortable with monads in Haskell, please don’t read this. It will confuse your intuition even more.
We have a abstract category \(\mathcal{C}\) which consists of objects and morphisms.
For each object there is an identity morphism id
and a composition rule \((\circ)\) for combining morphisms associatively. We can model this with the following type class in Haskell with kind polymorphism.
-- Morphisms
type (a ~> b) c = c a b
class Category (c :: k -> k -> *) where
id :: (a ~> a) c
(.) :: (y ~> z) c -> (x ~> y) c -> (x ~> z) c
In Haskell we call this cateogry Hask, over the type constructor (->)
of function types between Haskell types.
type Hask = (->)
instance Category Hask where
id x = x
(f . g) x = f (g x)
The constructor (->)
is sometimes confusing to read in typeclass signatures as a typelevel operator since it’s first argument usually appears to the left of it in infix form and the second to the right. For example the following are equivalent.
(->) ((->) a b) ((->) a c)
(a -> b) -> (a -> c)
Between two categories we can construct a functor denoted \(T\), which maps between objects and morphisms of categories that preserves morphism composition and identities.
Represented in Haskell by:
class (Category c, Category d) => Functor c d t where
fmap :: c a b -> d (t a) (t b)
With the familiar functors laws:
fmap id ≡ id
fmap (a . b) ≡ (fmap a) . (fmap b)
The identity functor \(1_\mathcal{C}\) for a category \(\mathcal{C}\) is a functor mapping all objects to themselves and all morphisms to themselves.
newtype Id a = Id a
instance Functor Hask Hask Id where
fmap f (Id a) = Id (f a)
instance Functor Hask Hask [] where
fmap f [] = []
fmap f (x:xs) = f x : (fmap f xs)
instance Functor Hask Hask Maybe where
fmap f Nothing = Nothing
fmap f (Just x) = Just (f x)
An endofunctor is a functor from a category to itself, i.e. (\(T : \mathcal{C} \to \mathcal{C}\)).
type Endofunctor c t = Functor c c t
newtype FComp f g a = C { unC :: f (g a) }
instance (Functor f, Functor g) => Functor (FComp f g) where
fmap h (C x) = C (fmap (fmap h) x)
The repeated composition of an endofunctor over a category is written with exponential notation:
\[ \begin{align*} T^2 &= T T : \mathcal{C} \rightarrow \mathcal{C} \\ T^3 &= T T T: \mathcal{C} \rightarrow \mathcal{C} \end{align*} \]
The category of small categories \(\textbf{Cat}\) is a category with categories as objects and functors as morphisms between categories.
For two functors \(F,G\) between two categories \(\mathcal{A,B}\):
\[ F : \mathcal{A} \rightarrow \mathcal{B} \\ G : \mathcal{A} \rightarrow \mathcal{B} \]
We can construct a mapping called a natural transformation \(\eta\) which is a mapping between functors \(\eta : F \rightarrow G\) that associates every object \(X\) in \(\mathcal{A}\) to a morphism in \(\mathcal{B}\):
\[ \eta_X : F(X) \rightarrow G(X) \]
Such that the following naturality condition holds for any morphism \(f : X \rightarrow Y\). Shown as a naturality square:
\[ \eta_Y \circ F(f) = G(f) \circ \eta_X \]
The natural transformation itself is shown diagrammatically between two functors as:
This is expressible in our general category class as the following existential type:
type Nat c f g = forall a. c (f a) (g a)
In the case of Hask we a family of polymorphic functions with signature:
type NatHask f g = forall a. (f a) -> (g a)
With the naturality condition as the following law for a natural transformation (h
), which happens to be a free theorem in Haskell’s type system.
fmap f . h ≡ h . fmap f
The canonical example is the natural transformation between the List functor and the Maybe functor ( where f = List
, g = Maybe
).
headMay :: forall a. [a] -> Maybe a
headMay [] = Nothing
headMay (x:xs) = Just x
Either way we chase the diagram we end up at the same place.
fmap f (headMay xs) ≡ headMay (fmap f xs)
Run through each of the cases of the naturality square for headMay
if you need to convince yourself of this.
fmap f (headMay [])
= fmap f Nothing
= Nothing
headMay (fmap f [])
= headMay []
= Nothing
fmap f (headMay (x:xs))
= fmap f (Just x)
= Just (f x)
headMay (fmap f (x:xs))
= headMay [f x]
= Just (f x)
A natural transformation \(\eta : C \rightarrow D\) is itself a morphism in the functor category \(\textbf{Fun}(\mathcal{C}, \mathcal{D})\) of functors between \(\mathcal{C}\) and \(\mathcal{D}\). The category \(\textbf{End}\) is the category of endofunctors between a category and itself.
 (FNat g) = FNat (f . g)
We can finally define a monad over a category \(\mathcal{C}\) to be a triple \((T, \eta, \mu)\) of:
class Endofunctor c t => Monad c t where
eta :: c a (t a)
mu :: c (t (t a)) (t a)
With an associativity square:
\[ \mu \circ T \mu = \mu \circ \mu T \\ \]
And a triangle equality:
\[ \mu \circ T \eta = \mu \circ \eta T = 1_C \\ \]
Alternatively we can express our triple as a series of string diagrams in which we invert the traditional commutative diagram of lines as morphism and objects as points and morphisms as points and objects as lines. In this form the monad laws have a nice geometric symmetry.
With the coherence conditions given diagrammatically:
There is an equivalent formulations of monads in terms of two functions ((>>=), return
) which can be written in terms of mu, eta
)
In Haskell we define a bind (>>=)
operator defined in terms of the natural transformations and fmap
of the underlying functor. The join
and return
functions can be defined in terms of mu
and eta
.
(>>=) :: (Monad c t) => c a (t b) -> c (t a) (t b)
(>>=) f = mu . fmap f
return :: (Monad c t) => c a (t a)
return = eta
In this form equivalent naturality conditions for the monad’s natural transformations give rise to the regular monad laws by substitution with our new definitions.
fmap f . return ≡ return . f
fmap f . join ≡ join . fmap (fmap f)
And the equivalent coherence conditions expressed in terms of bind and return are the well known Monad laws:
return a >>= f ≡ f a
m >>= return ≡ m
(m >>= f) >>= g ≡ m >>= (\x -> f x >>= g)
The final result is given a monad we can form a new category called the Kleisli category from the monad. The objects are embedded in our original c
category, but our arrows are now Kleisli arrows a -> T b
. Given this class of “actions” we’d like to write an operator which combined these morphisms just like we combine functions in our host category.
\[ \begin{align} & (b \to T c) \to (a \to T b) \to (a \to T c) \\ & (b \to c) \to (a \to b) \to (a \to c) \end{align} \]
In turns we out can for a specific function (<=<)
expressed in terms of \(\mu\) and the underlying functor, which gives associative composition operator of Kleisli arrows. The Kleisli category models “composition of actions” and form a very general model of computation.
The mapping between a Kleisli category formed from a category \(\mathcal{C}\) is that:
\[ f \circ g = \mu ( T f ) g \]
-- Kleisli category
newtype Kleisli c t a b = K (c a (t b))
-- Kleisli morphisms ( c a (t b) )
type (a :~> b) c t = Kleisli c t a b
-- Kleisli morphism composition
(<=<) :: (Monad c t) => c y (t z) -> c x (t y) -> c x (t z)
f <=< g = mu . fmap f . g
instance Monad c t => Category (Kleisli c t) where
-- id :: (Monad c t) => c a (t a)
id = K eta
-- (.) :: (Monad c t) => c y (t z) -> c x (t y) -> c x (t z)
(K f) . (K g) = K ( f <=< g )
In the case of Hask where c = (->)
we see the usual instances:
-- Kleisli category
newtype Kleisli m a b = K (a -> m b)
-- Kleisli morphisms ( a -> m b )
type (a :~> b) m = Kleisli m a b
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
f <=< g = mu . fmap f . g
instance Monad m => Category (Kleisli m) where
id = K return
(K f) . (K g) = K (f <=< g)
class Functor t where
fmap :: (a -> b) -> t a -> t b
class Functor t => Monad t where
eta :: a -> (t a)
mu :: t (t a) -> (t a)
(>>=) :: Monad t => t a -> (a -> t b) -> t b
ma >>= f = join . fmap f
Stated simply that the monad laws above are just the category laws in the Kleisli category, specifically the monad laws in terms of the Kleisli category of a monad m
are:
(f >=> g) >=> h ≡ f >=> (g >=> h)
return >=> f ≡ f
f >=> return ≡ f
For example, Just
is just an identity morphism in the Kleisli category of the Maybe
monad.
Just >=> f = f
f >=> Just = f
just :: (a :~> a) Maybe
just = K Just
left :: forall a b. (a :~> b) Maybe -> (a :~> b) Maybe
left f = just . f
right :: forall a b. (a :~> b) Maybe -> (a :~> b) Maybe
right f = f . just
For instance the List monad would have have:
instance Functor [] where
-- fmap :: (a -> b) -> [a] -> [b]
fmap f (x:xs) = f x : fmap f xs
instance Monad [] where
-- eta :: a -> [a]
eta x = [x]
-- mu :: [[a]] -> [a]
mu = concat
The Maybe monad would have:
instance Functor [] where
-- fmap :: (a -> b) -> Maybe a -> Maybe b
fmap f (Just x) = Just (f x)
fmap f Nothing = Nothing
instance Monad Maybe where
-- eta :: a -> Maybe a
eta x = Just x
-- mu :: (Maybe (Maybe a)) -> Maybe a
mu (Just (Just x)) = Just x
mu (Just Nothing) = Nothing
The IO monad would intuitively have the implementation:
instance Functor IO where
-- fmap :: (a -> b) -> IO a -> IO b
instance Monad Maybe where
-- eta :: a -> IO a
-- mu :: (IO (IO a)) -> IO a


Hosting a dashboard using Raspberry Pi.
Combination of Raspberry Pi with Dasboard.
Going through jenkins to have view on what was red color
Going through elastic search for do specific search
Having summary of daily sales
Monitor any items manually that you could think of
Why dont spent time on other staff :)
View all needed information on a Big TV
Deploy new dashboard with jenkins if needed
Customize for dashboard widget needed as you like
Could call for api in schedule been set
Knows HTML, SCSS(CSS), RUBY, COFFEE
Person who having idea of special widget :)
Good on designing in HTML CSS :)
Low learning curve, could learn on the spot :)
Feel free to join me :)


--- layout: page title: About ---
I am Paul Ashour, a full stack web developer with a drive for expanding my horizons. I followed my fascination with human languages into the realm of code, where I continue to apply a desire to thoroughly understand the languages I work with. My projects take inspiration from my interest in bringing people together through music and games, making use of Ruby on Rails, JavaScript and ReactJS technologies.
You can see some of my work here:
You can also find me singing strange four-part harmonies with my friends:


Comparison of the elastic constant C 33 predicted by ( a) PR, ( b) DT, ( c) RF, ( d) SVM (with RBF kernel), ( e) k-NN, ( f) GPR (with Matern kernel), ( g) GPR (with RBF kernel) and ( h) NN with measured values computed by MD simulation. The error bars shown for each value represent the standard deviation around the mean values.


Prince Paul Selibio
A few months ago, me and my tour guide group decided to explore Balabac, the southernmost municipality of Palawan.
Balabac is geographically near Malaysia than the rest of the Philippines and has strong connection with that country owing to its location and the fact that the place has a predominant Muslim population like Malaysia. It was the first time for all of us to explore this part of Palawan. Even though we are tour guides and are expected to have traveled to most areas of Palawan, we had apprehension to go to Balabac at first because the area is sensationally portrayed by media as a trouble spot adding to the fact that the place has no established tourism system. We had no contact, no accommodation and were completely clueless on how to go about with our trip.
It was timely, one of my facebook friends, Jay Cuario happened to be organizing a group to explore Balabac but upon inquiry I learned that his schedule and ours do not match so I instead get his contact in Balabac so we can schedule our tour on a separate date. I wasted no time in contacting the family of Jay’s friend, Lydz Alpha who shall be our host for the tour. They were very accommodating and agreed on our desired itinerary.


Warnemunde is the holiday resort and ferry terminal at the entrance of the river leading the 6 miles up to Rostock.
The entrance is possible both day and night, being well marked with no off-lying dangers.
The large modern marina of Hohe Dune lies to the east of the river entrance, on the opposite side of the river to Warnemunde and is rather remote from the town.
The western side of the entrance leads to the yacht harbour and also the fishing harbour (Alter Strom) at Warnemunde. This is close to the town centre
The channel up to Rostock is well marked although many buoys are unlit, so a daylight passage is advisable. There are a number of small yacht harbours on the east bank at Gehlsdorf but these are not so conveient for the city. Futher on there are a number of berthing options on the south bank, including the town quay (Stadthafen). The facilities here are being rapidly improved.
Last updated March 2012.


I am Designer, who is passionate about creating excellent digital products, assisting enterprises and non-profit organizations build user interface. My super power is finding the perfect balance between functionality and aesthetic.
The expertise of users is all that matters.
Users feedback on a product is essesntial for growth.
Product reach to end users is essiential for feedbacks.
UX Designer
A UI/UX Designer since i joined Jekalo System Solution after my college Education
Front-end Developer
Technical understanding of HTML, CSS and JavaScript, which helped me during my web journey as a web Developer.
Product Designer
Single handedly manager a product from start to finsh even got involve the product Marketing.
Mass Communication
Studied Mass Communication at Yaba Colledge of Technology, 3 years program.
Admin
Work as an Admin at Jekalo with robost data base on car documentation, whereby users are informed on when next document will expire.
Hours Worked
Project Finished
Happy Clients
Coffee Drinked


ReSpec defaults the lang attribute on your root element to en. If you are writing in another language, simply set this attribute to another value.
lang
en


| 007:145 Khan | : |
And We wrote for him on the Tablets the lesson to be drawn from all things and the explanation of all things (and said): Hold unto these with firmness, and enjoin your people to take the better therein. I shall show you the home of Al-Fasiqun (the rebellious, disobedient to Allah). |
| 007:145 Maulana | : |
And We ordained for him in the tablets admonition of every kind and clear explanation of all things. So take hold of them with firmness and enjoin thy people to take hold of what is best thereof. I shall show you the abode of the transgressors. |
| 007:145 Pickthal | : |
And We wrote for him, upon the tablets, the lesson to be drawn from all things and the explanation of all things, then (bade him): Hold it fast; and command thy people (saying): Take the better (course made clear) therein. I shall show thee the abode of evil-livers. |
| 007:145 Rashad | : |
We wrote for him on the tablets all kinds of enlightenments and details of everything: "You shall uphold these teachings strongly, and exhort your people to uphold them - these are the best teachings. I will point out for you the fate of the wicked." |
| 007:145 Sarwar | : |
We wrote advice and laws for him on Tablets about all kinds of things, saying, "Follow them and command your people to follow the good advice therein, and I will show you the dwellings of the evil-doers." |
| 007:145 Shakir | : |
And We ordained for him in the tablets admonition of every kind and clear explanation of all things; so take hold of them with firmness and enjoin your people to take hold of what is best thereof; I will show you the abode of the transgressors. |
| 007:145 Sherali | : |
And WE wrote for him upon the Tablets about everything an admonition and an explanation of all things. 'So hold them fast and bid thy people follow the best thereof. Soon shall I show you the abode of the transgressors.' |
| 007:145 Yusufali | : |
And We ordained laws for him in the tablets in all matters, both commanding and explaining all things, (and said): "Take and hold these with firmness, and enjoin thy people to hold fast by the best in the precepts: soon shall I show you the homes of the wicked,- (How they lie desolate)." |
Concepts/Themes Covered: الإيمان > الغيب > النار > أسماء النار > دار الفاسقين Faith> The Unseen World> Hell-Fire>Hell Names> The World of Dissolute
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


Jomo Kenyatta University of Agriculture and Technology | 2020 - 2025
Class Representative 2020/2021
Jomo Kenyatta University of Agriculture and Technology | 2019 - 2020
8 programming projects (Github - Samkamau81)
2 Hackathons(HackDartmouth,Hacktoons)
Technocrat-Major League Hacking
Othaya Boys High School | 2016 - 2019
Class Salutatorian - Grade A(minus) 79/84 points
Position 7 Nyeri County
Student Council Vice Chairman and School Deputy Captain (2019)
President-Peace Club
Laboratory Assistant Prefect (2018)
Treasurer-Peace Club
Major League Hacking | Excellent
Participated in the HackDartmouth Virtual Hackathon hosted by Dartmouth University as a Python BackEnd Developer of the Dynamic Group.
Project:AiRap Beat
Serene Apartments | Good
Designed a Desktop App called Landlord Application using Python and MySql (Github)


---
layout: page-fullwidth
title: "Committee"
subheadline: #"Reading Experience"
meta_teaser: #"Feeling Responsive uses Volkhov for headlines, Lato for everything else and if you are in need to show some code, it will be in Lucida Console."
teaser: "Meet the team who run SUSS."
header:
image_fullwidth: "P5130113.jpg"
categories:
- about
---
The Committee are in charge of running the club and are elected each year at the AGM. They volunteer their time to make sure there are regular trips, that gear is available, handle the finances and record our speleological activities.
{% for role in site.data.committee %}


--- layout: default --- {{ page.title }} by Brian Koser {{ page.date | date: "%Y-%m-%d" }} {{ content }}
by Brian Koser
{{ page.date | date: "%Y-%m-%d" }}