Sentence:
If your library is on a network and has the Dynix Gateways product , patrons and staff at your library can use gateways to access information on other systems as well.
Parse tree:
( (If ~ C < is head) (your ~ Det < library spec) (library ~ N < is subj) (is be I < can adjunct) (on ~ P_ > is pred) (a ~ Det < network spec) (network ~ N > on comp) (and ) (has have V_NP > is conj) (the ~ Det < product spec) (Dynix ~ U < product pre-mod) (Gateways ~ U < product pre-mod) (product "Dynix Gateways product" N > has comp1) (, ) (patrons patron N < can subj) (and ) (staff ~ N > patrons conj) (at ~ P_ > staff adjunct) (your ~ Det < library spec) (library ~ N > at comp) (can ~ I *) (use ~ V_NP_CP > can pred) (gateways gateway N > use comp1) (to ~ I > use comp2) (access ~ V_NP > to pred) (information ~ N > access comp1) (on ~ P_ > information adjunct) (other ~ N < systems noun-noun) (systems system N > on comp) (as "as well" A > access adjunct) (well ~ U > as post-mod) (. ) )
Sentence:
For example , you can search for items and place holds on items at other libraries , research computer centers , and universities.
Parse tree:
( (For ~ P_ < can adjunct) (example ~ N > For comp) (, ) (you ~ N < can subj) (can ~ I *) (search ~ V_[NP]_[PP] > can pred) (for ~ P_ > search comp2) (items item N > for comp) (and ) (place ~ V_NP > search conj) (holds hold N > place comp1) (on ~ P_ > holds adjunct) (items item N > on comp) (at ~ P_ > items adjunct) (other ~ N < libraries noun-noun) (libraries library N > at comp) (, ) (research ~ U < centers pre-mod) (computer ~ U < centers pre-mod) (centers "research computer center" N > libraries conj) (, ) (and ) (universities university N > centers conj) (. ) )
Sentence:
Typically , there are multiple search menus on your system , each of which is set up differently.
Parse tree:
( (Typically ~ A < are adjunct) (, ) (there ~ N < are subj) (are be I *) (multiple ~ A < menus adjunct) (search ~ U < menus pre-mod) (menus "search menu" N > are pred) (on ~ P_ > menus adjunct) (your ~ Det < system spec) (system ~ N > on comp) (, ) (each ~ N_[PP] < is spec) (of ~ P_ > each comp1) (which ~ N > of comp) (is be I *) (set "set up" V_[NP] > is pred) (up ~ U > set post-mod) (differently ~ A > set adjunct) (. ) )
Sentence:
The search menu in the Circulation module may make additional search methods available to library staff.
Parse tree:
( (The ~ Det < menu spec) (search ~ U < menu pre-mod) (menu "search menu" N < may subj) (in ~ P_ > menu adjunct) (the ~ Det < module spec) (Circulation ~ U < module pre-mod) (module "circulation module" N > in comp) (may ~ I *) (make ~ V_IP > may pred) (additional ~ A < methods adjunct) (search ~ U < methods pre-mod) (methods "search method" N < available subj) (available ~ A > make comp1) (to ~ P_ > available adjunct) (library ~ N < staff noun-noun) (staff ~ N > to comp) (. ) )
Sentence:
For example , an alphabetical search on the word " Ulysses " locates all titles that contain the word " Ulysses. "
Parse tree:
( (For ~ P_ < locates adjunct) (example ~ N > For comp) (, ) (an ~ Det < search spec) (alphabetical ~ A < search adjunct) (search ~ N < locates subj) (on ~ P_ > search adjunct) (the ~ Det < Ulysses spec) (word ~ N < Ulysses noun-noun) () (Ulysses ~ N > on comp) ( ) (locates locate V_NP *) (all ~ Det < titles spec) (titles title N > locates comp1) (that ~ C < contain head) (contain ~ V_NP > titles rel) (the ~ Det < Ulysses spec) (word ~ N < Ulysses noun-noun) ( ) (Ulysses ~ N > contain comp1) (. ) ( ) )
Sentence:
Displays the records that have a specific word or words in the TITLE , CONTENTS , SUBJECT , or SERIES fields of the BIB record , depending on which fields have been included in each index.
Parse tree:
( (Displays display N *) (the ~ Det < records spec) (records record N < word subj) (that ~ C < have head) (have ~ V_NP > records rel) (a ~ Det < specific spec) (specific ~ N > have comp1) (word ~ V_NP > Displays rel) (or ) (words word N < index subj) (in ~ P_ > words adjunct) (the ~ Det < TITLE spec) (TITLE ~ N > in comp) (, ) (CONTENTS content N > TITLE appo) (, ) (SUBJECT ~ N > CONTENTS conj) (, ) (or ) (SERIES ~ U < fields pre-mod) (fields "SERIES field" N > SUBJECT conj) (of ~ P_ > fields adjunct) (the ~ Det < record spec) (BIB ~ U < record pre-mod) (record "BIB record" N > of comp) (, ) (depending "depend on" V_CP > words rel) (on ~ U > depending post-mod) (which ~ Det < fields spec) (fields field N < have spec) (have ~ I > depending comp1) (been be I > have be) (included include V_NP > have pred) (in ~ P_ > included adjunct) (each ~ N_[PP] > in comp) (index ~ V_NP > word conj) (. ) )
Sentence:
For example , you can use an accelerated search command to perform an author authority search or a title keyword search.
Parse tree:
( (For ~ P_ < can adjunct) (example ~ N > For comp) (, ) (you ~ N < can subj) (can ~ I *) (use ~ V_NP_CP > can pred) (an ~ Det < command spec) (accelerated ~ A < command adjunct) (search ~ U < command pre-mod) (command "search command" N > use comp1) (to ~ I > use comp2) (perform ~ V_[NP] > to pred) (an ~ Det < search spec) (author ~ U < search pre-mod) (authority ~ U < search pre-mod) (search "author authority search" N > perform comp1) (or ) (a ~ Det < search spec) (title ~ U < search pre-mod) (keyword ~ U < search pre-mod) (search "title keyword search" N > search conj) (. ) )
Sentence:
The search abbreviation is included in parentheses following the search name :
Parse tree:
( (The ~ Det < abbreviation spec) (search ~ U < abbreviation pre-mod) (abbreviation "search abbreviation" N < is subj) (is be I *) (included include V_NP > is pred) (in ~ P_ > included adjunct) (parentheses ~ N > in comp) (following follow V_[NP] > parentheses rel) (the ~ Det < name spec) (search ~ U < name pre-mod) (name "search name" N > following comp1) (: ) )
Sentence:
A system menu
Parse tree:
( (A ~ Det < menu spec) (system ~ U < menu pre-mod) (menu "system menu" N *) )
Sentence:
Any screen where you can enter " SO " to start a search over
Parse tree:
( (Any ~ Det < screen spec) (screen ~ N *) (where ~ A < can spec) (you ~ N < can subj) (can ~ I > screen rel) (enter ~ V_[NP] > can pred) () (SO ~ N > enter comp1) ( ) (to ~ I *) (start ~ V_[NP] > to pred) (a ~ Det < search spec) (search ~ N > start comp1) (over ~ A > start adjunct) )
Sentence:
Certain abbreviations may work at one prompt but not at another.
Parse tree:
( (Certain ~ A_[CP] < abbreviations adjunct) (abbreviations abbreviation N < may subj) (may ~ I *) (work ~ V_[NP] > may pred) (at ~ P_ > work adjunct) (one ~ A < prompt adjunct) (prompt ~ N > at comp) (but ) (not ~ A < at spec) (at ~ P_ > at conj) (another ~ N > at comp) (. ) )
Sentence:
To perform an accelerated search , follow these instructions :
Parse tree:
( (To ~ I *) (perform ~ V_[NP] > To pred) (an ~ Det < search spec) (accelerated ~ A < search adjunct) (search ~ N > perform comp1) (, ) (follow ~ V_[NP] *) (these ~ Det < instructions spec) (instructions instruction N > follow comp1) (: ) )
Sentence:
That item 's full BIB display appears.
Parse tree:
(
(That ~ C < appears head)
(item ~ N < display spec)
('s )
(full ~ A < display adjunct)
(BIB ~ U < display pre-mod)
(display "BIB display" N < appears subj)
(appears appear V *)
(. )
)
Sentence:
Write down any information you need , or select the item if you are placing a hold.
Parse tree:
( (Write ~ V_[NP]_[PP] *) (down ~ P_ > Write adjunct) (any ~ Det < information spec) (information ~ N > down comp) (you ~ N < need subj) (need ~ V_NP > information rel) (, ) (or ) (select ~ V_NP > Write conj) (the ~ Det < item spec) (item ~ N > select comp1) (if ~ C < are head) (you ~ N < are subj) (are be I *) (placing place V_NP > are pred) (a ~ Det < hold spec) (hold ~ N > placing comp1) (. ) )
Sentence:
Alphabetical Title Search.
Parse tree:
( (Alphabetical ~ A < Search adjunct) (Title ~ U < Search pre-mod) (Search "title search" N *) (. ) )
Sentence:
Enter the line number of the alphabetical title search option.
Parse tree:
( (Enter ~ V_[NP] *) (the ~ Det < number spec) (line ~ U < number pre-mod) (number "line number" N > Enter comp1) (of ~ P_ > number adjunct) (the ~ Det < option spec) (alphabetical ~ A < option adjunct) (title ~ N < option noun-noun) (search ~ U < option pre-mod) (option "search option" N > of comp) (. ) )
Sentence:
A BIB summary screen appears , listing the titles that match your entry :
Parse tree:
( (A ~ Det < screen spec) (BIB ~ U < screen pre-mod) (summary ~ U < screen pre-mod) (screen "BIB summary screen" N < appears subj) (appears appear V *) (, ) (listing list V_[NP] *) (the ~ Det < titles spec) (titles title N > listing comp1) (that ~ C < match head) (match ~ V_[NP] > titles rel) (your ~ Det < entry spec) (entry ~ N > match comp1) (: ) )
Sentence:
When you access the BIB record you want , you can print the screen , write down any information you need , or select the item if you are placing a hold.
Parse tree:
( (When ~ A < access spec) (you ~ N < access subj) (access ~ V_NP < can adjunct) (the ~ Det < record spec) (BIB ~ U < record pre-mod) (record "BIB record" N > access comp1) (you ~ N < want subj) (want ~ V_NP > record rel) (, ) (you ~ N < can subj) (can ~ I *) (print ~ V_[NP] > can pred) (the ~ Det < screen spec) (screen ~ N > print comp1) (, ) (write ~ V_[NP]_[PP] > print conj) (down ~ P_ > write adjunct) (any ~ Det < information spec) (information ~ N > down comp) (you ~ N < need subj) (need ~ V_NP > information rel) (, ) (or ) (select ~ V_NP > write conj) (the ~ Det < item spec) (item ~ N > select comp1) (if ~ C < are head) (you ~ N < are subj) (are be I *) (placing place V_NP > are pred) (a ~ Det < hold spec) (hold ~ N > placing comp1) (. ) )
Sentence:
The cursor symbol ( > ) appears on the alphabetical list next to the heading that most closely matches your request.
Parse tree:
( (The ~ Det < symbol spec) (cursor ~ U < symbol pre-mod) (symbol "cursor symbol" N *) () (> ) ( ) (appears appear V *) (on ~ P_ > appears adjunct) (the ~ Det < list spec) (alphabetical ~ A < list adjunct) (list ~ N > on comp) (next ~ A > appears adjunct) (to ) (the ) (heading ~ A *) (that ~ C < matches head) (most ~ N_[PP] < matches subj) (closely ~ A < matches adjunct) (matches match V_[NP] *) (your ~ Det < request spec) (request ~ N_[CP] > matches comp1) (. ) )
Sentence:
Byzantine empire
Parse tree:
( (Byzantine ~ U < empire pre-mod) (empire "Byzantine empire" N *) )
Sentence:
When you are editing a document , you want to be able to move quickly through the pages.
Parse tree:
( (When ~ A < are spec) (you ~ N < are subj) (are be I < want adjunct) (editing edit V_NP > are pred) (a ~ Det < document spec) (document ~ N > editing comp1) (, ) (you ~ N < want subj) (want ~ V_CP *) (to ~ I > want comp1) (be ~ I > to be) (able ~ A_[CP] > to pred) (to ~ I > able comp1) (move ~ V_[NP] > to pred) (quickly ~ A < through spec) (through ~ P_ > move adjunct) (the ~ Det < pages spec) (pages page N > through comp) (. ) )
Sentence:
Scrolling changes the display but does not move the insertion point.
Parse tree:
( (Scrolling ~ N < changes subj) (changes change V_[NP] *) (the ~ Det < display spec) (display ~ N > changes comp1) (but ) (does "does not" I > changes conj) (not ~ U > does post-mod) (move ~ V_[NP] > does pred) (the ~ Det < point spec) (insertion ~ U < point pre-mod) (point "insertion point" N > move comp1) (. ) )
Sentence:
To use keyboard shortcuts to navigate a document
Parse tree:
( (To ~ I *) (use ~ V_NP_CP > To pred) (keyboard ~ U < shortcuts pre-mod) (shortcuts "keyboard shortcut" N > use comp1) (to ~ I > use comp2) (navigate ~ V_[NP] > to pred) (a ~ Det < document spec) (document ~ N > navigate comp1) )
Sentence:
Move the mouse pointer until the I - beam is at the beginning of the text you want to select.
Parse tree:
( (Move ~ V_CP *) (the ~ Det < pointer spec) (mouse ~ U < pointer pre-mod) (pointer "mouse pointer" N < is subj) (until ~ P_ > pointer adjunct) (the ~ Det < beam spec) (I ~ U < beam pre-mod) (- ~ U < beam pre-mod) (beam I-beam N > until comp) (is be I > Move comp1) (at ~ P_ > is pred) (the ~ Det < beginning spec) (beginning ~ N > at comp) (of ~ P_ > beginning adjunct) (the ~ Det < text spec) (text ~ N > of comp) (you ~ N < want subj) (want ~ V_CP > text rel) (to ~ I > want comp1) (select ~ V_NP > to pred) (. ) )
Sentence:
For information , refer to " Undoing one or more actions " in this chapter.
Parse tree:
( (For ~ P_ *) (information ~ N > For comp) (, ) (refer "refer to" V_NP_[PP] *) (to ~ U > refer post-mod) () (Undoing ~ N < one noun-noun) (one ~ N_[PP] > refer comp1) (or ) (more ~ N_[PP] < actions noun-noun) (actions action N > one conj) ( ) (in ~ P_ > actions adjunct) (this ~ Det < chapter spec) (chapter ~ N > in comp) (. ) )
Sentence:
Ami Pro provides three modes for typing text.
Parse tree:
( (Ami ~ U < Pro pre-mod) (Pro "Ami Pro" N < provides subj) (provides provide V_NP_[PP] *) (three ~ A < modes adjunct) (modes mode N > provides comp1) (for ~ P_ > modes adjunct) (typing type V_[NP] > for comp) (text ~ N > typing comp1) (. ) )
Sentence:
In Insert mode , you insert text at the position of the insertion point and any existing text automatically moves.
Parse tree:
( (In ~ P_ << insert adjunct) (Insert ~ U < mode pre-mod) (mode "Insert mode" N > In comp) (, ) (you ~ N < insert subj) (insert ~ V_NP *) (text ~ N > insert comp1) (at ~ P_ > text adjunct) (the ~ Det < position spec) (position ~ N_[CP] > at comp) (of ~ P_ > position adjunct) (the ~ Det < point spec) (insertion ~ U < point pre-mod) (point "insertion point" N > of comp) (and ) (any ~ Det < text spec) (existing ~ A < text adjunct) (text ~ N < moves subj) (automatically ~ A < moves adjunct) (moves move V_[NP] > insert conj) (. ) )
Sentence:
If you press BACKSPACE , Ami Pro deletes the selected text and one character to the left of the selected text.
Parse tree:
( (If ~ C < press head) (you ~ N < press subj) (press ~ V_NP < deletes adjunct) (BACKSPACE ~ N > press comp1) (, ) (Ami ~ U < Pro pre-mod) (Pro "Ami Pro" N < deletes subj) (deletes delete V_NP *) (the ~ Det < text spec) (selected ~ A < text adjunct) (text ~ N > deletes comp1) (and ) (one ~ A < character adjunct) (character ~ N > text conj) (to ~ P_ > character adjunct) (the ~ Det < left spec) (left ~ N > to comp) (of ~ P_ > left adjunct) (the ~ Det < text spec) (selected ~ A < text adjunct) (text ~ N > of comp) (. ) )
Sentence:
You can disable Drag & Drop.
Parse tree:
( (You ~ N < can subj) (can ~ I *) (disable ~ V_NP > can pred) (Drag ~ U < Drop pre-mod) (& ~ U < Drop pre-mod) (Drop "Drag & Drop" N > disable comp1) (. ) )
Sentence:
If you want to move the text , position the mouse pointer anywhere in the selected text and drag the mouse until the insertion point is in the desired location.
Parse tree:
( (If ~ C < want head) (you ~ N < want subj) (want ~ V_CP *) (to ~ I > want comp1) (move ~ V_[NP] > to pred) (the ~ Det < text spec) (text ~ N > move comp1) (, ) (position ~ V_NP > move conj) (the ~ Det < pointer spec) (mouse ~ U < pointer pre-mod) (pointer "mouse pointer" N > position comp1) (anywhere ~ A < in spec) (in ~ P_ > pointer adjunct) (the ~ Det < text spec) (selected ~ A < text adjunct) (text ~ N > in comp) (and ) (drag ~ V_[NP] > position conj) (the ~ Det < mouse spec) (mouse ~ N > drag comp1) (until ~ Conn_CP > want adjunct) (the ~ Det < point spec) (insertion ~ U < point pre-mod) (point "insertion point" N < is subj) (is be I > until head) (in ~ P_ > is pred) (the ~ Det < location spec) (desired ~ A < location adjunct) (location ~ N > in comp) (. ) )
Sentence:
The contents of the Clipboard appear in the desired location.
Parse tree:
( (The ~ Det < contents spec) (contents content N < appear subj) (of ~ P_ > contents adjunct) (the ~ Det < Clipboard spec) (Clipboard ~ N > of comp) (appear ~ V *) (in ~ P_ > appear adjunct) (the ~ Det < location spec) (desired ~ A < location adjunct) (location ~ N > in comp) (. ) )
Sentence:
To move or copy text between documents
Parse tree:
( (To ~ I *) (move ~ V_[NP] > To pred) (or ) (copy ~ V_[NP] > move conj) (text ~ N > copy comp1) (between ~ P_ > text adjunct) (documents document N > between comp) )
Sentence:
Choose Edit/Cut or Edit/Copy to place the selected text on the Clipboard.
Parse tree:
( (Choose ~ V_IP *) (Edit/Cut ~ N < to subj) (or ) (Edit/Copy ~ N > Edit/Cut conj) (to ~ I > Choose comp1) (place ~ V_NP > to pred) (the ~ Det < text spec) (selected ~ A < text adjunct) (text ~ N > place comp1) (on ~ P_ > text adjunct) (the ~ Det < Clipboard spec) (Clipboard ~ N > on comp) (. ) )
Sentence:
If the document into which you want to paste the text is already open , you can switch to that window by clicking in it or by choosing the Window menu and selecting the desired document.
Parse tree:
( (If ~ C < is head) (the ~ Det < document spec) (document ~ N < is subj) (into ~ P_ < want spec) (which ~ N > into comp) (you ~ N < want subj) (want ~ V_CP > document rel) (to ~ I > want comp1) (paste ~ V_NP > to pred) (the ~ Det < text spec) (text ~ N > paste comp1) (is be I < can adjunct) (already ~ A < open adjunct) (open ~ A > is pred) (, ) (you ~ N < can subj) (can ~ I *) (switch ~ V_PP > can pred) (to ~ P_ > switch comp1) (that ~ Det < window spec) (window ~ N > to comp) (by ~ P_CP > window adjunct) (clicking click V > by comp) (in ~ P_ > clicking adjunct) (it ~ N > in comp) (or ) (by ~ P_CP > in conj) (choosing choose V_[NP] > by comp) (the ~ Det < menu spec) (Window ~ U < menu pre-mod) (menu "window menu" N > choosing comp1) (and ) (selecting select V_NP > choosing conj) (the ~ Det < document spec) (desired ~ A < document adjunct) (document ~ N > selecting comp1) (. ) )
Sentence:
Press SHIFT+INS or CTRL+V.
Parse tree:
( (Press ~ V_NP *) (SHIFT+INS ~ N > Press comp1) (or ) (CTRL+V ~ N > SHIFT+INS conj) (. ) )
Sentence:
Select the text you want to protect.
Parse tree:
( (Select ~ V_NP *) (the ~ Det < text spec) (text ~ N > Select comp1) (you ~ N < want subj) (want ~ V_CP > text rel) (to ~ I > want comp1) (protect ~ V_NP > to pred) (. ) )
Sentence:
Permanently inserts the date the current document was created.
Parse tree:
( (Permanently ~ A < inserts adjunct) (inserts insert V_NP *) (the ~ Det < date spec) (date ~ N_[CP] > inserts comp1) (the ~ Det < document spec) (current ~ A < document adjunct) (document ~ N < was subj) (was be I > date comp1) (created create V_NP > was pred) (. ) )
Sentence:
You can select Off , 1 , 2 , 3 , or 4 levels.
Parse tree:
( (You ~ N < can subj) (can ~ I *) (select ~ V_NP > can pred) (Off ~ N > select comp1) (, ) (1 ~ N_[PP] > Off appo) (, ) (2 ~ N_[PP] > 1 appo) (, ) (3 ~ N_[PP] > 2 conj) (, ) (or ) (4 ~ A < levels adjunct) (levels level N > 3 conj) (. ) )
Sentence:
When you want to reverse an action , choose Edit/Undo.
Parse tree:
( (When ~ A < want spec) (you ~ N < want subj) (want ~ V_CP < choose adjunct) (to ~ I > want comp1) (reverse ~ V_[NP] > to pred) (an ~ Det < action spec) (action ~ N > reverse comp1) (, ) (choose ~ V_[NP] *) (Edit/Undo ~ N > choose comp1) (. ) )
Sentence:
Modifying the Appearance of Text
Parse tree:
( (Modifying modify V_NP *) (the ~ Det < Appearance spec) (Appearance ~ N > Modifying comp1) (of ~ P_ > Appearance adjunct) (Text ~ N > of comp) )
Sentence:
The following are suggestions on how to proceed when using the Translator 's Workbench together with Word for Windows 6.0.
Parse tree:
(
(The ~ Det < following spec)
(following ~ N < are subj)
(are be I *)
(suggestions suggestion N_[CP] > are pred)
(on ~ P_ > suggestions adjunct)
(how ~ A < to spec)
(to ~ I > on comp)
(proceed ~ V_[CP] > to pred)
(when ~ A *)
(using use V_NP *)
(the ~ Det < Translator spec)
(Translator ~ N < Workbench spec)
('s )
(Workbench ~ N > using comp1)
(together ~ A < with spec)
(with ~ P_ > Workbench adjunct)
(Word ~ U < 6.0 pre-mod)
(for ~ U < 6.0 pre-mod)
(Windows ~ U < 6.0 pre-mod)
(6.0 "Word for Windows 6.0" N > with comp)
(. )
)
Sentence:
Another important category of non - textual data is what is referred to as " hidden text. "
Parse tree:
( (Another ~ Det < category spec) (important ~ A_[] < category adjunct) (category ~ N < is subj) (of ~ P_ > category adjunct) (non non-textual A < data adjunct) (- ~ U > non post-mod) (textual ~ U > non post-mod) (data ~ N > of comp) (is be I *) (what ~ N < is spec) (is be I > is pred) (referred "refer to" V_NP_[PP] > is pred) (to ~ U > referred post-mod) (as ~ P_ > referred comp2) () (hidden ~ A < text adjunct) (text ~ N > as comp) (. ) ( ) )
Sentence:
Alternatively , choose the Options... menu item from Word 's Tools menu.
Parse tree:
(
(Alternatively ~ A < choose adjunct)
(, )
(choose ~ V_IP *)
(the ~ Det < item spec)
(Options... ~ N < item noun-noun)
(menu ~ U < item pre-mod)
(item "menu item" N < from subj)
(from ~ P_ > choose comp1)
(Word ~ N < menu spec)
('s )
(Tools ~ U < menu pre-mod)
(menu "Tools menu" N > from comp)
(. )
)
Sentence:
Thus , you will make sure that you see all the information that the Workbench manages during translation :
Parse tree:
( (Thus ~ A < will adjunct) (, ) (you ~ N < will subj) (will ~ I *) (make "make sure" V_CP > will pred) (sure ~ U > make post-mod) (that ~ C < see head) (you ~ N < see subj) (see ~ V_NP > make comp1) (all ~ Det < information spec) (the ~ Det > all) (information ~ N > see comp1) (that ~ C < manages head) (the ~ Det < Workbench spec) (Workbench ~ N < manages subj) (manages manage V_NP > information rel) (during ~ P_ > manages adjunct) (translation ~ N > during comp) (: ) )
Sentence:
Always put one abbreviation on a line , followed by a period.
Parse tree:
( (Always ~ A < put adjunct) (put ~ V_NP_PP *) (one ~ A < abbreviation adjunct) (abbreviation ~ N > put comp1) (on ~ P_ > put comp2) (a ~ Det < line spec) (line ~ N > on comp) (, ) (followed follow V_[NP] > line rel) (by ~ P_ > followed adjunct) (a ~ Det < period spec) (period ~ N > by comp) (. ) )
Sentence:
During the translation of this example , the Workbench should ignore the second sentence when moving from the first sentence to the third one.
Parse tree:
( (During ~ P_ < should adjunct) (the ~ Det < translation spec) (translation ~ N > During comp) (of ~ P_ > translation adjunct) (this ~ Det < example spec) (example ~ N > of comp) (, ) (the ~ Det < Workbench spec) (Workbench ~ N < should subj) (should ~ I *) (ignore ~ V_NP > should pred) (the ~ Det < sentence spec) (second ~ A < sentence adjunct) (sentence ~ N > ignore comp1) (when ~ A < moving adjunct) (moving ~ A *) (from ~ P_ > moving adjunct) (the ~ Det < sentence spec) (first ~ A < sentence adjunct) (sentence ~ N > from comp) (to ~ P_ > sentence adjunct) (the ~ Det < one spec) (third ~ U < one pre-mod) (one "third one" N_[PP] > to comp) (. ) )
Sentence:
In Word , you can immediately recognize a 100% match from the color of the target field.
Parse tree:
( (In ~ P_ < can adjunct) (Word ~ N > In comp) (, ) (you ~ N < can subj) (can ~ I *) (immediately ~ A < recognize adjunct) (recognize ~ V_IP > can pred) (a ~ Det < 100% spec) (100% ~ N < match subj) (match ~ N > recognize comp1) (from ~ P_ > match adjunct) (the ~ Det < color spec) (color ~ N > from comp) (of ~ P_ > color adjunct) (the ~ Det < field spec) (target ~ U < field pre-mod) (field "target field" N > of comp) (. ) )
Sentence:
The TWB1 button , also labeled Translate Until Next Fuzzy Match , tells the Workbench to do precisely this.
Parse tree:
( (The ~ Det < button spec) (TWB1 ~ U < button pre-mod) (button "TWB1 button" N < tells subj) (, ) (also ) (labeled ~ A < Match adjunct) (Translate ~ U < Match pre-mod) (Until ~ U < Match pre-mod) (Next ~ U < Match pre-mod) (Fuzzy ~ U < Match pre-mod) (Match "Translate Until Next Fuzzy Match" N > button appo) (, ) (tells tell V_NP_CP *) (the ~ Det < Workbench spec) (Workbench ~ N > tells comp1) (to ~ I > tells comp2) (do ~ V_NP > to pred) (precisely ) (this ~ N > do comp1) (. ) )
Sentence:
You can also use the shortcut [Alt] + [x] on the separate numeric keypad to start this function.
Parse tree:
( (You ~ N < can subj) (can ~ I *) (also ~ A < use adjunct) (use ~ V_NP_CP > can pred) (the ~ Det < [x] spec) (shortcut ~ N < [x] noun-noun) ([Alt] ~ U < [x] pre-mod) (+ ~ U < [x] pre-mod) ([x] "[Alt] + [x]" N > use comp1) (on ~ P_ > [x] adjunct) (the ~ Det < keypad spec) (separate ~ A < keypad adjunct) (numeric ~ A < keypad adjunct) (keypad ~ N > on comp) (to ~ I > use comp2) (start ~ V_[NP] > to pred) (this ~ Det < function spec) (function ~ N > start comp1) (. ) )
Sentence:
That is , these words make the source sentence longer or shorter than the TM sentence.
Parse tree:
( (That ~ N < is subj) (is be I *) (, ) (these ~ N > is pred) (words word N < make subj) (make ~ V_IP *) (the ~ Det < sentence spec) (source ~ U < sentence pre-mod) (sentence "source sentence" N < longer subj) (longer long A > make comp1) (or ) (shorter short A > longer conj) (than ~ P_ > shorter adjunct) (the ~ Det < sentence spec) (TM ~ U < sentence pre-mod) (sentence "TM sentence" N > than comp) (. ) )
Sentence:
Likewise , if something has been left out in the source sentence , you will have to delete the corresponding parts in the suggested translation as well.
Parse tree:
( (Likewise ~ A < will adjunct) (, ) (if ~ C < has head) (something ~ N < has subj) (has have I < will adjunct) (been be I > has be) (left "leave out" V_NP > has pred) (out ~ U > left post-mod) (in ~ P_ > left adjunct) (the ~ Det < sentence spec) (source ~ U < sentence pre-mod) (sentence "source sentence" N > in comp) (, ) (you ~ N < will subj) (will ~ I *) (have ~ V_CP > will pred) (to ~ I > have comp1) (delete ~ V_NP > to pred) (the ~ Det < parts spec) (corresponding ~ A < parts adjunct) (parts part N > delete comp1) (in ~ P_ > parts adjunct) (the ~ Det < translation spec) (suggested ~ A < translation adjunct) (translation ~ N > in comp) (as "as well" A > delete adjunct) (well ~ U > as post-mod) (. ) )
Sentence:
Automatic Substitution of Interchangeable Elements
Parse tree:
( (Automatic ~ A < Substitution adjunct) (Substitution ~ N *) (of ~ P_ > Substitution adjunct) (Interchangeable ~ A < Elements adjunct) (Elements element N > of comp) )
Sentence:
If the Workbench cannot find any fuzzy match , it will display a corresponding message ( " No match " ) in the lower right corner of its status bar and you will be presented with an empty yellow target field.
Parse tree:
( (If ~ C < cannot head) (the ~ Det < Workbench spec) (Workbench ~ N < cannot subj) (cannot ~ I < will adjunct) (find ~ V_NP_[PP] > cannot pred) (any ~ Det < match spec) (fuzzy ~ U < match pre-mod) (match "fuzzy match" N > find comp1) (, ) (it ~ N < will subj) (will ~ I *) (display ~ V_NP > will pred) (a ~ Det < message spec) (corresponding ~ A < message adjunct) (message ~ N > display comp1) () ( ) (No ~ Det < match spec) (match ~ N < will subj) ( ) ( ) (in ~ P_ > match adjunct) (the ~ Det < corner spec) (lower low A < corner adjunct) (right ~ N_[CP] < corner noun-noun) (corner ~ N > in comp) (of ~ P_ > corner adjunct) (its ~ Det < bar spec) (status ~ U < bar pre-mod) (bar "status bar" N > of comp) (and ) (you ~ N > bar conj) (will ~ I *) (be ~ I > will be) (presented present V_NP > will pred) (with ~ P_ > presented adjunct) (an ~ Det < field spec) (empty ~ A < field adjunct) (yellow ~ A < field adjunct) (target ~ U < field pre-mod) (field "target field" N > with comp) (. ) )
Sentence:
Then go on translating until you want to insert the next translation.
Parse tree:
( (Then ~ A < go adjunct) (go "go on" V_CP *) (on ~ U > go post-mod) (translating translate V_[NP]_[PP] > go comp1) (until ) (you ~ N < want subj) (want ~ V_CP *) (to ~ I > want comp1) (insert ~ V_NP > to pred) (the ~ Det < translation spec) (next ~ A < translation adjunct) (translation ~ N > insert comp1) (. ) )
Sentence:
Select the text to be copied in the Concordance window , usually the translation of the sentence part that you have searched for.
Parse tree:
( (Select ~ V_NP_CP *) (the ~ Det < text spec) (text ~ N > Select comp1) (to ~ I > Select comp2) (be ~ I > to be) (copied copy V_[NP] > to pred) (in ~ P_ < part adjunct) (the ~ Det < window spec) (Concordance ~ U < window pre-mod) (window "Concordance window" N > in comp) (, ) (usually ~ A < part adjunct) (the ~ Det < translation spec) (translation ~ N < part subj) (of ~ P_ > translation adjunct) (the ~ Det < sentence spec) (sentence ~ N > of comp) (part ~ V_[NP] *) (that ~ C < have head) (you ~ N < have subj) (have ~ I *) (searched search V_[NP]_[PP] > have pred) (for ) (. ) )
Sentence:
The same goes for formatting :
Parse tree:
( (The ~ Det < same spec) (same ~ N < goes subj) (goes go V_PP *) (for ~ P_ > goes comp1) (formatting ~ N > for comp) (: ) )
Sentence:
Making Corrections
Parse tree:
( (Making make V_NP *) (Corrections correction N > Making comp1) )
Sentence:
If you would like to make corrections to translations after their initial creation , you should always do this in TM mode so that the corrections will be stored in Translation Memory as well as in your document.
Parse tree:
( (If ~ C < would head) (you ~ N < would subj) (would ~ I < should adjunct) (like ~ V_CP > would pred) (to ~ I > like comp1) (make ~ V_NP > to pred) (corrections correction N > make comp1) (to ~ P_ > corrections adjunct) (translations translation N > to comp) (after ~ P_ > translations adjunct) (their ~ Det < creation spec) (initial ~ A < creation adjunct) (creation ~ N > after comp) (, ) (you ~ N < should subj) (should ~ I *) (always ~ A < do adjunct) (do ~ V_NP > should pred) (this ~ N > do comp1) (in ~ P_ > do adjunct) (TM ~ U < mode pre-mod) (mode "TM mode" N > in comp) (so ~ Conn_CP > should adjunct) (that ~ C < will head) (the ~ Det < corrections spec) (corrections correction N < will subj) (will ~ I > so head) (be ~ I > will be) (stored store V_NP > will pred) (in ~ P_ > stored adjunct) (Translation ~ U < Memory pre-mod) (Memory "translation memory" N > in comp) (as ) (well ) (as ) (in ~ P_ > in conj) (your ~ Det < document spec) (document ~ N > in comp) (. ) )
Sentence:
But consider the following example where text is used within an index entry field :
Parse tree:
( (But ~ A < consider adjunct) (consider ~ V_NP *) (the ~ Det < example spec) (following ~ A < example adjunct) (example ~ N > consider comp1) (where ~ A < is spec) (text ~ N < is subj) (is be I < within spec) (used use V_NP > is pred) (within ~ P_ > example adjunct) (an ~ Det < field spec) (index ~ U < field pre-mod) (entry ~ U < field pre-mod) (field "index entry field" N > within comp) (: ) )
Sentence:
If a perfect or fuzzy match is found , the Workbench will again automatically transfer its translation into the target field in WinWord.
Parse tree:
( (If ~ C < is head) (a ~ Det < match spec) (perfect ~ U < match pre-mod) (or ~ U < match pre-mod) (fuzzy ~ U < match pre-mod) (match "perfect or fuzzy match" N < is subj) (is be I < will adjunct) (found find V_NP_[PP] > is pred) (, ) (the ~ Det < Workbench spec) (Workbench ~ N < will subj) (will ~ I *) (again ) (automatically ) (transfer ~ V_NP > will pred) (its ~ Det < translation spec) (translation ~ N > transfer comp1) (into ~ P_ > translation adjunct) (the ~ Det < field spec) (target ~ U < field pre-mod) (field "target field" N > into comp) (in ~ P_ > field adjunct) (WinWord ~ N > in comp) (. ) )