Who’s the Real Debtor Here?
Throughout this manual, we’ve been examining the many ways in which the wealthy and the powerful use claims of debt to steal from and exert control over the vast majority of us. No matter how destructive the results, we are constantly told (and tell ourselves) that such a system is morally just because of a supposedly simple, eternal truth: Money owed must be repaid. This deeply entrenched and widely held belief in the black-and-white morality of debt is the linchpin that holds the debt system in place.
But nothing is ever as simple as it seems. At their core, monetary
debts are extremely narrow and simplified ways of representing what
are often very complicated relationships between creditors and
debtors. If we can zoom out from the simple calculation of money
owed and look at the broader histories, human relationships, and
power dynamics that lie behind a debt, it quickly becomes clear that
there are countless ways to imagine who owes what to whom. Seen in
this expanded context, a claim that repayment of a debt is morally
just can begin to seem absurd. (And yet, despite the
often-questionable moral legitimacy of their claims, the harsh truth
is that it’s usually the ones with the most powers of
economic coercion and brute force
at their disposal that get to decide which debts are legitimate in
the end.)
Nowhere is this dynamic better represented than by the sovereign debts imposed on the people of the global South, as discussed in the previous chapter. For decades, northern banks, the IMF, and the World Bank have demanded that residents of much poorer countries be held responsible for the repayment of loans taken on in their names, often by undemocratic regimes and under outrageous terms that might make a Goldman Sachs banker blush. Under the simple logic of debt, the failure to repay such loans has been used to justify the imposition of harsh, undemocratic “reforms” that have caused immense suffering.
But if we pull back and begin to look at the long history of domination, exploitation, and destruction imposed on the people of debtor nations to the benefit of their so-called creditors, it immediately becomes apparent just how questionable the morality of these simple calculations is. For instance, how many dollars should Great Britain pay African nations for the approximately 2.8 million people they abducted into the transatlantic slave trade? What should the annual interest rate be on the debt Spain owes, say, Peru, for the tons of silver it extracted through forced labor, and what should the penalty be for five hundred years of late payment? Though such calculations could never account for the true cost of centuries of suffering and oppression, when confronted with the simple morality that states “all debts must be repaid,” it’s important to think for a moment about who is really the debtor, and who is the creditor.
Along those lines, as the effects of human-induced climate change have begun to wreak havoc on a global scale, global justice movements have formulated a vitally important question in response: How do the South’s monetary debts to foreign creditors compare with the North’s liabilities for environmental impacts since the dawn of industrialization? The resulting concept of climate debt, first introduced almost twenty-five years ago, has provoked a powerful ongoing dialogue, elucidating stark disparities in how climate change is caused and experienced around the world.
After over two hundred years of humans spewing massive amounts of
carbon dioxide and other greenhouse gases into the earth’s
atmosphere, the planet is on the verge of an unprecedented
ecological catastrophe. We’ve already seen record-breaking droughts,
superstorms, hurricanes, heat waves, and floods. And that’s just the
tip of the (quickly melting) iceberg. But, historically, people in
what have come to be known as “developed nations” are by far the
largest emitters of greenhouse gases
and have reaped the lion’s share of the economic benefits when
compared to those of the global South. And although the whole planet
is experiencing rising temperatures, the impact is far from equal.
Both the IMF and the World Bank have acknowledged that the brunt of
the impact will be borne by some of the poorest populations in the
world, further immiserating them.
To say nothing of the human misery, suffering, and death wrought by climate change—past, present, and future—surely even just the simple monetary costs to the South of repairing damage, adapting as possible, and mitigating future damage must be considered a massive debt owed to them by the North. In demanding repayment of this debt, movements for climate justice have done much to highlight the economic forces that compel the destruction of the environment for the benefit of the few at the expense of all—but particularly the world’s poorest. To truly understand the nature of the debt that’s owed, we’ll need to understand the origins of the climate crisis a bit more thoroughly.
Growth, development, and the origins of climate debt
The current vast disparities in wealth, power, and standards of living between the people of developed nations and those of the global South reflect long histories of colonial domination and, later, exploitation through the neoliberal global economic order. In many ways, this centuries-long dynamic has been intensified, shaped, and transformed by industrialized nations’ utter addiction to carbon-based fuels.
For most of human history, the naturally renewable energy sources
humans used to sustain ourselves were readily found on the earth’s
surface: firewood, wind, water, animal power, etc. But, at around
the turn of the nineteenth century, as the industrial era was
dawning, new technologies made it possible to mine massive
quantities of carbon-based fuel in the form of coal. Suddenly,
people in the industrial centers of northern and central Europe (and
soon the United States) were able to tap into extraordinarily potent
stores of energy that had accumulated below the earth over millions
of years (Mitchell 2011, 15).
The introduction of such an intense productive power into Europe’s mix of industrial capitalist and colonial enterprises created enormous amounts of wealth and began a stretch of growth in productive output unparalleled in human history. It also had profound impacts on the way Western societies developed, continually transforming everything from modes of transportation, agriculture, and the organization of cities, to legal systems, forms of government, and the division of labor (Harvey 2010, 203). Colonies, mobilized to provide critical raw materials for Western industry, were industrialized at a much slower pace and, over time, the disparity in wealth between them and their colonizers increased exponentially.
In various ways, the large-scale transition of Western economies from coal to oil and the emerging global economic order of the mid-twentieth century greatly reduced the political power of labor and increasingly freed capitalist interests from the control of nation states. With capitalist profit-seeking behavior liberated and further intensified by uninterrupted flows of carbon in the form of oil, it became possible to imagine a global economic system based on growth without limits—though that growth was increasingly concentrated in the hands of the few, at home and abroad (Mitchell 2011, 15).
By the time the era of direct colonialism came to an end in the decades following World War II, carbon-rich industrialization had so thoroughly transformed the entire “Western way of life” that traditional ways of living in far-less industrialized countries of the global South stood in stark contrast. Without irony, industrialized governments seeking to extend their economic and political control pointed to the disparity in wealth between the “developed” North and the “undeveloped” South as justification for the imposition of unsustainable and paternalistic economic development programs through institutions like the IMF (Escobar 1995, 17). Promising investments and improvements in material conditions, “development experts” were deployed across the global South to push for the top-down implementation of economic, technological, and social changes, dismissing indigenous traditions and worldviews that might conflict with their visions of “progress.”
But, to many, it’s long been clear that Western-style economic
development is as unsustainable as the Western way of life itself.
In 1972, the influential Club of Rome think-tank published a
groundbreaking and disturbing report titled The
Limits to Growth, which concluded that the current rates of
industrial growth could not be sustained ecologically in the
long-term (Meadows et al. 1972). Subsequent surveys, drawing upon a
wider range of experts and a more comprehensive network of
scientific data, amplified the 1972 warning about the ruinous impact
of unrestrained growth. Thirty years later, the
Limits to Growth team reprised their study, confirming the
original predictions of economic and civilizational collapse in the
course of the twenty-first century (Meadows, Randers, and Meadows
2004).
Despite these and many other grave warnings, at this current stage of industrial capitalist development, carbon-enabled growth has become so deeply imbricated in the political, economic, and social operations of everyday life in developed nations that growth is no longer a means to an end, but a necessary end in itself. If capitalism is to continue in anything like its current form, production and consumption must steadily increase whether or not they fulfill a genuine need. Any slowdown in economic growth (a recession) and the entire system begins to fall apart. Perversely, governments at all levels are tasked first and foremost with ensuring growth—a good quality of life for their citizens is a distant second at best, and the health of the planet that sustains us barely registers (Harvey 2010, 259).
The crisis is here
Whatever one might make of the decision to organize entire societies around the need for ever-increasing profits, the fact of the matter is that such a choice is no longer an option—at least when it comes to profits enabled by carbon-based fuels. For one thing, the earth’s supply of carbon-based energy is limited, and we’re starting to bump up against that limit. Extracting fossil fuels has become an increasingly costly and energy-intensive enterprise, and while we may be able to prolong the inevitable with new, environmentally destructive technologies like fracking and deep-sea drilling, it won’t be long before the costs and energy required to extract carbon from the earth outweigh the benefits.
But more importantly, the burning of fossil fuels, deforestation, and other destruction of plant life through capitalist activity has lead to a massive buildup of carbon dioxide and other gases in the earth’s atmosphere. Before industrialization, carbon absorbed by plants and the oceans more or less balanced emissions from volcanoes and other sources. But over the last two centuries of carbon-fueled capitalist growth, a dramatic rise in greenhouse gases has begun to increase the amount of heat retained on the planet, causing wild fluctuations in global temperatures and destabilizing the balance that made settled human life possible for the past twelve thousand years.
Scientists calculate the amount of carbon dioxide in the atmosphere in measurements of parts per million (PPM). Historically, carbon dioxide was about 275 PPM. NASA scientist James Hansen has calculated that the highest level of carbon dioxide and its equivalents that the atmosphere can safely contain is about 350 PPM. Currently, we’re at 394 PPM and rising rapidly. The average global temperature has already increased by one degree Celsius and predictions consistent with current observations suggest that the temperature will rise by six to eight degrees Celsius by 2100 unless dramatic measures are taken soon. All the ruinous impacts we have seen so far are just the beginning. We’re quickly approaching a point of no return.
The development-inclined World Bank concludes in a recent report
that even if countries adhere to UN-brokered emissions-reduction
pledges—and they haven’t been thus far—we’re likely to see a 3.5 to
4 degree Celsius increase this century. The report warns that such
an increase will result in unprecedented heat waves, water scarcity,
food shortages, droughts, increasingly powerful hurricanes,
inundation of coastal cities, and severe impacts on ecosystems.
Ominously, it continues, “a 4°C [warmer] world is so different from
the current one that it comes with
high uncertainty and new risks
that threaten our ability to anticipate and plan for future
adaptation needs.”
Some see global crisis on an unprecedented scale unfolding in as little as a few years. Guy McPherson, an ecologist who has been studying climate change for twenty-five years, estimates that we’ll cross the threshold of 400 PPM in the next couple of years. “At that time,” he says, “we’ll also see the loss of Arctic ice in the summers.” Loss of Arctic ice means solar radiation that would otherwise have been reflected back out of the atmosphere will now be absorbed by the ocean, causing a significant intensification in warming and unleashing a host of unpredictable repercussions for global weather patterns. He warns, “The implications are truly dire and profound for our species and the rest of the living planet.”
Calculating the debt
The concept of ecological debt was first introduced by Chile’s
Instituto de Ecología Política in the lead-up to the 1992 Earth
Summit in Rio de Janeiro—the first major international climate
summit, involving representatives and heads of state from 172
governments. Ecological debt was explicitly presented as a framework
for discussing how much of their sovereign debts countries in the
South should pay in light of the historical legacy of resource
exploitation, loss of biodiversity, pollution, and outright
destruction they’ve suffered at the hands of the North. Many argued
that the obligation to repay the more recent high-interest loans had
to be
balanced against moral and economic liabilities
from the more distant past.
But, as with any monetary debt, the full dimensions of ecological debt did not readily lend themselves to quantification. (How do you calculate the dollar value of a traditional way of living that’s no longer possible?) Still, carbon emissions can be reliably measured and certainly represent a quantifiable economic benefit to those who emit them, alongside a neatly correlating negative impact on the climate we all share. As the impacts of global climate change came more clearly into view, this portion of the ecological obligation, appraised on the basis of atmospheric emissions estimates by nation, emerged as the main vehicle for demanding repayment, and subsequently came to be known as climate debt.
A brief look at the breakdown of carbon emissions by nation over
time quickly confirms what we already know: the lion’s share of the
greenhouse gases that are now wreaking ecological havoc were emitted
to benefit industrial economies, profit-seeking enterprises, and the
attendant consumer culture rooted in countries of the North. To give
one quick example of the disparities the data reveals,
the average Briton emits about as much carbon dioxide in one day
as a Kenyan will in an entire year.
Though the profits of climate destruction tend to accrue to those who’ve caused it, it so happens that the world’s poorest people, largely in nations of the global South, experience the destructive effects in extreme disproportion. One reason for this disparity is geographical: increase in sea levels, desertification, and storms all tend to occur with the most intensity nearer to the equator, around which many of the world’s poorest nations are arrayed. Additionally, many inhabitants of the South live and sustain themselves in traditional ways that are often intimately reliant on their specific local environments. When those environments change dramatically, or are no longer inhabitable, the challenge of adapting is far greater than it is for the larger proportion of people in industrialized nations whose climate-change-inducing consumption and production processes are less specifically local.
Poorer nations also simply lack the money needed to mitigate, adapt
to, or repair the destruction that’s being visited upon them. The
impact of recovery and cleanup is eating into a significant
percentage of the GDP of nations that are already struggling to
maintain a foothold in a global economy stacked against them. In
2012, record-breaking Typhoon Bopha slammed into the Philippines,
causing then-unprecedented death and destruction. Describing his
country’s predicament at the time, a Filipino UN negotiator
explained, “We have never had a typhoon like Bopha. . . . Each
destructive typhoon season costs us 2% of our GDP, and the
reconstruction costs a further 2%, which means we
lose nearly 5% of our economy every year to storms. . . . We have not seen any money from the rich countries to help
us to adapt. . . . We cannot go on like this.”
The following year, the Philippines were hit again. Typhoon Haiyan,
the strongest cyclone to make landfall in recorded history, killed
over six thousand people, displaced millions more, and caused
billions of dollars of damage. Such events will undoubtedly continue
with increasing frequency and intensity thanks to the
greenhouse-gas-induced warming of the ocean. Why should Filipinos,
who on average emit 0.9 metric tons of carbon annually, pay for the
destruction wrought by people in nations like the United States, who
emit
17.6?
And yet, despite the outsized role the United States plays in perpetuating the climate crisis, it’s important not to close our eyes to the deep disparities in experiences of climate change that exist even within the wealthier countries where it’s produced. Although U.S. residents are the global leaders in carbon use, members of the wealthiest 1% in the United States use ten thousand times more carbon than the average U.S. resident. And climate-induced disasters on the scale of Hurricane Katrina and Superstorm Sandy readily exposed the uneven pattern of impacts within cities, where communities of color and poor populations were often devastated and the wealthy often left relatively unscathed.
Climate debt in default
Though, crucially, the ’92 Earth Summit in Rio failed to set clear, enforceable goals for the reduction of carbon emissions, 154 governments did ratify the United Nations Framework Convention on Climate Change (UNFCCC), which created a formal international process for negotiating coordinated global action in response to the climate crisis. (Forty more countries have since signed on.) Since then, climate justice activists and governments of the world’s least developed countries have been elaborating the concept of climate debt and pushing the cause for repayment at major UNFCCC conferences. Results have often been slow in coming. Tellingly, despite the intense ongoing UNFCCC negotiations held since ’92, the amount of carbon pumped into the atmosphere annually has nearly doubled.
After 2009’s Copenhagen summit once again failed to produce
meaningful, legally binding commitments from industrialized nations
for compensation and emissions reductions, over thirty thousand
grassroots activists from 140 countries came together in Cochabamba,
Bolivia to consolidate their demands. Organized around principles of
participatory democracy, the 2010 World People’s Conference on
Climate Change produced a detailed People’s Accord, which outlined a
legal framework for how the North can be held accountable for their
outsized role in the destruction of the climate.
Among other things, the document calls on the North to “decolonize the atmosphere” by reducing and absorbing their emissions; to guarantee the human rights of the hundreds of millions forced to migrate by eliminating restrictive immigration policies; to monetarily compensate the South for the “loss of development opportunities due to living in a restricted atmospheric space”; to pay the costs of mitigation and adaptation; and to finance and share clean technologies. Bolivia submitted a proposal to the UNFCCC based on the Cochabamba accords shortly thereafter.
But they’re up against an array of powerful interests.  With a little
digging, behind these government officials’ and diplomats’
intransigence, you can usually find the influence of a sophisticated
network of ultra-rich individuals who benefit from the climate
crisis through crisscrossing networks of trade, finance, and
carbon-rich industry. An eye-opening 2011 report from the
International Forum on Globalization maps how these “carbon
billionaires” use their personal wealth to exert a tremendous amount
of influence, playing governments off of each other and holding
climate negotiations hostage to ensure they can
continue reaping profits
without being held accountable for the environmental costs.
Beyond Growth and Debt
Within our current nation-state-based global political framework, calculating climate debts by country may be the most practical way to account for the history of Northern-imposed capitalist industrial development and the disparities in wealth and mass destruction it continues to cause. Those of us who live in wealthy nations, to the extent that we engage with or agitate against the governments that claim to represent us, must demand that reparations are made for the environmental damage caused by over two hundred years of intense exploitation of the earth’s natural resources at the expense of the world’s poorest.
But in the same way that calculations of monetary loans simplify complicated relationships, calculating climate debt by nation-states’ emissions can obscure important exploitative power dynamics that exist at every level in a globalized neoliberal economy. Ultimately, beyond the billionaires and intransigent governments that perpetuate climate change lies the compelling force of the global capitalist economy itself, the very existence of which hinges on the ability to burn and emit carbon without acknowledging the costs. Its logic is integrated into our very way of life. As such, paying back the climate debt owed must be seen as just the first step towards setting aside our collective obsession with growth.
This is the fundamental challenge of climate change. If we’re going to avert complete destruction of the environment, what’s really needed is a radical shift in the values that guide us, along with a transformation of the way we organize our lives and our communities. A global economic system that relies on never-ending economic growth inevitably means more carbon emissions and greater climate change. To those of us who’ve lived our entire lives in such a world, it’s difficult to know how to begin imagining new ways of living together prosperously, with respect for each other and our shared climate. There are no simple answers.
But traditional cultures that have been resisting the imposition of
Western-style economic development for decades may be able to
provide some clues in the search for alternatives. In Andean regions
of Latin America for example, over decades of common struggle
against the destructive effects of development projects, a rich
discourse around concepts of
vivir bien
has emerged among diverse communities of indigenous people, peasant
groups, and the urban poor. Though a simple translation of the
Spanish words “vivir bien” would be something like “to live well,”
the term refers to a confluence of rich political and philosophical
concepts of “harmonious living” emerging from Aymara, Quechua,
Kichwa, Guarani, and other regional traditions.
As these traditions largely lack notions of linear progress, their concepts don’t lend themselves to simple translation but provide valuable counterpoints to Western worldviews. Though different cultures emphasize different aspects, concepts of vivir bien generally address issues Westerners might group under the term “quality of life,” but with the understanding that true well-being can only occur in a community. Importantly, nature is considered to be part of the community rather than simply a setting or a resource to be exploited. Though concepts of vivir bien have been enshrined in the constitutions of both Bolivia and Ecuador, it doesn’t represent a fixed set of principles. It continues to evolve in response to technocratic, commodifying, growth-focused development ideologies, yet draws in other facets of Western thought when useful as well. As Western cultures begin to imagine what life after the past two hundred years of carbon-fueled growth might look like, we might do well to draw in aspects of vivir bien in return.
Resources
Articles and Books
- Anthony Costello, Mustafa Abbas, Adriana Allen, Sarah Ball, Sarah Bell, Richard Bellamy, Sharon Friel, Nora Groce, Anne Johnson, Maria Kett, Maria Lee, Caren Levy, Mark Maslin, David McCoy, Bill McGuire, Hugh Montgomery, David Napier, Christina Pagel, Jinesh Patel, Jose Antonio, Puppim de Oliveira, Nanneke Redclift, Hannah Rees, Daniel Rogger, Joanne Scott, Judith Stephenson, John Twigg, Jonathan Wolff, and Craig Patterson. “Managing the Health Effects of Climate Change,” The Lancet 373 (2009): 1693–1733.
- “Each Country’s Share of CO2 Emissions,” Union of Concerned Scientists, August 20, 2010.
- International Climate Justice Network, “Bali Principles of Climate Justice,” World Summit on Sustainable Development, August 2002.
- Tim Jackson, “Prosperity without Growth? The Transition to a Sustainable Economy,” Sustainable Development Commission, March 2009.
- Cedric Johnson, The Neoliberal Deluge: Hurricane Katrina, Late Capitalism, and the Remaking of New Orleans (Minneapolis: University of Minnesota Press, 2011).
- Naomi Klein, The Shock Doctrine: The Rise of Disaster Capitalism (New York: Picador, 2011).
- Austin Ramzy, “After Protests, Chinese City Halts Chemical Plant Expansion,” Time, October 20, 2012.
- “Shouldering the Costs: Who Pays in the Aftermath of Hurricane Sandy?” Strike Debt, December 2, 2012.
References
- Escobar, Arturo. Encountering Development: The Making and Unmaking of the Third World. Princeton, NJ: Princeton University Press, 1995.
- Fabricant, Nicole, and Kathryn Hicks. “Bolivia vs. the Billionaires: Limitations of the ‘Climate Justice Movement’ in International Negotiations.” North American Congress on Latin America, Spring 2013.
- Graeber, David. Debt: The First 5,000 Years. New York: Melville, 2011.
- Gruener, Wolfgang. “Bill Gates Uses 10,000 Times the Energy of the Average American, MIT Says.” TG Daily, April 28, 2008.
- Gudynas, Eduardo. “Buen Vivir: Today’s Tomorrow.” Development 54, no. 4 (2011): 441–447.
- Hansen, James, Makiko Sato, Pushker Kharecha, David Beerling, Robert Berner, Valerie Masson-Delmotte, Mark Pagani, Maureen Raymo, Dana L. Royer, and James C. Zachos. “Target Atmospheric CO2: Where Should Humanity Aim?” The Open Atmospheric Science Journal 2 (2008): 217–31.
- Harvey, David. A Companion to Marx’s Capital. New York: Verso, 2010.
- International Forum on Globalization. “Outing the Oligarchy: Billionaires Who Benefit From Today’s Climate Crisis.” December 2011.
- Jamail, Dahr. “Are We Falling off the Climate Precipice?: Scientists Consider Extinction.” TomDispatch.com, December 17, 2013.
- Lagarde, Christine. “A New Global Economy for a New Generation.” Presented at the World Economic Forum, Davos, Switzerland, January 23, 2013.
- Lowrey, Annie. “The Inequality of Climate Change.” New York Times, November 12, 2013.
- Meadows, Donella H., Dennis L. Meadows, Jørgen Randers, and William H. Behrens III. The Limits to Growth. New York: Universe Books, 1972.
- Meadows, Donella H., Jørgen Randers, and Dennis L. Meadows. The Limits to Growth: The 30-Year Update. White River Junction, VT: Chelsea Green, 2004.
- Mitchell, Timothy. Carbon Democracy: Political Power in the Age of Oil. New York: Verso, 2011.
- Oliver, Rachel. “Rich, Poor and Climate Change.” CNN.com, February 18, 2008.
- Potsdam Institute for Climate Impact Research and Climate Analytics. “Turn Down the Heat: Why a 4°C Warmer World Must be Avoided.” The World Bank, November 2012.
- Ross, Andrew. “Climate Debt Denial.” Dissent, Summer 2013.
- Vidal, John. “Will Philippines Negotiator’s Tears Change Our Course on Climate Change?” The Guardian, December 6, 2012.
- World People’s Conference on Climate Change and the Rights of Mother Earth. “Peoples Agreement.” April 22, 2010.


