en to ka translation catalogue (391 entries)

[ctx: QObject|]
en: Import filter for Cachegrind/Callgrind generated profile data files
ka: შემოტანის ფილტრი Cachegrnd/Callgrind-ის მიერ გენერირებული პროფილის მონაცემის ფაილებისთვის

[ctx: ProfileContext|]
en: Invalid Context
ka: არასწორი კონტექსტი

[ctx: ProfileContext|]
en: Unknown Context
ka: უცნობი კონტექსტი

[ctx: ProfileContext|]
en: Part Source Line
ka: ნაწილის კოდის ხაზი

[ctx: ProfileContext|]
en: Source Line
ka: კოდის ხაზი

[ctx: ProfileContext|]
en: Part Line Call
ka: სტრიქონის გამოძახების ხაზი

[ctx: ProfileContext|]
en: Line Call
ka: ხაზის გამოძახება

[ctx: ProfileContext|]
en: Part Jump
ka: ნაწილზე გადასვლა

[ctx: ProfileContext|]
en: Jump
ka: გადასვლა

[ctx: ProfileContext|]
en: Part Instruction
ka: ნაწილის ინსტრუქცია

[ctx: ProfileContext|]
en: Instruction
ka: ინსტრუქცია

[ctx: ProfileContext|]
en: Part Instruction Jump
ka: ნაწილის ინსტრუქციაზე გადასვლა

[ctx: ProfileContext|]
en: Instruction Jump
ka: გადახტომის ინსტრუქცია

[ctx: ProfileContext|]
en: Part Instruction Call
ka: ნაწილის ინსტრუქციის გამოძახება

[ctx: ProfileContext|]
en: Instruction Call
ka: ინსტრუქციის გამოძახება

[ctx: ProfileContext|]
en: Part Call
ka: ნაწილის გამძახება

[ctx: ProfileContext|]
en: Call
ka: დარეკვა

[ctx: ProfileContext|]
en: Part Function
ka: ნაწილის ფუნქცია

[ctx: ProfileContext|]
en: Function Source File
ka: ფუნქციის კოდის ფაილი

[ctx: ProfileContext|]
en: Function
ka: ფუნქცია

[ctx: ProfileContext|]
en: Function Cycle
ka: ფუნქციის ციკლი

[ctx: ProfileContext|]
en: Part Class
ka: ნაწილის კლასი

[ctx: ProfileContext|]
en: Class
ka: კლასი

[ctx: ProfileContext|]
en: Part Source File
ka: ნაწილის კოდის ფაილი

[ctx: ProfileContext|]
en: Source File
ka: კოდის ფაილი

[ctx: ProfileContext|]
en: Part ELF Object
ka: ნაწილის ELF ობიექტი

[ctx: ProfileContext|]
en: ELF Object
ka: ELF ობიექტი

[ctx: ProfileContext|]
en: Profile Part
ka: პროფილის ნაწილი

[ctx: ProfileContext|]
en: Program Trace
ka: პროგრამის ტრეისი

[ctx: ProfileContext|]
en: BasicBlock
ka: ძირითადი ბლოკი

[ctx: QObject|]
en: %1 from %2
ka: %1 %2-დან

[ctx: QObject|]
en: (unknown)
ka: (უცნობია)

[ctx: QObject|]
en: Instruction Fetch
ka: ინსტრუქციის გამოთხოვა

[ctx: QObject|]
en: Data Read Access
ka: მონაცემების კითხვის წვდომა

[ctx: QObject|]
en: Data Write Access
ka: მონაცემების ჩაწერის წვდომა

[ctx: QObject|]
en: L1 Instr. Fetch Miss
ka: L1 ინსტრ. გამოთხ. აცდ

[ctx: QObject|]
en: L1 Data Read Miss
ka: L1 მონაც. წაკითხვ. აცდ

[ctx: QObject|]
en: L1 Data Write Miss
ka: L1 მონაც. ჩაწერ. აცდ

[ctx: QObject|]
en: L2 Instr. Fetch Miss
ka: L2 ინსტრ. გამოთხ. აცდ

[ctx: QObject|]
en: L2 Data Read Miss
ka: L2 მონაც. წაკითხვ. აცდ

[ctx: QObject|]
en: L2 Data Write Miss
ka: L2 მონაც. ჩაწერ. აცდ

[ctx: QObject|]
en: LL Instr. Fetch Miss
ka: LL ინსტრ. გამოთხ. აცდ

[ctx: QObject|]
en: LL Data Read Miss
ka: LL მონაც. წაკითხვ. აცდ

[ctx: QObject|]
en: LL Data Write Miss
ka: LL მონაც. ჩაწერ. აცდ

[ctx: QObject|]
en: L1 Miss Sum
ka: L1 აცდ. ჯამი

[ctx: QObject|]
en: L2 Miss Sum
ka: L2 აცდ. ჯამი

[ctx: QObject|]
en: Last-level Miss Sum
ka: ბოლო დონის (Last-level) აცდენების ჯამი

[ctx: QObject|]
en: Indirect Branch
ka: არაპირდაპირი ბრენჩი

[ctx: QObject|]
en: Mispredicted Ind. Branch
ka: გამოუცნობი არაპ. ბრენჩი

[ctx: QObject|]
en: Conditional Branch
ka: პირობითი ბრენჩი

[ctx: QObject|]
en: Mispredicted Cond. Branch
ka: გამოუცნობი პირობ. ბრენჩი

[ctx: QObject|]
en: Mispredicted Branch
ka: გამოუცნობი ბრენჩი

[ctx: QObject|]
en: Global Bus Event
ka: გლობალური მატარებლის მოვლენა

[ctx: QObject|]
en: Samples
ka: სემპლები

[ctx: QObject|]
en: System Time
ka: სისტემური დრო

[ctx: QObject|]
en: User Time
ka: მომხმარებლის დრო

[ctx: QObject|]
en: Cycle Estimation
ka: ციკლის შემდეგ

[ctx: QObject|]
en: (no caller)
ka: (გამომძახებლის გარეშე)

[ctx: QObject|]
en: %1 via %2
ka: %1 %2-ის გავლით

[ctx: QObject|]
en: (no callee)
ka: (გამოძახებულის გარეშე)

[ctx: QObject|]
en: (global)
ka: (გლობალური)

[ctx: QObject|]
en: (not found)
ka: (ვერ მოიძებნა)

[ctx: TraceData|]
en: Recalculating Function Cycles...
ka: ფუნქციის ციკლების გადათვლა...

[ctx: QObject|]
en: Call(s) from %1
ka: გამოძახებები %1-დან

[ctx: QObject|]
en: Call(s) to %1
ka: %1-ის გამოძახებები

[ctx: QObject|]
en: (unknown call)
ka: (უცნობი გამოძახება)

[ctx: QObject|]
en: Export Graph
ka: გრაფიკის გატანა

[ctx: CallGraphView|]
en: <b>Call Graph around active Function</b><p>Depending on configuration, this view shows the call graph environment of the active function. Note: the shown cost is <b>only</b> the cost which is spent while the active function was actually running; i.e. the cost shown for main() - if it is visible - should be the same as the cost of the active function, as that is the part of inclusive cost of main() spent while the active function was running.</p><p>For cycles, blue call arrows indicate that this is an artificial call added for correct drawing which actually never happened.</p><p>If the graph is larger than the widget area, an overview panner is shown in one edge. There are similar visualization options to the Call Treemap; the selected function is highlighted.</p>
ka: <b>გამოძახების გრაფიკი აქტიური ფუნქციის გარშემო</b><p>კონფიგურაციაზე დამოკიდებულებით, ეს ხედი გაჩვენებთ გამოძახების გრაფიკის გარემოს აქტიური ფუნქციისთვის. შენიშვნა: ნაჩვენები ფასი, <b>მხოლოდ</b>, ის ღირებულებაა, რომელიც აქტიური ფუნქციის გაშვებაზე დაიხარჯა, ანუ, ღირებულება ფუნქციისთვის main(), თუ ის ხილულია, იგივე უნდა იყოს, რაც აქტიური ფუნქციის, რადგან ის main() ფუნქციის ნაწილია. </p><p>ციკლებისთვის, ლურჯი გამოძახების ისრები მიუთითებს, რომ ეს დამატებულია ხელოვნური გამოძახება, რათა გრაფიკი სწორი იყოს, მაგრამ ის რეალობაში არასდროს მომხდარა.</p><p>თუ გრაფიკი ვიჯეტის ფართობზე დიდია, წიბოზე მინიატურას გაჩვენებთ. არსებობს იგივენაირი ვიზუალიზაციის პარამეტრები გამოძახების ხის რუკისთვისაც. მონიშნული ფუნქცია გამოიკვეთება.</p>

