Check your email for your account verification link. Check out our premium packages by clicking here or pressing the button below.
Welcome:
{{ user.name }}
{{ user.email }}
Your account will give you access to view and sample our entire database but the content you are sampling will only play for 20 minutes. Get your premium account today and share your account with 3 friends! Update your profile pic in the account
section


Reports invalid definition of a typing.NamedTuple.
Example:
import typing
class FullName(typing.NamedTuple):
first: str
last: str = ""
middle: str
As a fix, place the field with the default value after the fields without default values:
import typing
class FullName(typing.NamedTuple):
first: str
middle: str
last: str = ""


Enable camera
Start streaming
Stop streaming
CUE
Settings
Metadata
Format
Video Bitrate (MB/s)
Samplerate
Audio Bitrate (kB/s)
Channels
Stereo
Mono
Stream destination URI
Metadata updated!
Title:
Artist:
Update Metadata
Webcaster Client
Playlist 1
CUE
Title
Artist
Duration
Add files to playlist:
Play Through
Repeat playlist
Mixer
Microphone
CUE
Microphone source
Playlist 2
CUE
Title
Artist
Duration
Add files to playlist:
Play Through
Repeat playlist


Every decade develops new generation, generation that changes the tourism industry a sequence of stages to progress. Still events are known to be the spot of tourist visit in such places. Though as for the event to occur there need a place for the event to happen, therefore “EL MALOR” will be built to serve any event.
This improves the local economy, and to give big role on such event to happen, it provides the necessities of the event goer, ultimately to encourage in opportunity for a return visit, or to promote the events place to the market as a form word-of-mouth marketing.
See portfolioIf the reader notices the interior page design of a book – even if he or she likes what they see – I’ve missed, because I distracted them from their reading.
The space between an idea and a concept is your lips. If you can’t say it out loud you can’t do it.


{% extends "base.html" %} {% block content %}
Created at : {{ post.created }}
By : {{ post.user }}
{{ post.description }}


mutant fibre plant control jute strength {border-style "thick stem" px;} #ffffff;} tensile plants pollen diameter seed types Fibre fibres lignin mutants Research higher reported traits yield JRO following generations olitorius px; relation stem {font-family font-size grains significantly –. g/tex, (.% Analyses Corchorus Datta Plant SEM Table control. double; high number seeds significant type < .%) Palit Sengupta Technology University border-color border-width breeding cell content induced low morphometric phloem plant, raw size solid; {font-style {font-weight > (control: . cm Anatomical Fibres Figure Furthermore, Girth Jute Lignin Pollen Results Stem analysis assess assessed base, bold bundle bundles considering courier; economic efficient em; enhancement generation germination holocellulose important middle, mutant: normal noted obtained presented pt;} randomly secondary single suitable taken total types. upper


I used to write a lot. It wrote about day-to-day. I wrote about wins and losses, living, learning, and people. I haven’t written that way in a long time. I want to change that.
I wrote, what seems like ages ago, about a shift in my career. I left the classroom.  Honestly, until last March, I hadn’t ever considered what it would be like to not be a teacher. I went into college having my major declared. I stuck with the program, even though I wanted to quit in my third year. And I can’t even begin to explain how glad I am to have stayed with it for (nearly) four years after graduating.
I do have to admit that I’m still struggling with being part of the 50%. I had my reasons, as I’m sure everyone else does. But, it’s still hard to answer the question, or respond to the looks when I tell people I left teaching. Interesting side note: this fall was the first time in 25 years or so (including my own schooling) in which I didn’t experience a first day of school. It is definitely strange.
But, even in absentia, I can still experience students.
I bought a house nearly a year ago. We had overlooked it mainly because it looked pretty ugly on the inside. Not gonna lie. The yard is awesome though. We’ve got a full acre of land, with half of it fenced in the back. (I feel completely comfortable saying that a dog is in our future sometime.)
We moved in planning on doing some remodeling at some point. Mostly, because of the kitchen.
And then, we got another incredible piece of news.
My life had been inexplicably changed with the sound of my daughter’s heart beating strong and resolute. We had some serious work to do. What ensued was a display of love, support, and encouragement from family and friends as my wife and I worked hard to make sure our home would be ready for little _____ (sorry!) when she arrives any time now. It started with the kitchen and quickly spilled out into our dining room. (There are far too many pictures to post here, so feel free to browse through the project on Flickr.)
I haven’t been around for a while. I’m not writing in an effort to explain my absence or even to get more likes, props, kudos, or back-slaps for the blessings I’ve been given this year. I’m writing because of the support I’ve felt, along with friends and family physically here, from you. The notes on Twitter, the blog comments, and the emails…they did not fall on deaf ears.
The year has been wonderful, and I’m excited about the new things on my horizon, even though they’re not in a physical classroom any more. I’m reminded every day that learning can, and should, happen without walls, and I’m thankful for the friends surrounding me, helping me continue to learn.
Written on September 11th, 2013 by Brian Bennett Categorized in: All Life
Leave a comment


public interface VuforiaLocalizer
VuforiaLocalizer
interface provides
an interface for interacting with subsystems that can help support localization through
visual means.| Modifier and Type | Interface and Description |
|---|---|
static class |
VuforiaLocalizer.CameraDirection
VuforiaLocalizer.CameraDirection enumerates the identities of the cameras that Vuforia can use. |
static class |
VuforiaLocalizer.CloseableFrame
VuforiaLocalizer.CloseableFrame exposes a close() method so that one can proactively
reduce memory pressure when we're done with a Frame |
static class |
VuforiaLocalizer.Parameters
VuforiaLocalizer.Parameters provides configuration information for instantiating the Vuforia localizer |
| Modifier and Type | Method and Description |
|---|---|
CameraCalibration |
getCameraCalibration()
(Advanced) Returns information about Vuforia's knowledge of the camera that it is using.
|
java.util.concurrent.BlockingQueue<VuforiaLocalizer.CloseableFrame> |
getFrameQueue()
(Advanced) Returns a queue into which, if requested, Vuforia
Frame s are placed
as they become available. |
int |
getFrameQueueCapacity()
Returns the current capacity of the frame queue.
|
VuforiaTrackables |
loadTrackablesFromAsset(java.lang.String assetName)
Loads a Vuforia dataset from the indicated application asset, which must be of
type .XML.
|
VuforiaTrackables |
loadTrackablesFromFile(java.lang.String absoluteFileName)
Loads a Vuforia dataset from the indicated file, which must be a .XML file
and contain the full file path.
|
void |
setFrameQueueCapacity(int capacity)
Sets the maximum number of
Frame s that will simultaneously be stored in the
frame queue. |
VuforiaTrackables loadTrackablesFromAsset(java.lang.String assetName)
Datasets are created using the Vuforia Target Manager
assetName
- the name of the .XML dataset asset to loadloadTrackablesFromFile(String)
VuforiaTrackables loadTrackablesFromFile(java.lang.String absoluteFileName)
Datasets are created using the Vuforia Target Manager
absoluteFileName
- the full path to the .XML file of the datasetloadTrackablesFromAsset(String)
CameraCalibration getCameraCalibration()
com.vuforia.Tool#getProjectionGL(CameraCalibration, float, float)
java.util.concurrent.BlockingQueue<VuforiaLocalizer.CloseableFrame> getFrameQueue()
Frame
s are placed
as they become available. This provides a means by which camera image data can be accessed
even while the Vuforia engine is running.
While the Vuforia engine is running, it takes exclusive ownership of the camera it is
using. This impedes the ability to also use that camera image data in alternative visual
processing algorithms. However, periodically (at a rate of tens of Hz), the Vuforia engine
makes available Frame
s containing snapshots from the camera, and through which
camera image data can be retrieved. These can optionally be retrieved through the frame
queue.
To access these Frame
s, call setFrameQueueCapacity(int)
to enable the
frame queue. Once enabled, the frame queue can be accessed using getFrameQueue()
and the methods thereon used to access Frame
s as they become available.
When setFrameQueueCapacity(int)
is called, any frame queue returned previously by
getFrameQueue()
becomes invalid and must be re-fetched.
Frame
s may be retrieved.setFrameQueueCapacity(int)
,
Frame (Java),
Frame (C++),
BlockingQueuevoid setFrameQueueCapacity(int capacity)
Frame
s that will simultaneously be stored in the
frame queue. If the queue is full and new Frame
s become available, older frames
will be discarded. The frame queue initially has a capacity of zero.
Note that calling this method invalidates any frame queue retreived previously
through getFrameQueue()
.
capacity
- the maximum number of items that may be stored in the frame queuegetFrameQueue()
,
getFrameQueueCapacity()
int getFrameQueueCapacity()
setFrameQueueCapacity(int)
,
getFrameQueue()


In step two, you consent to a security screening. Please read the declaration before agreeing. You must also download, read and upload a signed consent form.
Complete all fields and upload all forms to submit your application.
(i) the Criminal Code, the Controlled Drugs and Substances Act (Canada), the Cannabis Act (Canada), or the Narcotic Control Act (Canada);
(ii) the British Columbia Cannabis Control and Licensing Act, the Cannabis Distribution Act, the Liquor Control and Licensing Act or the Liquor Distribution Act;
(iii) a provision of an Act of a province or territory if the provision regulates cannabis.
This includes ALL charges or convictions, including information as a young person under Section 119(1)(o) during the access period under the Youth Criminal Justice Act, regardless of the outcome, convictions that have received a record suspension and charges resulting in non-convictions.
The information on this form is required for the purpose of conducting a security screening assessment. It is a collected pursuant to section 8(1) fo the Privacy Act of Canada, and Section s.26(c) and 33.1(1)(b) of the British Columbia Freedom of Information and Protection of Privacy Act (FOIPPA).
The information on this form is required for the purposes of conducting a security screening assessment. It is collected pursuant to Section 8(1) of the Privacy Act of Canada, and Sections s.26(c), 32(b) and 33.1(1)(b) of the British Columbia Freedom of Information and Protection of Privacy Act (FOIPPA).
The Worker Security Verification Application requires the applicant’s signature. Digital signatures are not permitted.
Sign and make a high-resolution scan or photograph of your form.
Upload your completed signature form before continuing to submit and pay.
You are now ready to submit and pay. The security verification fee is $100. Please note this fee is non-refundable.
You'll make your payment through BC ExpressPay, a secure government service. It takes MasterCard and Visa debit and credit cards and American Express.
The Security Programs Division (SPD) will collect your personal information for the purpose of fulfilling the requirements of the Cannabis Control and Licensing Act (CCLA) and associated regulations in cannabis licensing, compliance and enforcement matters in accordance with Sections 26 (a) and (c) of the Freedom of Information and Protection of Privacy Act. Should you have any questions about the collection, use, or disclosure of personal information, please contact the Liquor and Cannabis Regulation Branch via mail to PO Box 9292 Stn Prov Govt Victoria B.C. V8W 9J8; email to CannabisWorker@gov.bc.ca;.