Video of man ripping facemask off Joe Montana statue emerges
by TSD StaffPrimetime games are great, but being played at night, it can sometimes draw the wrong types of fans — you know, the ones that drink a bit too much, and attend only 1-2 games per season.
That may have been the case for Monday’s Seahawks-49ers game at Levi’s Stadium, as it was noticed that someone (or a group of people) ripped the facemask off the Joe Montana statue.
It didn’t take long for the fan to get caught, though. And we even have video of it.
Santa Clara police released a statement about the incident, and stated that the man was arrested after the game was in the books.
The 49ers released a statement as well.


Qoutes of Note
With Love Do All Things.
- I Corinthians 16:14
Steve Jobs
|
The Bible
|
Bill Gates
|
More


Tutorial
Welcome to the Noise query language tutorial
The data set we'll work on is TV shows, imported from TVmaze.com via their json API. Each TV show (over 28,000!) is one document that contains information about the show itself, like the name, length and network. But also the cast and all the episodes. In all well over a million episodes listed!
Let's start simple and query for a show where we already know the name. Run the query with pushing the "Query" button.
The ~=
operator is for full text matching, which uses stemming to find words with common root words in the field.
The return .
means return the whole document. If you leave off the return clause the query returns the _id of the document.
Try modifying the query to find your favorite show.
find
{name: ~= "seinfeld"}
return
.
Phrase Match
Using ~=
operator with a phase (multiple words in order) will find documents with fields that contain the phrase.
This example finds multiple shows whose name field contain the words "star trek".
The return .name
means return the full name of the show.
find
{name: ~= "star trek"}
return
.name
Formating Results as Objects
In the return statement you can format result fields in json objects.
find
{name: ~= "star trek"}
return
{name: .name, status: .status}
Formating Results as Arrays
You can format the same results in arrays. You can also format the results as complex nested objects and arrays if you want.
find
{name: ~= "star trek"}
return
[.name, .status]
Proximity Match
Using the ~N=
operator where N is an integer turns it into a proximity match operator. Which means it matches if the the words in the query are N or less words away from each other. Here we have a query where "crime" and "family" can have no more than 5 words between them.
If you set the distance to 0, then the two words must be besides each other, but any order.
find
{summary: ~5= "crime family"}
return
.name
Exact Match
Using ==
with a string does an exact match query, it is case sensitive.
This example finds a show with exactly the name "Star Trek", it's the first movie.
Try again the ~=
operator to see the difference.
find
{name: == "Star Trek"}
return
.name
Find in Arrays
The genres
field contains an array of genres that apply to the show. If we want to find all shows for a particular genre, we have to let it know to look in the array for the value.
find
{genres: [ == "Crime"]}
return
.name
Find in Arrays: Nested Objects 1
Let's find shows with episodes that mention trial in the episode name.
find
{episodes: [{name: ~= "trial"}]}
return
.name
Boolean Operators 1
To have multiple criteria you can join them with &&
or ||
operators. Here we want to find shows that have both comedy and crime genres. If we change &&
to ||
it will find shows that are either.
find
{genres: [ == "Crime"] && genres: [ == "Comedy"]}
return
.name
Boolean Operators 2
Here we are looking for shows that are either "Crime Comedy" or "Crime Music" using &&
, ||
and parenthesis to group the criteria.
find
{
(genres: [ == "Crime"] && genres: [ == "Comedy"]) ||
(genres: [ == "Crime"] && genres: [ == "Music"])
}
return
.name
Boolean Operators 3
Here is another way to write the same query but using separate objects with a ||
between them. It's exactly the same as the previous query, but a little easier to read.
find
{genres: [ == "Crime"] && genres: [ == "Comedy"]} ||
{genres: [ == "Crime"] && genres: [ == "Music"]}
return
.name
Boolean Operators 4
There's also an alias for the &&
operator, it's the comma ,
. It has exactly the same semantics, but it makes certain queries easier to read. For example if you want to match on several different fields on an object.
find
{genres: [ == "Comedy"], status: == "In Development"}
return
.name
Not Operator
You can use the !
operator to negate any criteria. Here we want to find Comedy-Music shows that are not currently running.
Remove the !
operator to get all the Comedy-Music shows that are currently running.
Note: You must have at least one non-negated clause in the query or you will get an error.
find
{genres: [ == "Comedy"] && genres: [ == "Music"] && status: != "Running"}
return
.name
Order and Limit Results
Using the order clause you can order results by values found in the documents.
Using find {}
means look at every document in the index.
This examples looks at at every show and returns the 10 longest runtimes.
find
{}
order
.runtime desc
return
{name: .name, runtime: .runtime}
limit
10
Relevancy Scoring
Noise uses Term Frequency/Inverse Document Frequency (TF/IDF) scoring system. Use the score()
function to get the score, and use in the order clause with desc
to order the most relevant first.
find
{summary: ~= "trial", name: ~= "trial"}
order
score() desc
return
{name: .name, score: score()}
Relevancy Scoring: Boosting
You can boost the score by using the ^
operator follow by a boost factor.
Here we boost any result 2x where the summary also contains the word "crime".
find
{summary: ~= "trial", name: ~= "trial" ||
summary: ~= "crime"^2}
order
score() desc
return
{name: .name, score: score()}
Relevency Scoring: Boosting 2
You can boost multiple criteria by enclosing them in parethesis.
find
{summary: ~= "trial", name: ~= "trial" ||
(summary: ~= "crime" && name: ~= "crime")^2}
order
score() desc
return
{name: .name, score: score()}
Return a Field from All Nested Objects
You can return all fields from a nested object using []
.
find
{summary: ~= "trial"}
return
{name: .name, runtimes: .episodes[].runtime}
Aggregates: Group and Sum
For each show that is about a trial, let's figure out the total runtime of all episodes for that show.
find
{summary: ~= "trial"}
return
{name: group(.name), total_runtime: sum(.episodes[].runtime)}
Bind variables
Bind variables are used to capture matching elements in an array. The matching elements can then be used in return clauses. Before the array, add VariableName::
to indicate you wish to capture matching elements. Then use the same variable in the return statement.
Here we find all Simpsons episodes that mention Troy McClure.
find {
name: ~= "The Simpsons",
episodes: eps::[{
summary: ~= "Troy McClure"
}]
}
return eps
Bind Variables and Aggregates
You can also return just the desired fields from the bind variable by adding .fieldname
after the bind variable.
Let's figure out the total runtime of episodes for a show where the episodes have a "trial" in the episode summary
find
{episodes: eps::[{summary: ~= "trial"}]}
return
{name: group(.name), total_runtime: sum(eps.runtime)}
Aggregations: count()
Find number of shows each country has produced.
Some shows don't have a country name. use default="unknown" to return a friendlier string instead of null.
find {}
return {
country: group(.network.country.name) default="unknown",
shows: count()
}
Conclusion
Thanks for trying out Noise!
Feel free to keep playing around and let us know what you think on the mailing list.


