The other guide to CSS hacking
So, you're interested about learning how the skill to customize your browsing experience? Certainly you must be, since you've stumbled upon this page. Just copy-pasting existing styles wasn't enough, huh? Good for you! Being able to create something on your own - something unique - can be really fulfilling. Or, if you are in only to learn how to debug existing styles that's cool too, it's your effort anyhow. You may pay the price with sweat and tears but it's your sweat and tears and in the end you'll get exactly what you personally are after.
Now, if you are after a collection of existing styles, you can find several at my repository which also has a quick guide on how to setup userChrome.css. Others very much worth mentioning are:
Or just ask folks at reddit r/firefoxCSS which is quite active.
But hey, we are interested in learning how this stuff works right? RIGHT!?
This guide is will eventually specialize in Firefox UI modifications, but starts from the basic CSS concepts. You will be introduced to syntax, document model, properties and all sorts of good stuff. That's quite a long road ahead for sure, however being familiar with how CSS works is really a requirement for the later sections of this guide, since it won't make too much sense without. And hey, the CSS intro applies to web development basics just fine, even if the examples are somewhat specific to Firefox UI.
So let's dive in - start by clicking the triangle/arrow icon to the top or right.
Whoa there, what is this?
That thing up there (or on the side depending on your window size), that is Toyfox. Yeah, I know, I just had to name it something during development and that's what it became. And now you're stuck with it. Anyway, it will be your sandbox. There's three panes there:
- Browser window
- Document tree
- CSS editor
You can try styles by inputing them to the CSS editor, and if they are valid then Toyfox applies them to its browser window. Here, try some minimalism, just copy-paste this to the CSS editor
#page-action-buttons,.toolbarbutton{
opacity:0;
}
#urlbar{ transition: background-color 82ms linear }
#nav-bar:not(:hover) #urlbar{
background: transparent;
border-color:transparent;
}
.toolbar:hover #page-action-buttons,
.toolbar:hover .toolbarbutton{
opacity:1
}
#PersonalToolbar{
opacity:0;
margin-top: -32px;
}
#nav-bar:hover + #PersonalToolbar,
#PersonalToolbar:hover{
margin-top:0;
opacity:1
}
Pretty sweet, right? Don't worry about the rules you just applied for now. That's just a teaser about what you can do to the real Firefox after you are done with this guide. But clear the CSS editor for now and we'll carry on.
Toyfox
The browser window there represents something akin to a generic browser, Firefox more specifically (and you can't really customize any other browser to nearly a same degree anyway). Don't try to use it to browse any "nasty" sites though, she doesn't like it very much and might even bite you. There are some simple features like add/close a tab, toggle sidebar and bookmarks bar. You can also click a magic-button to enter magic realm and all the secrets of the universe shall be known to you. Well, if not that then at least it can help figuring out element boundaries as well as visualizing some structure by brightening elements when cursor is on top of them.
Just click a few buttons and see what they do - if anything at all.
But how does this relate to Firefox? Well, Toyfox is structured in roughly the same way as Firefox is, although it only includes the main UI (User Interface). That same code you used just now, will work with very minor changes in real Firefox. There are some technicalities why it won't work exactly as is. But you can certainly create rules which work the same on both. So just try stuff.
If you are familiar with how CSS syntax works and how CSS and document tree relate to each other you can jump ahead right about here
The document tree view shows that very same window, but in tree mode. HOLD UP a second, what you mean the same window? Well, glad you asked.
This is your first and very important lesson. The window you see is really this huge tree of nodes or elements (there is a small difference between element and node but it's not a important for us and I may use the terms interchangeably). When you start the browser the program renders that tree to a visual browser.
It must have some rules which it uses to turn those abstract nodes to a visual representation right? What do you think those are? Anyone? CSS! Indeed, there is enormous amount of styles built in to Firefox. Much less so to Toyfox btw.
In essence, what all CSS does is ask the browser to apply the style properties we define to elements in the tree that match our description.
To put this another way, CSS does not work in isolation. If that document tree changes, then your rules might not apply to it anymore. That tree and CSS are sides of the same coin. The tree defines structure, CSS defines appearance. Neither is any good in itself.
Think about this for a moment. The document tree exists outside the CSS realm. And the browser uses a list of rules to visualize that tree. We cannot modify that tree - that structure at all, we add rules and the browser applies them to some elements. This for example doesn't have any effect: #some-thing{ background:red }
That is perfectly valid CSS, and the browser applies it to that document. However, it does not visually change anything because the are no elements that match our description "#some-thing"
Certainly that is very limiting for us, right? Well yes, no question about it. But you can still do a whole lot. The key-thing to grasp right now is that this is what CSS IS. Understanding this concept is crucial. And that's also why the tree view of the document is so important. It shows you all the stuff there is to modify.
In web development context the situation is quite different. There you are also in control of the document tree structure which is HTML so you can create all the features you like. But if for some reason you are only able to change CSS then the document is equally locked. But now let's get on customizing!
The good stuff
This is the moment you've been waiting for right? Type this to the CSS input box: #main-window{ background-color:red }
Ahh, My eyes, I didn't ask for this! Quick, change that to something better, like rgb(60,60,70)
Much better, thanks. So let's break down what you just did.
Terminology
Ugh, boooring. Yeah, but bear with me this won't be take long and makes future much easier.
- Stylesheet - a CSS file like userChrome.css, or the contents of the CSS editor in Toyfox, basically a collection of all your rules
- Ruleset - the thing you just applied
#main-window{ background-color:red}
, which can be further broken down to: - Selectors - comma-separated list of element identifiers like:
#main-window,.menu
- Declaration block - the whole deal within curly braces:
{ background-color:red; color: blue}
- semi-colons separate each: - Declaration - here we have two declarations: 1.
background-color:red
and 2.color:blue
- [Property]:[value] - You can find out all the properties that browsers support and values they can use from MDN
See, that didn't take long at all - unless you got stuck on MDN, happens to the best of us.
In short, we first select which elements we want to target with out rules. And then list which properties we want to modify. That's it, we can all go home for milkshakes!
Well, technically yes. And you can certainly find everything else you need from MDN but there is a whole lot of very technical stuff on MDN so that might not be the easiest path.
Lets get back to our simple example: #main-window{ background-color:red }
notice how there are multiple ways to represent color. One is color keyword, like red. Others rgb() like you saw, rgba(30,40,66,0.7)
- which takes an additional alpha parameter to control transparency and html syntax #808000
and some others.
So what happened there? We changed the color of pretty much everything except text, how can that be? If you look at the tree view, you can see that #main-window
is there up top. That means basically that this element is behind everything inside it. And so, if there are no fully opaque elements on top of it, then its background will be seen through.
See if you can only apply the background-color to tabs toolbar. Scroll through the tree view until you can see something which might work, I'll wait.
#TabsToolbar
perhaps? Nice. Now, that background is only "under" everything that is inside tabs toolbar. Next, lets change text to something not-blinding-white. Try this:#main-window{ color:rgb(198, 198, 144) }
What? How come all text except selected tab become like some mustard. Some properties, such as color - which rather confusingly means text-color - are inherited. Meaning, when you add it to parent element, it will be used by everything under it until the element uses some explicit color. In this case a selected tab sets its own color to white.
All those diamond icons changed color too though. Right, well they are actually text so that explains that. However, many icons in the real Firefox UI behave similarly. They use SVG icons which can be made to use current elements' text color to fill their icon.
Delving deeper
Selectors
At this point you might have thought what do those colors in the tree view mean. Somehow those relate to matching rules to correct elements but how? First of all, all elements have a tag-name, a type if you will. This is invisible in the tree-view though since everything in Toyfox is a DIV
. But an element may also have an ID (red) and multiple classes (yellow). IDs should be unique in a document, but there can be multiple elements with a single class.
When you use IDs, then the appearance of only one element will change (with the exception of inherited properties and result of transparency like we saw). ID selectors always start with a #
like so: #PanelUI-button{ color:red }
This means that this color value will only apply to element with an ID "PanelUI-button". In this case it will get inherited by its .toolbarbutton-icon
which then colors the actual diamond to red.
Classes are used to categorize elements to groups where the visual representation of each element should be similar in some way. Such as all buttons should look similar, makes sense right?
So, maybe we want to have a border on all our buttons. Lets try toolbarbutton{ border: 1px solid #888 }
Shoot, nothing. Notice that all the yellow text classes begin with a dot. Class selectors should always begin with a dot so add that there.
Well, it worked but everything also shifted - sort of became taller. Indeed, maybe just add a partially transparent background instead to make them stand out a bit more - background-color: rgba(255,255,255,0.2)
. Just keep in mind for now that border can modify computed width/height. Still, with classes we can more easily style multiple similar elements.
In real Firefox toolbarbutton
(without the dot) would have worked because there is an element type toolbarbutton. Selectors that don't begin with either .
or #
are Type selectors. We can't demo type selectors with Toyfox though but they should be used for very similar purposes as classes
Constructing rulesets
The first thing you want to do is to figure out what element or elements you want to change. So you need to refer to the tree view to see what elements are called. Well, that one is obvious but you should generally group your rulesets in way that doesn't repeat same things too much. This will make it much easier to maintain. So lets say we want to make a rounded UI. Round buttons, tabs and url bar. You could write rules for each (and in some cases you may need to do just that) but generally it's best to group stuff if you can by listing the selectors, separated with a comma:
.tabbrowser-tab,
.toolbarbutton,
#urlbar{
border-radius: 20px;
}
Now, this declaration block is applied to every element that matches any of those selectors
Combinators
Yikes, sounds pretty complicated. Oh but here is where the real fun begins. Often what you actually want to do is to style things based on some condition.. So open a bunch of tabs in Toyfox. Now, as you can see the selected tab is different color, and so are every tab when your cursor is on top of them. Those are .tabbrowser-tab elements alright but we are applying some different rules to them when those conditions are met.
Descendants
Here the document tree starts to finally make sense. Okay, we have these .toolbarbutton
elements everywhere. So how do we target some specific ones such as the ones in the main toolbar #nav-bar
. Well, you can combine selectors by putting a space between selectors: #nav-bar .toolbarbutton{ background:red }
This will apply to all toolbarbuttons which are inside #nav-bar. Those buttons are Descendants of #nav-bar.
Children
Children work exactly the same as descendants except they only apply to immediate child nodes. Change the selector to this: #nav-bar > .toolbarbutton
Hmm, only the button that toggles bookmarks bar changed color. If you now check the tree view, you will see that #nav-bar has three immediate child nodes: #nav-bar-customization-target
, #BMB-button
and #PanelUI-button
, but only the BMB-button has a class .toolbarbutton.
Adjacent Sibling
Open at least four tabs now. Wait, actually we might want a bit more space for this first. Adjacent to the new tab button is this other button right, but its not doing anything. So let's hide it shall we? Unfortunately, if you look at the document tree you will see that it is just a general .toolbarbutton
so we can't target it specifically with what we have learned until now.
New tab button has an ID though, so we can definitely target that. And since the dumb button is adjacent to #new-tab-button we can also uniquely target it using adjacent combinator: #new-tab-button + .toolbarbutton{ display: none }
. Nice, now we can fit a little more tabs. So adjacent sibling will target the second item if it becomes immediately after the first
General Siblings
General sibling combinator ~
works just like the adjacent sibling, but it will match all the elements matching the second selector, without them needing to become immediately after the first. So lets try something: .tabbrowser-tab[selected] ~ .tabbrowser-tab{ background: green }
Now, if you select different tabs you'll see that all the tabs that become after it are green. If you change that ~
to +
only the next one after selected will be green.
Both of the sibling combinators have one limitation. The first and second selectors need to share the same parent - as in they have to on the same "level" in the document tree. In the tabs example the parent is .scrollbox
so this works fine. However, you can't do something like #new-tab-button ~ .titlebar-buttonbox-container{ background:red }
and expect it make "window controls" red, because if you look at the document tree you'll see that they don't have a common parent. Even if they look to be next to each other visually.
Attributes
Elements may have all sorts of attributes - which unfortunately you can't see in the tree-view (it would get too crowded). You can "access" them by using attribute selectors in combination of type,id or class selectors like this: .tabbrowser-tab[selected]{ background: blue }
Now, the declaration only applies to the selected tab. Attributes usually also have a value, that example applies always when the "selected" attribute exists but we might sometimes want to apply our rules only when the value is something specific: .toolbarbutton[id="new-tab-button"]{ background:red }
This is actually the same thing as using selector #new-tab-button
as you remember "#" means element id - so yes class and id are attributes as well.
Actually setting those attributes isn't automatic and we can't do that in CSS. There is a javascript program running in background which handles that. Same deal as CSS not being able to change the document tree - we just list rules how things should look like under some conditions.
Pseudo-classes
The what now? These are automatically applied sort of "statuses" for elements. There is actually a whole bunch of pseudo-classes but we will look at two specific ones - :hover
and :not()
now because they are somewhat related to attributes.
The :hover
pseudo-class is automatically set for every element when the cursor is on top of them. This status also "bubbles" up in the document tree so when any element, like a .toolbarbutton has :hover status then also every ancestor (opposite of descendant) has that status. You see this in action in toolbar buttons and tabs. When you move the cursor on top of them, they change appearance. But you could also do #main-window:hover{ background:red }
and now the background will be red when any part of the window has your cursor on top of it.
Negation pseudo-class :not()
negates the condition inside it. It's especially useful with attribute selectors. So you can write things like: .tabbrowser-tab:not([selected]){ background:red }
which only apply to tabs which don't have an attribute called "selected".
Okay, that's nice to know and all but not really that interesting. Yes, but you see, you are not limited to just simple combinators.
Hit F1 button please.
So some sort of menubar appears but now we have two sets of window controls which seems kinda wasteful don't you think? Menubar has an attribute called "hidden". Toyfox default rules hide the whole toolbar when that attribute exists but F1 removes that attribute (or adds it if it doesn't exist so you can hide it again). Lets see if we can construct a selector that hides the window-controls in tabs toolbar when the menubar is not hidden.
So first thing we definitely need is the selector for menubar - find it using the document tree.
Yeah, #toolbar-menubar
, that's the one. Okay, then we need to only apply our rules when the element is not hidden. So we must combine :not()
and [hidden]
. Now, if you look at document tree you see that both, #toolbar-menubar and #TabsToolbar share the same parent - #titlebar so we may use sibling combinators here to target #TabsToolbar
. Nice, for this purpose either one of adjacent or general would work. Of course, we don't want to hide the whole toolbar so lets continue chaining up selectors.
The window controls are all inside .titlebar-buttonbox-container so we can just hide that and everything inside will also be hidden. That container is also a direct child of #TabsToolbar
so we can use the child combinator >
. All that is left is to apply some rules to it. To hide we can just usedisplay: none
So lets's put all that together:
#toolbar-menubar:not([hidden]) + #TabsToolbar > .titlebar-buttonbox-container{ display: none }
SUCCESS! So now the window-controls on tabs toolbar are only shown when menubar is hidden. Nice UX
Information flow
Now, we basically covered all the combinators there. They all share one really important feature: information only runs downhill. There is a pretty nice analogy here.
Consider the document as a real tree. It has a root, it's "outer-most" element (in Toyfox #main-window). All elements belong to that tree - just like leafs. Water flows from the roots through any branches until it eventually gets to the leafs. But it does not go to the opposite direction, ever.
So what does "information" mean here? Well, easiest way to think about this are attributes. Consider this: .tabbrowser-tab[selected] ~ .tabbrowser-tab{...}
This applies the rules in brackets to tabs that become after the selected tab, right?. Or this:.toolbarbutton > .toolbarbutton-icon{...}
which applies to toolbarbutton-icons which are inside toolbarbutton.
In both cases the later is below the former in the document tree. Okay, for the tab example we would need to modify the analogy a bit but it would still make sense. The important thing to know is that we can never do the opposite. So we can not make a rule that applies to tabs that come before the selected one.
Kind of an exception is the :hover pseudo-class. By the tree-analogy it would mean something like "when you touch the tree". So even if you just touch one leaf, you are still touching the whole tree because the leaf is part of the tree. And thus the state is triggered for each ancestor of that leaf except for sections that are in another branch. Try this:
#main-window:hover{ background: yellow }
#TabsToolbar:hover{ background: blue }
#nav-bar:hover{ background: green }
It doesn't matter where within #main-window your cursor is, the background will still be yellow. Now, put your cursor on top of url bar. #nav-bar will be green because it is an ancestor of the #urlbar and so you are in a sense touching the nav-bar too. But TabsToolbar is in another branch of the tree and will not turn blue. Of course it will be if you actually move your cursor over it.
Oh boy, that was that. If you read and understood all that you are ready to jump in to more specific things. If not, well just play around with Toyfox until it makes sense.
Properties
So, all that and we haven't really looked at any CSS properties yet. True, but honestly getting the key concepts is more important. The properties as just things which each have a dedicated pageat MDN which describe them. Those however won't do much without the basic knowledge. And at any rate, nobody expects you to remember all the properties anyway - everybody looks up stuff online when needed. Still, we'll go through some main ones here.
Box model
Each element generate something called a "box". These boxes are defined by four areas from outer to inner: margin, border, padding and content. Together these describe how big the box appears on your screen.
Start by adding this bit .demo-container{ visibility:visible; }
and a blue box should appear in the Toyfox "content" area. There is actually three boxes for demonstration purposes.
The blue box is the inner-most box - "content". In this case it's automatically scaled to fit the text content inside. Now, lets add some border: .demo-box{ border-width: 6px }
. Notice how the content box didn't scale at all but was surrounded by a black border. The whole demo-box got bigger by 6 pixels on each side.. Okay, now add some padding to .demo-box. You can add multiple properties to the same block by separating them with ;
So the whole deal becomes:
.demo-box{
border-width: 4px;
padding:6px;
}
Just remember to keep the rule that sets things visible. Now, the padding box clearly is between border and the content. And again, the whole demo-box got bigger. The difference between these is that the padding-box color cannot be modified. Instead, the yellow that is visible is the background-color of the .demo-box. Change it's background to green background:green
Then we have margin. Same deal, add margin: 6px
to .demo-box. Okay, as before, the box was surrounded by yet another box - now red. Now though, the .demo-box did not get bigger. The red you see is the background-color of the .demo-container which is the parent element of .demo-box. In fact, all these properties made the parent bigger too, since it has to fit all its children inside it.
Margin also can have negative values. The eventual behavior can change depending on the scenario but the gist of it is that the parent element reserves negative space for our box. Practically what this means is that the box can be moved to some direction, so now add this to demo-box: margin-top: -12px
and it should be moved upwards outside the container.
So all these affect how big the box will be, but they may also have an effect to all of that box's ancestor elements.
Positioning
By default, everything is positioned to the screen by some rules, but in a manner where elements that are close to each other in the document tree will also be close to each other in the visual space. This is called position:static
A sort of extension to this is position:relative
which gives us some addition freedom such as to move elements "behind" each other if they would overlap. So, if add just z-index: -1
to .demo-box, nothing will happen. But if you also add position:relative
it will disappear. Well, not disappear, just be drawn behind the whole window. Indeed, if you make the window background transparent #main-window{ background-color: transparent }
you will see that our .demo-box is right there.
Please remove the z-index and window transparency rules now so the following makes more sense
Hopefully, it's by now clear that the appearance of any of the child elements affect the dimensions of the parent element and eventually the whole window because this effect cumulates. This is exactly what we saw happen earlier by setting a border for .toolbarbuttons and suddenly it affected whole UI. But wait, there is one exception to this rule. See what happens when you change the position of .demo-box to fixed
.
Hmm, the whole red box got removed but the demo-box is still there. Ok, what fixed position does is it removes the box from the normal layout. So now, the .demo-box does not affect the size of the container at all. And since there is nothing else inside the container its size becomes zero.
Fixed positioning isn't something that you should often do though. However, sometimes there is no other way to do what you want, because we are not in control of the document structure. And with fixed positioning we can freely position the box to whatever coordinates within the browser window with top:, right:, bottom:, left:
properties where zero coordinate is the window edge. So this .demo-box{ position:fixed; bottom:0px; right: 0px; }
should put the demo-box close to bottom right corner. If you then remove the margin from it, then it should go to actual corner.
Main drawback of fixed position is that the position cannot depend in any way from changes to the rest of the document - much like the rest of the document doesn't care about changes to the fixed element. This may not always matter if you can somehow guarantee that there won't ever be other elements where this fixed element is. But as a rule of thumb, you should first try to do whatever you want to do without fixed positioning.
There will be an example later on for a case where fixed position is useful, but we need go through few more things before that.
Dimensions
First, remove the position:fixed from .demo-box. Second, give .demo-container width:200px
and height:100px
. The red box should now be wider and taller than it needs to.
Just use width and height, easy right? WRONG! Oh man, it is much more complicated. Well, actually if you are talking about CSS in basic HTML then this is pretty much the general idea. However, Firefox UI is built with a language called XUL and it's default rules are vastly different to HTML. We will dig into the differences at later time, but for now you'll need to know that the behavior depends on something called Box Type.
Actually, you have already used two box-type changing rules. Remember when you hid the other set of toolbarbuttons? You used display: none
. It may not look like it but this set the box type to none which basically means, generate no box for this element. The display property does exactly this - change the box type. The other case was when you set position:fixed
For reasons I'm not going to talk about, this also changes the box type to block
and you cannot override it.
You can read as much as your heart desires about this topic here on MDN. Additionally, Toyfox uses flexbox model to emulate real Firefox behavior, more about that right here
The gist of it is though, that you are not be able to use simple width and height properties within Firefox or Toyfox UI. So how then? Let's see.
You can clear the rules related to the .demo-box and .demo-container now as we won't be needing those again. Let's go back to our Toyfox UI because that's what you are really here for. Close all but one Toyfox tabs too and this will work better.
First, lets paint the parent element of tabs something so we can better see it's boundaries: #tabbrowser-tabs > .scrollbox{ background-color: #191919 }
Now, it should be evident that this element is much wider than our only tab. So, how do you make tabs wider? The width property .tabbrowser-tab{ width: 200px }
ought to set width but if you try it nothing will happen.
Both in Toyfox and in Firefox the tabs have this flexing property. In essence it means that if there is space then the tabs try to grow to fill that space. However, tabs also have a property called max-width
which sets a limit for how much the tabs can grow. And, the scrollbox is constrained from outside so that it cannot get any narrower. So in the end there will be empty space inside it.
Then when you add more tabs, they do get narrower until at some point they don't. They have now reached their min-width
and won't be scaled down anymore. Instead, since the .scrollbox width is locked the tabs will overflow since they can't fit otherwise.
Yeah, but I wanted to control the tab width - how? Just set max-width to something like 200px, or to none
if you want to make tabs expand to the whole scrollbox if they can.
Don't actually do the above in real Firefox though, as it will cause tab closing to not work properly. Use this instead
Height has exactly the same behavior. The point is that width and height properties only work if there are no external constraints or flexing behavior. But often that is not the case.
Shorthand properties
The observant you may have noticed that the provided examples have sometimes used background-color:
and other times background:
. There are actually multiple background related properties - background-color is just one of them. The .tabbrowser-tab{ background: blue no-repeat }
actually means this:
.tabbrowser-tab{
background-color: blue;
background-position-x: 0%;
background-position-y: 0%;
background-repeat: no-repeat;
background-attachment: scroll;
background-image: none;
background-size: auto auto;
background-origin: padding-box;
background-clip: border-box;
}
This is what is known as a shorthand - a property that sets all the background-related properties at once, and the browser uses some defaults for the properties that it can't find at the shorthand value list. The other background-* properties are related to background-image. You can test what happens with this: body{ background: red }
It makes the whole Toyfox editor red. Now change that to background-color. Is the behavior counter-intuitive? Perhaps, but it makes sense once you know that background-image is always drawn on top of background-color.
Background-image defaults to none, so the first example background: red
sets the background-color to red alright, but it doesn't mention background-image and so the existing image (the checkerboard) is removed. The second example only sets background-color which now is indeed red but it's behind the image. Now, if you also apply background-image: none
you should see that it is indeed red back there.
Why do we have both? Well, the background-image might have transparency. So in those cases the background-color would be visible through the image.
Another widely used shorthands are for padding and margin. Both have this format .toolbarbutton{ margin: 1px 2px 3px 4px }
is same as:
.tabbrowser-tab{
margin-top: 1px;
margin-right: 2px;
margin-bottom: 3px;
margin-left: 4px;
}
If the shorthand value list only has one value, then that is applied to every margin. If it has two values, then the first is for top and bottom, the second is for left and right. Same applies to padding.
Yet another is border. This format is pretty widely used: border: 2px solid black
. This sets all the borders (top/right/bottom/left) to 2px wide, solid color where the color is black. Another useful is Border-width property which is like a sub-shorthand. It takes up to four values in same format as padding and margin does and only sets width related border-properties.
Usually, all properties that you see used that have a whitespace separated list of values are shorthands and as such may set more properties than they seem at first. But again, don't be afraid to refer to MDN to look up what properties actually do.
Variables
Also known as custom properties but I think that variable is a more descriptive term. A property that begins with a --
indicates that it is a CSS variable. Syntactically they are applied to elements just like any other property, but they don't do anything unless some element actually uses that variable. So how are they useful?
There is a high chance that you want different elements to share some color. But if you want to be able to change that color at some time, or in certain conditions, you would need to change that color for all affected elements. Sounds quite a lot of work, fortunately variables are a solution to this problem. Let's see, Toyfox uses this blue-ish color for toolbar, sidebar and selected tab, right? To change that we would need to do something like this:
.tabbrowser-tab[selected],
#nav-bar,
#PersonalToolbar,
#sidebar{
background-color: rgba(20,40,10,0.7);
}
Okay, in this case that wasn't so bad. But once we add more conditions and more elements to that should be affected the complexity quickly build up and becomes really hard to manage. So what if you wanted to set this color based on what tab is selected? Firefox and Toyfox have a title attribute on #main-window that reflects the current tab title. You can ue that but the selectors become annoying:
#main-window[title="a Tab"] .tabbrowser-tab[selected],
#main-window[title="a Tab"] #nav-bar,
#main-window[title="a Tab"] #PersonalToolbar,
#main-window[title="a Tab"] #sidebar{
background-color: rgba(20,40,10,0.7);
}
And if you want to add colors to other titles too then you'll have to repeat all that. But with variables we can do this:
#main-window{ --background-color: rgba(30,40,66,0.7) }
#main-window[title="a Tab"]{ --background-color: rgba(20,40,10,0.7) }
#main-window[title="tabberino"]{ --background-color: rgba(40,40,10,0.7) }
#main-window[title="tab this"]{ --background-color: rgba(80,40,40,0.7) }
.tabbrowser-tab[selected],
#nav-bar,
#PersonalToolbar,
#sidebar{
background-color: var(--background-color);
}
See, now we can just set the variable value on #main-window based on some condition and use whatever this color happens to be in the elements we want. How cool is that! But remember that even if we set the variable for #main-window it does absolutely nothing unless it is used somewhere. That's why we need to refer to it by using the var()
function.
The variable is visible to all elements in the branch that it is set in. You can override it on any branch that you wish though. You can for example add this:#navigator-toolbox{ --background-color: olive }
and the value will be changed for toolbars and the tab but not sidebar. Sidebar still "sees" the value in #main-window since it is not in the #navigator-toolbox branch.
Variables are very heavily used inside Firefox. There is absolutely enormous amount of different conditions, not to mention theming support which would not be practical without them. That is why you may have often seen rules like #main-window{ --toolbar-bgcolor: rgba(25,25,200,.5) !important; }
to change the Firefox UI color. Elements use the color in that variable by built-in rules. We just override that variable. And of course the elements stop respecting this variable if their background-color is not set to refer to the variable anymore.
Pseudo-elements
We already talked about pseudo-classes (:hover,:not(),etc.) remember? Pseudo-elements are different beasts, don't mix the two. So what are these then? Pseudo-elements are a way to add some content to the document.
Now that should ring some bells. If you remember, in beginning I said that we can't modify the document with CSS. Pseudo-elements are the one exception to that very important rule. They don't come without restrictions though. This is how they work:
.tabbrowser-tab::before{ content: "1" }
.tabbrowser-tab::after{ content: "2" }
This creates elements which are first child and last child of .tabbrowser-tab. It's not possible to create these somewhere in-between. However, they are not restricted to simple text elements. We can control their box-model and appearance just like any other element. The other restriction is that they are not really in the document tree. They can't have attributes or pseudo-classes of their own. So we can't do stuff like this:.tabbrowser-tab::after:hover + .tab-icon-image{ ... }
Basically that translates to "apply these to tab icon if the cursor is on top of the pseudo-element".
So let's experiment a bit. Real browsers show the url of link and bookmarks in the corner of the window. Now, toyfox doesn't have that feature.  So how should we go about doing that?
Now, the information we need is only stored in the title attribute of each .bookmark-item so that is definitely the highest-up element we can work with. The information doesn't flow outwards in the tree right? Next, we need to show something new, but we just learned we can do that with pseudo-elements. Now of course we only want to show stuff related to the bookmark that is under the cursor. :hover
does just that. So at this point we have:
.bookmark-item:hover::after{
content: "bookmark";
}
Now, that isn't too helpful is it. Don't worry about the content just yet. More pressing matter is that we definitely don't want to show the content inside that bookmark. Now, lets make fixed positioning useful for once. Apply position:fixed
and then bottom:0px
and right:0px
like we did with the demo box earlier.
Now we are getting somewhere. So we have a box with text now in roughly the correct place. Add some light background color of your choosing to it and then make the text black with color:
property. Well alright, now perhaps slight padding to it maybe padding: 1px 5px;
for 1px vertical and 5px horizontal. Would maybe look better still with a 1px border on top and left side. So lets do that by using what we learned about shorthands.
border: solid rgb(90,90,90);
border-width: 2px 0 0 2px;
We use the first shorthand to quickly set all borders to some solid rgb() color. And then use border-width shorthand to set the individual border-widths. As a final touch we can add small rounding effect with border-radius: 4px 0 0 0;
Ok, well it looks fine now but that static text ain't too helpful still. Right, well content property can actually be used to show attributes of the parent element by using attr()
function. So instead of "bookmarks"
use attr(title)
The whole thing should look like this:
.bookmark-item:hover::after{
content: attr(title);
position:fixed;
bottom:0px;
right:0px;
background:rgb(210,210,210);
color: black;
padding: 1px 5px;
border: solid rgb(90,90,90);
border-width: 1px 0 0 1px;
border-radius: 4px 0 0 0;
}
Dang, now that is pretty awesome don't ya think?
Specificity
The idea here is as following; your stylesheet may have hundreds of rulesets but what do you do when some rules "collide"? Such as this case:
.tabbrowser-tab{ background: blue }
.tabbrowser-tab[selected]{ background: red }
You might be tempted to say that whichever comes lated will be used. Makes kind of sense, and in fact that is what can happen. But the order of the rules in the stylesheet is only the last thing that the browser checks when determining importance. And indeed, if you put those rules in opposite order, the tab will still be red
Priority in descending order:
- Declaration has "!important" tag
- Element uses inline style (elements may have "style" attribute)
- Selector uses ID
- Selector uses class, attribute or pseudo-class
- Selector uses tag name
- Selector uses universal selector *
- Declaration becomes later in the css file
We can increase specificity by adding more selectors to the one we want, such as .scrollbox > .tabbrowser-tab{ background:blue }
. See, now it has two class selectors and will override all that only have only one. However, now both this and the one that uses [selected] attribute have two of the same "level". Now whichever comes later will be used.
Any "amount" of the lower level items won't win against one higher up, if that makes sense. What this means is that if we have this:
#tabbrowser-tabs .tabbrowser-tab{ background: blue }
div.scrollbox > div.tabbrowser-tab[selected]{ background: red }
Here the top one has 1 ID-level selector and 1 class-level selector. The bottom has 3 class-level selectors and 2 tag-name-level selectors and is later in the file. But the top one will always win because it has on ID-level selector. The bottom could have million class-level selectors and it still won't win.
Now, Firefox UI uses for some purposes style attributes. These win against #ID selectors though, and for those cases we have no option other than to resort to:
The infamous !important
tag. Just add that after the property value: .tabbrowser-tab{ background: red !important }
Now remember Firefox has whole bunch of CSS rules built-in, so your rules are competing against those. This means that often you need to increase specificity and the !important tag is usually the easiest way to do that. In some rare cases the built-in rules might also use !important so then you have no other option than to increase specificity by other means.
Congratulations! That was all about the CSS basics. Hopefully you have by now the general idea about how things work. Seriously, that was a lot of information so you can pat yourself in the back for me.
So well next be looking Firefox more specifically. Although it's similar to Toyfox there a loads of different behavior and additional stuff that isn't possible or practical to emulate with Toyfox. And sadly, documentation is pretty scarce, although MDN has some bits and pieces
But you are of to a great start, but still have the rest of the course to run.
Browser Structure
TBD


