Result:
found more than 469 distributions - search limited to the first 2001 files matching your query
( run in 0.460 )
Cindy-Apache2
view release on metacpan or search on metacpan
examples/site/tec/css/local.css view on Meta::CPAN
outline: none;
outline-offset: 0em;
/* Look like a link */
background: none;
color: blue;
cursor: pointer;
font: inherit;
text-decoration: underline;
}
/* Remove extra space inside buttons in Firefox */
CircuitLayout
view release on metacpan or search on metacpan
Examples/GDS2Tool/gds2tool view on Meta::CPAN
$G_mouseInfoText='mouse buttons: ruler | nothing | nothing';
ruler($G_canvas, 1, '', '');
}
elsif ($G_keyLast eq 'z')
{
$G_canvas -> configure(-cursor => 'crosshair');
zoom($G_canvas, 0, $x - 20, $y - 30);
}
elsif ($G_keyLast eq 'plus')
{
zoom($G_canvas, 2, $x, $y);
Examples/GDS2Tool/gds2tool view on Meta::CPAN
setCursor();
}
);
$G_keyBindingText = <<EOKBT;
<f> full view
<p> pan to cursor
<r> ruler
<z> zoom in with window
<-> zoom in on cursor
<+> zoom out on cursor
<Escape> clear, interrupt
<Delete> clear rulers
<Up-arrow> pan up
<Down-arrow> pan down
<Right-arrow> pan right
Examples/GDS2Tool/gds2tool view on Meta::CPAN
{
my ($canvas, $type, $x, $y) = @_;
if ($x ne '')
{
$G_statusText='Enter another coordinate';
$canvas -> configure(-cursor => 'pencil');
my ($x1,$y1) = $canvas -> worldxy($x,$y); ## convert before call....
$G_startx = round2Grid($x1,$G_xSnapGrid);
$G_starty = round2Grid($y1,$G_ySnapGrid);
startPolygon($canvas,
-type => 'line',
Examples/GDS2Tool/gds2tool view on Meta::CPAN
else ## zoom in with window
{
if ($x ne '')
{
$G_statusText='Enter 2nd coordinate';
$canvas -> configure(-cursor => 'crosshair');
my ($x1,$y1) = $canvas -> worldxy($x,$y); ## convert before call....
startPolygon($canvas,
-type => 'rectangle',
-x => $x1,
-y => $y1,
Examples/GDS2Tool/gds2tool view on Meta::CPAN
sub setCursor
{
if ($G_mouseMode eq 'pan')
{
$G_canvas -> configure(-cursor => 'circle');
}
elsif ($G_mouseMode eq 'ruler')
{
$G_canvas -> configure(-cursor => 'pencil');
}
elsif ($G_mouseMode =~ m/zoom/)
{
$G_canvas -> configure(-cursor => 'iron_cross') if ($G_mouseMode eq 'zoomin');
$G_canvas -> configure(-cursor => 'fleur') if ($G_mouseMode eq 'zoomout');
}
else
{
$G_canvas -> configure(-cursor => 'arrow');
}
}
################################################################################
sub showGridWindow
Clang
view release on metacpan or search on metacpan
lib/Clang.pm view on Meta::CPAN
use Clang;
my $index = Clang::Index -> new(1);
my $tunit = $index -> parse('file.c');
my $nodes = $tunit -> cursor -> children;
foreach my $node (@$nodes) {
say $node -> spelling;
say $node -> kind -> spelling;
}
Class-AlzaboWrapper
view release on metacpan or search on metacpan
lib/Class/AlzaboWrapper.pm view on Meta::CPAN
*column = \&Columns;
sub NewCursor
{
my $self = shift;
my $cursor = shift;
return
Class::AlzaboWrapper::Cursor->new
( cursor => $cursor );
}
# deprecated
*cursor = \&NewCursor;
sub TableToClass { $TableToClass{ $_[1]->name } }
# deprecated
*table_to_class = \&TableToClass;
lib/Class/AlzaboWrapper.pm view on Meta::CPAN
=item * AlzaboAttributes()
Returns a list of accessor methods that were created based on the
columns in the class's associated table.
=item * NewCursor ($cursor)
Given an C<Alzabo::Runtime::Cursor> object (either a row or join
cursor), this method returns a new C<Class::AlzaboWrapper::Cursor>
object.
=back
=head3 Object methods
lib/Class/AlzaboWrapper.pm view on Meta::CPAN
=back
=head3 Cursors
When using this module, you need to use the
C<Class::AlzaboWrapper::Cursor> module to wrap Alzabo's cursor
objects, so that objects the cursor returns are of the appropriate
subclass, not plain C<Alzabo::Runtime::Row> objects. The C<Cursor()>
method provides some syntactic sugar for creating
C<Class::AlzaboWrapper::Cursor> objects.
=head3 Attributes created by subclasses
Class-AutoDB
view release on metacpan or search on metacpan
lib/Class/AutoDB.pm view on Meta::CPAN
# both inherit from AutoClass anyway
use base qw(Class::AutoDB::Database Class::AutoDB::Connect Class::AutoClass);
@AUTO_ATTRIBUTES=qw(read_only read_only_schema alter_param index_param
object_table registry
session cursors
_db_cursor);
@OTHER_ATTRIBUTES=qw(server=>'host');
%SYNONYMS=();
Class::AutoClass::declare;
use vars qw($AUTO_REGISTRY); # TODO: move to Globals
lib/Class/AutoDB.pm view on Meta::CPAN
my @friend_names=map {$_->name} @{$person->friends};
print $person->name,"'s friends are @friend_names\n";
}
# retrieve and process objects one-by-one
my $cursor=$autodb->find(collection=>'Person');
while (my $person=$cursor->get_next) {
# do what you want with $person, for example, print friends list
my @friend_names=map {$_->name} @{$person->friends};
print $person->name,"'s friends are @friend_names\n";
}
lib/Class/AutoDB.pm view on Meta::CPAN
If you supply search_key=>value pairs and a SQL statement, they are ANDed.
=head3 find
Title : find
Usage : my $cursor=$autodb->find(collection=>'Person',name=>'Joe',sex=>'M')
-- OR --
my $cursor=$autodb->find(collection=>'Person',
query=>{name=>'Joe',sex=>'M'})
-- OR --
my $cursor=$autodb->find
-- OR --
my $cursor=$autodb->find(sql=>qq(SELECT oid FROM Person
WHERE name='Joe' OR name='Bill'))
Function: Execute query.
Returns : Class::AutoDB::Cursor object which can be used to retrieve results
Args : same as 'get'
Notes : same as 'get'
lib/Class/AutoDB.pm view on Meta::CPAN
Usage : my $count=$autodb->count(collection=>'Person',name=>'Joe',sex=>'M')
-- OR --
my $count=$autodb->count(collection=>'Person',
query=>{name=>'Joe',sex=>'M'})
-- OR --
my $cursor=$autodb->find
-- OR --
my $cursor=$autodb->find(sql=>qq(SELECT oid FROM Person
WHERE name='Joe' OR name='Bill'))
Function: Count number of objects satisfying query
Returns : number
Args : same as 'get'
Notes : same as 'get'
lib/Class/AutoDB.pm view on Meta::CPAN
related methods operating on Class::AutoDB objects.
=head3 get
Title : get
Usage : my @males=$cursor->get
-- OR --
my $males=$cursor->get
Function: Retrieve results of query associated with cursor
Returns : list or ARRAY of objects satisfying query
Args : none
It is possible to mix 'get' and 'get_next' operations. If some
'get_next' operations have been run on cursor, 'get' retrieves
remaining objects
=head3 get_next
Title : get_next
Usage : my $object=$cursor->get_next
Function: Retrieve next result for cursor or undef if there are no more
Returns : object satisfying query or undef
Args : none
Notes : Allows simple while loops to iterate over results as in SYNOPSIS
=head3 count
Title : count
Usage : my $count=$cursor->count
Function: Count number of objects satisfying query associated with cursor
Returns : number
Args : none
=head3 reset
Title : reset
Usage : $cursor->reset
Function: Re-execute query associated with cursor.
Returns : nothing
Args : none
Notes : Subsequent 'get' or 'get_next' operation will start at beginning
=head2 Updates
Class-DBI-Factory
view release on metacpan or search on metacpan
lib/Class/DBI/Factory/Ghost.pm view on Meta::CPAN
use vars qw( $VERSION $AUTOLOAD );
$VERSION = '0.04';
=head1 NAME
Class::DBI::Factory::Ghost - a minimal data-container used as a precursor for Class::DBI objects when populating forms or otherwise preparing to create a new object from existing data.
=head1 SYNOPSIS
my $thing = Class::DBI::Factory::Ghost->new({
id => 'new',
Class-DBI-Lite
view release on metacpan or search on metacpan
lib/Class/DBI/Lite/Iterator.pm view on Meta::CPAN
=head2 next
Returns the next object in the series, or undef.
Moves the internal cursor to the next object if one exists.
=head2 reset
Resets the internal cursor to the first object if one exists.
=head1 SEE ALSO
L<Class::DBI:Lite>
Class-DBI-Plugin-DeepAbstractSearchPager
view release on metacpan or search on metacpan
lib/Class/DBI/Plugin/DeepAbstractSearchPager.pm view on Meta::CPAN
If you are using a subclass of the pager, this method will not be called.
Will C<die> if using Oracle or DB2, since there is no simple syntax for limiting
the results set. DB2 has a C<FETCH> keyword, but that seems to apply to a
cursor and I don't know if there is a cursor available to the pager. There
should probably be others to add to the unsupported list.
Supports the following drivers:
DRIVER CDBI::P::Pager subclass
Class-DBI-Plugin-Pager
view release on metacpan or search on metacpan
lib/Class/DBI/Plugin/Pager.pm view on Meta::CPAN
If you are using a subclass of the pager, this method will not be called.
Will C<die> if using Oracle or DB2, since there is no simple syntax for limiting
the results set. DB2 has a C<FETCH> keyword, but that seems to apply to a
cursor and I don't know if there is a cursor available to the pager. There
should probably be others to add to the unsupported list.
Supports the following drivers:
DRIVER CDBI::P::Pager subclass
Class-DBI-Plugin-Senna
view release on metacpan or search on metacpan
lib/Class/DBI/Plugin/Senna.pm view on Meta::CPAN
sub senna_search
{
my $class = shift;
my $query = shift;
my $index = $class->senna_index();
my $cursor = $index->search($query);
my $iter = Class::DBI::Plugin::Senna::Iterator->new($class, $cursor);
if (wantarray) {
my @ret;
while (my $e = $iter->next) {
push @ret, $e;
}
lib/Class/DBI/Plugin/Senna.pm view on Meta::CPAN
fallback => 1
;
sub new
{
my($class, $them, $cursor) = @_;
bless {
_class => $them,
_cursor => $cursor,
}, $class;
}
sub count
{
my $self = shift;
my $cursor = $self->{_cursor};
return $cursor->hits;
}
sub reset
{
my $self = shift;
my $cursor = $self->{_cursor};
$cursor->rewind;
}
sub first
{
my $self = shift;
lib/Class/DBI/Plugin/Senna.pm view on Meta::CPAN
sub next
{
my $self = shift;
my $class = $self->{_class};
my $cursor = $self->{_cursor};
my $result = $cursor->next();
my $obj;
if (defined $result) {
$obj = $class->retrieve($result->key);
}
return $obj;
Class-Dot
view release on metacpan or search on metacpan
contrib/vim/taglist.vim view on Meta::CPAN
" Automatically open the taglist window on Vim startup
if !exists('Tlist_Auto_Open')
let Tlist_Auto_Open = 0
endif
" When the taglist window is toggle opened, move the cursor to the
" taglist window
if !exists('Tlist_GainFocus_On_ToggleOpen')
let Tlist_GainFocus_On_ToggleOpen = 0
endif
contrib/vim/taglist.vim view on Meta::CPAN
" sml language
let s:tlist_def_sml_settings = 'sml;e:exception;c:functor;s:signature;' .
\ 'r:structure;t:type;v:value;f:function'
" sql language
let s:tlist_def_sql_settings = 'sql;c:cursor;F:field;P:package;r:record;' .
\ 's:subtype;t:table;T:trigger;v:variable;f:function;p:procedure'
" tcl language
let s:tlist_def_tcl_settings = 'tcl;c:class;f:method;m:method;p:procedure'
contrib/vim/taglist.vim view on Meta::CPAN
new taglist_debug.txt
" Delete all the lines (if the buffer already exists)
silent! %delete _
" Add the messages
silent! put =s:tlist_msg
" Move the cursor to the first line
normal! gg
endfunction
" Tlist_Log_Msg
" Log the supplied debug message along with the time
contrib/vim/taglist.vim view on Meta::CPAN
" this file, as the tags for this file are removed
call s:Tlist_Window_Update_Line_Offsets(a:fidx + 1, 0, end - start + 1)
endfunction
" Tlist_Remove_File
" Remove the file under the cursor or the specified file index
" user_request - User requested to remove the file from taglist
function! s:Tlist_Remove_File(file_idx, user_request)
let fidx = a:file_idx
if fidx == -1
contrib/vim/taglist.vim view on Meta::CPAN
let s:tlist_win_maximized = 1
endif
endfunction
" Tlist_Ballon_Expr
" When the mouse cursor is over a tag in the taglist window, display the
" tag prototype (balloon)
function! Tlist_Ballon_Expr()
" Get the file index
let fidx = s:Tlist_Window_Get_File_Index_By_Linenum(v:beval_lnum)
if fidx == -1
contrib/vim/taglist.vim view on Meta::CPAN
endif
" Define the taglist autocommands
augroup TagListAutoCmds
autocmd!
" Display the tag prototype for the tag under the cursor.
autocmd CursorHold __Tag_List__ call s:Tlist_Window_Show_Info()
" Highlight the current tag periodically
autocmd CursorHold * silent call s:Tlist_Window_Highlight_Tag(
\ fnamemodify(bufname('%'), ':p'), line('.'), 1, 0)
contrib/vim/taglist.vim view on Meta::CPAN
if g:Tlist_File_Fold_Auto_Close
" Close all the folds
silent! %foldclose
endif
" Move the cursor to the top of the taglist window
normal! gg
endfunction
" Tlist_Post_Close_Cleanup()
" Close the taglist window and adjust the Vim window width
contrib/vim/taglist.vim view on Meta::CPAN
" create a fold for this tag type
let fold_start = ttype_start_lnum
let fold_end = fold_start + {fidx_ttype}_count
exe fold_start . ',' . fold_end . 'fold'
" Adjust the cursor position
if g:Tlist_Compact_Format == 0
exe ttype_start_lnum + {fidx_ttype}_count
else
exe ttype_start_lnum + {fidx_ttype}_count + 1
endif
contrib/vim/taglist.vim view on Meta::CPAN
let save_winnr = winnr()
" Goto the taglist window
call s:Tlist_Window_Goto_Window()
" Save the cursor position
let save_line = line('.')
let save_col = col('.')
" Update the taglist window
call s:Tlist_Window_Refresh_File(fname, a:ftype)
" Restore the cursor position
if v:version >= 601
call cursor(save_line, save_col)
else
exe save_line
exe 'normal! ' . save_col . '|'
endif
contrib/vim/taglist.vim view on Meta::CPAN
" Goto the taglist window
call s:Tlist_Window_Goto_Window()
if !g:Tlist_Auto_Highlight_Tag || !g:Tlist_Highlight_Tag_On_BufEnter
" Save the cursor position
let save_line = line('.')
let save_col = col('.')
endif
" Update the taglist window
contrib/vim/taglist.vim view on Meta::CPAN
endif
" Highlight the current tag
call s:Tlist_Window_Highlight_Tag(filename, cur_lnum, 1, center_tag_line)
else
" Restore the cursor position
if v:version >= 601
call cursor(save_line, save_col)
else
exe save_line
exe 'normal! ' . save_col . '|'
endif
endif
contrib/vim/taglist.vim view on Meta::CPAN
call s:Tlist_Window_Refresh_File(s:tlist_{fidx}_filename,
\ s:tlist_{fidx}_filetype)
exe s:tlist_{fidx}_start . ',' . s:tlist_{fidx}_end . 'foldopen!'
" Go back to the cursor line before the tag list is sorted
call search(curline, 'w')
call s:Tlist_Menu_Update_File(1)
else
call s:Tlist_Menu_Remove_File()
contrib/vim/taglist.vim view on Meta::CPAN
exe 'match TagListTagName ' . pat
endfunction
" Tlist_Window_Open_File
" Open the specified file in either a new window or an existing window
" and place the cursor at the specified tag pattern
function! s:Tlist_Window_Open_File(win_ctrl, filename, tagpat)
call s:Tlist_Log_Msg('Tlist_Window_Open_File (' . a:filename . ',' .
\ a:win_ctrl . ')')
let prev_Tlist_Skip_Refresh = s:Tlist_Skip_Refresh
let s:Tlist_Skip_Refresh = 1
contrib/vim/taglist.vim view on Meta::CPAN
endif
endif
" Jump to the tag
if a:tagpat != ''
" Add the current cursor position to the jump list, so that user can
" jump back using the ' and ` marks.
mark '
silent call search(a:tagpat, 'w')
" Bring the line to the middle of the window
contrib/vim/taglist.vim view on Meta::CPAN
call s:Tlist_Window_Open_File(a:win_ctrl, s:tlist_{fidx}_filename, tagpat)
endfunction
" Tlist_Window_Show_Info()
" Display information about the entry under the cursor
function! s:Tlist_Window_Show_Info()
call s:Tlist_Log_Msg('Tlist_Window_Show_Info()')
" Clear the previously displayed line
echo
contrib/vim/taglist.vim view on Meta::CPAN
" Calling the winline() function makes the line visible. Don't know
" of a better way to achieve this.
let lnum = line('.')
if lnum < s:tlist_{fidx}_start || lnum > s:tlist_{fidx}_end
" Move the cursor to the beginning of the file
exe s:tlist_{fidx}_start
endif
if foldclosed('.') != -1
.foldopen
contrib/vim/taglist.vim view on Meta::CPAN
return s:tlist_{fidx}_{tidx}_tag_name
endfunction
" Tlist_Window_Move_To_File
" Move the cursor to the beginning of the current file or the next file
" or the previous file in the taglist window
" dir == -1, move to start of current or previous function
" dir == 1, move to start of next function
function! s:Tlist_Window_Move_To_File(dir)
if foldlevel('.') == 0
contrib/vim/taglist.vim view on Meta::CPAN
let tagpat = s:Tlist_Get_Tag_SearchPat(fidx, a:tidx)
if tagpat == ''
return
endif
" Add the current cursor position to the jump list, so that user can
" jump back using the ' and ` marks.
mark '
silent call search(tagpat, 'w')
Class-Maker
view release on metacpan or search on metacpan
t/t_schema/02_tangram.t view on Meta::CPAN
my %class_hash = @$class_schema;
foreach my $class ( keys %class_hash )
{
my $cursor = $storage->cursor( $class );
my $inst_cnt = 0;
while(my $obj = $cursor->current())
{
#$obj->info() if $obj->can('info');
$inst_cnt++;
$cursor->next();
}
println qq{'$inst_cnt' instance(s) of class '$class' detected.};
$cursor->close();
}
eval
{
1;
Class-Rebless
view release on metacpan or search on metacpan
Tue, 22 Mar 2011 09:23:10 +0200 Gaal Yahas <gaal@forum2.org>
* This be 0.09.
* Do not descend into branches we've seen, in cyclical structures. (RJBS)
* Do not expose private recursor arguments via the public API.
Thu, 10 May 2007 19:24:11 +0300 Gaal Yahas <gaal@forum2.org>
* This be 0.08.
* Make license more visible.
Class-Trait
view release on metacpan or search on metacpan
lib/Class/Trait.pm view on Meta::CPAN
Class::Trait - Deprecated. Please use Moose::Role.
=head1 DEPRECATED
This module has long been deprecated. It was a precursor to Moose::Role and
other attempts to implement roles/traits in Perl. If you need standalone
roles, please use L<Role::Basic> or L<Role::Tiny>. If you need full OO, please
use L<Moose> or L<Moo>.
=head1 SYNOPSIS
Cmd-Dwarf
view release on metacpan or search on metacpan
examples/helloworld/app/lib/Dwarf/Module/SocialMedia/Twitter.pm view on Meta::CPAN
sub get_friends_ids {
my ($self, $id) = @_;
$id ||= $self->user_id;
my $cursor = -1;
my @ids = ();
while ($cursor != 0) {
my $result = $self->call('friends/ids', 'GET', {
user_id => $id,
cursor => $cursor,
});
$cursor = $result->{next_cursor_str};
push @ids, @{ $result->{ids} };
}
return \@ids;
}
sub get_followers_ids {
my ($self, $id) = @_;
$id ||= $self->user_id;
my $cursor = -1;
my @ids;
while ($cursor != 0) {
my $result = $self->call('followers/ids', 'GET', {
user_id => $id,
cursor => $cursor,
});
$cursor = $result->{next_cursor_str};
push @ids, @{ $result->{ids} };
}
return @ids;
}
Cmenu
view release on metacpan or search on metacpan
# DOWN : move down
# RITE : move right
# LEFT : move left
# LYNXR : move right - can mimic lynx-style motion
# LYNXL : move left - can mimic lynx-style motion
# Large cursor movement
# HOME : go to top (of menu)
# END : go to bottom (of menu)
# NEXT : next page
# PREV : previous page
# JUMP : leap to a specific menu item
# Method 4
# Explicit control sequences - should work for all terminals regardless
# These should be Uncommented for all systems/platforms
# Hacks for Xterms and standard emacs style definitions
# --< Xterm hacks >---------------------------------------------------------------
$kseq{"\033[A"}="UP"; # Ansi cursor-up (for DEC xterm)
$kseq{"\033[B"}="DOWN"; # Ansi cursor-down (for DEC xterm)
$kseq{"\033[C"}="RITE"; # Ansi cursor-right (for DEC xterm)
$kseq{"\033[D"}="LEFT"; # Ansi cursor-left (for DEC xterm)
# added mapping for Home/End and Page buttons for xterms
$kseq{"\033[E"}="PREV"; # Ansi guess (for DEC xterm)
$kseq{"\033[F"}="END"; # Ansi end key (for DEC xterm)
$kseq{"\033[G"}="NEXT"; # Ansi guess (for DEC xterm)
$kseq{"\033[H"}="HOME"; # Ansi home key (for DEC xterm)
&delwin($menu_inlay);
&standend();
&clear();
&refresh(); # clears the screen
&curs_set(1); # turn the cursor back on
&endwin(); # closes all structures and auto restores tty
print "$message\r\n";
exit();
}
}
# curses cookery
cbreak(); # permits keystroke examination
noecho(); # no input echo until enabled explicitly
curs_set(0); # turn the cursor off
# reset and draw button bar
$menu_hot_button=1;
&menu_button_bar(0);
# ------------------------------------------------------------------------------
KEYWAIT: for ($action) {
# Set return value as current option
$ret=$menu_sel_return[$menu_cur_option].$menu_sep;
# General cursor movement
/LEFT/ && do { # Left arrow
# Treat this like an UP-Menu request
$action="UP";
# redo KEYWAIT;
};
&menu_advice("");
}
&doupdate();
last KEYWAIT;
};
# larger cursor motion
/PREV/ && do { # Page up
if($menu_top_option<=0) {
# Hit the bottom
menu_advice("There are no more options!");
} else {
close(IN);
&menu_show("Help File ".$menu_help_root.$menu_help,$help,"HELP");
# these get switched off by menu_show so do this
cbreak(); # permits keystroke examination
noecho(); # no input echo until enabled explicitly
curs_set(0); # turn the cursor off
&menu_refresh();
} else {
beep();
&menu_advice("Help file ".$menu_help_root.$menu_help." not found");
&doupdate;
&delwin($menu_pane);
}
# curses cookery
nocbreak(); # permits keystroke examination
echo(); # no input echo until enabled explicitly
curs_set(1); # turn the cursor on
delwin($menu_window);
$ret;
}
#*********
# MENU_DRAW_PANE
#
# Function: Draws the actual menu especially after a keystroke
# Usually only necessary after big relocations of the menu cursor
#
# Input: Nothing
#
# Returns: Nothing
#
if(!$field) { $field=""; } # Make sure something is defined
$menu_field=newwin(1,$item_len,$item_line,$item_col);
bkgd($menu_field,$menu_attributes{"advice"});
# curses cookery
curs_set(1); # turn the cursor off
$ins=1; # turn insert mode on
$pos=length($field);
# Now edit the field
READ_KEY: do {
# ------------------------------------------------------------------------------
# Switch construct for dealing with key sequence input
# ------------------------------------------------------------------------------
EDITKEY: for ($action) {
# General cursor movement
/DOWN/ && do { # down arrow
$action="ACCEPT";
redo EDITKEY;
};
/UP/ && do { # Up arrow
/RITE/ && do { # Right arrow
$pos++;
if($pos>length($field)) {$pos=length($field); }
last EDITKEY;
};
# larger cursor motion
/PREV/ && do { # Page up
$action="ACCEPT";
redo EDITKEY;
};
/NEXT/ && do { # Page down
}
}; # end of option check
} until ($action eq "STOP");
# return screen to normal after field edit
curs_set(0); # turn the cursor off
delwin($menu_field);
move($menu_pane,$m_item-$menu_top_option,$m_indent);
clrtoeol($menu_pane);
&noutrefresh($menu_window);
}
if(!$message) {
# no message so destroy the old popup
# curses cookery
echo(); # no input echo until enabled explicitly
curs_set(1); # turn the cursor on
&delwin($menu_popup);
&menu_redraw_backdrop();
} else {
# create a new popup
noecho(); # no input echo until enabled explicitly
curs_set(0); # turn the cursor off
while(length($message)>$menu_screen_cols-8) {
chop $message;
};
# Initialise menu pane and control variables
erase($menu_popup);
# curses cookery
cbreak(); # permits keystroke examination
noecho(); # no input echo until enabled explicitly
curs_set(0); # turn the cursor off
if(length($message)<$menu_pane_cols) {
move($menu_popup,$menu_pane_lines/2,($menu_pane_cols-length($message))/2);
addstr($menu_popup,$message);
&refresh($menu_popup);
} until ($work ne "");
}
# curses cookery
nocbreak(); # permits keystroke examination
echo(); # no input echo until enabled explicitly
curs_set(1); # turn the cursor on
&delwin($menu_popup);
&menu_redraw_backdrop();
}
$work;
}
Cobalt-LCD
view release on metacpan or search on metacpan
lib/Cobalt/LCD.pm view on Meta::CPAN
Provided you have the sys-apps/cobalt-panel-utils package installed, you can `man` the heck out of those utilities:
lcd-write
lcd-swrite
lcd-yesno
lcd-setcursor
lcd-getip
lcd-flash
readbutton
iflink
iflinkstatus
Code-ART
view release on metacpan or search on metacpan
lib/Code/ART.pm view on Meta::CPAN
The original source code (as a string),
=item *
A string index at which some usage of the variable is located
(i.e. a point in the source where a hypothetical cursor would be "over" the variable).
=item *
The new name of the variable.
lib/Code/ART.pm view on Meta::CPAN
The module distribution includes a Vim plugin: F<vim/perlart.vim>
This plugin sets up a series of mappings that refactor or rename
code elements that have been visually selected or on which the
cursor is sitting.
For example, the <CTRL-S> mapping yanks the visual selection, refactors the
code into a subroutine, requests a name for the new subroutine, requests
a return value (if one seems needed), and then pastes the resulting
subroutine call over the original selected text.
lib/Code/ART.pm view on Meta::CPAN
=over
=item <CTRL-N>
Rename the variable under the cursor.
=item <CTRL-S>
Search for all instances of the variable under the cursor.
B<I<WARNING>>: In some environments, C<CTRL-S> will suspend terminal
interactions. If your terminal locks up when you use this mapping,
hit C<CTRL-Q> to restart terminal interactions. In this case,
you will need to either change the behaviour of C<CTRL-S> in
lib/Code/ART.pm view on Meta::CPAN
or L<https://stackoverflow.com/questions/3446320/in-vim-how-to-map-save-to-ctrl-s>),
or else change this mapping to something else.>
=item gd
Jump to the declaration of the variable under the cursor.
=item E<0x2a>
Jump to the next usage of the variable under the cursor.
=back
The following Visual mode mappings are also available:
=over
=item <CTRL-M>
Match all instances of the variable under the cursor.
=item <CTRL-H>
Hoist all instances of the visually selected code into a lexical variable.
Code-TidyAll
view release on metacpan or search on metacpan
php/PHP_CodeSniffer/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.1.css view on Meta::CPAN
<<<<<<< HEAD
line-height: -25px;
=======
line-height: -20px;
>>>>>>> ref/heads/feature-branch
cursor: pointer;
-moz-user-select: none;
}
/*
* The above tests are based on "normal" tokens.
CodeManager
view release on metacpan or search on metacpan
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
return {
%def,
accelItems => [
# navigation
[ CursorDown => 0, 0, kb::Down , sub{$_[0]-> cursor_down}],
[ CursorUp => 0, 0, kb::Up , sub{$_[0]-> cursor_up}],
[ CursorLeft => 0, 0, kb::Left , sub{$_[0]-> cursor_left}],
[ CursorRight => 0, 0, kb::Right , sub{$_[0]-> cursor_right}],
[ PageUp => 0, 0, kb::PgUp , sub{$_[0]-> cursor_pgup}],
[ PageDown => 0, 0, kb::PgDn , sub{$_[0]-> cursor_pgdn}],
[ Home => 0, 0, kb::Home , sub{$_[0]-> cursor_home}],
[ End => 0, 0, kb::End , sub{$_[0]-> cursor_end}],
[ CtrlPageUp => 0, 0, kb::PgUp|km::Ctrl , sub{$_[0]-> cursor_cpgup}],
[ CtrlPageDown => 0, 0, kb::PgDn|km::Ctrl , sub{$_[0]-> cursor_cpgdn}],
[ CtrlHome => 0, 0, kb::Home|km::Ctrl , sub{$_[0]-> cursor_chome}],
[ CtrlEnd => 0, 0, kb::End |km::Ctrl , sub{$_[0]-> cursor_cend}],
[ WordLeft => 0, 0, kb::Left |km::Ctrl , sub{$_[0]-> word_left}],
[ WordRight => 0, 0, kb::Right|km::Ctrl , sub{$_[0]-> word_right}],
[ ShiftCursorDown => 0, 0, km::Shift|kb::Down , q(cursor_shift_key)],
[ ShiftCursorUp => 0, 0, km::Shift|kb::Up , q(cursor_shift_key)],
[ ShiftCursorLeft => 0, 0, km::Shift|kb::Left , q(cursor_shift_key)],
[ ShiftCursorRight => 0, 0, km::Shift|kb::Right , q(cursor_shift_key)],
[ ShiftPageUp => 0, 0, km::Shift|kb::PgUp , q(cursor_shift_key)],
[ ShiftPageDown => 0, 0, km::Shift|kb::PgDn , q(cursor_shift_key)],
[ ShiftHome => 0, 0, km::Shift|kb::Home , q(cursor_shift_key)],
[ ShiftEnd => 0, 0, km::Shift|kb::End , q(cursor_shift_key)],
[ ShiftCtrlPageUp => 0, 0, km::Shift|kb::PgUp|km::Ctrl , q(cursor_shift_key)],
[ ShiftCtrlPageDown => 0, 0, km::Shift|kb::PgDn|km::Ctrl , q(cursor_shift_key)],
[ ShiftCtrlHome => 0, 0, km::Shift|kb::Home|km::Ctrl , q(cursor_shift_key)],
[ ShiftCtrlEnd => 0, 0, km::Shift|kb::End |km::Ctrl , q(cursor_shift_key)],
[ ShiftWordLeft => 0, 0, km::Shift|kb::Left |km::Ctrl , q(cursor_shift_key)],
[ ShiftWordRight => 0, 0, km::Shift|kb::Right|km::Ctrl , q(cursor_shift_key)],
[ Insert => 0, 0, kb::Insert , sub {$_[0]-> insertMode(!$_[0]-> insertMode)}],
# edit keys
[ Delete => 0, 0, kb::Delete, sub {
return if $_[0]-> {readOnly};
$_[0]-> has_selection ? $_[0]-> delete_block : $_[0]-> delete_char;
}],
[ Backspace => 0, 0, kb::Backspace, sub {$_[0]-> back_char unless $_[0]-> {readOnly}}],
[ DeleteChunk => 0, 0, '^Y', sub {$_[0]-> delete_current_chunk unless $_[0]-> {readOnly}}],
[ DeleteToEnd => 0, 0, '^E', sub {$_[0]-> delete_to_end unless $_[0]-> {readOnly}}],
[ DupLine => 0, 0, '^K', sub {$_[0]-> insert_line($_[0]-> cursorY, $_[0]-> get_line($_[0]-> cursorY)) unless $_[0]-> {readOnly}}],
[ DeleteBlock => 0, 0, '@D', sub {$_[0]-> delete_block unless $_[0]-> {readOnly}}],
[ SplitLine => 0, 0, kb::Enter, sub {$_[0]-> split_line if !$_[0]-> {readOnly} && $_[0]-> {wantReturns}}],
[ SplitLine2 => 0, 0, km::Ctrl|kb::Enter,sub {$_[0]-> split_line if !$_[0]-> {readOnly} && !$_[0]-> {wantReturns}}],
# block keys
[ CancelBlock => 0, 0, '@U', q(cancel_block)],
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
autoIndent => 1,
autoHScroll => 1,
autoVScroll => 1,
blockType => bt::CUA,
borderWidth => 1,
cursorSize => [ $::application-> get_default_cursor_width, $font-> { height}],
cursorVisible => 1,
cursorX => 0,
cursorY => 0,
cursorWrap => 0,
insertMode => 0,
hiliteNumbers => cl::Green,
hiliteQStrings => cl::LightBlue,
hiliteQQStrings => cl::LightBlue,
hiliteIDs => [[qw(
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
for ( qw( autoIndent topLine offset resetDisabled blockType persistentBlock
tabIndent readOnly wantReturns wantTabs
))
{ $self-> {$_} = 1; }
for ( qw( wordWrap hScroll vScroll rows maxLineCount maxLineLength maxLineWidth
scrollTransaction maxLine maxChunk capLen cursorY cursorX cursorWrap
cursorXl cursorYl syntaxHilite hiliteNumbers hiliteQStrings hiliteQQStrings
notifyChangeLock modified borderWidth autoHScroll autoVScroll blockShiftMark
))
{ $self-> {$_} = 0;}
$self-> { insertMode} = $::application-> insertMode;
for ( qw( markers lines chunkMap hiliteIDs hiliteChars hiliteREs)) { $self-> {$_} = []}
for ( qw( selStart selEnd selStartl selEndl)) { $self-> {$_} = [0,0]}
$self-> {defcw} = $::application-> get_default_cursor_width;
my %profile = $self-> SUPER::init(@_);
$self-> setup_indents;
$self-> {undo} = [];
$self-> {redo} = [];
$profile{selection} = [@{$profile{selStart}}, @{$profile{selEnd}}];
for ( qw( hiliteNumbers hiliteQStrings hiliteQQStrings hiliteIDs hiliteChars hiliteREs
autoHScroll autoVScroll
textRef syntaxHilite autoIndent persistentBlock blockType hScroll vScroll borderWidth
topLine tabIndent readOnly offset wordDelimiters wantTabs wantReturns
wordWrap cursorWrap markers undoLimit))
{ $self-> $_( $profile{ $_}); }
delete $self-> {resetDisabled};
$self-> {uChange} = 0;
$self-> reset;
$self-> selection( @{$profile{selection}});
for ( qw( cursorX cursorY))
{ $self-> $_( $profile{ $_}); }
$self-> reset_scrolls;
$self-> {modified} = 0;
$self-> {hiliteBlok_modified} = 0;
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$self-> {maxLine} = scalar @{$self-> {lines}} - 1;
$self-> {maxChunk} = $self-> {wordWrap} ? (scalar @{$self-> {chunkMap}}/3-1) : $self-> {maxLine};
$self-> {yTail} = ( $yTail > 0) ? 1 : 0;
# updating selections
$self-> selection( @{$self-> {selStart}}, @{$self-> {selEnd}});
# updating cursor
$self-> cursor( $self-> cursor);
my $chunk = $self-> get_chunk( $self-> {cursorYl});
my $x = $self-> {cursorXl};
$self-> {cursorAtX} = $self-> get_chunk_width( $chunk, 0, $x);
$self-> {cursorInsWidth} = $self-> get_chunk_width( $chunk, $x, 1);
}
# positioning cursor
my $cx = $a[0] + $self-> {cursorAtX} - $self-> {offset};
my $cy = $a[1] + $yTail + ($self-> {rows} - $self-> {cursorYl} + $self-> {topLine } - 1) * $fh;
my $xcw = $self-> {insertMode} ? $cw : $self-> {cursorInsWidth};
my $ycw = $fh;
$ycw -= $a[1] - $cy, $cy = $a[1] if $cy < $a[1];
$xcw = $size[0] + $a[0] - $cx - 1 if $cx + $xcw >= $size[0] + $a[0];
$self-> cursorVisible( $xcw > 0);
if ( $xcw > 0) {
$self-> cursorPos( $cx, $cy);
$self-> cursorSize( $xcw, $ycw);
}
$self-> {uChange} = 0;
}
#-------------------------------------------------------------------------------
sub reset_cursor
{
my $self = $_[0];
$self-> {uChange} = 2;
$self-> reset;
$self-> {uChange} = 0;
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
my ( $self, $btn, $mod, $x, $y) = @_;
return if $self-> {mouseTransaction};
return if $btn != mb::Left && $btn != mb::Middle;
my @xy = $self-> point2xy( $x, $y);
return unless $xy[2];
$self-> cursor( @xy);
if ( $btn == mb::Middle) {
my $cp = $::application-> bring('Primary');
return if !$cp || $self-> {readOnly};
$self-> insert_text( $cp-> text, 0);
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
return unless $self-> scroll_timer_semaphore;
$self-> scroll_timer_semaphore(0);
}
$self-> {delayPanning} = 1;
$self-> blockShiftMark(1);
$self-> cursor( @xy);
$self-> blockShiftMark(0);
$self-> update_block unless $self-> {mouseTransaction} == 2;
$self-> realize_panning;
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
}
return;
}
$self-> cancel_block;
$self-> cursor( @xy);
my $p = $xy[0];
my $sl = length $s;
my ($l,$r);
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
{
my ( $self, $code, $key, $mod, $repeat) = @_;
# $self->{hiliteBlok_modified} = 1;
# my @cs = $self-> cursor;
# my $curr_row = $self->{topLine} + $cs[1];
# my $blok_beg = $self->{hiliteBlok}->[0];
# my $blok_end = $self->{hiliteBlok}->[1];
# my ( $prev_type, $next_type ) = ( 0, 0 );
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
{ #wb:
$self-> delete_block if $self-> has_selection;
}
my @cs = $self-> cursor;
my $c = $self-> get_line( $cs[1] );
my $l = 0;
$self-> begin_undo_group;
if ( $self-> insertMode) {
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
}
# $next_type = 1 if $self-> get_line( $cs[1] ) =~ /($blok_beg|blok_end)/;
# $self-> area;
$self-> cursor( $cs[0] + $repeat, $cs[1]);
$self-> end_undo_group;
$self-> clear_event;
}
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$self-> reset_scrolls;
if ( !$self-> {resetDisabled}) {
$self-> lock;
$self-> selection(0,0,0,0);
$self-> reset;
$self-> cursor($self-> {cursorX}, $self-> {cursorY});
$self-> unlock;
$self-> notify(q(Change));
$self-> reset_scrolls;
}
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$_[0]-> $_( $_[0]-> {$c});
delete $_[0]-> {$c};
}
}
sub set_cursor
{
my ( $self, $x, $y) = @_;
my ( $ox, $oy) = ($self-> {cursorX}, $self-> {cursorY});
my $maxY = $self-> {maxLine};
$y = $maxY if $y < 0 || $y > $maxY;
$y = 0 if $y < 0; # ??
my $line = $self-> get_line( $y);
$x = length( $line) if $x < 0;
my ( $lx, $ly) = $self-> make_logical( $x, $y);
my ( $olx, $oly) = ( $self-> {cursorXl}, $self-> {cursorYl});
$self-> {cursorXl} = $lx;
$self-> {cursorYl} = $ly;
return if $y == $oy and $x == $ox and $lx == $olx and $ly == $oly;
my ( $tl, $r, $yt) = ( $self-> {topLine }, $self-> {rows}, $self-> {yTail});
if ( $ly < $tl) {
$self-> topLine ( $ly);
} elsif ( $ly >= $tl + $r) {
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
my $nofs = $atX - $actualWidth + $deltaX;
$nofs = $ofs + $avg if $nofs - $ofs < $avg;
$self-> offset( $nofs);
}
# check if last undo record contains cursor movements only, so these movements
# can be grouped
my $undo = 1;
if ( !$self-> {undo_in_action} && @{$self-> {undo}} && @{$self-> {undo}-> [-1]}) {
my $ok = 1;
for ( @{$self-> {undo}-> [-1]}) {
$ok = 0, last if $$_[0] ne 'cursor';
}
$undo = 0 if $ok;
}
$self-> push_undo_action( 'cursor', $self-> {cursorX}, $self-> {cursorY}) if $undo;
$self-> {cursorX} = $x;
$self-> {cursorY} = $y;
$self-> {cursorAtX} = $atX;
$self-> {cursorInsWidth} = $deltaX;
$self-> reset_cursor;
$self-> cancel_block
if !$self-> {blockShiftMark} && !$self-> {persistentBlock};
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
if ( $self-> {vScroll} && $self-> {scrollTransaction} != 1) {
$self-> {scrollTransaction} = 1;
$self-> {vScrollBar}-> value( $tl);
$self-> {scrollTransaction} = 0;
}
$self-> reset_cursor;
$self-> scroll( 0, $dt * ($self-> font-> height + $self->{lineSpace}),
clipRect => [ $self-> get_active_area]);
}
sub reset_indents
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
sub set_insert_mode
{
my ( $self, $insert) = @_;
my $oi = $self-> {insertMode};
$self-> {insertMode} = $insert;
$self-> reset_cursor if $oi != $insert;
$::application-> insertMode( $insert);
$self-> push_group_undo_action( 'insertMode', $oi) if $oi != $insert;
}
#-------------------------------------------------------------------------------
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
if ( $self-> {hScroll} && $self-> {scrollTransaction} != 2) {
$self-> {scrollTransaction} = 2;
$self-> {hScrollBar}-> value( $offset);
$self-> {scrollTransaction} = 0;
}
$self-> reset_cursor;
$self-> scroll( -$dt, 0,
clipRect => [ $self-> get_active_area]);
}
#-------------------------------------------------------------------------------
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
return if $self-> {readOnly};
return if !defined($s) or length( $s) == 0;
$self-> begin_undo_group;
$self-> cancel_block unless $self-> {blockType} == bt::CUA;
my @cs = $self-> cursor;
my @xy = @cs;
my @ln = split( "\n", $s, -1);
# my $zzz = join '|', @ln;
#print "<|$zzz|>$cs[1]\n";
# pop @ln unless length $ln[-1];
$s = $self-> get_line( $cs[1]);
#cursor position shift to end of the line if is greater than it:
$cs[0] = length( $s) if $cs[0] > length( $s);
my $cl = $cs[0] - length( $s);
# $s .= ' 'x$cl if $cl > 0;
# $cl = 0 if $cl < 0;
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$self-> lock_change(0);
$self-> end_undo_group;
$self-> area( $self->{topLine}, $self->{rows} ) if @{$self->{hiliteBlok}};
$self-> cursor( @xy );
}
sub insert_text_orig
{
my ( $self, $s, $hilite) = @_;
return if !defined($s) or length( $s) == 0;
$self-> begin_undo_group;
$self-> cancel_block unless $self-> {blockType} == bt::CUA;
my @cs = $self-> cursor;
my @ln = split( "\n", $s, -1);
pop @ln unless length $ln[-1];
$s = $self-> get_line( $cs[1]);
my $cl = $cs[0] - length( $s);
$s .= ' 'x$cl if $cl > 0;
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
my $self = $_[0];
return if exists $self-> {anchor};
my $blockType = $_[1] || $self-> {blockType};
$self-> selection(0,0,0,0);
$self-> blockType( $blockType);
$self-> {anchor} = [ $self-> {cursorX}, $self-> {cursorY}];
}
sub update_block
{
my $self = $_[0];
return unless exists $self-> {anchor};
$self-> selection( @{$self-> {anchor}}, $self-> {cursorX}, $self-> {cursorY});
}
sub end_block
{
my $self = $_[0];
return unless exists $self-> {anchor};
my @anchor = @{$self-> {anchor}};
delete $self-> {anchor};
$self-> selection( @anchor, $self-> {cursorX}, $self-> {cursorY});
}
sub cancel_block
{
delete $_[0]-> {anchor};
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$res++;
}
return $res;
}
sub cursor_down
{
my $d = $_[1] || 1;
#print "cursor_down\n";
my $l1 = $_[0]->get_line( $_[0]-> {cursorYl} );
my $l2 = $_[0]->get_line( $_[0]-> {cursorYl} + $d );
($l1,undef) = wstaw_tab_15( $l1, 0, $_[0]-> {cursorX}, '', 0 );
my $len2 = kursor_w_dol( $l2,length($l1));
$_[0]-> cursorLog( $len2, $_[0]-> {cursorYl} + $d);
$_[0]-> area( $_[0]->{topLine}, $_[0]->{rows} ) if $_[0]-> {hiliteBlok_modified} && @{$_[0]->{hiliteBlok}};
}
sub cursor_up
{
#print "cursor_up\n";
return if $_[0]-> {cursorYl} == 0;
my $d = $_[1] || 1;
my $l1 = $_[0]->get_line( $_[0]-> {cursorYl} );
my $l2 = $_[0]->get_line( $_[0]-> {cursorYl} - $d );
($l1,undef) = wstaw_tab_15( $l1, 0, $_[0]-> {cursorX}, '', 0 );
my $len2 = kursor_w_dol( $l2,length($l1));
my ( $x, $y) = $_[0]-> make_physical( $len2, $_[0]-> {cursorYl} - $d);
# my ( $x, $y) = $_[0]-> make_physical( $_[0]-> {cursorXl}, $_[0]-> {cursorYl} - $d);
$y = 0 if $y < 0;
$_[0]-> cursor( $x, $y);
$_[0]-> area( $_[0]->{topLine}, $_[0]->{rows} ) if $_[0]-> {hiliteBlok_modified} && @{$_[0]->{hiliteBlok}};
}
sub cursor_left
{
my $d = $_[1] || 1;
my $x = $_[0]-> cursorX;
if ( $x - $d >= 0) {
$_[0]-> cursorX( $x - $d)
} elsif ( $_[0]-> {cursorWrap}) {
if ( $d == 1) {
my $y = $_[0]-> cursorY - 1;
$_[0]-> cursor( -1, $y < 0 ? 0 : $y);
} else {
$_[0]-> cursor_left( $d - 1);
}
} else {
$_[0]-> cursorX( 0);
}
}
sub cursor_right
{
my $d = $_[1] || 1;
my $x = $_[0]-> cursorX;
if ( $_[0]-> {cursorWrap} || $_[0]-> {wordWrap}) {
my $y = $_[0]-> cursorY;
if ( $x + $d > length( $_[0]-> get_line( $y))) {
if ( $d == 1) {
$_[0]-> cursor( 0, $y + 1) if $y < $_[0]-> {maxLine};
} else {
$_[0]-> cursor_right( $d - 1);
}
} else {
$_[0]-> cursorX( $x + $d);
}
} else {
$_[0]-> cursorX( $x + $d);
}
}
sub cursor_home
{
my ($spaces) = ($_[0]-> get_line( $_[0]-> cursorY) =~ /^([s\t]*)/);
$_[0]-> begin_undo_group;
$_[0]-> offset(0);
$_[0]-> cursorX(0);
$_[0]-> end_undo_group;
}
sub cursor_end
{
my ($nonspaces) = ($_[0]-> get_line( $_[0]-> cursorY) =~ /^(.*?)[\s\t]*$/);
$_[0]-> cursorX( length $nonspaces);
}
sub cursor_cend {
$_[0]-> cursor( 0, -1 );
$_[0]-> cursor_end;
#print "cursor_cend\n";
$_[0]-> area if $_[0]-> {hiliteBlok_modified} && @{$_[0]->{hiliteBlok}};
}
sub cursor_chome {
$_[0]-> cursor( 0, 0 );
#print "cursor_chome\n";
$_[0]-> area if $_[0]-> {hiliteBlok_modified} && @{$_[0]->{hiliteBlok}};
}
#----------------------------------------------
sub cursor_cpgup
{
my @xy = (0,0);
#print "cursor_cpgup\n";
if ( $_[0]->{cursorYl} > $_[0]->topLine ) {
@xy = ( $_[0]-> {cursorXl}, $_[0]->topLine );
}
$_[0]-> cursorLog( @xy );
$_[0]-> area if $_[0]-> {hiliteBlok_modified} && @{$_[0]->{hiliteBlok}};
}
#----------------------------------------------
sub cursor_cpgdn
{
my @xy = ( 0, -1 );
#print "cursor_cpgdn\n";
if ( $_[0]->{cursorYl} < $_[0]->topLine + $_[0]->{rows} - 1 ) {
@xy = ( $_[0]-> {cursorXl}, $_[0]->topLine + $_[0]->{rows} - 1 );
}
$_[0]-> cursorLog( @xy );
$_[0]-> area if $_[0]-> {hiliteBlok_modified} && @{$_[0]->{hiliteBlok}};
# my $cy = $_[0]->{cursorYl} == $_[0]->topLine + $_[0]->{rows} - 1 ? 0 : $_[0]->topLine + $_[0]->{rows};
# $_[0]-> cursorLog( $_[0]-> {cursorXl}, $cy - 1 );
}
#----------------------------------------------
sub cursor_pgup
{
my $d = $_[1] || 1;
my $i;
my @xy = $_[0]->cursor;
for ( $i = 0; $i < $d; $i++) {
my ( $tl, $r) = ($_[0]-> topLine , $_[0]-> {rows} );
my $cy = $tl - $r;
$_[0]-> cursorLog( $_[0]-> {cursorXl}, $cy < 0 ? 0 : $cy);
$_[0]-> cursorLog( $_[0]-> {cursorXl}, $xy[1] < $r ? 0 : $xy[1] - $r );
$_[0]-> area( $_[0]->{topLine}, $_[0]->{rows} ) if $_[0]-> {hiliteBlok_modified} && @{$_[0]->{hiliteBlok}};
}
}
#----------------------------------------------
sub cursor_pgdn {
my $d = $_[1] || 1;
my $i;
my @xy = $_[0]->cursor;
for ( $i = 0; $i < $d; $i++) {
my ( $tl, $r) = ($_[0]-> topLine , $_[0]-> {rows} - 1);
my $cy = $tl + 2*$r + 1;
$_[0]-> cursorLog( $_[0]-> {cursorXl}, $cy);
$_[0]-> cursorLog( $_[0]-> {cursorXl}, $xy[1] + $r + 1 );
$_[0]-> area( $_[0]->{topLine}, $_[0]->{rows} ) if $_[0]-> {hiliteBlok_modified} && @{$_[0]->{hiliteBlok}};
}
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
my $d = $_[1] || 1;
my $i;
for ( $i = 0; $i < $d; $i++) {
my ( $x, $y, $w, $delta, $maxY) = (
$self-> cursorX, $self-> cursorY,
$self-> wordDelimiters, 0, $self-> {maxLine}
);
my $line = $self-> get_line( $y);
my $clen = length( $line);
if ($self-> {cursorWrap}) {
while ( $x >= $clen) {
$y++;
return if $y > $maxY;
$x = 0;
$line = $self-> get_line( $y);
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
}
if ( $x + $delta < $clen) {
$delta++ while ( $w =~ quotemeta substr $line, $x + $delta, 1) &&
$x + $delta < $clen;
}
$self-> cursor( $x + $delta, $y);
}
}
sub word_left
{
my $self = $_[0];
my $d = $_[1] || 1;
my $i;
for ( $i= 0;$i<$d; $i++) {
my ( $x, $y, $w, $delta) =
( $self-> cursorX, $self-> cursorY, $self-> wordDelimiters, 0);
my $line = $self-> get_line( $y);
my $clen = length( $line);
if ($self-> {cursorWrap}) {
while ( $x == 0) {
$y--;
$y = 0, last if $y < 0;
$line = $self-> get_line( $y);
$x = $clen = length( $line);
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
if ( $x + $delta > 0)
{
$delta-- while (!( $w =~ quotemeta( substr( $line, $x + $delta - 1, 1))) &&
( $x + $delta > 0))
}
$self-> cursor( $x + $delta, $y);
}
}
sub cursor_shift_key
{
my ( $self, $menuItem) = @_;
$self-> begin_undo_group;
$self-> start_block unless exists $self-> {anchor};
$menuItem =~ s/Shift//;
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$action = $self-> can( $action, 0) unless ref $action;
$self-> {delayPanning} = 1;
$self-> blockShiftMark(1);
$action-> ( @_);
$self-> blockShiftMark(0);
$self-> selection( @{$self-> {anchor}}, $self-> {cursorX}, $self-> {cursorY});
$self-> realize_panning;
$self-> end_undo_group;
}
sub blockShiftMark
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$self-> blockType( bt::Vertical);
$self-> {restorePersistentBlock} = 1
unless $self-> persistentBlock;
$self-> persistentBlock( 1);
$self-> cursor_shift_key(q(ShiftCursorRight));
}
}
sub mark_horizontal
{
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$self-> {restorePersistentBlock} = 1 unless $self-> persistentBlock;
$self-> persistentBlock( 1);
$self-> start_block;
$self-> selection(
$self-> make_physical( 0, $self-> {cursorYl}),
$self-> make_physical( -1, $self-> {cursorYl})
);
}
}
sub set_line
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$a[2], $a[3] - $fh * ( $_from - $tl)
);
} else {
$self-> repaint;
}
$self-> cursor( $self-> cursor);
$self-> end_undo_group;
$self-> notify(q(Change)) unless $self-> {notifyChangeLock};
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
) if $self-> {hScroll};
last;
}
}
}
$self-> cursor( $self-> cursor);
$self-> end_undo_group;
$self-> repaint;
$self-> notify(q(Change)) unless $self-> {notifyChangeLock};
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
substr( $c, 0, $end) = '';
$self-> set_line( $pey, $c, q(delete), 0, $end);
$ey--;
}
$self-> delete_line( $sy, $ey - $sy + 1) if $ey >= $sy;
$self-> cursor( $self-> {cursorX}, $psy);
$self-> unlock;
$self-> lock_change(0);
$self-> end_undo_group;
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
}
sub delete_char
{
my $self = $_[0];
$self-> delete_text( $self-> cursor, $_[1] || 1);
}
sub back_char
{
my $self = $_[0];
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$self-> delete_block;
return;
}
}
my @c = $self-> cursor;
my $d = $_[1] || 1;
$self-> begin_undo_group;
if ( $c[0] >= $d) {
$self-> delete_text( $c[0] - $d, $c[1], $d);
$self-> cursorX( $c[0] - $d);
} elsif ( $c[1] > 0) {
$self-> cursor( -1, $c[1] - 1);
$self-> delete_text( -1, $c[1] - 1);
}
$self-> end_undo_group;
}
sub delete_current_chunk
{
my $self = $_[0];
$self-> delete_chunk( $self-> {cursorYl});
}
sub delete_to_end
{
my $self = $_[0];
my @cs = $self-> cursor;
my $c = $self-> get_line( $cs[1]);
return if $cs[ 0] > length( $c);
$self-> set_line( $cs[1], substr( $c, 0, $cs[0]), q(delete), $cs[0], length( $c) - $cs[0]);
}
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
}
$self-> unlock;
$self-> lock_change(0);
}
$self-> cursorLog( $sel[0], $sel[1]);
$self-> cancel_block;
$self-> end_undo_group;
}
sub copy_block
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
my $i;
for ( $i = $sel[1]; $i <= $sel[3]; $i++) {
push @lines, $self-> get_line( $i);
}
$self-> insert_line( $self-> cursorY, @lines);
} else {
my @lines;
my $i;
for ( $i = $sel[1]; $i <= $sel[3]; $i++) {
my $c = $self-> get_line( $i);
$c .= ' ' x ($sel[2]-length($c))
if length($c) < $sel[2];
push( @lines, substr( $c, $sel[0], $sel[2]-$sel[0]));
}
my @cs = $self-> cursor;
for ( $i = $cs[1]; $i < $cs[1] + scalar @lines; $i++) {
my $c = $self-> get_line( $i);
$c .= ' 'x($cs[0]-length($c)) if length($c) < $cs[0];
substr( $c, $cs[0], 0) = $lines[ $i - $cs[1]];
$self-> set_line( $i, $c);
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
for ( $i = $sel[1]; $i <= $sel[3]; $i++) {
my $c = $self-> get_line( $i);
$c .= ' ' x ($sel[2]-length($c)) if length($c) < $sel[2];
push( @lines, substr( $c, $sel[0], $sel[2]-$sel[0]));
}
my @cs = $self-> cursor;
my $bx = $sel[3] - $sel[1] + 1;
for ( $i = $cs[1]; $i < $cs[1] + scalar @lines; $i++) {
my $c = $self-> get_line( $i);
$c .= ' ' x ($cs[0]-length($c))
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
}
sub split_line
{
my $self = $_[0];
my @cs = $self-> cursor;
my $c = $self-> get_line( $cs[1]);
$c .= ' 'x($cs[0]-length($c)) if length($c) < $cs[0];
my ( $old, $new) = ( substr( $c, 0, $cs[0]), substr( $c, $cs[0], length( $c) - $cs[0]));
$self-> lock_change(1);
$self-> begin_undo_group;
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
$new = $add.$new, $cshift = length( $add)
if length( $add) < length( $old);
}
$self-> insert_line( $cs[1]+1, $new);
$self-> cursor( $cshift, $cs[1] + 1);
$self-> end_undo_group;
$self-> lock_change(0);
}
sub begin_undo_group
lib/Prima/CodeManager/Edit.pm view on Meta::CPAN
sub select_all { $_[0]-> selection(0,0,-1,-1); }
sub autoIndent {($#_)?($_[0]-> {autoIndent} = $_[1]) :return $_[0]-> {autoIndent } }
sub blockType {($#_)?($_[0]-> set_block_type ( $_[1])) :return $_[0]-> {blockType} }
sub cursor {($#_)?($_[0]-> set_cursor ($_[1],$_[2])) :return $_[0]-> {cursorX},$_[0]-> {cursorY}}
sub cursorLog {($#_)?($_[0]-> set_cursor ($_[0]-> make_physical($_[1],$_[2]))) :return $_[0]-> {cursorXl},$_[0]-> {cursorYl}}
sub cursorX {($#_)?($_[0]-> set_cursor ($_[1],$_[0]-> {cursorY})):return $_[0]-> {cursorX} }
sub cursorY {($#_)?($_[0]-> set_cursor ($_[0]-> {q(cursorX)},$_[1])):return $_[0]-> {cursorY} }
sub cursorWrap {($#_)?($_[0]-> {cursorWrap }=$_[1]) :return $_[0]-> {cursorWrap }}
sub topLine {($#_)?($_[0]-> set_top_line ( $_[1])) :return $_[0]-> {topLine } }
sub hiliteNumbers {($#_)?$_[0]-> set_hilite_numbers ($_[1]) :return $_[0]-> {hiliteNumbers} }
sub hiliteQStrings {($#_)?$_[0]-> set_hilite_q_strings($_[1]) :return $_[0]-> {hiliteQStrings} }
sub hiliteQQStrings {($#_)?$_[0]-> set_hilite_qq_strings($_[1]) :return $_[0]-> {hiliteQQStrings} }
sub hiliteChars {($#_)?$_[0]-> set_hilite_chars ($_[1]) :return $_[0]-> {hiliteChars } }
Cog
view release on metacpan or search on metacpan
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
},
_mouseMove: function(event) {
// Only check for mouseups outside the document if you've moved inside the document
// at least once. This prevents the firing of mouseup in the case of IE<9, which will
// fire a mousemove event if content is placed under the cursor. See #7778
// Support: IE <9
if ( this._mouseMoved ) {
// IE mouseup check - mouseup happened when mouse was out of window
if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
return this._mouseUp(event);
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
_keyEvent: function( keyEvent, event ) {
if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
this._move( keyEvent, event );
// prevents moving cursor to beginning/end of the text field in some browsers
event.preventDefault();
}
}
});
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
nodeName = target.nodeName.toLowerCase();
if (nodeName === "input") {
target.disabled = false;
inst.trigger.filter("button").
each(function() { this.disabled = false; }).end().
filter("img").css({opacity: "1.0", cursor: ""});
} else if (nodeName === "div" || nodeName === "span") {
inline = $target.children("." + this._inlineClass);
inline.children().removeClass("ui-state-disabled");
inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
prop("disabled", false);
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
nodeName = target.nodeName.toLowerCase();
if (nodeName === "input") {
target.disabled = true;
inst.trigger.filter("button").
each(function() { this.disabled = true; }).end().
filter("img").css({opacity: "0.5", cursor: "default"});
} else if (nodeName === "div" || nodeName === "span") {
inline = $target.children("." + this._inlineClass);
inline.children().addClass("ui-state-disabled");
inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
prop("disabled", true);
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
inst.lastVal = null;
$.datepicker._lastInput = input;
$.datepicker._setDateFromField(inst);
if ($.datepicker._inDialog) { // hide cursor
input.value = "";
}
if (!$.datepicker._pos) { // position below input
$.datepicker._pos = $.datepicker._findPos(input);
$.datepicker._pos[1] += input.offsetHeight; // add the height
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
addClasses: true,
appendTo: "parent",
axis: false,
connectToSortable: false,
containment: false,
cursor: "auto",
cursorAt: false,
grid: false,
handle: false,
helper: "original",
iframeFix: false,
opacity: false,
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
//Generate the original position
this.originalPosition = this.position = this._generatePosition( event, false );
this.originalPageX = event.pageX;
this.originalPageY = event.pageY;
//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
//Set a containment if given in the options
this._setContainment();
//Trigger event + callbacks
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
}
});
}
});
$.ui.plugin.add("draggable", "cursor", {
start: function( event, ui, instance ) {
var t = $( "body" ),
o = instance.options;
if (t.css("cursor")) {
o._cursor = t.css("cursor");
}
t.css("cursor", o.cursor);
},
stop: function( event, ui, instance ) {
var o = instance.options;
if (o._cursor) {
$("body").css("cursor", o._cursor);
}
}
});
$.ui.plugin.add("draggable", "opacity", {
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
return !this.options.disabled && capture;
},
_mouseStart: function(event) {
var curleft, curtop, cursor,
o = this.options,
el = this.element;
this.resizing = true;
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
this.aspectRatio = (typeof o.aspectRatio === "number") ?
o.aspectRatio :
((this.originalSize.width / this.originalSize.height) || 1);
cursor = $(".ui-resizable-" + this.axis).css("cursor");
$("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
el.addClass("ui-resizable-resizing");
this._propagate("start", event);
return true;
},
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
if (this._helper && !o.animate) {
this._proportionallyResize();
}
}
$("body").css("cursor", "auto");
this.element.removeClass("ui-resizable-resizing");
this._propagate("stop", event);
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
options: {
appendTo: "parent",
axis: false,
connectWith: false,
containment: false,
cursor: "auto",
cursorAt: false,
dropOnEmpty: true,
forcePlaceholderSize: false,
forceHelperSize: false,
grid: false,
handle: false,
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
//Generate the original position
this.originalPosition = this._generatePosition(event);
this.originalPageX = event.pageX;
this.originalPageY = event.pageY;
//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
//Cache the former DOM position
this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
//If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
//Set a containment if given in the options
if(o.containment) {
this._setContainment();
}
if( o.cursor && o.cursor !== "auto" ) { // cursor option
body = this.document.find( "body" );
// support: IE
this.storedCursor = body.css( "cursor" );
body.css( "cursor", o.cursor );
this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
}
if(o.opacity) { // opacity option
if (this.helper.css("opacity")) {
this._storedOpacity = this.helper.css("opacity");
share/js/jquery-ui-1.11.4.js view on Meta::CPAN
}
}
//Do what was originally in plugins
if ( this.storedCursor ) {
this.document.find( "body" ).css( "cursor", this.storedCursor );
this.storedStylesheet.remove();
}
if(this._storedOpacity) {
this.helper.css("opacity", this._storedOpacity);
}
Collectd-Plugins-Amavis
view release on metacpan or search on metacpan
lib/Collectd/Plugins/Amavis.pm view on Meta::CPAN
my $db = BerkeleyDB::Hash->new(
-Filename => $db_file,
-Env => $env
) or die "could not open db: $!";
my $cursor = $db->db_cursor;
my ( $key, $val ) = ('','');
while ( $cursor->c_get($key,$val,DB_NEXT) == 0 ) {
if( $val !~ s/^(?:C32|C64|INT) //) {
next;
}
$val = int( $val );
$key =~ s/([a-z])([A-Z])/$1_$2/g;
Complete-Bash
view release on metacpan or search on metacpan
lib/Complete/Bash.pm view on Meta::CPAN
v => 1.1,
summary => 'Return line with point marked by a marker',
description => <<'_',
This is a utility function useful for testing/debugging. `parse_cmdline()`
expects a command-line and a cursor position (`$line`, `$point`). This routine
expects `$line` with a marker character (by default it's the caret, `^`) and
return (`$line`, `$point`) to feed to `parse_cmdline()`.
Example:
lib/Complete/Bash.pm view on Meta::CPAN
description => <<'_',
Optional. Known options:
* `truncate_current_word` (bool). If set to 1, will truncate current word to the
position of cursor, for example (`^` marks the position of cursor):
`--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
doing tab completion.
_
schema => 'hash*',
lib/Complete/Bash.pm view on Meta::CPAN
# this is a workaround. since bash breaks words using characters in
# $COMP_WORDBREAKS, which by default is "'@><=;|&(: this presents a problem
# we often encounter: if we want to provide with a list of strings
# containing say ':', most often Perl modules/packages, if user types e.g.
# "Text::AN" and we provide completion ["Text::ANSI"] then bash will change
# the word at cursor to become "Text::Text::ANSI" since it sees the current
# word as "AN" and not "Text::AN". the workaround is to chop /^Text::/ from
# completion answers. btw, we actually chop /^text::/i to handle
# case-insensitive matching, although this does not have the ability to
# replace the current word (e.g. if we type 'text::an' then bash can only
# replace the current word 'an' with 'ANSI).
lib/Complete/Bash.pm view on Meta::CPAN
% somecmd t<Tab>
two three
Another source is from a bash function (C<-F>). The function will receive input
in two variables: C<COMP_WORDS> (array, command-line chopped into words) and
C<COMP_CWORD> (integer, index to the array of words indicating the cursor
position). It must set an array variable C<COMPREPLY> that contains the list of
possible completion:
% _foo()
{
lib/Complete/Bash.pm view on Meta::CPAN
% foo <Tab>
--help --verbose --version
And yet another source is an external command (C<-C>) including, from a Perl
script. The command receives two environment variables: C<COMP_LINE> (string,
raw command-line) and C<COMP_POINT> (integer, cursor location). Program must
split C<COMP_LINE> into words, find the word to be completed, complete that, and
return the list of words one per-line to STDOUT. An example:
% cat foo-complete
#!/usr/bin/perl
lib/Complete/Bash.pm view on Meta::CPAN
Optional. Known options:
=over
=item * C<truncate_current_word> (bool). If set to 1, will truncate current word to the
position of cursor, for example (C<^> marks the position of cursor):
C<--vers^oo> to C<--vers> instead of C<--versoo>. This is more convenient when
doing tab completion.
=back
lib/Complete/Bash.pm view on Meta::CPAN
point($cmdline, $marker) -> any
Return line with point marked by a marker.
This is a utility function useful for testing/debugging. C<parse_cmdline()>
expects a command-line and a cursor position (C<$line>, C<$point>). This routine
expects C<$line> with a marker character (by default it's the caret, C<^>) and
return (C<$line>, C<$point>) to feed to C<parse_cmdline()>.
Example:
Complete-Getopt-Long
view release on metacpan or search on metacpan
lib/Complete/Getopt/Long.pm view on Meta::CPAN
single dash will be completed. For example if you have `-foo=s` in your option
specification, `-f<tab>` can complete it.
This can be used to complete old-style programs, e.g. emacs which has options
like `-nw`, `-nbc` etc (but also have double-dash options like
`--no-window-system` or `--no-blinking-cursor`).
_
},
},
result_naked => 1,
lib/Complete/Getopt/Long.pm view on Meta::CPAN
single dash will be completed. For example if you have C<-foo=s> in your option
specification, C<< -fE<lt>tabE<gt> >> can complete it.
This can be used to complete old-style programs, e.g. emacs which has options
like C<-nw>, C<-nbc> etc (but also have double-dash options like
C<--no-window-system> or C<--no-blinking-cursor>).
=item * B<completion> => I<code>
Completion routine to complete option valueE<sol>argument.
Compress-Deflate7
view release on metacpan or search on metacpan
7zip/CPP/7zip/UI/FileManager/BrowseDialog.cpp view on Meta::CPAN
Path += WCHAR_PATH_SEPARATOR;
LVITEMW item;
int index = 0;
int cursorIndex = -1;
#ifndef _SFX
if (_showDots)
{
UString itemName = L"..";
item.iItem = index;
if (selectedName.IsEmpty())
cursorIndex = item.iItem;
item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
int subItem = 0;
item.iSubItem = subItem++;
item.lParam = kParentIndex;
item.pszText = (wchar_t *)(const wchar_t *)itemName;
7zip/CPP/7zip/UI/FileManager/BrowseDialog.cpp view on Meta::CPAN
for (int i = 0; i < _files.Size(); i++)
{
const CFileInfoW &fi = _files[i];
item.iItem = index;
if (fi.Name.CompareNoCase(selectedName) == 0)
cursorIndex = item.iItem;
item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
int subItem = 0;
item.iSubItem = subItem++;
item.lParam = i;
item.pszText = (wchar_t *)(const wchar_t *)fi.Name;
7zip/CPP/7zip/UI/FileManager/BrowseDialog.cpp view on Meta::CPAN
_list.SetSubItem(index, subItem++, s);
}
index++;
}
if (_list.GetItemCount() > 0 && cursorIndex >= 0)
_list.SetItemState_FocusedSelected(cursorIndex);
_list.SortItems(CompareItems2, (LPARAM)this);
if (_list.GetItemCount() > 0 && cursorIndex < 0)
_list.SetItemState(0, LVIS_FOCUSED, LVIS_FOCUSED);
_list.EnsureVisible(_list.GetFocusedItem(), false);
_list.SetRedraw(true);
return S_OK;
}
Compress-Stream-Zstd
view release on metacpan or search on metacpan
ext/zstd/lib/dictBuilder/zdict.c view on Meta::CPAN
}
DISPLAYLEVEL(2, "finding patterns ... \n");
DISPLAYLEVEL(3, "minimum ratio : %u \n", minRatio);
{ U32 cursor; for (cursor=0; cursor < bufferSize; ) {
dictItem solution;
if (doneMarks[cursor]) { cursor++; continue; }
solution = ZDICT_analyzePos(doneMarks, suffix, reverseSuffix[cursor], buffer, minRatio, notificationLevel);
if (solution.length==0) { cursor++; continue; }
ZDICT_insertDictItem(dictList, dictListSize, solution, buffer);
cursor += solution.length;
DISPLAYUPDATE(2, "\r%4.2f %% \r", (double)cursor / (double)bufferSize * 100.0);
} }
_cleanup:
free(suffix0);
free(reverseSuffix);
Compress-Zstd
view release on metacpan or search on metacpan
ext/zstd/lib/dictBuilder/zdict.c view on Meta::CPAN
}
DISPLAYLEVEL(2, "finding patterns ... \n");
DISPLAYLEVEL(3, "minimum ratio : %u \n", minRatio);
{ U32 cursor; for (cursor=0; cursor < bufferSize; ) {
dictItem solution;
if (doneMarks[cursor]) { cursor++; continue; }
solution = ZDICT_analyzePos(doneMarks, suffix, reverseSuffix[cursor], buffer, minRatio, notificationLevel);
if (solution.length==0) { cursor++; continue; }
ZDICT_insertDictItem(dictList, dictListSize, solution, buffer);
cursor += solution.length;
DISPLAYUPDATE(2, "\r%4.2f %% \r", (double)cursor / bufferSize * 100);
} }
_cleanup:
free(suffix0);
free(reverseSuffix);
Config-Augeas-Validator
view release on metacpan or search on metacpan
lib/Config/Augeas/Validator.pm view on Meta::CPAN
sub play {
my ($self, @infiles) = @_;
my @files;
if ($self->{recurse}) {
printf "\033[?25l"; # hide cursor
print colored ("I: Recursively analyzing directories ", COLOR_INFO) unless $self->{quiet};
find sub {
my $exclude = $self->{exclude};
$exclude ||= '^$';
push @files, $File::Find::name
if(-e && $File::Find::name !~ /^$exclude$/);
$self->tick unless $self->{quiet}
}, @infiles;
print colored("[done]", COLOR_OK),"\n" unless $self->{quiet};
printf "\033[?25h"; # restore cursor
} elsif ($#infiles < 0) {
@files = $self->get_all_files();
$self->{syswide} = 1;
}else {
@files = @infiles;
Config-Model-LcdProc
view release on metacpan or search on metacpan
lib/Config/Model/models/LCDd/EyeboxOne.pl view on Meta::CPAN
'upstream_default' => 'yes',
'value_type' => 'uniline'
},
'Cursor',
{
'description' => 'Switch on the cursor? ',
'type' => 'leaf',
'upstream_default' => 'no',
'value_type' => 'uniline'
},
'Device',
Config-Model-TkUI
view release on metacpan or search on metacpan
lib/Config/Model/TkUI.pm view on Meta::CPAN
-tree_width => [ 'METHOD', undef, undef, 80 ],
-tree_height => [ 'METHOD', undef, undef, 30 ],
-width => [ $eh_frame, qw/width Width 1280/ ],
-height => [ $eh_frame, qw/height Height 1024/ ],
-selectmode => [ $tree, 'selectMode', 'SelectMode', 'single' ], #single',
#-oldcursor => [$hlist, undef, undef, undef],
DEFAULT => [$tree] );
$cw->Advertise( tree => $tree );
$cw->Advertise( menubar => $menubar );
$cw->Advertise( right_frame => $eh_frame );
( run in 0.460 second using v1.01-cache-2.11-cpan-4d50c553e7e )