All tags
- backup — 1 post
- code — 1 post
- command_line — 1 post
- command-line — 2 posts
- design — 1 post
- gtd — 1 post
- health — 1 post
- inspiration — 1 post
- java — 3 posts
- jira — 1 post
- kanban — 1 post
- productivity — 7 posts
- review — 1 post
- ssh — 1 post
- teams — 1 post
- tomcat — 2 posts
- vscode — 1 post
- windows — 1 post
- wordpress — 1 post
- writing — 1 post


Credit des Icons
Icons made by
Kiranshastry
from
www.flaticon.com
Icons made by
Pixel perfect
from
www.flaticon.com


Mentor Me
Join Now!
Home
Meet the Team
Meet Our Team
ALL
TEAM LEAD
USER INTERFACE
FRONT-END
BACK-END
George Adams
Front-End Architect
Karl Beska
Front-End Architect
Debi Jones
Back-End Architect
Zach Lasky
User Interface Developer
Larry Marcum
User Interface Developer
Max Trestman
Team Lead


|
The Natural Helmholtz-Hodge Decomposition
|
This is the complete list of members for RGrid, including all inherited members.
| dim | RGrid | |
| dx | RGrid | |
| dy | RGrid | |
| dz | RGrid | |
| get_coords(size_t v, size_t &x, size_t &y) const | RGrid | inline |
| get_coords(size_t v, size_t &x, size_t &y, size_t &z) const | RGrid | inline |
| get_dist(size_t v1, size_t v2) const | RGrid | inline |
| get_dist_sq(size_t v1, size_t v2) const | RGrid | inline |
| get_idx(size_t x, size_t y) const | RGrid | inline |
| get_idx(size_t x, size_t y, size_t z) const | RGrid | inline |
| get_nbrs(size_t X_, float one_over_dx_, size_t x, size_t &xm, size_t &xp, float &dx_) | RGrid | inlineprivatestatic |
| get_nbrs_idx_2D(size_t p, size_t &pxp, size_t &pxm, float &one_over_dx_, size_t &pyp, size_t &pym, float &one_over_dy_) const | RGrid | inline |
| get_nbrs_idx_3D(size_t p, size_t &pxp, size_t &pxm, float &one_over_dx_, size_t &pyp, size_t &pym, float &one_over_dy_, size_t &pzp, size_t &pzm, float &one_over_dz_) const | RGrid | inline |
| init() | RGrid | inlineprivate |
| init_local() | RGrid | inlineprivate |
| one_over_dx | RGrid | private |
| one_over_dy | RGrid | private |
| one_over_dz | RGrid | private |
| RGrid() | RGrid | inline |
| RGrid(size_t X_, float dx_) | RGrid | inline |
| RGrid(size_t X_, size_t Y_, float dx_, float dy_) | RGrid | inline |
| RGrid(size_t X_, size_t Y_, size_t Z_, float dx_, float dy_, float dz_) | RGrid | inline |
| sq_dx | RGrid | private |
| sq_dy | RGrid | private |
| sq_dz | RGrid | private |
| sz | RGrid | |
| X | RGrid | |
| XY | RGrid | private |
| Y | RGrid | |
| Z | RGrid |


