view release on metacpan or  search on metacpan

t/patterns.txt  view on Meta::CPAN

1|2|3|4|5|6|7|8|8|6|11:doubtlessly|faithlessly|fruitlessly|thanklessly|
1|2|3|4|5|6|7|8|8|7:marionette|silhouette|
1|2|3|4|5|6|7|8|8|7|1:silhouettes|
1|2|3|4|5|6|7|8|8|7|11:silhouetted|
1|2|3|4|5|6|7|8|8|7|11|12:earsplitting|
1|2|3|4|5|6|7|8|9:Abernathy|Alpheratz|Americans|Apetalous|Aphrodite|Archibald|Ashmolean|Auschwitz|Baltimore|Berkowitz|Bialystok|Blackburn|Blomquist|Bolshevik|Bromfield|Brunhilde|Brunswick|Bucharest|Bundestag|Byronizes|Byzantium|Cambridge|Catholics|Ca...
1|2|3|4|5|6|7|8|9|1:discharged|discounted|dislocated|dismounted|dispatched|downplayed|duplicated|exhaustive|expansible|metabolism|monetarism|sandwiches|scoundrels|searchings|shipwrecks|signatures|simulators|slanderous|slaughters|spreadings|subdomains...
1|2|3|4|5|6|7|8|9|10:Andromache|Babylonize|Blackstone|Bridgetown|Buchenwald|Burlingame|Candlewick|Charleston|Copernicus|Culbertson|Cumberland|Ektachrome|Fauntleroy|Fitzgerald|Fleischman|Fulbrights|Gatlinburg|Gilbertson|Heraclitus|Hieronymus|Kenilwort...
1|2|3|4|5|6|7|8|9|10|1:discouraged|disgruntled|speculators|subnetworks|subtrahends|sympathizes|thunderbolt|
1|2|3|4|5|6|7|8|9|10|10:harmfulness|typicalness|uprightness|
1|2|3|4|5|6|7|8|9|10|10|12:Jacksonville|Raymondville|domestically|impersonally|methodically|

 view release on metacpan or  search on metacpan

inc/My/Module/Recommend.pm  view on Meta::CPAN

use Carp;
use My::Module::Recommend::Any qw{ __any };

my @optionals = (
    __any( 'Clipboard'		=> <<'EOD' ),
      This module is needed to exchange data with the system clipboard.
      If you do not intend to use the copy() or paste() methods, you do
      not need to install this module.
EOD
);

 view release on metacpan or  search on metacpan

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

cline clines cling clinged clinger clingers clingier clingiest clinging clings
clingstone clingstones clingy clinic clinical clinically clinician clinicians
clinicopathologic clinicopathological clinicopathologically clinics clink
clinked clinker clinkered clinkering clinkers clinking clinks clinometer
clinometers clinquant clinquants clintonia clintonias cliometric cliometrician
cliometricians cliometrics clip clipboard clipboards clipped clipper clippers
clipping clippings clips clipsheet clipsheets clipt clique cliqued cliques
cliquey cliquier cliquiest cliquing cliquish cliquishly cliquishness
cliquishnesses cliquy clit clitella clitellum clitic clitics clitoral
clitorectomies clitorectomy clitoric clitoridectomies clitoridectomy
clitorides clitoris clitorises clits clivers clivia clivias cloaca cloacae

 view release on metacpan or  search on metacpan

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

/usr/include/gtk-2.0/gtk/gtkcellrendererpixbuf.h
/usr/include/gtk-2.0/gtk/gtkcellrenderertext.h
/usr/include/gtk-2.0/gtk/gtkcellrenderertoggle.h
/usr/include/gtk-2.0/gtk/gtkcheckbutton.h
/usr/include/gtk-2.0/gtk/gtkcheckmenuitem.h
/usr/include/gtk-2.0/gtk/gtkclipboard.h
/usr/include/gtk-2.0/gtk/gtkclist.h
/usr/include/gtk-2.0/gtk/gtkcolorbutton.h
/usr/include/gtk-2.0/gtk/gtkcolorsel.h
/usr/include/gtk-2.0/gtk/gtkcolorseldialog.h
/usr/include/gtk-2.0/gtk/gtkcombo.h

 view release on metacpan or  search on metacpan