Top: Basic types: string: Operators
#include <ptypes.h> class string { // assignment string& operator =(const char*); string& operator =(char); string& operator =(const string&); friend void assign(string&, const char* buf, int len); // concatenation string& operator +=(const char*); string& operator +=(char); string& operator +=(const string&); string operator +(const char*) const; string operator +(char) const; string operator +(const string&) const; friend string operator +(const char*, const string&); friend string operator +(char c, const string&); // comparison bool operator ==(const char*) const; bool operator ==(char) const; bool operator ==(const string&) const; bool operator !=(const char*) const; bool operator !=(char c) const; bool operator !=(const string&) const; // indexed character access, 0-based char& string::operator[] (int index); const char& string::operator[] (int index) const; }
The string class defines the following binary operators: assignment (=), concatenation (+), concatenation with assignment (+=) and comparison (==, !=). At least one of the operands (either left or right) must be of type string. Another operand can be one of the following: char, char* or string.
Indexed access operator allows to store or retrieve a value of an individual character. The index is 0-based. When compiled with either DEBUG or CHECK_BOUNDS conditional symbol, bounds checking is performed for the indexed access; if the index is out of bounds (i.e. less than 0 or equals to or greater than the length of the string), an unrecoverable error is raised. The non-debugging version of the library never checks for index overlfows, thus making your program somewhat faster but less safe.
Examples
string s1 = "abc", s2 = 'd', s3; s3 = s1 + s2; s2 += "ef"; s3[2] = 'B';
See also: Constructors/destructors, Typecasts, Manipulation, Conversion


