view release on metacpan or  search on metacpan

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

calcites calcitic calcitonin calcitonins calcium calciums calcspar calcspars
calctufa calctufas calctuff calctuffs calculable calculate calculated
calculatedly calculatedness calculatednesses calculates calculating
calculatingly calculation calculational calculations calculator calculators
calculi calculous calculus calculuses caldaria caldarium caldera calderas
caldron caldrons caleche caleches calefactories calefactory calendal calendar
calendared calendaring calendars calender calendered calenderer calenderers
calendering calenders calendric calendrical calends calendula calendulas
calenture calentures calesa calesas calf calflike calfs calfskin calfskins
caliber calibers calibrate calibrated calibrates calibrating calibration
calibrations calibrator calibrators calibre calibred calibres calices caliche
caliches calicle calicles calico calicoes calicos calif califate califates

 view release on metacpan or  search on metacpan

lib/Gantry.pm  view on Meta::CPAN

provides a more automated approach to
CRUD (Create, Retrieve, Update, Delete) support

=item L<Gantry::Plugins::Calendar>

These module creates a couple calendar views that can be used by other
applications and are highly customizeable. 

=item L<Gantry::Engine::MP13>

This module is the binding between the Gantry framework and the mod_perl API.

 view release on metacpan or  search on metacpan

lib/Gedcom/Date.pm  view on Meta::CPAN

L<https://github.com/ronsavage/Gedcom-Date>.

=head1 TODO

Implement other calendars (Julian, Hebrew, French).

More languages in as_text().

=head1 See Also

 view release on metacpan or  search on metacpan

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

	is       => 'rw',
	isa      => Str,
	required => 0,
);