12 February 2010 - The Ministry of Health of Indonesia has announced a new case of human infection of H5N1 avian influenza. A 25-year-old female from South Jakarta District, DKI Jakarta Province died on 25 January 2010. Laboratory tests were positive for H5N1 virus infection. The case was possibly infected from direct contact with poultry.
Of the 163 cases confirmed to date in Indonesia, 135 have been fatal.


{{content-for "head"}} {{content-for "head-footer"}}
Looks like you have JavaScript disabled.
The Travis CI webclient needs JavaScript to work properly.


Welcome To The IT Collective
The IT Collective is an open source project with the goal that any user who want to gain IT knowledge and skills can do so for free. Our mission is to make an IT information hub, community, and help study towards recognized industrial certificates to improve individuals employment.


Home
FileCollections
FeatureCollections
collections
#
collection name
comment
Edit
Delete
1
name
comment
Edit
Delete
add
edit collection
new collectionName
comment
请输入comment
add collection
collectionName
comment
请输入comment


When you work with us,you are a part of a team of committed collaboration.All aspects of our software development process are integrated,interactive and agile
our approach unifies design,development and product management to create exceptional product
We start project by understanding your business goals,the user's needs and the product requirements
Then we help translate them into effective and elegant solutions
before we sign a contract or write a line of code our team will spend the necessary time needed to understand your product vision
The outcome of this scoping session is a proposal or high-level statement of work.
Based on your requirements,we can provide a complete offering or just the pieces you need
our design practise offers a full range of services including brand strategy,interaction and visual design and user experiencing testing
Throughout your project,our designer create and implement visual design and workflows.solicite users feedback and work with you to make sure what get built is needed
all engineers are fluent in the latest enterprise,mobile and web development technologies
they collaborate with your team to write and improve code on a daily basis,using proven practises such as test-driven development and pair programming
planning and development is iterative.because we are constantly coding and testing,the products we build are always ready to go live
this iterative process allows for change as business requirements evolve