Prhymer: How It Came To Be
If you’re not interested in the history of why I came to build this, go to the post on How It Works.
Sometime towards the end of high school in early 2015, I became quite interested in the idea of creating a program that could write rap lyrics. In the process of exploring what it might take to build such a thing, I inevitably came to the problem of finding rhyming words. Finding rhyming words would involve creating some sort of way of finding how well any two given words rhymed with one another.
Out of all the tasks that would need to be accomplished to build such a thing, this problem seemed to be the simplest so I decided to tackle it first. “What could be so complicated, it’s just a matter of finding alignments between strings?” This, of course, ended up being fairly naive of me. English’s orthography-to-phonology translation happens to be fairly awful so often you’ll have two words that clearly rhyme but do not have similar sequences of characters that would lead you to believe that they rhyme.
Tackling the fact that English has fairly awful orthography-to-phonology means you’re gonna have to pursue one of two options:
- Build some sort of translator that would take substrings of a word that are known to typically create a certain sound and translate them to symbols that represent that sound (what I would later come to find out are called_ _phones).
- Find some sort of database that already has every English word’s spelling along with their symbolized pronunciations.
Not really even thinking that someone might have already done it and I could save myself the work, I set out to build number 1. This ended up being both a fairly straightforward process however with comparatively lousy results. Find common substrings that seem to usually create certain sounds and then write them down in an if-else cluster in a loop where the phonetic translation will be generated. Then you can move on to comparing the sequences of phones you just generated. There are a few problems that arise when building such a translator for English though:
- Many characters in the spelling of a word will have their phonetic output changed by the characters or sounds that came before it (sometimes even after). Finding all these cases is fairly troublesome and cases are encountered where the same environment produces two different sounds in different words. This means that the phonetic output of a word cannot be a function of the way it’s spelled.
- English orthography-to-phonology is horrible for the aforementioned reason.
Eventually realizing this, I took to Google to see if someone had already made an orthographic-to-phonological English dictionary. And I ended up finding out that someone(s) had. This was a fairly bittersweet moment. Bitter because I had already invested some time here and there for the past few weeks in order to try and make this translator and I didn’t want to see all my hard work being rendered essentially useless. Sweet because I no longer had to worry about all the cases where the phonetic transcription would not be correct and thus the measure of how two words rhyme could be completely off.
Now that I had an accurate English orthography-to-phonology dictionary, it was time to addressing the real meat of the problem: how do you compare two sequences of sound to see how well they rhyme?
Looking back, I should have just googled “sequence comparison algorithms” in order to draw some inspiration for solving this problem (or even better, being able to just directly adopt one to solve the problem). But I did not and ended up taking a fairly non-straightforward process to just end up creating a new sequence comparison algorithm. The most recent version (and the one that is presented in this post) only came about in the last few months in some spare time.
Even with all this switching of how I would do this, there was at least one common problem that arose in all versions: how are two elements (phones) considered as being a similar-sounding match and how much weight will each of these matches or non-matches hold? Upon some observation and inspection, I was finding that rhyming words were much more likely to sound like they rhyme if they have similar sequences of the same vowel sounds. Thus, it seemed to make more sense to put a higher value on having similar vowel sounds than similar consonant sounds.
There was also the problem of having two long sequences being compared usually yielding scores that would be impossible for any two shorter sequences to have. For example, comparing two sequences of sizes 2 and 3 will never yield as high of a score as two sequences of sizes 27 and 33. Thus it’s important to find how well two words rhyme based on a fraction/percentage rather than a raw score. Say the comparison of the former sequences yield a score of 2 while that comparison of the latter sequences yields a score of 22. Just because 22 > 2 doesn’t mean the second pair rhymes better. In fact, the two comparisons share the same fraction of a score (2/3 and 22/33 are both approximatively equal to 0.67). Thus they both have about 67% commonality.


