c# pdf viewer itextsharp : Rearrange pdf pages online application software utility azure windows wpf visual studio Windows%20Powershell%20in%20Action%202nd%20Edition70-part1528

670
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
16.1.5
The -LiteralPath parameter
You don’t have to turn to trial and error when you know the name of the file and 
want to suppress all pattern-matching behavior. You can accomplish this by using the 
-LiteralPath
parameter available on most core cmdlets. Say you want to copy a file 
from the previous example. If you use the regular path mechanism in 
Copy-Item
PS (11) > Copy-Item thumb[1].jpg c:\temp\junk.jpg 
PS (12) > Get-ChildItem c:\temp\junk.jpg 
Get-ChildItem : Cannot find path 'C:\temp\junk.jpg' because
it does not exist.
At line:1 char:4 
+ dir  <<<< c:\temp\junk.jpg
the copy fails because the square brackets were treated as pattern-matching metachar-
acters. Now try it using 
-LiteralPath
:
PS (13) > Copy-Item -literalpath thumb[1].jpg c:\temp\junk.jpg 
PS (14) > Get-ChildItem c:\temp\junk.jpg
Directory: Microsoft.PowerShell.Core\FileSystem::C:\temp
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
-a---          7/8/2006   7:58 PM       2066 junk.jpg
This time it works properly. When you pipe the output of a cmdlet such as 
Get-
ChildItem
into another cmdlet like 
Remove-Item
, the 
-LiteralPath
parameter is 
used to couple the cmdlets so that metacharacters in the paths returned by 
dir
don’t 
cause problems for 
Remove-Item
. If you want to delete the files we were looking at 
earlier, you can use 
Get-ChildItem
to see them:
PS (16) > Get-ChildItem thumb````[*
Directory: Microsoft.PowerShell.Core\FileSystem::C:\Doc
uments and Settings\brucepay\Local Settings\Temporary
Internet Files\Content.IE5\MYNBM9OJ
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
-a---          7/8/2006   7:58 PM       2066 thumb[1].jpg 
-a---         9/11/2006   2:48 PM      12476 thumb[2].txt 
-a---         9/11/2006   2:48 PM      11933 thumb[3].txt
Now pipe the output of 
Get-ChildItem
into 
Remove-Item
PS (17) > Get-ChildItem thumb````[* | Remove-Item
and verify that they’ve been deleted:
PS (18) > Get-ChildItem thumb````[*
No files are found, so the deletion was successful.
Rearrange pdf pages online - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
how to move pages in a pdf; pdf reverse page order preview
Rearrange pdf pages online - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
reorder pdf pages online; move pages in pdf document
P
OWER
S
HELL
AND
PATHS
671
This essentially covers the issues around working with file paths. From here we 
can move on to working with the file contents.
16.1.6
The Registry provider
PowerShell uses paths to access many types of hierarchical information on a Windows 
computer. One of the most important (okay, maybe the most important) types of 
hierarchical information is the Registry. The Registry is a store of hierarchical config-
uration information, much like the file system. But there’s one significant difference: 
in the Registry, a container has two axes: children and properties or, as you’re more 
used to calling them from hashtables, keys and values. This is one of the more com-
plex scenarios that the provider model addresses.
In the Registry provider, it’s no longer sufficient to just have the path; you also 
need to know whether you’re accessing a name or a property. Let’s take a look. Start 
by 
cd
’ing to the PowerShell hive in the Registry:
PS (1) > cd hklm:\software\microsoft\powershell
Use 
dir
to see what’s there:
PS (2) > dir
Hive: HKEY_LOCAL_MACHINE\software\microsoft\powershell
SKC  VC Name                           Property 
---  -- ----                           --------
  2 1                              {Install, PID}
Unfortunately, the default display for a Registry entry is a bit cryptic. We’ll 
Format-
List
to make it a bit more comprehensible:
PS (3) > dir | Format-List
Name        : 1 
ValueCount  : 2 
Property    : {Install, PID} 
SubKeyCount : 4
This code is quite a bit clearer. In this path you find a single item named 1. This item 
has two properties, or values, associated with it and four children, or subkeys. Now 
cd
into the container and run 
Get-ChildItem
again:
PS (4) > cd ./1 
PS (5) > Get-ChildItem
Hive: HKEY_LOCAL_MACHINE\software\microsoft\powershell\1
SKC  VC Name                           Property 
---  -- ----                           --------
  1 0409                           {Install}
  7 PowerShellEngine               {ApplicationBase, PSCompati...
  0 PSConfigurationProviders       {}
  0 ShellIds                       {}
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
rearrange pages in pdf reader; change pdf page order
Online Merge PDF files. Best free online merge PDF tool.
Then press the button below and download your PDF. By dragging your pages in the editor area you can rearrange them or delete single pages.
how to rearrange pdf pages online; reorder pages pdf file
672
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
You see information about the subkeys. But what about accessing the properties? You 
do this using the 
Get-ItemProperty
cmdlet. To get the value of the PowerShell 
Product 
ID
property, use the following:
PS (6) > Get-ItemProperty -Path . -Name PID
PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE
\software\microsoft\powershell\1
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE
\software\microsoft\powershell
PSChildName  : 1
PSDrive      : HKLM
PSProvider   : Microsoft.PowerShell.Core\Registry 
PID          : 89383-100-0001260-04309
Notice  that you  need to specify both the path and the name of the property to 
retrieve. Properties are always relative to a path. By specifying 
.
as the path, the prop-
erty is relative to the current directory. There’s another somewhat annoying thing 
about how 
Get-ItemProperty
works. It doesn’t return the value of the property; it 
returns a new object that has the property value as a member. So, before you can do 
anything with this value, you need to extract it from the containing object:
PS (9) > (Get-ItemProperty -Path . -Name PID).PID 
89383-100-0001260-04309
By using the 
.
operator to extract the member’s value, you can get just the value.
NOTE
This is another one of those design trade-offs the PowerShell 
team encountered as we developed this environment. If we returned 
just the value, we’d lose the context for the value (where it came from, 
and so on.) And so, in order to preserve this information, the team 
ended up forcing people to write what appears to be redundant code. A 
better way to handle this might’ve been to return the value with the 
context attached as synthetic properties.
16.2
F
ILE
PROCESSING
Let’s recap and see where we are. You know that PowerShell has a provider abstrac-
tion allowing users to work with system data stores as though they were drives. A 
provider is an installable software component that surfaces a data store in a form that 
can be mounted as a “drive.” These drives are a PowerShell fiction; that is, they have 
meaning only to PowerShell as opposed to system drives that have meaning every-
where. Also, unlike the system drives, PowerShell drive names can be longer than 
one character.
You’ve already seen some examples of non-file-system providers in earlier chap-
ters, where we worked with the variable: and function: drives. These providers let you 
use the 
New-Item
and 
Remove-Item
cmdlets to add and remove variables or func-
tions just as if they were files.
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
you want to change or rearrange current TIFF &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
change page order pdf preview; reorder pages in pdf document
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
a PDF document which is out of order, you need to rearrange the PDF you with examples for adding an (empty) page to a PDF and adding empty pages to a
how to move pages in pdf; how to move pages in a pdf document
F
ILE
PROCESSING
673
A key piece to making this provider abstraction is the set of core cmdlets listed in 
table 16.1. These cmdlets are the core set of commands for manipulating the system 
and correspond to commands found in other shell environments. Because these com-
mands are used so frequently, short aliases—the canonical aliases—are provided for 
the commands. By canonical, we mean that they follow a standard form: usually the 
first letter or two of the verb followed by the first letter or two of the noun. Two 
additional sets of “user portability” aliases are provided to help new users work with 
the system. There’s one set for 
cmd.exe
users and one set for 
UNIX
shell users. Note 
that these aliases map only the name; they don’t provide exact functional correspon-
dence to either the 
cmd.exe
or 
UNIX
commands.
Online help is available for all of these commands; type
help cmdlet-name
and you’ll receive detailed help on the cmdlets, their parameters, and some simple 
examples showing how to use them.
Table 16.1 List of core cmdlets, aliases, and equivalents in other shells
Cmdlet name
Canonical Cmd.exe
UNIX sh
Description
Get-Location
gl
cd
pwd
Get the current directory.
Set-Location
sl
cd, chdir
cd, chdir
Change the current directory.
Copy-Item
cpi
copy
cp
Copy files.
Remove-Item
ri
del, rd
rm, rmdir
Remove a file or directory. PowerShell 
has no separate command for removing 
directories as opposed to files.
Move-Item
mi
move
mv
Move a file.
Rename-Item
rni
ren
mv
Rename a file.
Set-Item
si
Set the contents of a file.
Clear-Item
cli
Clear the contents of a file.
New-Item
ni
Create a new empty file or directory. 
The type of object is controlled by the 
-ItemType parameter.
MkDir
md
mkdir
MkDir is implemented as a function in 
PowerShell so that users can create 
directories without having to specify 
-Type directory.
Get-Content
gc
type
cat
Send the contents of a file to the out-
put stream.
Set-Content
sc
Set the contents of a file. UNIX and 
cmd.exe have no equivalent. Redirec-
tion is used instead. The difference 
between Set-Content and Out-
File is discussed later in this chapter.
C# PowerPoint - How to Process PowerPoint
the simplest procedures, for instance, using online clear C# out useless PowerPoint document pages simply with solution to sort and rearrange PowerPoint slides
reorder pages in a pdf; how to reorder pdf pages in reader
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
well programmed Word pages sorter to rearrange Word pages in extracting single or multiple Word pages at one & profession imaging controls, PDF document, image
pdf move pages; change page order in pdf online
674
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
NOTE
The 
help
command (which is a wrapper function for 
Get-
Help
) also supports an 
-Online
parameter. This parameter will cause 
help information retrieved from Microsoft TechNet to be displayed 
using the default web browser rather than on the console. The online 
information is constantly being updated and corrected, so this is the 
best solution for getting help on PowerShell topics.
In the next few sections, we’ll look at some more sophisticated applications of these 
cmdlets, including how to deal with binary data. In traditional shell environments, 
binary data either required specialized commands or forced you to create new execut-
ables in a language such as 
C
, because the basic shell model couldn’t cope with binary 
data. You’ll see how PowerShell can work directly with binary data. But first, let’s take 
a minute to look at the PowerShell drive abstraction to simplify working with paths.
16.2.1
Reading and writing files
In PowerShell, files are read using the 
Get-Content
cmdlet. This cmdlet allows you 
to work with text files using a variety of character encodings. It also lets you work effi-
ciently with binary files, as you’ll see in a minute. Writing files is a bit more complex, 
because you have to choose between 
Set-Content
and 
Out-File
. The difference 
here is whether the output goes through the formatting subsystem. We’ll also explain 
this later on in this section. It’s important to point out that there are no separate 
open/read/close
or 
open/write/close
steps to working with files. The pipeline 
model allows you to process data, and never have to worry about closing file han-
dles—the system takes care of this for you.
Reading files with the Get-Content cmdlet
The 
Get-Content
cmdlet is the primary way to read files in PowerShell. Actually, it’s 
the primary way to read any content available through PowerShell drives. Figure 16.1 
shows a subset of the parameters available on the cmdlet.
Get-Content [-Path] <String[]> 
[-ReadCount <Int64>] 
[-TotalCount <Int64>] 
[-Delimiter <String>] 
[-Wait] 
[-Encoding <FileSystemCmdletProviderEncoding>]
Cmdlet name
Path to object to read
Total number of
objects to read
Encoding to use when
reading while
Switch parameter: if
specified, cmdlet waits
polling input until stopped
Line or record 
delimiter
Number of objects to
read in block
Figure 16.1 The 
Get-Content
cmdlet parameters. This cmdlet is used to read 
content from a content provider’s store.
Process Images in Web Image Viewer | Online Tutorials
used document types are supported, including PDF, multi-page easy to process image and file pages with the deleting a thumbnail, and you can rearrange the file
move pdf pages online; rearrange pdf pages reader
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
page will teach you to rearrange and readjust amount of robust PPT slides/pages editing methods and powerful & profession imaging controls, PDF document, image
reordering pdf pages; reorder pages in pdf reader
F
ILE
PROCESSING
675
Reading text files is simple. The command
Get-Content myfile.txt
will send the contents of myfile.txt to the output stream. Notice that the command 
signature for 
-Path
allows for an array of path names. This is how you concatenate a 
collection of files together. Let’s try this. First, create a collection of files:
PS (1) > 1..3 | foreach { "This is file $_" > "file$_.txt"} 
PS (2) > dir
Directory: Microsoft.PowerShell.Core\FileSystem::C:\Temp\fil
es
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
-a---          7/6/2006   8:33 PM         34 file1.txt 
-a---          7/6/2006   8:33 PM         34 file2.txt 
-a---          7/6/2006   8:33 PM         34 file3.txt
And now display their contents:
PS (3) > Get-Content file1.txt,file2.txt,file3.txt 
This is file 1 
This is file 2 
This is file 3
or simply
PS (4) > Get-Content *.txt 
This is file 1 
This is file 2 
This is file 3
In this example, the contents of file1.txt, file2.txt, and file3.txt are sent to the output 
stream in order. For 
cmd.exe
users, this is equivalent to
copy file1.txt+file2.txt+file3.txt con
Let’s try this in 
cmd.exe
:
C:\Temp\files>copy file1.txt+file2.txt+file3.txt con 
file1.txt
T h i s   i s   f i l e   1
file2.txt
h i s   i s   f i l e   2
file2.txt
h i s   i s   f i l e   3
1 file(s) copied.
The output looks funny because the files were written in Unicode. You need to tell 
the 
copy
command to write in 
ASCII
, and try it again:
C:\Temp\files>copy /a file1.txt+file2.txt+file3.txt con 
file1.txt 
This is file 1
676
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
file2.txt
This is file 2 
file2.txt 
This is file 3
1 file(s) copied.
By default, PowerShell uses Unicode for text, but you can override this. You’ll see 
how to do this in the section on writing files. In the meantime, let’s see how to work 
with binary files.
Example: the Get-HexDump function
Let’s look at an example that uses some of these features to deal with nontext files. 
You’re going to write a function that can be used to dump out a binary file. You’ll 
call this function 
Get-HexDump
. It takes the name of the file to display, the number 
of bytes to display per line, and the total number of bytes as parameters. You want 
the output of this function to look like the following:
PS (130) > Get-HexDump "$env:windir/Soap Bubbles.bmp" -w 12 -t 100 
42 4d ba 01 01 00 00 00 00 00 ba 01 BM ....... . 
00 00 28 00 00 00 00 01 00 00 00 01 ............ 
00 00 01 00 08 00 00 00 00 00 00 00 ............ 
01 00 12 0b 00 00 12 0b 00 00 61 00 ..........a. 
00 00 61 00 00 00 6b 10 10 00 73 10 ..a...k...s. 
10 00 73 18 18 00 7b 21 21 00 84 29 ..s......... 
29 00 84 31 31 00 6b 08 08 00 8c 39 ...11.k....9 
31 00 84 31 29 00 8c 31 31 00 7b 18 1..1...11... 
18 00 8c 39 ...9
In this example, you’re using 
Get-HexDump
to dump out the contents of one of the 
bitmap files in the Windows installation directory. You’ve specified that it display 12 
bytes per line and stop after the first 100 bytes. The first part of the display is the 
value of the byte in hexadecimal, and the portion on the right side is the character 
equivalent. Only values that correspond to letters or numbers are displayed. Non-
printable characters are shown as dots. The following listing shows the code for this 
function Get-HexDump ($path = $(throw "path must be specified"), 
$width=10, $total=-1) 
{
$OFS=""                      
Get-Content -Encoding byte $path -ReadCount $width `
-TotalCount $total | %{       
$record = $_
if (($record -eq 0).count -ne $width) 
{
$hex = $record | %{             
" " + ("{0:x}" -f $_).PadLeft(2,"0")} 
$char = $record | %{                 
if ([char]::IsLetterOrDigit($_))   
{ [char] $_ } else { "." }}   
Listing16.1    Get-HexDump
Set $OFS to 
empty
b
Skip record if 
length is zero
c
Format data
d
F
ILE
PROCESSING
677
"$hex $char"      
}
}
As required, the function takes a mandatory path parameter and optional parameters 
for the number of bytes per line and the total number of bytes to display. You’re going 
to be converting arrays to strings and you don’t want any spaces added, so you’ll set 
the output field separator character 
B
to be empty.
The 
Get-Content
cmdlet does all of the hard work. It reads the file in binary mode 
(indicated by setting encoding to byte), reads up to a maximum of 
-TotalCount
bytes, 
and writes them into the pipeline in records of length specified by 
-ReadCount
. The 
first thing you do in the 
foreach
scriptblock is save the record that was passed in, 
because you’ll be using nested scriptblocks that will cause 
$_
to be overwritten.
If the record is all zeros 
c
, you’re not going to bother displaying it. It might be a 
better design to make this optional, but we’ll leave it as is for this example. For dis-
play purposes, you’re converting the record of bytes 
d
into two-digit hexadecimal 
numbers. You use the format operator to format the string in hexadecimal and then 
the 
PadLeft()
method on strings to pad it out to two characters. Finally, you prefix 
the whole thing with a space. The variable 
$hex
ends up with a collection of these 
formatted strings.
Now you need to build the character equivalent of the record. You’ll use the 
methods on the 
[char]
class to decide whether you should display the character or a 
dot (.). Notice that even when you’re displaying the character, you’re still casting it 
into a 
[char]
. This is necessary because the record contains a byte value, which, if 
directly converted into a string, will be formatted as a number instead of as a charac-
ter. Finally, you’ll output the completed record, taking advantage of string expansion 
to build the output string (which is why you set 
$OFS
to 
""
).
This example illustrates the basic technique for getting at the binary data in a file. 
The technique has a variety of applications beyond simply displaying binary data, of 
course. Once you reach the data, you can determine a variety of characteristics about 
the content of that file. In the next section, we’ll look at an example and examine the 
content of a binary file to double-check on the type of that file.
Example: the Get-MagicNumber function
If you looked closely at the output from the 
BMP
file earlier, you might have noticed 
that the first two characters in the file were 
BP
. In fact, the first few bytes in a file are 
often used as a “magic number” that identifies the type of the file. You’ll write a short 
function called 
Get-MagicNumber
that displays the first four bytes of a file so you 
can investigate these magic numbers. Here’s what you want the output to look like. 
First, try this on a 
BMP
file:
PS (1) > Get-MagicNumber $env:windir/Zapotec.bmp 
424d 3225 'BM2.'
678
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
and then on an 
EXE
:
PS (2) > Get-MagicNumber $env:windir/explorer.exe 
4d5a 9000 'MZ..'
This utility dumps the header bytes of the executable. The first two bytes identify this 
file as an 
MS-DOS
executable.
NOTE
As you can see, the 
ASCII
representation of the header bytes 
(0x5A4D) is 
MZ
. These are the initials of Mark Zbikowski, one of the 
original architects of 
MS-DOS
.
The code for 
Get-MagicNumber
is shown in the following listing.
function Get-MagicNumber ($path) 
{
$OFS=""
$mn = Get-Content -Encoding byte $path -read 4 -total 4
$hex1 = ("{0:x}" -f ($mn[0]*256+$mn[1])).PadLeft(4, "0")
$hex2 = ("{0:x}" -f ($mn[2]*256+$mn[3])).PadLeft(4, "0")
[string] $chars = $mn| %{ if ([char]::IsLetterOrDigit($_))
{ [char] $_ } else { "." }}
"{0} {1} '{2}'" -f  $hex1, $hex2, $chars 
}
There’s not much that’s new in this function. Again, you set the output field separator 
string to be empty. You extract the first four bytes as two pairs of numbers formatted 
in hex and also as characters if they correspond to printable characters. Finally, you 
format the output as desired.
From these examples, you see that 
Get-Content
allows you to explore any type of 
file on a system, not just text files. For now, though, let’s return to text files and look 
at another parameter on 
Get-Content
-Delimiter
. When reading a text file, the 
default line delimiter is the newline character.
NOTE
The  end-of-line  sequence  on  Windows  is  generally  a  two-
character sequence: carriage return followed by newline. The .
NET I/O 
routines hide this detail and let us just pretend it’s a newline. In fact, 
the runtime will treat newline by itself, carriage return by itself, and the 
carriage return/newline sequence all as end-of-line sequences.
This parameter lets you change that. With this new knowledge, let’s return to the word-
counting problem from earlier. If you set the delimiter to be the space character instead 
of a newline, you can split the file as you read it. Let’s use this in an example that operates 
on one of the About help files included with PowerShell. Here’s the command:
Get-Content $pshome/en-us/about_Assignment_Operators.help.txt `
-Delimiter " " |
foreach { $_ -replace "[^\w]+"} |
where { $_ -notmatch "^[ `t]*`$"} |
Listing16.2    Get-MagicNumber
F
ILE
PROCESSING
679
group  |
sort -Descending count |
select -First 10 |
ft -auto name, count
The 
-Delimiter
parameter is used to split the file on space boundaries instead of 
newlines. You’re using the same group, sort, and format operations as before, but this 
time you’re sorting in descending order so you can use the 
Select-Object
cmdlet 
instead of array indexing to extract the top 10 words. You’re also doing more sophisti-
cated filtering. You’re using a 
foreach
filter to get rid of the characters that aren’t legal 
in a word. This is accomplished with the 
-replace
operator and the regular expres-
sion 
"[^\w]+".
The 
\w
pattern is a metacharacter that matches any legal character in 
a word. Putting it in the square brackets prefixed with the caret says it should match 
any character that isn’t valid in a word. The 
where
filter is used to discard any empty 
lines that may be in the text or that may have been created by the 
foreach
filter.
At this point, you should have a pretty good handle on reading files and process-
ing their contents. It’s time to look at the various ways to write files.
16.2.2
Writing files
There are two major ways to write files in PowerShell—by setting file content with 
the 
Set-Content
cmdlet and by writing files using the 
Out-File
cmdlet. The big 
difference is that 
Out-File
, like all the output cmdlets, tries to format the output. 
Set-Content
, on the other hand, simply writes the output. If its input objects aren’t 
already strings, it will convert them to strings by calling the 
ToString()
method. 
This isn’t usually what you want for objects, but it’s exactly what you want if your 
data is already formatted or if you’re working with binary data.
The other thing you need to be concerned with is how the files are encoded when 
they’re written. In an earlier example, you saw that, by default, text files are written in 
Unicode. Let’s rerun this example, changing the encoding to 
ASCII
instead:
PS (48) > 1..3 | %{ "This is file $_" | 
>> Set-Content -Encoding ascii file$_.txt } 
>>
The 
-Encoding
parameter is used to set how the files will be written. In this example, 
the files are written using 
ASCII
encoding. Now let’s rerun the 
cmd.exe
copy
exam-
ple that didn’t work earlier:
PS (49) > cmd /c copy file1.txt+file2.txt+file3.txt con 
file1.txt 
This is file 1 
file2.txt 
This is file 2 
file3.txt 
This is file 3
1 file(s) copied.
This time it works fine, because the encoding matches what 
cmd.exe
expected. In 
the next section, we’ll look at using 
-Encoding
to write binary files.
Documents you may be interested
Documents you may be interested