lib/Geo/Gpx.pm  view on Meta::CPAN

=item waypoints_clip( $name | $regex | LIST )

=item way_clip( )

Sends the coordinates of the waypoint(s) whose name is either C<$name> or matches C<$regex> to the clipboard (all points found are sent to the clipboard) and returns an array of points found. By default, the regex is case-sensitive; specify C<qr/(?i:...

Alternatively, an array of C<Geo::GXP::Points> can be provided. C<way_clip()> is a short-hand for this method (convenient when used interactively in the debugger).

This method is only supported on unix-based systems that have the C<xclip> utility installed (see DEPENDENCIES).

lib/Geo/Gpx.pm  view on Meta::CPAN

    for my $pt (@points_reversed) {
        croak 'way_clip() expects list of Geo::Gpx::Point objects' unless $pt->isa('Geo::Gpx::Point');
        my $coords = $pt->lat . ', ';
        $coords   .= $pt->lon;
        system("echo $coords | xclip -selection clipboard")
    }
    return @points
}

=over 4

 view release on metacpan or  search on metacpan

lib/Geo/TCX/Interactive.pm  view on Meta::CPAN

=over 4

=item way_clip( $name | $regex | LIST )

Sends the coordinates of waypoints whose name is either C<$name> or matches C<$regex> to the clipboard (all points found are sent to the clipboard). Returns an array of points found.

By default, the regex is case-sensitive; specify C<qr/(?i:...)/> to ignore case.

Alternatively, an array of C<Geo::GXP::Points> can be supplied such that we can call C<< $o->way_clip( $o->gpx->search_desc( qr/(?i:Sunset)/ ) >>.

lib/Geo/TCX/Interactive.pm  view on Meta::CPAN

    for my $pt (@points_reversed) {
        croak 'way_clip() expects list of Geo::Gpx::Point objects' unless $pt->isa('Geo::Gpx::Point');
        my $coords = $pt->lat . ', ';
        $coords   .= $pt->lon;
        system("echo $coords | xclip -selection clipboard")
    }
    return @points
}

=over 4

 view release on metacpan or  search on metacpan

lib/Getopt/Janus/Tk.pm  view on Meta::CPAN

      -label => "Open this directory",
      -command =>  sub { $self->open_directory($d) },
    );
    defined $f and $self->can_open_files and $mb->command(
      -label => "Copy this filespec", -command =>  sub {
        $mainwindow->clipboardClear;
        $mainwindow->clipboardAppend( '--', $f );
      },
    );
    $mb->pack;
  }

 view release on metacpan or  search on metacpan

xs/GnomeCanvasRichText.xs  view on Meta::CPAN

 */
#include "gnomecanvasperl.h"

MODULE = Gnome2::Canvas::RichText	PACKAGE = Gnome2::Canvas::RichText	PREFIX = gnome_canvas_rich_text_

##  void gnome_canvas_rich_text_cut_clipboard(GnomeCanvasRichText *text) 
void
gnome_canvas_rich_text_cut_clipboard (text)
	GnomeCanvasRichText *text

##  void gnome_canvas_rich_text_copy_clipboard(GnomeCanvasRichText *text) 
void
gnome_canvas_rich_text_copy_clipboard (text)
	GnomeCanvasRichText *text

##  void gnome_canvas_rich_text_paste_clipboard(GnomeCanvasRichText *text) 
void
gnome_canvas_rich_text_paste_clipboard (text)
	GnomeCanvasRichText *text

##  void gnome_canvas_rich_text_set_buffer(GnomeCanvasRichText *text, GtkTextBuffer *buffer) 
void
gnome_canvas_rich_text_set_buffer (text, buffer)

 view release on metacpan or  search on metacpan