Extract OpenGraph or meta tags from links.
https://unfurlify.mushroomcloud.moe/api?url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dz5iK8D-5T8s
url


This semester I am in a class in which we aim to analyze a "large" dataset. There is one text variable in particular that we want to draw some insight from.
We had just been told how to access the dataset minutes ago, and something along the lines of the below goes down.
Professor: So how is it going? Any issues loading the data? Does anyone have any immediate insights?
Student 1: I made a word cloud of [variable of interest]... the most common words seem to be foo, bar, baz, etc.
Student 2: I made a word cloud of [other string column] and the most common words are foo2, bar2, baz2...
Professor: Great. continues lecture
Me, after class to the Prof: Have you already done some analysis on this dataset? Did you know [variable of interest] is 68% null?
Professor: Actually, no, I haven't looked at it yet. That's... certainly good to know. drops some more knowledge
Next class, she called on me to bring this up, and I swear you could have heard a pin drop. 🤦♀
As with all of my classes, there are people in there much smarter than me - they know more models or more programming packages or more something. The students who spoke up initially already have real world experience in the field, but they forgot the first rule in the book... ABCD! Always Be Checking your Data.
Why? Because your data is almost never perfectly clean. I had a dataset come through where null values were coded as a string \N
... yeeeaaaaah.... Good luck finding that! At its most critical, your checks can alert you that something is seriously wrong. At its most benign, this can generate questions for later and give you an idea of the amount of cleaning you will need to do or lead to new avenues of analysis!
Here are some of the things I do (to a 🐼 data frame) before I even begin:
- Call
.head()
to peak at the first few rows. You can pass a number to investigate a larger amount of rows;.tail()
also exists. - Check for nulls
- Maybe rename columns
- For continuous variables, look at the range and check for outliers
- Maybe adjust how your program displays numbers with digits, so it is more interpretable
- For categoricals, check the number of unique elements with
.nunique()
. This can immediately alert you to issues with text - Make some quick histograms to check distributions
- If the dataset is large enough that memory may be an issue, make sure that the datatypes are appropriate for the content of each variable
I'll close out with one way to visualize null values in a dataset .
While this may not be practical on a larger scale without parallelization, you can use seaborn to create a heat map of your entire data frame. In the below example, I've obscured some information about what's in there, but I will tell you that the observations are in chronological order. In the absense of meta data, I think this tells a lot about this dataset.
1 2 3 4 5 6 7 8 9 10 11 12 |
|