[ctx: CallGraphView|]
en: Warning: a long lasting graph layouting is in progress.
    Reduce node/edge limits for speedup.
ka: გაფრთხილება: მიმდინარეობს გრაფიკის განლაგება, რომელსაც საკმაოდ დიდი დრო სჭირება.
    სიჩქარის გასაზრდელად შეამცირეთ კვანძების/წიბოების რაოდენობა.

[ctx: CallGraphView|]
en: Layouting stopped.
ka: განლაგება შეჩერდა.

[ctx: CallGraphView|]
en: The call graph has %1 nodes and %2 edges.
ka: გამოძახების გრაფიკს აქვს %1 კვანძი და %2 წიბო.

[ctx: CallGraphView|]
en: No graph available because the layouting process failed.
ka: გრაფიკი ხელმისაწვდომი არაა, რადგან განლაგების პროცესი ჩავარდა.

[ctx: CallGraphView|]
en: Trying to run the following command did not work:
    '%1'
ka: ვცდილობდი გამეშვა, მაგრამ არ იმუშავა შემდეგმა ბრძანებამ:
    '%1'

[ctx: CallGraphView|]
en: Please check that 'dot' is installed (package GraphViz).
ka: შეამოწმეთ, დაყენებულია თუ არა პროგრამა 'dot' (პაკეტი GraphViz).

[ctx: CallGraphView|]
en: No item activated for which to draw the call graph.
ka: ელემენტი, რომლისთვისაც გამოძახების რუკას დავხატავ, გააქტიურებული არაა.

[ctx: CallGraphView|]
en: No call graph can be drawn for the active item.
ka: აქტიური ელემენტისთვის გამოძახების რუკას ვერ დავხატავ.

[ctx: CallGraphView|]
en: Error running the graph layouting tool.
ka: გრაფიკის განლაგების პროგრამის გამოძახების შეცდომა.

[ctx: CallGraphView|]
en: There is no call graph available for function
    	'%1'
    because it has no cost of the selected event type.
ka: გამოძახების გრაფიკი ხელმისაწვდომი არაა ფუნქციისთვის 
    	'%1'
    იმიტომ, რომ მას მონიშნული მოვლენის ტიპის ღირებულება არ გააჩნია.

[ctx: CallGraphView|]
en: Caller Depth
ka: გამომძახებლის სიღრმე

[ctx: CallGraphView|]
en: Unlimited
ka: შეუზღუდავი

[ctx: CallGraphView|None]
en: Depth 0
ka: სიღრმე 0

[ctx: CallGraphView|]
en: max. 1
ka: მაქს. 1

[ctx: CallGraphView|]
en: max. 2
ka: მაქს. 2

[ctx: CallGraphView|]
en: max. 5
ka: მაქს. 5

[ctx: CallGraphView|]
en: max. 10
ka: მაქს. 10

[ctx: CallGraphView|]
en: max. 15
ka: მაქს. 15

[ctx: CallGraphView|]
en: Callee Depth
ka: გამოძახებულის სიღრმე

[ctx: CallGraphView|]
en: Min. Node Cost
ka: მინ. კვანძის ღირებულება

[ctx: CallGraphView|]
en: No Minimum
ka: მინიმუმის გარეშე

[ctx: CallGraphView|]
en: Min. Call Cost
ka: მინ. გამოძახების ღირებულება

[ctx: CallGraphView|]
en: Same as Node
ka: იგივე, რაც კვანძი

[ctx: CallGraphView|]
en: 50 % of Node
ka: კვანძის 50%

[ctx: CallGraphView|]
en: 20 % of Node
ka: კვანძის 20%

[ctx: CallGraphView|]
en: 10 % of Node
ka: კვანძის 10%

[ctx: CallGraphView|]
en: Birds-eye View
ka: გადახედვა

[ctx: CallGraphView|]
en: Top Left
ka: ზედა მარცხენა

[ctx: CallGraphView|]
en: Top Right
ka: ზედა მარჯვენა

[ctx: CallGraphView|]
en: Bottom Left
ka: ქვედა მარცხენა

[ctx: CallGraphView|]
en: Bottom Right
ka: ქვედა მარჯვენა

[ctx: CallGraphView|]
en: Automatic
ka: ავტომატური

[ctx: CallGraphView|]
en: Hide
ka: დამალვა

[ctx: CallGraphView|]
en: Layout
ka: განლაგება

[ctx: CallGraphView|]
en: Top to Down
ka: მაღლიდან დაბლა

[ctx: CallGraphView|]
en: Left to Right
ka: მარცხნიდან მარჯვნივ

[ctx: CallGraphView|]
en: Circular
ka: წრიული

[ctx: CallGraphView|]
en: Go to '%1'
ka: %1-ზე გადასვლა

[ctx: CallGraphView|]
en: Stop Layouting
ka: განლაგების შეჩერება

[ctx: CallGraphView|]
en: Export Graph
ka: გრაფიკის გატანა

[ctx: CallGraphView|]
en: As DOT file...
ka: DOT ფაილად...

[ctx: CallGraphView|]
en: As Image...
ka: როგორც გამოსახულება...

[ctx: CallGraphView|]
en: Graph
ka: გრაფიკი

[ctx: CallGraphView|]
en: Arrows for Skipped Calls
ka: ისრები გამოტოვებული გამოძახებებისთვის

[ctx: CallGraphView|]
en: Inner-cycle Calls
ka: შიდა-ციკლის გამოძახებები

[ctx: CallGraphView|]
en: Cluster Groups
ka: დაჯგუფება

[ctx: CallGraphView|]
en: Visualization
ka: ვიზუალიზაცია

[ctx: CallGraphView|]
en: Compact
ka: დაპატარავება

[ctx: CallGraphView|]
en: Normal
ka: ნორმალური

[ctx: CallGraphView|]
en: Tall
ka: მაღალი

[ctx: CallGraphView|]
en: Export Graph As Image
ka: გრაფიკის გამოსახულების ფაილში გატანა

[ctx: CallGraphView|]
en: Images (*.png *.jpg)
ka: გამოსახულებები (*.png *.jpg)

[ctx: QObject|]
en: (active)
ka: (აქტიური)

[ctx: CallMapView|Name]
en: A thing's name
ka: ობიექტის სახელი

[ctx: CallMapView|]
en: Cost
ka: ფასი

[ctx: CallMapView|]
en: Location
ka: მდებარეობა

[ctx: CallMapView|]
en: Calls
ka: ზარები

[ctx: CallMapView|]
en: <b>Caller Map</b><p>This graph shows the nested hierarchy of all callers of the current activated function. Each colored rectangle represents a function; its size tries to be proportional to the cost spent therein while the active function is running (however, there are drawing constraints).</p>
ka: <b>გამომძახებლების რუკა</b><p>ეს გრაფიკი ამჟამად აქტივირებული ფუნქციის ყველა გამომძახებლის ჩალაგებულ იერარქიას აჩვენებს. თითოეული ფერადი ოთხკუთხედი წარმოადგენს ფუნქციას, მისი ზომა კი დაახლოებით პროპორციულია ღირებულების, რომელიც დახარჯულია, სანამ ფუნქცია გაშვებული იყო (მაგრამ, არსებობს ხატვის შეზღუდვები).</p>

[ctx: CallMapView|]
en: <b>Call Map</b><p>This graph shows the nested hierarchy of all callees of the current activated function. Each colored rectangle represents a function; its size tries to be proportional to the cost spent therein while the active function is running (however, there are drawing constraints).</p>
ka: <b>გამოძახების რუკა</b><p>ეს გრაფიკი ამჟამად აქტივირებული ფუნქციის ყველა გამოძახებული ჩალაგებულ იერარქიას აჩვენებს. თითოეული ფერადი ოთხკუთხედი წარმოადგენს ფუნქციას, მისი ზომა კი დაახლოებით პროპორციულია ღირებულების, რომელიც დახარჯულია, სანამ ფუნქცია გაშვებული იყო (მაგრამ, არსებობს ხატვის შეზღუდვები).</p>