You can check out the source code for this project on GitHub
This map shows the path wastewater takes to the ALCOSAN treatment facility from an address or place name you search.
On the map, you'll see the sewer infrastructure network in the ALCOSAN service area. This represents a composite of data from 82 municipalities and authorities, with the color of the pipe indicating who owns the pipes.
Notably, this map shows the municipal sewer lines that may be taken over by ALCOSAN. This process, called regionalization, entails the transfer of ownership of multi-municipal trunk sewers, wet weather control facilities, and related infrastructure from customer municipalities to ALCOSAN. Note that regionalization extents shown here are preliminary and subject to change. Learn more about the regionalization process from the ALCOSAN website.
Using an address or place name, the map searches for the nearest sewer infrastructure and follows the network all the way downstream to the ALCOSAN treatment facility.
When you type in an address, the mapping program uses a geocoder to calculate the latitude and longitude of the address: the address's location in real-world coordinates. From that location, it determines where the nearest sewer structure is, and then traces the pipes downstream to the ALCOSAN treatment facility. On its way to ALCOSAN’s plant, wastewater passes through many miles of pipe and often through several municipalities. This highlights the inter-municipal nature of regional wet weather management, and the challenges that municipalities face in maintaining many miles of sewer line.
This map utilizes an existing database of sewer pipe infrastructure in the region. That database is maintained by 3 Rivers Wet Weather,with support from ALCOSAN and the 82 communities within ALCOSAN's service area.
Generally, Flush-It! will give you a good sense of where and how far your toilet flushes go. However, the starting point is an approximation, and it should not be used for planning or official use.
You can check out the source code for this project on GitHub.
The sewer database is managed in a geographic information systems (GIS): a PostGIS-enabled PostgreSQL database, from which the data is provided as a geo-aware web service via Esri ArcGIS Server software. The tracing functionality comes from a geoprocessing service that runs on that software and taps the database. The client-side web application makes calls to to both the database and the geoprocessing service via the ArcGIS REST API to do it's thing.
On the front-end (the map), we're using the Leaflet web mapping library, with an Open Street Map-sourced basemap service from Mapbox that we custom designed. Together, this software assembles all the contextual information, sewer data, and trace results onto the web map.
The rest of the application utilizes some other typical web and server libraries: Python Flask on the back-end, and Bootstrap and jQuery on the front-end.
The accuracy of the trace is limited by a combination of two factors: the varying spatial accuracy of the geocoder, and the lack of consistently documented service line locations (the connections from a building to the sewer). Consequently, you may find that the trace doesn't start quite where you think or know it should. To keep things simple (and fast) for this demonstration, we only look for the nearest sewer structure to the geocoded location.
Since the geocoded location is likely not the point at which the sewer service line attaches the building at the address, and because we don't have control over where specifically that address gets put on the map (we're using a geocoding service from Mapbox), the starting point for the trace is an approximation. Furthermore, the nearest structure to the geocoded address is not likely where the service line actually ties into the sewers—it likely connected directly to a pipe.
The underlying GIS technology and data utilized by the map is already in place and is used on a daily basis; we merely interfaced with it in a different way to make this little mapping application. With the exception of Esri ArcGIS Server, all of the software used by this application is free and open source.
In addition to showing where your toilet flushes go, this map demonstrates the power of using open data standards and open-source technology designed for the modern web.
What does this mean? Regionalization entails the transfer of ownership of trunk sewers, wet weather control facilities, and related infrastructure from customer municipalities to ALCOSAN. Learn more about regionalization from 3 Rivers Wet Weather.
You can check out the source code for this project on GitHub


| $$$$$$$ | SPONSOR | $$$$$$$ |
| SPONSOR | $$$$$$$ | SPONSOR |
|
Try it for free Already using Lasck? Sign in. |
| COMPANY | PRODUCT | RESOURCES | EXTRAS |
| About Us | Why Lasck? | Download | Podcast |
| Careers | Enterprise | Help Center | Lasck Shop |
| Blog | Customer Stories | Guides | Lasck at Work |
| Press | Pricing | Partners | Lasck Fund |
| Brand Guidelines | Security | Events | |
| App Directory | |||
| API | |||
| Gather Report | |||
| eBooks |


{% set PROTOTYPEURL = "examples" %} {% set contentTitle = "Example email" %} {% set title = contentTitle + " - " + serviceName %} {% block pageScripts %} {% endblock %} {% extends 'layouts/layout-email.html' %} {% block pageTitle %} {{ title }} {% endblock %} {% block beforeContent %} {% endblock %} {% block content %}
This is an example email. It's not really the code for email.
This is a template mocked up to act like the ideal presentation of an email.
You do not have to do anything.
You are receiving this email because you've clicked a link to see it
NHS Digital
1 Trevelyan Square, Boar Lane
Leeds, West Yorkshire
0300 303 5678


---
layout: post
title: Red House Painters - Have You Forgotten
date: '2011-08-02T14:14:00.001+02:00'
comments: true
tags:
- Music
modified_time: '2011-10-14T13:29:45.117+02:00'
thumbnail: https://img.youtube.com/vi/91j8k1MApLU/default.jpg
blogger_id: tag:blogger.com,1999:blog-5442825777886761537.post-203360752818212297
blogger_orig_url: http://stickmanscorral.blogspot.com/2011/08/red-house-painters-have-you-forgotten.html
---
Talking about the Vanilla Sky soundtrack, here's a great example of a "nearly perfect" song. I'm not sure where the problem lies exactly, but it's just missing that extra something that would make it one for the ages. (My instincts tell me it's the chorus and some sloppy lyrics in the middle...) Still, well worth a listen:
NOTE: Yes, I realise that these clips are not from Vanilla Sky. They're from À la folie... pas du tout (He loves me... he loves me not). However, it was about the only video that I could find on YouTube that had the correct version of the song, which didn't involve tortured little emo sayings flashing across the screen.


A link that opens in a new window with some more inline text.
An insecure link opening in a new window with some more inline text.
An insecure link with some more inline text.
Enter your security info with some more inline text.
A link that opens in a new window with some more inline text.
An insecure link opening in a new window with some more inline text.
An insecure link with some more inline text.
Enter your security info with some more inline text.
A link that opens in a new window with some more inline text.
An insecure link opening in a new window with some more inline text.
An insecure link with some more inline text.
Enter your security info with some more inline text.
A link that opens in a new window with some more inline text.
An insecure link opening in a new window with some more inline text.
An insecure link with some more inline text.
Enter your security info with some more inline text.
A link that opens in a new window with some more inline text.
An insecure link opening in a new window with some more inline text.
An insecure link with some more inline text.


Dashboard
Applications
Beneficiaries
Receipts
Fund Requests
Terminations
Transfer
Profile Settings
Personal Details
Household Member Information
Contact details


The application wants to access your account
The following permissions are requested by the above app.
Please review
these and consent if you approve.
Your consent to provide access is required.
If you do not approve, click Cancel, in which case no information will be shared with the app.


{% extends '_base.html' %} {% block title %}Payments{% endblock title %} {% block content %}
| Title | Account Affected | Amount +/- | Currency | Type | Property | Details |
|---|---|---|---|---|---|---|
| Today | ||||||
| Title of Payment | Title of Account | Amount Paid | EUR | Cash | Property Title | |
| Nike Lab | Account number 4154 81** **** 7617 | 9.32% | $232 | Closed |
|
|
| Yesterday | ||||||
| Pepsi Drink | Account number 4154 81** **** 7617 | -3.32% | $564 | Active |
|
|
| Headphones Beats | Account number 4154 81** **** 7617 | 4.65% | $232 | Closed |
|
|
| Headphones Beats | Account number 4154 81** **** 7617 | -4.32% | $564 | Active |
|
|
| Headphones Beats | Account number 4154 81** **** 7617 | -4.99% | $894 | Closed |
|


Bonded by a common viewpoint on what makes for delicious food, Johno Morisano and Chef Mashama Bailey partnered to build The Grey in Historic Downtown Savannah. Occupying a 1938 art deco Greyhound Bus Terminal that they painstakingly restored to its original luster, The Grey offers a food, wine and service experience that is simultaneously familiar and elevated. Bringing her personal take on Port City Southern food to a city of her youth allows Mashama to tap into all of her experiences to create dishes that are deep, layered, and soulful in their flavors. With a penchant for regional produce, seafood and meats, guests will find a melting pot of surprising and comforting tastes in all of Mashama’s cooking with something new revealed in each and every visit. A focus on European wines, Atlantic Trade liquors, and warm, old-world hospitality are the additional elements necessary to provide a complete experience for guests. The Grey continues the building’s long tradition of transporting people to a destination, but that destination is now one of elevated hospitality and intrinsic satisfaction.


Enterprise ID
{{people.EnterpriseId}}
Name
{{people.Name}}
Mobile
{{people.Mobile}}
Email
{{people.Email}}
Career Level
{{people.CareerLevel }}
Employment Type
{{people.EmploymentType }}
DU Name
{{people.DUName }}
Project
{{people.Project }}
Supervisor
{{people.Supervisor }}
Is Active
{{people.IsActive }}
AccentureDOJ
{{people.AccentureDOJ }}
ProjectDOJ
{{people.ProjectDOJ }}
DU Lead Name


As a proud affiliate of ITNAmerica, ITN{{affiliate}} provides dignified transportation for seniors, and adults with vision challenges.
ITN{{affiliate}} provides over 2,000 rides a year in Hall County, Georgia. Our newest fundraising campaign, Help On Wheels, aims to cover the cost of these rides, and will allow ITN to continue to grow and serve the community.
With a $25 per month recurring donation, you can sponsor one ride per month to a Hall County rider living on limited income.
Our goal is to collect 100 recurring donations of $25 per month each.
Please donate today to help a Hall County senior rider.