{% extends "base.html" %} {% block content %}
No observation recorded yet
{% else %} {% for observation in observations %}ID : {{ observation.id }} Survey_ID: {{ observation.survey_id }} Value: {{ observation.value }} Frequency: {{ observation.frequency }}


Projects
This project consists of an interactive "game" where you can create various Pacman figures that move across the screen and bouce off walls.
Pacman
This project consists of two eyes that follow your mouse across the web browser and showcases the use of JavaScript's onmousemove event.
Eyes
This project consists of Los Angeles metro's route 4 real-time bus tracking using it's API. The buses are shown with markers that can be clicked for more info.
Realtime Bus Tracker


Hashtable is part of System.Collection namespace. You can read more about collections here. The Hashtable class represents a collection of key/value pairs that are organized based on the hash code of the key.  It uses the key to access the elements in the collection. The mapping function is used to assign numerical values (keys) to the data. This helps in categorizing the data, which speeds up search times when you search for it. Hashtable is an older .NET Framework type. It is slower than the generic Dictionary type. In hashtable we don’t declare type of the object with it signature.
Lest crate an example of hashtable.
static void Main() { Hashtable hashtable = new Hashtable(); hashtable[1] = "John"; hashtable[4] = "Mike"; hashtable[7] = "Bob"; }
We can use class constructor to crate empty table, and than assign values to the selected index.
Each element is a key/value pair stored in a DictionaryEntry object. A key cannot be null, but a value can be. DictionaryEntry defines a dictionary key/value pair that can be set or retrieved. DictionaryEntry have two properties value and key. We can use this structure to loop through all objects in the table.
foreach (DictionaryEntry entry in hashtable) { Console.WriteLine("{0} : {1}", entry.Key, entry.Value); }
We can use conditions to check the data status before performing an action
public virtual bool ContainsKey(object key);
Hashtables are much more efficient than most other search trees when it comes to finding data. They are used in all kinds of computer software – especially database software.
We can use method like Add() or Remove() function to manipulate data in easy to understand way.
hashtable.Add(1, "Sandy"); hashtable.Add(2, "Bruce");
This was just an introduction to the subject, hash table is more complex subject that involves many rules like that the hash function should assign unique keys to each data slot, but in practice a pair of keys might get hashed to the same table. This is called collision. There are two ways of dealing with it. I’ll describe both of them in next post.


The following elephant chart describes the content of this page and the dependencies of subsequent pages.
Tip: Click each elephant to navigate to the relevant page.
This page provides an overview of the Discovery Data Model and specifies the requirements that a common data model must meet.
The Common Data Model has an open and transparent design, includes a wide breadth of data types, and is human readable.
The Common Data Model enables you to:
The Common Data Model is key to achieving the objectives by enabling other software applications to:
The Common Data Model also supports:
The Common Data Model is not:
Approaches to modelling data vary and change over time. There is no consensus as to the way forward yet. From time to time, particular health services elect to use particular standards for particular purposes for a period of time. Standards evolve and new versions have to be supported; this is a continuous evolution.
It is generally accepted that there is no prospect of even one country converging to a common model of health data and information any time soon. Population health also requires access to environmental, social, and economic data; there is likewise no accepted standard for data across these other domains.
Many argue that even if there was a common model, there is a need for innovation and new formats will be needed. Therefore the emphasis has been on systems being able to communicate with other systems via standard message formats.
More recently people have come to understand that there has to be a shared understanding of how data is stored and processed within systems (at least logically). There is a greater acceptance that there could be a shared representation of data across a particular communicating community.
In answer to the question as whether to have yet another data model, the choices are:
The option selected will be determined by the requirements. Therefore requirements must be specified in advance of the decision.
The following section lists requirements for a common data model.
Important: The words must and will imply mandatory requirements.
A common data model must support:
The data model must include personal consent, governance, and record ownership policies.
Note: The implementation of those policies, during query or data access, is not part of the data model.
Important: Any interpretation of records must take account of governance and consent in addition to interpreting data model queries.
The data model must encompass the (historically separate categories) of model data that are:
The model must incorporate the following international taxonomies and ontologies, including the semantic definitions and relationships defined within these ontologies together with their definitional relationships:
The model must reflect data that has been submitted from systems that support the following structural constructs:
Subject to mapping (human) resource availability, the model must accept inbound data and provide outbound data in the following NHS standard formats:
The model must support proprietary taxonomies and local coding schemes that are relevant to the health data provided by the community.
Subject to mapping (human) resource availability and legitimate mapping potential, the model must accept inbound data and provide outbound data in documented message formats including:
The model must be able to be rendered, in part, in a textual format that is understandable by a health informatician without recourse to advanced tools other than simple viewers. Those viewers include but are not limited to:
Note: The model is likely to be vast and it will be impractical to present the entire model as a text document. However, a description of an item or a structure or a definition of a structure must be able to be understood by an informatician when represented in text.
It must be practical for a user to visualise and understand the model data in both a diagrammatic form, for example a node graph, or navigable text based form via a web application.
It must be possible to access a data model independently of any record stores; the data model itself provides a model of any store that might use it. This instance of the data model is disconnected.
It must be possible for entries in a particular record store to directly reference entries in an data model both for query and display.
Likewise it must be possible for an application to be able to access an data model together with a record store that references it concurrently. This instance of the data model is connected.
It must be possible for several record stores to reference the same data model instance.
Operating alongside a record store (connected model) , the model must support information query at the level of a population defined by users who are using an application that accesses the data model directly or via APIs.
The following is included as an example:
A researcher is interested in analysing people with anaemia and their presenting haemoglobin level, for example how anaemic were they before they are diagnosed? The initial question might be:
“For our local patients with anaemia, what was their lowest haemoglobin level?”
This is a seemingly simple question. But in fact it is quite complex. The blood test may have been done before the diagnosis or after, or both. The patient may have received a blood transfusion and the levels may be normal even though they were very low just a few hours earlier. Likewise the Hb level may have been normal only to suddenly drop and the lowest level recorded only after the diagnosis. That means that the enquirer needs to make a judgement as to which Hb level is the one that counts. What this question might really mean is:
“For our local patients with anaemia, what was the lowest level of haemoglobin around the time of the diagnosis?”
It is important to relate the haemoglobin to the anaemia diagnosis, so a time based judgement may be needed. This might lead to a further refinement:
- Find patients with a condition of anaemia and,
- For each patient find the lowest haemoglobin value where the haemoglobin measurement date is between 1 month before and 1 month after the anaemia onset date.
Therefore the model should contain the descriptions and definitions of the concepts that make up these, and other, questions.
Identification of misfiled data
It must be possible for users, reviewing an data model associated with a record store, to identify data that does not fit with the model’s specification.
The data model must identify data stored in the records that do not match the expected attribute values.
For example, A GP might record 'admitted to hospital' as an observation with an observed concept code. The model might model this concept as a historical record of a care event. Therefore the 'admitted to hospital' code could be said to be misfiled.
The data model should enable users to easily see that 'admitted to hospital' is present within an observation even though it does not fit with the value type of an observation concept.
Manual and automated maintenance
It must be possible to both manually maintain the data model and automatically maintain it from the following sources:
- Scheduled import of terminologies, taxonomies or ontologies.
- On filing of health data into the record store from systems deemed to have reached a level of quality in respect of the data held in them.


