text:
<?php

include(__DIR__.'/config.php');

$mapo['title'] = "Me";

$mapo['header'] =  Template::Header();

$imageSlider = "";

for($i=1;$i<16;$i++){
  $imageSlider .= "

";
}

$host = "http://".$_SERVER['HTTP_HOST'];
$url = pathinfo($_SERVER["PHP_SELF"])["dirname"];
$sqlPath = "$host$url/files/sql-script.sql";
$sqlCodeContents = file_get_contents($sqlPath, true);

$sqlImagePath = "$host$url/img/mysql-cli.jpg";

$mapo['main'] = <<< TEMPLATE

        $imageSlider

KMOM07 - Projektarbete

KMOM06 - Bildhantering & galleri

Jag har en del programmeringserfarenhet av att jobba med bilder sedan tidigare. Mest med kanske .NET:s GDI+ med C# och sedan har jag jobbat lite med bildmanipulation med Actionscript 3 i Flash också. Det är väl
de språken som jag mest har manipulerat bilder med. Fast iofs kände jag tidigare till ImageMagick, har läst lite om det men inte gjort något direkt med det, kanske skulle prova det. Verkar som ImageMagick
har aningen lite mer features än GD, iaf om man läser om den här artikeln, men båda är bra och GD täcker väl de flesta behov man kan tänkas ha. Annars hittade
jag en trevlig jämförelse mellan GD, ImageMagick och Photoshop här. Då kan man ju få en bild av vilket verktyg man behöver vid vilket behov.

Det kändes väl ganska bra att jobba i GD och det är väl en bra samling av funktioner som finns där och PHP dokumentationen är ju behjälplig om man vill läsa mer om funktionerna. Det svåraste var väl alla
parametrarna intill img.php och hålla rätt på dem, för det blev ju ganska många av dem. Det var väl det svåraste med uppgiften. Ett stycke i taget var det ju ganska lätt, men att få alla fungera ihop var lite
svettigare. Det är ändå en rätt kraftfull bildhanterings-service man gjort. Kanske man skulle göra en variant med Imagemagick istället, och ha fler features till på det? Kanske även bygga ut det med databashantering
och liknande. Då skulle man ju ha något rätt bra. Annars tycker jag img.php är en bra funktion och jag lärde mig ju mer om cache-headers också, vilket var ju najs.

Jag tycker Anax (Mapo) - min webbtemplaten är rätt bra, skulle vilja ha routing i systemet rätt av iofs, utan att mecka med .htaccess-filer och annat mök. Sen att klasserna i src ligger i en egen folder
för varje klass är väl inte så snyggt. I egentligen skulle man vilja använda namespaces som är organiserade utefter mappstrukturen i projektet. Det tycker jag är bäst. Sen tycker jag sidkontrollerna är kanske
en aningen bara, fortfarande en aning för mycket procedurell programmering över det. Det jag i egentligen vill ha är ett riktigt MVC-mönster i projektet, men det här har varit en bra kurs för att lära sig strukturera
en webbapplikation från grunden, istället för att förlita sig på "magiska" ramverk, som man kanske inte förstår så mycket av som händer under huven. Det som jag tycker kanske känns bäst är väl CDatabase klassen, tycker
den är ett fullgott dataaccess pattern för att bygga applikationer med, och den använder ju PDO och transaktioner vid skrivoperationer och namngivna parametrar vilket jag tycker är alldeles förträffligt. Så där
har man ju rätt bra grejer där, rätt av. Annars är jag ganska nöjd med min design på websajten och har lyckats rätt bra med den.

Sen hade jag svårt med tid till studier under julhelgen i och med att man var bortrest en vecka och sedan skulle man flytta vid nyårsskiftet. Det var svårt att hinna med att studera och sätta sig till ro. Nu
är det fullt ös för att få slutprojektet i hamn innan januari slut så man kan börja med MVC-kursen.

KMOM05 - Lagring i DB

Objektorienteringen rullar på, och det känns bra. Är väl i egentligen inga större problem med att koda objektorienterat. Lite underligt är det trots allt i PHP i jämförelse
med C# - lite mer skriptspråk över det, antagligen ja för att det är ett skriptspråk. Nu blir det en del kataloger med varsin klass. Det kan väl iofs vara bra, men när projektet
växer - då kan vi säga att vi skapat ravioli-kod. På ett sätt är det väl bra, men i längden kanske det är bättre att klumpa ihop det
i större enheter.

Jag har väl inga problem att tänka objektorienterat när jag programmerar - har ju gjort det rätt länge. Men vad är optimal design? Det är där de svåra frågorna kommer fram.

Det blev en del moduler som CContent, CPage, CBlog, CTextFilter. De större modulerna blev välsignade med en egen instans. Det tycker jag de var värda. Mindre moduler eller sk hjälpfunktioner
fick förbli vara public static. Det är ju ändå rätt behändigt med det, trots en del motstånd mot public static inom den renläriga objektorienteringsskolan. Men jag är pragmatiker, och gillar att följa iaf
två regler - KISS och DRY.

Den funktion som jag kände var mest nyttig var väl CTextFilter - speciellt kanske markdown funktionen. Med den kan skapa mycket skojigt. Annars känns det väl bra också att jag implementerar arv i dataaccess-logiken,
tycker det skapar bra struktur i applikationerna, och ger mindre repetitivt skrivande. Det är också bra. Sedan börjar man bli mer bekväm med PhpStorm editorn. Tycker den är toppen alltså, bara en sak som sparar oändligt mycket tid
i ett stort projekt är med F12 på ett metodnamn kan navigera till definitionen på den. Annars är jag också nöjd att jag implementerat transaktioner i PDO när man skriver till databasen. Känns som det är nödvändigt för vilka
applikationer som helst i egentligen, inte bara affärskritiska. Allt är väl kritiskt eller viktigt för den som använder applikationen. Då vill man ju inte förlora data som man skapat?

Det går ju att pula med sådant hur länge som helst, speciellt om man vill få gränssnittet snyggt och rent och skapa mer behändiga funktioner kring huvudfunktionaliteten i det oändliga. Men överlag är jag nöjd.
CContent tog ju mest tid att implementera. Annars har julen varit bra, mycket mat och dryck har det blivit och en och annan julklapp fick man av tomten också.

Hyvää joulua!

KMOM04 - PDO och MySql

