File _service:obs_scm:ksanecore-VERSIONgit.20240404T... of Package ksanecore

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:ksanecore-VERSIONgit.20240404T022814~46f9196.obscpio of Package ksanecore (Revision 3bc327a9f090d67a2640000d39d7fabc)

Currently displaying revision 3bc327a9f090d67a2640000d39d7fabc , Show latest

07070100000000000081A4000000000000000000000001660E103E0000012C000000000000000000000000000000000000003800000000ksanecore-VERSIONgit.20240404T022814~46f9196/.gitignore# SPDX-FileCopyrightText: 2020 Alexander Stippich <a.stippich@gmx.net>
# SPDX-License-Identifier: CC0-1.0
*.kate-swp
tests/databases/*/*.db
.directory
.kdev4/
build*/
ksanecore.kdev4
src/.kdev_include_paths
CMakeLists.txt.user
/.clang-format
/compile_commands.json
.clangd
.cache
.idea
/cmake-build*
07070100000001000081A4000000000000000000000001660E103E0000013E000000000000000000000000000000000000003C00000000ksanecore-VERSIONgit.20240404T022814~46f9196/.gitlab-ci.yml# SPDX-FileCopyrightText: None
# SPDX-License-Identifier: CC0-1.0

include:
  - project: sysadmin/ci-utilities
    file:
      - /gitlab-templates/reuse-lint.yml
      - /gitlab-templates/linux.yml
      - /gitlab-templates/freebsd.yml
      - /gitlab-templates/linux-qt6.yml
      - /gitlab-templates/freebsd-qt6.yml
07070100000002000081A4000000000000000000000001660E103E00000193000000000000000000000000000000000000003900000000ksanecore-VERSIONgit.20240404T022814~46f9196/.kde-ci.yml# SPDX-FileCopyrightText: None
# SPDX-License-Identifier: CC0-1.0

Dependencies:
- 'on': ['Linux/Qt6', 'FreeBSD/Qt6']
  'require':
    'frameworks/extra-cmake-modules': '@latest-kf6'
    'frameworks/ki18n': '@latest-kf6'

- 'on': ['Linux/Qt5', 'FreeBSD/Qt5']
  'require':
    'frameworks/extra-cmake-modules': '@stable'
    'frameworks/ki18n': '@stable'

Options:
  require-passing-tests-on: [ '@all' ]
07070100000003000081A4000000000000000000000001660E103E00000D86000000000000000000000000000000000000003C00000000ksanecore-VERSIONgit.20240404T022814~46f9196/CMakeLists.txt# SPDX-FileCopyrightText: none
#
# SPDX-License-Identifier: BSD-2-Clause

cmake_minimum_required(VERSION 3.16.0)

# KDE Applications version, managed by release script.
set(RELEASE_SERVICE_VERSION_MAJOR "24")
set(RELEASE_SERVICE_VERSION_MINOR "04")
set(RELEASE_SERVICE_VERSION_MICRO "70")
set(RELEASE_SERVICE_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}.${RELEASE_SERVICE_VERSION_MINOR}.${RELEASE_SERVICE_VERSION_MICRO}")

project(KSaneCore VERSION ${RELEASE_SERVICE_VERSION})

include(FeatureSummary)
set(KF5_VERSION "5.90.0")
find_package(ECM ${KF5_VERSION} REQUIRED NO_MODULE)
set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://commits.kde.org/extra-cmake-modules")
set(CMAKE_MODULE_PATH ${KSaneCore_SOURCE_DIR}/cmake-modules ${ECM_MODULE_PATH})

include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDECompilerSettings NO_POLICY_SCOPE)

include(FeatureSummary)
include(ECMSetupVersion)
include(ECMGenerateHeaders)
include(ECMInstallIcons)
include(CMakePackageConfigHelpers)
include(CheckFunctionExists)
include(ECMGenerateExportHeader)
include(ECMQtDeclareLoggingCategory)
include(KDEGitCommitHooks)
include(KDEClangFormat)
include(ECMDeprecationSettings)
if (QT_MAJOR_VERSION STREQUAL "6")
    set(QT_REQUIRED_VERSION "6.4.0")
    set(KF_MIN_VERSION "5.240.0")
    set(KF_MAJOR_VERSION "6")
    set(KSANECORE_SUFFFIX "6")
else()
    set(KF_MAJOR_VERSION "5")
    set(KSANECORE_SUFFFIX "")
endif()

set(ksanecore_version_header "${CMAKE_CURRENT_BINARY_DIR}/src/ksanecore_version.h")
ecm_setup_version(
    ${RELEASE_SERVICE_VERSION}
    VARIABLE_PREFIX KSANECORE
    VERSION_HEADER "${ksanecore_version_header}"
    PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KSaneCore${KSANECORE_SUFFFIX}ConfigVersion.cmake"
    SOVERSION 1
)

# Dependencies
set(REQUIRED_QT_VERSION "5.15.2")
# Required Qt5 components to build this framework
find_package(Qt${QT_MAJOR_VERSION} ${REQUIRED_QT_VERSION} NO_MODULE REQUIRED Core Gui)
# Required KF5 frameworks
find_package(KF${KF_MAJOR_VERSION}I18n ${KF5_VERSION} REQUIRED)

# Check if sane API is available.
find_package(Sane REQUIRED)
message(STATUS "SANE_FOUND:       ${SANE_FOUND}")
message(STATUS "SANE_INCLUDE_DIR: ${SANE_INCLUDE_DIR}")
message(STATUS "SANE_LIBRARY:     ${SANE_LIBRARY}")

ecm_set_disabled_deprecation_versions(QT 6.4
    KF 5.101
)

add_subdirectory(src)
if (BUILD_TESTING)
    add_subdirectory(autotests)
endif()

set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KSaneCore${KSANECORE_SUFFFIX}")

configure_package_config_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/KSaneCoreConfig.cmake.in"
    "${CMAKE_CURRENT_BINARY_DIR}/KSaneCore${KSANECORE_SUFFFIX}Config.cmake"
    INSTALL_DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
)

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/KSaneCore${KSANECORE_SUFFFIX}Config.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/KSaneCore${KSANECORE_SUFFFIX}ConfigVersion.cmake"
    DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
    COMPONENT Devel
)

install(FILES
    "${ksanecore_version_header}"
    DESTINATION "${KDE_INSTALL_INCLUDEDIR}/KSaneCore${KSANECORE_SUFFFIX}"
    COMPONENT Devel
)

install(EXPORT KSaneCore${KSANECORE_SUFFFIX}Targets
    DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
    FILE KSaneCore${KSANECORE_SUFFFIX}Targets.cmake
    NAMESPACE KSane${KSANECORE_SUFFFIX}::
)

ki18n_install(po)

feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)

kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)
07070100000004000081A4000000000000000000000001660E103E0000010D000000000000000000000000000000000000004600000000ksanecore-VERSIONgit.20240404T022814~46f9196/KSaneCoreConfig.cmake.in# SPDX-FileCopyrightText: none
#
# SPDX-License-Identifier: BSD-2-Clause

@PACKAGE_INIT@

include(CMakeFindDependencyMacro)
find_dependency(Qt@QT_MAJOR_VERSION@Gui "@REQUIRED_QT_VERSION@")

include("${CMAKE_CURRENT_LIST_DIR}/KSaneCore@KSANECORE_SUFFFIX@Targets.cmake")
07070100000005000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003600000000ksanecore-VERSIONgit.20240404T022814~46f9196/LICENSES07070100000006000081A4000000000000000000000001660E103E000004F2000000000000000000000000000000000000004700000000ksanecore-VERSIONgit.20240404T022814~46f9196/LICENSES/BSD-2-Clause.txtCopyright (c) <year> <owner>

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
07070100000007000081A4000000000000000000000001660E103E000005C8000000000000000000000000000000000000004700000000ksanecore-VERSIONgit.20240404T022814~46f9196/LICENSES/BSD-3-Clause.txtCopyright (c) <year> <owner>. All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
07070100000008000081A4000000000000000000000001660E103E00001B88000000000000000000000000000000000000004200000000ksanecore-VERSIONgit.20240404T022814~46f9196/LICENSES/CC0-1.0.txtCreative Commons Legal Code

CC0 1.0 Universal

CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
    HEREUNDER.

Statement of Purpose

The laws of most jurisdictions throughout the world automatically confer
exclusive Copyright and Related Rights (defined below) upon the creator
and subsequent owner(s) (each and all, an "owner") of an original work of
authorship and/or a database (each, a "Work").

Certain owners wish to permanently relinquish those rights to a Work for
the purpose of contributing to a commons of creative, cultural and
scientific works ("Commons") that the public can reliably and without fear
of later claims of infringement build upon, modify, incorporate in other
works, reuse and redistribute as freely as possible in any form whatsoever
and for any purposes, including without limitation commercial purposes.
These owners may contribute to the Commons to promote the ideal of a free
culture and the further production of creative, cultural and scientific
works, or to gain reputation or greater distribution for their Work in
part through the use and efforts of others.

For these and/or other purposes and motivations, and without any
expectation of additional consideration or compensation, the person
associating CC0 with a Work (the "Affirmer"), to the extent that he or she
is an owner of Copyright and Related Rights in the Work, voluntarily
elects to apply CC0 to the Work and publicly distribute the Work under its
terms, with knowledge of his or her Copyright and Related Rights in the
Work and the meaning and intended legal effect of CC0 on those rights.

1. Copyright and Related Rights. A Work made available under CC0 may be
protected by copyright and related or neighboring rights ("Copyright and
Related Rights"). Copyright and Related Rights include, but are not
limited to, the following:

i. the right to reproduce, adapt, distribute, perform, display,
     communicate, and translate a Work;
 ii. moral rights retained by the original author(s) and/or performer(s);
iii. publicity and privacy rights pertaining to a person's image or
     likeness depicted in a Work;
 iv. rights protecting against unfair competition in regards to a Work,
     subject to the limitations in paragraph 4(a), below;
  v. rights protecting the extraction, dissemination, use and reuse of data
     in a Work;
 vi. database rights (such as those arising under Directive 96/9/EC of the
     European Parliament and of the Council of 11 March 1996 on the legal
     protection of databases, and under any national implementation
     thereof, including any amended or successor version of such
     directive); and
vii. other similar, equivalent or corresponding rights throughout the
     world based on applicable law or treaty, and any national
     implementations thereof.

2. Waiver. To the greatest extent permitted by, but not in contravention
of, applicable law, Affirmer hereby overtly, fully, permanently,
irrevocably and unconditionally waives, abandons, and surrenders all of
Affirmer's Copyright and Related Rights and associated claims and causes
of action, whether now known or unknown (including existing as well as
future claims and causes of action), in the Work (i) in all territories
worldwide, (ii) for the maximum duration provided by applicable law or
treaty (including future time extensions), (iii) in any current or future
medium and for any number of copies, and (iv) for any purpose whatsoever,
including without limitation commercial, advertising or promotional
purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
member of the public at large and to the detriment of Affirmer's heirs and
successors, fully intending that such Waiver shall not be subject to
revocation, rescission, cancellation, termination, or any other legal or
equitable action to disrupt the quiet enjoyment of the Work by the public
as contemplated by Affirmer's express Statement of Purpose.

3. Public License Fallback. Should any part of the Waiver for any reason
be judged legally invalid or ineffective under applicable law, then the
Waiver shall be preserved to the maximum extent permitted taking into
account Affirmer's express Statement of Purpose. In addition, to the
extent the Waiver is so judged Affirmer hereby grants to each affected
person a royalty-free, non transferable, non sublicensable, non exclusive,
irrevocable and unconditional license to exercise Affirmer's Copyright and
Related Rights in the Work (i) in all territories worldwide, (ii) for the
maximum duration provided by applicable law or treaty (including future
time extensions), (iii) in any current or future medium and for any number
of copies, and (iv) for any purpose whatsoever, including without
limitation commercial, advertising or promotional purposes (the
"License"). The License shall be deemed effective as of the date CC0 was
applied by Affirmer to the Work. Should any part of the License for any
reason be judged legally invalid or ineffective under applicable law, such
partial invalidity or ineffectiveness shall not invalidate the remainder
of the License, and in such case Affirmer hereby affirms that he or she
will not (i) exercise any of his or her remaining Copyright and Related
Rights in the Work or (ii) assert any associated claims and causes of
action with respect to the Work, in either case contrary to Affirmer's
express Statement of Purpose.

4. Limitations and Disclaimers.

a. No trademark or patent rights held by Affirmer are waived, abandoned,
    surrendered, licensed or otherwise affected by this document.
 b. Affirmer offers the Work as-is and makes no representations or
    warranties of any kind concerning the Work, express, implied,
    statutory or otherwise, including without limitation warranties of
    title, merchantability, fitness for a particular purpose, non
    infringement, or the absence of latent or other defects, accuracy, or
    the present or absence of errors, whether or not discoverable, all to
    the greatest extent permissible under applicable law.
 c. Affirmer disclaims responsibility for clearing rights of other persons
    that may apply to the Work or any use thereof, including without
    limitation any person's Copyright and Related Rights in the Work.
    Further, Affirmer disclaims responsibility for obtaining any necessary
    consents, permissions or other rights required for any use of the
    Work.
 d. Affirmer understands and acknowledges that Creative Commons is not a
    party to this document and has no duty or obligation with respect to
    this CC0 or use of the Work.
07070100000009000081A4000000000000000000000001660E103E0000652E000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/LICENSES/LGPL-2.1-only.txtGNU LESSER GENERAL PUBLIC LICENSE

Version 2.1, February 1999

Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.

[This is the first released version of the Lesser GPL.  It also counts as
the successor of the GNU Library Public License, version 2, hence the version
number 2.1.]

Preamble

The licenses for most software are designed to take away your freedom to share
and change it. By contrast, the GNU General Public Licenses are intended to
guarantee your freedom to share and change free software--to make sure the
software is free for all its users.

This license, the Lesser General Public License, applies to some specially
designated software packages--typically libraries--of the Free Software Foundation
and other authors who decide to use it. You can use it too, but we suggest
you first think carefully about whether this license or the ordinary General
Public License is the better strategy to use in any particular case, based
on the explanations below.

When we speak of free software, we are referring to freedom of use, not price.
Our General Public Licenses are designed to make sure that you have the freedom
to distribute copies of free software (and charge for this service if you
wish); that you receive source code or can get it if you want it; that you
can change the software and use pieces of it in new free programs; and that
you are informed that you can do these things.

To protect your rights, we need to make restrictions that forbid distributors
to deny you these rights or to ask you to surrender these rights. These restrictions
translate to certain responsibilities for you if you distribute copies of
the library or if you modify it.

For example, if you distribute copies of the library, whether gratis or for
a fee, you must give the recipients all the rights that we gave you. You must
make sure that they, too, receive or can get the source code. If you link
other code with the library, you must provide complete object files to the
recipients, so that they can relink them with the library after making changes
to the library and recompiling it. And you must show them these terms so they
know their rights.

We protect your rights with a two-step method: (1) we copyright the library,
and (2) we offer you this license, which gives you legal permission to copy,
distribute and/or modify the library.

To protect each distributor, we want to make it very clear that there is no
warranty for the free library. Also, if the library is modified by someone
else and passed on, the recipients should know that what they have is not
the original version, so that the original author's reputation will not be
affected by problems that might be introduced by others.

Finally, software patents pose a constant threat to the existence of any free
program. We wish to make sure that a company cannot effectively restrict the
users of a free program by obtaining a restrictive license from a patent holder.
Therefore, we insist that any patent license obtained for a version of the
library must be consistent with the full freedom of use specified in this
license.

Most GNU software, including some libraries, is covered by the ordinary GNU
General Public License. This license, the GNU Lesser General Public License,
applies to certain designated libraries, and is quite different from the ordinary
General Public License. We use this license for certain libraries in order
to permit linking those libraries into non-free programs.

When a program is linked with a library, whether statically or using a shared
library, the combination of the two is legally speaking a combined work, a
derivative of the original library. The ordinary General Public License therefore
permits such linking only if the entire combination fits its criteria of freedom.
The Lesser General Public License permits more lax criteria for linking other
code with the library.

We call this license the "Lesser" General Public License because it does Less
to protect the user's freedom than the ordinary General Public License. It
also provides other free software developers Less of an advantage over competing
non-free programs. These disadvantages are the reason we use the ordinary
General Public License for many libraries. However, the Lesser license provides
advantages in certain special circumstances.

For example, on rare occasions, there may be a special need to encourage the
widest possible use of a certain library, so that it becomes a de-facto standard.
To achieve this, non-free programs must be allowed to use the library. A more
frequent case is that a free library does the same job as widely used non-free
libraries. In this case, there is little to gain by limiting the free library
to free software only, so we use the Lesser General Public License.

In other cases, permission to use a particular library in non-free programs
enables a greater number of people to use a large body of free software. For
example, permission to use the GNU C Library in non-free programs enables
many more people to use the whole GNU operating system, as well as its variant,
the GNU/Linux operating system.

Although the Lesser General Public License is Less protective of the users'
freedom, it does ensure that the user of a program that is linked with the
Library has the freedom and the wherewithal to run that program using a modified
version of the Library.

The precise terms and conditions for copying, distribution and modification
follow. Pay close attention to the difference between a "work based on the
library" and a "work that uses the library". The former contains code derived
from the library, whereas the latter must be combined with the library in
order to run.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License Agreement applies to any software library or other program
which contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Lesser General
Public License (also called "this License"). Each licensee is addressed as
"you".

A "library" means a collection of software functions and/or data prepared
so as to be conveniently linked with application programs (which use some
of those functions and data) to form executables.

The "Library", below, refers to any such software library or work which has
been distributed under these terms. A "work based on the Library" means either
the Library or any derivative work under copyright law: that is to say, a
work containing the Library or a portion of it, either verbatim or with modifications
and/or translated straightforwardly into another language. (Hereinafter, translation
is included without limitation in the term "modification".)

"Source code" for a work means the preferred form of the work for making modifications
to it. For a library, complete source code means all the source code for all
modules it contains, plus any associated interface definition files, plus
the scripts used to control compilation and installation of the library.

Activities other than copying, distribution and modification are not covered
by this License; they are outside its scope. The act of running a program
using the Library is not restricted, and output from such a program is covered
only if its contents constitute a work based on the Library (independent of
the use of the Library in a tool for writing it). Whether that is true depends
on what the Library does and what the program that uses the Library does.

1. You may copy and distribute verbatim copies of the Library's complete source
code as you receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice and disclaimer
of warranty; keep intact all the notices that refer to this License and to
the absence of any warranty; and distribute a copy of this License along with
the Library.

You may charge a fee for the physical act of transferring a copy, and you
may at your option offer warranty protection in exchange for a fee.

2. You may modify your copy or copies of the Library or any portion of it,
thus forming a work based on the Library, and copy and distribute such modifications
or work under the terms of Section 1 above, provided that you also meet all
of these conditions:

a) The modified work must itself be a software library.

b) You must cause the files modified to carry prominent notices stating that
you changed the files and the date of any change.

c) You must cause the whole of the work to be licensed at no charge to all
third parties under the terms of this License.

d) If a facility in the modified Library refers to a function or a table of
data to be supplied by an application program that uses the facility, other
than as an argument passed when the facility is invoked, then you must make
a good faith effort to ensure that, in the event an application does not supply
such function or table, the facility still operates, and performs whatever
part of its purpose remains meaningful.

(For example, a function in a library to compute square roots has a purpose
that is entirely well-defined independent of the application. Therefore, Subsection
2d requires that any application-supplied function or table used by this function
must be optional: if the application does not supply it, the square root function
must still compute square roots.)

These requirements apply to the modified work as a whole. If identifiable
sections of that work are not derived from the Library, and can be reasonably
considered independent and separate works in themselves, then this License,
and its terms, do not apply to those sections when you distribute them as
separate works. But when you distribute the same sections as part of a whole
which is a work based on the Library, the distribution of the whole must be
on the terms of this License, whose permissions for other licensees extend
to the entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest your
rights to work written entirely by you; rather, the intent is to exercise
the right to control the distribution of derivative or collective works based
on the Library.

In addition, mere aggregation of another work not based on the Library with
the Library (or with a work based on the Library) on a volume of a storage
or distribution medium does not bring the other work under the scope of this
License.

3. You may opt to apply the terms of the ordinary GNU General Public License
instead of this License to a given copy of the Library. To do this, you must
alter all the notices that refer to this License, so that they refer to the
ordinary GNU General Public License, version 2, instead of to this License.
(If a newer version than version 2 of the ordinary GNU General Public License
has appeared, then you can specify that version instead if you wish.) Do not
make any other change in these notices.

Once this change is made in a given copy, it is irreversible for that copy,
so the ordinary GNU General Public License applies to all subsequent copies
and derivative works made from that copy.

This option is useful when you wish to copy part of the code of the Library
into a program that is not a library.

4. You may copy and distribute the Library (or a portion or derivative of
it, under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you accompany it with the complete corresponding
machine-readable source code, which must be distributed under the terms of
Sections 1 and 2 above on a medium customarily used for software interchange.

If distribution of object code is made by offering access to copy from a designated
place, then offering equivalent access to copy the source code from the same
place satisfies the requirement to distribute the source code, even though
third parties are not compelled to copy the source along with the object code.

5. A program that contains no derivative of any portion of the Library, but
is designed to work with the Library by being compiled or linked with it,
is called a "work that uses the Library". Such a work, in isolation, is not
a derivative work of the Library, and therefore falls outside the scope of
this License.

However, linking a "work that uses the Library" with the Library creates an
executable that is a derivative of the Library (because it contains portions
of the Library), rather than a "work that uses the library". The executable
is therefore covered by this License. Section 6 states terms for distribution
of such executables.

When a "work that uses the Library" uses material from a header file that
is part of the Library, the object code for the work may be a derivative work
of the Library even though the source code is not. Whether this is true is
especially significant if the work can be linked without the Library, or if
the work is itself a library. The threshold for this to be true is not precisely
defined by law.

If such an object file uses only numerical parameters, data structure layouts
and accessors, and small macros and small inline functions (ten lines or less
in length), then the use of the object file is unrestricted, regardless of
whether it is legally a derivative work. (Executables containing this object
code plus portions of the Library will still fall under Section 6.)

Otherwise, if the work is a derivative of the Library, you may distribute
the object code for the work under the terms of Section 6. Any executables
containing that work also fall under Section 6, whether or not they are linked
directly with the Library itself.

6. As an exception to the Sections above, you may also combine or link a "work
that uses the Library" with the Library to produce a work containing portions
of the Library, and distribute that work under terms of your choice, provided
that the terms permit modification of the work for the customer's own use
and reverse engineering for debugging such modifications.

You must give prominent notice with each copy of the work that the Library
is used in it and that the Library and its use are covered by this License.
You must supply a copy of this License. If the work during execution displays
copyright notices, you must include the copyright notice for the Library among
them, as well as a reference directing the user to the copy of this License.
Also, you must do one of these things:

a) Accompany the work with the complete corresponding machine-readable source
code for the Library including whatever changes were used in the work (which
must be distributed under Sections 1 and 2 above); and, if the work is an
executable linked with the Library, with the complete machine-readable "work
that uses the Library", as object code and/or source code, so that the user
can modify the Library and then relink to produce a modified executable containing
the modified Library. (It is understood that the user who changes the contents
of definitions files in the Library will not necessarily be able to recompile
the application to use the modified definitions.)

b) Use a suitable shared library mechanism for linking with the Library. A
suitable mechanism is one that (1) uses at run time a copy of the library
already present on the user's computer system, rather than copying library
functions into the executable, and (2) will operate properly with a modified
version of the library, if the user installs one, as long as the modified
version is interface-compatible with the version that the work was made with.

c) Accompany the work with a written offer, valid for at least three years,
to give the same user the materials specified in Subsection 6a, above, for
a charge no more than the cost of performing this distribution.

d) If distribution of the work is made by offering access to copy from a designated
place, offer equivalent access to copy the above specified materials from
the same place.

e) Verify that the user has already received a copy of these materials or
that you have already sent this user a copy.

For an executable, the required form of the "work that uses the Library" must
include any data and utility programs needed for reproducing the executable
from it. However, as a special exception, the materials to be distributed
need not include anything that is normally distributed (in either source or
binary form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component itself
accompanies the executable.

It may happen that this requirement contradicts the license restrictions of
other proprietary libraries that do not normally accompany the operating system.
Such a contradiction means you cannot use both them and the Library together
in an executable that you distribute.

7. You may place library facilities that are a work based on the Library side-by-side
in a single library together with other library facilities not covered by
this License, and distribute such a combined library, provided that the separate
distribution of the work based on the Library and of the other library facilities
is otherwise permitted, and provided that you do these two things:

a) Accompany the combined library with a copy of the same work based on the
Library, uncombined with any other library facilities. This must be distributed
under the terms of the Sections above.

b) Give prominent notice with the combined library of the fact that part of
it is a work based on the Library, and explaining where to find the accompanying
uncombined form of the same work.

8. You may not copy, modify, sublicense, link with, or distribute the Library
except as expressly provided under this License. Any attempt otherwise to
copy, modify, sublicense, link with, or distribute the Library is void, and
will automatically terminate your rights under this License. However, parties
who have received copies, or rights, from you under this License will not
have their licenses terminated so long as such parties remain in full compliance.

9. You are not required to accept this License, since you have not signed
it. However, nothing else grants you permission to modify or distribute the
Library or its derivative works. These actions are prohibited by law if you
do not accept this License. Therefore, by modifying or distributing the Library
(or any work based on the Library), you indicate your acceptance of this License
to do so, and all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

10. Each time you redistribute the Library (or any work based on the Library),
the recipient automatically receives a license from the original licensor
to copy, distribute, link with or modify the Library subject to these terms
and conditions. You may not impose any further restrictions on the recipients'
exercise of the rights granted herein. You are not responsible for enforcing
compliance by third parties with this License.

11. If, as a consequence of a court judgment or allegation of patent infringement
or for any other reason (not limited to patent issues), conditions are imposed
on you (whether by court order, agreement or otherwise) that contradict the
conditions of this License, they do not excuse you from the conditions of
this License. If you cannot distribute so as to satisfy simultaneously your
obligations under this License and any other pertinent obligations, then as
a consequence you may not distribute the Library at all. For example, if a
patent license would not permit royalty-free redistribution of the Library
by all those who receive copies directly or indirectly through you, then the
only way you could satisfy both it and this License would be to refrain entirely
from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any patents
or other property right claims or to contest validity of any such claims;
this section has the sole purpose of protecting the integrity of the free
software distribution system which is implemented by public license practices.
Many people have made generous contributions to the wide range of software
distributed through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing to
distribute software through any other system and a licensee cannot impose
that choice.

This section is intended to make thoroughly clear what is believed to be a
consequence of the rest of this License.

12. If the distribution and/or use of the Library is restricted in certain
countries either by patents or by copyrighted interfaces, the original copyright
holder who places the Library under this License may add an explicit geographical
distribution limitation excluding those countries, so that distribution is
permitted only in or among countries not thus excluded. In such case, this
License incorporates the limitation as if written in the body of this License.

13. The Free Software Foundation may publish revised and/or new versions of
the Lesser General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to address
new problems or concerns.

Each version is given a distinguishing version number. If the Library specifies
a version number of this License which applies to it and "any later version",
you have the option of following the terms and conditions either of that version
or of any later version published by the Free Software Foundation. If the
Library does not specify a license version number, you may choose any version
ever published by the Free Software Foundation.

14. If you wish to incorporate parts of the Library into other free programs
whose distribution conditions are incompatible with these, write to the author
to ask for permission. For software which is copyrighted by the Free Software
Foundation, write to the Free Software Foundation; we sometimes make exceptions
for this. Our decision will be guided by the two goals of preserving the free
status of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

NO WARRANTY

15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY
"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA
OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH
HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Libraries

If you develop a new library, and you want it to be of the greatest possible
use to the public, we recommend making it free software that everyone can
redistribute and change. You can do so by permitting redistribution under
these terms (or, alternatively, under the terms of the ordinary General Public
License).

To apply these terms, attach the following notices to the library. It is safest
to attach them to the start of each source file to most effectively convey
the exclusion of warranty; and each file should have at least the "copyright"
line and a pointer to where the full notice is found.

one line to give the library's name and an idea of what it does.
     Copyright (C) year  name of author

This library is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation; either version 2.1 of the License, or (at your option)
any later version.

This library is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
details.