An EBNF parser and LL(1) checker, written in Scala.
This project consists of
ebnf
: an EBNF parser and formatting filterloner
: an LL(1) checker that depends on the
ebnf
libraryEach project is split into an API component and a Main.scala
CLI component. The CLI driver serves as an example of the API usage, as a
proof-of-concept, and as a useful tool for developers (especially those
working on language and compiler design).
The CLI drivers have the same interface: they read from standard in, or
from a file if passed one as a parameter. They output to standard out a
formatted grammar, suitable for machine consumption, or an error message if
the input is not EBNF-formatted (see below). Loner additionally errors if
the grammar is not LL(1). The exit status reflects the success state (0:
success, 1: not ebnf, 2: invalid arguments). Given the -h
flags
gives a help message. Given the -q
suppresses output.
Compiled binaries can be found in the Releases of GitHub
API documentation available for
Check out the live demo!
See the docs for the EbnfParser. In brief:
From Matt Might's specification
Rules look like name ::= expansion
Every name is surrounded by angle brackets, <
>
.
An expansion is an expression containing terminal symbols and non-terminal symbols, joined together by sequencing and choice.
A terminal symbol is a literal like ("+" or "function") or a class of literals (like integer). It must be surrounded by single quotes.
Simply juxtaposing expressions indicates sequencing.
A vertical bar |
indicates choice.
Example:
<expr> ::= <term> '+' <expr> | <term>
<term> ::= <factor> '*' <term> | <factor>
<factor> ::= '(' <expr> ')' | <const>
<const> ::= 'integer'
[ expansion ]
, indicates that this
expansion is optional.For example, the rule:
<term> ::= [ '-' ] <factor>
allows factors to be negated.
For example, the rule:
<args> ::= <arg> { ',' <arg> }
defines a conventional comma-separated argument list.
()
, to explictly define the order
of expansion.For example, the rule:
<expr> ::= <term> ('+' | '-') <expr>
defines an expression form that allows both addition and subtraction.
This version of EBNF admits a "comment-like" extension syntax: a #
escapes
the rest of the line, such that it is not parsed at all. Indeed, it is not
kept in the grammar object at all, so the result of formatting loses the
comments (considered a feature: it cleans the output for consumption by
another tool).
The following grammar from the tests is thus valid:
# this is a comment
<A> ::= 'a' # a values
| 'b' # b values
| 'c' # c values
;
All whitespace is ignored.
Loner is configured and built using sbt
, and conforms to all
the standard commands. Because it provides main methods, the project code
may be run via run
.
The two primary projects are loner
and
ebnf
. Switch between them with project
; loner
depends on ebnf, for ease of development.
Documentation is generated via scaladocSite
.
sbt-site
and sbt-ghpages
provide site-generation
tools for the website.
Tests are written using scalatest
and are accessible via the
standard test
commands. All API features require tests—new
features or bug-fixes should ensure test coverage, in the style of the
originals.
It also uses the assembly
plugin (providing an
assembly
command), which is used to generated FAT executable
jars—these jars have no dependencies other than a working java runtime
environment, and are uploaded in the releases section. They can be executed
directly (chmod -u+x <jar> ; ./<jar>
) or via java
(java -jar <jar>
).
Does not support escaping special characters (yet).
This project was built while enrolled in Comp 520 at UNC Chapel Hill, taught by Dr. Jan Prins, in Spring 2019. The topics of this compilers course inspired loner.


NAME
zip_fopen,
zip_fopen_index —
open file in zip archive for reading
LIBRARY
libzip (-lzip)
SYNOPSIS
#include <zip.h>
zip_file_t *
zip_fopen(
zip_t
*archive,
const char
*fname,
zip_flags_t
flags);
zip_file_t *
zip_fopen_index(
zip_t
*archive,
zip_uint64_t
index,
zip_flags_t
flags);
DESCRIPTION
The
zip_fopen() function opens the file name
fname in
archive. The
flags argument specifies how the name lookup should be
done, according to the values are described in
zip_name_locate(3). Also, the
following values may be
or'ed to it.
-
-
ZIP_FL_COMPRESSED
- Read the compressed data. Otherwise the data is
uncompressed by zip_fread().
-
-
ZIP_FL_UNCHANGED
- Read the original data from the zip archive, ignoring any
changes made to the file.
The
zip_fopen_index() function opens the file at position
index.
If encrypted data is encountered, the functions call
zip_fopen_encrypted(3) or
zip_fopen_index_encrypted(3)
respectively, using the default password set with
zip_set_default_password(3).
RETURN VALUES
Upon successful completion, a
struct zip_file pointer is
returned. Otherwise,
NULL
is returned and the error
code in
archive is set to indicate the error.
ERRORS
-
-
- [
ZIP_ER_CHANGED
]
- The file data has been changed.
-
-
- [
ZIP_ER_COMPNOTSUPP
]
- The compression method used is not supported.
-
-
- [
ZIP_ER_ENCRNOTSUPP
]
- The encryption method used is not supported.
-
-
- [
ZIP_ER_MEMORY
]
- Required memory could not be allocated.
-
-
- [
ZIP_ER_NOPASSWD
]
- The file is encrypted, but no password has been
provided.
-
-
- [
ZIP_ER_READ
]
- A file read error occurred.
-
-
- [
ZIP_ER_SEEK
]
- A file seek error occurred.
-
-
- [
ZIP_ER_WRONGPASSWD
]
- The provided password does not match the password used for
encryption. Note that some incorrect passwords are not detected by the
check done by zip_fopen().
-
-
- [
ZIP_ER_ZLIB
]
- Initializing the zlib stream failed.
The function
zip_fopen() may also fail and set
zip_err for any of the errors specified for the routine
zip_name_locate(3).
The function
zip_fopen_index() may also fail with
ZIP_ER_INVAL
if
index is
invalid.
SEE ALSO
libzip(3),
zip_fclose(3),
zip_fread(3),
zip_fseek(3),
zip_get_num_entries(3),
zip_name_locate(3),
zip_set_default_password(3)
HISTORY
zip_fopen() and
zip_fopen_index() were added
in libzip 1.0.
AUTHORS
Dieter Baron
<
<EMAIL_ADDRESS>and
Thomas Klausner
<
tk@giga.or.at>


Got 'em. Huzzah! Never caught them in concert before. I'm seriously excited.
4/12/2008, 10:07:01 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Got 'em. Huzzah! Never caught them in concert before. I'm seriously excited.
4/12/2008, 10:07:01 AM
Favs: 0
Retweets: 0
link


Elephant Rides At Angkor Temples Finally To Be Banned By Cambodia
by Emily BrownOfficials in Cambodia have announced they are banning elephant rides at the country’s infamous Angkor temple park.
Advertisements
Millions of tourists visit northern Siem Reap every year to explore the Angkor archaeological complex, home to numerous temples built between the 9th and 15th centuries.
The park, a UNESCO World Heritage site, spans 400 square kilometers so many visitors opt to ride one of the attraction’s 14 elephants as they take in the spectacular monuments. The majestic animals have also been taught to put on performances for tourists.
Advertisements
However, the park has been criticised in the past because many of the animals being used are old or unhealthy. Animal rights activists have accused handlers of overworking the elephants and encouraged officials to stop using the elephants for the tourists’ entertainment.
Their efforts paid off as news of a ban was announced earlier this year and an official confirmed today, November 15, it will come into place early next year, The Straits Times reports.
Long Kosal, a spokesperson with the Apsara Authority, which manages the park, admitted some of the animals were ‘already old’ and that ‘using elephants for business is not appropriate anymore’. Not that subjecting animals to cruelty should have ever been appropriate, but at least they’re finally making moves to rectify their mistakes.
The company that owns the elephants will continue to look after them, though the animals are being moved from the park to a community forest about 25 miles (40 kilometres) away.
Advertisements
Kosal added:
They will live out their natural lives there.
So far, five of the 14 working elephants have been moved and the rest will be gradually transported throughout the next couple of months.
The rides – and therefore hopefully the animals’ suffering – will officially ‘end by the start of 2020’.
Advertisements
The confirmation of the ban comes three years after an elephant collapsed and died at the park while carrying two tourists.
At the time, the Independent reported a veterinarian examined the elephant and determined it died ‘due to high temperatures, heat exhaustion and lack of wind that would have helped to cool her’.
Another working elephant died at the popular attraction last year, after which a petition to end the elephant rides gained over 14,000 signatures.
Hopefully the beautiful animals will get to live the happy lives they deserve when the ban comes into place.
Emily Brown first began delivering important news stories aged just 13, when she launched her career with a paper round. She graduated with a BA Hons in English Language in the Media from Lancaster University, and went on to become a freelance writer and blogger. Emily contributed to The Sunday Times Travel Magazine and Student Problems before becoming a journalist at UNILAD, where she works on breaking news as well as longer form features.