Jag har inte gjort efter övningen rakt av, utan gjort efter eget huvud vad jag tyckte verkade vara bra. För övrigt tycker jag paginering och sortering i dagens läge borde
skötas av klienten, genom javascript företrädesvis för det är trots allt Webb det här handlar om. Tycker väl att det nästan blir bökigare att bygga så här mycket funktionalitet genom
en helt serverbaserad lösning som tämligen klumpig och saknar en hel del i UX. Men men, sånt är livet. Lite javascript har jag skrivit trots allt, bara för att höja användarupplevelsen till
en slags minsta gräns.

Själva sökfrågan ligger i en klass CDatabase i en metod GetMovies. Jag har använt mig StdClass som är ett anonymt objekt i PHP istället för en array. Det är väl inte så stor
skillnad, utan mer ett tycke om man tycker mer om objekt eller arrayer. Metoden bygger upp en dynamisk sql-sträng på vyn movies baserat på parametrarna in i metoden, men jag använder bindParam
från PDO som jag tycker är bra.
Det är en vanlig klass som man måste instansiera upp med publika metoder för att få tag i olika data som man behöver. Andra klasser som Helpers klassen och HtmlMovies har jag lämnat
dess metoder som public static för att slippa skapa en instans av dem och för att de mer agerar som utility funktioner.

Det är bra att känna till olika sätt att definiera en vy (view) -  MERGE vs TEMPTABLE ALGORITHM  - Om man skall definiera en vy skall man försöka använda sig av MERGE algoritmen istället för TEMPTABLE som isf
gör en table-scan av tabellen. Med MERGE kommer den optimera vyn att fungera som en vanlig sql-fråga istället. Annars kan man lämna den UNDEFINED vilket den är per default och försöker
då växla till den som är mest optimal för just den servern som databasen befinner sig på.
Annars är det ju en generell regel inom SQL att minimera antalet kolumner som vyn hämtar, hämta bara de som behövs. Exkludera de som inte behövs - allt för prestandan. Men vyer är ändå kraftfullt
och en av fördelarna är att de kapslar in komplicerad sql i ett lättåtkomligt anrop, vilket leder till mindre sqlsträngar i webbapplikationen, vilket är ett vanligt fel i sql-baserade webbapplikationer.

Lite länkar om vyer i mysql

http://stackoverflow.com/questions/10302615/mysql-views-performance

http://stackoverflow.com/questions/4426919/mysql-views-vs-php-query

http://stackoverflow.com/questions/4886874/are-mysql-views-dynamic-and-efficient

http://stackoverflow.com/questions/439056/is-a-view-faster-than-a-simple-query

http://www.hackvalue.nl/en/article/116/next_step_mysql_using_views_to_improve_performance

http://www.ovaistariq.net/667/mysql-using-views-as-performance-improvement-tools/#.VIYY-cnLJJQ

http://dba.stackexchange.com/questions/16372/when-to-use-views-in-mysql

http://www.percona.com/blog/2007/08/12/mysql-view-as-performance-troublemaker/

Kodnings standard
Jag har försökt ha en slags kodstandard i min kod, för att hålla kodbasen tydlig och förutsägbar. Ganska enkla regler, men som gör säkert stor skillnad i längden.

Max 3 input parametrar in i en funktion, annars gör man en klass eller en array av det.

Gruppera public och private properties och metoder var för sig för överskådlighet.

Separera klasser och metoder från dataaccess och rendering av html.

Reflektioner

Söksidan tog längre tid än jag räknade med och var bökigare än jag trodde, men det gick ju bra till slut. Det gick överlag bra att jobba med PHP PDO men några småproblem stötte man
väl på vägen. Nu när man jobbar objekt-orienterat känns det som det är kodning på riktigt i egentligen. Något annat skulle man inte vilja skriva. Min tanke är i alla fall att separera databasklasser
mot rendering av html. Det är iaf en no-no. Databasfunktioner skall finnas i egna klasser. Rendering av html skall finnas i andra klasser. Sen tycker jag är det är behändigt att kapsla in olika hjälpfunktioner
i egna klasser och funktioner, t.ex har jag en helpers klass som gör många av dessa repetitiva och tråkiga uppgifter, som kapslar in dem. Det minimerar ju en del redundans. Överlag känns det bra, och jag är redo
för mer!

Kippis ja kulaus!

KMOM03 - SQL och databasen MySql

 Jag har väl en ganska bra kunskap om SQL och databaser sen innan och har jobbat en hel del med databaser och kan en hel del om dessa. Mest med SQL Server och T-SQL som
är microsofts implementation av SQL-språket. Jag har skrivit massor av lagrade procedurer, vyer, triggrar, osv i det. Tidigare i mitt liv pluggade jag en ky-utbildning - Systemutvecklare .NET
inriktning databasdesign, så där läste vi flera databaskurser om just SQL Server, sen hade vi en kurs om Oracle med psql och ett moment om MySql också. Men bäst kan jag väl Sql Server följt av
MySql. Annars är jag väl också någorlunda bekant med MS Access också, och nu gick vi igenom SQLite i förra kursen också, så den kan man ju en del om också.

Kom igång med databasen MySQL och dess klienter

De här klienterna var jag bekant med sedan tidigare, hade ju de redan installerade på min dator. Så det var väl inget nytt för mig.

BTH's labbmiljö för databasen MySQL

Jag kopplade upp mig emot bth:s server med MySql Workbench. Föredrar den framför PhpMyAdmin.

Kom igång med SQL

Det var bra repetition med SQL-uppgiften. Det som kändes kanske lite obekant var att göra vyer i MySql. Annars var allt bekant sedan tidigare.
Annars känner jag mig obekväm med att anropa massor av vyer från andra vyer. Då får man massor av nästlade relationer till varandra och när en vy
ändras så kanske nästa kraschar. Och sen kanske prestandan inte blir det bästa heller. Överlag kan det bli en jäkla nästlad soppa av det tänker jag mig. Sådant beror väl på iofs,
om man kanske dokumenterar det.

Se sql koden för uppgiften

$sqlCodeContents

KMOM02 - Objektorienterad programmering i PHP

Jag har väl rätt goda kunskaper i objektorienterad programmering, jag jobbar ju dagligen med objektorienterad programmering i C# mestadels med ASP.NET MVC. Tycker väl att jag kan det rätt
bra, men allt kan jag nog inte ändå. Det finns nog en del saker som man inte har koll på. Men det är klart det är en liten omställning att skriva objektorienterat i PHP. Iofs har jag gjort det innan
på fritiden med lite småprojekt. Men framförallt känns det väldigt uppfriskande att koda i ett annat språk. Ändå känns väl objektorienterade lösningar som något som aldrig tar slut. Det går ju
abstrahera ut i all oändlighet. Tycker ändå det kan vara viktigt att sätta ner foten, nu är det nog; nu är det tillräckligt mycket abstraktion. Min filosofi är att få saker gjort med tillräckligt
mycket med klasser och tjafs.

