{-
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998

************************************************************************
*                                                                      *
\section[FloatIn]{Floating Inwards pass}
*                                                                      *
************************************************************************

The main purpose of @floatInwards@ is floating into branches of a
case, so that we don't allocate things, save them on the stack, and
then discover that they aren't needed in the chosen branch.
-}

{-# LANGUAGE CPP #-}
{-# OPTIONS_GHC -fprof-auto #-}
{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}

module GHC.Core.Opt.FloatIn ( floatInwards ) where

#include "HsVersions.h"

import GHC.Prelude
import GHC.Platform

import GHC.Core
import GHC.Core.Make hiding ( wrapFloats )
import GHC.Driver.Types     ( ModGuts(..) )
import GHC.Core.Utils
import GHC.Core.FVs
import GHC.Core.Opt.Monad    ( CoreM )
import GHC.Types.Id         ( isOneShotBndr, idType, isJoinId, isJoinId_maybe )
import GHC.Types.Var
import GHC.Core.Type
import GHC.Types.Var.Set
import GHC.Utils.Misc
import GHC.Driver.Session
import GHC.Utils.Panic
import GHC.Types.Basic      ( RecFlag(..), isRec )

{-
Top-level interface function, @floatInwards@.  Note that we do not
actually float any bindings downwards from the top-level.
-}

floatInwards :: ModGuts -> CoreM ModGuts
floatInwards pgm@(ModGuts { mg_binds = binds })
  = do { dflags <- getDynFlags
       ; let platform = targetPlatform dflags
       ; return (pgm { mg_binds = map (fi_top_bind platform) binds }) }
  where
    fi_top_bind platform (NonRec binder rhs)
      = NonRec binder (fiExpr platform [] (freeVars rhs))
    fi_top_bind platform (Rec pairs)
      = Rec [ (b, fiExpr platform [] (freeVars rhs)) | (b, rhs) <- pairs ]

{-
************************************************************************
*                                                                      *
\subsection{Mail from Andr\'e [edited]}
*                                                                      *
************************************************************************

{\em Will wrote: What??? I thought the idea was to float as far
inwards as possible, no matter what.  This is dropping all bindings
every time it sees a lambda of any kind.  Help! }

You are assuming we DO DO full laziness AFTER floating inwards!  We
have to [not float inside lambdas] if we don't.

If we indeed do full laziness after the floating inwards (we could
check the compilation flags for that) then I agree we could be more
aggressive and do float inwards past lambdas.

Actually we are not doing a proper full laziness (see below), which
was another reason for not floating inwards past a lambda.

This can easily be fixed.  The problem is that we float lets outwards,
but there are a few expressions which are not let bound, like case
scrutinees and case alternatives.  After floating inwards the
simplifier could decide to inline the let and the laziness would be
lost, e.g.

\begin{verbatim}
let a = expensive             ==> \b -> case expensive of ...
in \ b -> case a of ...
\end{verbatim}
The fix is
\begin{enumerate}
\item
to let bind the algebraic case scrutinees (done, I think) and
the case alternatives (except the ones with an
unboxed type)(not done, I think). This is best done in the
GHC.Core.Opt.SetLevels module, which tags things with their level numbers.
\item
do the full laziness pass (floating lets outwards).
\item
simplify. The simplifier inlines the (trivial) lets that were
 created but were not floated outwards.
\end{enumerate}

With the fix I think Will's suggestion that we can gain even more from
strictness by floating inwards past lambdas makes sense.

We still gain even without going past lambdas, as things may be
strict in the (new) context of a branch (where it was floated to) or
of a let rhs, e.g.
\begin{verbatim}
let a = something            case x of
in case x of                   alt1 -> case something of a -> a + a
     alt1 -> a + a      ==>    alt2 -> b
     alt2 -> b

let a = something           let b = case something of a -> a + a
in let b = a + a        ==> in (b,b)
in (b,b)
\end{verbatim}
Also, even if a is not found to be strict in the new context and is
still left as a let, if the branch is not taken (or b is not entered)
the closure for a is not built.

************************************************************************
*                                                                      *
\subsection{Main floating-inwards code}
*                                                                      *
************************************************************************
-}

type FreeVarSet  = DIdSet
type BoundVarSet = DIdSet

data FloatInBind = FB BoundVarSet FreeVarSet FloatBind
        -- The FreeVarSet is the free variables of the binding.  In the case
        -- of recursive bindings, the set doesn't include the bound
        -- variables.

type FloatInBinds = [FloatInBind]
        -- In reverse dependency order (innermost binder first)

fiExpr :: Platform
       -> FloatInBinds      -- Binds we're trying to drop
                            -- as far "inwards" as possible
       -> CoreExprWithFVs   -- Input expr
       -> CoreExpr          -- Result

fiExpr _ to_drop (_, AnnLit lit)     = wrapFloats to_drop (Lit lit)
                                       -- See Note [Dead bindings]
fiExpr _ to_drop (_, AnnType ty)     = ASSERT( null to_drop ) Type ty
fiExpr _ to_drop (_, AnnVar v)       = wrapFloats to_drop (Var v)
fiExpr _ to_drop (_, AnnCoercion co) = wrapFloats to_drop (Coercion co)
fiExpr platform to_drop (_, AnnCast expr (co_ann, co))
  = wrapFloats (drop_here ++ co_drop) $
    Cast (fiExpr platform e_drop expr) co
  where
    [drop_here, e_drop, co_drop]
      = sepBindsByDropPoint platform False
          [freeVarsOf expr, freeVarsOfAnn co_ann]
          to_drop

{-
Applications: we do float inside applications, mainly because we
need to get at all the arguments.  The next simplifier run will
pull out any silly ones.
-}

fiExpr platform to_drop ann_expr@(_,AnnApp {})
  = wrapFloats drop_here $ wrapFloats extra_drop $
    mkTicks ticks $
    mkApps (fiExpr platform fun_drop ann_fun)
           (zipWithEqual "fiExpr" (fiExpr platform) arg_drops ann_args)
           -- use zipWithEqual, we should have
           -- length ann_args = length arg_fvs = length arg_drops
  where
    (ann_fun, ann_args, ticks) = collectAnnArgsTicks tickishFloatable ann_expr
    fun_ty  = exprType (deAnnotate ann_fun)
    fun_fvs = freeVarsOf ann_fun
    arg_fvs = map freeVarsOf ann_args

    (drop_here : extra_drop : fun_drop : arg_drops)
       = sepBindsByDropPoint platform False
                             (extra_fvs : fun_fvs : arg_fvs)
                             to_drop
         -- Shortcut behaviour: if to_drop is empty,
         -- sepBindsByDropPoint returns a suitable bunch of empty
         -- lists without evaluating extra_fvs, and hence without
         -- peering into each argument

    (_, extra_fvs) = foldl' add_arg (fun_ty, extra_fvs0) ann_args
    extra_fvs0 = case ann_fun of
                   (_, AnnVar _) -> fun_fvs
                   _             -> emptyDVarSet
          -- Don't float the binding for f into f x y z; see Note [Join points]
          -- for why we *can't* do it when f is a join point. (If f isn't a
          -- join point, floating it in isn't especially harmful but it's
          -- useless since the simplifier will immediately float it back out.)

    add_arg :: (Type,FreeVarSet) -> CoreExprWithFVs -> (Type,FreeVarSet)
    add_arg (fun_ty, extra_fvs) (_, AnnType ty)
      = (piResultTy fun_ty ty, extra_fvs)

    add_arg (fun_ty, extra_fvs) (arg_fvs, arg)
      | noFloatIntoArg arg arg_ty
      = (res_ty, extra_fvs `unionDVarSet` arg_fvs)
      | otherwise
      = (res_ty, extra_fvs)
      where
       (_, arg_ty, res_ty) = splitFunTy fun_ty

{- Note [Dead bindings]
~~~~~~~~~~~~~~~~~~~~~~~
At a literal we won't usually have any floated bindings; the
only way that can happen is if the binding wrapped the literal
/in the original input program/.  e.g.
   case x of { DEFAULT -> 1# }
But, while this may be unusual it is not actually wrong, and it did
once happen (#15696).

Note [Do not destroy the let/app invariant]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Watch out for
   f (x +# y)
We don't want to float bindings into here
   f (case ... of { x -> x +# y })
because that might destroy the let/app invariant, which requires
unlifted function arguments to be ok-for-speculation.

Note [Join points]
~~~~~~~~~~~~~~~~~~
Generally, we don't need to worry about join points - there are places we're
not allowed to float them, but since they can't have occurrences in those
places, we're not tempted.

We do need to be careful about jumps, however:

  joinrec j x y z = ... in
  jump j a b c

Previous versions often floated the definition of a recursive function into its
only non-recursive occurrence. But for a join point, this is a disaster:

  (joinrec j x y z = ... in
  jump j) a b c -- wrong!

Every jump must be exact, so the jump to j must have three arguments. Hence
we're careful not to float into the target of a jump (though we can float into
the arguments just fine).

Note [Floating in past a lambda group]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* We must be careful about floating inside a value lambda.
  That risks losing laziness.
  The float-out pass might rescue us, but then again it might not.

* We must be careful about type lambdas too.  At one time we did, and
  there is no risk of duplicating work thereby, but we do need to be
  careful.  In particular, here is a bad case (it happened in the
  cichelli benchmark:
        let v = ...
        in let f = /\t -> \a -> ...
           ==>
        let f = /\t -> let v = ... in \a -> ...
  This is bad as now f is an updatable closure (update PAP)
  and has arity 0.

* Hack alert!  We only float in through one-shot lambdas,
  not (as you might guess) through lone big lambdas.
  Reason: we float *out* past big lambdas (see the test in the Lam
  case of FloatOut.floatExpr) and we don't want to float straight
  back in again.

  It *is* important to float into one-shot lambdas, however;
  see the remarks with noFloatIntoRhs.

So we treat lambda in groups, using the following rule:

 Float in if (a) there is at least one Id,
         and (b) there are no non-one-shot Ids

 Otherwise drop all the bindings outside the group.

This is what the 'go' function in the AnnLam case is doing.

(Join points are handled similarly: a join point is considered one-shot iff
it's non-recursive, so we float only into non-recursive join points.)

Urk! if all are tyvars, and we don't float in, we may miss an
      opportunity to float inside a nested case branch

Note [Floating coercions]
~~~~~~~~~~~~~~~~~~~~~~~~~
We could, in principle, have a coercion binding like
   case f x of co { DEFAULT -> e1 e2 }
It's not common to have a function that returns a coercion, but nothing
in Core prohibits it.  If so, 'co' might be mentioned in e1 or e2
/only in a type/.  E.g. suppose e1 was
  let (x :: Int |> co) = blah in blah2

But, with coercions appearing in types, there is a complication: we
might be floating in a "strict let" -- that is, a case. Case expressions
mention their return type. We absolutely can't float a coercion binding
inward to the point that the type of the expression it's about to wrap
mentions the coercion. So we include the union of the sets of free variables
of the types of all the drop points involved. If any of the floaters
bind a coercion variable mentioned in any of the types, that binder must
be dropped right away.

-}

fiExpr platform to_drop lam@(_, AnnLam _ _)
  | noFloatIntoLam bndrs       -- Dump it all here
     -- NB: Must line up with noFloatIntoRhs (AnnLam...); see #7088
  = wrapFloats to_drop (mkLams bndrs (fiExpr platform [] body))

  | otherwise           -- Float inside
  = mkLams bndrs (fiExpr platform to_drop body)

  where
    (bndrs, body) = collectAnnBndrs lam

{-
We don't float lets inwards past an SCC.
        ToDo: keep info on current cc, and when passing
        one, if it is not the same, annotate all lets in binds with current
        cc, change current cc to the new one and float binds into expr.
-}

fiExpr platform to_drop (_, AnnTick tickish expr)
  | tickish `tickishScopesLike` SoftScope
  = Tick tickish (fiExpr platform to_drop expr)

  | otherwise -- Wimp out for now - we could push values in
  = wrapFloats to_drop (Tick tickish (fiExpr platform [] expr))

{-
For @Lets@, the possible ``drop points'' for the \tr{to_drop}
bindings are: (a)~in the body, (b1)~in the RHS of a NonRec binding,
or~(b2), in each of the RHSs of the pairs of a @Rec@.

Note that we do {\em weird things} with this let's binding.  Consider:
\begin{verbatim}
let
    w = ...
in {
    let v = ... w ...
    in ... v .. w ...
}
\end{verbatim}
Look at the inner \tr{let}.  As \tr{w} is used in both the bind and
body of the inner let, we could panic and leave \tr{w}'s binding where
it is.  But \tr{v} is floatable further into the body of the inner let, and
{\em then} \tr{w} will also be only in the body of that inner let.

So: rather than drop \tr{w}'s binding here, we add it onto the list of
things to drop in the outer let's body, and let nature take its
course.

Note [extra_fvs (1): avoid floating into RHS]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider let x=\y....t... in body.  We do not necessarily want to float
a binding for t into the RHS, because it'll immediately be floated out
again.  (It won't go inside the lambda else we risk losing work.)
In letrec, we need to be more careful still. We don't want to transform
        let x# = y# +# 1#
        in
        letrec f = \z. ...x#...f...
        in ...
into
        letrec f = let x# = y# +# 1# in \z. ...x#...f... in ...
because now we can't float the let out again, because a letrec
can't have unboxed bindings.

So we make "extra_fvs" which is the rhs_fvs of such bindings, and
arrange to dump bindings that bind extra_fvs before the entire let.

Note [extra_fvs (2): free variables of rules]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
  let x{rule mentioning y} = rhs in body
Here y is not free in rhs or body; but we still want to dump bindings
that bind y outside the let.  So we augment extra_fvs with the
idRuleAndUnfoldingVars of x.  No need for type variables, hence not using
idFreeVars.
-}

fiExpr platform to_drop (_,AnnLet bind body)
  = fiExpr platform (after ++ new_float : before) body
           -- to_drop is in reverse dependency order
  where
    (before, new_float, after) = fiBind platform to_drop bind body_fvs
    body_fvs    = freeVarsOf body

{- Note [Floating primops]
~~~~~~~~~~~~~~~~~~~~~~~~~~
We try to float-in a case expression over an unlifted type.  The
motivating example was #5658: in particular, this change allows
array indexing operations, which have a single DEFAULT alternative
without any binders, to be floated inward.

SIMD primops for unpacking SIMD vectors into an unboxed tuple of unboxed
scalars also need to be floated inward, but unpacks have a single non-DEFAULT
alternative that binds the elements of the tuple. We now therefore also support
floating in cases with a single alternative that may bind values.

But there are wrinkles

* Which unlifted cases do we float?
  See Note [PrimOp can_fail and has_side_effects] in GHC.Builtin.PrimOps which
  explains:
   - We can float in can_fail primops (which concerns imprecise exceptions),
     but we can't float them out.
   - But we can float a has_side_effects primop, but NOT inside a lambda,
     so for now we don't float them at all. Hence exprOkForSideEffects.
   - Throwing precise exceptions is a special case of the previous point: We
     may /never/ float in a call to (something that ultimately calls)
     'raiseIO#'.
     See Note [Precise exceptions and strictness analysis] in GHC.Types.Demand.

* Because we can float can-fail primops (array indexing, division) inwards
  but not outwards, we must be careful not to transform
     case a /# b of r -> f (F# r)
  ===>
    f (case a /# b of r -> F# r)
  because that creates a new thunk that wasn't there before.  And
  because it can't be floated out (can_fail), the thunk will stay
  there.  Disaster!  (This happened in nofib 'simple' and 'scs'.)

  Solution: only float cases into the branches of other cases, and
  not into the arguments of an application, or the RHS of a let. This
  is somewhat conservative, but it's simple.  And it still hits the
  cases like #5658.   This is implemented in sepBindsByJoinPoint;
  if is_case is False we dump all floating cases right here.

* #14511 is another example of why we want to restrict float-in
  of case-expressions.  Consider
     case indexArray# a n of (# r #) -> writeArray# ma i (f r)
  Now, floating that indexing operation into the (f r) thunk will
  not create any new thunks, but it will keep the array 'a' alive
  for much longer than the programmer expected.

  So again, not floating a case into a let or argument seems like
  the Right Thing

For @Case@, the possible drop points for the 'to_drop'
bindings are:
  (a) inside the scrutinee
  (b) inside one of the alternatives/default (default FVs always /first/!).

-}

fiExpr platform to_drop (_, AnnCase scrut case_bndr _ [(con,alt_bndrs,rhs)])
  | isUnliftedType (idType case_bndr)
  , exprOkForSideEffects (deAnnotate scrut)
      -- See Note [Floating primops]
  = wrapFloats shared_binds $
    fiExpr platform (case_float : rhs_binds) rhs
  where
    case_float = FB (mkDVarSet (case_bndr : alt_bndrs)) scrut_fvs
                    (FloatCase scrut' case_bndr con alt_bndrs)
    scrut'     = fiExpr platform scrut_binds scrut
    rhs_fvs    = freeVarsOf rhs `delDVarSetList` (case_bndr : alt_bndrs)
    scrut_fvs  = freeVarsOf scrut

    [shared_binds, scrut_binds, rhs_binds]
       = sepBindsByDropPoint platform False
           [scrut_fvs, rhs_fvs]
           to_drop

fiExpr platform to_drop (_, AnnCase scrut case_bndr ty alts)
  = wrapFloats drop_here1 $
    wrapFloats drop_here2 $
    Case (fiExpr platform scrut_drops scrut) case_bndr ty
         (zipWithEqual "fiExpr" fi_alt alts_drops_s alts)
         -- use zipWithEqual, we should have length alts_drops_s = length alts
  where
        -- Float into the scrut and alts-considered-together just like App
    [drop_here1, scrut_drops, alts_drops]
       = sepBindsByDropPoint platform False
           [scrut_fvs, all_alts_fvs]
           to_drop

        -- Float into the alts with the is_case flag set
    (drop_here2 : alts_drops_s)
      | [ _ ] <- alts = [] : [alts_drops]
      | otherwise     = sepBindsByDropPoint platform True alts_fvs alts_drops

    scrut_fvs    = freeVarsOf scrut
    alts_fvs     = map alt_fvs alts
    all_alts_fvs = unionDVarSets alts_fvs
    alt_fvs (_con, args, rhs)
      = foldl' delDVarSet (freeVarsOf rhs) (case_bndr:args)
           -- Delete case_bndr and args from free vars of rhs
           -- to get free vars of alt

    fi_alt to_drop (con, args, rhs) = (con, args, fiExpr platform to_drop rhs)

------------------
fiBind :: Platform
       -> FloatInBinds      -- Binds we're trying to drop
                            -- as far "inwards" as possible
       -> CoreBindWithFVs   -- Input binding
       -> DVarSet           -- Free in scope of binding
       -> ( FloatInBinds    -- Land these before
          , FloatInBind     -- The binding itself
          , FloatInBinds)   -- Land these after

fiBind platform to_drop (AnnNonRec id ann_rhs@(rhs_fvs, rhs)) body_fvs
  = ( extra_binds ++ shared_binds          -- Land these before
                                           -- See Note [extra_fvs (1,2)]
    , FB (unitDVarSet id) rhs_fvs'         -- The new binding itself
          (FloatLet (NonRec id rhs'))
    , body_binds )                         -- Land these after

  where
    body_fvs2 = body_fvs `delDVarSet` id

    rule_fvs = bndrRuleAndUnfoldingVarsDSet id        -- See Note [extra_fvs (2): free variables of rules]
    extra_fvs | noFloatIntoRhs NonRecursive id rhs
              = rule_fvs `unionDVarSet` rhs_fvs
              | otherwise
              = rule_fvs
        -- See Note [extra_fvs (1): avoid floating into RHS]
        -- No point in floating in only to float straight out again
        -- We *can't* float into ok-for-speculation unlifted RHSs
        -- But do float into join points

    [shared_binds, extra_binds, rhs_binds, body_binds]
        = sepBindsByDropPoint platform False
            [extra_fvs, rhs_fvs, body_fvs2]
            to_drop

        -- Push rhs_binds into the right hand side of the binding
    rhs'     = fiRhs platform rhs_binds id ann_rhs
    rhs_fvs' = rhs_fvs `unionDVarSet` floatedBindsFVs rhs_binds `unionDVarSet` rule_fvs
                        -- Don't forget the rule_fvs; the binding mentions them!

fiBind platform to_drop (AnnRec bindings) body_fvs
  = ( extra_binds ++ shared_binds
    , FB (mkDVarSet ids) rhs_fvs'
         (FloatLet (Rec (fi_bind rhss_binds bindings)))
    , body_binds )
  where
    (ids, rhss) = unzip bindings
    rhss_fvs = map freeVarsOf rhss

        -- See Note [extra_fvs (1,2)]
    rule_fvs = mapUnionDVarSet bndrRuleAndUnfoldingVarsDSet ids
    extra_fvs = rule_fvs `unionDVarSet`
                unionDVarSets [ rhs_fvs | (bndr, (rhs_fvs, rhs)) <- bindings
                              , noFloatIntoRhs Recursive bndr rhs ]

    (shared_binds:extra_binds:body_binds:rhss_binds)
        = sepBindsByDropPoint platform False
            (extra_fvs:body_fvs:rhss_fvs)
            to_drop

    rhs_fvs' = unionDVarSets rhss_fvs `unionDVarSet`
               unionDVarSets (map floatedBindsFVs rhss_binds) `unionDVarSet`
               rule_fvs         -- Don't forget the rule variables!

    -- Push rhs_binds into the right hand side of the binding
    fi_bind :: [FloatInBinds]       -- one per "drop pt" conjured w/ fvs_of_rhss
            -> [(Id, CoreExprWithFVs)]
            -> [(Id, CoreExpr)]

    fi_bind to_drops pairs
      = [ (binder, fiRhs platform to_drop binder rhs)
        | ((binder, rhs), to_drop) <- zipEqual "fi_bind" pairs to_drops ]

------------------
fiRhs :: Platform -> FloatInBinds -> CoreBndr -> CoreExprWithFVs -> CoreExpr
fiRhs platform to_drop bndr rhs
  | Just join_arity <- isJoinId_maybe bndr
  , let (bndrs, body) = collectNAnnBndrs join_arity rhs
  = mkLams bndrs (fiExpr platform to_drop body)
  | otherwise
  = fiExpr platform to_drop rhs

------------------
noFloatIntoLam :: [Var] -> Bool
noFloatIntoLam bndrs = any bad bndrs
  where
    bad b = isId b && not (isOneShotBndr b)
    -- Don't float inside a non-one-shot lambda

noFloatIntoRhs :: RecFlag -> Id -> CoreExprWithFVs' -> Bool
-- ^ True if it's a bad idea to float bindings into this RHS
noFloatIntoRhs is_rec bndr rhs
  | isJoinId bndr
  = isRec is_rec -- Joins are one-shot iff non-recursive

  | otherwise
  = noFloatIntoArg rhs (idType bndr)

noFloatIntoArg :: CoreExprWithFVs' -> Type -> Bool
noFloatIntoArg expr expr_ty
  | isUnliftedType expr_ty
  = True  -- See Note [Do not destroy the let/app invariant]

   | AnnLam bndr e <- expr
   , (bndrs, _) <- collectAnnBndrs e
   =  noFloatIntoLam (bndr:bndrs)  -- Wrinkle 1 (a)
   || all isTyVar (bndr:bndrs)     -- Wrinkle 1 (b)
      -- See Note [noFloatInto considerations] wrinkle 2

  | otherwise  -- Note [noFloatInto considerations] wrinkle 2
  = exprIsTrivial deann_expr || exprIsHNF deann_expr
  where
    deann_expr = deAnnotate' expr

{- Note [noFloatInto considerations]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When do we want to float bindings into
   - noFloatIntoRHs: the RHS of a let-binding
   - noFloatIntoArg: the argument of a function application

Definitely don't float in if it has unlifted type; that
would destroy the let/app invariant.

* Wrinkle 1: do not float in if
     (a) any non-one-shot value lambdas
  or (b) all type lambdas
  In both cases we'll float straight back out again
  NB: Must line up with fiExpr (AnnLam...); see #7088

  (a) is important: we /must/ float into a one-shot lambda group
  (which includes join points). This makes a big difference
  for things like
     f x# = let x = I# x#
            in let j = \() -> ...x...
               in if <condition> then normal-path else j ()
  If x is used only in the error case join point, j, we must float the
  boxing constructor into it, else we box it every time which is very
  bad news indeed.

* Wrinkle 2: for RHSs, do not float into a HNF; we'll just float right
  back out again... not tragic, but a waste of time.

  For function arguments we will still end up with this
  in-then-out stuff; consider
    letrec x = e in f x
  Here x is not a HNF, so we'll produce
    f (letrec x = e in x)
  which is OK... it's not that common, and we'll end up
  floating out again, in CorePrep if not earlier.
  Still, we use exprIsTrivial to catch this case (sigh)

************************************************************************
*                                                                      *
\subsection{@sepBindsByDropPoint@}
*                                                                      *
************************************************************************

This is the crucial function.  The idea is: We have a wad of bindings
that we'd like to distribute inside a collection of {\em drop points};
insides the alternatives of a \tr{case} would be one example of some
drop points; the RHS and body of a non-recursive \tr{let} binding
would be another (2-element) collection.

So: We're given a list of sets-of-free-variables, one per drop point,
and a list of floating-inwards bindings.  If a binding can go into
only one drop point (without suddenly making something out-of-scope),
in it goes.  If a binding is used inside {\em multiple} drop points,
then it has to go in a you-must-drop-it-above-all-these-drop-points
point.

We have to maintain the order on these drop-point-related lists.
-}

-- pprFIB :: FloatInBinds -> SDoc
-- pprFIB fibs = text "FIB:" <+> ppr [b | FB _ _ b <- fibs]

sepBindsByDropPoint
    :: Platform
    -> Bool                -- True <=> is case expression
    -> [FreeVarSet]        -- One set of FVs per drop point
                           -- Always at least two long!
    -> FloatInBinds        -- Candidate floaters
    -> [FloatInBinds]      -- FIRST one is bindings which must not be floated
                           -- inside any drop point; the rest correspond
                           -- one-to-one with the input list of FV sets

-- Every input floater is returned somewhere in the result;
-- none are dropped, not even ones which don't seem to be
-- free in *any* of the drop-point fvs.  Why?  Because, for example,
-- a binding (let x = E in B) might have a specialised version of
-- x (say x') stored inside x, but x' isn't free in E or B.

type DropBox = (FreeVarSet, FloatInBinds)

sepBindsByDropPoint platform is_case drop_pts floaters
  | null floaters  -- Shortcut common case
  = [] : [[] | _ <- drop_pts]

  | otherwise
  = ASSERT( drop_pts `lengthAtLeast` 2 )
    go floaters (map (\fvs -> (fvs, [])) (emptyDVarSet : drop_pts))
  where
    n_alts = length drop_pts

    go :: FloatInBinds -> [DropBox] -> [FloatInBinds]
        -- The *first* one in the argument list is the drop_here set
        -- The FloatInBinds in the lists are in the reverse of
        -- the normal FloatInBinds order; that is, they are the right way round!

    go [] drop_boxes = map (reverse . snd) drop_boxes

    go (bind_w_fvs@(FB bndrs bind_fvs bind) : binds) drop_boxes@(here_box : fork_boxes)
        = go binds new_boxes
        where
          -- "here" means the group of bindings dropped at the top of the fork

          (used_here : used_in_flags) = [ fvs `intersectsDVarSet` bndrs
                                        | (fvs, _) <- drop_boxes]

          drop_here = used_here || cant_push

          n_used_alts = count id used_in_flags -- returns number of Trues in list.

          cant_push
            | is_case   = n_used_alts == n_alts   -- Used in all, don't push
                                                  -- Remember n_alts > 1
                          || (n_used_alts > 1 && not (floatIsDupable platform bind))
                             -- floatIsDupable: see Note [Duplicating floats]

            | otherwise = floatIsCase bind || n_used_alts > 1
                             -- floatIsCase: see Note [Floating primops]

          new_boxes | drop_here = (insert here_box : fork_boxes)
                    | otherwise = (here_box : new_fork_boxes)

          new_fork_boxes = zipWithEqual "FloatIn.sepBinds" insert_maybe
                                        fork_boxes used_in_flags

          insert :: DropBox -> DropBox
          insert (fvs,drops) = (fvs `unionDVarSet` bind_fvs, bind_w_fvs:drops)

          insert_maybe box True  = insert box
          insert_maybe box False = box

    go _ _ = panic "sepBindsByDropPoint/go"

{- Note [Duplicating floats]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

For case expressions we duplicate the binding if it is reasonably
small, and if it is not used in all the RHSs This is good for
situations like
     let x = I# y in
     case e of
       C -> error x
       D -> error x
       E -> ...not mentioning x...

If the thing is used in all RHSs there is nothing gained,
so we don't duplicate then.
-}

floatedBindsFVs :: FloatInBinds -> FreeVarSet
floatedBindsFVs binds = mapUnionDVarSet fbFVs binds

fbFVs :: FloatInBind -> DVarSet
fbFVs (FB _ fvs _) = fvs

wrapFloats :: FloatInBinds -> CoreExpr -> CoreExpr
-- Remember FloatInBinds is in *reverse* dependency order
wrapFloats []               e = e
wrapFloats (FB _ _ fl : bs) e = wrapFloats bs (wrapFloat fl e)

floatIsDupable :: Platform -> FloatBind -> Bool
floatIsDupable platform (FloatCase scrut _ _ _) = exprIsDupable platform scrut
floatIsDupable platform (FloatLet (Rec prs))    = all (exprIsDupable platform . snd) prs
floatIsDupable platform (FloatLet (NonRec _ r)) = exprIsDupable platform r

floatIsCase :: FloatBind -> Bool
floatIsCase (FloatCase {}) = True
floatIsCase (FloatLet {})  = False


/**
 * @license Copyright (c) 2003-2018, CKSource - Frederico Knabben. All rights reserved.
 * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
 */

CKEDITOR.plugins.setLang( 'codesnippet', 'id', {
	button: 'Masukkan potongan kode',
	codeContents: 'Konten kode',
	emptySnippetError: 'Potongan kode tidak boleh kosong',
	language: 'Bahasa',
	title: 'Potongan kode',
	pathName: 'potongan kode'
} );


@import '../shared/scss/_selected_theme_variables.scss';
.shippingbtn {
  font-size: 1em !important;
  width: 100%;
  border-radius: 0;
  i {
    font-size: 20px;
    color: $white;
    -moz-transform: scaleX(-1);
    -o-transform: scaleX(-1);
    -webkit-transform: scaleX(-1);
    transform: scaleX(-1);
    filter: FlipH;
    -ms-filter: 'FlipH';
  }
  &:hover {
    background-color:darken($theme-main-color, 25) !important;
  }
}

.landing {
  margin-top: 2rem;
  @media screen and (min-width: 320px) and (max-width: 768px) {
    margin-top: 1rem;
  }
}

:host {
  ::ng-deep .section-title {
    color: $black;
    text-transform: capitalize;
    font-weight: 600;
    position: absolute;
  }
  ::ng-deep .scrollbar-hidden {
    overflow: hidden !important;
  }
  ::ng-deep .product-tile {
    text-align: center;
    a {
      color: $gray-900;
      img {
        object-fit: scale-down;
        height: 200px;
        width: 100%;
      }
      &:hover {
        text-decoration: none;
      }
    }
  }
  ::ng-deep .product-box {
    border-radius: 5px;
    margin-top: 1rem;
    border: 1px solid transparent;
    @media screen and (min-width: 320px) and (max-width: 768px) {
      margin-right: 1rem;
      border: 1px solid $gray-10;
    }
    &:hover {
      -webkit-box-shadow: 0 1px 0 $gray-10;
      box-shadow: 0 1px 0 $gray-10;
      border-color: $gray-10;
    }
  }
  ::ng-deep.product-tile p {
    margin-bottom: 0px;
    white-space: normal;
    margin-top: 10px;
  }
  ::ng-deep.dropdown-toggle::after {
    vertical-align: 0.055em !important;
  }
  $break-small: 320px;
  @media screen and (min-width: $break-small) and (max-width: 767px) {
    ::ng-deep .section-title {
      font-size: 1.4em;
    }
  }
}


# Maintainer: J. Peter Mugaas <jpmugaas@suddenlink.net>

_realname=iocapture
pkgbase=mingw-w64-python-${_realname}
pkgname=("${MINGW_PACKAGE_PREFIX}-python-${_realname}")
provides=("${MINGW_PACKAGE_PREFIX}-python3-${_realname}")
conflicts=("${MINGW_PACKAGE_PREFIX}-python3-${_realname}")
replaces=("${MINGW_PACKAGE_PREFIX}-python3-${_realname}")
pkgver=0.1.2
pkgrel=1
pkgdesc="Capture stdout, stderr easily (mingw-w64)"
arch=('any')
url='https://github.com/oinume/iocapture'
license=('MIT')
depends=("${MINGW_PACKAGE_PREFIX}-python")
makedepends=("${MINGW_PACKAGE_PREFIX}-python-setuptools")
checkdepends=("${MINGW_PACKAGE_PREFIX}-python-pytest-runner"
              "${MINGW_PACKAGE_PREFIX}-python-flexmock"
              "${MINGW_PACKAGE_PREFIX}-python-pytest-cov"
              "${MINGW_PACKAGE_PREFIX}-python-six")
options=('staticlibs' 'strip' '!debug')
source=("${_realname}-$pkgver.tar.gz"::"https://github.com/oinume/iocapture/archive/$pkgver.tar.gz")
sha256sums=('57056d1a99a9c584ae2bb23a1aa855292fd2bcc01a8a6ad5467d7ca2e739d31b')

prepare() {
  cd "${srcdir}"
  rm -rf "python-build-${CARCH}" | true
  cp -r "${_realname}-${pkgver}" "python-build-${CARCH}"

  # Set version for setuptools_scm
  export SETUPTOOLS_SCM_PRETEND_VERSION=${pkgver}
}

build() {
  cd "${srcdir}/python-build-${CARCH}"
  ${MINGW_PREFIX}/bin/python setup.py build
}

check() {
  cd "${srcdir}/python-build-${CARCH}"
  ${MINGW_PREFIX}/bin/python setup.py pytest
}

package() {
  cd "${srcdir}/python-build-${CARCH}"

  MSYS2_ARG_CONV_EXCL="--prefix=;--install-scripts=;--install-platlib=" \
  ${MINGW_PREFIX}/bin/python setup.py install --prefix=${MINGW_PREFIX} \
    --root="${pkgdir}" --optimize=1 --skip-build

  install -Dm644 LICENSE "${pkgdir}${MINGW_PREFIX}/share/licenses/python-${_realname}/LICENSE"
}


set -ex
conda install numpy pyyaml mkl mkl-include setuptools cmake cffi typing
conda install pytorch torchvision -c pytorch # add cuda90 if CUDA 9
conda install visdom dominate -c conda-forge # install visdom and dominate


---
features:
  - New squashfs image output format.


<refentry xmlns="http://docbook.org/ns/docbook"
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xmlns:xi="http://www.w3.org/2001/XInclude"
          xmlns:src="http://nwalsh.com/xmlns/litprog/fragment"
          xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
          version="5.0" xml:id="refentry.version.suppress">
<refmeta>
<refentrytitle>refentry.version.suppress</refentrytitle>
<refmiscinfo class="other" otherclass="datatype">boolean</refmiscinfo>
</refmeta>
<refnamediv>
<refname>refentry.version.suppress</refname>
<refpurpose>Suppress "version" part of refentry "source" contents?</refpurpose>
</refnamediv>

<refsynopsisdiv>
<src:fragment xml:id="refentry.version.suppress.frag">
<xsl:param name="refentry.version.suppress">0</xsl:param></src:fragment>
</refsynopsisdiv>

<refsection><info><title>Description</title></info>

<para>If the value of <parameter>refentry.version.suppress</parameter>
is non-zero, then during <tag>refentry</tag> metadata gathering, no
"version" data is added to the <tag>refentry</tag> "source"
contents. Instead (unless
<parameter>refentry.source.name.suppress</parameter> is also
non-zero), only "source name" data is added to the "source"
contents.</para>

<para>If you find that the <tag>refentry</tag> metadata gathering
mechanism is causing unwanted "version" data to show up in your output
-- for example, in the footer (or possibly header) of a man page --
then you might consider setting a non-zero value for
<parameter>refentry.version.suppress</parameter>.</para>

<para>Note that the terms "source", "source name", and "version" have
special meanings in this context. For details, see the documentation
for the <parameter>refentry.source.name.profile</parameter>
parameter.</para>

</refsection>
</refentry>


// Copyright (c) 2018 Cisco and/or its affiliates.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at:
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package idxvpp

import (
	"strconv"
	"testing"

	"github.com/onsi/gomega"
	"go.ligato.io/cn-infra/v2/logging/logrus"
)

const (
	idx1 = 1
	idx2 = 2
	idx3 = 3
)

var (
	eth0 = "eth0"
	eth1 = "eth1"
	eth2 = "eth2"
)

func IndexFactory() (NameToIndexRW, error) {
	return NewNameToIndex(logrus.DefaultLogger(), "test", nil), nil
}

func Test01UnregisteredMapsToNothing(t *testing.T) {
	Given(t).NameToIdx(IndexFactory, nil).
		When().Name(eth1).IsDeleted().
		Then().Name(eth1).MapsToNothing().
		And().Notification(eth1, Write).IsNotExpected()
}

func Test02RegisteredReturnsIdx(t *testing.T) {
	Given(t).NameToIdx(IndexFactory, nil).
		When().Name(eth1).IsAdded(idx1).
		Then().Name(eth1).MapsTo(idx1).
		And().Notification(eth1, Write).IsExpectedFor(idx1)
}

func Test03RegFirstThenUnreg(t *testing.T) {
	Given(t).NameToIdx(IndexFactory, map[string]uint32{eth1: idx1}).
		When().Name(eth1).IsDeleted().
		Then().Name(eth1).MapsToNothing().
		And().Notification(eth1, Del).IsExpectedFor(idx1)
}

func Test03Eth0RegPlusEth1Unreg(t *testing.T) {
	Given(t).NameToIdx(IndexFactory, map[string]uint32{eth0: idx1, eth1: idx2}).
		When().Name(eth1).IsDeleted().
		Then().Name(eth1).MapsToNothing().
		And().Notification(eth1, Del).IsExpectedFor(idx2).
		And().Name(eth0).MapsTo(idx1).
		And().Notification(eth0, Write).IsNotExpected() //because watch is registered after given keyword
}

func Test04RegTwiceSameNameWithDifferentIdx(t *testing.T) {
	Given(t).NameToIdx(IndexFactory, nil).
		When().Name(eth1).IsAdded(idx1).
		Then().Name(eth1).MapsTo(idx1). //Notif eth1, idx1
		And().Notification(eth1, Write).IsExpectedFor(idx1).
		When().Name(eth1).IsAdded(idx2).
		Then().Name(eth1).MapsTo(idx2). //Notif eth1, idx1
		And().Notification(eth1, Write).IsExpectedFor(idx2)
}

const (
	flagKey = "flag"
	valsKey = "vals"
)

type Item struct {
	index uint32
	flag  bool
	vals  []string
}

func (item *Item) GetIndex() uint32 {
	return item.index
}

func createIdx(item interface{}) map[string][]string {
	typed, ok := item.(*Item)
	if !ok {
		return nil
	}

	return map[string][]string{
		flagKey: {strconv.FormatBool(typed.flag)},
		valsKey: typed.vals,
	}
}

func TestIndexedMetadata(t *testing.T) {
	gomega.RegisterTestingT(t)
	idxm := NewNameToIndex(logrus.DefaultLogger(), "title", createIdx)

	res := idxm.ListNames(flagKey, "true")
	gomega.Expect(res).To(gomega.BeNil())

	item1 := &Item{
		index: idx1,
		flag:  true,
		vals:  []string{"abc", "def", "xyz"},
	}
	item2 := &Item{
		index: idx2,
		flag:  false,
		vals:  []string{"abc", "klm", "opq"},
	}
	item3 := &Item{
		index: idx3,
		flag:  true,
		vals:  []string{"jkl"},
	}

	idxm.Put(eth0, item1)
	idxm.Put(eth1, item2)
	idxm.Put(eth2, item3)

	res = idxm.ListNames(flagKey, "false")
	gomega.Expect(res).NotTo(gomega.BeNil())
	gomega.Expect(res[0]).To(gomega.BeEquivalentTo(eth1))

	res = idxm.ListNames(flagKey, "true")
	gomega.Expect(len(res)).To(gomega.BeEquivalentTo(2))
	gomega.Expect(res).To(gomega.ContainElement(string(eth0)))
	gomega.Expect(res).To(gomega.ContainElement(string(eth2)))

	res = idxm.ListNames(valsKey, "abc")
	gomega.Expect(len(res)).To(gomega.BeEquivalentTo(2))
	gomega.Expect(res).To(gomega.ContainElement(string(eth0)))
	gomega.Expect(res).To(gomega.ContainElement(string(eth1)))

	res = idxm.ListNames(valsKey, "jkl")
	gomega.Expect(len(res)).To(gomega.BeEquivalentTo(1))
	gomega.Expect(res[0]).To(gomega.BeEquivalentTo(eth2))

	idxm.Delete(eth0)
	res = idxm.ListNames(flagKey, "true")
	gomega.Expect(len(res)).To(gomega.BeEquivalentTo(1))
	gomega.Expect(res[0]).To(gomega.BeEquivalentTo(eth2))

}

func TestOldIndexRemove(t *testing.T) {
	gomega.RegisterTestingT(t)
	idxm := NewNameToIndex(logrus.DefaultLogger(), "title", nil)

	idxm.Put(eth0, &OnlyIndex{idx1})

	item, found := idxm.LookupByName(eth0)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(item.GetIndex()).To(gomega.BeEquivalentTo(idx1))

	name, _, found := idxm.LookupByIndex(idx1)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(name).To(gomega.BeEquivalentTo(eth0))

	idxm.Put(eth0, &OnlyIndex{idx2})

	item, found = idxm.LookupByName(eth0)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(item.GetIndex()).To(gomega.BeEquivalentTo(idx2))

	name, item, found = idxm.LookupByIndex(idx2)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(name).To(gomega.BeEquivalentTo(string(eth0)))
	gomega.Expect(item).ToNot(gomega.BeNil())

	name, item, found = idxm.LookupByIndex(idx1)
	gomega.Expect(found).To(gomega.BeFalse())
	gomega.Expect(name).To(gomega.BeEquivalentTo(""))
	gomega.Expect(item).To(gomega.BeNil())
}

func TestUpdateIndex(t *testing.T) {
	gomega.RegisterTestingT(t)
	idxm := NewNameToIndex(logrus.DefaultLogger(), "title", nil)

	idxm.Put(eth0, &OnlyIndex{idx1})

	item, found := idxm.LookupByName(eth0)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(item.GetIndex()).To(gomega.BeEquivalentTo(idx1))

	success := idxm.Update(eth0, &OnlyIndex{idx2})
	gomega.Expect(success).To(gomega.BeTrue())

	item, found = idxm.LookupByName(eth0)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(item.GetIndex()).To(gomega.BeEquivalentTo(idx2))
}

func TestClearMapping(t *testing.T) {
	gomega.RegisterTestingT(t)
	idxm := NewNameToIndex(logrus.DefaultLogger(), "title", nil)

	idxm.Put(eth0, &OnlyIndex{idx1})
	idxm.Put(eth1, &OnlyIndex{idx2})
	idxm.Put(eth2, &OnlyIndex{idx3})

	item, found := idxm.LookupByName(eth0)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(item.GetIndex()).To(gomega.BeEquivalentTo(idx1))

	item, found = idxm.LookupByName(eth1)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(item.GetIndex()).To(gomega.BeEquivalentTo(idx2))

	item, found = idxm.LookupByName(eth2)
	gomega.Expect(found).To(gomega.BeTrue())
	gomega.Expect(item.GetIndex()).To(gomega.BeEquivalentTo(idx3))

	idxm.Clear()

	_, found = idxm.LookupByName(eth0)
	gomega.Expect(found).To(gomega.BeFalse())

	_, found = idxm.LookupByName(eth1)
	gomega.Expect(found).To(gomega.BeFalse())

	_, found = idxm.LookupByName(eth2)
	gomega.Expect(found).To(gomega.BeFalse())
}


/*

School Book style from goldblog.com.ua (c) Zaripov Yura <yur4ik7@ukr.net>

*/

.hljs {
	display: block;
	overflow-x: auto;
	padding: 15px 0.5em 0.5em 30px;
	font-size: 11px;
	line-height: 16px;
}

pre {
	background: #f6f6ae url(./school-book.png);
	border-top: solid 2px #d2e8b9;
	border-bottom: solid 1px #d2e8b9;
}

.hljs-keyword,
.hljs-selector-tag,
.hljs-literal {
	color: #005599;
	font-weight: bold;
}

.hljs,
.hljs-subst {
	color: #3e5915;
}

.hljs-string,
.hljs-title,
.hljs-section,
.hljs-type,
.hljs-symbol,
.hljs-bullet,
.hljs-attribute,
.hljs-built_in,
.hljs-builtin-name,
.hljs-addition,
.hljs-variable,
.hljs-template-tag,
.hljs-template-variable,
.hljs-link {
	color: #2c009f;
}

.hljs-comment,
.hljs-quote,
.hljs-deletion,
.hljs-meta {
	color: #e60415;
}

.hljs-keyword,
.hljs-selector-tag,
.hljs-literal,
.hljs-doctag,
.hljs-title,
.hljs-section,
.hljs-type,
.hljs-name,
.hljs-selector-id,
.hljs-strong {
	font-weight: bold;
}

.hljs-emphasis {
	font-style: italic;
}


alpha=50
beta=0.1
num-topics=1000
num-docs=298252
num-words=101257
num-iters=1000
num-sampling-threads=60
num-table-threads=4


# Basque translation of drawing.
# Copyright (C) 2018-2020 Romain F. T.
# This file is distributed under the same license as the drawing package.
# Alexander Gabilondo <alexgabi@disroot.org>, 2020
#
msgid ""
msgstr ""
"Project-Id-Version: drawing\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-09-22 00:36+0200\n"
"PO-Revision-Date: 2020-08-29 16:24+0200\n"
"Last-Translator: Alexander Gabilondo <alexgabi@disroot.org>\n"
"Language-Team: \n"
"Language: eu\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.3\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: data/com.github.maoschanz.drawing.desktop.in
#: data/com.github.maoschanz.drawing.appdata.xml.in src/deco_manager.py
#: src/main.py
msgid "Drawing"
msgstr "Drawing"

#: data/com.github.maoschanz.drawing.desktop.in
msgid "Simple drawing utility"
msgstr "Marrazteko utilitate sinplea"

#. Icon name, do not translate
#: data/com.github.maoschanz.drawing.desktop.in
msgid "com.github.maoschanz.drawing"
msgstr "com.github.maoschanz.drawing"

#. This is a list of keywords. "Paint" should not be translated, the others should. Don't forget the semicolons.
#: data/com.github.maoschanz.drawing.desktop.in
msgid "Paint;Sketch;Pencil;"
msgstr "Paint;Zirriborroa;Arkatza;"

#. Context: answer to "where do you want to open the image?"
#: data/com.github.maoschanz.drawing.desktop.in src/ui/app-menus.ui
#: src/ui/shortcuts.ui src/ui/win-menus.ui src/window.py
msgid "New Window"
msgstr "Leiho berria"

#: data/com.github.maoschanz.drawing.desktop.in src/ui/app-menus.ui
#: src/ui/headerbar.ui src/ui/headerbar-eos.ui src/ui/toolbar.ui
#: src/ui/toolbar-symbolic.ui src/ui/win-menus.ui src/ui/window.ui
msgid "New Image"
msgstr "Irudi berria"

#: data/com.github.maoschanz.drawing.desktop.in
msgid "Edit Image in Clipboard"
msgstr "Arbeleko irudia editatu"

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid "A drawing application for the GNOME desktop"
msgstr "Marrazteko aplikazioa GNOME mahaigainerako"

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"\"Drawing\" is a basic image editor, supporting PNG, JPEG and BMP file types."
msgstr ""
"«Drawing» irudien oinarrizko editorea  da, PNG, JPEG eta BMP formaturekin "
"bateragarria."

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"It allows you to draw or edit pictures with tools such as pencil, line or "
"arc (with various options), selection (cut/copy/paste/drag/…), shapes "
"(rectangle, circle, polygon, …), text insertion, resizing, cropping, "
"rotating, …"
msgstr ""
"Haren bidez irudiak marraztu edo editatu daitezke hainbat tresnen bidez, "
"hala nola arkatza, marra edo arkua, hautatu (ebaki/kopiatu/itsatsi/"
"arrastatu/...), formak (laukizuzena, zirkulua, poligonoa,...), testuaren "
"txertaketa, tamaina aldaketa, , mozketa, biraketa, …"

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"It's now possible to remove transparency when saving PNG files too. And "
"there are more color options to replace the transparent pixels."
msgstr ""

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"A new optional tool named \"Points\" has been added, it may help captioning "
"pictures."
msgstr ""

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid "Minors bugs to the 'rotate' tool have been fixed."
msgstr ""

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"Version 0.6 is a major update, with various important changes. The app is "
"more robust and has more tools:"
msgstr ""
"0.6 bertsioa pisuzko eguneraketa da, aldaketa esanguratsuak dakartzana. "
"Aplikazioa egonkorragoa da eta tresna gehiago ditu:"

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"Rectangle selection and freehand selection are now distinct tools, and the "
"'rotate' tool now supports any angle and handles horizontal or vertical "
"flipping."
msgstr ""
"Laukizuzena hautatzea eta eskuzko hautaketa tresnak desberdinak dira orain,  "
"'biratu' tresnak edozein angelu onartzen du eta  horizontalki edo bertikalki "
"iraultzeko aukera ematen du."

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"The numerous tools producing shapes (circle, rectangle, polygon, …), have "
"been merged into a single, more consistent 'shape' tool, along with 'rounded "
"rectangle' and 'ellipse'. Their filling options now include various types of "
"gradients."
msgstr ""
"Formak sortzen dituzten tresna ugariak (zirkulua, laukizuzena, "
"poligonoa ...), \"forma\" tresna koherente bakar batera batu dira,  gainera "
"\"laukizuzen biribila\" eta \"elipsea\" gehitu dira. Orain betetzeko aukerek "
"gradiente mota desberdinak ditu."

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"The text tool can now write using most system fonts, thus allowing more "
"complex characters to be used (e.g. Asian characters)."
msgstr ""
"Testu tresnak sistemako letra gehienak erabiliz idatzi dezake, eta horrela, "
"karaktere konplexuagoak erabil daitezke (adibidez, Asiako karaktereak)."

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"The 'saturate' tool has been replaced by 'filters', a more powerful tool "
"with several types of blur, color inversion, pixelisation, saturation and "
"transparency."
msgstr ""
"'Saturatu' tresnaren ordez 'iragazkiak' tresna jarri da, lausoak, kolorearen "
"alderantziketa, pixelizazioa, saturazioa eta gardentasuna tresna "
"indartsuagoa."

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid "A fullscreen mode is now available."
msgstr "Orain pantaila osoko modua erabili daiteke."

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"The most prominent new feature is the ability to zoom in (or out) on the "
"image, using the minimap, the touchpad or the mouse wheel."
msgstr ""
"Ezaugarri berririk nabarmenena irudia handitzeko (edo txikitzeko) gaitasuna "
"da, mapa txikia, ukipen-area edo saguaren gurpila erabiliz."

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid ""
"Version 0.4.14 features several minor bug fixes, and various new "
"translations."
msgstr ""
"0.4.14 bertsioak errore txiki batzuen zuzenketa eta itzulpen berriak biltzen "
"ditu."

#. This is just my name, do not translate it.
#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid "Romain F. T."
msgstr "Romain F. T."

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid "The window and its primary menu"
msgstr ""

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid "The selection and the actions associated with it"
msgstr ""

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid "Zooming in various shapes"
msgstr ""

#: data/com.github.maoschanz.drawing.appdata.xml.in
msgid "The \"new image\" menu opened"
msgstr ""

#: src/ui/app-menus.ui src/ui/preferences.ui src/ui/win-menus.ui
#: src/preferences.py
msgid "Preferences"
msgstr "Hobespenak"

#: src/ui/app-menus.ui src/ui/win-menus.ui
msgid "Report a bug"
msgstr "Errore baten berri eman"

#: src/ui/app-menus.ui src/ui/shortcuts.ui src/ui/win-menus.ui
msgid "Shortcuts"
msgstr "Laster-teklak"

#: src/ui/app-menus.ui src/ui/shortcuts.ui src/ui/win-menus.ui
msgid "Help"
msgstr "Laguntza"

#: src/ui/app-menus.ui
msgid "About"
msgstr "Honi buruz"

#: src/ui/app-menus.ui
msgid "Quit"
msgstr "Irten"

#: src/ui/app-menus.ui
msgid "_File"
msgstr "_Fitxategia"

#: src/ui/app-menus.ui src/ui/toolbar.ui src/ui/toolbar-symbolic.ui
#: src/ui/win-menus.ui
msgid "Open an image"
msgstr "Ireki irudi bat"

#: src/ui/app-menus.ui src/ui/shortcuts.ui src/ui/win-menus.ui
msgid "New Blank Image"
msgstr "Irudi zuri berria"

#: src/ui/app-menus.ui src/ui/win-menus.ui src/new_image_dialog.py
msgid "New Image With Custom Size"
msgstr "Tamaina pertsonalizatua duen irudi berria"

#: src/ui/app-menus.ui src/ui/shortcuts.ui src/ui/win-menus.ui
msgid "New Image From Selection"
msgstr "Irudi berria hautapenetik"

#: src/ui/app-menus.ui src/ui/shortcuts.ui src/ui/win-menus.ui
msgid "New Image From Clipboard"
msgstr "Irudi berri arbelatik"

#: src/ui/app-menus.ui src/ui/win-menus.ui
msgid "Reload file"
msgstr "Birkargatu fitxategia"

#: src/ui/app-menus.ui src/ui/headerbar-eos.ui src/ui/toolbar.ui
#: src/ui/toolbar-symbolic.ui src/ui/win-menus.ui src/properties.py
msgid "Image properties"
msgstr "Irudiaren propietateak"

#: src/ui/app-menus.ui src/ui/headerbar.ui src/ui/headerbar-eos.ui
#: src/ui/shortcuts.ui src/ui/toolbar.ui src/ui/toolbar-symbolic.ui
#: src/ui/win-menus.ui src/saving_manager.py
msgid "Save"
msgstr "Gorde"

#: src/ui/app-menus.ui src/ui/win-menus.ui
#, fuzzy
msgid "Save without transparency"
msgstr "Gehitu gardentasuna"

#: src/ui/app-menus.ui src/ui/headerbar-eos.ui src/ui/win-menus.ui
#: src/saving_manager.py
msgid "Save as…"
msgstr "Gorde honela…"

#: src/ui/app-menus.ui src/ui/selection-manager.ui src/ui/win-menus.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/selection.ui
msgid "Export as…"
msgstr "Esportatu honela…"

#: src/ui/app-menus.ui src/ui/win-menus.ui
msgid "Copy to clipboard"
msgstr ""

#: src/ui/app-menus.ui src/ui/win-menus.ui
msgid "Print"
msgstr "Inprimatu"

#: src/ui/app-menus.ui
msgid "Close Image"
msgstr "Itxi irudia"

#: src/ui/app-menus.ui
msgid "Close Window"
msgstr "Itxi leihoa"

#: src/ui/app-menus.ui src/ui/shortcuts.ui
msgid "Quit all windows"
msgstr "Itxi leiho guztiak"

#: src/ui/app-menus.ui
msgid "_Edit"
msgstr "_Editatu"

#: src/ui/app-menus.ui src/ui/headerbar.ui src/ui/headerbar-eos.ui
#: src/ui/shortcuts.ui src/ui/toolbar.ui src/ui/toolbar-symbolic.ui
#: src/ui/win-menus.ui src/deco_manager.py
msgid "Undo"
msgstr "Desegin"

#: src/ui/app-menus.ui src/ui/headerbar.ui src/ui/headerbar-eos.ui
#: src/ui/shortcuts.ui src/ui/toolbar.ui src/ui/toolbar-symbolic.ui
#: src/ui/win-menus.ui src/deco_manager.py
msgid "Redo"
msgstr "Berregin"

#: src/ui/app-menus.ui src/ui/win-menus.ui
msgid "Rebuild from history"
msgstr "Leheneratu historialetik"

#: src/ui/app-menus.ui src/ui/selection-manager.ui src/ui/shortcuts.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/selection.ui
msgid "Select all"
msgstr "Hautatu guztia"

#: src/ui/app-menus.ui src/ui/selection-manager.ui src/ui/shortcuts.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/selection.ui
msgid "Cut"
msgstr "Ebaki"

#: src/ui/app-menus.ui src/ui/selection-manager.ui src/ui/shortcuts.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/selection.ui
msgid "Copy"
msgstr "Kopiatu"

#: src/ui/app-menus.ui src/ui/selection-manager.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/selection.ui
msgid "Delete"
msgstr "Ezabatu"

#: src/ui/app-menus.ui src/ui/selection-manager.ui src/ui/shortcuts.ui
#: src/ui/toolbar.ui src/ui/toolbar-symbolic.ui
#: src/optionsbars/selection/optionsbar-selection.ui
msgid "Paste"
msgstr "Itsatsi"

#: src/ui/app-menus.ui src/ui/selection-manager.ui src/ui/toolbar.ui
#: src/ui/toolbar-symbolic.ui src/window.py
#: src/optionsbars/selection/optionsbar-selection.ui
msgid "Import"
msgstr "Inportatu"

#: src/ui/app-menus.ui
msgid "_View"
msgstr "_Ikusi"

#: src/ui/app-menus.ui
msgid "Show the preview"
msgstr "Erakutsi aurrebista"

#: src/ui/app-menus.ui src/ui/shortcuts.ui src/preferences.py
msgid "Zoom"
msgstr "Zoom"

#: src/ui/app-menus.ui src/ui/minimap.ui src/ui/shortcuts.ui
msgid "Optimal Zoom"
msgstr "Zoomik egokiena"

#: src/ui/app-menus.ui src/ui/minimap.ui src/ui/shortcuts.ui src/ui/toolbar.ui
#: src/ui/toolbar-symbolic.ui src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-scale.ui
msgid "Zoom Out"
msgstr "Txikiagotu"

#: src/ui/app-menus.ui src/ui/shortcuts.ui src/ui/toolbar.ui
#: src/ui/toolbar-symbolic.ui src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-scale.ui
msgid "Original Zoom"
msgstr "Jatorrizko tamaina"

#: src/ui/app-menus.ui src/ui/minimap.ui src/ui/shortcuts.ui src/ui/toolbar.ui
#: src/ui/toolbar-symbolic.ui src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-scale.ui
msgid "Zoom In"
msgstr "Handiagotu"

#. Context: this submenu is about moving the view to the
#. left/right/top/bottom
#: src/ui/app-menus.ui
msgid "Position"
msgstr "Kokapena"

#: src/ui/app-menus.ui src/ui/shortcuts.ui
msgid "Go Left"
msgstr "Ezkerretara"

#: src/ui/app-menus.ui src/ui/shortcuts.ui
msgid "Go Up"
msgstr "Gora"

#: src/ui/app-menus.ui src/ui/shortcuts.ui
msgid "Go Down"
msgstr "Behera"

#: src/ui/app-menus.ui src/ui/shortcuts.ui
msgid "Go Right"
msgstr "Eskuinera"

#: src/ui/app-menus.ui src/ui/shortcuts.ui
msgid "Tab at the left"
msgstr "Ezkerreko fitxa"

#: src/ui/app-menus.ui src/ui/shortcuts.ui
msgid "Tab at the right"
msgstr "Eskuineko fitxa"

#: src/ui/app-menus.ui src/ui/win-menus.ui
msgid "Refresh"
msgstr "Freskatu"

#: src/ui/app-menus.ui src/ui/shortcuts.ui src/ui/win-menus.ui
#: src/preferences.py
msgid "Show tools names"
msgstr "Erakutsi tresnen izenak"

#: src/ui/app-menus.ui src/ui/headerbar-eos.ui src/ui/shortcuts.ui
#: src/ui/toolbar.ui src/ui/toolbar-symbolic.ui src/ui/win-menus.ui
msgid "Fullscreen"
msgstr "Pantaila osoa"

#: src/ui/app-menus.ui src/ui/win-menus.ui
msgid "Exit fullscreen"
msgstr "Irten pantaila osotik"

#: src/ui/app-menus.ui
msgid "_Colors"
msgstr "_Koloreak"

#: src/ui/app-menus.ui
msgid "Edit Main Color…"
msgstr "Editatu kolore nagusia…"

#: src/ui/app-menus.ui
msgid "Edit Secondary Color…"
msgstr "Editatu bigarren kolorea…"

#: src/ui/app-menus.ui
msgid "Use color editor by default"
msgstr "Erabili kolore editorea lehenespenez"

#: src/ui/app-menus.ui src/ui/shortcuts.ui
#: src/optionsbars/classic/optionsbar-classic.ui
msgid "Exchange colors"
msgstr "Trukatu koloreak"

#: src/ui/app-menus.ui
msgid "Color application mode"
msgstr "Koloreen aplikazio modua"

#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Normal"
msgstr "Normala"

#. Context: possible ways to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Other modes"
msgstr "Bestelako moduak"

#. Context: a possible way to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Raw source color"
msgstr "Jatorrizko kolorea"

#. Context: a possible way to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Highlight"
msgstr "Nabarmendu"

#. Context: a possible way to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Difference"
msgstr "Batuketa"

#. Context: possible ways to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Photo-oriented modes"
msgstr "Argazkira bideratutako moduak"

#. Context: a possible way to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Hue only"
msgstr "Ñabardura bakarrik"

#. Context: a possible way to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Saturation only"
msgstr "Saturazioa bakarrik"

#. Context: a possible way to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Hue and saturation"
msgstr "Ñabardura eta saturazioa"

#. Context: a possible way to apply the color to the canvas
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Luminosity only"
msgstr "Argitasuna bakarrik"

#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Don't use the colors but…"
msgstr "Ez erabili koloreak baina…"

#. To translators: this is a verb
#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Blur"
msgstr "Lausotu"

#: src/ui/app-menus.ui src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Erase"
msgstr "Ezabatu"

#: src/ui/app-menus.ui
msgid "_Tools"
msgstr "_Tresnak"

#: src/ui/app-menus.ui
msgid "Previous tool"
msgstr "Aurreko tresna"

#: src/ui/app-menus.ui src/window.py
msgid "_Options"
msgstr "_Aukerak"

#: src/ui/app-menus.ui
msgid "_Help"
msgstr "_Laguntza"

#. Context: open the index of all help pages
#: src/ui/app-menus.ui
msgid "Index"
msgstr "Aurkibidea"

#. Context: open the help page about general use of the app
#: src/ui/app-menus.ui
msgid "Basic help"
msgstr "Oinarrizko laguntza"

#. Context: open the help page about classic tools
#: src/ui/app-menus.ui
msgid "Help about tools"
msgstr "Tresnen gaineko laguntza"

#. Context: open the help page about transformation tools (crop,
#. scale, rotate, filters, ...
#: src/ui/app-menus.ui
msgid "Canvas and selection"
msgstr "Oihala eta aukeraketa"

#. Context: open the help page about the selection
#: src/ui/app-menus.ui
msgid "Help about selection"
msgstr "Hautaketaren gaineko laguntza"

#: src/ui/app-menus.ui src/ui/win-menus.ui
msgid "About Drawing"
msgstr "Drawing-i buruz"

#: src/ui/headerbar.ui src/ui/headerbar-eos.ui src/ui/toolbar.ui
#: src/ui/toolbar-symbolic.ui src/window.py
msgid "Open"
msgstr "Ireki"

#: src/ui/new-image-dialog.ui src/ui/properties.ui
#: src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-scale.ui
msgid "Width"
msgstr "Zabalera"

#: src/ui/new-image-dialog.ui src/ui/properties.ui
#: src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-scale.ui
msgid "Height"
msgstr "Altuera"

#: src/ui/new-image-dialog.ui
msgid "Color"
msgstr "Kolorea"

#: src/ui/new-image-dialog.ui
msgid "Use these settings by default"
msgstr "Erabili ezarpen hauek lehenespenez"

#: src/ui/minimap.ui
msgid "100%"
msgstr "% 100"

#. To translators: it's a measure unit, it appears in tooltips over
#. numerical inputs
#: src/ui/properties.ui src/utilities.py
msgid "pixels"
msgstr "píxel"

#: src/ui/properties.ui
msgid "centimeters"
msgstr "zentimetro"

#: src/ui/properties.ui
msgid "inches"
msgstr "hazbete"

#: src/ui/preferences.ui
msgid "Images"
msgstr "Irudiak"

#: src/ui/preferences.ui src/ui/shortcuts.ui src/ui/win-menus.ui
msgid "Tools"
msgstr "Tresnak"

#: src/ui/preferences.ui
msgid "Window"
msgstr "Leihoa"

#: src/ui/selection-manager.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/selection.ui
msgid "Close selection"
msgstr "Itxi hautapena"

#: src/ui/selection-manager.ui src/ui/shortcuts.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/selection.ui
msgid "Unselect"
msgstr "Desautatu"

#: src/ui/selection-manager.ui src/tools/ui/selection.ui
#: src/tools/transform_tools/tool_crop.py
msgid "Crop"
msgstr "Moztu"

#: src/ui/selection-manager.ui src/tools/ui/selection.ui
#: src/tools/transform_tools/tool_scale.py
msgid "Scale"
msgstr "Eskalatu"

#: src/ui/selection-manager.ui src/tools/ui/selection.ui
#: src/tools/transform_tools/tool_rotate.py
msgid "Rotate"
msgstr "Biratu"

#: src/ui/selection-manager.ui src/tools/ui/selection.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Filters"
msgstr "Iragazkiak"

#: src/ui/selection-manager.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/selection.ui
msgid "Open As New Image"
msgstr "Ireki irudi berri gisa"

#: src/ui/shortcuts.ui
msgid "Keyboard Shortcuts"
msgstr "Laster-teklak"

#: src/ui/shortcuts.ui
msgid "General"
msgstr "Orokorra"

#: src/ui/shortcuts.ui
msgid "Main menu"
msgstr "Menu nagusia"

#: src/ui/shortcuts.ui
msgid "History"
msgstr "Historiala"

#: src/ui/shortcuts.ui
msgid "Image"
msgstr "Irudia"

#: src/ui/shortcuts.ui src/window.py
msgid "Open a picture"
msgstr "Ireki irudi bat"

#: src/ui/shortcuts.ui
msgid "Reload image from disk"
msgstr "Birkargatu irudia diskotik"

#: src/ui/shortcuts.ui src/saving_manager.py
msgid "Save picture as…"
msgstr "Gorde irudia honela…"

#: src/ui/shortcuts.ui
msgid "Close the active image"
msgstr "Itxi uneko irudia"

#: src/ui/shortcuts.ui
#, fuzzy
msgid "Open the tool options menu"
msgstr "Aukeren menua"

#: src/ui/shortcuts.ui
msgid "Back to previous tool"
msgstr "Atzera aurreko tresnara"

#: src/ui/shortcuts.ui
msgid "Colors"
msgstr "Koloreak"

#. Label displayed in the keyboard shortcuts dialog
#: src/ui/shortcuts.ui
msgid "Edit the main color (left click)"
msgstr "Editatu kolore nagusia (saguaren ezker klika)"

#. Label displayed in the keyboard shortcuts dialog
#: src/ui/shortcuts.ui
msgid "Edit the secondary color (right click)"
msgstr "Editatu bigarren kolorea (saguaren eskuin klika)"

#: src/ui/shortcuts.ui
msgid "Selection"
msgstr "Hautapena"

#. Label displayed in the keyboard shortcuts dialog
#: src/ui/shortcuts.ui
msgid "Delete the selection"
msgstr "Ezabatu hautapena"

#. Label displayed in the keyboard shortcuts dialog
#: src/ui/shortcuts.ui
msgid "Import a file as the selection"
msgstr "Inportatu fitxategia hautapen gisa"

#: src/ui/shortcuts.ui
msgid "Tabs"
msgstr "Fitxak"

#: src/ui/shortcuts.ui
msgid "Enter fullscreen mode"
msgstr "Pantaila osoko modura"

#: src/ui/shortcuts.ui
msgid "Exit fullscreen mode"
msgstr "Irten pantaila osotik"

#. Context: this section of the shortcuts window is about moving
#. the view to the left/right/top/bottom
#: src/ui/shortcuts.ui
msgid "Navigation"
msgstr "Nabigazioa"

#: src/ui/shortcuts.ui
msgid "Toggle the preview"
msgstr "Trukatu aurrebista"

#: src/ui/shortcuts.ui
msgid "Touch gestures"
msgstr "Ukipen keinuak"

#: src/ui/win-menus.ui
msgid "Troubleshoot selection"
msgstr "Hautapen arazoak konpontzen"

#: src/ui/win-menus.ui
msgid "Other tools"
msgstr "Beste tresnak"

#: src/ui/window.ui
msgid "Error starting the application, please report this bug."
msgstr "Errorea aplikazioa abiaraztean, mesedez eman errorearen berri."

#: src/deco_manager.py
#, python-format
msgid "Undo %s"
msgstr "Desegin %s"

#: src/deco_manager.py
#, python-format
msgid "Redo %s"
msgstr "Berregin %s"

#. Context: an error message
#: src/image.py
#, python-format
msgid "New pixbuf empty, no change applied to %s"
msgstr ""

#: src/image.py
msgid "Can't reload a never-saved file from the disk."
msgstr "Ezin da birkargatu diskoan inoiz gorde ez den fitxategia."

#: src/image.py src/properties.py
msgid "Unsaved file"
msgstr "Gorde gabeko fitxategia"

#: src/new_image_dialog.py src/saving_manager.py src/window.py
#: src/tools/utilities_paths.py src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-filters.ui
#: src/optionsbars/transform/optionsbar-rotate.ui
#: src/optionsbars/transform/optionsbar-scale.ui
#: src/optionsbars/transform/optionsbar-skew.ui src/tools/ui/tool-text.ui
#: src/tools/ui/tool-crop.ui src/tools/ui/tool-filters.ui
#: src/tools/ui/tool-rotate.ui src/tools/ui/tool-scale.ui
#: src/tools/ui/tool-skew.ui
msgid "Cancel"
msgstr "Utzi"

#. Context: Create a new image
#: src/new_image_dialog.py
msgid "Create"
msgstr "Sortu"

#. Description of a command line option
#: src/main.py
msgid "Show the app version"
msgstr "Erakutsi aplikazioaren bertsioa"

#. Description of a command line option
#: src/main.py
msgid "Open a new window"
msgstr "Ireki leiho berria"

#. Description of a command line option
#: src/main.py
msgid "Open a new tab"
msgstr "Ireki fitxa berria"

#. Description of a command line option
#: src/main.py
msgid "Edit the clipboard content"
msgstr "Editatu arbelaren edukia"

#: src/main.py
msgid "This version isn't stable!"
msgstr "Bertsio hau ez da egonkorra!"

#: src/main.py
msgid "Report bugs or ideas"
msgstr "Errore edo ideien berri eman"

#. To tranlators: "translate" this by a list of your names (one name
#. per line), they will be displayed in the "about" dialog
#: src/main.py
msgid "translator-credits"
msgstr "AlexanderGabilondo <alexgabi@disroot.org>, 2020"

#. To translators: this is credits for the icons, consider that "Art
#. Libre" is proper name
#: src/main.py
msgid "GNOME's \"Art Libre\" icon set authors"
msgstr "GNOMEren \"Art Libre\" ikono bildumaren egileak"

#: src/main.py
msgid "A drawing application for the GNOME desktop."
msgstr "Marrazteko aplikazioa GNOME mahaigainerako."

#: src/main.py
msgid "Official webpage"
msgstr "Webgune ofiziala"

#: src/main.py
#, python-format
msgid "Error opening this file. Did you mean %s ?"
msgstr "Errorea fitxategia irekitzean. %s esan nahi zenuen?"

#. This string displays the zoom level: %s will be replaced with a
#. number, while %% will be rendered as the symbol '%'
#: src/minimap.py
#, python-format
msgid "%s%%"
msgstr "%s %%"

#. Context: title of a section of the preferences
#: src/preferences.py
msgid "New images"
msgstr "Irudi berriak"

#: src/preferences.py
msgid "Default width"
msgstr "Zabalera lehenetsia"

#: src/preferences.py
msgid "Default height"
msgstr "Altuera lehenetsia"

#: src/preferences.py src/optionsbars/transform/optionsbar-crop.ui
#: src/tools/ui/tool-crop.ui
msgid "Default color"
msgstr "Kolore lehenetsia"

#. Context: title of a section of the preferences
#: src/preferences.py
msgid "Images saving"
msgstr "Irudiak gordetzen"

#: src/preferences.py
msgid "JPEG and BMP images can't handle transparency."
msgstr "JPEG eta BMP irudiek ezin dute gardentasuna kudeatu."

#: src/preferences.py
msgid ""
"If you save your images in these formats, what do want to use to replace "
"transparent pixels?"
msgstr ""
"Irudia formatu horietako batean gordetzen baduzu, zer erabili nahi duzu "
"pixel gardenen ordez?"

#: src/preferences.py src/saving_manager.py src/utilities.py
msgid "White"
msgstr "Zuria"

#: src/preferences.py src/saving_manager.py src/utilities.py
msgid "Black"
msgstr "Beltza"

#: src/preferences.py src/saving_manager.py
msgid "Checkboard"
msgstr "Xake-taula"

#: src/preferences.py src/saving_manager.py
msgid "Nothing"
msgstr "Ezer ez"

#: src/preferences.py
msgid "Ask before saving"
msgstr "Galdetu gorde aurretik"

#: src/preferences.py
msgid "You can zoom with Ctrl+scrolling, or only scrolling."
msgstr "Handiagotzeko Ktrl + saguaren gurpila edo gurpilaren bidez bakarrik."

#: src/preferences.py
msgid "See the user help manual for explanations."
msgstr "Begiratu erabiltzailearen laguntza-eskuliburua azalpenetarako."

#: src/preferences.py
msgid "Use 'Ctrl' to zoom"
msgstr "Erabili Ktrl handiagotzeko"

#. Context: title of a section of the preferences (appearance of the
#. tools: big icons?, labels?)
#: src/preferences.py
msgid "Appearance"
msgstr "Itxura"

#: src/preferences.py
msgid "Use big icons"
msgstr "Erabili ikono handiak"

#. Context: title of a section of the preferences
#: src/preferences.py
msgid "Additional tools"
msgstr "Tresna gehigarriak"

#: src/preferences.py
msgid ""
"These tools are not as reliable and useful as they should be, so they are "
"not all enabled by default."
msgstr ""
"Tresna hauek ez dira behar beste fidagarriak eta erabilgarriak, horregatik "
"ez daude berez aktibatuta."

#. Context: this is the name of a tool, in the meaning "a rubber eraser"
#: src/preferences.py src/tools/classic_tools/tool_eraser.py
msgid "Eraser"
msgstr "Borragoma"

#. Context: this is the name of a tool, a thick pencil dedicated to
#. highlight text, for example in screenshots
#: src/preferences.py src/tools/classic_tools/tool_highlight.py
msgid "Highlighter"
msgstr "Nabarmentzailea"

#: src/preferences.py
msgid "Points"
msgstr ""

#. Context: this is a tool to select an area according to a shape that
#. can be freely defined by the user.
#: src/preferences.py src/tools/selection_tools/select_free.py
msgid "Free selection"
msgstr "Hautapen librea"

#. Context: this is a tool to "magically" select an area depending on its
#. color. For example clicking on a white pixel will select the
#. surrounding area made of white pixels.
#: src/preferences.py src/tools/selection_tools/select_color.py
msgid "Color selection"
msgstr "Kolore hautapena"

#. Context: this is a tool to pick a RGBA color in the image in order to
#. use it to draw with other tools
#: src/preferences.py src/tools/classic_tools/tool_picker.py
msgid "Color Picker"
msgstr "Kolore-hautatzailea"

#. Context: the name of a tool to fill an area of one color with an other
#: src/preferences.py src/tools/classic_tools/tool_paint.py
msgid "Paint"
msgstr "Betegarria"

#. Context: title of a section of the preferences
#: src/preferences.py
msgid "Advanced options"
msgstr "Aukera aurreratuak"

#: src/preferences.py
msgid "Preview size"
msgstr "Aurrebistaren tamaina"

#. This label will not be displayed in the UI of stable versions
#: src/preferences.py
msgid "Development features"
msgstr "Garapen eginbideak"

#: src/preferences.py
msgid "Background color"
msgstr "Atzeko planoaren kolorea"

#. Context: title of a section of the preferences. It corresponds to the
#. window layout (header-bar? tool-bar? menu-bar?)
#: src/preferences.py
msgid "Layout"
msgstr "Diseinua"

#: src/preferences.py
msgid "The recommended value is \"Automatic\"."
msgstr "Gomendatutako balioa \"Automatikoa\" da."

#. It has to match what's written in the previous string.
#: src/preferences.py
msgid "Automatic"
msgstr "Automatikoa"

#: src/preferences.py
msgid "Compact"
msgstr "Trinkoa"

#: src/preferences.py
msgid "elementary OS"
msgstr "elementary OS"

#. "Legacy" is about the window layout, it means menubar+toolbar, you
#. can translate it like if it was "Traditional"
#: src/preferences.py
msgid "Legacy"
msgstr "Tradizionala"

#. "Legacy" is about the window layout, it means menubar+toolbar, you
#. can translate it like if it was "Traditional".
#. Symbolic icons are monochrome icons.
#: src/preferences.py
msgid "Legacy (symbolic icons)"
msgstr "Tradizionala (ikur ikonoak)"

#: src/preferences.py
msgid "Menubar only"
msgstr "Menu-barra bakarrik"

#: src/preferences.py
msgid "Toolbar only"
msgstr "Tresna-barra bakarrik"

#. Symbolic icons are monochrome icons.
#: src/preferences.py
msgid "Toolbar only (symbolic icons)"
msgstr "Tresna-barra bakarrik (ikur ikonoak)"

#: src/properties.py
#, python-format
msgid "%s px"
msgstr "%s px"

#: src/properties.py
#, python-format
msgid "%s cm"
msgstr "%s cm"

#: src/properties.py
#, python-format
msgid "%s in"
msgstr "%s in"

#. Context: the path of the edited file
#: src/properties.py
msgid "Path"
msgstr "Bide-izena"

#. Context: the file format of the edited file
#: src/properties.py
msgid "Format"
msgstr "Formatua"

#: src/properties.py
msgid "Colorspace"
msgstr "Kolore-eredua"

#. Context: an invalid colorspace format
#: src/properties.py
msgid "Invalid format"
msgstr "Formatu baliogabea"

#. Context: an error message
#: src/saving_manager.py
#, python-format
msgid "Failed to save %s"
msgstr "Errorea %s gordetzean"

#. Context: Untitled(.png) is the default name of a newly saved file
#: src/saving_manager.py
msgid "Untitled"
msgstr "Izenik gabe"

#. Context: the sentence "There are unsaved modifications to %s."
#: src/saving_manager.py
msgid "this picture"
msgstr "irudi hau"

#: src/saving_manager.py
msgid "Discard"
msgstr "Baztertu"

#. Context: %s will be replaced by the name of a file.
#: src/saving_manager.py src/window.py
#, python-format
msgid "There are unsaved modifications to %s."
msgstr "%s fitxategian gorde gabeko aldaketak daude."

#: src/saving_manager.py
msgid ""
"A part of the image is selected, and the pixels beneath the selection are "
"blank."
msgstr ""

#: src/saving_manager.py
msgid "Modifications from the current tool haven't been applied."
msgstr ""

#: src/saving_manager.py
#, fuzzy
msgid "Do you want to save anyway?"
msgstr "Non ireki nahi duzu %s?"

#. Context: confirm replacing transparent pixels with the selected color
#: src/saving_manager.py
msgid "Replace"
msgstr "Ordeztu"

#: src/saving_manager.py
msgid "This file format doesn't support transparent colors."
msgstr "Fitxategi formatu honek ez du kolore gardenik onartzen."

#: src/saving_manager.py
msgid "You can save the image as a PNG file, or replace transparency with:"
msgstr "Irudia PDF formatuan gorde dezakezu edo gardentasunen ordez hau jarri:"

#: src/saving_manager.py
msgid "Replace transparency with:"
msgstr "Gardentasunaren ordez hau jarri:"

#: src/utilities.py
msgid "Transparent"
msgstr "Gardena"

#: src/utilities.py
#, python-format
msgid "%s%% transparent"
msgstr "%s %% garden"

#: src/utilities.py
msgid "Grey"
msgstr "Grisa"

#: src/utilities.py
msgid "Orange"
msgstr "Laranja"

#: src/utilities.py
msgid "Brown"
msgstr "Marroia"

#. Context: the name of the current color is provided as a tooltip to
#. help users with color blindness, but some color names don't have a
#. clear definition. Here, the app thinks it's probably brown.
#: src/utilities.py
msgid "Probably brown"
msgstr "Marroia seguruenik"

#: src/utilities.py
msgid "Red"
msgstr "Gorria"

#: src/utilities.py
msgid "Green"
msgstr "Berdea"

#: src/utilities.py
msgid "Blue"
msgstr "Urdina"

#: src/utilities.py
msgid "Yellow"
msgstr "Horia"

#: src/utilities.py
msgid "Magenta"
msgstr "Magenta"

#: src/utilities.py
msgid "Purple"
msgstr "Morea"

#: src/utilities.py
msgid "Cyan"
msgstr "Ziana"

#. Context: the name of the current color is provided as a tooltip to
#. help users with color blindness, but some color names don't have a
#. clear definition. Here, the app thinks it's probably turquoise.
#: src/utilities.py
msgid "Probably turquoise"
msgstr "Turkesa seguruenik"

#. Context: the name of the current color is provided as a tooltip to
#. help users with color blindness, but some color names don't have a
#. clear definition. Here, the app can't find a corresponding color name.
#: src/utilities.py
msgid "Unknown color name"
msgstr "Kolore izen ezezaguna"

#: src/utilities.py
msgid "All pictures"
msgstr "Irudi guztiak"

#: src/utilities.py
msgid "PNG images"
msgstr "PNG irudiak"

#: src/utilities.py
msgid "JPEG images"
msgstr "JPEG irudiak"

#: src/utilities.py
msgid "BMP images"
msgstr "IBMP irudiak"

#. To translators: it appears in tooltips over numerical inputs
#: src/utilities.py
msgid "percents"
msgstr "ehunekoak"

#. To translators: it's the angle measure unit, it appears in a tooltip
#. over a numerical input
#: src/utilities.py
msgid "degrees"
msgstr "graduak"

#. Context: an error message
#: src/window.py
#, python-format
msgid "Failed to load tool: %s"
msgstr "Errorea tresna kargatzean: %s"

#: src/window.py
msgid "Modifications will take effect in the next new window."
msgstr "Aldaketok hurrengo leiho berrian gauzatuko dira."

#: src/window.py src/tools/abstract_tool.py
#: src/optionsbars/classic/optionsbar-classic.ui
#: src/tools/classic_tools/tool_eraser.py
#: src/tools/classic_tools/tool_highlight.py
msgid "No options"
msgstr "Aukerarik gabe"

#: src/window.py
msgid "Opened images"
msgstr "Irudi irekiak"

#: src/window.py
#, fuzzy, python-format
msgid "Error: pane invalid for '%s', please report this bug."
msgstr "Errorea aplikazioa abiaraztean, mesedez eman errorearen berri."

#: src/window.py
#, python-format
msgid "Loading %s"
msgstr "Kargatzen %s"

#. Context: answer to "where do you want to open the image?"
#: src/window.py
msgid "New Tab"
msgstr "Fitxa berria"

#: src/window.py
msgid "Discard changes"
msgstr "Baztertu aldaketak"

#. Context: %s will be replaced by the name of a file.
#: src/window.py
#, python-format
msgid "Where do you want to open %s?"
msgstr "Non ireki nahi duzu %s?"

#. Context for translation:
#. "What do you want to do with *these files*?"
#: src/window.py
msgid "these files"
msgstr "fitxategi hauek"

#. Context: %s will be replaced by the name of a file. The possible
#. answers are "cancel", "open", and "import"
#: src/window.py
#, python-format
msgid "What do you want to do with %s?"
msgstr "Zer egin nahi duzu %s-rekin?"

#: src/window.py
msgid "Import a picture"
msgstr "Inportatu irudi bat"

#: src/window.py
msgid "Required tool is not available"
msgstr "Eskatutako tresna ez dago erabilgarri"

#. Context: an error message
#: src/tools/abstract_tool.py
#, python-brace-format
msgid "Can't start operation: wrong tool id (expected {0}, got {1})"
msgstr ""

#: src/tools/utilities_paths.py
msgid "Continue"
msgstr "Jarraitu"

#: src/tools/utilities_paths.py
msgid "The area seems poorly delimited, or is very complex."
msgstr "Area hori ongi zehaztu gabe dago, edo oso konplexua da."

#: src/tools/utilities_paths.py
msgid "This algorithm may not be able to manage the wanted area."
msgstr "Algoritmo horrek agian ezin du eskatutako area kudeatu."

#: src/tools/utilities_paths.py
msgid "Do you want to abort the operation, or to let the tool struggle ?"
msgstr "Nahi duzu ataza gelditu, edo tresna horrekin saiakera egin?"

#. Context: fill a shape with the color of the left click
#: src/optionsbars/classic/optionsbar_color_popover.py
#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Main color"
msgstr "Kolore nagusia"

#. Context: fill a shape with the color of the right click
#: src/optionsbars/classic/optionsbar_color_popover.py
#: src/optionsbars/transform/optionsbar-crop.ui src/tools/ui/tool-shape.ui
#: src/tools/ui/tool-crop.ui src/tools/classic_tools/tool_shape.py
msgid "Secondary color"
msgstr "Bigarren kolorea"

#: src/optionsbars/classic/optionsbar-classic.ui
msgid "Tool size"
msgstr "Tresnaren tamaina"

#: src/optionsbars/classic/optionsbar-classic.ui
#: src/optionsbars/selection/optionsbar-selection.ui src/tools/ui/tool-text.ui
#: src/tools/ui/tool-filters.ui
msgid "Preview"
msgstr "Aurrebista"

#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "How the color will be applied to the existing pixels"
msgstr "Nola zabalduko da kolorea dauden pixeletan"

#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Back to the palette"
msgstr "Atzera paletara"

#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Palette"
msgstr "Paleta"

#: src/optionsbars/classic/optionsbar-color-popover.ui
msgid "Use this editor by default"
msgstr "Erabili editore hau lehenespenez"

#: src/optionsbars/selection/optionsbar-selection.ui
#: src/optionsbars/transform/optionsbar-rotate.ui
msgid "More actions"
msgstr "Ekintza gehiago"

#: src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-filters.ui
#: src/optionsbars/transform/optionsbar-rotate.ui
#: src/optionsbars/transform/optionsbar-scale.ui
#: src/optionsbars/transform/optionsbar-skew.ui src/tools/ui/tool-crop.ui
#: src/tools/ui/tool-filters.ui src/tools/ui/tool-rotate.ui
#: src/tools/ui/tool-scale.ui src/tools/ui/tool-skew.ui
msgid "Apply"
msgstr "Aplikatu"

#: src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-scale.ui
msgid "More options"
msgstr "Aukera gehiago"

#: src/optionsbars/transform/optionsbar-crop.ui src/tools/ui/tool-crop.ui
msgid "Expand with…"
msgstr "Zabaldu honekin…"

#: src/optionsbars/transform/optionsbar-crop.ui
#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-crop.ui
msgid "Transparency"
msgstr "Gardentasuna"

#: src/optionsbars/transform/optionsbar-filters.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Select a filter…"
msgstr "Aukeratu iragazkia…"

#: src/optionsbars/transform/optionsbar-filters.ui
msgid "Saturation"
msgstr "Saturazioa"

#: src/optionsbars/transform/optionsbar-filters.ui
msgid "Blur radius"
msgstr "Lausotze erradioa"

#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Change saturation"
msgstr "Aldatu saturazioa"

#. Context: a filter adding like a light veil on the image
#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Veil"
msgstr "Beloa"

#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Add transparency"
msgstr "Gehitu gardentasuna"

#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Invert colors"
msgstr "Trukatu koloreak"

#. Context: the title of the menu with various types of blurring
#. filters and their options.
#: src/optionsbars/transform/optionsbar-filters.ui
msgid "Blurring"
msgstr "Lausotzea"

#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Fast blur"
msgstr "Lausotze azkarra"

#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Slow blur"
msgstr "Lausotze motela"

#. Context: a filter that censors the image with some kind of tiles
#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
#: src/tools/transform_tools/tool_filters.py
msgid "Pixelisation"
msgstr "Pixelizazioa"

#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
msgid "Blur direction"
msgstr "Lausotzearen norabidea"

#. Context: about the blur direction
#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
msgid "Horizontal"
msgstr "Horizontala"

#. Context: about the blur direction
#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
msgid "Vertical"
msgstr "Bertikala"

#. Context: about the blur direction
#: src/optionsbars/transform/optionsbar-filters.ui src/tools/ui/tool-filters.ui
msgid "No direction"
msgstr "Norabiderik gabe"

#: src/optionsbars/transform/optionsbar-rotate.ui
msgid "Angle (degrees)"
msgstr "Angelua (gradu)"

#: src/optionsbars/transform/optionsbar-rotate.ui
msgid "Angle"
msgstr "Angelua"

#: src/optionsbars/transform/optionsbar-rotate.ui src/tools/ui/tool-rotate.ui
msgid "Rotate left"
msgstr "Biratu ezkerrera"

#: src/optionsbars/transform/optionsbar-rotate.ui src/tools/ui/tool-rotate.ui
msgid "Rotate right"
msgstr "Biratu eskuinera"

#: src/optionsbars/transform/optionsbar-rotate.ui src/tools/ui/tool-rotate.ui
msgid "Flip horizontally"
msgstr "Irauli horizontalki"

#: src/optionsbars/transform/optionsbar-rotate.ui src/tools/ui/tool-rotate.ui
msgid "Flip vertically"
msgstr "Irauli bertikalki"

#. Context: the title of a menu to chose how the image will be scaled
#: src/optionsbars/transform/optionsbar-scale.ui src/tools/ui/tool-scale.ui
msgid "Keep proportions"
msgstr "Mantendu proportzioak"

#. Context: an item in a menu whose title is "Keep proportions"
#. Context for translations: "Always [keep proportions]"
#: src/optionsbars/transform/optionsbar-scale.ui src/tools/ui/tool-scale.ui
msgid "Always"
msgstr "Beti"

#. Context: an item in a menu whose title is "Keep proportions"
#. Context for translations: "[Keep proportions only] when scaling from corners"
#: src/optionsbars/transform/optionsbar-scale.ui src/tools/ui/tool-scale.ui
msgid "When scaling from corners"
msgstr "Izkinatik eskalatzean"

#. Context: an item in a menu whose title is "Keep proportions"
#. Context for translations: "Never [keep proportions]"
#: src/optionsbars/transform/optionsbar-scale.ui src/tools/ui/tool-scale.ui
msgid "Never"
msgstr "Inoiz ez"

#: src/optionsbars/transform/optionsbar-skew.ui
msgid "Horizontal deformation"
msgstr "Itxuraldaketa horizontala"

#: src/optionsbars/transform/optionsbar-skew.ui
msgid "Vertical deformation"
msgstr "Itxuraldaketa bertikala"

#: src/tools/ui/tool-arc.ui src/tools/ui/tool-line.ui
#: src/tools/ui/tool-pencil.ui
msgid "Line shape"
msgstr "Marraren forma"

#. Context: this is the name of a line shape
#. Default values
#: src/tools/ui/tool-arc.ui src/tools/ui/tool-line.ui
#: src/tools/ui/tool-pencil.ui src/tools/classic_tools/tool_arc.py
#: src/tools/classic_tools/tool_line.py src/tools/classic_tools/tool_pencil.py
msgid "Round"
msgstr "Mutur borobilduak"

#. Context: this is the name of a line shape
#: src/tools/ui/tool-arc.ui src/tools/ui/tool-line.ui
#: src/tools/ui/tool-pencil.ui src/tools/classic_tools/tool_arc.py
#: src/tools/classic_tools/tool_line.py src/tools/classic_tools/tool_pencil.py
msgid "Thin"
msgstr "Mutur zorrotzak"

#. Context: this is the name of a line shape
#: src/tools/ui/tool-arc.ui src/tools/ui/tool-line.ui
#: src/tools/ui/tool-pencil.ui src/tools/classic_tools/tool_arc.py
#: src/tools/classic_tools/tool_line.py src/tools/classic_tools/tool_pencil.py
msgid "Square"
msgstr "Mutur karratuak"

#: src/tools/ui/tool-arc.ui src/tools/ui/tool-line.ui
#: src/tools/ui/tool-pencil.ui
msgid "Use dashes"
msgstr "Erabili marratxoak"

#: src/tools/ui/tool-arc.ui src/tools/ui/tool-line.ui
#: src/tools/classic_tools/tool_arc.py src/tools/classic_tools/tool_line.py
msgid "Arrow"
msgstr "Gezia"

#: src/tools/ui/tool-arc.ui src/tools/ui/tool-line.ui
#: src/tools/ui/tool-pencil.ui src/tools/ui/tool-shape.ui
msgid "Antialiasing"
msgstr "Antialiasing-a"

#: src/tools/ui/tool-line.ui
msgid "Color gradient"
msgstr "Kolore gradientea"

#. Context: title for the list of the possible painting algorithms.
#: src/tools/ui/tool-paint.ui
msgid "Behavior"
msgstr "Portaera"

#. Context: this is one of the possible painting algorithms. It
#. tries to draw a shape around the area to paint, and fill it
#. with the new color. The shape is approximative so it's not the
#. default behavior of the tool.
#: src/tools/ui/tool-paint.ui
msgid "Encircle and fill"
msgstr "Borobildu eta bete"

#. Context: this is one of the possible painting algorithms. It
#. erases the color the user clicked, and then replace transparent
#. pixels with the new color.
#: src/tools/ui/tool-paint.ui
msgid "Erase and replace"
msgstr "Ezabatu eta ordeztu"

#. Context: this is one of the possible painting algorithms. It
#. doesn't really paint, instead it erases the color the user
#. clicked. For example to cut out an object from its white
#. background.
#: src/tools/ui/tool-paint.ui
#, fuzzy
msgid "Remove color"
msgstr "Jatorrizko kolorea"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Solid outline"
msgstr "Ertz jarraia"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Dashed outline"
msgstr "Ertz etena"

#. if state_as_string == 'none':
#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "No outline"
msgstr "Ertzik gabe"

#: src/tools/ui/tool-shape.ui
msgid "Filling"
msgstr "Betegarria"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Empty shape"
msgstr "Forma hutsa"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Horizontal gradient"
msgstr "Gradiente horizontala"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Vertical gradient"
msgstr "Gradiente bertikala"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Radial gradient"
msgstr "Gradiente erradiala"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Rectangle"
msgstr "Laukizuzena"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Rounded rectangle"
msgstr "Laukizuzen borobildua"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Oval"
msgstr "Elipsea"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Polygon"
msgstr "Poligonoa"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Free shape"
msgstr "Forma librea"

#: src/tools/ui/tool-shape.ui src/tools/classic_tools/tool_shape.py
msgid "Circle"
msgstr "Zirkulua"

#: src/tools/ui/tool-shape.ui
msgid "Close shape"
msgstr "Itxi forma"

#: src/tools/ui/tool-text.ui
msgid "Insert here"
msgstr "Txertatu hemen"

#: src/tools/ui/tool-text.ui
msgid "Font"
msgstr "Letra-mota"

#: src/tools/ui/tool-text.ui
msgid "Select a font…"
msgstr "Hautatu letra-mota…"

#: src/tools/ui/tool-text.ui
msgid "Italic"
msgstr "Etzana"

#: src/tools/ui/tool-text.ui
msgid "Bold"
msgstr "Lodia"

#. Context: the types of background behind the inserted text
#: src/tools/ui/tool-text.ui
msgid "Background"
msgstr "Atzeko kolorea"

#. Context: a type of background behind the inserted text
#: src/tools/ui/tool-text.ui src/tools/classic_tools/tool_text.py
msgid "No background"
msgstr "Atzeko kolorerik gabe"

#. Context: a type of background behind the inserted text
#: src/tools/ui/tool-text.ui src/tools/classic_tools/tool_text.py
msgid "Shadow"
msgstr "Itzala"

#. Context: a type of background behind the inserted text
#: src/tools/ui/tool-text.ui src/tools/classic_tools/tool_text.py
msgid "Outline"
msgstr "Ertza"

#. Context: a type of background behind the inserted text
#: src/tools/ui/tool-text.ui src/tools/classic_tools/tool_text.py
msgid "Rectangle background"
msgstr "Betegarri laukizuzena"

#: src/tools/ui/selection.ui
#, fuzzy
msgid "Transform"
msgstr "Gardena"

#: src/tools/ui/selection.ui
msgid "Flip"
msgstr "Irauli"

#. In this context, "Skew" is the name of the tool changing rectangles
#. into parallelograms (= tilt, slant, bend). Named after MS Paint's
#. "Stretch/Skew" dialog.
#: src/tools/ui/selection.ui src/tools/transform_tools/tool_skew.py
msgid "Skew"
msgstr "Etzan"

#: src/tools/classic_tools/tool_arc.py
msgid "Curve"
msgstr "Kurba"

#: src/tools/classic_tools/tool_arc.py
msgid "Curve options"
msgstr "Kurbaren aukerak"

#: src/tools/classic_tools/tool_arc.py src/tools/classic_tools/tool_line.py
msgid "Dashed arrow"
msgstr "Puntukako gezia"

#: src/tools/classic_tools/tool_arc.py src/tools/classic_tools/tool_line.py
#: src/tools/classic_tools/tool_pencil.py
msgid "Dashed"
msgstr "Etena"

#: src/tools/classic_tools/tool_line.py
msgid "Line"
msgstr "Marra"

#: src/tools/classic_tools/tool_line.py
msgid "Line options"
msgstr "Marraren aukerak"

#: src/tools/classic_tools/tool_paint.py
msgid "Painting options"
msgstr "Betegarriaren aukerak"

#: src/tools/classic_tools/tool_paint.py
msgid "Click on an area to replace its color by transparency"
msgstr "Klikatu area batean kolorea kendu eta gardena uzteko"

#: src/tools/classic_tools/tool_pencil.py
msgid "Pencil"
msgstr "Arkatza"

#: src/tools/classic_tools/tool_pencil.py
msgid "Pencil options"
msgstr "Arkatzaren aukerak"

#: src/tools/classic_tools/tool_shape.py
msgid "Shape"
msgstr "Forma"

#: src/tools/classic_tools/tool_shape.py
msgid "Shape options"
msgstr "Formaren aukerak"

#: src/tools/classic_tools/tool_shape.py
msgid "Click on the shape's first point to close it."
msgstr "Klikatu formaren lehenengo puntuan bera ixteko."

#: src/tools/classic_tools/tool_text.py
msgid "Text"
msgstr "Testua"

#. XXX use "text options" instead
#: src/tools/classic_tools/tool_text.py
msgid "Font options"
msgstr "Letra motaren aukerak"

#: src/tools/selection_tools/abstract_select.py
msgid "Drag the selection or right-click on the canvas"
msgstr "Arrastatu hautapena edo oihalean eskuin klik egin"

#: src/tools/selection_tools/abstract_select.py
msgid "Select an area or right-click on the canvas"
msgstr "Hautatu area bat edo oihalean eskuin klik egin"

#: src/tools/selection_tools/select_rect.py
msgid "Rectangle selection"
msgstr "Laukizuzen formako hautapena"

#: src/tools/transform_tools/abstract_transform_tool.py
msgid "Error: invalid values"
msgstr "Errorea: datu baliogabeak"

#: src/tools/transform_tools/tool_crop.py
msgid "Cropping the selection"
msgstr "Hautapena mozten"

#: src/tools/transform_tools/tool_crop.py
msgid "Cropping the canvas"
msgstr "Oihala mozten"

#: src/tools/transform_tools/tool_filters.py
msgid "Click on the image to preview the selected filter"
msgstr "Klikatu irudia hautatutako iragazkia aurreikusteko"

#: src/tools/transform_tools/tool_rotate.py
msgid "Rotating the selection"
msgstr "Hautapena biratzen"

#: src/tools/transform_tools/tool_rotate.py
msgid "Rotating the canvas"
msgstr "Girando el lienzo"

#: src/tools/transform_tools/tool_scale.py
msgid "Scaling the selection"
msgstr "Oihala biratzen"

#: src/tools/transform_tools/tool_scale.py
msgid "Scaling the canvas"
msgstr "Oihala eskalatzen"

#~ msgid "Clipping"
#~ msgstr "Mozketa"

#~ msgid "Edit"
#~ msgstr "Editatu"

#~ msgid "Open a file"
#~ msgstr "Ireki fitxategia"

#~ msgid "Save as"
#~ msgstr "Gorde honela"


object Test {

  def main(args: Array[String]) {
    val is = List(1,2,3)

    is match {
// the erroneous brace is ignored, so we can't halt on it.
// maybe brace healing can detect overlapping unmatched (...}
// In this case, the fix emits an extra error:
// t5702-neg-bad-brace.scala:10: error: Unmatched closing brace '}' ignored here
// t5702-neg-bad-brace.scala:10: error: illegal start of simple pattern (i.e., =>)
// t5702-neg-bad-brace.scala:11: error: ')' expected but '}' found.
      case List(1, _*} =>
    }
  }
}