public abstract class DataRecordRollup extends AbstractDataTransform implements RecordRollup
| Modifier and Type | Field and Description |
|---|---|
protected DataRecordMetadata |
accumulatorMetadata
a metadata of group accumulator or
null if no group accumulator is used |
protected DataRecordMetadata |
inputMetadata
a metadata of input data records
|
protected DataRecordMetadata[] |
outputMetadata
a metadata of output data records
|
protected java.util.Properties |
parameters
parameters used during the initialization of this rollup transform
|
errorMessage, graph
ALL, SKIP
| Constructor and Description |
|---|
DataRecordRollup() |
| Modifier and Type | Method and Description |
|---|---|
boolean |
finishGroupOnError(java.lang.Exception exception,
DataRecord inputRecord,
DataRecord groupAccumulator)
This method is called for the last data record in a group in order to finish the group processing.
|
protected void |
init()
Override this method to provide user-desired initialization of this rollup transform.
|
void |
init(java.util.Properties parameters,
DataRecordMetadata inputMetadata,
DataRecordMetadata accumulatorMetadata,
DataRecordMetadata[] outputMetadata)
Initializes the rollup transform.
|
void |
initGroupOnError(java.lang.Exception exception,
DataRecord inputRecord,
DataRecord groupAccumulator)
This method is called for the first data record in a group.
|
int |
transformOnError(java.lang.Exception exception,
int counter,
DataRecord inputRecord,
DataRecord groupAccumulator,
DataRecord[] outputRecords)
This method is used to generate output data records based on the input data record and the contents of the group
"accumulator" (if it was requested).
|
boolean |
updateGroupOnError(java.lang.Exception exception,
DataRecord inputRecord,
DataRecord groupAccumulator)
This method is called for each data record (including the first one as well as the last one) in a group
in order to update the group "accumulator".
|
int |
updateTransformOnError(java.lang.Exception exception,
int counter,
DataRecord inputRecord,
DataRecord groupAccumulator,
DataRecord[] outputRecords)
This method is used to generate output data records based on the input data record and the contents of the group
"accumulator" (if it was requested).
|
finished, getGraph, getMessage, getNode, postExecute, preExecute, reset, setNode
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
finishGroup, initGroup, transform, updateGroup, updateTransform
finished, getGraph, getMessage, getNode, postExecute, preExecute, reset, setNode
protected java.util.Properties parameters
protected DataRecordMetadata inputMetadata
protected DataRecordMetadata accumulatorMetadata
null
if no group accumulator is usedprotected DataRecordMetadata[] outputMetadata
public final void init(java.util.Properties parameters, DataRecordMetadata inputMetadata, DataRecordMetadata accumulatorMetadata, DataRecordMetadata[] outputMetadata) throws ComponentNotReadyException
RecordRollup
init
in interface RecordRollup
parameters
- custom component attributes defined for the component which calls this transformationinputMetadata
- metadata of input data recordsaccumulatorMetadata
- metadata of a group "accumulator" used to store intermediate results
or null
if no metadata were specifiedoutputMetadata
- array of metadata of output data recordsComponentNotReadyException
- if an error occurred during the initializationprotected void init() throws ComponentNotReadyException
init(Properties, DataRecordMetadata, DataRecordMetadata, DataRecordMetadata[])
method.ComponentNotReadyException
- if the initialization fails for any reasonpublic void initGroupOnError(java.lang.Exception exception, DataRecord inputRecord, DataRecord groupAccumulator) throws TransformException
RecordRollup
RecordRollup.initGroup(DataRecord, DataRecord)
throws an exception.initGroupOnError
in interface RecordRollup
exception
- an exception that caused RecordRollup.initGroup(DataRecord, DataRecord)
to failinputRecord
- the first input data record in the groupgroupAccumulator
- the data record used as an "accumulator" for the group or null
if none
was requestedTransformException
- if any error occurred during initialization of the grouppublic boolean updateGroupOnError(java.lang.Exception exception, DataRecord inputRecord, DataRecord groupAccumulator) throws TransformException
RecordRollup
RecordRollup.updateGroup(DataRecord, DataRecord)
throws an exception.updateGroupOnError
in interface RecordRollup
exception
- an exception that caused RecordRollup.updateGroup(DataRecord, DataRecord)
to failinputRecord
- the current input data recordgroupAccumulator
- the data record used as an "accumulator" for the group or null
if none
was requestedtrue
if the RecordRollup.updateTransform(int, DataRecord, DataRecord, DataRecord[])
method
should be called to generate output data record(s) and send them to the output, false
otherwiseTransformException
- if any error occurred during update of the grouppublic boolean finishGroupOnError(java.lang.Exception exception, DataRecord inputRecord, DataRecord groupAccumulator) throws TransformException
RecordRollup
RecordRollup.finishGroup(DataRecord, DataRecord)
throws an exception.finishGroupOnError
in interface RecordRollup
exception
- an exception that caused RecordRollup.finishGroup(DataRecord, DataRecord)
to failinputRecord
- any input data record from the current groupgroupAccumulator
- the data record used as an "accumulator" for the group or null
if none
was requestedtrue
if the RecordRollup.transform(int, DataRecord, DataRecord, DataRecord[])
method should
be called to generate output data record(s) and send them to the output, false
otherwiseTransformException
- if any error occurred during final processing of the grouppublic int updateTransformOnError(java.lang.Exception exception, int counter, DataRecord inputRecord, DataRecord groupAccumulator, DataRecord[] outputRecords) throws TransformException
RecordRollup
RecordRollup.updateGroup(DataRecord, DataRecord)
method returns true. Called only
if RecordRollup.updateTransform(int, DataRecord, DataRecord, DataRecord[])
throws an exception.updateTransformOnError
in interface RecordRollup
exception
- an exception that caused RecordRollup.updateTransform(int, DataRecord, DataRecord, DataRecord[])
to failcounter
- the number of previous calls to this method for the current group updateinputRecord
- the current input data recordgroupAccumulator
- the data record used as an "accumulator" for the group or null
if none
was requestedoutputRecords
- output data records to be filled with dataTransformException
- if any error occurred during the transformationpublic int transformOnError(java.lang.Exception exception, int counter, DataRecord inputRecord, DataRecord groupAccumulator, DataRecord[] outputRecords) throws TransformException
RecordRollup
RecordRollup.finishGroup(DataRecord, DataRecord)
method returns true. Called only
if RecordRollup.transform(int, DataRecord, DataRecord, DataRecord[])
throws an exception.transformOnError
in interface RecordRollup
exception
- an exception that caused RecordRollup.transform(int, DataRecord, DataRecord, DataRecord[])
to failcounter
- the number of previous calls to this method for the current groupinputRecord
- any input data record from the current groupgroupAccumulator
- the data record used as an "accumulator" for the group or null
if none
was requestedoutputRecords
- output data records to be filled with dataTransformException
- if any error occurred during the transformationCopyright © 2002-2015 Javlin a.s.


Search
How to make great application with nuxtjs
NuxtJS VueJS JavaScript
100k 70
Why use JWT for Web SPA ?
SPA JWT FrontEnd
30k 12
100k 10
How to make a file in PHP using fopen ?
PHP BackEnd Help
2k 20