t/VteTerminal.t  view on Meta::CPAN

                               undef,
                               0, 0, 0), $number);

$terminal -> feed("BLA!\n");
$terminal -> feed_child("BOH!\n");
$terminal -> copy_clipboard();
$terminal -> paste_clipboard();
$terminal -> copy_primary();
$terminal -> paste_primary();
$terminal -> set_size(81, 25);

SKIP: {

 view release on metacpan or  search on metacpan

docs/assets/stylesheets/font-awesome/_icons.scss  view on Meta::CPAN

.#{$fa-css-prefix}-flash:before,
.#{$fa-css-prefix}-bolt:before { content: $fa-var-bolt; }
.#{$fa-css-prefix}-sitemap:before { content: $fa-var-sitemap; }
.#{$fa-css-prefix}-umbrella:before { content: $fa-var-umbrella; }
.#{$fa-css-prefix}-paste:before,
.#{$fa-css-prefix}-clipboard:before { content: $fa-var-clipboard; }
.#{$fa-css-prefix}-lightbulb-o:before { content: $fa-var-lightbulb-o; }
.#{$fa-css-prefix}-exchange:before { content: $fa-var-exchange; }
.#{$fa-css-prefix}-cloud-download:before { content: $fa-var-cloud-download; }
.#{$fa-css-prefix}-cloud-upload:before { content: $fa-var-cloud-upload; }
.#{$fa-css-prefix}-user-md:before { content: $fa-var-user-md; }

 view release on metacpan or  search on metacpan

Gtk/objects.pod  view on Meta::CPAN

=item * undef B<activate> (Gtk::Editable)

=item * undef B<changed> (Gtk::Editable)

=item * undef B<copy-clipboard> (Gtk::Editable)

=item * undef B<cut-clipboard> (Gtk::Editable)

=item * undef B<delete-text> (Gtk::Editable, integer, integer)

=item * undef B<insert-text> (Gtk::Editable, string, integer, gpointer)

Gtk/objects.pod  view on Meta::CPAN

=item * undef B<move-to-row> (Gtk::Editable, integer)

=item * undef B<move-word> (Gtk::Editable, integer)

=item * undef B<paste-clipboard> (Gtk::Editable)

=item * undef B<set-editable> (Gtk::Editable, bool)

=back

 view release on metacpan or  search on metacpan

GtkEditable.xs  view on Meta::CPAN

	Gtk::Editable editable
	int           start
	int           end

void
gtk_editable_cut_clipboard (editable, time)
	Gtk::Editable editable
	int           time

void
gtk_editable_copy_clipboard (editable, time)
	Gtk::Editable editable
	int           time

void
gtk_editable_paste_clipboard (editable, time)
	Gtk::Editable editable
	int           time

void
gtk_editable_claim_selection (editable, claim, time)

 view release on metacpan or  search on metacpan

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

=over 4

=item C<< Gtk2::Ex::EntryBits::select_region_noclip ($entry, $start, $end) >>

Select text from C<$start> to C<$end> like C<< $entry->select_region >>, but
don't put it on the clipboard.  This is a good way to let the user type over
previous text, without upsetting any cut and paste in progress.

This is implemented with a nasty hack temporarily pretending C<$entry> is
unrealized.

 view release on metacpan or  search on metacpan

examples/clipboard.pl  view on Meta::CPAN

#!/usr/bin/perl -w

#----------------------------------------------------------------------
#  clipboard.pl
#
#  A simple example of Gtk2/GladeXML Clipboard
#
#  Copyright (C) 2004 Fabrice Duballet
#

examples/clipboard.pl  view on Meta::CPAN

use Gtk2 '-init'; # auto-initializes Gtk2
use Gtk2::GladeXML;

# Load the UI from the Glade-2 file
my $glade = Gtk2::GladeXML->new("clipboard.glade");

# Connect the signal handlers
$glade->signal_autoconnect_from_package('main');

# Cache controls in perl-variables
my $editor = $glade->get_widget('textview1');
my $buffer = $editor->get_buffer();

my $clipboard = $editor->get_clipboard();

my $clipboard_buffer = $glade->get_widget('textview2')->get_buffer();

my $oldtext = '';

# Start it up
Gtk2->main;

examples/clipboard.pl  view on Meta::CPAN

# Handle cut
sub on_cut1_activate
{
    $buffer->cut_clipboard($clipboard, 1);
}

# Handle copy
sub on_copy1_activate
{
    $buffer->copy_clipboard($clipboard);
}

# Handle paste
sub on_paste1_activate
{  
    $buffer->paste_clipboard($clipboard, undef, 1);
}

# Handle expose-event
# Refresh textview buffer if the clipboard has a new content
sub on_textview2_expose_event
{
    my $newtext = $clipboard->wait_for_text();
    if ($newtext ne $oldtext)
    {
        $clipboard_buffer->set_text($newtext);
        $oldtext = $newtext;
    }
}

# Handles window-manager-quit: shuts down gtk2 lib

 view release on metacpan or  search on metacpan

xs/WebKitWebView.xs  view on Meta::CPAN

webkit_web_view_execute_script (web_view, script)
		WebKitWebView *web_view
		const gchar *script

gboolean
webkit_web_view_can_cut_clipboard (web_view)
		WebKitWebView *web_view

gboolean
webkit_web_view_can_copy_clipboard (web_view)
		WebKitWebView *web_view

gboolean
webkit_web_view_can_paste_clipboard (web_view)
		WebKitWebView *web_view

void
webkit_web_view_cut_clipboard (web_view)
		WebKitWebView *web_view

void
webkit_web_view_copy_clipboard (web_view)
		WebKitWebView *web_view

void
webkit_web_view_paste_clipboard (web_view)
		WebKitWebView *web_view

void
webkit_web_view_delete_selection (web_view)
		WebKitWebView *web_view

 view release on metacpan or  search on metacpan

ChangeLog.pre-git  view on Meta::CPAN

	* xs/GtkContainer.xs: Wrap gtk_container_get_focus_child.  Allow
	undef for the focus child argument to
	gtk_container_set_focus_child.

	* t/GtkClipboard.t
	* xs/GtkClipboard.xs: Wrap gtk_clipboard_request_uris,
	gtk_clipboard_wait_for_uris, and
	gtk_clipboard_wait_is_uris_available.  Also fix the rich text
	tests.

	* t/GtkCalendar.t
	* xs/GtkCalendar.xs: Wrap gtk_calendar_set_detail_func.

ChangeLog.pre-git  view on Meta::CPAN

	* MANIFEST, maps-2.10, xs_files-2.10, t/GtkCellRendererSpin.t,
	xs/GtkCellRendererSpin.xs: Add support for GtkCellRendererSpin.

	* t/GtkClipboard.t, xs/GtkClipboard.xs: Bind and test
	gtk_clipboard_request_rich_text, gtk_clipboard_wait_for_rich_text,
	gtk_clipboard_wait_is_rich_text_available.

	* t/GtkComboBox.t, xs/GtkComboBox.xs: Bind and test
	gtk_combo_box_set_title, gtk_combo_box_get_title.

	* t/GtkDnd.t, xs/GtkDnd.xs: Bind and test

ChangeLog.pre-git  view on Meta::CPAN

	* t/GtkDialog.t, xs/GtkDialog.xs: Bind and test
	gtk_alternative_dialog_button_order.

	* t/GtkClipboard.t, t/GtkSelection.t, xs/GtkClipboard.xs,
	xs/GtkSelection.xs: Bind and test gtk_clipboard_set_image,
	gtk_clipboard_wait_for_image,
	gtk_clipboard_wait_is_image_available,
	gtk_clipboard_request_image, gtk_clipboard_set_can_store,
	gtk_clipboard_store, gtk_clipboard_wait_is_target_available,
	gtk_target_list_add_text_targets,
	gtk_target_list_add_image_targets,
	gtk_target_list_add_uri_targets, gtk_selection_data_set_pixbuf,
	gtk_selection_data_get_pixbuf, gtk_selection_data_set_uris,
	gtk_selection_data_get_uris, and

ChangeLog.pre-git  view on Meta::CPAN

	GObject's.

	* t/GdkDisplay.t, xs/GdkDisplay.xs: Bind and test
	gdk_display_supports_selection_notification,
	gdk_display_request_selection_notification,
	gdk_display_supports_clipboard_persistence, and
	gdk_display_store_clipboard.

	* t/GdkDnd.t, xs/GdkDnd.xs: Bind and test gdk_drag_drop_succeeded.

	* xs/GdkDrawable.xs: Add a comment about gdk_draw_trapezoids and
	why we don't bind it.

ChangeLog.pre-git  view on Meta::CPAN

	* t/GtkCellView.t, xs/GtkCellView.xs: Bind and test
	gtk_cell_view_set_value, gtk_cell_view_set_values,
	gtk_cell_view_get_size_of_row.

	* xs/GtkClipboard.xs: Don't use the _noinc typemaps with
	gtk_clipboard_get and gtk_clipboard_get_for_display since we don't
	actually own the returned clipboards.

	* t/GtkEntryCompletion.t, xs/GtkEntryCompletion.xs: Bind and test
	gtk_entry_completion_get_text_column,
	gtk_entry_completion_insert_prefix,
	gtk_entry_completion_set_inline_completion,

ChangeLog.pre-git  view on Meta::CPAN

2004/01/12 09:49 (-0500) rwmcfa1

	* pm/TestHelper.pm: if we're not 2.2.0 or greated don't allow init
	to be skipped. earlier rel's have to for some pagno thing.

	* t/GtkClipboard.t: the clipboard didn't exist for sure until 2.2.0

2004/01/11 23:59 (+0100) kaffeetisch

	* MANIFEST
	A t/GtkDnd.t: New test.

ChangeLog.pre-git  view on Meta::CPAN

2004/01/08 18:55 (-0500) rwmcfa1

	* pm/TestHelper.pm: added at_least_version paramter, very useful.

	* t/27.GtkClipboard.t: use ^, to skip unless clipboard will be around.

	* xs/Gtk2.xs: apidoc fix, version_info should of been get_version_info.

2004/01/09 00:47 (+0100) kaffeetisch

ChangeLog.pre-git  view on Meta::CPAN

	module couldn't have worked as it was.  added class parameter to get
	and get_for_display.  implemented set_with_data and set_with_owner.
	made the others actually work.

	* gtk2perl.h, xs/GtkSelection.xs: moved the macro to gtk2perl.h as
	GTK2PERL_STACK_ITEMS_TO_TARGET_ENTRY_ARRAY so clipboard could use it.

	* t/27.GtkClipboard.t, MANIFEST: new test.

	 * xs/GtkStyle.xs: somehow we had implemented the deprecated
	 gtk_draw_flat_box instead of gtk_paint_flat_box.

ChangeLog.pre-git  view on Meta::CPAN

	to derive GObject types in perl; this is necessary to implement
	the constructor of a derived list or tree store.  factored out
	the stack handling code, into gtk2perl.h, to avoid needing to
	create another header.

	* xs/GtkTextBuffer.xs: implemented missing clipboard functions:
	add_selection_clipboard remove_selection_clipboard cut_clipboard
	copy_clipboard paste_clipboard

	* xs/GtkWidget.xs: implemented get_pointer, is_ancestor,
	translate_coordinates, set_style, ensure_style; added FIXMEs

	* xs/GdkEvent.xs: let gdk_event_set_screen in there twice, because

ChangeLog.pre-git  view on Meta::CPAN

2003/08/06 12:57 muppetman

	* xs/GtkWindow.xs: plug a memleak in list_toplevels

	* xs/GtkWidget.xs: ->get_clipboard

2003/08/05 22:16 muppetman

	* pm/SimpleList.pm: pod patch from James Curbo

 view release on metacpan or  search on metacpan

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

#                    if ( $keyval == &Gtk3::Gdk::KEY_C || $keyval == &Gtk3::Gdk::KEY_c ) {
#                        my ( $x , $y ) = $event->get_coords;
#                        my ( $path, $column, $cell_x, $cell_y ) = $self->{treeview}->get_path_at_pos( $event->get_root_coords->{x}, $event->get_root_coords->{y} );
#                        my $column_name = $column->{definition}->{name};
#                        my $value = $self->get_colummn_value( $column_name );
#                        my $clipboard = Gtk3::Clipboard::get( Gtk3::Gdk::Atom::intern( 'CLIPBOARD', 0 ) );
#                        $clipboard->set_text( $value, length $value );
#                        return TRUE;
#                    }
#                }
#                return FALSE;
#            }

 view release on metacpan or  search on metacpan

t/overrides.t  view on Meta::CPAN

  is ($button->get_label, '_Test');
}