[ctx: CallMapView|]
en: <p>Appearance options can be found in the context menu. To get exact size proportions, choose 'Hide incorrect borders'. As this mode can be <em>very</em> time consuming, you may want to limit the maximum drawn nesting level before. 'Best' determinates the split direction for children from the aspect ratio of the parent. 'Always Best' decides on remaining space for each sibling. 'Ignore Proportions' takes space for function name drawing <em>before</em> drawing children. Note that size proportions can get <em>heavily</em> wrong.</p><p>This is a <em>TreeMap</em> widget. Keyboard navigation is available with the left/right arrow keys for traversing siblings, and up/down arrow keys to go a nesting level up/down. <em>Return</em> activates the current item.</p>
ka: <p>გარეგნობის პარამეტრები კონტექსტურ მენიუში შეგიძლიათ, იპოვოთ. ზომის ზუსტი პროპორციების გასაგებად ჩართეთ 'არასწორი საზღვრების დამალვა', რადგან ეს რეჟიმი <em>ძალიან</em> ბევრ დროს ხარჯავს, შეიძლება, გსურთ შეზღუდოთ მაქსიმალური დახატული ჩალაგების დონეები მანამდე. 'საუკეთესო' განსაზღვრავს გაყოფის მიმართულებას შვილებისთვის მშობლის ზომის ფარდობიდან. 'ყოველთვის საუკეთესი' განსაზღვრავს დარჩენილ ადგილს თითოეული შვილისთვის. 'პროპორციების იგნორი' ადგილს ფუნქციების სახელის დასახატად შვილების <em>დახატვამდე</em> გამოყოფს. დაიმახსოვრეთ, რომ ზომის პროპორციები შეიძლება <em>ძალიან</em> არასწორი იყოს.</p><p>ეს <em>ხის რუკის</em>ვიჯეტია. კლავიატურის ნავიგაცია ხელმისაწვდომია მარჯვენა/მარცხენა ისრებით ერთი დონის შვილებისთვის. ჩალაგების დონეებში ნავიგაციისთვის კი ზემოთ/ქვემოთ ისრები გამოიყენეთ. ღილაკი <em>Enter</em> მიმდინარე ელემენტს გაააქტიურებს.</p>

[ctx: CallMapView|]
en: Go To
ka: გადასვლა

[ctx: CallMapView|]
en: Stop at Depth
ka: სიღრმეზე გაჩერება

[ctx: CallMapView|]
en: No Depth Limit
ka: სიღრის ლიმტის გარეშე

[ctx: CallMapView|]
en: Depth 10
ka: 10

[ctx: CallMapView|]
en: Depth 15
ka: 15

[ctx: CallMapView|]
en: Depth 20
ka: 20

[ctx: CallMapView|]
en: Depth of '%1' (%2)
ka: '%1'-ის სიღრმე (%2)

[ctx: CallMapView|]
en: Decrement Depth (to %1)
ka: სიღრმის შემცირება (%1-მდე)

[ctx: CallMapView|]
en: Increment Depth (to %1)
ka: სიღრმის გაზრდა (%1-მდე)

[ctx: CallMapView|]
en: Stop at Function
ka: გაჩერება ფუნქციაზე

[ctx: CallMapView|]
en: No Function Limit
ka: ფუნქცის ლიმიტის გარეშე

[ctx: CallMapView|]
en: Stop at Area
ka: ფართობზე გაჩერება

[ctx: CallMapView|]
en: No Area Limit
ka: ადგილის ლიმიტის გარეშე

[ctx: CallMapView|]
en: 100 Pixels
ka: 100 პიქსელი

[ctx: CallMapView|]
en: 200 Pixels
ka: 200 პიქსელი

[ctx: CallMapView|]
en: 500 Pixels
ka: 500 პიქსელი

[ctx: CallMapView|]
en: 1000 Pixels
ka: 1000 პიქსელი

[ctx: CallMapView|]
en: Area of '%1' (%2)
ka: '%1'-ის ფართობი (%2)

[ctx: CallMapView|]
en: Double Area Limit (to %1)
ka: ფართობის საზღვრის გაორმაგება (%1-მდე)

[ctx: CallMapView|]
en: Half Area Limit (to %1)
ka: ნახევარი ადგილის ლიმიტი (%1-მდე)

[ctx: CallMapView|]
en: Visualization
ka: ვიზუალიზაცია

[ctx: CallMapView|]
en: Split Direction
ka: გაყოფის მიმართულება

[ctx: CallMapView|]
en: Skip Incorrect Borders
ka: არასწორი საზღვრების გამოტოვება

[ctx: CallMapView|]
en: Border Width
ka: საზღვრის სიგანე

[ctx: CallMapView|]
en: Border 0
ka: საზღვარი 0

[ctx: CallMapView|]
en: Border 1
ka: საზღვარი 1

[ctx: CallMapView|]
en: Border 2
ka: საზღვარი 2

[ctx: CallMapView|]
en: Border 3
ka: საზღვარი 3

[ctx: CallMapView|]
en: Draw Symbol Names
ka: სიმბოლოს სახელების დახატვა

[ctx: CallMapView|]
en: Draw Cost
ka: ფასის დახატვა

[ctx: CallMapView|]
en: Draw Location
ka: მდებარეობის დახატვა

[ctx: CallMapView|]
en: Draw Calls
ka: გამოძახებების გახატვა

[ctx: CallMapView|]
en: Ignore Proportions
ka: პროპორციების იგნორი

[ctx: CallMapView|]
en: Allow Rotation
ka: შემობრუნების ჩართვა

[ctx: CallMapView|]
en: Shading
ka: ჩრდილები

[ctx: CallMapView|]
en: Call Map: Current is '%1'
ka: გამოძახებების რუკა: მიმდინარეა '%1'

[ctx: QObject|]
en: (no function)
ka: (ფუნქციის გარეშე)

[ctx: QObject|]
en: (no call)
ka: (გამოძახების გარეშე)

[ctx: CallView|]
en: Cost
ka: ფასი

[ctx: CallView|]
en: Cost per call
ka: გამოძახების ფასი

[ctx: CallView|]
en: Cost 2
ka: ღირებულება 2

[ctx: CallView|]
en: Cost 2 per call
ka: ღირებულება 2 თითოეულ გამოძახებაზე

[ctx: CallView|]
en: Count
ka: რაოდენობა

[ctx: CallView|]
en: Caller
ka: გამომძახებელი

[ctx: CallView|]
en: Callee
ka: გამოძახებული

[ctx: CallView|]
en: <b>List of direct Callers</b><p>This list shows all functions calling the current selected one directly, together with a call count and the cost spent in the current selected function while being called from the function from the list.</p><p>An icon instead of an inclusive cost specifies that this is a call inside of a recursive cycle. An inclusive cost makes no sense here.</p><p>Selecting a function makes it the current selected one of this information panel. If there are two panels (Split mode), the function of the other panel is changed instead.</p>
ka: <b>პირდაპირი გამომძახებლების სია</b><p>ეს სია შეიცავს ფუნქციებს, რომლებიც მიმდინარე ფუნქციას პირდაპირ იძახებენ, გამოძახებების რაოდენობასა და ამჟამად მონიშნული ფუნქციის ღირებულებით, რომელიც მონიშნული ფუნქციიდან გამოძახებისას დაიხარჯა.</p><p>ხატულა ინკლუზიური ფასის მაგიერ მიუთითებს, რომ ეს გამოძახება რეკურსიული ციკლის ნაწილია. ინკლუზიურ ღირებულებას აქ აზრი არ აქვს.</p><p>ფუნქციის მონიშვნა მას მიმდინარეს გახდის ერთ-ერთ ინფორმაციის პანელში. თუ არსებობს ორი პანელი (გაყოფის რეჟიმი), შეიცვლება სხვა პანელის ფუნქცია.</p>

[ctx: CallView|]
en: <b>List of direct Callees</b><p>This list shows all functions called by the current selected one directly, together with a call count and the cost spent in this function while being called from the selected function.</p><p>Selecting a function makes it the current selected one of this information panel. If there are two panels (Split mode), the function of the other panel is changed instead.</p>
ka: <b>პირდაპირი გამომძახებლების სია</b><p>ეს სია აჩვენებს ყველა ფუნქციას, რომელიც ამჟამად მონიშნული პირდაპირ იძახებს, გამოძახებების რაოდენობისა და ღირებულების ჩათვლით, რომელიც ფუნქციის გამოძახებისას დაიხარჯა.</p><p>ფუნქციის მონიშვნა მას მიმდინარედ დააყენებს და ის ინფორმაციის პანელზე გამოჩნდება. თუ გაქვთ ორი პანელი (გაყოფილი რეჟიმი), ამის მაგიერ, სხვა პანელის ფუნქცია შეიცვლება.</p>

[ctx: CallView|]
en: Go to '%1'
ka: %1-ზე გადასვლა