{# ``base.html`` is the template all our other templates derive from. While
Flask-Bootstrap ships with its own base, it is good form to create a custom
one for our app, as it allows customizing some aspects.
Deriving from bootstap/base.html gives us a basic page scaffoling.
You can find additional information about template inheritance at
http://jinja.pocoo.org/docs/templates/#template-inheritance
#}
{%- extends "bootstrap/base.html" %}
{# We also set a default title, usually because we might forget to set one.
In our sample app, we will most likely just opt not to change it #}
{% block title %}Sample App for Flask-Bootstrap{% endblock %}
{# While we are at it, we also enable fixes for legacy browsers. First we
import the necessary macros: #}
{% import "bootstrap/fixes.html" as fixes %}
{# Then, inside the head block, we apply these. To not replace the header,
``super()`` is used: #}
{% block head %}
{{super()}}
{#- Docs: http://pythonhosted.org/Flask-Bootstrap/macros.html#fixes
The sample application already contains the required static files. #}
{{fixes.ie8()}}
{%- endblock %}
{# Adding our own CSS files is also done here. Check the documentation at
http://pythonhosted.org/Flask-Bootstrap/basic-usage.html#available-blocks
for an overview. #}
{% block styles -%}
{{super()}} {# do not forget to call super or Bootstrap's own stylesheets
will disappear! #}
{% endblock %}
{# Finally, round things out with navigation #}
{% block navbar %}
{{nav.frontend_top.render()}}
{% endblock %}


"Building Chubby was an engineering effort required
to fill the needs mentioned above; it was not research.
We claim no new algorithms or techniques. "
We describe our experiences with the Chubby lock service, which is intended to provide coarse-grained locking as well as reliable (though low-volume) storage for
a loosely-coupled distributed system.
"Building Chubby was an engineering effort required
to fill the needs mentioned above; it was not research.
We claim no new algorithms or techniques. "
What's lock service? Why I need it?
"The purpose of the lock service is to allow its clients
to synchronize their activities and to agree on basic information about their environment."
"... to elect a master, to allow the
master to discover the servers it controls, and to permit
clients to find the master"
Why not just use Paxos?
Hard to retrofit to existing apps
You still need name service (e.g. to announce leader)
Lock-based interface is familiar to developers
Consensus is impractical with large clusters
Features:
Scalable advertising.
Event notifications.
Quick and consistent reads.
To avoid both financial loss and jail time, we provide
security mechanisms, including access control.
File and Directories
/ls/foo/wombat/pouch
ls - locks service prefix
foo - name of Chubby cell (resolved via DNS)
wombat/pouch - resolved within cell
Node
Permanent
Ephemeral
Locks
Distributed locks are difficult
a process holding a lock L may issue a request R, but then fail. Another process may acquire L and perform some action before R arrives at its
destination. If R later arrives, it may be acted on without
the protection of L, and potentially on inconsistent data
Sequencers
API
handle = chubby.Open("/ls/foo/wombat/pouch")
handle.Acquire() // or TryAcquire()
sequencer = handle.GetSequencer()
// call some external service using Sequencer.
// when fail or done
handle.Release()
Caching
Consistent
File, no file, meta-data, handles
Invalidation instead of Updates
Write invalidates caches
Sessions and Keep Alive
Lease based
Minimal communication (blocking RPC)
Cache invalidation
Scale
90,000 direct clients (!?!?!?!)
One Chubby cell per data center
Use and behaviour
Typical stats:
22k direct clients
1k locks
RPC rate 1-2k/s (93% Keep Alives)
Outages
61 outages over few weeks
52 less that 30s
4 network maintenance
2 suspected network problems
2 software errors
1 overload
Lost data 6 times
4 software errors
2 operator error
Abusive clients
Despite attempts at education, our developers regularly write loops that retry
indefinitely when a file is not present, or poll a file by
opening it and closing it repeatedly...
... In the end it was easier to make
repeated Open() calls cheap


| Duration | Last Successful Run at | Last Outcome | Last Message | Next Run in | ||
|---|---|---|---|---|---|---|
|
|
| ID | Signal Provider | Instrument | Side | P/L | Start Date | End Date | Duration | Entry Price | Stop Loss | Take Profit | Trade | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Link | None |
None.
| Instrument | Side | Signal Providers | Total Rank |
|---|---|---|---|
© 2017 Signal Aggregator


@import tags._ @import tools.Constants @(account: Account) @scripts = { } @main(scripts, "线上教学平台——Ekoo教育") { @topbar(account)
Whether you are new to tutoring or an established professional tutor, we will help you find new students.
@if(account != null){ @if(!account.user.role.equals(Role.TEACHER)){ SIGN UP }else{ SIGN UP } }else{ @messages.at("topbar.tutor") }At EkooEdu, you can find students really easily, organise your lessons
and get paid straight into your account.


Artist Profile
Band Profile
Logout
Band profile
Band name
Genre
Search by Band Genre
Alternative
Blues
Bluegrass
Classical
Country
Disco
Dub/Reggae
EDM/House/Techno
Electroclash
Electronic
Folk
Funk
Goth/Industrial
Hardcore/Metal
Hip-Hop/Rap
Indie Rock
Jazz
Latin
Motown
New Age
Opera
Pop
Progressive
Punk
R&B/Soul
Rock
Rockabilly
Ska
Tex-Mex/Tejano
Trance
Trip-Hop
World Music
Tell us more about your project
This is where the user can enter the description.


Let's start with the vaguest picture, and zoom in a bit each section (the final level of depth will be dealt with in another article).
According to Rules 101, a turn is like this:
Let's look at section 2. What does it mean?
Say we have the following:
[ > Crate | Crate ] -> [ > Crate | > Crate ]
[ > Player | Crate ] -> [ > Player | > Crate ]
The player won't be able to push several crates in a row with this, because the first rule gets applied first, and then the second rule. So order does matter - these aren't abstract replacement rules floating around in a vacuum.
Each rule gets applied in turn as often as it can be before the interpreter moves on to the next one. It sounds quite simple, doesn't it, but there's one point of ambiguity. The compiler compiles each rule you write down into several smaller rules (You can see the output by using the debug switch in the Prelude).
For instance
[ > Player | Crate ] -> [ > Player | > Crate ]
is compiled into these four instructions:
Rule Assembly : (4 rules ) =========== (52) UP [ up player | crate ] -> [ up player | up crate ] (52) DOWN [ down player | crate ] -> [ down player | down crate ] (52) LEFT [ left player | crate ] -> [ left player | left crate ] (52) RIGHT [ right player | crate ] -> [ right player | right crate ] ===========
So the question is: When I say that each rule is executed in turn to exhaustion, do I mean the few rules you write, or the many rules the interpreter ends up with?
The answer is "the former". The compiler generates lots of rules, but packs them together into rule groups. The interpreter then, instead of applying one rule as much as it can before moving to the next, loops through each rule group as often as it can, before moving to the next.
You might wonder if you can construct rule groups yourself. The answer is yes, with use of the modest + symbol..
[ > Player | Crate ] -> [ > Player | > Crate ]
+[< Player | Crate ] -> [ < Player | < Crate ]
That assigns both rules (or rather, the rules that are generated from them) to the same rule group.
This technique is used in the rigid bodies section (warning: it's a bit of an arcane subject).


* Quarterly
today’s Very Short List:
tech 23 Sep 2013
Mike Del Ponte is the co-founder of the Hidden Door Supper Club, an underground dinner series in San Francisco. TWITTER
Subscribe
* The Monocle design video podcast
* Soma
http://link.nyobserver.com/516ca68465217dc6e1b9a3a615iy0.ch0/UhtVe-YQwYEjDDm8Dfe36 very short list is a
delightful e-mail that shares
cultural gems from a
different curator every day.
If you have any problems reading this e-mail, click here
http://link.nyobserver.com/516ca68465217dc6e1b9a3a615iy0.ch0/UhtVe-YQwYEjDDm8E2249
Subscribe
Forward
My Account
Unsubscribe
style 20 Sep 2013
culture 17 Sep 2013
Michael Jackson on spy culture
tech 16 Sep 2013
Craig Shapiro with the best from the past.
Editorial Policy
Privacy Policy
Contact Us
Press
Terms + Conditions
very fine print: ©2013
Observer VSL LLC.
321 West 44th Street, 6th Floor
New York, NY 10036 USA
All rights reserved.
Questions?<PHONE_NUMBER>.
This message was intended for<EMAIL_ADDRESS>If you believe this has been sent to you in error, please safely unsubscribe


Rindow Framework is a PHP Application Framework that provides a modern programming and configuration model to all PHP programmers. Please read the README.md on the github.
It is "Form" and "Database" demo with annotated entities. This demo is including how to use annotation driven "Dependency Injection" and "Form Builder" and "Declarative Transaction".


Azure AD: Groups memberships in SAML 2.0 assertions to SAP Analytics Cloud
Someoe asked how to add group membership to the SAML 2.0 assertion from Azure AD to an application such as SAP Analytics Cloud. This would allow seemless single sign-on to SAP Analytics Cloud (SAC). This post documents the steps to sending group membership in the SAML 2.0 tokens from Azure AD to SAP Analytics Cloud (SAC).
Background:
You can pass group membership either as Application Roles or Security Group from Azure AD. Either gets translated into permissions during SAC’s authorization. See here to learn the Pros and Cons of Application Roles and Security Groups.
I chose to send group membership as Application Roles because I need to filter groups. In this case, Groups were sourced from an on-prem AD. Security Groups cannot yet be filtered. Security Groups are restricted. Instead it is much simpler and cleaner to use App Roles. Each user is already assigned to one or more Security Groups (sourced from on-prem). Each Security Group gets assigned to an App Role (in setp 4 below). When a user logs in to SAC, Azure AD will emit all the App Roles that the user is indirectly assigned to via Security Groups. Neat! This capability requires Azure AD Premium. You can learn about this capability here
Note: If groups are to be synched from an on-prem AD, AD Connect should be version 1.1.649.0 & above.
I do not have access to SAC. I’m going to use a WS-Federation client application to mimick the SAC client interaction with Azure AD. See optional step 6 for how to setup and configure SAC client application.
Here are the steps:
- Create the application in Azure AD
- Configure the SAP Analytics Cloud Application in Azure AD
- Create Roles for the Application in Azure AD
- Assign Security Groups & App Roles to the Application
- Customize the claims issued in the SAML tokens
- Optional: Configure a sample client for testing
- Test and verify
1. Create the application in Azure AD
The application object in Azure AD is a representation of SAP Analytics Cloud. This object is going to control authentication and issue SAML tokens. Azure AD provides a few options to register the application:
- Register via Portal > Enterprise Apps > Non-Gallery Application
- Register via Portal > Enterprise Apps > Gallery Application
- Register via Portal > App Registrations
I choose the first option - Non-Gallery App because its easier to learn when you can completely customize the SAML token when compared to SAP’s Gallery Application. Also, you can use the portal to customize the SAML tokens for (Non-Gallery) Enterprise Apps compared to App Registration Apps.
Here is how to register the SAP Analytics Cloud in Azure AD:
Go to: Portal > Azure Active Directory > Enterprise Applications > New application
Select Non-Gallery Application from the top right
Give it a name (say SAP Analytics Cloud) and click Add
Now you have created a Service Principal and an Application Object. The Service Principal is accessible through: Portal > Enterprise Application. The Application Object is accessible through: Portal > App Regisration. Be sure to not use the Application Object created under Portal > App Registration(Preview) because SAML 2.0 and WS-Federation protocols are not yet supported under the V2.0 endpoint (will be available soon). See here to learn more.
2. Configure the SAP Analytics Cloud Application in Azure AD
Now that you have an application object to represent SAP Analytics Cloud in Azure AD, lets configure it:
- Set the Logout URL
- Assign users to the application
- Provide the Application permissions to the Azure AD
2.1 Set the logout URL
Set the client application’s logout URL at: Portal > App Registration > Settings > Logout URL
You would set it to your SAC instance’s logout URL. This demo, sets it to https://localhost:44320 in support of optional step 6
2.2 Assign users to the application
An administrator can control which users or groups have access to the aplication. For this demo, I set User Assignment Required to No.
Go to: Portal > Enterprise Applications > Properties >User Assignment required set to No.
2.3 Provide the Application permissions to the Azure AD
Azure AD supports two kinds of permissions:
- Delegated permissions: Used by apps that have a signed-in user present
- Application permissions: Used by apps that run without a signed-in user present
We will configure an administrator consented delegate permision to the SAC app.
Go to: Portal > App Registration > Settings > Required permissions.
Click Add.
Select “Windows Azure Active Directory”
Provide Delegated Permission to the App for “Sign in and read user profile”
3. Create Roles for the Application in Azure AD
In this step, we define the application roles in Azure AD for the SAC application.
Azure AD provides two ways to create roles:
Chose the manifest approach because its easier to explain on the portal.
Lets create a sample SurveryCreator and SurveyAdministrator roles for this application:
"appRoles": [
{
"allowedMemberTypes": [
"User",
"Application"
],
"description": "Dummy App Role1",
"displayName": "AppRole1",
"id": "1b4f816e-5eaf-48b9-8613-7923830595ad",
"isEnabled": true,
"value": "AppRole1"
},
{
"allowedMemberTypes": [
"User",
"Application"
],
"description": "Dummy App RoleN",
"displayName": "AppRoleN",
"id": "c20e145e-5459-4a6c-a074-b942bbd4cfe1",
"isEnabled": true,
"value": "AppRoleN"
}
]
Notice that the “allowedMemberTypes” targets Applications and Users.
To define the role, go to: Portal > App Registrations
Select All Apps from the drop down and pick the app you registered earlier
Click Manifest and update the manifest with the App roles you want to create:
Also read the documentation on how to create App Roles
4. Assign Security Groups & App Roles to the Application
This is where we assign on-prem sourced Security Groups to the App Roles created for the Application. It allows us to filter and send only required Security Group names as App roles to SAC.
In this demo, I have two pre-exisitng Security Groups: SecurityGroup1 and SecurityGroup2 that are sourced from on-prem.We are going to assign these SecurityGroups to the Application and give them an App Role.
Go to: Portal > Enterprise Application Select the application Object Under Users and Groups, assign security groups to application roles Set the Roles for those assignments to be App Roles. Note, there is a 1:1 mapping between Security Groups and Application Roles
5. Customize the claim name issued in the SAML tokens
SAP Analytic Cloud client looks for the name at the end of the url formatted claim name, not the whole url – so set the claim name to to a friendly name. This example sets it to Name=“MyAppRoles”.
This changes the claim name in the SAML assertion from:
<Attribute Name="http://schemas.microsoft.com/ws/2008/06/identity/claims/role">
<AttributeValue>AppRole1</AttributeValue>
<AttributeValue>AppRoleN</AttributeValue>
</Attribute>
to:
<Attribute Name="MyAppRoles">
<AttributeValue>AppRole1</AttributeValue>
<AttributeValue>AppRoleN</AttributeValue>
</Attribute>
You can read more about it in the Azure documentation here
6. Optionally Configure a sample client for testing
Steps:
- Get the App ID URI from Azure AD
- Clone the sample repo
- Configure the sample application
6.1 Get the application’s App ID URI
The App ID URI is a uniquely identifier to the application in Azure AD.
Fetch the App ID URI from: Portal > App Registration > Settings > Properties > App ID URI
6.2 Clone the repo
Clone the WS-Federation client application repo.
6.3 Configure web.config
In the application’s web.config, set the following in Web.config:
- ida:Wtrealm key to the App ID URI. The App ID URI is auto created in Setp 1 when you register the application in Azure AD. The App ID URI is a URI that uniquely identifies the application in Azure AD.Find the App ID URI under: Portal > App Registration > Settings > Properties > App ID URI and set it to the ida:Wtrealm key in web.config
- ida:AADInstance key is set to
7. Test and verify!
Use a tool like SAML-tracer browser pluggin to incept and verify that the SAML assertions are getting correctly generated.
If you need to debug, here is some great help


o_O
Basic Binding
Auto updating
ms since 1st Jan 1970:
Binding to text fields
Checkbox
Select
Complex dependencies
Lists
Events and helpers
Capitalize
visible, and css
HELLOO
GOODBYE
classes
Animation
Animate Me!
Slower
Faster
Rate Limiting
Increments upon every mousemove
Increments at most 150ms


Making website is now one of the easiest thingh in the world. You just need to learn HTML, CSS JavaScript and you are good to go


| Top |
| GtkTargetList * | copy-target-list | Read |
| gint | cursor-position | Read |
| gboolean | has-selection | Read |
| GtkTargetList * | paste-target-list | Read |
| GtkTextTagTable * | tag-table | Read / Write / Construct Only |
| gchar * | text | Read / Write |
| void | apply-tag | Run Last |
| void | begin-user-action | Run Last |
| void | changed | Run Last |
| void | delete-range | Run Last |
| void | end-user-action | Run Last |
| void | insert-child-anchor | Run Last |
| void | insert-pixbuf | Run Last |
| void | insert-text | Run Last |
| void | mark-deleted | Run Last |
| void | mark-set | Run Last |
| void | modified-changed | Run Last |
| void | paste-done | Run Last |
| void | remove-tag | Run Last |
You may wish to begin by reading the text widget conceptual overview which gives an overview of all the objects and data types related to the text widget and how they work together.
GtkTextBuffer *
gtk_text_buffer_new (GtkTextTagTable *table
);
Creates a new text buffer.
gint
gtk_text_buffer_get_line_count (GtkTextBuffer *buffer
);
Obtains the number of lines in the buffer. This value is cached, so the function is very fast.
gint
gtk_text_buffer_get_char_count (GtkTextBuffer *buffer
);
Gets the number of characters in the buffer; note that characters and bytes are not the same, you can’t e.g. expect the contents of the buffer in string form to be this many bytes long. The character count is cached, so this function is very fast.
GtkTextTagTable *
gtk_text_buffer_get_tag_table (GtkTextBuffer *buffer
);
Get the GtkTextTagTable associated with this buffer.
void gtk_text_buffer_insert (GtkTextBuffer *buffer
,GtkTextIter *iter
,const gchar *text
,gint len
);
Inserts len
bytes of text
at position iter
. If len
is -1,
text
must be nul-terminated and will be inserted in its
entirety. Emits the “insert-text” signal; insertion actually occurs
in the default handler for the signal. iter
is invalidated when
insertion occurs (because the buffer contents change), but the
default signal handler revalidates it to point to the end of the
inserted text.
void gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer
,const gchar *text
,gint len
);
Simply calls gtk_text_buffer_insert()
, using the current
cursor position as the insertion point.
gboolean gtk_text_buffer_insert_interactive (GtkTextBuffer *buffer
,GtkTextIter *iter
,const gchar *text
,gint len
,gboolean default_editable
);
Like gtk_text_buffer_insert()
, but the insertion will not occur if
iter
is at a non-editable location in the buffer. Usually you
want to prevent insertions at ineditable locations if the insertion
results from a user action (is interactive).
default_editable
indicates the editability of text that doesn't
have a tag affecting editability applied to it. Typically the
result of gtk_text_view_get_editable()
is appropriate here.
gboolean gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer
,const gchar *text
,gint len
,gboolean default_editable
);
Calls gtk_text_buffer_insert_interactive()
at the cursor
position.
default_editable
indicates the editability of text that doesn't
have a tag affecting editability applied to it. Typically the
result of gtk_text_view_get_editable()
is appropriate here.
void gtk_text_buffer_insert_range (GtkTextBuffer *buffer
,GtkTextIter *iter
,const GtkTextIter *start
,const GtkTextIter *end
);
Copies text, tags, and pixbufs between start
and end
(the order
of start
and end
doesn’t matter) and inserts the copy at iter
.
Used instead of simply getting/inserting text because it preserves
images and tags. If start
and end
are in a different buffer from
buffer
, the two buffers must share the same tag table.
Implemented via emissions of the insert_text and apply_tag signals, so expect those.
buffer |
||
iter |
a position in |
|
start |
a position in a GtkTextBuffer |
|
end |
another position in the same buffer as |
gboolean gtk_text_buffer_insert_range_interactive (GtkTextBuffer *buffer
,GtkTextIter *iter
,const GtkTextIter *start
,const GtkTextIter *end
,gboolean default_editable
);
Same as gtk_text_buffer_insert_range()
, but does nothing if the
insertion point isn’t editable. The default_editable
parameter
indicates whether the text is editable at iter
if no tags
enclosing iter
affect editability. Typically the result of
gtk_text_view_get_editable()
is appropriate here.
buffer |
||
iter |
a position in |
|
start |
a position in a GtkTextBuffer |
|
end |
another position in the same buffer as |
|
default_editable |
default editability of the buffer |
void gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer
,GtkTextIter *iter
,const gchar *text
,gint len
,GtkTextTag *first_tag
,...
);
Inserts text
into buffer
at iter
, applying the list of tags to
the newly-inserted text. The last tag specified must be NULL
to
terminate the list. Equivalent to calling gtk_text_buffer_insert()
,
then gtk_text_buffer_apply_tag()
on the inserted text;
gtk_text_buffer_insert_with_tags()
is just a convenience function.
buffer |
||
iter |
an iterator in |
|
text |
UTF-8 text |
|
len |
length of |
|
first_tag |
first tag to apply to |
|
... |
|
void gtk_text_buffer_insert_with_tags_by_name (GtkTextBuffer *buffer
,GtkTextIter *iter
,const gchar *text
,gint len
,const gchar *first_tag_name
,...
);
Same as gtk_text_buffer_insert_with_tags()
, but allows you
to pass in tag names instead of tag objects.
void gtk_text_buffer_insert_markup (GtkTextBuffer *buffer
,GtkTextIter *iter
,const gchar *markup
,gint len
);
Inserts the text in markup
at position iter
. markup
will be inserted
in its entirety and must be nul-terminated and valid UTF-8. Emits the
“insert-text” signal, possibly multiple times; insertion
actually occurs in the default handler for the signal. iter
will point
to the end of the inserted text on return.
buffer |
||
iter |
location to insert the markup |
|
markup |
a nul-terminated UTF-8 string containing Pango markup |
|
len |
length of |
Since: 3.16
void gtk_text_buffer_delete (GtkTextBuffer *buffer
,GtkTextIter *start
,GtkTextIter *end
);
Deletes text between start
and end
. The order of start
and end
is not actually relevant; gtk_text_buffer_delete()
will reorder
them. This function actually emits the “delete-range” signal, and
the default handler of that signal deletes the text. Because the
buffer is modified, all outstanding iterators become invalid after
calling this function; however, the start
and end
will be
re-initialized to point to the location where text was deleted.
gboolean gtk_text_buffer_delete_interactive (GtkTextBuffer *buffer
,GtkTextIter *start_iter
,GtkTextIter *end_iter
,gboolean default_editable
);
Deletes all editable text in the given range.
Calls gtk_text_buffer_delete()
for each editable sub-range of
[start
,end
). start
and end
are revalidated to point to
the location of the last deleted range, or left untouched if
no text was deleted.
gboolean gtk_text_buffer_backspace (GtkTextBuffer *buffer
,GtkTextIter *iter
,gboolean interactive
,gboolean default_editable
);
Performs the appropriate action as if the user hit the delete
key with the cursor at the position specified by iter
. In the
normal case a single character will be deleted, but when
combining accents are involved, more than one character can
be deleted, and when precomposed character and accent combinations
are involved, less than one character will be deleted.
Because the buffer is modified, all outstanding iterators become
invalid after calling this function; however, the iter
will be
re-initialized to point to the location where text was deleted.
buffer |
||
iter |
a position in |
|
interactive |
whether the deletion is caused by user interaction |
|
default_editable |
whether the buffer is editable by default |
Since: 2.6
void gtk_text_buffer_set_text (GtkTextBuffer *buffer
,const gchar *text
,gint len
);
Deletes current contents of buffer
, and inserts text
instead. If
len
is -1, text
must be nul-terminated. text
must be valid UTF-8.
gchar * gtk_text_buffer_get_text (GtkTextBuffer *buffer
,const GtkTextIter *start
,const GtkTextIter *end
,gboolean include_hidden_chars
);
Returns the text in the range [start
,end
). Excludes undisplayed
text (text marked with tags that set the invisibility attribute) if
include_hidden_chars
is FALSE
. Does not include characters
representing embedded images, so byte and character indexes into
the returned string do not correspond to byte
and character indexes into the buffer. Contrast with
gtk_text_buffer_get_slice()
.
gchar * gtk_text_buffer_get_slice (GtkTextBuffer *buffer
,const GtkTextIter *start
,const GtkTextIter *end
,gboolean include_hidden_chars
);
Returns the text in the range [start
,end
). Excludes undisplayed
text (text marked with tags that set the invisibility attribute) if
include_hidden_chars
is FALSE
. The returned string includes a
0xFFFC character whenever the buffer contains
embedded images, so byte and character indexes into
the returned string do correspond to byte
and character indexes into the buffer. Contrast with
gtk_text_buffer_get_text()
. Note that 0xFFFC can occur in normal
text as well, so it is not a reliable indicator that a pixbuf or
widget is in the buffer.
void gtk_text_buffer_insert_pixbuf (GtkTextBuffer *buffer
,GtkTextIter *iter
,GdkPixbuf *pixbuf
);
Inserts an image into the text buffer at iter
. The image will be
counted as one character in character counts, and when obtaining
the buffer contents as a string, will be represented by the Unicode
“object replacement character” 0xFFFC. Note that the “slice”
variants for obtaining portions of the buffer as a string include
this character for pixbufs, but the “text” variants do
not. e.g. see gtk_text_buffer_get_slice()
and
gtk_text_buffer_get_text()
.
void gtk_text_buffer_insert_child_anchor (GtkTextBuffer *buffer
,GtkTextIter *iter
,GtkTextChildAnchor *anchor
);
Inserts a child widget anchor into the text buffer at iter
. The
anchor will be counted as one character in character counts, and
when obtaining the buffer contents as a string, will be represented
by the Unicode “object replacement character” 0xFFFC. Note that the
“slice” variants for obtaining portions of the buffer as a string
include this character for child anchors, but the “text” variants do
not. E.g. see gtk_text_buffer_get_slice()
and
gtk_text_buffer_get_text()
. Consider
gtk_text_buffer_create_child_anchor()
as a more convenient
alternative to this function. The buffer will add a reference to
the anchor, so you can unref it after insertion.
GtkTextChildAnchor * gtk_text_buffer_create_child_anchor (GtkTextBuffer *buffer
,GtkTextIter *iter
);
This is a convenience function which simply creates a child anchor
with gtk_text_child_anchor_new()
and inserts it into the buffer
with gtk_text_buffer_insert_child_anchor()
. The new anchor is
owned by the buffer; no reference count is returned to
the caller of gtk_text_buffer_create_child_anchor()
.
GtkTextMark * gtk_text_buffer_create_mark (GtkTextBuffer *buffer
,const gchar *mark_name
,const GtkTextIter *where
,gboolean left_gravity
);
Creates a mark at position where
. If mark_name
is NULL
, the mark
is anonymous; otherwise, the mark can be retrieved by name using
gtk_text_buffer_get_mark()
. If a mark has left gravity, and text is
inserted at the mark’s current location, the mark will be moved to
the left of the newly-inserted text. If the mark has right gravity
(left_gravity
= FALSE
), the mark will end up on the right of
newly-inserted text. The standard left-to-right cursor is a mark
with right gravity (when you type, the cursor stays on the right
side of the text you’re typing).
The caller of this function does not own a reference to the returned GtkTextMark, so you can ignore the return value if you like. Marks are owned by the buffer and go away when the buffer does.
Emits the “mark-set” signal as notification of the mark's initial placement.
buffer |
||
mark_name |
name for mark, or |
[allow-none] |
where |
location to place mark |
|
left_gravity |
whether the mark has left gravity |
void gtk_text_buffer_move_mark (GtkTextBuffer *buffer
,GtkTextMark *mark
,const GtkTextIter *where
);
Moves mark
to the new location where
. Emits the “mark-set”
signal as notification of the move.
void gtk_text_buffer_move_mark_by_name (GtkTextBuffer *buffer
,const gchar *name
,const GtkTextIter *where
);
Moves the mark named name
(which must exist) to location where
.
See gtk_text_buffer_move_mark()
for details.
void gtk_text_buffer_add_mark (GtkTextBuffer *buffer
,GtkTextMark *mark
,const GtkTextIter *where
);
Adds the mark at position where
. The mark must not be added to
another buffer, and if its name is not NULL
then there must not
be another mark in the buffer with the same name.
Emits the “mark-set” signal as notification of the mark's initial placement.
Since: 2.12
void gtk_text_buffer_delete_mark (GtkTextBuffer *buffer
,GtkTextMark *mark
);
Deletes mark
, so that it’s no longer located anywhere in the
buffer. Removes the reference the buffer holds to the mark, so if
you haven’t called g_object_ref()
on the mark, it will be freed. Even
if the mark isn’t freed, most operations on mark
become
invalid, until it gets added to a buffer again with
gtk_text_buffer_add_mark()
. Use gtk_text_mark_get_deleted()
to
find out if a mark has been removed from its buffer.
The “mark-deleted” signal will be emitted as notification after
the mark is deleted.
void gtk_text_buffer_delete_mark_by_name (GtkTextBuffer *buffer
,const gchar *name
);
Deletes the mark named name
; the mark must exist. See
gtk_text_buffer_delete_mark()
for details.
GtkTextMark * gtk_text_buffer_get_mark (GtkTextBuffer *buffer
,const gchar *name
);
Returns the mark named name
in buffer buffer
, or NULL
if no such
mark exists in the buffer.
GtkTextMark *
gtk_text_buffer_get_insert (GtkTextBuffer *buffer
);
Returns the mark that represents the cursor (insertion point).
Equivalent to calling gtk_text_buffer_get_mark()
to get the mark
named “insert”, but very slightly more efficient, and involves less
typing.
GtkTextMark *
gtk_text_buffer_get_selection_bound (GtkTextBuffer *buffer
);
Returns the mark that represents the selection bound. Equivalent
to calling gtk_text_buffer_get_mark()
to get the mark named
“selection_bound”, but very slightly more efficient, and involves
less typing.
The currently-selected text in buffer
is the region between the
“selection_bound” and “insert” marks. If “selection_bound” and
“insert” are in the same place, then there is no current selection.
gtk_text_buffer_get_selection_bounds()
is another convenient function
for handling the selection, if you just want to know whether there’s a
selection and what its bounds are.
gboolean
gtk_text_buffer_get_has_selection (GtkTextBuffer *buffer
);
Indicates whether the buffer has some text currently selected.
Since: 2.10
void gtk_text_buffer_place_cursor (GtkTextBuffer *buffer
,const GtkTextIter *where
);
This function moves the “insert” and “selection_bound” marks
simultaneously. If you move them to the same place in two steps
with gtk_text_buffer_move_mark()
, you will temporarily select a
region in between their old and new locations, which can be pretty
inefficient since the temporarily-selected region will force stuff
to be recalculated. This function moves them as a unit, which can
be optimized.
void gtk_text_buffer_select_range (GtkTextBuffer *buffer
,const GtkTextIter *ins
,const GtkTextIter *bound
);
This function moves the “insert” and “selection_bound” marks
simultaneously. If you move them in two steps
with gtk_text_buffer_move_mark()
, you will temporarily select a
region in between their old and new locations, which can be pretty
inefficient since the temporarily-selected region will force stuff
to be recalculated. This function moves them as a unit, which can
be optimized.
Since: 2.4
void gtk_text_buffer_apply_tag (GtkTextBuffer *buffer
,GtkTextTag *tag
,const GtkTextIter *start
,const GtkTextIter *end
);
Emits the “apply-tag” signal on buffer
. The default
handler for the signal applies tag
to the given range.
start
and end
do not have to be in order.
void gtk_text_buffer_remove_tag (GtkTextBuffer *buffer
,GtkTextTag *tag
,const GtkTextIter *start
,const GtkTextIter *end
);
Emits the “remove-tag” signal. The default handler for the signal
removes all occurrences of tag
from the given range. start
and
end
don’t have to be in order.
void gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer
,const gchar *name
,const GtkTextIter *start
,const GtkTextIter *end
);
Calls gtk_text_tag_table_lookup()
on the buffer’s tag table to
get a GtkTextTag, then calls gtk_text_buffer_apply_tag()
.
buffer |
||
name |
name of a named GtkTextTag |
|
start |
one bound of range to be tagged |
|
end |
other bound of range to be tagged |
void gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer
,const gchar *name
,const GtkTextIter *start
,const GtkTextIter *end
);
Calls gtk_text_tag_table_lookup()
on the buffer’s tag table to
get a GtkTextTag, then calls gtk_text_buffer_remove_tag()
.
buffer |
||
name |
name of a GtkTextTag |
|
start |
one bound of range to be untagged |
|
end |
other bound of range to be untagged |
void gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer
,const GtkTextIter *start
,const GtkTextIter *end
);
Removes all tags in the range between start
and end
. Be careful
with this function; it could remove tags added in code unrelated to
the code you’re currently writing. That is, using this function is
probably a bad idea if you have two or more unrelated code sections
that add tags.
GtkTextTag * gtk_text_buffer_create_tag (GtkTextBuffer *buffer
,const gchar *tag_name
,const gchar *first_property_name
,...
);
Creates a tag and adds it to the tag table for buffer
.
Equivalent to calling gtk_text_tag_new()
and then adding the
tag to the buffer’s tag table. The returned tag is owned by
the buffer’s tag table, so the ref count will be equal to one.
If tag_name
is NULL
, the tag is anonymous.
If tag_name
is non-NULL
, a tag called tag_name
must not already
exist in the tag table for this buffer.
The first_property_name
argument and subsequent arguments are a list
of properties to set on the tag, as with g_object_set()
.
void gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer
,GtkTextIter *iter
,gint line_number
,gint char_offset
);
Obtains an iterator pointing to char_offset
within the given line. Note
characters, not bytes; UTF-8 may encode one character as multiple bytes.
Before the 3.20 version, it was not allowed to pass an invalid location.
Since the 3.20 version, if line_number
is greater than the number of lines
in the buffer
, the end iterator is returned. And if char_offset
is off the
end of the line, the iterator at the end of the line is returned.
void gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer
,GtkTextIter *iter
,gint char_offset
);
Initializes iter
to a position char_offset
chars from the start
of the entire buffer. If char_offset
is -1 or greater than the number
of characters in the buffer, iter
is initialized to the end iterator,
the iterator one past the last valid character in the buffer.
void gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer
,GtkTextIter *iter
,gint line_number
);
Initializes iter
to the start of the given line. If line_number
is greater
than the number of lines in the buffer
, the end iterator is returned.
void gtk_text_buffer_get_iter_at_line_index (GtkTextBuffer *buffer
,GtkTextIter *iter
,gint line_number
,gint byte_index
);
Obtains an iterator pointing to byte_index
within the given line.
byte_index
must be the start of a UTF-8 character. Note bytes, not
characters; UTF-8 may encode one character as multiple bytes.
Before the 3.20 version, it was not allowed to pass an invalid location.
Since the 3.20 version, if line_number
is greater than the number of lines
in the buffer
, the end iterator is returned. And if byte_index
is off the
end of the line, the iterator at the end of the line is returned.
void gtk_text_buffer_get_iter_at_mark (GtkTextBuffer *buffer
,GtkTextIter *iter
,GtkTextMark *mark
);
Initializes iter
with the current position of mark
.
void gtk_text_buffer_get_iter_at_child_anchor (GtkTextBuffer *buffer
,GtkTextIter *iter
,GtkTextChildAnchor *anchor
);
Obtains the location of anchor
within buffer
.
void gtk_text_buffer_get_start_iter (GtkTextBuffer *buffer
,GtkTextIter *iter
);
Initialized iter
with the first position in the text buffer. This
is the same as using gtk_text_buffer_get_iter_at_offset()
to get
the iter at character offset 0.
void gtk_text_buffer_get_end_iter (GtkTextBuffer *buffer
,GtkTextIter *iter
);
Initializes iter
with the “end iterator,” one past the last valid
character in the text buffer. If dereferenced with
gtk_text_iter_get_char()
, the end iterator has a character value of 0.
The entire buffer lies in the range from the first position in
the buffer (call gtk_text_buffer_get_start_iter()
to get
character position 0) to the end iterator.
void gtk_text_buffer_get_bounds (GtkTextBuffer *buffer
,GtkTextIter *start
,GtkTextIter *end
);
Retrieves the first and last iterators in the buffer, i.e. the
entire buffer lies within the range [start
,end
).
gboolean
gtk_text_buffer_get_modified (GtkTextBuffer *buffer
);
Indicates whether the buffer has been modified since the last call
to gtk_text_buffer_set_modified()
set the modification flag to
FALSE
. Used for example to enable a “save” function in a text
editor.
void gtk_text_buffer_set_modified (GtkTextBuffer *buffer
,gboolean setting
);
Used to keep track of whether the buffer has been modified since the
last time it was saved. Whenever the buffer is saved to disk, call
gtk_text_buffer_set_modified (buffer
, FALSE). When the buffer is modified,
it will automatically toggled on the modified bit again. When the modified
bit flips, the buffer emits the “modified-changed” signal.
gboolean gtk_text_buffer_delete_selection (GtkTextBuffer *buffer
,gboolean interactive
,gboolean default_editable
);
Deletes the range between the “insert” and “selection_bound” marks,
that is, the currently-selected text. If interactive
is TRUE
,
the editability of the selection will be considered (users can’t delete
uneditable text).
void gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer
,GtkClipboard *clipboard
,GtkTextIter *override_location
,gboolean default_editable
);
Pastes the contents of a clipboard. If override_location
is NULL
, the
pasted text will be inserted at the cursor position, or the buffer selection
will be replaced if the selection is non-empty.
Note: pasting is asynchronous, that is, we’ll ask for the paste data and return, and at some point later after the main loop runs, the paste data will be inserted.
buffer |
||
clipboard |
the GtkClipboard to paste from |
|
override_location |
location to insert pasted text, or |
[allow-none] |
default_editable |
whether the buffer is editable by default |
void gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer
,GtkClipboard *clipboard
);
Copies the currently-selected text to a clipboard.
void gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer
,GtkClipboard *clipboard
,gboolean default_editable
);
Copies the currently-selected text to a clipboard, then deletes said text if it’s editable.
buffer |
||
clipboard |
the GtkClipboard object to cut to |
|
default_editable |
default editability of the buffer |
gboolean gtk_text_buffer_get_selection_bounds (GtkTextBuffer *buffer
,GtkTextIter *start
,GtkTextIter *end
);
Returns TRUE
if some text is selected; places the bounds
of the selection in start
and end
(if the selection has length 0,
then start
and end
are filled in with the same value).
start
and end
will be in ascending order. If start
and end
are
NULL, then they are not filled in, but the return value still indicates
whether text is selected.
void
gtk_text_buffer_begin_user_action (GtkTextBuffer *buffer
);
Called to indicate that the buffer operations between here and a
call to gtk_text_buffer_end_user_action()
are part of a single
user-visible operation. The operations between
gtk_text_buffer_begin_user_action()
and
gtk_text_buffer_end_user_action()
can then be grouped when creating
an undo stack. GtkTextBuffer maintains a count of calls to
gtk_text_buffer_begin_user_action()
that have not been closed with
a call to gtk_text_buffer_end_user_action()
, and emits the
“begin-user-action” and “end-user-action” signals only for the
outermost pair of calls. This allows you to build user actions
from other user actions.
The “interactive” buffer mutation functions, such as
gtk_text_buffer_insert_interactive()
, automatically call begin/end
user action around the buffer operations they perform, so there's
no need to add extra calls if you user action consists solely of a
single call to one of those functions.
void
gtk_text_buffer_end_user_action (GtkTextBuffer *buffer
);
Should be paired with a call to gtk_text_buffer_begin_user_action()
.
See that function for a full explanation.
void gtk_text_buffer_add_selection_clipboard (GtkTextBuffer *buffer
,GtkClipboard *clipboard
);
Adds clipboard
to the list of clipboards in which the selection
contents of buffer
are available. In most cases, clipboard
will be
the GtkClipboard of type GDK_SELECTION_PRIMARY
for a view of buffer
.
void gtk_text_buffer_remove_selection_clipboard (GtkTextBuffer *buffer
,GtkClipboard *clipboard
);
Removes a GtkClipboard added with
gtk_text_buffer_add_selection_clipboard()
.
buffer |
||
clipboard |
a GtkClipboard added to |
gboolean (*GtkTextBufferDeserializeFunc) (GtkTextBuffer *register_buffer
,GtkTextBuffer *content_buffer
,GtkTextIter *iter
,const guint8 *data
,gsize length
,gboolean create_tags
,gpointer user_data
,GError **error
);
A function that is called to deserialize rich text that has been
serialized with gtk_text_buffer_serialize()
, and insert it at iter
.
register_buffer |
the GtkTextBuffer the format is registered with |
|
content_buffer |
the GtkTextBuffer to deserialize into |
|
iter |
insertion point for the deserialized text |
|
data |
data to deserialize. |
[array length=length] |
length |
length of |
|
create_tags |
|
|
user_data |
user data that was specified when registering the format |
|
error |
return location for a GError |
gboolean gtk_text_buffer_deserialize (GtkTextBuffer *register_buffer
,GtkTextBuffer *content_buffer
,GdkAtom format
,GtkTextIter *iter
,const guint8 *data
,gsize length
,GError **error
);
This function deserializes rich text in format format
and inserts
it at iter
.
formats
to be used must be registered using
gtk_text_buffer_register_deserialize_format()
or
gtk_text_buffer_register_deserialize_tagset()
beforehand.
register_buffer |
the GtkTextBuffer |
|
content_buffer |
the GtkTextBuffer to deserialize into |
|
format |
the rich text format to use for deserializing |
|
iter |
insertion point for the deserialized text |
|
data |
data to deserialize. |
[array length=length] |
length |
length of |
|
error |
return location for a GError |
Since: 2.10
gboolean gtk_text_buffer_deserialize_get_can_create_tags (GtkTextBuffer *buffer
,GdkAtom format
);
This functions returns the value set with
gtk_text_buffer_deserialize_set_can_create_tags()
Since: 2.10
void gtk_text_buffer_deserialize_set_can_create_tags (GtkTextBuffer *buffer
,GdkAtom format
,gboolean can_create_tags
);
Use this function to allow a rich text deserialization function to create new tags in the receiving buffer. Note that using this function is almost always a bad idea, because the rich text functions you register should know how to map the rich text format they handler to your text buffers set of tags.
The ability of creating new (arbitrary!) tags in the receiving buffer
is meant for special rich text formats like the internal one that
is registered using gtk_text_buffer_register_deserialize_tagset()
,
because that format is essentially a dump of the internal structure
of the source buffer, including its tag names.
You should allow creation of tags only if you know what you are doing, e.g. if you defined a tagset name for your application suite’s text buffers and you know that it’s fine to receive new tags from these buffers, because you know that your application can handle the newly created tags.
buffer |
||
format |
a GdkAtom representing a registered rich text format |
|
can_create_tags |
whether deserializing this format may create tags |
Since: 2.10
GtkTargetList *
gtk_text_buffer_get_copy_target_list (GtkTextBuffer *buffer
);
This function returns the list of targets this text buffer can
provide for copying and as DND source. The targets in the list are
added with info
values from the GtkTextBufferTargetInfo enum,
using gtk_target_list_add_rich_text_targets()
and
gtk_target_list_add_text_targets()
.
Since: 2.10
GdkAtom * gtk_text_buffer_get_deserialize_formats (GtkTextBuffer *buffer
,gint *n_formats
);
This function returns the rich text deserialize formats registered
with buffer
using gtk_text_buffer_register_deserialize_format()
or
gtk_text_buffer_register_deserialize_tagset()
an array of GdkAtoms representing the registered formats.
[array length=n_formats][transfer container]
Since: 2.10
GtkTargetList *
gtk_text_buffer_get_paste_target_list (GtkTextBuffer *buffer
);
This function returns the list of targets this text buffer supports
for pasting and as DND destination. The targets in the list are
added with info
values from the GtkTextBufferTargetInfo enum,
using gtk_target_list_add_rich_text_targets()
and
gtk_target_list_add_text_targets()
.
Since: 2.10
GdkAtom * gtk_text_buffer_get_serialize_formats (GtkTextBuffer *buffer
,gint *n_formats
);
This function returns the rich text serialize formats registered
with buffer
using gtk_text_buffer_register_serialize_format()
or
gtk_text_buffer_register_serialize_tagset()
an array of GdkAtoms representing the registered formats.
[array length=n_formats][transfer container]
Since: 2.10
GdkAtom gtk_text_buffer_register_deserialize_format (GtkTextBuffer *buffer
,const gchar *mime_type
,GtkTextBufferDeserializeFunc function
,gpointer user_data
,GDestroyNotify user_data_destroy
);
This function registers a rich text deserialization function
along with
its mime_type
with the passed buffer
.
buffer |
||
mime_type |
the format’s mime-type |
|
function |
the deserialize function to register |
|
user_data |
|
|
user_data_destroy |
a function to call when |
Since: 2.10
GdkAtom gtk_text_buffer_register_deserialize_tagset (GtkTextBuffer *buffer
,const gchar *tagset_name
);
This function registers GTK+’s internal rich text serialization
format with the passed buffer
. See
gtk_text_buffer_register_serialize_tagset()
for details.
Since: 2.10
GdkAtom gtk_text_buffer_register_serialize_format (GtkTextBuffer *buffer
,const gchar *mime_type
,GtkTextBufferSerializeFunc function
,gpointer user_data
,GDestroyNotify user_data_destroy
);
This function registers a rich text serialization function
along with
its mime_type
with the passed buffer
.
buffer |
||
mime_type |
the format’s mime-type |
|
function |
the serialize function to register |
|
user_data |
|
|
user_data_destroy |
a function to call when |
Since: 2.10
GdkAtom gtk_text_buffer_register_serialize_tagset (GtkTextBuffer *buffer
,const gchar *tagset_name
);
This function registers GTK+’s internal rich text serialization
format with the passed buffer
. The internal format does not comply
to any standard rich text format and only works between GtkTextBuffer
instances. It is capable of serializing all of a text buffer’s tags
and embedded pixbufs.
This function is just a wrapper around
gtk_text_buffer_register_serialize_format()
. The mime type used
for registering is “application/x-gtk-text-buffer-rich-text”, or
“application/x-gtk-text-buffer-rich-text;format=tagset_name
” if a
tagset_name
was passed.
The tagset_name
can be used to restrict the transfer of rich text
to buffers with compatible sets of tags, in order to avoid unknown
tags from being pasted. It is probably the common case to pass an
identifier != NULL
here, since the NULL
tagset requires the
receiving buffer to deal with with pasting of arbitrary tags.
Since: 2.10
guint8 * (*GtkTextBufferSerializeFunc) (GtkTextBuffer *register_buffer
,GtkTextBuffer *content_buffer
,const GtkTextIter *start
,const GtkTextIter *end
,gsize *length
,gpointer user_data
);
A function that is called to serialize the content of a text buffer. It must return the serialized form of the content.
register_buffer |
the GtkTextBuffer for which the format is registered |
|
content_buffer |
the GtkTextBuffer to serialize |
|
start |
start of the block of text to serialize |
|
end |
end of the block of text to serialize |
|
length |
Return location for the length of the serialized data |
|
user_data |
user data that was specified when registering the format |
a newly-allocated array of guint8 which contains
the serialized data, or NULL
if an error occurred.
[nullable]
guint8 * gtk_text_buffer_serialize (GtkTextBuffer *register_buffer
,GtkTextBuffer *content_buffer
,GdkAtom format
,const GtkTextIter *start
,const GtkTextIter *end
,gsize *length
);
This function serializes the portion of text between start
and end
in the rich text format represented by format
.
formats
to be used must be registered using
gtk_text_buffer_register_serialize_format()
or
gtk_text_buffer_register_serialize_tagset()
beforehand.
register_buffer |
the GtkTextBuffer |
|
content_buffer |
the GtkTextBuffer to serialize |
|
format |
the rich text format to use for serializing |
|
start |
start of block of text to serialize |
|
end |
end of block of test to serialize |
|
length |
return location for the length of the serialized data. |
[out] |
Since: 2.10
void gtk_text_buffer_unregister_deserialize_format (GtkTextBuffer *buffer
,GdkAtom format
);
This function unregisters a rich text format that was previously
registered using gtk_text_buffer_register_deserialize_format()
or
gtk_text_buffer_register_deserialize_tagset()
.
Since: 2.10
void gtk_text_buffer_unregister_serialize_format (GtkTextBuffer *buffer
,GdkAtom format
);
This function unregisters a rich text format that was previously
registered using gtk_text_buffer_register_serialize_format()
or
gtk_text_buffer_register_serialize_tagset()
Since: 2.10
struct GtkTextBufferClass { GObjectClass parent_class; void (* insert_text) (GtkTextBuffer *buffer, GtkTextIter *pos, const gchar *new_text, gint new_text_length); void (* insert_pixbuf) (GtkTextBuffer *buffer, GtkTextIter *iter, GdkPixbuf *pixbuf); void (* insert_child_anchor) (GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextChildAnchor *anchor); void (* delete_range) (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end); void (* changed) (GtkTextBuffer *buffer); void (* modified_changed) (GtkTextBuffer *buffer); void (* mark_set) (GtkTextBuffer *buffer, const GtkTextIter *location, GtkTextMark *mark); void (* mark_deleted) (GtkTextBuffer *buffer, GtkTextMark *mark); void (* apply_tag) (GtkTextBuffer *buffer, GtkTextTag *tag, const GtkTextIter *start, const GtkTextIter *end); void (* remove_tag) (GtkTextBuffer *buffer, GtkTextTag *tag, const GtkTextIter *start, const GtkTextIter *end); void (* begin_user_action) (GtkTextBuffer *buffer); void (* end_user_action) (GtkTextBuffer *buffer); void (* paste_done) (GtkTextBuffer *buffer, GtkClipboard *clipboard); };
The class handler for the “insert-text” signal. |
||
The class handler for the “insert-pixbuf” signal. |
||
The class handler for the “insert-child-anchor” signal. |
||
The class handler for the “delete-range” signal. |
||
The class handler for the “changed” signal. |
||
The class handler for the “modified-changed” signal. |
||
The class handler for the “mark-set” signal. |
||
The class handler for the “mark-deleted” signal. |
||
The class handler for the “apply-tag” signal. |
||
The class handler for the “remove-tag” signal. |
||
The class handler for the “begin-user-action” signal. |
||
The class handler for the “end-user-action” signal. |
||
The class handler for the “paste-done” signal. |
These values are used as “info” for the targets contained in the
lists returned by gtk_text_buffer_get_copy_target_list()
and
gtk_text_buffer_get_paste_target_list()
.
The values counts down from -1
to avoid clashes
with application added drag destinations which usually start at 0.
“copy-target-list”
property“copy-target-list” GtkTargetList *
The list of targets this buffer supports for clipboard copying and as DND source.
Flags: Read
Since: 2.10
“cursor-position”
property“cursor-position” gint
The position of the insert mark (as offset from the beginning of the buffer). It is useful for getting notified when the cursor moves.
Flags: Read
Allowed values: >= 0
Default value: 0
Since: 2.10
“has-selection”
property“has-selection” gboolean
Whether the buffer has some text currently selected.
Flags: Read
Default value: FALSE
Since: 2.10
“paste-target-list”
property“paste-target-list” GtkTargetList *
The list of targets this buffer supports for clipboard pasting and as DND destination.
Flags: Read
Since: 2.10
“tag-table”
property“tag-table” GtkTextTagTable *
Text Tag Table.
Flags: Read / Write / Construct Only
“text”
property“text” gchar *
The text content of the buffer. Without child widgets and images,
see gtk_text_buffer_get_text()
for more information.
Flags: Read / Write
Default value: ""
Since: 2.8
“apply-tag”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkTextTag *tag, GtkTextIter *start, GtkTextIter *end, gpointer user_data)
The ::apply-tag signal is emitted to apply a tag to a range of text in a GtkTextBuffer. Applying actually occurs in the default handler.
Note that if your handler runs before the default handler it must not
invalidate the start
and end
iters (or has to revalidate them).
See also:
gtk_text_buffer_apply_tag()
,
gtk_text_buffer_insert_with_tags()
,
gtk_text_buffer_insert_range()
.
textbuffer |
the object which received the signal |
|
tag |
the applied tag |
|
start |
the start of the range the tag is applied to |
|
end |
the end of the range the tag is applied to |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“begin-user-action”
signalvoid user_function (GtkTextBuffer *textbuffer, gpointer user_data)
The ::begin-user-action signal is emitted at the beginning of a single user-visible operation on a GtkTextBuffer.
See also:
gtk_text_buffer_begin_user_action()
,
gtk_text_buffer_insert_interactive()
,
gtk_text_buffer_insert_range_interactive()
,
gtk_text_buffer_delete_interactive()
,
gtk_text_buffer_backspace()
,
gtk_text_buffer_delete_selection()
.
textbuffer |
the object which received the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“changed”
signalvoid user_function (GtkTextBuffer *textbuffer, gpointer user_data)
The ::changed signal is emitted when the content of a GtkTextBuffer has changed.
textbuffer |
the object which received the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“delete-range”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkTextIter *start, GtkTextIter *end, gpointer user_data)
The ::delete-range signal is emitted to delete a range from a GtkTextBuffer.
Note that if your handler runs before the default handler it must not
invalidate the start
and end
iters (or has to revalidate them).
The default signal handler revalidates the start
and end
iters to
both point to the location where text was deleted. Handlers
which run after the default handler (see g_signal_connect_after()
)
do not have access to the deleted text.
See also: gtk_text_buffer_delete()
.
textbuffer |
the object which received the signal |
|
start |
the start of the range to be deleted |
|
end |
the end of the range to be deleted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“end-user-action”
signalvoid user_function (GtkTextBuffer *textbuffer, gpointer user_data)
The ::end-user-action signal is emitted at the end of a single user-visible operation on the GtkTextBuffer.
See also:
gtk_text_buffer_end_user_action()
,
gtk_text_buffer_insert_interactive()
,
gtk_text_buffer_insert_range_interactive()
,
gtk_text_buffer_delete_interactive()
,
gtk_text_buffer_backspace()
,
gtk_text_buffer_delete_selection()
,
gtk_text_buffer_backspace()
.
textbuffer |
the object which received the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“insert-child-anchor”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkTextIter *location, GtkTextChildAnchor *anchor, gpointer user_data)
The ::insert-child-anchor signal is emitted to insert a GtkTextChildAnchor in a GtkTextBuffer. Insertion actually occurs in the default handler.
Note that if your handler runs before the default handler it must
not invalidate the location
iter (or has to revalidate it).
The default signal handler revalidates it to be placed after the
inserted anchor
.
See also: gtk_text_buffer_insert_child_anchor()
.
textbuffer |
the object which received the signal |
|
location |
position to insert |
|
anchor |
the GtkTextChildAnchor to be inserted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“insert-pixbuf”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkTextIter *location, GdkPixbuf *pixbuf, gpointer user_data)
The ::insert-pixbuf signal is emitted to insert a GdkPixbuf in a GtkTextBuffer. Insertion actually occurs in the default handler.
Note that if your handler runs before the default handler it must not
invalidate the location
iter (or has to revalidate it).
The default signal handler revalidates it to be placed after the
inserted pixbuf
.
See also: gtk_text_buffer_insert_pixbuf()
.
textbuffer |
the object which received the signal |
|
location |
position to insert |
|
pixbuf |
the GdkPixbuf to be inserted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“insert-text”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkTextIter *location, gchar *text, gint len, gpointer user_data)
The ::insert-text signal is emitted to insert text in a GtkTextBuffer. Insertion actually occurs in the default handler.
Note that if your handler runs before the default handler it must not
invalidate the location
iter (or has to revalidate it).
The default signal handler revalidates it to point to the end of the
inserted text.
See also:
gtk_text_buffer_insert()
,
gtk_text_buffer_insert_range()
.
textbuffer |
the object which received the signal |
|
location |
position to insert |
|
text |
the UTF-8 text to be inserted |
|
len |
length of the inserted text in bytes |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“mark-deleted”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkTextMark *mark, gpointer user_data)
The ::mark-deleted signal is emitted as notification after a GtkTextMark is deleted.
See also:
gtk_text_buffer_delete_mark()
.
textbuffer |
the object which received the signal |
|
mark |
The mark that was deleted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“mark-set”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkTextIter *location, GtkTextMark *mark, gpointer user_data)
The ::mark-set signal is emitted as notification after a GtkTextMark is set.
See also:
gtk_text_buffer_create_mark()
,
gtk_text_buffer_move_mark()
.
textbuffer |
the object which received the signal |
|
location |
The location of |
|
mark |
The mark that is set |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“modified-changed”
signalvoid user_function (GtkTextBuffer *textbuffer, gpointer user_data)
The ::modified-changed signal is emitted when the modified bit of a GtkTextBuffer flips.
See also:
gtk_text_buffer_set_modified()
.
textbuffer |
the object which received the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“paste-done”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkClipboard *clipboard, gpointer user_data)
The paste-done signal is emitted after paste operation has been completed.
This is useful to properly scroll the view to the end of the pasted text.
See gtk_text_buffer_paste_clipboard()
for more details.
textbuffer |
the object which received the signal |
|
clipboard |
the GtkClipboard pasted from |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.16
“remove-tag”
signalvoid user_function (GtkTextBuffer *textbuffer, GtkTextTag *tag, GtkTextIter *start, GtkTextIter *end, gpointer user_data)
The ::remove-tag signal is emitted to remove all occurrences of tag
from
a range of text in a GtkTextBuffer.
Removal actually occurs in the default handler.
Note that if your handler runs before the default handler it must not
invalidate the start
and end
iters (or has to revalidate them).
See also:
gtk_text_buffer_remove_tag()
.
textbuffer |
the object which received the signal |
|
tag |
the tag to be removed |
|
start |
the start of the range the tag is removed from |
|
end |
the end of the range the tag is removed from |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last