note('Gtk3::Clipboard::set_text');
{
  my $clipboard = Gtk3::Clipboard::get (Gtk3::Gdk::Atom::intern ('PRIMARY', Glib::FALSE));
  $clipboard->set_text ('→←');
  is ($clipboard->wait_for_text, '→←');
  $clipboard->set_text ('→←', 3); # wants length in bytes
  is ($clipboard->wait_for_text, '→');
}

note('Gtk3::ColorButton::new');
{
  my $button = Gtk3::ColorButton->new;

 view release on metacpan or  search on metacpan

share/public/guaclite.js  view on Meta::CPAN

     * Allocates an available stream index and creates a new
     * Guacamole.OutputStream using that index, associating the resulting
     * stream with this Guacamole.Client. Note that this stream will not yet
     * exist as far as the other end of the Guacamole connection is concerned.
     * Streams exist within the Guacamole protocol only when referenced by an
     * instruction which creates the stream, such as a "clipboard", "file", or
     * "pipe" instruction.
     *
     * @returns {!Guacamole.OutputStream}
     *     A new Guacamole.OutputStream with a newly-allocated index and
     *     associated with this Guacamole.Client.

share/public/guaclite.js  view on Meta::CPAN

        return stream;

    };

    /**
     * Opens a new clipboard object for writing, having the given mimetype. The
     * instruction necessary to create this stream will automatically be sent.
     *
     * @param {String} mimetype The mimetype of the data being sent.
     * @param {String} name The name of the pipe.
     * @return {!Guacamole.OutputStream} The created file stream.
     */
    this.createClipboardStream = function(mimetype) {

        // Allocate and associate stream with clipboard metadata
        var stream = guac_client.createOutputStream();
        tunnel.sendMessage("clipboard", stream.index, mimetype);
        return stream;

    };

    /**

share/public/guaclite.js  view on Meta::CPAN

     *     The name of the connection parameter whose value is being exposed.
     */
    this.onargv = null;

    /**
     * Fired when the clipboard of the remote client is changing.
     * 
     * @event
     * @param {Guacamole.InputStream} stream The stream that will receive
     *                                       clipboard data from the server.
     * @param {String} mimetype The mimetype of the data which will be received.
     */
    this.onclipboard = null;

    /**
     * Fired when a file stream is created. The stream provided to this event
     * handler will contain its own event handlers for received data.
     * 

share/public/guaclite.js  view on Meta::CPAN

            display.clip(layer);

        },

        "clipboard": function(parameters) {

            var stream_index = parseInt(parameters[0]);
            var mimetype = parameters[1];

            // Create stream 
            if (guac_client.onclipboard) {
                var stream = streams[stream_index] = new Guacamole.InputStream(guac_client, stream_index);
                guac_client.onclipboard(stream, mimetype);
            }

            // Otherwise, unsupported
            else
                guac_client.sendAck(stream_index, "Clipboard unsupported", 0x0100);

 view release on metacpan or  search on metacpan

lib/auto/HTML/JQuery/static/css/jquery-ui.css  view on Meta::CPAN

.ui-icon-close { background-position: -80px -128px; }
.ui-icon-closethick { background-position: -96px -128px; }
.ui-icon-key { background-position: -112px -128px; }
.ui-icon-lightbulb { background-position: -128px -128px; }
.ui-icon-scissors { background-position: -144px -128px; }
.ui-icon-clipboard { background-position: -160px -128px; }
.ui-icon-copy { background-position: -176px -128px; }
.ui-icon-contact { background-position: -192px -128px; }
.ui-icon-image { background-position: -208px -128px; }
.ui-icon-video { background-position: -224px -128px; }
.ui-icon-script { background-position: -240px -128px; }

 view release on metacpan or  search on metacpan

lib/HTML/Object/DOM/Element.pm  view on Meta::CPAN

See L<Mozilla documentation|https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert> for more information.

=head2 innerText

Represents the rendered text content of a node and its descendants. As a getter, it approximates the text the user would get if they highlighted the contents of the element with the cursor and then copied it to the clipboard. This returns a L<string ...

When setting some values, this method will ensure that HTML characters are escaped, namely: C<< < >>, C<< > >> and new lines are preceded by the C<< <br /> >> tag.

When the value is retrieved, this is reversed.

 view release on metacpan or  search on metacpan

Word/noun.txt  view on Meta::CPAN

clime,climes
clinic,clinics
clinician,clinicians
clinton,clintons
clip,clips
clipboard,clipboards
clipper,clippers
clipping,clippings
clique,cliques
cloak,cloaks
cloakroom,cloakrooms

 view release on metacpan or  search on metacpan

share/root/static/yui/assets/dpSyntaxHighlighter.js  view on Meta::CPAN

	
	// tools
	ExpandCode : '+ expand code',
	ViewPlain : 'view plain',
	Print : 'print',
	CopyToClipboard : 'copy to clipboard',
	About : '?',
	
	CopiedToClipboard : 'The code is in your clipboard now.'
};

dp.SyntaxHighlighter = dp.sh;

//

share/root/static/yui/assets/dpSyntaxHighlighter.js  view on Meta::CPAN

	
	wnd.document.write('<pre>' + code + '</pre>');
	wnd.document.close();
}

// copies the original source code in to the clipboard (IE only)
dp.sh.Utils.ToClipboard = function(sender)
{
	var code = sender.parentNode.originalCode;
	
	// This works only for IE. There's a way to make it work with Mozilla as well,
	// but it requires security settings changed on the client, which isn't by
	// default, so 99% of users won't have it working anyways.
	if(window.clipboardData)
	{
		window.clipboardData.setData('text', code);
		
		alert(dp.sh.Strings.CopiedToClipboard);
	}
}

share/root/static/yui/assets/dpSyntaxHighlighter.js  view on Meta::CPAN

			cell.innerHTML += '<span><b>' + UtilHref('Expand', dp.sh.Strings.ExpandCode) + '</b>' + pipe + '</span>';
		}

		cell.innerHTML += UtilHref('ViewSource', dp.sh.Strings.ViewPlain) + pipe + UtilHref('PrintSource', dp.sh.Strings.Print);
		
		// IE has this clipboard object which is easy enough to use
		if(window.clipboardData)
			cell.innerHTML += pipe + UtilHref('ToClipboard', dp.sh.Strings.CopyToClipboard);
		
		cell.innerHTML += pipe + UtilHref('About', dp.sh.Strings.About);
	}

 view release on metacpan or  search on metacpan

lib/IUP.pm  view on Meta::CPAN

    button          => 'IUP::Button',
    calendar        => 'IUP::Calendar',          # https://webserver2.tecgraf.puc-rio.br/iup/en/elem/iupcalendar.html
    canvas          => 'IUP::Canvas',
    cbox            => 'IUP::Cbox',
    cells           => 'IUP::Cells',
    clipboard       => 'IUP::Clipboard',
    colorbar        => 'IUP::ColorBar',
    colorbrowser    => 'IUP::ColorBrowser',
    colordlg        => 'IUP::ColorDlg',
    constants       => 'IUP::Constants',
    datepick        => 'IUP::DatePick',          # https://webserver2.tecgraf.puc-rio.br/iup/en/elem/iupdatepick.html

 view release on metacpan or  search on metacpan

lib/Image/ExifTool/TagLookup.pm  view on Meta::CPAN

	'classifystate' => { 150 => 0xe1 },
	'clearretouch' => { 372 => 0x7c },
	'clearretouchvalue' => { 372 => 0xa3 },
	'client' => { 566 => 'client' },
	'clientname' => { 544 => 'ClientName' },
	'clipboardaspectratio' => { 536 => 'ClipboardAspectRatio', 538 => 'ClipboardAspectRatio' },
	'clipboardorientation' => { 536 => 'ClipboardOrientation', 538 => 'ClipboardOrientation' },
	'clipfilename' => { 437 => 'clfn' },
	'clipid' => { 437 => 'clid' },
	'clmodeshootingspeed' => { 325 => '10.2', 326 => '11.3', 328 => '11.2', 329 => '11.2', 334 => '11.2', 335 => '10.2', 338 => '11.2', 339 => '11.2', 340 => '11.1', 341 => 0x3f, 342 => 0x3b, 343 => 0x3b, 344 => 0x3b },
	'cluster' => { 536 => 'Cluster', 538 => 'Cluster' },
	'cmcontrast' => { 355 => 0x2022 },

 view release on metacpan or  search on metacpan

lib/Image/Magick/CommandParser.pm  view on Meta::CPAN

@@ pseudo_image_formats
canvas
caption
clip
clipboard
fractal
gradient
hald
histogram
label

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

t/exploit/image.bmp3
t/exploit/image.bpg
t/exploit/image.cals
t/exploit/image.cgm
t/exploit/image.cin
t/exploit/image.clipboard
t/exploit/image.cmyk
t/exploit/image.cmyka
t/exploit/image.cr2
t/exploit/image.crw
t/exploit/image.cur

 view release on metacpan or  search on metacpan

lib/JaM/GUI/Compose.pm  view on Meta::CPAN

		{ path        => '/_Edit',
                  type        => '<Branch>' },

                { path        => '/Edit/Cu_t',
		  accelerator => '<control>X',
                  callback    => sub { $self->gtk_text->signal_emit_by_name( 'cut-clipboard' ) } },
                { path        => '/Edit/_Copy',
		  accelerator => '<control>C',
                  callback    => sub { $self->gtk_text->signal_emit_by_name( 'copy-clipboard' ) } },
                { path        => '/Edit/_Paste',
		  accelerator => '<control>V',
                  callback    => sub { $self->gtk_text->signal_emit_by_name( 'paste-clipboard' ) } },

		{ path	      => '/Edit/sep1',
		  type	      => '<Separator>' },

                { path        => '/Edit/Delete _Quoted text beneath cursor',

 view release on metacpan or  search on metacpan

bin/make-bookmarklet  view on Meta::CPAN

my $src = do { local $/; <> };
my $bookmarklet = make_bookmarklet($src);
print $bookmarklet;
eval {
    system("/bin/echo -n '$bookmarklet' | /usr/bin/pbcopy")
      ;                    # put bookmarklet on clipboard.
};
warn "Bookmarklet code not be placed in your clipboard: $@" if $@;

__END__

=head1 NAME

bin/make-bookmarklet  view on Meta::CPAN

human-readable JavaScript code into bookmarklet form.

=head1 DESCRIPTION

This script will attempt to copy the bookmarklet code to
your desktop clipboard using pbcopy if possible. A warning
will be issued if it cannot regardless of the availablity of
pbcopy, the bookmarklet code will be output.

=head1 USAGE