[ctx: CallView|]
en: %1 per call
ka: %1 თითოეული გამოძახებისას

[ctx: QObject|]
en: Control-flow graph requires running callgrind with option --dump-instr=yes
ka: Control-flow-ის გრაფიკი ითხოვს, გაშვებული იყოს callgrind პარამეტრით --dump-instr=yes

[ctx: QObject|]
en: For annotated machine code, the following object file is needed
        '%1'
    This file cannot be found.
ka: ანოტაციის მქონე მანქანური კოდისთვის შემდეგი ობიექტის ფაილია საჭირო:
        '%1'
    ფაილი აღმოჩენილი არაა.

[ctx: QObject|]
en: If cross-compiled, set SYSROOT variable.
ka: თუ ჯვარედიდან/აგებულია, დააყენეთ ცვლადი SYSROOT.

[ctx: QObject|]
en: There is an error trying to execute the command
        '%1'
    Check that you have installed 'objdump'.
    This utility can be found in the 'binutils' package
ka: შესრულების შეცდომა ბრძანებისთვის
        "%1"
    შეამოწმეთ, დაყენებული გაქვთ თუ არა 'objdump'.
    ამ პროგრამას პაკეტში 'binutils' იპოვით

[ctx: QObject|]
en: There are %1 cost line(s) without machine code.
    This happens because the code of %2 does not seem to match the profile data file.
    Are you using an old profile data file or is the abovementioned
    ELF object from an updated installation/another machine?
ka: არსებობს %1 ფასის ხაზი მანქაური კოდის გარეშე.
    ეს ხდება იმიტომ, რომ %2-ის კოდი, როგორც ჩანს, პროფილის მონაცემების ფაილს არ ემთხვევა.
    იყენებთ ძველ პროფილის მონაცემების ფაილს, თუ ზემოთ მოხსენიებული
    ELF ობიექტის ფაილი სხვა მანქანიდანაა?

[ctx: QObject|]
en: There seems to be an error trying to execute the command '%1'.
    Check that the ELF object used in the command exists.
    Check that you have installed 'objdump'.
    This utility can be found in the 'binutils' package.
ka: როგორც ჩანს, არსებობს შესრულები შეცდომა პროგრამისთვის '%1'.
    შეამოწმეთ, რომ ბრძანების მიერ გამოყენებული ELF ობიექტი არსებობს.
    შეამოწმეთ, რომ დაყენებული გაქვთ 'objdump'.
    ეს პროგრამა პაკეტის 'binutils' ნაწილია.

[ctx: QObject|]
en: This is Control Flow Graph by KetchuppOfficial
ka: ეს არის საკონტროლო ნაკადის გრაფიკი KetchuppOfficial-სგან

[ctx: QObject|]
en: Warning: a long lasting graph layouting is in progress.
    Reduce node/edge limits for speedup.
ka: გაფრთხილება: მიმდინარეობს გრაფიკის განლაგება, რომელსაც საკმაოდ დიდი დრო სჭირება.
    სიჩქარის გასაზრდელად შეამცირეთ კვანძების/წიბოების რაოდენობა.

[ctx: QObject|]
en: Layouting stopped.
ka: განლაგება შეჩერდა.

[ctx: QObject|]
en: The call graph has %1 nodes and %2 edges.
ka: გამოძახების გრაფიკს აქვს %1 კვანძი და %2 წიბო.

[ctx: QObject|]
en: No graph available because the layouting process failed.
ka: გრაფიკი ხელმისაწვდომი არაა, რადგან განლაგების პროცესი ჩავარდა.

[ctx: QObject|]
en: Trying to run the following command did not work:
    '%1'
ka: ვცდილობდი გამეშვა, მაგრამ არ იმუშავა შემდეგმა ბრძანებამ:
    '%1'

[ctx: QObject|]
en: Please check that 'dot' is installed (package GraphViz).
ka: შეამოწმეთ, დაყენებულია თუ არა პროგრამა 'dot' (პაკეტი GraphViz).

[ctx: QObject|]
en: Error running the graph layouting tool.
    Please check that 'dot' is installed (package Graphviz).
ka: გრაფიკის განლაგების პროგრამის გაშვების შეცდომა.
    შეამოწმეთ, დაყენებულია თუ არა პროგრამა 'dot' (პაკეტი GraphViz).

[ctx: QObject|]
en: This basic block
ka: ეს საბაზისო ბლოკია

[ctx: QObject|]
en: PC only
ka: მხოლოდ PC

[ctx: QObject|]
en: Show instructions' PC
ka: ინსტრუქციის პროფილის კონტექსტის ჩვენება

[ctx: QObject|]
en: Show instructions' cost
ka: ინსტრუქციის ღირებულების ჩვენება

[ctx: QObject|]
en: As DOT file...
ka: DOT ფაილად...

[ctx: QObject|]
en: As Image...
ka: როგორც გამოსახულება...

[ctx: QObject|]
en: Export Graph as Image
ka: გრაფიკის გატანა გამოსახულების ფაილში

[ctx: QObject|]
en: Images (*.png *.jpg)
ka: გამოსახულებები (*.png *.jpg)

[ctx: QObject|]
en: No trace data
ka: ტრეისის მონაცემების გარეშე

[ctx: QObject|]
en: No item activated for which to draw the control-flow graph.
ka: ელემენტი, რომლისთვისაც კონტროლის დინების გრაფიკს დავხატავ, გააქტიურებული არაა.

[ctx: QObject|]
en: No control-flow graph can be drawn for the active item.
ka: აქტიური ელემენტისთვის კონტროლის დინების გრაფიკს ვერ დავხატავ.

[ctx: QObject|]
en: Stop Layouting
ka: განლაგების შეჩერება

[ctx: QObject|]
en: Birds-eye View
ka: გადახედვა

[ctx: QObject|]
en: Top Left
ka: ზედა მარცხენა

[ctx: QObject|]
en: Top Right
ka: ზედა მარჯვენა

[ctx: QObject|]
en: Bottom Left
ka: ქვედა მარცხენა

[ctx: QObject|]
en: Bottom Right
ka: ქვედა მარჯვენა

[ctx: QObject|]
en: Automatic
ka: ავტომატური

[ctx: QObject|]
en: Hide
ka: დამალვა

[ctx: QObject|]
en: Layout
ka: განლაგება

[ctx: QObject|]
en: Top to Down
ka: მაღლიდან დაბლა

[ctx: QObject|]
en: Left to Right
ka: მარცხნიდან მარჯვნივ

[ctx: QObject|]
en: Min. basic block cost
ka: მინ. საბაზისო ბლოკის ღირებულება

[ctx: QObject|]
en: Undefined
ka: გაურკვეველი

[ctx: QObject|]
en: (%n item(s) skipped) | (%n item(s) skipped)
ka[0]: (გამოტოვებულია %n ელემენტი)
ka[1]: (გამოტოვებულია %n ელემენტი)

[ctx: QObject|]
en: (%n function(s) skipped) | (%n function(s) skipped)
ka[0]: (გამოტოვებულია %n ფუნქცია)
ka[1]: (გამოტოვებულია %n ფუნქცია)

[ctx: CoverageView|]
en: Incl.
ka: ჩათვლ.

[ctx: CoverageView|]
en: Distance
ka: მანძილი

[ctx: CoverageView|]
en: Called
ka: გამოძახებულია

[ctx: CoverageView|]
en: Caller
ka: გამომძახებელი

[ctx: CoverageView|]
en: Calling
ka: ირეკება

[ctx: CoverageView|]
en: Callee
ka: გამოძახებული