You should have received a copy of the GNU Lesser General Public License along
with this library; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA Also add information
on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your school,
if any, to sign a "copyright disclaimer" for the library, if necessary. Here
is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in
the library `Frob' (a library for tweaking knobs) written
by James Random Hacker.

signature of Ty Coon, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!
0707010000000A000081A4000000000000000000000001660E103E00001CBB000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/LICENSES/LGPL-3.0-only.txtGNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007

Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.

This version of the GNU Lesser General Public License incorporates the terms
and conditions of version 3 of the GNU General Public License, supplemented
by the additional permissions listed below.

0. Additional Definitions.

As used herein, "this License" refers to version 3 of the GNU Lesser General
Public License, and the "GNU GPL" refers to version 3 of the GNU General Public
License.

"The Library" refers to a covered work governed by this License, other than
an Application or a Combined Work as defined below.

An "Application" is any work that makes use of an interface provided by the
Library, but which is not otherwise based on the Library. Defining a subclass
of a class defined by the Library is deemed a mode of using an interface provided
by the Library.

A "Combined Work" is a work produced by combining or linking an Application
with the Library.  The particular version of the Library with which the Combined
Work was made is also called the "Linked Version".

The "Minimal Corresponding Source" for a Combined Work means the Corresponding
Source for the Combined Work, excluding any source code for portions of the
Combined Work that, considered in isolation, are based on the Application,
and not on the Linked Version.

The "Corresponding Application Code" for a Combined Work means the object
code and/or source code for the Application, including any data and utility
programs needed for reproducing the Combined Work from the Application, but
excluding the System Libraries of the Combined Work.

1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License without
being bound by section 3 of the GNU GPL.

2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a facility
refers to a function or data to be supplied by an Application that uses the
facility (other than as an argument passed when the facility is invoked),
then you may convey a copy of the modified version:

a) under this License, provided that you make a good faith effort to ensure
that, in the event an Application does not supply the function or data, the
facility still operates, and performs whatever part of its purpose remains
meaningful, or

b) under the GNU GPL, with none of the additional permissions of this License
applicable to that copy.

3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from a header
file that is part of the Library.  You may convey such object code under terms
of your choice, provided that, if the incorporated material is not limited
to numerical parameters, data structure layouts and accessors, or small macros,
inline functions and templates (ten or fewer lines in length), you do both
of the following:

a) Give prominent notice with each copy of the object code that the Library
is used in it and that the Library and its use are covered by this License.

b) Accompany the object code with a copy of the GNU GPL and this license document.

4. Combined Works.
You may convey a Combined Work under terms of your choice that, taken together,
effectively do not restrict modification of the portions of the Library contained
in the Combined Work and reverse engineering for debugging such modifications,
if you also do each of the following:

a) Give prominent notice with each copy of the Combined Work that the Library
is used in it and that the Library and its use are covered by this License.

b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.

c) For a Combined Work that displays copyright notices during execution, include
the copyright notice for the Library among these notices, as well as a reference
directing the user to the copies of the GNU GPL and this license document.

d) Do one of the following:

0) Convey the Minimal Corresponding Source under the terms of this License,
and the Corresponding Application Code in a form suitable for, and under terms
that permit, the user to recombine or relink the Application with a modified
version of the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying Corresponding Source.

1) Use a suitable shared library mechanism for linking with the Library.
A suitable mechanism is one that (a) uses at run time a copy of the Library
already present on the user's computer system, and (b) will operate properly
with a modified version of the Library that is interface-compatible with the
Linked Version.

e) Provide Installation Information, but only if you would otherwise be required
to provide such information under section 6 of the GNU GPL, and only to the
extent that such information is necessary to install and execute a modified
version of the Combined Work produced by recombining or relinking the Application
with a modified version of the Linked Version. (If you use option 4d0, the
Installation Information must accompany the Minimal Corresponding Source and
Corresponding Application Code. If you use option 4d1, you must provide the
Installation Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)

5. Combined Libraries.
You may place library facilities that are a work based on the Library side
by side in a single library together with other library facilities that are
not Applications and are not covered by this License, and convey such a combined
library under terms of your choice, if you do both of the following:

a) Accompany the combined library with a copy of the same work based on the
Library, uncombined with any other library facilities, conveyed under the
terms of this License.

b) Give prominent notice with the combined library that part of it is a work
based on the Library, and explaining where to find the accompanying uncombined
form of the same work.

6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions of the
GNU Lesser General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to address
new problems or concerns.

Each version is given a distinguishing version number. If the Library as you
received it specifies that a certain numbered version of the GNU Lesser General
Public License "or any later version" applies to it, you have the option of
following the terms and conditions either of that published version or of
any later version published by the Free Software Foundation. If the Library
as you received it does not specify a version number of the GNU Lesser General
Public License, you may choose any version of the GNU Lesser General Public
License ever published by the Free Software Foundation.

If the Library as you received it specifies that a proxy can decide whether
future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is permanent
authorization for you to choose that version for the Library.
0707010000000B000081A4000000000000000000000001660E103E00000299000000000000000000000000000000000000005700000000ksanecore-VERSIONgit.20240404T022814~46f9196/LICENSES/LicenseRef-KDE-Accepted-LGPL.txtThis library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the license or (at your option) any later version
that is accepted by the membership of KDE e.V. (or its successor
approved by the membership of KDE e.V.), which shall act as a
proxy as defined in Section 6 of version 3 of the license.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
0707010000000C000081A4000000000000000000000001660E103E000002F6000000000000000000000000000000000000003700000000ksanecore-VERSIONgit.20240404T022814~46f9196/README.md<!--
 SPDX-FileCopyrightText: none

SPDX-License-Identifier: CC0-1.0
-->

# KSaneCore

## Introduction

KSaneCore is a library that provides a Qt interface for the SANE library for scanner hardware.

## About

KSaneCore is a Qt-based interface for SANE library to control scanner hardware.

The library documentation is available on the header files.

## Dependencies

- CMake          >= 3.11.0                https://cmake.org
 - Qt             >= 5.15.2                https://qt.io
 - KDE Frameworks >= 5.90.0                https://www.kde.org
 - libsane        >= 1.0.32                http://www.sane-project.org

## Install

In order to compile, just use something like this:

```bash
cd path/to/ksanecore
mkdir build && cd build
cmake ..
make
```
0707010000000D000081A4000000000000000000000001660E103E0000007F000000000000000000000000000000000000003200000000ksanecore-VERSIONgit.20240404T022814~46f9196/TODO# SPDX-FileCopyrightText: none
#
# SPDX-License-Identifier: CC0-1.0

# KSaneCore
Implement reading multi-value options of SANE
0707010000000E000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003700000000ksanecore-VERSIONgit.20240404T022814~46f9196/autotests0707010000000F000081A4000000000000000000000001660E103E000001DD000000000000000000000000000000000000004600000000ksanecore-VERSIONgit.20240404T022814~46f9196/autotests/CMakeLists.txt# SPDX-FileCopyrightText: none
#
# SPDX-License-Identifier: BSD-2-Clause

find_package(Qt${QT_MAJOR_VERSION} ${REQUIRED_QT_VERSION} CONFIG REQUIRED Test)

include(ECMMarkAsTest)

macro(ksane_tests)
  foreach(_testname ${ARGN})
    add_executable(${_testname} ${_testname}.cpp)
    target_link_libraries(${_testname} Qt${QT_MAJOR_VERSION}::Test KSane::Core)
    add_test(ksanecore-${_testname} ${_testname})
    ecm_mark_as_test(${_testname})
  endforeach(_testname)
endmacro()
07070100000010000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003B00000000ksanecore-VERSIONgit.20240404T022814~46f9196/cmake-modules07070100000011000081A4000000000000000000000001660E103E0000033B000000000000000000000000000000000000004A00000000ksanecore-VERSIONgit.20240404T022814~46f9196/cmake-modules/FindSane.cmake# cmake macro to test if we use sane
#
#  SANE_FOUND - system has SANE libs
#  SANE_INCLUDE_DIR - the SANE include directory
#  SANE_LIBRARIES - The libraries needed to use SANE

# SPDX-FileCopyrightText: 2006 Marcus Hufgard <hufgardm@hufgard.de>
#
# SPDX-License-Identifier: BSD-3-Clause

FIND_PATH(SANE_INCLUDE_DIR sane/sane.h)

FIND_LIBRARY(SANE_LIBRARY NAMES sane libsane
   PATH_SUFFIXES sane
)

INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Sane  DEFAULT_MSG  SANE_LIBRARY SANE_INCLUDE_DIR )

MARK_AS_ADVANCED(SANE_INCLUDE_DIR SANE_LIBRARY)

if(Sane_FOUND AND NOT TARGET Sane::Sane)
    add_library(Sane::Sane UNKNOWN IMPORTED)
    set_target_properties(Sane::Sane PROPERTIES
        IMPORTED_LOCATION "${SANE_LIBRARY}"
        INTERFACE_INCLUDE_DIRECTORIES "${SANE_INCLUDE_DIR}"
    )
endif()
07070100000012000081A4000000000000000000000001660E103E00000164000000000000000000000000000000000000003B00000000ksanecore-VERSIONgit.20240404T022814~46f9196/metainfo.yaml# SPDX-FileCopyrightText: none
#
# SPDX-License-Identifier: CC0-1.0

description: Qt interface for the SANE library for scanner hardware
type: functional
public_lib: true
platforms:
 - name: Linux
 - name: FreeBSD
 #- name: Windows
 #- name: MacOSX
 #- name: Android
release: false
libraries:
 - cmake: "KSane::Core"
cmakename: KSaneCore
07070100000013000041ED000000000000000000000023660E103E00000000000000000000000000000000000000000000003000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po07070100000014000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ar07070100000015000081A4000000000000000000000001660E103E000008FA000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ar/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Zayed Al-Saidi <zayed.alsaidi@gmail.com>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-02-07 09:20+0400\n"
"Last-Translator: Zayed Al-Saidi <zayed.alsaidi@gmail.com>\n"
"Language-Team: ar\n"
"Language: ar\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=6; plural=n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 "
"&& n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5;\n"
"X-Generator: Lokalize 21.07.70\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "أوقف المسح بواسط مستخدم."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "مهلة نمط الدفعات"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "حدد المهلة الزمنية بين كل عملية مسح عند تمكين وضع الدُفعات."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "نمط الدفعات مع مهلة"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr "تمكن من المسح في وضع الدُفعات. يواصل المسح بعد مهلة حتى يتم إلغاؤه."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "اعكس الألوان"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "اعكس ألوان الصورة الممسوحة."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "بالعرض %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "امسح حجم المنطقة"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "حدد حجم صفحة محدد مسبقًا لمنطقة المسح."
07070100000016000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/bg07070100000017000081A4000000000000000000000001660E103E00000ADE000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/bg/ksanecore.po# Bulgarian translations for ksanecore package.
# Copyright (C) 2022 This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Automatically generated, 2022.
# Mincho Kondarev <mkondarev@yahoo.de>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-07-18 22:47+0200\n"
"Last-Translator: Mincho Kondarev <mkondarev@yahoo.de>\n"
"Language-Team: Bulgarian <kde-i18n-doc@kde.org>\n"
"Language: bg\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 22.04.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Сканирането е спряно от потребителя."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Интервал на сканиране в режим пакетна обработка"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Задава забавяне на времето между командите за сканиране в режим пакетна "
"обработка"

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Режим на пакетна обработка с интервал на сканиране"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Активира режим на изпълнение на пакетни команди. Продължава сканирането през "
"определен интервал от време до отмяната му."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Инвертиране на цветовете"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Инвертиране на  цветове на сканираното изображение."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Пейзаж %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Размер за областта за сканиране"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr ""
"Изберете предварително определен размер на страницата за сканираната област."
07070100000018000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ca07070100000019000081A4000000000000000000000001660E103E00002DB8000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ca/ksanecore.po# Translation of ksanecore.po to Catalan
# Copyright (C) 2008-2021 This_file_is_part_of_KDE
# This file is distributed under the license LGPL version 2.1 or
# version 3 or later versions approved by the membership of KDE e.V.
#
# Josep M. Ferrer <txemaq@gmail.com>, 2008, 2009, 2010, 2011, 2012, 2015, 2018, 2020, 2021.
# Antoni Bella Pérez <antonibella5@yahoo.com>, 2015, 2016, 2020.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2021-11-07 11:43+0100\n"
"Last-Translator: Josep M. Ferrer <txemaq@gmail.com>\n"
"Language-Team: Catalan <kde-i18n-ca@kde.org>\n"
"Language: ca\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Accelerator-Marker: &\n"
"X-Generator: Lokalize 20.12.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "L'usuari ha aturat l'escaneig."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Temps de retard en el mode de treball per lots"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Especifiqueu el temps de retard entre cada escaneig quan el mode de treball "
"per lots és actiu."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Mode de treball per lots amb temps de retard"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Activa l'escaneig en el mode de treball per lots. L'escaneig continua "
"després d'un retard fins que es cancel·la."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Inverteix els colors"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Inverteix els colors de la imatge escanejada."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Apaïsada %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Mida de l'àrea d'escaneig"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Selecciona una mida de pàgina predefinida per a l'àrea d'escaneig."

#~ msgid "Open scan dialog"
#~ msgstr "Obre el diàleg d'escaneig"

#~ msgid "None"
#~ msgstr "Cap"

#~ msgid "MH"
#~ msgstr "MH"

#~ msgid "MR"
#~ msgstr "MR"

#~ msgid "MMR"
#~ msgstr "MMR"

#~ msgid "JPEG"
#~ msgstr "JPEG"

#~ msgid "Auto"
#~ msgstr "Auto"

#~ msgid "Flatbed"
#~ msgstr "De superfície plana"

#~ msgid "ADF"
#~ msgstr "ADF"

#~ msgid "Advanced"
#~ msgstr "Avançat"

#~ msgid "Compression"
#~ msgstr "Compressió"

#~ msgid ""
#~ "Selects the scanner compression method for faster scans, possibly at the "
#~ "expense of image quality."
#~ msgstr ""
#~ "Selecciona el mètode de compressió per a accelerar els escaneigs, "
#~ "possiblement a expenses de la qualitat de la imatge."

#~ msgid "JPEG compression factor"
#~ msgstr "Factor de compressió del JPEG"

#~ msgid ""
#~ "Sets the scanner JPEG compression factor. Larger numbers mean better "
#~ "compression, and smaller numbers mean better image quality."
#~ msgstr ""
#~ "Defineix el factor de compressió del JPEG de l'escàner. Els números més "
#~ "grans indiquen una compressió millor, els números més petits indiquen una "
#~ "millor qualitat de la imatge."

#~ msgid "Batch scan"
#~ msgstr "Escaneig per lots"

#~ msgid "Enables continuous scanning with automatic document feeder (ADF)."
#~ msgstr ""
#~ "Habilita l'escaneig continu amb un alimentador automàtic de documents "
#~ "(ADF, en anglès)."

#~ msgid "Duplex"
#~ msgstr "Doble cara"

#~ msgid "Enables scanning on both sides of the page."
#~ msgstr "Habilita l'escaneig de les dues cares de la pàgina."

#~ msgid "Geometry"
#~ msgstr "Geometria"

#~ msgid "Length measurement"
#~ msgstr "Mesura de la longitud"

#~ msgid ""
#~ "Selects how the scanned image length is measured and reported, which is "
#~ "impossible to know in advance for scrollfed scans."
#~ msgstr ""
#~ "Selecciona com s'ha de mesurar i informar la longitud de la imatge "
#~ "escanejada, la qual és impossible de conèixer per avançat en els escàners "
#~ "d'alimentació per desplaçament."

#~ msgid "Unknown"
#~ msgstr "Desconegut"

#~ msgid "Unlimited"
#~ msgstr "Sense límit"

#~ msgid "Approximate"
#~ msgstr "Aproximat"

#~ msgid "Padded"
#~ msgstr "Per farciment"

#~ msgid "Exact"
#~ msgstr "Exacte"

#~ msgid "???"
#~ msgstr "???"

#~ msgid ""
#~ "<html>The SANE (Scanner Access Now Easy) system could not find any device."
#~ " Check that the scanner is plugged in and turned on or check your "
#~ "systems scanner setup. For details about SANE see the <a href='http://"
#~ "www.sane-project.org/'>SANE homepage</a>.</html>"
#~ msgstr ""
#~ "<html>El sistema de SANE (Scanner Access Now Easy) no ha pogut trobar cap "
#~ "dispositiu. Verifiqueu que l'escàner estigui connectat i encès o "
#~ "verifiqueu la configuració de l'escàner en el sistema. Per als detalls "
#~ "quant al SANE, vegeu la <a href='http://www.sane-project.org/'>pàgina web "
#~ "de SANE</a>.</html>"

#~ msgid "Reload devices list"
#~ msgstr "Actualitza la llista de dispositius"

#~ msgid "Looking for devices. Please wait."
#~ msgstr "S'estan cercant dispositius. Espereu, si us plau."

#~ msgid "Sorry. No devices found."
#~ msgstr "No s'ha trobat cap dispositiu."

#~ msgid "Found devices:"
#~ msgstr "Dispositius trobats:"

#~ msgid "Zoom In"
#~ msgstr "Apropa"

#~ msgid "Zoom Out"
#~ msgstr "Allunya"

#~ msgid "Zoom to Selection"
#~ msgstr "Zoom a la selecció"

#~ msgid "Zoom to Fit"
#~ msgstr "Zoom fins que ajusti"

#~ msgid "Clear Selections"
#~ msgstr "Neteja les seleccions"

#~ msgid "Waiting for the scan to start."
#~ msgstr "S'està esperant que s'iniciï l'escaneig."

#~ msgid "Cancel current scan operation"
#~ msgstr "Cancel·la l'operació actual d'escaneig"

#~ msgid "Scan Preview Image (%1)"
#~ msgstr "Escaneja una vista prèvia de la imatge (%1)"

#~ msgctxt "Preview button text"
#~ msgid "Preview"
#~ msgstr "Vista prèvia"

#~ msgid "Scan Final Image (%1)"
#~ msgstr "Escaneja la imatge final (%1)"

#~ msgctxt "Final scan button text"
#~ msgid "Scan"
#~ msgstr "Escaneja"

#~ msgid "Basic Options"
#~ msgstr "Opcions bàsiques"

#~ msgid "Advanced Options"
#~ msgstr "Opcions avançades"

#~ msgid "Scanner Specific Options"
#~ msgstr "Opcions específiques de l'escàner"

#~ msgid "Authentication required for resource: %1"
#~ msgstr "Es requereix autenticació per al recurs: %1"

#~ msgid ""
#~ "The image data contained 16 bits per color, but the color depth has been "
#~ "truncated to 8 bits per color."
#~ msgstr ""
#~ "Les dades de la imatge tenien 16 bits per color, però la profunditat de "
#~ "color s'ha truncat a 8 bits per color."

#~ msgid "Scan Area Size"
#~ msgstr "Mida de l'àrea d'escaneig"

#~ msgid " mm"
#~ msgstr " mm"

#~ msgid " inch"
#~ msgstr " polzada"

#~ msgid "Width"
#~ msgstr "Amplada"

#~ msgid "Height"
#~ msgstr "Alçada"

#~ msgid "X Offset"
#~ msgstr "Desplaçament X"

#~ msgid "Y Offset"
#~ msgstr "Desplaçament Y"

#~ msgid "Image intensity"
#~ msgstr "Intensitat de la imatge"

#~ msgid ""
#~ "Gamma-correction table. In color mode this option equally affects the "
#~ "red, green, and blue channels simultaneously (i.e., it is an intensity "
#~ "gamma table)."
#~ msgstr ""
#~ "Taula de la correcció gamma. En el mode de color aquesta opció afecta "
#~ "igualment els canals vermell, verd i blau simultàniament (és a dir, és "
#~ "una taula d'intensitat de la gamma)."

#~ msgid "Separate color intensity tables"
#~ msgstr "Separa les taules d'intensitat del color"

#~ msgctxt "This is compared to the option string returned by sane"
#~ msgid "Transparency"
#~ msgstr "Transparència"

#~ msgctxt "This is compared to the option string returned by sane"
#~ msgid "Negative"
#~ msgstr "Negatiu"

#~ msgid "Next scan starts in %1 s."
#~ msgstr "L'escaneig següent comença dintre de %1 s."

#~ msgctxt "@title:window"
#~ msgid "General Error"
#~ msgstr "Error general"

#~ msgctxt "@title:window"
#~ msgid "Information"
#~ msgstr "Informació"

#~ msgid "Custom"
#~ msgstr "Personalitzat"

#~ msgctxt "Page size landscape"
#~ msgid " Landscape"
#~ msgstr " Apaïsat"

#~ msgctxt "Label for a scanner option"
#~ msgid "%1:"
#~ msgstr "%1:"

#~ msgctxt "Parameter and Unit"
#~ msgid "%1 Pixel"
#~ msgid_plural "%1 Pixels"
#~ msgstr[0] "%1 píxel"
#~ msgstr[1] "%1 píxels"

#~ msgctxt "Parameter and Unit"
#~ msgid "%1 Bit"
#~ msgid_plural "%1 Bits"
#~ msgstr[0] "%1 bit"
#~ msgstr[1] "%1 bits"

#~ msgctxt "Parameter and Unit (Millimeter)"
#~ msgid "%1 mm"
#~ msgstr "%1 mm"

#~ msgctxt "Parameter and Unit (Dots Per Inch)"
#~ msgid "%1 DPI"
#~ msgstr "%1 PPP"

#~ msgctxt "Parameter and Unit (Percentage)"
#~ msgid "%1 %"
#~ msgstr "%1%"

#~ msgctxt "Parameter and Unit (Microseconds)"
#~ msgid "%1 µs"
#~ msgstr "%1 µs"

#~ msgctxt "Parameter and Unit (seconds)"
#~ msgid "%1 s"
#~ msgstr "%1 s"

#~ msgid "%1"
#~ msgstr "%1"

#~ msgctxt "Label for button to reset text in a KLineEdit"
#~ msgid "Reset"
#~ msgstr "Reinicialitza"

#~ msgctxt "Label for button to write text in a KLineEdit to sane"
#~ msgid "Set"
#~ msgstr "Defineix"

#~ msgctxt "Double numbers. SpinBox parameter unit"
#~ msgid " Pixels"
#~ msgstr " píxels"

#~ msgctxt "Double numbers. SpinBox parameter unit"
#~ msgid " Bits"
#~ msgstr " bits"

#~ msgctxt "Double numbers. SpinBox parameter unit (Millimeter)"
#~ msgid " mm"
#~ msgstr " mm"

#~ msgctxt "Double numbers. SpinBox parameter unit (Dots Per Inch)"
#~ msgid " DPI"
#~ msgstr " PPP"

#~ msgctxt "Double numbers. SpinBox parameter unit (Percentage)"
#~ msgid " %"
#~ msgstr " %"

#~ msgctxt "Double numbers. SpinBox parameter unit (Microseconds)"
#~ msgid " µs"
#~ msgstr " µs"

#~ msgctxt "SpinBox parameter unit (seconds), float"
#~ msgid " s"
#~ msgstr " s"

#~ msgid "Brightness"
#~ msgstr "Lluminositat"

#~ msgid "Contrast"
#~ msgstr "Contrast"

#~ msgid "Gamma"
#~ msgstr "Gamma"

#~ msgctxt "SpinBox parameter unit"
#~ msgid " Pixel"
#~ msgid_plural " Pixels"
#~ msgstr[0] " píxel"
#~ msgstr[1] " píxels"

#~ msgctxt "SpinBox parameter unit"
#~ msgid " Bit"
#~ msgid_plural " Bits"
#~ msgstr[0] " bit"
#~ msgstr[1] " bits"

#~ msgctxt "SpinBox parameter unit (Millimeter)"
#~ msgid " mm"
#~ msgid_plural " mm"
#~ msgstr[0] " mm"
#~ msgstr[1] " mm"

#~ msgctxt "SpinBox parameter unit (Dots Per Inch)"
#~ msgid " DPI"
#~ msgid_plural " DPI"
#~ msgstr[0] " PPP"
#~ msgstr[1] " PPP"

#~ msgctxt "SpinBox parameter unit (Percentage)"
#~ msgid " %"
#~ msgid_plural " %"
#~ msgstr[0] " %"
#~ msgstr[1] " %"

#~ msgctxt "SpinBox parameter unit (Microseconds)"
#~ msgid " µs"
#~ msgid_plural " µs"
#~ msgstr[0] " µs"
#~ msgstr[1] " µs"

#~ msgctxt "SpinBox parameter unit (seconds)"
#~ msgid " s"
#~ msgid_plural " s"
#~ msgstr[0] " s"
#~ msgstr[1] " s"

#~ msgid "%1 Pixel"
#~ msgid_plural "%1 Pixels"
#~ msgstr[0] "%1 píxel"
#~ msgstr[1] "%1 píxels"

#~ msgid "%1 Bit"
#~ msgid_plural "%1 Bits"
#~ msgstr[0] "%1 bit"
#~ msgstr[1] "%1 bits"

#~ msgid "%1 mm"
#~ msgid_plural "%1 mm"
#~ msgstr[0] "%1 mm"
#~ msgstr[1] "%1 mm"

#~ msgid "%1 DPI"
#~ msgid_plural "%1 DPI"
#~ msgstr[0] "%1 PPP"
#~ msgstr[1] "%1 PPP"

#~ msgid "%1 %"
#~ msgid_plural "%1 %"
#~ msgstr[0] "%1 %"
#~ msgstr[1] "%1 %"

#~ msgid "%1 µs"
#~ msgid_plural "%1 µs"
#~ msgstr[0] "%1 µs"
#~ msgstr[1] "%1 µs"
0707010000001A000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003C00000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ca@valencia0707010000001B000081A4000000000000000000000001660E103E000009B0000000000000000000000000000000000000004900000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ca@valencia/ksanecore.po# Translation of ksanecore.po to Catalan (Valencian)
# Copyright (C) 2008-2021 This_file_is_part_of_KDE
# This file is distributed under the license LGPL version 2.1 or
# version 3 or later versions approved by the membership of KDE e.V.
#
# Josep M. Ferrer <txemaq@gmail.com>, 2008, 2009, 2010, 2011, 2012, 2015, 2018, 2020, 2021.
# Antoni Bella Pérez <antonibella5@yahoo.com>, 2015, 2016, 2020.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2021-11-07 11:43+0100\n"
"Last-Translator: Josep M. Ferrer <txemaq@gmail.com>\n"
"Language-Team: Catalan <kde-i18n-ca@kde.org>\n"
"Language: ca@valencia\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Accelerator-Marker: &\n"
"X-Generator: Lokalize 20.12.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "L'usuari ha parat l'escaneig."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Temps de retard en el mode de treball per lots"

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Mode de treball per lots amb temps de retard"

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Invertix els colors"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Invertix els colors de la imatge escanejada."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Apaïsada %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Mida de l'àrea d'escaneig"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Selecciona una mida de pàgina predefinida per a l'àrea d'escaneig."
0707010000001C000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/cs0707010000001D000081A4000000000000000000000001660E103E00000775000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/cs/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Vit Pelcak <vit@pelcak.org>, 2022.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-11 19:19+0100\n"
"Last-Translator: Vit Pelcak <vpelcak@suse.cz>\n"
"Language-Team: Czech <kde-i18n-doc@kde.org>\n"
"Language: cs\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;\n"
"X-Generator: Lokalize 21.12.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Skenování zastaveno uživatelem"

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr ""

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr ""

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Invertovat barvy"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Invertovat barvy skenovaného obrázku."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Na šířku %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Velikost oblasti skenování"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Vyberte předurčenou velikost stránky pro oblast skenování."
0707010000001E000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/de0707010000001F000081A4000000000000000000000001660E103E000007D0000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/de/ksanecore.po# German translations for ksanecore package.
# Copyright (C) 2022 This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Frederik Schwarzer <schwarzer@kde.org>, 2022, 2023.
#
# Automatically generated, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2023-03-24 19:43+0100\n"
"Last-Translator: Frederik Schwarzer <schwarzer@kde.org>\n"
"Language-Team: German <kde-i18n-de@kde.org>\n"
"Language: de\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Generator: Lokalize 22.12.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Der Scan wurde durch den Benutzer abgebrochen."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr ""

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr ""

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Farben umkehren"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Die Farben des gescannten Bildes umkehren."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Querformat %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Größe des Scanbereichs"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Wählen Sie eine vordefinierte Seitengröße für den Scanbereich."
07070100000020000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003600000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/en_GB07070100000021000081A4000000000000000000000001660E103E00000825000000000000000000000000000000000000004300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/en_GB/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Steve Allewell <steve.allewell@gmail.com>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-01 15:41+0000\n"
"Last-Translator: Steve Allewell <steve.allewell@gmail.com>\n"
"Language-Team: British English <kde-l10n-en_gb@kde.org>\n"
"Language: en_GB\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 21.12.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Scanning stopped by user."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Batch mode time delay"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "Specify the time delay between each scan when batch mode is enabled."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Batch mode with time delay"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Enables batch mode scanning. Continues scanning after a delay until "
"cancelled."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Invert colours"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Invert the colours of the scanned image."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Landscape %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Scan area size"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Select a predefined page size for the scanning area."
07070100000022000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/eo07070100000023000081A4000000000000000000000001660E103E000008A8000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/eo/ksanecore.po# translation of ksanecore.pot to esperanto
# Copyright (C) 2023 Free Software Foundation, Inc.
# This file is distributed under the same license as the ksanecore package.
# Oliver Kellogg <okellogg@users.sourceforge.net, 2023.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2023-07-29 12:25+0100\n"
"Last-Translator: Oliver Kellogg <okellogg@users.sourceforge.net>\n"
"Language-Team: Esperanto <kde-i18n-eo@kde.org>\n"
"Language: eo\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: translate-po (https://github.com/zcribe/translate-po)\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Skanado ĉesis de uzanto."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Batch-reĝimo tempoprokrasto"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Indiku la tempoprokraston inter ĉiu skanado kiam stapla reĝimo estas "
"ebligita."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Stapla reĝimo kun tempoprokrasto"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Ebligas staploreĝiman skanadon. Daŭrigas skanadon post prokrasto ĝis nuligo."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Inverti kolorojn"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Inversigi la kolorojn de la skanita bildo."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Pejzaĝo %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Grandeco de skana areo"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Elektu antaŭdifinitan paĝgrandecon por la skana areo."
07070100000024000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/es07070100000025000081A4000000000000000000000001660E103E000008BC000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/es/ksanecore.po# Spanish translations for ksanecore.po package.
# Copyright (C) 2022 This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Automatically generated, 2022.
# Eloy Cuadra <ecuadra@eloihr.net>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-03 00:51+0100\n"
"Last-Translator: Eloy Cuadra <ecuadra@eloihr.net>\n"
"Language-Team: Spanish <kde-l10n-es@kde.org>\n"
"Language: es\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 21.12.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Escaneo detenido por el usuario."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Demora para el modo por lotes"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Indique el tiempo de demora entre cada escaneo cuando se activa el modo por "
"lotes."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Modo por lotes con tiempo de demora"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Activa el escaneo en el modo por lotes. Continúa escaneando tras una demora "
"hasta que se cancele."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Invertir colores"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Invertir los colores de la imagen escaneada."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Apaisado %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Tamaño del área de escaneo"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Seleccione un tamaño de página predefinido para el área a escanear."
07070100000026000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/eu07070100000027000081A4000000000000000000000001660E103E00000901000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/eu/ksanecore.po# Translation for ksanecore.po to Euskara/Basque (eu).
# Copyright (C) 2022, This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# KDE euskaratzeko proiektuko arduraduna <xalba@ni.eus>.
#
# Translators:
# Iñigo Salvador Azurmendi <xalba@ni.eus>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-07-30 23:20+0200\n"
"Last-Translator: Iñigo Salvador Azurmendi <xalba@ni.eus>\n"
"Language-Team: Basque <kde-i18n-eu@kde.org>\n"
"Language: eu\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Generator: Lokalize 22.04.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Erabiltzaileak eskaneatzea gelditu du."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Sortaka moduko atzerapen-denbora"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "Adierazi eskaneatze arteko atzerapena sortaka modua gaituta dagoenean."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Sortaka modua atzerapenarekin"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Sortaka eskaneatzeko modua gaitzen du. Atzerapen baten ondoren eskaneatzen "
"jarraitzen du bertan behera utzi arte."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Alderantzikatu koloreak"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Alderantzikatu eskaneatutako irudiaren koloreak."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Paisaia %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Eskaneatze eremuaren tamaina"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Hautatu eskaneatze-eremurako aurrez definitutako orri-tamaina bat."
07070100000028000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/fi07070100000029000081A4000000000000000000000001660E103E00000812000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/fi/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Tommi Nieminen <translator@legisign.org>, 2022.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-06-05 19:39+0300\n"
"Last-Translator: Tommi Nieminen <translator@legisign.org>\n"
"Language-Team: Finnish <kde-i18n-doc@kde.org>\n"
"Language: fi\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Generator: Lokalize 21.12.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Käyttäjä lopetti kuvanluvun."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Eräajon aikaviive"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "Aseta kuvanlukujen välinen aikaviive käytettäessä eräajoa."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Eräajo aikaviipeellä"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Mahdollistaa eräajoluvun. Jatkaa lukemista aina aikaviipeellä, kunnes "
"perutaan."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Käännä värit"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Käännä luetun kuvan värit."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Vaaka-%1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Tutkittavan alueen koko"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Aseta tutkittavaksi alueeksi esiasetettu paperikoko."
0707010000002A000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/fr0707010000002B000081A4000000000000000000000001660E103E00000842000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/fr/ksanecore.po# Xavier Besnard <xavier.besnard@kde.org>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-02 10:43+0100\n"
"Last-Translator: Xavier Besnard <xavier.besnard@neuf.fr>\n"
"Language-Team: French <kde-francophone@kde.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Lokalize 21.12.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Numérisation arrêtée par l'utilisateur."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Délai pour le mode de numérisation par lots"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Spécifier le délai entre chaque numérisation quand le mode par lots est "
"activé."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Mode de numérisation par lots avec délai"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Active la numérisation avec le mode par lots. Poursuit la numérisation après "
"un délai, sauf si annulé."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Inverser les couleurs"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Inverser les couleurs de l'image numérisée."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Paysage %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Taille de la zone de numérisation"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr ""
"Sélectionner une taille prédéfinie de taille pour la zone de numérisation."
0707010000002C000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/gl0707010000002D000081A4000000000000000000000001660E103E000008AA000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/gl/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Adrián Chaves (Gallaecio) <adrian@chaves.io>, 2023.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2023-04-30 09:37+0200\n"
"Last-Translator: Adrián Chaves (Gallaecio) <adrian@chaves.io>\n"
"Language-Team: Galician <proxecto@trasno.gal>\n"
"Language: gl\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 23.04.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "A persoa usuaria detivo a dixitalización."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Tempo de repouso do modo en lote"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Indica o tempo de repouso entre cada dixitalización cando se activa o modo "
"en lote."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Modo en lote con tempo de repouso"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Activa a dixitalización en modo en lote. Continúa dixitalizando tras un "
"tempo de repouso ata que se cancela."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Inverter as cores"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Inverter as cores da imaxe dixitalizada."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Apaisado %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Tamaño da zona de dixitalización"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr ""
"Seleccione un tamaño de páxina predefinido para a zona de dixitalización."
0707010000002E000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/hi0707010000002F000081A4000000000000000000000001660E103E00000A98000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/hi/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Raghavendra Kamath <raghu@raghukamath.com>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-15 20:12+0530\n"
"Last-Translator: Raghavendra Kamath <raghu@raghukamath.com>\n"
"Language-Team: Hindi <kde-l10n-hi@kde.org>\n"
"Language: hi\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n!=1);\n"
"X-Generator: Lokalize 21.04.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "उपयोक्ता द्वारा स्कैन करना बंद कर दिया गया है।"

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "बैच मोड समय विलंब"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "बैच मोड सक्षम होने पर प्रत्येक स्कैन के बीच का समय विलंब निर्दिष्ट करें।"

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "समय विलंब के साथ बैच मोड"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr "बैच मोड स्कैनिंग सक्षम करता है। रद्द होने तक विलंब के बाद स्कैन करना जारी रखता है।"

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "रंग उलटें"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "स्कैन की गई छवि के रंगों को उलट दें।"

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "आड़ा %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "स्कैन क्षेत्र का आकार"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "स्कैनिंग क्षेत्र के लिए एक पूर्वनिर्धारित पृष्ठ आकार का चयन करें।"
07070100000030000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/it07070100000031000081A4000000000000000000000001660E103E000008A4000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/it/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Luigi Toscano <luigi.toscano@tiscali.it>, 2022.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-02 01:34+0100\n"
"Last-Translator: Luigi Toscano <luigi.toscano@tiscali.it>\n"
"Language-Team: Italian <kde-i18n-it@kde.org>\n"
"Language: it\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Generator: Lokalize 21.08.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Scansione interrotta dall'utente."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Ritardo modalità non interattiva"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Specifica il ritardo tra scansioni quando è attiva la modalità non "
"interattiva."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Modalità non interattiva con ritardo"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Abilita la scansione in modalità non interattiva. Continua la scansione dopo "
"un certo intervallo finché non viene annullata."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Inverti i colori"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Inverti i colori dell'immagine scansionata."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "%1 orizzontale"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Dimensione area di scansione"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr ""
"Seleziona una dimensione di pagina predefinita per l'area di scansione."
07070100000032000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ja07070100000033000081A4000000000000000000000001660E103E0000083D000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ja/ksanecore.po# SPDX-FileCopyrightText: 2024 Tarot Osuji <tarot@sdf.org>
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2024-01-14 08:08+0900\n"
"Last-Translator: Tarot Osuji <tarot@sdf.org>\n"
"Language-Team: Japanese <kde-jp@kde.org>\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Accelerator-Marker: &\n"
"X-Text-Markup: kde4\n"
"X-Generator: Lokalize 23.08.4\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "ユーザによりスキャンが停止しました。"

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "バッチモードの遅延時間"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "バッチモード時の各スキャン間の遅延時間を指定します。"

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "バッチモード"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"バッチモードでスキャンします。キャンセルされるまで遅延後にスキャンを続けま"
"す。"

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "色を反転"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "スキャンした画像の色を反転します。"

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "横長 %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "スキャン領域のサイズ"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "スキャン領域の定義済みページサイズを選択します。"
07070100000034000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ka07070100000035000081A4000000000000000000000001660E103E00000B6F000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ka/ksanecore.po# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-05-16 14:13+0200\n"
"Last-Translator: Temuri Doghonadze <temuri.doghonadze@gmail.com>\n"
"Language-Team: Georgian <kde-i18n-doc@kde.org>\n"
"Language: ka\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Generator: Poedit 3.0.1\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "სკანირება შეწყვეტილია მომხმარებლის მიერ."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "მიმდევრობითი რეჟიმის დაყოვნების დრო"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "მიუთითეთ მიმდევრობით რეჟიმში სკანირებებს შორის დაყოვნების დრო."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "მიმდევრობითი რეჟიმი დაყოვნების მხარდაჭერით"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"მიმდევრობით სკანირების რეჟიმის ჩართვა. სკანირება დაყოვნების შემდეგ იქამდე "
"გაგრძელდება, სანამ ხელით არ შეაჩერებთ."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "ფერების ინვერსია"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "სკანირებული გამოსახულების ფერების ინვერსია."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "ლანდშაფტი %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "სკანირების ფართობის ზომა"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "აირჩიეთ სკანირების ფართობის გვერდის ზომა."
07070100000036000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ko07070100000037000081A4000000000000000000000001660E103E0000086E000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ko/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Shinjo Park <kde@peremen.name>, 2022.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-02-20 22:55+0100\n"
"Last-Translator: Shinjo Park <kde@peremen.name>\n"
"Language-Team: Korean <kde-kr@kde.org>\n"
"Language: ko\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Lokalize 21.08.1\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "사용자가 스캔을 중단했습니다."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "일괄 작업 모드 시간 지연"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "일괄 작업 모드에서 각각 스캔별 지연 시간을 설정합니다."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "시간 지연이 있는 일괄 작업 모드"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"일괄 작업 스캔 모드를 활성화합니다. 취소하기 전까지 일정 시간 대기한 후 스캔"
"을 계속합니다."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "색 반전"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "스캔된 이미지의 색상을 반전합니다."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "가로 %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "스캔 영역 크기"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "사전 정의된 스캔 영역 크기를 선택합니다."
07070100000038000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/lt07070100000039000081A4000000000000000000000001660E103E000006E1000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/lt/ksanecore.po# Lithuanian translations for ksanecore package.
# Copyright (C) 2023 This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Automatically generated, 2023.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2023-02-01 00:55+0000\n"
"Last-Translator: Automatically generated\n"
"Language-Team: none\n"
"Language: lt\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : n%10>=2 && (n%100<10 || n"
"%100>=20) ? 1 : n%10==0 || (n%100>10 && n%100<20) ? 2 : 3);\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr ""

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr ""

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr ""

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr ""

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr ""

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr ""

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr ""

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr ""
0707010000003A000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/nl0707010000003B000081A4000000000000000000000001660E103E00000844000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/nl/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Freek de Kruijf <freekdekruijf@kde.nl>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-01 12:37+0100\n"
"Last-Translator: Freek de Kruijf <freekdekruijf@kde.nl>\n"
"Language-Team: \n"
"Language: nl\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 21.12.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Scannen is gestopt door gebruiker."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Tijdsvertraging van modus bulk"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"De tijdsvertraging specificeren tussen elke scan wanneer modus bulk is "
"ingeschakeld."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Modus bulk met tijdsvertraging"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Schakelt scannen in modus bulk in. Gaat door met scannen na een vertraging "
"tot annuleren."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Kleuren omkeren"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "De kleuren omkeren van de gescande afbeelding."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Landschap %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Scangebiedgrootte"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Een voorgedefinieerde paginagrootte selecteren voor het scangebied."
0707010000003C000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/nn0707010000003D000081A4000000000000000000000001660E103E0000084B000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/nn/ksanecore.po# Translation of ksanecore to Norwegian Nynorsk
#
# Karl Ove Hufthammer <karl@huftis.org>, 2023.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2023-03-20 19:54+0100\n"
"Last-Translator: Karl Ove Hufthammer <karl@huftis.org>\n"
"Language-Team: Norwegian Nynorsk <l10n-no@lister.huftis.org>\n"
"Language: nn\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 22.12.3\n"
"X-Environment: kde\n"
"X-Accelerator-Marker: &\n"
"X-Text-Markup: kde4\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Skanning avbroten av brukaren."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Pausetid ved fleirskanning"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "Vel lengda på pausen mellom kvar skanning i fleirskanningsmodus."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Fleirskanningsmodus med pausar"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Slår på fleirskanningsmodus. Skannar til han vert avbroten, med med ein "
"pause mellom kvar innskanning."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Omvende fargar"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Snu fargane på det innskanna biletet."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Liggjande %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Storleik på skanneområde"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Vel ein ferdig sidestorleik for skanneområdet."
0707010000003E000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/pl0707010000003F000081A4000000000000000000000001660E103E000008B0000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/pl/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-27 19:35+0100\n"
"Last-Translator: Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>\n"
"Language-Team: Polish <kde-i18n-doc@kde.org>\n"
"Language: pl\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 "
"|| n%100>=20) ? 1 : 2);\n"
"X-Generator: Lokalize 22.03.70\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Skanowanie zatrzymane przez użytkownika."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Opóźnienie trybu wsadowego"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "Określ opóźnienie czasowe pomiędzy każdym skanem w trybie wsadowym."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Tryb wsadowy z opóźnieniem czasowym"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Włącza tryb skanowania wsadowego. Kontynuuje skanowanie po opóźnieniu aż do "
"odwołania."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Odwróć barwy"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Odwróć barwy na zeskanowanym obrazie."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "W poziomie %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Rozmiar obszaru skanowania"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Wybierz jeden z rozmiarów strony dla obszaru skanowania."
07070100000040000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/pt07070100000041000081A4000000000000000000000001660E103E000008A7000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/pt/ksanecore.po# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-03-23 17:48+0000\n"
"Last-Translator: José Nuno Coelho Pires <zepires@gmail.com>\n"
"Language-Team: Portuguese <kde-i18n-pt@kde.org>\n"
"Language: pt\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "A digitalização foi interrompida pelo utilizador."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Atraso de tempo no modo em lote"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Defina o atraso de tempo entre cada digitalização quando o modo em lote está "
"activo."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Modo em lote com atraso de tempo"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Activa a digitalização num modo em lote. Continua a digitalizar ao fim de "
"algum tempo, até que cancele a operação."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Inverter as cores"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Inverter as cores da imagem digitalizada."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Paisagem %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Tamanho da área de digitalização"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr ""
"Seleccione um tamanho de página predefinido para a área de digitalização."
07070100000042000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003600000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/pt_BR07070100000043000081A4000000000000000000000001660E103E000008A4000000000000000000000000000000000000004300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/pt_BR/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Luiz Fernando Ranghetti <elchevive@opensuse.org>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-07-13 14:58-0300\n"
"Last-Translator: Luiz Fernando Ranghetti <elchevive@opensuse.org>\n"
"Language-Team: Portuguese <kde-i18n-pt_BR@kde.org>\n"
"Language: pt_BR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Lokalize 21.12.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Digitalização parada pelo usuário."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Atraso do modo em lote"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Especifique o atraso entre cada digitalização quando o modo em lote estiver "
"habilitado."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Modo em lote com atraso de tempo"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Habilita a digitalização em lote. Continua a digitalização após um atraso "
"até ser cancelado."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Inverter cores"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Inverter as cores da imagem digitalizada."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Paisagem %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Tamanho da área de digitalização"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr ""
"Selecionar um tamanho de página pré-definido para a área de digitalização."
07070100000044000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ro07070100000045000081A4000000000000000000000001660E103E0000087F000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ro/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Sergiu Bivol <sergiu@cip.md>, 2022, 2024.
#
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2024-02-24 14:48+0000\n"
"Last-Translator: Sergiu Bivol <sergiu@cip.md>\n"
"Language-Team: Romanian <kde-i18n-ro@kde.org>\n"
"Language: ro\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=n==1 ? 0 : (n==0 || (n%100 > 0 && n%100 < "
"20)) ? 1 : 2;\n"
"X-Generator: Lokalize 21.12.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Scanare oprită de utilizator."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Întârziere pentru scanarea în serie"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Specifică intervalul între fiecare scanare când e activ regimul în serie."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Scanare în serie cu întârziere"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Activează scanarea în serie. Continuă să scaneze după o pauză, până e oprit."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Inversează culorile"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Inversează culorile imaginii scanate."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Peisaj %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Dimensiunea zonei scanate"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Alegeți o dimensiune de pagină predefinită pentru zona scanării."
07070100000046000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ru07070100000047000081A4000000000000000000000001660E103E00000AD4000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/ru/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Olesya Gerasimenko <translation-team@basealt.ru>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-10-03 12:17+0300\n"
"Last-Translator: Olesya Gerasimenko <translation-team@basealt.ru>\n"
"Language-Team: Basealt Translation Team\n"
"Language: ru\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=4; plural=n==1 ? 3 : n%10==1 && n%100!=11 ? 0 : n"
"%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
"X-Generator: Lokalize 22.04.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Сканирование остановлено пользователем."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Задержка во времени для пакетного сканирования"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Указать задержку во времени между каждым сканированием, когда пакетный режим "
"включён."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Пакетное сканирование с задержкой во времени"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Включить пакетное сканирование. Сканирование будет продолжаться после "
"задержки во времени, пока не будет отменено."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Инвертировать цвета"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Инвертировать цвета отсканированного изображения."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Альбомная %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Размер области сканирования"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Выберите предустановленный размер страницы для области сканирования."
07070100000048000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/sk07070100000049000081A4000000000000000000000001660E103E00000855000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/sk/ksanecore.po# translation of ksanecore.po to Slovak
# Roman Paholík <wizzardsk@gmail.com>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-08 11:52+0100\n"
"Last-Translator: Roman Paholik <wizzardsk@gmail.com>\n"
"Language-Team: Slovak <kde-sk@linux.sk>\n"
"Language: sk\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Lokalize 21.12.1\n"
"Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Skenovanie bolo zastavené používateľom."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Časové oneskorenie hromadného režimu"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Určte časové oneskorenie medzi každým skenovaním, keď je povolený hromadný "
"režim."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Hromadný režim s časovým oneskorením"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Povolí režim hromadného skenovania. Skenovanie pokračuje po oneskorení, až "
"kým sa nezruší."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Invertovať farby"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Invertovať farby naskenovaného obrázka."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Krajinka %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Veľkosť oblasti skenovania"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Vyberte preddefinovanú veľkosť strany pre oblasť skenovania."
0707010000004A000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/sl0707010000004B000081A4000000000000000000000001660E103E0000088D000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/sl/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Matjaž Jeran <matjaz.jeran@amis.net>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-02 09:32+0100\n"
"Last-Translator: Matjaž Jeran <matjaz.jeran@amis.net>\n"
"Language-Team: Slovenian <lugos-slo@lugos.si>\n"
"Language: sl\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=4; plural=(n%100==1 ? 1 : n%100==2 ? 2 : n%100==3 || n"
"%100==4 ? 3 : 0);\n"
"X-Generator: Lokalize 21.04.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Skeniranje je ustavil uporabnik."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Časovna zakasnitev v paketnem načinu"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Določite časovno zakasnitev med vsakim skenom, kadar je omogočeno paketno "
"skeniranje."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Paketni način s časovno zakasnitvijo"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Omogoči paketno skeniranje. Nadaljuje skeniranje po zakasnitvi do preklica."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Invertiraj barve"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Invertira barve skenirane slike."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Ležeče %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Velikost skeniranega področja"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Določi prej določeno velikost skeniranega področja."
0707010000004C000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/sv0707010000004D000081A4000000000000000000000001660E103E0000088D000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/sv/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Stefan Asserhäll <stefan.asserhall@bredband.net>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-01 10:13+0100\n"
"Last-Translator: Stefan Asserhäll <stefan.asserhall@bredband.net>\n"
"Language-Team: Swedish <kde-i18n-doc@kde.org>\n"
"Language: sv\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Lokalize 20.08.1\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Inläsning stoppad av användaren."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Tidsfördröjning för bakgrundsläge"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Ange tidsfördröjningen mellan varje inläsning när bakgrundsläge är aktiverat."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Bakgrundsläge med tidsfördröjning"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Aktiverar inläsning i bakgrundsläge. Fortsätter inläsning efter en "
"fördröjning tills det avbryts."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Invertera färger"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Invertera färgerna på den inlästa bilden."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Liggande %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Läs in områdesstorlek"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Välj en fördefinierad sidstorlek för inläsningsområdet."
0707010000004E000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/tr0707010000004F000081A4000000000000000000000001660E103E00000886000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/tr/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Emir SARI <emir_sari@icloud.com>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-04-26 11:18+0300\n"
"Last-Translator: Emir SARI <emir_sari@icloud.com>\n"
"Language-Team: Turkish <kde-l10n-tr@kde.org>\n"
"Language: tr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Lokalize 21.12.3\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Tarama, kullanıcı tarafından durduruldu."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Toplu iş kipi zaman gecikmesi"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Toplu iş kipi etkinleştirildiğinde, iki tarama arasında ne kadar gecikme "
"olacağını belirtin."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Zaman gecikmesi ile toplu iş kipi"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Toplu iş kipinde taramayı etkinleştirir. İptal edilene dek taramayı araya "
"gecikme ekleyerek sürdürür."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Renkleri ters çevir"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Taranan görselin renklerini ters çevir."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Yatay %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Tarama alanı boyutu"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Tarama alanı için önceden tanımlanmış bir sayfa boyutu seçin."
07070100000050000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/uk07070100000051000081A4000000000000000000000001660E103E00000A7D000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/uk/ksanecore.po# Copyright (C) YEAR This file is copyright:
# This file is distributed under the same license as the ksanecore package.
#
# Yuri Chornoivan <yurchor@ukr.net>, 2022.
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2022-01-01 09:25+0200\n"
"Last-Translator: Yuri Chornoivan <yurchor@ukr.net>\n"
"Language-Team: Ukrainian <kde-i18n-uk@kde.org>\n"
"Language: uk\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=4; plural=n==1 ? 3 : n%10==1 && n%100!=11 ? 0 : n"
"%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
"X-Generator: Lokalize 20.12.0\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "Сканування припинено користувачем."

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "Затримка у пакетному режимі"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr ""
"Вкажіть часову затримку між послідовними скануваннями, якщо увімкнено "
"пакетний режим."

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "Пакетний режим із часовою затримкою"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr ""
"Вмикає пакетний режим сканування. Сканування продовжуватиметься із проміжною "
"затримкою, аж доки процес не буде припинено."

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "Інвертувати кольори"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "Інвертувати кольори сканованого зображення."

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "Альбомна %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "Розмір області сканування"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "Виберіть попередньо визначений розмір сторінки для області сканування."
07070100000052000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003600000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/zh_CN07070100000053000081A4000000000000000000000001660E103E000007D0000000000000000000000000000000000000004300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/zh_CN/ksanecore.pomsgid ""
msgstr ""
"Project-Id-Version: kdeorg\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2024-04-03 19:22\n"
"Last-Translator: \n"
"Language-Team: Chinese Simplified\n"
"Language: zh_CN\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Crowdin-Project: kdeorg\n"
"X-Crowdin-Project-ID: 269464\n"
"X-Crowdin-Language: zh-CN\n"
"X-Crowdin-File: /kf5-trunk/messages/ksanecore/ksanecore.pot\n"
"X-Crowdin-File-ID: 26513\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "扫描已被用户停止。"

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "批量模式时间延迟"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "指定在启用批量模式时，每次扫描之间的时间延迟。"

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "批量模式 (带时间延迟)"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr "启用批量扫描模式。每次扫描后经过一定的延迟时间后继续扫描，直至取消。"

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "颜色反相"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "反相处理扫描图像的颜色。"

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "横向 %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "扫描区域大小"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "选择扫描区域的预设页面大小。"
07070100000054000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003600000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/zh_TW07070100000055000081A4000000000000000000000001660E103E000008C9000000000000000000000000000000000000004300000000ksanecore-VERSIONgit.20240404T022814~46f9196/po/zh_TW/ksanecore.po# Chinese translations for ksanecore package
# ksanecore 套件的正體中文翻譯.
# Copyright (C) 2022 This file is copyright:
# This file is distributed under the same license as the ksanecore package.
# Automatically generated, 2022.
#
# SPDX-FileCopyrightText: 2023 Kisaragi Hiu <mail@kisaragi-hiu.com>
msgid ""
msgstr ""
"Project-Id-Version: ksanecore\n"
"Report-Msgid-Bugs-To: https://bugs.kde.org\n"
"POT-Creation-Date: 2023-11-05 12:28+0000\n"
"PO-Revision-Date: 2023-12-24 04:16+0900\n"
"Last-Translator: Kisaragi Hiu <mail@kisaragi-hiu.com>\n"
"Language-Team: Traditional Chinese <zh-l10n@lists.slat.org>\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Lokalize 23.08.4\n"

#: interface.cpp:221
#, kde-format
msgid "Scanning stopped by user."
msgstr "掃描已被使用者停止。"

#: options/batchdelayoption.cpp:31
#, kde-format
msgid "Batch mode time delay"
msgstr "批次模式時間延遲"

#: options/batchdelayoption.cpp:36
#, kde-format
msgid "Specify the time delay between each scan when batch mode is enabled."
msgstr "指定使用批次模式時在每次掃描之間的時間延遲。"

#: options/batchmodeoption.cpp:31
#, kde-format
msgid "Batch mode with time delay"
msgstr "使用時間延遲的批次模式"

#: options/batchmodeoption.cpp:36
#, kde-format
msgid ""
"Enables batch mode scanning. Continues scanning after a delay until canceled."
msgstr "啟用批次模式掃描。過一段延遲時間之後會繼續掃描，找到被取消。"

#: options/invertoption.cpp:58
#, kde-format
msgid "Invert colors"
msgstr "反轉顏色"

#: options/invertoption.cpp:63
#, kde-format
msgid "Invert the colors of the scanned image."
msgstr "反轉掃描後影像的色彩。"

#: options/pagesizeoption.cpp:98
#, kde-format
msgctxt "Page size landscape"
msgid "Landscape %1"
msgstr "橫向 %1"

#: options/pagesizeoption.cpp:177
#, kde-format
msgid "Scan area size"
msgstr "掃描區域大小"

#: options/pagesizeoption.cpp:182
#, kde-format
msgid "Select a predefined page size for the scanning area."
msgstr "在預先定義的頁面大小中選取一個作為掃描區域的大小。"
07070100000056000041ED000000000000000000000003660E103E00000000000000000000000000000000000000000000003100000000ksanecore-VERSIONgit.20240404T022814~46f9196/src07070100000057000081A4000000000000000000000001660E103E00000C41000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/CMakeLists.txt# SPDX-FileCopyrightText: none
#
# SPDX-License-Identifier: BSD-2-Clause

add_library(KSaneCore${KSANECORE_SUFFFIX})
add_library(KSane${KSANECORE_SUFFFIX}::Core ALIAS KSaneCore${KSANECORE_SUFFFIX})

set_target_properties(KSaneCore${KSANECORE_SUFFFIX} PROPERTIES
    VERSION     ${KSANECORE_VERSION}
    SOVERSION   ${KSANECORE_SOVERSION}
    EXPORT_NAME "Core"
)

target_compile_definitions(KSaneCore${KSANECORE_SUFFFIX} PRIVATE -DTRANSLATION_DOMAIN=\"ksanecore\")

target_sources(KSaneCore${KSANECORE_SUFFFIX} PRIVATE
    finddevicesthread.cpp
    scanthread.cpp
    imagebuilder.cpp
    interface.cpp
    interface_p.cpp
    authentication.cpp
    option.cpp
    internaloption.cpp
    deviceinformation.cpp
    options/baseoption.cpp
    options/actionoption.cpp
    options/booloption.cpp
    options/stringoption.cpp
    options/gammaoption.cpp
    options/integeroption.cpp
    options/doubleoption.cpp
    options/listoption.cpp
    options/invertoption.cpp
    options/pagesizeoption.cpp
    options/batchmodeoption.cpp
    options/batchdelayoption.cpp
)

ecm_qt_declare_logging_category(KSaneCore${KSANECORE_SUFFFIX}
  HEADER ksanecore_debug.h
  IDENTIFIER KSANECORE_LOG
  CATEGORY_NAME org.kde.ksane.core
)

if (QT_MAJOR_VERSION STREQUAL "5")
 set(_generate_export_header_version_args)
else()
 # For Qt6/KF6 world transitively include the version header
 if(ECM_VERSION VERSION_LESS "5.106")
 set(include_version_header_code "#include <ksanecore_version.h>\n")
 set(_generate_export_header_version_args CUSTOM_CONTENT_FROM_VARIABLE include_version_header_code)
 else()
 set(_generate_export_header_version_args USE_VERSION_HEADER)
 endif()
endif()

ecm_generate_export_header(KSaneCore${KSANECORE_SUFFFIX}
    BASE_NAME KSaneCore
    VERSION ${KSANECORE_VERSION}
    DEPRECATED_BASE_VERSION 0
    ${_generate_export_header_version_args}
)

target_include_directories(KSaneCore${KSANECORE_SUFFFIX}
 INTERFACE
 "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR}/KSaneCore${KSANECORE_SUFFFIX}>"
 PRIVATE
 ${CMAKE_CURRENT_SOURCE_DIR}/options
)

target_link_libraries(KSaneCore${KSANECORE_SUFFFIX}
    PUBLIC
        Qt${QT_MAJOR_VERSION}::Core
        Qt${QT_MAJOR_VERSION}::Gui
    PRIVATE
        Sane::Sane
        KF${KF_MAJOR_VERSION}::I18n
)

ecm_generate_headers(KSaneCore_CamelCase_HEADERS
    HEADER_NAMES
        Interface
        Option
        DeviceInformation
    REQUIRED_HEADERS KSaneCore_HEADERS
    PREFIX KSaneCore
    RELATIVE "../src/"
)

# Install files

install(TARGETS KSaneCore${KSANECORE_SUFFFIX}
    EXPORT KSaneCore${KSANECORE_SUFFFIX}Targets
    ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/ksanecore_export.h"
    DESTINATION "${KDE_INSTALL_INCLUDEDIR}/KSaneCore${KSANECORE_SUFFFIX}"
    COMPONENT Devel
)

install(FILES
    ${KSaneCore_HEADERS}
    DESTINATION "${KDE_INSTALL_INCLUDEDIR}/KSaneCore${KSANECORE_SUFFFIX}/ksanecore"
    COMPONENT Devel
)

install(FILES
    ${KSaneCore_CamelCase_HEADERS}
    DESTINATION "${KDE_INSTALL_INCLUDEDIR}/KSaneCore${KSANECORE_SUFFFIX}/KSaneCore"
    COMPONENT Devel
)
07070100000058000081ED000000000000000000000001660E103E00000088000000000000000000000000000000000000003D00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/Messages.sh#! /bin/sh

# SPDX-FileCopyrightText: None
# SPDX-License-Identifier: CC0-1.0

$XGETTEXT `find . -name \*.cpp` -o $podir/ksanecore.pot

07070100000059000081A4000000000000000000000001660E103E00000D10000000000000000000000000000000000000004400000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/authentication.cpp/*
 * SPDX-FileCopyrightText: 2010 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "authentication.h"

// Qt includes
#include <QMutex>
#include <QMutexLocker>
#include <QList>

#include <ksanecore_debug.h>

namespace KSaneCore
{

static Authentication *s_instance = nullptr;
Q_GLOBAL_STATIC(QMutex, s_mutex)

struct Authentication::Private {
    struct AuthStruct {
        QString resource;
        QString username;
        QString password;
    };

QList<AuthStruct> authList;
};

Authentication *Authentication::getInstance()
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 QMutexLocker<QMutex> locker(s_mutex);
#else
 QMutexLocker locker(s_mutex);
#endif

if (s_instance == nullptr) {
        s_instance = new Authentication();
    }
    return s_instance;
}

Authentication::Authentication() : d(new Private) {}

Authentication::~Authentication()
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 QMutexLocker<QMutex> locker(s_mutex);
#else
 QMutexLocker locker(s_mutex);
#endif
 d->authList.clear();
 delete d;
}

void Authentication::setDeviceAuth(const QString &resource, const QString &username, const QString &password)
{
 // This is a short list so we do not need a QMap...
 int i;
 for (i = 0; i < d->authList.size(); i++) {
 if (resource == d->authList.at(i).resource) {
 // update the existing node
 d->authList[i].username = username;
 d->authList[i].password = password;
 break;
 }
 }
 if (i == d->authList.size()) {
 // Add a new list node
 Private::AuthStruct tmp;
 tmp.resource = resource;
 tmp.username = username;
 tmp.password = password;
 d->authList << tmp;
 }
}

void Authentication::clearDeviceAuth(const QString &resource)
{
 // This is a short list so we do not need a QMap...
 for (int i = 0; i < d->authList.size(); i++) {
 if (resource == d->authList.at(i).resource) {
 d->authList.removeAt(i);
 return;
 }
 }
}

/** static function called by sane_open to get authorization from user */
void Authentication::authorization(SANE_String_Const resource, SANE_Char *username, SANE_Char *password)
{
 qCDebug(KSANECORE_LOG) << resource;
 // This is vague in the standard... what can I find in the resource string?
 // I have found that "resource contains the backend name + "$MD5$....."
 // it does not contain unique identifiers like ":libusb:001:004"
 // -> remove $MD5 and later before comparison...
 QString res = QString::fromUtf8(resource);
 int end = res.indexOf(QStringLiteral("$MD5$"));
 res = res.left(end);
 qCDebug(KSANECORE_LOG) << res;

const QList<Private::AuthStruct> list = getInstance()->d->authList;
 for (const auto &authItem : list) {
 qCDebug(KSANECORE_LOG) << res << authItem.resource;
 if (authItem.resource.contains(res)) {
 qstrncpy(username, authItem.username.toLocal8Bit().constData(), SANE_MAX_USERNAME_LEN);
 qstrncpy(password, authItem.password.toLocal8Bit().constData(), SANE_MAX_PASSWORD_LEN);
 break;
 }
 }
}

} // namespace KSaneCore
0707010000005A000081A4000000000000000000000001660E103E00000387000000000000000000000000000000000000004200000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/authentication.h/*
 * SPDX-FileCopyrightText: 2010 Kare Sars <kare dot sars at iki dot fi>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_AUTHENTICATION_H
#define KSANE_AUTHENTICATION_H

// Qt includes
#include <QString>

// Sane includes
extern "C"
{
#include <sane/saneopts.h>
#include <sane/sane.h>
}

namespace KSaneCore
{

/**
 * Sane authentication helpers.
 */
class Authentication
{
public:
    static Authentication *getInstance();
    ~Authentication();

void setDeviceAuth(const QString &resource, const QString &username, const QString &password);
    void clearDeviceAuth(const QString &resource);
    static void authorization(SANE_String_Const resource, SANE_Char *username, SANE_Char *password);

private:
    Authentication();
    struct Private;
    Private *const d;
};

} // namespace KSaneCore

#endif // KSANE_AUTHENTICATION_H
0707010000005B000081A4000000000000000000000001660E103E000002BB000000000000000000000000000000000000004700000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/deviceinformation.cpp/*
 * SPDX-FileCopyrightText: 2022 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "deviceinformation.h"
#include "deviceinformation_p.h"

namespace KSaneCore
{

DeviceInformation::DeviceInformation() : d(std::make_unique<DeviceInformationPrivate>())
{
}

DeviceInformation::~DeviceInformation() = default;

QString DeviceInformation::name() const
{
    return d->name;
}

QString DeviceInformation::vendor() const
{
    return d->vendor;
}

QString DeviceInformation::model() const
{
    return d->model;
}

QString DeviceInformation::type() const
{
    return d->type;
}

} // namespace KSaneCore
0707010000005C000081A4000000000000000000000001660E103E0000052B000000000000000000000000000000000000004500000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/deviceinformation.h/*
 * SPDX-FileCopyrightText: 2022 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_DEVICEINFORMATION_H
#define KSANE_DEVICEINFORMATION_H

#include <memory>

// Qt includes
#include <QString>

#include "ksanecore_export.h"

namespace KSaneCore
{

class DeviceInformationPrivate;

/**
 * A wrapper class providing access to the internal information
 * of the scanner device provided by SANE
 */
class KSANECORE_EXPORT DeviceInformation
{

public:
    explicit DeviceInformation();
    ~DeviceInformation();

/** This function returns a unique device name for the scanner device
     * @return the unique device name name */
    QString name() const;

/** This function returns the device vendor string of the scanner device
     * @return the device vendor string */
    QString vendor() const;

/** This function returns the device vendor string of the scanner device
     * @return the device model name */
    QString model() const;

/** This function returns the device type (e.g., "flatbed scanner")
     * @return the device type */
    QString type() const;

protected:
 std::unique_ptr<KSaneCore::DeviceInformationPrivate> d;
};

} // namespace KSaneCore

#endif // KSANE_DEVICEINFORMATION_H

0707010000005D000081A4000000000000000000000001660E103E00000265000000000000000000000000000000000000004700000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/deviceinformation_p.h/*
 * SPDX-FileCopyrightText: 2022 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_DEVICEINFORMATION_P_H
#define KSANE_DEVICEINFORMATION_P_H

#include "baseoption.h"

namespace KSaneCore
{

class DeviceInformationPrivate
{
public:
    QString name;     /* unique device name */
    QString vendor;   /* device vendor string */
    QString model;    /* device model name */
    QString type;     /* device type (e.g., "flatbed scanner") */
};

} // namespace KSaneCore

#endif // KSANE_DEVICEINFORMATION_P_H

0707010000005E000081A4000000000000000000000001660E103E00000E39000000000000000000000000000000000000004700000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/finddevicesthread.cpp/*
 * SPDX-FileCopyrightText: 2009 Grzegorz Kurtyka <grzegorz dot kurtyka at gmail dot com>
 * SPDX-FileCopyrightText: 2010 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "finddevicesthread.h"

// Sane includes
extern "C"
{
#include <sane/saneopts.h>
#include <sane/sane.h>
}

#include <QMutex>
#include <QMutexLocker>

#include <ksanecore_debug.h>

#include "deviceinformation_p.h"

namespace KSaneCore
{
static FindSaneDevicesThread *s_instancesane = nullptr;
Q_GLOBAL_STATIC(QMutex, s_mutexsane)

class InternalDeviceInformation : public DeviceInformation
{
public:
    InternalDeviceInformation(const QString &name, const QString &vendor,
                              const QString &model, const QString &type)
    {
        d->name = name;
        d->model = model;
        d->vendor = vendor;
        d->type = type;
    }
};

FindSaneDevicesThread *FindSaneDevicesThread::getInstance()
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 QMutexLocker<QMutex> locker(s_mutexsane);
#else
 QMutexLocker locker(s_mutexsane);
#endif

if (s_instancesane == nullptr) {
        s_instancesane = new FindSaneDevicesThread();
    }

return s_instancesane;
}

FindSaneDevicesThread::FindSaneDevicesThread() : QThread(nullptr)
{
}

FindSaneDevicesThread::~FindSaneDevicesThread()
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 QMutexLocker<QMutex> locker(s_mutexsane);
#else
 QMutexLocker locker(s_mutexsane);
#endif
 qDeleteAll(m_deviceList);
 wait();
}

void FindSaneDevicesThread::run()
{
    SANE_Device const **devList;
    SANE_Status         status;

// This is unfortunately not very reliable as many back-ends do not refresh
    // the device list after the sane_init() call...
    status = sane_get_devices(&devList, SANE_FALSE);

qDeleteAll(m_deviceList);
    m_deviceList.clear();
    if (status == SANE_STATUS_GOOD) {
        int i = 0;

while (devList[i] != nullptr) {
 /* Do not list cameras as scanner devices when requested.
 * Strings taken from SANE API documentation. */
 const QString type = QString::fromUtf8(devList[i]->type);
 if (m_deviceType == Interface::AllDevices
 || (m_deviceType == Interface::NoCameraAndVirtualDevices && type != QLatin1String("still camera") && type != QLatin1String("video camera")
 && type != QLatin1String("virtual device"))) {
 InternalDeviceInformation *device = new InternalDeviceInformation(QString::fromUtf8(devList[i]->name),
 QString::fromUtf8(devList[i]->vendor),
 QString::fromUtf8(devList[i]->model),
 type);
 m_deviceList.append(std::move(device));
 qCDebug(KSANECORE_LOG) << "Adding device " << device->vendor() << device->name() << device->model() << device->type() << " to device list";
 } else {
 qCDebug(KSANECORE_LOG) << "Ignoring device type" << type;
 }
 i++;
 }
 }
}

QList<DeviceInformation *> FindSaneDevicesThread::devicesList() const
{
 return m_deviceList;
}

void FindSaneDevicesThread::setDeviceType(const Interface::DeviceType type)
{
    m_deviceType = type;
}

} // namespace KSaneCore

#include "moc_finddevicesthread.cpp"
0707010000005F000081A4000000000000000000000001660E103E000003B5000000000000000000000000000000000000004500000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/finddevicesthread.h/*
 * SPDX-FileCopyrightText: 2007-2008 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_FIND_DEVICES_THREAD_H
#define KSANE_FIND_DEVICES_THREAD_H

#include "deviceinformation.h"
#include "interface.h"

#include <QThread>
#include <QList>

namespace KSaneCore
{

class FindSaneDevicesThread : public QThread
{
    Q_OBJECT

public:
    static FindSaneDevicesThread *getInstance();
    ~FindSaneDevicesThread() override;
    void run() override;

QList<DeviceInformation *> devicesList() const;
 void setDeviceType(const Interface::DeviceType type);

private:
    FindSaneDevicesThread();

QList<DeviceInformation *> m_deviceList;
 Interface::DeviceType m_deviceType = Interface::AllDevices;
};

} // namespace KSaneCore

#endif // KSANE_FIND_DEVICES_THREAD_H
07070100000060000081A4000000000000000000000001660E103E00002594000000000000000000000000000000000000004200000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/imagebuilder.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2018 Alexander Volkov <a.volkov@rusbitech.ru>
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "imagebuilder.h"

#include <QImage>

#include <ksanecore_debug.h>

namespace KSaneCore
{
ImageBuilder::ImageBuilder(QImage *image, int *dpi)
    : m_image(image), m_dpi(dpi)
{
    m_pixelData[0] = 0;
    m_pixelData[1] = 0;
    m_pixelData[2] = 0;
    m_pixelData[3] = 0;
    m_pixelData[4] = 0;
    m_pixelData[5] = 0;
}

void ImageBuilder::start(const SANE_Parameters &params)
{
    beginFrame(params);
    QImage::Format imageFormat = QImage::Format_RGB32;
    if (m_params.format == SANE_FRAME_GRAY) {
        switch (m_params.depth) {
        case 1:
            imageFormat = QImage::Format_Mono;
            break;
        case 16:
            imageFormat = QImage::Format_Grayscale16;
            break;
        default:
            imageFormat = QImage::Format_Grayscale8;
            break;
        }
    } else if (m_params.depth > 8) {
        imageFormat = QImage::Format_RGBX64;
    }
    // create a new image if necessary
    if ((m_image->height() != m_params.lines) ||
            (m_image->width() != m_params.pixels_per_line) || m_image->format() != imageFormat) {
        // just hope that the frame size is not changed between different frames of the same image.

int pixelLines = m_params.lines;
 // handscanners have the number of lines -1 -> make room for something
 if (m_params.lines <= 0) {
 pixelLines = m_params.pixels_per_line;
 }
 *m_image = QImage(m_params.pixels_per_line, pixelLines, imageFormat);
 if (m_image->format() == QImage::Format_Mono) {
 m_image->setColorTable(QVector<QRgb>({0xFFFFFFFF,0xFF000000}));
 }
 int dpm = *m_dpi * (1000.0 / 25.4);
 m_image->setDotsPerMeterX(dpm);
 m_image->setDotsPerMeterY(dpm);
 }
 m_image->fill(0xFFFFFFFF);
}

void ImageBuilder::beginFrame(const SANE_Parameters &params)
{
    m_params = params;
    m_frameRead  = 0;
    m_pixelX    = 0;
    m_pixelY    = 0;
    m_pixelDataIndex = 0;
}

bool ImageBuilder::copyToImage(const SANE_Byte readData[], int read_bytes)
{
 switch (m_params.format) {
 case SANE_FRAME_GRAY:
 if (m_params.depth == 1) {
 for (int i = 0; i < read_bytes; i++) {
 if (m_pixelY >= m_image->height()) {
 renewImage();
 }
 uchar *imageBits = m_image->scanLine(m_pixelY);
 imageBits[m_pixelX / 8] = readData[i];
 m_pixelX += 8;
 if (m_pixelX >= m_params.pixels_per_line) {
 m_pixelX = 0;
 m_pixelY++;
 }
 m_frameRead++;
 }
 return true;
 } else if (m_params.depth == 8) {
 for (int i = 0; i < read_bytes; i++) {
 if (m_pixelY >= m_image->height()) {
 renewImage();
 }
 uchar *grayScale = m_image->scanLine(m_pixelY);
 grayScale[m_pixelX] = readData[i];
 incrementPixelData();
 m_frameRead++;
 }
 return true;
 } else if (m_params.depth == 16) {
 for (int i = 0; i < read_bytes; i++) {
 m_pixelData[m_pixelDataIndex] = readData[i];
 m_pixelDataIndex++;
 if (m_pixelDataIndex == 2) {
 m_pixelDataIndex = 0;
 }
 if (m_pixelDataIndex == 0) {
 if (m_pixelY >= m_image->height()) {
 renewImage();
 }
 quint16 *grayScale = reinterpret_cast<quint16*>(m_image->scanLine(m_pixelY));
 grayScale[m_pixelX] = m_pixelData[0] + (m_pixelData[1] << 8);
 incrementPixelData();
 }
 m_frameRead++;
 }
 return true;
 }
 break;

case SANE_FRAME_RGB:
 if (m_params.depth == 8) {
 for (int i = 0; i < read_bytes; i++) {
 m_pixelData[m_pixelDataIndex] = readData[i];
 m_pixelDataIndex++;
 if (m_pixelDataIndex == 3) {
 m_pixelDataIndex = 0;
 }
 if (m_pixelDataIndex == 0) {
 if (m_pixelY >= m_image->height()) {
 renewImage();
 }
 QRgb *rgbData = reinterpret_cast<QRgb*>(m_image->scanLine(m_pixelY));
 rgbData[m_pixelX] = qRgb(m_pixelData[0], m_pixelData[1], m_pixelData[2]);
 incrementPixelData();
 }
 m_frameRead++;
 }
 return true;
 } else if (m_params.depth == 16) {
 for (int i = 0; i < read_bytes; i++) {
 m_pixelData[m_pixelDataIndex] = readData[i];
 m_pixelDataIndex++;
 if (m_pixelDataIndex == 6) {
 m_pixelDataIndex = 0;
 }
 if (m_pixelDataIndex == 0) {
 if (m_pixelY >= m_image->height()) {
 renewImage();
 }
 QRgba64 *rgbData = reinterpret_cast<QRgba64*>(m_image->scanLine(m_pixelY));
 rgbData[m_pixelX] = QRgba64::fromRgba64((m_pixelData[0] + (m_pixelData[1] << 8)),
 (m_pixelData[2] + (m_pixelData[3] << 8)),
 (m_pixelData[4] + (m_pixelData[5] << 8)),
 0xFFFF);
 incrementPixelData();
 }
 m_frameRead++;
 }
 return true;
 }
 break;

case SANE_FRAME_RED: {
 int index = 0;
 if (m_params.depth == 8) {
 for (int i = 0; i < read_bytes; i++) {
 index = m_frameRead * 4 + 2;
 if (index >= m_image->sizeInBytes()) {
 renewImage();
 }
 m_image->bits()[index] = readData[i];
 m_frameRead++;
 }
 return true;
 } else if (m_params.depth == 16) {
 for (int i = 0; i < read_bytes; i++) {
 index = (m_frameRead - m_frameRead % 2) * 4 + m_frameRead % 2;
 if (index >= m_image->sizeInBytes()) {
 renewImage();
 }
 m_image->bits()[index] = readData[i];
 m_frameRead++;
 }
 return true;
 }
 break;
 }
 case SANE_FRAME_GREEN: {
 int index = 0;
 if (m_params.depth == 8) {
 for (int i = 0; i < read_bytes; i++) {
 int index = m_frameRead * 4 + 1;
 if (index >= m_image->sizeInBytes()) {
 renewImage();
 }
 m_image->bits()[index] = readData[i];
 m_frameRead++;
 }
 return true;
 } else if (m_params.depth == 16) {
 for (int i = 0; i < read_bytes; i++) {
 index = (m_frameRead - m_frameRead % 2) * 4 + 2 + m_frameRead % 2;
 if (index >= m_image->sizeInBytes()) {
 renewImage();
 }
 m_image->bits()[index] = readData[i];
 m_frameRead++;
 }
 return true;
 }
 break;
 }
 case SANE_FRAME_BLUE: {
 int index = 0;
 if (m_params.depth == 8) {
 for (int i = 0; i < read_bytes; i++) {
 int index = m_frameRead * 4;
 if (index >= m_image->sizeInBytes()) {
 renewImage();
 }
 m_image->bits()[index] = readData[i];
 m_frameRead++;
 }
 return true;
 } else if (m_params.depth == 16) {
 for (int i = 0; i < read_bytes; i++) {
 index = (m_frameRead - m_frameRead % 2) * 4 + 4 + m_frameRead % 2;
 if (index >= m_image->sizeInBytes()) {
 renewImage();
 }
 m_image->bits()[index] = readData[i];
 m_frameRead++;
 }
 return true;
 }
 break;
 }
 }

qCWarning(KSANECORE_LOG) << "Format" << m_params.format << "and depth" << m_params.depth << "is not yet supported by libksane!";
 return false;
}

void ImageBuilder::renewImage()
{
    int start = m_image->sizeInBytes();

// resize the image
    *m_image = m_image->copy(0, 0, m_image->width(), m_image->height() + m_image->width());

for (int i = start; i < m_image->sizeInBytes(); i++) { // New parts are filled with "transparent black"
 m_image->bits()[i] = 0xFF; // Change to opaque white (0xFFFFFFFF), or white, whatever the format is
 }
}

void ImageBuilder::cropImagetoSize()
{
    int height = m_pixelY ? m_pixelY : m_frameRead / m_params.bytes_per_line;
    if (m_image->height() == height)
        return;
    *m_image = m_image->copy(0, 0, m_image->width(), height);
}

void ImageBuilder::incrementPixelData()
{
    m_pixelX++;
    if (m_pixelX >= m_params.pixels_per_line) {
        m_pixelY++;
        m_pixelX=0;
    }
}

} // namespace KSaneCore
07070100000061000081A4000000000000000000000001660E103E00000477000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/imagebuilder.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2018 Alexander Volkov <a.volkov@rusbitech.ru>
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_IMAGE_BUILDER_H
#define KSANE_IMAGE_BUILDER_H

extern "C"
{
#include <sane/sane.h>
}

class QImage;

namespace KSaneCore
{

/* Constructs a QImage out of the raw scanned data retrieved via libsane */
class ImageBuilder
{
public:
    ImageBuilder(QImage *image, int *dpi);

void start(const SANE_Parameters &params);
    void beginFrame(const SANE_Parameters &params);
    bool copyToImage(const SANE_Byte readData[], int read_bytes);
    void setDPI(int dpi);
    void cropImagetoSize();

private:
    void renewImage();
    void incrementPixelData();

SANE_Parameters m_params;
    int m_frameRead = 0;
    int m_pixelX = 0;
    int m_pixelY = 0;
    int m_pixelData[6];
    int m_pixelDataIndex = 0;

QImage *m_image;
    int *m_dpi;
};

} // namespace KSaneCore

#endif // KSANE_IMAGE_BUILDER_H
07070100000062000081A4000000000000000000000001660E103E00002142000000000000000000000000000000000000003F00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/interface.cpp/*
 * SPDX-FileCopyrightText: 2007-2010 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2009 Matthias Nagl <matthias at nagl dot info>
 * SPDX-FileCopyrightText: 2009 Grzegorz Kurtyka <grzegorz dot kurtyka at gmail dot com>
 * SPDX-FileCopyrightText: 2007-2008 Gilles Caulier <caulier dot gilles at gmail dot com>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

// Qt includes

#include <QMutex>

// Sane includes
extern "C" {
#include <sane/sane.h>
#include <sane/saneopts.h>
}

#include "interface.h"
#include "interface_p.h"

#include <ksanecore_debug.h>

namespace KSaneCore
{
static int s_objectCount = 0;

Q_GLOBAL_STATIC(QMutex, s_objectMutex)

Interface::Interface(QObject *parent)
 : QObject(parent)
 , d(std::make_unique<InterfacePrivate>(this))
{
 SANE_Int version;
 SANE_Status status;

s_objectMutex->lock();
    s_objectCount++;

if (s_objectCount == 1) {
 // only call sane init for the first instance
 status = sane_init(&version, &Authentication::authorization);
 if (status != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << "libksane: sane_init() failed(" << sane_strstatus(status) << ")";
 }
 }
 s_objectMutex->unlock();

d->m_readValuesTimer.setSingleShot(true);
    connect(&d->m_readValuesTimer, &QTimer::timeout, d.get(), &InterfacePrivate::reloadValues);
}

Interface::~Interface()
{
    closeDevice();

s_objectMutex->lock();
 s_objectCount--;
 if (s_objectCount <= 0) {
 // only delete the find-devices and authorization singletons and call sane_exit
 // if this is the last instance
 delete d->m_findDevThread;
 delete d->m_auth;
 sane_exit();
 }
 s_objectMutex->unlock();
}

QString Interface::deviceName() const
{
    return d->m_devName;
}

QString Interface::deviceVendor() const
{
    return d->m_vendor;
}

QString Interface::deviceModel() const
{
    return d->m_model;
}

bool Interface::reloadDevicesList(const DeviceType type)
{
    /* On some SANE backends, the handle becomes invalid when
     * querying for new devices. Hence, this is only allowed when
     * no device is currently opened. */
    if (d->m_saneHandle == nullptr) {
        d->m_findDevThread->setDeviceType(type);
        d->m_findDevThread->start();
        return true;
    }
    return false;
}

Interface::OpenStatus Interface::openDevice(const QString &deviceName)
{
    SANE_Status status;

if (d->m_saneHandle != nullptr) {
        // this CoreInterface already has an open device
        return OpenStatus::OpeningFailed;
    }

// don't bother trying to open if the device string is empty
    if (deviceName.isEmpty()) {
        return OpenStatus::OpeningFailed;
    }
    // save the device name
    d->m_devName = deviceName;

// Try to open the device
    status = sane_open(deviceName.toLatin1().constData(), &d->m_saneHandle);

if (status == SANE_STATUS_ACCESS_DENIED) {
        return OpenStatus::OpeningDenied;
    }

if (status != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << "sane_open(\"" << deviceName << "\", &handle) failed! status = " << sane_strstatus(status);
 d->m_devName.clear();
 return OpenStatus::OpeningFailed;
 }

return d->loadDeviceOptions();
}

Interface::OpenStatus Interface::openRestrictedDevice(const QString &deviceName, const QString &userName, const QString &password)
{
    SANE_Status status;

if (d->m_saneHandle != nullptr) {
        // this CoreInterface already has an open device
        return OpenStatus::OpeningFailed;
    }

// don't bother trying to open if the device string is empty
    if (deviceName.isEmpty()) {
        return OpenStatus::OpeningFailed;
    }
    // save the device name
    d->m_devName = deviceName;

// add/update the device user-name and password for authentication
    d->m_auth->setDeviceAuth(d->m_devName, userName, password);

// Try to open the device
    status = sane_open(deviceName.toLatin1().constData(), &d->m_saneHandle);

if (status == SANE_STATUS_ACCESS_DENIED) {
        return OpenStatus::OpeningDenied;
    }

if (status != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << "sane_open(\"" << deviceName << "\", &handle) failed! status = " << sane_strstatus(status);
 d->m_auth->clearDeviceAuth(d->m_devName);
 d->m_devName.clear();
 return OpenStatus::OpeningFailed;
 }

return d->loadDeviceOptions();
}

bool Interface::closeDevice()
{
    if (!d->m_saneHandle) {
        return false;
    }
    stopScan();

disconnect(d->m_scanThread);
    if (d->m_scanThread->isRunning()) {
        connect(d->m_scanThread, &QThread::finished, d->m_scanThread, &QThread::deleteLater);
    }
    if (d->m_scanThread->isFinished()) {
        d->m_scanThread->deleteLater();
    }
    d->m_scanThread = nullptr;

d->m_auth->clearDeviceAuth(d->m_devName);
    sane_close(d->m_saneHandle);
    d->m_saneHandle = nullptr;
    d->clearDeviceOptions();

return true;
}

void Interface::startScan()
{
    if (!d->m_saneHandle) {
        return;
    }
    d->m_cancelMultiPageScan = false;
    // execute a pending value reload
    while (d->m_readValuesTimer.isActive()) {
        d->m_readValuesTimer.stop();
        d->reloadValues();
    }
    d->m_optionPollTimer.stop();
    Q_EMIT scanProgress(-1);
    d->m_scanThread->start();
}

void Interface::stopScan()
{
    if (!d->m_saneHandle) {
        return;
    }

d->m_cancelMultiPageScan = true;
    if (d->m_scanThread->isRunning()) {
        d->m_scanThread->cancelScan();
    }
    if (d->m_batchModeTimer.isActive()) {
        d->m_batchModeTimer.stop();
        Q_EMIT batchModeCountDown(0);
        Q_EMIT scanFinished(ScanStatus::NoError, i18n("Scanning stopped by user."));
    }
}

QImage *Interface::scanImage() const
{
    if (d->m_saneHandle != nullptr) {
        return d->m_scanThread->scanImage();
    }
    return nullptr;
}

void Interface::lockScanImage()
{
    if (d->m_saneHandle != nullptr) {
        d->m_scanThread->lockScanImage();
    }
}

void Interface::unlockScanImage()
{
    if (d->m_saneHandle != nullptr) {
        d->m_scanThread->unlockScanImage();
    }
}

QList<Option *> Interface::getOptionsList()
{
 return d->m_externalOptionsList;
}

Option *Interface::getOption(Interface::OptionName optionEnum)
{
    auto it = d->m_optionsLocation.find(optionEnum);
    if (it != d->m_optionsLocation.end()) {
        return d->m_externalOptionsList.at(it.value());
    }
    return nullptr;
}

Option *Interface::getOption(const QString &optionName)
{
    for (const auto &option : qAsConst(d->m_externalOptionsList)) {
        if (option->name() == optionName) {
            return option;
        }
    }
    return nullptr;
}

QMap<QString, QString> Interface::getOptionsMap()
{
 QMap<QString, QString> options;
 QString tmp;

for (const auto option : qAsConst(d->m_optionsList)) {
        tmp = option->valueAsString();
        if (!tmp.isEmpty()) {
            options[option->name()] = tmp;
        }
    }
    return options;
}

int Interface::setOptionsMap(const QMap<QString, QString> &options)
{
 if (!d->m_saneHandle || d->m_scanThread->isRunning()) {
 return -1;
 }

QMap<QString, QString> optionMapCopy = options;

int i;
    int ret = 0;

Option *sourceOption = getOption(SourceOption);
    Option *modeOption = getOption(ScanModeOption);

// Priorize source option
    if (sourceOption != nullptr && optionMapCopy.contains(sourceOption->name())) {
        if (sourceOption->setValue(optionMapCopy[sourceOption->name()])) {
            ret++;
        }
        optionMapCopy.remove(sourceOption->name());
    }

// Priorize mode option
    if (modeOption != nullptr && optionMapCopy.contains(modeOption->name())) {
        if (modeOption->setValue(optionMapCopy[modeOption->name()])) {
            ret++;
        }
        optionMapCopy.remove(modeOption->name());
    }

// Update remaining options
 for (i = 0; i < d->m_optionsList.size(); i++) {
 const auto it = optionMapCopy.find(d->m_optionsList.at(i)->name());
 if (it != optionMapCopy.end() && d->m_optionsList.at(i)->setValue(it.value())) {
 ret++;
 }
 }
 return ret;
}

} // NameSpace KSaneCore

#include "moc_interface.cpp"
07070100000063000081A4000000000000000000000001660E103E00002B5C000000000000000000000000000000000000003D00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/interface.h/*
 * SPDX-FileCopyrightText: 2007-2010 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2007 Gilles Caulier <caulier dot gilles at gmail dot com>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_COREINTERFACE_H
#define KSANE_COREINTERFACE_H

#include "ksanecore_export.h"

#include <memory>

#include <QImage>
#include <QList>
#include <QObject>

#include "deviceinformation.h"

namespace KSaneCore
{

class InterfacePrivate;
class Option;

/**
 * This class provides the core interface for accessing the scan controls and options.
 */
class KSANECORE_EXPORT Interface : public QObject
{
    Q_OBJECT
    friend class InterfacePrivate;

public:
    /**
     * Enum defining the message level of the returned scan status string.
     * @note There might come more enumerations in the future.
     */
    enum ScanStatus {
        NoError, // The scanning has finished successfully
        ErrorGeneral, // The error string should contain an error message.
        Information // There is some information to the user.
    };

/**
     * Enum determining whether the scanner opened correctly.
     */
    enum OpenStatus {
        OpeningSucceeded, // scanner opened successfully
        OpeningDenied, // access was denied,
        OpeningFailed, // opening the scanner failed for unknown reasons
    };

/**
     * This enumeration is used to obtain a specific option with getOption(KSaneOptionName).
     * Depending on the backend, not all options are available, nor this list is complete.
     * For the remaining options, getOptionsList() must be used.
     */
    enum OptionName {
        SourceOption,
        ScanModeOption,
        BitDepthOption,
        ResolutionOption,
        TopLeftXOption,
        TopLeftYOption,
        BottomRightXOption,
        BottomRightYOption,
        FilmTypeOption,
        NegativeOption,
        InvertColorOption,
        PageSizeOption,
        ThresholdOption,
        XResolutionOption,
        YResolutionOption,
        PreviewOption,
        WaitForButtonOption,
        BrightnessOption,
        ContrastOption,
        GammaOption,
        GammaRedOption,
        GammaGreenOption,
        GammaBlueOption,
        BlackLevelOption,
        WhiteLevelOption,
        BatchModeOption,
        BatchDelayOption,
    };

/**
     * This enumeration is used to filter the devices found by SANE.
     * Sometimes, webcam may show up as scanner device and some
     * more special scanner are also classified as cameras.
     */
    enum DeviceType { AllDevices, NoCameraAndVirtualDevices };

/**
     * This constructor initializes the private class variables.
     */
    explicit Interface(QObject *parent = nullptr);

/**
     * Standard destructor.
     */
    ~Interface() override;

/**
     * Get the list of available scanning devices. Connect to availableDevices()
     * which is fired once these devices are known. While the querying is done in a
     * separate thread and thus not blocking the application, the application must
     * ensure that no other action accessing the scanner device (settings options etc.)
     * is performed during this period.
     * @return whether the devices list are being reloaded or not
     * @param type specify whether only specific device types shall be queried
     */
    bool reloadDevicesList(DeviceType type = AllDevices);

/**
     * This method opens the specified scanner device and adds the scan options to the
     * options list.
     * @param deviceName is the SANE device name for the scanner to open.
     * @return the status of the opening action.
     */
    OpenStatus openDevice(const QString &deviceName);

/**
     * This method opens the specified scanner device with a specified username and password.
     * Adds the scan options to the options list.
     * @param deviceName is the SANE device name for the scanner to open.
     * @param userName the username required to open for the scanner.
     * @param password the password required to open for the scanner.
     * @return the status of the opening action.
     */
    OpenStatus openRestrictedDevice(const QString &deviceName, const QString &userName, const QString &password);

/**
     * This method closes the currently open scanner device.
     * @return 'true' if all goes well and 'false' if no device is open.
     */
    bool closeDevice();

/**
     * This method returns the internal device name of the currently opened scanner.
     * @note Due to limitations of the SANE API, this will function will return an empty string
     * if reloadDevicesList() has not been called before.
     */
    QString deviceName() const;

/**
     * This method returns the vendor name of the currently opened scanner.
     * @note Due to limitations of the SANE API, this will function will return an empty string
     * if reloadDevicesList() has not been called before.
     */
    QString deviceVendor() const;

/**
     * This method returns the model of the currently opened scanner.
     * @note Due to limitations of the SANE API, this will function will return an empty string
     * if reloadDevicesList() has not been called before.
     */
    QString deviceModel() const;

/**
 * This function returns all available options when a device is opened.
 * @return list containing pointers to all KSaneOptions provided by the backend.
 * Becomes invalid when closing a device.
 * The pointers must not be deleted by the client.
 */
 QList<Option *> getOptionsList();

/**
     * This function returns a specific option.
     * @param optionEnum the enum specifying the option.
     * @return pointer to the KSaneOption. Returns a nullptr in case the options
     * is not available for the currently opened device.
     */
    Option *getOption(OptionName optionEnum);

/**
     * This function returns a specific option.
     * @param optionName the internal name of the option defined by SANE.
     * @return pointer to the KSaneOption. Returns a nullptr in case the options
     * is not available for the currently opened device.
     */
    Option *getOption(const QString &optionName);

/**
 * This method reads the available parameters and their values and
 * returns them in a QMap (Name, value)
 * @return map with the parameter names and their values.
 */
 QMap<QString, QString> getOptionsMap();

/**
 * This method can be used to write many parameter values at once.
 * @param options a QMap with the parameter names and values.
 * @return This function returns the number of successful writes
 * or -1 if scanning is in progress.
 */
 int setOptionsMap(const QMap<QString, QString> &options);

/**
     * Gives direct access to the QImage that is used to store the image
     * data retrieved from the scanner.
     * Useful to display an in-progress image while scanning.
     * When accessing the direct image pointer during a scan, the image
     * must be locked before accessing the image and unlocked afterwards
     * using the lockScanImage() and unlockScanImage() functions.
     * @return pointer for direct access of the QImage data.
     */
    QImage *scanImage() const;

/**
     * Locks the mutex protecting the QImage pointer of scanImage() from
     * concurrent access during scanning.
     */
    void lockScanImage();

/**
     * Unlocks the mutex protecting the QImage pointer of scanImage() from
     * concurrent access during scanning. The scanning progress will blocked
     * when lockScanImage() is called until unlockScanImage() is called.
     */
    void unlockScanImage();

public Q_SLOTS:
    /**
     * This method is used to cancel a scan or prevent an automatic new scan.
     */
    void stopScan();

/**
     * This method is used to start a scan.
     * @note CoreInterface may return one or more images as a result of one invocation of this slot.
     * If no more images are wanted stopScan() should be called in the slot handling the
     * imageReady signal.
     */
    void startScan();

Q_SIGNALS:
    /**
     * This signal is emitted when a final scan is ready.
     * @param scannedImage is the QImage containing the scanned image data.
     */
    void scannedImageReady(const QImage &scannedImage);

/**
     * This signal is emitted when the scanning has ended.
     * @param status contains a ScanStatus status code.
     * @param strStatus If an error has occurred this string will contain an error message.
     * otherwise the string is empty.
     */
    void scanFinished(KSaneCore::Interface::ScanStatus status, const QString &strStatus);

/**
     * This signal is emitted when the user is to be notified about something.
     * @param type contains a ScanStatus code to identify the type of message (error/info/...).
     * @param strStatus If an error has occurred this string will contain an error message.
     * otherwise the string is empty.
     */
    void userMessage(KSaneCore::Interface::ScanStatus status, const QString &strStatus);

/**
     * This signal is emitted for progress information during a scan.
     * @param percent is the percentage of the scan progress (0-100).
     * A negative value indicates that a scan is being prepared.
     */
    void scanProgress(int percent);

/**
 * This signal is emitted every time the device list is updated or
 * after reloadDevicesList() is called.
 * @param deviceList is a QList of KSane::DeviceInformation that contain the
 * device name, model, vendor and type of the attached scanners.
 * @note The list is only a snapshot of the current available devices. Devices
 * might be added or removed/opened after the signal is emitted.
 */
 void availableDevices(const QList<DeviceInformation *> &deviceList);

/**
     * This signal is emitted when a hardware button is pressed.
     * @param optionName is the untranslated technical name of the sane-option.
     * @param optionLabel is the translated user visible label of the sane-option.
     * @param pressed indicates if the value is true or false.
     * @note The SANE standard does not specify hardware buttons and their behaviors,
     * so this signal is emitted for sane-options that behave like hardware buttons.
     * That is the sane-options are read-only and type boolean. The naming of hardware
     * buttons also differ from backend to backend.
     */
    void buttonPressed(const QString &optionName, const QString &optionLabel, bool pressed);

/**
     * This signal is emitted for the count down when in batch mode.
     * @param remainingSeconds are the remaining seconds until the next scan starts.
     */
    void batchModeCountDown(int remainingSeconds);

private:
 std::unique_ptr<InterfacePrivate> d;
};

} // namespace KSaneCore

#endif // KSANE_COREINTERFACE_H
07070100000064000081A4000000000000000000000001660E103E0000419F000000000000000000000000000000000000004100000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/interface_p.cpp/*
 * SPDX-FileCopyrightText: 2007-2008 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2007-2008 Gilles Caulier <caulier dot gilles at gmail dot com>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "interface_p.h"

#include <QImage>
#include <QRegularExpression>

#include <ksanecore_debug.h>

#include "actionoption.h"
#include "batchdelayoption.h"
#include "batchmodeoption.h"
#include "booloption.h"
#include "doubleoption.h"
#include "gammaoption.h"
#include "integeroption.h"
#include "internaloption.h"
#include "invertoption.h"
#include "listoption.h"
#include "pagesizeoption.h"
#include "stringoption.h"

namespace KSaneCore
{

InterfacePrivate::InterfacePrivate(Interface *parent)
    : q(parent)
{
    clearDeviceOptions();

m_findDevThread = FindSaneDevicesThread::getInstance();
    connect(m_findDevThread, &FindSaneDevicesThread::finished, this, &InterfacePrivate::devicesListUpdated);
    connect(m_findDevThread, &FindSaneDevicesThread::finished, this, &InterfacePrivate::signalDevicesListUpdate);

m_auth = Authentication::getInstance();
    m_optionPollTimer.setInterval(100);
    connect(&m_optionPollTimer, &QTimer::timeout, this, &InterfacePrivate::pollPollOptions);

m_batchModeTimer.setInterval(1000);
    connect(&m_batchModeTimer, &QTimer::timeout, this, &InterfacePrivate::batchModeTimerUpdate);
}

Interface::OpenStatus InterfacePrivate::loadDeviceOptions()
{
 static const QHash<QString, Interface::OptionName> stringEnumTranslation = {
 {QStringLiteral(SANE_NAME_SCAN_SOURCE), Interface::SourceOption},
 {QStringLiteral(SANE_NAME_SCAN_MODE), Interface::ScanModeOption},
 {QStringLiteral(SANE_NAME_BIT_DEPTH), Interface::BitDepthOption},
 {QStringLiteral(SANE_NAME_SCAN_RESOLUTION), Interface::ResolutionOption},
 {QStringLiteral(SANE_NAME_SCAN_TL_X), Interface::TopLeftXOption},
 {QStringLiteral(SANE_NAME_SCAN_TL_Y), Interface::TopLeftYOption},
 {QStringLiteral(SANE_NAME_SCAN_BR_X), Interface::BottomRightXOption},
 {QStringLiteral(SANE_NAME_SCAN_BR_Y), Interface::BottomRightYOption},
 {QStringLiteral("film-type"), Interface::FilmTypeOption},
 {QStringLiteral(SANE_NAME_NEGATIVE), Interface::NegativeOption},
 {InvertColorsOptionName, Interface::InvertColorOption},
 {PageSizeOptionName, Interface::PageSizeOption},
 {QStringLiteral(SANE_NAME_THRESHOLD), Interface::ThresholdOption},
 {QStringLiteral(SANE_NAME_SCAN_X_RESOLUTION), Interface::XResolutionOption},
 {QStringLiteral(SANE_NAME_SCAN_Y_RESOLUTION), Interface::YResolutionOption},
 {QStringLiteral(SANE_NAME_PREVIEW), Interface::PreviewOption},
 {QStringLiteral("wait-for-button"), Interface::WaitForButtonOption},
 {QStringLiteral(SANE_NAME_BRIGHTNESS), Interface::BrightnessOption},
 {QStringLiteral(SANE_NAME_CONTRAST), Interface::ContrastOption},
 {QStringLiteral(SANE_NAME_GAMMA_VECTOR), Interface::GammaOption},
 {QStringLiteral(SANE_NAME_GAMMA_VECTOR_R), Interface::GammaRedOption},
 {QStringLiteral(SANE_NAME_GAMMA_VECTOR_G), Interface::GammaGreenOption},
 {QStringLiteral(SANE_NAME_GAMMA_VECTOR_B), Interface::GammaBlueOption},
 {QStringLiteral(SANE_NAME_BLACK_LEVEL), Interface::BlackLevelOption},
 {QStringLiteral(SANE_NAME_WHITE_LEVEL), Interface::WhiteLevelOption},
 {BatchModeOptionName, Interface::BatchModeOption},
 {BatchDelayOptionName, Interface::BatchDelayOption},
 };

const SANE_Option_Descriptor *optDesc;
    SANE_Status status;
    SANE_Word numSaneOptions;
    SANE_Int res;
    // update the device list if needed to get the vendor and model info
    if (m_findDevThread->devicesList().size() == 0) {
        m_findDevThread->start();
    } else {
        // use the "old" existing list
        devicesListUpdated();
        // if m_vendor is not updated it means that the list needs to be updated.
        if (m_vendor.isEmpty()) {
            m_findDevThread->start();
        }
    }

// Read the options (start with option 0 the number of parameters)
 optDesc = sane_get_option_descriptor(m_saneHandle, 0);
 if (optDesc == nullptr) {
 m_auth->clearDeviceAuth(m_devName);
 m_devName.clear();
 return Interface::OpeningFailed;
 }
 QVarLengthArray<char> data(optDesc->size);
 status = sane_control_option(m_saneHandle, 0, SANE_ACTION_GET_VALUE, data.data(), &res);
 if (status != SANE_STATUS_GOOD) {
 m_auth->clearDeviceAuth(m_devName);
 m_devName.clear();
 return Interface::OpeningFailed;
 }
 numSaneOptions = *reinterpret_cast<SANE_Word *>(data.data());

// read the rest of the options
 BaseOption *option = nullptr;
 BaseOption *optionTopLeftX = nullptr;
 BaseOption *optionTopLeftY = nullptr;
 BaseOption *optionBottomRightX = nullptr;
 BaseOption *optionBottomRightY = nullptr;
 BaseOption *optionResolution = nullptr;
 m_optionsList.reserve(numSaneOptions);
 m_externalOptionsList.reserve(numSaneOptions);
 for (int i = 1; i < numSaneOptions; ++i) {
 switch (BaseOption::optionType(sane_get_option_descriptor(m_saneHandle, i))) {
 case Option::TypeDetectFail:
 option = new BaseOption(m_saneHandle, i);
 break;
 case Option::TypeBool:
 option = new BoolOption(m_saneHandle, i);
 break;
 case Option::TypeInteger:
 option = new IntegerOption(m_saneHandle, i);
 break;
 case Option::TypeDouble:
 option = new DoubleOption(m_saneHandle, i);
 break;
 case Option::TypeValueList:
 option = new ListOption(m_saneHandle, i);
 break;
 case Option::TypeString:
 option = new StringOption(m_saneHandle, i);
 break;
 case Option::TypeGamma:
 option = new GammaOption(m_saneHandle, i);
 break;
 case Option::TypeAction:
 option = new ActionOption(m_saneHandle, i);
 break;
 }
 option->readOption();
 option->readValue();

if (option->name() == QStringLiteral(SANE_NAME_SCAN_TL_X)) {
            optionTopLeftX = option;
        }
        if (option->name() == QStringLiteral(SANE_NAME_SCAN_TL_Y)) {
            optionTopLeftY = option;
        }
        if (option->name() == QStringLiteral(SANE_NAME_SCAN_BR_X)) {
            optionBottomRightX = option;
        }
        if (option->name() == QStringLiteral(SANE_NAME_SCAN_BR_Y)) {
            optionBottomRightY = option;
        }
        if (option->name() == QStringLiteral(SANE_NAME_SCAN_RESOLUTION)) {
            optionResolution = option;
        }
        if (option->name() == QStringLiteral(SANE_NAME_SCAN_SOURCE)) {
            // some scanners only have ADF and never update the source name
            determineMultiPageScanning(option->value());
            connect(option, &BaseOption::valueChanged, this, &InterfacePrivate::determineMultiPageScanning);
        }
        if (option->name() == QStringLiteral("wait-for-button")) {
            connect(option, &BaseOption::valueChanged, this, &InterfacePrivate::setWaitForExternalButton);
        }

m_optionsList.append(option);
        m_externalOptionsList.append(new InternalOption(option));
        connect(option, &BaseOption::optionsNeedReload, this, &InterfacePrivate::reloadOptions);
        connect(option, &BaseOption::valuesNeedReload, this, &InterfacePrivate::scheduleValuesReload);

if (option->needsPolling()) {
            m_optionsPollList.append(option);
            if (option->type() == Option::TypeBool) {
                connect(option, &BaseOption::valueChanged, this, [=](const QVariant &newValue) {
                    Q_EMIT q->buttonPressed(option->name(), option->title(), newValue.toBool());
                });
            }
        }
        const auto it = stringEnumTranslation.find(option->name());
        if (it != stringEnumTranslation.constEnd()) {
            m_optionsLocation.insert(it.value(), i - 1);
        }
    }

// add extra option for selecting specific page sizes
    BaseOption *pageSizeOption = new PageSizeOption(optionTopLeftX, optionTopLeftY, optionBottomRightX, optionBottomRightY, optionResolution);
    m_optionsList.append(pageSizeOption);
    m_externalOptionsList.append(new InternalOption(pageSizeOption));
    m_optionsLocation.insert(Interface::PageSizeOption, m_optionsList.size() - 1);

// add extra option for batch mode scanning with a delay
    m_batchMode = new BatchModeOption();
    m_optionsList.append(m_batchMode);
    m_externalOptionsList.append(new InternalOption(m_batchMode));
    m_optionsLocation.insert(Interface::BatchModeOption, m_optionsList.size() - 1);
    m_batchModeDelay = new BatchDelayOption();
    m_optionsList.append(m_batchModeDelay);
    m_externalOptionsList.append(new InternalOption(m_batchModeDelay));
    m_optionsLocation.insert(Interface::BatchDelayOption, m_optionsList.size() - 1);

// add extra option for inverting image colors
    BaseOption *invertOption = new InvertOption();
    m_optionsList.append(invertOption);
    m_externalOptionsList.append(new InternalOption(invertOption));
    m_optionsLocation.insert(Interface::InvertColorOption, m_optionsList.size() - 1);

// NOTICE The Pixma network backend behaves badly. polling a value will result in 1 second
    // sleeps for every poll. The problem has been reported, but no easy/quick fix was available and
    // the bug has been there for multiple years. Since this destroys the usability of the backend totally,
    // we simply put the backend on the naughty list and disable the option polling.
    static QRegularExpression pixmaNetworkBackend(QStringLiteral("pixma.*\\d+\\.\\d+\\.\\d+\\.\\d+"));
    m_optionPollingNaughtylisted = false;
    if (pixmaNetworkBackend.match(m_devName).hasMatch()) {
        m_optionPollingNaughtylisted = true;
    }

// start polling the poll options
    if (m_optionsPollList.size() > 0 && !m_optionPollingNaughtylisted) {
        m_optionPollTimer.start();
    }

// Create the scan thread
    m_scanThread = new ScanThread(m_saneHandle);

m_scanThread->setImageInverted(invertOption->value());
    connect(invertOption, &InvertOption::valueChanged, m_scanThread, &ScanThread::setImageInverted);

if (optionResolution != nullptr) {
        m_scanThread->setImageResolution(optionResolution->value());
        connect(optionResolution, &BaseOption::valueChanged, m_scanThread, &ScanThread::setImageResolution);
    }

connect(m_scanThread, &ScanThread::scanProgressUpdated, q, &Interface::scanProgress);
    connect(m_scanThread, &ScanThread::finished, this, &InterfacePrivate::imageScanFinished);

// try to set to default values
    setDefaultValues();
    return Interface::OpeningSucceeded;
}

void InterfacePrivate::clearDeviceOptions()
{
    // delete all the options in the list.
    while (!m_optionsList.isEmpty()) {
        delete m_optionsList.takeFirst();
        delete m_externalOptionsList.takeFirst();
    }

m_optionsLocation.clear();
    m_optionsPollList.clear();
    m_optionPollTimer.stop();

m_devName.clear();
    m_model.clear();
    m_vendor.clear();
    m_batchMode = nullptr;
    m_batchModeDelay = nullptr;
}

void InterfacePrivate::devicesListUpdated()
{
 if (m_vendor.isEmpty()) {
 const QList<DeviceInformation *> deviceList = m_findDevThread->devicesList();
 for (const auto &device : deviceList) {
 if (device->name() == m_devName) {
 m_vendor = device->vendor();
 m_model = device->model();
 break;
 }
 }
 }
}

void InterfacePrivate::signalDevicesListUpdate()
{
    Q_EMIT q->availableDevices(m_findDevThread->devicesList());
}

void InterfacePrivate::setDefaultValues()
{
    Option *option;

// Try to get Color mode by default
    if ((option = q->getOption(Interface::ScanModeOption)) != nullptr) {
        option->setValue(sane_i18n(SANE_VALUE_SCAN_MODE_COLOR));
    }

// Try to set 8 bit color
    if ((option = q->getOption(Interface::BitDepthOption)) != nullptr) {
        option->setValue(8);
    }

// Try to set Scan resolution to 300 DPI
    if ((option = q->getOption(Interface::ResolutionOption)) != nullptr) {
        option->setValue(300);
    }
}

void InterfacePrivate::scheduleValuesReload()
{
    m_readValuesTimer.start(5);
}

void InterfacePrivate::reloadOptions()
{
    for (const auto option : qAsConst(m_optionsList)) {
        option->readOption();
        // Also read the values
        option->readValue();
    }
}

void InterfacePrivate::reloadValues()
{
    for (const auto option : qAsConst(m_optionsList)) {
        option->readValue();
    }
}

void InterfacePrivate::pollPollOptions()
{
 for (int i = 1; i < m_optionsPollList.size(); ++i) {
 m_optionsPollList.at(i)->readValue();
 }
}

void InterfacePrivate::imageScanFinished()
{
 Q_EMIT q->scanProgress(100);
 if (m_scanThread->frameStatus() == ScanThread::ReadReady) {
 Q_EMIT q->scannedImageReady(*m_scanThread->scanImage());
 // now check if we should have automatic ADF batch scanning
 if (m_executeMultiPageScanning && !m_cancelMultiPageScan) {
 // in batch mode only one area can be scanned per page
 Q_EMIT q->scanProgress(-1);
 m_scanThread->start();
 return;
 }
 // check if we should have timed batch scanning
 if (m_batchMode->value().toBool() && !m_cancelMultiPageScan) {
 // in batch mode only one area can be scanned per page
 m_batchModeCounter = 0;
 batchModeTimerUpdate();
 m_batchModeTimer.start();
 return;
 }
 // Check if we have a "wait for button" batch scanning
 if (m_waitForExternalButton) {
 qCDebug(KSANECORE_LOG) << "waiting for external button press to start next scan";
 Q_EMIT q->scanProgress(-1);
 m_scanThread->start();
 return;
 }
 scanIsFinished(Interface::NoError, QString());
 } else {
 switch (m_scanThread->saneStatus()) {
 case SANE_STATUS_GOOD:
 case SANE_STATUS_CANCELLED:
 case SANE_STATUS_EOF:
 scanIsFinished(Interface::NoError, sane_i18n(sane_strstatus(m_scanThread->saneStatus())));
 break;
 case SANE_STATUS_NO_DOCS:
 Q_EMIT q->userMessage(Interface::Information, sane_i18n(sane_strstatus(m_scanThread->saneStatus())));
 scanIsFinished(Interface::Information, sane_i18n(sane_strstatus(m_scanThread->saneStatus())));
 break;
 case SANE_STATUS_UNSUPPORTED:
 case SANE_STATUS_IO_ERROR:
 case SANE_STATUS_NO_MEM:
 case SANE_STATUS_INVAL:
 case SANE_STATUS_JAMMED:
 case SANE_STATUS_COVER_OPEN:
 case SANE_STATUS_DEVICE_BUSY:
 case SANE_STATUS_ACCESS_DENIED:
 Q_EMIT q->userMessage(Interface::ErrorGeneral, sane_i18n(sane_strstatus(m_scanThread->saneStatus())));
 scanIsFinished(Interface::ErrorGeneral, sane_i18n(sane_strstatus(m_scanThread->saneStatus())));
 break;
 }
 }
}

void InterfacePrivate::scanIsFinished(Interface::ScanStatus status, const QString &message)
{
    sane_cancel(m_saneHandle);
    if (m_optionsPollList.size() > 0 && !m_optionPollingNaughtylisted) {
        m_optionPollTimer.start();
    }

Q_EMIT q->scanFinished(status, message);
}

void InterfacePrivate::determineMultiPageScanning(const QVariant &value)
{
    const QString sourceString = value.toString();

m_executeMultiPageScanning = sourceString.contains(QStringLiteral("Automatic Document Feeder"))
        || sourceString.contains(sane_i18n("Automatic Document Feeder")) || sourceString.contains(QStringLiteral("ADF"))
        || sourceString.contains(QStringLiteral("Duplex"));
}

void InterfacePrivate::setWaitForExternalButton(const QVariant &value)
{
    m_waitForExternalButton = value.toBool();
}

void InterfacePrivate::batchModeTimerUpdate()
{
    const int delay = m_batchModeDelay->value().toInt();
    Q_EMIT q->batchModeCountDown(delay - m_batchModeCounter);
    if (m_batchModeCounter >= delay) {
        m_batchModeCounter = 0;
        if (m_scanThread != nullptr) {
            Q_EMIT q->scanProgress(-1);
            m_scanThread->start();
        }
        m_batchModeTimer.stop();
    }
    m_batchModeCounter++;
}

} // NameSpace KSaneCore

#include "moc_interface_p.cpp"
07070100000065000081A4000000000000000000000001660E103E00000A34000000000000000000000000000000000000003F00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/interface_p.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_CORE_PRIVATE_H
#define KSANE_CORE_PRIVATE_H

#include <QHash>
#include <QList>
#include <QSet>
#include <QTime>
#include <QTimer>
#include <QVarLengthArray>
#include <QVector>

#include "authentication.h"
#include "baseoption.h"
#include "finddevicesthread.h"
#include "interface.h"
#include "scanthread.h"

/** This namespace collects all methods and classes in LibKSane. */
namespace KSaneCore
{

class InterfacePrivate : public QObject
{
    Q_OBJECT

public:
    explicit InterfacePrivate(Interface *parent);
    Interface::OpenStatus loadDeviceOptions();
    void clearDeviceOptions();
    void setDefaultValues();

void scanIsFinished(Interface::ScanStatus status, const QString &message);

public Q_SLOTS:
    void devicesListUpdated();
    void signalDevicesListUpdate();
    void imageScanFinished();
    void scheduleValuesReload();
    void reloadOptions();
    void reloadValues();

private Q_SLOTS:
    void determineMultiPageScanning(const QVariant &value);
    void setWaitForExternalButton(const QVariant &value);
    void pollPollOptions();
    void batchModeTimerUpdate();

public:
    // device info
    SANE_Handle m_saneHandle = nullptr;
    QString m_devName;
    QString m_vendor;
    QString m_model;

// Option variables
 QList<BaseOption *> m_optionsList;
 QList<Option *> m_externalOptionsList;
 QHash<Interface::OptionName, int> m_optionsLocation;
 QList<BaseOption *> m_optionsPollList;
 QTimer m_readValuesTimer;
 QTimer m_optionPollTimer;
 bool m_optionPollingNaughtylisted = false;

QString m_saneUserName;
    QString m_sanePassword;

ScanThread *m_scanThread = nullptr;
    FindSaneDevicesThread *m_findDevThread;
    Authentication *m_auth;
    Interface *q;

// state variables
    // determines whether scanner will send multiple images
    bool m_executeMultiPageScanning = false;
    // scanning has been cancelled externally
    bool m_cancelMultiPageScan = false;
    // next scanning will start with a hardware button press
    bool m_waitForExternalButton = false;
    // batch mode options
    BaseOption *m_batchMode = nullptr;
    BaseOption *m_batchModeDelay = nullptr;
    QTimer m_batchModeTimer;
    int m_batchModeCounter = 0;
};

} // NameSpace KSaneCore

#endif // KSANE_CORE_PRIVATE_H
07070100000066000081A4000000000000000000000001660E103E000002B1000000000000000000000000000000000000004400000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/internaloption.cpp/*
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "internaloption.h"
#include "option_p.h"

namespace KSaneCore
{

InternalOption::InternalOption(BaseOption *option, QObject *parent)
    : Option(parent)
{
    d->option = option;
    connect(d->option, &BaseOption::optionReloaded, this, &Option::optionReloaded);
    connect(d->option, &BaseOption::valueChanged, this, &Option::valueChanged);
    connect(d->option, &BaseOption::destroyed, this, [=]() {
        d->option = nullptr;
    });
}

} // namespace KSaneCore

#include "moc_internaloption.cpp"
07070100000067000081A4000000000000000000000001660E103E000001FF000000000000000000000000000000000000004200000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/internaloption.h/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_INTERNAL_OPTION_H
#define KSANE_INTERNAL_OPTION_H

#include "baseoption.h"
#include "option.h"

namespace KSaneCore
{

class InternalOption : public Option
{
    Q_OBJECT

public:

explicit InternalOption(BaseOption *option, QObject *parent = nullptr);

};

} // namespace KSaneCore

#endif // KSANE_INTERNAL_OPTION_H

07070100000068000081A4000000000000000000000001660E103E00000BC9000000000000000000000000000000000000003C00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/option.cpp/*
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "option.h"
#include "baseoption.h"
#include "option_p.h"

#include <ksanecore_debug.h>

namespace KSaneCore
{

Option::Option(QObject *parent)
 : QObject(parent)
 , d(std::make_unique<OptionPrivate>())
{
}

Option::~Option() = default;

Option::OptionState Option::state() const
{
    if (d->option != nullptr) {
        return d->option->state();
    } else {
        return StateDisabled;
    }
}

QString Option::name() const
{
    if (d->option != nullptr) {
        return d->option->name();
    } else {
        return QString();
    }
}

QString Option::title() const
{
    if (d->option != nullptr) {
        return d->option->title();
    } else {
        return QString();
    }
}

QString Option::description() const
{
    if (d->option != nullptr) {
        return d->option->description();
    } else {
        return QString();
    }
}

Option::OptionType Option::type() const
{
    if (d->option != nullptr) {
        return d->option->type();
    } else {
        return TypeDetectFail;
    }
}

QVariant Option::minimumValue() const
{
    if (d->option != nullptr) {
        return d->option->minimumValue();
    } else {
        return QVariant();
    }
}

QVariant Option::maximumValue() const
{
    if (d->option != nullptr) {
        return d->option->maximumValue();
    } else {
        return QVariant();
    }
}

QVariant Option::stepValue() const
{
    if (d->option != nullptr) {
        return d->option->stepValue();
    } else {
        return QVariant();
    }
}

QVariantList Option::valueList() const
{
    if (d->option != nullptr) {
        return d->option->valueList();
    } else {
        return QVariantList();
    }
}

QVariantList Option::internalValueList() const
{
    if (d->option != nullptr) {
        return d->option->internalValueList();
    } else {
        return QVariantList();
    }
}

QVariant Option::value() const
{
    if (d->option != nullptr) {
        return d->option->value();
    } else {
        return QVariant();
    }
}

Option::OptionUnit Option::valueUnit() const
{
    if (d->option != nullptr) {
        return d->option->valueUnit();
    } else {
        return UnitNone;
    }
}

int Option::valueSize() const
{
    if (d->option != nullptr) {
        return d->option->valueSize();
    } else {
        return 0;
    }
}

bool Option::setValue(const QVariant &value)
{
    if (d->option != nullptr) {
        return d->option->setValue(value);
    } else {
        return false;
    }
}

bool Option::storeCurrentData()
{
    if (d->option != nullptr) {
        return d->option->storeCurrentData();
    } else {
        return false;
    }
}

bool Option::restoreSavedData()
{
    if (d->option != nullptr) {
        return d->option->restoreSavedData();
    } else {
        return false;
    }
}

} // namespace KSaneCore

#include "moc_option.cpp"
07070100000069000081A4000000000000000000000001660E103E000014DC000000000000000000000000000000000000003A00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/option.h/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_COREOPTION_H
#define KSANE_COREOPTION_H

#include <memory>

// Qt includes

#include "ksanecore_export.h"
#include <QObject>
#include <QString>
#include <QVariant>

namespace KSaneCore
{

class OptionPrivate;

/**
 * A wrapper class providing access to the internal KSaneBaseOption
 * to access all options provided by KSANECore/SANE
 */
class KSANECORE_EXPORT Option : public QObject
{
    Q_OBJECT

public:
    /** This enumeration describes the type of the option. */
    enum OptionType { TypeDetectFail, TypeBool, TypeInteger, TypeDouble, TypeValueList, TypeString, TypeGamma, TypeAction };

Q_ENUM(OptionType)

/** This enumeration describes the unit of the value of the option,
     * if any. */
    enum OptionUnit { UnitNone, UnitPixel, UnitBit, UnitMilliMeter, UnitDPI, UnitPercent, UnitMicroSecond, UnitSecond };

Q_ENUM(OptionUnit)

/** This enumeration describes the current statue of the value of
     * the option, indicating if this option should be displayed or not. */
    enum OptionState { StateHidden, StateDisabled, StateActive };

Q_ENUM(OptionState)

explicit Option(QObject *parent = nullptr);
    ~Option() override;

/** This function returns the internal name of the option
     * @return the internal name */
    QString name() const;

/** This function returns the translated title of the option
     * @return the title */
    QString title() const;

/** This function returns a more verbose, translated description
     * of the option.
     * @return the description */
    QString description() const;

/** This function the type of the option as determined by KSANECore.
     * Each type provides a different implementation for different
     * variable types, e.g. integer, float or string.
     * @return the type of option the of value OptionType */
    OptionType type() const;

/** This function returns the state of the option indicating
     * if the function is disabled or should be hidden.
     * @return the state of option the of value OptionState */
    OptionState state() const;

/** This function returns the currently active value for the option.
     * @return the current value */
    QVariant value() const;

/** This function returns the minimum value for the option.
     * Returns an empty QVariant if this value is not applicable
     * for the option type.
     * @return the minimum value */
    QVariant minimumValue() const;

/** This function returns the maximum value for the option.
     * Returns an empty QVariant if this value is not applicable
     * for the option type.
     * @return the maximum value */
    QVariant maximumValue() const;

/** This function returns the step value for the option.
     * Returns an empty QVariant if this value is not applicable
     * for the option type.
     * @return the step value */
    QVariant stepValue() const;

/** This function returns the list of possible values if the option
     * is of type OptionType::TypeValueList. The list may contain
     * formatted or translated values.
     * @return a list with all possible values */
    QVariantList valueList() const;

/** This function returns the list of possible values if the option
     * is of type OptionType::TypeValueList. The list contains the raw
     * internal values without any formatting or translation.
     * @return a list with all possible internal values */
    QVariantList internalValueList() const;

/** This function returns an enum specifying whether the values
     * of the option have a unit, e.g. mm, px, etc.
     * @return unit of value CoreOptionUnit */
    OptionUnit valueUnit() const;

/** This function returns the size of the values of the option
     * of type CoreOptionType::TypeValueList.
     * If the size is greater than one, value() and setValue()
     * return and expect a QVariantList with an accordingly number
     * of elements. If the option is a CoreOptionType::TypeString,
     * the size represents the number of characters in the string.
     * @return the number of elements */
    int valueSize() const;

/** This function temporarily stores the current value
     * in a member variable. */
    bool storeCurrentData();

/** This function restores the previously saved value
     * and makes it the current value. */
    bool restoreSavedData();

Q_SIGNALS:
    /** This signal is emitted when the option is reloaded, which may
     * happen if the value of other options has changed. */
    void optionReloaded();

/** This signal is emitted when the current value is updated,
     * either when a user sets a new value or by a reload by the backend. */
    void valueChanged(const QVariant &value);

public Q_SLOTS:

/** This slot allows to change the current value of the option.
     * @param value the new value of option inside a QVariant.
     * In case the variant cannot be cast to a value suitable for
     * the specific option, the value is discarded. */
    bool setValue(const QVariant &value);

protected:
 std::unique_ptr<KSaneCore::OptionPrivate> d;
};

} // namespace KSaneCore

#endif // KSANE_COREOPTION_H
0707010000006A000081A4000000000000000000000001660E103E0000018C000000000000000000000000000000000000003C00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/option_p.h/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_COREOPTION_P_H
#define KSANE_COREOPTION_P_H

#include "baseoption.h"

namespace KSaneCore
{

class OptionPrivate
{
public:
    BaseOption *option;
};

} // namespace KSaneCore

#endif // KSANE_COREOPTION_P_H
0707010000006B000041ED000000000000000000000002660E103E00000000000000000000000000000000000000000000003900000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options0707010000006C000081A4000000000000000000000001660E103E00000286000000000000000000000000000000000000004A00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/actionoption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "actionoption.h"

#include <ksanecore_debug.h>

namespace KSaneCore
{

ActionOption::ActionOption(const SANE_Handle handle, const int index)
    : BaseOption(handle, index)
{
    m_optionType = Option::TypeAction;
}

bool ActionOption::setValue(const QVariant &)
{
    unsigned char data[4];
    writeData(data);
    return true;
}

} // namespace KSaneCore

#include "moc_actionoption.cpp"
0707010000006D000081A4000000000000000000000001660E103E00000219000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/actionoption.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_ACTION_OPTION_H
#define KSANE_ACTION_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

class ActionOption : public BaseOption
{
    Q_OBJECT

public:
    ActionOption(const SANE_Handle handle, const int index);

public Q_SLOTS:
    bool setValue(const QVariant &value) override;
};

} // namespace KSaneCore

#endif // KSANE_ACTION_OPTION_H
0707010000006E000081A4000000000000000000000001660E103E000026B8000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/baseoption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "baseoption.h"

#include <ksanecore_debug.h>

namespace KSaneCore
{

BaseOption::BaseOption() : QObject()
{
}

BaseOption::BaseOption(const SANE_Handle handle, const int index)
    : QObject(), m_handle(handle), m_index(index)
{
}

BaseOption::~BaseOption()
{
    if (m_data) {
        free(m_data);
        m_data = nullptr;
    }
}

void BaseOption::readOption()
{
    beginOptionReload();
    endOptionReload();
}

void BaseOption::beginOptionReload()
{
    if (m_handle != nullptr) {
        m_optDesc = sane_get_option_descriptor(m_handle, m_index);
    }
}

void BaseOption::endOptionReload()
{
    Q_EMIT optionReloaded();
}

Option::OptionState BaseOption::state() const
{
    if (m_optDesc == nullptr) {
        return Option::StateHidden;
    }

if (((m_optDesc->cap & SANE_CAP_SOFT_DETECT) == 0) || (m_optDesc->cap & SANE_CAP_INACTIVE) || ((m_optDesc->size == 0) && (type() != Option::TypeAction))) {
        return Option::StateHidden;
    } else if ((m_optDesc->cap & SANE_CAP_SOFT_SELECT) == 0) {
        return Option::StateDisabled;
    }
    return Option::StateActive;
}

bool BaseOption::needsPolling() const
{
    if (!m_optDesc) {
        return false;
    }

if ((m_optDesc->cap & SANE_CAP_SOFT_DETECT) && !(m_optDesc->cap & SANE_CAP_SOFT_SELECT)) {
 qCDebug(KSANECORE_LOG) << name() << "optDesc->cap =" << m_optDesc->cap;
 return true;
 }

return false;
}

QString BaseOption::name() const
{
    if (m_optDesc == nullptr) {
        return QString();
    }
    return QString::fromUtf8(m_optDesc->name);
}

QString BaseOption::title() const
{
    if (m_optDesc == nullptr) {
        return QString();
    }
    return sane_i18n(m_optDesc->title);
}

QString BaseOption::description() const
{
    if (m_optDesc == nullptr) {
        return QString();
    }
    return sane_i18n(m_optDesc->desc);
}

Option::OptionType BaseOption::type() const
{
    return m_optionType;
}

bool BaseOption::writeData(void *data)
{
    SANE_Status status;
    SANE_Int res;

if (state() == Option::StateDisabled) {
        return false;
    }

status = sane_control_option(m_handle, m_index, SANE_ACTION_SET_VALUE, data, &res);
 if (status != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << m_optDesc->name << "sane_control_option returned:" << sane_strstatus(status);
 // write failed. re read the current setting
 readValue();
 return false;
 }
 if (res & SANE_INFO_INEXACT) {
 //qCDebug(KSANECORE_LOG) << "write was inexact. Reload value just in case...";
 readValue();
 }

if (res & SANE_INFO_RELOAD_OPTIONS) {
        Q_EMIT optionsNeedReload();
        // optReload reloads also the values
    } else if (res & SANE_INFO_RELOAD_PARAMS) {
        // 'else if' because with optReload we force also valReload :)
        Q_EMIT valuesNeedReload();
    }

return true;
}

void BaseOption::readValue() {}

SANE_Word BaseOption::toSANE_Word(unsigned char *data)
{
 SANE_Word tmp;
 // if __BYTE_ORDER is not defined we get #if 0 == 0
#if __BYTE_ORDER == __LITTLE_ENDIAN
 tmp = (data[0] & 0xff);
 tmp += ((SANE_Word)(data[1] & 0xff)) << 8;
 tmp += ((SANE_Word)(data[2] & 0xff)) << 16;
 tmp += ((SANE_Word)(data[3] & 0xff)) << 24;
#else
 tmp = (data[3] & 0xff);
 tmp += ((SANE_Word)(data[2] & 0xff)) << 8;
 tmp += ((SANE_Word)(data[1] & 0xff)) << 16;
 tmp += ((SANE_Word)(data[0] & 0xff)) << 24;
#endif
 return tmp;
}

void BaseOption::fromSANE_Word(unsigned char *data, SANE_Word from)
{
    // if __BYTE_ORDER is not defined we get #if 0 == 0
#if __BYTE_ORDER == __LITTLE_ENDIAN
    data[0] = (from & 0x000000FF);
    data[1] = (from & 0x0000FF00) >> 8;
    data[2] = (from & 0x00FF0000) >> 16;
    data[3] = (from & 0xFF000000) >> 24;
#else
    data[3] = (from & 0x000000FF);
    data[2] = (from & 0x0000FF00) >> 8;
    data[1] = (from & 0x00FF0000) >> 16;
    data[0] = (from & 0xFF000000) >> 24;
#endif
}

QVariant BaseOption::value() const
{
    return QVariant();
}

QVariant BaseOption::minimumValue() const
{
    return QVariant();
}

QVariant BaseOption::maximumValue() const
{
    return QVariant();
}

QVariant BaseOption::stepValue() const
{
    return QVariant();
}

QVariantList BaseOption::valueList() const
{
    return QVariantList();
}

QVariantList BaseOption::internalValueList() const
{
    return QVariantList();
}

Option::OptionUnit BaseOption::valueUnit() const
{
    if (m_optDesc != nullptr) {
        switch (m_optDesc->unit) {
        case SANE_UNIT_PIXEL:
            return Option::UnitPixel;
        case SANE_UNIT_BIT:
            return Option::UnitBit;
        case SANE_UNIT_MM:
            return Option::UnitMilliMeter;
        case SANE_UNIT_DPI:
            return Option::UnitDPI;
        case SANE_UNIT_PERCENT:
            return Option::UnitPercent;
        case SANE_UNIT_MICROSECOND:
            return Option::UnitMicroSecond;
        default:
            return Option::UnitNone;
        }
    } else {
        return Option::UnitNone;
    }
}

int BaseOption::valueSize() const
{
    if (m_optDesc != nullptr) {
        return m_optDesc->size / sizeof(SANE_Word);
    }
    return 0;
}

QString BaseOption::valueAsString() const
{
    return QString();
}

bool BaseOption::setValue(const QVariant &)
{
    return false;
}

bool BaseOption::storeCurrentData()
{
    SANE_Status status;
    SANE_Int res;

// check if we can read the value
    if (state() == Option::StateHidden) {
        return false;
    }

// read that current value
 if (m_data != nullptr) {
 free(m_data);
 }
 m_data = (unsigned char *)malloc(m_optDesc->size);
 status = sane_control_option(m_handle, m_index, SANE_ACTION_GET_VALUE, m_data, &res);
 if (status != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << m_optDesc->name << "sane_control_option returned" << status;
 return false;
 }
 return true;
}

bool BaseOption::restoreSavedData()
{
    // check if we have saved any data
    if (m_data == nullptr) {
        return false;
    }

// check if we can write the value
    if (state() == Option::StateHidden) {
        return false;
    }
    if (state() == Option::StateDisabled) {
        return false;
    }

writeData(m_data);
    readValue();
    return true;
}

Option::OptionType BaseOption::optionType(const SANE_Option_Descriptor *optDesc)
{
    if (!optDesc) {
        return Option::TypeDetectFail;
    }

switch (optDesc->constraint_type) {
 case SANE_CONSTRAINT_NONE:
 switch (optDesc->type) {
 case SANE_TYPE_BOOL:
 return Option::TypeBool;
 case SANE_TYPE_INT:
 if (optDesc->size == sizeof(SANE_Word)) {
 return Option::TypeInteger;
 }
 qCDebug(KSANECORE_LOG) << "Can not handle:" << optDesc->title;
 qCDebug(KSANECORE_LOG) << "SANE_CONSTRAINT_NONE && SANE_TYPE_INT";
 qCDebug(KSANECORE_LOG) << "size" << optDesc->size << "!= sizeof(SANE_Word)";
 break;
 case SANE_TYPE_FIXED:
 if (optDesc->size == sizeof(SANE_Word)) {
 return Option::TypeDouble;
 }
 qCDebug(KSANECORE_LOG) << "Can not handle:" << optDesc->title;
 qCDebug(KSANECORE_LOG) << "SANE_CONSTRAINT_NONE && SANE_TYPE_FIXED";
 qCDebug(KSANECORE_LOG) << "size" << optDesc->size << "!= sizeof(SANE_Word)";
 break;
 case SANE_TYPE_BUTTON:
 return Option::TypeAction;
 case SANE_TYPE_STRING:
 return Option::TypeString;
 case SANE_TYPE_GROUP:
 return Option::TypeDetectFail;
 }
 break;
 case SANE_CONSTRAINT_RANGE:
 switch (optDesc->type) {
 case SANE_TYPE_BOOL:
 return Option::TypeBool;
 case SANE_TYPE_INT:
 if (optDesc->size == sizeof(SANE_Word)) {
 return Option::TypeInteger;
 }

if ((strcmp(optDesc->name, SANE_NAME_GAMMA_VECTOR) == 0) ||
 (strcmp(optDesc->name, SANE_NAME_GAMMA_VECTOR_R) == 0) ||
 (strcmp(optDesc->name, SANE_NAME_GAMMA_VECTOR_G) == 0) ||
 (strcmp(optDesc->name, SANE_NAME_GAMMA_VECTOR_B) == 0)) {
 return Option::TypeGamma;
 }
 qCDebug(KSANECORE_LOG) << "Can not handle:" << optDesc->title;
 qCDebug(KSANECORE_LOG) << "SANE_CONSTRAINT_RANGE && SANE_TYPE_INT && !SANE_NAME_GAMMA_VECTOR...";
 qCDebug(KSANECORE_LOG) << "size" << optDesc->size << "!= sizeof(SANE_Word)";
 break;
 case SANE_TYPE_FIXED:
 if (optDesc->size == sizeof(SANE_Word)) {
 return Option::TypeDouble;
 }
 qCDebug(KSANECORE_LOG) << "Can not handle:" << optDesc->title;
 qCDebug(KSANECORE_LOG) << "SANE_CONSTRAINT_RANGE && SANE_TYPE_FIXED";
 qCDebug(KSANECORE_LOG) << "size" << optDesc->size << "!= sizeof(SANE_Word)";
 qCDebug(KSANECORE_LOG) << "Analog Gamma vector?";
 break;
 case SANE_TYPE_STRING:
 qCDebug(KSANECORE_LOG) << "Can not handle:" << optDesc->title;
 qCDebug(KSANECORE_LOG) << "SANE_CONSTRAINT_RANGE && SANE_TYPE_STRING";
 return Option::TypeDetectFail;
 case SANE_TYPE_BUTTON:
 return Option::TypeAction;
 case SANE_TYPE_GROUP:
 return Option::TypeDetectFail;
 }
 break;
 case SANE_CONSTRAINT_WORD_LIST:
 case SANE_CONSTRAINT_STRING_LIST:
 return Option::TypeValueList;
 }
 return Option::TypeDetectFail;
}

} // namespace KSaneCore

#include "moc_baseoption.cpp"
0707010000006F000081A4000000000000000000000001660E103E00000997000000000000000000000000000000000000004600000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/baseoption.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_BASE_OPTION_H
#define KSANE_BASE_OPTION_H

// Qt includes
#include <QObject>

//KDE includes

#include <KLocalizedString>

// Sane includes
extern "C"
{
#include <sane/sane.h>
#include <sane/saneopts.h>
}

#include "../option.h"

#define SANE_TRANSLATION_DOMAIN "sane-backends"

namespace KSaneCore
{

inline QString sane_i18n(const char *text) {
    return i18nd(SANE_TRANSLATION_DOMAIN, text);
}

class BaseOption : public QObject
{
    Q_OBJECT

public:

BaseOption();
    BaseOption(const SANE_Handle handle, const int index);
    ~BaseOption() override;
    static Option::OptionType optionType(const SANE_Option_Descriptor *optDesc);

bool needsPolling() const;
    virtual void readOption();
    virtual void readValue();

virtual QString name() const;
    virtual QString title() const;
    virtual QString description() const;
    virtual Option::OptionType type() const;
    virtual Option::OptionState state() const;
    virtual QVariant minimumValue() const;
    virtual QVariant maximumValue() const;
    virtual QVariant stepValue() const;
    virtual QVariant value() const;
    virtual QVariantList valueList() const;
    virtual QVariantList internalValueList() const;
    virtual Option::OptionUnit valueUnit() const;
    virtual int valueSize() const;
    virtual QString valueAsString() const;

bool storeCurrentData();
    bool restoreSavedData();

Q_SIGNALS:
    void optionsNeedReload();
    void valuesNeedReload();
    void optionReloaded();
    void valueChanged(const QVariant &value);

public Q_SLOTS:

virtual bool setValue(const QVariant &value);

protected:

static SANE_Word toSANE_Word(unsigned char *data);
    static void fromSANE_Word(unsigned char *data, SANE_Word from);
    bool writeData(void *data);
    void beginOptionReload();
    void endOptionReload();

SANE_Handle m_handle = nullptr;
 int m_index = -1;
 const SANE_Option_Descriptor *m_optDesc = nullptr; ///< This pointer is provided by sane
 unsigned char *m_data= nullptr;
 Option::OptionType m_optionType = Option::TypeDetectFail;
};

} // namespace KSaneCore

#endif // KSANE_BASE_OPTION_H

07070100000070000081A4000000000000000000000001660E103E000005DE000000000000000000000000000000000000004E00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/batchdelayoption.cpp/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "batchdelayoption.h"
#include <ksanecore_debug.h>

namespace KSaneCore
{

BatchDelayOption::BatchDelayOption()
{
    m_optionType = Option::TypeInteger;
}

Option::OptionState BatchDelayOption::state() const
{
    return Option::StateActive;
    ;
}

QString BatchDelayOption::name() const
{
    return BatchDelayOptionName;
}

QString BatchDelayOption::title() const
{
    return i18n("Batch mode time delay");
}

QString BatchDelayOption::description() const
{
    return i18n("Specify the time delay between each scan when batch mode is enabled.");
}

QVariant BatchDelayOption::minimumValue() const
{
    return 0;
}

QVariant BatchDelayOption::maximumValue() const
{
    return 300;
}

QVariant BatchDelayOption::stepValue() const
{
    return 1;
}

QVariant BatchDelayOption::value() const
{
    return m_delayValue;
}

QString BatchDelayOption::valueAsString() const
{
    return QString::number(m_delayValue);
}

Option::OptionUnit BatchDelayOption::valueUnit() const
{
    return Option::UnitSecond;
}

bool BatchDelayOption::setValue(const QVariant &val)
{
    bool ok;
    int newValue = val.toInt(&ok);
    if (ok && newValue != m_delayValue) {
        m_delayValue = newValue;
        Q_EMIT valueChanged(m_delayValue);
    }
    return ok;
}

} // NameSpace KSaneCore

#include "moc_batchdelayoption.cpp"
07070100000071000081A4000000000000000000000001660E103E00000463000000000000000000000000000000000000004C00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/batchdelayoption.h/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_DELAY_OPTION_H
#define KSANE_DELAY_OPTION_H

#include "baseoption.h"
#include "option.h"

namespace KSaneCore
{

static const QString BatchDelayOptionName = QStringLiteral("KSane::BatchTimeDelay");

class BatchDelayOption : public BaseOption
{
    Q_OBJECT

public:
    BatchDelayOption();

Option::OptionState state() const override;
    QString name() const override;
    QString title() const override;
    QString description() const override;

QVariant minimumValue() const override;
    QVariant maximumValue() const override;
    QVariant stepValue() const override;
    QVariant value() const override;
    QString valueAsString() const override;
    Option::OptionUnit valueUnit() const override;

public Q_SLOTS:
    bool setValue(const QVariant &value) override;

private:
    Option::OptionState m_state = Option::StateHidden;
    int m_delayValue = 10;
};

} // NameSpace KSaneCore

#endif // KSANE_DELAY_OPTION_H
07070100000072000081A4000000000000000000000001660E103E00000536000000000000000000000000000000000000004D00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/batchmodeoption.cpp/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "batchmodeoption.h"

#include <ksanecore_debug.h>

namespace KSaneCore
{

BatchModeOption::BatchModeOption()
{
    m_optionType = Option::TypeBool;
}

Option::OptionState BatchModeOption::state() const
{
    return Option::StateActive;
}

QString BatchModeOption::name() const
{
    return BatchModeOptionName;
}

QString BatchModeOption::title() const
{
    return i18n("Batch mode with time delay");
}

QString BatchModeOption::description() const
{
    return i18n("Enables batch mode scanning. Continues scanning after a delay until canceled.");
}

bool BatchModeOption::setValue(const QVariant &value)
{
    const bool toggled = value.toBool();

if (m_checked != toggled) {
        m_checked = toggled;
        Q_EMIT valueChanged(m_checked);
    }
    return true;
}

QVariant BatchModeOption::value() const
{
    return m_checked;
}

QString BatchModeOption::valueAsString() const
{
    if (state() == Option::StateHidden) {
        return QString();
    }
    if (m_checked) {
        return QStringLiteral("true");
    } else {
        return QStringLiteral("false");
    }
}

} // NameSpace KSaneCore

#include "moc_batchmodeoption.cpp"
07070100000073000081A4000000000000000000000001660E103E0000035D000000000000000000000000000000000000004B00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/batchmodeoption.h/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_BATCH_OPTION_H
#define KSANE_BATCH_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

static const QString BatchModeOptionName = QStringLiteral("KSane::BatchMode");

class BatchModeOption : public BaseOption
{
    Q_OBJECT

public:
    BatchModeOption();

Option::OptionState state() const override;
    QString name() const override;
    QString title() const override;
    QString description() const override;

QVariant value() const override;
    QString valueAsString() const override;

public Q_SLOTS:
    bool setValue(const QVariant &value) override;

private:
    bool m_checked = false;
};

} // NameSpace KSaneCore

#endif // KSANE_BATCH_OPTION_H
07070100000074000081A4000000000000000000000001660E103E0000077C000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/booloption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "booloption.h"

#include <QVarLengthArray>

#include <ksanecore_debug.h>

namespace KSaneCore
{

BoolOption::BoolOption(const SANE_Handle handle, const int index)
    : BaseOption(handle, index)
{
    m_optionType = Option::TypeBool;
}

bool BoolOption::setValue(const QVariant &value)
{
    if (state() == Option::StateHidden) {
        return false;
    }

bool toggled = value.toBool();

if (m_checked != toggled) {
        unsigned char data[4];

m_checked = toggled;
        fromSANE_Word(data, (toggled) ? 1 : 0);
        writeData(data);
        Q_EMIT valueChanged(m_checked);
    }
    return true;
}

void BoolOption::readValue()
{
    if (state() == Option::StateHidden) {
        return;
    }

// read the current value
 QVarLengthArray<unsigned char> data(m_optDesc->size);
 SANE_Status status;
 SANE_Int res;
 status = sane_control_option(m_handle, m_index, SANE_ACTION_GET_VALUE, data.data(), &res);
 if (status != SANE_STATUS_GOOD) {
 return;
 }
 bool old = m_checked;
 m_checked = (toSANE_Word(data.data()) != 0) ? true : false;

if ((old != m_checked) && ((m_optDesc->cap & SANE_CAP_SOFT_SELECT) == 0)) {
        Q_EMIT valueChanged(m_checked);
    }
}

QVariant BoolOption::value() const
{
    if (state() == Option::StateHidden) {
        return QVariant();
    }
    return m_checked;
}

QString BoolOption::valueAsString() const
{
    if (state() == Option::StateHidden) {
        return QString();
    }
    if (m_checked) {
        return QStringLiteral("true");
    } else {
        return QStringLiteral("false");
    }
}

} // namespace KSaneCore

#include "moc_booloption.cpp"
07070100000075000081A4000000000000000000000001660E103E000002A7000000000000000000000000000000000000004600000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/booloption.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_BOOL_OPTION_H
#define KSANE_BOOL_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

class BoolOption : public BaseOption
{
    Q_OBJECT

public:
    BoolOption(const SANE_Handle handle, const int index);

void readValue() override;

QVariant value() const override;
    QString valueAsString() const override;

public Q_SLOTS:
    bool setValue(const QVariant &value) override;

private:
    bool m_checked = false;
};

} // namespace KSaneCore

#endif // KSANE_BOOL_OPTION_H
07070100000076000081A4000000000000000000000001660E103E00000DF4000000000000000000000000000000000000004A00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/doubleoption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "doubleoption.h"

#include <QVarLengthArray>

#include <ksanecore_debug.h>

static const double FIXED_MAX = 32767.9999;
static const double FIXED_MIN = -32768.0;
static const double MIN_FIXED_STEP = 0.0001;
static const double FIXED_PRECISION = 1.0 / 65536;

namespace KSaneCore
{

DoubleOption::DoubleOption(const SANE_Handle handle, const int index)
    : BaseOption(handle, index)
{
    m_optionType = Option::TypeDouble;
}

void DoubleOption::readOption()
{
    beginOptionReload();

double step = MIN_FIXED_STEP;
 if (m_optDesc->constraint_type == SANE_CONSTRAINT_RANGE) {
 step = SANE_UNFIX(m_optDesc->constraint.range->quant);
 if (step < MIN_FIXED_STEP) {
 step = MIN_FIXED_STEP;
 }
 }
 m_minChange = step;

endOptionReload();
}

void DoubleOption::readValue()
{
    if (state() == Option::StateHidden) {
        return;
    }

// read that current value
 QVarLengthArray<unsigned char> data(m_optDesc->size);
 SANE_Status status;
 SANE_Int res;
 status = sane_control_option(m_handle, m_index, SANE_ACTION_GET_VALUE, data.data(), &res);
 if (status != SANE_STATUS_GOOD) {
 return;
 }

double newValue = SANE_UNFIX(toSANE_Word(data.data()));
    if (abs(newValue - m_value) >= FIXED_PRECISION) {
        m_value = newValue;
        Q_EMIT valueChanged(m_value);
    }
}

bool DoubleOption::setValue(const QVariant &value)
{
 if (state() == Option::StateHidden) {
 return false;
 }
 bool ok;
 double newValue = value.toDouble(&ok);
 if (ok && abs(newValue - m_value) >= m_minChange) {
 unsigned char data[4];
 SANE_Word fixed;
 //qCDebug(KSANE_LOG) <<m_optDesc->name << fVal << "!=" << val;
 m_value = newValue;
 fixed = SANE_FIX(newValue);
 fromSANE_Word(data, fixed);
 writeData(data);
 Q_EMIT valueChanged(m_value);
 }
 return ok;
}

QVariant DoubleOption::minimumValue() const
{
    QVariant value;
    if (m_optDesc->constraint_type == SANE_CONSTRAINT_RANGE) {
        value = SANE_UNFIX(m_optDesc->constraint.range->min);
    } else {
        value = FIXED_MIN;
    }
    return value;
}

QVariant DoubleOption::maximumValue() const
{
    QVariant value;
    if (m_optDesc->constraint_type == SANE_CONSTRAINT_RANGE) {
        value = SANE_UNFIX(m_optDesc->constraint.range->max);
    } else {
        value = FIXED_MAX;
    }
    return value;
}

QVariant DoubleOption::stepValue() const
{
    QVariant value;
    if (m_optDesc->constraint_type == SANE_CONSTRAINT_RANGE) {
        value = SANE_UNFIX(m_optDesc->constraint.range->quant);
        /* work around broken backends, the step value must never be zero
         * assume a minimum step value of 0.1 */
        if (value == 0) {
            value = 0.1;
        }
    } else {
        value = MIN_FIXED_STEP;
    }
    return value;
}

QVariant DoubleOption::value() const
{
    if (state() == Option::StateHidden) {
        return QVariant();
    }
    return QVariant(m_value);
}

QString DoubleOption::valueAsString() const
{
    if (state() == Option::StateHidden) {
        return QString();
    }
    return QString::number(m_value, 'F', 6);
}

} // namespace KSaneCore

#include "moc_doubleoption.cpp"
07070100000077000081A4000000000000000000000001660E103E000003B9000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/doubleoption.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_DOUBLE_OPTION_H
#define KSANE_DOUBLE_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

class DoubleOption : public BaseOption
{
    Q_OBJECT

public:
    DoubleOption(const SANE_Handle handle, const int index);

void readValue() override;
    void readOption() override;

public Q_SLOTS:
    bool setValue(const QVariant &value) override;

private:
    double  m_value = 0;
    double  m_minChange = 0.0001;
};

} // namespace KSaneCore

#endif // KSANE_DOUBLE_OPTION_H
07070100000078000081A4000000000000000000000001660E103E00002350000000000000000000000000000000000000004900000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/gammaoption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "gammaoption.h"

#include <QVarLengthArray>

#include <ksanecore_debug.h>

#include <cmath>

namespace KSaneCore
{

GammaOption::GammaOption(const SANE_Handle handle, const int index)
    : BaseOption(handle, index)
{
    m_optionType = Option::TypeGamma;
}

bool GammaOption::setValue(const QVariant &value)
{
 if (state() == Option::StateHidden) {
 return false;
 }
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 if (static_cast<QMetaType::Type>(value.type()) == QMetaType::QString) {
#else
 if (value.userType() == QMetaType::QString) {
#endif
 const QString stringValue = value.toString();
 QStringList gammaValues;
 int brightness;
 int contrast;
 int gamma;
 bool ok = true;

gammaValues = stringValue.split(QLatin1Char(':'));
        if (gammaValues.size() != 3) {
            return false;
        }
        brightness = gammaValues.at(0).toInt(&ok);
        if (ok) {
            contrast = gammaValues.at(1).toInt(&ok);
        }
        if (ok) {
            gamma = gammaValues.at(2).toInt(&ok);
        }

if (ok && (m_brightness != brightness || m_contrast != contrast || m_gamma != gamma) ) {
 m_brightness = brightness;
 m_contrast = contrast;
 m_gamma = gamma;
 calculateGTwriteData();
 }
 return true;
 }
 if (value.canConvert<QVariantList>()) { // It's a list
 QVariantList copy = value.toList();
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 if (copy.size() != 3 || static_cast<QMetaType::Type>(copy.at(0).type()) != QMetaType::Int
 || static_cast<QMetaType::Type>(copy.at(1).type()) != QMetaType::Int || static_cast<QMetaType::Type>(copy.at(2).type()) != QMetaType::Int) {
#else
 if (copy.size() != 3 || copy.at(0).userType() != QMetaType::Int || copy.at(1).userType() != QMetaType::Int || copy.at(2).userType() != QMetaType::Int) {
#endif
 return false;
 }
 if (m_brightness != copy.at(0).toInt() || m_contrast != copy.at(1).toInt() || m_gamma != copy.at(2).toInt() ) {
 m_brightness = copy.at(0).toInt();
 m_contrast = copy.at(1).toInt();
 m_gamma = copy.at(2).toInt();
 calculateGTwriteData();
 }
 return true;
 }
 return false;
}

void GammaOption::readValue()
{
    if (state() == Option::StateHidden) {
        return;
    }

QVarLengthArray<unsigned char> data(m_optDesc->size);
 SANE_Status status;
 SANE_Int res;
 status = sane_control_option(m_handle, m_index, SANE_ACTION_GET_VALUE, data.data(), &res);
 if (status != SANE_STATUS_GOOD) {
 return;
 }

QVector<int> gammaTable;
 gammaTable.reserve(data.size() / sizeof(int));
 for (int i = 0; i < data.size(); i += sizeof(SANE_Word)) gammaTable.append(toSANE_Word(&data[i]));

if (gammaTable != m_gammaTable) {
        m_gammaTable = gammaTable;

m_gammaTableMax = m_optDesc->constraint.range->max;

calculateBCGwriteData();
    }
}

QVariant GammaOption::value() const
{
    if (state() == Option::StateHidden) {
        return QVariant();
    }
    return QVariantList{ m_brightness, m_contrast, m_gamma };
}

int GammaOption::valueSize() const
{
    return 3;
}

QVariant GammaOption::maximumValue() const
{
 QVariant value;
 if (m_optDesc) {
 value = static_cast<float>(m_optDesc->constraint.range->max);
 return value;
 }
 return value;
}

QString GammaOption::valueAsString() const
{
    if (state() == Option::StateHidden) {
        return QString();
    }

return QString::asprintf("%d:%d:%d", m_brightness, m_contrast, m_gamma);
}

void GammaOption::calculateGTwriteData()
{
    double maxValue = m_optDesc->constraint.range->max;
    double gamma    = 100.0 / m_gamma;
    double contrast = (200.0 / (100.0 - m_contrast)) - 1;
    double halfMax  = maxValue / 2.0;
    // NOTE: This used to add the value times 2, not scaled to maxValue
    double brightness = m_brightness * maxValue / 100.0;
    double x;

for (int i = 0; i < m_gammaTable.size(); i++) {
 // apply gamma
 x = std::pow(static_cast<double>(i) / m_gammaTable.size(), gamma) * maxValue;

// apply contrast
        x = (contrast * (x - halfMax)) + halfMax;

// apply brightness + rounding
        x += brightness + 0.5;

// ensure correct value
 if (x > maxValue) {
 x = maxValue;
 }
 if (x < 0) {
 x = 0;
 }

m_gammaTable[i] = static_cast<int>(x);
 }

writeData(m_gammaTable.data());
    QVariantList values = { m_brightness, m_contrast, m_gamma };
    Q_EMIT valueChanged(values);
}

void GammaOption::calculateBCGwriteData() {
 int beginIndex = 0;
 int endIndex = m_gammaTable.size() - 1;
 // Find the start and end of the curve, to skip the flat regions
 while (beginIndex < endIndex && m_gammaTable[beginIndex] == m_gammaTable[0])
 beginIndex++;
 while (endIndex > beginIndex && m_gammaTable[endIndex] == m_gammaTable[m_gammaTable.size()-1])
 endIndex--;

float gamma = 0, contrast = 0, brightness = 0;
 const QVector<int> &gammaTable = m_gammaTable;
 const int &gammaTableMax = m_gammaTableMax;

auto guessGamma = [&gammaTable, &gamma](int i1, int i2, int step) {
 int diff1 = gammaTable[i1 + step] - gammaTable[i1 - step];
 int diff2 = gammaTable[i2 + step] - gammaTable[i2 - step];
 if (diff1 == 0 || diff2 == 0)
 return;
 float stepProportion = static_cast<float>(i2) / i1;
 float diffProportion = static_cast<float>(diff2) / diff1;
 float guessedGamma = log(stepProportion * diffProportion) / log(stepProportion);
 gamma += guessedGamma;
 };

auto guessContrast = [&gammaTable, &gammaTableMax, &gamma, &contrast](int i1, int i2, int) {
 int prevVal = gammaTable[i1], nextVal = gammaTable[i2];
 float scaledDiff = static_cast<float>(nextVal - prevVal) / gammaTableMax;
 float scaledPrevIndex = static_cast<float>(i1) / gammaTable.size();
 float scaledNextIndex = static_cast<float>(i2) / gammaTable.size();
 float guessedContrast = scaledDiff / (pow(scaledNextIndex, gamma) - pow(scaledPrevIndex, gamma));
 contrast += guessedContrast;
 };

auto guessBrightness = [&gammaTable, &gammaTableMax, &gamma, &contrast, &brightness](int i, int, int) {
 float scaledThisVal = static_cast<float>(gammaTable[i]) / gammaTableMax;
 float scaledIndex = static_cast<float>(i) / gammaTable.size();
 float guessedBrightness = scaledThisVal - ((pow(scaledIndex, gamma) - 0.5) * contrast + 0.5);
 brightness += guessedBrightness;
 };

const int numberOfApproximations = 16;

auto passValuePairsAndSteps = [&beginIndex, &endIndex](auto func) {
 const int step = (endIndex - beginIndex) / 8;
 for (int i = 0; i < numberOfApproximations;) {
 // Calculate step, even if not passed to the function, to separate the samples
 int i1 = rand() % (endIndex - beginIndex - 2 * step - 2) + beginIndex + step + 1;
 int i2 = rand() % (endIndex - beginIndex - 2 * step - 2) + beginIndex + step + 1;
 if (i2 - i1 >= 4 * step) {
 func(i1, i2, step);
 i++;
 }
 }
 };

if (endIndex == beginIndex) {
 qCDebug(KSANECORE_LOG()) << "Ignoring gamma table: horizontal line at" << m_gammaTable[0];
 setValue(QVariantList{0, 0, 100}); // Ignore the table, it's wrong
 return;
 }

if (endIndex - beginIndex <= 32) { // Table too small, make single guesses
 if (endIndex - beginIndex > 4) { // Measurements don't overlap by just one value
 guessGamma(beginIndex + 2, endIndex - 2, 2);
 } else {
 gamma = 1.0; // Assume linear gamma
 }
 guessContrast(beginIndex, endIndex, 0);
 guessBrightness((beginIndex + endIndex) / 2, 0, 0);
 } else {
 passValuePairsAndSteps(guessGamma);
 gamma /= numberOfApproximations;

passValuePairsAndSteps(guessContrast);
        contrast /= numberOfApproximations;

passValuePairsAndSteps(guessBrightness);
        brightness /= numberOfApproximations;
    }

int newGamma = 100.0 / gamma;
    int newContrast = 100.0 - 200.0 / (contrast + 1.0);
    int newBrightness = brightness * 100.0;

if (m_gamma != newGamma || m_contrast != newContrast || m_brightness != newBrightness) {
        m_gamma = newGamma;
        m_contrast = newContrast;
        m_brightness = newBrightness;

QVariantList values = { m_brightness, m_contrast, m_gamma };
        Q_EMIT valueChanged(values);
    }
}

} // namespace KSaneCore

#include "moc_gammaoption.cpp"
07070100000079000081A4000000000000000000000001660E103E000003C8000000000000000000000000000000000000004700000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/gammaoption.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_GAMMA_OPTION_H
#define KSANE_GAMMA_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

class GammaOption : public BaseOption
{
    Q_OBJECT

public:
    GammaOption(const SANE_Handle handle, const int index);

void readValue() override;

QVariant maximumValue() const override;
    QVariant value() const override;
    int valueSize() const override;
    QString valueAsString() const override;

public Q_SLOTS:
    bool setValue(const QVariant & value) override;

private:
    void calculateGTwriteData();
    void calculateBCGwriteData();

int m_brightness;
 int m_contrast;
 int m_gamma;
 QVector<int> m_gammaTable;
 int m_gammaTableMax;
};

}  // namespace KSane

#endif // KSANE_GAMMA_OPTION_H
0707010000007A000081A4000000000000000000000001660E103E00000AA7000000000000000000000000000000000000004B00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/integeroption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "integeroption.h"

#include <QVarLengthArray>

static const int KSW_INT_MAX = 2147483647;
static const int KSW_INT_MIN = -2147483647 - 1; // prevent warning

namespace KSaneCore
{

IntegerOption::IntegerOption(const SANE_Handle handle, const int index)
    : BaseOption(handle, index)
{
    m_optionType = Option::TypeInteger;
}

void IntegerOption::readValue()
{
    if (state() == Option::StateHidden) {
        return;
    }

int newValue = toSANE_Word(data.data());
    if (newValue != m_iVal) {
        m_iVal = newValue;
        Q_EMIT valueChanged(m_iVal);
    }
}

QVariant IntegerOption::minimumValue() const
{
 QVariant value;
 if (m_optDesc->constraint_type == SANE_CONSTRAINT_RANGE) {
 value = static_cast<int>(m_optDesc->constraint.range->min);
 } else {
 value = KSW_INT_MIN;
 }
 return value;
}

QVariant IntegerOption::maximumValue() const
{
 QVariant value;
 if (m_optDesc->constraint_type == SANE_CONSTRAINT_RANGE) {
 value = static_cast<int>(m_optDesc->constraint.range->max);
 } else {
 value = KSW_INT_MAX;
 }
 return value;
}

QVariant IntegerOption::stepValue() const
{
 QVariant value;
 if (m_optDesc->constraint_type == SANE_CONSTRAINT_RANGE) {
 value = static_cast<int>(m_optDesc->constraint.range->quant);
 // guard against possible broken backends
 if (value == 0) {
 value = 1;
 }
 } else {
 value = 1;
 }
 return value;
}

QVariant IntegerOption::value() const
{
    QVariant value;
    if (state() == Option::StateHidden) {
        return value;
    }
    value = m_iVal;
    return value;
}

QString IntegerOption::valueAsString() const
{
    if (state() == Option::StateHidden) {
        return QString();
    }
    return QString::number(m_iVal);
}

bool IntegerOption::setValue(const QVariant &val)
{
    bool ok;
    int newValue = val.toInt(&ok);
    if (ok && newValue != m_iVal) {
        unsigned char data[4];
        m_iVal = newValue;
        fromSANE_Word(data, newValue);
        writeData(data);
        Q_EMIT valueChanged(m_iVal);
    }
    return ok;
}

} // namespace KSaneCore

#include "moc_integeroption.cpp"
0707010000007B000081A4000000000000000000000001660E103E0000032F000000000000000000000000000000000000004900000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/integeroption.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_INTEGER_OPTION_H
#define KSANE_INTEGER_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

class IntegerOption : public BaseOption
{
    Q_OBJECT

public:
    IntegerOption(const SANE_Handle handle, const int index);

void readValue() override;

public Q_SLOTS:
    bool setValue(const QVariant &value) override;

private:
    int m_iVal = 0;
};

} // namespace KSaneCore

#endif // KSANE_INTEGER_OPTION_H
0707010000007C000081A4000000000000000000000001660E103E000004E0000000000000000000000000000000000000004A00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/invertoption.cpp/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "invertoption.h"

#include <ksanecore_debug.h>

namespace KSaneCore
{

InvertOption::InvertOption()
{
    m_optionType = Option::TypeBool;
}

bool InvertOption::setValue(const QVariant &value)
{
 if (value.canConvert<bool>()) {
 if (m_checked != value.toBool()) {
 m_checked = value.toBool();
 Q_EMIT valueChanged(m_checked);
 }
 return true;
 } else {
 return false;
 }
}

QVariant InvertOption::value() const
{
    return m_checked;
}

QString InvertOption::valueAsString() const
{
    if (m_checked) {
        return QStringLiteral("true");
    } else {
        return QStringLiteral("false");
    }
}

Option::OptionState InvertOption::state() const
{
    return Option::StateActive;
}

QString InvertOption::name() const
{
    return InvertColorsOptionName;
}

QString InvertOption::title() const
{
    return i18n("Invert colors");
}

QString InvertOption::description() const
{
    return i18n("Invert the colors of the scanned image.");
}

} // namespace KSaneCore

#include "moc_invertoption.cpp"
0707010000007D000081A4000000000000000000000001660E103E00000360000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/invertoption.h/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_INVERT_OPTION_H
#define KSANE_INVERT_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

static const QString InvertColorsOptionName = QStringLiteral("KSane::InvertColors");

class InvertOption : public BaseOption
{
    Q_OBJECT

public:
    InvertOption();

QVariant value() const override;
    QString valueAsString() const override;

Option::OptionState state() const override;
    QString name() const override;
    QString title() const override;
    QString description() const override;

public Q_SLOTS:
    bool setValue(const QVariant &value) override;

private:
    bool m_checked = false;
};

} // namespace KSaneCore

#endif // KSANE_INVERT_OPTION_H
0707010000007E000081A4000000000000000000000001660E103E000021EB000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/listoption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "listoption.h"

#include <QVarLengthArray>

#include <ksanecore_debug.h>

namespace KSaneCore
{

ListOption::ListOption(const SANE_Handle handle, const int index)
    : BaseOption(handle, index)
{
    m_optionType = Option::TypeValueList;
}

void ListOption::readValue()
{
    if (BaseOption::state() == Option::StateHidden) {
        return;
    }

QVariant newValue;
 switch (m_optDesc->type) {
 case SANE_TYPE_INT:
 newValue = static_cast<int>(toSANE_Word(data.data()));
 break;
 case SANE_TYPE_FIXED:
 newValue = SANE_UNFIX(toSANE_Word(data.data()));
 break;
 case SANE_TYPE_STRING:
 newValue = sane_i18n(reinterpret_cast<char *>(data.data()));
 break;
 default:
 break;
 }

if (newValue != m_currentValue) {
        m_currentValue = newValue;
        Q_EMIT valueChanged(m_currentValue);
    }
}

void ListOption::readOption()
{
    beginOptionReload();
    countEntries();
    endOptionReload();
}

QVariantList ListOption::valueList() const
{
    int i;
    QVariantList list;
    list.reserve(m_entriesCount);

switch (m_optDesc->type) {
 case SANE_TYPE_INT:
 for (i = 1; i <= m_optDesc->constraint.word_list[0]; ++i) {
 list << static_cast<int>(m_optDesc->constraint.word_list[i]);;
 }
 break;
 case SANE_TYPE_FIXED:
 for (i = 1; i <= m_optDesc->constraint.word_list[0]; ++i) {
 list << SANE_UNFIX(m_optDesc->constraint.word_list[i]);
 }
 break;
 case SANE_TYPE_STRING:
 i = 0;
 while (m_optDesc->constraint.string_list[i] != nullptr) {
 list << sane_i18n(m_optDesc->constraint.string_list[i]);
 i++;
 }
 break;
 default :
 qCDebug(KSANECORE_LOG) << "can not handle type:" << m_optDesc->type;
 break;
 }
 return list;
}

QVariantList ListOption::internalValueList() const
{
    int i;
    QVariantList list;
    list.reserve(m_entriesCount);

switch (m_optDesc->type) {
 case SANE_TYPE_INT:
 for (i = 1; i <= m_optDesc->constraint.word_list[0]; ++i) {
 list << static_cast<int>(m_optDesc->constraint.word_list[i]);;
 }
 break;
 case SANE_TYPE_FIXED:
 for (i = 1; i <= m_optDesc->constraint.word_list[0]; ++i) {
 list << SANE_UNFIX(m_optDesc->constraint.word_list[i]);
 }
 break;
 case SANE_TYPE_STRING:
 i = 0;
 while (m_optDesc->constraint.string_list[i] != nullptr) {
 list << QString::fromLatin1(m_optDesc->constraint.string_list[i]);
 i++;
 }
 break;
 default :
 qCDebug(KSANECORE_LOG) << "can not handle type:" << m_optDesc->type;
 break;
 }
 return list;
}

bool ListOption::setValue(const QVariant &value)
{
 bool success = false;
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 if (static_cast<QMetaType::Type>(value.type()) == QMetaType::QString) {
#else
 if (value.userType() == QMetaType::QString) {
#endif
 success = setValue(value.toString());
 } else {
 success = setValue(value.toDouble());
 }

return success;
}

QVariant ListOption::minimumValue() const
{
 QVariant value;
 if (BaseOption::state() == Option::StateHidden) {
 return value;
 }
 double dValueMin;
 int iValueMin;
 switch (m_optDesc->type) {
 case SANE_TYPE_INT:
 iValueMin = static_cast<int>(m_optDesc->constraint.word_list[1]);
 for (int i = 2; i <= m_optDesc->constraint.word_list[0]; i++) {
 iValueMin = qMin(static_cast<int>(m_optDesc->constraint.word_list[i]), iValueMin);
 }
 value = iValueMin;
 break;
 case SANE_TYPE_FIXED:
 dValueMin = SANE_UNFIX(m_optDesc->constraint.word_list[1]);
 for (int i = 2; i <= m_optDesc->constraint.word_list[0]; i++) {
 dValueMin = qMin(SANE_UNFIX(m_optDesc->constraint.word_list[i]), dValueMin);
 }
 value = dValueMin;
 break;
 default:
 qCDebug(KSANECORE_LOG) << "can not handle type:" << m_optDesc->type;
 return value;
 }
 return value;
}

QVariant ListOption::value() const
{
    if (BaseOption::state() == Option::StateHidden) {
        return QVariant();
    }
    return m_currentValue;
}

bool ListOption::setValue(double value)
{
    unsigned char data[4];
    double tmp;
    double minDiff;
    int i;
    int minIndex = 1;

switch (m_optDesc->type) {
 case SANE_TYPE_INT:
 tmp = static_cast<double>(m_optDesc->constraint.word_list[minIndex]);
 minDiff = qAbs(value - tmp);
 for (i = 2; i <= m_optDesc->constraint.word_list[0]; ++i) {
 tmp = static_cast<double>(m_optDesc->constraint.word_list[i]);
 if (qAbs(value - tmp) < minDiff) {
 minDiff = qAbs(value - tmp);
 minIndex = i;
 }
 }
 fromSANE_Word(data, m_optDesc->constraint.word_list[minIndex]);
 writeData(data);
 readValue();
 return (minDiff < 1.0);
 case SANE_TYPE_FIXED:
 tmp = SANE_UNFIX(m_optDesc->constraint.word_list[minIndex]);
 minDiff = qAbs(value - tmp);
 for (i = 2; i <= m_optDesc->constraint.word_list[0]; ++i) {
 tmp = SANE_UNFIX(m_optDesc->constraint.word_list[i]);
 if (qAbs(value - tmp) < minDiff) {
 minDiff = qAbs(value - tmp);
 minIndex = i;
 }
 }
 fromSANE_Word(data, m_optDesc->constraint.word_list[minIndex]);
 writeData(data);
 readValue();
 return (minDiff < 1.0);
 default:
 qCDebug(KSANECORE_LOG) << "can not handle type:" << m_optDesc->type;
 break;
 }
 return false;
}

QString ListOption::valueAsString() const
{
    if (BaseOption::state() == Option::StateHidden) {
        return QString();
    }
    return m_currentValue.toString();
}

bool ListOption::setValue(const QString &value)
{
    if (BaseOption::state() == Option::StateHidden) {
        return false;
    }

unsigned char data[4];
    void* data_ptr = nullptr;
    SANE_Word fixed;
    int i;
    double d;
    bool ok;
    QString tmp;

switch (m_optDesc->type) {
    case SANE_TYPE_INT:
        i = value.toInt(&ok);
        if (ok) {
            fromSANE_Word(data, i);
            data_ptr = data;
        } else {
            return false;
        }

break;
    case SANE_TYPE_FIXED:
        d = value.toDouble(&ok);
        if (ok) {
            fixed = SANE_FIX(d);
            fromSANE_Word(data, fixed);
            data_ptr = data;
        } else {
            return false;
        }

break;
 case SANE_TYPE_STRING:
 i = 0;
 while (m_optDesc->constraint.string_list[i] != nullptr) {
 tmp = QString::fromLatin1(m_optDesc->constraint.string_list[i]);
 if (value != tmp) {
 tmp = sane_i18n(m_optDesc->constraint.string_list[i]);
 }
 if (value == tmp) {
 data_ptr = (void *)m_optDesc->constraint.string_list[i];
 break;
 }
 i++;
 }
 if (m_optDesc->constraint.string_list[i] == nullptr) {
 return false;
 }
 break;
 default:
 qCDebug(KSANECORE_LOG) << "can only handle SANE_TYPE: INT, FIXED and STRING";
 return false;
 }
 writeData(data_ptr);

readValue();
    return true;
}

void ListOption::countEntries()
{
    m_entriesCount = 0;

switch (m_optDesc->type) {

case SANE_TYPE_INT:
    case SANE_TYPE_FIXED:
        m_entriesCount = m_optDesc->constraint.word_list[0];
        break;

case SANE_TYPE_STRING:
        while (m_optDesc->constraint.string_list[m_entriesCount] != nullptr) {
            m_entriesCount++;
        }
        break;

default :
 qCDebug(KSANECORE_LOG) << "can not handle type:" << m_optDesc->type;
 break;
 }
}

Option::OptionState ListOption::state() const
{
 if (m_entriesCount <= 1) {
 return Option::StateHidden;
 } else {
 return BaseOption::state();
 }
}

} // namespace KSaneCore

#include "moc_listoption.cpp"
0707010000007F000081A4000000000000000000000001660E103E00000415000000000000000000000000000000000000004600000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/listoption.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_VALUELIST_OPTION_H
#define KSANE_VALUELIST_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

class ListOption : public BaseOption
{
    Q_OBJECT

public:
    ListOption(const SANE_Handle handle, const int index);

void readValue() override;
    void readOption() override;

QVariant minimumValue() const override;
    QVariant value() const override;
    QString valueAsString() const override;
    QVariantList valueList() const override;
    QVariantList internalValueList() const override;
    Option::OptionState state() const override;

public Q_SLOTS:
    bool setValue(const QVariant &value) override;

private:
    bool setValue(double value);
    bool setValue(const QString &value);
    void countEntries();

QVariant m_currentValue;
    int m_entriesCount = 0;
};

} // namespace KSaneCore

#endif // KSANE_VALUELIST_OPTION_H
07070100000080000081A4000000000000000000000001660E103E00001DDC000000000000000000000000000000000000004C00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/pagesizeoption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "pagesizeoption.h"

#include <QPageSize>
#include <QSizeF>

#include <ksanecore_debug.h>

static constexpr int PageSizeWiggleRoom = 2; // in mm

namespace KSaneCore
{

PageSizeOption::PageSizeOption(BaseOption *optionTopLeftX,
                               BaseOption *optionTopLeftY,
                               BaseOption *optionBottomRightX,
                               BaseOption *optionBottomRightY,
                               BaseOption *optionResolution)
    : BaseOption()
{
    if (optionTopLeftX == nullptr || optionTopLeftY == nullptr || optionBottomRightX == nullptr || optionBottomRightY == nullptr) {
        m_optionType = Option::TypeDetectFail;
        return;
    }

connect(optionTopLeftX, &BaseOption::valueChanged, this, &PageSizeOption::optionTopLeftXUpdated);
    connect(optionTopLeftY, &BaseOption::valueChanged, this, &PageSizeOption::optionTopLeftYUpdated);
    connect(optionBottomRightX, &BaseOption::valueChanged, this, &PageSizeOption::optionBottomRightXUpdated);
    connect(optionBottomRightY, &BaseOption::valueChanged, this, &PageSizeOption::optionBottomRightYUpdated);

m_optionTopLeftX = optionTopLeftX;
    m_optionTopLeftY = optionTopLeftY;
    m_optionBottomRightX = optionBottomRightX;
    m_optionBottomRightY = optionBottomRightY;
    m_optionResolution = optionResolution;

const QList<QPageSize::PageSizeId> possibleSizesList = {
 QPageSize::A3,
 QPageSize::A4,
 QPageSize::A5,
 QPageSize::A6,
 QPageSize::Letter,
 QPageSize::Legal,
 QPageSize::Tabloid,
 QPageSize::B3,
 QPageSize::B4,
 QPageSize::B5,
 QPageSize::B6,
 QPageSize::C5E,
 QPageSize::Comm10E,
 QPageSize::DLE,
 QPageSize::Executive,
 QPageSize::Folio,
 QPageSize::Ledger,
 QPageSize::JisB3,
 QPageSize::JisB4,
 QPageSize::JisB5,
 QPageSize::JisB6,
 };

m_availableSizesList << QPageSize::size(QPageSize::Custom, QPageSize::Millimeter);
 m_availableSizesListNames << QPageSize::name(QPageSize::Custom);

double maxScannerWidth = ensureMilliMeter(m_optionBottomRightX, m_optionBottomRightX->maximumValue().toDouble());
    double maxScannerHeight = ensureMilliMeter(m_optionBottomRightY, m_optionBottomRightY->maximumValue().toDouble());

// Add portrait page sizes
 for (const auto sizeCode : possibleSizesList) {
 QSizeF size = QPageSize::size(sizeCode, QPageSize::Millimeter);
 if (size.width() - PageSizeWiggleRoom > maxScannerWidth) {
 continue;
 }
 if (size.height() - PageSizeWiggleRoom > maxScannerHeight) {
 continue;
 }
 m_availableSizesList << size;
 m_availableSizesListNames << QPageSize::name(sizeCode);
 }

// Add landscape page sizes
 for (const auto sizeCode : possibleSizesList) {
 QSizeF size = QPageSize::size(sizeCode, QPageSize::Millimeter);
 size.transpose();
 if (size.width() - PageSizeWiggleRoom > maxScannerWidth) {
 continue;
 }
 if (size.height() - PageSizeWiggleRoom > maxScannerHeight) {
 continue;
 }
 m_availableSizesList << size;
 m_availableSizesListNames << i18nc("Page size landscape", "Landscape %1", QPageSize::name(sizeCode));
 }

// Set custom as current
    m_currentIndex = 0;
    if (m_availableSizesList.count() > 1) {
        m_state = Option::StateActive;
    } else {
        m_state = Option::StateHidden;
    }
    m_optionType = Option::TypeValueList;
}

bool PageSizeOption::setValue(const QVariant &value)
{
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 if (static_cast<QMetaType::Type>(value.type()) == QMetaType::QString) {
#else
 if (value.userType() == QMetaType::QString) {
#endif
 QString newValue = value.toString();
 if (newValue == m_availableSizesListNames.at(m_currentIndex)) {
 return true;
 }
 for (int i = 0; i < m_availableSizesListNames.size(); i++) {
 QString sizeEntry = m_availableSizesListNames.at(i).toString();
 if (sizeEntry == newValue) {
 m_currentIndex = i;

if (i != 0) {
                    const auto size = m_availableSizesList.at(i);
                    m_optionTopLeftX->setValue(0);
                    m_optionTopLeftY->setValue(0);
                    m_optionBottomRightX->setValue(size.width());
                    m_optionBottomRightY->setValue(size.height());
                }
                Q_EMIT valueChanged(sizeEntry);
                return true;
            }
        }
    }
    return false;
}

QVariant PageSizeOption::value() const
{
 if (m_currentIndex >= 0 && m_currentIndex < m_availableSizesListNames.size()) {
 return m_availableSizesListNames.at(m_currentIndex);
 } else {
 return QVariant();
 }
}

QString PageSizeOption::valueAsString() const
{
 if (m_currentIndex >= 0 && m_currentIndex < m_availableSizesListNames.size()) {
 return m_availableSizesListNames.at(m_currentIndex).toString();
 } else {
 return QString();
 }
}

QVariantList PageSizeOption::valueList() const
{
    return m_availableSizesListNames;
}

Option::OptionState PageSizeOption::state() const
{
    return m_state;
}

QString PageSizeOption::name() const
{
    return PageSizeOptionName;
}

QString PageSizeOption::title() const
{
    return i18n("Scan area size");
}

QString PageSizeOption::description() const
{
    return i18n("Select a predefined page size for the scanning area.");
}

void PageSizeOption::optionTopLeftXUpdated()
{
 if (m_currentIndex > 0 && m_currentIndex < m_availableSizesList.size() && m_optionTopLeftY->value().toDouble() != 0) {
 m_currentIndex = 0;
 Q_EMIT valueChanged(QPageSize::name(QPageSize::Custom));
 }
}

void PageSizeOption::optionTopLeftYUpdated()
{
 if (m_currentIndex > 0 && m_currentIndex < m_availableSizesList.size() && m_optionTopLeftY->value().toDouble() != 0) {
 m_currentIndex = 0;
 Q_EMIT valueChanged(QPageSize::name(QPageSize::Custom));
 }
}

void PageSizeOption::optionBottomRightXUpdated()
{
 if (m_currentIndex > 0 && m_currentIndex < m_availableSizesList.size()
 && ensureMilliMeter(m_optionBottomRightX, m_optionBottomRightX->value().toDouble()) != m_availableSizesList.at(m_currentIndex).width()) {
 m_currentIndex = 0;
 Q_EMIT valueChanged(QPageSize::name(QPageSize::Custom));
 }
}

void PageSizeOption::optionBottomRightYUpdated()
{
 if (m_currentIndex > 0 && m_currentIndex < m_availableSizesList.size()
 && ensureMilliMeter(m_optionBottomRightY, m_optionBottomRightY->value().toDouble()) != m_availableSizesList.at(m_currentIndex).height()) {
 m_currentIndex = 0;
 Q_EMIT valueChanged(QPageSize::name(QPageSize::Custom));
 }
}

double PageSizeOption::ensureMilliMeter(BaseOption *option, double value)
{
    // convert if necessary with current DPI if available
    if (option->valueUnit() == Option::UnitPixel && m_optionResolution != nullptr) {
        double dpi = m_optionResolution->value().toDouble();
        if (dpi > 1) {
            return value / (dpi / 25.4);
        }
    }
    return value;
}

} // namespace KSaneCore

#include "moc_pagesizeoption.cpp"
07070100000081000081A4000000000000000000000001660E103E000006AF000000000000000000000000000000000000004A00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/pagesizeoption.h/*
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_PAGESIZE_OPTION_H
#define KSANE_PAGESIZE_OPTION_H

#include <QList>

#include "baseoption.h"

namespace KSaneCore
{

static const QString PageSizeOptionName = QStringLiteral("KSane::PageSize");

class PageSizeOption : public BaseOption
{
    Q_OBJECT

public:
    PageSizeOption(BaseOption *m_optionTopLeftX,
                   BaseOption *m_optionTopLeftY,
                   BaseOption *m_optionBottomRightX,
                   BaseOption *m_optionBottomRightY,
                   BaseOption *m_optionResolution);

QVariant value() const override;
    QString valueAsString() const override;

Option::OptionState state() const override;
    QString name() const override;
    QString title() const override;
    QString description() const override;
    QVariantList valueList() const override;

public Q_SLOTS:
    bool setValue(const QVariant &value) override;

private Q_SLOTS:
    void optionTopLeftXUpdated();
    void optionTopLeftYUpdated();
    void optionBottomRightXUpdated();
    void optionBottomRightYUpdated();

private:
    double ensureMilliMeter(BaseOption *option, double value);

BaseOption *m_optionTopLeftX;
 BaseOption *m_optionTopLeftY;
 BaseOption *m_optionBottomRightX;
 BaseOption *m_optionBottomRightY;
 BaseOption *m_optionResolution;
 int m_currentIndex = -1;
 Option::OptionState m_state = Option::StateDisabled;
 QVariantList m_availableSizesListNames;
 QList<QSizeF> m_availableSizesList;
};

} // namespace KSaneCore

#endif // KSANE_PAGESIZE_OPTION_H
07070100000082000081A4000000000000000000000001660E103E00000710000000000000000000000000000000000000004A00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/stringoption.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "stringoption.h"

#include <QVarLengthArray>

#include <ksanecore_debug.h>

namespace KSaneCore
{

StringOption::StringOption(const SANE_Handle handle, const int index)
    : BaseOption(handle, index)
{
    m_optionType = Option::TypeString;
}

bool StringOption::setValue(const QVariant &val)
{
    if (state() == Option::StateHidden) {
        return false;
    }
    QString text = val.toString();
    QString tmp;
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    tmp += QStringView(text).left(m_optDesc->size);
#else
    tmp += text.leftRef(m_optDesc->size);
#endif
    if (tmp != text) {
        writeData(tmp.toLatin1().data());
        Q_EMIT valueChanged(tmp);
    }
    return true;
}

void StringOption::readValue()
{
    if (state() == Option::StateHidden) {
        return;
    }

m_string = QString::fromUtf8(reinterpret_cast<char *>(data.data()));

Q_EMIT valueChanged(m_string);
}

QVariant StringOption::value() const
{
    return QVariant(m_string);
}

int StringOption::valueSize() const
{
 return static_cast<int>(m_optDesc->size);
}

QString StringOption::valueAsString() const
{
    if (state() == Option::StateHidden) {
        return QString();
    }
    return m_string;
}

} // namespace KSaneCore

#include "moc_stringoption.cpp"
07070100000083000081A4000000000000000000000001660E103E000002D3000000000000000000000000000000000000004800000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/options/stringoption.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_STRING_OPTION_H
#define KSANE_STRING_OPTION_H

#include "baseoption.h"

namespace KSaneCore
{

class StringOption : public BaseOption
{
    Q_OBJECT

public:
    StringOption(const SANE_Handle handle, const int index);

void readValue() override;

QVariant value() const override;
    int valueSize() const override;
    QString valueAsString() const override;

public Q_SLOTS:
    bool setValue(const QVariant &val) override;

private:
    QString       m_string;
};

} // namespace KSaneCore

#endif // KSANE_STRING_OPTION_H
07070100000084000081A4000000000000000000000001660E103E00001C98000000000000000000000000000000000000004000000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/scanthread.cpp/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#include "scanthread.h"

#include <QMutexLocker>
#include <QVariant>

#include <ksanecore_debug.h>

namespace KSaneCore
{

ScanThread::ScanThread(SANE_Handle handle):
 QThread(), m_saneHandle(handle), m_imageBuilder(&m_image, &m_dpi)
{
 m_emitProgressUpdateTimer.setSingleShot(false);
 m_emitProgressUpdateTimer.setInterval(500);
 connect(&m_emitProgressUpdateTimer, &QTimer::timeout, this, &ScanThread::updateScanProgress);
 connect(this, &QThread::started, &m_emitProgressUpdateTimer, QOverload<>::of(&QTimer::start));
 connect(this, &QThread::finished,&m_emitProgressUpdateTimer, &QTimer::stop);
}

void ScanThread::setImageInverted(const QVariant &newValue)
{
    const bool newInvert = newValue.toBool();
    if (m_invertColors != newInvert) {
        m_invertColors = newInvert;
        m_image.invertPixels();
    }
}

void ScanThread::setImageResolution(const QVariant &newValue)
{
    bool ok;
    const int newDPI = newValue.toInt(&ok);
    if (ok && m_dpi != newDPI) {
        m_dpi = newDPI;
    }
}

ScanThread::ReadStatus ScanThread::frameStatus()
{
    return m_readStatus;
}

SANE_Status ScanThread::saneStatus()
{
    return m_saneStatus;
}

QImage *ScanThread::scanImage()
{
    return &m_image;
}

void ScanThread::lockScanImage()
{
    m_imageMutex.lock();
}

void ScanThread::unlockScanImage()
{
    m_imageMutex.unlock();
}

void ScanThread::cancelScan()
{
    m_readStatus = ReadCancel;
}

void ScanThread::run()
{
    m_dataSize = 0;
    m_readStatus = ReadOngoing;
    m_announceFirstRead = true;

// Start the scanning with sane_start
    m_saneStatus = sane_start(m_saneHandle);

if (m_readStatus == ReadCancel) {
        return;
    }

if (m_saneStatus != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << "sane_start=" << sane_strstatus(m_saneStatus);
 sane_cancel(m_saneHandle);
 m_readStatus = ReadError;
 return;
 }

// Read image parameters
 m_saneStatus = sane_get_parameters(m_saneHandle, &m_params);
 if (m_saneStatus != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << "sane_get_parameters=" << sane_strstatus(m_saneStatus);
 sane_cancel(m_saneHandle);
 m_readStatus = ReadError;
 return;
 }

// calculate data size
    m_frameSize  = m_params.lines * m_params.bytes_per_line;
    if ((m_params.format == SANE_FRAME_RED) ||
            (m_params.format == SANE_FRAME_GREEN) ||
            (m_params.format == SANE_FRAME_BLUE)) {
        // this is unfortunately calculated again for every frame....
        m_dataSize = m_frameSize * 3;
    } else {
        m_dataSize = m_frameSize;
    }

m_imageBuilder.start(m_params);
    m_frameRead = 0;
    m_frame_t_count = 0;

while (m_readStatus == ReadOngoing) {
        readData();
    }
}

void ScanThread::updateScanProgress()
{
 // handscanners have negative data size
 if (m_dataSize <= 0) {
 return;
 }

int bytesRead;

if (m_frameSize < m_dataSize) {
 bytesRead = m_frameRead + (m_frameSize * m_frame_t_count);
 } else {
 bytesRead = m_frameRead;
 }

if (bytesRead > 0) {
 Q_EMIT scanProgressUpdated(static_cast<int>((static_cast<float>(bytesRead) * 100.0) / m_dataSize));
 }
}

void ScanThread::readData()
{
    SANE_Int readBytes = 0;
    m_saneStatus = sane_read(m_saneHandle, m_readData, SCAN_READ_CHUNK_SIZE, &readBytes);

if (readBytes > 0 && m_announceFirstRead) {
        Q_EMIT scanProgressUpdated(0);
        m_announceFirstRead = false;
    }

switch (m_saneStatus) {
    case SANE_STATUS_GOOD:
        // continue to parsing the data
        break;

case SANE_STATUS_EOF:
 // (handscanners have negative frame size)
 if (m_frameRead < m_frameSize) {
 qCDebug(KSANECORE_LOG) << "frameRead =" << m_frameRead << ", frameSize =" << m_frameSize << "readBytes =" << readBytes;
 if ((readBytes > 0) && ((m_frameRead + readBytes) <= m_frameSize)) {
 qCDebug(KSANECORE_LOG) << "This is not a standard compliant backend";
 copyToScanData(readBytes);
 }
 // There are broken backends that return wrong number for bytes_per_line
 if (m_params.depth == 1 && m_params.lines > 0 && m_params.lines * m_params.pixels_per_line <= m_frameRead * 8) {
 qCDebug(KSANECORE_LOG) << "Warning!! This backend seems to return wrong bytes_per_line for line-art images!";
 qCDebug(KSANECORE_LOG) << "Warning!! Trying to correct the value!";
 m_params.bytes_per_line = m_frameRead / m_params.lines;
 }
 m_readStatus = ReadReady; // It is better to return a broken image than nothing
 return;
 }
 if (m_params.last_frame == SANE_TRUE) {
 // this is where it all ends well :)
 m_imageBuilder.cropImagetoSize();
 m_readStatus = ReadReady;
 return;
 } else {
 // start reading next frame
 m_saneStatus = sane_start(m_saneHandle);
 if (m_saneStatus != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << "sane_start =" << sane_strstatus(m_saneStatus);
 m_readStatus = ReadError;
 return;
 }
 m_saneStatus = sane_get_parameters(m_saneHandle, &m_params);
 if (m_saneStatus != SANE_STATUS_GOOD) {
 qCDebug(KSANECORE_LOG) << "sane_get_parameters =" << sane_strstatus(m_saneStatus);
 m_readStatus = ReadError;
 sane_cancel(m_saneHandle);
 return;
 }
 //qCDebug(KSANECORE_LOG) << "New Frame";
 m_imageBuilder.beginFrame(m_params);
 m_frameRead = 0;
 m_frame_t_count++;
 break;
 }
 default:
 qCDebug(KSANECORE_LOG) << "sane_read=" << m_saneStatus << "=" << sane_strstatus(m_saneStatus);
 m_readStatus = ReadError;
 sane_cancel(m_saneHandle);
 return;
 }

copyToScanData(readBytes);
}

void ScanThread::copyToScanData(int readBytes)
{
 if (m_invertColors) {
 if (m_params.depth == 16) {
 //if (readBytes%2) qCDebug(KSANECORE_LOG) << "readBytes=" << readBytes;
 quint16 *u16ptr = reinterpret_cast<quint16 *>(m_readData);
 for (int i = 0; i < readBytes / 2; i++) {
 u16ptr[i] = 0xFFFF - u16ptr[i];
 }
 } else if (m_params.depth == 8) {
 for (int i = 0; i < readBytes; i++) {
 m_readData[i] = 0xFF - m_readData[i];
 }
 } else if (m_params.depth == 1) {
 for (int i = 0; i < readBytes; i++) {
 m_readData[i] = ~m_readData[i];
 }
 }
 }

QMutexLocker locker(&m_imageMutex);
    if (m_imageBuilder.copyToImage(m_readData, readBytes)) {
        m_frameRead += readBytes;
    } else {
        m_readStatus = ReadError;
    }
}

} // namespace KSaneCore

#include "moc_scanthread.cpp"
07070100000085000081A4000000000000000000000001660E103E000007D5000000000000000000000000000000000000003E00000000ksanecore-VERSIONgit.20240404T022814~46f9196/src/scanthread.h/*
 * SPDX-FileCopyrightText: 2009 Kare Sars <kare dot sars at iki dot fi>
 * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
 * SPDX-FileCopyrightText: 2021 Alexander Stippich <a.stippich@gmx.net>
 *
 * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */

#ifndef KSANE_SCAN_THREAD_H
#define KSANE_SCAN_THREAD_H

#include "imagebuilder.h"

// Sane includes
extern "C"
{
#include <sane/saneopts.h>
#include <sane/sane.h>
}

#include <QThread>
#include <QMutex>
#include <QByteArray>
#include <QImage>
#include <QTimer>

#define SCAN_READ_CHUNK_SIZE 100000

namespace KSaneCore
{

class ScanThread: public QThread
{
    Q_OBJECT
public:
    enum ReadStatus {
        ReadOngoing,
        ReadError,
        ReadCancel,
        ReadReady
    };

explicit ScanThread(SANE_Handle handle);
    void run() override;
    void setImageInverted(const QVariant &newValue);
    void setImageResolution(const QVariant &newValue);
    void cancelScan();

ReadStatus frameStatus();
    SANE_Status saneStatus();

void lockScanImage();
    QImage *scanImage();
    void unlockScanImage();

Q_SIGNALS:

void scanProgressUpdated(int progress);

private:
    void readData();
    void updateScanProgress();
    void copyToScanData(int readBytes);

SANE_Byte       m_readData[SCAN_READ_CHUNK_SIZE];
    SANE_Handle     m_saneHandle;
    int             m_frameSize = 0;
    int             m_frameRead = 0;
    int             m_frame_t_count = 0;
    int             m_dataSize = 0;
    int             m_dpi = 0;
    SANE_Parameters m_params;
    SANE_Status     m_saneStatus = SANE_STATUS_GOOD;
    ReadStatus      m_readStatus = ReadReady;
    bool            m_announceFirstRead = true;
    bool            m_invertColors = false;
    ImageBuilder    m_imageBuilder;
    QImage          m_image;
    QMutex          m_imageMutex;

QTimer          m_emitProgressUpdateTimer;
};

} // namespace KSaneCore

#endif // KSANE_SCAN_THREAD_H
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!596 blocks

Places

File _service:obs_scm:ksanecore-VERSIONgit.20240404T022814~46f9196.obscpio of Package ksanecore (Revision 3bc327a9f090d67a2640000d39d7fabc)

Places