Jag valde Månadens babe för att den uppgiften tilltalade mig mer än tärningsspelet. Jag började uppgiften med att göra en testsida för att testa olika tids- och datumfunktioner så att jag
hade det klart när jag började med uppgiften. Så resultatet blev en array of arrays av en månadskalender. Det var rätt skönt att ha koll på det innan jag började med att göra klasstrukturen. Så basen i projektet
är väl objektet CalenderDay som håller all information om en kalenderdag. Hela kalendern är en array av Kalenderdagar. Inte svårare än så. Men för att pumpa ut html:n på sidan har jag gjort en HtmlCalendar som
ärver Calendar och gör html-renderingen från basobjektet. En tanke skulle kunna extenda Calender som t.ex. en JSONCalendar eller en XmlCalendar som outputtar kalenderdatat i respektive data.
Sen själva arbetet var väl inte helt lätt, men gick bra till slut. De största problemen hade jag väl att få rätt med föregående månad och nästa månad blev rätt. Det uppkom en liten bugg under arbetets gång
som jag fixade under utvecklingen. Annnars tog ju stylingen av html/css en del tid, och är väl inte alltid så lätt som man tror, speciellt om man försöker få det någorlunda tjusigt. Hoppas det blev rätt bra,
design kan ju vara rätt subjektivt; men relativt nöjd av resultate är jag nog trots allt. Sen tog det en stund att fixa bilder till månadens babe och redigera dessa i Photoshop. Själv tycker jag att jag valde
rätt tjusiga damer. Iaf enligt personlig preferens. Sen hade jag lite problem med uppladdningen med Filezilla, fick ladda om det några gånger till, en katalog i taget och då funkade det bra. Sen fick jag också
 fixa till url:en på bilderna som inte syntes, men det fixade jag med. Alltsammmans blev en ny branch på mitt github-konto. Sedan mergade jag ihop
den med master-branchen. Annars känner jag mig nöjd över resultatet.

KMOM01 - Kom igång med PHP

Hej allihopa!

Jag heter Marko Poikkimäki och är 38 år gammal och bor i Göteborg. Jag har fru och två barn. På fritiden gillar jag att motionera lite blandat med styrke- och konditionsträning i allmänhet
och så tränar jag karate regelbundet. På dagarna jobbar jag som .NET utvecklare. Detta har jag gjort sedan jag gick klart en ky-utbildning till Systemutvecklare .NET år 2008. Men efter att ha jobbat ett antal år med Windows-plattformen vill jag bredda min kompetens till open-source världen. Därför läser jag det här PHP-kurspaketet för att lära mig
PHP ordentligt.

Bildspelet är från min familjs semester i Ibiza, Figueral i somras. Det var en väldigt trevlig semester.

Reflektioner:
 Det känns som nivån har höjsts sedan föregående kurs, lite mer att göra på varje moment. Det har varit lärorikt och jag tycker mig ha lärt en hel del nytt för mig om PHP. Men det har varit kul, webbprogrammering
 är verkligen roligt.

Utvecklingsmiljön som jag använder är  PHPStorm  som nog är den bästa och mest avancerade editorn för PHP. Efter en omröstning
gjord av Sitepoint blev editorn utsedd som bäst. Jag rekommenderar editorn, tycker den är bra, vilket andra verkar också tycka.
Sedan använder jag Notepad++ flitigt som texteditor också.
Bla annat använde jag Bower för att installera javascript-bibliotek i mitt projekt.
Annars sitter jag på Windows 8.1 med XAMPP installerat. Filezilla använder jag som ftp-klient. Använder även TortoiseGit vilket jag tycker underlättar i Git:andet.

Webbmallen fick namnet MAPO - efter mina initialer, lite ego kanske, men kan inte programmering vara en form av sjävbekräftelse?

Jag gjorde en egen design, för att jag ville ha en egen  och dumpade Anax projektets stil. Jag tog lite delar från mitt förra projekt BMO från HTMLPHP-kursen. Ägnade ju en bra stund med att fixa designen där så jag ville
gärna återanvända saker därifrån.

Source-filen gick bra att implementera och jag gjorde enligt instruktionerna.

Github använde jag och den hittar du här. Använder en kombination av cmd-line och tortoisegit.

TEMPLATE;

$mapo["pagescript"] = <<< TEMPLATE

    function showSqlCode() {
        $('#sql-code-container').slideToggle();
    }

    function toggleMySqlViews(){
        $('#mysql-list').slideToggle();
    }

    $(function() {
        $('.banner').unslider({ speed: 500, delay: 3000 });
    });
TEMPLATE;

$mapo['footer'] = Template::Footer();

include(MAPO_THEME_PATH);


text:
'use strict';

exports.__esModule = true;

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _classnames = require('classnames');

var _classnames2 = _interopRequireDefault(_classnames);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _bootstrapUtils = require('./utils/bootstrapUtils');

var _createChainedFunction = require('./utils/createChainedFunction');

var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var propTypes = {
  onClick: _react.PropTypes.func,
  /**
   * The toggle content, if left empty it will render the default toggle (seen above).
   */
  children: _react.PropTypes.node
};

var contextTypes = {
  $bs_navbar: _react.PropTypes.shape({
    bsClass: _react.PropTypes.string,
    expanded: _react.PropTypes.bool,
    onToggle: _react.PropTypes.func.isRequired
  })
};

var NavbarToggle = function (_React$Component) {
  (0, _inherits3['default'])(NavbarToggle, _React$Component);

  function NavbarToggle() {
    (0, _classCallCheck3['default'])(this, NavbarToggle);
    return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
  }

  NavbarToggle.prototype.render = function render() {
    var _props = this.props,
        onClick = _props.onClick,
        className = _props.className,
        children = _props.children,
        props = (0, _objectWithoutProperties3['default'])(_props, ['onClick', 'className', 'children']);

    var navbarProps = this.context.$bs_navbar || { bsClass: 'navbar' };

    var buttonProps = (0, _extends3['default'])({
      type: 'button'
    }, props, {
      onClick: (0, _createChainedFunction2['default'])(onClick, navbarProps.onToggle),
      className: (0, _classnames2['default'])(className, (0, _bootstrapUtils.prefix)(navbarProps, 'toggle'), !navbarProps.expanded && 'collapsed')
    });

    if (children) {
      return _react2['default'].createElement(
        'button',
        buttonProps,
        children
      );
    }

    return _react2['default'].createElement(
      'button',
      buttonProps,
      _react2['default'].createElement(
        'span',
        { className: 'sr-only' },
        'Toggle navigation'
      ),
      _react2['default'].createElement('span', { className: 'icon-bar' }),
      _react2['default'].createElement('span', { className: 'icon-bar' }),
      _react2['default'].createElement('span', { className: 'icon-bar' })
    );
  };

  return NavbarToggle;
}(_react2['default'].Component);