[ctx: CoverageView|]
en: <b>List of all Callers</b><p>This list shows all functions calling the current selected one, either directly or with several functions in-between on the stack; the number of functions in-between plus one is called the <em>Distance</em> (e.g. for function A,B,C there exists a call from A to C when A calls B and B calls C, i.e. A => B => C. The distance here is 2).</p><p>Absolute cost shown is the cost spent in the selected function while a listed function is active; relative cost is the percentage of all cost spent in the selected function while the listed one is active. The cost graphic shows logarithmic percentage with a different color for each distance.</p><p>As there can be many calls from the same function, the distance column sometimes shows the range of distances for all calls happening; then, in parentheses, there is the medium distance, i.e. the distance where most of the call costs happened.</p><p>Selecting a function makes it the current selected one of this information panel. If there are two panels (Split mode), the function of the other panel is changed instead.</p>
ka: <b>ყველა დამრეკველის სია</b><p>ეს სია აჩვენებს ყველა ფუნქციას, რომელიც მოუწოდებს მიმდინარე შერჩეულს,პირდაპირ ან რამდენიმე ფუნქციით დასტის შორის; პლუს ერთს შორის ფუნქციების რაოდენობას ეწოდება<em>მანძილი </em> (მაგ., ფუნქციისთვის a, B, C არსებობს ზარი a-დან C-მდე, როდესაც ზარები b და B მოუწოდებს C, ანუ A => B => C. მანძილი აქ არის 2).</p> <p>აბსოლუტური ღირებულება ნაჩვენებია შერჩეულ ფუნქციაში დახარჯული ღირებულება, ხოლო ჩამოთვლილი ფუნქცია აქტიურია; ფარდობითი ღირებულება არის შერჩეულ ფუნქციაში დახარჯული ყველა ღირებულების პროცენტი, ხოლო ჩამოთვლილი აქტიურია. ღირებულება გრაფიკული გვიჩვენებს ლოგარითმული პროცენტული სხვადასხვა ფერის თითოეული მანძილი.</p> <p>რადგან ერთი და იგივე ფუნქციიდან ბევრი ზარი შეიძლება იყოს, მანძილის სვეტი ზოგჯერ აჩვენებს მანძილების დიაპაზონს ყველა ზარისთვის; შემდეგ, ფრჩხილებში, არის საშუალო მანძილი, ანუ მანძილი, სადაც მოხდა ზარის ხარჯების უმეტესობა.</p> <p>ფუნქციის შერჩევა ხდის ამ ინფორმაციის პანელის მიმდინარე შერჩეულ ერთ-ერთს. თუ არსებობს ორი პანელი (გაყოფილი რეჟიმი), ამის ნაცვლად იცვლება მეორე პანელის ფუნქცია.</p>

[ctx: CoverageView|]
en: <b>List of all Callees</b><p>This list shows all functions called by the current selected one, either directly or with several function in-between on the stack; the number of function in-between plus one is called the <em>Distance</em> (e.g. for function A,B,C there exists a call from A to C when A calls B and B calls C, i.e. A => B => C. The distance here is 2).</p><p>Absolute cost shown is the cost spent in the listed function while the selected is active; relative cost is the percentage of all cost spent in the listed function while the selected one is active. The cost graphic always shows logarithmic percentage with a different color for each distance.</p><p>As there can be many calls to the same function, the distance column sometimes shows the range of distances for all calls happening; then, in parentheses, there is the medium distance, i.e. the distance where most of the call costs happened.</p><p>Selecting a function makes it the current selected one of this information panel. If there are two panels (Split mode), the function of the other panel is changed instead.</p>
ka: <b>სია ყველა Callees</b><p>ეს სია აჩვენებს ყველა ფუნქცია მოუწოდა მიმდინარე შერჩეული ერთი, ან პირდაპირ ან რამდენიმე ფუნქცია შორის დასტის; რაოდენობის ფუნქცია შორის პლუს ერთი ეწოდება<em>მანძილი </em> (მაგ ფუნქცია a,B,C არსებობს ზარი A To C როდესაც ზარები B და B მოუწოდებს C, ანუ A => B => c. მანძილი აქ არის 2).</p> <p>აბსოლუტური ღირებულება ნაჩვენებია ჩამოთვლილ ფუნქციაში დახარჯული ღირებულება, ხოლო შერჩეული აქტიურია; ფარდობითი ღირებულება არის ჩამოთვლილ ფუნქციაში დახარჯული ყველა ხარჯის პროცენტი, ხოლო შერჩეული აქტიურია. ხარჯების გრაფიკა ყოველთვის აჩვენებს ლოგარითმულ პროცენტს განსხვავებული ფერით თითოეული მანძილისთვის.</p> <p>რადგან შეიძლება ბევრი ზარი იყოს იმავე ფუნქციაზე, მანძილის სვეტი ზოგჯერ აჩვენებს მანძილების დიაპაზონს ყველა ზარის განხორციელებისთვის; შემდეგ, კვეთაში, არის საშუალო მანძილი, ანუ მანძილი, სადაც მოხდა ზარის ხარჯების უმეტესობა.</p> <p>ფუნქციის შერჩევა ხდის ამ ინფორმაციის პანელის მიმდინარე შერჩეულ ერთ-ერთს. თუ არსებობს ორი პანელი (გაყოფილი რეჟიმი), ამის ნაცვლად იცვლება მეორე პანელის ფუნქცია.</p>

[ctx: CoverageView|]
en: Go to '%1'
ka: %1-ზე გადასვლა

[ctx: QObject|]
en: Unknown Type
ka: უცნობი ტიპი

[ctx: EventTypeView|]
en: Event Type
ka: მოვლენის ტიპი

[ctx: EventTypeView|]
en: Incl.
ka: ჩათვლ.

[ctx: EventTypeView|]
en: Short
ka: მოკლე

[ctx: EventTypeView|]
en: Formula
ka: ფორმულა

[ctx: EventTypeView|]
en: <b>Cost Types List</b><p>This list shows all cost types available and what the self/inclusive cost of the current selected function is for that cost type.</p><p>By choosing a cost type from the list, you change the cost type of costs shown all over KCachegrind to be the selected one.</p>
ka: <b>ხარჯების ტიპების სია</b> < p>ეს სია აჩვენებს ყველა ხელმისაწვდომი ღირებულების ტიპს და რა არის მიმდინარე შერჩეული ფუნქციის თვით/ინკლუზიური ღირებულება ამ ღირებულების ტიპისთვის.</p> < p>სიიდან ღირებულების ტიპის არჩევით, თქვენ შეცვლით ხარჯების ტიპს, რომელიც ნაჩვენებია მთელ KCachegrind-ში, რომ იყოს არჩეული.</p>

[ctx: EventTypeView|]
en: Set as Secondary Event Type
ka: დააყენებს, როგორც დამხმარე მოვლენის ტიპს

[ctx: EventTypeView|]
en: Hide Secondary Event Type
ka: დამხმარე მოვლენის ტიპის დამალვა

[ctx: EventTypeView|]
en: Edit Long Name
ka: გრძელი სახელის ჩასწორება

[ctx: EventTypeView|]
en: Edit Short Name
ka: მოკლე სახელის ჩასწორება

[ctx: EventTypeView|]
en: Edit Formula
ka: ფორმულის ჩასწორება

[ctx: EventTypeView|]
en: Remove
ka: წაშლა

[ctx: EventTypeView|]
en: New Event Type...
ka: ახალი მოვლენის ტიპი...

[ctx: EventTypeView|]
en: New%1
ka: ახალი%1

[ctx: EventTypeView|]
en: New Event Type %1
ka: ახალი მოვლენის ტიპი %1

[ctx: FunctionListModel|]
en: Incl.
ka: ჩათვლ.

[ctx: FunctionListModel|]
en: Called
ka: გამოძახებულია

[ctx: FunctionListModel|]
en: Function
ka: ფუნქცია

[ctx: FunctionListModel|]
en: Location
ka: მდებარეობა

[ctx: FunctionListModel|]
en: (%1 function(s) skipped)
ka: (გამოტოვებულია %1 ფუნქცია)

[ctx: FunctionSelection|]
en: Function Profile
ka: ფუნქციის პროფილი

[ctx: FunctionSelection|]
en: &Search:
ka: &ძებნა:

[ctx: FunctionSelection|]
en: Search Query
ka: საძებნი სტრიქონი

[ctx: FunctionSelection|]
en: Group
ka: ჯგუფი

[ctx: FunctionSelection|]
en: (No Grouping)
ka: (დაჯგუფების გარეშე)

[ctx: FunctionSelection|]
en: <b>The Flat Profile</b><p>The flat profile contains a group and a function selection list. The group list contains all groups where costs are spent in, depending on the chosen group type. The group list is hidden when group type 'Function' is selected.</p><p>The function list contains the functions of the selected group (or all for 'Function' group type), ordered by the costs spent therein. Functions with costs less than 1% are hidden on default.</p>
ka: <b>ბრტყელი პროფილი</b> <p> ბრტყელი პროფილი შეიცავს ჯგუფს და ფუნქციის შერჩევის სიას. ჯგუფის სია შეიცავს ყველა ჯგუფს, სადაც ხარჯები იხარჯება, არჩეული ჯგუფის ტიპის მიხედვით. ჯგუფის სია იმალება, როდესაც ჯგუფის ტიპი "ფუნქცია" შეირჩევა.</p> < p>ფუნქციების სია შეიცავს შერჩეული ჯგუფის ფუნქციებს (ან ყველა "ფუნქციის" ჯგუფის ტიპისთვის), დალაგებული მასში დახარჯული ხარჯების მიხედვით. ფუნქციები, რომელთა ხარჯები 1% - ზე ნაკლებია, ნაგულისხმევად იმალება.</p>