Logs a workout to the health app.
logWorkout(type: <#Type (WFWorkoutReadableActivityType)#>, date: <#Date#>, duration: <#Time#>, calories: <#Quantity#>, distance: <#Quantity#>)
logWorkout(type: Cycling, date: December 1st 2020, duration: 10 Minutes, calories: 214 cal, distance: 1 mi)


--- title: "Reversing a Commit" lastmod: 2019-03-06T00:00:00.000Z draft: false type: docs maths: true linktitle: "Reversing a Commit" menu: docs: parent: Website Management weight: 190 ---
This page was put separate so that it can be clearly identified in case of emergency. The following will cover how to reverse a commit on GitHub.
NOTE: IF YOU DO THIS IT WILL DELETE EVERYTHING AFTER THE SELECTED COMMIT, SO MAKE SURE NO ONE ELSES CODE IS BEING DELETED, AND/OR YOU HAVE SAVED VERSIONS OF THE DELETED CODE SOMEWHERE ELSE.
Go to the main page of the repository on Github.
Click on the commits button seen on the left.
Pick the commit you want to roll back to. Any commits done after this will be deleted. In the picture below the 9cbf342 commit has been selected (you will pick your own commit).
After selecting the commit you wish to roll back to (not the commit you wish to delete) you will see the following screen:
Copy the highlighted text shown above (the text beside “commit”) - this is the identifier for that commit.
Note: I cut off part of the identifier in the screenshot so that it is not accidentally used.
Open up the command console (git bash) and type (this assumes you are in the relevant repository):
git reset – hard (paste the commit identifier from your clipboard)
git push – force
All commits that occured after the chosen commit will be deleted. You should backup the files before doing this procedure.


{% extends 'hqwebapp/base_section.html' %} {% load crispy_forms_tags %} {% load i18n %} {% load hq_shared_tags %} {% block page_content %}
{% blocktrans %} View enterprise permissions. {% endblocktrans %}
{% blocktrans %} Web users in this project space are automatically granted their same permissions in the following spaces. They will not appear as members of these spaces. {% endblocktrans %}
| {{ mirror }} |


The Dish
By Ross Anthony
Back in '69, the USA made good on its promise to put a man on the moon. This modest, yet charming, Australian comedy asks, "What's the primary purpose of that?" Then answers its own question, "Perhaps a live TV signal so that the entire world, all of mankind, could watch."
Since these signals can't bend around the Earth, the US needs a high performance communications dish on the other side of the planet. When the moon (and therefore Apollo XI) pass over the land down under, all eyes will be on a signal pulled out of the sky by a loveably real team of four gentlemen in a field of sheep. The patient dish director, with a pipe, is the heart of the team. His emotional and sharp-whitted right-hand man has a problem with the no-nonsense black-tied NASA American. The young engineer crunches numbers while wobbling weak in the knees over the local girl who brings the crew lunch.
Such involvement in the lunar landing is a scientist's dream. As the responsibility heats up the tension, bonds cement across our four leads. Meanwhile, the tiny town of Parkes, Australia prepares to be either exulted or embarrassed as obstacles mount, "He knows everything about Apollo 11 - does he know where it is?"
The local band of teens tunes up to play America's national anthem for the visiting US ambassador, but forgoes their own set up for the Jimi Hendrix (teeth to guitar) version. Any disappointment over that missed-op fades when the band's brass instead fires up the theme to "Hawaii Five-O."
This sharp-tongued small film is well directed, acted, cast, written, conceived and scored. The mayor and his family play perfect on the screen. Watching Armstrong take "One giant leap for mankind" on the telly in their living room crowded with neighbors will likely choke you up as it did I.
Quote from engineer Neil "Fox" Mason at the Dish's Control Desk in Parkes, Australia back in '69:
"Delivering the pictures to the world was my proudest moment. Apollo XI was a once in a lifetime experience and it was great listening to the original audio broadcast that is used in the movie. It brought back lots of memories. ... I think it's one of mankind's greatest achievements in the 20th century."
The Dish. Copyright © 2001. Rated PG. * Starring Sam Neill, Kevin Harrington, Tom Long, Patrick Warburton, Genevieve Mody, Tayler Kane, Billie Brown, Roy Billing. * Directed by Rob Sitch. * Written and Produced by Santo Cilauro, Tom Gleiser, Jane Kennedy and Rob Sitch at Warner Bros/Working Dog/Distant Horizon.
Grade..........................A-
-- Copyright © 2000. Ross Anthony, currently based in Los Angeles, has scripted and shot documentaries, music videos, and shorts in 35 countries across North America, Europe, Africa and Asia.
For more reviews visit: http://www.RossAnthony.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


The Spry.Data.DataSet class is the base class from which all other data sets derive from. The Spry.Data.DataSet class provides basic functionality for maintaining an array of row objects, destructive and non-destructive filtering, and sorting.
The Spry.Data.DataSet class derives from Spry.Utils.Notifier so it can also dispatch notifications.
Notifier --> DataSet
Spry.Data.DataSet is the constructor function for the Data Set. The constructor takes an optional single argument, which is an object that specifies the initial options for the Data Set.
Spry.Data.DataSet(options)
N/A
// An example of creating a data set with no options specified: var ds1 = new Spry.Data.DataSet(); // An example of creating a data set with some options defined: var ds2 = new Spry.Data.DataSet({ sortOnLoad: "firstname", sortOrderOnLoad: "descending" });
Only some methods can be called directly after the data set constructor. Some methods depend on the data being loaded to run. The list below can be called directly after the constructor:
All others should be used after the data is finished loading, via called functions or observers.
N/A
This function cancels the loading of the data set data. This is will interrupt any requests made by the loadData() function. This function is also called internally by loadData() before making another request for data.
cancelLoadData()
N/A
N/A
var ds = new Spry.Data.DataSet(); ... ds.loadData(); ... ds.cancelLoadData();
This function is used to remove duplicate rows from the data set. The distinct function will evaluate all the columns and if it finds 2 or more rows where every value is the same, it will throw away the duplicate rows and keep only one. This function can only be called *after* the data has been loaded into the data set.
Distinct can also be run automatically whenever new data is loaded into the data set. This is done by specifying the distinctOnLoad constructor option. In case the distinct functionality is need only for specific column(s) they may be defined through the additional parameter distinctFieldsOnLoad.
distinct(columnNames)
columnNames - String or Array. The column(s) of the data set to use when determining if a row is distinct. This parameter is optional. If ommited, all columns are used to determine if a row is distinct or not. If specified, must be a string that is the name of the column to use for the distinct process, or, must be an array of column names to used for the distinct process.
N/A
/* After a data set is defined and loaded with data, you can call * distinct on it. */ var ds1 = Spry.Data.XMLDataSet("xml.xml","xpath"); ... ds1.distinct(); /* Run distinct automatically whenever data is loaded. */ var ds2 = Spry.Data.XMLDataSet("xml.xml","xpath", {distinctOnLoad: true, distinctFieldsOnLoad:['fld1', 'fld2']});
This function is used to non-destructively filter the data set based on a filter function provided by the caller. The filter function passed in must have the following interface:
function myFilterFunc(ds, row, rowIndex) { ... }
The arguments to this function are as follows:
The caller's filter function is called once for each row in the data set. If the caller's filter function wishes to add the row to the filtered view of the data set, then it must return the row object passed into the function. If it does not want the row to be in the filtered view of the data set, then it must return null.
As previously mentioned, this filtering is done non-destructively so internally, the data set is using the function to determine if it should add a row to a copy of the row array.
The caller's filter function remains active until it is removed. The filter function can be removed by calling filter with a null value instead of a function reference.
After filtering, a call to the getData function will return the filtered array of rows. To get the unfiltered array of rows, you must call getData, passing in a true for the unfiltered argument.
FilterData is the destructive filter, which actually throws out the filtered data from memory.
datasetname.filter(filterFunction);
filterFunction - Function Reference. The function to use to determine if a row should be filtered out or not.
N/A
var myFilterFunc = function(dataSet, row, rowNumber) { // Filter out all rows with paths that begin // with the letter 's'. if (row["@path"].search(/^s/) != -1) return row; // Return the row to keep it in the data set. return null; // Return null to remove the row from the data set. } // Filter the data. dsPhotos.filter(myFilterFunc); ... // Remove the filter. dsPhotos.filter(null);
This function is used to filter the data set based on a filter function provided by the caller. filterData is a destructive method, which means that all rows that are discarded by the filtering is lost. The data can only be retrieved again by loading the data back into the data set again.
The filter function passed in must have the following interface:
function myFilterFunc(ds, row, rowIndex) { ... }
The arguments to this function are as follows:
The caller's filter function is called once for each row in the data set. If the caller's filter function wishes to keep the row, then it must return the row object passed into the function. If it does not want to keep the row, then it must return null.
As previously mentioned, this filtering is destructive so internally, the data set is modifying its only copy of the row array.
The caller's filter function remains active until it is removed, so if the data set is reloaded, the filtering will occur. The filter function can be removed by calling filter with a null value instead of a function reference.
filter is the non-destructive version of this function.
datasetname.filterData(filterFunction);
filterFunction - Function Reference. The function to use to determine if a row should be kept or discarded.
N/A
var myFilterFunc = function(dataSet, row, rowNumber) { // Filter out all rows with paths that begin // with the letter 's'. if (row["@path"].search(/^s/) != -1) return row; // Return the row to keep it in the data set. return null; // Return null to remove the row from the data set. } // Filter the data. dsPhotos.filterData(myFilterFunc); ... // Remove the filter. dsPhotos.filterData(null);
N/A
Finds all rows within the data set that have the same column values contained in the specified object.
findRowsWithColumnValues(valueObj, firstMatchOnly, unfiltered)
valueObj - Object. Object containing the names of the columns and their values which each row must contain to be considered a match.
firstMatchOnly - Boolean. Optional argument. If true, causes the function to return the row object that first matched the values specified in valueObj. If not match was found, returns null.
unfiltered - Boolean. Optional argument. If true the function does its find through the unfiltered set of rows within the data set. If false or undefined, the find is done through the filtered set of rows.
The value returned by this function depends on the value of the firstMatchOnly argument. If firstMatchOnly is true, the function will return either the first row object that matches, or null. If firstMatchOnly is false or undefined, the function will return an array of all matches. This array may be empty (length == 0) if no matches were found.
var ds = new Spry.Data.DataSet(); .. // Look for all rows that have a column called "color" with a value of "red" // and a column called "type" with a value of "sports". var matchingRows = ds.findRowsWithColumnValues({ color: "red", type: "sports" alert("Found " + matchingRows.length + "match(es)."); //Look for the first row that matches: var firstMatchingRow = ds.findRowsWithColumnValues({ color: "red", type: "sports" }, true); if (firstMatchingRow != null) alert("Found a match!"); else alert("Failed to find a match!");
This function returns the column type of the specified column.
getColumnType(columnName);
columnName - String. The name of the column.
The column type of the specified column, as a string:
var ds = new Spry.Data.DataSet(); ... var colType = ds.getColumnType("firstname");
This function returns the object that is the 'currentRow' in the data set. By default, the current row is the first row of the data set, but this can be changed by calling the function setCurrentRow() or setCurrentRowNumber().
getCurrentRow()
N/A
The row object or null.
Developers should note that the row object returned is the data set's internal row object. Any changes to the properties of this object results in a change to the data within the data set.
var row = ds1.getCurrentRow(); if (row["@title"] == "Me, Myself and I") ...
This function returns the row ID of the current row.
Developers should not confuse the ID of a row with the index of the row. The ID is a column that contains a unique identifier for the row. This identifier does not change if the rows of the data set are sorted, where as the row index for a given row will change if the rows are sorted.
getCurrentRowID()
N/A
Integer or String that represents the row ID.
The actual type of the row ID is left up to the implementor, but it must be an integer or string that can be used as a key into an associative array.
var rowID = ds.getCurrentRowID(); alert("Current row is: " + rowID);
This function returns the row index for the current row.
Developers should not confuse the row number for a row with its ID. The ID is a column that contains a unique identifier for the row. This identifier does not change if the rows of the data set are sorted, where as the row index for a given row may change if the rows are sorted.
getCurrentRowNumber()
N/A
Returns an integer index (row number) of the row within the data set.
var rowNumber = ds.getCurrentRowNumber(); alert("Current row number is: " + rowNumber);
This function returns an array of the internal row objects that store the data in the data set. Modifying any property of a row object results in a modification of the data in the data set. Users should keep in mind that some data sets load their data asynchronously, so they should check if it is ok to access the data, with a call to getDataWasLoaded(), before attempting to call getData().
getData(unfiltered)
unfiltered - Boolean. Optional argument. If true, getData() returns the unfiltered data array. If false or undefined, it returns the filtered version of the rows array.
Returns an array of row objects.
// Run through all of the rows in the data set. For each row, // get the value in the "name" column and check to see if it // is equal to the string "Spry". If it is, return the ID of // the matching row. var rows = ds.getData(); for (var i = 0; i < rows.length; i++) { if (rows[i]["name"] == "Spry") return rows[i]["ds_RowID"]; }
This function returns 'true' if a data set successfully loaded its data. If this function returns true, it is safe to access and manipulate the data set. This function will return false if a load request is pending, or an error ocurred while trying to load the data.
getDataWasLoaded()
N/A
true/false
if (ds.getDataWasLoaded()) { var rows = ds.getData(); for (var i = 0; i < rows.length; i++) { if (rows[i]["name"] == "Spry") return rows[i]["ds_RowID"]; } }
This method will return true if a request for data has been made and has not yet completed. Otherwise, it will return false.
getLoadDataRequestIsPending()
N/A
true/false
// Fire off a load request if the data set is not already // in the midst of loading its data: if (!ds.getLoadDataRequestIsPending()) ds.loadData();
This method returns the row object associated with the specified row ID.
getRowByID(rowID)
rowID - Integer or String. The ID of the row.
Returns the row object with the given rowID or null if it is not found.
// Get the row with the ID of 10. var row = ds.getRowByID(10); // If we have a match, extract out the value // of the firstname column. if (row) var firstname = row.firstname;
This method returns the row object at the specified row number within the data set.
getRowByRowNumber(rowNumber, unfiltered)
rowNumber - Integer. The row number of the row to fetch.
unfiltered - Boolean. If true, the data set will return the row object at the given row number in the internal unfiltered data array. Otherwise, it returns the row object at the given row number in the filtered data array.
Returns the row object at the given row number or null if it is not found.
// Get row 10 of the unfiltered data. var row = ds.getRowByRowNumber(10, true); // If we have a match, extract out the value // of the firstname column. if (row) var firstname = row.firstname;
This function returns the number of rows in the data set. If the data set has a non-destructive filter, this function returns the number of filtered rows. Users can pass an optional boolean argument to this function. If true, it will return the number of unfiltered rows. If false it will return the number of filtered rows.
getRowCount(unfiltered);
unfiltered - Boolean. Optional argument. If true, getRowCount the number of rows in the unfiltered data array. Otherwise, it returns the number of rows in the filtered data array.
An integer that is the number of rows in the data set.
var filteredRowCount = ds.getRowCount(); var unfilteredRowCount = ds.getRowCount(true);
This function returns the row number for the specified row object in the data set. If the data set has an active non-destructive filter, the row number returned is of the row within the filtered data array. An optional boolean argument can be passed to the function which tells the function to return the row number for the row within the unfiltered data array.
getRowNumber(rowObject, unfiltered)
rowObject - Object. The row to look for.
unfiltered - Boolean. Optional argument. If true the row number returned for the specified row is its row index within the unfiltered data array. Otherwise, it returns the index of the row within the filtered data array.
An integer that is the number of the specified row in the data set. Returns -1 if the row is not found within the data set.
This function returns the name of the column that was used when the data set was last sorted. This function will return an empty string if the data set was never sorted.
getSortColumn()
N/A
A string that is the name of the column last used for a primary sort. If the data set has never been sorted, an empty it returns an empty string.
var columnName = ds.getSortColumn();
This function returns the name of the sort order that was used when the data set was last sorted. This function will return an empty string if the data set was never sorted.
getSortOrder()
N/A
The current sort order of the data set:
var sortOrderName = ds1.getSortOrder();
datasetname.getUnfilteredData();
This function is *DEPRECATED*. Use getData(true) instead.
The default implementation for this function fires off asynchronous notifications for "onPostLoad" and "onDataChanged" events. Classes that derive from Spry.Data.DataSet are expected to override this function to trigger async loading of the data for the data set.
loadData()
N/A
NA
ds.setURL("newXML.xml"); ds.loadData();"
This function is used to set a column type for a data column. This is used to tell the data set the type of data it is dealing with. A common application is for setting numeric data as 'number'. This ensures that the column will sort numerically, and not alpha-numerically.
The valid column types are:
The 'html' column type results in the automatic entity decoding of values stored in a column of that type when the data is first loaded.
setColumnType(columnName, type)
columnName - String or Array of Strings. The name(s) of the column(s) to set.
type - String. One of the following values:
N/A
var ds1 = new Spry.Data.XMLDataSet("myxml.xml","races/standings"); // Example of setting the type of one column: ds1.setColumnType("start", "date"); // Example of setting the type of multiple columns // with one call: ds1.setColumnType(["rank","place"],"number");
Sets the current row of the data set to the row with the specified row ID.
This method will cause an "onCurrentRowChanged" notification to be sent to all observers.
setCurrentRow(rowID)
rowID - Integer or String. The row ID of the row that is to become the current row.
N/A
// Set the current row of the data set // to the row with the integer ID of 13:
ds.setCurrentRow(13);
This function makes the row, at the specified row number (index), the current row of the data set. Spry uses a zero based counting system for row numbers.
Developers should not confuse the ID of a row with the index of the row. A row ID is a unique identifier that is stored within the row in a column called "ds_RowID". This identifier does not change even if the rows of the data set are sorted, where as the row index for a given row can change if the rows are sorted.
setCurrentRowNumber(rowNumber)
rowNumber - Integer. The row number of the row that will become the current row.
N/A
// Make the 3rd row of the data set the current row. Remember // that the row number is zero based. ds.setCurrentRowNumber(2);
Replaces the data inside the data set with the row data in the specified array. If the row data does not have a ds_RowID column defined, it will automatically create one and assign an ID that is the equivalent of the row's index within the array.
Developers should be aware that the data set takes ownership of the objects within the array that is passed in. That is, it uses those objects as its row object internally. It does not make a copy of the objects.
By default, this function will trigger a synchronous "onPreLoad" notification, followed by asynchronous "onPostLoad" and "onDataChanged" notifications that are made sometime *after* the function has exited. If developers want these notifications to happen synchronously before the function exits, they can pass a true for the optional 2nd argument to the function. Developers should be aware that synchronous notifications could cause potential notification cycles in complex situations where data sets and regions are used together, so use sync notifications with caution.
setDataFromDoc(arrayOfObjects, fireSyncLoad)
arrayOfObjects - Array of row objects.
fireSyncLoad - Boolean. Optional argument. If true forces synchronous notifications for "onPostLoad" and "onDataChanged" before the function exits.
// Create an array of data: var arr = [ { color: "red", type: "sedan" }, { color: "blue", type: coupe" } ]; // Create a data set: var ds = new Spry.Data.DataSet(); // Now set the data inside the data set: ds.setDataFromArray(arr);
Sorts the data set using the specified column(s) and sort order.
Developers specify what columns to sort by passing in a single column name string, or an array of column name strings as the first argument to the function. By specifying more than one column name, developers are able to perform secondary, tertiary, etc, sorts on the data.
Valid sort orders are:
The "toggle" sort order will sort the data set in "ascending" order if it has not been previously sorted, otherwise, it causes the data set to sort in the opposite direction from the last sort.
sort(column, order)
column - String or Array of Strings. The column names to sort.
order - The sort order to be used during the sort. Values for order must be one of the following:
N/A
// An example of sorting a data set in ascending order // based on the values in a single column called "lastname":
ds.sort("lastname", "ascending"); // An example of toggling the sort of a data set based // on the values in multiple columns. Since 3 columns are // specified, the data set will perform a tertiary sort: ds.sort(["firstname", "lastname", "@id"], "toggle");
This function creates an interval timer that will continuously reload the data set at the interval specified.
Every time the interval timer fires, the loadData() method of the data set is called.
startLoadInterval(interval);
interval - Integer. The number of milliseconds that must elapse before the data is reloaded.
N/A
// Reload the data in the data set every 10 seconds: ds.startLoadInterval(10000);
This function kills the interval timer that was started with a call to startLoadInterval().
stopLoadInterval()
N/A
// Reload the data set every 10 seconds: ds.startLoadInterval(10000); ... // Stop the continuous loading of data: ds.stoptLoadInterval();
Copyright © 2007. Adobe Systems Incorporated.
All rights reserved.


'Outback Gable' Verandahs, Pergola or Patio
Exhibiting a strong presence and style, the pitched roof of a Stratco Outback Gable Carport, Pergola, Verandah or Patio is endowed with an open feel that will enrich your home and outdoor area.
Contact Shane on<PHONE_NUMBER>
Enhance your lifestyle with a Stratco Outback Gable veranda, patio or carport
The Stratco Outback Gable is available as a freestanding unit or attached to your home. Combined with flat roof or pergola sections, the prominent pitched roof becomes the main feature of the design.
The gable is available in a Clearspan design. Match the Outback Deck with Outback Rooflites to supply natural filtered light.
Clearspan Gable
The Outback Clearspan Gable uses only the Outback Deck, a very strong material that does not need extra purlins to support it. This leaves the roof area clean and uncluttered. The Clearspan Gable can span an impressive 7.5 metres wide with a 22 degree pitch.
Outback Gable | Showcase
View some of the stunning Melbourne 'Outback Gable'
Verandahs, Carpots and Patios below.


Home
Vehicle Booking
Contact Us
About us
Vehicle Booking Form
First Name
Last Name
Address
Address 2
City
State
Choose...
...
Zip
Model Name
Choose...
Maserati
Audi R8
Mercedes Benz
Model color
Choose...
yellow
white
red
Days Hired
Check me out
Reserve The Beast!
Copyright © 2021 All Rights Reserved To NFZ's Nifkolo.inc


File
public class File
Provides access to a file on the local file system
-
Checks that the file exists on the file system - returns: True if the file exists or false otherwise
Declaration
Swift
public var exists: Bool
Return Value
True if the file exists or false otherwise
-
Returns true if the file has been opened
Declaration
Swift
public var isOpen: Bool
-
Returns the file’s path
Declaration
Swift
public var path: String
-
Returns the file path. If the file is a symbolic link, the link will be resolved.
Declaration
Swift
public var realPath: String
-
Returns the modification date for the file in the standard UNIX format of seconds since 1970/01/01 00:00:00 GMT - returns: The date as Int
Declaration
Swift
public var modificationTime: Int
Return Value
The date as Int
-
Create a file object given a path and open mode - parameter path: Path to the file which will be accessed - parameter fd: The file descriptor, if any, for an already opened file
Declaration
Swift
public init(_ path: String, fd: Int32 = -1)
Parameters
path
Path to the file which will be accessed
fd
The file descriptor, if any, for an already opened file
-
Closes the file if it had been opened
Declaration
Swift
public func close()
-
Resets the internal file descriptor, leaving the file opened if it had been.
Declaration
Swift
public func abandon()
-
The current file read/write position.
Declaration
Swift
public var marker: Int
-
Closes and deletes the file
Declaration
Swift
public func delete()
-
Moves the file to the new location, optionally overwriting any existing file - parameter path: The path to move the file to - parameter overWrite: Indicates that any existing file at the destination path should first be deleted - returns: Returns a new file object representing the new location - throws:
PerfectError.FileError
Declaration
Swift
public func moveTo(path: String, overWrite: Bool = false) throws -> File
Parameters
path
The path to move the file to
overWrite
Indicates that any existing file at the destination path should first be deleted
Return Value
Returns a new file object representing the new location
-
Copies the file to the new location, optionally overwriting any existing file - parameter path: The path to copy the file to - parameter overWrite: Indicates that any existing file at the destination path should first be deleted - returns: Returns a new file object representing the new location - throws:
PerfectError.FileError
Declaration
Swift
public func copyTo(path pth: String, overWrite: Bool = false) throws -> File
Parameters
path
The path to copy the file to
overWrite
Indicates that any existing file at the destination path should first be deleted
Return Value
Returns a new file object representing the new location
-
Returns the size of the file in bytes
Declaration
Swift
public var size: Int
-
Returns true if the file is a symbolic link
Declaration
Swift
public var isLink: Bool
-
Returns true if the file is actually a directory
Declaration
Swift
public var isDir: Bool
-
Returns the UNIX style permissions for the file
Declaration
Swift
public var perms: Int
-
Reads up to the indicated number of bytes from the file - parameter count: The maximum number of bytes to read - returns: The bytes read as an array of UInt8. May have a count of zero. - throws:
PerfectError.FileError
Declaration
Swift
public func readSomeBytes(count: Int) throws -> [UInt8]
Parameters
count
The maximum number of bytes to read
Return Value
The bytes read as an array of UInt8. May have a count of zero.
-
Reads the entire file as a string
Declaration
Swift
public func readString() throws -> String
-
Writes the string to the file using UTF-8 encoding - parameter s: The string to write - returns: Returns the number of bytes which were written - throws:
PerfectError.FileError
Declaration
Swift
public func write(string: String) throws -> Int
Parameters
s
The string to write
Return Value
Returns the number of bytes which were written
-
Write the indicated bytes to the file - parameter bytes: The array of UInt8 to write. - parameter dataPosition: The offset within
bytes
at which to begin writing. - parameter length: The number of bytes to write. - throws:PerfectError.FileError
Declaration
Swift
public func write(bytes: [UInt8], dataPosition: Int = 0, length: Int = Int.max) throws -> Int
Parameters
bytes
The array of UInt8 to write.
dataPosition
The offset within
bytes
at which to begin writing.length
The number of bytes to write.
-
Attempts to place an advisory lock starting from the current position marker up to the indicated byte count. This function will block the current thread until the lock can be performed. - parameter byteCount: The number of bytes to lock - throws:
PerfectError.FileError
Declaration
Swift
public func lock(byteCount: Int) throws
Parameters
byteCount
The number of bytes to lock
-
Unlocks the number of bytes starting from the current position marker up to the indicated byte count. - parameter byteCount: The number of bytes to unlock - throws:
PerfectError.FileError
Declaration
Swift
public func unlock(byteCount: Int) throws
Parameters
byteCount
The number of bytes to unlock
-
Attempts to place an advisory lock starting from the current position marker up to the indicated byte count. This function will throw an exception if the file is already locked, but will not block the current thread. - parameter byteCount: The number of bytes to lock - throws:
PerfectError.FileError
Declaration
Swift
public func tryLock(byteCount: Int) throws
Parameters
byteCount
The number of bytes to lock
-
Tests if the indicated bytes are locked - parameter byteCount: The number of bytes to test - returns: True if the file is locked - throws:
PerfectError.FileError
Declaration
Swift
public func testLock(byteCount: Int) throws -> Bool
Parameters
byteCount
The number of bytes to test
Return Value
True if the file is locked


HolidayBooking
PackageSelection
HolidayPackage.nel
HolidayBooking
BookingHistory
PackageSelection
Reports
Report1
Report2
Report3
Employee Maint.
Human Resources
+


The goal of this post is to setup Facebook authentication in a way that we get access to the person’s basic information and their email address when they log in.
Setting up auth from an external service is hard. At least it is if the steps aren’t really documented. I’m sharing the steps I followed to get Facebook auth working for a brand new ASP.NET Core site.
These instructions assume you’ve got Visual Studio 2015 RC1 installed. I expect these steps should keep working after VS RTMs as well.
The official docs contain good instructions, but they’re not quite complete. Let’s start off by following them and then we’ll move forward from there:
Run the app to make sure it works. In the site, click the “Log in” button on the top left corner to see the login screen. You’ll note that it lets you create a new account. It saves this account in a local Sql database that was installed on your computer with Visual Studio (we’ll talk more about this later). On the right hand side you’ll see instructions for setting up logins using an external service like Facebook.
Get Facebook developer credentials by creating an app in Facebook
Use SecretManager to store the Facebook AppId and AppSecret. The SecretManager is a pretty cool tool since it gives you a good place to put your secrets without risking them accidentally ending up checked into your source control and ending up on Github
Enable the Facebook middleware. This tells ASP.NET Core that you want to use Facebook authentication and will set you up with the basics that you’ll need. Visual Studio will prompt you to add a reference to Microsoft.AspNet.Authentication.Facebook when you add the Facebook middleware code.
Herea are the two changes you’ll have made to your project: adding the Facebook middleware and adding the reference
If you run your site and try to login with your Facebook account you may notice the following error:
That’s because we never setup the database! What, you don’t remember creating a database? That’s because it was done for you automatically when you created the project, or at least part of it was.
When you installed Visual Studio 2015, you also got a copy of sqllocaldb installed on your computer. That lets your computer act as a local Sql Server instance and you can create and access databases on it. If you look in your site’s appsettings.json file you’ll see something similar to the following setting that sets your connection string:
json
"Data": {
"DefaultConnection": {
"ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=aspnet5-FacebookAuthSite-1746853f-78c4-4424-8598-a8e8d950b167;Trusted_Connection=True;MultipleActiveResultSets=true"
}
}
That’s says where your database is. This is great for testing, but once you’re ready to host your site in the cloud you’ll want to change that connection string to point to a database on Azure SQL Server or some other cloud server. You don’t need to worry abou this right now, but when you’re ready to change the connection string you can use the SecretManager on your local computer to hold the connection string for the local sql db, while use a different type of configuration (like an App Setting if you’re hosting your site on Azure Web Apps) to store your production database’s connection string.
We need to create the all the user tables for our site (we never created them, hence the error message that we saw). Normally we’d do this using Entity Framework migrations on the command line (via commands ‘dnx ef migrations add {migrationName}’ and ‘dnx ef migrations update’), but luckily for us our site shows a handy “Apply Migrations” button that’ll just do that for us. Just click that button and your database will be setup. And then hit refresh to see the working web page.
Now if you go back to the login screen and try to create a site using Facebook authentication, you’ll be redirected to a page that prompts you to add an email address to complete your registration.
That’s a bit inconvenient for the user, ideally we’d just ask Facebook to give us the user’s email address. So let’s do that.
The way we do that is by asking the user for permission to access their personal information when we register them. This is done by specifying Facebook Permissions in our authentication code. Each kind of permission lets us pull different user information from Facebook. We really just want ‘email’, but let’s also get ‘public_profile’ just for the heck of it (I think we get ‘public_profile’ by default anyways).
We add these permissions by to the options we send in to the UseFacebookAuthentication middleware. In Startup.cs, in the Configure method, change the call to UseFacebookAuthentication to:
``` csharp app.UseFacebookAuthentication(options => { options.AppId = Configuration[“Authentication:Facebook:AppId”]; options.AppSecret = Configuration[“Authentication:Facebook:AppSecret”];
options.Scope.Add("public_profile");
options.Scope.Add("email"); }); ```
Now when the user tries to register using Facebook auth they’ll see something like this if they click the ‘Edit the info you provide’ button on Facebook.
When they click Ok you’ll have access to read their email address!
Great, we can access the email address, but when we try to register we still get back to the same page as before with a blank email:
What gives? Let’s take a look at the code. The route we’re hitting is “Account/ExternalLoginCallback”, so let’s look at the Account controller class, ExternalLoginCallback method. Near the bottom of that method is the code
csharp
var email = info.ExternalPrincipal.FindFirstValue(ClaimTypes.Email);
So we’re expecting the email address claim (claims are how we identify information about users who are trying to log in) but we’re not getting it. If you inspect that code in the debugger you can verify that there is no email claim.
Turns out Facebook doesn’t send that to us when the user logs in. I don’t know why. But we can explicitly ask Facebook for this information. To do that we need to make an http request to Facebook’s Graph Api. The Graph Api lets us access all the information about the user that we had earlier requested access to.
The Graph Api is a REST Api, but in order to avoid the complexities of using it I’ll just use the Facebook nuget package. Unfortunately this package does not work on the dnxcore environment, meaning we can only run it on Windows based servers, but you can create your own Facebook Graph Api client if you want to run your site using dnxcore.
Let’s install the Facebook nuget package by modifying the frameworks element in your project.json file to like like the following:
json
"frameworks": {
"dnx451": {
"dependencies": {
"Facebook": "7.0.6"
}
}
}
We had to remove the dnxcore framework since we will no longer support it, and we’re marking the Facebook package explicitly as a dnx451 only package.
Now to actually use the Graph Api lets go back to the Startup.cs class -> Configure method -> UseFacebookAuthentication middleware. We want to configure the options to say that whenever a user logs in, call the Facebook Graph Api and get the user’s email address, and add that as the email claim. You’ll use the following code to do that (intellisense will prompt you to add some dependency references and using statements as well):
``` csharp app.UseFacebookAuthentication(options => { options.AppId = Configuration[“Authentication:Facebook:AppId”]; options.AppSecret = Configuration[“Authentication:Facebook:AppSecret”];
options.Scope.Add("public_profile");
options.Scope.Add("email");
options.Events = new OAuthEvents
{
OnCreatingTicket = context => {
// Use the Facebook Graph Api to get the user's email address
// and add it to the email claim
var client = new FacebookClient(context.AccessToken);
dynamic info = client.Get("me", new { fields = "name,id,email" });
context.Identity.AddClaim(new Claim(ClaimTypes.Email, info.email));
return Task.FromResult(0);
}
}; }); ```
(Fyi, the team managing the Facebook package has vanished into the netherwebs, but you can find a [cached copy of their documentation here] (http://web.archive.org/web/20150317045522/http://facebooksdk.net/docs/web/getting-started/))
Now if we redeploy our site and try to register using Facebook we’ll see the following page:
We have the email!
Note, this message is a bit wasteful since we’ll be asking Facebook to give us the user’s email address on every authenticated request that they make, when we really only want to do this when they first register. I’ll leave it as an exercise for the user to optimize this code flow.
The code you have now should match what’s in this commit.
Great, we’re now reading the email address. And we know the user’s name. So what do we need this extra registration page for?
We should really just register the user automatically.
Digging around in the code, we see that in the AuthenticationController class, the ExternalLoginCallback method creates an ExternalLoginConfirmationViewModel view model with the user’s email and then calls the ExternalLoginConfirmation view to let the user add in the custom details, which, when the user hits “Register” will send a POST request to the ExternalLoginConfirmation method with all the required data. We can skip the middle step of involving the user and just send the required data to the ExternalLoginConfirmation method ourselves.
In fact, if you look at the ExternalLoginConfirmation method, they set the user’s email as the user name as well. Let’s fix that too while we’re at it.
csharp
var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
The first step will be to extend our ExternalLoginConfirmationViewModel to add a UserName property. Edit ViewModels\ExternalLoginConfirmationViewModel.cs to look like the following:
``` csharp public class ExternalLoginConfirmationViewModel { [Required] [EmailAddress] public string Email { get; set; }
[Required]
[EmailAddress]
public string UserName { get; set; } } ```
Now, in our AccountController’s ExternalLoginCallback method, change the last else statement (where it calls the ExternalLoginConfirmation View) to match the below code. We’re specifying the UserName using the Name claim and passing that directly to the ExternalLoginConfirmation method instead of invoking a View. The ExternalLoginConfirmation will generate and return the regisration completed view directly.
``` csharp else { // If the user does not have an account, then ask the user to create an account. ViewData[“ReturnUrl”] = returnUrl; ViewData[“LoginProvider”] = info.LoginProvider; var email = info.ExternalPrincipal.FindFirstValue(ClaimTypes.Email); var name = info.ExternalPrincipal.FindFirstValue(ClaimTypes.Name);
return await ExternalLoginConfirmation(new ExternalLoginConfirmationViewModel { Email = email, UserName = name });
name }); } ```
We also need to modify the ExternalLoginConfirmation to actually read the UserName from the model:
``` csharp
public async Task
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return View("ExternalLoginFailure");
}
var user = new ApplicationUser { UserName = model.UserName, Email = model.Email };
var result = await _userManager.CreateAsync(user); ```
And finally we need to modify the last line of ExternalLoginConfirmation, where it returns the view, to explicitly mention the name of the view:
csharp
return View("ExternalLoginConfirmation", model);
Without that line, when ExternalLoginCallback calls ExternalLoginConfirmation, the View method would look for a view named ExternalLoginCallback, which doesn’t exist.
Now let’s try to run our site and log in. And you might now see an error like
The message says that the name can only have numbers and letters, but my name contains a space so it’s complaining. It’s gonna be tough getting names from Facebook if we don’t allow spaces in the name, so let’s fix that.
This setting resides back in Startup.cs, but this time we’ll go to the ConfigureServices method, which is where all the dependency injection gets setup. We’ll modify the services.AddIdentity()
method to pass in the below options:
csharp
services.AddIdentity<ApplicationUser, IdentityRole>(options => {
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._' ";
})
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();
This expands our list of allwed characters in the user name to include a space, and I also threw in a few extra characters for good measure. It’s not perfect, but it’ll at least protect us from some of the falsehoods developers believe about names.
Try running your site again and registering as a new user using Facebook authentication and…hey we’re in!
Fyi, this commit contains all the changes you should have made.
We’ve registered a user, but where is the data actually stored? Lets take a quick look around the database and check it out.
In Visual Studio, go to View->SQL Server Object Explorer to start browsing the database. There if you poke around the folders you’ll find a database corresponding to your project.
You can expand the database to see all the tables in there. Right now you’ll only see tables created for managing users.
Right click the dbo.AspNetUsers table and click “View data”, and you’ll see a table open up containing the Facebook user you just registered!
That’s it for this post. Hope you guys were able to follow all the steps. Shout out in the comments if you found this stuff helpful or if you run into any problems.


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
A
B
C
D
E
F
G
H
I
K
L
M
N
O
P
R
S
T
U
V
W
X
I
IData
- Interface in
interfaces
IDisplay
- Interface in
interfaces
IGameEditor
- Interface in
gameElements
IGameLoader
- Interface in
interfaces
IGoal
- Interface in
gameElements
IGoalVisitor
- Interface in
gameElements
IKeyboardAction
- Interface in
gameElements
IKeyboardAction.KeyboardActions
- Enum in
gameElements
ILevel
- Interface in
gameElements
incrementHealth(double)
- Method in class gameElements.
Health
init(SettingsWindow)
- Method in class authoringEnvironment.mainWindow.
GameMakerWindow
initMenuBar(ITabPane)
- Method in class authoringEnvironment.authoringToolbar.
AuthoringMenubarCreator
This method initializes the menubar using the tabpane (to set the add tab action).
IntegerPropertyConverter
- Class in
exampledata.XStreamHandlers
Created at 17/09/11 11:16.
IntegerPropertyConverter(Mapper)
- Constructor for class exampledata.XStreamHandlers.
IntegerPropertyConverter
interfaces
- package interfaces
IProperties
- Interface in
spriteProperties
Created by davidyan on 4/6/16.
isCollidingWithUser(Collision)
- Method in class gameElements.
Collision
IScreen
- Interface in
gameplayer
isDead()
- Method in class gameElements.
Health
isDead()
- Method in class gameElements.
Sprite
isEnabled()
- Method in class gameElements.
Defense
isFinished()
- Method in class gameElements.
Goal
isFinished()
- Method in class gameElements.
GoalProperties
isUserControlled()
- Method in class gameElements.
Actor
isUserControlled()
- Method in class gameElements.
Sprite
ITab
- Interface in
interfaces
ITabPane
- Interface in
interfaces
ITEMPATHS
- Static variable in class authoringEnvironment.itemWindow.
ItemWindowData
ItemPaths
- Static variable in class authoringEnvironment.itemWindow.
ItemWindowData
ItemWindow
- Class in
authoringEnvironment.itemWindow
ItemWindow(ITabPane)
- Constructor for class authoringEnvironment.itemWindow.
ItemWindow
ItemWindowData
- Class in
authoringEnvironment.itemWindow
ItemWindowData()
- Constructor for class authoringEnvironment.itemWindow.
ItemWindowData
A
B
C
D
E
F
G
H
I
K
L
M
N
O
P
R
S
T
U
V
W
X
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes


Key Bindings Explorer Module
Features
Key Bindings Explorer is a simple module that lets you explore
all the currently defined key bindings. Invoking the actions shows the Key
Binding Dialog showing the current key bindings in a tablular form.
- Show Key Bindings (Alt+U K)
- Show Action Bindings (Alt+U A)
In each row of the table it shows details of the key binding.
- The first column shows the key sequence that invokes the action.
- The second column shows the key sequence (without the modifiers) that
invokes the action.
- The third column shows the invoked action.
- The fourth column shows the context in which the key sequence is
applicable. A blank context means global context. Other contexts indicate
the type of editor.
On top of the first, second and third column there are text fields which let you
quickly search for an entry in respective columns. In the text fields above
the first and second column simply type the key sequence (e.g. Alt+U) to
initiate the search.
The table columns can be sorted (ascending and descending) by clicking on the headers.
Use control click to do add secondary and tertiary sort columns.
You can also save the current view as Html/Xml by clicking on the Output
to Html/Xml actions.
TODO:
- Show non bound actions.
- Support modification of key bindings.


I used to know a man whose name, unusually, was Hot Zinc. His character was equally rum. He muttered much in Dutch, while twisting twigs into dollies. Angular and emaciated, they were frightening dollies, quite unsuitable for the tiny tots who form the standard dolly demographic.
The airbag in his car was of a wholly new type. It was devised by his cousin. He had dozens of cousins, and the name of the airbag designer was Ulf Drib, which is an anagram of bird flu.  In May 1968 he threw a pebble at a policeman in Paris. Youthful folly! Now he was fat and comfortable and bourgeois and able to manipulate air in wondrous ways.
It was good thing he did, for Hot Zinc was a terrible driver. He ploughed into a gaggle of swans beside a canal. The prototype new airbag saved his life. The swans', not.