Traditions and Hearthside Stories of West Cornwall, Vol. 2, by William Bottrell, [1873], at sacred-texts.com
Zennor folks tell the following story, which, according to them, accounts for a singular carving on a bench-end in their Church.
Hundreds of years ago a very beautiful and richly attired lady attended service in Zennor Church occasionally—now and then she went to Morvah also;—her visits were by no means regular,—often long intervals would elapse between them.
Yet whenever she came the people were enchanted with her good looks and sweet singing. Although Zennor folks were remarkable for their fine psalmody, she excelled them all; and they wondered how, after the scores of years that they had seen
her, she continued to look so young and fair. No one knew whence she came nor whither she went; yet many watched her as far as they could see from Tregarthen Hill.
She took some notice of a fine young man, called Mathey Trewella, who was the best singer in the parish. He once followed her, but he never returned; after that she was never more seen in Zennor Church, and it might not have been known to this day who or what she was but for the merest accident.
One Sunday morning a vessel cast anchor about a mile from Pendower Cove; soon after a mermaid came close alongside and hailed the ship. Rising out of the water as far as her waist, with her yellow hair floating around her, she told the captain that she was returning from church, and requested him to trip his anchor just for a minute, as the fluke of it rested on the door of her dwelling, and she was anxious to get in to her children.
Others say that while she was out on the ocean a-fishing of a Sunday morning, the anchor was dropped on the trap-door which gave access to her submarine abode. Finding, on her return, how she was hindered from opening her door, she begged the captain to have the anchor raised that she might enter her dwelling to dress her children and be ready in time for church.
However it may be, her polite request had a magical effect upon the sailors, for they immediately "worked with a will," hove anchor and set sail, not wishing to remain a moment longer than they could help near her habitation. Sea-faring men, who understood most about mermaids, regarded their appearance as a token that bad luck was near at hand. It was believed they could take such shapes as suited their purpose, and that they had often allured men to live with them.
When Zennor folks learnt that a mermaid dwelt near Pen-dower, and what she had told the captain, they concluded—it was, this sea-lady who had visited their church, and enticed Trewella to her abode. To commemorate these somewhat unusual events they had the figure she bore—when in her ocean-home—carved in holy-oak, which may still be seen.


Suspects held in Halloween shooting at California Airbnb
The Contra County Sheriff's office said on Thursday the four men were arrested along with a fifth man, who was charged with being an accessory to the crime and was being held in lieu of $500,000 bail.
California authorities on Friday were holding four suspects charged with murder and conspiracy in connection with a deadly shooting at a Halloween costume party hosted at an Airbnb rental house in California.
The Contra County Sheriff's office said on Thursday the four men were arrested along with a fifth man, who was charged with being an accessory to the crime and was being held in lieu of $500,000 bail. The suspects range in age from 21 to 30.
The Oct. 31 shooting, which left five dead and several others wounded, occurred at a party attended by more than 100 people at a house booked through Airbnb Inc in Orinda, less than 20 miles (30 km) east of San Francisco.
The incident prompted Airbnb to ban "party houses" and institute stricter guest conduct policies.
"Extraordinary cooperation among multiple law enforcement agencies led to these arrests and a small measure of justice for the true victims,” Contra Costa Sheriff David Livingston said in the statement.
Livingston also said two of the deceased victims inside the house had been armed and the investigation was ongoing.