[ctx: FunctionSelection|]
en: Go to '%1'
ka: %1-ზე გადასვლა

[ctx: FunctionSelection|]
en: Grouping
ka: დაჯგუფება

[ctx: FunctionSelection|]
en: No Grouping
ka: დაჯგუფების გარეშე

[ctx: QObject|]
en: Active call to '%1'
ka: აქტიური გამოძახება '%1'-ზე

[ctx: QObject|]
en: Call to '%1'
ka: '%1'-ის გამოძახება

[ctx: QObject|]
en: %n call(s) to '%2' | %n call(s) to '%2'
ka[0]: %n გამოძახება '%2'-ზე
ka[1]: %n გამოძახება '%2'-ზე

[ctx: QObject|]
en: Jump %1 of %2 times to 0x%3
ka: %1-დან %2 გადასვლა 0x%3-ზე

[ctx: QObject|]
en: Jump %1 times to 0x%2
ka: %1-ჯერ გადასვლა 0x%2-ze

[ctx: QObject|]
en: (cycle)
ka: (ციკლი)

[ctx: InstrView|]
en: Cost
ka: ფასი

[ctx: InstrView|]
en: Cost 2
ka: ღირებულება 2

[ctx: InstrView|]
en: Hex
ka: თექვსმეტობითი

[ctx: InstrView|]
en: Assembly Instructions
ka: ასამბლერის ინსტრუქციები

[ctx: InstrView|]
en: Source Position
ka: კოდის მდებარეობა

[ctx: InstrView|]
en: <b>Annotated Machine Code</b><p>The annotated machine code list shows the assembly instructions of the current selected function together with (self) cost spent while executing an instruction. If this is a call instruction, lines with details on the call happening are inserted into the source: the cost spent inside of the call, the number of calls happening, and the call destination.</p><p>The machine code shown is generated with the 'objdump' utility from the 'binutils' package.</p><p>Select a line with call information to make the destination function of this call current.</p>
ka: <b>ანოტირებული მანქანის კოდი</b> <p> ანოტირებული მანქანის კოდის სია აჩვენებს მიმდინარე შერჩეული ფუნქციის შეკრების ინსტრუქციებს ინსტრუქციის შესრულებისას დახარჯულ (თვით) ხარჯებთან ერთად. თუ ეს არის ზარის ინსტრუქცია, კოდიში ჩასმულია ხაზები ზარის შესახებ დეტალებით: ზარის შიგნით დახარჯული ღირებულება, ზარების რაოდენობა და ზარის დანიშნულება.</p> <p>ნაჩვენები მანქანის კოდი წარმოიქმნება "objdump" პროგრამით "binutils" პაკეტიდან.</p> <p>აირჩიეთ ხაზი ზარის ინფორმაციით, რათა ამ ზარის დანიშნულების ფუნქცია მიმდინარე იყოს.</p>

[ctx: InstrView|]
en: Go to '%1'
ka: %1-ზე გადასვლა

[ctx: InstrView|]
en: Go to Address %1
ka: გადასვლა მისამართზე %1

[ctx: InstrView|]
en: Hex Code
ka: თექვსმეტობითი კოდი

[ctx: InstrView|]
en: There is no instruction info in the profile data file.
ka: პროფილის მონაცემების ფაილში ინსტრუქციის ინფორმაცია აღწერილი არაა.

[ctx: InstrView|]
en: Tip: For Callgrind, rerun with option
ka: მინიშნება: Callgrind-სთვის, გაუშვით თავიდან, პარამეტრით

[ctx: InstrView|]
en: To see (conditional) jumps, additionally specify
ka: (პირობითი) გადასვლების სანახავად დამატებით მიუთიტეთ

[ctx: InstrView|]
en: For annotated machine code, the following object file is needed:
ka: ანოტაციის მქონე მანქანური კოდისთვის შემდეგი ობიექტის ფაილია საჭირო:

[ctx: InstrView|]
en: This file can not be found.
ka: ეს ფაილი აღმოჩენილი არაა.

[ctx: InstrView|]
en: If cross-compiled, set SYSROOT variable.
ka: თუ ჯვარედიდან/აგებულია, დააყენეთ ცვლადი SYSROOT.

[ctx: InstrView|]
en: There is an error trying to execute the command
ka: შეცდომა ბრძანების შესრულებისას

[ctx: InstrView|]
en: Check that you have installed 'objdump'.
ka: შეამოწმეთ, თუ გიყენიათ 'objdump'.

[ctx: InstrView|]
en: This utility can be found in the 'binutils' package.
ka: ეს პროგრამა 'binutils' პაკეტის ნაწილია.

[ctx: InstrView|]
en: (No Instruction)
ka: (ინსტრუქციის გარეშე)

[ctx: InstrView|]
en: There are %n cost line(s) without machine code. | There are %n cost line(s) without machine code.
ka[0]: არსებობს %n ღიღებულების ხაზი მანქანური კოდის გარეშე.
ka[1]: არსებობს %n ღიღებულების ხაზი მანქანური კოდის გარეშე.

[ctx: InstrView|]
en: This happens because the code of
ka: ეს ხდება იმიტომ, რომ კოდი ელემენტისთვის

[ctx: InstrView|]
en: does not seem to match the profile data file.
ka: პროფილის მონაცემების ფაილს არ ემთხვევა.

[ctx: InstrView|]
en: Are you using an old profile data file or is the above mentioned
ka: იყენებთ ძველ პროფილის მონაცემების ფაილს ან ხდება ერთ-ერთი ზემოჩამოთვლილიდან

[ctx: InstrView|]
en: ELF object from an updated installation/another machine?
ka: ELF ობიექტი განახლებული დაყენებიდან/სხვა მანქანიდან?

[ctx: InstrView|]
en: There seems to be an error trying to execute the command
ka: როგორც ჩანს, ამ ბრძანების შესრულება შეცდომებს იწვევს

[ctx: InstrView|]
en: Check that the ELF object used in the command exists.
ka: შემოწმება, არსებობს თუ არა ბრძანებაში გამოყენებული ELF ობიექტი.

[ctx: QObject|]
en: Profile Part %1
ka: პროფილის ნაწილი %1

[ctx: QObject|]
en: (no trace)
ka: (ტრეისის გარეშე)

[ctx: QObject|]
en: (no part)
ka: (ნაწილის გარეშე)

[ctx: QObject|]
en: (none)
ka: (არაფერი)

[ctx: PartSelection|]
en: Parts Overview
ka: ნაწილების მიმოხილვა