NavbarToggle.propTypes = propTypes;
NavbarToggle.contextTypes = contextTypes;

exports['default'] = NavbarToggle;
module.exports = exports['default'];

redpajama_set_name: RedPajamaGithub


text:
START_ATF_NAMESPACE
    int _guild_battle_suggest_request_result_zocl::size()
    {
        using org_ptr = int (WINAPIV*)(struct _guild_battle_suggest_request_result_zocl*);
        return (org_ptr(0x14025d5f0L))(this);
    };
END_ATF_NAMESPACE


text:
This repo will hold our email templates, which follow the patterns created by [Cerberus](http://tedgoas.github.io/Cerberus/).

## Contents
Our custom templates use media queries and are based off of `template-with-media-queries.html`. There's also `template-without-media-queries.html` that just uses a fluid, single-column layout, which we can also use as a base.

### `base-responsive-template.html`
This template shows the various components we might use in an email, such as thumbnails and buttons.

### `welcome-template.html`
This template is for the new welcome email in Intercom. [Here's the draft of the email](https://app.intercom.io/a/apps/604d24eb524b3aff74f79015ad1715189f0b38b4/messages/auto/5603181/edit) in Intercom.

### Assets
The folder `template-assets` contains the Droplr and social logos, but these are just for reference as I've hard-coded my own drop URLs for the images in the templates, like this:

`<img src="http://bernar.d.pr/rGG7+" alt="Droplr Logo" width="80" height="26" border="0" style="margin: auto;">`

## Intercom
In Intercom, the [Responsive Template](https://app.intercom.io/apps/604d24eb524b3aff74f79015ad1715189f0b38b4/custom_email_templates/8864) uses `welcome-template.html`.

For new templates, just copy the HTML over and insert a `{{ content }}` tag where the content of the WYSIWYG editor will go. The template also needs an `{{ unsubscribe_link }}` tag. The `welcome-template.html` template already has these in place.


text:
/****************************************************
 * Filter row class.
 *
 * Author: Surinder singh http://www.sencha.com/forum/member.php?75710-Surinder-singh, surinder83singh@gmail.com
 * Demo Page : http://www.developerextensions.com/index.php?option=com_extensiondemo&view=extensiondemo&layout=ext&extension=Ext-FilterRow_1.2&Itemid=482
 * @class Ext.ux.grid.FilterRow
 * Notes: Removed a columns resizable bug tested/told by gang.alecs@gmail.com
 ************************************************/
Ext.namespace('Ext.ux.grid');
Ext.ux.grid.FilterRow = function(config) {
    Ext.apply(this, config);
    this.addEvents(
        "change"
    );
    Ext.ux.grid.FilterRow.superclass.constructor.call(this);
};

Ext.extend(Ext.ux.grid.FilterRow, Ext.util.Observable, {
	init: function(grid) {
		this.grid = grid;
		this.grid.addClass('filter-row');
		var view = grid.getView();
		var headerTpl = new Ext.Template(
			'
',
				'

{cells}

',
			"
"
		);

        Ext.applyIf(view, { templates: {} });
		view.templates.header = headerTpl;
		view.templates.hcell = new Ext.Template(
			'',
				'
',
					this.grid.enableHdMenu ? '' : '',
					'{value}',
					'

',
					'',
				'
',
			'	'
       	);

        grid.on('resize', this.syncFields, this);
        grid.on('columnresize', this.syncFields, this);
        grid.on('render', this.renderFields, this);
		grid.on('render', this.renderFilterMenu, this);
		// private
		var FilterRow = this;
		view.updateHeaders = function(){
			this.innerHd.firstChild.innerHTML = this.renderHeaders();
			this.innerHd.firstChild.style.width = this.getOffsetWidth();
			this.innerHd.firstChild.firstChild.style.width = this.getTotalWidth();
			FilterRow.renderFields();
		};
        Ext.apply(grid, {
            enableColumnHide_: false,
            enableColumnMove: true
        });
		this.on('change', function(filterRow){
			grid.store.baseParams ={};
			for(var i in filterRow.data){
				grid.store.baseParams['filter['+i+']'] = filterRow.data[i];
			}
			grid.store.reload();
		}, grid);
    },
	filterOptionClick:function(filterMenu){
		filterMenu.filterInput.filterOption = filterMenu.value;
		if( filterMenu.value=='NoFilter' ){
			filterMenu.filterInput.setValue('');
		}
		this.onChange();
	},
	beforeFilterMenuShow:function(){
		var grid = this.grid;
		var view = grid.getView();

		var cm = view.cm,  colCount = cm.getColumnCount();

        this.filterMenu.removeAll();
		var filterOptions 	= cm.config[view.hdCtxIndex].filterOptions;
		var filterInput 	= cm.config[view.hdCtxIndex].filterInput;

		this.filterMenu.add(new Ext.menu.CheckItem({
			itemId:"filteroption-clear",
			text: 'No Filter',
			value: 'NoFilter',
			cls: "filteroption-nofilter",
			filterInput:filterInput,
			checked:(filterInput.filterOption=='NoFilter')
		}));

		if(filterOptions && Ext.isArray(filterOptions)){
			for(var i = 0; i < filterOptions.length; i++){
				this.filterMenu.add(new Ext.menu.CheckItem({
                    itemId:"filteroption-"+filterOptions[i].value,
					text: filterOptions[i].text,
					value: filterOptions[i].value,
					cls: "filteroption-"+filterOptions[i].cls,
					filterInput:filterInput,
					checked:(filterInput.filterOption==filterOptions[i].value)
                }));
			}
		}
	},
	setFilterMenu:function(){
		var grid = this.grid;
		var view = grid.getView();
		var filterInput = view.cm.config[view.hdCtxIndex].filterInput;
		if(filterInput){
			view.hmenu.items.get("Filter").setDisabled( false );
		}else{
			view.hmenu.items.get("Filter").setDisabled( true );
		}
	},

	renderFilterMenu:function(){
		var grid = this.grid;
		var view = grid.getView();
		this.filterMenu = new Ext.menu.Menu({id:grid.id + "-filter-menu"});
		this.filterMenu.on({
			scope: this,
			beforeshow: this.beforeFilterMenuShow,
			itemclick: this.filterOptionClick
		});

		view.hmenu.on({
			scope: this,
			beforeshow: this.setFilterMenu
		});

		view.hmenu.add('-', {
			itemId:"Filter",
			hideOnClick: false,
			text:'Filter',
			menu: this.filterMenu,
			iconCls: 'x-filter-icon'
		});
	},

    renderFields: function() {
		//alert('renderFields')
        var grid = this.grid;
		var filterRow = this;
        var cm = grid.getColumnModel();
        var cols = cm.config;
        var gridId = grid.id;
        Ext.each(cols, function(col) {
            if (!col.hidden) {
                var filterDivId = gridId + "-filter-" + col.id;
                var editor 		= col.filterInput;
				var clearFilter = col.clearFilter;
                if (editor) {
					if(Ext.isIE){
						col.filterInput = editor = editor.cloneConfig({value:editor.getValue()});
					}
                    if (editor.getXType() == 'combo') {
                        editor.on('select', this.resetNoFilterOption, this, editor);
                    } else {
                        editor.on('change', this.resetNoFilterOption, this, editor);
                    }
					new Ext.Panel({border:false, layout:'fit', items:editor, renderTo:filterDivId});
                }else if(clearFilter) {
					/*var clearFilter = new Ext.form.DisplayField({
							  text:'         ',
							  scope:filterRow,
							  tooltip:'Clear Filters',
							  tooltipType:'qtip',
							  value:'xxxxx',
							  handler: function(){
								this.clearAllFilters();
								this.grid.getStore().baseParams = {};
								this.grid.getStore().reload();
							  }
						 });*/
					Ext.get(filterDivId).addClass('ClearFilter');
					Ext.EventManager.addListener( filterDivId, 'click', function(){
						this.clearAllFilters();
						this.grid.getStore().baseParams = {};
						this.grid.getStore().reload();
					}, filterRow );
					/*new Ext.Panel({
					  border:false,
					  layout:'fit',
					  cls:'ClearFilter',
					  items_:clearFilter,
					  html:'xxxx',
					  renderTo:filterDivId
					});*/
				}
            }
        }, this);
    },

     clearAllFilters: function() {
        var grid 	= this.grid;
        var cm 		= grid.getColumnModel();
        var cols 	= cm.config;
        var data 	= {};
		var dataIndex = '';
        Ext.each(cols, function(col) {
			//alert(col.header);
            if (!col.hidden) {
                var editor = col.filterInput;
                if (editor) {
                	editor.setValue('');
					dataIndex = editor.dataIndex?editor.dataIndex:col.dataIndex;
                    data[dataIndex] 				= editor.getValue();
					data[dataIndex+'_filterOption'] = editor.filterOption;
                }
            }
        });
        return data;
    },

    getData: function() {
        var grid 	= this.grid;
        var cm 		= grid.getColumnModel();
        var cols 	= cm.config;
        var data 	= {};
		var value	= '';
		var dataIndex = '';
        Ext.each(cols, function(col) {
			//alert(col.header+'::'+col.hidden)
            if (!col.hidden) {
                var editor = col.filterInput;
                if (editor) {
					value = editor.getValue();
					if(editor.getXType()=='datefield' && value.format){
						value = value.format(editor.format);
					}
					dataIndex = editor.dataIndex?editor.dataIndex:col.dataIndex;
                    data[dataIndex] 				= value;
					data[dataIndex+'_filterOption'] = editor.filterOption;
                }
            }
        });
        return data;
    },
	resetNoFilterOption: function(editor){
		if(editor.filterOption=='NoFilter'){//if filter value have been changed , but "NoFilter" menu is still selected then reset it
			editor.filterOption = '';
		}
        this.onChange();
    },
    onChange: function(){
        this.fireEvent("change", { filter: this, data: this.getData() });
    },

    clearFilters: function(){
        this.fireEvent("change", { filter: this, data: {} });
    },

    syncFields: function(){
		//return;
        var grid 	= this.grid;
        var cm 		= grid.getColumnModel();
        var cols 	= cm.config;
        Ext.each(cols, function(col){
            if (!col.hidden) {
                var editor = col.filterInput;
                if (editor) {
                    editor.setSize(col.width - 18);
                }else if(col.clearFilter && col.clearFilter.setSize){
					col.clearFilter.setSize(col.width - 10);
				}
            }
        });
    }
});


text:
.ControlsBar {
  background-color: #333;
  color: #fff;
}


text:
import java.util.stream.IntStream;

public class RuthAaron {

    public static void main(String[] args) {
        System.out.println(new RuthAaron().check(714, 715));
        System.out.println(new RuthAaron().check(77, 78));
        System.out.println(new RuthAaron().check(20, 21));
    }

    boolean check(int first, int second) {
        return sumOfPrimeFactors(first) == sumOfPrimeFactors(second);
    }

    private int sumOfPrimeFactors(int n) {
        return IntStream.rangeClosed(2, n / 2)
                .filter(i -> isPrime(i) && n % i == 0)
                .sum();
    }

    private boolean isPrime(int number) {
        for (int i = 2; i < number / 2; i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }
}


text:
package org.drools.guvnor.client.asseteditor;

import com.google.gwt.event.shared.EventBus;
import com.google.gwt.user.client.ui.MenuBar;

/**
 * Creates a MenuBar component for a MultiViewEditor instance
 */
public interface MultiViewEditorMenuBarCreator {

    MenuBar createMenuBar(MultiViewEditor editor, EventBus eventBus);

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--
This file is part of dependency-check-maven.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Copyright (c) 2017 Jeremy Long. All Rights Reserved.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.owasp.test</groupId>
    <artifactId>verify-dependency-management</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <dependencyManagement>
        <dependencies>
            <dependency>
              <groupId>com.fasterxml.jackson.dataformat</groupId>
              <artifactId>jackson-dataformat-xml</artifactId>
              <version>2.6.3</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>


text:
class FullscreenControllerTestWindow : public TestBrowserWindow {
 public:
  // Simulate the window state with an enumeration.
  enum WindowState {
    NORMAL,
    FULLSCREEN,
    // No TO_ state for METRO_SNAP, the windows implementation is synchronous.
    METRO_SNAP,
    TO_NORMAL,
    TO_FULLSCREEN,
  };

  FullscreenControllerTestWindow();
  virtual ~FullscreenControllerTestWindow() {}

  // BrowserWindow Interface:
  virtual void EnterFullscreen(const GURL& url,
                               FullscreenExitBubbleType type) OVERRIDE;
  virtual void ExitFullscreen() OVERRIDE;
  virtual bool ShouldHideUIForFullscreen() const OVERRIDE;
  virtual bool IsFullscreen() const OVERRIDE;
#if defined(OS_WIN)
  virtual void SetMetroSnapMode(bool enable) OVERRIDE;
  virtual bool IsInMetroSnapMode() const OVERRIDE;
#endif
#if defined(OS_MACOSX)
  virtual void EnterFullscreenWithChrome() OVERRIDE;
  virtual bool IsFullscreenWithChrome() OVERRIDE;
  virtual bool IsFullscreenWithoutChrome() OVERRIDE;
#endif

  static const char* GetWindowStateString(WindowState state);
  WindowState state() const { return state_; }
  void set_browser(Browser* browser) { browser_ = browser; }

  // Simulates the window changing state.
  void ChangeWindowFullscreenState();

 private:
  // Enters fullscreen with |new_mac_with_chrome_mode|.
  void EnterFullscreen(bool new_mac_with_chrome_mode);

  // Returns true if ChangeWindowFullscreenState() should be called as a result
  // of updating the current fullscreen state to the passed in state.
  bool IsTransitionReentrant(bool new_fullscreen,
                             bool new_mac_with_chrome_mode);

  WindowState state_;
  bool mac_with_chrome_mode_;
  Browser* browser_;
};

FullscreenControllerTestWindow::FullscreenControllerTestWindow()
    : state_(NORMAL),
      mac_with_chrome_mode_(false),
      browser_(NULL) {
}

void FullscreenControllerTestWindow::EnterFullscreen(
    const GURL& url, FullscreenExitBubbleType type) {
  EnterFullscreen(false);
}

void FullscreenControllerTestWindow::ExitFullscreen() {
  if (IsFullscreen()) {
    state_ = TO_NORMAL;
    mac_with_chrome_mode_ = false;

    if (IsTransitionReentrant(false, false))
      ChangeWindowFullscreenState();
  }
}

bool FullscreenControllerTestWindow::ShouldHideUIForFullscreen() const {
  return IsFullscreen();
}

bool FullscreenControllerTestWindow::IsFullscreen() const {
#if defined(OS_MACOSX)
  return state_ == FULLSCREEN || state_ == TO_FULLSCREEN;
#else
  return state_ == FULLSCREEN || state_ == TO_NORMAL;
#endif
}

#if defined(OS_WIN)
void FullscreenControllerTestWindow::SetMetroSnapMode(bool enable) {
  if (enable != IsInMetroSnapMode()) {
    if (enable)
      state_ = METRO_SNAP;
    else
      state_ = NORMAL;
  }
  if (FullscreenControllerStateTest::IsReentrant())
    ChangeWindowFullscreenState();
}

bool FullscreenControllerTestWindow::IsInMetroSnapMode() const {
  return state_ == METRO_SNAP;
}
#endif

#if defined(OS_MACOSX)
void FullscreenControllerTestWindow::EnterFullscreenWithChrome() {
  EnterFullscreen(true);
}

bool FullscreenControllerTestWindow::IsFullscreenWithChrome() {
  return IsFullscreen() && mac_with_chrome_mode_;
}

bool FullscreenControllerTestWindow::IsFullscreenWithoutChrome() {
  return IsFullscreen() && !mac_with_chrome_mode_;
}
#endif

// static
const char* FullscreenControllerTestWindow::GetWindowStateString(
    WindowState state) {
  switch (state) {
    case NORMAL:
      return "NORMAL";
    case FULLSCREEN:
      return "FULLSCREEN";
    case METRO_SNAP:
      return "METRO_SNAP";
    case TO_FULLSCREEN:
      return "TO_FULLSCREEN";
    case TO_NORMAL:
      return "TO_NORMAL";
    default:
      NOTREACHED() << "No string for state " << state;
      return "WindowState-Unknown";
  }
}

void FullscreenControllerTestWindow::ChangeWindowFullscreenState() {
  // Several states result in "no operation" intentionally. The tests
  // assume that all possible states and event pairs can be tested, even
  // though window managers will not generate all of these.
  switch (state_) {
    case NORMAL:
      break;
    case FULLSCREEN:
      break;
    case METRO_SNAP:
      break;
    case TO_FULLSCREEN:
      state_ = FULLSCREEN;
      break;
    case TO_NORMAL:
      state_ = NORMAL;
      break;
    default:
      NOTREACHED();
  }
  // Emit a change event from every state to ensure the Fullscreen Controller
  // handles it in all circumstances.
  browser_->WindowFullscreenStateChanged();
}

void FullscreenControllerTestWindow::EnterFullscreen(
    bool new_mac_with_chrome_mode) {
  bool reentrant = IsTransitionReentrant(true, new_mac_with_chrome_mode);

  mac_with_chrome_mode_ = new_mac_with_chrome_mode;
  if (!IsFullscreen())
    state_ = TO_FULLSCREEN;

  if (reentrant)
    ChangeWindowFullscreenState();
}

bool FullscreenControllerTestWindow::IsTransitionReentrant(
    bool new_fullscreen,
    bool new_mac_with_chrome_mode) {
#if defined(OS_MACOSX)
  bool mac_with_chrome_mode_changed = new_mac_with_chrome_mode ?
      IsFullscreenWithoutChrome() : IsFullscreenWithChrome();
#else
  bool mac_with_chrome_mode_changed = false;
#endif
  bool fullscreen_changed = (new_fullscreen != IsFullscreen());

  if (!fullscreen_changed && !mac_with_chrome_mode_changed)
    return false;

  if (FullscreenControllerStateTest::IsReentrant())
    return true;

  // BrowserWindowCocoa::EnterFullscreen() and
  // BrowserWindowCocoa::EnterFullscreenWithChrome() are reentrant when
  // switching between fullscreen with chrome and fullscreen without chrome.
  return state_ == FULLSCREEN &&
      !fullscreen_changed &&
      mac_with_chrome_mode_changed;
}

// Unit test fixture testing Fullscreen Controller through its states. ---------
class FullscreenControllerStateUnitTest : public BrowserWithTestWindowTest,
                                          public FullscreenControllerStateTest {
 public:
  FullscreenControllerStateUnitTest();

  // FullscreenControllerStateTest:
  virtual void SetUp() OVERRIDE;
  virtual void ChangeWindowFullscreenState() OVERRIDE;
  virtual const char* GetWindowStateString() OVERRIDE;
  virtual void VerifyWindowState() OVERRIDE;

 protected:
  // FullscreenControllerStateTest:
  virtual bool ShouldSkipStateAndEventPair(State state, Event event) OVERRIDE;
  virtual Browser* GetBrowser() OVERRIDE;
  FullscreenControllerTestWindow* window_;
};

FullscreenControllerStateUnitTest::FullscreenControllerStateUnitTest ()
    : window_(NULL) {
}

void FullscreenControllerStateUnitTest::SetUp() {
  window_ = new FullscreenControllerTestWindow();
  set_window(window_);  // BrowserWithTestWindowTest takes ownership.
  BrowserWithTestWindowTest::SetUp();
  window_->set_browser(browser());
}

void FullscreenControllerStateUnitTest::ChangeWindowFullscreenState() {
  window_->ChangeWindowFullscreenState();
}

const char* FullscreenControllerStateUnitTest::GetWindowStateString() {
  return FullscreenControllerTestWindow::GetWindowStateString(window_->state());
}

void FullscreenControllerStateUnitTest::VerifyWindowState() {
  switch (state_) {
    case STATE_NORMAL:
      EXPECT_EQ(FullscreenControllerTestWindow::NORMAL,
                window_->state()) << GetAndClearDebugLog();
      break;
    case STATE_BROWSER_FULLSCREEN_NO_CHROME:
      EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
                window_->state()) << GetAndClearDebugLog();
      break;
    case STATE_BROWSER_FULLSCREEN_WITH_CHROME:
      EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
                window_->state()) << GetAndClearDebugLog();
      break;
#if defined(OS_WIN)
    case STATE_METRO_SNAP:
      EXPECT_EQ(FullscreenControllerTestWindow::METRO_SNAP,
                window_->state()) << GetAndClearDebugLog();
      break;
#endif
    case STATE_TAB_FULLSCREEN:
      EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
                window_->state()) << GetAndClearDebugLog();
      break;
    case STATE_TAB_BROWSER_FULLSCREEN:
      EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
                window_->state()) << GetAndClearDebugLog();
      break;
    case STATE_TAB_BROWSER_FULLSCREEN_CHROME:
      EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
                window_->state()) << GetAndClearDebugLog();
      break;
    case STATE_TO_NORMAL:
      EXPECT_EQ(FullscreenControllerTestWindow::TO_NORMAL,
                window_->state()) << GetAndClearDebugLog();
      break;
    case STATE_TO_BROWSER_FULLSCREEN_NO_CHROME:
      EXPECT_EQ(FullscreenControllerTestWindow::TO_FULLSCREEN,
                window_->state()) << GetAndClearDebugLog();
      break;
    case STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME:
      EXPECT_EQ(FullscreenControllerTestWindow::TO_FULLSCREEN,
                window_->state()) << GetAndClearDebugLog();
      break;
    case STATE_TO_TAB_FULLSCREEN:
      EXPECT_EQ(FullscreenControllerTestWindow::TO_FULLSCREEN,
                window_->state()) << GetAndClearDebugLog();
      break;
    default:
      NOTREACHED() << GetAndClearDebugLog();
  }

  FullscreenControllerStateTest::VerifyWindowState();
}