has _calendar =>
(
	default  => sub{return 'Gregorian'},
	is       => 'rw',
	isa      => Str,
	required => 0,

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

	# Initialize the action class via global variables - Yuk!
	# The point is that we don't create an action instance.
	# Marpa creates one but we can't get our hands on it.

	$Genealogy::Gedcom::Date::Actions::calendar = $self -> clean_calendar;
	$Genealogy::Gedcom::Date::Actions::logger   = $self -> logger;

	$self -> bnf
	(
<<'END_OF_GRAMMAR'

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

:start					::= gedcom_date

gedcom_date				::= date
							| lds_ord_date

date					::= calendar_escape calendar_date

calendar_escape			::=
calendar_escape			::= calendar_name 					action => calendar_name		# ($t1)
							| ('@#d') calendar_name ('@')	action => calendar_name		#   "
							| ('@#D') calendar_name ('@')	action => calendar_name		#   "

calendar_date			::= gregorian_date					action => gregorian_date	# ($t1)
							| julian_date					action => julian_date		# ($t1)
							| french_date					action => french_date		# ($t1)
							| german_date					action => german_date		# ($t1)
							| hebrew_date					action => hebrew_date		# ($t1)

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

							| 'between':i

calculated				~ 'cal':i
							| 'calculated':i

calendar_name			~ 'french r':i
							| 'frenchr':i
							| 'german':i
							| 'gregorian':i
							| 'hebrew':i
							| 'julian':i

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

} # End of canonical_form.

# ------------------------------------------------

sub clean_calendar
{
	my($self)     = @_;
	my($calendar) = $self -> _calendar;
	$calendar     =~ s/\@\#d(.+)\@/$1/; # Zap gobbledegook if present.
	$calendar     = ucfirst lc $calendar;

	return $self -> _calendar($calendar);

} # End of clean_calendar.

# --------------------------------------------------

sub compare
{

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

# --------------------------------------------------

sub process_ambiguous
{
	my($self)     = @_;
	my($calendar) = $self -> clean_calendar;
	my(%count)    =
	(
		AND  => 0,
		BET  => 0,
		FROM => 0,

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

		for $item (@$value)
		{
			if ($$item{kind} eq 'Calendar')
			{
				$calendar = $$item{type};

				next;
			}

			if ($calendar eq $$item{type})
			{
				# We have to allow for the fact that when 'From .. To' or 'Between ... And'
				# are used, both dates are ambiguous, and we end up with double the number
				# of elements in the arrayref compared to what's expected.

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

				{
					($$result[0], $$result[1]) = ($$result[1], $$result[0]);
				}
			}

			# Reset the calendar. Note: The 'next' above skips this statement.

			$calendar = $self -> clean_calendar;
		}
	}

	return $result;

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

# --------------------------------------------------

sub process_unambiguous
{
	my($self)     = @_;
	my($calendar) = $self -> clean_calendar;
	my($result)   = [];
	my($value)    = $self -> recce -> value;
	$value        = $self -> decode_result($$value);

	if ($#$value == 0)
	{
		$value = $$value[0];

		if ($$value{type} =~ /^(?:$calendar|Phrase)$/)
		{
			$$result[0] = $value;
		}
		else
		{

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

	{
		$result = [$$value[1], $$value[3] ];
	}
	elsif ($$value[0]{kind} eq 'Calendar')
	{
		$calendar = $$value[0]{type};

		if ($calendar eq $$value[1]{type})
		{
			$result = [$$value[1] ];
		}
	}
	elsif ( ($$value[0]{type} eq $calendar) && ($$value[1]{type} eq $calendar) )
	{
		$result = $value;
	}

	return $result;

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

=item o If Gregorian (in any form) was in the original string, it is discarded

This is done because it's the default.

=item o If any other calendar escape was in the original string, it is preserved

And it's output in all caps.

And as a special case, 'FRENCHR' is returned as 'FRENCH R'.

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

=item o Input may be in Unicode

=item o Input may be in any case

=item o Input may omit calendar escapes when the date is unambigous

=item o Any of the following tokens may be used

=over 4

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

=over 4

=item o bce

If the input contains any (case-insensitive) BCE indicator, under any calendar escape, the C<bce>
key will hold the exact indicator.

=item o canonical => $string

L</parse([%args])> calls L</canonical_date($hashref)> to populate this key.

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

The C<kind> key is always present, and always takes the value 'Date' or 'Phrase'.

If the value is 'Phrase', see the C<phrase> and C<type> keys.

During processing, there can be another - undocumented - element in the arrayref. It represents
the calendar escape, and in that case C<kind> takes the value 'Calendar'. This element is discarded
before the final arrayref is returned to the caller.

=item o month => $string

If the input contains a month, then the C<month> key will be present. The case of $string will be

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

If the year contains a suffix (/00), see also the C<suffix> key, above. This means the value of
the C<year> key is never "$integer/$two_digits".

=back

=head2 When should I use a calendar escape?

=over 4

=item o In theory, for every non-Gregorian date

In practice, if the month name is unique to a specific language, then the escape is not needed,
since L<Marpa::R2> and this code automatically handle ambiguity.

Likewise, if you use a Gregorian year in the form 1700/01, then the calendar escape is obvious.

The escape is, of course, always inserted into the values returned by the C<canonical> pair of
methods when they process non-Gregorian dates. That makes their output compatible with
other software. And no matter what case you use specifying the calendar escape, it is always
output in upper-case.

=item o When you wish to force the code to provide an unambiguous result

All Gregorian and Julian dates are ambiguous, unless they use the year format 1700/01.

So, to resolve the ambiguity, add the calendar escape.

=back

=head2 Why is '@' escaped with '\' when L<Data::Dumper::Concise>'s C<Dumper()> prints things?

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

Yes.

See t/German.t for sample code.

=head2 Can I change the default calendar?

No. It is always Gregorian.

=head2 Are dates massaged before being processed?

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

=item o You tried to enter the German month name 'Mär' via the shell

Read more about this by running 'perl scripts/parse.pl -h', where it discusses '-d'.

=item o You mistyped the calendar escape

Check: Are any of these valid?

=over 4

lib/Genealogy/Gedcom/Date.pm  view on Meta::CPAN

Yes, the last 3 are accepted by this module, and the last one is accepted by other software.

=item o The date is in American format (month day year)

=item o You used a Julian calendar with a Gregorian year

Dates - such as 1900/01 - which do not fit the Gedcom definition of a Julian year, are filtered
out.

=back

 view release on metacpan or  search on metacpan

lib/Genealogy/Gedcom/Reader/Lexer.pm  view on Meta::CPAN

		 copyright_source_data => 90,
		 count_of_children => 3,
		 count_of_marriages => 3,
		 date => 35,
		 date_approximated => 35,
		 date_calendar => 35,
		 date_calendar_escape => 15,
		 date_exact => 11,
		 date_fren => 35,
		 date_greg => 35,
		 date_hebr => 35,
		 date_juln => 35,

 view release on metacpan or  search on metacpan

t/sandbox/pkg-files.lst  view on Meta::CPAN

/usr/include/gtk-1.2/gtk/gtkbin.h
/usr/include/gtk-1.2/gtk/gtkbindings.h
/usr/include/gtk-1.2/gtk/gtkbbox.h
/usr/include/gtk-1.2/gtk/gtkbox.h
/usr/include/gtk-1.2/gtk/gtkbutton.h
/usr/include/gtk-1.2/gtk/gtkcalendar.h
/usr/include/gtk-1.2/gtk/gtkcheckbutton.h
/usr/include/gtk-1.2/gtk/gtkcheckmenuitem.h
/usr/include/gtk-1.2/gtk/gtkclist.h
/usr/include/gtk-1.2/gtk/gtkcolorsel.h
/usr/include/gtk-1.2/gtk/gtkcombo.h

t/sandbox/pkg-files.lst  view on Meta::CPAN

/usr/share/gtk-2.0/demo/alphatest.png
/usr/share/gtk-2.0/demo/apple-red.png
/usr/share/gtk-2.0/demo/background.jpg
/usr/share/gtk-2.0/demo/floppybuddy.gif
/usr/share/gtk-2.0/demo/gnome-applets.png
/usr/share/gtk-2.0/demo/gnome-calendar.png
/usr/share/gtk-2.0/demo/gnome-foot.png
/usr/share/gtk-2.0/demo/gnome-gimp.png
/usr/share/gtk-2.0/demo/gnome-gmush.png
/usr/share/gtk-2.0/demo/gnome-gsame.png
/usr/share/gtk-2.0/demo/gnu-keys.png

t/sandbox/pkg-files.lst  view on Meta::CPAN

/usr/include/gtk-2.0/gtk/gtkbbox.h
/usr/include/gtk-2.0/gtk/gtkbin.h
/usr/include/gtk-2.0/gtk/gtkbindings.h
/usr/include/gtk-2.0/gtk/gtkbox.h
/usr/include/gtk-2.0/gtk/gtkbutton.h
/usr/include/gtk-2.0/gtk/gtkcalendar.h
/usr/include/gtk-2.0/gtk/gtkcelleditable.h
/usr/include/gtk-2.0/gtk/gtkcelllayout.h
/usr/include/gtk-2.0/gtk/gtkcellrenderer.h
/usr/include/gtk-2.0/gtk/gtkcellrendererpixbuf.h
/usr/include/gtk-2.0/gtk/gtkcellrenderertext.h

 view release on metacpan or  search on metacpan

lib/Geo/EOP/xsd/eop1.1/gmlSubset.xsd  view on Meta::CPAN

	<!-- ================================================= -->
	<complexType name="AbstractTimeGeometricPrimitiveType" abstract="true">
		<annotation>
			<documentation xml:lang="en">The abstract supertype for temporal geometric primitives.
       A temporal geometry must be associated with a temporal reference system via URI. 
       The Gregorian calendar with UTC is the default reference system, following ISO 
       8601. Other reference systems in common use include the GPS calendar and the 
       Julian calendar.</documentation>
		</annotation>
		<complexContent>
			<extension base="gml:AbstractTimePrimitiveType">
				<attribute name="frame" type="anyURI" use="optional" default="#ISO-8601"/>
			</extension>

lib/Geo/EOP/xsd/eop1.1/gmlSubset.xsd  view on Meta::CPAN

		<annotation>
			<documentation xml:lang="en">Direct representation of a temporal position. 
      Indeterminate time values are also allowed, as described in ISO 19108. The indeterminatePosition 
      attribute can be used alone or it can qualify a specific value for temporal position (e.g. before 
      2002-12, after 1019624400). 
      For time values that identify position within a calendar, the calendarEraName attribute provides 
      the name of the calendar era to which the date is referenced (e.g. the Meiji era of the Japanese calendar).</documentation>
		</annotation>
		<simpleContent>
			<extension base="gml:TimePositionUnion">
				<attribute name="frame" type="anyURI" use="optional" default="#ISO-8601"/>
				<attribute name="calendarEraName" type="string" use="optional"/>
				<attribute name="indeterminatePosition" type="gml:TimeIndeterminateValueType" use="optional"/>
			</extension>
		</simpleContent>
	</complexType>
	<!-- ================================================= -->

lib/Geo/EOP/xsd/eop1.1/gmlSubset.xsd  view on Meta::CPAN

      by defining a union of XML Schema simple types for indicating temporal position relative 
      to a specific reference system. 
      
      Dates and dateTime may be indicated with varying degrees of precision.  
      dateTime by itself does not allow right-truncation, except for fractions of seconds. 
      When used with non-Gregorian calendars based on years, months, days, 
      the same lexical representation should still be used, with leading zeros added if the 
      year value would otherwise have fewer than four digits.  
      
      An ordinal position may be referenced via URI identifying the definition of an ordinal era.  
      
      A time coordinate value is indicated as a decimal (e.g. UNIX time, GPS calendar).</documentation>
		</annotation>
		<union memberTypes="gml:CalDate time dateTime anyURI decimal"/>
	</simpleType>
	<!-- ================================================= -->
	<simpleType name="CalDate">
		<annotation>
			<documentation xml:lang="en">Calendar dates may be indicated with varying degrees of precision, 
      using year, year-month, date. 
      When used with non-Gregorian calendars based on years, months, days, 
      the same lexical representation should still be used, with leading zeros added if the 
      year value would otherwise have fewer than four digits.  
      time is used for a position that recurs daily (see clause 5.4.4.2 of ISO 19108:2002).</documentation>
		</annotation>
		<union memberTypes="date gYearMonth gYear"/>

 view release on metacpan or  search on metacpan

lib/Geo/GML/xsd/gml-3.0.0/base/temporal.xsd  view on Meta::CPAN

  <!-- ===================================== -->
  <complexType name="AbstractTimeType" abstract="true">
    <annotation>
      <documentation xml:lang="en">
       A temporal object must be associated with a temporal reference system via URI. 
       The Gregorian calendar with UTC is the default reference system, following ISO 
       8601. Other reference systems in common use include the GPS calendar and the 
       Julian calendar.
      </documentation>
    </annotation>
    <complexContent>
      <extension base="gml:AbstractGMLType">
        <attribute name="frame" type="anyURI" use="optional" default="#ISO-8601"/>

lib/Geo/GML/xsd/gml-3.0.0/base/temporal.xsd  view on Meta::CPAN

      Date and time may be indicated with varying degrees of precision:
      year, year-month, date, or dateTime (all ISO 8601 format). Note 
      that the dateTime type does not allow right-truncation (i.e. omitting 
      seconds). An ordinal era may be referenced via URI, and a decimal value
      can be used to indicate the distance from the scale origin (e.g. UNIX time,  
      GPS calendar).
      </documentation>
    </annotation>
    <union memberTypes="dateTime date gYearMonth gYear anyURI decimal"/>
  </simpleType>
  <!-- ================================================================== -->

lib/Geo/GML/xsd/gml-3.0.0/base/temporal.xsd  view on Meta::CPAN

  <complexType name="TimePositionType" final="#all">
    <annotation>
      <documentation xml:lang="en">
      Indeterminate time values are also allowed, as described in ISO 19108. The indeterminatePosition 
      attribute can be used alone or it can qualify a specific value for temporal position (e.g. before 
      2002-12, after 1019624400). For time values that identify position within a calendar, the 
      calendarEraName attribute provides the name of the calendar era to which the date is 
      referenced (e.g. the Meiji era of the Japanese calendar).
      </documentation>
    </annotation>
    <simpleContent>
      <extension base="gml:TemporalPositionType">
        <attribute name="indeterminatePosition" type="gml:TimeIndeterminateValueType" use="optional"/>
        <attribute name="calendarEraName" type="string" use="optional"/>
        <attribute name="frame" type="anyURI" use="optional" default="#ISO-8601"/>
      </extension>
    </simpleContent>
  </complexType>
  <!-- ================================================================== -->

lib/Geo/GML/xsd/gml-3.0.0/base/temporal.xsd  view on Meta::CPAN

  <!-- ===================================== -->
  <complexType name="TimeReferenceSystemType">
    <annotation>
      <documentation xml:lang="en">
        A value in the time domain is measured relative to a temporal reference system. Common 
        types of reference systems include calendars, ordinal temporal reference systems, and 
        temporal coordinate systems (time elapsed since some epoch, e.g. UNIX time).
      </documentation>
    </annotation>
    <complexContent>
      <extension base="gml:DefinitionType">

 view release on metacpan or  search on metacpan

shapereader/dbf.h  view on Meta::CPAN

} dbf_record_t;

/**
 * Convert a Julian date into a tm structure
 *
 * Calculates the calendar date from a Julian date and the time since
 * midnight.
 *
 * The tm_isdst member of the tm structure is always set to -1.
 *
 * @param jd days since 1 January -4712.

shapereader/dbf.h  view on Meta::CPAN

 * Converts a date string in the format "YYYYMMDD" into a tm structure
 *
 * Fills a tm structure with the day, month and year from a date string.
 *
 * The tm_wday member is only valid after 15 October 1582 in the Gregorian
 * calendar.
 *
 * The tm_isdst member is always set to -1.
 *
 * @param ymd a date string in the format "YYYYMMDD".
 * @param n the string length

shapereader/dbf.h  view on Meta::CPAN

 *
 * Fills a tm structure with the day, month and year from a date in the
 * format "YYYYMMDD".
 *
 * The tm_wday member is only valid after 15 October 1582 in the Gregorian
 * calendar.
 *
 * The tm_isdst member is always set to -1.
 *
 * @memberof dbf_record_t
 * @param record a record.

 view release on metacpan or  search on metacpan

t/options-valid.t  view on Meta::CPAN

        , 'bell|b'
        , 'breaks|b'
        , 'bydate|b'
        , 'bydate|d'
        , 'byte|b'
        , 'calendar_height|height|h=s'
        , 'cat|C'
        , 'change|c=i'
        , 'changer|c=s'
        , 'changes|c=i'
        , 'chdir|d'

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

        - updated pixelmap with stub documentation.
        - redim_pdl calls affine_new directly rather than via the
          perl interpreter -> smaller Perl-Server, faster operation.
        - try to uninstall. Of course this doesn't work here, so just
          trust it will work elsewhere.
        - improved yinyang for the perl calendar ;)
        - added perl_fu_ as prefix for Image, Drawables and Channels.
        - fixed Load/Save of PF_TEXT.

1.096 Thu Jul  8 21:36:36 CEST 1999
	- fix around PDL-2.002 exporting its own ppport.h.

 view release on metacpan or  search on metacpan

lib/GitInsight.pm  view on Meta::CPAN

use List::Util qw(max);

use LWP::UserAgent;
use POSIX qw(strftime ceil);

has [qw(username contribs calendar)];
has 'verbose'      => sub {0};
has 'no_day_stats' => sub {0};
has 'statistics'   => sub {0};
has 'ca_output'    => sub {1};
has 'accuracy'     => sub {0};
has [qw(left_cutoff cutoff_offset file_output)];

sub contrib_calendar {
    my $self = shift;
    my $username = shift || $self->username;
    $self->username($username) if !$self->username;
    my $ua = LWP::UserAgent->new;
    $ua->timeout(10);

lib/GitInsight.pm  view on Meta::CPAN

sub prediction_start_day { @{ shift->{result} }[0]->[2] }

sub _accuracy {
    my $self = shift;
    my ( @chunks, @commits );
    push @chunks, [ splice @{ $self->calendar }, 0, 7 ]
        while @{ $self->calendar };

    #@chunks contain a list of arrays of 7 days each

    my $total_days = 0;
    my $accuracy   = 0;

lib/GitInsight.pm  view on Meta::CPAN

    info "Accuracy is $accuracy / $total_days" if $self->verbose;
    info sprintf( "%.5f", $accuracy_prob * 100 ) . " \%" if $self->verbose;
    return $self;
}

sub _decode_calendar {
    shift;
    my $content = shift;
    my @out;
    push( @out, [ $2, $1 ] )
        while ( $content =~ m/data\-count="(.*?)" data\-date="(.*?)"/g );

lib/GitInsight.pm  view on Meta::CPAN

sub decode {
    my $self = shift;

    #my $response = ref $_[0] ne "ARRAY" ? eval(shift) : shift;
    my $response
        = ref $_[0] ne "ARRAY" ? $self->_decode_calendar(shift) : shift;
    $self->calendar( dclone($response) );
    my %commits_count;
    my $min = $self->left_cutoff || 0;
    $self->{result} = [];    #empty the result
    $min = 0 if ( $min < 0 );    # avoid negative numbers
    my $max

lib/GitInsight.pm  view on Meta::CPAN

    my $max_commit
        = max( map { $_->[1] } @{$response} );    #Calculating label steps
    label_step( 0 .. $max_commit );   #calculating quartiles over commit count
    info( "Max commit is: " . $max_commit ) if $self->verbose;
    $self->{first_day}->{day} = wday( $response->[0]->[0] )
        ; #getting the first day of the commit calendar, it's where the ca will start
    my ($index)
        = grep { $GitInsight::Util::wday[$_] eq $self->{first_day}->{day} }
        0 .. $#GitInsight::Util::wday;
    $self->{first_day}->{index} = $index;
    $self->{first_day}->{data}  = $response->[$min]->[0];

lib/GitInsight.pm  view on Meta::CPAN

sub process {
    my $self = shift;
    croak "process() called while you have not specified an username"
        if !$self->username;
    $self->contrib_calendar( $self->username )
        if !$self->contribs and $self->username;
    $self->_transition_matrix;
    $self->_markov;
    $self->_gen_stats if ( $self->statistics );
    $self->{png} = $self->draw_ca( @{ $self->{ca} } )

lib/GitInsight.pm  view on Meta::CPAN

    # $Result contains the next week predictions and is an arrayref of arrayrefs    [  [ 'Sat', 1, '2014-07-1', [ 0 ,  '0.151515151515152', '0.0606060606060606', '0.0404040404040404',  0  ]  ],   ..   [            'DayofWeek',      'winner_label',  '...


=head1 DESCRIPTION

GitInsight is module that allow you to predict your github contributions in the "calendar contribution" style of github (the table of contribution that you see on your profile page).

=head1 HOW DOES IT WORK?

GitInsight generates a transation probrability matrix from your github contrib_calendar to compute the possibles states for the following days. Given that GitHub split the states thru 5 states (or here also called label), the probability can be infer...

=head2 THEORY

We trace the transitions states in a matrix and increasing the count as far as we observe a transition (L<https://en.wikipedia.org/wiki/Transition_matrix>), then we inference the probabilities using Bayesan method L<https://en.wikipedia.org/wiki/Baye...

lib/GitInsight.pm  view on Meta::CPAN

Enable/disable verbosity (1/0)

=head1 METHODS

=head2 contrib_calendar($username)

Fetches the github contrib_calendar of the specified user

=head2 process

Calculate the predictions and generate the CA

=head2 start_day

Returns the first day of the contrib_calendar

=head2 last_day

Returns the last day of the contrib calendar (prediction included)

=head2 prediction_start_day

Returns the first day of the prediction (7 days of predictions)

 view release on metacpan or  search on metacpan

ChangeLog.pre-git  view on Meta::CPAN

	with a convenience implementation of add_watch/remove_watch

2003/05/02 18:11 muppetman

	* Gtk2/gtk-demo/apple-red.png, Gtk2/gtk-demo/background.jpg,
	Gtk2/gtk-demo/gnome-applets.png, Gtk2/gtk-demo/gnome-calendar.png,
	Gtk2/gtk-demo/gnome-foot.png, Gtk2/gtk-demo/gnome-gimp.png,
	Gtk2/gtk-demo/gnome-gmush.png, Gtk2/gtk-demo/gnome-gsame.png,
	Gtk2/gtk-demo/gnu-keys.png: images needed by Gtk2/gtk-demo/pixbufs.pl,
	directly from the gtk+-2.2.1 source distribution.

 view release on metacpan or  search on metacpan

ChangeLog.pre-git  view on Meta::CPAN

	with a convenience implementation of add_watch/remove_watch

2003/05/02 18:11 muppetman

	* Gtk2/gtk-demo/apple-red.png, Gtk2/gtk-demo/background.jpg,
	Gtk2/gtk-demo/gnome-applets.png, Gtk2/gtk-demo/gnome-calendar.png,
	Gtk2/gtk-demo/gnome-foot.png, Gtk2/gtk-demo/gnome-gimp.png,
	Gtk2/gtk-demo/gnome-gmush.png, Gtk2/gtk-demo/gnome-gsame.png,
	Gtk2/gtk-demo/gnu-keys.png: images needed by Gtk2/gtk-demo/pixbufs.pl,
	directly from the gtk+-2.2.1 source distribution.

 view release on metacpan or  search on metacpan

eg/calendar/calendarlist.pl  view on Meta::CPAN

use constant MAX_PAGE_SIZE => 3;

my $client = Google::API::Client->new;
my $service = $client->build('calendar', 'v3');

my $file = "$FindBin::Bin/../client_secrets.json";
my $auth_driver = Google::API::OAuth2::Client->new_from_client_secrets($file, $service->{auth_doc});

my $dat_file = "$FindBin::Bin/token.dat";

eg/calendar/calendarlist.pl  view on Meta::CPAN

        maxResults => MAX_PAGE_SIZE,
    );
    if ($page_token) {
        $body{pageToken} = $page_token;
    }
    # Call calendarlist.list
    my $list = $service->calendarList->list(
        body => \%body,
    )->execute({ auth_driver => $auth_driver });
    $page_token = $list->{nextPageToken};
    for my $entry (@{$list->{items}}) {
        say '* ' . encode_utf8($entry->{summary});
        # Call calendarlist.get
        my $calendar = $service->calendarList->get(
            body => {
                calendarId => $entry->{id},
            }
        )->execute({ auth_driver => $auth_driver });
        if (my $description = $calendar->{description}) {
            say '  ' . encode_utf8($description);
        }
    }
    $count++;
} until (!$page_token);

 view release on metacpan or  search on metacpan

lib/Google/OAuth.pm  view on Meta::CPAN

	}

sub emailkey {
	my $self = shift ;
	my $url = 'https://www.googleapis.com'
				.'/calendar/v3/users/me/calendarList' ;
	my $calinfo = $self->content( GET => $url ) ;
	my @owner = grep $_->{accessRole} eq 'owner', @{ $calinfo->{items} } ;
	return $self->{emailkey} = $owner[0]->{summary} ;
	}

lib/Google/OAuth.pm  view on Meta::CPAN

	}

my %scopes = (
	'm8.feeds' 
			=> 'https://www.google.com/m8/feeds',
	'calendar' 
			=> 'https://www.googleapis.com/auth/calendar',
	'calendar.readonly' 
			=> 'https://www.googleapis.com/auth/calendar.readonly',
	'drive.readonly' 
			=> 'https://www.googleapis.com/auth/drive.readonly',
	'drive' 
			=> 'https://www.googleapis.com/auth/drive',
        ) ;

lib/Google/OAuth.pm  view on Meta::CPAN

	}

sub scope {
	shift @_ if $_[0] eq __PACKAGE__ ;
	my $self = ref $_[0] eq __PACKAGE__? shift @_: undef ;
	my %args = map { $_ => 1 } ( @_, 'calendar.readonly' ) ;

	my $scope = join ' ', map { $scopes{$_} } keys %args ;
	return $scope unless $self ;

	$self->{scope} = $scope ;

lib/Google/OAuth.pm  view on Meta::CPAN

  ## eg $users[0] = 'perlmonster@gmail.com'
  $token = Google::OAuth->token( $users[0] ) ;

  ## Get Google Calendar data for this user
  $calobject = $token->content( GET => 'https://www.googleapis.com'
		.'/calendar/v3/users/me/calendarList' 
		) ;

  ## Insert a calendar event
  %event = ( ... ) ;  ## See Google documentation
  $url = sprintf 'https://www.googleapis.com'
		.'/calendar/v3/calendars/%s/events', $token->{emailkey} ;
  $token->content( POST => $url, 
		Google::OAuth::CGI->new( \%event )->query_string ) ;


=head1 DESCRIPTION

lib/Google/OAuth.pm  view on Meta::CPAN

Google::OAuth provides the capability to utilize the Google App's published 
API.  The link below (to Google's Calendar reference) demonstrates their
API in the form of HTTP REST requests.  This API is consistent with the 
arguments of a Google::OAuth token's methods.

  https://developers.google.com/google-apps/calendar/v3/reference/

Based on the documentation, the integration process looks deceptively easy.  
Google::OAuth takes the same approach by providing a framework that also 
looks deceptively easy.  Notwithstanding, this package includes the tools 
to get you set up and running.

lib/Google/OAuth.pm  view on Meta::CPAN

=head1 CREATING TOKENS

Most likely, your API tests will fail.  By default Google's tokens do not 
allow data access without explicitly defining scope. The token created during
installation is only capable of reading your calendar data.  For additional 
access, you'll need to generate a new token.

As described above, this process consists of 3 phases:

=over 8

lib/Google/OAuth.pm  view on Meta::CPAN

Most of this package's methods operate on C<Google::OAuth> tokens.  Since
these requests are more generic, and independent of any token, the token
request method uses a more general superclass, C<Google::OAuth::Client>.

  print Google::OAuth::Client->new->scope(
    		'calendar.readonly' )->token_request ;

The token_request method is detailed below.  There are numerous internal 
definitions described within the method.  Based on my experience, these 
default values are sufficient.  However, the default values can be 
overridden using arguments passed to the constructor.

lib/Google/OAuth.pm  view on Meta::CPAN

=over 8

=item I<m8.feeds>

=item I<calendar>

=item I<calendar.readonly>

=item I<drive.readonly>

=item I<drive>

lib/Google/OAuth.pm  view on Meta::CPAN

          'requested' => 1366389672,
          'error' => 'Invalid Grant'
        };

Another problem may occur if the token has insufficient privileges to 
access calendar data:

  $token = bless( {
                 'refresh_token' => '1/1v3Tvzj31e5M',
                 'expires_in' => '3600',
                 'requested' => 1366390047,

lib/Google/OAuth.pm  view on Meta::CPAN

  $token = $token->token if $token->expired ;

  ## Get Google Calendar data for this users
  $calobject = $token->content( GET => 'https://www.googleapis.com'
		.'/calendar/v3/users/me/calendarList' ) ;

Persistent objects in L<NoSQL::PL2SQL> can be either volatile or non-volatile.
Volatile objects cache write operations until the object is destroyed, and 
therefore must be explicitly destroyed.  As mentioned above, the 
C<grant_code()> method returns a volatile object.  As a convenience, the

lib/Google/OAuth.pm  view on Meta::CPAN

  $token->token if $token->expired ;

  ## Get Google Calendar data for this users
  $calobject = $token->content( GET => 'https://www.googleapis.com'.
		'/calendar/v3/users/me/calendarList' ) ;

  ## Somewhere before exiting
  undef $token ;

lib/Google/OAuth.pm  view on Meta::CPAN

=over 8

=item  http://developers.google.com/

=item  http://www.tqis.com/eloquency/googlecalendar.htm

=back 8

There is a page on my developer site to discuss Google::OAuth

 view release on metacpan or  search on metacpan

t/proto/wkt/copies/duration.proto  view on Meta::CPAN

option java_multiple_files = true;
option objc_class_prefix = "GPB";

// A Duration represents a signed, fixed-length span of time represented
// as a count of seconds and fractions of seconds at nanosecond
// resolution. It is independent of any calendar and concepts like "day"
// or "month". It is related to Timestamp in that the difference between
// two Timestamp values is a Duration and it can be added or subtracted
// from a Timestamp. Range is approximately +-10,000 years.
//
// # Examples

 view release on metacpan or  search on metacpan

lib/Greek.pm  view on Meta::CPAN

    |  UTF-8   |  Latin-1  |                     |
    +----------+-----------+---------------------+
    | UTF8     |            Not UTF8             |
    | Flagged  |            Flagged              |
    +--------------------------------------------+
    http://perl-users.jp/articles/advent-calendar/2010/casual/4

  Confusion of Perl string model is made from double meanings of
  "Binary string."
  Meanings of "Binary string"
  1. Non-Text string

 view release on metacpan or  search on metacpan

public/css/bootstrap.min.css  view on Meta::CPAN

 * Bootstrap v3.0.3 (http://getbootstrap.com)
 * Copyright 2013 Twitter, Inc.
 * Licensed under http://www.apache.org/licenses/LICENSE-2.0
 */

/*! normalize.css v2.1.3 | MIT License | git.io/normalize */article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block}audio,canvas,video{display:inline-block}audio:not([controls]){display:none;height:0}[hidde...

 view release on metacpan or  search on metacpan

Gnome/pkg.defs  view on Meta::CPAN

(define-enum GtkClockType
   (increasing GTK_CLOCK_INCREASING)
   (decreasing GTK_CLOCK_DECREASING)
   (realtime GTK_CLOCK_REALTIME))

; enumerations from "./gtkcalendar.h"

; now in Gtk

;(define-enum GtkCalendarDisplayOptions
;   (show-heading GTK_CALENDAR_SHOW_HEADING)

 view release on metacpan or  search on metacpan

lib/Gtk2/Ex/CalendarButton.pm  view on Meta::CPAN

sub new {
	my ($class, $date) = @_;
	my $self  = {};
	bless ($self, $class);
	$self->{button} = Gtk2::Button->new;
	$self->{calendar} = Gtk2::Calendar->new;
    $self->{date} = undef;
    if ($date) {
        $self->set_date($date);
    }
    else {
        $self->_update_button_label;
    }
	my $calwindow = $self->_create_calendar_window();
	$self->{button}->signal_connect('clicked' => 
		sub {
			my ($self, $event) = @_;
			$calwindow->set_position('mouse');
			$calwindow->show_all;

lib/Gtk2/Ex/CalendarButton.pm  view on Meta::CPAN

sub get_button {
    my ($self) = @_;
    return $self->{button};
}

sub get_calendar {
    my ($self) = @_;
    return $self->{calendar};
}

sub get_date {
    my ($self) = @_;
    return $self->{date};

lib/Gtk2/Ex/CalendarButton.pm  view on Meta::CPAN

sub set_date {
    my ($self, $date) = @_;
    $self->{date} = $date;
    my ($year, $month, $day) = @$date;
    my $cal = $self->{calendar};
    $cal->select_month($month, $year);
    $cal->select_day($day);
    $self->_update_button_label;
}

sub _update_button_label {
    my ($self) = @_;
	my ($year, $month, $day) = $self->{calendar}->get_date;
	$self->{date} = [$year, $month, $day];
	$month = _month()->[$month];
	$self->{button}->set_label("$month $day\, $year"); 
	&{$self->{'date-changed'}}($self) if $self->{'date-changed'};
}

sub _create_calendar_window {
    my ($self) = @_;
	my $vbox = Gtk2::VBox->new;
	my $ok = Gtk2::Button->new_from_stock('gtk-ok');
	my $cancel= Gtk2::Button->new_from_stock('gtk-cancel');
	my $hbox = Gtk2::HBox->new;
	$hbox->pack_start($ok, TRUE, TRUE, 0);
	$hbox->pack_start($cancel, TRUE, TRUE, 0);
	$vbox->pack_start($self->{calendar}, TRUE, TRUE, 0);
	$vbox->pack_start($hbox, TRUE, TRUE, 0);
	my $calwindow = Gtk2::Window->new('popup');
	$calwindow->add($vbox);
    $ok->signal_connect('clicked' => 
		sub {

lib/Gtk2/Ex/CalendarButton.pm  view on Meta::CPAN

=head1 FUNCTIONS

=head2 get_button

=head2 get_calendar

=head2 get_date

=head2 set_date

 view release on metacpan or  search on metacpan

lib/Gtk2/Ex/DBITableFilter/FilterWidget.pm  view on Meta::CPAN

	
	my $choices = ['before', 'after'];
	my $joiner  = [ '', 'and', 'or'];
	
	my $datelabel1 = Gtk2::Label->new;
	my $datelabelbox1 = _calendar_popup($datelabel1, $date1);
	my $combobox1 = Gtk2::ComboBox->new_text;	
	$combobox1->append_text($choices->[0]);
	$combobox1->append_text($choices->[1]);
	my $index1 = 1;
	if ($command1) {

lib/Gtk2/Ex/DBITableFilter/FilterWidget.pm  view on Meta::CPAN

		$index1 = { map { $_ => $i++ } @$choices }->{$command1};
	}
	$combobox1->set_active($index1);
	
	my $datelabel2 = Gtk2::Label->new;
	my $datelabelbox2 = _calendar_popup($datelabel2, $date2);
	my $combobox2 = Gtk2::ComboBox->new_text;	
	$combobox2->append_text($choices->[0]);
	$combobox2->append_text($choices->[1]);
	my $index2 = 0;
	if ($command1) {

lib/Gtk2/Ex/DBITableFilter/FilterWidget.pm  view on Meta::CPAN

		$button = $button->get_parent;
	} until ($button->isa ('Gtk2::Button'));
	return $button;
}

sub _calendar_popup {
	my ($datelabel, $datestr) = @_;
	my $datelabelbox = _add_button_press(_add_arrow($datelabel));
	my $datepopup = Gtk2::Ex::PopupWindow->new($datelabelbox);
	my $date = Gtk2::Calendar->new;
	if ($datestr) {

 view release on metacpan or  search on metacpan

lib/Gtk2/Ex/Datasheet/DBI.pm  view on Meta::CPAN

    my ( $cell ) = @_;
    
    my $popup = Gtk2::Window->new ('popup');
    my $vbox = Gtk2::VBox->new( 0, 0 );
    
    my $calendar = Gtk2::Calendar->new();
    
    $calendar->modify_font( Gtk2::Pango::FontDescription->from_string( "Arial " . $cell->get( "font" ) ) );
    
    my $hbox = Gtk2::HBox->new( 0, 0 );
    
    my $today = Gtk2::Button->new('Today');
    my $none = Gtk2::Button->new('None');

lib/Gtk2/Ex/Datasheet/DBI.pm  view on Meta::CPAN

    $none->signal_connect( clicked => sub {
        $cell->{ _none_clicked_callback }->( @_ )
            if ( exists( $cell->{ _none_clicked_callback } ) );
    } );
    
    $calendar->signal_connect( day_selected_double_click => sub {
        $cell->{ _day_selected_double_click_callback }->( @_ )
            if ( exists( $cell->{ _day_selected_double_click_callback } ) );
    } );
    
    $calendar->signal_connect( month_changed => sub {
        $cell->{ _month_changed }->( @_ )
            if ( exists( $cell->{ _month_changed } ) );
    } );
    
    $hbox->pack_start( $today, 1, 1, 0 );
    $hbox->pack_start( $none, 1, 1, 0 );
    
    $vbox->pack_start( $calendar, 1, 1, 0 );
    $vbox->pack_start( $hbox, 0, 0, 0 );
    
    # Find out if the click happended outside of our window.  If so, hide it.
    # Largely copied from Planner (the former MrProject).
    

lib/Gtk2/Ex/Datasheet/DBI.pm  view on Meta::CPAN

    } );
    
    $popup->add( $vbox );
    
    $cell->{ _popup } = $popup;
    $cell->{ _calendar } = $calendar;
}

sub START_EDITING {
    
    my ( $cell, $event, $view, $path, $background_area, $cell_area, $flags ) = @_;
    
    my $popup = $cell -> { _popup };
    my $calendar = $cell->{ _calendar };
    
    # Specify the callbacks.  Will be called by the signal handlers set up in
    # INIT_INSTANCE.
    $cell->{ _today_clicked_callback } = sub {
        

lib/Gtk2/Ex/Datasheet/DBI.pm  view on Meta::CPAN

        
    };
    
    $cell->{ _day_selected_double_click_callback } = sub {
        
        my ( $calendar ) = @_;
        my ( $year, $month, $day ) = $calendar->get_date();
        
        $cell->signal_emit( edited => $path, join( "-", $cell -> add_padding( $year, ++$month, $day ) ) );
        $cell->hide_popup();
        
    };
    
    $cell->{ _month_changed } = sub {
        
        my ( $calendar ) = @_;
        
        my ( $selected_year, $selected_month ) = $calendar->get_date();
        my ( $current_year, $current_month, $current_day ) = $cell->get_today();
        
        if ( $selected_year == $current_year && ++$selected_month == $current_month ) {
            $calendar->mark_day( $current_day );
        }
        else {
            $calendar->unmark_day( $current_day );
        }
        
    };
    
    my ( $year, $month, $day ) = $cell->get_date();
    
    $calendar->select_month( $month - 1, $year );
    $calendar->select_day( $day );
    
    # Necessary to get the correct allocation of the popup.
    $popup->move( -500, -500 );
    $popup->show_all();
    

 view release on metacpan or  search on metacpan

lib/Gtk2/Ex/DateRange.pm  view on Meta::CPAN

	my $i = 0;	my $commandhash = 	{ map { $_ => $i++ } @$commandchoices };
	   $i = 0;	my $joinerhash  = 	{ map { $_ => $i++ } @$joinerchoices  };
	_model_error_check($commandhash, $joinerhash, $model);
	
	$self->{commandcombo1}->set_active($commandhash->{$model->[0]});
	_set_calendar_date($self->{calendar1}, $model->[1]);
	_update_date_label($self->{calendar1}, $self->{datelabel1});
	if ($#{@$model} == 1) {
		$self->{freezesignals} = TRUE;
		$self->{joinercombo}->set_active(0);
		$self->{commandcombo2}->set_active(-1);
		$self->{datelabel2}->set_label('(select a date)');

lib/Gtk2/Ex/DateRange.pm  view on Meta::CPAN

	}
	
	$self->{joinercombo}->set_active($joinerhash->{$model->[2]});
	
	$self->{commandcombo2}->set_active($commandhash->{$model->[3]});
	_set_calendar_date($self->{calendar2}, $model->[4]);
	_update_date_label($self->{calendar2}, $self->{datelabel2});
	
	$self->{freezesignals} = FALSE;
	&{ $self->{signals}->{'changed'} } if $self->{signals}->{'changed'};		
}

lib/Gtk2/Ex/DateRange.pm  view on Meta::CPAN

	my $commandchoices = ['before', 'after', 'on or after', 'on or before'];
	my $joinerchoices  = ['', 'and', 'or'];
	
	my $commandcombo1 = Gtk2::ComboBox->new_text;	
	my $datelabel1 = Gtk2::Label->new('(select a date)');
	my $calendar1 = Gtk2::Calendar->new;
	my $datelabelbox1 = $self->_calendar_popup($datelabel1, $calendar1, 1);
	foreach my $x (@$commandchoices) {
		$commandcombo1->append_text($x);
	}
	$commandcombo1->signal_connect ( 'changed' =>
		sub {

lib/Gtk2/Ex/DateRange.pm  view on Meta::CPAN

		}
	);

	my $commandcombo2 = Gtk2::ComboBox->new_text;	
	my $datelabel2 = Gtk2::Label->new('(select a date)');
	my $calendar2 = Gtk2::Calendar->new;
	my $datelabelbox2 = $self->_calendar_popup($datelabel2, $calendar2, 4);
	foreach my $x (@$commandchoices) {
		$commandcombo2->append_text($x);
	}
	$commandcombo2->signal_connect ( 'changed' =>
		sub {

lib/Gtk2/Ex/DateRange.pm  view on Meta::CPAN

	$self->{commandchoices}= $commandchoices;
	$self->{joinerchoices} = $joinerchoices;
	
	$self->{commandcombo1} = $commandcombo1;
	$self->{datelabel1}    = $datelabel1;
	$self->{calendar1}     = $calendar1;
	$self->{datelabelbox1} = $datelabelbox1;

	$self->{commandcombo2} = $commandcombo2;
	$self->{datelabel2}    = $datelabel2;
	$self->{calendar2}     = $calendar2;
	$self->{datelabelbox2} = $datelabelbox2;

	$self->{joinercombo}   = $joinercombo;	

	$self->{datelabelbox1}->set_sensitive(FALSE);

lib/Gtk2/Ex/DateRange.pm  view on Meta::CPAN

	$table->attach($datelabelbox2,1,2,1,2, 'expand', 'expand', 0, 0);
	return $table;	
}

sub _get_date_string {
	my ($calendar) = @_;
	my ($year, $month, $day) = $calendar->get_date();
	$month += 1;
	$day   = "0$day" if $day < 10;
	$month = "0$month" if $month < 10;
	return "$year-$month-$day";
}

sub _set_calendar_date {
	my ($calendar, $datestr) = @_;
	my ($year, $month, $day) = split '-', $datestr;
	$calendar->select_month($month-1, $year);
	$calendar->select_day($day);	
}

sub _update_date_label {
	my ($calendar, $datelabel) = @_;
	my ($year, $month, $day) = $calendar->get_date();
	$month = _month()->[$month];
	my $date_str = "$month $day \, $year";
	$datelabel->set_text($date_str);	
}

sub _calendar_popup {
	my ($self, $datelabel, $calendar, $num) = @_;
	my $datelabelbox = _add_button_press(_add_arrow($datelabel));
	my $datepopup = Gtk2::Ex::PopupWindow->new($datelabel);
	my $okbutton = Gtk2::Button->new_from_stock('gtk-ok');
	$okbutton->signal_connect ('button-release-event' => 
		sub {
			_update_date_label($calendar, $datelabel);
			$self->{model}->[$num] = _get_date_string($calendar);
			$self->{joinercombo}->set_sensitive(TRUE) if ($num == 1);
			$datepopup->hide;
			&{ $self->{signals}->{'changed'} } 
				if $self->{signals}->{'changed'} and !$self->{freezesignals};
		}
	);
	$calendar->signal_connect ( 'day-selected' =>
		sub {
			_update_date_label($calendar, $datelabel);
			$self->{model}->[$num] = _get_date_string($calendar);
			$self->{joinercombo}->set_sensitive(TRUE) if ($num == 1);
		}
	);	
	my $hbox = Gtk2::HBox->new (TRUE, 0);
	$hbox->pack_start ($okbutton, TRUE, TRUE, 0); 	
	my $vbox = Gtk2::VBox->new (FALSE, 0);
	$vbox->pack_start ($calendar, TRUE, TRUE, 0); 
	$vbox->pack_start ($hbox, FALSE, FALSE, 0); 	
	$datepopup->{window}->add($vbox);
	$datelabelbox->signal_connect ('button-release-event' => 
		sub { 
			$datepopup->show;

 view release on metacpan or  search on metacpan

lib/Gtk2/Ex/ICal/Recur.pm  view on Meta::CPAN

__END__

=head1 NAME

Gtk2::Ex::ICal::Recur - A widget for scheduling a recurring 
set of 'events' (events in the calendar sense). Like a meeting
appointment for example, on all mondays and thursdays for the next 3
months. Kinda like Evolution or Outlook meeting schedule.

=head1 DESCRIPTION

 view release on metacpan or  search on metacpan

examples/calendar.pl  view on Meta::CPAN

# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
#
# $Id$
#

# this was originally gtk-2.2.1/examples/calendar/calendar.c
# ported to gtk2-perl (and perl-ized) by rm

use strict;
use Gtk2;

examples/calendar.pl  view on Meta::CPAN

use constant DEF_PAD => 10;
use constant DEF_PAD_SMALL => 5;

use constant TM_YEAR_BASE => 1900;

sub calendar_select_font
{
	my $calendar = shift;

	my $fsd = Gtk2::FontSelectionDialog->new ('Font Selection Dialog');
	$fsd->set_position('mouse');

	$fsd->set_font_name ($calendar->get_style->font_desc->to_string);

	$fsd->signal_connect ('response' => sub {
		my (undef, $response) = @_;
		if ($response eq 'ok') {
			my $font_name = $fsd->get_font_name;
			return unless $font_name;
			$calendar->modify_font
				(Gtk2::Pango::FontDescription->from_string
				 	($font_name));
		}
		$fsd->destroy;
	});

	$fsd->show;
}


sub calendar_set_signal_strings
{
	my $sig_ref = shift;
	my $new_sig = shift;

	$sig_ref->{prev2}->set_text($sig_ref->{prev}->get_text);
	$sig_ref->{prev}->set_text($sig_ref->{curr}->get_text);
	$sig_ref->{curr}->set_text($new_sig);
}

sub create_calendar
{
	my $window;
	my $vbox;
	my $vbox2;
	my $vbox3;
	my $hbox;
	my $hbbox;
	my $calendar;
	my @toggles;
	my $button;
	my $frame;
	my $separator;
	my $label;

examples/calendar.pl  view on Meta::CPAN

	$hbbox->set_spacing(5);

	# Calendar widget
	$frame = Gtk2::Frame->new('Calendar');
	$hbbox->pack_start($frame, FALSE, TRUE, DEF_PAD);
	$calendar = Gtk2::Calendar->new;

	$calendar->mark_day(19);
	$frame->add($calendar);
	$calendar->display_options([]);

	$calendar->signal_connect( 'month_changed' => sub {
			my ($year, $month, $day) = $calendar->get_date; 
			calendar_set_signal_strings($_[1], 'month changed: '.
				sprintf("%02d/%d/%d", $month+1, $day, $year) );
		}, \%signals );
	$calendar->signal_connect( 'day_selected' => sub {
			my ($year, $month, $day) = $calendar->get_date; 
			calendar_set_signal_strings($_[1], 'day selected: '.
				sprintf("%02d/%d/%d", $month+1, $day, $year) );
		}, \%signals );
	$calendar->signal_connect( 'day_selected_double_click' => sub {
			my ($year, $month, $day) = $calendar->get_date; 
			calendar_set_signal_strings($_[1], 
				'day selected double click: '.
				sprintf("%02d/%d/%d", $month+1, $day, $year) );
		}, \%signals );
	$calendar->signal_connect( 'prev_month' => sub {
			my ($year, $month, $day) = $calendar->get_date; 
			calendar_set_signal_strings($_[1], 'prev month: '.
				sprintf("%02d/%d/%d", $month+1, $day, $year) );
		}, \%signals );
	$calendar->signal_connect( 'next_month' => sub {
			my ($year, $month, $day) = $calendar->get_date; 
			calendar_set_signal_strings($_[1], 'next month: '.
				sprintf("%02d/%d/%d", $month+1, $day, $year) );
		}, \%signals );
	$calendar->signal_connect( 'prev_year' => sub {
			my ($year, $month, $day) = $calendar->get_date; 
			calendar_set_signal_strings($_[1], 'prev year: '.
				sprintf("%02d/%d/%d", $month+1, $day, $year) );
		}, \%signals );
	$calendar->signal_connect( 'next_year' => sub {
			my ($year, $month, $day) = $calendar->get_date; 
			calendar_set_signal_strings($_[1], 'next year: '.
				sprintf("%02d/%d/%d", $month+1, $day, $year) );
		}, \%signals );

	$separator = Gtk2::VSeparator->new;
	$hbox->pack_start($separator, FALSE, TRUE, 0);

examples/calendar.pl  view on Meta::CPAN

					if( $toggles[$j]->get_active )
					{
						push @$opts, $flags[$j];
					}
				}
				$calendar->display_options($opts);
			});
		$vbox3->pack_start($toggles[$i], TRUE, TRUE, 0);
	}
	foreach (@flags)
	{

examples/calendar.pl  view on Meta::CPAN

	}
	
	# Build the right font-button
	$button = Gtk2::Button->new('Font...');
	$button->signal_connect( 'clicked' => sub {
			calendar_select_font($_[1]);
		}, $calendar );
	$vbox2->pack_start($button, FALSE, FALSE, 0);

	#
	# Build the Signal-event part.
	#

examples/calendar.pl  view on Meta::CPAN

}


Gtk2->init;

create_calendar;

Gtk2->main;

exit 0;

 view release on metacpan or  search on metacpan

lib/Gtk3/Ex/DBI/Datasheet.pm  view on Meta::CPAN

    my ( $cell ) = @_;
    
    my $popup = Gtk3::Window->new ('popup');
    my $vbox = Gtk3::VBox->new( 0, 0 );
    
    my $calendar = Gtk3::Calendar->new();
    
    #$calendar->modify_font( Gtk3::Pango::FontDescription->from_string( "Arial " . $cell->get( "font" ) ) );
    $calendar->modify_font( Pango::FontDescription::from_string( "Arial " . $cell->get( "font" ) ) );
    
    my $hbox = Gtk3::HBox->new( 0, 0 );
    
    my $today = Gtk3::Button->new('Today');
    my $none = Gtk3::Button->new('None');

lib/Gtk3/Ex/DBI/Datasheet.pm  view on Meta::CPAN

    $none->signal_connect( clicked => sub {
        $cell->{ _none_clicked_callback }->( @_ )
            if ( exists( $cell->{ _none_clicked_callback } ) );
    } );
    
    $calendar->signal_connect( day_selected_double_click => sub {
        $cell->{ _day_selected_double_click_callback }->( @_ )
            if ( exists( $cell->{ _day_selected_double_click_callback } ) );
    } );
    
    $calendar->signal_connect( month_changed => sub {
        $cell->{ _month_changed }->( @_ )
            if ( exists( $cell->{ _month_changed } ) );
    } );
    
    $hbox->pack_start( $today, 1, 1, 0 );
    $hbox->pack_start( $none, 1, 1, 0 );
    
    $vbox->pack_start( $calendar, 1, 1, 0 );
    $vbox->pack_start( $hbox, 0, 0, 0 );
    
    # Find out if the click happended outside of our window.  If so, hide it.
    # Largely copied from Planner (the former MrProject).
    

lib/Gtk3/Ex/DBI/Datasheet.pm  view on Meta::CPAN

    } );
    
    $popup->add( $vbox );
    
    $cell->{ _popup } = $popup;
    $cell->{ _calendar } = $calendar;
}

sub START_EDITING {
    
    my ( $cell, $event, $view, $path, $background_area, $cell_area, $flags ) = @_;
    
    my $popup = $cell -> { _popup };
    my $calendar = $cell->{ _calendar };
    
    # Specify the callbacks.  Will be called by the signal handlers set up in
    # INIT_INSTANCE.
    $cell->{ _today_clicked_callback } = sub {
        

lib/Gtk3/Ex/DBI/Datasheet.pm  view on Meta::CPAN

        
    };
    
    $cell->{ _day_selected_double_click_callback } = sub {
        
        my ( $calendar ) = @_;
        my ( $year, $month, $day ) = $calendar->get_date();
        
        $cell->signal_emit( edited => $path, join( "-", $cell -> add_padding( $year, ++$month, $day ) ) );
        $cell->hide_popup();
        
    };
    
    $cell->{ _month_changed } = sub {
        
        my ( $calendar ) = @_;
        
        my ( $selected_year, $selected_month ) = $calendar->get_date();
        my ( $current_year, $current_month, $current_day ) = $cell->get_today();
        
        if ( $selected_year == $current_year && ++$selected_month == $current_month ) {
            $calendar->mark_day( $current_day );
        }
        else {
            $calendar->unmark_day( $current_day );
        }
        
    };
    
    my ( $year, $month, $day ) = $cell->get_date();
    
    $calendar->select_month( $month - 1, $year );
    $calendar->select_day( $day );
    
    # Necessary to get the correct allocation of the popup.
    $popup->move( -500, -500 );
    $popup->show_all();
    

 view release on metacpan or  search on metacpan

public/js/ui/jquery-ui-1.8.21.custom.min.js  view on Meta::CPAN

* Copyright (c) 2012 AUTHORS.txt; Licensed MIT, GPL */
(function(a,b){function e(){return++c}function f(){return++d}var c=0,d=0;a.widget("ui.tabs",{options:{add:null,ajaxOptions:null,cache:!1,cookie:null,collapsible:!1,disable:null,disabled:[],enable:null,event:"click",fx:null,idPrefix:"ui-tabs-",load:nu...
* https://github.com/jquery/jquery-ui
* Includes: jquery.ui.datepicker.js
* Copyright (c) 2012 AUTHORS.txt; Licensed MIT, GPL */
(function($,undefined){function Datepicker(){this.debug=!1,this._curInst=null,this._keyEvent=!1,this._disabledInputs=[],this._datepickerShowing=!1,this._inDialog=!1,this._mainDivId="ui-datepicker-div",this._inlineClass="ui-datepicker-inline",this._ap...
* https://github.com/jquery/jquery-ui
* Includes: jquery.ui.progressbar.js
* Copyright (c) 2012 AUTHORS.txt; Licensed MIT, GPL */
(function(a,b){a.widget("ui.progressbar",{options:{value:0,max:100},min:0,_create:function(){this.element.addClass("ui-progressbar ui-widget ui-widget-content ui-corner-all").attr({role:"progressbar","aria-valuemin":this.min,"aria-valuemax":this.opti...
* https://github.com/jquery/jquery-ui