[ctx: PartSelection|A thing's name]
en: Name
ka: სახელი

[ctx: PartSelection|]
en: Cost
ka: ფასი

[ctx: PartSelection|]
en: (no trace parts)
ka: (ტრეისის ნაწილების გარეშე)

[ctx: PartSelection|]
en: <b>The Parts Overview</b><p>A trace consists of multiple trace parts when there are several profile data files from one profile run. The Trace Part Overview dockable shows these, horizontally ordered in execution time; the rectangle sizes are proportional to the total cost spent in the parts. You can select one or several parts to constrain all costs shown to these parts only.</p><p>The parts are further subdivided: there is a partitioning and an callee split mode: <ul><li>Partitioning: You see the partitioning into groups for a trace part, according to the group type selected. E.g. if ELF object groups are selected, you see colored rectangles for each used ELF object (shared library or executable), sized according to the cost spent therein.</li><li>Callee: A rectangle showing the inclusive cost of the current selected function in the trace part is shown. This is split up into smaller rectangles to show the costs of its callees.</li></ul></p>
ka: <b>ნაწილების მიმოხილვა</b> <p> კვალი შედგება მრავალი კვალი ნაწილისაგან, როდესაც არსებობს რამდენიმე პროფილის მონაცემთა ფაილი ერთი პროფილის გაშვებიდან. კვალი ნაწილი მიმოხილვა dockable გვიჩვენებს ამ, ჰორიზონტალურად უბრძანა შესრულების დროს; მართკუთხედი ზომის პროპორციული საერთო ღირებულება დაიხარჯა ნაწილები. თქვენ შეგიძლიათ აირჩიოთ ერთი ან რამდენიმე ნაწილი, რათა შეზღუდოთ მხოლოდ ამ ნაწილებზე ნაჩვენები ყველა ხარჯი.</p><p>ნაწილები კიდევ უფრო იყოფა: არსებობს დანაწევრება და callee გაყოფილი რეჟიმი:<ul> <li>დანაწევრება: ხედავთ დანაწევრებას ჯგუფებად კვალი ნაწილისთვის, შერჩეული ჯგუფის ტიპის მიხედვით. მაგ. თუ ELF ობიექტების ჯგუფები შეირჩევა, ხედავთ ფერად მართკუთხედებს თითოეული გამოყენებული ELF ობიექტისთვის (საერთო ბიბლიოთეკა ან შესრულებადი), ზომით მასში დახარჯული ღირებულების მიხედვით.</li> <li>Callee: ნაჩვენებია მართკუთხედი, რომელიც აჩვენებს მიმდინარე შერჩეული ფუნქციის ინკლუზიურ ღირებულებას კვალი ნაწილში. ეს იყოფა უფრო პატარა მართკუთხედებად, რათა აჩვენოს მისი კალეების ხარჯები.</li> </ul> </p>

[ctx: PartSelection|]
en: Profile Part Overview: Current is '%1'
ka: პროფილის ნაწილის გადახედვა: მიმდინარეა '%1'

[ctx: PartSelection|]
en: Deselect '%1'
ka: '%1'-ის მონიშვნის მოხსნა

[ctx: PartSelection|]
en: Select '%1'
ka: '%1'-ის მონიშვნა

[ctx: PartSelection|]
en: Select All Parts
ka: ყველა ნაწილის მონიშვნა

[ctx: PartSelection|]
en: Visible Parts
ka: ხილული ნაწილები

[ctx: PartSelection|]
en: Hide Selected Parts
ka: მონიშნული ნაწილების დამალვა

[ctx: PartSelection|]
en: Show Hidden Parts
ka: დამალული ნაწილების ჩვენება

[ctx: PartSelection|]
en: Go to '%1'
ka: %1-ზე გადასვლა

[ctx: PartSelection|]
en: Visualization
ka: ვიზუალიზაცია

[ctx: PartSelection|]
en: Partitioning Mode
ka: დაყოფის რეჟიმი

[ctx: PartSelection|]
en: Zoom Function
ka: გადიდების ფუნქცია

[ctx: PartSelection|]
en: Show Direct Calls
ka: პირდაპირი გამოძახებების ჩვენება

[ctx: PartSelection|]
en: Increment Shown Call Levels
ka: ნაჩვენები გამოძახების დონეების გაზრდა

[ctx: PartSelection|]
en: Diagram Mode
ka: დიაგრამის რეჟიმი

[ctx: PartSelection|]
en: Draw Names
ka: სახელების გამოტანა

[ctx: PartSelection|]
en: Draw Costs
ka: ფასების გამოტანა

[ctx: PartSelection|]
en: Ignore Proportions
ka: პროპორციების იგნორი

[ctx: PartSelection|]
en: Allow Rotation
ka: შემობრუნების ჩართვა

[ctx: PartSelection|]
en: Draw Frames
ka: ჩარჩოების დახატვა

[ctx: PartSelection|]
en: Hide Info
ka: ინფორმაციის დამალვა

[ctx: PartSelection|]
en: Show Info
ka: ინფორმაციის ჩვენება

[ctx: PartSelection|]
en: (no trace loaded)
ka: (ტრეისი ჩატვირთული არაა)

[ctx: PartView|]
en: Profile Part
ka: პროფილის ნაწილი

[ctx: PartView|]
en: Incl.
ka: ჩათვლ.

[ctx: PartView|]
en: Called
ka: გამოძახებულია

[ctx: PartView|]
en: Comment
ka: შენიშვნა

[ctx: PartView|]
en: <b>Trace Part List</b><p>This list shows all trace parts of the loaded trace. For each part, the self/inclusive cost of the current selected function, spent in the part, is shown; percentage costs are always relative to the total cost <em>of the part</em> (not to the whole trace as in the Trace Part Overview). Also shown are the calls happening to/from the current function inside of the trace part.</p><p>By choosing one or more trace parts from the list, the costs shown all over KCachegrind will only be the ones spent in the selected part(s). If no list selection is shown, in fact all trace parts are selected implicitly.</p><p>This is a multi-selection list. You can select ranges by dragging the mouse or use SHIFT/CTRL modifiers. Selection/Deselection of trace parts can also be done by using the Trace Part Overview Dockable. This one also supports multiple selection.</p><p>Note that the list is hidden if only one trace part is loaded.</p>
ka: <b>კვალი ნაწილი სია</b> <p> ეს სია აჩვენებს ყველა კვალი ნაწილები დატვირთული კვალი. თითოეული ნაწილისთვის ნაჩვენებია მიმდინარე შერჩეული ფუნქციის თვით/ინკლუზიური ღირებულება, რომელიც დახარჯულია ნაწილში; პროცენტული ხარჯები ყოველთვის ფარდობითია ნაწილის საერთო ღირებულებასთან <em></em> (არა მთელ კვალზე, როგორც კვალი ნაწილის მიმოხილვაში). ასევე ნაჩვენებია ზარები, რომლებიც ხდება / მიმდინარე ფუნქციიდან კვალი ნაწილის შიგნით.</p> <p>სიიდან ერთი ან მეტი კვალი ნაწილის არჩევით, kcachegrind-ზე ნაჩვენები ხარჯები იქნება მხოლოდ შერჩეულ ნაწილში დახარჯული ხარჯები. თუ სიის შერჩევა არ არის ნაჩვენები, სინამდვილეში ყველა კვალი ნაწილი ირიბად არის შერჩეული.</p> <p>ეს არის მრავალ შერჩევის სია. თქვენ შეგიძლიათ აირჩიოთ დიაპაზონები მაუსის გადმოწევით ან გამოიყენოთ SHIFT/CTRL მოდიფიკატორები. კვალი ნაწილების შერჩევა/გაუქმება ასევე შეიძლება გაკეთდეს კვალი ნაწილის მიმოხილვის გამოყენებით. ეს ასევე მხარს უჭერს მრავალჯერადი შერჩევა.</p> <p>გაითვალისწინეთ, რომ სია იმალება, თუ მხოლოდ ერთი კვალი ნაწილია დატვირთული.</p>

[ctx: QObject|]
en: Jump %1 of %2 times to %3
ka: %1-დან %2-ჯერ გადასვლა %3-ზე

[ctx: QObject|]
en: Jump %1 times to %2
ka: %1-ზე გადასვლა %2-ზე

[ctx: SourceView|]
en: Cost
ka: ფასი

[ctx: SourceView|]
en: Cost 2
ka: ღირებულება 2

[ctx: SourceView|]
en: Source
ka: კოდი

[ctx: SourceView|]
en: <b>Annotated Source</b><p>The annotated source list shows the source lines of the current selected function together with (self) cost spent while executing the code of this source line. If there was a call in a source line, lines with details on the call happening are inserted into the source: the cost spent inside of the call, the number of calls happening, and the call destination.</p><p>Select a inserted call information line to make the destination function current.</p>
ka: <b>ანოტირებული კოდი</b> <p> ანოტირებული კოდის სია აჩვენებს მიმდინარე შერჩეული ფუნქციის კოდის ხაზებს ამ კოდის ხაზის კოდის შესრულებისას დახარჯულ (თვით) ხარჯებთან ერთად. თუ იყო ზარი კოდის ხაზში, ხაზები, სადაც დეტალები ხდება ზარის შესახებ, ჩასმულია კოდიში: ზარის შიგნით დახარჯული ღირებულება, ზარების რაოდენობა და ზარის დანიშნულება.</p> <p>აირჩიეთ ჩასმული ზარის ინფორმაციის ხაზი, რათა დანიშნულების ფუნქცია მიმდინარე იყოს.</p>

[ctx: SourceView|]
en: Go to '%1'
ka: %1-ზე გადასვლა

[ctx: SourceView|]
en: Go to Line %1
ka: %1-ე ხაზზე გადასვლა

[ctx: SourceView|]
en: There is no cost of current selected type associated
ka: ამჟამად არჩეული ტიპის ღირებულება ასოცირებული არაა

[ctx: SourceView|]
en: with any source line of this function in file
ka: ამ ფუნქციის ნებისმიერ კოდის ხაზით ფაილში

[ctx: SourceView|]
en: Thus, no annotated source can be shown.
ka: ამიტომ, ანოტაციის მქონე კოდი ნაჩვენები არაა.

[ctx: SourceView|]
en: --- From '%1' ---
ka: --- '%1'-დან ---

[ctx: SourceView|]
en: --- Inlined from '%1' ---
ka: --- ხაზშივე, '%1'-სგან ---

[ctx: SourceView|]
en: --- Inlined from unknown source ---
ka: --- ხაზშივე, უცნობი კოდიდან---

[ctx: SourceView|]
en: There is no source available for the following function:
ka: კოდი ხელმისაწვდომი არაა შემდეგი ფუნქციისთვის:

[ctx: SourceView|]
en: This is because no debug information is present.
ka: ეს ხდება იმიტომ, რომ გამართვის ინფორმაცია წარმოდგენილი არაა.

[ctx: SourceView|]
en: Recompile source and redo the profile run.
ka: კოდის თავიდან აგება და პროფილის თავიდან გაშვება.

[ctx: SourceView|]
en: The function is located in this ELF object:
ka: ფუმქცია ამ ELF ობიექტშია მოთავსებული:

[ctx: SourceView|]
en: This is because its source file cannot be found:
ka: ხდება იმიტომ, რომ მისი კოდის ფაილი ვერ ვიპოვე:

[ctx: SourceView|]
en: Add the folder of this file to the source folder list.
ka: ამ ფაილის საქაღალდის ჩამატება კოდის საქაღალდეების სიაში.

[ctx: SourceView|]
en: The list can be found in the configuration dialog.
ka: სია შეგიძლიათ მორგების ფანჯარაში იხილოთ.

[ctx: StackSelection|]
en: Stack Selection
ka: სტეკის არჩევანი

[ctx: StackSelection|]
en: Cost
ka: ფასი

[ctx: StackSelection|]
en: Cost2
ka: ღირებულება2

[ctx: StackSelection|]
en: Calls
ka: ზარები

[ctx: StackSelection|]
en: Function
ka: ფუნქცია

[ctx: TabBar|]
en: Move to Top
ka: თავში ატანა

[ctx: TabBar|Move to Top]
en: Top
ka: ზემოთ

[ctx: TabBar|]
en: Move to Right
ka: მარჯვნივ გადატანა

[ctx: TabBar|Move to Right]
en: Right
ka: მარჯვნივ

[ctx: TabBar|]
en: Move to Bottom
ka: ბოლოში ჩამოტანა

[ctx: TabBar|Move to Bottom]
en: Bottom
ka: ბოლოში

[ctx: TabBar|]
en: Move to Bottom Left
ka: ქვემოთ მარცხნივ გადატანა

[ctx: TabBar|Move to Bottom Left]
en: Bottom Left
ka: ქვედა მარცხენა

[ctx: TabBar|]
en: Move Area To
ka: ადგილის გადატანა

[ctx: TabBar|]
en: Hide This Tab
ka: ამ ჩანართის დამალვა

[ctx: TabBar|]
en: Hide Area
ka: ადგილის დამალვა

[ctx: TabBar|Show on Top]
en: Top
ka: ზემოთ

[ctx: TabBar|Show on Right]
en: Right
ka: მარჯვნივ

[ctx: TabBar|Show on Bottom]
en: Bottom
ka: ბოლოში

[ctx: TabBar|Show on Bottom Left]
en: Bottom Left
ka: ქვედა მარცხენა

[ctx: TabBar|]
en: Show Hidden On
ka: დამალულის ჩვენება ჩართ

[ctx: TabView|]
en: (No profile data file loaded)
ka: (პროფილის მონაცემები ჩატვირთული არაა)

[ctx: TabView|]
en: Types
ka: ტიპები

[ctx: TabView|]
en: Callers
ka: გამომძახებლები

[ctx: TabView|]
en: All Callers
ka: ყველა გამომძახებელი

[ctx: TabView|]
en: Callee Map
ka: გამოძახებულის რუკა

[ctx: TabView|]
en: Source Code
ka: საწყისი კოდი

[ctx: TabView|]
en: Control Flow Graph
ka: კონტროლის ნაკადის გრაფიკი

[ctx: TabView|]
en: Parts
ka: ნაწილებ

[ctx: TabView|]
en: Callees
ka: გამოძახებულები

[ctx: TabView|]
en: Call Graph
ka: გამოძახებების გრაფი

[ctx: TabView|]
en: All Callees
ka: ყველა გამოძახებული

[ctx: TabView|]
en: Caller Map
ka: გამომძახებლის რუკა

[ctx: TabView|]
en: Machine Code
ka: მანქანური კოდი

[ctx: TabView|]
en: <b>Information Tabs</b><p>This widget shows information for the currently selected function in different tabs: <ul><li>The Costs tab shows a list of available event types and the inclusive and self-costs related to these types.</li><li>The Parts tab shows a list of trace parts if the trace consists of more than one part (otherwise, this tab is hidden). The cost of the selected function spent in the different parts together with the calls happening is shown.</li><li>The Call Lists tab shows direct callers and callees of the function in more detail.</li><li>The Coverage tab shows the same as the Call Lists tab, but also shows indirect callers and callees, not just direct ones.</li><li>The Call Graph tab shows a graphical visualization of the calls made by this function.</li><li>The Source Code tab presents annotated source code if debugging information and the source file are available.</li><li>The Machine Code tab presents annotated assembly instructions if profile information at instruction level is available.</li></ul>For more information, see the <em>What's This?</em> help of the corresponding tab widget.</p>
ka: <b>საინფორმაციო ჩანართები</b><p>ეს ვიჯეტი აჩვენებს ინფორმაციას ამჟამად შერჩეული ფუნქციისთვის სხვადასხვა ჩანართებში:<ul> <li > ხარჯების ჩანართი აჩვენებს ხელმისაწვდომი ღონისძიების ტიპების ჩამონათვალს და ამ ტიპებთან დაკავშირებულ ინკლუზიურ და თვით ხარჯებს.</li> <li>ნაწილების ჩანართი აჩვენებს კვალი ნაწილების ჩამონათვალს, თუ კვალი შედგება ერთზე მეტი ნაწილისგან (წინააღმდეგ შემთხვევაში, ეს ჩანართი იმალება). ნაჩვენებია სხვადასხვა ნაწილში დახარჯული შერჩეული ფუნქციის ღირებულება ზარებთან ერთად.</li> <li>ზარის სიების ჩანართში მოცემულია ფუნქციის პირდაპირი დამრეკველები და კალეები უფრო დეტალურად.</li> <li>დაფარვის ჩანართი აჩვენებს იგივე, რაც ზარის სიების ჩანართი, მაგრამ ასევე აჩვენებს არაპირდაპირ დამრეკველებს და კალეებს, არა მხოლოდ პირდაპირი პირობა.</li> <li>ზარის გრაფიკის ჩანართი აჩვენებს ამ ფუნქციის მიერ განხორციელებული ზარების გრაფიკულ ვიზუალიზაციას.</li> <li>წყარო კოდის ჩანართი წარმოადგენს ანოტირებულ წყაროს კოდს, თუ ხელმისაწვდომია ინფორმაციის გამართვა და წყარო ფაილი.</li> <li>მანქანა კოდი tab წარმოგიდგენთ ანოტირებული ასამბლეის ინსტრუქციებს, თუ პროფილის ინფორმაცია ინსტრუქციის დონეზე ხელმისაწვდომია.</li> </ul>დამატებითი ინფორმაციისთვის იხილეთ <em > რა არის ეს?</em> შესაბამისი ჩანართის ვიჯეტის დახმარება.</p>

[ctx: TabView|]
en: (No function selected)
ka: (ფუნქცია არჩეული არაა)

[ctx: QObject|]
en: No description available
ka: აღწერის გარეშე

[ctx: TreeMapWidget|]
en: Text %1
ka: ტექტი %1

[ctx: TreeMapWidget|]
en: Recursive Bisection
ka: რეკურსიული ბისექცია

[ctx: TreeMapWidget|]
en: Columns
ka: სვეტები

[ctx: TreeMapWidget|]
en: Rows
ka: სტრიქონები

[ctx: TreeMapWidget|]
en: Always Best
ka: ყოველთვის საუკეთესო

[ctx: TreeMapWidget|]
en: Best
ka: საუკეთესო

[ctx: TreeMapWidget|]
en: Alternate (V)
ka: ალტერნატიული (V)

[ctx: TreeMapWidget|]
en: Alternate (H)
ka: ალტერნატიული (H)

[ctx: TreeMapWidget|]
en: Horizontal
ka: ჰორიზონტალური

[ctx: TreeMapWidget|]
en: Vertical
ka: ვერტიკალური