bool FullscreenControllerStateUnitTest::ShouldSkipStateAndEventPair(
    State state, Event event) {
#if defined(OS_MACOSX)
  // TODO(scheib) Toggle, Window Event, Toggle, Toggle on Mac as exposed by
  // test *.STATE_TO_NORMAL__TOGGLE_FULLSCREEN runs interactively and exits to
  // Normal. This doesn't appear to be the desired result, and would add
  // too much complexity to mimic in our simple FullscreenControllerTestWindow.
  // http://crbug.com/156968
  if ((state == STATE_TO_NORMAL ||
       state == STATE_TO_BROWSER_FULLSCREEN_NO_CHROME ||
       state == STATE_TO_TAB_FULLSCREEN) &&
      event == TOGGLE_FULLSCREEN)
    return true;
#endif

  return FullscreenControllerStateTest::ShouldSkipStateAndEventPair(state,
                                                                    event);
}

Browser* FullscreenControllerStateUnitTest::GetBrowser() {
  return BrowserWithTestWindowTest::browser();
}

// Tests -----------------------------------------------------------------------

#define TEST_EVENT(state, event) \
    TEST_F(FullscreenControllerStateUnitTest, state##__##event) { \
      AddTab(browser(), GURL(chrome::kAboutBlankURL)); \
      ASSERT_NO_FATAL_FAILURE(TestStateAndEvent(state, event)) \
          << GetAndClearDebugLog(); \
    }
    // Progress of tests can be examined by inserting the following line:
    // LOG(INFO) << GetAndClearDebugLog(); }