Local Hero A film review by Marty Mapes Copyright 1999 Marty Mapes
**** (out of 4) LOCAL HERO is one of my all-time favorite movies. I can watch it again and again, year after year. Each time I see something new, and each time I see something familiar. It is my yearly pilgrimage to Scotland to visit old friends and homey places.
The setting is a charming small town called Ferness. The town is geographically and economically isolated. It conists of a small row of houses, pressed between a cliff and the sea. There is a pub, a tiny hotel, a church, and one red phone box.
The inhabitants of Ferness are good, kind, small-town folk. Fishermen pull a living from the sea and everyone else makes a living however they can, doubling up on jobs when necessary. They may appear quirky at first, but once you get to know them, they are no more unusual than your own friends and family.
Ferness sounds like an idyllic town, ripe for a fairy tale. The film does indeed start out that way. There is an uncaring villain who works for corporate developers.  There is even a mermaid.
What ACTUALLY happens is less a fairy tale and more human nature.
A big oil company sets out to buy the scenic little town on a bay in north Scotland. It plans to replace the town with an oil refinery.
The oil company sends "Mac" MacIntyre (Peter Riegert) from acquisitions to buy the land. (He's actually Polish, but he's got the right name for the job.) He'd rather deal over the phone, but the company insists he be on-site. He arrives and meets Danny (Peter Capaldi), his assistant while in Scotland, and Marina (Jenny Seagrove), a marine biologist working for the Aberdeen branch of Knox Oil, who wants to turn the bay into a marine sanctuary. (She knows nothing of the company's plans, and wouldn't believe them even if she knew.)
Mac and Danny head up to Ferness where they meet Gordon Urquhart (Denis Lawson), hotel proprietor, accountant, and barkeep. Mac confirms to Gordon the rumor that the the oil company wants to buy all of Ferness. He entrusts Gordon, as the local accountant, to meet with the populace and work out some numbers for the purchase of the town. In the meantime, Gordon suggests that Mac take a look around; get to know the place.
Mac spends the day settling in and walking around the beach in his suit and tie with Danny trailing behind. They spot an old man in the distance, doing the same.
The townspeople of this paradise are thrilled at the chance to sell their land and become instant millionaires. That night, when Mac has to call home, he learns his name and reputation have preceeded him. He has become a local hero to these people he'll make rich, and they instantly take a liking to him.
The next day Mac has lightened up a bit. He still has his suit on, but he fits in better. The locals are starting to accept him as part of the population, and he's even learned a name or two. Eventually Mac slips farther and farther into the local life. Each scene shows Mac in less and less formal clothes as he grows more and more fond of Ferness. Meanwhile, Gordon carries on the business of arranging for the sale of the land.
As the deal draws near, the locals call a ceilidh (pronounced "Kay-Lee", it means town meeting) to socialize and talk about the deal.  Grizzled fishermen argue over the relative merits of Mazzeratis and Ferraris.
Everyone has a great time with the POSSIBLE exception of Mac. Mac has grown to love this town and its people. The ceilidh only cements the sense of community that Mac wants in his life, that only the undeveloped village could provide. Ironically, he will be the destroyer of the village, and even more ironically, he will be the only one who feels its loss.
At the emotional apex of the story, Mac, uninhibited with drink, asks Gordon to trade with him. Everything. The car, the house, the job. Mac wants to trade his Porsche, his six-figure salary, and his stock options, for Gordon's life in Ferness, doing odd jobs, running the hotel, being the local bartender, and living a simple life. Nothing comes of the proposition, but it is the point when Mac sheds his shell and bares his soul.
The deal is nearly sealed when, the next day, Mac and Gordon get a shock. Ben (Fulton Mackay), the old man who walks the beach, actually OWNS the beach, and he won't sell. Mac's boss, Mr. Happer (Burt Lancaster) flies to Ferness to close the deal himself.
Happer and Ben, who share an interest in astronomy, become fast friends and somehow, Old Ben manages to change Happer's mind, at least about the refinery. Happer still wants to acquire the site, but not to destroy it. He wants to build an observatory, an institute for scientific research. Marina was right all along.
Nearly everyone is happy with Happer's new arrangement. The townspeople will still get to sell their property. Happer gets his bay. Ben keeps his beach. Marina gets her laboratory, and Danny gets Marina.
But not everyone wins. In the most devastating moment of the film, Happer tells Mac to pack up and head back to Houston immediately to take care of business from that end. It becomes painfully clear how far Mac has fallen in love with Ferness-when he gets the order to return, he is in a sweater, he has five o'clock shadow, and he's eating an orange that Ben found on the beach. When the film cuts to him in his creaseless suit and crisp tie, we understand what a transformation he had undergone while in town.
Mac obeys his boss, but before he leaves he puts his outer shell back on. He insists on paying for his stay at the hotel, he shaves, he dresses properly, and his businesslike manner almost conceals the disappointment in his face.
He walks into his cold, cramped, fluorescent apartment, smells the sea shells he brought back, and hangs up the snapshots he took of Ferness.
He steps out on the balcony and looks out at the bleak neon skyline of Houston, with its traffic and sirens, longing for the friendly open streets of Ferness.
Mac can't return and see Ferness. Work will presumably keep him in Houston, and development will soon forever change the place.
But I can go back, year after year, and I do. With each viewing, the simple joy of life at Ferness, and the transitory pricelessness of that particular time and place becomes more and more dear.
Check out more current movie reviews at http://www.moviehabit.com
-- Marty Mapes<EMAIL_ADDRESS>Movie Habit http://www.moviehabit.com
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


To add an anchor just enter the domain name. E.g saza.com.ng
Note that by addidng an anchor this way, you automaically trust this anchor and will be able to hold all its assets. You can hold single assets using the change trust function


{% extends 'base.html' %} {% block content %} {% if notfound %}
Enter a crypto currency symbol into the Navbar "Lookup Crypto" field above...
Then, just click "Lookup"" for current Price, 24h High, 24h Low, and Market Cap will all be returned to this screen.
{{ crypto.Message }}
Price: {{ value.USD.PRICE }}
24h High: {{ value.USD.HIGHDAY }}
24h Low: {{ value.USD.LOWDAY }}
Market Cap: {{ value.USD.MKTCAP }}


Director Robert Zemeckis ("Back to the Future") describes the screenplay of "What Lies Beneath" as "written in the language of Hitchcock." I am not sure if that is as insulting as Gus Van Sant's abominable "Psycho" remake but it comes close. Not only does such a statement make me want to vomit, but it further illustrates how audiences today might be compelled to agree, since they will accept anything with two glamorous movie stars. Actually, it is written in the language of "Scream" and every slasher flick post-"Halloween," and the truth is that all of those films are superior to this monotonous, suspenseless and incredibly silly thriller.
Let's look at what lies beneath the episodic structure. The beautiful, luscious Michelle Pfeiffer plays Claire Spencer, the morose wife to Norman Spencer (Harrison Ford), a successful geneticist. They live in some country house by a lake in Vermont, and their daughter has just gone away to college. Claire misses her tremendously, and is beginning to feel the effects of loneliness and isolation, especially since her husband is working late hours. At home, she finds there are problems with the electrical outlets in the bathroom (well, she gets a little shock occasionally). Soon, she finds the front door to her house opens by itself. Then picture frames begin to fall by themselves. But wait!!! Who is the bearded gentleman living with his wife in the house next door? And could the wife have been killed by her husband?  And is this another remake of "Rear Window," but without Christopher Reeve?
So far, so good. I must say that this is a fine setup for a possibly supernatural thriller. And Pfeiffer plays her role straight, lending a sympathetic hand for this melancholy heroine. Is she seeing things, or is there really a ghost in the house? But, oh my, does Zemeckis and writer Clark Gregg screw it up by installing one too many red herrings. If you are one of the unlucky few who saw the trailer for this movie, you know the inevitable denouement and everything that leads to it. Suffice to say, I will not disclose much more except to say that the setup is completely ruined and fabricated, leading to a hodgepodge of other movies entirely.
Basically, "What Lies Beneath" is a hybrid of Hitchcock, "Sixth Sense," "Stir of Echoes," "The Stepfather" and anything else you can think of. Ask yourself this one question: are we seeing a thriller, a drama about a potential tryst, a ghost story, the latest slasher picture, or all the above? Apparently, Zemeckis and Gregg have no idea so they copy and paste it all together hoping it will make sense and surprise audiences. No sale.
I must say that I enjoyed the climactic, tense bathtub scene (recalling "Fatal Attraction's" bloody climax) and the lovely Pfeiffer's performance who invests more weight in the role than is necessary. There is also James Remar as the suspicious, curt neighbor (worth mentioning because he gives the best performance in the film, and he also bears an uncanny resemblance to Harrison Ford's bearded Richard Kimble in "The Fugitive") Unfortunately, Ford is left in the sidelines, barely registering any chemistry with Pfeiffer, and director Zemeckis is intent on throwing in the "fake scares" cliche, one after another, not to mention the old "the killer is never really dead" syndrome. From Ford, Pfeiffer, and Zemeckis, all that lies beneath is a lack of purpose.
For more reviews, check out JERRY AT THE MOVIES at http://buffs.moviething.com/buffs/faust/
E-mail me with any questions, comments or general complaints at<EMAIL_ADDRESS>or at<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