// Soak tests:

// Tests all states with all permutations of multiple events to detect lingering
// state issues that would bleed over to other states.
// I.E. for each state test all combinations of events E1, E2, E3.
//
// This produces coverage for event sequences that may happen normally but
// would not be exposed by traversing to each state via TransitionToState().
// TransitionToState() always takes the same path even when multiple paths
// exist.
TEST_F(FullscreenControllerStateUnitTest, TransitionsForEachState) {
  // A tab is needed for tab fullscreen.
  AddTab(browser(), GURL(chrome::kAboutBlankURL));
  TestTransitionsForEachState();
  // Progress of test can be examined via LOG(INFO) << GetAndClearDebugLog();
}

// Individual tests for each pair of state and event:

TEST_EVENT(STATE_NORMAL, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_NORMAL, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_NORMAL, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_NORMAL, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_NORMAL, METRO_SNAP_TRUE);
TEST_EVENT(STATE_NORMAL, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_NORMAL, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_NORMAL, BUBBLE_ALLOW);
TEST_EVENT(STATE_NORMAL, BUBBLE_DENY);
TEST_EVENT(STATE_NORMAL, WINDOW_CHANGE);

TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, METRO_SNAP_TRUE);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, BUBBLE_ALLOW);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, BUBBLE_DENY);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, WINDOW_CHANGE);

TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, METRO_SNAP_TRUE);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, BUBBLE_ALLOW);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, BUBBLE_DENY);
TEST_EVENT(STATE_BROWSER_FULLSCREEN_WITH_CHROME, WINDOW_CHANGE);

#if defined(OS_WIN)
TEST_EVENT(STATE_METRO_SNAP, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_METRO_SNAP, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_METRO_SNAP, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_METRO_SNAP, TAB_FULLSCREEN_FALSE);
TEST_EVENT(STATE_METRO_SNAP, METRO_SNAP_TRUE);
TEST_EVENT(STATE_METRO_SNAP, METRO_SNAP_FALSE);
TEST_EVENT(STATE_METRO_SNAP, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_METRO_SNAP, BUBBLE_ALLOW);
TEST_EVENT(STATE_METRO_SNAP, BUBBLE_DENY);
TEST_EVENT(STATE_METRO_SNAP, WINDOW_CHANGE);
#endif

TEST_EVENT(STATE_TAB_FULLSCREEN, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_TAB_FULLSCREEN, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_TAB_FULLSCREEN, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_TAB_FULLSCREEN, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_TAB_FULLSCREEN, METRO_SNAP_TRUE);
TEST_EVENT(STATE_TAB_FULLSCREEN, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_TAB_FULLSCREEN, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_TAB_FULLSCREEN, BUBBLE_ALLOW);
TEST_EVENT(STATE_TAB_FULLSCREEN, BUBBLE_DENY);
TEST_EVENT(STATE_TAB_FULLSCREEN, WINDOW_CHANGE);

TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, METRO_SNAP_TRUE);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, BUBBLE_ALLOW);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, BUBBLE_DENY);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, WINDOW_CHANGE);

TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, METRO_SNAP_TRUE);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, BUBBLE_ALLOW);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, BUBBLE_DENY);
TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN_CHROME, WINDOW_CHANGE);

TEST_EVENT(STATE_TO_NORMAL, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_TO_NORMAL, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_TO_NORMAL, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_TO_NORMAL, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_TO_NORMAL, METRO_SNAP_TRUE);
TEST_EVENT(STATE_TO_NORMAL, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_TO_NORMAL, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_TO_NORMAL, BUBBLE_ALLOW);
TEST_EVENT(STATE_TO_NORMAL, BUBBLE_DENY);
TEST_EVENT(STATE_TO_NORMAL, WINDOW_CHANGE);

TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, METRO_SNAP_TRUE);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, BUBBLE_ALLOW);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, BUBBLE_DENY);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, WINDOW_CHANGE);

TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, METRO_SNAP_TRUE);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, BUBBLE_ALLOW);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, BUBBLE_DENY);
TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME, WINDOW_CHANGE);

TEST_EVENT(STATE_TO_TAB_FULLSCREEN, TOGGLE_FULLSCREEN);
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, TOGGLE_FULLSCREEN_CHROME);
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, TAB_FULLSCREEN_TRUE);
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, TAB_FULLSCREEN_FALSE);
#if defined(OS_WIN)
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, METRO_SNAP_TRUE);
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, METRO_SNAP_FALSE);
#endif
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, BUBBLE_EXIT_LINK);
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, BUBBLE_ALLOW);
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, BUBBLE_DENY);
TEST_EVENT(STATE_TO_TAB_FULLSCREEN, WINDOW_CHANGE);

// Specific one-off tests for known issues:

// TODO(scheib) Toggling Tab fullscreen while pending Tab or
// Browser fullscreen is broken currently http://crbug.com/154196
TEST_F(FullscreenControllerStateUnitTest,
       DISABLED_ToggleTabWhenPendingBrowser) {
#if !defined(OS_WIN)  // Only possible without reentrancy
  AddTab(browser(), GURL(chrome::kAboutBlankURL));
  ASSERT_NO_FATAL_FAILURE(
      TransitionToState(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME))
      << GetAndClearDebugLog();

  ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE)) << GetAndClearDebugLog();
  ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_FALSE)) << GetAndClearDebugLog();
  ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE)) << GetAndClearDebugLog();
#endif
}

// TODO(scheib) Toggling Tab fullscreen while pending Tab or
// Browser fullscreen is broken currently http://crbug.com/154196
TEST_F(FullscreenControllerStateUnitTest, DISABLED_ToggleTabWhenPendingTab) {
#if !defined(OS_WIN)  // Only possible without reentrancy
  AddTab(browser(), GURL(chrome::kAboutBlankURL));
  ASSERT_NO_FATAL_FAILURE(
      TransitionToState(STATE_TO_TAB_FULLSCREEN))
      << GetAndClearDebugLog();

  ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE)) << GetAndClearDebugLog();
  ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_FALSE)) << GetAndClearDebugLog();
  ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE)) << GetAndClearDebugLog();
#endif
}

// Debugging utility: Display the transition tables. Intentionally disabled
TEST_F(FullscreenControllerStateUnitTest, DISABLED_DebugLogStateTables) {
  std::ostringstream output;
  output << "\n\nTransition Table:";
  output << GetTransitionTableAsString();

  output << "\n\nInitial transitions:";
  output << GetStateTransitionsAsString();

  // Calculate all transition pairs.
  for (int state1_int = 0; state1_int < NUM_STATES; state1_int++) {
    State state1 = static_cast<State>(state1_int);
    for (int state2_int = 0; state2_int < NUM_STATES; state2_int++) {
      State state2 = static_cast<State>(state2_int);
      if (ShouldSkipStateAndEventPair(state1, EVENT_INVALID) ||
          ShouldSkipStateAndEventPair(state2, EVENT_INVALID))
        continue;
      // Compute the transition
      if (NextTransitionInShortestPath(state1, state2, NUM_STATES).state ==
          STATE_INVALID) {
        LOG(ERROR) << "Should be skipping state transitions for: "
            << GetStateString(state1) << " " << GetStateString(state2);
      }
    }
  }

  output << "\n\nAll transitions:";
  output << GetStateTransitionsAsString();
  LOG(INFO) << output.str();
}

// Test that the fullscreen exit bubble is closed by
// WindowFullscreenStateChanged() if fullscreen is exited via BrowserWindow.
// This currently occurs when an extension exits fullscreen via changing the
// browser bounds.
TEST_F(FullscreenControllerStateUnitTest, ExitFullscreenViaBrowserWindow) {
  AddTab(browser(), GURL(chrome::kAboutBlankURL));
  ASSERT_TRUE(InvokeEvent(TOGGLE_FULLSCREEN));
  ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE));
  ASSERT_TRUE(browser()->window()->IsFullscreen());
  // Exit fullscreen without going through fullscreen controller.
  browser()->window()->ExitFullscreen();
  ChangeWindowFullscreenState();
  EXPECT_EQ(FEB_TYPE_NONE,
            browser()->fullscreen_controller()->GetFullscreenExitBubbleType());
}


text:
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QLogin login;
    login.show();
    return app.exec();
}