Movies
-
no country for old men
Year:
Director:
Cast: Actor1, Actor2, Actor3
Rating:
Brazil
A bureaucrat in a retro-future world tries to correct an administrative error and himself becomes an enemy of the state.

Year: 1998
Director:
Cast: Jeff Bridges, John Goodman, Julianne Moore, Steve Buscemi
Rating: R


THE THIRD MIRACLE A film review by Steve Rhodes Copyright 2000 Steve Rhodes RATING (0 TO ****): **
"Will a Chicago woman become the next saint?" asks the breathless television reporter on location at the site where the dead woman's blood appears on a statue of the Virgin Mary. Actually, the blood isn't currently in evidence since it only comes out during the month of November and only when it rains. Don't ask.
Yes, in THE THIRD MIRACLE it's time again to lambaste and lampoon one of Hollywood's favorites, the Catholic Church. The Catholic hierarchy is shown, as always, flaunting their wealth. The local bishop (Charles Haid) goes to fancy spas where he gets mud packs. Acting like a CEO, he hobnobs with other wealthy locals at $5,000 a plate dinners. The nefarious Archbishop Wener (Armin Mueller-Stah), known within the church as "the devil's advocate," rides in long black limousines and looks down at the people like unwashed rabble.
The church employs priests ostensibly to discover saints but actually to prove contenders unworthy of canonization. Chief among these debunkers is Father Frank Shore (Ed Harris), known as "the miracle killer." A cynical man, who has long since given up his own belief in God, Father Shore is convincing as a non-believer, however it is hard to imagine a time when he ever believed. Although he is shown as a ruthless investigator in the past, this time he proposes the Chicago woman as a saint with relatively little digging, one of the many problems with the script's credibility.
What director Agnieszka Holland (WASHINGTON SQUARE) gives us in the place of plausibility are lots of atmospherics. On numerous occasions she has the camera pan up the side of dilapidated inner city buildings to see the underbelly of low-flying, large jet planes overhead. Their loud rumble and their dominant size must have some important symbolism. What that meaning might be is less clear. The same goes for the film's wonderful, eclectic score. It doesn't go with the movie, but it's treat to listen to.
Harris, who is miscast as a priest, is given a female companion. Anne Heche plays Roxanna, the non-religious daughter of the would-be saint. Roxanna still resents the way her mother dumped her at age 16 so that the mother could follow God's calling. With attractive leads like Harris and Heche, think Father Shore might be inclined to break his vows of celibacy? This subplot is stuck into the story clearly just for the titillation factor.
If you need to know precisely what saints do once they go to heaven, the pedantic movie explains this and other mysteries. Father Shore tells Roxanna that saints are important because they have God's ear, so that people on earth can enlist the saints' help with God. "Do you believe all of this?" Roxanna asks him. "You ask tough questions," he replies after a pregnant pause.
The movie is like that interchange about belief. Masquerading as a religious picture -- the press kit talks more about saints than about the movie -- the film doesn't deliver. A movie can poke fun at religion and still seriously consider issues of faith, see DOGMA for example. THE THIRD MIRACLE, on the other hand, plays as a cheap mockery of serious faith. There are few members of the clergy in it that are credible.
When first confronted with the possibility that an American might be proposed for sainthood, European Archbishop Wener puts down such a ludicrous notion with xenophobic reasoning. "Is it truly the soil in which sainthood can grow?" he says in disbelief about America. Disbelief is what this movie is all about. One thing can be said for it, even if the picture is balderdash, it is quite well-acted balderdash. Harris, in particular, pours his heart and soul into a role that's lacking in both.
THE THIRD MIRACLE runs 2:00. It is rated R for some language, sex-related and violent images, and brief drug use. It would be acceptable for most teenagers.
Email<EMAIL_ADDRESS>Web: http://www.InternetReviews.com
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


A phony alpha pointing to the same binary. Meant as a placeholder to demonstrate multiple versions.
IMPORTANT: This data is being loaded from a URL.


Key: = Must support, = QICore-defined extension, = Is-Modifier
| Field | Card. | Type and Description |
|---|---|---|
| adjustment |
0..1
|
Money
|
| adjustmentReason |
0..1
|
Code
|
| amount |
0..1
|
Money
|
| date |
0..1
|
DateTime
|
| id |
0..1
|
String
|
| identifier |
0..1
|
Identifier
|
| type |
0..1
|
Code
|
Key: = Must support, = QICore-defined extension, = Is-Modifier


Today we've launched a new feature on BBLog.
The plugin gallery.
Everybody can add new BBLog plugins to the gallery.
The whole gallery will also be integrated into BBLog in the future.
But as of now, you can fill the gallery with your generated plugins.
Together we can make a cool new feature for the community.
In the future the user can select the gallery directly in battlelog, no need of code anymore, no need of JS urls anymore. Simple and easy.
Also for the plugin creators, we can track the plugin usage for the last 24h and you have a idea of how much your plugin have been active used. As i said, that's future music, but it comes.
Let's go, have fun with it.
A call to all plugin creator's that already have a plugin topic here on getbblog.com
Add your plugin to the gallery as well, in the future i'll remove the "Plugin" features from the topics, this means the "One Click Install" button, all focus for ready to use plugins should from now be in the gallery. The forums is now just for feedback and discussions.
If you found bugs in the Plugin Gallery or the Upload process? Post it here!
Krayziesoldier
Awesome job again!
GreatApo
Awesome!
I created / edited / uploaded 2 plug-ins with no problems. Everything is working!
Keep up the good work!
Question:
The new plug-in links have a "m" get parameter. What does it stand for? Is this necessary?
dapil
Plugin Developer
Looks awesome! I added all my plugins.
Topicstarter
BrainFooLong
Administrator
The m= parameter is a "nocache" parameter.
This will be automatically removed after some days of no change on the JS file.

Edit:
"Last update" works?
I just updated one of my plugins and it still says "Last Update: 08.09.2014 20:46"...


| Class | Description |
|---|---|
| Definitions |
Definitions for facebookjazz package.
|
| FacebookComment |
A user comment retrieved from Facebook.
|
| FacebookEvent |
Details of an event retrieved from Facebook.
|
| FacebookExtractor |
A high-level client implementation for retrieving user's Facebook profile contents.
|
| FacebookExtractor.ExtractedVideo |
Extended to contain video id from FQL queries
|
| FacebookGroup |
A group retrieved from Facebook.
|
| FacebookJazzDAO |
DAO for storing facebook summarization information.
|
| FacebookJazzService |
This service enables facebook profile summarization
|
| FacebookLike |
A Facebook like.
|
| FacebookLocation |
Location retrieved from Facebook.
|
| FacebookPhotoDescription |
Photo description retrieved from Facebook.
|
| FacebookPhotoTag |
Tag of a photo retrieved from Facebook.
|
| FacebookProfile |
a class containing a profile of a single facebook user
|
| FacebookRelationship |
Container for a relationship information retrieved from Facebook.
|
| FacebookStatusMessage |
Status message retrieved from Facebook.
|
| FacebookUserDetails |
output class for facebook user details.
|
| FacebookVideoDescription |
Video description retrieved from Facebook.
|
| FBFeedbackTaskDetails |
Task details for a Facebook feedback task.
|
| FBJContentCore |
FacebookJazz core methods.
|
| FBJContentCore.TagRemovalJob |
A job for removing all tags of a single user, generated by the Facebook Jazz service.
|
| FBJContentCore.WeightModifierRemovalJob |
Job for removing content for the user designated by data key JOB_KEY_USER_ID for services designated by data key JOB_KEY_SERVICE_TYPES
|
| FBSummarizationFeedbackTask |
An implementation of ASyncTask, meant for executing a Facebook summarization feedback task.
|
| FBSummarizationTask |
An implementation of ASyncTask, meant for executing a Facebook summarization task.
|
| FBSummarizationTaskDetails |
Details of a Facebook Summarization Task.
|
| FBTaskDAO |
DAO for saving and retrieving FacebookJazz tasks.
|
| FBTaskResponse |
A summarization task response received from an analysis back-end.
|
| WeightedStringElement |
An extension of an XML element with weight added as an attribute.
|
| WeightModifier |
A user defined weight modifier.
|
| WeightModifierList |
The list of weight modifiers.
|
| Enum | Description |
|---|---|
| FacebookEvent.RSVPStatus |
Reply status for a Facebook event.
|
| FacebookExtractor.ContentType |
Valid content types for a profile
|
| FacebookGroup.Privacy |
Facebook Privacy setting.
|
| WeightModifier.WeightModifierType |
content weight type
|
Copyright © 2015 Tampere University of Technology, Pori Department.