pax_global_header00006660000000000000000000000064144033076000014507gustar00rootroot0000000000000052 comment=997fd557b96ea238e27a15f11b0acf338cfe7db4 kImageAnnotator-0.6.1/000077500000000000000000000000001440330760000145765ustar00rootroot00000000000000kImageAnnotator-0.6.1/.github/000077500000000000000000000000001440330760000161365ustar00rootroot00000000000000kImageAnnotator-0.6.1/.github/FUNDING.yml000066400000000000000000000002401440330760000177470ustar00rootroot00000000000000# These are supported funding model platforms github: DamirPorobic liberapay: dporobic patreon: dporobic open_collective: ksnip custom: paypal.me/damirporobic kImageAnnotator-0.6.1/.github/scripts/000077500000000000000000000000001440330760000176255ustar00rootroot00000000000000kImageAnnotator-0.6.1/.github/scripts/build_kImageAnnotator.sh000066400000000000000000000002301440330760000244160ustar00rootroot00000000000000#!/bin/bash mkdir build && cd build cmake .. -G"${CMAKE_GENERATOR}" -DBUILD_TESTS=ON -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX} ${MAKE_BINARY} VERBOSE=1kImageAnnotator-0.6.1/.github/scripts/linux/000077500000000000000000000000001440330760000207645ustar00rootroot00000000000000kImageAnnotator-0.6.1/.github/scripts/linux/setup_linux_build_variables.sh000066400000000000000000000001511440330760000271030ustar00rootroot00000000000000#!/bin/bash echo "MAKE_BINARY=make" >> $GITHUB_ENV echo "CMAKE_GENERATOR=Unix Makefiles" >> $GITHUB_ENV kImageAnnotator-0.6.1/.github/scripts/setup_build_variables.sh000066400000000000000000000002541440330760000245310ustar00rootroot00000000000000#!/bin/bash WORKSPACE="$GITHUB_WORKSPACE" INSTALL_PREFIX="$WORKSPACE/tmp" echo "WORKSPACE=$WORKSPACE" >> $GITHUB_ENV echo "INSTALL_PREFIX=$INSTALL_PREFIX" >> $GITHUB_ENV kImageAnnotator-0.6.1/.github/scripts/setup_googleTest.sh000066400000000000000000000004061440330760000235150ustar00rootroot00000000000000#!/bin/bash git clone --depth 1 https://github.com/google/googletest cd googletest || exit mkdir build && cd build || exit cmake .. -G"${CMAKE_GENERATOR}" -DCMAKE_INSTALL_PREFIX="${INSTALL_PREFIX}" -DBUILD_SHARED_LIBS=ON ${MAKE_BINARY} && ${MAKE_BINARY} installkImageAnnotator-0.6.1/.github/scripts/setup_kColorPicker.sh000066400000000000000000000004131440330760000237660ustar00rootroot00000000000000#!/bin/bash git clone --depth 1 https://github.com/ksnip/kColorPicker.git cd kColorPicker || exit mkdir build && cd build || exit cmake .. -G"${CMAKE_GENERATOR}" -DBUILD_EXAMPLE=OFF -DCMAKE_INSTALL_PREFIX="${INSTALL_PREFIX}" ${MAKE_BINARY} && ${MAKE_BINARY} installkImageAnnotator-0.6.1/.github/scripts/windows/000077500000000000000000000000001440330760000213175ustar00rootroot00000000000000kImageAnnotator-0.6.1/.github/scripts/windows/setup_windows_build_variables.sh000066400000000000000000000003351440330760000277750ustar00rootroot00000000000000#!/bin/bash echo "MAKE_BINARY=nmake" >> $GITHUB_ENV echo "CMAKE_GENERATOR=NMake Makefiles" >> $GITHUB_ENV echo "LIB=$LIB;$INSTALL_PREFIX/lib" >> $GITHUB_ENV echo "INCLUDE=$INCLUDE;$INSTALL_PREFIX/include" >> $GITHUB_ENVkImageAnnotator-0.6.1/.github/workflows/000077500000000000000000000000001440330760000201735ustar00rootroot00000000000000kImageAnnotator-0.6.1/.github/workflows/linux.yml000066400000000000000000000021131440330760000220520ustar00rootroot00000000000000name: linux on: push: branches: [ master ] pull_request: branches: [ master ] jobs: build: runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v2 - name: Set up build variables run: bash ./.github/scripts/setup_build_variables.sh - name: Set up linux build variables run: bash ./.github/scripts/linux/setup_linux_build_variables.sh - name: Install Qt uses: jurplel/install-qt-action@v2 with: version: '5.15.2' host: 'linux' install-deps: 'true' - name: Install dependencies run: sudo apt-get install extra-cmake-modules xvfb - name: Set up GoogleTest run: bash ./.github/scripts/setup_googleTest.sh - name: Set up kColorPicker run: bash ./.github/scripts/setup_kColorPicker.sh - name: Build run: bash ./.github/scripts/build_kImageAnnotator.sh - name: Test working-directory: ${{github.workspace}}/build/tests run: xvfb-run --auto-servernum --server-num=1 --server-args="-screen 0 1024x768x24" ctest --extra-verbose kImageAnnotator-0.6.1/.github/workflows/windows.yml000066400000000000000000000022741440330760000224150ustar00rootroot00000000000000name: windows on: push: branches: [ master ] pull_request: branches: [ master ] jobs: build: runs-on: windows-latest steps: - name: Checkout uses: actions/checkout@v2 - name: Set up build variables run: bash ./.github/scripts/setup_build_variables.sh - name: Set up windows build variables run: bash ./.github/scripts/windows/setup_windows_build_variables.sh - name: Install Qt uses: jurplel/install-qt-action@v2 with: version: '5.15.2' host: 'windows' install-deps: 'true' arch: 'win64_msvc2019_64' - name: Set up nmake uses: ilammy/msvc-dev-cmd@v1 - name: Set up kColorPicker run: bash ./.github/scripts/setup_kColorPicker.sh - name: Set up GoogleTest run: bash ./.github/scripts/setup_googleTest.sh - name: Add GoogleTest bin dir to PATH uses: myci-actions/export-env-var-powershell@1 with: name: PATH value: $env:PATH;$env:INSTALL_PREFIX/bin - name: Build run: bash ./.github/scripts/build_kImageAnnotator.sh - name: Test working-directory: ${{github.workspace}}/build/tests run: ctest --extra-verbose kImageAnnotator-0.6.1/.gitignore000066400000000000000000000012241440330760000165650ustar00rootroot00000000000000# C++ objects and libs *.slo *.lo *.o *.a *.la *.lai *.so *.dll *.dylib # Qt-es /.qmake.cache /.qmake.stash *.pro.user *.pro.user.* *.qbs.user *.qbs.user.* *.moc moc_*.cpp qrc_*.cpp ui_*.h Makefile* *build-* # QtCreator *.autosave # QtCtreator Qml *.qmlproject.user *.qmlproject.user.* # QtCtreator CMake CMakeLists.txt.user # kdevelop apidocs .kdev4 build *~ *.kdev4 *.bak *.orig *.rej doxygen.log Doxyfile *.kdevelop *.kdevelop.filelist *.kdevelop.pcs *.kdevses .*kate-swp build/ mem.log.* massif.* callgrind.* perf.data* # from kdiff3 *.BACKUP.* *.BASE.* *.LOCAL.* *.REMOTE.* # visual studio code *.vscode/ # clion *.idea *.idea/ # misc .directorykImageAnnotator-0.6.1/CHANGELOG.md000066400000000000000000000440211440330760000164100ustar00rootroot00000000000000# Change log ## Release 0.6.1 * Fixed: Fix for unnecessary scrollbars when a screenshot has a smaller size than the previous one. ([#303](https://github.com/ksnip/kImageAnnotator/issues/303)) * Fixed: Add KDE support for scale factor. ([#302](https://github.com/ksnip/kImageAnnotator/issues/302)) * Fixed: Show tab tooltips on initial tabs. * Fixed: Sticker resizing is broken when bounding rect flipped. ([#306](https://github.com/ksnip/kImageAnnotator/issues/306)) ## Release 0.6.0 * New: Add optional undo, redo, crop, scale and modify canvas buttons to dock widgets. ([#263](https://github.com/ksnip/kImageAnnotator/issues/263)) * New: Cut out vertical or horizontal slice of an image. ([#236](https://github.com/ksnip/kImageAnnotator/issues/236)) * New: Middle-click on tab header closes tab. ([#280](https://github.com/ksnip/kImageAnnotator/issues/280)) * New: Add button to fit image into current view. ([#281](https://github.com/ksnip/kImageAnnotator/issues/281)) * New: Allow changing item opacity. ([#110](https://github.com/ksnip/kImageAnnotator/issues/110)) * New: Add support for RGBA colors with transparency. ([#119](https://github.com/ksnip/kImageAnnotator/issues/119)) * New: Add mouse cursor sticker. ([#290](https://github.com/ksnip/kImageAnnotator/issues/290)) * New: Allow scaling stickers per setting. ([#285](https://github.com/ksnip/kImageAnnotator/issues/285)) * New: Respect original aspect ratio of stickers. ([#291](https://github.com/ksnip/kImageAnnotator/issues/291)) * New: Respect original size of stickers. ([#295](https://github.com/ksnip/kImageAnnotator/issues/295)) * Fixed: Adding image effect does not send image change notification. ([#283](https://github.com/ksnip/kImageAnnotator/issues/283)) * Fixed: Blur / Pixelate break when going past image edge once. ([#267](https://github.com/ksnip/kImageAnnotator/issues/267)) * Fixed: Item opacity not applied when item shadow disabled. ([#284](https://github.com/ksnip/kImageAnnotator/issues/284)) * Changed: Max font size changed to 100pt. ## Release 0.5.3 * Fixed: Crash while typing text on wayland. ([#256](https://github.com/ksnip/kImageAnnotator/issues/256)) * Changed: Show scrollbar when not all tools visible. ([#258](https://github.com/ksnip/kImageAnnotator/issues/258)) ## Release 0.5.2 * Fixed: Memory leaks caught by ASAN. ([#243](https://github.com/ksnip/kImageAnnotator/issues/243)) * Changed: Use system font provided by QGuiApplication as default for text tool. ([#247](https://github.com/ksnip/kImageAnnotator/issues/247)) ## Release 0.5.1 * Fixed: Crashes on destruction. ([#242](https://github.com/ksnip/kImageAnnotator/issues/242)) ## Release 0.5.0 * New: Add function for loading translations. ([#173](https://github.com/ksnip/kImageAnnotator/issues/173)) * New: Add a new tool for creating resizable movable duplicates of regions. ([#131](https://github.com/ksnip/kImageAnnotator/issues/131)) * New: Add support for hiding annotation settings panel. ([#182](https://github.com/ksnip/kImageAnnotator/issues/182)) * New: Add config option for numbering tool to only set next number. ([#42](https://github.com/ksnip/kImageAnnotator/issues/42)) * New: Allow manually changing canvas size. ([#92](https://github.com/ksnip/kImageAnnotator/issues/92)) * New: Canvas background color configurable. ([#91](https://github.com/ksnip/kImageAnnotator/issues/91)) * New: Zoom in and out with keyboard shortcuts. ([#192](https://github.com/ksnip/kImageAnnotator/issues/192)) * New: Zoom in and out via buttons from UI. ([#197](https://github.com/ksnip/kImageAnnotator/issues/197)) * New: Add reset zoom keyboard shortcut with tooltip. ([#209](https://github.com/ksnip/kImageAnnotator/issues/209)) * New: Add keyboard shortcut support for text tool. ([#183](https://github.com/ksnip/kImageAnnotator/issues/183)) * New: Allow rotating background image. ([#199](https://github.com/ksnip/kImageAnnotator/issues/199)) * New: Allow flipping background image horizontally and vertically. ([#221](https://github.com/ksnip/kImageAnnotator/issues/221)) * New: Configurable UI with dockable settings widgets. ([#102](https://github.com/ksnip/kImageAnnotator/issues/102)) * New: Add invert color image effect. ([#228](https://github.com/ksnip/kImageAnnotator/issues/228)) * New: Allow disabling item shadow per item from UI. ([#223](https://github.com/ksnip/kImageAnnotator/issues/223)) * New: Add a font selection to UI. ([#130](https://github.com/ksnip/kImageAnnotator/issues/130)) * New: Add zoom in/out capability to crop view. ([#212](https://github.com/ksnip/kImageAnnotator/issues/212)) * New: Allow to zoom in modify canvas view. ([#229](https://github.com/ksnip/kImageAnnotator/issues/229)) * New: Select item after drawing it and allow changing settings. ([#230](https://github.com/ksnip/kImageAnnotator/issues/230)) * Changed: Change drop shadow to cover all sites. ([#202](https://github.com/ksnip/kImageAnnotator/issues/202)) * Fixed: Deleting item outside image doesn't decrease canvas size. ([#164](https://github.com/ksnip/kImageAnnotator/issues/164)) * Fixed: Duplicate region of grayscale image has color. ([#214](https://github.com/ksnip/kImageAnnotator/issues/214)) * Fixed: Marker shows fill and width config when modifying existing item. ([#225](https://github.com/ksnip/kImageAnnotator/issues/225)) * Fixed: Highlighter/Marker washed out color and overlapping. ([#227](https://github.com/ksnip/kImageAnnotator/issues/227)) * Fixed: Popup menus shown outside screen. ([#226](https://github.com/ksnip/kImageAnnotator/issues/226)) * Fixed: Not possible to enter value in the width tool. ([#233](https://github.com/ksnip/kImageAnnotator/issues/233)) * Fixed: Obfuscation tool shows fonts settings when switching from tool with font. ([#231](https://github.com/ksnip/kImageAnnotator/issues/231)) * Fixed: Annotation tools are not displayed if application starts with docks hidden. ([#237](https://github.com/ksnip/kImageAnnotator/issues/237)) * Fixed: Vertical scrollbar missing after using Paste embedded and moving the image. ([#232](https://github.com/ksnip/kImageAnnotator/issues/232)) * Fixed: Not possible to disable tool automatically deselected after drawn. ([#238](https://github.com/ksnip/kImageAnnotator/issues/238)) * Fixed: Annotation tool shortcuts do not work if the panel is hidden. ([#239](https://github.com/ksnip/kImageAnnotator/issues/239)) ## Release 0.4.2 * Fixed: Fetching image from annotator with HiDPI enabled pixelates image. ([#218](https://github.com/ksnip/kImageAnnotator/issues/218)) * Fixed: Keep aspect ratio only work when pressing CTRL before moving resize handle. ([#219](https://github.com/ksnip/kImageAnnotator/issues/219)) ## Release 0.4.1 * Changed: Horizontally align text inside spin box. ([#203](https://github.com/ksnip/kImageAnnotator/issues/203)) * Changed: Change zoom with mouse wheel to CTRL+Wheel. ([#210](https://github.com/ksnip/kImageAnnotator/issues/210)) * Fixed: Brazilian Portuguese translation not loaded. ([#176](https://github.com/ksnip/kImageAnnotator/issues/176)) * Fixed: error: control reaches end of non-void function. ([#177](https://github.com/ksnip/kImageAnnotator/issues/177)) * Fixed: Cursor in Text tool have too bad visibility. ([#184](https://github.com/ksnip/kImageAnnotator/issues/184)) * Fixed: bumped SONAME without name change. ([#185](https://github.com/ksnip/kImageAnnotator/issues/185)) * Fixed: Entering multiple characters at once moves the text cursor only for one character. ([#186](https://github.com/ksnip/kImageAnnotator/issues/186)) * Fixed: Activating context menu while drawing item leaves item in error state. ([#196](https://github.com/ksnip/kImageAnnotator/issues/196)) * Fixed: Icons not scaled on gnome with hdpi enabled. ([#201](https://github.com/ksnip/kImageAnnotator/issues/201)) * Fixed: Text/Number Pointer and Text/Number Arrow don't inherit Text/Number Font in Settings. ([#208](https://github.com/ksnip/kImageAnnotator/issues/208)) ## Release 0.4.0 * New: Add Pixelate image area tool. ([#140](https://github.com/ksnip/kImageAnnotator/issues/140)) * New: Zoom in and out. ([#123](https://github.com/ksnip/kImageAnnotator/issues/123)) * New: Add interface for adding custom tab context menu actions. ([#96](https://github.com/ksnip/kImageAnnotator/issues/96)) * New: Add drop shadow to captured images. ([#133](https://github.com/ksnip/kImageAnnotator/issues/133)) * New: Add grayscale image effect. ([#151](https://github.com/ksnip/kImageAnnotator/issues/151)) * New: Add numeric pointer with arrow annotation item. ([#152](https://github.com/ksnip/kImageAnnotator/issues/152)) * New: Add text pointer annotation item. ([#154](https://github.com/ksnip/kImageAnnotator/issues/154)) * New: Add text pointer with arrow annotation item. ([#153](https://github.com/ksnip/kImageAnnotator/issues/153)) * New: Add option to automatically switching to select tool after drawing item. ([#161](https://github.com/ksnip/kImageAnnotator/issues/161)) * New: Edit Text box with double click. ([#60](https://github.com/ksnip/kImageAnnotator/issues/60)) * New: Resize elements while keeping aspect ratio. ([#170](https://github.com/ksnip/kImageAnnotator/issues/170)) * Changed: Draw point when clicking and releasing without moving cursor. ([#136](https://github.com/ksnip/kImageAnnotator/issues/136)) * Changed: Zoom out less than 100%. ([#150](https://github.com/ksnip/kImageAnnotator/issues/150)) * Changed: Change to select tool after adding new annotation item. ([#155](https://github.com/ksnip/kImageAnnotator/issues/155)) * Changed: Move current zoom text to left side config panel. ([#157](https://github.com/ksnip/kImageAnnotator/issues/157)) * Fixed: Blur radius not updated when changing current items settings. ([#142](https://github.com/ksnip/kImageAnnotator/issues/142)) * Fixed: Text tool opens many unix sockets. ([#144](https://github.com/ksnip/kImageAnnotator/issues/144)) * Fixed: Text No Border and No Fill shows shadow beneath text. ([#148](https://github.com/ksnip/kImageAnnotator/issues/148)) * Fixed: Item properties remain displayed after item is removed or deselected. ([#168](https://github.com/ksnip/kImageAnnotator/issues/168)) * Fixed: Changing text box through editing text doesn't update resize handles. ([#171](https://github.com/ksnip/kImageAnnotator/issues/171)) * Fixed kColorPicker: Border around colors is not centered. ([#6](https://github.com/ksnip/kColorPicker/issues/6)) ## Release 0.3.2 * Fixed: Tests fail to build with shared library. ([#128](https://github.com/ksnip/kImageAnnotator/issues/128)) ## Release 0.3.1 * Fixed: Crashes after undoing a number annotation. ([#114](https://github.com/ksnip/kImageAnnotator/issues/114)) * Fixed: Text overlapping when resizing text box. ([#53](https://github.com/ksnip/kImageAnnotator/issues/53)) * Fixed: Snap lines to degrees not working when CTRL pressed before clicking annotation area. ([#113](https://github.com/ksnip/kImageAnnotator/issues/113)) * Fixed: "Border and Fill" submenu cutting off text under windows. ([#117](https://github.com/ksnip/kImageAnnotator/issues/117)) * Fixed: Undo removes several or all items. ([#121](https://github.com/ksnip/kImageAnnotator/issues/121)) * Fixed: Marker Rect and Ellipse draw only border but no fill. ([#126](https://github.com/ksnip/kImageAnnotator/issues/126)) ## Release 0.3.0 * New: Tabs for images. ([#48](https://github.com/ksnip/kImageAnnotator/issues/48)) * New: Add option to translate UI. ([#54](https://github.com/ksnip/kImageAnnotator/issues/54)) * New: Saved image expand to include annotations out of border. ([#90](https://github.com/ksnip/kImageAnnotator/issues/90)) * New: Add support for stickers. ([#74](https://github.com/ksnip/kImageAnnotator/issues/74)) * New: Add tab context menu for close all tabs and close other tabs. ([#93](https://github.com/ksnip/kImageAnnotator/issues/93)) * New: Add Number with Arrow/pointer tool. ([#79](https://github.com/ksnip/kImageAnnotator/issues/79)) * Changed: Make dropdown buttons show popup on click. ([#89](https://github.com/ksnip/kImageAnnotator/issues/89)) * Changed: Hide unavailable setting widgets. ([#101](https://github.com/ksnip/kImageAnnotator/issues/101)) * Changed: Make arrow size decrease with stroke size. ([#84](https://github.com/ksnip/kImageAnnotator/issues/84)) * Fixed: Using select tool marks image as changed. ([#97](https://github.com/ksnip/kImageAnnotator/issues/97)) * Fixed: Emoticon selector shows a half of current emoticon. ([#104](https://github.com/ksnip/kImageAnnotator/issues/104)) * Fixed: FillPicker text or icon sometimes not visible. ([#105](https://github.com/ksnip/kImageAnnotator/issues/105)) * Fixed: Wrong image scaling on hdpi screen. ([#81](https://github.com/ksnip/kImageAnnotator/issues/81)) * Fixed: Copy area size differs from last capture. ([#107](https://github.com/ksnip/kImageAnnotator/issues/107)) * Fixed: Number Tool not reset when switching between tabs. ([#106](https://github.com/ksnip/kImageAnnotator/issues/106)) ## Release 0.2.1 * Fixed: Edit border around text box doesn't disappear when done with editing. ([#71](https://github.com/ksnip/kImageAnnotator/issues/71)) * Fixed: Edit border not shown under Windows when NoFillNoBorder selected for Text Tool. ([#72](https://github.com/ksnip/kImageAnnotator/issues/72)) * Fixed: When adding text with background under Windows a filled rect is show in top left corner. ([#73](https://github.com/ksnip/kImageAnnotator/issues/73)) * Fixed: Drawing text tool rect from right to left and bottom top create no rect. ([#76](https://github.com/ksnip/kImageAnnotator/issues/76)) * Fixed: Text Tool FillType selection not saved. ([#75](https://github.com/ksnip/kImageAnnotator/issues/75)) * Fixed: Icons not scaled with HiDPI. ([#77](https://github.com/ksnip/kImageAnnotator/issues/77)) * Fixed: Text Cursor not show on Linux. ([#70](https://github.com/ksnip/kImageAnnotator/issues/70)) ## Release 0.2.0 * New: Add image item and interface for adding them externally. ([#45](https://github.com/ksnip/kImageAnnotator/issues/45)) * New: Edit text box content. ([#51](https://github.com/ksnip/kImageAnnotator/issues/51)) * New: Add cmake uninstall target. ([#47](https://github.com/ksnip/kImageAnnotator/issues/47)) * New: Panning image by holding space or mouse middle button and dragging. ([#9](https://github.com/ksnip/kImageAnnotator/issues/9)) * New: Change annotation element config after drawing. ([#44](https://github.com/ksnip/kImageAnnotator/issues/44)) * Changed: Increase blur level so that large text is not visible. ([#62](https://github.com/ksnip/kImageAnnotator/issues/62)) * Changed: Crop widget updates shows via cursor if something is movable. ([#64](https://github.com/ksnip/kImageAnnotator/issues/64)) * Changed: Multi-tool buttons select current (last) tool on single click. ([#66](https://github.com/ksnip/kImageAnnotator/issues/66)) * Fixed: Ctrl Modifier stuck on second or third screenshot with Ctrl-N. ([#58](https://github.com/ksnip/kImageAnnotator/issues/58)) * Fixed: Unable to select number annotation when clicking on the number without background. ([#46](https://github.com/ksnip/kImageAnnotator/issues/46)) * Fixed: Undo/Redo is now disabled during crop and scale operation. ([#56](https://github.com/ksnip/kImageAnnotator/issues/56)) * Fixed: Mess with russian letters in text tool when typing in Russian. ([#59](https://github.com/ksnip/kImageAnnotator/issues/59)) * Fixed: Text tool does not allow me to type accents. ([#57](https://github.com/ksnip/kImageAnnotator/issues/57)) * Fixed: Highlighter rect and ellipse have only border but no fill. ([#65](https://github.com/ksnip/kImageAnnotator/issues/65)) * Fixed: Saved tool selection not loaded on startup. ([#67](https://github.com/ksnip/kImageAnnotator/issues/67)) * Fixed: On startup does not highlight tool, when this tool not the first item in the list. ([#63](https://github.com/ksnip/kImageAnnotator/issues/63)) * Fixed: Cursor image cannot be grabbed for moving. ([#69](https://github.com/ksnip/kImageAnnotator/issues/69)) * Fixed: Accents still not work in text tool on Linux. ([#61](https://github.com/ksnip/kImageAnnotator/issues/61)) ## Release 0.1.0 * New: Double Arrow annotation tool. ([#23](https://github.com/ksnip/kImageAnnotator/issues/23)) * New: Marker Rectangle and Ellipse annotation tool. ([#26](https://github.com/ksnip/kImageAnnotator/issues/26)) * New: Add icons for dark theme. ([#37](https://github.com/ksnip/kImageAnnotator/issues/37)) * New: Add config option to setup blur radius. ([#25](https://github.com/ksnip/kImageAnnotator/issues/25)) * Changed: Blur tool is now preciser and fits the rect. ([#28](https://github.com/ksnip/kImageAnnotator/issues/28)) * Changed: Enter finishes text input and shift-enter adds new line in Text Tool. ([#30](https://github.com/ksnip/kImageAnnotator/issues/30)) * Changed: Text item draws border around the text when in text edit mode. ([#34](https://github.com/ksnip/kImageAnnotator/issues/34)) * Fixed: Double-click on annotation area causes SIGSEGV crash. ([#29](https://github.com/ksnip/kImageAnnotator/issues/29)) * Fixed: CAPS LOCK doesnt work on image editor. ([#27](https://github.com/ksnip/kImageAnnotator/issues/27)) * Fixed: Unable to select text item when clicking on text. ([#32](https://github.com/ksnip/kImageAnnotator/issues/32)) * Fixed: Some blurs get removed when losing focus. ([#35](https://github.com/ksnip/kImageAnnotator/issues/35)) * Fixed: Items cannot be resized when drawn from bottom right to top left. ([#38](https://github.com/ksnip/kImageAnnotator/issues/38)) * Fixed: Right click on annotation items selects item but doesn't switch tool. ([#40](https://github.com/ksnip/kImageAnnotator/issues/40)) * Fixed: Copy number annotation item doesn't increment number. ([#41](https://github.com/ksnip/kImageAnnotator/issues/41)) * Fixed: Crash on startup after adding Blur Radius Picker. ([#43](https://github.com/ksnip/kImageAnnotator/issues/43)) ## Release 0.0.2 * New: Added blur annotation tool. ([#20](https://github.com/ksnip/kImageAnnotator/issues/20)) * New: Keep number tool sequence consecutive after deleting item. ([#7](https://github.com/ksnip/kImageAnnotator/issues/7)) * New: Added control for setting first number for numbering tool. ([#7](https://github.com/ksnip/kImageAnnotator/issues/7)) * New: Text and Number tool have now noBorderAndNoFill type. ([#22](https://github.com/ksnip/kImageAnnotator/issues/22)) ## Release 0.0.1 * New: Initial release kImageAnnotator-0.6.1/CMakeLists.txt000066400000000000000000000106501440330760000173400ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.5) project(kImageAnnotator LANGUAGES CXX VERSION 0.6.1) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_CXX_VISIBILITY_PRESET hidden) set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) set(CMAKE_AUTOMOC ON) set(CMAKE_AUTORCC ON) option(BUILD_TESTS "Build Unit Tests" OFF) option(BUILD_EXAMPLE "Build Example Application" ON) include(GNUInstallDirs) if (WIN32) set(KIMAGEANNOTATOR_LANG_INSTALL_DIR "translations") elseif (APPLE) set(KIMAGEANNOTATOR_LANG_INSTALL_DIR "../Resources") elseif (UNIX) set(KIMAGEANNOTATOR_LANG_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/kImageAnnotator/translations") string(REGEX REPLACE "//" "/" KIMAGEANNOTATOR_LANG_INSTALL_DIR "${KIMAGEANNOTATOR_LANG_INSTALL_DIR}") endif () set(QT_MIN_VERSION 5.9.4) find_package(Qt5 ${QT_MIN_VERSION} REQUIRED Widgets Svg) if (UNIX AND NOT APPLE) find_package(X11 REQUIRED) endif () include(FeatureSummary) set(KCOLORPICKER_MIN_VERSION 0.2.0) find_package(kColorPicker ${KCOLORPICKER_MIN_VERSION} REQUIRED) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) add_subdirectory(src) add_subdirectory(translations) if (BUILD_EXAMPLE) add_subdirectory(example) endif (BUILD_EXAMPLE) if (BUILD_TESTS) add_subdirectory(tests) endif (BUILD_TESTS) include(CMakePackageConfigHelpers) add_library(kImageAnnotator ${KIMAGEANNOTATOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/include/kImageAnnotator/KImageAnnotator.h ${CMAKE_CURRENT_SOURCE_DIR}/resources/kImageAnnotator_resources.qrc src/common/helper/DesktopEnvironmentChecker.cpp src/common/helper/DesktopEnvironmentChecker.h src/common/enum/DesktopEnvironmentType.h) add_library(kImageAnnotator::kImageAnnotator ALIAS kImageAnnotator) target_include_directories(kImageAnnotator PUBLIC $ $ $ ) target_link_libraries(kImageAnnotator PUBLIC Qt5::Widgets Qt5::Svg PRIVATE kColorPicker::kColorPicker) if (UNIX AND NOT APPLE) # X11::X11 imported target only available with sufficiently new CMake if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.14.0) target_link_libraries(kImageAnnotator PRIVATE X11::X11) else() target_link_libraries(kImageAnnotator PRIVATE X11) endif() endif () target_compile_definitions(kImageAnnotator PRIVATE KIMAGEANNOTATOR_LIB) target_compile_definitions(kImageAnnotator PRIVATE KIMAGEANNOTATOR_LANG_INSTALL_DIR="${KIMAGEANNOTATOR_LANG_INSTALL_DIR}") set_target_properties(kImageAnnotator PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin VERSION ${PROJECT_VERSION} SOVERSION 0 ) install(TARGETS kImageAnnotator EXPORT kImageAnnotator-targets ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ) install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/kImageAnnotator DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ) configure_package_config_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/kImageAnnotatorConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/cmake/kImageAnnotatorConfig.cmake INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/kImageAnnotator ) write_basic_package_version_file( ${CMAKE_CURRENT_BINARY_DIR}/cmake/kImageAnnotatorConfig-version.cmake VERSION ${PROJECT_VERSION} COMPATIBILITY AnyNewerVersion ) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/kImageAnnotatorConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/cmake/kImageAnnotatorConfig-version.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/kImageAnnotator ) export( EXPORT kImageAnnotator-targets FILE ${CMAKE_CURRENT_BINARY_DIR}/cmake/kImageAnnotator-targets.cmake NAMESPACE kImageAnnotator:: ) install( EXPORT kImageAnnotator-targets FILE kImageAnnotator-targets.cmake NAMESPACE kImageAnnotator:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/kImageAnnotator ) # uninstall target if(NOT TARGET uninstall) configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY) add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) endif() kImageAnnotator-0.6.1/LICENSE000066400000000000000000000167441440330760000156170ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. 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. kImageAnnotator-0.6.1/README.md000066400000000000000000000053171440330760000160630ustar00rootroot00000000000000# kImageAnnotator [![Linux Build Status][github-badge-linux]][github-url-linux] [![Windows Build Status][github-badge-windows]][github-url-windows] [![Translation status][weblate-badge]][weblate-url] Tool for annotating images Version 0.6.1 ![kImageAnnotator](https://i.imgur.com/4vlPDUn.png "kImageAnnotator") ### Dependencies kImageAnnotator depends on [kColorPicker](https://github.com/ksnip/kColorPicker) which needs to be installed before building kImageAnnotator. Install instructions can be found on the GitHub page. ### Building from source 1. Get the latest release from GitHub by cloning the repo: `$ git clone https://github.com/ksnip/kImageAnnotator` 2. Change to repo directory: `$ cd kImageAnnotator` 3. Make new build directory and enter it: `$ mkdir build && cd build` 4. Create the makefile and build the project: `$ cmake .. && make` 5. Install shared library (not required when only using the example): `$ sudo make install` 6. Run the example application: `$ ./example/kImageAnnotator-example` ### Shared vs Static You can either build the project as shared library by providing the flag `-DBUILD_SHARED_LIBS=ON` to cmake or `-DBUILD_SHARED_LIBS=OFF` to build as static library. When no flag is provided a static library is build. For windows, we currently only support building as static library. ### Integrate library 1. Let cmake find the shared library, optionally with version `set(KIMAGEANNOTATOR_MIN_VERSION "0.x.x")` `find_package(kImageAnnotator ${KIMAGEANNOTATOR_MIN_VERSION} REQUIRED)` 2. Link the library with your application `target_link_libraries(myApp kImageAnnotator)` ### Translations We are always looking for help with translations, contributors are welcome! For translations, we use [Weblate](https://hosted.weblate.org/projects/kimageannotator/kimageannotator/)! [![Translation status](https://hosted.weblate.org/widgets/kimageannotator/-/kimageannotator/multi-green.svg)](https://hosted.weblate.org/engage/kimageannotator/?utm_source=widget) ### Acknowledgement Stickers designed by [OpenMoji](https://openmoji.org/) – the open-source emoji and icon project. [github-badge-linux]: https://github.com/ksnip/kImageAnnotator/actions/workflows/linux.yml/badge.svg [github-url-linux]: https://github.com/ksnip/kImageAnnotator/actions [github-badge-windows]: https://github.com/ksnip/kImageAnnotator/actions/workflows/windows.yml/badge.svg [github-url-windows]: https://github.com/ksnip/kImageAnnotator/actions [weblate-badge]: https://hosted.weblate.org/widgets/kimageannotator/-/kimageannotator/svg-badge.svg [weblate-url]: https://hosted.weblate.org/engage/kimageannotator/?utm_source=widgetkImageAnnotator-0.6.1/cmake/000077500000000000000000000000001440330760000156565ustar00rootroot00000000000000kImageAnnotator-0.6.1/cmake/cmake_uninstall.cmake.in000066400000000000000000000017551440330760000224460ustar00rootroot00000000000000if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt") endif(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files) string(REGEX REPLACE "\n" ";" files "${files}") foreach(file ${files}) message(STATUS "Uninstalling $ENV{DESTDIR}${file}") if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") exec_program( "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" OUTPUT_VARIABLE rm_out RETURN_VALUE rm_retval ) if(NOT "${rm_retval}" STREQUAL 0) message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") endif(NOT "${rm_retval}" STREQUAL 0) else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") message(STATUS "File $ENV{DESTDIR}${file} does not exist.") endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") endforeach(file) kImageAnnotator-0.6.1/cmake/kImageAnnotatorConfig.cmake.in000066400000000000000000000003511440330760000234750ustar00rootroot00000000000000include(CMakeFindDependencyMacro) @PACKAGE_INIT@ find_dependency(Qt5 @QT_MIN_VERSION@ COMPONENTS Widgets) if(NOT TARGET kImageAnnotator::kImageAnnotator) include("${CMAKE_CURRENT_LIST_DIR}/kImageAnnotator-targets.cmake") endif() kImageAnnotator-0.6.1/example/000077500000000000000000000000001440330760000162315ustar00rootroot00000000000000kImageAnnotator-0.6.1/example/CMakeLists.txt000066400000000000000000000001611440330760000207670ustar00rootroot00000000000000add_executable(kImageAnnotator-example main.cpp) target_link_libraries(kImageAnnotator-example kImageAnnotator) kImageAnnotator-0.6.1/example/main.cpp000066400000000000000000000075101440330760000176640ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include #include #include #include using kImageAnnotator::KImageAnnotator; int main(int argc, char **argv) { QApplication::setAttribute(Qt::AA_EnableHighDpiScaling); QApplication app(argc, argv); auto settingsCollapsed = false; QPixmap pixmap(QSize(500, 500)); pixmap.fill(QColor(Qt::darkGreen)); auto kImageAnnotator = new KImageAnnotator(); kImageAnnotator->setTabBarAutoHide(true); kImageAnnotator->addTab(pixmap, QLatin1String("image1"), QLatin1String("image1")); kImageAnnotator->addTab(pixmap, QLatin1String("image2"), QLatin1String("image2")); kImageAnnotator->addTab(pixmap, QLatin1String("image3"), QLatin1String("image3")); kImageAnnotator->addTab(pixmap, QLatin1String("image4"), QLatin1String("image4")); kImageAnnotator->setControlsWidgetVisible(true); kImageAnnotator->adjustSize(); QMainWindow mainWindow; mainWindow.setCentralWidget(kImageAnnotator); auto menuBar = mainWindow.menuBar(); auto menu = new QMenu(QLatin1String("Edit"), &mainWindow); auto annotationAction = new QAction(QLatin1String("Annotation"), &mainWindow); auto cropAction = new QAction(QLatin1String("Crop"), &mainWindow); auto scaleAction = new QAction(QLatin1String("Scale"), &mainWindow); auto rotateAction = new QAction(QLatin1String("Rotate"), &mainWindow); auto cutAction = new QAction(QLatin1String("Cut"), &mainWindow); auto modifyCanvasAction = new QAction(QLatin1String("Modify Canvas"), &mainWindow); auto toggleDocksAction = new QAction(QLatin1String("Toggle Docks"), &mainWindow); mainWindow.connect(annotationAction, &QAction::triggered, kImageAnnotator, &KImageAnnotator::showAnnotator); mainWindow.connect(cropAction, &QAction::triggered, kImageAnnotator, &KImageAnnotator::showCropper); mainWindow.connect(scaleAction, &QAction::triggered, kImageAnnotator, &KImageAnnotator::showScaler); mainWindow.connect(rotateAction, &QAction::triggered, kImageAnnotator, &KImageAnnotator::showRotator); mainWindow.connect(cutAction, &QAction::triggered, kImageAnnotator, &KImageAnnotator::showCutter); mainWindow.connect(modifyCanvasAction, &QAction::triggered, kImageAnnotator, &KImageAnnotator::showCanvasModifier); mainWindow.connect(toggleDocksAction, &QAction::triggered, [kImageAnnotator, settingsCollapsed]() mutable { settingsCollapsed = !settingsCollapsed; kImageAnnotator->setSettingsCollapsed(settingsCollapsed); }); mainWindow.connect(kImageAnnotator, &KImageAnnotator::tabCloseRequested, [kImageAnnotator](int tabId) { kImageAnnotator->removeTab(tabId); }); menu->addAction(annotationAction); menu->addAction(cropAction); menu->addAction(scaleAction); menu->addAction(rotateAction); menu->addAction(cutAction); menu->addAction(modifyCanvasAction); menu->addAction(toggleDocksAction); menuBar->addMenu(menu); mainWindow.show(); mainWindow.setMinimumSize(kImageAnnotator->sizeHint()); QPixmap imageItem(QSize(100, 100)); imageItem.fill(QColor(Qt::yellow)); kImageAnnotator->insertImageItem(QPointF(100,100), imageItem); return app.exec(); } kImageAnnotator-0.6.1/include/000077500000000000000000000000001440330760000162215ustar00rootroot00000000000000kImageAnnotator-0.6.1/include/kImageAnnotator/000077500000000000000000000000001440330760000213045ustar00rootroot00000000000000kImageAnnotator-0.6.1/include/kImageAnnotator/KImageAnnotator.h000066400000000000000000000056221440330760000245050ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_KIMAGEANNOTATOR_H #define KIMAGEANNOTATOR_KIMAGEANNOTATOR_H #include #include namespace kImageAnnotator { KIMAGEANNOTATOR_EXPORT void loadTranslations(); class KImageAnnotatorPrivate; class KIMAGEANNOTATOR_EXPORT KImageAnnotator : public QWidget { Q_OBJECT Q_DECLARE_PRIVATE(KImageAnnotator) public: explicit KImageAnnotator(); ~KImageAnnotator() override; QImage image() const; QImage imageAt(int index) const; QAction *undoAction(); QAction *redoAction(); QSize sizeHint() const override; void showAnnotator(); void showCropper(); void showScaler(); void showRotator(); void showCanvasModifier(); void showCutter(); public Q_SLOTS: void loadImage(const QPixmap &pixmap); int addTab(const QPixmap &pixmap, const QString &title, const QString &toolTip); void updateTabInfo(int index, const QString &title, const QString &toolTip); void insertImageItem(const QPointF &position, const QPixmap &pixmap); Q_DECL_DEPRECATED void setTextFont(const QFont &font); Q_DECL_DEPRECATED void setNumberFont(const QFont &font); Q_DECL_DEPRECATED void setItemShadowEnabled(bool enabled); void setSmoothPathEnabled(bool enabled); void setSaveToolSelection(bool enabled); void setSmoothFactor(int factor); void setSwitchToSelectToolAfterDrawingItem(bool enabled); void setNumberToolSeedChangeUpdatesAllItems(bool enabled); void setTabBarAutoHide(bool enabled); void removeTab(int index); void setStickers(const QStringList &stickerPaths, bool keepDefault); void addTabContextMenuActions(const QList & actions); void setSettingsCollapsed(bool isCollapsed); void setCanvasColor(const QColor &color); void setSelectItemAfterDrawing(bool enabled); void setControlsWidgetVisible(bool enabled); Q_SIGNALS: void imageChanged() const; void currentTabChanged(int index) const; void tabCloseRequested(int index) const; void tabMoved(int fromIndex, int toIndex); void tabContextMenuOpened(int index) const; private: QScopedPointer const d_ptr; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_KIMAGEANNOTATOR_H kImageAnnotator-0.6.1/include/kImageAnnotator/KImageAnnotatorExport.h000066400000000000000000000022611440330760000257030ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_KIMAGEANNOTATOR_EXPORT_H #define KIMAGEANNOTATOR_KIMAGEANNOTATOR_EXPORT_H #include #if defined(_WIN32) # define KIMAGEANNOTATOR_EXPORT #else #if defined(KIMAGEANNOTATOR_LIB) # define KIMAGEANNOTATOR_EXPORT Q_DECL_EXPORT #else # define KIMAGEANNOTATOR_EXPORT Q_DECL_IMPORT #endif #endif #endif // KIMAGEANNOTATOR_KIMAGEANNOTATOR_EXPORT_HkImageAnnotator-0.6.1/resources/000077500000000000000000000000001440330760000166105ustar00rootroot00000000000000kImageAnnotator-0.6.1/resources/icons/000077500000000000000000000000001440330760000177235ustar00rootroot00000000000000kImageAnnotator-0.6.1/resources/icons/dark/000077500000000000000000000000001440330760000206445ustar00rootroot00000000000000kImageAnnotator-0.6.1/resources/icons/dark/arrow.svg000066400000000000000000000066431440330760000225300ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/blur.svg000066400000000000000000000157771440330760000223520ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/bold.svg000066400000000000000000000056521440330760000223150ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/border.svg000066400000000000000000000036761440330760000226560ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/check.svg000066400000000000000000000035741440330760000224530ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/color.svg000066400000000000000000000047201440330760000225060ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/crop.svg000066400000000000000000000116531440330760000223360ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/cut.svg000066400000000000000000000051661440330760000221700ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/disabled.svg000066400000000000000000000046531440330760000231440ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/doubleArrow.svg000066400000000000000000000123421440330760000236540ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/dragHandle.svg000066400000000000000000000103521440330760000234170ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/dark/dropShadow.svg000066400000000000000000000070631440330760000235050ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/duplicate.svg000066400000000000000000001006111440330760000233360ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/effect.svg000066400000000000000000000154041440330760000226250ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/ellipse.svg000066400000000000000000000036431440330760000230300ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/fillType.svg000066400000000000000000000114071440330760000231600ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/fillType_borderAndFill.svg000066400000000000000000000037121440330760000257470ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/fillType_borderAndNoFill.svg000066400000000000000000000055311440330760000262450ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/fillType_noBorderAndNoFill.svg000066400000000000000000000037351440330760000265460ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/fitImage.svg000066400000000000000000000217021440330760000231140ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/dark/grayscale.svg000066400000000000000000000112231440330760000233360ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/invertColor.svg000066400000000000000000000060761440330760000237040ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/dark/italic.svg000066400000000000000000000051411440330760000226330ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/line.svg000066400000000000000000000037161440330760000223230ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/markerEllipse.svg000066400000000000000000000155501440330760000241720ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/markerPen.svg000066400000000000000000000122521440330760000233130ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/markerRect.svg000066400000000000000000000151211440330760000234640ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/modifycanvas.svg000066400000000000000000000115251440330760000240540ustar00rootroot00000000000000 kImageAnnotator-0.6.1/resources/icons/dark/number.svg000066400000000000000000000055071440330760000226640ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/numberArrow.svg000066400000000000000000000257571440330760000237100ustar00rootroot00000000000000 image/svg+xml   1 kImageAnnotator-0.6.1/resources/icons/dark/numberPointer.svg000066400000000000000000000100471440330760000242200ustar00rootroot00000000000000 image/svg+xml   kImageAnnotator-0.6.1/resources/icons/dark/obfuscateFactor.svg000066400000000000000000000101171440330760000244770ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/opacity.svg000066400000000000000000000050231440330760000230350ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/pen.svg000066400000000000000000000153561440330760000221610ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/pixelate.svg000066400000000000000000000132341440330760000232030ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/rect.svg000066400000000000000000000036471440330760000223340ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/redo.svg000066400000000000000000000070631440330760000223240ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/resetZoom.svg000066400000000000000000000213661440330760000233640ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/dark/rotate.svg000066400000000000000000000125521440330760000226700ustar00rootroot00000000000000 kImageAnnotator-0.6.1/resources/icons/dark/scale.svg000066400000000000000000000416211440330760000224600ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/dark/select.svg000066400000000000000000000074331440330760000226530ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/sticker.svg000066400000000000000000000061111440330760000230300ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/text.svg000066400000000000000000000042701440330760000223540ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/textArrow.svg000066400000000000000000000265311440330760000233730ustar00rootroot00000000000000 image/svg+xml     kImageAnnotator-0.6.1/resources/icons/dark/textColor.svg000066400000000000000000000062231440330760000233530ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/textPointer.svg000066400000000000000000000074471440330760000237260ustar00rootroot00000000000000 image/svg+xml   kImageAnnotator-0.6.1/resources/icons/dark/underline.svg000066400000000000000000000057371440330760000233660ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/undo.svg000066400000000000000000000071271440330760000223410ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/width.svg000066400000000000000000000114201440330760000225020ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/dark/zoom.svg000066400000000000000000000047401440330760000223560ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/000077500000000000000000000000001440330760000210325ustar00rootroot00000000000000kImageAnnotator-0.6.1/resources/icons/light/arrow.svg000066400000000000000000000066431440330760000227160ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/blur.svg000066400000000000000000000136361440330760000225300ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/bold.svg000066400000000000000000000056501440330760000225010ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/border.svg000066400000000000000000000036731440330760000230410ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/check.svg000066400000000000000000000036031440330760000226320ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/color.svg000066400000000000000000000047141440330760000226770ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/crop.svg000066400000000000000000000116731440330760000225260ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/cut.svg000066400000000000000000000052011440330760000223440ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/disabled.svg000066400000000000000000000046501440330760000233270ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/doubleArrow.svg000066400000000000000000000124051440330760000240420ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/dragHandle.svg000066400000000000000000000140141440330760000236040ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/light/dropShadow.svg000066400000000000000000000070601440330760000236700ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/duplicate.svg000066400000000000000000001005061440330760000235270ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/effect.svg000066400000000000000000000155311440330760000230140ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/ellipse.svg000066400000000000000000000036521440330760000232160ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/fillType.svg000066400000000000000000000114351440330760000233470ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/fillType_borderAndFill.svg000066400000000000000000000037241440330760000261400ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/fillType_borderAndNoFill.svg000066400000000000000000000055311440330760000264330ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/fillType_noBorderAndNoFill.svg000066400000000000000000000037351440330760000267340ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/fitImage.svg000066400000000000000000000214611440330760000233040ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/light/grayscale.svg000066400000000000000000000111351440330760000235260ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/invertColor.svg000066400000000000000000000061071440330760000240650ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/light/italic.svg000066400000000000000000000051561440330760000230270ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/line.svg000066400000000000000000000037131440330760000225060ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/markerEllipse.svg000066400000000000000000000155411440330760000243600ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/markerPen.svg000066400000000000000000000122471440330760000235050ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/markerRect.svg000066400000000000000000000151251440330760000236560ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/modifycanvas.svg000066400000000000000000000112061440330760000242360ustar00rootroot00000000000000 kImageAnnotator-0.6.1/resources/icons/light/number.svg000066400000000000000000000054671440330760000230570ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/numberArrow.svg000066400000000000000000000256651440330760000240740ustar00rootroot00000000000000 image/svg+xml   1 kImageAnnotator-0.6.1/resources/icons/light/numberPointer.svg000066400000000000000000000101701440330760000244030ustar00rootroot00000000000000 image/svg+xml   kImageAnnotator-0.6.1/resources/icons/light/obfuscateFactor.svg000066400000000000000000000100451440330760000246650ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/opacity.svg000066400000000000000000000050241440330760000232240ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/pen.svg000066400000000000000000000155251440330760000223450ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/pixelate.svg000066400000000000000000000132421440330760000233700ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/rect.svg000066400000000000000000000036521440330760000225160ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/redo.svg000066400000000000000000000070471440330760000225140ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/resetZoom.svg000066400000000000000000000201611440330760000235420ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/light/rotate.svg000066400000000000000000000130561440330760000230560ustar00rootroot00000000000000 kImageAnnotator-0.6.1/resources/icons/light/scale.svg000066400000000000000000000411561440330760000226510ustar00rootroot00000000000000 image/svg+xmlkImageAnnotator-0.6.1/resources/icons/light/select.svg000066400000000000000000000075141440330760000230410ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/sticker.svg000066400000000000000000000062041440330760000232210ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/text.svg000066400000000000000000000042711440330760000225430ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/textArrow.svg000066400000000000000000000265311440330760000235610ustar00rootroot00000000000000 image/svg+xml     kImageAnnotator-0.6.1/resources/icons/light/textColor.svg000066400000000000000000000062521440330760000235430ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/textPointer.svg000066400000000000000000000073351440330760000241100ustar00rootroot00000000000000 image/svg+xml   kImageAnnotator-0.6.1/resources/icons/light/underline.svg000066400000000000000000000060101440330760000235350ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/undo.svg000066400000000000000000000070531440330760000225250ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/width.svg000066400000000000000000000115401440330760000226730ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/icons/light/zoom.svg000066400000000000000000000050111440330760000225340ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/kImageAnnotator_resources.qrc000066400000000000000000000205701440330760000245000ustar00rootroot00000000000000 icons/dark/arrow.svg icons/dark/crop.svg icons/dark/duplicate.svg icons/dark/doubleArrow.svg icons/dark/number.svg icons/dark/numberPointer.svg icons/dark/numberArrow.svg icons/dark/markerPen.svg icons/dark/markerRect.svg icons/dark/markerEllipse.svg icons/dark/modifycanvas.svg icons/dark/line.svg icons/dark/pen.svg icons/dark/rect.svg icons/dark/redo.svg icons/dark/rotate.svg icons/dark/select.svg icons/dark/scale.svg icons/dark/sticker.svg icons/dark/text.svg icons/dark/textPointer.svg icons/dark/textArrow.svg icons/dark/undo.svg icons/dark/ellipse.svg icons/dark/blur.svg icons/dark/pixelate.svg icons/dark/obfuscateFactor.svg icons/dark/color.svg icons/dark/width.svg icons/dark/textColor.svg icons/dark/fillType.svg icons/dark/fillType_borderAndFill.svg icons/dark/fillType_borderAndNoFill.svg icons/dark/fillType_noBorderAndNoFill.svg icons/dark/effect.svg icons/dark/border.svg icons/dark/dropShadow.svg icons/dark/grayscale.svg icons/dark/invertColor.svg icons/dark/disabled.svg icons/dark/zoom.svg icons/dark/dragHandle.svg icons/dark/check.svg icons/dark/bold.svg icons/dark/italic.svg icons/dark/underline.svg icons/dark/cut.svg icons/dark/fitImage.svg icons/dark/resetZoom.svg icons/dark/opacity.svg icons/light/arrow.svg icons/light/crop.svg icons/light/duplicate.svg icons/light/doubleArrow.svg icons/light/number.svg icons/light/numberPointer.svg icons/light/numberArrow.svg icons/light/markerPen.svg icons/light/markerRect.svg icons/light/markerEllipse.svg icons/light/modifycanvas.svg icons/light/line.svg icons/light/pen.svg icons/light/rect.svg icons/light/redo.svg icons/light/rotate.svg icons/light/select.svg icons/light/scale.svg icons/light/sticker.svg icons/light/text.svg icons/light/textPointer.svg icons/light/textArrow.svg icons/light/undo.svg icons/light/ellipse.svg icons/light/blur.svg icons/light/pixelate.svg icons/light/obfuscateFactor.svg icons/light/color.svg icons/light/width.svg icons/light/textColor.svg icons/light/fillType.svg icons/light/fillType_borderAndFill.svg icons/light/fillType_borderAndNoFill.svg icons/light/fillType_noBorderAndNoFill.svg icons/light/effect.svg icons/light/border.svg icons/light/dropShadow.svg icons/light/grayscale.svg icons/light/invertColor.svg icons/light/disabled.svg icons/light/zoom.svg icons/light/dragHandle.svg icons/light/check.svg icons/light/bold.svg icons/light/italic.svg icons/light/underline.svg icons/light/cut.svg icons/light/fitImage.svg icons/light/resetZoom.svg icons/light/opacity.svg stickers/face_blowing_a_kiss.svg stickers/face_savoring_food.svg stickers/grinning_face_with_big_eyes.svg stickers/grinning_face_with_smiling_eyes.svg stickers/grinning_face_with_sweat.svg stickers/grinning_squinting_face.svg stickers/hushed_face.svg stickers/nerd_face.svg stickers/neutral_face.svg stickers/smiling_face_with_heart_eyes.svg stickers/smiling_face_with_hearts.svg stickers/confused_face.svg stickers/face_with_symbols_on_mouth.svg stickers/pouting_face.svg stickers/smiling_face_with_sunglasses.svg stickers/check_mark.svg stickers/cross_mark.svg stickers/cursor.svg kImageAnnotator-0.6.1/resources/stickers/000077500000000000000000000000001440330760000204375ustar00rootroot00000000000000kImageAnnotator-0.6.1/resources/stickers/check_mark.svg000066400000000000000000000041421440330760000232500ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/confused_face.svg000066400000000000000000000055071440330760000237530ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/cross_mark.svg000066400000000000000000000046331440330760000233310ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/cursor.svg000066400000000000000000000035241440330760000225010ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/face_blowing_a_kiss.svg000066400000000000000000000120211440330760000251240ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/face_savoring_food.svg000066400000000000000000000074001440330760000247760ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/face_with_symbols_on_mouth.svg000066400000000000000000000122361440330760000265750ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/grinning_face_with_big_eyes.svg000066400000000000000000000065711440330760000266630ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/grinning_face_with_smiling_eyes.svg000066400000000000000000000072451440330760000275630ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/grinning_face_with_sweat.svg000066400000000000000000000104741440330760000262150ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/grinning_squinting_face.svg000066400000000000000000000070511440330760000260550ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/hushed_face.svg000066400000000000000000000077001440330760000234220ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/nerd_face.svg000066400000000000000000000134541440330760000230750ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/neutral_face.svg000066400000000000000000000054071440330760000236160ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/pouting_face.svg000066400000000000000000000065211440330760000236270ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/smiling_face_with_heart_eyes.svg000066400000000000000000000114321440330760000270440ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/smiling_face_with_hearts.svg000066400000000000000000000152231440330760000262040ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/resources/stickers/smiling_face_with_sunglasses.svg000066400000000000000000000140601440330760000271030ustar00rootroot00000000000000 image/svg+xml kImageAnnotator-0.6.1/src/000077500000000000000000000000001440330760000153655ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/CMakeLists.txt000066400000000000000000000273621440330760000201370ustar00rootroot00000000000000set(KIMAGEANNOTATOR_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/gui/KImageAnnotator.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/CoreView.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/AnnotationWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/AnnotationView.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/scrollAndZoomView/ScrollAndZoomView.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/scrollAndZoomView/ViewZoomer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/settings/ItemSettingsWidgetConfigurator.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/settings/AnnotationSettingsAdapter.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/settings/AnnotationItemSettings.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/settings/AnnotationImageSettings.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/settings/AnnotationGeneralSettings.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/settings/AnnotationToolSelection.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/settings/AnnotationControlsWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/docks/AnnotationDockWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/docks/AnnotationDockWidgetDragHandle.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/docks/AbstractAnnotationDockWidgetContent.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/tabs/AnnotationTabContent.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/tabs/AnnotationTabWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/tabs/AnnotationTabContextMenu.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/tabs/AnnotationTabCloser.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/annotator/tabs/AnnotationTabClickEventFilter.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/canvasModifier/ModifyCanvasView.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/canvasModifier/ModifyCanvasWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/canvasModifier/ModifyCanvasSelectionRestrictor.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/cropper/CropWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/cropper/CropView.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/cropper/CropSelectionRestrictor.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/cutter/CutSelectionRestrictor.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/cutter/CutView.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/cutter/CutWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/selection/SelectionHandler.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/selection/SelectionMoveHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/selection/BaseSelectionHandles.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/selection/SelectionHandlesAll.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/selection/SelectionHandlesHorizontal.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/selection/SelectionHandlesVertical.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/selection/BaseSelectionView.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/rotator/RotateDialog.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/rotator/RotateWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/scaler/ScaleDialog.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/scaler/ScaleWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gui/scaler/ScaleSizeHandler.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/ZoomValueProvider.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/AnnotationArea.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/AnnotationItemFactory.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/AnnotationPropertiesFactory.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/AbstractSettingsProvider.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/imageEffects/ImageEffectFactory.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/imageEffects/NoImageEffect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/imageEffects/DropShadowImageEffect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/imageEffects/BorderImageEffect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/imageEffects/GrayscaleImageEffect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/core/imageEffects/InvertColorImageEffect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/properties/AnnotationProperties.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/properties/AnnotationPathProperties.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/properties/AnnotationTextProperties.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/properties/AnnotationObfuscateProperties.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/properties/AnnotationStickerProperties.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/AnnotationItemModifier.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/AnnotationItemResizer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/AnnotationMultiItemResizer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/AnnotationItemSelector.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/AnnotationItemMover.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/AnnotationItemArranger.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/AnnotationItemEditor.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/resizeHandles/AbstractItemResizeHandles.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/resizeHandles/AbstractRectResizeHandles.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/resizeHandles/LineResizeHandles.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/resizeHandles/RectResizeHandles.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/resizeHandles/PathResizeHandles.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/resizeHandles/PointerRectResizeHandles.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/resizeHandles/ResizeHandle.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/modifiers/resizeHandles/ResizeHandlesFactory.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AbstractAnnotationItem.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AbstractAnnotationLine.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AbstractAnnotationObfuscate.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AbstractAnnotationRect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AbstractAnnotationPointerRect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AbstractAnnotationPath.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationLine.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationMarkerEllipse.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationMarkerPen.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationMarkerRect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationArrow.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationDoubleArrow.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationRect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationEllipse.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationNumber.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationNumberPointer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationNumberArrow.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationPen.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationPixelate.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationText.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationTextPointer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationTextArrow.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationBlur.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationImage.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationSticker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/AnnotationDuplicate.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/BaseAnnotationNumber.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/text/AnnotationTextHandler.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/text/KeyInputHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/text/TextCursor.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/text/CapsLockStatusChecker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/helper/NumberRectHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/items/helper/AnnotationShapeCreator.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/AddCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/DeleteCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/FlipCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/MoveCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/ResizeCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/ArrangeCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/CropCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/CutCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/ScaleCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/RotateCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/PasteCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/ChangePropertiesCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/undo/ModifyCanvasCommand.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/misc/itemEffects/ShadowEffect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/misc/itemEffects/NoEffect.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/misc/ImageBlurrer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/misc/AnnotationItemClipboard.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/misc/AnnotationContextMenu.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/misc/NumberManager.cpp ${CMAKE_CURRENT_SOURCE_DIR}/annotations/misc/CanvasPainter.cpp ${CMAKE_CURRENT_SOURCE_DIR}/backend/Config.cpp ${CMAKE_CURRENT_SOURCE_DIR}/backend/SettingsAdapter.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/provider/DevicePixelRatioScaler.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/provider/ScaledSizeProvider.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/CursorHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/KeyHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/MathHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/ItemHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/ShapeHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/ConfigNameHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/IconLoader.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/PathHelper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/filter/IgnoreShortcutsFilter.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/filter/KeyEventListener.cpp ${CMAKE_CURRENT_SOURCE_DIR}/common/platform/PlatformChecker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/ToolPicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/Controls.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/CustomFontComboBox.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/CustomSpinBox.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/CustomToolButton.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/CustomToolButtonAction.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/ToggleButton.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/ColorDialogButton.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/ColorPicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/NumberPicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/BoolPicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/FillModePicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/FontPicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/SettingsPickerWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/StickerPicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/ImageEffectPicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/settingsPicker/ZoomPicker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/menuButtons/GridMenu.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/menuButtons/GridMenuButton.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/menuButtons/GridMenuToolButton.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/menuButtons/ListMenuToolButton.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/menuButtons/ListMenu.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/menuButtons/ListMenuItem.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/menuButtons/ListItemGroup.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/misc/AbstractExpandingWidget.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/misc/FlowLayout.cpp ${CMAKE_CURRENT_SOURCE_DIR}/widgets/misc/AttachedSeparator.cpp ) if (UNIX AND NOT APPLE) list(APPEND KIMAGEANNOTATOR_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/common/helper/DesktopEnvironmentChecker.cpp ) endif () set(KIMAGEANNOTATOR_SRCS ${KIMAGEANNOTATOR_SRCS} PARENT_SCOPE) kImageAnnotator-0.6.1/src/annotations/000077500000000000000000000000001440330760000177225ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/core/000077500000000000000000000000001440330760000206525ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/core/AbstractSettingsProvider.cpp000066400000000000000000000044511440330760000263610ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractSettingsProvider.h" namespace kImageAnnotator { AbstractSettingsProvider::AbstractSettingsProvider() : mSettingsListener(nullptr), mZoomValueProvider(nullptr) { } void AbstractSettingsProvider::toolChanged(Tools tool) { if(mSettingsListener != nullptr) { mSettingsListener->toolChanged(tool); } } void AbstractSettingsProvider::numberToolSeedChanged(int numberToolSeed) { if(mSettingsListener != nullptr) { mSettingsListener->numberToolSeedChanged(numberToolSeed); } } void AbstractSettingsProvider::itemSettingChanged() { if(mSettingsListener != nullptr) { mSettingsListener->itemSettingsChanged(); } } void AbstractSettingsProvider::setActiveListener(ISettingsListener *settingsListener) { mSettingsListener = settingsListener; if(mSettingsListener != nullptr) { updateNumberToolSeed(mSettingsListener->numberToolSeed()); } } void AbstractSettingsProvider::setActiveZoomValueProvider(ZoomValueProvider *zoomValueProvider) { mZoomValueProvider = zoomValueProvider; if(mZoomValueProvider != nullptr) { updateZoomLevel(mZoomValueProvider->zoomValue()); } } void AbstractSettingsProvider::effectChanged(ImageEffects effect) { if(mSettingsListener != nullptr) { mSettingsListener->imageEffectChanged(effect); } } void AbstractSettingsProvider::zoomValueChanged(double value) { if(mZoomValueProvider != nullptr) { mZoomValueProvider->setZoomValue(value); } } void AbstractSettingsProvider::fitImageToView() { mZoomValueProvider->fitImageToView(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/core/AbstractSettingsProvider.h000066400000000000000000000047001440330760000260230ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTSETTINGSPROVIDER_H #define KIMAGEANNOTATOR_ABSTRACTSETTINGSPROVIDER_H #include #include #include "ISettingsListener.h" #include "ZoomValueProvider.h" #include "src/common/enum/FillModes.h" #include "src/annotations/items/AbstractAnnotationItem.h" namespace kImageAnnotator { class AbstractSettingsProvider { public: AbstractSettingsProvider(); ~AbstractSettingsProvider() = default; virtual void editItem(AbstractAnnotationItem *item) = 0; virtual void activateSelectTool() = 0; virtual Tools toolType() const = 0; virtual QColor toolColor() const = 0; virtual QColor textColor() const = 0; virtual int toolWidth() const = 0; virtual QFont font() const = 0; virtual FillModes fillType() const = 0; virtual int obfuscationFactor() const = 0; virtual QString sticker() const = 0; virtual ImageEffects effect() const = 0; virtual qreal scaling() const = 0; virtual qreal opacity() const = 0; virtual bool shadowEnabled() const = 0; virtual void updateNumberToolSeed(int numberToolSeed) = 0; virtual void updateZoomLevel(double value) = 0; void setActiveListener(ISettingsListener *settingsListener); void setActiveZoomValueProvider(ZoomValueProvider *zoomValueProvider); protected: virtual void toolChanged(Tools tool); virtual void numberToolSeedChanged(int numberToolSeed); virtual void itemSettingChanged(); virtual void effectChanged(ImageEffects effect); virtual void zoomValueChanged(double value); virtual void fitImageToView(); private: ISettingsListener *mSettingsListener; ZoomValueProvider *mZoomValueProvider; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTSETTINGSPROVIDER_H kImageAnnotator-0.6.1/src/annotations/core/AnnotationArea.cpp000066400000000000000000000323461440330760000242710ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationArea.h" namespace kImageAnnotator { AnnotationArea::AnnotationArea( Config *config, AbstractSettingsProvider *settingsProvider, IDevicePixelRatioScaler *devicePixelRatioScaler, ZoomValueProvider *zoomValueProvider, QWidget *parent) : QGraphicsScene(parent), mUndoStack(new UndoStack), mBackgroundImage(nullptr), mCurrentItem(nullptr), mUndoAction(nullptr), mRedoAction(nullptr), mConfig(config), mKeyHelper(new KeyHelper), mSettingsProvider(settingsProvider), mItemModifier(new AnnotationItemModifier(zoomValueProvider)), mPropertiesFactory(new AnnotationPropertiesFactory(config, mSettingsProvider)), mItemFactory(new AnnotationItemFactory(mPropertiesFactory, mSettingsProvider, mConfig)), mItems(new QList()), mItemCopier(new AnnotationItemClipboard(mItemModifier)), mDevicePixelRatioScaler(devicePixelRatioScaler), mCanvasColor(config->canvasColor()) { Q_ASSERT(mSettingsProvider != nullptr); Q_ASSERT(mConfig != nullptr); addItem(mItemModifier); connect(mItemModifier, &AnnotationItemModifier::newCommand, mUndoStack, &UndoStack::push); connect(mItemModifier, &AnnotationItemModifier::itemsSelected, this, &AnnotationArea::itemsSelected); connect(mItemModifier, &AnnotationItemModifier::itemsDeselected, this, &AnnotationArea::itemsDeselected); connect(mItemModifier, &AnnotationItemModifier::itemModified, this, &AnnotationArea::imageChanged); connect(mUndoStack, &UndoStack::indexChanged, this, &AnnotationArea::update); connect(mKeyHelper, &KeyHelper::deleteReleased, this, &AnnotationArea::deleteSelectedItems); connect(mKeyHelper, &KeyHelper::escapeReleased, mItemModifier, &AnnotationItemModifier::clear); connect(mKeyHelper, &KeyHelper::undoPressed, mUndoStack, &UndoStack::undo); connect(mKeyHelper, &KeyHelper::redoPressed, mUndoStack, &UndoStack::redo); connect(&mKeyListener, &KeyEventListener::keyPressed, mKeyHelper, &KeyHelper::keyPress); connect(&mKeyListener, &KeyEventListener::keyReleased, mKeyHelper, &KeyHelper::keyRelease); } AnnotationArea::~AnnotationArea() { delete mPropertiesFactory; delete mItemFactory; delete mItems; delete mKeyHelper; delete mUndoStack; delete mItemModifier; delete mItemCopier; delete mDevicePixelRatioScaler; } void AnnotationArea::loadImage(const QPixmap &image) { if (image.isNull()) { return; } resetAnnotationArea(); replaceBackgroundImage(image); imageEffectChanged(mSettingsProvider->effect()); } void AnnotationArea::insertImageItem(const QPointF &position, const QPixmap &image) { auto imageItem = mItemFactory->create(position, image); mUndoStack->push(new AddCommand(imageItem, this)); toolChanged(mSettingsProvider->toolType()); } void AnnotationArea::replaceBackgroundImage(const QPixmap &image) { mBackgroundImage = QSharedPointer(addPixmap(image)); setSceneRect(QRect()); } QImage AnnotationArea::image() { if (mBackgroundImage == nullptr) { return QImage(); } mItemModifier->clear(); setSceneRect(canvasRect()); auto scaleFactor = mDevicePixelRatioScaler->scaleFactor(); auto sceneRect = this->sceneRect(); auto scaledSceneSize = sceneRect.size().toSize() * scaleFactor; auto scaledSceneRect = QRectF(sceneRect.topLeft(), scaledSceneSize); QImage image(scaledSceneSize, QImage::Format_ARGB32_Premultiplied); image.fill(mCanvasColor); image.setDevicePixelRatio(scaleFactor); QPainter painter(&image); painter.setRenderHint(QPainter::Antialiasing); render(&painter, QRectF(), scaledSceneRect); setSceneRect(QRect()); // Reset scene rect return image; } QAction *AnnotationArea::undoAction() { if(mUndoAction == nullptr) { mUndoAction = mUndoStack->createUndoAction(this); } return mUndoAction; } QAction *AnnotationArea::redoAction() { if(mRedoAction == nullptr) { mRedoAction = mUndoStack->createRedoAction(this); } return mRedoAction; } void AnnotationArea::addAnnotationItem(AbstractAnnotationItem *item) { mItems->prepend(item); addItem(item); emit imageChanged(); } void AnnotationArea::removeAnnotationItem(AbstractAnnotationItem *item) { removeItem(item); mItems->removeOne(item); emit imageChanged(); } void AnnotationArea::crop(const QRectF &rect) { auto scaledRect = mDevicePixelRatioScaler->scale(rect); mUndoStack->push(new CropCommand(mBackgroundImage.data(), scaledRect, this)); emit imageChanged(); } void AnnotationArea::scale(const QSize &size) { mUndoStack->push(new ScaleCommand(mBackgroundImage.data(), size, this)); emit imageChanged(); } void AnnotationArea::rotate(qreal angel) { mUndoStack->push(new RotateCommand(mBackgroundImage.data(), angel, this)); emit imageChanged(); } void AnnotationArea::flip(FlipDirection direction) { mUndoStack->push(new FlipCommand(mBackgroundImage.data(), direction)); emit imageChanged(); } void AnnotationArea::clearSelection() { mItemModifier->clear(); QGraphicsScene::clearSelection(); } void AnnotationArea::itemSettingsChanged() { auto selectedItems = mItemModifier->selectedItems(); if(selectedItems.count() == 1) { auto item = selectedItems.first(); auto properties = mPropertiesFactory->create(item->toolType()); mUndoStack->push(new ChangePropertiesCommand(item, properties)); } } void AnnotationArea::numberToolSeedChanged(int numberToolSeed) { mItemFactory->setNumberToolSeed(numberToolSeed); } int AnnotationArea::numberToolSeed() const { return mItemFactory->numberToolSeed(); } void AnnotationArea::imageEffectChanged(ImageEffects effect) { auto graphicsEffect = ImageEffectFactory::create(effect); mBackgroundImage->setGraphicsEffect(graphicsEffect); emit imageChanged(); } void AnnotationArea::setCanvasRect(const QRectF &rect) { mCanvasRect = rect; } QRectF AnnotationArea::canvasRect() const { if(!isCustomCanvasRect()) { auto backgroundImageRect = mBackgroundImage->graphicsEffect()->boundingRect(); return annotationItemsBoundingRect().united(backgroundImageRect); } else { return mCanvasRect; } } bool AnnotationArea::isCustomCanvasRect() const { return !mCanvasRect.isNull(); } void AnnotationArea::setCanvasColor(const QColor &color) { mCanvasColor = color; } QColor AnnotationArea::canvasColor() const { return mCanvasColor; } void AnnotationArea::modifyCanvas(const QRectF &canvasRect, const QColor &color) { mUndoStack->push(new ModifyCanvasCommand(canvasRect, color, this)); emit imageChanged(); } QRectF AnnotationArea::backgroundImageRect() const { return mBackgroundImage->boundingRect(); } void AnnotationArea::cut(const QRectF &rect) { auto scaledRect = mDevicePixelRatioScaler->scale(rect); mUndoStack->push(new CutCommand(mBackgroundImage.data(), scaledRect, this)); emit imageChanged(); } void AnnotationArea::update() { mItemModifier->updateSelection(); QGraphicsScene::update(); } void AnnotationArea::mousePressEvent(QGraphicsSceneMouseEvent *event) { if (event->button() == Qt::LeftButton) { if (mSettingsProvider->toolType() == Tools::Select) { mItemModifier->handleMousePress(event->scenePos(), mItems, mKeyHelper->isControlPressed()); } else { mItemModifier->clear(); addItemAtPosition(event->scenePos()); } } QGraphicsScene::mousePressEvent(event); } void AnnotationArea::mouseMoveEvent(QGraphicsSceneMouseEvent *event) { if (event->buttons() == Qt::LeftButton) { if (mCurrentItem) { addPointToCurrentItem(event->scenePos()); } else { mItemModifier->handleMouseMove(event->scenePos(), mKeyHelper->isControlPressed()); } } QGraphicsScene::mouseMoveEvent(event); } void AnnotationArea::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { if (event->button() == Qt::LeftButton) { if (mSettingsProvider->toolType() == Tools::Select) { mItemModifier->handleMouseRelease(mItems); } finishDrawingItem(event->scenePos()); } QGraphicsScene::mouseReleaseEvent(event); } void AnnotationArea::finishDrawingItem(const QPointF &pos) { if(mCurrentItem != nullptr) { mCurrentItem->finish(); auto isSelectToolAfterDrawingEnabled = mConfig->switchToSelectToolAfterDrawingItem() && mConfig->selectItemAfterDrawing(); if (mCurrentItem->requiresSelectionAfterCreation() || isSelectToolAfterDrawingEnabled) { mItemModifier->selectItem(mCurrentItem); } else if (mConfig->switchToSelectToolAfterDrawingItem()) { mSettingsProvider->activateSelectTool(); } mCurrentItem = nullptr; } } QRectF AnnotationArea::annotationItemsBoundingRect() const { QRectF boundingRect; for(auto item : *mItems) { boundingRect = boundingRect.united(item->boundingRect()); } return boundingRect; } void AnnotationArea::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) { if (event->button() == Qt::LeftButton && mSettingsProvider->toolType() == Tools::Select) { mItemModifier->handleMouseDoubleClick(event->scenePos(), mItems); } } void AnnotationArea::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) { finishDrawingItem(event->scenePos()); mItemModifier->handleSelectionAt(event->scenePos(), mItems, mKeyHelper->isControlPressed()); auto selectedItems = mItemModifier->selectedItems(); AnnotationContextMenu contextMenu; auto isMenuOverItem = !selectedItems.isEmpty(); contextMenu.setOverItem(isMenuOverItem); contextMenu.setPastEnabled(!mItemCopier->isEmpty()); contextMenu.setEditVisible(selectedEditableItem() != nullptr); AnnotationItemArranger itemArranger(selectedItems, mItems); connect(&itemArranger, &AnnotationItemArranger::newCommand, mUndoStack, &UndoStack::push); connect(&contextMenu, &AnnotationContextMenu::bringToFront, &itemArranger, &AnnotationItemArranger::bringToFront); connect(&contextMenu, &AnnotationContextMenu::bringForward, &itemArranger, &AnnotationItemArranger::bringForward); connect(&contextMenu, &AnnotationContextMenu::sendBackward, &itemArranger, &AnnotationItemArranger::sendBackward); connect(&contextMenu, &AnnotationContextMenu::sendToBack, &itemArranger, &AnnotationItemArranger::sendToBack); connect(&contextMenu, &AnnotationContextMenu::copy, mItemCopier, &AnnotationItemClipboard::copyItems); connect(&contextMenu, &AnnotationContextMenu::paste, this, &AnnotationArea::pasteCopiedItems); connect(&contextMenu, &AnnotationContextMenu::erase, this, &AnnotationArea::deleteSelectedItems); connect(&contextMenu, &AnnotationContextMenu::edit, this, &AnnotationArea::enableEditing); contextMenu.exec(event->screenPos()); } void AnnotationArea::addItemAtPosition(const QPointF &position) { mCurrentItem = mItemFactory->create(position); mUndoStack->push(new AddCommand(mCurrentItem, this)); } void AnnotationArea::addPointToCurrentItem(const QPointF &position) { mCurrentItem->addPoint(position, mKeyHelper->isControlPressed()); } void AnnotationArea::toolChanged(Tools toolType) { auto isSelectTool = toolType == Tools::Select; for (auto item : *mItems) { if (isSelectTool) { item->setCursor(CursorHelper::movableCursor()); } else { item->unsetCursor(); } } if (!isSelectTool) { mItemModifier->clear(); } } void AnnotationArea::resetAnnotationArea() { removeAllItems(); mItemModifier->clear(); mItemCopier->clear(); mUndoStack->clear(); mItemFactory->reset(); mKeyHelper->reset(); } void AnnotationArea::removeAllItems() { for (auto item : *mItems) { removeAnnotationItem(item); } } void AnnotationArea::deleteSelectedItems() { auto selectedItems = mItemModifier->selectedItems(); mItemModifier->clear(); mUndoStack->push(new DeleteCommand(selectedItems, this)); if (mSettingsProvider->toolType() == Tools::Select) { mSettingsProvider->activateSelectTool(); } } void AnnotationArea::pasteCopiedItems(const QPointF &position) { auto copiedItems = mItemCopier->copiedItemsWithOffset(); mUndoStack->push(new PasteCommand(copiedItems, position, mItemFactory, this)); } void AnnotationArea::enableEditing() { auto editableItem = selectedEditableItem(); if(editableItem != nullptr) { mItemModifier->clear(); editableItem->enableEditing(); itemsDeselected(); } } EditableItem* AnnotationArea::selectedEditableItem() const { auto selectedItems = mItemModifier->selectedItems(); return selectedItems.length() != 1 ? nullptr : dynamic_cast(selectedItems[0]); } void AnnotationArea::itemsSelected(const QList &items) const { if(items.count() != 1) { mSettingsProvider->activateSelectTool(); return; } auto item = items.first(); mSettingsProvider->editItem(item); } void AnnotationArea::itemsDeselected() { mSettingsProvider->activateSelectTool(); } void AnnotationArea::dragMoveEvent(QGraphicsSceneDragDropEvent *event) { Q_UNUSED(event) // Overriding default dragMoveEvent in order to accept drops without items under them } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/core/AnnotationArea.h000066400000000000000000000124761440330760000237400ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONAREA_H #define KIMAGEANNOTATOR_ANNOTATIONAREA_H #include #include #include #include #include #include #include "AnnotationItemFactory.h" #include "AbstractSettingsProvider.h" #include "ISettingsListener.h" #include "src/annotations/modifiers/AnnotationItemModifier.h" #include "src/annotations/modifiers/AnnotationItemArranger.h" #include "src/annotations/misc/AnnotationItemClipboard.h" #include "src/annotations/misc/AnnotationContextMenu.h" #include "src/backend/Config.h" #include "src/common/enum/Tools.h" #include "src/common/enum/FlipDirection.h" #include "src/common/helper/CursorHelper.h" #include "src/common/helper/KeyHelper.h" #include "src/common/provider/IDevicePixelRatioScaler.h" #include "src/common/filter/KeyEventListener.h" #include "src/annotations/undo/UndoStack.h" #include "src/annotations/undo/CropCommand.h" #include "src/annotations/undo/FlipCommand.h" #include "src/annotations/undo/ScaleCommand.h" #include "src/annotations/undo/PasteCommand.h" #include "src/annotations/undo/CutCommand.h" #include "src/annotations/undo/ChangePropertiesCommand.h" #include "src/annotations/undo/ModifyCanvasCommand.h" #include "src/annotations/undo/RotateCommand.h" #include "src/annotations/core/ZoomValueProvider.h" #include "src/annotations/core/imageEffects/ImageEffectFactory.h" namespace kImageAnnotator { class AnnotationArea : public QGraphicsScene, public ISettingsListener { Q_OBJECT public: explicit AnnotationArea(Config *config, AbstractSettingsProvider *settingsProvider, IDevicePixelRatioScaler *devicePixelRatioScaler, ZoomValueProvider *zoomValueProvider, QWidget *parent); ~AnnotationArea() override; virtual void loadImage(const QPixmap &image); virtual void insertImageItem(const QPointF &position, const QPixmap &image); QImage image(); QAction* undoAction(); QAction* redoAction(); virtual void addAnnotationItem(AbstractAnnotationItem *item); virtual void removeAnnotationItem(AbstractAnnotationItem *item); virtual void crop(const QRectF& rect); virtual void scale(const QSize& size); virtual void rotate(qreal angel); virtual void flip(FlipDirection direction); virtual void clearSelection(); virtual void toolChanged(Tools toolType) override; void itemSettingsChanged() override; void numberToolSeedChanged(int numberToolSeed) override; int numberToolSeed() const override; void imageEffectChanged(ImageEffects effect) override; void setCanvasRect(const QRectF &rect); QRectF canvasRect() const; bool isCustomCanvasRect() const; void setCanvasColor(const QColor &color); QColor canvasColor() const; void modifyCanvas(const QRectF &canvasRect, const QColor &color); QRectF backgroundImageRect() const; void cut(const QRectF &rect); public slots: virtual void update(); signals: void imageChanged() const; protected: void mousePressEvent(QGraphicsSceneMouseEvent* event) override; void mouseMoveEvent(QGraphicsSceneMouseEvent* event) override; void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) override; void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event) override; void dragMoveEvent(QGraphicsSceneDragDropEvent *event) override; void contextMenuEvent(QGraphicsSceneContextMenuEvent * event) override; private: Config *mConfig; AbstractSettingsProvider *mSettingsProvider; AnnotationPropertiesFactory *mPropertiesFactory; AnnotationItemFactory *mItemFactory; QSharedPointer mBackgroundImage; AbstractAnnotationItem *mCurrentItem; AnnotationItemModifier *mItemModifier; QList *mItems; KeyHelper *mKeyHelper; UndoStack *mUndoStack; AnnotationItemClipboard *mItemCopier; QAction *mUndoAction; QAction *mRedoAction; IDevicePixelRatioScaler *mDevicePixelRatioScaler; KeyEventListener mKeyListener; QRectF mCanvasRect; QColor mCanvasColor; void addItemAtPosition(const QPointF& position); void addPointToCurrentItem(const QPointF& position); void resetAnnotationArea(); void removeAllItems(); void replaceBackgroundImage(const QPixmap &image); void finishDrawingItem(const QPointF &pos); QRectF annotationItemsBoundingRect() const; private slots: void deleteSelectedItems(); void pasteCopiedItems(const QPointF &position); void enableEditing(); EditableItem* selectedEditableItem() const; void itemsSelected(const QList &items) const; void itemsDeselected(); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONAREA_H kImageAnnotator-0.6.1/src/annotations/core/AnnotationItemFactory.cpp000066400000000000000000000212501440330760000256370ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemFactory.h" namespace kImageAnnotator { AnnotationItemFactory::AnnotationItemFactory(AnnotationPropertiesFactory *propertiesFactory, AbstractSettingsProvider *settingsProvider, Config *config) : mPropertiesFactory(propertiesFactory), mSettingsProvider(settingsProvider), mConfig(config), mNumberManager(new NumberManager), mNextZValue(1) { Q_ASSERT(mSettingsProvider != nullptr); Q_ASSERT(mConfig != nullptr); connect(mConfig, &Config::numberUpdateModeChanged, this, &AnnotationItemFactory::setNumberUpdateMode); connect(mNumberManager, &NumberManager::numberSeedChanged, this, &AnnotationItemFactory::numberSeedChanged); setNumberUpdateMode(mConfig->numberUpdateMode()); reset(); } AnnotationItemFactory::~AnnotationItemFactory() { delete mNumberManager; } void AnnotationItemFactory::reset() { mNextZValue = 1; mNumberManager->reset(); } void AnnotationItemFactory::setNumberToolSeed(int numberSeed) { mNumberManager->setNumberSeed(numberSeed); } int AnnotationItemFactory::numberToolSeed() const { return mNumberManager->numberSeed(); } void AnnotationItemFactory::setNumberUpdateMode(NumberUpdateMode numberUpdateMode) { mNumberManager->setNumberUpdateMode(numberUpdateMode); } AbstractAnnotationItem *AnnotationItemFactory::create(const QPointF &initPosition) { auto toolType = mSettingsProvider->toolType(); auto properties = mPropertiesFactory->create(toolType); auto newItem = createItem(initPosition, toolType, properties); initItem(newItem); return newItem; } AbstractAnnotationItem *AnnotationItemFactory::create(const QPointF &initPosition, const QPixmap &image) { auto properties = mPropertiesFactory->createFromConfig(Tools::Image); auto newItem = new AnnotationImage(initPosition, image, properties); initItem(newItem); return newItem; } AbstractAnnotationItem *AnnotationItemFactory::clone(const AbstractAnnotationItem *item) { Q_ASSERT(item != nullptr); auto newItem = cloneItem(item); initItem(newItem); return newItem; } AbstractAnnotationItem *AnnotationItemFactory::createItem(const QPointF &initPosition, const Tools &toolType, const PropertiesPtr &properties) { AbstractAnnotationItem *newItem = nullptr; switch (toolType) { case Tools::Duplicate: newItem = new AnnotationDuplicate(initPosition, properties); break; case Tools::Pen: newItem = new AnnotationPen(initPosition, properties.staticCast()); break; case Tools::MarkerPen: newItem = new AnnotationMarkerPen(initPosition, properties.staticCast()); break; case Tools::MarkerRect: newItem = new AnnotationMarkerRect(initPosition, properties); break; case Tools::MarkerEllipse: newItem = new AnnotationMarkerEllipse(initPosition, properties); break; case Tools::Line: newItem = new AnnotationLine(initPosition, properties); break; case Tools::Ellipse: newItem = new AnnotationEllipse(initPosition, properties); break; case Tools::Rect: newItem = new AnnotationRect(initPosition, properties); break; case Tools::Arrow: newItem = new AnnotationArrow(initPosition, properties); break; case Tools::DoubleArrow: newItem = new AnnotationDoubleArrow(initPosition, properties); break; case Tools::Number: newItem = new AnnotationNumber(initPosition, properties.staticCast()); mNumberManager->addItem(dynamic_cast(newItem)); break; case Tools::NumberPointer: newItem = new AnnotationNumberPointer(initPosition, properties.staticCast()); mNumberManager->addItem(dynamic_cast(newItem)); break; case Tools::NumberArrow: newItem = new AnnotationNumberArrow(initPosition, properties.staticCast()); mNumberManager->addItem(dynamic_cast(newItem)); break; case Tools::Text: newItem = new AnnotationText(initPosition, properties.staticCast()); break; case Tools::TextPointer: newItem = new AnnotationTextPointer(initPosition, properties.staticCast()); break; case Tools::TextArrow: newItem = new AnnotationTextArrow(initPosition, properties.staticCast()); break; case Tools::Blur: newItem = new AnnotationBlur(initPosition, properties.staticCast()); break; case Tools::Pixelate: newItem = new AnnotationPixelate(initPosition, properties.staticCast()); break; case Tools::Sticker: newItem = new AnnotationSticker(initPosition, properties.staticCast()); break; default: qCritical("Cannot create item for provided tool type."); } return newItem; } AbstractAnnotationItem *AnnotationItemFactory::cloneItem(const AbstractAnnotationItem *item) { Q_ASSERT(item != nullptr); AbstractAnnotationItem *newItem = nullptr; switch (item->toolType()) { case Tools::Duplicate: newItem = new AnnotationDuplicate(*(dynamic_cast(item))); break; case Tools::Pen: newItem = new AnnotationPen(*(dynamic_cast(item))); break; case Tools::MarkerPen: newItem = new AnnotationMarkerPen(*(dynamic_cast(item))); break; case Tools::MarkerRect: newItem = new AnnotationMarkerRect(*(dynamic_cast(item))); break; case Tools::MarkerEllipse: newItem = new AnnotationMarkerEllipse(*(dynamic_cast(item))); break; case Tools::Line: newItem = new AnnotationLine(*(dynamic_cast(item))); break; case Tools::Ellipse: newItem = new AnnotationEllipse(*(dynamic_cast(item))); break; case Tools::Rect: newItem = new AnnotationRect(*(dynamic_cast(item))); break; case Tools::Arrow: newItem = new AnnotationArrow(*(dynamic_cast(item))); break; case Tools::DoubleArrow: newItem = new AnnotationDoubleArrow(*(dynamic_cast(item))); break; case Tools::Number: newItem = new AnnotationNumber(*(dynamic_cast(item))); mNumberManager->addItem(dynamic_cast(newItem)); break; case Tools::NumberPointer: newItem = new AnnotationNumberPointer(*(dynamic_cast(item))); mNumberManager->addItem(dynamic_cast(newItem)); break; case Tools::NumberArrow: newItem = new AnnotationNumberArrow(*(dynamic_cast(item))); mNumberManager->addItem(dynamic_cast(newItem)); break; case Tools::Text: newItem = new AnnotationText(*(dynamic_cast(item))); break; case Tools::TextPointer: newItem = new AnnotationTextPointer(*(dynamic_cast(item))); break; case Tools::TextArrow: newItem = new AnnotationTextArrow(*(dynamic_cast(item))); break; case Tools::Blur: newItem = new AnnotationBlur(*(dynamic_cast(item))); break; case Tools::Pixelate: newItem = new AnnotationPixelate(*(dynamic_cast(item))); break; case Tools::Image: newItem = new AnnotationImage(*(dynamic_cast(item))); break; case Tools::Sticker: newItem = new AnnotationSticker(*(dynamic_cast(item))); break; default: qCritical("Cannot create item for provided tool type."); } return newItem; } void AnnotationItemFactory::initItem(AbstractAnnotationItem *item) { if(item != nullptr) { item->init(); item->setZValue(mNextZValue++); } } void AnnotationItemFactory::numberSeedChanged(int newNumberSeed) { mSettingsProvider->updateNumberToolSeed(newNumberSeed); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/core/AnnotationItemFactory.h000066400000000000000000000064371440330760000253160ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMFACTORY_H #define KIMAGEANNOTATOR_ANNOTATIONITEMFACTORY_H #include #include "AnnotationPropertiesFactory.h" #include "src/annotations/items/AnnotationDuplicate.h" #include "src/annotations/items/AnnotationPen.h" #include "src/annotations/items/AnnotationPixelate.h" #include "src/annotations/items/AnnotationLine.h" #include "src/annotations/items/AnnotationMarkerEllipse.h" #include "src/annotations/items/AnnotationMarkerPen.h" #include "src/annotations/items/AnnotationMarkerRect.h" #include "src/annotations/items/AnnotationArrow.h" #include "src/annotations/items/AnnotationDoubleArrow.h" #include "src/annotations/items/AnnotationRect.h" #include "src/annotations/items/AnnotationEllipse.h" #include "src/annotations/items/AnnotationNumber.h" #include "src/annotations/items/AnnotationNumberPointer.h" #include "src/annotations/items/AnnotationNumberArrow.h" #include "src/annotations/items/AnnotationText.h" #include "src/annotations/items/AnnotationTextPointer.h" #include "src/annotations/items/AnnotationTextArrow.h" #include "src/annotations/items/AnnotationBlur.h" #include "src/annotations/items/AnnotationImage.h" #include "src/annotations/items/AnnotationSticker.h" #include "src/annotations/misc/NumberManager.h" #include "src/common/enum/Tools.h" #include "src/common/enum/NumberUpdateMode.h" namespace kImageAnnotator { class AnnotationItemFactory : public QObject { Q_OBJECT public: explicit AnnotationItemFactory(AnnotationPropertiesFactory *propertiesFactory, AbstractSettingsProvider *settingsProvider, Config *config); ~AnnotationItemFactory() override; void reset(); void setNumberToolSeed(int numberSeed); int numberToolSeed() const; AbstractAnnotationItem *create(const QPointF &initPosition); AbstractAnnotationItem *create(const QPointF &initPosition, const QPixmap &image); AbstractAnnotationItem *clone(const AbstractAnnotationItem *item); private slots: void setNumberUpdateMode(NumberUpdateMode numberUpdateMode); private: int mNextZValue; AnnotationPropertiesFactory *mPropertiesFactory; AbstractSettingsProvider *mSettingsProvider; NumberManager *mNumberManager; Config *mConfig; AbstractAnnotationItem *createItem(const QPointF &initPosition, const Tools &toolType, const PropertiesPtr &properties); AbstractAnnotationItem *cloneItem(const AbstractAnnotationItem *item); void initItem(AbstractAnnotationItem *item); void numberSeedChanged(int newNumberSeed); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONITEMFACTORY_H kImageAnnotator-0.6.1/src/annotations/core/AnnotationPropertiesFactory.cpp000066400000000000000000000125171440330760000271030ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationPropertiesFactory.h" namespace kImageAnnotator { AnnotationPropertiesFactory::AnnotationPropertiesFactory(Config *config, AbstractSettingsProvider *settingsProvider) : mConfig(config), mSettingsProvider(settingsProvider) { Q_ASSERT(mConfig != nullptr); Q_ASSERT(mSettingsProvider != nullptr); } PropertiesPtr AnnotationPropertiesFactory::create(Tools tool) const { return create(tool, false); } PropertiesPtr AnnotationPropertiesFactory::createFromConfig(Tools tool) const { return create(tool, true); } PropertiesPtr AnnotationPropertiesFactory::create(Tools tool, bool fromConfig) const { auto properties = createPropertiesObject(tool); setColor(properties, tool); setTextColor(properties); setWidthSize(properties); setFill(properties, tool); setShadowEnabled(properties, tool, fromConfig); setPathProperties(properties); setTextProperties(properties); setObfuscateProperties(properties); setStickerProperties(properties); setScaling(properties); setOpacity(properties); return properties; } PropertiesPtr AnnotationPropertiesFactory::createPropertiesObject(Tools toolType) { switch (toolType) { case Tools::Pen: case Tools::MarkerPen: return PropertiesPtr(new AnnotationPathProperties()); case Tools::Number: case Tools::NumberPointer: case Tools::NumberArrow: case Tools::Text: case Tools::TextPointer: case Tools::TextArrow: return PropertiesPtr(new AnnotationTextProperties()); case Tools::Blur: case Tools::Pixelate: return PropertiesPtr(new AnnotationObfuscateProperties()); case Tools ::Sticker: return PropertiesPtr(new AnnotationStickerProperties()); default: return PropertiesPtr(new AnnotationProperties()); } } void AnnotationPropertiesFactory::setColor(const PropertiesPtr &properties, Tools toolType) const { auto color = mSettingsProvider->toolColor(); if(toolType == Tools::Duplicate) { color.setAlpha(30); } properties->setColor(color); } void AnnotationPropertiesFactory::setTextColor(const PropertiesPtr &properties) const { properties->setTextColor(mSettingsProvider->textColor()); } void AnnotationPropertiesFactory::setWidthSize(const PropertiesPtr &properties) const { properties->setWidth(mSettingsProvider->toolWidth()); } void AnnotationPropertiesFactory::setFill(const PropertiesPtr &properties, Tools toolType) const { switch (toolType) { case Tools::MarkerPen: case Tools::MarkerRect: case Tools::MarkerEllipse: case Tools::Image: case Tools::Sticker: case Tools::NumberPointer: case Tools::TextPointer: case Tools::Duplicate: properties->setFillType(mConfig->toolFillType(toolType)); break; default: properties->setFillType(mSettingsProvider->fillType()); } } void AnnotationPropertiesFactory::setShadowEnabled(const PropertiesPtr &properties, Tools tool, bool fromConfig) const { auto enabled = fromConfig ? mConfig->shadowEnabled(tool) : mSettingsProvider->shadowEnabled(); properties->setShadowEnabled(enabled); } void AnnotationPropertiesFactory::setPathProperties(const PropertiesPtr &properties) const { auto pathProperties = properties.dynamicCast(); if (pathProperties != nullptr) { pathProperties->setSmoothPathEnabled(mConfig->smoothPathEnabled()); pathProperties->setSmoothFactor(mConfig->smoothFactor()); } } void AnnotationPropertiesFactory::setTextProperties(const PropertiesPtr &properties) const { auto textProperties = properties.dynamicCast(); if (textProperties != nullptr) { textProperties->setFont(mSettingsProvider->font()); } } void AnnotationPropertiesFactory::setObfuscateProperties(const PropertiesPtr &properties) const { auto obfuscateProperties = properties.dynamicCast(); if (obfuscateProperties != nullptr) { obfuscateProperties->setFactor(mSettingsProvider->obfuscationFactor()); } } void AnnotationPropertiesFactory::setStickerProperties(const PropertiesPtr &properties) const { auto stickerProperties = properties.dynamicCast(); if (stickerProperties != nullptr) { stickerProperties->setPath(mSettingsProvider->sticker()); } } void AnnotationPropertiesFactory::setScaling(const PropertiesPtr &properties) const { auto stickerProperties = properties.dynamicCast(); if (stickerProperties != nullptr) { stickerProperties->setScaling(mSettingsProvider->scaling()); } } void AnnotationPropertiesFactory::setOpacity(const PropertiesPtr &properties) const { if (properties != nullptr) { properties->setOpacity(mSettingsProvider->opacity()); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/core/AnnotationPropertiesFactory.h000066400000000000000000000051621440330760000265460ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONPROPERTIESFACTORY_H #define KIMAGEANNOTATOR_ANNOTATIONPROPERTIESFACTORY_H #include "src/annotations/properties/AnnotationProperties.h" #include "src/annotations/properties/AnnotationPathProperties.h" #include "src/annotations/properties/AnnotationTextProperties.h" #include "src/annotations/properties/AnnotationObfuscateProperties.h" #include "src/annotations/properties/AnnotationStickerProperties.h" #include "src/backend/Config.h" #include "src/common/enum/Tools.h" #include "AbstractSettingsProvider.h" namespace kImageAnnotator { class AnnotationPropertiesFactory { public: explicit AnnotationPropertiesFactory(Config *config, AbstractSettingsProvider *settingsProvider); ~AnnotationPropertiesFactory() = default; PropertiesPtr create(Tools tool) const; PropertiesPtr createFromConfig(Tools tool) const; private: Config *mConfig; AbstractSettingsProvider *mSettingsProvider; PropertiesPtr create(Tools tool, bool fromConfig) const; static PropertiesPtr createPropertiesObject(Tools toolType); void setShadowEnabled(const PropertiesPtr &properties, Tools tool, bool fromConfig) const; void setColor(const PropertiesPtr &properties, Tools toolType) const; void setTextColor(const PropertiesPtr &properties) const; void setWidthSize(const PropertiesPtr &properties) const; void setFill(const PropertiesPtr &properties, Tools toolType) const; void setPathProperties(const PropertiesPtr &properties) const; void setTextProperties(const PropertiesPtr &properties) const; void setObfuscateProperties(const PropertiesPtr &properties) const; void setStickerProperties(const PropertiesPtr &properties) const; void setScaling(const PropertiesPtr &properties) const; void setOpacity(const PropertiesPtr &properties) const; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONPROPERTIESFACTORY_H kImageAnnotator-0.6.1/src/annotations/core/ISettingsListener.h000066400000000000000000000025261440330760000244470ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ISETTINGSLISTENER_H #define KIMAGEANNOTATOR_ISETTINGSLISTENER_H #include "src/common/enum/Tools.h" #include "src/common/enum/ImageEffects.h" namespace kImageAnnotator { class ISettingsListener { public: virtual void toolChanged(Tools toolType) = 0; virtual void itemSettingsChanged() = 0; virtual void numberToolSeedChanged(int numberToolSeed) = 0; virtual int numberToolSeed() const = 0; virtual void imageEffectChanged(ImageEffects effect) = 0; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ISETTINGSLISTENER_H kImageAnnotator-0.6.1/src/annotations/core/ZoomValueProvider.cpp000066400000000000000000000017421440330760000250160ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ZoomValueProvider.h" namespace kImageAnnotator { kImageAnnotator::ZoomValueProvider::ZoomValueProvider(QObject *parent) : QObject(parent) { } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/core/ZoomValueProvider.h000066400000000000000000000025171440330760000244640ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ZOOMVALUEPROVIDER_H #define KIMAGEANNOTATOR_ZOOMVALUEPROVIDER_H #include namespace kImageAnnotator { class ZoomValueProvider : public QObject { Q_OBJECT public: explicit ZoomValueProvider(QObject *parent = nullptr); ~ZoomValueProvider() override = default; virtual double zoomValue() const = 0; virtual void setZoomValue(double zoomValue) = 0; virtual void fitImageToView() = 0; signals: void zoomValueChanged(double value); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ZOOMVALUEPROVIDER_H kImageAnnotator-0.6.1/src/annotations/core/imageEffects/000077500000000000000000000000001440330760000232345ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/core/imageEffects/BorderImageEffect.cpp000066400000000000000000000021061440330760000272340ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "BorderImageEffect.h" namespace kImageAnnotator { void BorderImageEffect::draw(QPainter *painter) { QPoint offset; const auto pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset); painter->drawPixmap(offset, pixmap); painter->drawRect(pixmap.rect()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/core/imageEffects/BorderImageEffect.h000066400000000000000000000023331440330760000267030ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_BORDERIMAGEEFFECT_H #define KIMAGEANNOTATOR_BORDERIMAGEEFFECT_H #include #include namespace kImageAnnotator { class BorderImageEffect : public QGraphicsEffect { Q_OBJECT public: explicit BorderImageEffect() = default; ~BorderImageEffect() override = default; protected: void draw(QPainter * painter) override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_BORDERIMAGEEFFECT_H kImageAnnotator-0.6.1/src/annotations/core/imageEffects/DropShadowImageEffect.cpp000066400000000000000000000017651440330760000301030ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "DropShadowImageEffect.h" namespace kImageAnnotator { DropShadowImageEffect::DropShadowImageEffect() { setColor(QColor(0, 0, 0)); setBlurRadius(30); setOffset(QPoint(0, 2)); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/core/imageEffects/DropShadowImageEffect.h000066400000000000000000000022641440330760000275430ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_DROPSHADOWIMAGEEFFECT_H #define KIMAGEANNOTATOR_DROPSHADOWIMAGEEFFECT_H #include namespace kImageAnnotator { class DropShadowImageEffect : public QGraphicsDropShadowEffect { Q_OBJECT public: explicit DropShadowImageEffect(); ~DropShadowImageEffect() override = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_DROPSHADOWIMAGEEFFECT_H kImageAnnotator-0.6.1/src/annotations/core/imageEffects/GrayscaleImageEffect.cpp000066400000000000000000000021341440330760000277320ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "GrayscaleImageEffect.h" namespace kImageAnnotator { void GrayscaleImageEffect::draw(QPainter *painter) { QPoint offset; const auto pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset); painter->drawImage(offset, pixmap.toImage().convertToFormat(QImage::Format_Grayscale8)); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/core/imageEffects/GrayscaleImageEffect.h000066400000000000000000000023551440330760000274040ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_GRAYSCALEIMAGEEFFECT_H #define KIMAGEANNOTATOR_GRAYSCALEIMAGEEFFECT_H #include #include namespace kImageAnnotator { class GrayscaleImageEffect : public QGraphicsEffect { Q_OBJECT public: explicit GrayscaleImageEffect() = default; ~GrayscaleImageEffect() override = default; protected: void draw(QPainter * painter) override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_GRAYSCALEIMAGEEFFECT_H kImageAnnotator-0.6.1/src/annotations/core/imageEffects/ImageEffectFactory.cpp000066400000000000000000000023561440330760000274350ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ImageEffectFactory.h" QGraphicsEffect *kImageAnnotator::ImageEffectFactory::create(kImageAnnotator::ImageEffects effect) { switch (effect) { case ImageEffects::DropShadow: return new DropShadowImageEffect; case ImageEffects::Border: return new BorderImageEffect; case ImageEffects::Grayscale: return new GrayscaleImageEffect; case ImageEffects::InvertColor: return new InvertColorImageEffect; default: return new NoImageEffect; } } kImageAnnotator-0.6.1/src/annotations/core/imageEffects/ImageEffectFactory.h000066400000000000000000000025611440330760000271000ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_IMAGEEFFECTFACTORY_H #define KIMAGEANNOTATOR_IMAGEEFFECTFACTORY_H #include #include "NoImageEffect.h" #include "DropShadowImageEffect.h" #include "GrayscaleImageEffect.h" #include "BorderImageEffect.h" #include "InvertColorImageEffect.h" #include "src/common/enum/ImageEffects.h" namespace kImageAnnotator { class ImageEffectFactory { public: explicit ImageEffectFactory() = default; ~ImageEffectFactory() = default; static QGraphicsEffect* create(ImageEffects effect); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_IMAGEEFFECTFACTORY_H kImageAnnotator-0.6.1/src/annotations/core/imageEffects/InvertColorImageEffect.cpp000066400000000000000000000021041440330760000302630ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "InvertColorImageEffect.h" namespace kImageAnnotator { void InvertColorImageEffect::draw(QPainter *painter) { QPoint offset; auto image = sourcePixmap(Qt::LogicalCoordinates, &offset).toImage(); image.invertPixels(); painter->drawImage(offset, image); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/core/imageEffects/InvertColorImageEffect.h000066400000000000000000000023721440330760000277370ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_INVERTCOLORIMAGEEFFECT_H #define KIMAGEANNOTATOR_INVERTCOLORIMAGEEFFECT_H #include #include namespace kImageAnnotator { class InvertColorImageEffect : public QGraphicsEffect { Q_OBJECT public: explicit InvertColorImageEffect() = default; ~InvertColorImageEffect() override = default; protected: void draw(QPainter * painter) override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_INVERTCOLORIMAGEEFFECT_H kImageAnnotator-0.6.1/src/annotations/core/imageEffects/NoImageEffect.cpp000066400000000000000000000020321440330760000263710ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "NoImageEffect.h" namespace kImageAnnotator { void NoImageEffect::draw(QPainter *painter) { QPoint offset; const auto pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset); painter->drawPixmap(offset, pixmap); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/core/imageEffects/NoImageEffect.h000066400000000000000000000023031440330760000260370ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_NOIMAGEEFFECT_H #define KIMAGEANNOTATOR_NOIMAGEEFFECT_H #include #include namespace kImageAnnotator { class NoImageEffect : public QGraphicsEffect { Q_OBJECT public: explicit NoImageEffect() = default; ~NoImageEffect() override = default; protected: void draw(QPainter * painter) override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_NOIMAGEEFFECT_H kImageAnnotator-0.6.1/src/annotations/items/000077500000000000000000000000001440330760000210435ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationItem.cpp000066400000000000000000000120331440330760000261630ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractAnnotationItem.h" namespace kImageAnnotator { AbstractAnnotationItem::AbstractAnnotationItem(const PropertiesPtr &properties): mProperties(properties) { mShape = new QPainterPath(); mStroker = new QPainterPathStroker(mPainterPen); Q_ASSERT(mProperties != nullptr); } AbstractAnnotationItem::AbstractAnnotationItem(const AbstractAnnotationItem &other) { mProperties = other.mProperties->clone(); mShape = new QPainterPath(*other.mShape); mPainterPen = other.mPainterPen; mStroker = new QPainterPathStroker(mPainterPen); setZValue(other.zValue()); setCursor(other.cursor()); setOpacity(other.opacity()); } AbstractAnnotationItem::~AbstractAnnotationItem() { delete mShape; delete mStroker; } QRectF AbstractAnnotationItem::boundingRect() const { auto width = 0; if (mShape->elementCount() > 0) { width = mProperties->width() * 0.5; } return mShape->boundingRect().adjusted(-width, -width, width, width); } QPainterPath AbstractAnnotationItem::shape() const { auto path = mStroker->createStroke(*mShape); if (hasFill()) { path.addPath(*mShape); } return path; } bool AbstractAnnotationItem::intersects(const QRectF &rect) const { return shape().intersects(rect); } void AbstractAnnotationItem::setShape(QPainterPath &newShape) { mShape->swap(newShape); } QPointF AbstractAnnotationItem::position() { return boundingRect().topLeft(); } PropertiesPtr AbstractAnnotationItem::properties() const { return mProperties; } void AbstractAnnotationItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) { if (mShape->elementCount() == 0) { return; } adjustPainter(painter); if (mShape->elementCount() == 1 && hasBorder()) { drawPoint(painter); } else { drawPath(painter); } } void AbstractAnnotationItem::adjustPainter(QPainter *painter) const { painter->setCompositionMode(compositionMode()); painter->setRenderHint(QPainter::Antialiasing, true); shiftPainterForAllOddShapeWidth(painter); } QPen AbstractAnnotationItem::painterPen() const { return mPainterPen; } QPainter::CompositionMode AbstractAnnotationItem::compositionMode() const { return QPainter::CompositionMode_Source; } void AbstractAnnotationItem::drawPoint(QPainter *painter) const { painter->setPen(Qt::NoPen); painter->setBrush(mPainterPen.color()); const auto element = mShape->elementAt(0); const auto width = mPainterPen.widthF(); const auto x = element.x - 0.5 * width; const auto y = element.y - 0.5 * width; if (mPainterPen.capStyle() == Qt::RoundCap) { painter->drawEllipse(x, y, width, width); } else { painter->drawRect(x, y, width, width); } } void AbstractAnnotationItem::drawPath(QPainter *painter) const { if (hasBorder()) { painter->setPen(mPainterPen); } else { painter->setPen(Qt::NoPen); } if (hasFill()) { painter->setBrush(mProperties->color()); } painter->drawPath(*mShape); } void AbstractAnnotationItem::updateProperties() { mPainterPen.setColor(mProperties->color()); mPainterPen.setWidth(mProperties->width()); mPainterPen.setCapStyle(Qt::RoundCap); mPainterPen.setJoinStyle(Qt::RoundJoin); setOpacity(mProperties->opacity()); updateShadow(); emit propertiesChanged(); } void AbstractAnnotationItem::shiftPainterForAllOddShapeWidth(QPainter *painter) const { if (mPainterPen.width() % 2 != 0) { painter->translate(0.5, 0.5); } } bool AbstractAnnotationItem::hasFill() const { auto fillType = mProperties->fillType(); return fillType == FillModes::BorderAndFill || fillType == FillModes::NoBorderAndFill; } bool AbstractAnnotationItem::hasBorder() const { auto fillType = mProperties->fillType(); return fillType == FillModes::BorderAndFill || fillType == FillModes::BorderAndNoFill; } void AbstractAnnotationItem::finish() { // By default, does nothing } bool AbstractAnnotationItem::requiresSelectionAfterCreation() const { return false; } void AbstractAnnotationItem::setProperties(const PropertiesPtr &properties) { Q_ASSERT(properties != nullptr); prepareGeometryChange(); mProperties = properties; updateProperties(); } void AbstractAnnotationItem::init() { updateProperties(); } void AbstractAnnotationItem::updateShadow() { if (mProperties->shadowEnabled()) { setGraphicsEffect(new ShadowEffect()); } else { setGraphicsEffect(new NoEffect()); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationItem.h000066400000000000000000000057121440330760000256360ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTANNOTATIONITEM_H #define KIMAGEANNOTATOR_ABSTRACTANNOTATIONITEM_H #include #include #include #include #include "src/annotations/properties/AnnotationProperties.h" #include "src/common/enum/FillModes.h" #include "src/common/enum/Tools.h" #include "src/annotations/misc/itemEffects/ShadowEffect.h" #include "src/annotations/misc/itemEffects/NoEffect.h" namespace kImageAnnotator { class AbstractAnnotationItem : public QGraphicsWidget { Q_OBJECT; public: explicit AbstractAnnotationItem(const PropertiesPtr &properties); AbstractAnnotationItem(const AbstractAnnotationItem &other); ~AbstractAnnotationItem() override; QRectF boundingRect() const override; QPainterPath shape() const override; virtual bool intersects(const QRectF &rect) const; virtual void addPoint(const QPointF &position, bool modified) = 0; virtual void setPointAt(const QPointF &point, int index, bool keepAspectRatio) = 0; virtual QPointF pointAt(int index) const = 0; virtual void setPosition(const QPointF &newPosition) = 0; virtual QPointF position(); virtual PropertiesPtr properties() const; virtual void finish(); virtual bool requiresSelectionAfterCreation() const; virtual void scale(qreal sx, qreal sy) = 0; virtual Tools toolType() const = 0; virtual void setProperties(const PropertiesPtr &properties); virtual void init(); signals: void propertiesChanged(); protected: void setShape(QPainterPath &newShape); virtual void updateShape() = 0; void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) override; bool hasFill() const; bool hasBorder() const; void adjustPainter(QPainter *painter) const; QPen painterPen() const; virtual QPainter::CompositionMode compositionMode() const; virtual void updateShadow(); private: PropertiesPtr mProperties; QPainterPath *mShape; QPainterPathStroker *mStroker; QPen mPainterPen; void shiftPainterForAllOddShapeWidth(QPainter *painter) const; void drawPath(QPainter *painter) const; void drawPoint(QPainter *painter) const; void updateProperties(); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ABSTRACTANNOTATIONITEM_H kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationLine.cpp000066400000000000000000000056011440330760000261570ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractAnnotationLine.h" namespace kImageAnnotator { AbstractAnnotationLine::AbstractAnnotationLine(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationItem(properties) { mLine = new QLineF(); mLine->setP1(startPosition); } AbstractAnnotationLine::AbstractAnnotationLine(const AbstractAnnotationLine &other) : AbstractAnnotationItem(other) { mLine = new QLineF(*other.mLine); } AbstractAnnotationLine::~AbstractAnnotationLine() { delete mLine; } void AbstractAnnotationLine::addPoint(const QPointF &position, bool modified) { prepareGeometryChange(); mLine->setP2(position); snapToAngle(modified); updateShape(); } void AbstractAnnotationLine::setPosition(const QPointF &newPosition) { prepareGeometryChange(); mLine->translate(newPosition - position()); updateShape(); } QLineF AbstractAnnotationLine::line() const { return *mLine; } void AbstractAnnotationLine::setPointAt(const QPointF &point, int index, bool snapToAngle) { prepareGeometryChange(); if (index <= 0) { if (snapToAngle) { mLine->setP1(getSnapPoint(mLine->p2(), point)); } else { mLine->setP1(point); } } else { if (snapToAngle) { mLine->setP2(getSnapPoint(mLine->p1(), point)); } else { mLine->setP2(point); } } updateShape(); } QPointF AbstractAnnotationLine::pointAt(int index) const { if (index <= 0) { return mLine->p1(); } else { return mLine->p2(); } } void AbstractAnnotationLine::scale(qreal sx, qreal sy) { prepareGeometryChange(); QTransform transform; transform.scale(sx, sy); auto scaledLine = transform.map(*mLine); mLine->setP1(scaledLine.p1()); mLine->setP2(scaledLine.p2()); updateShape(); } void AbstractAnnotationLine::snapToAngle(bool enabled) { if (enabled) { auto newAngle = MathHelper::roundAngleTo(mLine->angle(), 45); mLine->setAngle(newAngle); } } QPointF AbstractAnnotationLine::getSnapPoint(QPointF from, QPointF to) const { QLineF line = QLineF(from, to); const auto angle = line.angle(); auto newAngle = MathHelper::roundAngleTo(angle, 45); line.setAngle(newAngle); return line.p2(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationLine.h000066400000000000000000000033661440330760000256320ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTANNOTATIONLINE_H #define KIMAGEANNOTATOR_ABSTRACTANNOTATIONLINE_H #include "AbstractAnnotationItem.h" #include "src/common/helper/MathHelper.h" namespace kImageAnnotator { class AbstractAnnotationLine : public AbstractAnnotationItem { public: AbstractAnnotationLine(const QPointF &startPosition, const PropertiesPtr &properties); AbstractAnnotationLine(const AbstractAnnotationLine &other); ~AbstractAnnotationLine() override; void addPoint(const QPointF &position, bool modified) override; void setPosition(const QPointF &newPosition) override; QLineF line() const; void setPointAt(const QPointF &point, int index, bool snapToAngle) override; QPointF pointAt(int index) const override; void scale(qreal sx, qreal sy) override; protected: QLineF *mLine; void snapToAngle(bool enabled); QPointF getSnapPoint(QPointF from, QPointF to) const; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ABSTRACTANNOTATIONLINE_H kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationObfuscate.cpp000066400000000000000000000055771440330760000272170ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractAnnotationObfuscate.h" #include namespace kImageAnnotator { AbstractAnnotationObfuscate::AbstractAnnotationObfuscate(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationRect(startPosition, properties), mObfuscationUpdateRequired(true) { connect(this, &AbstractAnnotationItem::propertiesChanged, this, &AbstractAnnotationObfuscate::propertiesUpdated); } AbstractAnnotationObfuscate::AbstractAnnotationObfuscate(const AbstractAnnotationObfuscate &other) : AbstractAnnotationRect(other), mObfuscationUpdateRequired(true) { connect(this, &AbstractAnnotationItem::propertiesChanged, this, &AbstractAnnotationObfuscate::propertiesUpdated); } ObfuscatePropertiesPtr AbstractAnnotationObfuscate::obfuscateProperties() const { return AbstractAnnotationItem::properties().staticCast(); } void AbstractAnnotationObfuscate::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) { // We need to update the image here, otherwise the scene is not ready // to be painted, and we only draw the background if (mObfuscationUpdateRequired) { updateOverlayImage(); mObfuscationUpdateRequired = false; } painter->drawImage(mRect->normalized(), mObfuscatedImage); } void AbstractAnnotationObfuscate::updateShape() { mObfuscationUpdateRequired = true; QPainterPath path; path.addRect(*mRect); setShape(path); } void AbstractAnnotationObfuscate::updateOverlayImage() { auto parentScene = scene(); if (parentScene != nullptr) { auto sceneSize = parentScene->sceneRect().size().toSize(); QImage image(sceneSize, QImage::Format_ARGB32_Premultiplied); image.fill(Qt::transparent); QPainter imagePainter(&image); parentScene->render(&imagePainter); auto sceneOffset = parentScene->sceneRect().topLeft().toPoint(); auto itemRect = mRect->normalized().toRect(); itemRect.translate(-sceneOffset); auto sceneBehindItem = image.copy(itemRect); mObfuscatedImage = obfuscateBackground(sceneBehindItem); } } void AbstractAnnotationObfuscate::propertiesUpdated() { updateShape(); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationObfuscate.h000066400000000000000000000035071440330760000266530ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTANNOTATIONOBFUSCATE_H #define KIMAGEANNOTATOR_ABSTRACTANNOTATIONOBFUSCATE_H #include #include "AbstractAnnotationRect.h" #include "src/annotations/properties/AnnotationObfuscateProperties.h" namespace kImageAnnotator { class AbstractAnnotationObfuscate : public AbstractAnnotationRect { public: AbstractAnnotationObfuscate(const QPointF &startPosition, const PropertiesPtr &properties); AbstractAnnotationObfuscate(const AbstractAnnotationObfuscate &other); ~AbstractAnnotationObfuscate() override = default; ObfuscatePropertiesPtr obfuscateProperties() const; protected: void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) override; void updateShape() override; virtual QImage obfuscateBackground(const QImage &sceneBehindItem) const = 0; private: QImage mObfuscatedImage; bool mObfuscationUpdateRequired; void updateOverlayImage(); private slots: void propertiesUpdated(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTANNOTATIONOBFUSCATE_H kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationPath.cpp000066400000000000000000000062251440330760000261670ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractAnnotationPath.h" namespace kImageAnnotator { AbstractAnnotationPath::AbstractAnnotationPath(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationItem(properties) { mPath = new QPainterPath(); mPath->moveTo(startPosition); mPath->lineTo(startPosition); } AbstractAnnotationPath::AbstractAnnotationPath(const AbstractAnnotationPath &other) : AbstractAnnotationItem(other) { mPath = new QPainterPath(*other.mPath); } AbstractAnnotationPath::~AbstractAnnotationPath() { delete mPath; } void AbstractAnnotationPath::addPoint(const QPointF &position, bool modified) { Q_UNUSED(modified) prepareGeometryChange(); mPath->lineTo(position); updateShape(); } void AbstractAnnotationPath::setPosition(const QPointF &newPosition) { prepareGeometryChange(); mPath->translate(newPosition - position()); updateShape(); } void AbstractAnnotationPath::setPointAt(const QPointF &point, int handleIndex, bool keepAspectRatio) { auto oppositeIndex = (handleIndex + 4) % 8; auto currentPos = ShapeHelper::rectPointAtIndex(boundingRect(), oppositeIndex); auto rect = ShapeHelper::setRectPointAtIndex(boundingRect(), handleIndex, point, keepAspectRatio); if (rect.width() >= Constants::MinPathResizeRectSize && rect.height() >= Constants::MinPathResizeRectSize) { prepareGeometryChange(); scalePath(rect); mPath->translate(currentPos - ShapeHelper::rectPointAtIndex(boundingRect(), oppositeIndex)); updateShape(); } } QPointF AbstractAnnotationPath::pointAt(int index) const { return ShapeHelper::rectPointAtIndex(mPath->boundingRect(), index); } void AbstractAnnotationPath::finish() { if (pathProperties()->smoothPathEnabled()) { prepareGeometryChange(); auto smoothPath = ShapeHelper::smoothOut(*mPath, pathProperties()->smoothFactor()); mPath->swap(smoothPath); updateShape(); } } void AbstractAnnotationPath::scale(qreal sx, qreal sy) { prepareGeometryChange(); QTransform transform; transform.scale(sx, sy); auto scaledPath = transform.map(*mPath); mPath->swap(scaledPath); updateShape(); } void AbstractAnnotationPath::scalePath(const QRectF &rect) { scale(rect.width() / boundingRect().width(), rect.height() / boundingRect().height()); } PathPropertiesPtr AbstractAnnotationPath::pathProperties() const { return AbstractAnnotationItem::properties().staticCast(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationPath.h000066400000000000000000000035671440330760000256420ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTANNOTATIONPATH_H #define KIMAGEANNOTATOR_ABSTRACTANNOTATIONPATH_H #include "AbstractAnnotationItem.h" #include "src/annotations/properties/AnnotationPathProperties.h" #include "src/common/helper/ShapeHelper.h" #include "src/common/constants/Constants.h" namespace kImageAnnotator { class AbstractAnnotationPath : public AbstractAnnotationItem { public: AbstractAnnotationPath(const QPointF &startPosition, const PropertiesPtr &properties); AbstractAnnotationPath(const AbstractAnnotationPath &other); ~AbstractAnnotationPath() override; void addPoint(const QPointF &position, bool modified) override; void setPosition(const QPointF &newPosition) override; void setPointAt(const QPointF &point, int handleIndex, bool keepAspectRatio) override; QPointF pointAt(int index) const override; void finish() override; void scale(qreal sx, qreal sy) override; PathPropertiesPtr pathProperties() const; protected: QPainterPath *mPath; private: void scalePath(const QRectF &rect); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTANNOTATIONPATH_H kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationPointerRect.cpp000066400000000000000000000047351440330760000275350ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractAnnotationPointerRect.h" namespace kImageAnnotator { AbstractAnnotationPointerRect::AbstractAnnotationPointerRect(const QPointF &startPosition, const kImageAnnotator::PropertiesPtr &properties) : AbstractAnnotationRect(startPosition, properties), mPointerIndex(8), mPointer(startPosition) { } AbstractAnnotationPointerRect::AbstractAnnotationPointerRect(const AbstractAnnotationPointerRect &other) : AbstractAnnotationRect(other), mPointer(QPointF(other.mPointer)), mPointerIndex(8) { } void AbstractAnnotationPointerRect::addPoint(const QPointF &position, bool modified) { prepareGeometryChange(); mPointer = position; updateShape(); } void AbstractAnnotationPointerRect::setPosition(const QPointF &newPosition) { auto offset = AbstractAnnotationRect::position() - newPosition; mPointer -= offset; AbstractAnnotationRect::setPosition(newPosition); } void AbstractAnnotationPointerRect::setPointAt(const QPointF &point, int index, bool keepAspectRatio) { Q_UNUSED(keepAspectRatio); if(isPointer(index)){ mPointer = point; prepareGeometryChange(); updateShape(); } else { AbstractAnnotationRect::setPointAt(point, index, false); } } QPointF AbstractAnnotationPointerRect::pointAt(int index) const { return isPointer(index) ? mPointer : AbstractAnnotationRect::pointAt(index); } void AbstractAnnotationPointerRect::finish() { auto rectWidth = mRect->width(); if(mRect->contains(mPointer)) { auto offset = rectWidth * 0.8; mPointer += QPointF(offset, -offset); prepareGeometryChange(); updateShape(); } AbstractAnnotationItem::finish(); } bool AbstractAnnotationPointerRect::isPointer(int index) const { return index == mPointerIndex; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationPointerRect.h000066400000000000000000000032751440330760000272000ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTANNOTATIONPOINTERRECT_H #define KIMAGEANNOTATOR_ABSTRACTANNOTATIONPOINTERRECT_H #include "AbstractAnnotationRect.h" namespace kImageAnnotator { class AbstractAnnotationPointerRect : public AbstractAnnotationRect { public: AbstractAnnotationPointerRect(const QPointF &startPosition, const PropertiesPtr &properties); AbstractAnnotationPointerRect(const AbstractAnnotationPointerRect &other); ~AbstractAnnotationPointerRect() override = default; void addPoint(const QPointF &position, bool modified) override; void setPosition(const QPointF &newPosition) override; void setPointAt(const QPointF &point, int index, bool keepAspectRatio) override; QPointF pointAt(int index) const override; void finish() override; protected: QPointF mPointer; int mPointerIndex; bool isPointer(int index) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTANNOTATIONPOINTERRECT_H kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationRect.cpp000066400000000000000000000052631440330760000261710ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractAnnotationRect.h" namespace kImageAnnotator { AbstractAnnotationRect::AbstractAnnotationRect(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationItem(properties), mRect(new QRectF()) { mRect->setTopLeft(startPosition); mRect->setBottomRight(startPosition); } AbstractAnnotationRect::AbstractAnnotationRect(const AbstractAnnotationRect &other) : AbstractAnnotationItem(other), mRect(new QRectF(*other.mRect)) { } AbstractAnnotationRect::~AbstractAnnotationRect() { delete mRect; } void AbstractAnnotationRect::addPoint(const QPointF &position, bool modified) { prepareGeometryChange(); mRect->setBottomRight(position); makeSymmetric(modified); updateShape(); } void AbstractAnnotationRect::setPosition(const QPointF &newPosition) { prepareGeometryChange(); mRect->translate(newPosition - position()); updateShape(); } QRectF AbstractAnnotationRect::rect() const { return *mRect; } void AbstractAnnotationRect::setPointAt(const QPointF &point, int index, bool keepAspectRatio) { prepareGeometryChange(); auto newRect = ShapeHelper::setRectPointAtIndex(*mRect, index, point, keepAspectRatio); mRect->setRect(newRect.x(), newRect.y(), newRect.width(), newRect.height()); updateShape(); } QPointF AbstractAnnotationRect::pointAt(int index) const { return ShapeHelper::rectPointAtIndex(*mRect, index); } void AbstractAnnotationRect::scale(qreal sx, qreal sy) { prepareGeometryChange(); QTransform transform; transform.scale(sx, sy); auto scaledRect = transform.mapRect(*mRect); mRect->setRect(scaledRect.x(), scaledRect.y(), scaledRect.width(), scaledRect.height()); updateShape(); } void AbstractAnnotationRect::makeSymmetric(bool enabled) { if (enabled) { mRect->setHeight(MathHelper::smallerValue(mRect->height(), mRect->width())); mRect->setWidth(MathHelper::smallerValue(mRect->width(), mRect->height())); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AbstractAnnotationRect.h000066400000000000000000000034341440330760000256340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTANNOTATIONRECT_H #define KIMAGEANNOTATOR_ABSTRACTANNOTATIONRECT_H #include "AbstractAnnotationItem.h" #include "src/common/helper/MathHelper.h" #include "src/common/helper/ShapeHelper.h" #include "src/common/constants/Constants.h" namespace kImageAnnotator { class AbstractAnnotationRect : public AbstractAnnotationItem { public: AbstractAnnotationRect(const QPointF &startPosition, const PropertiesPtr &properties); AbstractAnnotationRect(const AbstractAnnotationRect &other); ~AbstractAnnotationRect() override; void addPoint(const QPointF &position, bool modified) override; void setPosition(const QPointF &newPosition) override; QRectF rect() const; void setPointAt(const QPointF &point, int index, bool keepAspectRatio) override; QPointF pointAt(int index) const override; void scale(qreal sx, qreal sy) override; protected: QRectF *mRect; void makeSymmetric(bool enabled); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ABSTRACTANNOTATIONRECT_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationArrow.cpp000066400000000000000000000031061440330760000246740ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationArrow.h" namespace kImageAnnotator { AnnotationArrow::AnnotationArrow(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationLine(startPosition, properties) { } AnnotationArrow::AnnotationArrow(const AnnotationArrow &other) : AbstractAnnotationLine(other) { } Tools AnnotationArrow::toolType() const { return Tools::Arrow; } void AnnotationArrow::updateShape() { QLineF shaft(*mLine); shaft.setLength(shaft.length() - 5); auto arrow = AnnotationShapeCreator::createArrowHead(properties()->width() / 2); arrow = AnnotationShapeCreator::translate(arrow, mLine->p2(), -mLine->angle()); QPainterPath path(shaft.p1()); path.lineTo(shaft.p2()); path.addPolygon(arrow); path.closeSubpath(); setShape(path); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationArrow.h000066400000000000000000000026341440330760000243460ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONARROW_H #define KIMAGEANNOTATOR_ANNOTATIONARROW_H #include "src/annotations/items/AbstractAnnotationLine.h" #include "src/annotations/items/helper/AnnotationShapeCreator.h" namespace kImageAnnotator { class AnnotationArrow : public AbstractAnnotationLine { public: AnnotationArrow(const QPointF &startPosition, const PropertiesPtr &properties); AnnotationArrow(const AnnotationArrow &other); ~AnnotationArrow() override = default; Tools toolType() const override; protected: void updateShape() override; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONARROW_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationBlur.cpp000066400000000000000000000025671440330760000245200ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationBlur.h" namespace kImageAnnotator { AnnotationBlur::AnnotationBlur(const QPointF &startPosition, const ObfuscatePropertiesPtr &properties) : AbstractAnnotationObfuscate(startPosition, properties) { } AnnotationBlur::AnnotationBlur(const AnnotationBlur &other) : AbstractAnnotationObfuscate(other) { } Tools AnnotationBlur::toolType() const { return Tools::Blur; } QImage AnnotationBlur::obfuscateBackground(const QImage &sceneBehindItem) const { return mItemBlurrer.blurred(sceneBehindItem, obfuscateProperties()->factor(), false); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationBlur.h000066400000000000000000000027161440330760000241610ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONBLUR_H #define KIMAGEANNOTATOR_ANNOTATIONBLUR_H #include "AbstractAnnotationObfuscate.h" #include "src/annotations/misc/ImageBlurrer.h" namespace kImageAnnotator { class AnnotationBlur : public AbstractAnnotationObfuscate { public: AnnotationBlur(const QPointF &startPosition, const ObfuscatePropertiesPtr &properties); AnnotationBlur(const AnnotationBlur &other); ~AnnotationBlur() override = default; Tools toolType() const override; protected: QImage obfuscateBackground(const QImage &sceneBehindItem) const override; private: ImageBlurrer mItemBlurrer; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONBLUR_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationDoubleArrow.cpp000066400000000000000000000035441440330760000260350ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationDoubleArrow.h" namespace kImageAnnotator { AnnotationDoubleArrow::AnnotationDoubleArrow(const QPointF &startPosition, const PropertiesPtr &properties) : AnnotationArrow(startPosition, properties) { } AnnotationDoubleArrow::AnnotationDoubleArrow(const AnnotationArrow &other) : AnnotationArrow(other) { } Tools AnnotationDoubleArrow::toolType() const { return Tools::DoubleArrow; } void AnnotationDoubleArrow::updateShape() { QLineF shaft(mLine->p2(), mLine->p1()); shaft.setLength(shaft.length() - 5); shaft.setPoints(shaft.p2(), shaft.p1()); shaft.setLength(shaft.length() - 5); auto arrow = AnnotationShapeCreator::createArrowHead(properties()->width() / 2); auto startArrowHead = AnnotationShapeCreator::translate(arrow, mLine->p2(), -mLine->angle()); auto endArrowHead = AnnotationShapeCreator::translate(arrow, mLine->p1(), -mLine->angle() + 180); QPainterPath path(shaft.p1()); path.lineTo(shaft.p2()); path.addPolygon(startArrowHead); path.addPolygon(endArrowHead); path.closeSubpath(); setShape(path); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/AnnotationDoubleArrow.h000066400000000000000000000025461440330760000255030ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONDOUBLEARROW_H #define KIMAGEANNOTATOR_ANNOTATIONDOUBLEARROW_H #include "AnnotationArrow.h" namespace kImageAnnotator { class AnnotationDoubleArrow : public AnnotationArrow { public: AnnotationDoubleArrow(const QPointF &startPosition, const PropertiesPtr &properties); explicit AnnotationDoubleArrow(const AnnotationArrow &other); ~AnnotationDoubleArrow() override = default; Tools toolType() const override; protected: void updateShape() override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONDOUBLEARROW_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationDuplicate.cpp000066400000000000000000000043301440330760000255140ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationDuplicate.h" namespace kImageAnnotator { AnnotationDuplicate::AnnotationDuplicate(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationRect(startPosition, properties) { } Tools AnnotationDuplicate::toolType() const { return Tools::Duplicate; } bool AnnotationDuplicate::requiresSelectionAfterCreation() const { return true; } void AnnotationDuplicate::updateShape() { QPainterPath path; path.addRect(*mRect); setShape(path); } void AnnotationDuplicate::finish() { prepareGeometryChange(); captureScene(); } void AnnotationDuplicate::captureScene() { auto parentScene = scene(); if (parentScene != nullptr) { *mRect = parentScene->sceneRect().intersected(*mRect); updateShape(); mSceneSelectionImage = QImage(mRect->normalized().size().toSize(), QImage::Format_ARGB32_Premultiplied); mSceneSelectionImage.fill(Qt::transparent); QPainter imagePainter(&mSceneSelectionImage); QRectF targetRect; targetRect.setSize(mRect->normalized().size()); targetRect.setTopLeft(QPointF(0, 0)); parentScene->render(&imagePainter, targetRect, mRect->normalized()); } } void AnnotationDuplicate::paint(QPainter *painter, const QStyleOptionGraphicsItem *style, QWidget *widget) { if (mSceneSelectionImage.isNull()) { AbstractAnnotationItem::paint(painter, style, widget); } else { painter->drawImage(mRect->normalized(), mSceneSelectionImage); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationDuplicate.h000066400000000000000000000030641440330760000251640ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONDUPLICATE_H #define KIMAGEANNOTATOR_ANNOTATIONDUPLICATE_H #include #include "AbstractAnnotationRect.h" namespace kImageAnnotator { class AnnotationDuplicate : public AbstractAnnotationRect { public: AnnotationDuplicate(const QPointF &startPosition, const PropertiesPtr &properties); ~AnnotationDuplicate() override = default; Tools toolType() const override; void finish() override; bool requiresSelectionAfterCreation() const override; protected: void paint(QPainter *painter, const QStyleOptionGraphicsItem *style, QWidget *widget) override; void updateShape() override; private: QImage mSceneSelectionImage; void captureScene(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONDUPLICATE_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationEllipse.cpp000066400000000000000000000024731440330760000252050ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationEllipse.h" namespace kImageAnnotator { AnnotationEllipse::AnnotationEllipse(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationRect(startPosition, properties) { } AnnotationEllipse::AnnotationEllipse(const AnnotationEllipse &other) : AbstractAnnotationRect(other) { } Tools AnnotationEllipse::toolType() const { return Tools::Ellipse; } void AnnotationEllipse::updateShape() { QPainterPath path; path.addEllipse(*mRect); setShape(path); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationEllipse.h000066400000000000000000000025251440330760000246500ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONELLIPSE_H #define KIMAGEANNOTATOR_ANNOTATIONELLIPSE_H #include "AbstractAnnotationRect.h" namespace kImageAnnotator { class AnnotationEllipse : public AbstractAnnotationRect { public: AnnotationEllipse(const QPointF &startPosition, const PropertiesPtr &properties); AnnotationEllipse(const AnnotationEllipse &other); ~AnnotationEllipse() override = default; Tools toolType() const override; protected: void updateShape() override; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONELLIPSE_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationImage.cpp000066400000000000000000000030361440330760000246260ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationImage.h" namespace kImageAnnotator { kImageAnnotator::AnnotationImage::AnnotationImage(const QPointF &startPosition, const QPixmap &image, const PropertiesPtr &properties) : AnnotationRect(startPosition, properties) { mImage = image; mRect->setRect(mRect->x(), mRect->y(), image.width(), image.height()); updateShape(); } AnnotationImage::AnnotationImage(const AnnotationImage &other) : AnnotationRect(other) { this->mImage = other.mImage; updateShape(); } Tools AnnotationImage::toolType() const { return Tools::Image; } void AnnotationImage::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) { painter->drawPixmap(mRect->toRect().normalized(), mImage); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationImage.h000066400000000000000000000026541440330760000243000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONIMAGE_H #define KIMAGEANNOTATOR_ANNOTATIONIMAGE_H #include "AnnotationRect.h" namespace kImageAnnotator { class AnnotationImage : public AnnotationRect { public: AnnotationImage(const QPointF &startPosition, const QPixmap &image, const PropertiesPtr &properties); AnnotationImage(const AnnotationImage &other); ~AnnotationImage() override = default; Tools toolType() const override; protected: void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) override; private: QPixmap mImage; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONIMAGE_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationLine.cpp000066400000000000000000000024561440330760000245000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationLine.h" namespace kImageAnnotator { AnnotationLine::AnnotationLine(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationLine(startPosition, properties) { } AnnotationLine::AnnotationLine(const AnnotationLine &other) : AbstractAnnotationLine(other) { } Tools AnnotationLine::toolType() const { return Tools::Line; } void AnnotationLine::updateShape() { QPainterPath path(mLine->p1()); path.lineTo(mLine->p2()); setShape(path); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationLine.h000066400000000000000000000024351440330760000241420ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONLINE_H #define KIMAGEANNOTATOR_ANNOTATIONLINE_H #include "AbstractAnnotationLine.h" namespace kImageAnnotator { class AnnotationLine : public AbstractAnnotationLine { public: AnnotationLine(const QPointF &startPosition, const PropertiesPtr &properties); AnnotationLine(const AnnotationLine &other); ~AnnotationLine() override = default; Tools toolType() const override; protected: void updateShape() override; }; } #endif // KIMAGEANNOTATOR_ANNOTATIONLINE_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationMarkerEllipse.cpp000066400000000000000000000027641440330760000263520ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationMarkerEllipse.h" namespace kImageAnnotator { AnnotationMarkerEllipse::AnnotationMarkerEllipse(const QPointF &startPosition, const PropertiesPtr &properties) : AnnotationEllipse(startPosition, properties) { } Tools AnnotationMarkerEllipse::toolType() const { return Tools::MarkerEllipse; } void AnnotationMarkerEllipse::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { AnnotationEllipse::paint(painter, option, widget); } QPainter::CompositionMode AnnotationMarkerEllipse::compositionMode() const { return QPainter::CompositionMode_Multiply; } void AnnotationMarkerEllipse::updateShadow() { setGraphicsEffect(nullptr); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/AnnotationMarkerEllipse.h000066400000000000000000000030521440330760000260060ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONMARKERELLIPSE_H #define KIMAGEANNOTATOR_ANNOTATIONMARKERELLIPSE_H #include "AnnotationEllipse.h" namespace kImageAnnotator { class AnnotationMarkerEllipse : public AnnotationEllipse { Q_OBJECT public: AnnotationMarkerEllipse(const QPointF &startPosition, const PropertiesPtr &properties); AnnotationMarkerEllipse(const AnnotationMarkerEllipse &other) = default; ~AnnotationMarkerEllipse() override = default; Tools toolType() const override; protected: void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; QPainter::CompositionMode compositionMode() const override; void updateShadow() override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONMARKERELLIPSE_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationMarkerPen.cpp000066400000000000000000000027141440330760000254720ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationMarkerPen.h" namespace kImageAnnotator { AnnotationMarkerPen::AnnotationMarkerPen(const QPointF &startPosition, const PropertiesPtr &properties) : AnnotationPen(startPosition, properties) { } Tools AnnotationMarkerPen::toolType() const { return Tools::MarkerPen; } void AnnotationMarkerPen::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { AnnotationPen::paint(painter, option, widget); } QPainter::CompositionMode AnnotationMarkerPen::compositionMode() const { return QPainter::CompositionMode_Multiply; } void AnnotationMarkerPen::updateShadow() { setGraphicsEffect(nullptr); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/AnnotationMarkerPen.h000066400000000000000000000030021440330760000251260ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONMARKERPEN_H #define KIMAGEANNOTATOR_ANNOTATIONMARKERPEN_H #include "AnnotationPen.h" namespace kImageAnnotator { class AnnotationMarkerPen : public AnnotationPen { Q_OBJECT public: AnnotationMarkerPen(const QPointF &startPosition, const PropertiesPtr &properties); AnnotationMarkerPen(const AnnotationMarkerPen &other) = default; ~AnnotationMarkerPen() override = default; Tools toolType() const override; protected: void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; QPainter::CompositionMode compositionMode() const override; void updateShadow() override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONMARKERPEN_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationMarkerRect.cpp000066400000000000000000000027271440330760000256510ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationMarkerRect.h" namespace kImageAnnotator { AnnotationMarkerRect::AnnotationMarkerRect(const QPointF &startPosition, const PropertiesPtr &properties) : AnnotationRect(startPosition, properties) { } Tools AnnotationMarkerRect::toolType() const { return Tools::MarkerRect; } void AnnotationMarkerRect::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { AnnotationRect::paint(painter, option, widget); } QPainter::CompositionMode AnnotationMarkerRect::compositionMode() const { return QPainter::CompositionMode_Multiply; } void AnnotationMarkerRect::updateShadow() { setGraphicsEffect(nullptr); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationMarkerRect.h000066400000000000000000000030141440330760000253040ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONMARKERRECT_H #define KIMAGEANNOTATOR_ANNOTATIONMARKERRECT_H #include "AnnotationRect.h" namespace kImageAnnotator { class AnnotationMarkerRect : public AnnotationRect { Q_OBJECT public: AnnotationMarkerRect(const QPointF &startPosition, const PropertiesPtr &properties); AnnotationMarkerRect(const AnnotationMarkerRect &other) = default; ~AnnotationMarkerRect() override = default; Tools toolType() const override; protected: void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; QPainter::CompositionMode compositionMode() const override; void updateShadow() override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONMARKERRECT_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationNumber.cpp000066400000000000000000000050251440330760000250340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationNumber.h" namespace kImageAnnotator { AnnotationNumber::AnnotationNumber(const QPointF ¢erPosition, const TextPropertiesPtr &properties) : AbstractAnnotationRect(centerPosition, properties) { mRect->moveCenter(centerPosition); connect(this, &AbstractAnnotationItem::propertiesChanged, this, &AnnotationNumber::updateRect); } AnnotationNumber::AnnotationNumber(const AnnotationNumber &other) : AbstractAnnotationRect(other), BaseAnnotationNumber(other) { connect(this, &AbstractAnnotationItem::propertiesChanged, this, &AnnotationNumber::updateRect); } void AnnotationNumber::addPoint(const QPointF &position, bool modified) { Q_UNUSED(position); Q_UNUSED(modified); // Nothing to do here } Tools AnnotationNumber::toolType() const { return Tools::Number; } QPainterPath AnnotationNumber::shape() const { auto path = AbstractAnnotationItem::shape(); path.addRect(*mRect); return path; } TextPropertiesPtr AnnotationNumber::textProperties() const { return AbstractAnnotationItem::properties().staticCast(); } void AnnotationNumber::init() { AbstractAnnotationItem::init(); updateRect(); } void AnnotationNumber::updateShape() { QPainterPath path; path.addEllipse(*mRect); setShape(path); } void AnnotationNumber::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { AbstractAnnotationRect::paint(painter, option, widget); painter->setFont(textProperties()->font()); painter->setPen(properties()->textColor()); painter->drawText(boundingRect(), Qt::AlignCenter, numberString()); } void AnnotationNumber::updateRect() { prepareGeometryChange(); BaseAnnotationNumber::updateRect(mRect, textProperties()->font()); updateShape(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationNumber.h000066400000000000000000000034741440330760000245070ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONNUMBER_H #define KIMAGEANNOTATOR_ANNOTATIONNUMBER_H #include "src/annotations/items/AbstractAnnotationRect.h" #include "src/annotations/items/BaseAnnotationNumber.h" #include "src/annotations/properties/AnnotationTextProperties.h" namespace kImageAnnotator { class AnnotationNumber : public AbstractAnnotationRect, public BaseAnnotationNumber { Q_OBJECT public: AnnotationNumber(const QPointF ¢erPosition, const TextPropertiesPtr& properties); AnnotationNumber(const AnnotationNumber &other); ~AnnotationNumber() override = default; void addPoint(const QPointF &position, bool modified) override; Tools toolType() const override; QPainterPath shape() const override; TextPropertiesPtr textProperties() const; void init() override; protected: void updateShape() override; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; private slots: void updateRect() override; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONNUMBER_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationNumberArrow.cpp000066400000000000000000000050011440330760000260410ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationNumberArrow.h" namespace kImageAnnotator { AnnotationNumberArrow::AnnotationNumberArrow(const QPointF &startPosition, const kImageAnnotator::TextPropertiesPtr &properties) : AnnotationNumberPointer(startPosition, properties) { } AnnotationNumberArrow::AnnotationNumberArrow(const kImageAnnotator::AnnotationNumberArrow &other) : AnnotationNumberPointer(other) { } Tools AnnotationNumberArrow::toolType() const { return Tools::NumberArrow; } void AnnotationNumberArrow::updateShape() { QLineF tmpLine(mPointer, mRect->center()); tmpLine.setLength(tmpLine.length() - mRect->width() / 2); QLineF shaft(tmpLine.p2(), tmpLine.p1()); shaft.setLength(tmpLine.length() - 5); auto arrow = AnnotationShapeCreator::createArrowHead(properties()->width() / 2); arrow = AnnotationShapeCreator::translate(arrow, mPointer, -shaft.angle()); mRect->moveCenter(mRect->center()); mArrowShape = QPainterPath(shaft.p1()); mArrowShape.setFillRule(Qt::WindingFill); mArrowShape.lineTo(shaft.p2()); mArrowShape.addPolygon(arrow); QPainterPath path(mArrowShape); path.addEllipse(*mRect); path.closeSubpath(); setShape(path); } void AnnotationNumberArrow::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { adjustPainter(painter); painter->setPen(painterPen()); painter->setBrush(properties()->color()); // Draw Arrow painter->drawPath(mArrowShape); // Draw Ellipse if(!hasFill()) { painter->setBrush(Qt::NoBrush); } if(!hasBorder()) { painter->setPen(Qt::NoPen); } painter->drawEllipse(*mRect); // Draw Number painter->setFont(textProperties()->font()); painter->setPen(properties()->textColor()); painter->drawText(*mRect, Qt::AlignCenter, numberString()); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/AnnotationNumberArrow.h000066400000000000000000000030171440330760000255130ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONNUMBERARROW_H #define KIMAGEANNOTATOR_ANNOTATIONNUMBERARROW_H #include "src/annotations/items/AnnotationNumberPointer.h" namespace kImageAnnotator { class AnnotationNumberArrow : public AnnotationNumberPointer { Q_OBJECT public: AnnotationNumberArrow(const QPointF &startPosition, const TextPropertiesPtr& properties); AnnotationNumberArrow(const AnnotationNumberArrow &other); ~AnnotationNumberArrow() override = default; Tools toolType() const override; protected: void updateShape() override; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; private: QPainterPath mArrowShape; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONNUMBERARROW_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationNumberPointer.cpp000066400000000000000000000054231440330760000263770ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationNumberPointer.h" namespace kImageAnnotator { AnnotationNumberPointer::AnnotationNumberPointer(const QPointF &startPosition, const TextPropertiesPtr &properties) : AbstractAnnotationPointerRect(startPosition, properties) { connect(this, &AbstractAnnotationItem::propertiesChanged, this, &AnnotationNumberPointer::updateRect); } AnnotationNumberPointer::AnnotationNumberPointer(const AnnotationNumberPointer &other) : AbstractAnnotationPointerRect(other), BaseAnnotationNumber(other) { connect(this, &AbstractAnnotationItem::propertiesChanged, this, &AnnotationNumberPointer::updateRect); } Tools AnnotationNumberPointer::toolType() const { return Tools::NumberPointer; } TextPropertiesPtr AnnotationNumberPointer::textProperties() const { return AbstractAnnotationItem::properties().staticCast(); } void AnnotationNumberPointer::init() { AbstractAnnotationItem::init(); updateRect(); } void AnnotationNumberPointer::updateShape() { auto line = QLineF(mRect->center(), mPointer); auto pointerWidth = qMin(mRect->width(), mRect->height()) * 0.7; auto pointer = AnnotationShapeCreator::createPointer(pointerWidth, line.length()); auto finishedPointer = AnnotationShapeCreator::translate(pointer, mPointer, -line.angle()); QPainterPath path(mRect->center()); path.setFillRule(Qt::WindingFill); path.addPolygon(finishedPointer); path.closeSubpath(); path.addEllipse(*mRect); auto painterPath = path.simplified(); setShape(painterPath); } void AnnotationNumberPointer::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { AbstractAnnotationPointerRect::paint(painter, option, widget); painter->setFont(textProperties()->font()); painter->setPen(properties()->textColor()); painter->drawText(*mRect, Qt::AlignCenter, numberString()); } void AnnotationNumberPointer::updateRect() { prepareGeometryChange(); BaseAnnotationNumber::updateRect(mRect, textProperties()->font()); updateShape(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationNumberPointer.h000066400000000000000000000035321440330760000260430ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONNUMBERPOINTER_H #define KIMAGEANNOTATOR_ANNOTATIONNUMBERPOINTER_H #include "src/annotations/items/AbstractAnnotationPointerRect.h" #include "src/annotations/items/BaseAnnotationNumber.h" #include "src/annotations/items/helper/AnnotationShapeCreator.h" #include "src/annotations/properties/AnnotationTextProperties.h" namespace kImageAnnotator { class AnnotationNumberPointer : public AbstractAnnotationPointerRect, public BaseAnnotationNumber { Q_OBJECT public: AnnotationNumberPointer(const QPointF &startPosition, const TextPropertiesPtr& properties); AnnotationNumberPointer(const AnnotationNumberPointer &other); ~AnnotationNumberPointer() override = default; Tools toolType() const override; TextPropertiesPtr textProperties() const; void init() override; protected: void updateShape() override; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; private slots: void updateRect() override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONNUMBERPOINTER_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationPen.cpp000066400000000000000000000024261440330760000243300ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationPen.h" namespace kImageAnnotator { AnnotationPen::AnnotationPen(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationPath(startPosition, properties) { updateShape(); } AnnotationPen::AnnotationPen(const AnnotationPen &other) : AbstractAnnotationPath(other) { } Tools AnnotationPen::toolType() const { return Tools::Pen; } void AnnotationPen::updateShape() { QPainterPath path(*mPath); setShape(path); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationPen.h000066400000000000000000000024611440330760000237740ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONPEN_H #define KIMAGEANNOTATOR_ANNOTATIONPEN_H #include "AbstractAnnotationPath.h" namespace kImageAnnotator { class AnnotationPen : public AbstractAnnotationPath { public: AnnotationPen(const QPointF &startPosition, const PropertiesPtr &properties); AnnotationPen(const AnnotationPen &other); ~AnnotationPen() override = default; Tools toolType() const override; protected: void updateShape() override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONPEN_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationPixelate.cpp000066400000000000000000000035141440330760000253600ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationPixelate.h" namespace kImageAnnotator { AnnotationPixelate::AnnotationPixelate(const QPointF &startPosition, const ObfuscatePropertiesPtr &properties) : AbstractAnnotationObfuscate(startPosition, properties) { } AnnotationPixelate::AnnotationPixelate(const AnnotationPixelate &other) : AbstractAnnotationObfuscate(other) { } Tools AnnotationPixelate::toolType() const { return Tools::Pixelate; } QImage AnnotationPixelate::obfuscateBackground(const QImage &sceneBehindItem) const { auto result = sceneBehindItem.convertToFormat( QImage::Format_ARGB32_Premultiplied ); auto factor = obfuscateProperties()->factor(); int width = sceneBehindItem.width() * (0.5 / qMax(1, factor)); int height = sceneBehindItem.height() * (0.5 / qMax(1, factor)); QSize size = QSize(qMax(width, 1), qMax(height, 1)); result = result.scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); result = result.scaled(sceneBehindItem.width(), sceneBehindItem.height()); return result; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationPixelate.h000066400000000000000000000026311440330760000250240ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONPIXELATE_H #define KIMAGEANNOTATOR_ANNOTATIONPIXELATE_H #include "AbstractAnnotationObfuscate.h" namespace kImageAnnotator { class AnnotationPixelate : public AbstractAnnotationObfuscate { public: AnnotationPixelate(const QPointF &startPosition, const ObfuscatePropertiesPtr &properties); AnnotationPixelate(const AnnotationPixelate &other); ~AnnotationPixelate() override = default; Tools toolType() const override; protected: QImage obfuscateBackground(const QImage &sceneBehindItem) const override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONPIXELATE_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationRect.cpp000066400000000000000000000024341440330760000245020ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationRect.h" namespace kImageAnnotator { AnnotationRect::AnnotationRect(const QPointF &startPosition, const PropertiesPtr &properties) : AbstractAnnotationRect(startPosition, properties) { } AnnotationRect::AnnotationRect(const AnnotationRect &other) : AbstractAnnotationRect(other) { } Tools AnnotationRect::toolType() const { return Tools::Rect; } void AnnotationRect::updateShape() { QPainterPath path; path.addRect(*mRect); setShape(path); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationRect.h000066400000000000000000000025041440330760000241450ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONRECT_H #define KIMAGEANNOTATOR_ANNOTATIONRECT_H #include "AbstractAnnotationRect.h" namespace kImageAnnotator { class AnnotationRect : public AbstractAnnotationRect { Q_OBJECT public: AnnotationRect(const QPointF &startPosition, const PropertiesPtr &properties); AnnotationRect(const AnnotationRect &other); ~AnnotationRect() override = default; Tools toolType() const override; protected: void updateShape() override; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONRECT_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationSticker.cpp000066400000000000000000000047211440330760000252120ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationSticker.h" namespace kImageAnnotator { AnnotationSticker::AnnotationSticker(const QPointF ¢erPosition, const StickerPropertiesPtr &properties) : AbstractAnnotationRect(centerPosition, properties) { connect(this, &AbstractAnnotationItem::propertiesChanged, this, &AnnotationSticker::propertiesUpdated); } AnnotationSticker::AnnotationSticker(const AnnotationSticker &other) : AbstractAnnotationRect(other) { connect(this, &AbstractAnnotationItem::propertiesChanged, this, &AnnotationSticker::propertiesUpdated); } void AnnotationSticker::addPoint(const QPointF &position, bool modified) { Q_UNUSED(position); Q_UNUSED(modified); // Nothing to do here } Tools AnnotationSticker::toolType() const { return Tools::Sticker; } StickerPropertiesPtr AnnotationSticker::stickerProperties() const { return AbstractAnnotationItem::properties().staticCast(); } void AnnotationSticker::init() { AbstractAnnotationItem::init(); propertiesUpdated(); } void AnnotationSticker::updateShape() { QPainterPath path; path.addEllipse(*mRect); setShape(path); } void AnnotationSticker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { auto boundingRect = mRect->toRect().normalized(); mSvgRenderer.render(painter, boundingRect); } void AnnotationSticker::updateRect() { auto center = mRect->center(); auto scaling = stickerProperties()->scaling(); mRect->setSize(mSvgRenderer.defaultSize() * scaling); mRect->moveCenter(center); } void AnnotationSticker::propertiesUpdated() { prepareGeometryChange(); mSvgRenderer.load(stickerProperties()->path()); updateRect(); updateShape(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationSticker.h000066400000000000000000000033711440330760000246570ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONSTICKER_H #define KIMAGEANNOTATOR_ANNOTATIONSTICKER_H #include #include "AbstractAnnotationRect.h" #include "src/annotations/properties/AnnotationStickerProperties.h" namespace kImageAnnotator { class AnnotationSticker : public AbstractAnnotationRect { public: AnnotationSticker(const QPointF ¢erPosition, const StickerPropertiesPtr& properties); AnnotationSticker(const AnnotationSticker &other); ~AnnotationSticker() override = default; void addPoint(const QPointF &position, bool modified) override; Tools toolType() const override; StickerPropertiesPtr stickerProperties() const; void init() override; protected: void updateShape() override; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; private: QSvgRenderer mSvgRenderer; void updateRect(); private slots: void propertiesUpdated(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONSTICKER_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationText.cpp000066400000000000000000000065151440330760000245350ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationText.h" namespace kImageAnnotator { AnnotationText::AnnotationText(const QPointF &startPosition, const TextPropertiesPtr &properties) : AbstractAnnotationRect(startPosition, properties) { setupFlags(); connectSlots(); } AnnotationText::AnnotationText(const AnnotationText &other) : AbstractAnnotationRect(other), mTextHandler(other.mTextHandler) { setupFlags(); connectSlots(); } void AnnotationText::updateShape() { QPainterPath path; path.addRect(*mRect); setShape(path); } void AnnotationText::focusOutEvent(QFocusEvent *event) { disableEditing(); QGraphicsWidget::focusOutEvent(event); } void AnnotationText::keyPressEvent(QKeyEvent *event) { mTextHandler.handleKeyEvent(event); } void AnnotationText::inputMethodEvent(QInputMethodEvent *event) { mTextHandler.insertText(event->commitString()); } void AnnotationText::paint(QPainter *painter, const QStyleOptionGraphicsItem *style, QWidget *widget) { // Paint border AbstractAnnotationRect::paint(painter, style, widget); // Paint Text auto font = textProperties()->font(); auto color = textProperties()->textColor(); auto margin = textProperties()->width(); auto isShadowEnabled = properties()->shadowEnabled(); mTextHandler.paintText(painter, mRect, font, color, margin, isShadowEnabled); } void AnnotationText::finish() { enableEditing(); } Tools AnnotationText::toolType() const { return Tools::Text; } QPainterPath AnnotationText::shape() const { auto path = AbstractAnnotationItem::shape(); auto font = textProperties()->font(); auto margin = textProperties()->width(); path.addRect(mTextHandler.getTextRect(mRect, font, margin)); return path; } void AnnotationText::escape() { clearFocus(); } void AnnotationText::refresh() { prepareGeometryChange(); auto font = textProperties()->font(); auto margin = textProperties()->width(); mTextHandler.updateRect(mRect, font, margin); updateShape(); } void AnnotationText::connectSlots() { connect(&mTextHandler, &AnnotationTextHandler::changed, this, &AnnotationText::refresh); connect(&mTextHandler, &AnnotationTextHandler::finished, this, &AnnotationText::escape); } void AnnotationText::enableEditing() { setFocus(); mTextHandler.enableEditing(); } void AnnotationText::disableEditing() { mTextHandler.disableEditing(); } TextPropertiesPtr AnnotationText::textProperties() const { return AbstractAnnotationItem::properties().staticCast(); } void AnnotationText::setupFlags() { setFlag(ItemIsFocusable, true); setFlag(ItemAcceptsInputMethod, true); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/AnnotationText.h000066400000000000000000000041111440330760000241700ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTEXT_H #define KIMAGEANNOTATOR_ANNOTATIONTEXT_H #include "AbstractAnnotationRect.h" #include "src/annotations/items/interfaces/EditableItem.h" #include "src/annotations/items/text/AnnotationTextHandler.h" #include "src/annotations/properties/AnnotationTextProperties.h" namespace kImageAnnotator { class AnnotationText : public AbstractAnnotationRect, public EditableItem { Q_OBJECT public: AnnotationText(const QPointF &startPosition, const TextPropertiesPtr &properties); AnnotationText(const AnnotationText &other); ~AnnotationText() override = default; void finish() override; Tools toolType() const override; QPainterPath shape() const override; void enableEditing() override; void disableEditing() override; TextPropertiesPtr textProperties() const; protected: void updateShape() override; void focusOutEvent(QFocusEvent *event) override; void keyPressEvent(QKeyEvent *event) override; void inputMethodEvent(QInputMethodEvent *event) override; void paint(QPainter *painter, const QStyleOptionGraphicsItem *style, QWidget *widget) override; private: AnnotationTextHandler mTextHandler; void connectSlots(); void setupFlags(); private slots: void escape(); void refresh(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTEXT_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationTextArrow.cpp000066400000000000000000000051331440330760000255430ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTextArrow.h" namespace kImageAnnotator { AnnotationTextArrow::AnnotationTextArrow(const QPointF &startPosition, const TextPropertiesPtr &properties) : AnnotationTextPointer(startPosition, properties) { } AnnotationTextArrow::AnnotationTextArrow(const AnnotationTextArrow &other) : AnnotationTextPointer(other) { } Tools AnnotationTextArrow::toolType() const { return Tools::TextArrow; } void AnnotationTextArrow::updateShape() { QLineF tmpLine(mPointer, mRect->center()); QPointF intersectionPoint = ShapeHelper::intersectionBetweenRectAndLineFromCenter(tmpLine, *mRect); QLineF shaft(intersectionPoint, mPointer); shaft.setLength(shaft.length() - 5); auto arrow = AnnotationShapeCreator::createArrowHead(properties()->width() / 2); arrow = AnnotationShapeCreator::translate(arrow, mPointer, -shaft.angle()); mRect->moveCenter(mRect->center()); mArrowShape = QPainterPath(shaft.p1()); mArrowShape.setFillRule(Qt::WindingFill); mArrowShape.lineTo(shaft.p2()); mArrowShape.addPolygon(arrow); QPainterPath path(mArrowShape); path.addRect(*mRect); path.closeSubpath(); setShape(path); } void AnnotationTextArrow::paint(QPainter *painter, const QStyleOptionGraphicsItem *style, QWidget *widget) { adjustPainter(painter); painter->setPen(painterPen()); painter->setBrush(properties()->color()); // Draw Arrow painter->drawPath(mArrowShape); // Border and fill if(!hasFill()) { painter->setBrush(Qt::NoBrush); } if(!hasBorder()) { painter->setPen(Qt::NoPen); } painter->drawRect(*mRect); // Paint Text auto font = textProperties()->font(); auto color = textProperties()->textColor(); auto margin = textProperties()->width(); auto isShadowEnabled = properties()->shadowEnabled(); mTextHandler.paintText(painter, mRect, font, color, margin, isShadowEnabled); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/AnnotationTextArrow.h000066400000000000000000000027441440330760000252150ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTEXTARROW_H #define KIMAGEANNOTATOR_ANNOTATIONTEXTARROW_H #include "AnnotationTextPointer.h" namespace kImageAnnotator { class AnnotationTextArrow : public AnnotationTextPointer { Q_OBJECT public: AnnotationTextArrow(const QPointF &startPosition, const TextPropertiesPtr &properties); AnnotationTextArrow(const AnnotationTextArrow &other); ~AnnotationTextArrow() override = default; Tools toolType() const override; protected: void updateShape() override; void paint(QPainter *painter, const QStyleOptionGraphicsItem *style, QWidget *widget) override; private: QPainterPath mArrowShape; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTEXTARROW_H kImageAnnotator-0.6.1/src/annotations/items/AnnotationTextPointer.cpp000066400000000000000000000101061440330760000260650ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTextPointer.h" namespace kImageAnnotator { AnnotationTextPointer::AnnotationTextPointer(const QPointF &startPosition, const TextPropertiesPtr &properties) : AbstractAnnotationPointerRect(startPosition, properties) { setupFlags(); connectSlots(); mRect->setWidth(20); mRect->setHeight(properties->font().pixelSize()); } AnnotationTextPointer::AnnotationTextPointer(const AnnotationTextPointer &other) : AbstractAnnotationPointerRect(other), mTextHandler(other.mTextHandler) { setupFlags(); connectSlots(); } void AnnotationTextPointer::finish() { enableEditing(); AbstractAnnotationPointerRect::finish(); } Tools AnnotationTextPointer::toolType() const { return Tools::TextPointer; } QPainterPath AnnotationTextPointer::shape() const { auto path = AbstractAnnotationItem::shape(); if(!hasFill()){ auto font = textProperties()->font(); auto margin = textProperties()->width(); path.addRect(mTextHandler.getTextRect(mRect, font, margin)); } return path; } void AnnotationTextPointer::enableEditing() { setFocus(); mTextHandler.enableEditing(); } void AnnotationTextPointer::disableEditing() { mTextHandler.disableEditing(); } TextPropertiesPtr AnnotationTextPointer::textProperties() const { return AbstractAnnotationItem::properties().staticCast(); } void AnnotationTextPointer::updateShape() { auto line = QLineF(mRect->center(), mPointer); auto pointerWidth = qMin(mRect->width(), mRect->height()) * 0.7; auto pointer = AnnotationShapeCreator::createPointer(pointerWidth, line.length()); auto finishedPointer = AnnotationShapeCreator::translate(pointer, mPointer, -line.angle()); QPainterPath path(mRect->center()); path.setFillRule(Qt::WindingFill); path.addPolygon(finishedPointer); path.closeSubpath(); path.addRect(*mRect); auto painterPath = path.simplified(); setShape(painterPath); } void AnnotationTextPointer::focusOutEvent(QFocusEvent *event) { disableEditing(); QGraphicsWidget::focusOutEvent(event); } void AnnotationTextPointer::keyPressEvent(QKeyEvent *event) { mTextHandler.handleKeyEvent(event); } void AnnotationTextPointer::inputMethodEvent(QInputMethodEvent *event) { mTextHandler.insertText(event->commitString()); } void AnnotationTextPointer::paint(QPainter *painter, const QStyleOptionGraphicsItem *style, QWidget *widget) { // Paint border and fill AbstractAnnotationRect::paint(painter, style, widget); // Paint Text auto font = textProperties()->font(); auto color = textProperties()->textColor(); auto margin = textProperties()->width(); auto isShadowEnabled = properties()->shadowEnabled(); mTextHandler.paintText(painter, mRect, font, color, margin, isShadowEnabled); } void AnnotationTextPointer::connectSlots() { connect(&mTextHandler, &AnnotationTextHandler::changed, this, &AnnotationTextPointer::refresh); connect(&mTextHandler, &AnnotationTextHandler::finished, this, &AnnotationTextPointer::escape); } void AnnotationTextPointer::setupFlags() { setFlag(ItemIsFocusable, true); setFlag(ItemAcceptsInputMethod, true); } void AnnotationTextPointer::escape() { clearFocus(); } void AnnotationTextPointer::refresh() { prepareGeometryChange(); auto font = textProperties()->font(); auto margin = textProperties()->width(); mTextHandler.updateRect(mRect, font, margin); updateShape(); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/AnnotationTextPointer.h000066400000000000000000000043021440330760000255330ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTEXTPOINTER_H #define KIMAGEANNOTATOR_ANNOTATIONTEXTPOINTER_H #include "AbstractAnnotationPointerRect.h" #include "src/annotations/items/interfaces/EditableItem.h" #include "src/annotations/items/text/AnnotationTextHandler.h" #include "src/annotations/items/helper/AnnotationShapeCreator.h" #include "src/annotations/properties/AnnotationTextProperties.h" namespace kImageAnnotator { class AnnotationTextPointer : public AbstractAnnotationPointerRect, public EditableItem { Q_OBJECT public: AnnotationTextPointer(const QPointF &startPosition, const TextPropertiesPtr &properties); AnnotationTextPointer(const AnnotationTextPointer &other); ~AnnotationTextPointer() override = default; void finish() override; Tools toolType() const override; QPainterPath shape() const override; void enableEditing() override; void disableEditing() override; TextPropertiesPtr textProperties() const; protected: AnnotationTextHandler mTextHandler; void updateShape() override; void focusOutEvent(QFocusEvent *event) override; void keyPressEvent(QKeyEvent *event) override; void inputMethodEvent(QInputMethodEvent *event) override; void paint(QPainter *painter, const QStyleOptionGraphicsItem *style, QWidget *widget) override; private: void connectSlots(); void setupFlags(); private slots: void escape(); void refresh(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTEXTPOINTER_H kImageAnnotator-0.6.1/src/annotations/items/BaseAnnotationNumber.cpp000066400000000000000000000024331440330760000256270ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "BaseAnnotationNumber.h" namespace kImageAnnotator { void BaseAnnotationNumber::setNumber(int number) { mNumberString = QString::number(number); updateRect(); } int BaseAnnotationNumber::number() const { return mNumberString.toInt(); } QString BaseAnnotationNumber::numberString() const { return mNumberString; } void BaseAnnotationNumber::updateRect(QRectF *rect, const QFont &font) const { mNumberRectHelper.updateRect(rect, mNumberString, font); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/BaseAnnotationNumber.h000066400000000000000000000030051440330760000252700ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_BASEANNOTATIONNUMBER_H #define KIMAGEANNOTATOR_BASEANNOTATIONNUMBER_H #include #include #include "src/annotations/items/helper/NumberRectHelper.h" namespace kImageAnnotator { class BaseAnnotationNumber { public: BaseAnnotationNumber() = default; ~BaseAnnotationNumber() = default; BaseAnnotationNumber(const BaseAnnotationNumber &other) = default; void setNumber(int number); int number() const; protected: QString numberString() const; void updateRect(QRectF *rect, const QFont &font) const; virtual void updateRect() = 0; private: QString mNumberString; NumberRectHelper mNumberRectHelper; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_BASEANNOTATIONNUMBER_H kImageAnnotator-0.6.1/src/annotations/items/helper/000077500000000000000000000000001440330760000223225ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/items/helper/AnnotationShapeCreator.cpp000066400000000000000000000032621440330760000274440ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationShapeCreator.h" namespace kImageAnnotator { QPolygonF AnnotationShapeCreator::createPointer(qreal width, qreal length) { QPointF p0(0, 0); QPointF p1(-length, width / 2); QPointF p2(-length, -width / 2); QPolygonF pointer; return pointer << p0 << p1 << p2 << p0; } QPolygonF AnnotationShapeCreator::createArrowHead(int scaleFactor) { auto arrowHeadLength = 15 + scaleFactor; auto arrowHeadWidth = 5 + scaleFactor; auto arrowHeadMid = 13 + scaleFactor; QPointF p0(0, 0); QPointF p1(-arrowHeadLength, arrowHeadWidth); QPointF p2(-arrowHeadMid, 0); QPointF p3(-arrowHeadLength, -arrowHeadWidth); QPolygonF arrow; return arrow << p0 << p1 << p2 << p3 << p0; } QPolygonF AnnotationShapeCreator::translate(const QPolygonF &shape, const QPointF &pos, qreal angle) { return QTransform().translate(pos.x(), pos.y()).rotate(angle).map(shape); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/helper/AnnotationShapeCreator.h000066400000000000000000000024251440330760000271110ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONSHAPECREATOR_H #define KIMAGEANNOTATOR_ANNOTATIONSHAPECREATOR_H #include #include namespace kImageAnnotator { class AnnotationShapeCreator { public: static QPolygonF createPointer(qreal width, qreal length); static QPolygonF createArrowHead(int scaleFactor); static QPolygonF translate(const QPolygonF &shape, const QPointF &pos, qreal angle); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONSHAPECREATOR_H kImageAnnotator-0.6.1/src/annotations/items/helper/NumberRectHelper.cpp000066400000000000000000000026671440330760000262470ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "NumberRectHelper.h" namespace kImageAnnotator { void NumberRectHelper::updateRect(QRectF *rect, const QString &text, const QFont &font) const { auto center = rect->center(); auto size = getTextRectSize(text, font); rect->setSize(size); rect->moveCenter(center); } QSizeF NumberRectHelper::getTextRectSize(const QString &text, const QFont &font) const { QFontMetricsF metrics(font); auto boundingRect = metrics.boundingRect(text).adjusted(-5, -5, 5, 5); auto largestSite = boundingRect.width() > boundingRect.height() ? boundingRect.width() : boundingRect.height(); return { largestSite, largestSite }; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/helper/NumberRectHelper.h000066400000000000000000000025151440330760000257040ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_NUMBERRECTHELPER_H #define KIMAGEANNOTATOR_NUMBERRECTHELPER_H #include #include #include #include #include namespace kImageAnnotator { class NumberRectHelper { public: NumberRectHelper() = default; ~NumberRectHelper() = default; void updateRect(QRectF *rect, const QString &text, const QFont &font) const; protected: QSizeF getTextRectSize(const QString &text, const QFont &font) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_NUMBERRECTHELPER_H kImageAnnotator-0.6.1/src/annotations/items/interfaces/000077500000000000000000000000001440330760000231665ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/items/interfaces/EditableItem.h000066400000000000000000000020131440330760000256630ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_EDITABLEITEM_H #define KIMAGEANNOTATOR_EDITABLEITEM_H class EditableItem { public: virtual void enableEditing() = 0; virtual void disableEditing() = 0; }; #endif //KIMAGEANNOTATOR_EDITABLEITEM_H kImageAnnotator-0.6.1/src/annotations/items/text/000077500000000000000000000000001440330760000220275ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/items/text/AnnotationTextHandler.cpp000066400000000000000000000137071440330760000270200ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTextHandler.h" namespace kImageAnnotator { AnnotationTextHandler::AnnotationTextHandler() : mIsInEditMode(false) { setupEditModeOutlinePen(); connectSlots(); } AnnotationTextHandler::AnnotationTextHandler(const AnnotationTextHandler &other) : mText(other.mText), mTextCursor(other.mTextCursor), mIsInEditMode(false) { setupEditModeOutlinePen(); connectSlots(); } void AnnotationTextHandler::insertText(const QString &text) { mText.insert(mTextCursor.position(), text); mTextCursor.moveForwardBy(mText, text.length()); emit changed(); } void AnnotationTextHandler::removeText(TextPositions direction) { auto currentCursorPos = mTextCursor.position(); if (direction == TextPositions::Previous) { if (currentCursorPos == 0) { return; } mText.remove(currentCursorPos - 1, 1); moveCursor(TextPositions::Previous); } else if (direction == TextPositions::Next) { if (currentCursorPos >= mText.length()) { return; } mText.remove(currentCursorPos, 1); } } void AnnotationTextHandler::moveCursor(TextPositions direction) { mTextCursor.move(direction, mText); } void AnnotationTextHandler::pasteText() { auto clipboard = QApplication::clipboard(); if (clipboard->text().isEmpty()) { return; } mText.insert(mTextCursor.position(), clipboard->text()); mTextCursor.setPosition(mTextCursor.position() + clipboard->text().length()); } void AnnotationTextHandler::enableEditing() { mTextCursor.start(); mIgnoreShortcutsFilter.apply(); mIsInEditMode = true; emit changed(); } void AnnotationTextHandler::disableEditing() { mTextCursor.stop(); mIgnoreShortcutsFilter.remove(); mIsInEditMode = false; emit changed(); } void AnnotationTextHandler::paintText(QPainter *painter, QRectF *rect, const QFont &font, const QColor &color, int margin, bool isShadowEnabled) { auto textArea = rect->toRect(); if (mIsInEditMode && textArea.isValid()) { painter->setBrush(Qt::NoBrush); painter->setPen(mEditModeOutlinePen); painter->drawRect(textArea); } // Workaround for issue #70 / #184 -> Cursor not drawn with Qt 5.9 // https://bugreports.qt.io/browse/QTBUG-82022 if (mIsInEditMode && isShadowEnabled) { painter->setBrush(QColor(255,255,255,50)); painter->drawRect(*rect); } // Paint text painter->setPen(color); painter->setClipRect(rect->adjusted(margin, margin, -margin, -margin)); QFontMetrics fontMetrics(font); auto boxHeight = 0; QTextDocument document(mText); for (auto block = document.begin(); block != document.end(); block = block.next()) { auto blockPosition = block.position(); auto blockLength = block.length(); QTextLayout textLayout(block); textLayout.setCacheEnabled(true); textLayout.setFont(font); auto blockHeight = 0; textLayout.setCacheEnabled(true); textLayout.beginLayout(); while (true) { auto line = textLayout.createLine(); if (!line.isValid()) { break; } line.setLineWidth(textArea.width() - margin * 2); blockHeight += fontMetrics.leading(); line.setPosition(textArea.adjusted(margin, margin, 0, 0).topLeft()); blockHeight += line.height(); } textLayout.endLayout(); textLayout.draw(painter, QPoint(0, boxHeight)); if (mTextCursor.isVisible() && isCursorInBlock(blockPosition, blockLength)) { textLayout.drawCursor(painter, QPointF(0, boxHeight), mTextCursor.position() - blockPosition, 1); } boxHeight += blockHeight; } } void AnnotationTextHandler::updateRect(QRectF *rect, const QFont &font, int margin) const { auto newRect = getTextRect(rect, font, margin).normalized(); auto currentRect = rect->normalized(); if (newRect.width() > currentRect.width()) { currentRect.setWidth(newRect.width()); } if (newRect.height() > currentRect.height()) { currentRect.setHeight(newRect.height()); } rect->setRect(currentRect.x(), currentRect.y(), currentRect.width(), currentRect.height()); } bool AnnotationTextHandler::isCursorInBlock(int blockPosition, int blockLength) const { return mTextCursor.position() >= blockPosition && mTextCursor.position() < blockPosition + blockLength; } void AnnotationTextHandler::setupEditModeOutlinePen() { mEditModeOutlinePen.setColor(Qt::white); mEditModeOutlinePen.setWidthF(1); mEditModeOutlinePen.setStyle(Qt::DotLine); } QRect AnnotationTextHandler::getTextRect(QRectF *rect, const QFont& font, int margin) const { QFontMetrics fontMetrics(font); auto newRect = fontMetrics.boundingRect(rect->toRect().normalized(), Qt::AlignLeft, mText); newRect.adjust(0, 2, (margin * 2) + 2, margin * 2); return newRect; } void AnnotationTextHandler::handleKeyEvent(QKeyEvent *event) { mKeyInputHelper.handleKeyPress(event); emit changed(); } void AnnotationTextHandler::connectSlots() { connect(&mKeyInputHelper, &KeyInputHelper::move, this, &AnnotationTextHandler::moveCursor); connect(&mKeyInputHelper, &KeyInputHelper::insert, this, &AnnotationTextHandler::insertText); connect(&mKeyInputHelper, &KeyInputHelper::remove, this, &AnnotationTextHandler::removeText); connect(&mKeyInputHelper, &KeyInputHelper::paste, this, &AnnotationTextHandler::pasteText); connect(&mKeyInputHelper, &KeyInputHelper::escape, this, &AnnotationTextHandler::finished); connect(&mTextCursor, &TextCursor::tick, this, &AnnotationTextHandler::changed); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/text/AnnotationTextHandler.h000066400000000000000000000043601440330760000264600ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTEXTHANDLER_H #define KIMAGEANNOTATOR_ANNOTATIONTEXTHANDLER_H #include #include #include #include "src/annotations/items/text/TextCursor.h" #include "src/common/filter/IgnoreShortcutsFilter.h" #include "src/annotations/items/text/KeyInputHelper.h" namespace kImageAnnotator { class AnnotationTextHandler : public QObject { Q_OBJECT public: explicit AnnotationTextHandler(); AnnotationTextHandler(const AnnotationTextHandler &other); ~AnnotationTextHandler() override = default; void insertText(const QString &text); void enableEditing(); void disableEditing(); void paintText(QPainter *painter, QRectF *rect, const QFont &font, const QColor &color, int margin, bool isShadowEnabled); void updateRect(QRectF *rect, const QFont &font, int margin) const; QRect getTextRect(QRectF *rect, const QFont& font, int margin) const; void handleKeyEvent(QKeyEvent *event); signals: void changed() const; void finished() const; private: QString mText; TextCursor mTextCursor; IgnoreShortcutsFilter mIgnoreShortcutsFilter; bool mIsInEditMode; QPen mEditModeOutlinePen; KeyInputHelper mKeyInputHelper; bool isCursorInBlock(int blockPosition, int blockLength) const; void setupEditModeOutlinePen(); void connectSlots(); void removeText(TextPositions direction); void moveCursor(TextPositions direction); void pasteText(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTEXTHANDLER_H kImageAnnotator-0.6.1/src/annotations/items/text/CapsLockStatusChecker.cpp000066400000000000000000000030201440330760000267160ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CapsLockStatusChecker.h" #if defined(_WIN32) #include #endif #if defined(__linux__) #include "src/common/platform/PlatformChecker.h" #include #include #endif namespace kImageAnnotator { bool CapsLockStatusChecker::isCapsLockEnabled() { #if defined(_WIN32) return GetKeyState(VK_CAPITAL) == 1; #elif defined(__linux__) if (PlatformChecker::instance()->isWayland()) { return false; } else { auto display = XOpenDisplay(nullptr); auto capsState = false; if (display) { unsigned n; XkbGetIndicatorState(display, XkbUseCoreKbd, &n); capsState = (n & 0x01) == 1; } XCloseDisplay(display); return capsState; } #else return false; #endif } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/items/text/CapsLockStatusChecker.h000066400000000000000000000022371440330760000263740ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CAPSLOCKSTATUSCHECKER_H #define KIMAGEANNOTATOR_CAPSLOCKSTATUSCHECKER_H namespace kImageAnnotator { class CapsLockStatusChecker { public: static bool isCapsLockEnabled(); protected: explicit CapsLockStatusChecker() = default; ~CapsLockStatusChecker() = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CAPSLOCKSTATUSCHECKER_H kImageAnnotator-0.6.1/src/annotations/items/text/KeyInputHelper.cpp000066400000000000000000000056711440330760000254540ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "KeyInputHelper.h" namespace kImageAnnotator { void KeyInputHelper::handleKeyPress(const QKeyEvent *event) const { switch (event->key()) { case Qt::Key_Backspace: emit remove(TextPositions::Previous); break; case Qt::Key_Return: case Qt::Key_Enter: if (isShiftPressed(event)) { emit insert(QLatin1String("\n")); } else { emit escape(); } break; case Qt::Key_Delete: emit remove(TextPositions::Next); break; case Qt::Key_Escape: emit escape(); return; case Qt::Key_Left: if (isControlPressed(event)) { emit move(TextPositions::PreviousWordBeginning); } else { emit move(TextPositions::Previous); } break; case Qt::Key_Right: if (isControlPressed(event)) { emit move(TextPositions::NextWordBeginning); } else { emit move(TextPositions::Next); } break; case Qt::Key_Up: emit move(TextPositions::Up); break; case Qt::Key_Down: emit move(TextPositions::Down); break; case Qt::Key::Key_Home: emit move(TextPositions::Beginning); break; case Qt::Key::Key_End: emit move(TextPositions::End); break; case Qt::Key_Paste: emit paste(); break; default: if (event->matches(QKeySequence::Paste)) { emit paste(); break; } if (event->text().isEmpty()) { return; } emit insert(getTextWithCorrectCase(event)); } } QString KeyInputHelper::getTextWithCorrectCase(const QKeyEvent *event) const { auto text = event->text(); bool capsLockEnabled = CapsLockStatusChecker::isCapsLockEnabled(); bool shiftPressed = isShiftPressed(event); if (shiftPressed && capsLockEnabled) { return text.toLower(); } else if (!shiftPressed && capsLockEnabled) { return text.toUpper(); } return text; } bool KeyInputHelper::isShiftPressed(const QKeyEvent *event) const { return isModifierPressed(event, Qt::ShiftModifier); } bool KeyInputHelper::isControlPressed(const QKeyEvent *event) const { return isModifierPressed(event, Qt::ControlModifier); } bool KeyInputHelper::isModifierPressed(const QKeyEvent *event, Qt::KeyboardModifier modifier) const { return static_cast(event->modifiers() & modifier); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/text/KeyInputHelper.h000066400000000000000000000032601440330760000251110ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_KEYINPUTHELPER_H #define KIMAGEANNOTATOR_KEYINPUTHELPER_H #include #include "TextPositions.h" #include "CapsLockStatusChecker.h" namespace kImageAnnotator { class KeyInputHelper : public QObject { Q_OBJECT public: explicit KeyInputHelper() = default; ~KeyInputHelper() override = default; void handleKeyPress(const QKeyEvent *event) const; bool isShiftPressed(const QKeyEvent *event) const; bool isControlPressed(const QKeyEvent *event) const; QString getTextWithCorrectCase(const QKeyEvent *event) const; signals: void remove(TextPositions position) const; void insert(const QString &text) const; void move(TextPositions position) const; void paste() const; void escape() const; private: bool isModifierPressed(const QKeyEvent *event, Qt::KeyboardModifier modifier) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_KEYINPUTHELPER_H kImageAnnotator-0.6.1/src/annotations/items/text/TextCursor.cpp000066400000000000000000000133271440330760000246630ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "TextCursor.h" namespace kImageAnnotator { TextCursor::TextCursor() : mBlinkTimer(new QTimer(this)), mLineFeedChar(QChar::LineFeed) { connectSlots(); } TextCursor::TextCursor(const TextCursor &other) : mBlinkTimer(new QTimer(this)), mPosition(other.mPosition), mLineFeedChar(QChar::LineFeed) { connectSlots(); } TextCursor::~TextCursor() { delete mBlinkTimer; } void TextCursor::move(TextPositions direction, const QString &text) { switch (direction) { case TextPositions::Beginning: moveCursorToBeginning(); break; case TextPositions::End: moveCursorToEnd(text); break; case TextPositions::NextWordBeginning: moveCursorToNextWordBeginning(text); break; case TextPositions::Next: moveCursorForwardBy(text, 1); break; case TextPositions::PreviousWordBeginning: moveCursorToPreviousWordBeginning(text); break; case TextPositions::Previous: moveCursorBack(text); break; case TextPositions::Up: moveCursorUp(text); break; case TextPositions::Down: moveCursorDown(text); break; } mIsVisible = true; } void TextCursor::moveForwardBy(const QString &text, int moveBy) { moveCursorForwardBy(text, moveBy); mIsVisible = true; } void TextCursor::start() { mIsVisible = true; mBlinkTimer->start(mBlinkIntervalInMs); } void TextCursor::stop() { mBlinkTimer->stop(); mIsVisible = false; } int TextCursor::position() const { return mPosition; } void TextCursor::setPosition(int newPosition) { mPosition = newPosition; } bool TextCursor::isVisible() const { return mIsVisible; } void TextCursor::moveCursorToBeginning() { mPosition = 0; } void TextCursor::moveCursorToEnd(const QString &text) { mPosition = text.length(); } void TextCursor::moveCursorToNextWordBeginning(const QString &text) { auto lastSpacePos = -1; auto currentPos = mPosition; while (currentPos < text.length()) { auto currentChar = text.at(currentPos); if (currentChar == mLineFeedChar && currentPos != mPosition) { break; } if (currentChar.isSpace()) { lastSpacePos = currentPos; } else if (lastSpacePos >= 0) { break; } currentPos++; } mPosition = currentPos; } void TextCursor::moveCursorForwardBy(const QString &text, int moveBy) { mPosition += moveBy; if (mPosition > text.length()) { mPosition = text.length(); } } void TextCursor::moveCursorToPreviousWordBeginning(const QString &text) { auto lastNonSpacePos = -1; auto currentPos = mPosition - 1; while (currentPos >= 0) { auto currentChar = text.at(currentPos); if (currentChar == mLineFeedChar) { lastNonSpacePos = currentPos; if (lastNonSpacePos + 1 != mPosition) { lastNonSpacePos++; } break; } if (currentChar.isSpace()) { if (lastNonSpacePos >= 0) { break; } } else { lastNonSpacePos = currentPos; } currentPos--; } if (lastNonSpacePos >= 0) { mPosition = lastNonSpacePos; } else { mPosition = 0; } } void TextCursor::moveCursorBack(const QString &text) { mPosition--; if (mPosition < 0) { mPosition = 0; } } void TextCursor::moveCursorUp(const QString &text) { QTextDocument document(text); auto currentBlock = document.findBlock(mPosition); if (currentBlock == document.firstBlock()) { return; } auto positionInBlock = currentBlock.position(); auto previousBlock = currentBlock.previous(); fitPositionToNewBlock(positionInBlock, previousBlock); } void TextCursor::moveCursorDown(const QString &text) { QTextDocument document(text); auto currentBlock = document.findBlock(mPosition); if (currentBlock == document.lastBlock()) { return; } auto positionInBlock = currentBlock.position(); auto nextBlock = currentBlock.next(); fitPositionToNewBlock(positionInBlock, nextBlock); } void TextCursor::fitPositionToNewBlock(int positionInBlock, const QTextBlock &targetBlock) { if ((mPosition - positionInBlock) < targetBlock.length()) { moveToSamePositionInNewBlock(positionInBlock, targetBlock); } else { movePositionToEndOfBlock(targetBlock); } } void TextCursor::moveToSamePositionInNewBlock(int positionInBlock, const QTextBlock &targetBlock) { mPosition = targetBlock.position() + mPosition - positionInBlock; } void TextCursor::movePositionToEndOfBlock(const QTextBlock &targetBlock) { mPosition = targetBlock.position() + targetBlock.length() - 1; } void TextCursor::connectSlots() { connect(mBlinkTimer, &QTimer::timeout, [this]() { mIsVisible = !mIsVisible; emit tick(); }); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/items/text/TextCursor.h000066400000000000000000000044171440330760000243300ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_TEXTCURSOR_H #define KIMAGEANNOTATOR_TEXTCURSOR_H #include #include #include #include "TextPositions.h" namespace kImageAnnotator { class TextCursor : public QObject { Q_OBJECT public: explicit TextCursor(); TextCursor(const TextCursor &other); ~TextCursor() override; void move(TextPositions direction, const QString &text); void moveForwardBy(const QString &text, int moveBy); void start(); void stop(); int position() const; void setPosition(int newPosition); bool isVisible() const; signals: void tick() const; private: int mBlinkIntervalInMs = 800; QTimer *mBlinkTimer; int mPosition = 0; bool mIsVisible = false; QChar mLineFeedChar; void moveCursorToBeginning(); void moveCursorToEnd(const QString &text); void moveCursorToNextWordBeginning(const QString &text); void moveCursorForwardBy(const QString &text, int moveBy); void moveCursorToPreviousWordBeginning(const QString &text); void moveCursorBack(const QString &text); void moveCursorUp(const QString &text); void moveCursorDown(const QString &text); void fitPositionToNewBlock(int positionInBlock, const QTextBlock &targetBlock); void movePositionToEndOfBlock(const QTextBlock &targetBlock); void moveToSamePositionInNewBlock(int positionInBlock, const QTextBlock &targetBlock); void connectSlots(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_TEXTCURSOR_H kImageAnnotator-0.6.1/src/annotations/items/text/TextPositions.h000066400000000000000000000022711440330760000250360ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_TEXTPOSITIONS_H #define KIMAGEANNOTATOR_TEXTPOSITIONS_H #include namespace kImageAnnotator { enum class TextPositions { Beginning, End, PreviousWordBeginning, NextWordBeginning, Next, Previous, Up, Down }; } // namespace kImageAnnotator Q_DECLARE_METATYPE(kImageAnnotator::TextPositions) #endif //KIMAGEANNOTATOR_TEXTPOSITIONS_H kImageAnnotator-0.6.1/src/annotations/misc/000077500000000000000000000000001440330760000206555ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/misc/AbstractCloneableItemEffect.cpp000066400000000000000000000015161440330760000266700ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractClonableItemEffect.h" kImageAnnotator-0.6.1/src/annotations/misc/AbstractCloneableItemEffect.h000066400000000000000000000020601440330760000263300ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTITEMEFFECT_H #define KIMAGEANNOTATOR_ABSTRACTITEMEFFECT_H #include namespace kImageAnnotator { class AbstractClonableItemEffect { }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTITEMEFFECT_H kImageAnnotator-0.6.1/src/annotations/misc/AnnotationContextMenu.cpp000066400000000000000000000045351440330760000256740ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationContextMenu.h" namespace kImageAnnotator { AnnotationContextMenu::AnnotationContextMenu() { mArrangeMenu = addMenu(tr("Arrange")); mArrangeMenu->addAction(tr("Bring to Front"), this, &AnnotationContextMenu::bringToFront); mArrangeMenu->addAction(tr("Bring Forward"), this, &AnnotationContextMenu::bringForward); mArrangeMenu->addAction(tr("Send Backward"), this, &AnnotationContextMenu::sendBackward); mArrangeMenu->addAction(tr("Send to Back"), this, &AnnotationContextMenu::sendToBack); addSeparator(); mSelectThisAction = addAction(tr("Select This")); addSeparator(); mCopyAction = addAction(tr("Copy")); mPastAction = addAction(tr("Paste")); addSeparator(); mEditAction = addAction(tr("Edit"), this, &AnnotationContextMenu::edit); mDeleteAction = addAction(tr("Delete"), this, &AnnotationContextMenu::erase); } void AnnotationContextMenu::setOverItem(bool isOverItem) { mArrangeMenu->setEnabled(isOverItem); mCopyAction->setEnabled(isOverItem); mDeleteAction->setEnabled(isOverItem); mSelectThisAction->setEnabled(isOverItem); } void AnnotationContextMenu::setPastEnabled(bool enabled) { mPastAction->setEnabled(enabled); } void AnnotationContextMenu::setEditVisible(bool enabled) { mEditAction->setVisible(enabled); } void AnnotationContextMenu::exec(const QPointF &position) { auto selectedAction = QMenu::exec(position.toPoint()); if (selectedAction && selectedAction == mPastAction) { emit paste(position); } if (selectedAction && selectedAction == mCopyAction) { emit copy(position); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/misc/AnnotationContextMenu.h000066400000000000000000000032761440330760000253420ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONCONTEXTMENU_H #define KIMAGEANNOTATOR_ANNOTATIONCONTEXTMENU_H #include namespace kImageAnnotator { class AnnotationContextMenu : public QMenu { Q_OBJECT public: explicit AnnotationContextMenu(); ~AnnotationContextMenu() override = default; void setOverItem(bool isOverItem); void setPastEnabled(bool enabled); void setEditVisible(bool enabled); void exec(const QPointF &position); signals: void bringToFront() const; void bringForward() const; void sendBackward() const; void sendToBack() const; void copy(const QPointF &position) const; void paste(const QPointF &position) const; void erase() const; void edit() const; private: QMenu *mArrangeMenu; QAction *mCopyAction; QAction *mPastAction; QAction *mSelectThisAction; QAction *mDeleteAction; QAction *mEditAction; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONCONTEXTMENU_H kImageAnnotator-0.6.1/src/annotations/misc/AnnotationItemClipboard.cpp000066400000000000000000000030341440330760000261320ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemClipboard.h" namespace kImageAnnotator { AnnotationItemClipboard::AnnotationItemClipboard(const AnnotationItemModifier *itemModifier) { Q_ASSERT(itemModifier != nullptr); mItemModifier = itemModifier; } bool AnnotationItemClipboard::isEmpty() const { return mCopiedItemsToOffset.count() == 0; } void AnnotationItemClipboard::copyItems(const QPointF &position) { clear(); for (auto item : mItemModifier->selectedItems()) { mCopiedItemsToOffset[item] = item->position() - position; } } QHash AnnotationItemClipboard::copiedItemsWithOffset() const { return mCopiedItemsToOffset; } void AnnotationItemClipboard::clear() { mCopiedItemsToOffset.clear(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/misc/AnnotationItemClipboard.h000066400000000000000000000031521440330760000256000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMCLIPBOARD_H #define KIMAGEANNOTATOR_ANNOTATIONITEMCLIPBOARD_H #include #include "src/annotations/modifiers/AnnotationItemModifier.h" #include "src/annotations/core/AnnotationItemFactory.h" namespace kImageAnnotator { class AnnotationItemClipboard : public QObject { Q_OBJECT public: explicit AnnotationItemClipboard(const AnnotationItemModifier *itemModifier); ~AnnotationItemClipboard() override = default; bool isEmpty() const; QHash copiedItemsWithOffset() const; public slots: void copyItems(const QPointF &position); void clear(); private: const AnnotationItemModifier *mItemModifier; QHash mCopiedItemsToOffset; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONITEMCLIPBOARD_H kImageAnnotator-0.6.1/src/annotations/misc/CanvasPainter.cpp000066400000000000000000000030701440330760000241170ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CanvasPainter.h" namespace kImageAnnotator { CanvasPainter::CanvasPainter() : mCanvasBackground(new QImage(QSize(20, 20), QImage::Format_ARGB32_Premultiplied)) { createTiledBackground(); } CanvasPainter::~CanvasPainter() { delete mCanvasBackground; } void CanvasPainter::paint(QPainter *painter, const QRectF &rect, const QColor &color) { painter->setPen(Qt::NoPen); painter->setBrush(*mCanvasBackground); painter->drawRect(rect); painter->setBrush(color); painter->drawRect(rect); } void CanvasPainter::createTiledBackground() { mCanvasBackground->fill(Qt::white); QPainter painter(mCanvasBackground); painter.setPen(Qt::NoPen); painter.setBrush(Qt::gray); painter.drawRect(0, 0, 10, 10); painter.drawRect(10, 10, 20, 20); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/misc/CanvasPainter.h000066400000000000000000000023071440330760000235660ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CANVASPAINTER_H #define KIMAGEANNOTATOR_CANVASPAINTER_H #include namespace kImageAnnotator { class CanvasPainter { public: CanvasPainter(); ~CanvasPainter(); void paint(QPainter *painter, const QRectF &rect, const QColor &color); private: QImage *mCanvasBackground; void createTiledBackground(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CANVASPAINTER_H kImageAnnotator-0.6.1/src/annotations/misc/ImageBlurrer.cpp000066400000000000000000000054241440330760000237460ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ImageBlurrer.h" /* * Solution provided by liuyanghejerry * See: https://stackoverflow.com/questions/3903223/qt4-how-to-blur-qpixmap-image */ namespace kImageAnnotator { QImage ImageBlurrer::blurred(const QImage &image, int radius, bool alphaOnly) const { auto alpha = getAlpha(radius); auto result = image.convertToFormat(QImage::Format_ARGB32_Premultiplied); auto r1 = image.rect().top(); auto r2 = image.rect().bottom(); auto c1 = image.rect().left(); auto c2 = image.rect().right(); auto bpl = result.bytesPerLine(); int rgba[4]; unsigned char *p; auto i1 = 0; auto i2 = 3; if (alphaOnly) { i1 = i2 = 3; } for (auto col = c1; col <= c2; col++) { p = result.scanLine(r1) + col * 4; for (auto i = i1; i <= i2; i++) { rgba[i] = p[i] << 4; } p += bpl; for (auto j = r1; j < r2; j++, p += bpl) { for (auto i = i1; i <= i2; i++) { p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 64) >> 4; } } } for (auto row = r1; row <= r2; row++) { p = result.scanLine(row) + c1 * 4; for (auto i = i1; i <= i2; i++) { rgba[i] = p[i] << 4; } p += 4; for (auto j = c1; j < c2; j++, p += 4) { for (auto i = i1; i <= i2; i++) { p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 64) >> 4; } } } for (auto col = c1; col <= c2; col++) { p = result.scanLine(r2) + col * 4; for (auto i = i1; i <= i2; i++) { rgba[i] = p[i] << 4; } p -= bpl; for (auto j = r1; j < r2; j++, p -= bpl) { for (auto i = i1; i <= i2; i++) { p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 64) >> 4; } } } for (auto row = r1; row <= r2; row++) { p = result.scanLine(row) + c2 * 4; for (auto i = i1; i <= i2; i++) { rgba[i] = p[i] << 4; } p -= 4; for (auto j = c1; j < c2; j++, p -= 4) { for (auto i = i1; i <= i2; i++) { p[i] = (rgba[i] += ((p[i] << 4) - rgba[i]) * alpha / 64) >> 4; } } } return result; } int ImageBlurrer::getAlpha(int radius) const { return abs(radius - 21); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/misc/ImageBlurrer.h000066400000000000000000000023021440330760000234030ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_IMAGEBLURRER_H #define KIMAGEANNOTATOR_IMAGEBLURRER_H #include namespace kImageAnnotator { class ImageBlurrer { public: explicit ImageBlurrer() = default; ~ImageBlurrer() = default; QImage blurred(const QImage &image, int radius, bool alphaOnly) const; private: int getAlpha(int radius) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_IMAGEBLURRER_H kImageAnnotator-0.6.1/src/annotations/misc/NumberManager.cpp000066400000000000000000000050471440330760000241120ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "NumberManager.h" namespace kImageAnnotator { NumberManager::NumberManager() : mNumberSeed(1), mNumberUpdateMode(NumberUpdateMode::UpdateAllNumbers) { } void kImageAnnotator::NumberManager::addItem(AnnotationNumber *item) { addItemInner(item); } void kImageAnnotator::NumberManager::addItem(AnnotationNumberPointer *item) { addItemInner(item); } void NumberManager::addItem(AnnotationNumberArrow *item) { addItemInner(item); } void NumberManager::addItemInner(AbstractAnnotationItem *item) { Q_ASSERT(item != nullptr); mItems.append(item); if (mNumberUpdateMode == NumberUpdateMode::UpdateAllNumbers) { connect(item, &AbstractAnnotationItem::visibleChanged, this, &NumberManager::updateExistingNumbersIfRequired); updateExistingNumbers(); } else { initItemNumber(item); emit numberSeedChanged(mNumberSeed); } } void NumberManager::initItemNumber(AbstractAnnotationItem *item) { auto numberItem = dynamic_cast(item); numberItem->setNumber(mNumberSeed++); } void NumberManager::reset() { mItems.clear(); } void NumberManager::updateExistingNumbersIfRequired() { if(mNumberUpdateMode == NumberUpdateMode::UpdateAllNumbers) { updateExistingNumbers(); } } void NumberManager::updateExistingNumbers() { auto number = mNumberSeed; for (auto item : mItems) { if (item->isVisible()) { auto numberItem = dynamic_cast(item); numberItem->setNumber(number++); } } } void NumberManager::setNumberSeed(int numberSeed) { mNumberSeed = numberSeed; updateExistingNumbersIfRequired(); } int NumberManager::numberSeed() const { return mNumberSeed; } void NumberManager::setNumberUpdateMode(NumberUpdateMode numberUpdateMode) { mNumberUpdateMode = numberUpdateMode; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/misc/NumberManager.h000066400000000000000000000036541440330760000235610ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_NUMBERMANAGER_H #define KIMAGEANNOTATOR_NUMBERMANAGER_H #include #include "src/common/enum/NumberUpdateMode.h" #include "src/annotations/items/AnnotationNumber.h" #include "src/annotations/items/AnnotationNumberPointer.h" #include "src/annotations/items/AnnotationNumberArrow.h" namespace kImageAnnotator { class NumberManager : public QObject { Q_OBJECT public: explicit NumberManager(); ~NumberManager() override = default; void addItem(AnnotationNumber *item); void addItem(AnnotationNumberPointer *item); void addItem(AnnotationNumberArrow *item); void reset(); void setNumberSeed(int numberSeed); int numberSeed() const; void setNumberUpdateMode(NumberUpdateMode numberUpdateMode); signals: void numberSeedChanged(int numberSeed); public slots: void updateExistingNumbersIfRequired(); private: int mNumberSeed; QList mItems; NumberUpdateMode mNumberUpdateMode; void addItemInner(AbstractAnnotationItem *item); void initItemNumber(AbstractAnnotationItem *item); void updateExistingNumbers(); }; } // namepsace kImageAnnotator #endif //KIMAGEANNOTATOR_NUMBERMANAGER_H kImageAnnotator-0.6.1/src/annotations/misc/itemEffects/000077500000000000000000000000001440330760000231135ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/misc/itemEffects/NoEffect.cpp000066400000000000000000000020371440330760000253120ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "NoEffect.h" namespace kImageAnnotator { void NoEffect::draw(QPainter *painter) { QPoint offset; const auto pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset); painter->drawPixmap(offset, pixmap); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/misc/itemEffects/NoEffect.h000066400000000000000000000022531440330760000247570ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_NOEFFECT_H #define KIMAGEANNOTATOR_NOEFFECT_H #include #include namespace kImageAnnotator { class NoEffect : public QGraphicsEffect { public: explicit NoEffect() = default; ~NoEffect() override = default; protected: void draw(QPainter * painter) override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_NOEFFECT_H kImageAnnotator-0.6.1/src/annotations/misc/itemEffects/ShadowEffect.cpp000066400000000000000000000017711440330760000261670ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ShadowEffect.h" namespace kImageAnnotator { ShadowEffect::ShadowEffect() { setColor(QColor(63, 63, 63, 190)); setBlurRadius(7); setOffset(QPoint(2, 2)); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/misc/itemEffects/ShadowEffect.h000066400000000000000000000022111440330760000256220ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SHADOWEFFECT_H #define KIMAGEANNOTATOR_SHADOWEFFECT_H #include namespace kImageAnnotator { class ShadowEffect : public QGraphicsDropShadowEffect { public: explicit ShadowEffect(); ~ShadowEffect() override = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SHADOWEFFECT_H kImageAnnotator-0.6.1/src/annotations/modifiers/000077500000000000000000000000001440330760000217035ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemArranger.cpp000066400000000000000000000053461440330760000270320ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemArranger.h" namespace kImageAnnotator { AnnotationItemArranger::AnnotationItemArranger(const QList &selectedItems, QList *items) : mSelectedItems(selectedItems), mItems(items) { } void AnnotationItemArranger::bringToFront() { moveForward(true); } void AnnotationItemArranger::bringForward() { moveForward(false); } void AnnotationItemArranger::sendBackward() { moveBackward(false); } void AnnotationItemArranger::sendToBack() { moveBackward(true); } void AnnotationItemArranger::moveForward(bool toFront) { QList> itemToSwap; for (auto selected : mSelectedItems) { for (auto i = mItems->count() - 1; i >= 0; i--) { auto item = mItems->value(i); if (ItemHelper::zValueGreaterThen(item, selected) && !mSelectedItems.contains(item)) { itemToSwap.append(qMakePair(selected, item)); if (!toFront) { break; } } } } createAndEmitArrangeCommand(itemToSwap); } void AnnotationItemArranger::moveBackward(bool toBack) { QList> itemToSwap; for (auto i = mSelectedItems.count() - 1; i >= 0; i--) { auto selected = mSelectedItems.value(i); for (auto item : *mItems) { if (item->zValue() < selected->zValue() && !mSelectedItems.contains(item)) { itemToSwap.append(qMakePair(selected, item)); if (!toBack) { break; } } } } createAndEmitArrangeCommand(itemToSwap); } void AnnotationItemArranger::createAndEmitArrangeCommand(const QList> &itemToSwap) const { emit newCommand(new ArrangeCommand(itemToSwap, mItems)); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemArranger.h000066400000000000000000000036001440330760000264660ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMARRANGER_H #define KIMAGEANNOTATOR_ANNOTATIONITEMARRANGER_H #include #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/annotations/undo/ArrangeCommand.h" #include "src/common/helper/ItemHelper.h" namespace kImageAnnotator { class AnnotationItemArranger : public QObject { Q_OBJECT public: explicit AnnotationItemArranger(const QList &selectedItems, QList *items); ~AnnotationItemArranger() override = default; signals: void newCommand(ArrangeCommand *arrange) const; public slots: void bringToFront(); void bringForward(); void sendBackward(); void sendToBack(); private: QList mSelectedItems; QList *mItems; void moveForward(bool toFront); void moveBackward(bool toBack); void createAndEmitArrangeCommand(const QList> &itemToSwap) const; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONITEMARRANGER_H kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemEditor.cpp000066400000000000000000000033171440330760000265130ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemEditor.h" namespace kImageAnnotator { AnnotationItemEditor::AnnotationItemEditor() : mCurrentEditItem(nullptr) { } void AnnotationItemEditor::handleEditAt(const QPointF &pos, QList *items) { mCurrentEditItem = findEditableItemAt(pos, items); if (mCurrentEditItem != nullptr) { mCurrentEditItem->enableEditing(); } } bool AnnotationItemEditor::isEditing() const { return mCurrentEditItem != nullptr; } void AnnotationItemEditor::clear() { mCurrentEditItem = nullptr; } EditableItem *AnnotationItemEditor::findEditableItemAt(const QPointF &position, QList *items) { QRectF rect(position - QPointF(2, 2), QSize(4, 4)); for (auto item : *items) { auto editableItem = dynamic_cast(item); if (editableItem != nullptr && item->intersects(rect)) { return editableItem; } } return nullptr; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemEditor.h000066400000000000000000000027611440330760000261620ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMEDITOR_H #define KIMAGEANNOTATOR_ANNOTATIONITEMEDITOR_H #include #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/annotations/items/interfaces/EditableItem.h" namespace kImageAnnotator { class AnnotationItemEditor : public QObject { Q_OBJECT public: explicit AnnotationItemEditor(); void handleEditAt(const QPointF &pos, QList *items); bool isEditing() const; void clear(); private: EditableItem *mCurrentEditItem; static EditableItem *findEditableItemAt(const QPointF &position, QList *items); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONITEMEDITOR_H kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemModifier.cpp000066400000000000000000000120151440330760000270160ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemModifier.h" namespace kImageAnnotator { AnnotationItemModifier::AnnotationItemModifier(ZoomValueProvider *zoomValueProvider) : mItemSelector(new AnnotationItemSelector(zoomValueProvider)), mItemResizer(new AnnotationMultiItemResizer(zoomValueProvider)), mItemMover(new AnnotationItemMover), mItemEditor(new AnnotationItemEditor) { addToGroup(mItemSelector); addToGroup(mItemResizer); setZValue(1000); setAcceptHoverEvents(true); connect(mItemMover, &AnnotationItemMover::newCommand, this, &AnnotationItemModifier::itemChanged); connect(mItemResizer, &AnnotationMultiItemResizer::newCommand, this, &AnnotationItemModifier::itemChanged); } AnnotationItemModifier::~AnnotationItemModifier() { delete mItemResizer; delete mItemSelector; delete mItemMover; delete mItemEditor; } void AnnotationItemModifier::handleMousePress(const QPointF &pos, QList *items, bool isCtrlPressed) { mItemEditor->clear(); mItemResizer->grabHandle(pos); if (mItemResizer->isResizing()) { mItemResizer->hideCurrentResizer(); return; } mItemSelector->handleSelectionOrShowSelectionRectAt(pos, items, isCtrlPressed); if (mItemSelector->isSelecting()) { mItemResizer->detach(); return; } auto selectedItems = mItemSelector->selectedItems(); mItemMover->setOffset(pos, selectedItems); mItemResizer->hide(); handleSelection(); updateCursor(mItemMover->cursor()); } void AnnotationItemModifier::handleMouseMove(const QPointF &pos, bool isCtrlPressed) { if (mItemResizer->isResizing()) { mItemResizer->moveHandle(pos, isCtrlPressed); updateCursor(mItemResizer->cursorForCurrentHandle()); } else if (mItemSelector->isSelecting()) { mItemSelector->extendSelectionRectWhenShown(pos); } else { mItemMover->moveItems(pos); mItemSelector->refresh(); } } void AnnotationItemModifier::handleMouseRelease(QList *items) { if (mItemResizer->isResizing()) { mItemResizer->releaseHandle(); mItemResizer->showCurrentResizer(); } else if (mItemSelector->isSelecting()) { mItemSelector->finishSelectionRectWhenShown(items); } else { mItemMover->clearOffset(); mItemResizer->show(); updateCursor(mItemMover->cursor()); } handleSelection(); } void AnnotationItemModifier::handleMouseDoubleClick(const QPointF &pos, QList *items) { mItemEditor->handleEditAt(pos, items); if (mItemEditor->isEditing()) { clear(); } } void AnnotationItemModifier::handleSelectionAt(const QPointF &pos, QList *items, bool isCtrlPressed) { mItemSelector->handleSelectionAt(pos, items, isCtrlPressed); handleSelection(); } QList AnnotationItemModifier::selectedItems() const { return mItemSelector->selectedItems(); } QRectF AnnotationItemModifier::boundingRect() const { if (mItemResizer->hasItemsAttached()) { return mItemResizer->boundingRect(); } return mItemSelector->boundingRect(); } void AnnotationItemModifier::selectItem(AbstractAnnotationItem *item) { mItemSelector->selectItem(item); handleSelection(); } void AnnotationItemModifier::clear() { mItemSelector->clearSelection(); mItemResizer->detach(); } void AnnotationItemModifier::updateSelection() { mItemSelector->update(); mItemResizer->update(); mItemResizer->refresh(); } void AnnotationItemModifier::mousePressEvent(QGraphicsSceneMouseEvent *event) { Q_UNUSED(event) // Move Cursor disappears when we let this event propagate } void AnnotationItemModifier::hoverMoveEvent(QGraphicsSceneHoverEvent *event) { if (mItemMover->isMoving()) { return; } updateCursor(mItemResizer->cursorForPos(event->scenePos())); QGraphicsItemGroup::hoverMoveEvent(event); } void AnnotationItemModifier::handleSelection() { auto selectedItems = mItemSelector->selectedItems(); auto count = selectedItems.count(); if (count == 0) { clear(); emit itemsDeselected(); } else { mItemResizer->attachTo(selectedItems); emit itemsSelected(selectedItems); } } void AnnotationItemModifier::updateCursor(Qt::CursorShape cursor) { if (cursor == CursorHelper::defaultCursor()) { unsetCursor(); } else { setCursor(cursor); } } void AnnotationItemModifier::itemChanged(QUndoCommand *command) { emit itemModified(); emit newCommand(command); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemModifier.h000066400000000000000000000052711440330760000264710ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMMODIFIER_H #define KIMAGEANNOTATOR_ANNOTATIONITEMMODIFIER_H #include #include #include #include #include "AnnotationMultiItemResizer.h" #include "AnnotationItemSelector.h" #include "AnnotationItemMover.h" #include "AnnotationItemEditor.h" namespace kImageAnnotator { class AnnotationItemModifier : public QObject, public QGraphicsItemGroup { Q_OBJECT public: explicit AnnotationItemModifier(ZoomValueProvider *zoomValueProvider); ~AnnotationItemModifier() override; void handleMousePress(const QPointF &pos, QList *items, bool isCtrlPressed); void handleMouseMove(const QPointF &pos, bool isCtrlPressed); void handleMouseRelease(QList *items); void handleMouseDoubleClick(const QPointF &pos, QList *items); void handleSelectionAt(const QPointF &pos, QList *items, bool isCtrlPressed); QList selectedItems() const; QRectF boundingRect() const override; void selectItem(AbstractAnnotationItem *item); public slots: void clear(); void updateSelection(); signals: void newCommand(QUndoCommand *command); void itemsSelected(const QList &items) const; void itemsDeselected(); void itemModified() const; void itemEdit(); protected: void mousePressEvent(QGraphicsSceneMouseEvent *event) override; void hoverMoveEvent(QGraphicsSceneHoverEvent *event) override; private: AnnotationMultiItemResizer *mItemResizer; AnnotationItemSelector *mItemSelector; AnnotationItemMover *mItemMover; AnnotationItemEditor *mItemEditor; void handleSelection(); void updateCursor(Qt::CursorShape cursor); private slots: void itemChanged(QUndoCommand *command); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONITEMMODIFIER_H kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemMover.cpp000066400000000000000000000032561440330760000263570ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemMover.h" namespace kImageAnnotator { void AnnotationItemMover::setOffset(const QPointF &pos, const QList &selectedItems) { for (auto item : selectedItems) { mItemToOffset[item] = QPointF(pos - item->position()); } } void AnnotationItemMover::moveItems(const QPointF &pos) { QHash itemToNewPos; for (auto item : mItemToOffset.keys()) { if (item != nullptr) { itemToNewPos[item] = pos - mItemToOffset[item]; } } emit newCommand(new MoveCommand(itemToNewPos)); } void AnnotationItemMover::clearOffset() { mItemToOffset.clear(); } bool AnnotationItemMover::isMoving() { return !mItemToOffset.isEmpty(); } Qt::CursorShape AnnotationItemMover::cursor() { if (isMoving()) { return CursorHelper::movingCursor(); } else { return CursorHelper::defaultCursor(); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemMover.h000066400000000000000000000032301440330760000260140ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMMOVER_H #define KIMAGEANNOTATOR_ANNOTATIONITEMMOVER_H #include #include #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/annotations/undo/MoveCommand.h" #include "src/common/helper/CursorHelper.h" namespace kImageAnnotator { class AnnotationItemMover : public QObject { Q_OBJECT public: explicit AnnotationItemMover() = default; ~AnnotationItemMover() override = default; void setOffset(const QPointF &pos, const QList &selectedItems); void moveItems(const QPointF &pos); void clearOffset(); bool isMoving(); Qt::CursorShape cursor(); signals: void newCommand(MoveCommand *move) const; private: QHash mItemToOffset; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONITEMMOVER_H kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemResizer.cpp000066400000000000000000000062051440330760000267070ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemResizer.h" namespace kImageAnnotator { AnnotationItemResizer::AnnotationItemResizer(AbstractAnnotationItem *item, ZoomValueProvider *zoomValueProvider) : mAnnotationItem(item), mZoomValueProvider(zoomValueProvider), mCurrentHandle(-1) { mResizeHandles = ResizeHandlesFactory::createResizeHandles(item, zoomValueProvider->zoomValue()); connect(zoomValueProvider, &ZoomValueProvider::zoomValueChanged, this, &AnnotationItemResizer::applyZoomValue); prepareGeometryChange(); } AnnotationItemResizer::~AnnotationItemResizer() { mAnnotationItem = nullptr; delete mResizeHandles; } QRectF AnnotationItemResizer::boundingRect() const { auto size = mResizeHandles->handleSize() / 2; return mAnnotationItem->boundingRect().normalized().adjusted(-size, -size, size, size); } void AnnotationItemResizer::grabHandle(const QPointF &pos) { mCurrentHandle = mResizeHandles->indexOfHandleAt(pos); if (mCurrentHandle != -1) { mClickOffset = pos - mResizeHandles->handle(mCurrentHandle).anchor(); } } void AnnotationItemResizer::moveHandle(const QPointF &pos, bool isCtrlPressed) { if (mCurrentHandle != -1) { emit newCommand(new ResizeCommand(mAnnotationItem, mCurrentHandle, pos - mClickOffset, isCtrlPressed)); } } void AnnotationItemResizer::releaseHandle() { mCurrentHandle = -1; } bool AnnotationItemResizer::isResizing() const { return mCurrentHandle != -1; } void AnnotationItemResizer::refresh() { prepareGeometryChange(); mResizeHandles->update(); } bool AnnotationItemResizer::isItemVisible() const { return mAnnotationItem != nullptr && mAnnotationItem->isVisible(); } Qt::CursorShape AnnotationItemResizer::cursorForPos(const QPointF &pos) { return mResizeHandles->cursorForPos(pos); } Qt::CursorShape AnnotationItemResizer::cursorForCurrentHandle() { return mResizeHandles->cursorForHandle(mCurrentHandle); } void AnnotationItemResizer::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) { painter->setPen(QPen(Qt::white, 1.0 / mZoomValueProvider->zoomValue())); painter->setBrush(Qt::gray); auto handles = mResizeHandles->handles(); for (auto &handle : handles) { painter->drawRect(handle); } } void AnnotationItemResizer::applyZoomValue(double value) { mResizeHandles->applyZoomValue(value); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemResizer.h000066400000000000000000000041601440330760000263520ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMRESIZER_H #define KIMAGEANNOTATOR_ANNOTATIONITEMRESIZER_H #include #include "resizeHandles/ResizeHandlesFactory.h" #include "src/annotations/undo/ResizeCommand.h" #include "src/annotations/core/ZoomValueProvider.h" namespace kImageAnnotator { class AnnotationItemResizer : public QGraphicsWidget { Q_OBJECT public: AnnotationItemResizer(AbstractAnnotationItem *item, ZoomValueProvider *zoomValueProvider); ~AnnotationItemResizer() override; QRectF boundingRect() const override; void grabHandle(const QPointF &pos); void moveHandle(const QPointF &pos, bool isCtrlPressed); void releaseHandle(); bool isResizing() const; void refresh(); bool isItemVisible() const; Qt::CursorShape cursorForPos(const QPointF &pos); Qt::CursorShape cursorForCurrentHandle(); signals: void newCommand(ResizeCommand *resize) const; protected: void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; private: AbstractItemResizeHandles *mResizeHandles; AbstractAnnotationItem *mAnnotationItem; ZoomValueProvider *mZoomValueProvider; int mCurrentHandle; QPointF mClickOffset; void applyZoomValue(double value); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONITEMRESIZER_H kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemSelector.cpp000066400000000000000000000124651440330760000270510ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemSelector.h" namespace kImageAnnotator { AnnotationItemSelector::AnnotationItemSelector(ZoomValueProvider *zoomValueProvider) { mSelectedItems = new QList(); mShowSelectionRect = false; mSelectionPen.setStyle(Qt::DashLine); mSelectionPen.setColor(Qt::gray); applyZoomValue(zoomValueProvider->zoomValue()); connect(zoomValueProvider, &ZoomValueProvider::zoomValueChanged, this, &AnnotationItemSelector::applyZoomValue); } AnnotationItemSelector::~AnnotationItemSelector() { delete mSelectedItems; } QRectF AnnotationItemSelector::boundingRect() const { if (isSelecting()) { return mSelectionRect.normalized(); } else { return mSelectedItemsBoundingRect; } } void AnnotationItemSelector::handleSelectionOrShowSelectionRectAt(const QPointF &pos, QList *items, bool isModifying) { handleSelectionAt(pos, items, isModifying); if (mSelectedItems->count() > 0) { return; } initSelectionRectAt(pos); mShowSelectionRect = true; } void AnnotationItemSelector::handleSelectionAt(const QPointF &pos, QList *items, bool modifying) { prepareGeometryChange(); if (modifying) { toggleItemSelectionAt(pos, items); } else { selectItemAt(pos, items); } } void AnnotationItemSelector::extendSelectionRectWhenShown(const QPointF &pos) { if (!mShowSelectionRect) { return; } prepareGeometryChange(); updateSelectionRect(pos); } void AnnotationItemSelector::finishSelectionRectWhenShown(QList *items) { if (!mShowSelectionRect) { return; } prepareGeometryChange(); mShowSelectionRect = false; selectItemsUnderRect(items); } void AnnotationItemSelector::clearSelection() { prepareGeometryChange(); mSelectedItems->clear(); mSelectedItemsBoundingRect = QRectF(); } QList AnnotationItemSelector::selectedItems() const { return *mSelectedItems; } bool AnnotationItemSelector::isSelecting() const { return mShowSelectionRect; } void AnnotationItemSelector::refresh() { prepareGeometryChange(); mSelectedItemsBoundingRect = QRectF(); for (auto item : *mSelectedItems) { mSelectedItemsBoundingRect = mSelectedItemsBoundingRect.united(item->boundingRect()); } } void AnnotationItemSelector::update() { for (auto item : *mSelectedItems) { if (!item->isVisible()) { unselectItem(item); } } } void AnnotationItemSelector::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { Q_UNUSED(option) Q_UNUSED(widget) if (mShowSelectionRect) { painter->setPen(QPen(Qt::darkBlue, mSelectionPen.widthF())); painter->setBrush(QColor(0, 0, 255, 60)); painter->drawRect(mSelectionRect); } painter->setPen(mSelectionPen); painter->setBrush(Qt::NoBrush); for (auto item : *mSelectedItems) { painter->drawRect(item->boundingRect()); } } void AnnotationItemSelector::initSelectionRectAt(const QPointF &position) { mSelectionRect.setTopLeft(position); updateSelectionRect(position); } void AnnotationItemSelector::updateSelectionRect(const QPointF &position) { mSelectionRect.setBottomRight(position); } void AnnotationItemSelector::selectItemAt(const QPointF &position, QList *items) { auto item = findItemAt(position, items); if (item == nullptr) { clearSelection(); return; } if (!mSelectedItems->contains(item)) { clearSelection(); selectItem(item); } } void AnnotationItemSelector::toggleItemSelectionAt(const QPointF &position, QList *items) { auto item = findItemAt(position, items); if (item == nullptr) { clearSelection(); return; } if (mSelectedItems->contains(item)) { unselectItem(item); } else { selectItem(item); } } void AnnotationItemSelector::selectItemsUnderRect(QList *items) { clearSelection(); for (auto item : *items) { if (item->intersects(mSelectionRect)) { selectItem(item); } } } void AnnotationItemSelector::selectItem(AbstractAnnotationItem *item) { mSelectedItems->append(item); refresh(); } void AnnotationItemSelector::unselectItem(AbstractAnnotationItem *item) { mSelectedItems->removeOne(item); refresh(); } AbstractAnnotationItem *AnnotationItemSelector::findItemAt(const QPointF &position, QList *items) { QRectF rect(position - QPointF(2, 2), QSize(4, 4)); for (auto item : *items) { if (item->intersects(rect)) { return item; } } return nullptr; } void AnnotationItemSelector::applyZoomValue(double value) { mSelectionPen.setWidthF(1.0 / value); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationItemSelector.h000066400000000000000000000052541440330760000265140ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMSELECTOR_H #define KIMAGEANNOTATOR_ANNOTATIONITEMSELECTOR_H #include #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/annotations/core/ZoomValueProvider.h" namespace kImageAnnotator { class AnnotationItemSelector : public QGraphicsWidget { public: explicit AnnotationItemSelector(ZoomValueProvider *zoomValueProvider); ~AnnotationItemSelector() override; QRectF boundingRect() const override; void handleSelectionOrShowSelectionRectAt(const QPointF &pos, QList *items, bool isModifying); void extendSelectionRectWhenShown(const QPointF &pos); void finishSelectionRectWhenShown(QList *items); void handleSelectionAt(const QPointF &pos, QList *items, bool modifying); void clearSelection(); QList selectedItems() const; bool isSelecting() const; void refresh(); void update(); void selectItem(AbstractAnnotationItem *item); protected: void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; private: QRectF mSelectionRect; QRectF mSelectedItemsBoundingRect; QList *mSelectedItems; bool mShowSelectionRect; QPen mSelectionPen; void initSelectionRectAt(const QPointF &position); void updateSelectionRect(const QPointF &position); void selectItemAt(const QPointF &position, QList *items); void toggleItemSelectionAt(const QPointF &position, QList *items); void selectItemsUnderRect(QList *items); void unselectItem(AbstractAnnotationItem *item); AbstractAnnotationItem *findItemAt(const QPointF &position, QList *items); void applyZoomValue(double value); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONITEMSELECTOR_H kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationMultiItemResizer.cpp000066400000000000000000000107601440330760000277230ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationMultiItemResizer.h" namespace kImageAnnotator { AnnotationMultiItemResizer::AnnotationMultiItemResizer(ZoomValueProvider *zoomValueProvider) { mZoomValueProvider = zoomValueProvider; mCurrentResizer = nullptr; } QRectF AnnotationMultiItemResizer::boundingRect() const { QRectF rect; for (auto resizer : childItems()) { rect = rect.united(resizer->boundingRect()); } return rect; } void AnnotationMultiItemResizer::attachTo(const QList& items) { detach(); for (auto item : items) { auto resizer = getResizerForItem(item); showResizer(resizer); } } void AnnotationMultiItemResizer::detach() { for (auto resizer : childItems()) { hideResizer(resizer); } mCurrentResizer = nullptr; } void AnnotationMultiItemResizer::grabHandle(const QPointF &pos) { for (auto item : childItems()) { auto resizer = castToResizer(item); resizer->grabHandle(pos); if (resizer->isResizing()) { mCurrentResizer = resizer; return; } } mCurrentResizer = nullptr; } void AnnotationMultiItemResizer::moveHandle(const QPointF &pos, bool isCtrlPressed) { if (mCurrentResizer == nullptr) { return; } mCurrentResizer->moveHandle(pos, isCtrlPressed); } void AnnotationMultiItemResizer::releaseHandle() { if (mCurrentResizer == nullptr) { return; } mCurrentResizer->releaseHandle(); } bool AnnotationMultiItemResizer::isResizing() const { return mCurrentResizer != nullptr && mCurrentResizer->isResizing(); } void AnnotationMultiItemResizer::refresh() { for (auto item : childItems()) { auto resizer = castToResizer(item); resizer->refresh(); } } void AnnotationMultiItemResizer::update() { for (auto item : childItems()) { auto resizer = castToResizer(item); if (!resizer->isItemVisible()) { hideResizer(resizer); } } } bool AnnotationMultiItemResizer::hasItemsAttached() const { return childItems().count() > 0; } Qt::CursorShape AnnotationMultiItemResizer::cursorForPos(const QPointF &pos) { for (auto item : childItems()) { auto resizer = castToResizer(item); if (resizer->boundingRect().contains(pos)) { return resizer->cursorForPos(pos); } } return CursorHelper::defaultCursor(); } Qt::CursorShape AnnotationMultiItemResizer::cursorForCurrentHandle() { if (mCurrentResizer == nullptr) { return CursorHelper::defaultCursor(); } return mCurrentResizer->cursorForCurrentHandle(); } void AnnotationMultiItemResizer::hideCurrentResizer() { if (mCurrentResizer == nullptr) { return; } mCurrentResizer->hide(); } void AnnotationMultiItemResizer::showCurrentResizer() { if (mCurrentResizer == nullptr) { return; } mCurrentResizer->show(); } AnnotationItemResizer *AnnotationMultiItemResizer::getResizerForItem(AbstractAnnotationItem *item) { if (!mItemToResizer.contains(item)) { mItemToResizer[item] = new AnnotationItemResizer(item, mZoomValueProvider); connect(mItemToResizer[item], &AnnotationItemResizer::newCommand, this, &AnnotationMultiItemResizer::newCommand); } return mItemToResizer[item]; } void AnnotationMultiItemResizer::hideResizer(QGraphicsItem *resizer) { removeFromGroup(resizer); resizer->hide(); } void AnnotationMultiItemResizer::showResizer(AnnotationItemResizer *resizer) { addToGroup(resizer); resizer->refresh(); resizer->show(); } AnnotationItemResizer *AnnotationMultiItemResizer::castToResizer(QGraphicsItem *item) { return dynamic_cast(item); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/AnnotationMultiItemResizer.h000066400000000000000000000045101440330760000273640ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONMULTIITEMRESIZER_H #define KIMAGEANNOTATOR_ANNOTATIONMULTIITEMRESIZER_H #include #include #include "AnnotationItemResizer.h" namespace kImageAnnotator { class ZoomValueProvider; class AnnotationMultiItemResizer : public QObject, public QGraphicsItemGroup { Q_OBJECT public: explicit AnnotationMultiItemResizer(ZoomValueProvider *zoomValueProvider); ~AnnotationMultiItemResizer() override = default; QRectF boundingRect() const override; void attachTo(const QList& items); void detach(); void grabHandle(const QPointF &pos); void moveHandle(const QPointF &pos, bool isCtrlPressed); void releaseHandle(); bool isResizing() const; void refresh(); void update(); bool hasItemsAttached() const; Qt::CursorShape cursorForPos(const QPointF &pos); Qt::CursorShape cursorForCurrentHandle(); void hideCurrentResizer(); void showCurrentResizer(); signals: void newCommand(ResizeCommand *resize) const; private: ZoomValueProvider *mZoomValueProvider; QHash mItemToResizer; AnnotationItemResizer *mCurrentResizer; AnnotationItemResizer *getResizerForItem(AbstractAnnotationItem *item); void showResizer(AnnotationItemResizer *resizer); void hideResizer(QGraphicsItem *resizer); static AnnotationItemResizer *castToResizer(QGraphicsItem *item) ; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONMULTIITEMRESIZER_H kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/000077500000000000000000000000001440330760000245035ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/AbstractItemResizeHandles.cpp000066400000000000000000000047501440330760000322600ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractItemResizeHandles.h" namespace kImageAnnotator { AbstractItemResizeHandles::AbstractItemResizeHandles() { } int AbstractItemResizeHandles::indexOfHandleAt(const QPointF &pos) const { for (auto handle : mHandles) { if (handle.contains(pos)) { return mHandles.indexOf(handle); } } return -1; } int AbstractItemResizeHandles::indexOfHandleWithAnchorAt(const QPointF &pos) const { for (auto handle : mHandles) { if (handle.anchor() == pos) { return mHandles.indexOf(handle); } } return -1; } ResizeHandle AbstractItemResizeHandles::handle(int index) const { if (index < 0 || index >= mHandles.count()) { return ResizeHandle(); } return mHandles[index]; } QList AbstractItemResizeHandles::handles() const { return mHandles; } Qt::CursorShape AbstractItemResizeHandles::cursorForPos(const QPointF &pos) const { auto index = indexOfHandleAt(pos); return cursorForHandle(index); } Qt::CursorShape AbstractItemResizeHandles::cursorForHandle(int index) const { if (index == -1 || mCursors.isEmpty()) { return CursorHelper::defaultCursor(); } return mCursors[index]; } void AbstractItemResizeHandles::initHandles(int count, double zoomValue) { mHandles.clear(); for (auto i = 0; i < count; i++) { mHandles.append(ResizeHandle(zoomValue)); } } double AbstractItemResizeHandles::handleSize() const { return mHandles.empty() ? 0.0 : mHandles.first().handleSize(); } void AbstractItemResizeHandles::applyZoomValue(double value) { for (auto &handle : mHandles) { handle.applyZoomValue(value); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/AbstractItemResizeHandles.h000066400000000000000000000036021440330760000317200ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTITEMRESIZEHANDLES_H #define KIMAGEANNOTATOR_ABSTRACTITEMRESIZEHANDLES_H #include "ResizeHandle.h" #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/common/helper/CursorHelper.h" namespace kImageAnnotator { class AbstractItemResizeHandles { public: AbstractItemResizeHandles(); virtual ~AbstractItemResizeHandles() = default; virtual void update() = 0; virtual int indexOfHandleAt(const QPointF &pos) const; virtual int indexOfHandleWithAnchorAt(const QPointF &pos) const; virtual ResizeHandle handle(int index) const; virtual QList handles() const; virtual Qt::CursorShape cursorForPos(const QPointF &pos) const; virtual Qt::CursorShape cursorForHandle(int index) const; double handleSize() const; void applyZoomValue(double value); protected: QList mHandles; QList mCursors; virtual void initHandles(int count, double zoomValue); virtual void initCursors() = 0; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTITEMRESIZEHANDLES_H kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/AbstractRectResizeHandles.cpp000066400000000000000000000060721440330760000322560ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractRectResizeHandles.h" namespace kImageAnnotator { void AbstractRectResizeHandles::update() { auto rect = getRect(); auto offset = getOffset(); mHandles[0].moveCenter(ShapeHelper::rectTopLeftWithOffset(rect, offset)); mHandles[0].setAnchor(rect.topLeft()); mHandles[1].moveCenter(ShapeHelper::rectTopWithOffset(rect, offset)); mHandles[1].setAnchor(ShapeHelper::rectTop(rect)); mHandles[2].moveCenter(ShapeHelper::rectTopRightWithOffset(rect, offset)); mHandles[2].setAnchor(rect.topRight()); mHandles[3].moveCenter(ShapeHelper::rectRightWithOffset(rect, offset)); mHandles[3].setAnchor(ShapeHelper::rectRight(rect)); mHandles[4].moveCenter(ShapeHelper::rectBottomRightWithOffset(rect, offset)); mHandles[4].setAnchor(rect.bottomRight()); mHandles[5].moveCenter(ShapeHelper::rectBottomWithOffset(rect, offset)); mHandles[5].setAnchor(ShapeHelper::rectBottom(rect)); mHandles[6].moveCenter(ShapeHelper::rectBottomLeftWithOffset(rect, offset)); mHandles[6].setAnchor(rect.bottomLeft()); mHandles[7].moveCenter(ShapeHelper::rectLeftWithOffset(rect, offset)); mHandles[7].setAnchor(ShapeHelper::rectLeft(rect)); updateRectCursors(); } void AbstractRectResizeHandles::initCursors() { mCursors.clear(); mCursors.append(CursorHelper::fDiagResizeCursor()); mCursors.append(CursorHelper::verticalResizeCursor()); mCursors.append(CursorHelper::bDiagResizeCursor()); mCursors.append(CursorHelper::horizontalResizeCursor()); mCursors.append(CursorHelper::fDiagResizeCursor()); mCursors.append(CursorHelper::verticalResizeCursor()); mCursors.append(CursorHelper::bDiagResizeCursor()); mCursors.append(CursorHelper::horizontalResizeCursor()); } void AbstractRectResizeHandles::updateRectCursors() { if (mCursors.isEmpty()) { return; } auto rect = getItemBoundingRect(); mCursors[indexOfHandleWithAnchorAt(rect.topLeft())] = CursorHelper::fDiagResizeCursor(); mCursors[indexOfHandleWithAnchorAt(rect.topRight())] = CursorHelper::bDiagResizeCursor(); mCursors[indexOfHandleWithAnchorAt(rect.bottomRight())] = CursorHelper::fDiagResizeCursor(); mCursors[indexOfHandleWithAnchorAt(rect.bottomLeft())] = CursorHelper::bDiagResizeCursor(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/AbstractRectResizeHandles.h000066400000000000000000000030661440330760000317230ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTRECTRESIZEHANDLES_H #define KIMAGEANNOTATOR_ABSTRACTRECTRESIZEHANDLES_H #include "AbstractItemResizeHandles.h" #include "src/annotations/items/AbstractAnnotationRect.h" #include "src/common/helper/ShapeHelper.h" namespace kImageAnnotator { class AbstractRectResizeHandles : public AbstractItemResizeHandles { public: AbstractRectResizeHandles() = default; ~AbstractRectResizeHandles() override = default; void update() override; protected: void initCursors() override; virtual QRectF getRect() const = 0; virtual double getOffset() const = 0; virtual QRectF getItemBoundingRect() const = 0; private: void updateRectCursors(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTRECTRESIZEHANDLES_H kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/LineResizeHandles.cpp000066400000000000000000000031341440330760000305600ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "LineResizeHandles.h" namespace kImageAnnotator { LineResizeHandles::LineResizeHandles(AbstractAnnotationLine *lineItem, double zoomValue) : mLineItem(lineItem) { initHandles(2, zoomValue); initCursors(); update(); } void LineResizeHandles::update() { auto line = mLineItem->line(); auto offset = mLineItem->properties()->width(); auto outerLine = ShapeHelper::extendLine(line, offset); mHandles[0].moveCenter(QPointF(outerLine.p1().x(), outerLine.p1().y())); mHandles[0].setAnchor(line.p1()); mHandles[1].moveCenter(QPointF(outerLine.p2().x(), outerLine.p2().y())); mHandles[1].setAnchor(line.p2()); } void LineResizeHandles::initCursors() { mCursors.clear(); mCursors.append(CursorHelper::allResizeCursor()); mCursors.append(CursorHelper::allResizeCursor()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/LineResizeHandles.h000066400000000000000000000026611440330760000302310ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_LINERESIZEHANDLES_H #define KIMAGEANNOTATOR_LINERESIZEHANDLES_H #include "AbstractItemResizeHandles.h" #include "src/annotations/items/AbstractAnnotationLine.h" #include "src/common/helper/ShapeHelper.h" namespace kImageAnnotator { class LineResizeHandles : public AbstractItemResizeHandles { public: LineResizeHandles(AbstractAnnotationLine *lineItem, double zoomValue); ~LineResizeHandles() override = default; void update() override; protected: void initCursors() override; private: AbstractAnnotationLine *mLineItem; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_LINERESIZEHANDLES_H kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/PathResizeHandles.cpp000066400000000000000000000024521440330760000305670ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "PathResizeHandles.h" namespace kImageAnnotator { PathResizeHandles::PathResizeHandles(AbstractAnnotationPath *pathItem, double zoomValue) : mPathItem(pathItem) { initHandles(8, zoomValue); initCursors(); update(); } QRectF PathResizeHandles::getRect() const { return getItemBoundingRect(); } double PathResizeHandles::getOffset() const { return 0.0; } QRectF PathResizeHandles::getItemBoundingRect() const { return mPathItem->boundingRect(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/PathResizeHandles.h000066400000000000000000000027061440330760000302360ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_PATHRESIZEHANDLES_H #define KIMAGEANNOTATOR_PATHRESIZEHANDLES_H #include "AbstractRectResizeHandles.h" #include "src/annotations/items/AbstractAnnotationPath.h" namespace kImageAnnotator { class PathResizeHandles : public AbstractRectResizeHandles { public: PathResizeHandles(AbstractAnnotationPath *pathItem, double zoomValue); ~PathResizeHandles() override = default; protected: QRectF getRect() const override; double getOffset() const override; QRectF getItemBoundingRect() const override; private: AbstractAnnotationPath *mPathItem; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_PATHRESIZEHANDLES_H kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/PointerRectResizeHandles.cpp000066400000000000000000000027001440330760000321250ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "PointerRectResizeHandles.h" namespace kImageAnnotator { PointerRectResizeHandles::PointerRectResizeHandles(AbstractAnnotationPointerRect *pointerRectItem, double zoomValue) : RectResizeHandles(pointerRectItem, zoomValue), mPointerRectItem(pointerRectItem) { initHandles(9, zoomValue); initCursors(); update(); } void PointerRectResizeHandles::update() { RectResizeHandles::update(); mHandles[8].moveCenter(mPointerRectItem->pointAt(8)); mHandles[8].setAnchor(mPointerRectItem->pointAt(8)); } void PointerRectResizeHandles::initCursors() { RectResizeHandles::initCursors(); mCursors.append(CursorHelper::allResizeCursor()); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/PointerRectResizeHandles.h000066400000000000000000000026461440330760000316030ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_POINTERRECTRESIZEHANDLES_H #define KIMAGEANNOTATOR_POINTERRECTRESIZEHANDLES_H #include "RectResizeHandles.h" #include "src/annotations/items/AbstractAnnotationPointerRect.h" namespace kImageAnnotator { class PointerRectResizeHandles : public RectResizeHandles { public: PointerRectResizeHandles(AbstractAnnotationPointerRect *pointerRectItem, double zoomValue); ~PointerRectResizeHandles() override = default; void update() override; protected: void initCursors() override; private: AbstractAnnotationPointerRect *mPointerRectItem; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_POINTERRECTRESIZEHANDLES_H kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/RectResizeHandles.cpp000066400000000000000000000024741440330760000305740ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "RectResizeHandles.h" namespace kImageAnnotator { RectResizeHandles::RectResizeHandles(AbstractAnnotationRect *rectItem, double zoomValue) : mRectItem(rectItem) { initHandles(8, zoomValue); initCursors(); update(); } QRectF RectResizeHandles::getRect() const { return mRectItem->rect(); } double RectResizeHandles::getOffset() const { return 0.5 * mRectItem->properties()->width(); } QRectF RectResizeHandles::getItemBoundingRect() const { return mRectItem->rect().normalized(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/RectResizeHandles.h000066400000000000000000000027061440330760000302370ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_RECTRESIZEHANDLES_H #define KIMAGEANNOTATOR_RECTRESIZEHANDLES_H #include "AbstractRectResizeHandles.h" #include "src/annotations/items/AbstractAnnotationRect.h" namespace kImageAnnotator { class RectResizeHandles : public AbstractRectResizeHandles { public: RectResizeHandles(AbstractAnnotationRect *rectItem, double zoomValue); ~RectResizeHandles() override = default; protected: QRectF getRect() const override; double getOffset() const override; QRectF getItemBoundingRect() const override; private: AbstractAnnotationRect *mRectItem; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_RECTRESIZEHANDLES_H kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/ResizeHandle.cpp000066400000000000000000000026771440330760000276000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ResizeHandle.h" namespace kImageAnnotator { double ResizeHandle::mDefaultHandleSize = 10.0; ResizeHandle::ResizeHandle(double zoomValue) : QRectF(0, 0, mDefaultHandleSize / zoomValue, mDefaultHandleSize / zoomValue) { } QPointF ResizeHandle::anchor() const { return center() + mOffset; } void ResizeHandle::setAnchor(const QPointF &pos) { mOffset = pos - center(); } void ResizeHandle::applyZoomValue(double value) { const auto offset = 0.5 * (handleSize() - mDefaultHandleSize / value); adjust(offset, offset, -offset, -offset); } double ResizeHandle::handleSize() const { return width(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/ResizeHandle.h000066400000000000000000000024521440330760000272340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_RESIZEHANDLE_H #define KIMAGEANNOTATOR_RESIZEHANDLE_H #include namespace kImageAnnotator { class ResizeHandle : public QRectF { public: explicit ResizeHandle(double zoomValue = 1.0); ~ResizeHandle() = default; QPointF anchor() const; void setAnchor(const QPointF &pos); void applyZoomValue(double value); double handleSize() const; private: static double mDefaultHandleSize; QPointF mOffset; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_RESIZEHANDLE_H kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/ResizeHandlesFactory.cpp000066400000000000000000000052441440330760000313040ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ResizeHandlesFactory.h" namespace kImageAnnotator { AbstractItemResizeHandles *ResizeHandlesFactory::createResizeHandles(AbstractAnnotationItem *item, double zoomValue) { auto resizeHandles = GetLineResizeHandles(item, zoomValue); if (resizeHandles != nullptr) { return resizeHandles; } resizeHandles = GetPointerRectResizeHandles(item, zoomValue); if (resizeHandles != nullptr) { return resizeHandles; } resizeHandles = GetRectResizeHandles(item, zoomValue); if (resizeHandles != nullptr) { return resizeHandles; } resizeHandles = GetPathResizeHandles(item, zoomValue); return resizeHandles; } AbstractItemResizeHandles *ResizeHandlesFactory::GetLineResizeHandles(AbstractAnnotationItem *item, double zoomValue) { auto lineItem = dynamic_cast(item); if (lineItem != nullptr) { return new LineResizeHandles(lineItem, zoomValue); } return nullptr; } AbstractItemResizeHandles *ResizeHandlesFactory::GetRectResizeHandles(AbstractAnnotationItem *item, double zoomValue) { auto rectItem = dynamic_cast(item); if (rectItem != nullptr) { return new RectResizeHandles(rectItem, zoomValue); } return nullptr; } AbstractItemResizeHandles *ResizeHandlesFactory::GetPointerRectResizeHandles(AbstractAnnotationItem *item, double zoomValue) { auto rectItem = dynamic_cast(item); if (rectItem != nullptr) { return new PointerRectResizeHandles(rectItem, zoomValue); } return nullptr; } AbstractItemResizeHandles *ResizeHandlesFactory::GetPathResizeHandles(AbstractAnnotationItem *item, double zoomValue) { auto pathItem = dynamic_cast(item); if (pathItem != nullptr) { return new PathResizeHandles(pathItem, zoomValue); } return nullptr; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/modifiers/resizeHandles/ResizeHandlesFactory.h000066400000000000000000000033131440330760000307440ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_RESIZEHANDLESFACTORY_H #define KIMAGEANNOTATOR_RESIZEHANDLESFACTORY_H #include "LineResizeHandles.h" #include "RectResizeHandles.h" #include "PathResizeHandles.h" #include "PointerRectResizeHandles.h" namespace kImageAnnotator { class ResizeHandlesFactory { public: static AbstractItemResizeHandles *createResizeHandles(AbstractAnnotationItem *item, double zoomValue); private: static AbstractItemResizeHandles *GetPathResizeHandles(AbstractAnnotationItem *item, double zoomValue); static AbstractItemResizeHandles *GetRectResizeHandles(AbstractAnnotationItem *item, double zoomValue); static AbstractItemResizeHandles *GetLineResizeHandles(AbstractAnnotationItem *item, double zoomValue); static AbstractItemResizeHandles *GetPointerRectResizeHandles(AbstractAnnotationItem *item, double zoomValue); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_RESIZEHANDLESFACTORY_H kImageAnnotator-0.6.1/src/annotations/properties/000077500000000000000000000000001440330760000221165ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/properties/AnnotationObfuscateProperties.cpp000066400000000000000000000025341440330760000306510ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationObfuscateProperties.h" namespace kImageAnnotator { AnnotationObfuscateProperties::AnnotationObfuscateProperties(const AnnotationObfuscateProperties &other) : AnnotationProperties(other), mFactor(1) { mFactor = other.mFactor; } PropertiesPtr AnnotationObfuscateProperties::clone() const { return PropertiesPtr(new AnnotationObfuscateProperties(*this)); } int AnnotationObfuscateProperties::factor() const { return mFactor; } void AnnotationObfuscateProperties::setFactor(int factor) { mFactor = factor; } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/properties/AnnotationObfuscateProperties.h000066400000000000000000000030231440330760000303100ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONOBFUSCATEPROPERTIES_H #define KIMAGEANNOTATOR_ANNOTATIONOBFUSCATEPROPERTIES_H #include "AnnotationProperties.h" namespace kImageAnnotator { class AnnotationObfuscateProperties; typedef QSharedPointer ObfuscatePropertiesPtr; class AnnotationObfuscateProperties : public AnnotationProperties { public: AnnotationObfuscateProperties() = default; AnnotationObfuscateProperties(const AnnotationObfuscateProperties &other); ~AnnotationObfuscateProperties() override = default; PropertiesPtr clone() const override; int factor() const; void setFactor(int factor); private: int mFactor; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONOBFUSCATEPROPERTIES_H kImageAnnotator-0.6.1/src/annotations/properties/AnnotationPathProperties.cpp000066400000000000000000000032241440330760000276270ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationPathProperties.h" namespace kImageAnnotator { AnnotationPathProperties::AnnotationPathProperties(const QColor &color, int size) : AnnotationProperties(color, size) { } AnnotationPathProperties::AnnotationPathProperties(const PathPropertiesPtr &other) : AnnotationProperties(other) { mSmoothPathEnabled = other->mSmoothPathEnabled; mSmoothFactor = other->mSmoothFactor; } PropertiesPtr AnnotationPathProperties::clone() const { return PropertiesPtr(new AnnotationPathProperties(*this)); } bool AnnotationPathProperties::smoothPathEnabled() const { return mSmoothPathEnabled; } void AnnotationPathProperties::setSmoothPathEnabled(bool enabled) { mSmoothPathEnabled = enabled; } int AnnotationPathProperties::smoothFactor() const { return mSmoothFactor; } void AnnotationPathProperties::setSmoothFactor(int factor) { mSmoothFactor = factor; } } kImageAnnotator-0.6.1/src/annotations/properties/AnnotationPathProperties.h000066400000000000000000000032171440330760000272760ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONPATHPROPERTIES_H #define KIMAGEANNOTATOR_ANNOTATIONPATHPROPERTIES_H #include "AnnotationProperties.h" namespace kImageAnnotator { class AnnotationPathProperties; typedef QSharedPointer PathPropertiesPtr; class AnnotationPathProperties : public AnnotationProperties { public: AnnotationPathProperties() = default; AnnotationPathProperties(const QColor &color, int size); explicit AnnotationPathProperties(const PathPropertiesPtr &other); ~AnnotationPathProperties() override = default; PropertiesPtr clone() const override; bool smoothPathEnabled() const; void setSmoothPathEnabled(bool enabled); int smoothFactor() const; void setSmoothFactor(int factor); private: bool mSmoothPathEnabled; int mSmoothFactor; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONPATHPROPERTIES_H kImageAnnotator-0.6.1/src/annotations/properties/AnnotationProperties.cpp000066400000000000000000000045071440330760000270170ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationProperties.h" namespace kImageAnnotator { AnnotationProperties::AnnotationProperties(const QColor &color, int size) : mColor(color), mTextColor(color), mWidth(size), mFillType(FillModes::BorderAndFill), mOpacity(0.5) { } AnnotationProperties::AnnotationProperties(const PropertiesPtr &other) { mColor = other->mColor; mTextColor = other->mTextColor; mWidth = other->mWidth; mFillType = other->mFillType; mShadowEnabled = other->mShadowEnabled; mOpacity = other->mOpacity; } QColor AnnotationProperties::color() const { return mColor; } void AnnotationProperties::setColor(const QColor &color) { mColor = qMove(color); } QColor AnnotationProperties::textColor() const { return mTextColor; } void AnnotationProperties::setTextColor(const QColor &color) { mTextColor = qMove(color); } int AnnotationProperties::width() const { return mWidth; } void AnnotationProperties::setWidth(int size) { mWidth = size; } FillModes AnnotationProperties::fillType() const { return mFillType; } void AnnotationProperties::setFillType(FillModes fillType) { mFillType = fillType; } bool AnnotationProperties::shadowEnabled() const { return mShadowEnabled; } void AnnotationProperties::setShadowEnabled(bool enabled) { mShadowEnabled = enabled; } qreal AnnotationProperties::opacity() const { return mOpacity; } void AnnotationProperties::setOpacity(qreal opacity) { mOpacity = opacity; } PropertiesPtr AnnotationProperties::clone() const { return PropertiesPtr(new AnnotationProperties(*this)); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/properties/AnnotationProperties.h000066400000000000000000000036331440330760000264630ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONPROPERTIES_H #define KIMAGEANNOTATOR_ANNOTATIONPROPERTIES_H #include #include #include "src/common/enum/FillModes.h" namespace kImageAnnotator { class AnnotationProperties; typedef QSharedPointer PropertiesPtr; class AnnotationProperties { public: AnnotationProperties() = default; AnnotationProperties(const QColor &color, int size); explicit AnnotationProperties(const PropertiesPtr &other); virtual ~AnnotationProperties() = default; QColor color() const; void setColor(const QColor &color); QColor textColor() const; void setTextColor(const QColor &color); int width() const; void setWidth(int size); FillModes fillType() const; void setFillType(FillModes fillType); bool shadowEnabled() const; void setShadowEnabled(bool enabled); qreal opacity() const; void setOpacity(qreal opacity); virtual PropertiesPtr clone() const; private: QColor mColor; QColor mTextColor; int mWidth; FillModes mFillType; bool mShadowEnabled{}; qreal mOpacity{}; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_ANNOTATIONPROPERTIES_H kImageAnnotator-0.6.1/src/annotations/properties/AnnotationStickerProperties.cpp000066400000000000000000000030331440330760000303350ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationStickerProperties.h" namespace kImageAnnotator { AnnotationStickerProperties::AnnotationStickerProperties(const kImageAnnotator::AnnotationStickerProperties &other) : AnnotationProperties(other) { this->mPath = other.mPath; this->mScaling = other.mScaling; } PropertiesPtr kImageAnnotator::AnnotationStickerProperties::clone() const { return PropertiesPtr(new AnnotationStickerProperties(*this)); } QString AnnotationStickerProperties::path() const { return mPath; } void AnnotationStickerProperties::setPath(const QString &path) { mPath = path; } qreal AnnotationStickerProperties::scaling() const { return mScaling; } void AnnotationStickerProperties::setScaling(qreal scaling) { mScaling = scaling; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/properties/AnnotationStickerProperties.h000066400000000000000000000030411440330760000300010ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONSTICKERPROPERTIES_H #define KIMAGEANNOTATOR_ANNOTATIONSTICKERPROPERTIES_H #include "AnnotationProperties.h" namespace kImageAnnotator { class AnnotationStickerProperties : public AnnotationProperties { public: AnnotationStickerProperties() = default; AnnotationStickerProperties(const AnnotationStickerProperties &other); ~AnnotationStickerProperties() override = default; PropertiesPtr clone() const override; QString path() const; void setPath(const QString &path); qreal scaling() const; void setScaling(qreal scaling); private: QString mPath; qreal mScaling; }; typedef QSharedPointer StickerPropertiesPtr; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONSTICKERPROPERTIES_H kImageAnnotator-0.6.1/src/annotations/properties/AnnotationTextProperties.cpp000066400000000000000000000026001440330760000276540ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTextProperties.h" namespace kImageAnnotator { AnnotationTextProperties::AnnotationTextProperties(const QColor &color, int size) : AnnotationProperties(color, size) { } AnnotationTextProperties::AnnotationTextProperties(const AnnotationTextProperties &other) : AnnotationProperties(other) { mFont = other.mFont; } PropertiesPtr AnnotationTextProperties::clone() const { return PropertiesPtr(new AnnotationTextProperties(*this)); } QFont AnnotationTextProperties::font() const { return mFont; } void AnnotationTextProperties::setFont(const QFont &font) { mFont = font; } }kImageAnnotator-0.6.1/src/annotations/properties/AnnotationTextProperties.h000066400000000000000000000030561440330760000273270ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTEXTPROPERTIES_H #define KIMAGEANNOTATOR_ANNOTATIONTEXTPROPERTIES_H #include #include "AnnotationProperties.h" namespace kImageAnnotator { class AnnotationTextProperties; typedef QSharedPointer TextPropertiesPtr; class AnnotationTextProperties : public AnnotationProperties { public: AnnotationTextProperties() = default; AnnotationTextProperties(const QColor &color, int size); AnnotationTextProperties(const AnnotationTextProperties &other); ~AnnotationTextProperties() override = default; PropertiesPtr clone() const override; QFont font() const; void setFont(const QFont &font); private: QFont mFont; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTEXTPROPERTIES_H kImageAnnotator-0.6.1/src/annotations/undo/000077500000000000000000000000001440330760000206675ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/annotations/undo/AddCommand.cpp000066400000000000000000000023161440330760000233640ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AddCommand.h" namespace kImageAnnotator { AddCommand::AddCommand(AbstractAnnotationItem *item, AnnotationArea *annotationArea) { mItem = item; mAnnotationArea = annotationArea; } void AddCommand::undo() { mAnnotationArea->removeAnnotationItem(mItem); mItem->hide(); } void AddCommand::redo() { mAnnotationArea->addAnnotationItem(mItem); mItem->show(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/AddCommand.h000066400000000000000000000026461440330760000230370ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ADDCOMMAND_H #define KIMAGEANNOTATOR_ADDCOMMAND_H #include #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class AnnotationArea; class AddCommand : public QUndoCommand { public: AddCommand(AbstractAnnotationItem *item, AnnotationArea *annotationArea); ~AddCommand() = default; virtual void undo() override; virtual void redo() override; private: AbstractAnnotationItem *mItem; AnnotationArea *mAnnotationArea; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ADDCOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/ArrangeCommand.cpp000066400000000000000000000032751440330760000242600ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ArrangeCommand.h" namespace kImageAnnotator { ArrangeCommand::ArrangeCommand(QList> itemToSwap, QList *allItems) { mItemToSwap = itemToSwap; mAllItems = allItems; } void ArrangeCommand::undo() { for (auto i = mItemToSwap.count() - 1; i >= 0; i--) { auto pair = mItemToSwap[i]; swapZValues(pair.first, pair.second); } ItemHelper::sortItemsByZValueDesc(mAllItems); } void ArrangeCommand::redo() { for (auto pair : mItemToSwap) { swapZValues(pair.first, pair.second); } ItemHelper::sortItemsByZValueDesc(mAllItems); } void ArrangeCommand::swapZValues(AbstractAnnotationItem *item1, AbstractAnnotationItem *item2) const { auto tmpZValue = item1->zValue(); item1->setZValue(item2->zValue()); item2->setZValue(tmpZValue); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/ArrangeCommand.h000066400000000000000000000031161440330760000237170ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ARRANGECOMMAND_H #define KIMAGEANNOTATOR_ARRANGECOMMAND_H #include #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/common/helper/ItemHelper.h" namespace kImageAnnotator { class ArrangeCommand : public QUndoCommand { public: ArrangeCommand(QList> itemToSwap, QList *allItems); virtual void undo() override; virtual void redo() override; private: QList> mItemToSwap; QList *mAllItems; void swapZValues(AbstractAnnotationItem *item1, AbstractAnnotationItem *item2) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ARRANGECOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/ChangePropertiesCommand.cpp000066400000000000000000000023621440330760000261370ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ChangePropertiesCommand.h" namespace kImageAnnotator { ChangePropertiesCommand::ChangePropertiesCommand(AbstractAnnotationItem *item, const PropertiesPtr &properties) { mItem = item; mNewProperties = properties; mOldProperties = mItem->properties(); } void ChangePropertiesCommand::undo() { mItem->setProperties(mOldProperties); } void ChangePropertiesCommand::redo() { mItem->setProperties(mNewProperties); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/undo/ChangePropertiesCommand.h000066400000000000000000000027561440330760000256130ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CHANGEPROPERTIESCOMMAND_H #define KIMAGEANNOTATOR_CHANGEPROPERTIESCOMMAND_H #include #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/annotations/properties/AnnotationProperties.h" namespace kImageAnnotator { class ChangePropertiesCommand : public QUndoCommand { public: ChangePropertiesCommand(AbstractAnnotationItem *item, const PropertiesPtr &properties); ~ChangePropertiesCommand() override = default; void undo() override; void redo() override; private: AbstractAnnotationItem *mItem; PropertiesPtr mNewProperties; PropertiesPtr mOldProperties; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CHANGEPROPERTIESCOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/CropCommand.cpp000066400000000000000000000036131440330760000236000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CropCommand.h" namespace kImageAnnotator { CropCommand::CropCommand(QGraphicsPixmapItem *backgroundImage, const QRectF &cropRect, AnnotationArea *annotationArea) : mAnnotationArea(annotationArea), mBackgroundImage(backgroundImage), mOriginalImage(backgroundImage->pixmap()), mCroppedImage(mOriginalImage.copy(cropRect.toRect())), mNewItemOffset(cropRect.topLeft()) { } void CropCommand::undo() { for (auto item : mAnnotationArea->items()) { auto baseItem = dynamic_cast(item); if (baseItem != nullptr) { baseItem->setPosition(baseItem->position() + mNewItemOffset); } } mBackgroundImage->setPixmap(mOriginalImage); mAnnotationArea->setSceneRect(mBackgroundImage->boundingRect()); } void CropCommand::redo() { for (auto item : mAnnotationArea->items()) { auto baseItem = dynamic_cast(item); if (baseItem != nullptr) { baseItem->setPosition(baseItem->position() - mNewItemOffset); } } mBackgroundImage->setPixmap(mCroppedImage); mAnnotationArea->setSceneRect(mBackgroundImage->boundingRect()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/CropCommand.h000066400000000000000000000026641440330760000232520ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPCOMMAND_H #define KIMAGEANNOTATOR_CROPCOMMAND_H #include #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class CropCommand : public QUndoCommand { public: CropCommand(QGraphicsPixmapItem *backgroundImage, const QRectF &cropRect, AnnotationArea *annotationArea); ~CropCommand() override = default; void undo() override; void redo() override; private: AnnotationArea *mAnnotationArea; QPixmap mOriginalImage; QPixmap mCroppedImage; QGraphicsPixmapItem *mBackgroundImage; QPointF mNewItemOffset; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CROPCOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/CutCommand.cpp000066400000000000000000000047031440330760000234310ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CutCommand.h" namespace kImageAnnotator { CutCommand::CutCommand(QGraphicsPixmapItem *backgroundImage, const QRectF &cutOutRect, AnnotationArea *annotationArea) : mAnnotationArea(annotationArea), mBackgroundImage(backgroundImage), mOriginalImage(backgroundImage->pixmap()) { auto imageRect = backgroundImage->boundingRect(); if(isVerticalCut(cutOutRect, imageRect)) { createCutImage(imageRect, cutOutRect.bottomLeft(), cutOutRect.topRight(), cutOutRect.topLeft()); } else { createCutImage(imageRect, cutOutRect.topRight(), cutOutRect.bottomLeft(), cutOutRect.topLeft()); } } void CutCommand::undo() { mBackgroundImage->setPixmap(mOriginalImage); mAnnotationArea->setSceneRect(mBackgroundImage->boundingRect()); } void CutCommand::redo() { mBackgroundImage->setPixmap(mCutImage); mAnnotationArea->setSceneRect(mBackgroundImage->boundingRect()); } bool CutCommand::isVerticalCut(const QRectF &cutOutRect, const QRectF &imageRect) const { return imageRect.top() == cutOutRect.top() && imageRect.bottom() == cutOutRect.bottom(); } void CutCommand::createCutImage(const QRectF &imageRect, const QPointF &bottomRightRect1, const QPointF &topLeftRect2, const QPointF &connectionPoint) { auto rect1 = QRectF(imageRect.topLeft(), bottomRightRect1); auto rect2 = QRectF(topLeftRect2, imageRect.bottomRight()); auto image1 = mOriginalImage.copy(rect1.toRect()); auto image2 = mOriginalImage.copy(rect2.toRect()); rect2.moveTopLeft(connectionPoint); mCutImage = QPixmap(rect1.united(rect2).size().toSize()); QPainter painter(&mCutImage); painter.drawPixmap(rect1.topLeft(), image1); painter.drawPixmap(rect2.topLeft(), image2); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/CutCommand.h000066400000000000000000000032031440330760000230700ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUTCOMMAND_H #define KIMAGEANNOTATOR_CUTCOMMAND_H #include #include #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class CutCommand : public QUndoCommand { public: CutCommand(QGraphicsPixmapItem *backgroundImage, const QRectF &cutOutRect, AnnotationArea *annotationArea); ~CutCommand() override = default; void undo() override; void redo() override; private: AnnotationArea *mAnnotationArea; QPixmap mOriginalImage; QPixmap mCutImage; QGraphicsPixmapItem *mBackgroundImage; bool isVerticalCut(const QRectF &cutOutRect, const QRectF &imageRect) const; void createCutImage(const QRectF &imageRect, const QPointF &bottomRightRect1, const QPointF &topLeftRect2, const QPointF &connectionPoint); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CUTCOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/DeleteCommand.cpp000066400000000000000000000024761440330760000241050ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "DeleteCommand.h" namespace kImageAnnotator { DeleteCommand::DeleteCommand(QList items, AnnotationArea *annotationArea) { mItems = items; mAnnotationArea = annotationArea; } void DeleteCommand::undo() { for (auto item : mItems) { mAnnotationArea->addAnnotationItem(item); item->show(); } } void DeleteCommand::redo() { for (auto item : mItems) { mAnnotationArea->removeAnnotationItem(item); item->hide(); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/DeleteCommand.h000066400000000000000000000026521440330760000235460ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_DELETECOMMAND_H #define KIMAGEANNOTATOR_DELETECOMMAND_H #include #include "src/annotations/items/AbstractAnnotationItem.h" #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class AnnotationArea; class DeleteCommand : public QUndoCommand { public: DeleteCommand(QList items, AnnotationArea *annotationArea); virtual void undo() override; virtual void redo() override; private: QList mItems; AnnotationArea *mAnnotationArea; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_DELETECOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/FlipCommand.cpp000066400000000000000000000030711440330760000235650ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "FlipCommand.h" namespace kImageAnnotator { FlipCommand::FlipCommand(QGraphicsPixmapItem *backgroundImage, FlipDirection direction) : mBackgroundImage(backgroundImage), mOldPixmap(backgroundImage->pixmap()) { mNewPixmap = flipPixmap(mOldPixmap, direction); } void FlipCommand::undo() { mBackgroundImage->setPixmap(mOldPixmap); } void FlipCommand::redo() { mBackgroundImage->setPixmap(mNewPixmap); } QPixmap FlipCommand::flipPixmap(const QPixmap &sourcePixmap, FlipDirection direction) { auto flipHorizontal = direction == FlipDirection::Horizontal; auto flipVertical = direction == FlipDirection::Vertical; auto flippedImage = sourcePixmap.toImage().mirrored(flipHorizontal, flipVertical); return QPixmap::fromImage(flippedImage); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/undo/FlipCommand.h000066400000000000000000000026771440330760000232450ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_FLIPCOMMAND_H #define KIMAGEANNOTATOR_FLIPCOMMAND_H #include #include #include "src/common/enum/FlipDirection.h" namespace kImageAnnotator { class FlipCommand : public QUndoCommand { public: FlipCommand(QGraphicsPixmapItem *backgroundImage, FlipDirection direction); ~FlipCommand() override = default; void undo() override; void redo() override; private: QGraphicsPixmapItem *mBackgroundImage; QPixmap mOldPixmap; QPixmap mNewPixmap; static QPixmap flipPixmap(const QPixmap &sourcePixmap, FlipDirection direction); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_FLIPCOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/ModifyCanvasCommand.cpp000066400000000000000000000031171440330760000252570ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ModifyCanvasCommand.h" namespace kImageAnnotator { ModifyCanvasCommand::ModifyCanvasCommand(const QRectF &canvasRect, const QColor &color, AnnotationArea *annotationArea) : mAnnotationArea(annotationArea), mNewCanvasColor(color), mOriginalCanvasColor(annotationArea->canvasColor()) { mOriginalCanvasRect = mAnnotationArea->isCustomCanvasRect() ? annotationArea->canvasRect() : QRectF(); mNewCanvasRect = canvasRect == annotationArea->canvasRect() ? QRectF() : canvasRect; } void ModifyCanvasCommand::undo() { mAnnotationArea->setCanvasRect(mOriginalCanvasRect); mAnnotationArea->setCanvasColor(mOriginalCanvasColor); } void ModifyCanvasCommand::redo() { mAnnotationArea->setCanvasRect(mNewCanvasRect); mAnnotationArea->setCanvasColor(mNewCanvasColor); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/undo/ModifyCanvasCommand.h000066400000000000000000000027301440330760000247240ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MODIFYCANVASCOMMAND_H #define KIMAGEANNOTATOR_MODIFYCANVASCOMMAND_H #include #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class ModifyCanvasCommand : public QUndoCommand { public: explicit ModifyCanvasCommand(const QRectF &canvasRect, const QColor &color, AnnotationArea *annotationArea); ~ModifyCanvasCommand() override = default; void undo() override; void redo() override; private: AnnotationArea *mAnnotationArea; QRectF mNewCanvasRect; QRectF mOriginalCanvasRect; QColor mNewCanvasColor; QColor mOriginalCanvasColor; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_MODIFYCANVASCOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/MoveCommand.cpp000066400000000000000000000033311440330760000236000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "MoveCommand.h" namespace kImageAnnotator { MoveCommand::MoveCommand(QHash itemToNewPos) { mNewPos = itemToNewPos; for (auto item : itemToNewPos.keys()) { mOriginalPos[item] = item->position(); } } void MoveCommand::undo() { moveItems(mOriginalPos); } void MoveCommand::redo() { moveItems(mNewPos); } bool MoveCommand::mergeWith(const QUndoCommand *command) { const auto moveCommand = dynamic_cast(command); auto mergedNewPos = moveCommand->mNewPos; if (mNewPos.keys() != mergedNewPos.keys()) { return false; } mNewPos = mergedNewPos; return true; } int MoveCommand::id() const { return Id; } void MoveCommand::moveItems(QHash &itemToPos) const { for (auto item : itemToPos.keys()) { item->setPosition(itemToPos[item]); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/MoveCommand.h000066400000000000000000000031571440330760000232530ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MOVECOMMAND_H #define KIMAGEANNOTATOR_MOVECOMMAND_H #include #include "src/annotations/items/AbstractAnnotationItem.h" namespace kImageAnnotator { class MoveCommand : public QUndoCommand { public: enum { Id = 1234 }; explicit MoveCommand(QHash itemToNewPos); ~MoveCommand() = default; virtual void undo() override; virtual void redo() override; virtual bool mergeWith(const QUndoCommand *command) override; virtual int id() const override; private: QHash mOriginalPos; QHash mNewPos; void moveItems(QHash &itemToPos) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_MOVECOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/PasteCommand.cpp000066400000000000000000000035011440330760000237450ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "PasteCommand.h" namespace kImageAnnotator { PasteCommand::PasteCommand(const QHash &itemsWithOffset, const QPointF &position, AnnotationItemFactory *itemFactory, kImageAnnotator::AnnotationArea *annotationArea) { Q_ASSERT(annotationArea != nullptr); Q_ASSERT(itemFactory != nullptr); mAnnotationArea = annotationArea; mItemFactory = itemFactory; for (auto item : itemsWithOffset.keys()) { auto pastedItem = itemFactory->clone(item); pastedItem->setPosition(position + itemsWithOffset[item]); mPastedItems.append(pastedItem); } } PasteCommand::~PasteCommand() { // Deleting with the annotation area } void PasteCommand::undo() { for (auto item : mPastedItems) { mAnnotationArea->removeAnnotationItem(item); item->hide(); } } void PasteCommand::redo() { for (auto item : mPastedItems) { mAnnotationArea->addAnnotationItem(item); item->show(); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/PasteCommand.h000066400000000000000000000027131440330760000234160ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_PASTECOMMAND_H #define KIMAGEANNOTATOR_PASTECOMMAND_H #include #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class PasteCommand : public QUndoCommand { public: PasteCommand(const QHash &itemsWithOffset, const QPointF &position, AnnotationItemFactory *itemFactory, AnnotationArea *annotationArea); ~PasteCommand(); void undo() override; void redo() override; private: AnnotationArea *mAnnotationArea; AnnotationItemFactory *mItemFactory; QVector mPastedItems; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_PASTECOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/ResizeCommand.cpp000066400000000000000000000032701440330760000241350ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ResizeCommand.h" namespace kImageAnnotator { ResizeCommand::ResizeCommand(AbstractAnnotationItem *item, int handleIndex, QPointF newPos, bool keepAspectRatio) { mItem = item; mHandleIndex = handleIndex; mNewPos = newPos; mOriginalPos = item->pointAt(handleIndex); mKeepAspectRatio = keepAspectRatio; } void ResizeCommand::undo() { mItem->setPointAt(mOriginalPos, mHandleIndex, false); } void ResizeCommand::redo() { mItem->setPointAt(mNewPos, mHandleIndex, mKeepAspectRatio); } bool ResizeCommand::mergeWith(const QUndoCommand *command) { const auto resizeCommand = dynamic_cast(command); if (mItem != resizeCommand->mItem || mHandleIndex != resizeCommand->mHandleIndex) { return false; } mNewPos = resizeCommand->mNewPos; return true; } int ResizeCommand::id() const { return Id; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/ResizeCommand.h000066400000000000000000000031301440330760000235750ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_RESIZECOMMAND_H #define KIMAGEANNOTATOR_RESIZECOMMAND_H #include #include "src/annotations/items/AbstractAnnotationItem.h" namespace kImageAnnotator { class ResizeCommand : public QUndoCommand { public: enum { Id = 1235 }; explicit ResizeCommand(AbstractAnnotationItem *item, int handleIndex, QPointF newPos, bool keepAspectRatio); ~ResizeCommand() = default; virtual void undo() override; virtual void redo() override; virtual bool mergeWith(const QUndoCommand *command) override; virtual int id() const override; private: AbstractAnnotationItem *mItem; int mHandleIndex; QPointF mNewPos; QPointF mOriginalPos; bool mKeepAspectRatio; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_RESIZECOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/RotateCommand.cpp000066400000000000000000000036241440330760000241350ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "RotateCommand.h" namespace kImageAnnotator { RotateCommand::RotateCommand(QGraphicsPixmapItem *backgroundImage, qreal angel, AnnotationArea *annotationArea) : mBackgroundImage(backgroundImage), mAnnotationArea(annotationArea), mOldPixmap(mBackgroundImage->pixmap()) { mNewPixmap = rotatePixmap(mOldPixmap, angel); } void RotateCommand::undo() { mBackgroundImage->setPixmap(mOldPixmap); mAnnotationArea->setSceneRect(mBackgroundImage->boundingRect()); } void RotateCommand::redo() { mBackgroundImage->setPixmap(mNewPixmap); mAnnotationArea->setSceneRect(mBackgroundImage->boundingRect()); } QPixmap RotateCommand::rotatePixmap(const QPixmap &sourcePixmap, qreal angel) { auto center = sourcePixmap.rect().center(); QTransform transform; transform.translate(center.x(), center.y()); transform.rotate(angel); transform.translate(-center.x(), -center.y()); auto rotatedPixmap = sourcePixmap.transformed(transform, Qt::SmoothTransformation); auto nonTransparentContentRect = QRegion(rotatedPixmap.mask()).boundingRect(); return rotatedPixmap.copy(nonTransparentContentRect); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/undo/RotateCommand.h000066400000000000000000000027611440330760000236030ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ROTATECOMMAND_H #define KIMAGEANNOTATOR_ROTATECOMMAND_H #include #include #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class RotateCommand : public QUndoCommand { public: RotateCommand(QGraphicsPixmapItem *backgroundImage, qreal angel, AnnotationArea *annotationArea); ~RotateCommand() override = default; void undo() override; void redo() override; private: QGraphicsPixmapItem *mBackgroundImage; AnnotationArea *mAnnotationArea; QPixmap mOldPixmap; QPixmap mNewPixmap; static QPixmap rotatePixmap(const QPixmap &sourcePixmap, qreal angel); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ROTATECOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/ScaleCommand.cpp000066400000000000000000000043621440330760000237260ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ScaleCommand.h" namespace kImageAnnotator { kImageAnnotator::ScaleCommand::ScaleCommand(QGraphicsPixmapItem *backgroundImage, const QSize &newSize, kImageAnnotator::AnnotationArea *annotationArea) { mAnnotationArea = annotationArea; mBackgroundImage = backgroundImage; auto currentSize = backgroundImage->boundingRect().size(); mWidthScaleFactor = (qreal) newSize.width() / currentSize.width(); mHeightScaleFactor = (qreal) newSize.height() / currentSize.height(); mOldImage = new QPixmap(backgroundImage->pixmap()); mNewImage = new QPixmap(mOldImage->scaled(newSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation)); } ScaleCommand::~ScaleCommand() { delete mOldImage; delete mNewImage; } void ScaleCommand::undo() { scaleItems(1 / mWidthScaleFactor, 1 / mHeightScaleFactor); mBackgroundImage->resetTransform(); mBackgroundImage->setPixmap(*mOldImage); mAnnotationArea->setSceneRect(mBackgroundImage->boundingRect()); } void ScaleCommand::redo() { scaleItems(mWidthScaleFactor, mHeightScaleFactor); mBackgroundImage->resetTransform(); mBackgroundImage->setPixmap(*mNewImage); mAnnotationArea->setSceneRect(mBackgroundImage->boundingRect()); } void ScaleCommand::scaleItems(qreal widthScaleFactor, qreal heightScaleFactor) { for (auto base : mAnnotationArea->items()) { auto item = dynamic_cast(base); if (item != nullptr) { item->scale(widthScaleFactor, heightScaleFactor); } } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/annotations/undo/ScaleCommand.h000066400000000000000000000027761440330760000234020ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SCALECOMMAND_H #define KIMAGEANNOTATOR_SCALECOMMAND_H #include #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class ScaleCommand : public QUndoCommand { public: ScaleCommand(QGraphicsPixmapItem *backgroundImage, const QSize &newSize, AnnotationArea *annotationArea); ~ScaleCommand(); void undo() override; void redo() override; private: AnnotationArea *mAnnotationArea; QGraphicsPixmapItem *mBackgroundImage; QPixmap *mOldImage; QPixmap *mNewImage; qreal mWidthScaleFactor; qreal mHeightScaleFactor; void scaleItems(qreal widthScaleFactor, qreal heightScaleFactor); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SCALECOMMAND_H kImageAnnotator-0.6.1/src/annotations/undo/UndoStack.cpp000066400000000000000000000015711440330760000232720ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "UndoStack.h" namespace kImageAnnotator { } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/annotations/undo/UndoStack.h000066400000000000000000000022271440330760000227360ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_UNDOSTACK_H #define KIMAGEANNOTATOR_UNDOSTACK_H #include #include "AddCommand.h" #include "DeleteCommand.h" namespace kImageAnnotator { class UndoStack : public QUndoStack { public: explicit UndoStack() = default; ~UndoStack() override = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_UNDOSTACK_H kImageAnnotator-0.6.1/src/backend/000077500000000000000000000000001440330760000167545ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/backend/Config.cpp000066400000000000000000000350661440330760000206770ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include "Config.h" namespace kImageAnnotator { Config::Config(const QSharedPointer &settings) : mSettings(settings), mSelectTool(Tools::Pen), mSmoothPathEnabled(false), mSaveToolSelection(false), mSmoothFactor(0), mSwitchToSelectToolAfterDrawingItem(true), mSelectItemAfterDrawing(true), mNumberUpdateMode(NumberUpdateMode::UpdateOnlyNewNumbers) { mAllTools = QList{ Tools::Pen, Tools::MarkerPen, Tools::MarkerRect, Tools::MarkerEllipse, Tools::Line, Tools::Arrow, Tools::DoubleArrow, Tools::Rect, Tools::Ellipse, Tools::Number, Tools::NumberPointer, Tools::NumberArrow, Tools::Text, Tools::TextPointer, Tools::TextArrow, Tools::Blur, Tools::Pixelate, Tools::Image, Tools::Sticker, Tools::Duplicate }; initGeneralSettings(); initToolSettings(); } Tools Config::selectedTool() const { return mSelectTool; } void Config::setSelectedToolType(Tools tool) { if (selectedTool() == tool) { return; } mSelectTool = tool; saveToolType(tool); } QColor Config::toolColor(Tools tool) const { return mToolToColor[tool]; } void Config::setToolColor(const QColor &color, Tools tool) { if (toolColor(tool) == color) { return; } mToolToColor[tool] = color; saveToolColor(tool, color); } QColor Config::toolTextColor(Tools tool) const { return mToolToTextColor[tool]; } void Config::setToolTextColor(const QColor &color, Tools tool) { if (toolTextColor(tool) == color) { return; } mToolToTextColor[tool] = color; saveToolTextColor(tool, color); } int Config::toolWidth(Tools tool) const { return mToolToWidth[tool]; } void Config::setToolWidth(int width, Tools tool) { if (toolWidth(tool) == width) { return; } mToolToWidth[tool] = width; saveToolWidth(tool, width); } FillModes Config::toolFillType(Tools tool) const { return mToolToFillType[tool]; } void Config::setToolFillType(FillModes fillType, Tools tool) { if (toolFillType(tool) == fillType) { return; } mToolToFillType[tool] = fillType; saveToolFillType(tool, fillType); } QFont Config::toolFont(Tools tool) const { return mToolToFont[tool]; } void Config::setToolFont(const QFont &font, Tools tool) { if (toolFont(tool) == font) { return; } mToolToFont[tool] = font; saveToolFont(tool, font); } bool Config::shadowEnabled(Tools tool) const { return mToolToShadowEnabled[tool]; } void Config::setShadowEnabled(bool enabled, Tools tool) { if (shadowEnabled(tool) == enabled) { return; } mToolToShadowEnabled[tool] = enabled; saveToolShadowEnabled(tool, enabled); } bool Config::smoothPathEnabled() const { return mSmoothPathEnabled; } void Config::setSmoothPathEnabled(bool enabled) { mSmoothPathEnabled = enabled; } void Config::setSaveToolSelection(bool enabled) { if (mSaveToolSelection == enabled) { return; } mSaveToolSelection = enabled; initToolSettings(); } int Config::smoothFactor() const { return mSmoothFactor; } void Config::setSmoothFactor(int factor) { mSmoothFactor = factor; } bool Config::switchToSelectToolAfterDrawingItem() const { return mSwitchToSelectToolAfterDrawingItem; } void Config::setSwitchToSelectToolAfterDrawingItem(bool enabled) { mSwitchToSelectToolAfterDrawingItem = enabled; } NumberUpdateMode Config::numberUpdateMode() const { return mNumberUpdateMode; } void Config::setNumberToolUpdateMode(enum NumberUpdateMode numberUpdateMode) { if (numberUpdateMode != mNumberUpdateMode) { mNumberUpdateMode = numberUpdateMode; emit numberUpdateModeChanged(numberUpdateMode); } } int Config::obfuscationFactor(Tools toolType) const { return mToolToObfuscationFactor[toolType]; } void Config::setObfuscationFactor(int factor, Tools toolType) { if (obfuscationFactor(toolType) == factor) { return; } mToolToObfuscationFactor[toolType] = factor; saveToolObfuscateFactor(toolType, factor); } QColor Config::canvasColor() const { return mCanvasColor; } void Config::setCanvasColor(const QColor &color) { mCanvasColor = color; } QByteArray Config::annotatorDockWidgetsState() const { return mSettings->value(ConfigNameHelper::annotatorDockWidgetsState(), QVariant()).toByteArray(); } void Config::setAnnotatorDockWidgetsState(const QByteArray &state) { mSettings->setValue(ConfigNameHelper::annotatorDockWidgetsState(), state); mSettings->sync(); } bool Config::selectItemAfterDrawing() const { return mSelectItemAfterDrawing; } void Config::setSelectItemAfterDrawing(bool enabled) { mSelectItemAfterDrawing = enabled; } qreal Config::toolScaling(Tools tool) const { return mToolToScaling[tool]; } void Config::setToolScaling(qreal scaling, Tools tool) { if (toolScaling(tool) == scaling) { return; } mToolToScaling[tool] = scaling; saveToolOpacity(tool, scaling); } qreal Config::toolOpacity(Tools tool) const { return mToolToOpacity[tool]; } void Config::setToolOpacity(qreal opacity, Tools tool) { if (toolOpacity(tool) == opacity) { return; } mToolToOpacity[tool] = opacity; saveToolOpacity(tool, opacity); } // Private Methods void Config::initToolSettings() { initSelectedTool(); initToolColors(); initToolTextColors(); initToolWidths(); initToolFillTypes(); initToolFonts(); initToolScaling(); initToolOpacity(); initObfuscateFactor(); initShadowEnabled(); } void Config::initSelectedTool() { mSelectTool = loadToolType(); }; void Config::initToolColors() { for (auto toolType : mAllTools) { mToolToColor[toolType] = loadToolColor(toolType); } } void Config::initToolTextColors() { for (auto toolType : mAllTools) { mToolToTextColor[toolType] = loadToolTextColor(toolType); } } void Config::initToolWidths() { for (auto toolType : mAllTools) { mToolToWidth[toolType] = loadToolWidth(toolType); } } void Config::initToolFillTypes() { for (auto toolType : mAllTools) { mToolToFillType[toolType] = loadToolFillType(toolType); } } void Config::initToolFonts() { for (auto toolType : mAllTools) { mToolToFont[toolType] = loadToolFont(toolType); } } void Config::initToolScaling() { for (auto toolType : mAllTools) { mToolToScaling[toolType] = loadToolScaling(toolType); } } void Config::initToolOpacity() { for (auto toolType : mAllTools) { mToolToOpacity[toolType] = loadToolOpacity(toolType); } } void Config::initObfuscateFactor() { for (auto toolType : mAllTools) { mToolToObfuscationFactor[toolType] = loadToolObfuscateFactor(toolType); } } void Config::initShadowEnabled() { for (auto toolType : mAllTools) { mToolToShadowEnabled[toolType] = loadToolShadowEnabled(toolType); } } void Config::initGeneralSettings() { mSaveToolSelection = false; mSmoothPathEnabled = true; mSmoothFactor = 7; mSwitchToSelectToolAfterDrawingItem = false; mSelectItemAfterDrawing = true; mNumberUpdateMode = NumberUpdateMode::UpdateOnlyNewNumbers; mCanvasColor = Qt::white; } QColor Config::loadToolColor(Tools toolType) { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::toolColor(toolType), defaultToolColor(toolType)).value(); } else { return defaultToolColor(toolType); } } void Config::saveToolColor(Tools toolType, const QColor &color) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::toolColor(toolType), color); mSettings->sync(); } } QColor Config::loadToolTextColor(Tools toolType) { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::toolTextColor(toolType), defaultToolTextColor(toolType)).value(); } else { return defaultToolTextColor(toolType); } } void Config::saveToolTextColor(Tools toolType, const QColor &color) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::toolTextColor(toolType), color); mSettings->sync(); } } int Config::loadToolWidth(Tools toolType) { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::toolWidth(toolType), defaultToolWidth(toolType)).value(); } else { return defaultToolWidth(toolType); } } void Config::saveToolWidth(Tools toolType, int size) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::toolWidth(toolType), size); mSettings->sync(); } } FillModes Config::loadToolFillType(Tools toolType) { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::toolFillType(toolType), static_cast(defaultToolFillMode(toolType))).value(); } else { return defaultToolFillMode(toolType); } } void Config::saveToolFillType(Tools toolType, FillModes fillType) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::toolFillType(toolType), static_cast(fillType)); mSettings->sync(); } } QFont Config::loadToolFont(Tools tool) const { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::toolFont(tool), defaultToolFont(tool)).value(); } else { return defaultToolFont(tool); } } void Config::saveToolFont(Tools tool, const QFont &font) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::toolFont(tool), font); mSettings->sync(); } } Tools Config::loadToolType() { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::toolType(), static_cast(defaultToolType())).value(); } else { return defaultToolType(); } } void Config::saveToolType(Tools toolType) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::toolType(), static_cast(toolType)); mSettings->sync(); } } int Config::loadToolObfuscateFactor(Tools toolType) { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::obfuscateFactor(toolType), defaultObfuscateFactor()).value(); } else { return defaultObfuscateFactor(); } } void Config::saveToolObfuscateFactor(Tools toolType, int radius) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::obfuscateFactor(toolType), radius); mSettings->sync(); } } bool Config::loadToolShadowEnabled(Tools tool) { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::shadowEnabled(tool), defaultShadowEnabled(tool)).toBool(); } else { return defaultShadowEnabled(tool); } } void Config::saveToolShadowEnabled(Tools tool, bool enabled) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::shadowEnabled(tool), enabled); mSettings->sync(); } } qreal Config::loadToolScaling(Tools tool) { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::toolScaling(tool), defaultToolScaling()).value(); } else { return defaultToolOpacity(); } } void Config::saveToolScaling(Tools tool, qreal scaling) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::toolScaling(tool), scaling); mSettings->sync(); } } qreal Config::loadToolOpacity(Tools tool) { if (mSaveToolSelection) { return mSettings->value(ConfigNameHelper::toolOpacity(tool), defaultToolOpacity()).value(); } else { return defaultToolOpacity(); } } void Config::saveToolOpacity(Tools tool, qreal opacity) { if (mSaveToolSelection) { mSettings->setValue(ConfigNameHelper::toolOpacity(tool), opacity); mSettings->sync(); } } QColor Config::defaultToolColor(Tools toolType) { switch (toolType) { case Tools::MarkerPen: case Tools::MarkerRect: case Tools::MarkerEllipse: return { Qt::yellow }; case Tools::Line: return { Qt::blue }; case Tools::Rect: return { Qt::gray }; case Tools::Text: return { Qt::black }; case Tools::Blur: case Tools::Pixelate: return { Qt::white }; case Tools::Duplicate: return { Qt::green }; default: return { Qt::red }; } } QColor Config::defaultToolTextColor(Tools toolType) { switch (toolType) { case Tools::Text: case Tools::TextPointer: case Tools::TextArrow: case Tools::Number: case Tools::NumberPointer: case Tools::NumberArrow: return { Qt::white }; default: return { Qt::blue }; } } int Config::defaultToolWidth(Tools toolType) { switch (toolType) { case Tools::MarkerPen: return 30; case Tools::Arrow: case Tools::DoubleArrow: return 6; case Tools::Number: return 5; case Tools::Text: case Tools::TextArrow: return 2; case Tools::NumberPointer: case Tools::TextPointer: case Tools::Duplicate: return 1; default: return 3; } } FillModes Config::defaultToolFillMode(Tools toolType) { switch (toolType) { case Tools::Arrow: case Tools::DoubleArrow: case Tools::Rect: case Tools::Number: case Tools::NumberPointer: case Tools::Blur: case Tools::Pixelate: case Tools::TextPointer: case Tools::Image: case Tools::Sticker: return FillModes::BorderAndFill; case Tools::MarkerRect: case Tools::MarkerEllipse: case Tools::Duplicate: return FillModes::NoBorderAndFill; case Tools::NumberArrow: case Tools::TextArrow: return FillModes::NoBorderAndNoFill; default: return FillModes::BorderAndNoFill; } } QFont Config::defaultToolFont(Tools tool) { auto textFont = QFont(QGuiApplication::font().family(), 15, QFont::Bold); auto numberFont = QFont(QGuiApplication::font().family(), 20, QFont::Bold); switch (tool) { case Tools::Number: case Tools::NumberPointer: case Tools::NumberArrow: return numberFont; case Tools::Text: case Tools::TextPointer: case Tools::TextArrow: default: return textFont; } } Tools Config::defaultToolType() { return Tools::Pen; } int Config::defaultObfuscateFactor() { return 10; } bool Config::defaultShadowEnabled(Tools tool) { switch (tool) { case Tools::Pen: case Tools::Line: case Tools::Number: case Tools::NumberPointer: case Tools::NumberArrow: case Tools::Arrow: case Tools::DoubleArrow: case Tools::Rect: case Tools::Ellipse: case Tools::Sticker: case Tools::Text: return true; case Tools::TextPointer: case Tools::TextArrow: case Tools::Blur: case Tools::Pixelate: case Tools::MarkerPen: case Tools::MarkerRect: case Tools::MarkerEllipse: case Tools::Duplicate: case Tools::Image: case Tools::Select: default: return false; } } qreal Config::defaultToolScaling() { return 1.0; } qreal Config::defaultToolOpacity() { return 1.0; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/backend/Config.h000066400000000000000000000123751440330760000203420ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CONFIG_H #define KIMAGEANNOTATOR_CONFIG_H #include #include #include #include #include #include "ISettings.h" #include "src/common/enum/Tools.h" #include "src/common/enum/FillModes.h" #include "src/common/enum/NumberUpdateMode.h" #include "src/common/helper/ConfigNameHelper.h" namespace kImageAnnotator { class Config : public QObject { Q_OBJECT public: explicit Config(const QSharedPointer &settings); ~Config() override = default; public slots: Tools selectedTool() const; void setSelectedToolType(Tools tool); QColor toolColor(Tools tool) const; void setToolColor(const QColor &color, Tools tool); QColor toolTextColor(Tools tool) const; void setToolTextColor(const QColor &color, Tools tool); int toolWidth(Tools tool) const; void setToolWidth(int width, Tools tool); FillModes toolFillType(Tools tool) const; void setToolFillType(FillModes fillType, Tools tool); QFont toolFont(Tools tool) const; void setToolFont(const QFont &font, Tools tool); bool shadowEnabled(Tools tool) const; void setShadowEnabled(bool enabled, Tools tool); bool smoothPathEnabled() const; void setSmoothPathEnabled(bool enabled); void setSaveToolSelection(bool enabled); int smoothFactor() const; void setSmoothFactor(int factor); bool switchToSelectToolAfterDrawingItem() const; void setSwitchToSelectToolAfterDrawingItem(bool enabled); NumberUpdateMode numberUpdateMode() const; void setNumberToolUpdateMode(enum NumberUpdateMode numberUpdateMode); int obfuscationFactor(Tools toolType) const; void setObfuscationFactor(int factor, Tools toolType); QColor canvasColor() const; void setCanvasColor(const QColor &color); QByteArray annotatorDockWidgetsState() const; void setAnnotatorDockWidgetsState(const QByteArray &state); bool selectItemAfterDrawing() const; void setSelectItemAfterDrawing(bool enabled); qreal toolScaling(Tools tool) const; void setToolScaling(qreal scaling, Tools tool); qreal toolOpacity(Tools tool) const; void setToolOpacity(qreal opacity, Tools tool); signals: void numberUpdateModeChanged(enum NumberUpdateMode numberUpdateMode) const; private: QSharedPointer mSettings; QList mAllTools; Tools mSelectTool; QHash mToolToColor; QHash mToolToTextColor; QHash mToolToWidth; QHash mToolToFillType; QHash mToolToFont; QHash mToolToObfuscationFactor; QHash mToolToShadowEnabled; QHash mToolToOpacity; QHash mToolToScaling; bool mSmoothPathEnabled; bool mSaveToolSelection; int mSmoothFactor; bool mSwitchToSelectToolAfterDrawingItem; bool mSelectItemAfterDrawing; NumberUpdateMode mNumberUpdateMode; QColor mCanvasColor; void initToolSettings(); void initSelectedTool(); void initToolColors(); void initToolTextColors(); void initToolWidths(); void initToolFillTypes(); void initToolFonts(); void initToolScaling(); void initToolOpacity(); void initObfuscateFactor(); void initShadowEnabled(); void initGeneralSettings(); QColor loadToolColor(Tools toolType); void saveToolColor(Tools toolType, const QColor &color); QColor loadToolTextColor(Tools toolType); void saveToolTextColor(Tools toolType, const QColor &color); int loadToolWidth(Tools toolType); void saveToolWidth(Tools toolType, int size); FillModes loadToolFillType(Tools toolType); void saveToolFillType(Tools toolType, FillModes fillType); QFont loadToolFont(Tools tool) const; void saveToolFont(Tools tool, const QFont &font); Tools loadToolType(); void saveToolType(Tools toolType); int loadToolObfuscateFactor(Tools toolType); void saveToolObfuscateFactor(Tools toolType, int radius); bool loadToolShadowEnabled(Tools tool); void saveToolShadowEnabled(Tools tool, bool enabled); qreal loadToolScaling(Tools tool); void saveToolScaling(Tools tool, qreal scaling); qreal loadToolOpacity(Tools tool); void saveToolOpacity(Tools tool, qreal opacity); static QColor defaultToolColor(Tools toolType); static QColor defaultToolTextColor(Tools toolType); static int defaultToolWidth(Tools toolType); static FillModes defaultToolFillMode(Tools toolType); static QFont defaultToolFont(Tools tool); static Tools defaultToolType(); static int defaultObfuscateFactor(); static bool defaultShadowEnabled(Tools tool); static qreal defaultToolScaling(); static qreal defaultToolOpacity(); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_CONFIG_H kImageAnnotator-0.6.1/src/backend/ISettings.h000066400000000000000000000023471440330760000210440ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ISETTINGS_H #define KIMAGEANNOTATOR_ISETTINGS_H namespace kImageAnnotator { class ISettings { public: explicit ISettings() = default; virtual ~ISettings() = default; virtual void sync() = 0; virtual void setValue(const QString &key, const QVariant &value) = 0; virtual QVariant value(const QString &key, const QVariant &defaultValue) const = 0; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ISETTINGS_H kImageAnnotator-0.6.1/src/backend/SettingsAdapter.cpp000066400000000000000000000022561440330760000225660ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SettingsAdapter.h" namespace kImageAnnotator { void SettingsAdapter::sync() { mSettings.sync(); } void SettingsAdapter::setValue(const QString &key, const QVariant &value) { mSettings.setValue(key, value); } QVariant SettingsAdapter::value(const QString &key, const QVariant &defaultValue) const { return mSettings.value(key, defaultValue); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/backend/SettingsAdapter.h000066400000000000000000000025441440330760000222330ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SETTINGSADAPTER_H #define KIMAGEANNOTATOR_SETTINGSADAPTER_H #include #include "ISettings.h" namespace kImageAnnotator { class SettingsAdapter : public ISettings { public: explicit SettingsAdapter() = default; ~SettingsAdapter() override = default; void sync() override; void setValue(const QString &key, const QVariant &value) override; QVariant value(const QString &key, const QVariant &defaultValue) const override; private: QSettings mSettings; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SETTINGSADAPTER_H kImageAnnotator-0.6.1/src/common/000077500000000000000000000000001440330760000166555ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/common/constants/000077500000000000000000000000001440330760000206715ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/common/constants/Constants.h000066400000000000000000000025601440330760000230210ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONCONSTANTS_H #define KIMAGEANNOTATOR_ANNOTATIONCONSTANTS_H #include #include namespace kImageAnnotator { inline namespace Constants { const int MinPathResizeRectSize = 20; const int ResizeHandleSize = 16; const QSize SettingsWidgetSize(64, 32); const QSize ToolButtonIconSize(28, 28); const QSize MenuItemIconSize(20, 20); const QSize SettingsWidgetIconSize(20, 20); const QColor HoverColor(173, 216, 230); // "#add8e6" } // namespace Constants } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONCONSTANTS_H kImageAnnotator-0.6.1/src/common/enum/000077500000000000000000000000001440330760000176215ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/common/enum/DesktopEnvironmentType.h000066400000000000000000000021301440330760000244660ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_DESKTOPENVIRONMENTTYPE_H #define KIMAGEANNOTATOR_DESKTOPENVIRONMENTTYPE_H namespace kImageAnnotator { enum class DesktopEnvironmentType { Unknown, Kde, Gnome }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_DESKTOPENVIRONMENTTYPE_H kImageAnnotator-0.6.1/src/common/enum/FillModes.h000066400000000000000000000021731440330760000216530ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_FILLMODES_H #define KIMAGEANNOTATOR_FILLMODES_H #include namespace kImageAnnotator { enum class FillModes { BorderAndNoFill, BorderAndFill, NoBorderAndNoFill, NoBorderAndFill }; } // namespace kImageAnnotator Q_DECLARE_METATYPE(kImageAnnotator::FillModes); #endif // KIMAGEANNOTATOR_FILLMODES_H kImageAnnotator-0.6.1/src/common/enum/FlipDirection.h000066400000000000000000000021101440330760000225170ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_FLIPDIRECTION_H #define KIMAGEANNOTATOR_FLIPDIRECTION_H namespace kImageAnnotator { enum class FlipDirection { Horizontal, Vertical }; } // namespace kImageAnnotator Q_DECLARE_METATYPE(kImageAnnotator::FlipDirection); #endif //KIMAGEANNOTATOR_FLIPDIRECTION_H kImageAnnotator-0.6.1/src/common/enum/ImageEffects.h000066400000000000000000000021761440330760000223220ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_IMAGEEFFECTS_H #define KIMAGEANNOTATOR_IMAGEEFFECTS_H #include namespace kImageAnnotator { enum class ImageEffects { NoEffect, DropShadow, Grayscale, Border, InvertColor, }; } // namespace kImageAnnotator Q_DECLARE_METATYPE(kImageAnnotator::ImageEffects); #endif // KIMAGEANNOTATOR_IMAGEEFFECTS_H kImageAnnotator-0.6.1/src/common/enum/NumberUpdateMode.h000066400000000000000000000021161440330760000231720ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_NUMBERUPDATEMODE_H #define KIMAGEANNOTATOR_NUMBERUPDATEMODE_H #include namespace kImageAnnotator { enum class NumberUpdateMode { UpdateAllNumbers, UpdateOnlyNewNumbers }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_NUMBERUPDATEMODE_H kImageAnnotator-0.6.1/src/common/enum/Tools.h000066400000000000000000000025431440330760000210760ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_TOOLS_H #define KIMAGEANNOTATOR_TOOLS_H #include namespace kImageAnnotator { enum class Tools { Select, Pen, MarkerPen, MarkerRect, MarkerEllipse, Line, Arrow, DoubleArrow, Rect, Ellipse, Number, NumberPointer, NumberArrow, Text, TextPointer, TextArrow, Blur, Image, Sticker, Pixelate, Duplicate }; inline uint qHash(const Tools &tool, uint seed) { Q_UNUSED(seed) return static_cast(tool); } } // namespace kImageAnnotator Q_DECLARE_METATYPE(kImageAnnotator::Tools) #endif // KIMAGEANNOTATOR_TOOLS_H kImageAnnotator-0.6.1/src/common/filter/000077500000000000000000000000001440330760000201425ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/common/filter/IgnoreShortcutsFilter.cpp000066400000000000000000000024511440330760000251600ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "IgnoreShortcutsFilter.h" namespace kImageAnnotator { void IgnoreShortcutsFilter::apply() { QCoreApplication::instance()->installEventFilter(this); } void IgnoreShortcutsFilter::remove() { QCoreApplication::instance()->removeEventFilter(this); } bool IgnoreShortcutsFilter::eventFilter(QObject *watched, QEvent *event) { if(event->type() == QEvent::ShortcutOverride) { event->accept(); return true; } return QObject::eventFilter(watched, event); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/common/filter/IgnoreShortcutsFilter.h000066400000000000000000000024761440330760000246340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_IGNORESHORTCUTSFILTER_H #define KIMAGEANNOTATOR_IGNORESHORTCUTSFILTER_H #include #include namespace kImageAnnotator { class IgnoreShortcutsFilter : public QObject { Q_OBJECT public: explicit IgnoreShortcutsFilter() = default; ~IgnoreShortcutsFilter() override = default; void apply(); void remove(); protected: bool eventFilter(QObject *watched, QEvent *event) override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_IGNORESHORTCUTSFILTER_H kImageAnnotator-0.6.1/src/common/filter/KeyEventListener.cpp000066400000000000000000000034671440330760000241200ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "KeyEventListener.h" namespace kImageAnnotator { KeyEventListener::KeyEventListener() { QCoreApplication::instance()->installEventFilter(this); } KeyEventListener::~KeyEventListener() { QCoreApplication::instance()->removeEventFilter(this); } bool KeyEventListener::eventFilter(QObject *watched, QEvent *event) { if (event->type() == QEvent::KeyPress) { handleKeyPressed(event); } else if (event->type() == QEvent::KeyRelease) { handleKeyReleased(event); } return QObject::eventFilter(watched, event); } void KeyEventListener::handleKeyReleased(QEvent *event) { auto keyEvent = dynamic_cast(event); if(mPressedKeyCodes.contains(keyEvent->key())) { mPressedKeyCodes.removeAll(keyEvent->key()); emit keyReleased(keyEvent); } } void KeyEventListener::handleKeyPressed(QEvent *event) { auto keyEvent = dynamic_cast(event); if(!mPressedKeyCodes.contains(keyEvent->key())) { mPressedKeyCodes.append(keyEvent->key()); emit keyPressed(keyEvent); } } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/common/filter/KeyEventListener.h000066400000000000000000000027141440330760000235570ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_KEYEVENTLISTENER_H #define KIMAGEANNOTATOR_KEYEVENTLISTENER_H #include #include #include #include namespace kImageAnnotator { class KeyEventListener : public QObject { Q_OBJECT public: explicit KeyEventListener(); ~KeyEventListener() override; signals: void keyPressed(QKeyEvent *event); void keyReleased(QKeyEvent *event); protected: bool eventFilter(QObject *watched, QEvent *event) override; private: QList mPressedKeyCodes; void handleKeyPressed(QEvent *event); void handleKeyReleased(QEvent *event); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_KEYEVENTLISTENER_H kImageAnnotator-0.6.1/src/common/helper/000077500000000000000000000000001440330760000201345ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/common/helper/ConfigNameHelper.cpp000066400000000000000000000050531440330760000240110ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ConfigNameHelper.h" namespace kImageAnnotator { QString ConfigNameHelper::kImageAnnotator() { return QLatin1String("KImageAnnotator/"); } QString ConfigNameHelper::toolType() { return kImageAnnotator() + QLatin1String("ToolType"); } QString ConfigNameHelper::toolWidth(Tools tool) { return kImageAnnotator() + QLatin1String("ToolWidth_") + QString::number(static_cast(tool)); } QString ConfigNameHelper::toolColor(Tools tool) { return kImageAnnotator() + QLatin1String("ToolColor_") + QString::number(static_cast(tool)); } QString ConfigNameHelper::toolTextColor(Tools tool) { return kImageAnnotator() + QLatin1String("ToolTextColor_") + QString::number(static_cast(tool)); } QString ConfigNameHelper::toolFillType(Tools tool) { return kImageAnnotator() + QLatin1String("ToolFillType_") + QString::number(static_cast(tool)); } QString ConfigNameHelper::toolFont(Tools tool) { return kImageAnnotator() + QLatin1String("ToolFont_") + QString::number(static_cast(tool)); } QString ConfigNameHelper::obfuscateFactor(Tools tool) { return kImageAnnotator() + QLatin1String("ToolObfuscateFactor_") + QString::number(static_cast(tool)); } QString ConfigNameHelper::shadowEnabled(Tools tool) { return kImageAnnotator() + QLatin1String("ToolShadowEnabled_") + QString::number(static_cast(tool)); } QString ConfigNameHelper::annotatorDockWidgetsState() { return kImageAnnotator() + QLatin1String("AnnotatorDockWidgetsState"); } QString ConfigNameHelper::toolOpacity(Tools tool) { return kImageAnnotator() + QLatin1String("ToolOpacity_") + QString::number(static_cast(tool)); } QString ConfigNameHelper::toolScaling(Tools tool) { return kImageAnnotator() + QLatin1String("ToolScaling_") + QString::number(static_cast(tool)); } }kImageAnnotator-0.6.1/src/common/helper/ConfigNameHelper.h000066400000000000000000000030161440330760000234530ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CONFIGNAMEFORMATTER_H #define KIMAGEANNOTATOR_CONFIGNAMEFORMATTER_H #include #include "src/common/enum/Tools.h" namespace kImageAnnotator { class ConfigNameHelper { public: static QString kImageAnnotator(); static QString toolType(); static QString toolWidth(Tools tool); static QString toolColor(Tools tool); static QString toolTextColor(Tools tool); static QString toolFillType(Tools tool); static QString toolFont(Tools tool); static QString obfuscateFactor(Tools tool); static QString shadowEnabled(Tools tool); static QString annotatorDockWidgetsState(); static QString toolOpacity(Tools tool); static QString toolScaling(Tools tool); }; } #endif //KIMAGEANNOTATOR_CONFIGNAMEFORMATTER_H kImageAnnotator-0.6.1/src/common/helper/CursorHelper.cpp000066400000000000000000000030431440330760000232550ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CursorHelper.h" namespace kImageAnnotator { Qt::CursorShape CursorHelper::defaultCursor() { return Qt::ArrowCursor; } Qt::CursorShape CursorHelper::allResizeCursor() { return Qt::SizeAllCursor; } Qt::CursorShape CursorHelper::horizontalResizeCursor() { return Qt::SizeHorCursor; } Qt::CursorShape CursorHelper::verticalResizeCursor() { return Qt::SizeVerCursor; } Qt::CursorShape CursorHelper::bDiagResizeCursor() { return Qt::SizeBDiagCursor; } Qt::CursorShape CursorHelper::fDiagResizeCursor() { return Qt::SizeFDiagCursor; } Qt::CursorShape CursorHelper::movableCursor() { return Qt::OpenHandCursor; } Qt::CursorShape CursorHelper::movingCursor() { return Qt::ClosedHandCursor; } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/common/helper/CursorHelper.h000066400000000000000000000025641440330760000227310ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CURSORHELPER_H #define KIMAGEANNOTATOR_CURSORHELPER_H #include namespace kImageAnnotator { class CursorHelper { public: Qt::CursorShape static defaultCursor(); Qt::CursorShape static verticalResizeCursor(); Qt::CursorShape static horizontalResizeCursor(); Qt::CursorShape static bDiagResizeCursor(); Qt::CursorShape static fDiagResizeCursor(); Qt::CursorShape static allResizeCursor(); Qt::CursorShape static movableCursor(); Qt::CursorShape static movingCursor(); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_CURSORHELPER_H kImageAnnotator-0.6.1/src/common/helper/DesktopEnvironmentChecker.cpp000066400000000000000000000030131440330760000257600ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "DesktopEnvironmentChecker.h" namespace kImageAnnotator { DesktopEnvironmentType DesktopEnvironmentChecker::getDesktopEnvironment() { auto currentDesktop = QString(qgetenv("XDG_CURRENT_DESKTOP")); if (contains(currentDesktop, QLatin1String("gnome")) || contains(currentDesktop, QLatin1String("unity"))) { return DesktopEnvironmentType::Gnome; } else if (contains(currentDesktop, QLatin1String("kde"))) { return DesktopEnvironmentType::Kde; } else { return DesktopEnvironmentType::Unknown; } } bool DesktopEnvironmentChecker::contains(const QString &value1, const QLatin1String &value2) { return value1.contains(value2, Qt::CaseInsensitive); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/common/helper/DesktopEnvironmentChecker.h000066400000000000000000000025311440330760000254310ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_DESKTOPENVIRONMENTCHECKER_H #define KIMAGEANNOTATOR_DESKTOPENVIRONMENTCHECKER_H #include #include "src/common/enum/DesktopEnvironmentType.h" namespace kImageAnnotator { class DesktopEnvironmentChecker { public: DesktopEnvironmentChecker() = default; ~DesktopEnvironmentChecker() = default; DesktopEnvironmentType getDesktopEnvironment(); static bool contains(const QString &value1, const QLatin1String &value2) ; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_DESKTOPENVIRONMENTCHECKER_H kImageAnnotator-0.6.1/src/common/helper/IconLoader.cpp000066400000000000000000000030011440330760000226510ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "IconLoader.h" namespace kImageAnnotator { QIcon IconLoader::load(const QString &name) { auto type = getThemePrefix(); return QIcon(QLatin1String(":/icons/") + type + name); } QPixmap IconLoader::loadAsPixmap(const QString &name) { auto type = getThemePrefix(); return QPixmap(QLatin1String(":/icons/") + type + name); } QString IconLoader::getThemePrefix() { return isDarkTheme() ? QLatin1String("dark/") : QLatin1String("light/"); } double IconLoader::getThemeLuma() { auto color = QApplication::palette().background().color(); return 0.2126 * color.redF() + 0.7152 * color.greenF() + 0.0722 * color.blueF(); } bool IconLoader::isDarkTheme() { return getThemeLuma() > 0.4; } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/common/helper/IconLoader.h000066400000000000000000000024471440330760000223330ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ICONLOADER_H #define KIMAGEANNOTATOR_ICONLOADER_H #include #include #include namespace kImageAnnotator { class IconLoader { public: static QIcon load(const QString &name); static QPixmap loadAsPixmap(const QString &name); private: IconLoader() = default; ~IconLoader() = default; static bool isDarkTheme(); static QString getThemePrefix(); static double getThemeLuma(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ICONLOADER_H kImageAnnotator-0.6.1/src/common/helper/ItemHelper.cpp000066400000000000000000000022671440330760000227050ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ItemHelper.h" namespace kImageAnnotator { bool ItemHelper::zValueGreaterThen(const AbstractAnnotationItem *item1, const AbstractAnnotationItem *item2) { return item1->zValue() > item2->zValue(); } void ItemHelper::sortItemsByZValueDesc(QList *items) { qSort(items->begin(), items->end(), ItemHelper::zValueGreaterThen); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/common/helper/ItemHelper.h000066400000000000000000000023521440330760000223450ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ITEMHELPER_H #define KIMAGEANNOTATOR_ITEMHELPER_H #include "src/annotations/items/AbstractAnnotationItem.h" namespace kImageAnnotator { class ItemHelper { public: static bool zValueGreaterThen(const AbstractAnnotationItem *item1, const AbstractAnnotationItem *item2); static void sortItemsByZValueDesc(QList *items); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ITEMHELPER_H kImageAnnotator-0.6.1/src/common/helper/KeyHelper.cpp000066400000000000000000000051361440330760000225350ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "KeyHelper.h" namespace kImageAnnotator { KeyHelper::KeyHelper() { reset(); } void KeyHelper::keyPress(QKeyEvent *keyEvent) { auto key = static_cast(keyEvent->key()); if (mKeyToIsPressed.contains(key)) { mKeyToIsPressed[key] = true; emitPressSignal(key); } } void KeyHelper::keyRelease(QKeyEvent *keyEvent) { auto key = static_cast(keyEvent->key()); if (mKeyToIsPressed.contains(key)) { mKeyToIsPressed[key] = false; emitReleaseSignal(key); } } bool KeyHelper::isControlPressed() const { return mKeyToIsPressed[Qt::Key_Control]; } bool KeyHelper::isShiftPressed() const { return mKeyToIsPressed[Qt::Key_Shift]; } bool KeyHelper::isSpacePressed() const { return mKeyToIsPressed[Qt::Key_Space]; } void KeyHelper::reset() { mKeyToIsPressed[Qt::Key_Delete] = false; mKeyToIsPressed[Qt::Key_Escape] = false; mKeyToIsPressed[Qt::Key_Enter] = false; mKeyToIsPressed[Qt::Key_Return] = false; mKeyToIsPressed[Qt::Key_Control] = false; mKeyToIsPressed[Qt::Key_Shift] = false; mKeyToIsPressed[Qt::Key_Space] = false; mKeyToIsPressed[Qt::Key_Z] = false; } void KeyHelper::emitReleaseSignal(Qt::Key key) { switch (key) { case Qt::Key_Delete: emit deleteReleased(); break; case Qt::Key_Escape: emit escapeReleased(); break; case Qt::Key_Return: emit returnReleased(); break; case Qt::Key_Enter: emit enterReleased(); break; } } void KeyHelper::emitPressSignal(Qt::Key key) { if (key == Qt::Key_Z && isControlPressed()) { if (isShiftPressed()) { emit redoPressed(); } else { emit undoPressed(); } } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/common/helper/KeyHelper.h000066400000000000000000000031451440330760000222000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_KEYHELPER_H #define KIMAGEANNOTATOR_KEYHELPER_H #include #include namespace kImageAnnotator { class KeyHelper : public QObject { Q_OBJECT public: explicit KeyHelper(); ~KeyHelper() override = default; bool isControlPressed() const; bool isShiftPressed() const; bool isSpacePressed() const; void reset(); signals: void deleteReleased() const; void escapeReleased() const; void undoPressed() const; void redoPressed() const; void enterReleased() const; void returnReleased() const; public slots: void keyPress(QKeyEvent *keyEvent); void keyRelease(QKeyEvent *keyEvent); private: QHash mKeyToIsPressed; void emitReleaseSignal(Qt::Key key); void emitPressSignal(Qt::Key key); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_KEYHELPER_H kImageAnnotator-0.6.1/src/common/helper/MathHelper.cpp000066400000000000000000000032651440330760000226770ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include "MathHelper.h" namespace kImageAnnotator { qreal MathHelper::roundAngleTo(const qreal currentAngle, const int increments) { auto modulo = (int) currentAngle % increments; auto requiredRoundup = modulo < increments / 2 ? -modulo : increments - modulo; auto newAngle = qFloor(currentAngle + requiredRoundup); return newAngle; } qreal MathHelper::smallerValue(qreal value1, qreal value2) { qreal value = (qAbs(value1) < qAbs(value2)) ? qAbs(value1) : qAbs(value2); return (value1 < 0) ? -value : value; } qreal MathHelper::distanceBetweenPoints(const QPointF &point1, const QPointF &point2) { auto horizontalDistance = (point1.x() - point2.x()) * (point1.x() - point2.x()); auto verticalDistance = (point1.y() - point2.y()) * (point1.y() - point2.y()); return qSqrt(horizontalDistance + verticalDistance); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/common/helper/MathHelper.h000066400000000000000000000023331440330760000223370ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MATHHELPER_H #define KIMAGEANNOTATOR_MATHHELPER_H #include namespace kImageAnnotator { class MathHelper { public: static qreal roundAngleTo(qreal currentAngle, int increments); static qreal smallerValue(qreal value1, qreal value2); static qreal distanceBetweenPoints(const QPointF &point1, const QPointF &point2); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_MATHHELPER_H kImageAnnotator-0.6.1/src/common/helper/PathHelper.cpp000066400000000000000000000027611440330760000227020ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "PathHelper.h" namespace kImageAnnotator { QString PathHelper::extractFilename(const QString& path) { auto filename = extractFilenameWithFormat(path); if (filename.contains(QLatin1Char('.'))) { return filename.section(QLatin1Char('.'), 0, -2); } else { return filename; } } QString PathHelper::extractFilenameWithFormat(const QString &path) { return path.section(QLatin1Char('/'), -1); } QString PathHelper::prettyFilename(const QString &filename) { auto parts = filename.split(QLatin1Char('_'), QString::SkipEmptyParts); for (auto i = 0; i < parts.size() ; i++) { parts[i].replace(0, 1, parts[i][0].toUpper()); } return parts.join(QLatin1Char(' ')); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/common/helper/PathHelper.h000066400000000000000000000023151440330760000223420ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_PATHHELPER_H #define KIMAGEANNOTATOR_PATHHELPER_H #include #include namespace kImageAnnotator { class PathHelper { public: static QString extractFilename(const QString &path); static QString extractFilenameWithFormat(const QString &path); static QString prettyFilename(const QString &filename); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_PATHHELPER_H kImageAnnotator-0.6.1/src/common/helper/ShapeHelper.cpp000066400000000000000000000231321440330760000230410ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include #include "ShapeHelper.h" namespace kImageAnnotator { QPointF ShapeHelper::rectTopLeftWithOffset(const QRectF &rect, int offset) { auto xOffset = invertOffsetIfLeftSmallerThenRight(rect, offset); auto yOffset = invertOffsetIfTopSmallerThenBottom(rect, offset); return { rect.topLeft().x() + xOffset, rect.topLeft().y() + yOffset }; } QPointF ShapeHelper::rectTop(const QRectF &rect) { return { rect.center().x(), rect.top() }; } QPointF ShapeHelper::rectTopWithOffset(const QRectF &rect, int offset) { offset = invertOffsetIfTopSmallerThenBottom(rect, offset); return { rect.center().x(), rect.top() + offset }; } QPointF ShapeHelper::rectTopRightWithOffset(const QRectF &rect, int offset) { auto xOffset = invertOffsetIfLeftSmallerThenRight(rect, -offset); auto yOffset = invertOffsetIfTopSmallerThenBottom(rect, offset); return { rect.topRight().x() + xOffset, rect.topRight().y() + yOffset }; } QPointF ShapeHelper::rectRight(const QRectF &rect) { return { rect.right(), rect.center().y() }; } QPointF ShapeHelper::rectRightWithOffset(const QRectF &rect, int offset) { offset = invertOffsetIfLeftSmallerThenRight(rect, -offset); return { rect.right() + offset, rect.center().y() }; } QPointF ShapeHelper::rectBottomRightWithOffset(const QRectF &rect, int offset) { auto xOffset = invertOffsetIfLeftSmallerThenRight(rect, -offset); auto yOffset = invertOffsetIfTopSmallerThenBottom(rect, -offset); return { rect.bottomRight().x() + xOffset, rect.bottomRight().y() + yOffset }; } QPointF ShapeHelper::rectBottom(const QRectF &rect) { return { rect.center().x(), rect.bottom() }; } QPointF ShapeHelper::rectBottomWithOffset(const QRectF &rect, int offset) { offset = invertOffsetIfTopSmallerThenBottom(rect, -offset); return { rect.center().x(), rect.bottom() + offset }; } QPointF ShapeHelper::rectBottomLeftWithOffset(const QRectF &rect, int offset) { auto xOffset = invertOffsetIfLeftSmallerThenRight(rect, offset); auto yOffset = invertOffsetIfTopSmallerThenBottom(rect, -offset); return { rect.bottomLeft().x() + xOffset, rect.bottomLeft().y() + yOffset }; } QPointF ShapeHelper::rectLeft(const QRectF &rect) { return { rect.left(), rect.center().y() }; } QPointF ShapeHelper::rectLeftWithOffset(const QRectF &rect, int offset) { offset = invertOffsetIfLeftSmallerThenRight(rect, offset); return { rect.left() + offset, rect.center().y() }; } QLineF ShapeHelper::extendLine(const QLineF &line, int extendBy) { QLineF newLine(line.p2().x(), line.p2().y(), line.p1().x(), line.p1().y()); newLine.setLength(newLine.length() + extendBy / 2); newLine.setLine(newLine.p2().x(), newLine.p2().y(), newLine.p1().x(), newLine.p1().y()); newLine.setLength(newLine.length() + extendBy / 2); return newLine; } QPointF ShapeHelper::rectPointAtIndex(const QRectF &rect, int index) { if (index == 0) { return rect.topLeft(); } else if (index == 1) { return ShapeHelper::rectTop(rect); } else if (index == 2) { return rect.topRight(); } else if (index == 3) { return ShapeHelper::rectRight(rect); } else if (index == 4) { return rect.bottomRight(); } else if (index == 5) { return ShapeHelper::rectBottom(rect); } else if (index == 6) { return rect.bottomLeft(); } else if (index == 7) { return ShapeHelper::rectLeft(rect); } else { qCritical("Invalid rectangle index provided, returning empty point."); return {}; } } QRectF ShapeHelper::setRectPointAtIndex(const QRectF &rect, int index, const QPointF &pos, bool keepAspectRatio) { auto updatedRect = rect; if (index == 0) { if (!keepAspectRatio) { updatedRect.setTopLeft(pos); } else { const auto xDif = updatedRect.topLeft().x() - pos.x(); const auto yDif = updatedRect.topLeft().y() - pos.y(); const auto min = qMin(xDif, yDif); const auto newX = updatedRect.topLeft().x() - min; const auto newY = updatedRect.topLeft().y() - min; updatedRect.setTopLeft(QPointF(newX, newY)); } } else if (index == 1) { updatedRect.setTop(pos.y()); } else if (index == 2) { if (!keepAspectRatio) { updatedRect.setTopRight(pos); } else { const auto xDif = pos.x() - updatedRect.topRight().x(); const auto yDif = updatedRect.topRight().y() - pos.y(); const auto min = qMin(xDif, yDif); const auto newX = updatedRect.topRight().x() + min; const auto newY = updatedRect.topRight().y() - min; updatedRect.setTopRight(QPointF(newX, newY)); } } else if (index == 3) { updatedRect.setRight(pos.x()); } else if (index == 4) { if (!keepAspectRatio) { updatedRect.setBottomRight(pos); } else { const auto xDif = pos.x() - updatedRect.bottomRight().x(); const auto yDif = pos.y() - updatedRect.bottomRight().y(); const auto min = qMin(xDif, yDif); const auto newX = updatedRect.bottomRight().x() + min; const auto newY = updatedRect.bottomRight().y() + min; updatedRect.setBottomRight(QPointF(newX, newY)); } } else if (index == 5) { updatedRect.setBottom(pos.y()); } else if (index == 6) { if (!keepAspectRatio) { updatedRect.setBottomLeft(pos); } else { const auto xDif = updatedRect.bottomLeft().x() - pos.x(); const auto yDif = pos.y() - updatedRect.bottomLeft().y(); const auto min = qMin(xDif, yDif); const auto newX = updatedRect.bottomLeft().x() - min; const auto newY = updatedRect.bottomLeft().y() + min; updatedRect.setBottomLeft(QPointF(newX, newY)); } } else if (index == 7) { updatedRect.setLeft(pos.x()); } else { qCritical("Invalid rectangle index provided, returning unchanged rectangle."); } return updatedRect; } QPainterPath ShapeHelper::smoothOut(const QPainterPath &path, int smoothFactor) { auto points = getPathPoints(path, smoothFactor); // Don't proceed if we only have 3 or less points. if (points.count() < 3) { return path; } return createSmoothPath(points); } QPainterPath ShapeHelper::createSmoothPath(const QList &points) { QPointF point1, point2; QPainterPath smoothPath; smoothPath.moveTo(points[0]); smoothPath.lineTo(points[1]); for (auto i = 2; i < points.count() - 2; i++) { point1 = getBeginOfRounding(points[i], points[i + 1]); smoothPath.quadTo(points[i], point1); point2 = getEndOfRounding(points[i], points[i + 1]); smoothPath.lineTo(point2); } smoothPath.lineTo(points[points.count() - 1]); return smoothPath; } QList ShapeHelper::getPathPoints(const QPainterPath &path, int smootFactor) { QList points; QPointF p; for (auto i = 0; i < path.elementCount() - 1; i++) { p = QPointF(path.elementAt(i).x, path.elementAt(i).y); // Except for first and last points, check what the distance between two // points is and if its less the min, don't add them to the list. if (points.count() > 1 && (i < path.elementCount() - 2) && (MathHelper::distanceBetweenPoints(points.last(), p) < smootFactor)) { continue; } points.append(p); } return points; } int ShapeHelper::invertOffsetIfLeftSmallerThenRight(const QRectF &rect, int xOffset) { if (rect.left() < rect.right()) { xOffset *= -1; } return xOffset; } int ShapeHelper::invertOffsetIfTopSmallerThenBottom(const QRectF &rect, int yOffset) { if (rect.top() < rect.bottom()) { yOffset *= -1; } return yOffset; } QPointF ShapeHelper::getBeginOfRounding(const QPointF &point1, const QPointF &point2) { QPointF startPoint; auto rat = getRoundingRate(point1, point2); startPoint.setX((1.0 - rat) * point1.x() + rat * point2.x()); startPoint.setY((1.0 - rat) * point1.y() + rat * point2.y()); return startPoint; } QPointF ShapeHelper::getEndOfRounding(const QPointF &point1, const QPointF &point2) { QPointF endPoint; auto rat = getRoundingRate(point1, point2); endPoint.setX(rat * point1.x() + (1.0 - rat) * point2.x()); endPoint.setY(rat * point1.y() + (1.0 - rat) * point2.y()); return endPoint; } double ShapeHelper::getRoundingRate(const QPointF &point1, const QPointF &point2) { auto rat = 10.0 / MathHelper::distanceBetweenPoints(point1, point2); if (rat > 0.5) { rat = 0.5; } return rat; } QPointF ShapeHelper::intersectionBetweenRectAndLineFromCenter(const QLineF &line, const QRectF &rect) { QLineF leftLine(rect.bottomLeft(), rect.topLeft()); QLineF topLine(rect.topLeft(), rect.topRight()); QLineF rightLine(rect.topRight(), rect.bottomRight()); QLineF bottomLine(rect.bottomLeft(), rect.bottomRight()); QPointF intersectionPoint; if(linesIntersect(line, leftLine, intersectionPoint)) { return intersectionPoint; } else if(linesIntersect(line, topLine, intersectionPoint)) { return intersectionPoint; } else if(linesIntersect(line, rightLine, intersectionPoint)) { return intersectionPoint; } else if(linesIntersect(line, bottomLine, intersectionPoint)) { return intersectionPoint; } return intersectionPoint; } bool ShapeHelper::linesIntersect(const QLineF &line1, const QLineF &line2, QPointF &intersection) { return line1.intersect(line2, &intersection) == QLineF::BoundedIntersection; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/common/helper/ShapeHelper.h000066400000000000000000000056601440330760000225140ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SHAPEHELPER_H #define KIMAGEANNOTATOR_SHAPEHELPER_H #include #include #include #include "src/common/helper/MathHelper.h" #include "src/common/constants/Constants.h" namespace kImageAnnotator { class ShapeHelper { public: static QPointF rectTopLeftWithOffset(const QRectF &rect, int offset); static QPointF rectTop(const QRectF &rect); static QPointF rectTopWithOffset(const QRectF &rect, int offset); static QPointF rectTopRightWithOffset(const QRectF &rect, int offset); static QPointF rectRight(const QRectF &rect); static QPointF rectRightWithOffset(const QRectF &rect, int offset); static QPointF rectBottomRightWithOffset(const QRectF &rect, int offset); static QPointF rectBottom(const QRectF &rect); static QPointF rectBottomWithOffset(const QRectF &rect, int offset); static QPointF rectBottomLeftWithOffset(const QRectF &rect, int offset); static QPointF rectLeft(const QRectF &rect); static QPointF rectLeftWithOffset(const QRectF &rect, int offset); static QLineF extendLine(const QLineF &line, int extendBy); static QPointF rectPointAtIndex(const QRectF &rect, int index); static QRectF setRectPointAtIndex(const QRectF &rect, int index, const QPointF &pos, bool keepAspectRatio = false); static QPainterPath smoothOut(const QPainterPath &path, int smoothFactor); static QPointF intersectionBetweenRectAndLineFromCenter(const QLineF &line, const QRectF &rect); private: static int invertOffsetIfTopSmallerThenBottom(const QRectF &rect, int yOffset); static int invertOffsetIfLeftSmallerThenRight(const QRectF &rect, int xOffset); static QPointF getBeginOfRounding(const QPointF &point1, const QPointF &point2); static QPointF getEndOfRounding(const QPointF &point1, const QPointF &point2); static double getRoundingRate(const QPointF &point1, const QPointF &point2); static QList getPathPoints(const QPainterPath &path, int smootFactor); static QPainterPath createSmoothPath(const QList &points); static bool linesIntersect(const QLineF &line1, const QLineF &line2, QPointF &intersection); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_SHAPEHELPER_H kImageAnnotator-0.6.1/src/common/platform/000077500000000000000000000000001440330760000205015ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/common/platform/PlatformChecker.cpp000066400000000000000000000022511440330760000242560ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "PlatformChecker.h" namespace kImageAnnotator { PlatformChecker *PlatformChecker::instance() { static PlatformChecker instance; return &instance; } bool PlatformChecker::isWayland() const { return mIsWayland; } PlatformChecker::PlatformChecker() { auto output = qgetenv("XDG_CURRENT_DESKTOP"); mIsWayland = output.contains("wayland"); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/common/platform/PlatformChecker.h000066400000000000000000000022631440330760000237260ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_PLATFORMCHECKER_H #define KIMAGEANNOTATOR_PLATFORMCHECKER_H #include namespace kImageAnnotator { class PlatformChecker { public: virtual ~PlatformChecker() = default; static PlatformChecker *instance(); bool isWayland() const; private: bool mIsWayland; PlatformChecker(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_PLATFORMCHECKER_H kImageAnnotator-0.6.1/src/common/provider/000077500000000000000000000000001440330760000205075ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/common/provider/DevicePixelRatioScaler.cpp000066400000000000000000000023371440330760000255520ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "DevicePixelRatioScaler.h" namespace kImageAnnotator { QRectF DevicePixelRatioScaler::scale(const QRectF &rect) const { auto factor = scaleFactor(); return {rect.left() * factor, rect.top() * factor, rect.width() * factor, rect.height() * factor}; } qreal DevicePixelRatioScaler::scaleFactor() const { auto desktopWidget = QApplication::desktop(); return desktopWidget->devicePixelRatioF(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/common/provider/DevicePixelRatioScaler.h000066400000000000000000000025141440330760000252140ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_DEVICEPIXELRATIOSCALER_H #define KIMAGEANNOTATOR_DEVICEPIXELRATIOSCALER_H #include #include #include "IDevicePixelRatioScaler.h" namespace kImageAnnotator { class DevicePixelRatioScaler : public IDevicePixelRatioScaler { public: DevicePixelRatioScaler() = default; ~DevicePixelRatioScaler() override = default; QRectF scale(const QRectF &rect) const override; qreal scaleFactor() const override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_DEVICEPIXELRATIOSCALER_H kImageAnnotator-0.6.1/src/common/provider/IDevicePixelRatioScaler.h000066400000000000000000000022631440330760000253260ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_IDEVICEPIXELRATIOSCALER_H #define KIMAGEANNOTATOR_IDEVICEPIXELRATIOSCALER_H namespace kImageAnnotator { class IDevicePixelRatioScaler { public: virtual ~IDevicePixelRatioScaler() = default; virtual QRectF scale(const QRectF &rect) const = 0; virtual qreal scaleFactor() const = 0; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_IDEVICEPIXELRATIOSCALER_H kImageAnnotator-0.6.1/src/common/provider/ScaledSizeProvider.cpp000066400000000000000000000041561440330760000247620ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ScaledSizeProvider.h" namespace kImageAnnotator { int ScaledSizeProvider::scaledWidth(int width) { return (int)(width * scaleFactor()); } QSize ScaledSizeProvider::scaledSize(const QSize &size) { return size * scaleFactor(); } QSize ScaledSizeProvider::settingsWidgetIconSize() { return scaledSize(Constants::SettingsWidgetIconSize); } QSize ScaledSizeProvider::menuItemIconSize() { return scaledSize(Constants::MenuItemIconSize); } int ScaledSizeProvider::resizeHandleSize() { return scaledWidth(Constants::ResizeHandleSize); } qreal ScaledSizeProvider::scaleFactor() { static auto scaleFactor = getScaleFactor(); return scaleFactor; } qreal ScaledSizeProvider::getScaleFactor() { #if defined(__linux__) DesktopEnvironmentChecker desktopEnvironmentChecker; auto environment = desktopEnvironmentChecker.getDesktopEnvironment(); if (environment == DesktopEnvironmentType::Gnome) { auto screen = QApplication::primaryScreen(); auto logicalDotsPerInch = (int) screen->logicalDotsPerInch(); auto physicalDotsPerInch = (int) screen->physicalDotsPerInch(); return (qreal)logicalDotsPerInch / (qreal)physicalDotsPerInch; } else if (environment == DesktopEnvironmentType::Kde) { auto screen = QApplication::primaryScreen(); return screen->devicePixelRatio(); } #endif return 1; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/common/provider/ScaledSizeProvider.h000066400000000000000000000030341440330760000244210ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SCALEDSIZEPROVIDER_H #define KIMAGEANNOTATOR_SCALEDSIZEPROVIDER_H #include #if defined(__linux__) #include #include #include "src/common/helper/DesktopEnvironmentChecker.h" #endif #include "src/common/constants/Constants.h" namespace kImageAnnotator { class ScaledSizeProvider { public: static int scaledWidth(int width); static QSize scaledSize(const QSize &size); static QSize settingsWidgetIconSize(); static QSize menuItemIconSize(); static int resizeHandleSize(); private: static qreal scaleFactor(); static qreal getScaleFactor(); ScaledSizeProvider() = default; ~ScaledSizeProvider() = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SCALEDSIZEPROVIDER_H kImageAnnotator-0.6.1/src/gui/000077500000000000000000000000001440330760000161515ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/CoreView.cpp000066400000000000000000000131431440330760000204020ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CoreView.h" namespace kImageAnnotator { CoreView::CoreView(Config *config) : mConfig(config), mAnnotationWidget(new AnnotationWidget(mConfig)), mCropWidget(new CropWidget), mScaleWidget(new ScaleWidget), mRotateWidget(new RotateWidget), mCutWidget(new CutWidget(this)), mModifyCanvasWidget(new ModifyCanvasWidget) { addWidget(mAnnotationWidget); addWidget(mCropWidget); addWidget(mScaleWidget); addWidget(mRotateWidget); addWidget(mModifyCanvasWidget); addWidget(mCutWidget); connect(mAnnotationWidget, &AnnotationWidget::imageChanged, this, &CoreView::imageChanged); connect(mAnnotationWidget, &AnnotationWidget::currentTabChanged, this, &CoreView::currentTabChanged); connect(mAnnotationWidget, &AnnotationWidget::tabCloseRequested, this, &CoreView::tabCloseRequested); connect(mAnnotationWidget, &AnnotationWidget::tabMoved, this, &CoreView::tabMoved); connect(mAnnotationWidget, &AnnotationWidget::tabContextMenuOpened, this, &CoreView::tabContextMenuOpened); connect(mAnnotationWidget, &AnnotationWidget::activateCrop, this, &CoreView::showCropper); connect(mAnnotationWidget, &AnnotationWidget::activateScale, this, &CoreView::showScaler); connect(mAnnotationWidget, &AnnotationWidget::activateRotate, this, &CoreView::showRotator); connect(mAnnotationWidget, &AnnotationWidget::activateModifyCanvas, this, &CoreView::showCanvasModifier); connect(mAnnotationWidget, &AnnotationWidget::activateCut, this, &CoreView::showCutter); connect(mCropWidget, &CropWidget::closing, this, &CoreView::showAnnotator); connect(mScaleWidget, &ScaleWidget::closing, this, &CoreView::showAnnotator); connect(mRotateWidget, &RotateWidget::closing, this, &CoreView::showAnnotator); connect(mModifyCanvasWidget, &ModifyCanvasWidget::closing, this, &CoreView::showAnnotator); connect(mCutWidget, &CutWidget::closing, this, &CoreView::showAnnotator); } CoreView::~CoreView() { delete mAnnotationWidget; delete mCropWidget; delete mScaleWidget; delete mRotateWidget; delete mModifyCanvasWidget; } QImage CoreView::image() const { return mAnnotationWidget->image(); } QImage CoreView::imageAt(int index) const { return mAnnotationWidget->imageAt(index); } void CoreView::loadImage(const QPixmap &pixmap) { mAnnotationWidget->loadImage(pixmap); } int CoreView::addTab(const QPixmap &pixmap, const QString &title, const QString &toolTip) { return mAnnotationWidget->addTab(pixmap, title, toolTip); } void CoreView::updateTabInfo(int index, const QString &title, const QString &toolTip) { mAnnotationWidget->updateTabInfo(index, title, toolTip); } void CoreView::insertImageItem(const QPointF &position, const QPixmap &pixmap) { mAnnotationWidget->insertImageItem(position, pixmap); } void CoreView::removeTab(int index) { mAnnotationWidget->removeTab(index); } void CoreView::showAnnotator() { mAnnotationWidget->setUndoEnabled(true); setCurrentWidget(mAnnotationWidget); } void CoreView::showCropper() { mAnnotationWidget->setUndoEnabled(false); mAnnotationWidget->clearSelection(); setCurrentWidget(mCropWidget); mCropWidget->activate(mAnnotationWidget->annotationArea()); } void CoreView::showScaler() { mAnnotationWidget->setUndoEnabled(false); mAnnotationWidget->clearSelection(); setCurrentWidget(mScaleWidget); mScaleWidget->activate(mAnnotationWidget->annotationArea()); } void CoreView::showRotator() { mAnnotationWidget->setUndoEnabled(false); mAnnotationWidget->clearSelection(); setCurrentWidget(mRotateWidget); mRotateWidget->activate(mAnnotationWidget->annotationArea()); } void CoreView::showCutter() { mAnnotationWidget->setUndoEnabled(false); mAnnotationWidget->clearSelection(); setCurrentWidget(mCutWidget); mCutWidget->activate(mAnnotationWidget->annotationArea()); } void CoreView::showCanvasModifier() { mAnnotationWidget->setUndoEnabled(false); mAnnotationWidget->clearSelection(); setCurrentWidget(mModifyCanvasWidget); mModifyCanvasWidget->activate(mAnnotationWidget->annotationArea()); } void CoreView::setControlsWidgetVisible(bool enabled) { mAnnotationWidget->setControlsWidgetVisible(enabled); } void CoreView::setSettingsCollapsed(bool isCollapsed) { mAnnotationWidget->setSettingsCollapsed(isCollapsed); } void CoreView::setTabBarAutoHide(bool enabled) { mAnnotationWidget->setTabBarAutoHide(enabled); } QAction *CoreView::undoAction() { return mAnnotationWidget->undoAction(); } QAction *CoreView::redoAction() { return mAnnotationWidget->redoAction(); } QSize CoreView::sizeHint() const { return mAnnotationWidget->sizeHint(); } void CoreView::reloadConfig() { mAnnotationWidget->reloadConfig(); } void CoreView::setStickers(const QStringList &stickerPaths, bool keepDefault) { mAnnotationWidget->setStickers(stickerPaths, keepDefault); } void CoreView::addTabContextMenuActions(const QList &actions) { mAnnotationWidget->addTabContextMenuActions(actions); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/CoreView.h000066400000000000000000000052601440330760000200500ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SWITCHER_H #define KIMAGEANNOTATOR_SWITCHER_H #include #include "src/annotations/core/AnnotationArea.h" #include "src/gui/annotator/AnnotationWidget.h" #include "src/gui/cropper/CropWidget.h" #include "src/gui/scaler/ScaleWidget.h" #include "src/gui/rotator/RotateWidget.h" #include "src/gui/cutter/CutWidget.h" #include "src/gui/canvasModifier/ModifyCanvasWidget.h" namespace kImageAnnotator { class CoreView : public QStackedWidget { Q_OBJECT public: explicit CoreView(Config *config); ~CoreView() override; QImage image() const; QImage imageAt(int index) const; QAction *undoAction(); QAction *redoAction(); QSize sizeHint() const override; void reloadConfig(); signals: void imageChanged() const; void currentTabChanged(int index) const; void tabCloseRequested(int index) const; void tabMoved(int fromIndex, int toIndex); void tabContextMenuOpened(int index) const; public slots: void loadImage(const QPixmap &pixmap); int addTab(const QPixmap &pixmap, const QString &title, const QString &toolTip); void updateTabInfo(int index, const QString &title, const QString &toolTip); void insertImageItem(const QPointF &position, const QPixmap &pixmap); void removeTab(int index); void showAnnotator(); void showCropper(); void showScaler(); void showRotator(); void showCutter(); void showCanvasModifier(); void setControlsWidgetVisible(bool enabled); void setSettingsCollapsed(bool isCollapsed); void setTabBarAutoHide(bool enabled); void setStickers(const QStringList &stickerPaths, bool keepDefault); void addTabContextMenuActions(const QList & actions); private: Config *mConfig; AnnotationWidget *mAnnotationWidget; CropWidget *mCropWidget; ScaleWidget *mScaleWidget; RotateWidget *mRotateWidget; CutWidget *mCutWidget; ModifyCanvasWidget *mModifyCanvasWidget; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SWITCHER_H kImageAnnotator-0.6.1/src/gui/KImageAnnotator.cpp000066400000000000000000000160431440330760000217040ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include #include #include #include "CoreView.h" #include "src/backend/SettingsAdapter.h" inline void initResource() { Q_INIT_RESOURCE(kImageAnnotator_resources); } namespace kImageAnnotator { void loadTranslations() { static QTranslator *existingTranslator = nullptr; auto translator = new QTranslator(QCoreApplication::instance()); auto translationsLoaded = translator->load(QLocale(), QLatin1String("kImageAnnotator"), QLatin1String("_"), QLatin1String(KIMAGEANNOTATOR_LANG_INSTALL_DIR)); if (translationsLoaded) { if (existingTranslator != nullptr) { QCoreApplication::removeTranslator(existingTranslator); delete existingTranslator; } QCoreApplication::installTranslator(translator); existingTranslator = translator; } } class KImageAnnotatorPrivate { Q_DISABLE_COPY(KImageAnnotatorPrivate) Q_DECLARE_PUBLIC(KImageAnnotator) explicit KImageAnnotatorPrivate(KImageAnnotator *kImageAnnotator); KImageAnnotator *const q_ptr; Config mConfig; CoreView mCoreView; QHBoxLayout mMainLayout; }; KImageAnnotator::KImageAnnotator() : d_ptr(new KImageAnnotatorPrivate(this)) {} KImageAnnotator::~KImageAnnotator() {} QImage KImageAnnotator::image() const { Q_D(const KImageAnnotator); return d->mCoreView.image(); } QImage KImageAnnotator::imageAt(int index) const { Q_D(const KImageAnnotator); return d->mCoreView.imageAt(index); } QAction *KImageAnnotator::undoAction() { Q_D(KImageAnnotator); return d->mCoreView.undoAction(); } QAction *KImageAnnotator::redoAction() { Q_D(KImageAnnotator); return d->mCoreView.redoAction(); } void KImageAnnotator::loadImage(const QPixmap &pixmap) { Q_D(KImageAnnotator); d->mCoreView.loadImage(pixmap); if (isHidden()) { show(); } } int KImageAnnotator::addTab(const QPixmap &pixmap, const QString &title, const QString &toolTip) { Q_D(KImageAnnotator); auto newTabIndex = d->mCoreView.addTab(pixmap, title, toolTip); if (isHidden()) { show(); } return newTabIndex; } void KImageAnnotator::updateTabInfo(int index, const QString &title, const QString &toolTip) { Q_D(KImageAnnotator); d->mCoreView.updateTabInfo(index, title, toolTip); } void KImageAnnotator::insertImageItem(const QPointF &position, const QPixmap &pixmap) { Q_D(KImageAnnotator); d->mCoreView.insertImageItem(position, pixmap); } QSize KImageAnnotator::sizeHint() const { Q_D(const KImageAnnotator); return d->mCoreView.sizeHint(); } void KImageAnnotator::setTextFont(const QFont &font) { Q_UNUSED(font) // Deprecated, will be removed with the next major release } void KImageAnnotator::setNumberFont(const QFont &font) { Q_UNUSED(font) // Deprecated, will be removed with the next major release } void KImageAnnotator::setItemShadowEnabled(bool enabled) { Q_UNUSED(enabled) // Deprecated, will be removed with the next major release } void KImageAnnotator::setSmoothPathEnabled(bool enabled) { Q_D(KImageAnnotator); d->mConfig.setSmoothPathEnabled(enabled); } void KImageAnnotator::setSaveToolSelection(bool enabled) { Q_D(KImageAnnotator); d->mConfig.setSaveToolSelection(enabled); d->mCoreView.reloadConfig(); } void KImageAnnotator::setSmoothFactor(int factor) { Q_D(KImageAnnotator); d->mConfig.setSmoothFactor(factor); } void KImageAnnotator::setSwitchToSelectToolAfterDrawingItem(bool enabled) { Q_D(KImageAnnotator); d->mConfig.setSwitchToSelectToolAfterDrawingItem(enabled); } void KImageAnnotator::setNumberToolSeedChangeUpdatesAllItems(bool enabled) { Q_D(KImageAnnotator); auto mode = enabled ? NumberUpdateMode::UpdateAllNumbers : NumberUpdateMode::UpdateOnlyNewNumbers; d->mConfig.setNumberToolUpdateMode(mode); } void KImageAnnotator::setTabBarAutoHide(bool enabled) { Q_D(KImageAnnotator); d->mCoreView.setTabBarAutoHide(enabled); } void KImageAnnotator::removeTab(int index) { Q_D(KImageAnnotator); d->mCoreView.removeTab(index); } void KImageAnnotator::showAnnotator() { Q_D(KImageAnnotator); d->mCoreView.showAnnotator(); } void KImageAnnotator::showCropper() { Q_D(KImageAnnotator); d->mCoreView.showCropper(); } void KImageAnnotator::showScaler() { Q_D(KImageAnnotator); d->mCoreView.showScaler(); } void KImageAnnotator::showRotator() { Q_D(KImageAnnotator); d->mCoreView.showRotator(); } void KImageAnnotator::showCanvasModifier() { Q_D(KImageAnnotator); d->mCoreView.showCanvasModifier(); } void KImageAnnotator::showCutter() { Q_D(KImageAnnotator); d->mCoreView.showCutter(); } void KImageAnnotator::setSettingsCollapsed(bool isCollapsed) { Q_D(KImageAnnotator); d->mCoreView.setSettingsCollapsed(isCollapsed); } void KImageAnnotator::setStickers(const QStringList &stickerPaths, bool keepDefault) { Q_D(KImageAnnotator); d->mCoreView.setStickers(stickerPaths, keepDefault); } void KImageAnnotator::addTabContextMenuActions(const QList &actions) { Q_D(KImageAnnotator); d->mCoreView.addTabContextMenuActions(actions); } void KImageAnnotator::setCanvasColor(const QColor &color) { Q_D(KImageAnnotator); d->mConfig.setCanvasColor(color); } void KImageAnnotator::setSelectItemAfterDrawing(bool enabled) { Q_D(KImageAnnotator); d->mConfig.setSelectItemAfterDrawing(enabled); } void KImageAnnotator::setControlsWidgetVisible(bool enabled) { Q_D(KImageAnnotator); d->mCoreView.setControlsWidgetVisible(enabled); } // KImageAnnotatorPrivate KImageAnnotatorPrivate::KImageAnnotatorPrivate(KImageAnnotator *kImageAnnotator) : q_ptr(kImageAnnotator), mConfig(QSharedPointer(new SettingsAdapter)), mCoreView(&mConfig) { initResource(); mMainLayout.addWidget(&mCoreView); kImageAnnotator->setLayout(&mMainLayout); kImageAnnotator->hide(); kImageAnnotator->connect(&mCoreView, &CoreView::imageChanged, kImageAnnotator, &KImageAnnotator::imageChanged); kImageAnnotator->connect(&mCoreView, &CoreView::currentTabChanged, kImageAnnotator, &KImageAnnotator::currentTabChanged); kImageAnnotator->connect(&mCoreView, &CoreView::tabCloseRequested, kImageAnnotator, &KImageAnnotator::tabCloseRequested); kImageAnnotator->connect(&mCoreView, &CoreView::tabMoved, kImageAnnotator, &KImageAnnotator::tabMoved); kImageAnnotator->connect(&mCoreView, &CoreView::tabContextMenuOpened, kImageAnnotator, &KImageAnnotator::tabContextMenuOpened); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/000077500000000000000000000000001440330760000201565ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/annotator/AnnotationView.cpp000066400000000000000000000022771440330760000236370ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationView.h" namespace kImageAnnotator { AnnotationView::AnnotationView(QWidget *parent) : ScrollAndZoomView(parent) { } void AnnotationView::drawBackground(QPainter *painter, const QRectF &rect) { auto annotationArea = dynamic_cast(scene()); mCanvasPainter.paint(painter, annotationArea->canvasRect(), annotationArea->canvasColor()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/AnnotationView.h000066400000000000000000000030641440330760000232770ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONVIEW_H #define KIMAGEANNOTATOR_ANNOTATIONVIEW_H #include #include #include #include "src/gui/scrollAndZoomView/ScrollAndZoomView.h" #include "src/common/helper/KeyHelper.h" #include "src/annotations/core/AnnotationArea.h" #include "src/annotations/misc/CanvasPainter.h" #include "src/gui/scrollAndZoomView/ViewZoomer.h" namespace kImageAnnotator { class AnnotationView : public ScrollAndZoomView { Q_OBJECT public: explicit AnnotationView(QWidget *parent); ~AnnotationView() override = default; protected: void drawBackground(QPainter *painter, const QRectF &rect) override; private: CanvasPainter mCanvasPainter; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONVIEW_H kImageAnnotator-0.6.1/src/gui/annotator/AnnotationWidget.cpp000066400000000000000000000162211440330760000241420ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationWidget.h" namespace kImageAnnotator { AnnotationWidget::AnnotationWidget(Config *config) : mConfig(config), mItemSettings(new AnnotationItemSettings()), mGeneralSettings(new AnnotationGeneralSettings), mToolSelection(new AnnotationToolSelection), mImageSettings(new AnnotationImageSettings), mControlsWidget(new AnnotationControlsWidget), mSettingsAdapter(new AnnotationSettingsAdapter(mGeneralSettings, mItemSettings, mToolSelection, mImageSettings, mControlsWidget, config)), mAnnotationTabWidget(new AnnotationTabWidget(config, mSettingsAdapter)), mControlsDockWidget(nullptr) { initGui(); restoreDockWidgetsState(); } AnnotationWidget::~AnnotationWidget() { delete mSettingsAdapter; delete mItemSettings; delete mToolSelection; delete mImageSettings; delete mControlsWidget; delete mGeneralSettings; } QSize AnnotationWidget::sizeHint() const { auto offset = ScaledSizeProvider::scaledSize(QSize(100, 100)); return QMainWindow::sizeHint() + offset; } void AnnotationWidget::initGui() { setCentralWidget(mAnnotationTabWidget); insertDockWidget(Qt::LeftDockWidgetArea, mToolSelection); insertDockWidget(Qt::TopDockWidgetArea, mItemSettings); insertDockWidget(Qt::BottomDockWidgetArea, mGeneralSettings); insertDockWidget(Qt::BottomDockWidgetArea, mImageSettings); setFocusPolicy(Qt::ClickFocus); connect(mAnnotationTabWidget, &AnnotationTabWidget::imageChanged, this, &AnnotationWidget::imageChanged); connect(mAnnotationTabWidget, &AnnotationTabWidget::currentChanged, this, &AnnotationWidget::currentTabChanged); connect(mAnnotationTabWidget, &AnnotationTabWidget::tabCloseRequested, this, &AnnotationWidget::tabCloseRequested); connect(mAnnotationTabWidget, &AnnotationTabWidget::tabMoved, this, &AnnotationWidget::tabMoved); connect(mAnnotationTabWidget, &AnnotationTabWidget::tabContextMenuOpened, this, &AnnotationWidget::tabContextMenuOpened); connect(mControlsWidget, &AnnotationControlsWidget::undo, mAnnotationTabWidget, &AnnotationTabWidget::undoTriggered); connect(mControlsWidget, &AnnotationControlsWidget::redo, mAnnotationTabWidget, &AnnotationTabWidget::redoTriggered); connect(mControlsWidget, &AnnotationControlsWidget::showScale, this, &AnnotationWidget::activateScale); connect(mControlsWidget, &AnnotationControlsWidget::showCrop, this, &AnnotationWidget::activateCrop); connect(mControlsWidget, &AnnotationControlsWidget::showRotate, this, &AnnotationWidget::activateRotate); connect(mControlsWidget, &AnnotationControlsWidget::showModifyCanvas, this, &AnnotationWidget::activateModifyCanvas); connect(mControlsWidget, &AnnotationControlsWidget::showCut, this, &AnnotationWidget::activateCut); connect(qApp, &QCoreApplication::aboutToQuit, this, &AnnotationWidget::persistDockWidgets); } AnnotationDockWidget *AnnotationWidget::insertDockWidget(Qt::DockWidgetArea area, AbstractAnnotationDockWidgetContent *content) { auto dockWidget = new AnnotationDockWidget(content); mDockWidgets.append(dockWidget); addDockWidget(area, dockWidget); return dockWidget; } QImage AnnotationWidget::image() const { auto currentAnnotationArea = annotationArea(); return currentAnnotationArea != nullptr ? currentAnnotationArea->image() : QImage(); } QImage AnnotationWidget::imageAt(int index) const { auto annotationArea = annotationAreaAt(index); return annotationArea != nullptr ? annotationArea->image() : QImage(); } void AnnotationWidget::loadImage(const QPixmap &pixmap) { auto currentAnnotationArea = annotationArea(); auto currentIndex = mAnnotationTabWidget->currentIndex(); if (currentIndex <= 0 && currentAnnotationArea == nullptr) { insertTab(0, pixmap, QString(), QString()); } else { removeTab(currentIndex); addTab(pixmap, QString(), QString()); } } int AnnotationWidget::addTab(const QPixmap &pixmap, const QString &title, const QString &toolTip) { return mAnnotationTabWidget->addTab(pixmap, title, toolTip); } int AnnotationWidget::insertTab(int index, const QPixmap &pixmap, const QString &title, const QString &toolTip) { return mAnnotationTabWidget->insertTab(index, pixmap, title, toolTip); } void AnnotationWidget::updateTabInfo(int index, const QString &title, const QString &toolTip) { mAnnotationTabWidget->updateTabInfo(index, title, toolTip); } void AnnotationWidget::insertImageItem(const QPointF &position, const QPixmap &pixmap) const { auto currentAnnotationArea = annotationArea(); if(currentAnnotationArea != nullptr) { currentAnnotationArea->insertImageItem(position, pixmap); } } void AnnotationWidget::removeTab(int index) { mAnnotationTabWidget->removeTab(index); } void AnnotationWidget::setUndoEnabled(bool enabled) { mAnnotationTabWidget->setUndoRedoEnabled(enabled); } QAction *AnnotationWidget::undoAction() const { return mAnnotationTabWidget->undoAction(); } QAction *AnnotationWidget::redoAction() const { return mAnnotationTabWidget->redoAction(); } void AnnotationWidget::clearSelection() const { auto currentAnnotationArea = annotationArea(); if(currentAnnotationArea != nullptr) { annotationArea()->clearSelection(); } } AnnotationArea *AnnotationWidget::annotationArea() const { return mAnnotationTabWidget->currentAnnotationArea(); } AnnotationArea *AnnotationWidget::annotationAreaAt(int index) const { return mAnnotationTabWidget->annotationAreaAt(index); } void AnnotationWidget::reloadConfig() { mSettingsAdapter->reloadConfig(); } void AnnotationWidget::setTabBarAutoHide(bool enabled) { mAnnotationTabWidget->setTabBarAutoHide(enabled); } void AnnotationWidget::setStickers(const QStringList &stickerPaths, bool keepDefault) { mItemSettings->setStickers(stickerPaths, keepDefault); } void AnnotationWidget::addTabContextMenuActions(const QList &actions) { mAnnotationTabWidget->addContextMenuActions(actions); } void AnnotationWidget::setSettingsCollapsed(bool isCollapsed) { for(auto dockWidget : mDockWidgets) { dockWidget->setCollapsed(isCollapsed); } } void AnnotationWidget::setControlsWidgetVisible(bool enabled) { if (enabled) { if (mControlsDockWidget == nullptr) { mControlsDockWidget = insertDockWidget(Qt::BottomDockWidgetArea, mControlsWidget); } restoreDockWidgetsState(); } else { removeDockWidget(mControlsDockWidget); } } void AnnotationWidget::persistDockWidgets() { mConfig->setAnnotatorDockWidgetsState(saveState()); } void AnnotationWidget::restoreDockWidgetsState() { restoreState(mConfig->annotatorDockWidgetsState()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/AnnotationWidget.h000066400000000000000000000066631440330760000236200ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONWIDGET_H #define KIMAGEANNOTATOR_ANNOTATIONWIDGET_H #include #include #include #include #include "src/gui/annotator/settings/AnnotationSettingsAdapter.h" #include "src/gui/annotator/docks/AnnotationDockWidget.h" #include "src/gui/annotator/tabs/AnnotationTabWidget.h" #include "src/annotations/core/AnnotationArea.h" #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class AnnotationWidget : public QMainWindow { Q_OBJECT public: explicit AnnotationWidget(Config *config); ~AnnotationWidget() override; QSize sizeHint() const override; QImage image() const; QImage imageAt(int index) const; void loadImage(const QPixmap &pixmap); int addTab(const QPixmap &pixmap, const QString &title, const QString &toolTip); int insertTab(int index, const QPixmap &pixmap, const QString &title, const QString &toolTip); void updateTabInfo(int index, const QString &title, const QString &toolTip); void insertImageItem(const QPointF &position, const QPixmap &pixmap) const; void removeTab(int index); void setUndoEnabled(bool enabled); QAction* undoAction() const; QAction* redoAction() const; void clearSelection() const; AnnotationArea* annotationArea() const; AnnotationArea *annotationAreaAt(int index) const; void reloadConfig(); void setTabBarAutoHide(bool enabled); void setStickers(const QStringList &stickerPaths, bool keepDefault); void addTabContextMenuActions(const QList & actions); void setSettingsCollapsed(bool isCollapsed); void setControlsWidgetVisible(bool enabled); signals: void imageChanged() const; void currentTabChanged(int index) const; void tabCloseRequested(int index) const; void tabMoved(int fromIndex, int toIndex); void tabContextMenuOpened(int index) const; void activateScale() const; void activateCrop() const; void activateRotate() const; void activateModifyCanvas() const; void activateCut() const; private: Config *mConfig; AnnotationItemSettings *mItemSettings; AnnotationGeneralSettings *mGeneralSettings; AnnotationToolSelection *mToolSelection; AnnotationImageSettings *mImageSettings; AnnotationControlsWidget *mControlsWidget; AnnotationSettingsAdapter *mSettingsAdapter; AnnotationTabWidget *mAnnotationTabWidget; QList mDockWidgets; AnnotationDockWidget *mControlsDockWidget; void initGui(); AnnotationDockWidget *insertDockWidget(Qt::DockWidgetArea area, AbstractAnnotationDockWidgetContent *content); private slots: void persistDockWidgets(); void restoreDockWidgetsState(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONWIDGET_H kImageAnnotator-0.6.1/src/gui/annotator/docks/000077500000000000000000000000001440330760000212615ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/annotator/docks/AbstractAnnotationDockWidgetContent.cpp000066400000000000000000000031371440330760000310670ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractAnnotationDockWidgetContent.h" namespace kImageAnnotator { void AbstractAnnotationDockWidgetContent::setOrientation(Qt::Orientation orientation) { auto mainLayout = dynamic_cast(layout()); if(mainLayout != nullptr) { if(orientation == Qt::Horizontal) { mainLayout->setDirection(QBoxLayout::LeftToRight); mainLayout->setAlignment(Qt::AlignLeft | Qt::AlignCenter); } else { mainLayout->setDirection(QBoxLayout::TopToBottom); mainLayout->setAlignment(Qt::AlignTop | Qt::AlignCenter); } for (auto widget : mExpandingWidget) { widget->setExpanding(orientation != Qt::Horizontal); } adjustSize(); } } void AbstractAnnotationDockWidgetContent::addExpandingWidget(AbstractExpandingWidget *widget) { mExpandingWidget.append(widget); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/annotator/docks/AbstractAnnotationDockWidgetContent.h000066400000000000000000000031011440330760000305230ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTANNOTATIONDOCKWIDGETCONTENT_H #define KIMAGEANNOTATOR_ABSTRACTANNOTATIONDOCKWIDGETCONTENT_H #include #include #include #include #include "src/widgets/misc/AbstractExpandingWidget.h" namespace kImageAnnotator { class AbstractAnnotationDockWidgetContent : public QWidget { public: AbstractAnnotationDockWidgetContent() = default; ~AbstractAnnotationDockWidgetContent() override = default; virtual void setOrientation(Qt::Orientation orientation); virtual QString name() const = 0; protected: void addExpandingWidget(AbstractExpandingWidget *widget); private: QList mExpandingWidget; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTANNOTATIONDOCKWIDGETCONTENT_H kImageAnnotator-0.6.1/src/gui/annotator/docks/AnnotationDockWidget.cpp000066400000000000000000000056101440330760000260460ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationDockWidget.h" namespace kImageAnnotator { AnnotationDockWidget::AnnotationDockWidget(AbstractAnnotationDockWidgetContent *content) : QDockWidget(content->name()), mContent(content), mDragHandle(new AnnotationDockWidgetDragHandle(this)), mVerticalFeatures(features() ^ QDockWidget::DockWidgetFloatable), mHorizontalFeatures(QDockWidget::DockWidgetVerticalTitleBar | mVerticalFeatures) { setObjectName(content->name()); setAllowedAreas(Qt::AllDockWidgetAreas); setSizePolicy(QSizePolicy::Policy::Ignored, QSizePolicy::Policy::Ignored); setTitleBarWidget(mDragHandle); setToolTip(mContent->name()); setWidget(content); connect(this, &QDockWidget::dockLocationChanged, this, &AnnotationDockWidget::updateDockLocation); } AnnotationDockWidget::~AnnotationDockWidget() { delete mDragHandle; } void AnnotationDockWidget::setCollapsed(bool isCollapsed) { if (isCollapsed) { mSizeBeforeCollapse = size(); setFixedSize(0, 0); } else if (mSizeBeforeCollapse.isValid()){ // Workaround for issue Issue #240 that prevents the bug on auto hide panels setFixedSize(mSizeBeforeCollapse); setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX); mSizeBeforeCollapse = QSize(); } } void AnnotationDockWidget::updateDockLocation(Qt::DockWidgetArea area) { if(area == Qt::TopDockWidgetArea || area == Qt::BottomDockWidgetArea) { setOrientation(Qt::Horizontal, mHorizontalFeatures); } else if (area == Qt::LeftDockWidgetArea || area == Qt::RightDockWidgetArea) { setOrientation(Qt::Vertical, mVerticalFeatures); } else { resizeToDragHandle(); } } void AnnotationDockWidget::setOrientation(Qt::Orientation orientation, QDockWidget::DockWidgetFeatures &features) { mContent->setOrientation(orientation); mDragHandle->setOrientation(orientation); setFeatures(features); resizeToContent(); } void AnnotationDockWidget::resizeToDragHandle() { auto offset = ScaledSizeProvider::scaledSize(QSize(2, 3)); setFixedSize(mDragHandle->sizeHint() + offset); } void AnnotationDockWidget::resizeToContent() { setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX); setMinimumSize(0, 0); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/docks/AnnotationDockWidget.h000066400000000000000000000035001440330760000255070ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONDOCKWIDGET_H #define KIMAGEANNOTATOR_ANNOTATIONDOCKWIDGET_H #include #include "AbstractAnnotationDockWidgetContent.h" #include "AnnotationDockWidgetDragHandle.h" #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class AnnotationDockWidget : public QDockWidget { Q_OBJECT public: explicit AnnotationDockWidget(AbstractAnnotationDockWidgetContent *content); ~AnnotationDockWidget() override; void setCollapsed(bool isCollapsed); private: AbstractAnnotationDockWidgetContent *mContent; AnnotationDockWidgetDragHandle *mDragHandle; QDockWidget::DockWidgetFeatures mVerticalFeatures; QDockWidget::DockWidgetFeatures mHorizontalFeatures; QSize mSizeBeforeCollapse; void resizeToContent(); private slots: void updateDockLocation(Qt::DockWidgetArea area); void setOrientation(Qt::Orientation orientation, QDockWidget::DockWidgetFeatures &features); void resizeToDragHandle(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONDOCKWIDGET_H kImageAnnotator-0.6.1/src/gui/annotator/docks/AnnotationDockWidgetDragHandle.cpp000066400000000000000000000051521440330760000277610ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationDockWidgetDragHandle.h" namespace kImageAnnotator { AnnotationDockWidgetDragHandle::AnnotationDockWidgetDragHandle(QWidget *parent) : QWidget(parent), mLabel(new QLabel(this)), mLayout(new QHBoxLayout(this)) { QTransform t; t.rotate(90); mHorizontalHandlerImage = IconLoader::loadAsPixmap(QLatin1String("dragHandle.svg")); mVerticalHandlerImage = mHorizontalHandlerImage.transformed(t); setContextMenuPolicy(Qt::PreventContextMenu); initGui(); } QSize AnnotationDockWidgetDragHandle::sizeHint() const { return QWidget::sizeHint(); } QSize AnnotationDockWidgetDragHandle::minimumSizeHint() const { return QWidget::sizeHint(); } void AnnotationDockWidgetDragHandle::paintEvent(QPaintEvent *event) { QWidget::paintEvent(event); } void AnnotationDockWidgetDragHandle::mouseDoubleClickEvent(QMouseEvent *event) { event->ignore(); } void AnnotationDockWidgetDragHandle::mouseMoveEvent(QMouseEvent *event) { event->ignore(); } void AnnotationDockWidgetDragHandle::mousePressEvent(QMouseEvent *event) { event->ignore(); } void AnnotationDockWidgetDragHandle::mouseReleaseEvent(QMouseEvent *event) { event->ignore(); } void AnnotationDockWidgetDragHandle::setOrientation(Qt::Orientation orientation) { if (orientation == Qt::Horizontal) { mLabel->setPixmap(mHorizontalHandlerImage); } else { mLabel->setPixmap(mVerticalHandlerImage); } } void AnnotationDockWidgetDragHandle::initGui() { auto leftMargin = ScaledSizeProvider::scaledWidth(5); auto topMargin = ScaledSizeProvider::scaledWidth(5); auto rightMargin = 0; auto bottomMargin = ScaledSizeProvider::scaledWidth(2); mLayout->addWidget(mLabel); mLayout->setAlignment(Qt::AlignCenter); mLayout->setContentsMargins(leftMargin, topMargin, rightMargin, bottomMargin); setCursor(Qt::SizeAllCursor); setLayout(mLayout); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/docks/AnnotationDockWidgetDragHandle.h000066400000000000000000000036311440330760000274260ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONDOCKWIDGETDRAGHANDLE_H #define KIMAGEANNOTATOR_ANNOTATIONDOCKWIDGETDRAGHANDLE_H #include #include #include #include #include "src/common/helper/IconLoader.h" #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class AnnotationDockWidgetDragHandle : public QWidget { Q_OBJECT public: explicit AnnotationDockWidgetDragHandle(QWidget *parent); ~AnnotationDockWidgetDragHandle() override = default; QSize sizeHint() const override; QSize minimumSizeHint() const override; void setOrientation(Qt::Orientation orientation); protected: void paintEvent(QPaintEvent *event) override; void mouseDoubleClickEvent(QMouseEvent *event) override; void mouseMoveEvent(QMouseEvent *event) override; void mousePressEvent(QMouseEvent *event) override; void mouseReleaseEvent(QMouseEvent *event) override; private: QPixmap mVerticalHandlerImage; QPixmap mHorizontalHandlerImage; QLabel *mLabel; QHBoxLayout *mLayout; void initGui(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONDOCKWIDGETDRAGHANDLE_H kImageAnnotator-0.6.1/src/gui/annotator/settings/000077500000000000000000000000001440330760000220165ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationControlsWidget.cpp000066400000000000000000000037201440330760000275260ustar00rootroot00000000000000/* * Copyright (C) 2021 Antonio Prcela * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationControlsWidget.h" namespace kImageAnnotator { AnnotationControlsWidget::AnnotationControlsWidget() : mMainLayout(new QBoxLayout(QBoxLayout::LeftToRight)), mControls(new Controls(this)) { mMainLayout->addWidget(mControls); mMainLayout->setContentsMargins(0, 0, 0, 0); connect(mControls, &Controls::undo, this, &AnnotationControlsWidget::undo); connect(mControls, &Controls::redo, this, &AnnotationControlsWidget::redo); connect(mControls, &Controls::crop, this, &AnnotationControlsWidget::showCrop); connect(mControls, &Controls::scale, this, &AnnotationControlsWidget::showScale); connect(mControls, &Controls::rotate, this, &AnnotationControlsWidget::showRotate); connect(mControls, &Controls::modifyCanvas, this, &AnnotationControlsWidget::showModifyCanvas); connect(mControls, &Controls::cut, this, &AnnotationControlsWidget::showCut); setLayout(mMainLayout); setFocusPolicy(Qt::ClickFocus); } void AnnotationControlsWidget::setOrientation(Qt::Orientation orientation) { AbstractAnnotationDockWidgetContent::setOrientation(orientation); } QString AnnotationControlsWidget::name() const { return tr("Controls"); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationControlsWidget.h000066400000000000000000000031541440330760000271740ustar00rootroot00000000000000/* * Copyright (C) 2021 Antonio Prcela * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONCONTROLSWIDGET_H #define KIMAGEANNOTATOR_ANNOTATIONCONTROLSWIDGET_H #include "src/gui/annotator/docks/AbstractAnnotationDockWidgetContent.h" #include "src/widgets/Controls.h" namespace kImageAnnotator { class AnnotationControlsWidget : public AbstractAnnotationDockWidgetContent { Q_OBJECT public: AnnotationControlsWidget(); ~AnnotationControlsWidget() override = default; void setOrientation(Qt::Orientation orientation) override; QString name() const override; Q_SIGNALS: void undo() const; void redo() const; void showCrop() const; void showScale() const; void showRotate() const; void showModifyCanvas() const; void showCut() const; private: QBoxLayout *mMainLayout; Controls *mControls; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONCONTROLSWIDGET_H kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationGeneralSettings.cpp000066400000000000000000000033651440330760000276620ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationGeneralSettings.h" namespace kImageAnnotator { AnnotationGeneralSettings::AnnotationGeneralSettings() : mMainLayout(new QBoxLayout(QBoxLayout::LeftToRight)), mZoomPicker(new ZoomPicker(this)) { initGui(); } AnnotationGeneralSettings::~AnnotationGeneralSettings() { delete mZoomPicker; } void AnnotationGeneralSettings::initGui() { mMainLayout->addWidget(mZoomPicker); mMainLayout->setContentsMargins(3, 0, 3, 0); addExpandingWidget(mZoomPicker); setLayout(mMainLayout); setFocusPolicy(Qt::ClickFocus); connect(mZoomPicker, &ZoomPicker::zoomValueChanged, this, &AnnotationGeneralSettings::zoomValueChanged); connect(mZoomPicker, &ZoomPicker::fitImageToView, this, &AnnotationGeneralSettings::fitImageToCurrentView); } void AnnotationGeneralSettings::updateZoomLevel(double value) { mZoomPicker->setZoomValue(value); } QString AnnotationGeneralSettings::name() const { return tr("General Settings"); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationGeneralSettings.h000066400000000000000000000030251440330760000273200ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONGENERALSETTINGS_H #define KIMAGEANNOTATOR_ANNOTATIONGENERALSETTINGS_H #include "src/gui/annotator/docks/AbstractAnnotationDockWidgetContent.h" #include "src/widgets/settingsPicker/ZoomPicker.h" namespace kImageAnnotator { class AnnotationGeneralSettings : public AbstractAnnotationDockWidgetContent { Q_OBJECT public: explicit AnnotationGeneralSettings(); ~AnnotationGeneralSettings() override; void updateZoomLevel(double value); QString name() const override; signals: void zoomValueChanged(double value); void fitImageToCurrentView(); private: QBoxLayout *mMainLayout; ZoomPicker *mZoomPicker; void initGui(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONGENERALSETTINGS_H kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationImageSettings.cpp000066400000000000000000000033421440330760000273220ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationImageSettings.h" namespace kImageAnnotator { AnnotationImageSettings::AnnotationImageSettings() : mMainLayout(new QBoxLayout(QBoxLayout::LeftToRight)), mEffectPicker(new ImageEffectPicker(this)) { initGui(); } AnnotationImageSettings::~AnnotationImageSettings() { delete mEffectPicker; } ImageEffects AnnotationImageSettings::effect() const { return mEffectPicker->effect(); } void AnnotationImageSettings::setEffect(ImageEffects effect) { mEffectPicker->setEffect(effect); } QString AnnotationImageSettings::name() const { return tr("Image Settings"); } void AnnotationImageSettings::initGui() { mMainLayout->addWidget(mEffectPicker); mMainLayout->setContentsMargins(3, 0, 3, 0); addExpandingWidget(mEffectPicker); setLayout(mMainLayout); setFocusPolicy(Qt::ClickFocus); connect(mEffectPicker, &ImageEffectPicker::effectSelected, this, &AnnotationImageSettings::effectChanged); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationImageSettings.h000066400000000000000000000030351440330760000267660ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONIMAGESETTINGS_H #define KIMAGEANNOTATOR_ANNOTATIONIMAGESETTINGS_H #include "src/gui/annotator/docks/AbstractAnnotationDockWidgetContent.h" #include "src/widgets/settingsPicker/ImageEffectPicker.h" namespace kImageAnnotator { class AnnotationImageSettings : public AbstractAnnotationDockWidgetContent { Q_OBJECT public: explicit AnnotationImageSettings(); ~AnnotationImageSettings() override; ImageEffects effect() const; void setEffect(ImageEffects effect); QString name() const override; signals: void effectChanged(ImageEffects effect); private: QBoxLayout *mMainLayout; ImageEffectPicker *mEffectPicker; void initGui(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONIMAGESETTINGS_H kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationItemSettings.cpp000066400000000000000000000177351440330760000272110ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemSettings.h" namespace kImageAnnotator { AnnotationItemSettings::AnnotationItemSettings() : mMainLayout(new QBoxLayout(QBoxLayout::LeftToRight)), mColorPicker(new ColorPicker(this)), mWidthPicker(new NumberPicker(this)), mTextColorPicker(new ColorPicker(this)), mFillModePicker(new FillModePicker(this)), mNumberToolSeedPicker(new NumberPicker(this)), mObfuscateFactorPicker(new NumberPicker(this)), mStickerPicker(new StickerPicker(this)), mShadowPicker(new BoolPicker(this)), mFontPicker(new FontPicker(this)), mOpacityPicker(new NumberPicker(this)), mScalingPicker(new NumberPicker(this)) { initGui(); } void AnnotationItemSettings::initGui() { mColorPicker->setIcon(IconLoader::load(QLatin1String("color.svg"))); mColorPicker->setToolTip(tr("Color")); mTextColorPicker->setIcon(IconLoader::load(QLatin1String("textColor.svg"))); mTextColorPicker->setToolTip(tr("Text Color")); mWidthPicker->setIcon(IconLoader::load(QLatin1String("width.svg"))); mWidthPicker->setToolTip(tr("Width")); mNumberToolSeedPicker->setIcon(IconLoader::load(QLatin1String("number.svg"))); mNumberToolSeedPicker->setToolTip(tr("Number Seed")); mNumberToolSeedPicker->setRange(1, 100); mObfuscateFactorPicker->setIcon(IconLoader::load(QLatin1String("obfuscateFactor.svg"))); mObfuscateFactorPicker->setToolTip(tr("Obfuscation Factor")); mShadowPicker->setIcon(IconLoader::load(QLatin1String("dropShadow.svg"))); mShadowPicker->setToolTip(tr("Item Shadow")); mScalingPicker->setIcon(IconLoader::load(QLatin1String("scale.svg"))); mScalingPicker->setToolTip(tr("Scale")); mScalingPicker->setRange(0, 500); mScalingPicker->setSuffix(QLatin1String("%")); mScalingPicker->setSingleStep(10); mOpacityPicker->setIcon(IconLoader::load(QLatin1String("opacity.svg"))); mOpacityPicker->setToolTip(tr("Opacity")); mOpacityPicker->setRange(0, 100); mOpacityPicker->setSuffix(QLatin1String("%")); mOpacityPicker->setSingleStep(10); insertPickerWidget(mColorPicker); insertPickerWidget(mWidthPicker); insertPickerWidget(mFillModePicker); insertPickerWidget(mTextColorPicker); insertPickerWidget(mFontPicker); insertPickerWidget(mNumberToolSeedPicker); insertPickerWidget(mObfuscateFactorPicker); insertPickerWidget(mStickerPicker); insertPickerWidget(mShadowPicker); insertPickerWidget(mScalingPicker); insertPickerWidget(mOpacityPicker); mWidgetConfigurator.setColorWidget(mColorPicker); mWidgetConfigurator.setTextColorWidget(mTextColorPicker); mWidgetConfigurator.setWidthWidget(mWidthPicker); mWidgetConfigurator.setFillTypeWidget(mFillModePicker); mWidgetConfigurator.setFirstNumberWidget(mNumberToolSeedPicker); mWidgetConfigurator.setObfuscateFactorWidget(mObfuscateFactorPicker); mWidgetConfigurator.setStickerWidget(mStickerPicker); mWidgetConfigurator.setShadowWidget(mShadowPicker); mWidgetConfigurator.setFontWidget(mFontPicker); mWidgetConfigurator.setScalingWidget(mScalingPicker); mWidgetConfigurator.setOpacityWidget(mOpacityPicker); mMainLayout->setContentsMargins(3, 0, 3, 0); setLayout(mMainLayout); setFocusPolicy(Qt::ClickFocus); connect(mColorPicker, &ColorPicker::colorSelected, this, &AnnotationItemSettings::toolColorChanged); connect(mWidthPicker, &NumberPicker::numberSelected, this, &AnnotationItemSettings::toolWidthChanged); connect(mTextColorPicker, &ColorPicker::colorSelected, this, &AnnotationItemSettings::toolTextColorChanged); connect(mFillModePicker, &FillModePicker::fillSelected, this, &AnnotationItemSettings::toolFillTypeChanged); connect(mNumberToolSeedPicker, &NumberPicker::numberSelected, this, &AnnotationItemSettings::notifyNumberToolSeedChanged); connect(mObfuscateFactorPicker, &NumberPicker::numberSelected, this, &AnnotationItemSettings::obfuscateFactorChanged); connect(mStickerPicker, &StickerPicker::stickerSelected, this, &AnnotationItemSettings::stickerChanged); connect(mShadowPicker, &BoolPicker::enabledStateChanged, this, &AnnotationItemSettings::shadowEnabledChanged); connect(mFontPicker, &FontPicker::fontChanged, this, &AnnotationItemSettings::fontChanged); connect(mOpacityPicker, &NumberPicker::numberSelected, this, &AnnotationItemSettings::opacitySelected); connect(mScalingPicker, &NumberPicker::numberSelected, this, &AnnotationItemSettings::scalingSelected); } void AnnotationItemSettings::insertPickerWidget(SettingsPickerWidget *pickerWidget) { auto separator = new AttachedSeparator(pickerWidget); mMainLayout->addWidget(pickerWidget); mMainLayout->addWidget(separator); addExpandingWidget(pickerWidget); mSeparators.append(separator); } void AnnotationItemSettings::setUpForTool(Tools tool) { mWidgetConfigurator.setCurrentTool(tool); } QColor AnnotationItemSettings::toolColor() const { return mColorPicker->color(); } void AnnotationItemSettings::setToolColor(const QColor &color) { mColorPicker->setColor(color); } QColor AnnotationItemSettings::textColor() const { return mTextColorPicker->color(); } void AnnotationItemSettings::setTextColor(const QColor &color) { mTextColorPicker->setColor(color); } int AnnotationItemSettings::toolWidth() const { return mWidthPicker->number(); } void AnnotationItemSettings::setToolWidth(int width) { mWidthPicker->setNumber(width); } FillModes AnnotationItemSettings::fillMode() const { return mFillModePicker->fillType(); } void AnnotationItemSettings::setFillMode(FillModes mode) { mFillModePicker->setFillType(mode); } int AnnotationItemSettings::obfuscationFactor() const { return mObfuscateFactorPicker->number(); } void AnnotationItemSettings::setObfuscationFactor(int factor) { mObfuscateFactorPicker->setNumber(factor); } QString AnnotationItemSettings::sticker() const { return mStickerPicker->sticker(); } void AnnotationItemSettings::setStickers(const QStringList &stickerPaths, bool keepDefault) { mStickerPicker->setStickers(stickerPaths, keepDefault); } bool AnnotationItemSettings::shadowEnabled() const { return mShadowPicker->enabledState(); } void AnnotationItemSettings::setShadowEnabled(bool enabled) { mShadowPicker->setEnabledState(enabled); } void AnnotationItemSettings::updateNumberToolSeed(int numberToolSeed) { mNumberToolSeedPicker->setNumber(numberToolSeed); } QFont AnnotationItemSettings::font() const { return mFontPicker->currentFont(); } void AnnotationItemSettings::setFont(const QFont &font) { mFontPicker->setCurrentFont(font); } qreal AnnotationItemSettings::scaling() const { return mScalingPicker->number() / 100.0; } void AnnotationItemSettings::setScaling(qreal scaling) { mScalingPicker->setNumber(scaling * 100); } qreal AnnotationItemSettings::opacity() const { return mOpacityPicker->number() / 100.0; } void AnnotationItemSettings::setOpacity(qreal opacity) { mOpacityPicker->setNumber(opacity * 100); } QString AnnotationItemSettings::name() const { return tr("Item Settings"); } void AnnotationItemSettings::setOrientation(Qt::Orientation orientation) { for(auto separator : mSeparators) { separator->setEnabled(orientation == Qt::Horizontal); } AbstractAnnotationDockWidgetContent::setOrientation(orientation); } void AnnotationItemSettings::scalingSelected(int scaling) { emit scalingChanged(scaling / 100.0); } void AnnotationItemSettings::opacitySelected(int opacity) { emit opacityChanged(opacity / 100.0); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationItemSettings.h000066400000000000000000000072161440330760000266470ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMSETTINGS_H #define KIMAGEANNOTATOR_ANNOTATIONITEMSETTINGS_H #include "ItemSettingsWidgetConfigurator.h" #include "src/backend/Config.h" #include "src/widgets/settingsPicker/ColorPicker.h" #include "src/widgets/settingsPicker/NumberPicker.h" #include "src/widgets/settingsPicker/FillModePicker.h" #include "src/widgets/settingsPicker/StickerPicker.h" #include "src/widgets/settingsPicker/BoolPicker.h" #include "src/widgets/settingsPicker/FontPicker.h" #include "src/widgets/misc/AttachedSeparator.h" #include "src/gui/annotator/docks/AbstractAnnotationDockWidgetContent.h" #include "src/annotations/items/AbstractAnnotationItem.h" namespace kImageAnnotator { class AnnotationItemSettings : public AbstractAnnotationDockWidgetContent { Q_OBJECT public: explicit AnnotationItemSettings(); ~AnnotationItemSettings() override = default; void setUpForTool(Tools tool); QColor toolColor() const; void setToolColor(const QColor &color); QColor textColor() const; void setTextColor(const QColor &color); int toolWidth() const; void setToolWidth(int width); FillModes fillMode() const; void setFillMode(FillModes mode); int obfuscationFactor() const; void setObfuscationFactor(int factor); QString sticker() const; void setStickers(const QStringList &stickerPaths, bool keepDefault); bool shadowEnabled() const; void setShadowEnabled(bool enabled); void updateNumberToolSeed(int numberToolSeed); QFont font() const; void setFont(const QFont &font); qreal scaling() const; void setScaling(qreal scaling); qreal opacity() const; void setOpacity(qreal opacity); QString name() const override; void setOrientation(Qt::Orientation orientation) override; signals: void toolColorChanged(const QColor &color); void toolTextColorChanged(const QColor &color); void toolWidthChanged(int width); void toolFillTypeChanged(FillModes fill); void notifyNumberToolSeedChanged(int newNumberToolSeed); void obfuscateFactorChanged(int factor); void stickerChanged(const QString &sticker); void shadowEnabledChanged(bool enabled); void fontChanged(const QFont &font); void scalingChanged(qreal opacity); void opacityChanged(qreal opacity); private: QBoxLayout *mMainLayout; ColorPicker *mColorPicker; NumberPicker *mWidthPicker; ColorPicker *mTextColorPicker; FillModePicker *mFillModePicker; NumberPicker *mNumberToolSeedPicker; NumberPicker *mObfuscateFactorPicker; StickerPicker *mStickerPicker; BoolPicker *mShadowPicker; FontPicker *mFontPicker; NumberPicker *mOpacityPicker; NumberPicker *mScalingPicker; ItemSettingsWidgetConfigurator mWidgetConfigurator; QList mSeparators; void initGui(); void insertPickerWidget(SettingsPickerWidget *pickerWidget); private slots: void scalingSelected(int scaling); void opacitySelected(int opacity); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONITEMSETTINGS_H kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationSettingsAdapter.cpp000066400000000000000000000217751440330760000276720ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationSettingsAdapter.h" namespace kImageAnnotator { AnnotationSettingsAdapter::AnnotationSettingsAdapter( AnnotationGeneralSettings *generalSettings, AnnotationItemSettings *itemSettings, AnnotationToolSelection *toolSettings, AnnotationImageSettings *imageSettings, AnnotationControlsWidget *controls, Config *config) : mGeneralSettings(generalSettings), mItemSettings(itemSettings), mToolSettings(toolSettings), mImageSettings(imageSettings), mConfig(config) { connect(mToolSettings, &AnnotationToolSelection::toolTypeChanged, this, &AnnotationSettingsAdapter::toolTypeChanged); connect(mImageSettings, &AnnotationImageSettings::effectChanged, this, &AnnotationSettingsAdapter::effectChanged); connect(mGeneralSettings, &AnnotationGeneralSettings::zoomValueChanged, this, &AnnotationSettingsAdapter::zoomValueChanged); connect(mGeneralSettings, &AnnotationGeneralSettings::fitImageToCurrentView, this, &AnnotationSettingsAdapter::fitImageToCurrentView); connect(mItemSettings, &AnnotationItemSettings::toolColorChanged, this, &AnnotationSettingsAdapter::toolColorChanged); connect(mItemSettings, &AnnotationItemSettings::toolWidthChanged, this, &AnnotationSettingsAdapter::toolWidthChanged); connect(mItemSettings, &AnnotationItemSettings::toolTextColorChanged, this, &AnnotationSettingsAdapter::toolTextColorChanged); connect(mItemSettings, &AnnotationItemSettings::toolFillTypeChanged, this, &AnnotationSettingsAdapter::toolFillTypeChanged); connect(mItemSettings, &AnnotationItemSettings::notifyNumberToolSeedChanged, this, &AnnotationSettingsAdapter::notifyNumberToolSeedChanged); connect(mItemSettings, &AnnotationItemSettings::obfuscateFactorChanged, this, &AnnotationSettingsAdapter::obfuscateFactorChanged); connect(mItemSettings, &AnnotationItemSettings::stickerChanged, this, &AnnotationSettingsAdapter::stickerChanged); connect(mItemSettings, &AnnotationItemSettings::shadowEnabledChanged, this, &AnnotationSettingsAdapter::shadowEnabledChanged); connect(mItemSettings, &AnnotationItemSettings::fontChanged, this, &AnnotationSettingsAdapter::fontChanged); connect(mItemSettings, &AnnotationItemSettings::scalingChanged, this, &AnnotationSettingsAdapter::scalingChanged); connect(mItemSettings, &AnnotationItemSettings::opacityChanged, this, &AnnotationSettingsAdapter::opacityChanged); reloadConfig(); } void AnnotationSettingsAdapter::editItem(AbstractAnnotationItem *item) { activateSelectTool(); loadFromItem(item); mExistingItemEditInfo.startEdit(item->toolType()); } void AnnotationSettingsAdapter::activateSelectTool() { mToolSettings->setToolType(Tools::Select); mItemSettings->setUpForTool(Tools::Select); } Tools AnnotationSettingsAdapter::toolType() const { return mToolSettings->toolType(); } QColor AnnotationSettingsAdapter::toolColor() const { return mItemSettings->toolColor(); } QColor AnnotationSettingsAdapter::textColor() const { return mItemSettings->textColor(); } int AnnotationSettingsAdapter::toolWidth() const { return mItemSettings->toolWidth(); } QFont AnnotationSettingsAdapter::font() const { return mItemSettings->font(); } FillModes AnnotationSettingsAdapter::fillType() const { return mItemSettings->fillMode(); } int AnnotationSettingsAdapter::obfuscationFactor() const { return mItemSettings->obfuscationFactor(); } QString AnnotationSettingsAdapter::sticker() const { return mItemSettings->sticker(); } ImageEffects AnnotationSettingsAdapter::effect() const { return mImageSettings->effect(); } qreal AnnotationSettingsAdapter::scaling() const { return mItemSettings->scaling(); } qreal AnnotationSettingsAdapter::opacity() const { return mItemSettings->opacity(); } bool AnnotationSettingsAdapter::shadowEnabled() const { return mItemSettings->shadowEnabled(); } void AnnotationSettingsAdapter::updateNumberToolSeed(int numberToolSeed) { mItemSettings->updateNumberToolSeed(numberToolSeed); } void AnnotationSettingsAdapter::updateZoomLevel(double value) { mGeneralSettings->updateZoomLevel(value); } void AnnotationSettingsAdapter::reloadConfig() { mToolSettings->setToolType(mConfig->selectedTool()); mImageSettings->setEffect(ImageEffects::NoEffect); mItemSettings->setUpForTool(toolType()); } void AnnotationSettingsAdapter::effectChanged(ImageEffects effect) { AbstractSettingsProvider::effectChanged(effect); } void AnnotationSettingsAdapter::zoomValueChanged(double value) { AbstractSettingsProvider::zoomValueChanged(value); } void AnnotationSettingsAdapter::fitImageToCurrentView() { AbstractSettingsProvider::fitImageToView(); } void AnnotationSettingsAdapter::loadFromConfig(Tools tool) { mItemSettings->setUpForTool(tool); mItemSettings->setToolColor(mConfig->toolColor(tool)); mItemSettings->setTextColor(mConfig->toolTextColor(tool)); mItemSettings->setToolWidth(mConfig->toolWidth(tool)); mItemSettings->setFillMode(mConfig->toolFillType(tool)); mItemSettings->setFont(mConfig->toolFont(tool)); mItemSettings->setObfuscationFactor(mConfig->obfuscationFactor(tool)); mItemSettings->setShadowEnabled(mConfig->shadowEnabled(tool)); mItemSettings->setScaling(mConfig->toolScaling(tool)); mItemSettings->setOpacity(mConfig->toolOpacity(tool)); } void AnnotationSettingsAdapter::loadFromItem(const AbstractAnnotationItem *item) { auto properties = item->properties(); mItemSettings->setUpForTool(item->toolType()); mItemSettings->setToolColor(properties->color()); mItemSettings->setTextColor(properties->textColor()); mItemSettings->setToolWidth(properties->width()); mItemSettings->setFillMode(properties->fillType()); mItemSettings->setShadowEnabled(properties->shadowEnabled()); mItemSettings->setOpacity(properties->opacity()); auto textProperties = properties.dynamicCast(); if(textProperties != nullptr) { mItemSettings->setFont(textProperties->font()); } auto obfuscateProperties = properties.dynamicCast(); if(obfuscateProperties != nullptr) { mItemSettings->setObfuscationFactor(obfuscateProperties->factor()); } auto stickerProperties = properties.dynamicCast(); if(stickerProperties != nullptr) { mItemSettings->setScaling(stickerProperties->scaling()); } } void AnnotationSettingsAdapter::toolTypeChanged(Tools toolType) { mExistingItemEditInfo.stopEdit(); mConfig->setSelectedToolType(toolType); if(!mExistingItemEditInfo.isEdit()) { loadFromConfig(toolType); } toolChanged(toolType); } void AnnotationSettingsAdapter::toolColorChanged(const QColor &color) { configChanged([&](Tools tool){ mConfig->setToolColor(color, tool); }); } void AnnotationSettingsAdapter::toolTextColorChanged(const QColor &color) { configChanged([&](Tools tool){ mConfig->setToolTextColor(color, tool); }); } void AnnotationSettingsAdapter::toolWidthChanged(int width) { configChanged([&](Tools tool){ mConfig->setToolWidth(width, tool); }); } void AnnotationSettingsAdapter::toolFillTypeChanged(FillModes fill) { configChanged([&](Tools tool){ mConfig->setToolFillType(fill, tool); }); } void AnnotationSettingsAdapter::notifyNumberToolSeedChanged(int newNumberToolSeed) { numberToolSeedChanged(newNumberToolSeed); } void AnnotationSettingsAdapter::obfuscateFactorChanged(int factor) { configChanged([&](Tools tool){ mConfig->setObfuscationFactor(factor, tool); }); } void AnnotationSettingsAdapter::stickerChanged(const QString &sticker) { if(mExistingItemEditInfo.isEdit()) { itemSettingChanged(); } } void AnnotationSettingsAdapter::shadowEnabledChanged(bool enabled) { configChanged([&](Tools tool){ mConfig->setShadowEnabled(enabled, tool); }); } void AnnotationSettingsAdapter::fontChanged(const QFont &font) { configChanged([&](Tools tool){ mConfig->setToolFont(font, tool); }); } void AnnotationSettingsAdapter::opacityChanged(qreal opacity) { configChanged([&](Tools tool){ mConfig->setToolOpacity(opacity, tool); }); } void AnnotationSettingsAdapter::scalingChanged(qreal scaling) { configChanged([&](Tools tool){ mConfig->setToolScaling(scaling, tool); }); } void AnnotationSettingsAdapter::configChanged(const std::function &configChangedMethod) { if(mExistingItemEditInfo.isEdit()) { itemSettingChanged(); configChangedMethod(mExistingItemEditInfo.toolType()); } else { configChangedMethod(toolType()); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationSettingsAdapter.h000066400000000000000000000070731440330760000273320ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONSETTINGSADAPTER_H #define KIMAGEANNOTATOR_ANNOTATIONSETTINGSADAPTER_H #include "AnnotationGeneralSettings.h" #include "AnnotationItemSettings.h" #include "AnnotationToolSelection.h" #include "AnnotationImageSettings.h" #include "AnnotationControlsWidget.h" #include "ExistingItemEditInfo.h" #include "src/annotations/core/AbstractSettingsProvider.h" #include "src/annotations/properties/AnnotationTextProperties.h" #include "src/annotations/properties/AnnotationObfuscateProperties.h" #include "src/annotations/properties/AnnotationStickerProperties.h" namespace kImageAnnotator { class AnnotationSettingsAdapter : public QObject, public AbstractSettingsProvider { Q_OBJECT public: explicit AnnotationSettingsAdapter( AnnotationGeneralSettings *generalSettings, AnnotationItemSettings *itemSettings, AnnotationToolSelection *toolSettings, AnnotationImageSettings *imageSettings, AnnotationControlsWidget *controls, Config *config); ~AnnotationSettingsAdapter() override = default; void editItem(AbstractAnnotationItem *item) override; void activateSelectTool() override; Tools toolType() const override; QColor toolColor() const override; QColor textColor() const override; int toolWidth() const override; QFont font() const override; FillModes fillType() const override; int obfuscationFactor() const override; QString sticker() const override; ImageEffects effect() const override; qreal scaling() const override; qreal opacity() const override; bool shadowEnabled() const override; void updateNumberToolSeed(int numberToolSeed) override; void updateZoomLevel(double value) override; void reloadConfig(); private: AnnotationGeneralSettings *mGeneralSettings; AnnotationItemSettings *mItemSettings; AnnotationToolSelection *mToolSettings; AnnotationImageSettings *mImageSettings; Config *mConfig; ExistingItemEditInfo mExistingItemEditInfo; void configChanged(const std::function& configChangedMethod); private slots: void effectChanged(ImageEffects effect) override; void zoomValueChanged(double value) override; void toolTypeChanged(Tools toolType); void loadFromConfig(Tools tool); void loadFromItem(const AbstractAnnotationItem *item); void toolColorChanged(const QColor &color); void toolTextColorChanged(const QColor &color); void toolWidthChanged(int width); void toolFillTypeChanged(FillModes fill); void notifyNumberToolSeedChanged(int newNumberToolSeed); void obfuscateFactorChanged(int factor); void stickerChanged(const QString &sticker); void shadowEnabledChanged(bool enabled); void fontChanged(const QFont &font); void scalingChanged(qreal scaling); void opacityChanged(qreal opacity); void fitImageToCurrentView(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONSETTINGSADAPTER_H kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationToolSelection.cpp000066400000000000000000000036461440330760000273510ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationToolSelection.h" namespace kImageAnnotator { AnnotationToolSelection::AnnotationToolSelection() : mMainLayout(new QVBoxLayout), mToolPicker(new ToolPicker(this)), mScrollAreaToolPicker(new QScrollArea(this)) { mScrollAreaToolPicker->setWidgetResizable(true); mScrollAreaToolPicker->setFrameShape(QFrame::NoFrame); mScrollAreaToolPicker->setWidget(mToolPicker); mMainLayout->addWidget(mScrollAreaToolPicker); mMainLayout->setContentsMargins(0, 0, 0, 0); setLayout(mMainLayout); setFocusPolicy(Qt::ClickFocus); connect(mToolPicker, &ToolPicker::toolSelected, this, &AnnotationToolSelection::toolTypeChanged); } AnnotationToolSelection::~AnnotationToolSelection() { delete mToolPicker; } Tools AnnotationToolSelection::toolType() const { return mToolPicker->tool(); } void AnnotationToolSelection::setToolType(Tools tool) { mToolPicker->setTool(tool); } void AnnotationToolSelection::setOrientation(Qt::Orientation orientation) { AbstractAnnotationDockWidgetContent::setOrientation(orientation); } QString AnnotationToolSelection::name() const { return tr("Tool Selection"); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/settings/AnnotationToolSelection.h000066400000000000000000000030661440330760000270120ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTOOLSELECTION_H #define KIMAGEANNOTATOR_ANNOTATIONTOOLSELECTION_H #include "src/gui/annotator/docks/AbstractAnnotationDockWidgetContent.h" #include "src/widgets/ToolPicker.h" namespace kImageAnnotator { class AnnotationToolSelection : public AbstractAnnotationDockWidgetContent { Q_OBJECT public: AnnotationToolSelection(); ~AnnotationToolSelection() override; Tools toolType() const; void setToolType(Tools tool); void setOrientation(Qt::Orientation orientation) override; QString name() const override; signals: void toolTypeChanged(Tools toolType); private: QVBoxLayout *mMainLayout; ToolPicker *mToolPicker; QScrollArea *mScrollAreaToolPicker; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTOOLSELECTION_H kImageAnnotator-0.6.1/src/gui/annotator/settings/ExistingItemEditInfo.h000066400000000000000000000025521440330760000262260ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_EXISTINGITEMEDITINFO_H #define KIMAGEANNOTATOR_EXISTINGITEMEDITINFO_H namespace kImageAnnotator { struct ExistingItemEditInfo { public: ExistingItemEditInfo() { mIsEdit = false; mToolType = Tools::Select; } void startEdit(Tools tool) { mIsEdit = true; mToolType = tool; } void stopEdit() { mIsEdit = false; } bool isEdit() const { return mIsEdit; } Tools toolType() const { return mToolType; } private: bool mIsEdit; Tools mToolType; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_EXISTINGITEMEDITINFO_H kImageAnnotator-0.6.1/src/gui/annotator/settings/ItemSettingsWidgetConfigurator.cpp000066400000000000000000000311451440330760000306740ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ItemSettingsWidgetConfigurator.h" namespace kImageAnnotator { ItemSettingsWidgetConfigurator::ItemSettingsWidgetConfigurator() : mColorWidget(nullptr), mTextColorWidget(nullptr), mWidthWidget(nullptr), mFillModeWidget(nullptr), mFirstNumberWidget(nullptr), mObfuscateFactorWidget(nullptr), mStickerWidget(nullptr), mShadowPicker(nullptr), mFontPicker(nullptr), mScalingPicker(nullptr), mOpacityPicker(nullptr) { mCurrentTool = Tools::Select; } void ItemSettingsWidgetConfigurator::setCurrentTool(Tools tool) { if (mCurrentTool == tool) { return; } mCurrentTool = tool; updateWidgets(); } void ItemSettingsWidgetConfigurator::setColorWidget(ColorPicker *widget) { mColorWidget = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setTextColorWidget(ColorPicker *widget) { mTextColorWidget = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setWidthWidget(NumberPicker *widget) { mWidthWidget = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setFillTypeWidget(FillModePicker *widget) { mFillModeWidget = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setFirstNumberWidget(NumberPicker *widget) { mFirstNumberWidget = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setObfuscateFactorWidget(NumberPicker *widget) { mObfuscateFactorWidget = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setStickerWidget(StickerPicker *widget) { mStickerWidget = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setShadowWidget(BoolPicker *widget) { mShadowPicker = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setFontWidget(FontPicker *widget) { mFontPicker = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setScalingWidget(NumberPicker *widget) { mScalingPicker = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::setOpacityWidget(NumberPicker *widget) { mOpacityPicker = widget; updateWidgets(); } void ItemSettingsWidgetConfigurator::updateWidgets() const { updateProperties(); updateVisibility(); } void ItemSettingsWidgetConfigurator::updateProperties() const { switch (mCurrentTool) { case Tools::Text: case Tools::Number: case Tools::NumberArrow: setNoFillAndNoBorderVisible(true); break; case Tools::MarkerPen: setWidthRange(1, 100); setColorShowAlphaChannel(false); break; case Tools::MarkerRect: case Tools::MarkerEllipse: setColorShowAlphaChannel(false); break; default: setNoFillAndNoBorderVisible(false); setWidthRange(1, 20); setColorShowAlphaChannel(true); setTextColorShowAlphaChannel(true); } } void ItemSettingsWidgetConfigurator::updateVisibility() const { switch (mCurrentTool) { case Tools::Select: setColorWidgetVisible(false); setTextColorWidgetVisible(false); setWidthWidgetVisible(false); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(false); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(false); break; case Tools::Image: setColorWidgetVisible(false); setTextColorWidgetVisible(false); setWidthWidgetVisible(false); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::Pen: setColorWidgetVisible(true); setTextColorWidgetVisible(false); setWidthWidgetVisible(true); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::MarkerPen: setColorWidgetVisible(true); setTextColorWidgetVisible(false); setWidthWidgetVisible(true); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(false); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(false); break; case Tools::MarkerRect: case Tools::MarkerEllipse: setColorWidgetVisible(true); setTextColorWidgetVisible(false); setWidthWidgetVisible(false); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(false); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(false); break; case Tools::Line: case Tools::Arrow: case Tools::DoubleArrow: setColorWidgetVisible(true); setTextColorWidgetVisible(false); setWidthWidgetVisible(true); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::Ellipse: case Tools::Rect: setColorWidgetVisible(true); setTextColorWidgetVisible(false); setWidthWidgetVisible(true); setFillWidgetVisible(true); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::Number: setColorWidgetVisible(true); setTextColorWidgetVisible(true); setWidthWidgetVisible(true); setFillWidgetVisible(true); setFirstNumberWidgetVisible(true); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(true); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::NumberPointer: setColorWidgetVisible(true); setTextColorWidgetVisible(true); setWidthWidgetVisible(false); setFillWidgetVisible(false); setFirstNumberWidgetVisible(true); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(true); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::NumberArrow: setColorWidgetVisible(true); setTextColorWidgetVisible(true); setWidthWidgetVisible(true); setFillWidgetVisible(true); setFirstNumberWidgetVisible(true); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(true); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::Text: setColorWidgetVisible(true); setTextColorWidgetVisible(true); setWidthWidgetVisible(true); setFillWidgetVisible(true); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(true); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::TextPointer: setColorWidgetVisible(true); setTextColorWidgetVisible(true); setWidthWidgetVisible(false); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(true); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::TextArrow: setColorWidgetVisible(true); setTextColorWidgetVisible(true); setWidthWidgetVisible(true); setFillWidgetVisible(true); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(true); setFontWidgetVisible(true); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; case Tools::Blur: case Tools::Pixelate: setColorWidgetVisible(false); setTextColorWidgetVisible(false); setWidthWidgetVisible(false); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(true); setStickerWidgetVisible(false); setShadowWidgetVisible(false); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(false); break; case Tools::Sticker: setColorWidgetVisible(false); setTextColorWidgetVisible(false); setWidthWidgetVisible(false); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(true); setShadowWidgetVisible(true); setFontWidgetVisible(false); setScalingWidgetVisible(true); setOpacityWidgetVisible(true); break; case Tools::Duplicate: setColorWidgetVisible(false); setTextColorWidgetVisible(false); setWidthWidgetVisible(false); setFillWidgetVisible(false); setFirstNumberWidgetVisible(false); setObfuscateFactorWidgetVisible(false); setStickerWidgetVisible(false); setShadowWidgetVisible(false); setFontWidgetVisible(false); setScalingWidgetVisible(false); setOpacityWidgetVisible(true); break; default: qCritical("Unknown tool type in WidgetConfigurator"); } } void ItemSettingsWidgetConfigurator::setColorWidgetVisible(bool enabled) const { if (mColorWidget) { mColorWidget->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setTextColorWidgetVisible(bool enabled) const { if (mTextColorWidget) { mTextColorWidget->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setWidthWidgetVisible(bool enabled) const { if (mWidthWidget) { mWidthWidget->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setFillWidgetVisible(bool enabled) const { if (mFillModeWidget) { mFillModeWidget->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setFirstNumberWidgetVisible(bool enabled) const { if (mFirstNumberWidget) { mFirstNumberWidget->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setNoFillAndNoBorderVisible(bool enabled) const { if (mFillModeWidget) { if (enabled) { mFillModeWidget->addNoFillAndNoBorderToList(); } else { mFillModeWidget->removeNoFillAndNoBorderToList(); } } } void ItemSettingsWidgetConfigurator::setObfuscateFactorWidgetVisible(bool enabled) const { if (mObfuscateFactorWidget) { mObfuscateFactorWidget->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setStickerWidgetVisible(bool enabled) const { if (mStickerWidget) { mStickerWidget->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setShadowWidgetVisible(bool enabled) const { if (mShadowPicker) { mShadowPicker->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setFontWidgetVisible(bool enabled) const { if (mFontPicker) { mFontPicker->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setOpacityWidgetVisible(bool enabled) const { if (mOpacityPicker) { mOpacityPicker->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setScalingWidgetVisible(bool enabled) const { if (mScalingPicker) { mScalingPicker->setVisible(enabled); } } void ItemSettingsWidgetConfigurator::setWidthRange(int min, int max) const { if (mWidthWidget) { mWidthWidget->setRange(min, max); } } void ItemSettingsWidgetConfigurator::setColorShowAlphaChannel(bool showAlphaChannel) const { if (mColorWidget) { mColorWidget->setShowAlphaChannel(showAlphaChannel); } } void ItemSettingsWidgetConfigurator::setTextColorShowAlphaChannel(bool showAlphaChannel) const { if (mTextColorWidget) { mTextColorWidget->setShowAlphaChannel(showAlphaChannel); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/settings/ItemSettingsWidgetConfigurator.h000066400000000000000000000064661440330760000303510ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_WIDGETCONFIGURATORSWITCHER_H #define KIMAGEANNOTATOR_WIDGETCONFIGURATORSWITCHER_H #include #include "src/common/enum/Tools.h" #include "src/widgets/settingsPicker/ColorPicker.h" #include "src/widgets/settingsPicker/FillModePicker.h" #include "src/widgets/ToolPicker.h" #include "src/widgets/settingsPicker/NumberPicker.h" #include "src/widgets/settingsPicker/StickerPicker.h" #include "src/widgets/settingsPicker/BoolPicker.h" #include "src/widgets/settingsPicker/FontPicker.h" namespace kImageAnnotator { class ItemSettingsWidgetConfigurator { public: explicit ItemSettingsWidgetConfigurator(); ~ItemSettingsWidgetConfigurator() = default; void setCurrentTool(Tools tool); void setColorWidget(ColorPicker *widget); void setTextColorWidget(ColorPicker *widget); void setWidthWidget(NumberPicker *widget); void setFillTypeWidget(FillModePicker *widget); void setFirstNumberWidget(NumberPicker *widget); void setObfuscateFactorWidget(NumberPicker *widget); void setStickerWidget(StickerPicker *widget); void setShadowWidget(BoolPicker *widget); void setFontWidget(FontPicker *widget); void setScalingWidget(NumberPicker *widget); void setOpacityWidget(NumberPicker *widget); private: Tools mCurrentTool; ColorPicker *mColorWidget; ColorPicker *mTextColorWidget; NumberPicker *mWidthWidget; FillModePicker *mFillModeWidget; NumberPicker *mFirstNumberWidget; NumberPicker *mObfuscateFactorWidget; StickerPicker *mStickerWidget; BoolPicker *mShadowPicker; FontPicker *mFontPicker; NumberPicker *mScalingPicker; NumberPicker *mOpacityPicker; void updateWidgets() const; void updateProperties() const; void updateVisibility() const; void setColorWidgetVisible(bool enabled) const; void setTextColorWidgetVisible(bool enabled) const; void setWidthWidgetVisible(bool enabled) const; void setFillWidgetVisible(bool enabled) const; void setFirstNumberWidgetVisible(bool enabled) const; void setNoFillAndNoBorderVisible(bool enabled) const; void setObfuscateFactorWidgetVisible(bool enabled) const; void setStickerWidgetVisible(bool enabled) const; void setShadowWidgetVisible(bool enabled) const; void setFontWidgetVisible(bool enabled) const; void setOpacityWidgetVisible(bool enabled) const; void setScalingWidgetVisible(bool enabled) const; void setWidthRange(int min, int max) const; void setColorShowAlphaChannel(bool showAlphaChannel) const; void setTextColorShowAlphaChannel(bool showAlphaChannel) const; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_WIDGETCONFIGURATORSWITCHER_H kImageAnnotator-0.6.1/src/gui/annotator/tabs/000077500000000000000000000000001440330760000211075ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabClickEventFilter.cpp000066400000000000000000000027311440330760000274750ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTabClickEventFilter.h" namespace kImageAnnotator { AnnotationTabClickEventFilter::AnnotationTabClickEventFilter(QTabBar *tabBar, QObject *parent) : QObject(parent), mTabBar(tabBar) { mTabBar->installEventFilter(this); } bool AnnotationTabClickEventFilter::eventFilter(QObject *object, QEvent *event) { if (object == mTabBar && event->type() == QEvent::MouseButtonPress) { auto mouseEvent = dynamic_cast(event); if (mouseEvent->button() == Qt::MiddleButton) { int index = mTabBar->tabAt(mouseEvent->pos()); emit closeTabTriggered(index); return true; } } return QObject::eventFilter(object, event); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabClickEventFilter.h000066400000000000000000000026531440330760000271450ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTABCLICKEVENTFILTER_H #define KIMAGEANNOTATOR_ANNOTATIONTABCLICKEVENTFILTER_H #include #include #include namespace kImageAnnotator { class AnnotationTabClickEventFilter : public QObject { Q_OBJECT public: explicit AnnotationTabClickEventFilter(QTabBar *tabBar, QObject *parent); ~AnnotationTabClickEventFilter() override = default; signals: void closeTabTriggered(int index); protected: bool eventFilter(QObject *object, QEvent *event) override; private: QTabBar *mTabBar; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTABCLICKEVENTFILTER_H kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabCloser.cpp000066400000000000000000000050411440330760000255240ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTabCloser.h" namespace kImageAnnotator { AnnotationTabCloser::AnnotationTabCloser(QTabWidget *parent) : QObject(parent), mTabWidget(parent) { Q_ASSERT(mTabWidget != nullptr); } void AnnotationTabCloser::closeTabTriggered(int index) { const auto selectedTabIndex = getValidIndex(index); mTabWidget->setCurrentIndex(selectedTabIndex); mTabWidget->tabCloseRequested(selectedTabIndex); } void AnnotationTabCloser::closeOtherTabsTriggered(int index) { auto selectedWidget = mTabWidget->widget(getValidIndex(index)); auto tabCount = mTabWidget->count(); for(auto i = tabCount - 1; i >= 0; i--) { auto currentWidget = mTabWidget->widget(i); if(currentWidget != selectedWidget) { mTabWidget->setCurrentIndex(i); mTabWidget->tabCloseRequested(i); } } mTabWidget->setCurrentWidget(selectedWidget); } void AnnotationTabCloser::closeAllTabsTriggered() { auto tabCount = mTabWidget->count(); for(auto i = tabCount - 1; i >= 0; i--) { mTabWidget->setCurrentIndex(i); mTabWidget->tabCloseRequested(i); } } void AnnotationTabCloser::closeAllTabsToLeftTriggered(int index) { auto selectedWidget = mTabWidget->widget(getValidIndex(index)); for(auto i = index - 1; i >= 0; i--) { mTabWidget->setCurrentIndex(i); mTabWidget->tabCloseRequested(i); } mTabWidget->setCurrentWidget(selectedWidget); } void AnnotationTabCloser::closeAllTabsToRightTriggered(int index) { auto tabCount = mTabWidget->count(); for(auto i = tabCount - 1; i > index; i--) { mTabWidget->setCurrentIndex(i); mTabWidget->tabCloseRequested(i); } mTabWidget->setCurrentIndex(index); } int AnnotationTabCloser::getValidIndex(int index) const { return index >= 0 && index < mTabWidget->count() ? index : mTabWidget->currentIndex(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabCloser.h000066400000000000000000000027541440330760000252010ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTABCLOSER_H #define KIMAGEANNOTATOR_ANNOTATIONTABCLOSER_H #include #include namespace kImageAnnotator { class AnnotationTabCloser : public QObject { Q_OBJECT public: explicit AnnotationTabCloser(QTabWidget *parent); ~AnnotationTabCloser() override = default; public slots: void closeTabTriggered(int index); void closeOtherTabsTriggered(int index); void closeAllTabsTriggered(); void closeAllTabsToLeftTriggered(int index); void closeAllTabsToRightTriggered(int index); private: QTabWidget *mTabWidget; int getValidIndex(int index) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTABCLOSER_H kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabContent.cpp000066400000000000000000000035641440330760000257170ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTabContent.h" namespace kImageAnnotator { AnnotationTabContent::AnnotationTabContent(const QPixmap &pixmap, Config *config, AbstractSettingsProvider *settingsProvider) : mAnnotationView(new AnnotationView(this)), mZoomValueProvider(mAnnotationView->zoomValueProvider()), mAnnotationArea(new AnnotationArea(config, settingsProvider, new DevicePixelRatioScaler, mZoomValueProvider, this)), mMainLayout(new QHBoxLayout(this)), mSettingsProvider(settingsProvider) { mAnnotationView->setScene(mAnnotationArea); mAnnotationArea->loadImage(pixmap); mMainLayout->addWidget(mAnnotationView); setLayout(mMainLayout); connect(mZoomValueProvider, &ZoomValueProvider::zoomValueChanged, this, &AnnotationTabContent::zoomValueChange); } AnnotationArea* AnnotationTabContent::annotationArea() const { return mAnnotationArea; } ZoomValueProvider *AnnotationTabContent::zoomValueProvider() const { return mAnnotationView->zoomValueProvider(); } void AnnotationTabContent::zoomValueChange(double value) { mSettingsProvider->updateZoomLevel(value); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabContent.h000066400000000000000000000034101440330760000253520ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef ANNOTATIONTAB_H #define ANNOTATIONTAB_H #include #include #include "src/gui/annotator/AnnotationView.h" #include "src/gui/annotator/settings/AnnotationItemSettings.h" #include "src/annotations/core/AnnotationArea.h" #include "src/common/provider/DevicePixelRatioScaler.h" #include "src/gui/scrollAndZoomView/ViewZoomer.h" namespace kImageAnnotator { class AnnotationTabContent : public QWidget { Q_OBJECT public: AnnotationTabContent(const QPixmap &pixmap, Config *config, AbstractSettingsProvider *settingsProvider); ~AnnotationTabContent() override = default; AnnotationArea* annotationArea() const; ZoomValueProvider* zoomValueProvider() const; private: AnnotationView *mAnnotationView; ZoomValueProvider *mZoomValueProvider; AnnotationArea *mAnnotationArea; QHBoxLayout *mMainLayout; AbstractSettingsProvider *mSettingsProvider; private slots: void zoomValueChange(double value); }; } // namespace kImageAnnotator #endif //ANNOTATIONTAB_H kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabContextMenu.cpp000066400000000000000000000104321440330760000265460ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTabContextMenu.h" namespace kImageAnnotator { AnnotationTabContextMenu::AnnotationTabContextMenu(QWidget *parent) : QMenu(parent), mCloseTab(new QAction(this)), mClosedOtherTabs(new QAction(this)), mCloseAllTabs(new QAction(this)), mCloseAllTabsToLeft(new QAction(this)), mCloseAllTabsToRight(new QAction(this)), mTabIndex(-1) { mCloseTab->setText(tr("Close")); mClosedOtherTabs->setText(tr("Close Other")); mCloseAllTabs->setText(tr("Close All")); mCloseAllTabsToLeft->setText(tr("Close All to the Left")); mCloseAllTabsToRight->setText(tr("Close All to the Right")); mCloseTab->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_W)); mCloseTab->setShortcutContext(Qt::ApplicationShortcut); parent->addAction(mCloseTab); connect(mCloseTab, &QAction::triggered, this, &AnnotationTabContextMenu::closeTabTriggered); connect(mClosedOtherTabs, &QAction::triggered, this, &AnnotationTabContextMenu::closeOtherTabsTriggered); connect(mCloseAllTabs, &QAction::triggered, this, &AnnotationTabContextMenu::closeAllTabsTriggered); connect(mCloseAllTabsToLeft, &QAction::triggered, this, &AnnotationTabContextMenu::closeAllTabsToLeftTriggered); connect(mCloseAllTabsToRight, &QAction::triggered, this, &AnnotationTabContextMenu::closeAllTabsToRightTriggered); addAction(mCloseTab); addAction(mClosedOtherTabs); addAction(mCloseAllTabs); addAction(mCloseAllTabsToLeft); addAction(mCloseAllTabsToRight); } AnnotationTabContextMenu::~AnnotationTabContextMenu() { delete mCloseTab; delete mClosedOtherTabs; delete mCloseAllTabs; qDeleteAll(mCustomActionMap.keys()); } void AnnotationTabContextMenu::show(int tabIndex, const QPoint &pos) { mTabIndex = tabIndex; exec(pos); mTabIndex = -1; } void AnnotationTabContextMenu::closeTabTriggered() const { emit closeTab(mTabIndex); } void AnnotationTabContextMenu::closeOtherTabsTriggered() const { emit closeOtherTabs(mTabIndex); } void AnnotationTabContextMenu::closeAllTabsTriggered() const { emit closeAllTabs(); } void AnnotationTabContextMenu::closeAllTabsToLeftTriggered() const { emit closeAllTabsToLeft(mTabIndex); } void AnnotationTabContextMenu::closeAllTabsToRightTriggered() const { emit closeAllTabsToRight(mTabIndex); } void AnnotationTabContextMenu::addCustomActions(const QList &customActions) { addSeparator(); for(auto innerAction : customActions) { if(innerAction->isSeparator()) { addSeparator(); } else { addCustomAction(innerAction); } } } void AnnotationTabContextMenu::addCustomAction(QAction *innerAction) { auto outerAction = new QAction(this); outerAction->setText(innerAction->text()); outerAction->setIcon(innerAction->icon()); outerAction->setToolTip(innerAction->toolTip()); outerAction->setEnabled(innerAction->isEnabled()); mCustomActionMap[outerAction] = innerAction; connect(innerAction, &QAction::changed, this, &AnnotationTabContextMenu::customActionChanged); connect(outerAction, &QAction::triggered, this, &AnnotationTabContextMenu::customActionTriggered); addAction(outerAction); } void AnnotationTabContextMenu::customActionTriggered() { auto outerAction = dynamic_cast(sender()); auto innerAction = mCustomActionMap.value(outerAction); innerAction->setData(mTabIndex); innerAction->trigger(); } void AnnotationTabContextMenu::customActionChanged() { auto innerAction = dynamic_cast(sender()); auto outerAction = mCustomActionMap.key(innerAction); outerAction->setEnabled(innerAction->isEnabled()); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabContextMenu.h000066400000000000000000000037671440330760000262300ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTABCONTEXTMENU_H #define KIMAGEANNOTATOR_ANNOTATIONTABCONTEXTMENU_H #include namespace kImageAnnotator { class AnnotationTabContextMenu : public QMenu { Q_OBJECT public: explicit AnnotationTabContextMenu(QWidget *parent); ~AnnotationTabContextMenu() override; void show(int tabIndex, const QPoint &pos); void addCustomActions(const QList & customActions); signals: void closeTab(int index) const; void closeOtherTabs(int index) const; void closeAllTabs() const; void closeAllTabsToLeft(int index) const; void closeAllTabsToRight(int index) const; private: int mTabIndex; QAction *mCloseTab; QAction *mClosedOtherTabs; QAction *mCloseAllTabs; QAction *mCloseAllTabsToLeft; QAction *mCloseAllTabsToRight; QHash mCustomActionMap; void closeTabTriggered() const; void closeOtherTabsTriggered() const; void closeAllTabsTriggered() const; void closeAllTabsToLeftTriggered() const; void closeAllTabsToRightTriggered() const; private slots: void customActionTriggered(); void customActionChanged(); void addCustomAction(QAction *innerAction); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ANNOTATIONTABCONTEXTMENU_H kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabWidget.cpp000066400000000000000000000131701440330760000255220ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTabWidget.h" namespace kImageAnnotator { AnnotationTabWidget::AnnotationTabWidget(Config *config, AbstractSettingsProvider *settingsProvider) : mConfig(config), mTabBar(tabBar()), mSettingsProvider(settingsProvider), mUndoAction(new QAction(this)), mRedoAction(new QAction(this)), mTabContextMenu(new AnnotationTabContextMenu(this)), mTabCloser(new AnnotationTabCloser(this)), mTabClickFilter(new AnnotationTabClickEventFilter(mTabBar, this)) { setTabBarAutoHide(true); setMovable(true); setTabsClosable(true); mTabBar->setContextMenuPolicy(Qt::CustomContextMenu); connect(mUndoAction, &QAction::triggered, this, &AnnotationTabWidget::undoTriggered); connect(mRedoAction, &QAction::triggered, this, &AnnotationTabWidget::redoTriggered); connect(mTabBar, &QTabBar::tabMoved, this, &AnnotationTabWidget::tabMoved); connect(mTabBar, &QTabBar::customContextMenuRequested, this, &AnnotationTabWidget::showTabContextMenu); connect(mTabBar, &QTabBar::currentChanged, this, &AnnotationTabWidget::tabChanged); connect(mTabContextMenu, &AnnotationTabContextMenu::closeTab, mTabCloser, &AnnotationTabCloser::closeTabTriggered); connect(mTabContextMenu, &AnnotationTabContextMenu::closeOtherTabs, mTabCloser, &AnnotationTabCloser::closeOtherTabsTriggered); connect(mTabContextMenu, &AnnotationTabContextMenu::closeAllTabs, mTabCloser, &AnnotationTabCloser::closeAllTabsTriggered); connect(mTabContextMenu, &AnnotationTabContextMenu::closeAllTabsToLeft, mTabCloser, &AnnotationTabCloser::closeAllTabsToLeftTriggered); connect(mTabContextMenu, &AnnotationTabContextMenu::closeAllTabsToRight, mTabCloser, &AnnotationTabCloser::closeAllTabsToRightTriggered); connect(mTabClickFilter, &AnnotationTabClickEventFilter::closeTabTriggered, mTabCloser, &AnnotationTabCloser::closeTabTriggered); } int AnnotationTabWidget::addTab(const QPixmap &image, const QString &title, const QString &toolTip) { auto content = new AnnotationTabContent(image, mConfig, mSettingsProvider); connect(content->annotationArea(), &AnnotationArea::imageChanged, this, &AnnotationTabWidget::imageChanged); auto newTabIndex = QTabWidget::addTab(content, title); setTabToolTip(newTabIndex, toolTip); return newTabIndex; } int AnnotationTabWidget::insertTab(int index, const QPixmap &image, const QString &title, const QString &toolTip) { auto content = new AnnotationTabContent(image, mConfig, mSettingsProvider); connect(content->annotationArea(), &AnnotationArea::imageChanged, this, &AnnotationTabWidget::imageChanged); auto newTabIndex = QTabWidget::insertTab(index, content, title); setTabToolTip(newTabIndex, toolTip); return newTabIndex; } AnnotationArea* AnnotationTabWidget::currentAnnotationArea() const { return currentWidget() != nullptr ? dynamic_cast(currentWidget())->annotationArea() : nullptr; } AnnotationArea *AnnotationTabWidget::annotationAreaAt(int index) const { return widget(index) != nullptr ? dynamic_cast(widget(index))->annotationArea() : nullptr; } ZoomValueProvider *AnnotationTabWidget::currentZoomValueProvider() const { return currentWidget() != nullptr ? dynamic_cast(currentWidget())->zoomValueProvider() : nullptr; } QAction *AnnotationTabWidget::undoAction() const { return mUndoAction; } QAction *AnnotationTabWidget::redoAction() const { return mRedoAction; } void AnnotationTabWidget::updateTabInfo(int index, const QString &title, const QString &toolTip) { setTabText(index, title); setTabToolTip(index, toolTip); } void AnnotationTabWidget::setUndoRedoEnabled(bool enabled) { mUndoAction->setEnabled(enabled); mRedoAction->setEnabled(enabled); } void AnnotationTabWidget::tabInserted(int index) { updateCurrentWidget(index); QTabWidget::tabInserted(index); } void AnnotationTabWidget::tabRemoved(int index) { QTabWidget::tabRemoved(index); } void AnnotationTabWidget::undoTriggered() const { auto annotationArea = currentAnnotationArea(); if(annotationArea != nullptr) { annotationArea->undoAction()->trigger(); } } void AnnotationTabWidget::redoTriggered() const { auto annotationArea = currentAnnotationArea(); if(annotationArea != nullptr) { annotationArea->redoAction()->trigger(); } } void AnnotationTabWidget::updateCurrentWidget(int index) { setCurrentIndex(index); } void AnnotationTabWidget::showTabContextMenu(const QPoint &pos) { if (!pos.isNull()) { int tabIndex = mTabBar->tabAt(pos); emit tabContextMenuOpened(tabIndex); mTabContextMenu->show(tabIndex, mTabBar->mapToGlobal(pos)); } } void AnnotationTabWidget::tabChanged() { mSettingsProvider->setActiveListener(currentAnnotationArea()); mSettingsProvider->setActiveZoomValueProvider(currentZoomValueProvider()); } void AnnotationTabWidget::addContextMenuActions(const QList &actions) { mTabContextMenu->addCustomActions(actions); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/annotator/tabs/AnnotationTabWidget.h000066400000000000000000000050471440330760000251730ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef ANNOTATIONTABWIDGET_H #define ANNOTATIONTABWIDGET_H #include #include #include "AnnotationTabContent.h" #include "AnnotationTabContextMenu.h" #include "AnnotationTabCloser.h" #include "AnnotationTabClickEventFilter.h" namespace kImageAnnotator { class AnnotationTabWidget : public QTabWidget { Q_OBJECT public: AnnotationTabWidget(Config *config, AbstractSettingsProvider *settingsProvider); ~AnnotationTabWidget() override = default; int addTab(const QPixmap &image, const QString &title, const QString &toolTip); int insertTab(int index, const QPixmap &image, const QString &title, const QString &toolTip); AnnotationArea* currentAnnotationArea() const; AnnotationArea *annotationAreaAt(int index) const; ZoomValueProvider* currentZoomValueProvider() const; QAction* undoAction() const; QAction* redoAction() const; void updateTabInfo(int index, const QString &title, const QString &toolTip); void setUndoRedoEnabled(bool enabled); void addContextMenuActions(const QList & actions); signals: void imageChanged() const; void tabMoved(int fromIndex, int toIndex) const; void tabContextMenuOpened(int index) const; public slots: void undoTriggered() const; void redoTriggered() const; protected: void tabInserted(int index) override; void tabRemoved(int index) override; private: Config *mConfig; QTabBar *mTabBar; AbstractSettingsProvider *mSettingsProvider; QAction *mUndoAction; QAction *mRedoAction; AnnotationTabContextMenu *mTabContextMenu; AnnotationTabCloser *mTabCloser; AnnotationTabClickEventFilter *mTabClickFilter; private slots: void updateCurrentWidget(int index); void showTabContextMenu(const QPoint &pos); void tabChanged(); }; } // namespace kImageAnnotator #endif //ANNOTATIONTABWIDGET_H kImageAnnotator-0.6.1/src/gui/canvasModifier/000077500000000000000000000000001440330760000211035ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/canvasModifier/ModifyCanvasSelectionRestrictor.cpp000066400000000000000000000041571440330760000301300ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ModifyCanvasSelectionRestrictor.h" namespace kImageAnnotator { QRectF &ModifyCanvasSelectionRestrictor::restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const { if (newRect.x() > rectLimit.x()) { newRect.setX(rectLimit.x()); } if (newRect.y() > rectLimit.y()) { newRect.setY(rectLimit.y()); } if (newRect.right() < rectLimit.right()) { newRect.setRight(rectLimit.right()); } if (newRect.height() < rectLimit.height()) { newRect.setHeight(rectLimit.height()); } if (newRect.x() + newRect.width() < rectLimit.width()) { newRect.setWidth(rectLimit.width() - newRect.x()); } if (newRect.y() + newRect.height() < rectLimit.height()) { newRect.setHeight(rectLimit.height() - newRect.y()); } return newRect; } QRectF &ModifyCanvasSelectionRestrictor::restrictMove(QRectF &newRect, const QRectF &rectLimit) const { if (newRect.x() > rectLimit.x()) { newRect.moveLeft(rectLimit.x()); } if (newRect.y() > rectLimit.y()) { newRect.moveTop(rectLimit.y()); } if ((newRect.x() + newRect.width()) < rectLimit.width()) { newRect.moveTo(rectLimit.width() - newRect.width(), newRect.y()); } if ((newRect.y() + newRect.height()) < rectLimit.height()) { newRect.moveTo(newRect.x(), rectLimit.height() - newRect.height()); } return newRect; } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/canvasModifier/ModifyCanvasSelectionRestrictor.h000066400000000000000000000027351440330760000275750ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CANVASMDIFIERSELECTIONRESTRICTOR_H #define KIMAGEANNOTATOR_CANVASMDIFIERSELECTIONRESTRICTOR_H #include #include "src/gui/selection/ISelectionRestrictor.h" namespace kImageAnnotator { class ModifyCanvasSelectionRestrictor : public ISelectionRestrictor { public: explicit ModifyCanvasSelectionRestrictor() = default; ~ModifyCanvasSelectionRestrictor() override = default; QRectF &restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const override; QRectF &restrictMove(QRectF &newRect, const QRectF &rectLimit) const override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CANVASMDIFIERSELECTIONRESTRICTOR_H kImageAnnotator-0.6.1/src/gui/canvasModifier/ModifyCanvasView.cpp000066400000000000000000000033211440330760000250240ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ModifyCanvasView.h" namespace kImageAnnotator { ModifyCanvasView::ModifyCanvasView(SelectionHandler *selectionHandler, KeyHelper *keyHelper, QWidget *parent) : BaseSelectionView(selectionHandler, keyHelper, parent) { setViewportUpdateMode(ViewportUpdateMode::FullViewportUpdate); } void ModifyCanvasView::setCanvasRect(const QRectF &rect) { mCanvasRect = rect; } void ModifyCanvasView::setCanvasColor(const QColor &color) { mCanvasColor = color; } void ModifyCanvasView::drawForeground(QPainter *painter, const QRectF &rect) { painter->setClipRegion(QRegion(rect.toRect()).subtracted(QRegion(currentSelection().toRect()))); painter->setBrush(QColor(0, 0, 0, 150)); painter->drawRect(rect); BaseSelectionView::drawForeground(painter, rect); } void ModifyCanvasView::drawBackground(QPainter *painter, const QRectF &rect) { mCanvasPainter.paint(painter, mCanvasRect, mCanvasColor); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/canvasModifier/ModifyCanvasView.h000066400000000000000000000031411440330760000244710ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MODIFYCANVASVIEW_H #define KIMAGEANNOTATOR_MODIFYCANVASVIEW_H #include "src/gui/selection/BaseSelectionView.h" #include "src/annotations/misc/CanvasPainter.h" namespace kImageAnnotator { class ModifyCanvasView : public BaseSelectionView { Q_OBJECT public: explicit ModifyCanvasView(SelectionHandler *selectionHandler, KeyHelper *keyHelper, QWidget *parent); ~ModifyCanvasView() override = default; void setCanvasRect(const QRectF &rect); void setCanvasColor(const QColor &color); protected: void drawForeground(QPainter *painter, const QRectF &rect) override; void drawBackground(QPainter *painter, const QRectF &rect) override; private: CanvasPainter mCanvasPainter; QRectF mCanvasRect; QColor mCanvasColor; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_MODIFYCANVASVIEW_H kImageAnnotator-0.6.1/src/gui/canvasModifier/ModifyCanvasWidget.cpp000066400000000000000000000173121440330760000253420ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ModifyCanvasWidget.h" namespace kImageAnnotator { ModifyCanvasWidget::ModifyCanvasWidget() : mAnnotationArea(nullptr), mSelectionHandler(new SelectionHandler(new ModifyCanvasSelectionRestrictor, QSharedPointer(new SelectionHandlesAll))), mModifyCanvasView(new ModifyCanvasView(mSelectionHandler, mKeyHelper, this)), mKeyHelper(new KeyHelper()), mApplyButton(new QPushButton(this)), mCancelButton(new QPushButton(this)), mPanelLayout(new QHBoxLayout), mPositionXLabel(new QLabel(this)), mPositionYLabel(new QLabel(this)), mHeightLabel(new QLabel(this)), mWidthLabel(new QLabel(this)), mColorLabel(new QLabel(this)), mPositionXLineEdit(new QLineEdit(this)), mPositionYLineEdit(new QLineEdit(this)), mWidthLineEdit(new QLineEdit(this)), mHeightLineEdit(new QLineEdit(this)), mMainLayout(new QVBoxLayout(this)), mInputValidator(new QIntValidator(-9999, 9999, this)), mRestrictCheckBox(new QCheckBox(this)), mColorDialogButton(new ColorDialogButton(this)), mZoomPicker(new ZoomPicker(this)) { initSelectionHandler(); initKeyHelper(); initGui(); initZoomPicker(); } ModifyCanvasWidget::~ModifyCanvasWidget() { delete mKeyHelper; delete mColorDialogButton; delete mZoomPicker; delete mSelectionHandler; } void ModifyCanvasWidget::activate(AnnotationArea *annotationArea) { Q_ASSERT(annotationArea != nullptr); mAnnotationArea = annotationArea; mSelectionHandler->init(annotationArea); mModifyCanvasView->init(annotationArea); reset(); setFocus(); } void ModifyCanvasWidget::keyReleaseEvent(QKeyEvent *event) { mKeyHelper->keyRelease(event); QWidget::keyReleaseEvent(event); } void ModifyCanvasWidget::initGui() { mRestrictCheckBox->setText(tr("Restricted")); mRestrictCheckBox->setToolTip(tr("When enabled enforces the canvas\n" "to include the background image.")); mRestrictCheckBox->setChecked(mSelectionHandler->restrictionEnabled()); connect(mRestrictCheckBox, &QCheckBox::stateChanged, this, &ModifyCanvasWidget::restrictionChanged); auto width = ScaledSizeProvider::scaledWidth(80); mPositionXLabel->setText(tr("X:")); mPositionXLineEdit->setValidator(mInputValidator); mPositionXLineEdit->setFixedSize(width, mPositionXLineEdit->minimumSizeHint().height()); connect(mPositionXLineEdit, &QLineEdit::textEdited, this, &ModifyCanvasWidget::xChanged); mPositionYLabel->setText(tr("Y:")); mPositionYLineEdit->setValidator(mInputValidator); mPositionYLineEdit->setFixedSize(width, mPositionYLineEdit->minimumSizeHint().height()); connect(mPositionYLineEdit, &QLineEdit::textEdited, this, &ModifyCanvasWidget::yChanged); mWidthLabel->setText(tr("W:")); mWidthLineEdit->setValidator(mInputValidator); mWidthLineEdit->setFixedSize(width, mWidthLineEdit->minimumSizeHint().height()); connect(mWidthLineEdit, &QLineEdit::textEdited, this, &ModifyCanvasWidget::widthChanged); mHeightLabel->setText(tr("H:")); mHeightLineEdit->setValidator(mInputValidator); mHeightLineEdit->setFixedSize(width, mHeightLineEdit->minimumSizeHint().height()); connect(mHeightLineEdit, &QLineEdit::textEdited, this, &ModifyCanvasWidget::heightChanged); mColorLabel->setText(tr("Color:")); mColorLabel->setToolTip(tr("Canvas Background Color")); connect(mColorDialogButton, &ColorDialogButton::colorChanged, mModifyCanvasView, &ModifyCanvasView::setCanvasColor); mApplyButton->setText(tr("Apply")); connect(mApplyButton, &QPushButton::clicked, this, &ModifyCanvasWidget::apply); mCancelButton->setText(tr("Cancel")); connect(mCancelButton, &QPushButton::clicked, this, &ModifyCanvasWidget::closing); mPanelLayout->setAlignment(Qt::AlignCenter); mPanelLayout->addWidget(mZoomPicker); mPanelLayout->addStretch(1); mPanelLayout->addWidget(mRestrictCheckBox); mPanelLayout->addSpacing(10); mPanelLayout->addWidget(mColorLabel); mPanelLayout->addWidget(mColorDialogButton); mPanelLayout->addSpacing(10); mPanelLayout->addWidget(mPositionXLabel); mPanelLayout->addWidget(mPositionXLineEdit); mPanelLayout->addWidget(mPositionYLabel); mPanelLayout->addWidget(mPositionYLineEdit); mPanelLayout->addWidget(mWidthLabel); mPanelLayout->addWidget(mWidthLineEdit); mPanelLayout->addWidget(mHeightLabel); mPanelLayout->addWidget(mHeightLineEdit); mPanelLayout->addStretch(1); mPanelLayout->addWidget(mApplyButton); mPanelLayout->addWidget(mCancelButton); mMainLayout->addWidget(mModifyCanvasView); mMainLayout->addLayout(mPanelLayout); setLayout(mMainLayout); } void ModifyCanvasWidget::initKeyHelper() { connect(mKeyHelper, &KeyHelper::escapeReleased, this, &ModifyCanvasWidget::closing); connect(mKeyHelper, &KeyHelper::returnReleased, this, &ModifyCanvasWidget::apply); connect(mKeyHelper, &KeyHelper::enterReleased, this, &ModifyCanvasWidget::apply); } void ModifyCanvasWidget::initSelectionHandler() const { connect(mSelectionHandler, &SelectionHandler::selectionChanged, this, &ModifyCanvasWidget::selectionChanged); connect(mSelectionHandler, &SelectionHandler::selectionChanged, mModifyCanvasView, &ModifyCanvasView::setCanvasRect); } void ModifyCanvasWidget::reset() { auto selection = mAnnotationArea->canvasRect(); auto selectionLimit = mAnnotationArea->sceneRect(); mSelectionHandler->resetSelection(selection, selectionLimit); mColorDialogButton->setColor(mAnnotationArea->canvasColor()); mModifyCanvasView->setCanvasColor(mAnnotationArea->canvasColor()); mModifyCanvasView->setCanvasRect(mAnnotationArea->canvasRect()); } void ModifyCanvasWidget::initZoomPicker() { auto zoomValueProvider = mModifyCanvasView->zoomValueProvider(); connect(zoomValueProvider, &ZoomValueProvider::zoomValueChanged, mZoomPicker, &ZoomPicker::setZoomValue); connect(mZoomPicker, &ZoomPicker::zoomValueChanged, zoomValueProvider, &ZoomValueProvider::setZoomValue); connect(mZoomPicker, &ZoomPicker::fitImageToView, zoomValueProvider, &ZoomValueProvider::fitImageToView); mZoomPicker->setZoomValue(zoomValueProvider->zoomValue()); } void ModifyCanvasWidget::apply() { mAnnotationArea->modifyCanvas(mSelectionHandler->selection(), mColorDialogButton->color()); emit closing(); } void ModifyCanvasWidget::selectionChanged(const QRectF &rect) { mPositionXLineEdit->setText(QString::number(rect.topLeft().x())); mPositionYLineEdit->setText(QString::number(rect.topLeft().y())); mWidthLineEdit->setText(QString::number(rect.width())); mHeightLineEdit->setText(QString::number(rect.height())); } void ModifyCanvasWidget::xChanged(const QString &text) { auto x = text.toInt(); mSelectionHandler->setPositionX(x); } void ModifyCanvasWidget::yChanged(const QString &text) { auto y = text.toInt(); mSelectionHandler->setPositionY(y); } void ModifyCanvasWidget::widthChanged(const QString &text) { auto width = text.toInt(); mSelectionHandler->setWidth(width); } void ModifyCanvasWidget::heightChanged(const QString &text) { auto height = text.toInt(); mSelectionHandler->setHeight(height); } void ModifyCanvasWidget::restrictionChanged() { mSelectionHandler->setRestrictionEnabled(mRestrictCheckBox->isChecked()); } } // kImageAnnotator namespace kImageAnnotator-0.6.1/src/gui/canvasModifier/ModifyCanvasWidget.h000066400000000000000000000053741440330760000250140ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MODIFYCANVASWIDGET_H #define KIMAGEANNOTATOR_MODIFYCANVASWIDGET_H #include #include #include #include #include #include #include #include #include "ModifyCanvasView.h" #include "ModifyCanvasSelectionRestrictor.h" #include "src/annotations/core/AnnotationArea.h" #include "src/common/helper/KeyHelper.h" #include "src/gui/selection/SelectionHandler.h" #include "src/gui/selection/SelectionHandlesAll.h" #include "src/widgets/ColorDialogButton.h" #include "src/widgets/settingsPicker/ZoomPicker.h" namespace kImageAnnotator { class ModifyCanvasWidget : public QWidget { Q_OBJECT public: explicit ModifyCanvasWidget(); ~ModifyCanvasWidget() override; void activate(AnnotationArea *annotationArea); signals: void closing() const; protected: void keyReleaseEvent(QKeyEvent *event) override; private: AnnotationArea *mAnnotationArea; KeyHelper *mKeyHelper; SelectionHandler *mSelectionHandler; ModifyCanvasView *mModifyCanvasView; QVBoxLayout *mMainLayout; QHBoxLayout *mPanelLayout; QPushButton *mApplyButton; QPushButton *mCancelButton; QLineEdit *mPositionXLineEdit; QLineEdit *mPositionYLineEdit; QLineEdit *mWidthLineEdit; QLineEdit *mHeightLineEdit; QLabel *mPositionXLabel; QLabel *mPositionYLabel; QLabel *mWidthLabel; QLabel *mHeightLabel; QLabel *mColorLabel; QIntValidator *mInputValidator; QCheckBox *mRestrictCheckBox; ColorDialogButton *mColorDialogButton; ZoomPicker *mZoomPicker; void initGui(); void initKeyHelper(); void initSelectionHandler() const; void reset(); void initZoomPicker(); private slots: void apply(); void selectionChanged(const QRectF &rect); void xChanged(const QString &text); void yChanged(const QString &text); void widthChanged(const QString &text); void heightChanged(const QString &text); void restrictionChanged(); }; } // kImageAnnotator namespace #endif //KIMAGEANNOTATOR_MODIFYCANVASWIDGET_H kImageAnnotator-0.6.1/src/gui/cropper/000077500000000000000000000000001440330760000176235ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/cropper/CropSelectionRestrictor.cpp000066400000000000000000000041431440330760000251630ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CropSelectionRestrictor.h" namespace kImageAnnotator { QRectF &CropSelectionRestrictor::restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const { if (newRect.x() < rectLimit.x()) { newRect.setX(rectLimit.x()); } if (newRect.y() < rectLimit.y()) { newRect.setY(rectLimit.y()); } if (newRect.width() < 0) { newRect.setWidth(0); newRect.moveLeft(currentRect.left()); } if (newRect.height() < 0) { newRect.setHeight(0); newRect.moveTop(currentRect.top()); } if (newRect.x() + newRect.width() > rectLimit.width()) { newRect.setWidth(rectLimit.width() - newRect.x()); } if (newRect.y() + newRect.height() > rectLimit.height()) { newRect.setHeight(rectLimit.height() - newRect.y()); } return newRect; } QRectF &CropSelectionRestrictor::restrictMove(QRectF &newRect, const QRectF &rectLimit) const { if (newRect.x() < rectLimit.x()) { newRect.moveLeft(rectLimit.x()); } if (newRect.y() < rectLimit.y()) { newRect.moveTop(rectLimit.y()); } if ((newRect.x() + newRect.width()) > rectLimit.width()) { newRect.moveTo(rectLimit.width() - newRect.width(), newRect.y()); } if ((newRect.y() + newRect.height()) > rectLimit.height()) { newRect.moveTo(newRect.x(), rectLimit.height() - newRect.height()); } return newRect; } } // namespave kImageAnnotatorkImageAnnotator-0.6.1/src/gui/cropper/CropSelectionRestrictor.h000066400000000000000000000026521440330760000246330ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPSELECTIONRESTRICTOR_H #define KIMAGEANNOTATOR_CROPSELECTIONRESTRICTOR_H #include #include "src/gui/selection/ISelectionRestrictor.h" namespace kImageAnnotator { class CropSelectionRestrictor : public ISelectionRestrictor { public: explicit CropSelectionRestrictor() = default; ~CropSelectionRestrictor() override = default; QRectF &restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const override; QRectF &restrictMove(QRectF &newRect, const QRectF &rectLimit) const override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CROPSELECTIONRESTRICTOR_H kImageAnnotator-0.6.1/src/gui/cropper/CropView.cpp000066400000000000000000000033121440330760000220640ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CropView.h" namespace kImageAnnotator { CropView::CropView(SelectionHandler *cropSelectionHandler, KeyHelper *keyHelper, QWidget *parent) : BaseSelectionView(cropSelectionHandler, keyHelper, parent) { } void CropView::drawForeground(QPainter *painter, const QRectF &rect) { auto annotationArea = dynamic_cast(scene()); auto backgroundImageRect = annotationArea->backgroundImageRect(); painter->setClipRegion(QRegion(backgroundImageRect.toRect()).subtracted(QRegion(currentSelection().toRect()))); painter->setBrush(QColor(0, 0, 0, 150)); painter->drawRect(backgroundImageRect); BaseSelectionView::drawForeground(painter, rect); } void CropView::drawBackground(QPainter *painter, const QRectF &rect) { auto annotationArea = dynamic_cast(scene()); mCanvasPainter.paint(painter, annotationArea->canvasRect(), annotationArea->canvasColor()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/cropper/CropView.h000066400000000000000000000026621440330760000215400ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPVIEW_H #define KIMAGEANNOTATOR_CROPVIEW_H #include "src/gui/selection/BaseSelectionView.h" #include "src/annotations/misc/CanvasPainter.h" namespace kImageAnnotator { class CropView : public BaseSelectionView { Q_OBJECT public: explicit CropView(SelectionHandler *selectionHandler, KeyHelper *keyHelper, QWidget *parent); ~CropView() override = default; protected: void drawForeground(QPainter *painter, const QRectF &rect) override; void drawBackground(QPainter *painter, const QRectF &rect) override; private: CanvasPainter mCanvasPainter; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CROPVIEW_H kImageAnnotator-0.6.1/src/gui/cropper/CropWidget.cpp000066400000000000000000000141621440330760000224020ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CropWidget.h" namespace kImageAnnotator { CropWidget::CropWidget() : mAnnotationArea(nullptr), mKeyHelper(new KeyHelper()), mSelectionHandler(new SelectionHandler(new CropSelectionRestrictor, QSharedPointer(new SelectionHandlesAll))), mCropView(new CropView(mSelectionHandler, mKeyHelper, this)), mApplyButton(new QPushButton(this)), mCancelButton(new QPushButton(this)), mPanelLayout(new QHBoxLayout), mPositionXLabel(new QLabel(this)), mPositionYLabel(new QLabel(this)), mHeightLabel(new QLabel(this)), mWidthLabel(new QLabel(this)), mPositionXLineEdit(new QLineEdit(this)), mPositionYLineEdit(new QLineEdit(this)), mWidthLineEdit(new QLineEdit(this)), mHeightLineEdit(new QLineEdit(this)), mMainLayout(new QVBoxLayout(this)), mInputValidator(new QIntValidator(0, 9999, this)), mZoomPicker(new ZoomPicker(this)) { initSelectionHandler(); initKeyHelper(); initGui(); initZoomPicker(); } CropWidget::~CropWidget() { delete mKeyHelper; delete mSelectionHandler; delete mCropView; delete mZoomPicker; } void CropWidget::activate(AnnotationArea *annotationArea) { Q_ASSERT(annotationArea != nullptr); mAnnotationArea = annotationArea; mSelectionHandler->init(annotationArea); mCropView->init(annotationArea); reset(); setFocus(); } void CropWidget::initGui() { mApplyButton->setText(tr("Apply")); connect(mApplyButton, &QPushButton::clicked, this, &CropWidget::crop); mCancelButton->setText(tr("Cancel")); connect(mCancelButton, &QPushButton::clicked, this, &CropWidget::closing); auto width = ScaledSizeProvider::scaledWidth(80); mPositionXLabel->setText(tr("X:")); mPositionXLineEdit->setValidator(mInputValidator); mPositionXLineEdit->setFixedSize(width, mPositionXLineEdit->minimumSizeHint().height()); connect(mPositionXLineEdit, &QLineEdit::textEdited, this, &CropWidget::xChanged); mPositionYLabel->setText(tr("Y:")); mPositionYLineEdit->setValidator(mInputValidator); mPositionYLineEdit->setFixedSize(width, mPositionYLineEdit->minimumSizeHint().height()); connect(mPositionYLineEdit, &QLineEdit::textEdited, this, &CropWidget::yChanged); mWidthLabel->setText(tr("W:")); mWidthLineEdit->setValidator(mInputValidator); mWidthLineEdit->setFixedSize(width, mWidthLineEdit->minimumSizeHint().height()); connect(mWidthLineEdit, &QLineEdit::textEdited, this, &CropWidget::widthChanged); mHeightLabel->setText(tr("H:")); mHeightLineEdit->setValidator(mInputValidator); mHeightLineEdit->setFixedSize(width, mHeightLineEdit->minimumSizeHint().height()); connect(mHeightLineEdit, &QLineEdit::textEdited, this, &CropWidget::heightChanged); mPanelLayout->setAlignment(Qt::AlignCenter); mPanelLayout->addWidget(mZoomPicker); mPanelLayout->addStretch(1); mPanelLayout->addWidget(mPositionXLabel); mPanelLayout->addWidget(mPositionXLineEdit); mPanelLayout->addWidget(mPositionYLabel); mPanelLayout->addWidget(mPositionYLineEdit); mPanelLayout->addWidget(mWidthLabel); mPanelLayout->addWidget(mWidthLineEdit); mPanelLayout->addWidget(mHeightLabel); mPanelLayout->addWidget(mHeightLineEdit); mPanelLayout->addStretch(1); mPanelLayout->addWidget(mApplyButton); mPanelLayout->addWidget(mCancelButton); mMainLayout->addWidget(mCropView); mMainLayout->addLayout(mPanelLayout); setLayout(mMainLayout); } void CropWidget::keyReleaseEvent(QKeyEvent *event) { mKeyHelper->keyRelease(event); QWidget::keyReleaseEvent(event); } void CropWidget::crop() { Q_ASSERT(mAnnotationArea != nullptr); mAnnotationArea->crop(mSelectionHandler->selection()); emit closing(); } void CropWidget::selectionChanged(const QRectF &rect) { mPositionXLineEdit->setText(QString::number(rect.topLeft().x())); mPositionYLineEdit->setText(QString::number(rect.topLeft().y())); mWidthLineEdit->setText(QString::number(rect.width())); mHeightLineEdit->setText(QString::number(rect.height())); } void kImageAnnotator::CropWidget::xChanged(const QString &text) { auto x = text.toInt(); mSelectionHandler->setPositionX(x); } void CropWidget::yChanged(const QString &text) { auto y = text.toInt(); mSelectionHandler->setPositionY(y); } void CropWidget::widthChanged(const QString &text) { auto width = text.toInt(); mSelectionHandler->setWidth(width); } void CropWidget::heightChanged(const QString &text) { auto height = text.toInt(); mSelectionHandler->setHeight(height); } void CropWidget::reset() { auto selection = mAnnotationArea->backgroundImageRect(); mSelectionHandler->resetSelection(selection, selection); } void CropWidget::initZoomPicker() const { auto zoomValueProvider = mCropView->zoomValueProvider(); connect(zoomValueProvider, &ZoomValueProvider::zoomValueChanged, mZoomPicker, &ZoomPicker::setZoomValue); connect(mZoomPicker, &ZoomPicker::zoomValueChanged, zoomValueProvider, &ZoomValueProvider::setZoomValue); connect(mZoomPicker, &ZoomPicker::fitImageToView, zoomValueProvider, &ZoomValueProvider::fitImageToView); mZoomPicker->setZoomValue(zoomValueProvider->zoomValue()); } void CropWidget::initSelectionHandler() const { connect(mSelectionHandler, &SelectionHandler::selectionChanged, this, &CropWidget::selectionChanged); } void CropWidget::initKeyHelper() { connect(mKeyHelper, &KeyHelper::escapeReleased, this, &CropWidget::closing); connect(mKeyHelper, &KeyHelper::returnReleased, this, &CropWidget::crop); connect(mKeyHelper, &KeyHelper::enterReleased, this, &CropWidget::crop); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/cropper/CropWidget.h000066400000000000000000000047601440330760000220520ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPWIDGET_H #define KIMAGEANNOTATOR_CROPWIDGET_H #include #include #include #include #include #include #include "CropView.h" #include "src/gui/selection/SelectionHandler.h" #include "src/gui/selection/SelectionHandlesAll.h" #include "src/annotations/core/AnnotationArea.h" #include "src/common/helper/KeyHelper.h" #include "src/common/provider/ScaledSizeProvider.h" #include "src/widgets/settingsPicker/ZoomPicker.h" namespace kImageAnnotator { class CropWidget : public QWidget { Q_OBJECT public: explicit CropWidget(); ~CropWidget() override; void activate(AnnotationArea *annotationArea); signals: void closing() const; protected: void keyReleaseEvent(QKeyEvent *event) override; private: AnnotationArea *mAnnotationArea; KeyHelper *mKeyHelper; SelectionHandler *mSelectionHandler; CropView *mCropView; QVBoxLayout *mMainLayout; QHBoxLayout *mPanelLayout; QPushButton *mApplyButton; QPushButton *mCancelButton; QLineEdit *mPositionXLineEdit; QLineEdit *mPositionYLineEdit; QLineEdit *mWidthLineEdit; QLineEdit *mHeightLineEdit; QLabel *mPositionXLabel; QLabel *mPositionYLabel; QLabel *mWidthLabel; QLabel *mHeightLabel; QIntValidator *mInputValidator; ZoomPicker *mZoomPicker; void initGui(); void initKeyHelper(); void initSelectionHandler() const; void reset(); void initZoomPicker() const; private slots: void crop(); void selectionChanged(const QRectF &rect); void xChanged(const QString &text); void yChanged(const QString &text); void widthChanged(const QString &text); void heightChanged(const QString &text); }; } // kImageAnnotator namespace #endif //KIMAGEANNOTATOR_CROPWIDGET_H kImageAnnotator-0.6.1/src/gui/cutter/000077500000000000000000000000001440330760000174575ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/cutter/CutSelectionRestrictor.cpp000066400000000000000000000041401440330760000246440ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CutSelectionRestrictor.h" namespace kImageAnnotator { QRectF &CutSelectionRestrictor::restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const { if (newRect.x() < rectLimit.x()) { newRect.setX(rectLimit.x()); } if (newRect.y() < rectLimit.y()) { newRect.setY(rectLimit.y()); } if (newRect.width() < 0) { newRect.setWidth(0); newRect.moveLeft(currentRect.left()); } if (newRect.height() < 0) { newRect.setHeight(0); newRect.moveTop(currentRect.top()); } if (newRect.x() + newRect.width() > rectLimit.width()) { newRect.setWidth(rectLimit.width() - newRect.x()); } if (newRect.y() + newRect.height() > rectLimit.height()) { newRect.setHeight(rectLimit.height() - newRect.y()); } return newRect; } QRectF &CutSelectionRestrictor::restrictMove(QRectF &newRect, const QRectF &rectLimit) const { if (newRect.x() < rectLimit.x()) { newRect.moveLeft(rectLimit.x()); } if (newRect.y() < rectLimit.y()) { newRect.moveTop(rectLimit.y()); } if ((newRect.x() + newRect.width()) > rectLimit.width()) { newRect.moveTo(rectLimit.width() - newRect.width(), newRect.y()); } if ((newRect.y() + newRect.height()) > rectLimit.height()) { newRect.moveTo(newRect.x(), rectLimit.height() - newRect.height()); } return newRect; } } // kImageAnnotator namespace kImageAnnotator-0.6.1/src/gui/cutter/CutSelectionRestrictor.h000066400000000000000000000026441440330760000243200ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUTSELECTIONRESTRICTOR_H #define KIMAGEANNOTATOR_CUTSELECTIONRESTRICTOR_H #include #include "src/gui/selection/ISelectionRestrictor.h" namespace kImageAnnotator { class CutSelectionRestrictor : public ISelectionRestrictor { public: explicit CutSelectionRestrictor() = default; ~CutSelectionRestrictor() override = default; QRectF &restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const override; QRectF &restrictMove(QRectF &newRect, const QRectF &rectLimit) const override; }; } // kImageAnnotator namespace #endif //KIMAGEANNOTATOR_CUTSELECTIONRESTRICTOR_H kImageAnnotator-0.6.1/src/gui/cutter/CutView.cpp000066400000000000000000000027221440330760000215540ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CutView.h" namespace kImageAnnotator { CutView::CutView(SelectionHandler *selectionHandler, KeyHelper *keyHelper, QWidget *parent) : BaseSelectionView(selectionHandler, keyHelper, parent) { } void CutView::drawForeground(QPainter *painter, const QRectF &rect) { painter->setBrush(QColor(0, 0, 0, 150)); painter->drawRect(currentSelection().toRect()); BaseSelectionView::drawForeground(painter, rect); } void CutView::drawBackground(QPainter *painter, const QRectF &rect) { auto annotationArea = dynamic_cast(scene()); mCanvasPainter.paint(painter, annotationArea->canvasRect(), annotationArea->canvasColor()); } } // kImageAnnotator namespace kImageAnnotator-0.6.1/src/gui/cutter/CutView.h000066400000000000000000000026551440330760000212260ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUTVIEW_H #define KIMAGEANNOTATOR_CUTVIEW_H #include "src/gui/selection/BaseSelectionView.h" #include "src/annotations/misc/CanvasPainter.h" namespace kImageAnnotator { class CutView : public BaseSelectionView { Q_OBJECT public: explicit CutView(SelectionHandler *selectionHandler, KeyHelper *keyHelper, QWidget *parent); ~CutView() override = default; protected: void drawForeground(QPainter *painter, const QRectF &rect) override; void drawBackground(QPainter *painter, const QRectF &rect) override; private: CanvasPainter mCanvasPainter; }; } // kImageAnnotator namespace #endif //KIMAGEANNOTATOR_CUTVIEW_H kImageAnnotator-0.6.1/src/gui/cutter/CutWidget.cpp000066400000000000000000000115331440330760000220650ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CutWidget.h" namespace kImageAnnotator { CutWidget::CutWidget(QWidget *parent) : QWidget(parent), mAnnotationArea(nullptr), mKeyHelper(new KeyHelper()), mSelectionHandler(new SelectionHandler(new CutSelectionRestrictor, QSharedPointer(new SelectionHandlesVertical))), mCutView(new CutView(mSelectionHandler, mKeyHelper, this)), mZoomPicker(new ZoomPicker(this)), mApplyButton(new QPushButton(this)), mCancelButton(new QPushButton(this)), mOrientationGroupBox(new QGroupBox(this)), mVerticalOrientationRadioButton(new QRadioButton(this)), mHorizontalOrientationRadioButton(new QRadioButton(this)), mPanelLayout(new QHBoxLayout), mOrientationLayout(new QHBoxLayout), mMainLayout(new QVBoxLayout(this)), mDefaultSelectionWidth(100) { initKeyHelper(); initGui(); initZoomPicker(); } void CutWidget::activate(AnnotationArea *annotationArea) { Q_ASSERT(annotationArea != nullptr); mAnnotationArea = annotationArea; mSelectionHandler->init(annotationArea); mCutView->init(annotationArea); reset(); setFocus(); } void CutWidget::initGui() { mVerticalOrientationRadioButton->setText(tr("Vertical")); connect(mVerticalOrientationRadioButton, &QRadioButton::clicked, this, &CutWidget::orientationChanged); mVerticalOrientationRadioButton->setChecked(true); mHorizontalOrientationRadioButton->setText(tr("Horizontal")); connect(mHorizontalOrientationRadioButton, &QRadioButton::clicked, this, &CutWidget::orientationChanged); mApplyButton->setText(tr("Apply")); connect(mApplyButton, &QPushButton::clicked, this, &CutWidget::cut); mCancelButton->setText(tr("Cancel")); connect(mCancelButton, &QPushButton::clicked, this, &CutWidget::closing); mOrientationLayout->addWidget(mVerticalOrientationRadioButton); mOrientationLayout->addWidget(mHorizontalOrientationRadioButton); mOrientationLayout->addStretch(1); mOrientationGroupBox->setLayout(mOrientationLayout); mOrientationGroupBox->setFlat(true); mPanelLayout->setAlignment(Qt::AlignCenter); mPanelLayout->addWidget(mZoomPicker); mPanelLayout->addStretch(1); mPanelLayout->addWidget(mOrientationGroupBox); mPanelLayout->addStretch(1); mPanelLayout->addWidget(mApplyButton); mPanelLayout->addWidget(mCancelButton); mMainLayout->addWidget(mCutView); mMainLayout->addLayout(mPanelLayout); setLayout(mMainLayout); } void CutWidget::initKeyHelper() { connect(mKeyHelper, &KeyHelper::escapeReleased, this, &CutWidget::closing); connect(mKeyHelper, &KeyHelper::returnReleased, this, &CutWidget::cut); connect(mKeyHelper, &KeyHelper::enterReleased, this, &CutWidget::cut); } void CutWidget::reset() { auto selectionLimit = mAnnotationArea->backgroundImageRect(); auto selection = selectionLimit; if (isVerticalOrientation()) { selection.setWidth(mDefaultSelectionWidth); selection.moveLeft(selectionLimit.center().x() - mDefaultSelectionWidth / 2); } else { selection.setHeight(mDefaultSelectionWidth); selection.moveTop(selectionLimit.center().y() - mDefaultSelectionWidth / 2); } mSelectionHandler->resetSelection(selection, selectionLimit); } void CutWidget::initZoomPicker() const { auto zoomValueProvider = mCutView->zoomValueProvider(); connect(zoomValueProvider, &ZoomValueProvider::zoomValueChanged, mZoomPicker, &ZoomPicker::setZoomValue); connect(mZoomPicker, &ZoomPicker::zoomValueChanged, zoomValueProvider, &ZoomValueProvider::setZoomValue); connect(mZoomPicker, &ZoomPicker::fitImageToView, zoomValueProvider, &ZoomValueProvider::fitImageToView); mZoomPicker->setZoomValue(zoomValueProvider->zoomValue()); } void CutWidget::cut() { Q_ASSERT(mAnnotationArea != nullptr); mAnnotationArea->cut(mSelectionHandler->selection()); emit closing(); } void CutWidget::orientationChanged() { if(isVerticalOrientation()) { mSelectionHandler->replaceHandles(QSharedPointer(new SelectionHandlesVertical)); } else { mSelectionHandler->replaceHandles(QSharedPointer(new SelectionHandlesHorizontal)); } reset(); } bool CutWidget::isVerticalOrientation() const { return mVerticalOrientationRadioButton->isChecked(); } } // kImageAnnotator namespace kImageAnnotator-0.6.1/src/gui/cutter/CutWidget.h000066400000000000000000000043741440330760000215370ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUTWIDGET_H #define KIMAGEANNOTATOR_CUTWIDGET_H #include #include #include #include #include #include "CutView.h" #include "CutSelectionRestrictor.h" #include "src/annotations/core/AnnotationArea.h" #include "src/gui/selection/SelectionHandler.h" #include "src/gui/selection/SelectionHandlesHorizontal.h" #include "src/gui/selection/SelectionHandlesVertical.h" #include "src/common/helper/KeyHelper.h" #include "src/widgets/settingsPicker/ZoomPicker.h" namespace kImageAnnotator { class CutWidget : public QWidget { Q_OBJECT public: explicit CutWidget(QWidget *parent); ~CutWidget() override = default; void activate(AnnotationArea *annotationArea); signals: void closing() const; private: AnnotationArea *mAnnotationArea; KeyHelper *mKeyHelper; SelectionHandler *mSelectionHandler; CutView *mCutView; ZoomPicker *mZoomPicker; QVBoxLayout *mMainLayout; QHBoxLayout *mPanelLayout; QHBoxLayout *mOrientationLayout; QPushButton *mApplyButton; QPushButton *mCancelButton; QGroupBox *mOrientationGroupBox; QRadioButton *mVerticalOrientationRadioButton; QRadioButton *mHorizontalOrientationRadioButton; qreal mDefaultSelectionWidth; void initGui(); void initKeyHelper(); void reset(); void initZoomPicker() const; bool isVerticalOrientation() const; private slots: void cut(); void orientationChanged(); }; } // kImageAnnotator namespace #endif //KIMAGEANNOTATOR_CUTWIDGET_H kImageAnnotator-0.6.1/src/gui/rotator/000077500000000000000000000000001440330760000176435ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/rotator/RotateDialog.cpp000066400000000000000000000122141440330760000227250ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "RotateDialog.h" namespace kImageAnnotator { RotateDialog::RotateDialog(QWidget *parent) : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint), m180RadioButton(new QRadioButton(this)), m90ClockwiseRadioButton(new QRadioButton(this)), m90CounterClockwiseRadioButton(new QRadioButton(this)), mArbitraryRotationRadioButton(new QRadioButton(this)), mFlipHorizontalRadioButton(new QRadioButton(this)), mFlipVerticalRadioButton(new QRadioButton(this)), mArbitraryRotationSpinBox(new CustomSpinBox(this)), mOkButton(new QPushButton(this)), mCancelButton(new QPushButton(this)), mRotateRadioButtonLayout(new QGridLayout), mFlipRadioButtonLayout(new QGridLayout), mRotateButtonGroupBox(new QGroupBox(this)), mFlipButtonGroupBox(new QGroupBox(this)), mButtonRowLayout(new QHBoxLayout), mMainLayout(new QVBoxLayout), mButtonGroup(new QButtonGroup(this)) { setWindowTitle(tr("Rotate Image")); initGui(); setDefault(); } void RotateDialog::initGui() { m180RadioButton->setText(tr("180°")); m180RadioButton->setChecked(true); mButtonGroup->addButton(m180RadioButton); m90ClockwiseRadioButton->setText(tr("90° Clockwise")); mButtonGroup->addButton(m90ClockwiseRadioButton); m90CounterClockwiseRadioButton->setText(tr("90° Counter Clockwise")); mButtonGroup->addButton(m90CounterClockwiseRadioButton); mArbitraryRotationRadioButton->setText(tr("Arbitrary")); mArbitraryRotationRadioButton->setToolTip(tr("Positive values rotate clockwise, negative values counter clockwise.\n" "Rotating by non 90° multipliers might introduce loss of quality.")); mButtonGroup->addButton(mArbitraryRotationRadioButton); mArbitraryRotationSpinBox->setSuffix(QString::fromUtf8("°")); mArbitraryRotationSpinBox->setToolTip(mArbitraryRotationRadioButton->toolTip()); mArbitraryRotationSpinBox->setMinimum(-360); mArbitraryRotationSpinBox->setMaximum(360); mFlipHorizontalRadioButton->setText(tr("Horizontal")); mButtonGroup->addButton(mFlipHorizontalRadioButton); mFlipVerticalRadioButton->setText(tr("Vertical")); mButtonGroup->addButton(mFlipVerticalRadioButton); mOkButton->setText(tr("OK")); connect(mOkButton, &QPushButton::clicked, this, &RotateDialog::finish); mCancelButton->setText(tr("Cancel")); connect(mCancelButton, &QPushButton::clicked, this, &RotateDialog::cancel); connect(mButtonGroup, QOverload::of(&QButtonGroup::buttonClicked), this, &RotateDialog::selectionChanged); mRotateRadioButtonLayout->setColumnMinimumWidth(0, 20); mRotateRadioButtonLayout->addWidget(m180RadioButton, 0, 0, 1, 2); mRotateRadioButtonLayout->addWidget(m90ClockwiseRadioButton, 1, 0, 1, 2); mRotateRadioButtonLayout->addWidget(m90CounterClockwiseRadioButton, 2, 0, 1, 2); mRotateRadioButtonLayout->addWidget(mArbitraryRotationRadioButton, 3, 0, 1, 2); mRotateRadioButtonLayout->addWidget(mArbitraryRotationSpinBox, 4, 1, 1, 1); mFlipRadioButtonLayout->addWidget(mFlipHorizontalRadioButton, 0, 0); mFlipRadioButtonLayout->addWidget(mFlipVerticalRadioButton, 1, 0); mRotateButtonGroupBox->setTitle(tr("Rotate")); mRotateButtonGroupBox->setLayout(mRotateRadioButtonLayout); mFlipButtonGroupBox->setTitle(tr("Flip")); mFlipButtonGroupBox->setLayout(mFlipRadioButtonLayout); mButtonRowLayout->addWidget(mOkButton); mButtonRowLayout->addWidget(mCancelButton); mButtonRowLayout->setAlignment(Qt::AlignRight); mMainLayout->addWidget(mRotateButtonGroupBox); mMainLayout->addWidget(mFlipButtonGroupBox); mMainLayout->addLayout(mButtonRowLayout); setLayout(mMainLayout); } void RotateDialog::setDefault() { m180RadioButton->setChecked(true); mArbitraryRotationSpinBox->setValue(45); selectionChanged(); } void RotateDialog::finish() { if (m180RadioButton->isChecked()) { emit rotate(180); } else if (m90ClockwiseRadioButton->isChecked()) { emit rotate(90); } else if (m90CounterClockwiseRadioButton->isChecked()) { emit rotate(-90); } else if (mArbitraryRotationRadioButton->isChecked()) { emit rotate(mArbitraryRotationSpinBox->value()); } else if (mFlipHorizontalRadioButton->isChecked()) { emit flip(FlipDirection::Horizontal); } else if (mFlipVerticalRadioButton->isChecked()) { emit flip(FlipDirection::Vertical); } close(); } void RotateDialog::cancel() { close(); } void RotateDialog::selectionChanged() { mArbitraryRotationSpinBox->setEnabled(mArbitraryRotationRadioButton->isChecked()); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/rotator/RotateDialog.h000066400000000000000000000042111440330760000223700ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ROTATEDIALOG_H #define KIMAGEANNOTATOR_ROTATEDIALOG_H #include #include #include #include #include #include #include #include #include "src/widgets/CustomSpinBox.h" #include "src/common/enum/FlipDirection.h" namespace kImageAnnotator { class RotateDialog : public QDialog { Q_OBJECT public: explicit RotateDialog(QWidget *parent = nullptr); ~RotateDialog() override = default; signals: void rotate(qreal angle) const; void flip(FlipDirection direction) const; private: QRadioButton *m180RadioButton; QRadioButton *m90ClockwiseRadioButton; QRadioButton *m90CounterClockwiseRadioButton; QRadioButton *mArbitraryRotationRadioButton; QRadioButton *mFlipHorizontalRadioButton; QRadioButton *mFlipVerticalRadioButton; CustomSpinBox *mArbitraryRotationSpinBox; QPushButton *mOkButton; QPushButton *mCancelButton; QGridLayout *mRotateRadioButtonLayout; QGridLayout *mFlipRadioButtonLayout; QGroupBox *mRotateButtonGroupBox; QGroupBox *mFlipButtonGroupBox; QHBoxLayout *mButtonRowLayout; QVBoxLayout *mMainLayout; QButtonGroup *mButtonGroup; void initGui(); void setDefault(); private slots: void finish(); void cancel(); void selectionChanged(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ROTATEDIALOG_H kImageAnnotator-0.6.1/src/gui/rotator/RotateWidget.cpp000066400000000000000000000035121440330760000227520ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "RotateWidget.h" namespace kImageAnnotator { RotateWidget::RotateWidget() : mAnnotationArea(nullptr), mView(new QGraphicsView), mMainLayout(new QVBoxLayout(this)) { initGui(); } RotateWidget::~RotateWidget() { delete mView; } void RotateWidget::activate(AnnotationArea *annotationArea) { Q_ASSERT(annotationArea != nullptr); mAnnotationArea = annotationArea; mView->setScene(annotationArea); showDialog(); } void RotateWidget::initGui() { mMainLayout->addWidget(mView); setLayout(mMainLayout); } void RotateWidget::showDialog() { RotateDialog rotateDialog(this); connect(&rotateDialog, &RotateDialog::rotate, this, &RotateWidget::rotate); connect(&rotateDialog, &RotateDialog::flip, this, &RotateWidget::flip); rotateDialog.exec(); emit closing(); } void RotateWidget::rotate(qreal angel) { Q_ASSERT(mAnnotationArea != nullptr); mAnnotationArea->rotate(angel); } void RotateWidget::flip(FlipDirection direction) { Q_ASSERT(mAnnotationArea != nullptr); mAnnotationArea->flip(direction); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/rotator/RotateWidget.h000066400000000000000000000027571440330760000224310ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ROTATEWIDGET_H #define KIMAGEANNOTATOR_ROTATEWIDGET_H #include #include #include #include "RotateDialog.h" #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class RotateWidget : public QWidget { Q_OBJECT public: explicit RotateWidget(); ~RotateWidget() override; void activate(AnnotationArea *annotationArea); signals: void closing() const; private: AnnotationArea *mAnnotationArea; QGraphicsView *mView; QVBoxLayout *mMainLayout; void initGui(); void showDialog(); void rotate(qreal angel); void flip(FlipDirection direction); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ROTATEWIDGET_H kImageAnnotator-0.6.1/src/gui/scaler/000077500000000000000000000000001440330760000174225ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/scaler/ScaleDialog.cpp000066400000000000000000000125311440330760000222770ustar00rootroot00000000000000/* * Copyright (C) 2017 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ScaleDialog.h" namespace kImageAnnotator { ScaleDialog::ScaleDialog(const QSize &imageSize, QWidget *parent) : QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint), mKeepAspectRatioCheckBox(new QCheckBox), mWidthPixelLabel(new QLabel(this)), mHeightPixelLabel(new QLabel(this)), mWidthPercentLabel(new QLabel(this)), mHeightPercentLabel(new QLabel(this)), mWidthPixelSpinBox(new CustomSpinBox(this)), mHeightPixelSpinBox(new CustomSpinBox(this)), mWidthPercentSpinBox(new CustomSpinBox(this)), mOkButton(new QPushButton(this)), mCancelButton(new QPushButton(this)), mHeightPercentSpinBox(new CustomSpinBox(this)), mPixelGridLayout(new QGridLayout), mPercentGridLayout(new QGridLayout), mPixelGroupBox(new QGroupBox(this)), mPercentGroupBox(new QGroupBox(this)), mButtonRowLayout(new QHBoxLayout), mMainLayout(new QVBoxLayout(this)) { setWindowTitle(tr("Scale Image")); mSizeHandler.setSize(imageSize); initGui(); } void ScaleDialog::initGui() { mKeepAspectRatioCheckBox->setText(tr("Keep Aspect Ratio")); connect(mKeepAspectRatioCheckBox, &QCheckBox::toggled, &mSizeHandler, &ScaleSizeHandler::setAspectRatio); mKeepAspectRatioCheckBox->setChecked(true); mWidthPixelLabel->setText(tr("Width:")); mHeightPixelLabel->setText(tr("Height:")); mWidthPercentLabel->setText(tr("Width:")); mHeightPercentLabel->setText(tr("Height:")); mWidthPixelSpinBox->setSuffix(QLatin1String("px")); mWidthPixelSpinBox->setMinimum(1); mWidthPixelSpinBox->setMaximum(4000); mWidthPixelSpinBox->setValueSilent(mSizeHandler.size().width()); mWidthPixelSpinBox->setWrapping(false); connect(mWidthPixelSpinBox, &CustomSpinBox::valueChanged, &mSizeHandler, &ScaleSizeHandler::setWidthPixel); connect(&mSizeHandler, &ScaleSizeHandler::widthPixelChanged, mWidthPixelSpinBox, &CustomSpinBox::setValueSilent); mHeightPixelSpinBox->setSuffix(QLatin1String("px")); mHeightPixelSpinBox->setMinimum(1); mHeightPixelSpinBox->setMaximum(4000); mHeightPixelSpinBox->setValueSilent(mSizeHandler.size().height()); mHeightPixelSpinBox->setWrapping(false); connect(mHeightPixelSpinBox, &CustomSpinBox::valueChanged, &mSizeHandler, &ScaleSizeHandler::setHeightPixel); connect(&mSizeHandler, &ScaleSizeHandler::heightPixelChanged, mHeightPixelSpinBox, &CustomSpinBox::setValueSilent); mWidthPercentSpinBox->setSuffix(QLatin1String("%")); mWidthPercentSpinBox->setMinimum(1); mWidthPercentSpinBox->setMaximum(400); mWidthPercentSpinBox->setValueSilent(100); mWidthPercentSpinBox->setWrapping(false); connect(mWidthPercentSpinBox, &CustomSpinBox::valueChanged, &mSizeHandler, &ScaleSizeHandler::setWidthPercent); connect(&mSizeHandler, &ScaleSizeHandler::widthPercentChanged, mWidthPercentSpinBox, &CustomSpinBox::setValueSilent); mHeightPercentSpinBox->setSuffix(QLatin1String("%")); mHeightPercentSpinBox->setMinimum(1); mHeightPercentSpinBox->setMaximum(400); mHeightPercentSpinBox->setValueSilent(100); mHeightPercentSpinBox->setWrapping(false); connect(mHeightPercentSpinBox, &CustomSpinBox::valueChanged, &mSizeHandler, &ScaleSizeHandler::setHeightPercent); connect(&mSizeHandler, &ScaleSizeHandler::heightPercentChanged, mHeightPercentSpinBox, &CustomSpinBox::setValueSilent); mOkButton->setText(tr("OK")); connect(mOkButton, &QPushButton::clicked, this, &ScaleDialog::scale); mCancelButton->setText(tr("Cancel")); connect(mCancelButton, &QPushButton::clicked, this, &ScaleDialog::cancel); mPixelGridLayout->addWidget(mWidthPixelLabel, 0, 0); mPixelGridLayout->addWidget(mWidthPixelSpinBox, 0, 1); mPixelGridLayout->addWidget(mHeightPixelLabel, 1, 0); mPixelGridLayout->addWidget(mHeightPixelSpinBox, 1, 1); mPercentGridLayout->addWidget(mWidthPercentLabel, 0, 0); mPercentGridLayout->addWidget(mWidthPercentSpinBox, 0, 1); mPercentGridLayout->addWidget(mHeightPercentLabel, 1, 0); mPercentGridLayout->addWidget(mHeightPercentSpinBox, 1, 1); mPixelGroupBox->setTitle(tr("Pixel")); mPixelGroupBox->setLayout(mPixelGridLayout); mPercentGroupBox->setTitle(tr("Percent")); mPercentGroupBox->setLayout(mPercentGridLayout); mButtonRowLayout->addWidget(mOkButton); mButtonRowLayout->addWidget(mCancelButton); mButtonRowLayout->setAlignment(Qt::AlignRight); mMainLayout->addWidget(mKeepAspectRatioCheckBox); mMainLayout->addWidget(mPixelGroupBox); mMainLayout->addWidget(mPercentGroupBox); mMainLayout->addLayout(mButtonRowLayout); setLayout(mMainLayout); } void ScaleDialog::scale() { QSize newSize(mWidthPixelSpinBox->value(), mHeightPixelSpinBox->value()); emit finished(newSize); close(); } void ScaleDialog::cancel() { close(); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/scaler/ScaleDialog.h000066400000000000000000000040651440330760000217470ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SCALEDIALOG_H #define KIMAGEANNOTATOR_SCALEDIALOG_H #include #include #include #include #include #include #include #include #include "ScaleSizeHandler.h" #include "src/widgets/CustomSpinBox.h" namespace kImageAnnotator { class ScaleDialog : public QDialog { Q_OBJECT public: explicit ScaleDialog(const QSize &imageSize, QWidget *parent = nullptr); ~ScaleDialog() override = default; signals: void finished(const QSize &newSize) const; private: ScaleSizeHandler mSizeHandler; QCheckBox *mKeepAspectRatioCheckBox; QLabel *mWidthPixelLabel; QLabel *mHeightPixelLabel; QLabel *mWidthPercentLabel; QLabel *mHeightPercentLabel; CustomSpinBox *mWidthPixelSpinBox; CustomSpinBox *mHeightPixelSpinBox; CustomSpinBox *mWidthPercentSpinBox; CustomSpinBox *mHeightPercentSpinBox; QPushButton *mOkButton; QPushButton *mCancelButton; QGridLayout *mPixelGridLayout; QGridLayout *mPercentGridLayout; QGroupBox *mPixelGroupBox; QGroupBox *mPercentGroupBox; QHBoxLayout *mButtonRowLayout; QVBoxLayout *mMainLayout; void initGui(); private slots: void scale(); void cancel(); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_SCALEDIALOG_H kImageAnnotator-0.6.1/src/gui/scaler/ScaleSizeHandler.cpp000066400000000000000000000046121440330760000233110ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ScaleSizeHandler.h" namespace kImageAnnotator { ScaleSizeHandler::ScaleSizeHandler() : mKeepAspectRatio(true) { } void ScaleSizeHandler::setSize(QSize size) { mSize = size; } QSize ScaleSizeHandler::size() const { return mSize; } void ScaleSizeHandler::setAspectRatio(bool keepAspectRatio) { mKeepAspectRatio = keepAspectRatio; } void ScaleSizeHandler::setWidthPixel(int width) { auto percent = calculatePercent(width, mSize.width()); emit widthPercentChanged(percent * 100); if (mKeepAspectRatio) { setHeight(percent); } } void ScaleSizeHandler::setWidthPercent(float width) { auto percent = calculatePercent(width, 100); emit widthPixelChanged(percent * mSize.width()); if (mKeepAspectRatio) { setHeight(percent); } } void ScaleSizeHandler::setHeightPixel(int height) { auto percent = calculatePercent(height, mSize.height()); emit heightPercentChanged(percent * 100); if (mKeepAspectRatio) { setWidth(percent); } } void ScaleSizeHandler::setHeightPercent(float height) { auto percent = calculatePercent(height, 100); emit heightPixelChanged(percent * mSize.height()); if (mKeepAspectRatio) { setWidth(percent); } } float ScaleSizeHandler::calculatePercent(int newValue, int baseValue) const { return (float) newValue / (float) baseValue; } void ScaleSizeHandler::setHeight(float percent) const { emit heightPixelChanged(percent * mSize.height()); emit heightPercentChanged(percent * 100); } void ScaleSizeHandler::setWidth(float percent) const { emit widthPixelChanged(percent * mSize.width()); emit widthPercentChanged(percent * 100); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/scaler/ScaleSizeHandler.h000066400000000000000000000033761440330760000227640ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SCALESIZEHANDLER_H #define KIMAGEANNOTATOR_SCALESIZEHANDLER_H #include #include namespace kImageAnnotator { class ScaleSizeHandler : public QObject { Q_OBJECT public: explicit ScaleSizeHandler(); ~ScaleSizeHandler() override = default; void setSize(QSize size); QSize size() const; signals: void widthPixelChanged(int width) const; void widthPercentChanged(float width) const; void heightPixelChanged(int height) const; void heightPercentChanged(float height) const; public slots: void setAspectRatio(bool keepAspectRatio); void setWidthPixel(int width); void setWidthPercent(float width); void setHeightPixel(int height); void setHeightPercent(float height); private: bool mKeepAspectRatio; QSize mSize; float calculatePercent(int newValue, int baseValue) const; void setHeight(float percent) const; void setWidth(float percent) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SCALESIZEHANDLER_H kImageAnnotator-0.6.1/src/gui/scaler/ScaleWidget.cpp000066400000000000000000000032601440330760000223220ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ScaleWidget.h" namespace kImageAnnotator { kImageAnnotator::ScaleWidget::ScaleWidget() : mAnnotationArea(nullptr), mView(new QGraphicsView), mMainLayout(new QVBoxLayout(this)) { initGui(); } ScaleWidget::~ScaleWidget() { delete mView; } void ScaleWidget::activate(AnnotationArea *annotationArea) { Q_ASSERT(annotationArea != nullptr); mAnnotationArea = annotationArea; mView->setScene(annotationArea); showDialog(); } void ScaleWidget::initGui() { mMainLayout->addWidget(mView); setLayout(mMainLayout); } void ScaleWidget::showDialog() { auto sceneSize = mAnnotationArea->sceneRect().size(); ScaleDialog scaleDialog(sceneSize.toSize(), this); connect(&scaleDialog, &ScaleDialog::finished, this, &ScaleWidget::scale); scaleDialog.exec(); emit closing(); } void ScaleWidget::scale(const QSize &newSize) { mAnnotationArea->scale(newSize); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/scaler/ScaleWidget.h000066400000000000000000000027131440330760000217710ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SCALEWIDGET_H #define KIMAGEANNOTATOR_SCALEWIDGET_H #include #include #include #include "ScaleDialog.h" #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class ScaleWidget : public QWidget { Q_OBJECT public: explicit ScaleWidget(); ~ScaleWidget() override; void activate(AnnotationArea *annotationArea); signals: void closing() const; private: AnnotationArea *mAnnotationArea; QGraphicsView *mView; QVBoxLayout *mMainLayout; void initGui(); void showDialog(); void scale(const QSize &newSize); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SCALEWIDGET_H kImageAnnotator-0.6.1/src/gui/scrollAndZoomView/000077500000000000000000000000001440330760000215725ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/scrollAndZoomView/ScrollAndZoomView.cpp000066400000000000000000000062621440330760000256650ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ScrollAndZoomView.h" namespace kImageAnnotator { ScrollAndZoomView::ScrollAndZoomView(QWidget *parent) : QGraphicsView(parent), mIsDragging(false), mViewZoomer(new ViewZoomer(this)) { setTransformationAnchor(QGraphicsView::NoAnchor); disableDragging(); setViewportUpdateMode(ViewportUpdateMode::FullViewportUpdate); } ScrollAndZoomView::~ScrollAndZoomView() { delete mViewZoomer; } ZoomValueProvider *ScrollAndZoomView::zoomValueProvider() const { return mViewZoomer; } void ScrollAndZoomView::keyPressEvent(QKeyEvent *event) { mKeyHelper.keyPress(event); if(mKeyHelper.isSpacePressed()) { enableDragging(mapFromGlobal(QCursor::pos())); } QGraphicsView::keyPressEvent(event); } void ScrollAndZoomView::keyReleaseEvent(QKeyEvent *event) { mKeyHelper.keyRelease(event); if(!mKeyHelper.isSpacePressed()) { disableDragging(); } QGraphicsView::keyReleaseEvent(event); } void ScrollAndZoomView::mouseMoveEvent(QMouseEvent *event) { if (mIsDragging) { scrollTo(event->pos()); } else { QGraphicsView::mouseMoveEvent(event); } } void ScrollAndZoomView::mousePressEvent(QMouseEvent *event) { if (event->button() == Qt::MidButton) { enableDragging(event->pos()); } else { QGraphicsView::mousePressEvent(event); } } void ScrollAndZoomView::mouseReleaseEvent(QMouseEvent *event) { if (event->button() == Qt::MidButton) { disableDragging(); } else { QGraphicsView::mouseReleaseEvent(event); } } void ScrollAndZoomView::wheelEvent(QWheelEvent *event) { if (event->modifiers() & Qt::ControlModifier ) { mViewZoomer->wheelZoom(event); } else { QGraphicsView::wheelEvent(event); } } void ScrollAndZoomView::scrollTo(const QPoint &pos) { auto delta = pos - mLastPosition; scrollByDelta(horizontalScrollBar(), delta.x()); scrollByDelta(verticalScrollBar(), delta.y()); mLastPosition = pos; } void ScrollAndZoomView::scrollByDelta(QScrollBar *scrollBar, int delta) const { scrollBar->setValue(scrollBar->value() - delta); } void ScrollAndZoomView::enableDragging(const QPoint &pos) { mIsDragging = true; mLastPosition = pos; setDragCursorEnabled(true); } void ScrollAndZoomView::disableDragging() { mIsDragging = false; mLastPosition = {}; setDragCursorEnabled(false); } void ScrollAndZoomView::setDragCursorEnabled(bool enabled) const { enabled ? QGuiApplication::setOverrideCursor(Qt::SizeAllCursor) : QGuiApplication::restoreOverrideCursor(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/scrollAndZoomView/ScrollAndZoomView.h000066400000000000000000000037031440330760000253270ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SCROLLANDZOOMVIEW_H #define KIMAGEANNOTATOR_SCROLLANDZOOMVIEW_H #include #include #include #include #include "ViewZoomer.h" #include "src/common/helper/KeyHelper.h" namespace kImageAnnotator { class ScrollAndZoomView : public QGraphicsView { Q_OBJECT public: explicit ScrollAndZoomView(QWidget *parent); ~ScrollAndZoomView() override; ZoomValueProvider *zoomValueProvider() const; protected: void keyPressEvent(QKeyEvent *event) override; void keyReleaseEvent(QKeyEvent *event) override; void mouseMoveEvent(QMouseEvent *event) override; void mousePressEvent(QMouseEvent *event) override; void mouseReleaseEvent(QMouseEvent *event) override; void wheelEvent(QWheelEvent *event) override; private: ViewZoomer *mViewZoomer; bool mIsDragging; QPoint mLastPosition; KeyHelper mKeyHelper; void scrollTo(const QPoint &pos); void scrollByDelta(QScrollBar *scrollBar, int delta) const; void enableDragging(const QPoint &pos); void disableDragging(); void setDragCursorEnabled(bool enabled) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SCROLLANDZOOMVIEW_H kImageAnnotator-0.6.1/src/gui/scrollAndZoomView/ViewZoomer.cpp000066400000000000000000000041541440330760000244100ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ViewZoomer.h" namespace kImageAnnotator { ViewZoomer::ViewZoomer(QGraphicsView *view) : ZoomValueProvider(view), mView(view), mMinScale(0.1), mMaxScale(8.0) { } double ViewZoomer::zoomValue() const { return mView->transform().m11(); } void ViewZoomer::zoom(double factor) { auto currentZoomValue = zoomValue(); auto newZoomValue = currentZoomValue + factor; newZoomValue = QString::number(newZoomValue, 'f', 1).toDouble(); if(newZoomValue >= mMinScale && newZoomValue <= mMaxScale) { mView->resetMatrix(); mView->scale(newZoomValue, newZoomValue); emit zoomValueChanged(zoomValue()); } } void ViewZoomer::zoomToPoint(double factor, const QPoint &viewPoint) { const auto scenePoint = mView->mapToScene(viewPoint); zoom(factor); const auto delta = mView->mapToScene(viewPoint) - scenePoint; mView->translate(delta.x(), delta.y()); } void ViewZoomer::wheelZoom(QWheelEvent *event) { auto zoomInFactor = 0.1; const auto factor = event->angleDelta().y() < 0.0 ? -zoomInFactor : zoomInFactor; zoomToPoint(factor, event->pos()); event->accept(); // supress scrolling } void ViewZoomer::fitImageToView() { mView->fitInView(mView->sceneRect(), Qt::KeepAspectRatio); emit zoomValueChanged(zoomValue()); } void ViewZoomer::setZoomValue(double value) { zoom(value - zoomValue()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/scrollAndZoomView/ViewZoomer.h000066400000000000000000000030201440330760000240440ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_VIEWZOOMER_H #define KIMAGEANNOTATOR_VIEWZOOMER_H #include "src/annotations/core/ZoomValueProvider.h" #include #include class QPoint; namespace kImageAnnotator { class ViewZoomer : public ZoomValueProvider { Q_OBJECT public: explicit ViewZoomer(QGraphicsView *view); ~ViewZoomer() override = default; double zoomValue() const override; void setZoomValue(double value) override; void zoom(double factor); void zoomToPoint(double factor, const QPoint &viewPoint); void wheelZoom(QWheelEvent *event); void fitImageToView() override; private: QGraphicsView *mView; double mMinScale; double mMaxScale; }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_VIEWZOOMER_H kImageAnnotator-0.6.1/src/gui/selection/000077500000000000000000000000001440330760000201365ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/gui/selection/BaseSelectionHandles.cpp000066400000000000000000000066171440330760000246730ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "BaseSelectionHandles.h" namespace kImageAnnotator { BaseSelectionHandles::BaseSelectionHandles() : mGrabbedIndex(-1), mHandleSize(ScaledSizeProvider::resizeHandleSize()) { } QList BaseSelectionHandles::handles() const { return mIndexToHandleMap.values(); } void BaseSelectionHandles::grabHandle(const QPointF &position, const QRectF &selection) { for (auto entry : mIndexToHandleMap.toStdMap()) { auto index = entry.first; auto handle = entry.second; if (handle.contains(position)) { mGrabbedIndex = index; mGrabOffset = position - ShapeHelper::rectPointAtIndex(selection, mGrabbedIndex); return; } } mGrabbedIndex = -1; } void BaseSelectionHandles::releaseHandle() { mGrabbedIndex = -1; } int BaseSelectionHandles::grabbedIndex() const { return mGrabbedIndex; } void BaseSelectionHandles::updateHandles(const QRectF &selection) { auto offset = mHandleSize * 0.5; if (mIndexToHandleMap.contains(0)) { mIndexToHandleMap[0].moveTopLeft(ShapeHelper::rectTopLeftWithOffset(selection, 0).toPoint()); } if(mIndexToHandleMap.contains(1)) { mIndexToHandleMap[1].moveCenter(ShapeHelper::rectTopWithOffset(selection, -offset).toPoint()); } if(mIndexToHandleMap.contains(2)) { mIndexToHandleMap[2].moveTopRight(ShapeHelper::rectTopRightWithOffset(selection, 0).toPoint()); } if(mIndexToHandleMap.contains(3)) { mIndexToHandleMap[3].moveCenter(ShapeHelper::rectRightWithOffset(selection, -offset).toPoint()); } if(mIndexToHandleMap.contains(4)) { mIndexToHandleMap[4].moveBottomRight(ShapeHelper::rectBottomRightWithOffset(selection, 0).toPoint()); } if(mIndexToHandleMap.contains(5)) { mIndexToHandleMap[5].moveCenter(ShapeHelper::rectBottomWithOffset(selection, -offset).toPoint()); } if(mIndexToHandleMap.contains(6)) { mIndexToHandleMap[6].moveBottomLeft(ShapeHelper::rectBottomLeftWithOffset(selection, 0).toPoint()); } if(mIndexToHandleMap.contains(7)) { mIndexToHandleMap[7].moveCenter(ShapeHelper::rectLeftWithOffset(selection, -offset).toPoint()); } } bool BaseSelectionHandles::isHandleGrabbed() const { return mGrabbedIndex != -1; } QPointF BaseSelectionHandles::grabOffset() const { return mGrabOffset; } void BaseSelectionHandles::applyZoomValue(double value) { auto oldHandleSize = mHandleSize; mHandleSize = ScaledSizeProvider::resizeHandleSize() / value; auto offset = 0.5 * (oldHandleSize - mHandleSize); for (auto &handle : mIndexToHandleMap) { handle.adjust(offset, offset, -offset, -offset); } } void BaseSelectionHandles::insertHandle(int index) { mIndexToHandleMap[index] = QRectF(0, 0, mHandleSize, mHandleSize); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/selection/BaseSelectionHandles.h000066400000000000000000000034431440330760000243320ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPHANDELS_H #define KIMAGEANNOTATOR_CROPHANDELS_H #include #include #include #include "ISelectionHandles.h" #include "src/common/provider/ScaledSizeProvider.h" #include "src/common/helper/ShapeHelper.h" namespace kImageAnnotator { class BaseSelectionHandles : public ISelectionHandles { public: ~BaseSelectionHandles() override = default; QList handles() const override; void grabHandle(const QPointF &position, const QRectF &selection) override; void releaseHandle() override; int grabbedIndex() const override; void updateHandles(const QRectF &selection) override; bool isHandleGrabbed() const override; QPointF grabOffset() const override; void applyZoomValue(double value) override; protected: explicit BaseSelectionHandles(); void insertHandle(int index); private: QMap mIndexToHandleMap; int mGrabbedIndex; QPointF mGrabOffset; double mHandleSize; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CROPHANDELS_H kImageAnnotator-0.6.1/src/gui/selection/BaseSelectionView.cpp000066400000000000000000000070451440330760000242230ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "BaseSelectionView.h" namespace kImageAnnotator { BaseSelectionView::BaseSelectionView(SelectionHandler *cropSelectionHandler, KeyHelper *keyHelper, QWidget *parent) : ScrollAndZoomView(parent), mKeyHelper(keyHelper), mSelectionHandler(cropSelectionHandler) { connect(zoomValueProvider(), &ZoomValueProvider::zoomValueChanged, this, &BaseSelectionView::applyZoomValue); } void BaseSelectionView::init(AnnotationArea *annotationArea) { Q_ASSERT(annotationArea != nullptr); setScene(annotationArea); } void BaseSelectionView::keyPressEvent(QKeyEvent *event) { mKeyHelper->keyPress(event); ScrollAndZoomView::keyPressEvent(event); } void BaseSelectionView::keyReleaseEvent(QKeyEvent *event) { mKeyHelper->keyRelease(event); ScrollAndZoomView::keyReleaseEvent(event); } void BaseSelectionView::mouseMoveEvent(QMouseEvent *event) { if (mSelectionHandler->isInMotion()) { mSelectionHandler->move(mapToScene(event->pos())); } else { ScrollAndZoomView::mouseMoveEvent(event); } updateCursor(mapToScene(event->pos())); } void BaseSelectionView::mousePressEvent(QMouseEvent *event) { if(event->button() == Qt::LeftButton) { mSelectionHandler->grab(mapToScene(event->pos())); } else { ScrollAndZoomView::mousePressEvent(event); } updateCursor(mapToScene(event->pos())); } void BaseSelectionView::mouseReleaseEvent(QMouseEvent *event) { if (mSelectionHandler->isInMotion()) { mSelectionHandler->release(); } else { ScrollAndZoomView::mouseReleaseEvent(event); } updateCursor(mapToScene(event->pos())); } void BaseSelectionView::drawForeground(QPainter *painter, const QRectF &rect) { auto selection = mSelectionHandler->selection(); auto zoomValue = zoomValueProvider()->zoomValue(); auto lineWidth = 1 / zoomValue; // Draw border around selected are painter->setClipRect(rect); painter->setBrush(Qt::NoBrush); painter->setPen(QPen(Qt::gray, lineWidth, Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin)); painter->drawRect(selection); if (!mSelectionHandler->isInMotion()) { painter->setPen(QPen(Qt::white, lineWidth, Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin)); painter->setBrush(QColor(Qt::gray)); auto handles = mSelectionHandler->selectionHandles(); for (auto handle : handles) { painter->drawRect(handle); } } QGraphicsView::drawForeground(painter, rect); } QRectF BaseSelectionView::currentSelection() const { return mSelectionHandler->selection(); } void BaseSelectionView::updateCursor(const QPointF &pos) { if(mSelectionHandler->isInMotion()) { setCursor(Qt::ClosedHandCursor); } else if(mSelectionHandler->selectionContains(pos)) { setCursor(Qt::OpenHandCursor); } else { unsetCursor(); } } void BaseSelectionView::applyZoomValue(double value) { mSelectionHandler->applyZoomValue(value); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/selection/BaseSelectionView.h000066400000000000000000000036441440330760000236710ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_BASESELECTIONVIEW_H #define KIMAGEANNOTATOR_BASESELECTIONVIEW_H #include "src/gui/scrollAndZoomView/ScrollAndZoomView.h" #include "src/gui/selection/SelectionHandler.h" #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class BaseSelectionView : public ScrollAndZoomView { Q_OBJECT public: explicit BaseSelectionView(SelectionHandler *selectionHandler, KeyHelper *keyHelper, QWidget *parent); ~BaseSelectionView() override = default; void init(AnnotationArea *annotationArea); protected: void keyPressEvent(QKeyEvent *event) override; void keyReleaseEvent(QKeyEvent *event) override; void mouseMoveEvent(QMouseEvent *event) override; void mousePressEvent(QMouseEvent *event) override; void mouseReleaseEvent(QMouseEvent *event) override; void drawForeground(QPainter *painter, const QRectF &rect) override; QRectF currentSelection() const; private: KeyHelper *mKeyHelper; SelectionHandler *mSelectionHandler; void updateCursor(const QPointF &pos); private slots: void applyZoomValue(double value); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_BASESELECTIONVIEW_H kImageAnnotator-0.6.1/src/gui/selection/ISelectionHandles.h000066400000000000000000000027451440330760000236540ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ISELECTIONHANDLES_H #define KIMAGEANNOTATOR_ISELECTIONHANDLES_H namespace kImageAnnotator { class ISelectionHandles { public: explicit ISelectionHandles() = default; virtual ~ISelectionHandles() = default; virtual QList handles() const = 0; virtual void grabHandle(const QPointF &position, const QRectF &selection) = 0; virtual void releaseHandle() = 0; virtual int grabbedIndex() const = 0; virtual void updateHandles(const QRectF &selection) = 0; virtual bool isHandleGrabbed() const = 0; virtual QPointF grabOffset() const = 0; virtual void applyZoomValue(double value) = 0; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ISELECTIONHANDLES_H kImageAnnotator-0.6.1/src/gui/selection/ISelectionRestrictor.h000066400000000000000000000024671440330760000244370ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ISELECTIONRESTRICTOR_H #define KIMAGEANNOTATOR_ISELECTIONRESTRICTOR_H namespace kImageAnnotator { class ISelectionRestrictor { public: explicit ISelectionRestrictor() = default; virtual ~ISelectionRestrictor() = default; virtual QRectF &restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const = 0; virtual QRectF &restrictMove(QRectF &newRect, const QRectF &rectLimit) const = 0; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ISELECTIONRESTRICTOR_H kImageAnnotator-0.6.1/src/gui/selection/SelectionHandler.cpp000066400000000000000000000110711440330760000240650ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SelectionHandler.h" namespace kImageAnnotator { SelectionHandler::SelectionHandler(ISelectionRestrictor *selectionRestrictor, const QSharedPointer &selectionHandles) : mAnnotationArea(nullptr), mSelectionRestrictor(selectionRestrictor), mRestrictionEnabled(true), mHandles(selectionHandles) { } SelectionHandler::~SelectionHandler() { delete mSelectionRestrictor; } void SelectionHandler::init(AnnotationArea *annotationArea) { mAnnotationArea = annotationArea; } QRectF SelectionHandler::selection() const { return mSelection; } QList SelectionHandler::selectionHandles() const { return mHandles->handles(); } void SelectionHandler::grab(const QPointF &position) { mHandles->grabHandle(position, mSelection); if (!mHandles->isHandleGrabbed()) { mMoveHelper.grabSelection(position, mSelection); } if (isInMotion()) { update(); } } void SelectionHandler::move(const QPointF &position) { if (mHandles->isHandleGrabbed()) { auto selection = ShapeHelper::setRectPointAtIndex(mSelection, mHandles->grabbedIndex(), position - mHandles->grabOffset()); setSelection(restrictResize(selection)); } else if (mMoveHelper.isSelectionGabbed()) { auto selection = mSelection; selection.moveTopLeft(position - mMoveHelper.grabOffset()); setSelection(restrictMove(selection)); } if (isInMotion()) { update(); } } void SelectionHandler::release() { if (isInMotion()) { mHandles->releaseHandle(); mMoveHelper.releaseSelection(); update(); } } void SelectionHandler::resetSelection(const QRectF &selection, const QRectF &selectionLimit) { Q_ASSERT(mAnnotationArea != nullptr); setSelection(selection); mSelectionLimit = selectionLimit; } bool SelectionHandler::isInMotion() const { return mMoveHelper.isSelectionGabbed() || mHandles->isHandleGrabbed(); } void SelectionHandler::setWidth(int width) { QRectF selection(mSelection.x(), mSelection.y(), width, mSelection.height()); setSelection(restrictResize(selection)); } void SelectionHandler::setHeight(int height) { QRectF selection(mSelection.x(), mSelection.y(), mSelection.width(), height); setSelection(restrictResize(selection)); } void SelectionHandler::setPositionX(int x) { QRectF selection(x, mSelection.y(), mSelection.width(), mSelection.height()); setSelection(restrictMove(selection)); } void SelectionHandler::setPositionY(int y) { QRectF selection(mSelection.x(), y, mSelection.width(), mSelection.height()); setSelection(restrictMove(selection)); } void SelectionHandler::update() { Q_ASSERT(mAnnotationArea != nullptr); mHandles->updateHandles(mSelection); mAnnotationArea->update(); notifyAboutChange(); } void SelectionHandler::notifyAboutChange() const { emit selectionChanged(mSelection); } void SelectionHandler::setSelection(const QRectF &rect) { mSelection = rect; update(); } bool SelectionHandler::selectionContains(const QPointF &pos) const { return mSelection.contains(pos); } void SelectionHandler::setRestrictionEnabled(bool enabled) { mRestrictionEnabled = enabled; restrictResize(mSelection); update(); } QRectF &SelectionHandler::restrictResize(QRectF &selection) { if(mRestrictionEnabled) { return mSelectionRestrictor->restrictResize(selection, mSelection, mSelectionLimit) ; } else { return selection.isValid() ? selection : mSelection; } } QRectF &SelectionHandler::restrictMove(QRectF &selection) const { return mRestrictionEnabled ? mSelectionRestrictor->restrictMove(selection, mSelectionLimit) : selection; } bool SelectionHandler::restrictionEnabled() const { return mRestrictionEnabled; } void SelectionHandler::applyZoomValue(double value) { mHandles->applyZoomValue(value); mHandles->updateHandles(mSelection); } void SelectionHandler::replaceHandles(const QSharedPointer handles) { mHandles = handles; update(); } }kImageAnnotator-0.6.1/src/gui/selection/SelectionHandler.h000066400000000000000000000050011440330760000235260ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPHANDLES_H #define KIMAGEANNOTATOR_CROPHANDLES_H #include #include #include "src/gui/cropper/CropSelectionRestrictor.h" #include "src/gui/selection/ISelectionHandles.h" #include "SelectionMoveHelper.h" #include "src/annotations/core/AnnotationArea.h" namespace kImageAnnotator { class SelectionHandler : public QObject { Q_OBJECT public: explicit SelectionHandler(ISelectionRestrictor *selectionRestrictor, const QSharedPointer &selectionHandles); ~SelectionHandler() override; void init(AnnotationArea *annotationArea); QRectF selection() const; QList selectionHandles() const; void grab(const QPointF &position); void move(const QPointF &position); void release(); void setWidth(int width); void setHeight(int height); void setPositionX(int x); void setPositionY(int y); void resetSelection(const QRectF &selection, const QRectF &selectionLimit); bool isInMotion() const; bool selectionContains(const QPointF &pos) const; void setRestrictionEnabled(bool enabled); bool restrictionEnabled() const; void applyZoomValue(double value); void replaceHandles(const QSharedPointer handles); signals: void selectionChanged(const QRectF &rect) const; private: AnnotationArea *mAnnotationArea; QRectF mSelection; QRectF mSelectionLimit; ISelectionRestrictor *mSelectionRestrictor; QSharedPointer mHandles; SelectionMoveHelper mMoveHelper; bool mRestrictionEnabled; void update(); void notifyAboutChange() const; void setSelection(const QRectF &rect); QRectF &restrictResize(QRectF &selection); QRectF &restrictMove(QRectF &selection) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CROPHANDLES_H kImageAnnotator-0.6.1/src/gui/selection/SelectionHandlesAll.cpp000066400000000000000000000021351440330760000245200ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SelectionHandlesAll.h" namespace kImageAnnotator { SelectionHandlesAll::SelectionHandlesAll() : BaseSelectionHandles() { insertHandle(0); insertHandle(1); insertHandle(2); insertHandle(3); insertHandle(4); insertHandle(5); insertHandle(6); insertHandle(7); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/gui/selection/SelectionHandlesAll.h000066400000000000000000000022451440330760000241670ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SELECTIONHANDLESALL_H #define KIMAGEANNOTATOR_SELECTIONHANDLESALL_H #include "BaseSelectionHandles.h" namespace kImageAnnotator { class SelectionHandlesAll : public BaseSelectionHandles { public: explicit SelectionHandlesAll(); ~SelectionHandlesAll() override = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SELECTIONHANDLESALL_H kImageAnnotator-0.6.1/src/gui/selection/SelectionHandlesHorizontal.cpp000066400000000000000000000020101440330760000261310ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SelectionHandlesHorizontal.h" namespace kImageAnnotator { SelectionHandlesHorizontal::SelectionHandlesHorizontal() : BaseSelectionHandles() { insertHandle(1); insertHandle(5); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/selection/SelectionHandlesHorizontal.h000066400000000000000000000023171440330760000256100ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SELECTIONHANDLESHORIZONTAL_H #define KIMAGEANNOTATOR_SELECTIONHANDLESHORIZONTAL_H #include "BaseSelectionHandles.h" namespace kImageAnnotator { class SelectionHandlesHorizontal : public BaseSelectionHandles { public: explicit SelectionHandlesHorizontal(); ~SelectionHandlesHorizontal() override = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SELECTIONHANDLESHORIZONTAL_H kImageAnnotator-0.6.1/src/gui/selection/SelectionHandlesVertical.cpp000066400000000000000000000020011440330760000255510ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SelectionHandlesVertical.h" namespace kImageAnnotator { SelectionHandlesVertical::SelectionHandlesVertical() : BaseSelectionHandles() { insertHandle(3); insertHandle(7); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/gui/selection/SelectionHandlesVertical.h000066400000000000000000000023031440330760000252230ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SELECTIONHANDLESVERTICAL_H #define KIMAGEANNOTATOR_SELECTIONHANDLESVERTICAL_H #include "BaseSelectionHandles.h" namespace kImageAnnotator { class SelectionHandlesVertical : public BaseSelectionHandles { public: explicit SelectionHandlesVertical(); ~SelectionHandlesVertical() override = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SELECTIONHANDLESVERTICAL_H kImageAnnotator-0.6.1/src/gui/selection/SelectionMoveHelper.cpp000066400000000000000000000026571440330760000245700ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SelectionMoveHelper.h" namespace kImageAnnotator { SelectionMoveHelper::SelectionMoveHelper() : mIsSelectionGabbed(false) { } void SelectionMoveHelper::grabSelection(const QPointF &position, const QRectF &selection) { if (selection.contains(position)) { mGrabOffset = position - selection.topLeft(); mIsSelectionGabbed = true; } else { mIsSelectionGabbed = false; } } void SelectionMoveHelper::releaseSelection() { mIsSelectionGabbed = false; } bool SelectionMoveHelper::isSelectionGabbed() const { return mIsSelectionGabbed; } QPointF kImageAnnotator::SelectionMoveHelper::grabOffset() const { return mGrabOffset; } } kImageAnnotator-0.6.1/src/gui/selection/SelectionMoveHelper.h000066400000000000000000000025341440330760000242270ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SELECTIONMOVEHELPER_H #define KIMAGEANNOTATOR_SELECTIONMOVEHELPER_H #include #include namespace kImageAnnotator { class SelectionMoveHelper { public: explicit SelectionMoveHelper(); ~SelectionMoveHelper() = default; void grabSelection(const QPointF &position, const QRectF &selection); void releaseSelection(); bool isSelectionGabbed() const; QPointF grabOffset() const; private: bool mIsSelectionGabbed{}; QPointF mGrabOffset; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SELECTIONMOVEHELPER_H kImageAnnotator-0.6.1/src/widgets/000077500000000000000000000000001440330760000170335ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/widgets/ColorDialogButton.cpp000066400000000000000000000045041440330760000231340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ColorDialogButton.h" namespace kImageAnnotator { ColorDialogButton::ColorDialogButton(QWidget* parent) : QPushButton(parent) { connect(this, &ColorDialogButton::clicked, this, &ColorDialogButton::openDialog); setIconSize(QSize(48, iconSize().height())); } QColor ColorDialogButton::color() const { return mColor; } void ColorDialogButton::setColor(const QColor& color) { mColor = color; auto pixmapIcon = createPixmapFromColor(mColor); setIcon(pixmapIcon); setToolTip(mColor.name(QColor::HexArgb)); } QPixmap ColorDialogButton::createPixmapFromColor(const QColor& color) const { QImage tiledBackground(QSize(10, 10), QImage::Format_ARGB32_Premultiplied); tiledBackground.fill(Qt::white); QPainter tiledBackgroundPainter(&tiledBackground); tiledBackgroundPainter.setPen(Qt::NoPen); tiledBackgroundPainter.setBrush(Qt::gray); tiledBackgroundPainter.drawRect(0, 0, 5, 5); tiledBackgroundPainter.drawRect(5, 5, 10, 10); QPixmap pixmap(iconSize()); QPainter pixmapPainter(&pixmap); pixmapPainter.setPen(Qt::gray); pixmapPainter.setBrush(tiledBackground); pixmapPainter.drawRect(0,0, iconSize().width() - 1, iconSize().height() - 1); pixmapPainter.setBrush(color); pixmapPainter.drawRect(0,0, iconSize().width() - 1, iconSize().height() - 1); return pixmap; } void ColorDialogButton::openDialog() { auto color = QColorDialog::getColor(mColor, parentWidget(), QString(), QColorDialog::ShowAlphaChannel); if (color.isValid() && color != mColor) { setColor(color); emit colorChanged(color); } } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/ColorDialogButton.h000066400000000000000000000026621440330760000226040ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_COLORDIALOGBUTTON_H #define KIMAGEANNOTATOR_COLORDIALOGBUTTON_H #include #include #include namespace kImageAnnotator { class ColorDialogButton : public QPushButton { Q_OBJECT public: explicit ColorDialogButton(QWidget *parent); ~ColorDialogButton() override = default; void setColor(const QColor &color); QColor color() const; signals: void colorChanged(const QColor &color); private: QColor mColor; QPixmap createPixmapFromColor(const QColor &color) const; private slots: void openDialog(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_COLORDIALOGBUTTON_H kImageAnnotator-0.6.1/src/widgets/Controls.cpp000066400000000000000000000057301440330760000213470ustar00rootroot00000000000000/* * Copyright (C) 2021 Antonio Prcela * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "Controls.h" namespace kImageAnnotator { Controls::Controls(QWidget *parent) : QWidget(parent), mLayout(new QHBoxLayout(this)) { initGui(); setFocusPolicy(Qt::ClickFocus); } void Controls::initGui() { auto undoAction = createAction(tr("Undo"), IconLoader::load(QLatin1String("undo.svg"))); undoAction->setShortcut(Qt::Key_Undo); createButton(undoAction); auto redoAction = createAction(tr("Redo"), IconLoader::load(QLatin1String("redo.svg"))); redoAction->setShortcut(Qt::Key_Redo); createButton(redoAction); auto cropAction = createAction(tr("Crop"), IconLoader::load(QLatin1String("crop.svg"))); createButton(cropAction); auto scaleAction = createAction(tr("Scale"), IconLoader::load(QLatin1String("scale.svg"))); createButton(scaleAction); auto rotateAction = createAction(tr("Rotate"), IconLoader::load(QLatin1String("rotate.svg"))); createButton(rotateAction); auto modifyCanvasAction = createAction(tr("Modify canvas"), IconLoader::load(QLatin1String("modifycanvas.svg"))); createButton(modifyCanvasAction); auto cutAction = createAction(tr("Cut"), IconLoader::load(QLatin1String("cut.svg"))); createButton(cutAction); connect(undoAction, &QAction::triggered, this, &Controls::undo); connect(redoAction, &QAction::triggered, this, &Controls::redo); connect(cropAction, &QAction::triggered, this, &Controls::crop); connect(scaleAction, &QAction::triggered, this, &Controls::scale); connect(rotateAction, &QAction::triggered, this, &Controls::rotate); connect(modifyCanvasAction, &QAction::triggered, this, &Controls::modifyCanvas); connect(cutAction, &QAction::triggered, this, &Controls::cut); mLayout->setContentsMargins(0, 0, 0, 0); setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); setLayout(mLayout); } QAction *Controls::createAction(const QString &tooltip, const QIcon &icon) { auto action = new CustomToolButtonAction(this); action->setIcon(icon); action->setToolTip(tooltip); action->updateDefaultWidget(); return action; } CustomToolButton *Controls::createButton(QAction *defaultAction) { auto button = new CustomToolButton(this); button->setAction(defaultAction); mLayout->addWidget(button); return button; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/Controls.h000066400000000000000000000031201440330760000210030ustar00rootroot00000000000000/* * Copyright (C) 2021 Antonio Prcela * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CONTROLS_H #define KIMAGEANNOTATOR_CONTROLS_H #include #include #include #include "CustomToolButton.h" #include "CustomToolButtonAction.h" #include "src/common/helper/IconLoader.h" namespace kImageAnnotator { class Controls : public QWidget { Q_OBJECT public: explicit Controls(QWidget *parent); ~Controls() override = default; Q_SIGNALS: void undo() const; void redo() const; void crop() const; void scale() const; void rotate() const; void modifyCanvas() const; void cut() const; private: QHBoxLayout *mLayout; void initGui(); QAction *createAction(const QString &tooltip, const QIcon &icon); CustomToolButton *createButton(QAction *defaultAction); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_CONTROLS_H kImageAnnotator-0.6.1/src/widgets/CustomFontComboBox.cpp000066400000000000000000000030361440330760000232730ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CustomFontComboBox.h" namespace kImageAnnotator { CustomFontComboBox::CustomFontComboBox(QWidget *parent) : QFontComboBox(parent) { connect(this, QOverload::of(&QComboBox::currentIndexChanged), this, &CustomFontComboBox::elideCurrentText); elideCurrentText(); } QString CustomFontComboBox::selectItemText() const { return itemText(currentIndex()); } void CustomFontComboBox::resizeEvent(QResizeEvent *event) { elideCurrentText(); QComboBox::resizeEvent(event); } void CustomFontComboBox::elideCurrentText() { auto buttonsWidth = ScaledSizeProvider::scaledWidth(30); auto elidedText = fontMetrics().elidedText(selectItemText(), Qt::ElideRight, width() - buttonsWidth); setCurrentText(elidedText); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/CustomFontComboBox.h000066400000000000000000000025751440330760000227470ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUSTOMFONTCOMBOBOX_H #define KIMAGEANNOTATOR_CUSTOMFONTCOMBOBOX_H #include #include #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class CustomFontComboBox : public QFontComboBox { Q_OBJECT public: explicit CustomFontComboBox(QWidget *parent); ~CustomFontComboBox() override = default; QString selectItemText() const; protected: void resizeEvent(QResizeEvent *event) override; private slots: void elideCurrentText(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CUSTOMFONTCOMBOBOX_H kImageAnnotator-0.6.1/src/widgets/CustomSpinBox.cpp000066400000000000000000000023461440330760000223210ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CustomSpinBox.h" namespace kImageAnnotator { kImageAnnotator::CustomSpinBox::CustomSpinBox(QWidget *parent) : QSpinBox(parent) { setAlignment(Qt::AlignHCenter); connect(this, static_cast(&QSpinBox::valueChanged), this, &CustomSpinBox::valueChanged); } void CustomSpinBox::setValueSilent(int value) { blockSignals(true); QSpinBox::setValue(value); blockSignals(false); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/CustomSpinBox.h000066400000000000000000000023231440330760000217610ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUSTOMSPINBOX_H #define KIMAGEANNOTATOR_CUSTOMSPINBOX_H #include namespace kImageAnnotator { class CustomSpinBox : public QSpinBox { Q_OBJECT public: explicit CustomSpinBox(QWidget *parent = nullptr); ~CustomSpinBox() override = default; void setValueSilent(int value); signals: void valueChanged(int) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CUSTOMSPINBOX_H kImageAnnotator-0.6.1/src/widgets/CustomToolButton.cpp000066400000000000000000000035371440330760000230530ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CustomToolButton.h" namespace kImageAnnotator { CustomToolButton::CustomToolButton(QWidget *parent) : QToolButton(parent) { setCheckable(true); setAutoRaise(true); setIconSize(ScaledSizeProvider::scaledSize(QSize(24, 24))); setFocusPolicy(Qt::NoFocus); connect(this, &CustomToolButton::triggered, this, &CustomToolButton::setActiveAction); } void CustomToolButton::setButtonText(const QString &text) { mButtonText = text; refreshText(); } void CustomToolButton::setActiveAction(QAction *action) { QToolButton::setDefaultAction(action); refreshText(); } void CustomToolButton::trigger() { if (defaultAction() != nullptr) { defaultAction()->trigger(); } } void CustomToolButton::refreshText() { QToolButton::setText(mButtonText); } void CustomToolButton::setMenu(QMenu *menu) { setPopupMode(QToolButton::MenuButtonPopup); QToolButton::setMenu(menu); setActiveAction(menu->actions().first()); } void CustomToolButton::setAction(QAction *action) { setPopupMode(QToolButton::DelayedPopup); setDefaultAction(action); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/CustomToolButton.h000066400000000000000000000027371440330760000225210ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUSTOMTOOLBUTTON_H #define KIMAGEANNOTATOR_CUSTOMTOOLBUTTON_H #include #include #include #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class CustomToolButton : public QToolButton { Q_OBJECT public: explicit CustomToolButton(QWidget *parent = nullptr); ~CustomToolButton() override = default; void setButtonText(const QString &text); void setMenu(QMenu *menu); void setAction(QAction *action); public slots: void setActiveAction(QAction *action); void trigger(); void refreshText(); private: QString mButtonText; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CUSTOMTOOLBUTTON_H kImageAnnotator-0.6.1/src/widgets/CustomToolButtonAction.cpp000066400000000000000000000033121440330760000242000ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CustomToolButtonAction.h" namespace kImageAnnotator { CustomToolButtonAction::CustomToolButtonAction(QObject *parent) : QWidgetAction(parent) { initDefaultWidget(); } CustomToolButtonAction::~CustomToolButtonAction() { delete mText; delete mImage; delete mLayout; delete mMenuItem; } void CustomToolButtonAction::updateDefaultWidget() { mText->setText(toolTip()); mImage->setPixmap(icon().pixmap(ScaledSizeProvider::menuItemIconSize())); mMenuItem->setToolTip(toolTip()); setDefaultWidget(mMenuItem); } void CustomToolButtonAction::initDefaultWidget() { mMenuItem = new QWidget; mText = new QLabel(mMenuItem); mImage = new QLabel(mMenuItem); mLayout = new QHBoxLayout(mMenuItem); mLayout->setAlignment(Qt::AlignLeft); mLayout->addWidget(mImage); mLayout->addWidget(mText); mMenuItem->setLayout(mLayout); mMenuItem->setStyleSheet(QLatin1String(":hover{background-color:palette(highlight);}")); } } kImageAnnotator-0.6.1/src/widgets/CustomToolButtonAction.h000066400000000000000000000026471440330760000236570ustar00rootroot00000000000000/* * Copyright (C) 2019 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUSTOMTOOLBUTTONMENU_H #define KIMAGEANNOTATOR_CUSTOMTOOLBUTTONMENU_H #include #include #include #include #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class CustomToolButtonAction : public QWidgetAction { public: explicit CustomToolButtonAction(QObject *parent); ~CustomToolButtonAction() override; void updateDefaultWidget(); private: QLabel *mImage; QLabel *mText; QHBoxLayout *mLayout; QWidget *mMenuItem; void initDefaultWidget(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_CUSTOMTOOLBUTTONMENU_H kImageAnnotator-0.6.1/src/widgets/ToggleButton.cpp000066400000000000000000000017521440330760000221610ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ToggleButton.h" namespace kImageAnnotator { ToggleButton::ToggleButton(QWidget *parent) : QToolButton(parent) { setCheckable(true); setFocusPolicy(Qt::NoFocus); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/ToggleButton.h000066400000000000000000000021621440330760000216220ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_TOGGLEBUTTON_H #define KIMAGEANNOTATOR_TOGGLEBUTTON_H #include namespace kImageAnnotator { class ToggleButton : public QToolButton { Q_OBJECT public: explicit ToggleButton(QWidget *parent); ~ToggleButton() override = default; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_TOGGLEBUTTON_H kImageAnnotator-0.6.1/src/widgets/ToolPicker.cpp000066400000000000000000000135471440330760000216240ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ToolPicker.h" namespace kImageAnnotator { ToolPicker::ToolPicker(QWidget *parent) : QWidget(parent), mLayout(new FlowLayout(this)), mActionGroup(new QActionGroup(this)), mSelectedToolType(Tools::Select) { initGui(); setFocusPolicy(Qt::ClickFocus); } void ToolPicker::setTool(Tools newTool) { auto action = mActionToTool.key(newTool); auto button = mActionToButton[action]; button->setDefaultAction(action); action->setChecked(true); setToolAndNotify(newTool); } Tools ToolPicker::tool() { return mSelectedToolType; } void ToolPicker::initGui() { connect(mActionGroup, &QActionGroup::triggered, this, &ToolPicker::actionTriggered); auto action = createAction(tr("Select"), IconLoader::load(QLatin1String("select.svg")), Qt::Key_S, Tools::Select); createButton(action); action = createAction(tr("Duplicate"), IconLoader::load(QLatin1String("duplicate.svg")), Qt::Key_U, Tools::Duplicate); createButton(action); auto menu = new QMenu(this); action = createAction(tr("Arrow"), IconLoader::load(QLatin1String("arrow.svg")), Qt::Key_A, Tools::Arrow); menu->addAction(action); action = createAction(tr("Double Arrow"), IconLoader::load(QLatin1String("doubleArrow.svg")), Qt::Key_D, Tools::DoubleArrow); menu->addAction(action); action = createAction(tr("Line"), IconLoader::load(QLatin1String("line.svg")), Qt::Key_L, Tools::Line); menu->addAction(action); createButton(menu); action = createAction(tr("Pen"), IconLoader::load(QLatin1String("pen.svg")), Qt::Key_P, Tools::Pen); createButton(action); menu = new QMenu(this); action = createAction(tr("Marker Pen"), IconLoader::load(QLatin1String("markerPen.svg")), Qt::Key_M, Tools::MarkerPen); menu->addAction(action); action = createAction(tr("Marker Rectangle"), IconLoader::load(QLatin1String("markerRect.svg")), Qt::Key_J, Tools::MarkerRect); menu->addAction(action); action = createAction(tr("Marker Ellipse"), IconLoader::load(QLatin1String("markerEllipse.svg")), Qt::Key_K, Tools::MarkerEllipse); menu->addAction(action); createButton(menu); menu = new QMenu(this); action = createAction(tr("Text"), IconLoader::load(QLatin1String("text.svg")), Qt::Key_T, Tools::Text); menu->addAction(action); action = createAction(tr("Text Pointer"), IconLoader::load(QLatin1String("textPointer.svg")), Qt::Key_C, Tools::TextPointer); menu->addAction(action); action = createAction(tr("Text Arrow"), IconLoader::load(QLatin1String("textArrow.svg")), Qt::Key_H, Tools::TextArrow); menu->addAction(action); createButton(menu); menu = new QMenu(this); action = createAction(tr("Number"), IconLoader::load(QLatin1String("number.svg")), Qt::Key_N, Tools::Number); menu->addAction(action); action = createAction(tr("Number Pointer"), IconLoader::load(QLatin1String("numberPointer.svg")), Qt::Key_O, Tools::NumberPointer); menu->addAction(action); action = createAction(tr("Number Arrow"), IconLoader::load(QLatin1String("numberArrow.svg")), Qt::Key_W, Tools::NumberArrow); menu->addAction(action); createButton(menu); menu = new QMenu(this); action = createAction(tr("Blur"), IconLoader::load(QLatin1String("blur.svg")), Qt::Key_B, Tools::Blur); menu->addAction(action); action = createAction(tr("Pixelate"), IconLoader::load(QLatin1String("pixelate.svg")), Qt::Key_X, Tools::Pixelate); menu->addAction(action); createButton(menu); menu = new QMenu(this); action = createAction(tr("Rectangle"), IconLoader::load(QLatin1String("rect.svg")), Qt::Key_R, Tools::Rect); menu->addAction(action); action = createAction(tr("Ellipse"), IconLoader::load(QLatin1String("ellipse.svg")), Qt::Key_E, Tools::Ellipse); menu->addAction(action); createButton(menu); action = createAction(tr("Sticker"), IconLoader::load(QLatin1String("sticker.svg")), Qt::Key_I, Tools::Sticker); createButton(action); mLayout->setContentsMargins(3, 0, 0, 3); mLayout->setSpacing(2, 2); setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); setLayout(mLayout); } QAction *ToolPicker::createAction(const QString &tooltip, const QIcon &icon, Qt::Key shortcut, Tools toolType) { auto action = new CustomToolButtonAction(this); action->setCheckable(true); action->setIcon(icon); action->setShortcut(shortcut); action->setToolTip(tooltip + QLatin1String(" (") + shortcut + QLatin1String(")")); action->updateDefaultWidget(); mActionToTool[action] = toolType; mActionGroup->addAction(action); return action; } CustomToolButton *ToolPicker::createButton(QAction *defaultAction) { auto button = new CustomToolButton(this); button->setAction(defaultAction); mActionToButton[defaultAction] = button; mLayout->addWidget(button); return button; } CustomToolButton *ToolPicker::createButton(QMenu *menu) { auto button = new CustomToolButton(this); button->setMenu(menu); for(auto action : menu->actions()) { mActionToButton[action] = button; } mLayout->addWidget(button); return button; } void ToolPicker::actionTriggered(QAction *action) { auto newTool = mActionToTool.value(action); setToolAndNotify(newTool); } void ToolPicker::setToolAndNotify(Tools newTool) { mSelectedToolType = newTool; emit toolSelected(mSelectedToolType); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/ToolPicker.h000066400000000000000000000036621440330760000212660ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_TOOLPICKER_H #define KIMAGEANNOTATOR_TOOLPICKER_H #include #include #include #include #include "CustomToolButton.h" #include "CustomToolButtonAction.h" #include "src/common/enum/Tools.h" #include "src/common/helper/IconLoader.h" #include "src/widgets/misc/FlowLayout.h" namespace kImageAnnotator { class ToolPicker : public QWidget { Q_OBJECT public: explicit ToolPicker(QWidget *parent); ~ToolPicker() override = default; void setTool(Tools newTool); Tools tool(); signals: void toolSelected(Tools newTool); private: QActionGroup *mActionGroup; FlowLayout *mLayout; Tools mSelectedToolType; QHash mActionToTool; QHash mActionToButton; void initGui(); QAction *createAction(const QString &tooltip, const QIcon &icon, Qt::Key shortcut, Tools toolType); CustomToolButton *createButton(QAction *defaultAction); CustomToolButton *createButton(QMenu *menu); private slots: void actionTriggered(QAction *action); void setToolAndNotify(Tools newTool); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_TOOLPICKER_H kImageAnnotator-0.6.1/src/widgets/menuButtons/000077500000000000000000000000001440330760000213565ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/widgets/menuButtons/GridMenu.cpp000066400000000000000000000061371440330760000236030ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "GridMenu.h" namespace kImageAnnotator { GridMenu::GridMenu(QWidget *parent) : QMenu(parent), mLayout(new QGridLayout(this)), mButtonGroup(new QButtonGroup(this)) { setLayout(mLayout); mLayout->setSpacing(0); mLayout->setContentsMargins(4, 4, 4, 4); } GridMenu::~GridMenu() { qDeleteAll(mButtonGroup->buttons()); } void GridMenu::addItem(const QIcon &icon, const QString &toolTip, const QVariant &data) { auto button = createButton(icon, toolTip, data); addButtonToLayout(button); if(mLayout->count() == 1) { button->setChecked(true); emit selectionChanged(); } } void GridMenu::addButtonToLayout(GridMenuButton *button) { auto itemCount = mLayout->count(); auto row = itemCount / 4; auto column = (itemCount % 4) + 1; mLayout->addWidget(button, row, column); } GridMenuButton *GridMenu::createButton(const QIcon &icon, const QString &toolTip, const QVariant &data) const { auto button = new GridMenuButton(icon, toolTip, data); connect(button, &QToolButton::clicked, this, &GridMenu::buttonClicked); mButtonGroup->addButton(button); return button; } void kImageAnnotator::GridMenu::setCurrentData(const QVariant &data) { for(auto button : mButtonGroup->buttons()) { auto gridMenuButton = dynamic_cast(button); if(gridMenuButton != nullptr && gridMenuButton->data() == data) { gridMenuButton->setChecked(true); emit selectionChanged(); return; } } } QIcon kImageAnnotator::GridMenu::currentIcon() const { auto button = mButtonGroup->checkedButton(); return button != nullptr ? button->icon() : QIcon(); } QVariant kImageAnnotator::GridMenu::currentData() const { auto button = dynamic_cast(mButtonGroup->checkedButton()); return button != nullptr ? button->data() : QVariant(); } QString kImageAnnotator::GridMenu::currentToolTip() const { auto button = mButtonGroup->checkedButton(); return button != nullptr ? button->toolTip() : QString(); } void GridMenu::clear() { auto buttons = mButtonGroup->buttons(); for(auto button : buttons) { mButtonGroup->removeButton(button); mLayout->removeWidget(button); } qDeleteAll(buttons); QMenu::clear(); emit selectionChanged(); } QSize GridMenu::sizeHint() const { return mLayout->sizeHint(); } void kImageAnnotator::GridMenu::buttonClicked() { close(); emit selectionChanged(); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/menuButtons/GridMenu.h000066400000000000000000000033701440330760000232440ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_GRIDMENU_H #define KIMAGEANNOTATOR_GRIDMENU_H #include #include #include #include #include "GridMenuButton.h" #include "src/common/provider/DevicePixelRatioScaler.h" namespace kImageAnnotator { class GridMenu : public QMenu { Q_OBJECT public: explicit GridMenu(QWidget *parent); ~GridMenu() override; void addItem(const QIcon &icon, const QString &toolTip, const QVariant &data); void setCurrentData(const QVariant &data); QIcon currentIcon() const; QVariant currentData() const; QString currentToolTip() const; void clear(); QSize sizeHint() const override; signals: void selectionChanged(); private: QButtonGroup *mButtonGroup; QGridLayout *mLayout; void buttonClicked(); GridMenuButton *createButton(const QIcon &icon, const QString &toolTip, const QVariant &data) const; void addButtonToLayout(GridMenuButton *button); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_GRIDMENU_H kImageAnnotator-0.6.1/src/widgets/menuButtons/GridMenuButton.cpp000066400000000000000000000035741440330760000250010ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "GridMenuButton.h" namespace kImageAnnotator { GridMenuButton::GridMenuButton(const QIcon &icon, const QString &toolTip, QVariant data) : mData(std::move(data)) { setIcon(icon); setToolTip(toolTip); setIconSize(ScaledSizeProvider::scaledSize(QSize(32, 32))); setCheckable(true); setFixedSize(iconSize() + ScaledSizeProvider::scaledSize(QSize(4,4))); } QVariant kImageAnnotator::GridMenuButton::data() const { return mData; } void GridMenuButton::paintEvent(QPaintEvent *event) { QPainter painter(this); QStyleOption styleOption; styleOption.initFrom(this); auto buttonRect = event->rect().adjusted(0, 0, -1, -1); if(styleOption.state & QStyle::State_MouseOver) { auto defaultPen = painter.pen(); auto defaultBrush = painter.brush(); painter.setPen(Constants::HoverColor); painter.setBrush(Constants::HoverColor); painter.drawRect(buttonRect); painter.setPen(defaultPen); painter.setBrush(defaultBrush); } painter.drawPixmap(buttonRect.topLeft() + QPointF(2, 2), icon().pixmap(iconSize())); if(isChecked()) { painter.drawRect(buttonRect); } } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/menuButtons/GridMenuButton.h000066400000000000000000000026351440330760000244430ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_GRIDMENUBUTTON_H #define KIMAGEANNOTATOR_GRIDMENUBUTTON_H #include #include #include #include #include #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class GridMenuButton : public QToolButton { Q_OBJECT public: GridMenuButton(const QIcon &icon, const QString &toolTip, QVariant data); ~GridMenuButton() override = default; QVariant data() const; protected slots: void paintEvent(QPaintEvent *event) override; private: QVariant mData; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_GRIDMENUBUTTON_H kImageAnnotator-0.6.1/src/widgets/menuButtons/GridMenuToolButton.cpp000066400000000000000000000033631440330760000256330ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "GridMenuToolButton.h" namespace kImageAnnotator { GridMenuToolButton::GridMenuToolButton(QWidget *parent) : QToolButton(parent), mMenu(new GridMenu(this)) { setMenu(mMenu); connect(mMenu, &GridMenu::selectionChanged, this, &GridMenuToolButton::selectionChanged); connect(mMenu, &GridMenu::selectionChanged, this, &GridMenuToolButton::updateIconAndToolTip); } GridMenuToolButton::~GridMenuToolButton() { delete mMenu; } void GridMenuToolButton::addItem(const QIcon &icon, const QString &toolTip, const QVariant &data) { mMenu->addItem(icon, toolTip, data); } QVariant GridMenuToolButton::currentData() const { return mMenu->currentData(); } void kImageAnnotator::GridMenuToolButton::setCurrentData(const QVariant &data) { mMenu->setCurrentData(data); } void GridMenuToolButton::clear() { mMenu->clear(); } void GridMenuToolButton::updateIconAndToolTip() { setIcon(mMenu->currentIcon()); setToolTip(mMenu->currentToolTip()); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/menuButtons/GridMenuToolButton.h000066400000000000000000000027221440330760000252760ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_GRIDMENUTOOLBUTTON_H #define KIMAGEANNOTATOR_GRIDMENUTOOLBUTTON_H #include #include "src/widgets/menuButtons/GridMenu.h" namespace kImageAnnotator { class GridMenuToolButton : public QToolButton { Q_OBJECT public: explicit GridMenuToolButton(QWidget *parent); ~GridMenuToolButton() override; void addItem(const QIcon &icon, const QString &toolTip, const QVariant &data); QVariant currentData() const; void setCurrentData(const QVariant &data); void clear(); signals: void selectionChanged(); private: GridMenu *mMenu; private slots: void updateIconAndToolTip(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_GRIDMENUTOOLBUTTON_H kImageAnnotator-0.6.1/src/widgets/menuButtons/ListItemGroup.cpp000066400000000000000000000031051440330760000246300ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ListItemGroup.h" namespace kImageAnnotator { ListItemGroup::ListItemGroup(QObject *parent) : QObject(parent), mCheckedItem(nullptr) { } void ListItemGroup::addItem(ListMenuItem *item) { mItems.append(item); connect(item, &ListMenuItem::toggled, this, &ListItemGroup::updateCheckedItem); if(mCheckedItem == nullptr) { mCheckedItem = item; mCheckedItem->setIsChecked(true); } } ListMenuItem *ListItemGroup::checkedItem() const { return mCheckedItem; } QList ListItemGroup::items() const { return mItems; } void ListItemGroup::updateCheckedItem() { auto item = dynamic_cast(sender()); if(item != nullptr && item->isChecked()) { mCheckedItem->setIsChecked(false); mCheckedItem = item; emit checkedItemChanged(); } } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/menuButtons/ListItemGroup.h000066400000000000000000000026651440330760000243070ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_LISTITEMGROUP_H #define KIMAGEANNOTATOR_LISTITEMGROUP_H #include #include #include "src/widgets/menuButtons/ListMenuItem.h" namespace kImageAnnotator { class ListItemGroup : public QObject { Q_OBJECT public: explicit ListItemGroup(QObject *parent); ~ListItemGroup() override = default; void addItem(ListMenuItem *item); ListMenuItem* checkedItem() const; QList items() const; signals: void checkedItemChanged(); private: QList mItems; ListMenuItem *mCheckedItem; private slots: void updateCheckedItem(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_LISTITEMGROUP_H kImageAnnotator-0.6.1/src/widgets/menuButtons/ListMenu.cpp000066400000000000000000000044701440330760000236270ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ListMenu.h" namespace kImageAnnotator { ListMenu::ListMenu(QWidget *parent) : QMenu(parent), mLayout(new QVBoxLayout(this)), mListItemGroup(new ListItemGroup(this)) { setLayout(mLayout); mLayout->setContentsMargins(0, 0, 0, 0); mLayout->setSpacing(0); connect(mListItemGroup, &ListItemGroup::checkedItemChanged, this, &ListMenu::selectionChanged); } ListMenu::~ListMenu() { qDeleteAll(mListItemGroup->items()); } void ListMenu::addItem(const QIcon &icon, const QString &text, const QVariant &data) { auto item = new ListMenuItem(icon, text, data, this); mLayout->addWidget(item); mListItemGroup->addItem(item); } QVariant ListMenu::currentData() const { auto item = mListItemGroup->checkedItem(); return item != nullptr ? item->data() : QVariant(); } void ListMenu::setCurrentData(const QVariant &data) { for(auto item : mListItemGroup->items()) { if(item->data() == data){ item->setIsChecked(true); return; } } } QIcon ListMenu::currentIcon() const { auto item = mListItemGroup->checkedItem(); return item != nullptr ? item->icon() : QIcon(); } QString ListMenu::currentText() const { auto item = mListItemGroup->checkedItem(); return item != nullptr ? item->text() : QString(); } void ListMenu::setDataVisible(const QVariant &data, bool isVisible) { for(auto item : mListItemGroup->items()) { if(item->data() == data){ item->setVisible(isVisible); setMinimumSize(mLayout->minimumSize()); return; } } } QSize ListMenu::sizeHint() const { return mLayout->sizeHint(); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/menuButtons/ListMenu.h000066400000000000000000000032161440330760000232710ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_LISTMENU_H #define KIMAGEANNOTATOR_LISTMENU_H #include #include #include "src/widgets/menuButtons/ListMenuItem.h" #include "src/widgets/menuButtons/ListItemGroup.h" #include "src/common/provider/DevicePixelRatioScaler.h" namespace kImageAnnotator { class ListMenu : public QMenu { Q_OBJECT public: explicit ListMenu(QWidget *parent); ~ListMenu() override; void addItem(const QIcon &icon, const QString &text, const QVariant &data); QVariant currentData() const; void setCurrentData(const QVariant &data); QIcon currentIcon() const; QString currentText() const; void setDataVisible(const QVariant &data, bool isVisible); QSize sizeHint() const override; signals: void selectionChanged(); private: QVBoxLayout *mLayout; ListItemGroup *mListItemGroup; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_LISTMENU_H kImageAnnotator-0.6.1/src/widgets/menuButtons/ListMenuItem.cpp000066400000000000000000000062541440330760000244500ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include "ListMenuItem.h" namespace kImageAnnotator { ListMenuItem::ListMenuItem(const QIcon &icon, const QString &text, const QVariant &data, QWidget *parent) : QWidget(parent), mIcon(icon), mText(text), mData(data), mIsChecked(false), mSpacer(6), mMargin(5) { setMouseTracking(true); mIconSize = ScaledSizeProvider::menuItemIconSize(); auto offsetForTextWidth = 1.15; // Width not correct calculated on windows #117 mTextSize = QSize(fontMetrics().width(mText) * offsetForTextWidth, fontMetrics().height()); mIconOffset = QPoint(mMargin, mMargin); mTextOffset = QPoint(mIconSize.width() + mIconOffset.x() + mSpacer, (mIconSize.height() - mTextSize.height()) / 2 + mIconOffset.y()); mSize = QSize(mIconSize.width() + mTextSize.width() + mMargin * 2 + mSpacer, mIconSize.height() + mMargin * 2); } QVariant ListMenuItem::data() const { return mData; } QIcon ListMenuItem::icon() const { return mIcon; } QString ListMenuItem::text() const { return mText; } QSize ListMenuItem::minimumSizeHint() const { return mSize; } bool ListMenuItem::isChecked() const { return mIsChecked; } void ListMenuItem::setIsChecked(bool isChecked) { mIsChecked = isChecked; emit toggled(isChecked); update(); } void ListMenuItem::paintEvent(QPaintEvent *event) { QPainter painter(this); QStyleOption styleOption; styleOption.initFrom(this); auto rect = event->rect().adjusted(0,0,-1,-1); if(styleOption.state & QStyle::State_MouseOver) { auto defaultBrush = painter.brush(); auto defaultPen = painter.pen(); painter.setBrush(Constants::HoverColor); painter.setPen(Constants::HoverColor); painter.drawRect(rect); painter.setBrush(defaultBrush); painter.setPen(defaultPen); } painter.drawPixmap(rect.topLeft() + mIconOffset, mIcon.pixmap(mIconSize)); painter.drawText(QRect(rect.topLeft() + mTextOffset, mTextSize), Qt::AlignLeft | Qt::AlignVCenter, mText); if(mIsChecked) { painter.drawRect(rect); } } void ListMenuItem::mouseMoveEvent(QMouseEvent *event) { update(); QWidget::mouseMoveEvent(event); } void ListMenuItem::leaveEvent(QEvent *event) { update(); QWidget::leaveEvent(event); } void ListMenuItem::mouseReleaseEvent(QMouseEvent* event) { QWidget::mouseReleaseEvent(event); QRect itemRect(QPoint(0, 0), mSize); if (isEnabled() && itemRect.contains(mapFromGlobal(QCursor::pos()))) { mIsChecked = true; emit toggled(mIsChecked); } } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/menuButtons/ListMenuItem.h000066400000000000000000000036161440330760000241140ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_LISTMENUITEM_H #define KIMAGEANNOTATOR_LISTMENUITEM_H #include #include #include #include #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class ListMenuItem : public QWidget { Q_OBJECT public: explicit ListMenuItem(const QIcon &icon, const QString &text, const QVariant &data, QWidget *parent); ~ListMenuItem() override = default; QVariant data() const; QIcon icon() const; QString text() const; QSize minimumSizeHint() const override; bool isChecked() const; void setIsChecked(bool isChecked); signals: void toggled(bool isChecked); protected: void paintEvent(QPaintEvent* event) override; void mouseMoveEvent(QMouseEvent *event) override; void leaveEvent(QEvent *event) override; void mouseReleaseEvent(QMouseEvent* event) override; private: QString mText; QIcon mIcon; bool mIsChecked; QVariant mData; QSize mIconSize; QSize mTextSize; QPoint mIconOffset; QPoint mTextOffset; int mMargin; int mSpacer; QSize mSize; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_LISTMENUITEM_H kImageAnnotator-0.6.1/src/widgets/menuButtons/ListMenuToolButton.cpp000066400000000000000000000035111440330760000256540ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ListMenuToolButton.h" namespace kImageAnnotator { ListMenuToolButton::ListMenuToolButton(QWidget *parent) : QToolButton(parent), mMenu(new ListMenu(this)) { setPopupMode(QToolButton::InstantPopup); setMenu(mMenu); connect(mMenu, &ListMenu::selectionChanged, this, &ListMenuToolButton::selectionChanged); connect(mMenu, &ListMenu::selectionChanged, this, &ListMenuToolButton::updateIconAndToolTip); } ListMenuToolButton::~ListMenuToolButton() { delete mMenu; } void ListMenuToolButton::addItem(const QIcon &icon, const QString &text, const QVariant &data) { mMenu->addItem(icon, text, data); } QVariant ListMenuToolButton::currentData() const { return mMenu->currentData(); } void ListMenuToolButton::setCurrentData(const QVariant &data) { mMenu->setCurrentData(data); } void ListMenuToolButton::setDataVisible(const QVariant &data, bool isVisible) { mMenu->setDataVisible(data, isVisible); } void ListMenuToolButton::updateIconAndToolTip() { setIcon(mMenu->currentIcon()); setToolTip(mMenu->currentText()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/menuButtons/ListMenuToolButton.h000066400000000000000000000027741440330760000253330ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_LISTMENUTOOLBUTTON_H #define KIMAGEANNOTATOR_LISTMENUTOOLBUTTON_H #include #include "src/widgets/menuButtons/ListMenu.h" namespace kImageAnnotator { class ListMenuToolButton : public QToolButton { Q_OBJECT public: explicit ListMenuToolButton(QWidget *parent); ~ListMenuToolButton() override; void addItem(const QIcon &icon, const QString &text, const QVariant &data); QVariant currentData() const; void setCurrentData(const QVariant &data); void setDataVisible(const QVariant &data, bool isVisible); signals: void selectionChanged(); private: ListMenu *mMenu; private slots: void updateIconAndToolTip(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_LISTMENUTOOLBUTTON_H kImageAnnotator-0.6.1/src/widgets/misc/000077500000000000000000000000001440330760000177665ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/widgets/misc/AbstractExpandingWidget.cpp000066400000000000000000000021461440330760000252420ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AbstractExpandingWidget.h" namespace kImageAnnotator { void AbstractExpandingWidget::setExpanding(bool enabled) { auto horizontalPolicy = enabled ? QSizePolicy::Expanding : QSizePolicy::Preferred; expandingWidget()->setSizePolicy(horizontalPolicy, QSizePolicy::Preferred); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/misc/AbstractExpandingWidget.h000066400000000000000000000023471440330760000247120ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ABSTRACTEXPANDINGWIDGET_H #define KIMAGEANNOTATOR_ABSTRACTEXPANDINGWIDGET_H #include namespace kImageAnnotator { class AbstractExpandingWidget { public: AbstractExpandingWidget() = default; ~AbstractExpandingWidget() = default; virtual void setExpanding(bool enabled); protected: virtual QWidget* expandingWidget() = 0; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ABSTRACTEXPANDINGWIDGET_H kImageAnnotator-0.6.1/src/widgets/misc/AttachedSeparator.cpp000066400000000000000000000031321440330760000240670ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AttachedSeparator.h" namespace kImageAnnotator { AttachedSeparator::AttachedSeparator(SettingsPickerWidget *target) : QFrame(target), mTarget(target) { Q_ASSERT(mTarget != nullptr); setContentsMargins(0, 3, 0, 3); setFrameShape(QFrame::VLine); setFrameShadow(QFrame::Sunken); connect(mTarget, &SettingsPickerWidget::visibilityChanged, this, &AttachedSeparator::targetVisibilityChanged); updateVisibility(); } void AttachedSeparator::targetVisibilityChanged(bool visible) { setVisible(visible && isEnabled()); } void AttachedSeparator::changeEvent(QEvent *event) { if(event->type() == QEvent::EnabledChange) { updateVisibility(); } QFrame::changeEvent(event); } void AttachedSeparator::updateVisibility() { targetVisibilityChanged(mTarget->isVisible()); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/misc/AttachedSeparator.h000066400000000000000000000026511440330760000235410ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ATTACHEDSEPARATOR_H #define KIMAGEANNOTATOR_ATTACHEDSEPARATOR_H #include #include #include "src/widgets/settingsPicker/SettingsPickerWidget.h" namespace kImageAnnotator { class AttachedSeparator : public QFrame { Q_OBJECT public: explicit AttachedSeparator(SettingsPickerWidget *target); ~AttachedSeparator() override = default; protected: void changeEvent(QEvent *event) override; private: SettingsPickerWidget *mTarget; void updateVisibility(); private slots: void targetVisibilityChanged(bool visible); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ATTACHEDSEPARATOR_H kImageAnnotator-0.6.1/src/widgets/misc/FlowLayout.cpp000066400000000000000000000104221440330760000225760ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "FlowLayout.h" /* * Implementation based on Qt FlowLayout Example https://doc.qt.io/qt-5/qtwidgets-layouts-flowlayout-example.html */ namespace kImageAnnotator { FlowLayout::FlowLayout(QWidget *parent) : QLayout(parent), mHorizontalSpacing(-1), mVerticalSpacing(-1) { } FlowLayout::~FlowLayout() { qDeleteAll(mItems); } void FlowLayout::addItem(QLayoutItem *item) { mItems.append(item); } int FlowLayout::horizontalSpacing() const { return mHorizontalSpacing >= 0 ? mHorizontalSpacing : smartSpacing(QStyle::PM_LayoutHorizontalSpacing); } int FlowLayout::verticalSpacing() const { return mVerticalSpacing >= 0 ? mVerticalSpacing : smartSpacing(QStyle::PM_LayoutVerticalSpacing); } int FlowLayout::count() const { return mItems.size(); } QLayoutItem *FlowLayout::itemAt(int index) const { return mItems.value(index); } QLayoutItem *FlowLayout::takeAt(int index) { if (index < 0 || index >= count()) { return nullptr; } return mItems.takeAt(index); } void FlowLayout::setSpacing(int horizontal, int vertical) { mHorizontalSpacing = horizontal; mVerticalSpacing = vertical; } Qt::Orientations FlowLayout::expandingDirections() const { return { }; } bool FlowLayout::hasHeightForWidth() const { return true; } int FlowLayout::heightForWidth(int width) const { auto rect = QRect(0, 0, width, 0); auto height = calculateLayout(rect, false); return height; } void FlowLayout::setGeometry(const QRect &rect) { QLayout::setGeometry(rect); calculateLayout(rect, true); } QSize FlowLayout::sizeHint() const { return minimumSize(); } QSize FlowLayout::minimumSize() const { QSize size; for (auto item : qAsConst(mItems)) { size = size.expandedTo(item->minimumSize()); } auto margins = contentsMargins(); size += QSize(margins.left() + margins.right(), margins.top() + margins.bottom()); return size; } int FlowLayout::calculateLayout(const QRect &rect, bool applyChanged) const { auto margins = contentsMargins(); auto effectiveRect = rect.adjusted(+margins.left(), +margins.top(), -margins.right(), -margins.bottom()); auto x = effectiveRect.x(); auto y = effectiveRect.y(); auto spaceX = horizontalSpacing(); auto spaceY = verticalSpacing(); auto lineHeight = 0; auto largestItemWidth = 0; auto largestItemHeight = 0; auto minHorizontalWidth = 0; for (auto item : qAsConst(mItems)) { largestItemWidth = qMax(item->sizeHint().width(), largestItemWidth); largestItemHeight = qMax(item->sizeHint().height(), largestItemHeight); minHorizontalWidth += item->sizeHint().width(); } auto isEqualWidthPerItemRequired = largestItemHeight * 2 > effectiveRect.height() || effectiveRect.width() >= minHorizontalWidth ; for (auto item : qAsConst(mItems)) { auto width = isEqualWidthPerItemRequired ? item->sizeHint().width() : largestItemWidth; auto nextX = x + width + spaceX; auto isOutsideCurrentRow = nextX - spaceX > effectiveRect.right() && lineHeight > 0; if (isOutsideCurrentRow) { x = effectiveRect.x(); y = y + lineHeight + spaceY; nextX = x + width + spaceX; lineHeight = 0; } if (applyChanged) { item->setGeometry(QRect(QPoint(x, y), item->sizeHint())); } x = nextX; lineHeight = qMax(lineHeight, item->sizeHint().height()); } return y + lineHeight - rect.y() + margins.bottom(); } int FlowLayout::smartSpacing(QStyle::PixelMetric pixelMetric) const { auto parent = this->parent(); auto parentWidget = dynamic_cast(parent); return parentWidget->style()->pixelMetric(pixelMetric, nullptr, parentWidget); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/misc/FlowLayout.h000066400000000000000000000035431440330760000222510ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_FLOWLAYOUT_H #define KIMAGEANNOTATOR_FLOWLAYOUT_H #include #include #include namespace kImageAnnotator { class FlowLayout : public QLayout { public: explicit FlowLayout(QWidget *parent); ~FlowLayout() override; void addItem(QLayoutItem *item) override; int horizontalSpacing() const; int verticalSpacing() const; Qt::Orientations expandingDirections() const override; bool hasHeightForWidth() const override; int heightForWidth(int) const override; int count() const override; QLayoutItem *itemAt(int index) const override; QSize minimumSize() const override; void setGeometry(const QRect &rect) override; QSize sizeHint() const override; QLayoutItem *takeAt(int index) override; void setSpacing(int horizontal, int vertical); private: QList mItems; int mHorizontalSpacing; int mVerticalSpacing; int calculateLayout(const QRect &rect, bool applyChanged) const; int smartSpacing(QStyle::PixelMetric pixelMetric) const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_FLOWLAYOUT_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/000077500000000000000000000000001440330760000220315ustar00rootroot00000000000000kImageAnnotator-0.6.1/src/widgets/settingsPicker/BoolPicker.cpp000066400000000000000000000045421440330760000245730ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "BoolPicker.h" namespace kImageAnnotator { BoolPicker::BoolPicker(QWidget *parent) : SettingsPickerWidget(parent), mToolButton(new ListMenuToolButton(this)), mLayout(new QHBoxLayout(this)), mLabel(new QLabel(this)) { initGui(); } void BoolPicker::setEnabledState(bool enabled) { mToolButton->setCurrentData(static_cast(enabled)); } bool BoolPicker::enabledState() const { return mToolButton->currentData().value(); } void BoolPicker::setToolTip(const QString &toolTip) { mLabel->setToolTip(toolTip); QWidget::setToolTip(toolTip); } void BoolPicker::setIcon(const QIcon &icon) { mLabel->setPixmap(icon.pixmap(ScaledSizeProvider::settingsWidgetIconSize())); } QWidget *BoolPicker::expandingWidget() { return mToolButton; } void BoolPicker::initGui() { mLayout->setContentsMargins(0, 0, 0, 0); insertItem(true, QLatin1String("check.svg"), tr("Enabled")); insertItem(false, QLatin1String("disabled.svg"), tr("Disabled")); mToolButton->setFocusPolicy(Qt::NoFocus); connect(mToolButton, &ListMenuToolButton::selectionChanged, this, &BoolPicker::selectionChanged); mLayout->addWidget(mLabel); mLayout->addWidget(mToolButton); mLayout->setAlignment(Qt::AlignLeft); setLayout(mLayout); } void BoolPicker::insertItem(bool enabled, const QString &iconName, const QString &text) { auto icon = IconLoader::load(iconName); mToolButton->addItem(icon, text, static_cast(enabled)); } void BoolPicker::selectionChanged() { auto enabled = mToolButton->currentData().value(); emit enabledStateChanged(enabled); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/settingsPicker/BoolPicker.h000066400000000000000000000034601440330760000242360ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_BOOLPICKER_H #define KIMAGEANNOTATOR_BOOLPICKER_H #include #include #include #include "SettingsPickerWidget.h" #include "src/widgets/menuButtons/ListMenuToolButton.h" #include "src/common/helper/IconLoader.h" #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class BoolPicker : public SettingsPickerWidget { Q_OBJECT public: explicit BoolPicker(QWidget *parent); ~BoolPicker() override = default; void setEnabledState(bool enabled); bool enabledState() const; void setToolTip(const QString &toolTip); void setIcon(const QIcon &icon); signals: void enabledStateChanged(bool enabled) const; protected: QWidget* expandingWidget() override; private: QHBoxLayout *mLayout; QLabel *mLabel; ListMenuToolButton *mToolButton; void initGui(); void insertItem(bool enabled, const QString &iconName, const QString &text); private slots: void selectionChanged(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_BOOLPICKER_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/ColorPicker.cpp000066400000000000000000000042131440330760000247510ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ColorPicker.h" namespace kImageAnnotator { ColorPicker::ColorPicker(QWidget *parent) : SettingsPickerWidget(parent), mLayout(new QHBoxLayout(this)), mLabel(new QLabel(this)), mkColorPicker(new KColorPicker(parent)) { initGui(); connect(mkColorPicker, &KColorPicker::colorChanged, this, &ColorPicker::colorChanged); } void ColorPicker::setColor(const QColor &color) { mkColorPicker->setColor(color); emit colorSelected(color); } QColor ColorPicker::color() const { return mkColorPicker->color(); } void ColorPicker::setToolTip(const QString &toolTip) { mLabel->setToolTip(toolTip); mkColorPicker->setToolTip(toolTip); } void ColorPicker::setIcon(const QIcon &icon) { mLabel->setPixmap(icon.pixmap(ScaledSizeProvider::settingsWidgetIconSize())); } QWidget *ColorPicker::expandingWidget() { return mkColorPicker; } void ColorPicker::initGui() { mLayout->setContentsMargins(0, 0, 0, 0); mLabel->setFixedSize(ScaledSizeProvider::settingsWidgetIconSize()); mkColorPicker->setFocusPolicy(Qt::NoFocus); mLayout->addWidget(mLabel); mLayout->addWidget(mkColorPicker); mLayout->setAlignment(Qt::AlignLeft); setLayout(mLayout); } void ColorPicker::colorChanged(const QColor &color) { setColor(color); } void ColorPicker::setShowAlphaChannel(bool showAlphaChannel) { mkColorPicker->resetColors(showAlphaChannel); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/settingsPicker/ColorPicker.h000066400000000000000000000034051440330760000244200ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_COLORPICKER_H #define KIMAGEANNOTATOR_COLORPICKER_H #include #include #include #include #include "SettingsPickerWidget.h" #include "src/common/provider/ScaledSizeProvider.h" using kColorPicker::KColorPicker; namespace kImageAnnotator { class ColorPicker : public SettingsPickerWidget { Q_OBJECT public: explicit ColorPicker(QWidget *parent); ~ColorPicker() override = default; void setColor(const QColor &color); QColor color() const; void setToolTip(const QString &toolTip); void setIcon(const QIcon &icon); void setShowAlphaChannel(bool showAlphaChannel); signals: void colorSelected(const QColor &color); protected: QWidget* expandingWidget() override; private: QHBoxLayout *mLayout; QLabel *mLabel; KColorPicker *mkColorPicker; void initGui(); private slots: void colorChanged(const QColor &color); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_COLORPICKER_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/FillModePicker.cpp000066400000000000000000000055261440330760000253760ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "FillModePicker.h" namespace kImageAnnotator { FillModePicker::FillModePicker(QWidget *parent) : SettingsPickerWidget(parent), mToolButton(new ListMenuToolButton(this)), mLayout(new QHBoxLayout(this)), mLabel(new QLabel(this)) { initGui(); } void FillModePicker::setFillType(FillModes fillType) { mToolButton->setCurrentData(static_cast(fillType)); } void FillModePicker::addNoFillAndNoBorderToList() { mToolButton->setDataVisible(static_cast(FillModes::NoBorderAndNoFill), true); } void FillModePicker::removeNoFillAndNoBorderToList() { mToolButton->setDataVisible(static_cast(FillModes::NoBorderAndNoFill), false); } FillModes FillModePicker::fillType() const { return mToolButton->currentData().value(); } QWidget *FillModePicker::expandingWidget() { return mToolButton; } void FillModePicker::initGui() { mLayout->setContentsMargins(0, 0, 0, 0); auto icon = IconLoader::load(QLatin1String("fillType.svg")); mLabel->setPixmap(icon.pixmap(ScaledSizeProvider::settingsWidgetIconSize())); mLabel->setToolTip(tr("Border And Fill Visibility")); insertItem(FillModes::BorderAndFill, QLatin1String("fillType_borderAndFill.svg"), tr("Border and Fill")); insertItem(FillModes::BorderAndNoFill, QLatin1String("fillType_borderAndNoFill.svg"), tr("Border and No Fill")); insertItem(FillModes::NoBorderAndNoFill, QLatin1String("fillType_noBorderAndNoFill.svg"), tr("No Border and No Fill")); mToolButton->setFocusPolicy(Qt::NoFocus); connect(mToolButton, &ListMenuToolButton::selectionChanged, this, &FillModePicker::selectionChanged); mLayout->addWidget(mLabel); mLayout->addWidget(mToolButton); mLayout->setAlignment(Qt::AlignLeft); setLayout(mLayout); } void FillModePicker::insertItem(FillModes fillType, const QString &iconName, const QString &text) { auto icon = IconLoader::load(iconName); mToolButton->addItem(icon, text, static_cast(fillType)); } void FillModePicker::selectionChanged() { auto fillType = mToolButton->currentData().value(); emit fillSelected(fillType); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/settingsPicker/FillModePicker.h000066400000000000000000000036631440330760000250430ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_FILLMODEPICKER_H #define KIMAGEANNOTATOR_FILLMODEPICKER_H #include #include #include #include #include #include #include "SettingsPickerWidget.h" #include "src/widgets/menuButtons/ListMenuToolButton.h" #include "src/common/enum/FillModes.h" #include "src/common/helper/IconLoader.h" #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class FillModePicker : public SettingsPickerWidget { Q_OBJECT public: explicit FillModePicker(QWidget *parent); ~FillModePicker() override = default; void setFillType(FillModes fillType); void addNoFillAndNoBorderToList(); void removeNoFillAndNoBorderToList(); FillModes fillType() const; signals: void fillSelected(FillModes fillType) const; protected: QWidget* expandingWidget() override; private: QHBoxLayout *mLayout; QLabel *mLabel; ListMenuToolButton *mToolButton; void initGui(); void insertItem(FillModes fillType, const QString &iconName, const QString &text); private slots: void selectionChanged(); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_FILLMODEPICKER_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/FontPicker.cpp000066400000000000000000000071141440330760000246040ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "FontPicker.h" namespace kImageAnnotator { FontPicker::FontPicker(QWidget *parent) : SettingsPickerWidget(parent), mLayout(new QBoxLayout(QBoxLayout::LeftToRight, this)), mButtonLayout(new QHBoxLayout), mFontComboBox(new CustomFontComboBox(this)), mSizeSpinBox(new CustomSpinBox(this)), mBoldToggle(new ToggleButton(this)), mItalicToggle(new ToggleButton(this)), mUnderlineToggle(new ToggleButton(this)) { initGui(); } void FontPicker::setCurrentFont(const QFont &font) { mBoldToggle->setChecked(font.bold()); mItalicToggle->setChecked(font.italic()); mUnderlineToggle->setChecked(font.underline()); mSizeSpinBox->setValue(font.pointSize()); mFontComboBox->setCurrentFont(font); } QFont FontPicker::currentFont() const { auto font = mFontComboBox->currentFont(); font.setPointSize(mSizeSpinBox->value()); font.setBold(mBoldToggle->isChecked()); font.setItalic(mItalicToggle->isChecked()); font.setUnderline(mUnderlineToggle->isChecked()); return font; } void FontPicker::setExpanding(bool enabled) { mLayout->setDirection(enabled ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight); AbstractExpandingWidget::setExpanding(enabled); } QWidget *FontPicker::expandingWidget() { return mFontComboBox; } void FontPicker::initGui() { mLayout->setContentsMargins(0, 0, 0, 0); mFontComboBox->setFocusPolicy(Qt::NoFocus); mFontComboBox->setLayoutDirection(Qt::LeftToRight); mFontComboBox->setMinimumWidth(ScaledSizeProvider::scaledWidth(100)); connect(mFontComboBox, &QFontComboBox::currentFontChanged, this, &FontPicker::selectionChanged); mSizeSpinBox->setSuffix(QLatin1String("pt")); mSizeSpinBox->setToolTip(tr("Font Size")); mSizeSpinBox->setRange(5, 100); connect(mSizeSpinBox, &CustomSpinBox::valueChanged, this, &FontPicker::selectionChanged); mBoldToggle->setIcon(IconLoader::load(QLatin1String("bold.svg"))); mBoldToggle->setToolTip(tr("Bold")); connect(mBoldToggle, &ToggleButton::toggled, this, &FontPicker::selectionChanged); mItalicToggle->setIcon(IconLoader::load(QLatin1String("italic.svg"))); mItalicToggle->setToolTip(tr("Italic")); connect(mItalicToggle, &ToggleButton::toggled, this, &FontPicker::selectionChanged); mUnderlineToggle->setIcon(IconLoader::load(QLatin1String("underline.svg"))); mUnderlineToggle->setToolTip(tr("Underline")); connect(mUnderlineToggle, &ToggleButton::toggled, this, &FontPicker::selectionChanged); mButtonLayout->addWidget(mBoldToggle); mButtonLayout->addWidget(mItalicToggle); mButtonLayout->addWidget(mUnderlineToggle); mLayout->addWidget(mFontComboBox); mLayout->addWidget(mSizeSpinBox); mLayout->addLayout(mButtonLayout); mLayout->setAlignment(Qt::AlignLeft); setLayout(mLayout); } void FontPicker::selectionChanged() { setToolTip(mFontComboBox->selectItemText()); emit fontChanged(currentFont()); } } // namespace kImageAnnotatorkImageAnnotator-0.6.1/src/widgets/settingsPicker/FontPicker.h000066400000000000000000000034571440330760000242570ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_FONTPICKER_H #define KIMAGEANNOTATOR_FONTPICKER_H #include #include "SettingsPickerWidget.h" #include "src/widgets/ToggleButton.h" #include "src/widgets/CustomSpinBox.h" #include "src/widgets/CustomFontComboBox.h" #include "src/common/helper/IconLoader.h" namespace kImageAnnotator { class FontPicker : public SettingsPickerWidget { Q_OBJECT public: explicit FontPicker(QWidget *parent); ~FontPicker() override = default; void setCurrentFont(const QFont &font); QFont currentFont() const; void setExpanding(bool enabled) override; signals: void fontChanged(const QFont &font) const; protected: QWidget* expandingWidget() override; private: QBoxLayout *mLayout; QHBoxLayout *mButtonLayout; CustomFontComboBox *mFontComboBox; CustomSpinBox *mSizeSpinBox; ToggleButton *mBoldToggle; ToggleButton *mItalicToggle; ToggleButton *mUnderlineToggle; void initGui(); private slots: void selectionChanged(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_FONTPICKER_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/ImageEffectPicker.cpp000066400000000000000000000051661440330760000260420ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ImageEffectPicker.h" namespace kImageAnnotator { ImageEffectPicker::ImageEffectPicker(QWidget *parent) : SettingsPickerWidget(parent), mToolButton(new ListMenuToolButton(this)), mLayout(new QHBoxLayout(this)), mLabel(new QLabel(this)) { initGui(); } void ImageEffectPicker::setEffect(ImageEffects effect) { mToolButton->setCurrentData(static_cast(effect)); } ImageEffects ImageEffectPicker::effect() const { return mToolButton->currentData().value(); } QWidget *ImageEffectPicker::expandingWidget() { return mToolButton; } void ImageEffectPicker::initGui() { mLayout->setContentsMargins(1, 0, 0, 0); auto icon = IconLoader::load(QLatin1String("effect.svg")); mLabel->setPixmap(icon.pixmap(ScaledSizeProvider::settingsWidgetIconSize())); mLabel->setToolTip(tr("Image Effects")); insertItem(ImageEffects::NoEffect, QLatin1String("disabled.svg"), tr("No Effect")); insertItem(ImageEffects::DropShadow, QLatin1String("dropShadow.svg"), tr("Drop Shadow")); insertItem(ImageEffects::Grayscale, QLatin1String("grayscale.svg"), tr("Grayscale")); insertItem(ImageEffects::InvertColor, QLatin1String("invertColor.svg"), tr("Invert Color")); insertItem(ImageEffects::Border, QLatin1String("border.svg"), tr("Border")); mToolButton->setFocusPolicy(Qt::NoFocus); connect(mToolButton, &ListMenuToolButton::selectionChanged, this, &ImageEffectPicker::selectionChanged); mLayout->addWidget(mLabel); mLayout->addWidget(mToolButton); setLayout(mLayout); } void ImageEffectPicker::insertItem(ImageEffects effects, const QString &iconName, const QString &text) { auto icon = IconLoader::load(iconName); mToolButton->addItem(icon, text, static_cast(effects)); } void ImageEffectPicker::selectionChanged() { auto effect = mToolButton->currentData().value(); emit effectSelected(effect); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/settingsPicker/ImageEffectPicker.h000066400000000000000000000035631440330760000255060ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_IMAGEEFFECTPICKER_H #define KIMAGEANNOTATOR_IMAGEEFFECTPICKER_H #include #include #include #include #include #include #include "SettingsPickerWidget.h" #include "src/widgets/menuButtons/ListMenuToolButton.h" #include "src/common/provider/ScaledSizeProvider.h" #include "src/common/enum/ImageEffects.h" #include "src/common/helper/IconLoader.h" namespace kImageAnnotator { class ImageEffectPicker : public SettingsPickerWidget { Q_OBJECT public: explicit ImageEffectPicker(QWidget *parent); ~ImageEffectPicker() override = default; void setEffect(ImageEffects effect); ImageEffects effect() const; signals: void effectSelected(ImageEffects effect) const; protected: QWidget* expandingWidget() override; private: QHBoxLayout *mLayout; QLabel *mLabel; ListMenuToolButton *mToolButton; void initGui(); private slots: void insertItem(ImageEffects effects, const QString &iconName, const QString &text); void selectionChanged(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_IMAGEEFFECTPICKER_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/NumberPicker.cpp000066400000000000000000000047641440330760000251360ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "NumberPicker.h" namespace kImageAnnotator { NumberPicker::NumberPicker(QWidget *parent) : SettingsPickerWidget(parent), mLayout(new QHBoxLayout(this)), mLabel(new QLabel(this)), mSpinBox(new CustomSpinBox(this)) { initGui(); connect(mSpinBox, &CustomSpinBox::valueChanged, this, &NumberPicker::selectionChanged); } void NumberPicker::setNumber(int number) { mSpinBox->setValue(number); } void NumberPicker::initGui() { mLayout->setContentsMargins(0, 0, 0, 0); mLabel->setFixedSize(ScaledSizeProvider::settingsWidgetIconSize()); mSpinBox->setMinimum(1); mSpinBox->setMaximum(20); setFocusPolicy(Qt::NoFocus); mLayout->addWidget(mLabel); mLayout->addWidget(mSpinBox); mLayout->setAlignment(Qt::AlignLeft); setLayout(mLayout); } void NumberPicker::setNumberAndNotify(int number) const { emit numberSelected(number); } void NumberPicker::selectionChanged() { setNumberAndNotify(mSpinBox->value()); } void NumberPicker::setRange(int min, int max) { auto oldState = mSpinBox->blockSignals(true); if (min >= 0 && max >= min) { mSpinBox->setMinimum(min); mSpinBox->setMaximum(max); } mSpinBox->blockSignals(oldState); } int NumberPicker::number() const { return mSpinBox->value(); } void NumberPicker::setToolTip(const QString &toolTip) { mLabel->setToolTip(toolTip); mSpinBox->setToolTip(toolTip); } void NumberPicker::setSuffix(const QString &suffix) { mSpinBox->setSuffix(suffix); } void NumberPicker::setSingleStep(int value) { mSpinBox->setSingleStep(value); } void NumberPicker::setIcon(const QIcon &icon) { mLabel->setPixmap(icon.pixmap(ScaledSizeProvider::settingsWidgetIconSize())); } QWidget *NumberPicker::expandingWidget() { return mSpinBox; } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/settingsPicker/NumberPicker.h000066400000000000000000000034761440330760000246020ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_NUMBERPICKER_H #define KIMAGEANNOTATOR_NUMBERPICKER_H #include #include #include #include #include "src/widgets/CustomSpinBox.h" #include "SettingsPickerWidget.h" #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class NumberPicker : public SettingsPickerWidget { Q_OBJECT public: explicit NumberPicker(QWidget *parent); ~NumberPicker() override = default; void setNumber(int number); void setRange(int min, int max); int number() const; void setToolTip(const QString &toolTip); void setIcon(const QIcon &icon); void setSuffix(const QString &suffix); void setSingleStep(int value); signals: void numberSelected(int number) const; protected: QWidget* expandingWidget() override; private: QHBoxLayout *mLayout; CustomSpinBox *mSpinBox; QLabel *mLabel; void initGui(); void setNumberAndNotify(int number) const; private slots: void selectionChanged(); }; } // namespace kImageAnnotator #endif // KIMAGEANNOTATOR_NUMBERPICKER_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/SettingsPickerWidget.cpp000066400000000000000000000023131440330760000266360ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SettingsPickerWidget.h" namespace kImageAnnotator { SettingsPickerWidget::SettingsPickerWidget(QWidget *parent) : QWidget(parent) { } void SettingsPickerWidget::showEvent(QShowEvent *event) { emit visibilityChanged(true); QWidget::showEvent(event); } void SettingsPickerWidget::hideEvent(QHideEvent *event) { emit visibilityChanged(false); QWidget::hideEvent(event); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/settingsPicker/SettingsPickerWidget.h000066400000000000000000000026251440330760000263110ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SETTINGSPICKERWIDGET_H #define KIMAGEANNOTATOR_SETTINGSPICKERWIDGET_H #include #include "src/widgets/misc/AbstractExpandingWidget.h" namespace kImageAnnotator { class SettingsPickerWidget : public QWidget, public AbstractExpandingWidget { Q_OBJECT public: explicit SettingsPickerWidget(QWidget *parent); ~SettingsPickerWidget() override = default; signals: void visibilityChanged(bool visible); protected: void showEvent(QShowEvent *event) override; void hideEvent(QHideEvent *event) override; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_SETTINGSPICKERWIDGET_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/StickerPicker.cpp000066400000000000000000000070471440330760000253070ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "StickerPicker.h" namespace kImageAnnotator { StickerPicker::StickerPicker(QWidget *parent) : SettingsPickerWidget(parent), mLayout(new QHBoxLayout(this)), mLabel(new QLabel(this)), mToolButton(new GridMenuToolButton(this)) { init(); } void StickerPicker::setSticker(const QString &name) { mToolButton->setCurrentData(name); } QString StickerPicker::sticker() const { return mToolButton->currentData().toString(); } void StickerPicker::setStickers(const QStringList &stickerPaths, bool keepDefault) { mToolButton->clear(); if(keepDefault) { addDefaultStickers(); } for(const auto& stickerPath : stickerPaths) { addItem(stickerPath); } } QWidget *StickerPicker::expandingWidget() { return mToolButton; } void StickerPicker::init() { mLayout->setContentsMargins(0, 0, 0, 0); auto icon = IconLoader::load(QLatin1String("sticker.svg")); mLabel->setPixmap(icon.pixmap(ScaledSizeProvider::settingsWidgetIconSize())); mLabel->setToolTip(tr("Sticker")); mLabel->setMargin(0); mToolButton->setFocusPolicy(Qt::NoFocus); mToolButton->setPopupMode(QToolButton::InstantPopup); connect(mToolButton, &GridMenuToolButton::selectionChanged, this, &StickerPicker::selectionChanged); addDefaultStickers(); mLayout->addWidget(mLabel); mLayout->addWidget(mToolButton); mLayout->setAlignment(Qt::AlignLeft); setLayout(mLayout); } void StickerPicker::addDefaultStickers() { QStringList defaultStickers{ QLatin1String("face_blowing_a_kiss"), QLatin1String("face_savoring_food"), QLatin1String("grinning_face_with_big_eyes"), QLatin1String("grinning_face_with_smiling_eyes"), QLatin1String("grinning_face_with_sweat"), QLatin1String("grinning_squinting_face"), QLatin1String("hushed_face"), QLatin1String("nerd_face"), QLatin1String("neutral_face"), QLatin1String("smiling_face_with_heart_eyes"), QLatin1String("smiling_face_with_hearts"), QLatin1String("confused_face"), QLatin1String("face_with_symbols_on_mouth"), QLatin1String("pouting_face"), QLatin1String("smiling_face_with_sunglasses"), QLatin1String("check_mark"), QLatin1String("cross_mark"), QLatin1String("cursor") }; for(const auto& sticker : defaultStickers) { addItem(getResourcePath(sticker)); } } QString StickerPicker::getResourcePath(const QString &name) { return QLatin1String(":/stickers/") + name + QLatin1String(".svg"); } void StickerPicker::addItem(const QString &path) { auto icon = QIcon(path); auto filename = PathHelper::extractFilename(path); filename = PathHelper::prettyFilename(filename); mToolButton->addItem(icon, filename, path); } void StickerPicker::selectionChanged() const { emit stickerSelected(sticker()); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/settingsPicker/StickerPicker.h000066400000000000000000000035251440330760000247510ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_STICKERPICKER_H #define KIMAGEANNOTATOR_STICKERPICKER_H #include #include #include #include "SettingsPickerWidget.h" #include "src/widgets/menuButtons/GridMenuToolButton.h" #include "src/common/helper/IconLoader.h" #include "src/common/helper/PathHelper.h" namespace kImageAnnotator { class StickerPicker : public SettingsPickerWidget { Q_OBJECT public: explicit StickerPicker(QWidget *parent); ~StickerPicker() override = default; void setSticker(const QString &name); QString sticker() const; void setStickers(const QStringList &stickerPaths, bool keepDefault); signals: void stickerSelected(const QString &sticker) const; protected: QWidget* expandingWidget() override; private: QHBoxLayout *mLayout; QLabel *mLabel; GridMenuToolButton *mToolButton; void init(); void addItem(const QString &path); private slots: void selectionChanged() const; static QString getResourcePath(const QString &name); void addDefaultStickers(); }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_STICKERPICKER_H kImageAnnotator-0.6.1/src/widgets/settingsPicker/ZoomPicker.cpp000066400000000000000000000104161440330760000246210ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ZoomPicker.h" namespace kImageAnnotator { ZoomPicker::ZoomPicker(QWidget *parent) : SettingsPickerWidget(parent), mLayout(new QHBoxLayout), mLabel(new QLabel(this)), mSpinBox(new CustomSpinBox(this)), mZoomInAction(new QAction(this)), mZoomOutAction(new QAction(this)), mResetZoomAction(new QAction(this)), mFitImageAction(new QAction(this)) { initGui(); } QWidget *ZoomPicker::expandingWidget() { return mSpinBox; } void ZoomPicker::initGui() { mLayout->setContentsMargins(1, 0, 0, 0); auto icon = IconLoader::load(QLatin1String("zoom.svg")); mLabel->setPixmap(icon.pixmap(ScaledSizeProvider::settingsWidgetIconSize())); mSpinBox->setFocusPolicy(Qt::NoFocus); mSpinBox->setRange(10, 800); mSpinBox->setSingleStep(10); mSpinBox->setSuffix(QLatin1String("%")); mSpinBox->setWrapping(false); mResetZoomAction = createAction(tr("Reset Zoom"), IconLoader::load(QLatin1String("resetZoom.svg"))); connect(mResetZoomAction, &QAction::triggered, this, &ZoomPicker::resetZoomOut); mResetZoomButton = createButton(mResetZoomAction); mFitImageAction = createAction(tr("Fit Image"), IconLoader::load(QLatin1String("fitImage.svg"))); connect(mFitImageAction, &QAction::triggered, this, &ZoomPicker::fitImageToView); mFitImageButton = createButton(mFitImageAction); mZoomInAction->setShortcut(QKeySequence::ZoomIn); mZoomOutAction->setShortcut(QKeySequence::ZoomOut); mResetZoomAction->setShortcut(Qt::CTRL + Qt::Key_0); mFitImageAction->setShortcut(Qt::CTRL + Qt::Key_F); setToolTip(getToolTip()); connect(mZoomInAction, &QAction::triggered, this, &ZoomPicker::zoomIn); connect(mZoomOutAction, &QAction::triggered, this, &ZoomPicker::zoomOut); addAction(mZoomInAction); addAction(mZoomOutAction); addAction(mResetZoomAction); connect(mSpinBox, &CustomSpinBox::valueChanged, this, &ZoomPicker::notifyZoomValueChanged); mLayout->addWidget(mLabel); mLayout->addWidget(mSpinBox); mLayout->addWidget(mFitImageButton); mLayout->addWidget(mResetZoomButton); mLayout->setAlignment(Qt::AlignLeft); setLayout(mLayout); } QString ZoomPicker::getToolTip() const { auto newLine = QLatin1String("\n"); auto zoomIn = tr("Zoom In (%1)").arg(mZoomInAction->shortcut().toString()); auto zoomOut = tr("Zoom Out (%1)").arg(mZoomOutAction->shortcut().toString()); auto resetZoom = tr("Reset Zoom (%1)").arg(mResetZoomAction->shortcut().toString()); auto fitZoom = tr("Fit image to view (%1)").arg(mFitImageAction->shortcut().toString()); return zoomIn + newLine + zoomOut + newLine + resetZoom + newLine + fitZoom; } QAction *ZoomPicker::createAction(const QString &tooltip, const QIcon &icon) { auto action = new CustomToolButtonAction(this); action->setIcon(icon); action->setToolTip(tooltip); action->updateDefaultWidget(); return action; } CustomToolButton *ZoomPicker::createButton(QAction *defaultAction) { auto button = new CustomToolButton(this); button->setAction(defaultAction); return button; } void ZoomPicker::setZoomValue(double value) { auto zoomValue = qRound(value * 100); mSpinBox->setValueSilent(zoomValue); } void ZoomPicker::fitImageToCurrentView() { emit fitImageToView(); } void ZoomPicker::notifyZoomValueChanged(double value) { emit zoomValueChanged(value / 100.0); } void ZoomPicker::zoomIn() { int currentZoom = mSpinBox->value(); notifyZoomValueChanged(currentZoom + 10); } void ZoomPicker::zoomOut() { auto currentZoom = mSpinBox->value(); notifyZoomValueChanged(currentZoom - 10); } void ZoomPicker::resetZoomOut() { notifyZoomValueChanged(100); } } // namespace kImageAnnotator kImageAnnotator-0.6.1/src/widgets/settingsPicker/ZoomPicker.h000066400000000000000000000043051440330760000242660ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ZOOMPICKER_H #define KIMAGEANNOTATOR_ZOOMPICKER_H #include #include #include #include #include #include "src/widgets/CustomSpinBox.h" #include "src/widgets/CustomToolButton.h" #include "src/widgets/CustomToolButtonAction.h" #include "src/widgets/settingsPicker/SettingsPickerWidget.h" #include "src/common/helper/IconLoader.h" #include "src/common/provider/ScaledSizeProvider.h" namespace kImageAnnotator { class ZoomPicker : public SettingsPickerWidget { Q_OBJECT public: explicit ZoomPicker(QWidget *parent); ~ZoomPicker() override = default; public slots: void setZoomValue(double value); void fitImageToCurrentView(); signals: void zoomValueChanged(double zoomLevel); void fitImageToView(); protected: QWidget* expandingWidget() override; private: QHBoxLayout *mLayout; QLabel *mLabel; CustomSpinBox *mSpinBox; QAction *mZoomInAction; QAction *mZoomOutAction; QAction *mResetZoomAction; CustomToolButton *mResetZoomButton; QAction *mFitImageAction; CustomToolButton *mFitImageButton; QAction *createAction(const QString &tooltip, const QIcon &icon); CustomToolButton *createButton(QAction *defaultAction); void initGui(); private slots: void notifyZoomValueChanged(double value); void zoomIn(); void zoomOut(); void resetZoomOut(); QString getToolTip() const; }; } // namespace kImageAnnotator #endif //KIMAGEANNOTATOR_ZOOMPICKER_H kImageAnnotator-0.6.1/tests/000077500000000000000000000000001440330760000157405ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/CMakeLists.txt000066400000000000000000000067201440330760000205050ustar00rootroot00000000000000find_package(Qt5 ${QT_MIN_VERSION} REQUIRED Test) find_package(GTest CONFIG REQUIRED) enable_testing() set(UNITTEST_SRC annotations/core/AnnotationAreaTest.cpp annotations/core/AnnotationItemFactoryTest.cpp annotations/core/AnnotationPropertiesFactoryTest.cpp annotations/modifiers/AnnotationItemResizerTest.cpp annotations/modifiers/AnnotationMultiItemResizerTest.cpp annotations/modifiers/AnnotationItemSelectorTest.cpp annotations/modifiers/AnnotationItemModifierTest.cpp annotations/modifiers/AnnotationItemArrangerTest.cpp annotations/modifiers/AnnotationItemMoverTest.cpp annotations/modifiers/resizeHandles/LineResizeHandlesTest.cpp annotations/modifiers/resizeHandles/RectResizeHandlesTest.cpp annotations/modifiers/resizeHandles/PointerRectResizeHandlesTest.cpp annotations/undo/AddCommandTest.cpp annotations/undo/DeleteCommandTest.cpp annotations/undo/ModifyCanvasCommandTest.cpp annotations/undo/MoveCommandTest.cpp annotations/undo/ResizeCommandTest.cpp annotations/undo/ArrangeCommandTest.cpp annotations/undo/CropCommandTest.cpp annotations/undo/ScaleCommandTest.cpp annotations/undo/PasteCommandTest.cpp annotations/undo/RotateCommandTest.cpp annotations/items/helper/KeyInputHelperTest.cpp annotations/items/helper/TextCursorTest.cpp annotations/misc/AnnotationItemClipboardTest.cpp annotations/misc/NumberManagerTest.cpp backend/ConfigTest.cpp common/helper/KeyHelperTest.cpp common/helper/MathHelperTest.cpp common/helper/ItemHelperTest.cpp common/helper/ShapeHelperTest.cpp common/helper/PathHelperTest.cpp gui/cropper/CropSelectionRestrictorTest.cpp gui/canvasModifier/ModifyCanvasSelectionRestrictorTest.cpp gui/selection/SelectionMoveHelperTest.cpp gui/selection/SelectionHandlerTest.cpp gui/selection/SelectionHandlesAllTest.cpp gui/scaler/ScaleSizeHandlerTest.cpp gui/annotator/tabs/AnnotationTabCloserTest.cpp gui/annotator/tabs/AnnotationTabContextMenuTest.cpp widgets/CustomSpinBoxTest.cpp widgets/misc/AttachedSeparatorTest.cpp widgets/settingsPicker/ToolPickerTest.cpp widgets/settingsPicker/ColorPickerTest.cpp widgets/settingsPicker/NumberPickerTest.cpp widgets/settingsPicker/FillModePickerTest.cpp widgets/settingsPicker/ImageEffectPickerTest.cpp widgets/settingsPicker/StickerPickerTest.cpp widgets/settingsPicker/ZoomPickerTest.cpp ) set(TESTUTILS_SRC utils/TestRunner.h mocks/gui/selection/SelectionHandlesMock.h mocks/backend/SettingsMock.h mocks/MockZoomValueProvider.cpp mocks/MockSettingsProvider.cpp mocks/MockDevicePixelRatioScaler.cpp mocks/MockDefaultParameters.h mocks/MockSelectionRestrictor.cpp ) add_library(KIMAGEANNOTATOR_STATIC STATIC ${KIMAGEANNOTATOR_SRCS}) target_link_libraries(KIMAGEANNOTATOR_STATIC Qt5::Widgets kImageAnnotator::kImageAnnotator kColorPicker::kColorPicker Qt5::Svg) if (UNIX AND NOT APPLE) # X11::X11 imported target only available with sufficiently new CMake if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.14.0) target_link_libraries(KIMAGEANNOTATOR_STATIC X11::X11) else() target_link_libraries(KIMAGEANNOTATOR_STATIC X11) endif() endif () target_compile_definitions(KIMAGEANNOTATOR_STATIC PRIVATE KIMAGEANNOTATOR_LANG_INSTALL_DIR="${KIMAGEANNOTATOR_LANG_INSTALL_DIR}") foreach (UnitTest ${UNITTEST_SRC}) get_filename_component(UnitTestName ${UnitTest} NAME_WE) add_executable(${UnitTestName} ${UnitTest} ${TESTUTILS_SRC}) target_link_libraries(${UnitTestName} KIMAGEANNOTATOR_STATIC GTest::gmock Qt5::Test) add_test(${UnitTestName} ${UnitTestName}) endforeach (UnitTest) kImageAnnotator-0.6.1/tests/annotations/000077500000000000000000000000001440330760000202755ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/annotations/core/000077500000000000000000000000001440330760000212255ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/annotations/core/AnnotationAreaTest.cpp000066400000000000000000000130201440330760000254700ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationAreaTest.h" void AnnotationAreaTest::ExportAsImage_Should_ExportImage_When_ImageSet() { QPixmap pixmap(QSize(400, 400)); pixmap.fill(QColor(Qt::green)); MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); annotationArea.loadImage(pixmap); auto resultImage = annotationArea.image(); auto expectedImage = pixmap.toImage().convertToFormat(QImage::Format_ARGB32_Premultiplied); QCOMPARE(expectedImage, resultImage); } void AnnotationAreaTest::ExportAsImage_Should_ExportEmptyImage_When_NoImageSet() { MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); auto resultImage = annotationArea.image(); QCOMPARE(QImage(), resultImage); } void AnnotationAreaTest::ExportAsImage_Should_ExportScaledImage_When_ScalingEnabled() { auto scaleFactor = 1.5; QPixmap pixmap(QSize(400, 400)); pixmap.fill(QColor(Qt::green)); MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); scalerMock->setScaleFactor(scaleFactor); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); annotationArea.loadImage(pixmap); auto resultImage = annotationArea.image(); auto expectedImage = pixmap.scaled(pixmap.size() * scaleFactor).toImage().convertToFormat(QImage::Format_ARGB32_Premultiplied); expectedImage.setDevicePixelRatio(scaleFactor); QCOMPARE(resultImage, expectedImage); } void AnnotationAreaTest::AddAnnotationItem_Should_AddAnnotationItemToScene() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); auto lineItem = new AnnotationLine(p1, properties); lineItem->addPoint(p2, false); MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); annotationArea.addAnnotationItem(lineItem); QCOMPARE(annotationArea.items().contains(lineItem), true); } void AnnotationAreaTest::RemoveAnnotationItem_Should_RemoveAnnotationItemFromScene() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); auto lineItem = new AnnotationLine(p1, properties); lineItem->addPoint(p2, false); MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); annotationArea.addAnnotationItem(lineItem); QCOMPARE(annotationArea.items().contains(lineItem), true); annotationArea.removeAnnotationItem(lineItem); QCOMPARE(annotationArea.items().contains(lineItem), false); } void AnnotationAreaTest::CanvasRect_Should_ReturnRectUnionOfAllItems_When_NoCanvasRectSet() { QRectF backgroundImageBoundingRect(0,0,400,400); QPixmap pixmap(backgroundImageBoundingRect.size().toSize()); pixmap.fill(QColor(Qt::green)); MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); annotationArea.loadImage(pixmap); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(600, 600); auto lineItem = new AnnotationLine(p1, properties); lineItem->addPoint(p2, false); annotationArea.addAnnotationItem(lineItem); auto defaultCanvasRect = backgroundImageBoundingRect.united(lineItem->boundingRect().toRect()); auto canvasRect = annotationArea.canvasRect(); QCOMPARE(canvasRect, defaultCanvasRect); } void AnnotationAreaTest::CanvasRect_Should_ReturnUserDefinedRect_When_CanvasRectSet() { QRect backgroundImageBoundingRect(0,0,400,400); QPixmap pixmap(backgroundImageBoundingRect.size()); pixmap.fill(QColor(Qt::green)); MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); annotationArea.loadImage(pixmap); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(600, 600); auto lineItem = new AnnotationLine(p1, properties); lineItem->addPoint(p2, false); annotationArea.addAnnotationItem(lineItem); auto userDefinedCanvasRect = QRectF(100, 100, 300, 300); annotationArea.setCanvasRect(userDefinedCanvasRect); auto canvasRect = annotationArea.canvasRect(); QCOMPARE(canvasRect, userDefinedCanvasRect); } TEST_MAIN(AnnotationAreaTest); kImageAnnotator-0.6.1/tests/annotations/core/AnnotationAreaTest.h000066400000000000000000000036611440330760000251470ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONAREATEST_H #define KIMAGEANNOTATOR_ANNOTATIONAREATEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/core/AnnotationArea.h" #include "src/annotations/items/AnnotationLine.h" #include "src/annotations/modifiers/resizeHandles/ResizeHandle.h" #include "tests/mocks/MockDefaultParameters.h" using kImageAnnotator::AnnotationArea; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::Config; using kImageAnnotator::PropertiesPtr; using kImageAnnotator::ResizeHandle; class AnnotationAreaTest : public QObject { Q_OBJECT private slots: void ExportAsImage_Should_ExportImage_When_ImageSet(); void ExportAsImage_Should_ExportEmptyImage_When_NoImageSet(); void ExportAsImage_Should_ExportScaledImage_When_ScalingEnabled(); void AddAnnotationItem_Should_AddAnnotationItemToScene(); void RemoveAnnotationItem_Should_RemoveAnnotationItemFromScene(); void CanvasRect_Should_ReturnRectUnionOfAllItems_When_NoCanvasRectSet(); void CanvasRect_Should_ReturnUserDefinedRect_When_CanvasRectSet(); }; #endif // KIMAGEANNOTATOR_ANNOTATIONAREATEST_H kImageAnnotator-0.6.1/tests/annotations/core/AnnotationItemFactoryTest.cpp000066400000000000000000000170101440330760000270510ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemFactoryTest.h" void AnnotationItemFactoryTest::TestCreate_Should_CreateItemAtProvidedPosition() { QPointF position(10, 10); auto toolType = Tools::Line; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(toolType); settingsProvider->setToolWidth(0); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(position); item->addPoint(QPoint(20, 20), false); QCOMPARE(item->position(), position); } void AnnotationItemFactoryTest::TestCreate_Should_CreateImageItemAtProvidedPosition() { QPointF position(10, 10); QPixmap image(200,200); MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(Tools::Image); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(position, image); QVERIFY(dynamic_cast(item) != nullptr); QCOMPARE(item->position(), position); } void AnnotationItemFactoryTest::TestCreate_Should_ReturnNullPtrForUnknownType() { MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType((Tools) 21); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(QPoint(0, 0)); QVERIFY(item == nullptr); } void AnnotationItemFactoryTest::TestCreate_Should_ReturnAnnotationLine_When_TypeIsLine() { MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(Tools::Line); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(QPoint(0, 0)); auto result = dynamic_cast(item); QVERIFY(result != nullptr); } void AnnotationItemFactoryTest::TestCreate_Should_ReturnAnnotationArrow_When_TypeIsArrow() { MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(Tools::Arrow); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(QPoint(0, 0)); auto result = dynamic_cast(item); QVERIFY(result != nullptr); } void AnnotationItemFactoryTest::TestCreate_Should_ReturnAnnotationRect_When_TypeIsRect() { MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(Tools::Rect); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(QPoint(0, 0)); auto result = dynamic_cast(item); QVERIFY(result != nullptr); } void AnnotationItemFactoryTest::TestCreate_Should_ReturnAnnotationEllipse_When_TypeIsEllipse() { MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(Tools::Ellipse); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(QPoint(0, 0)); auto result = dynamic_cast(item); QVERIFY(result != nullptr); } void AnnotationItemFactoryTest::TestCreate_Should_ReturnAnnotationNumber_When_TypeIsNumber() { MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(Tools::Number); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(QPoint(0, 0)); auto result = dynamic_cast(item); QVERIFY(result != nullptr); } void AnnotationItemFactoryTest::TestCreate_Should_ReturnAnnotationSticker_When_TypeIsSticker() { MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(Tools::Sticker); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(QPoint(0, 0)); auto result = dynamic_cast(item); QVERIFY(result != nullptr); } void AnnotationItemFactoryTest::TestCreate_Should_ReturnAnnotationNumberPointer_When_TypeIsNumberPointer() { MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(Tools::NumberPointer); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(QPoint(0, 0)); auto result = dynamic_cast(item); QVERIFY(result != nullptr); } void AnnotationItemFactoryTest::TestClone_Should_ReturnNewItemOfSameType() { QPointF position(10, 10); auto tool = Tools::Line; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(position); item->addPoint(QPoint(20, 20), false); auto clonedItem = itemFactory.clone(item); QVERIFY(clonedItem != item); QCOMPARE(clonedItem->toolType(), item->toolType()); } void AnnotationItemFactoryTest::TestClone_Should_IncrementZValueForClonedItem() { QPointF position(10, 10); auto tool = Tools::Line; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); AnnotationItemFactory itemFactory(&propertiesFactory, settingsProvider, ¶meters.config); auto item = itemFactory.create(position); item->addPoint(QPoint(20, 20), false); auto clonedItem = itemFactory.clone(item); QVERIFY(clonedItem->zValue() > item->zValue()); } TEST_MAIN(AnnotationItemFactoryTest); kImageAnnotator-0.6.1/tests/annotations/core/AnnotationItemFactoryTest.h000066400000000000000000000047641440330760000265320ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMFACTORYTEST_H #define KIMAGEANNOTATOR_ANNOTATIONITEMFACTORYTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/core/AnnotationItemFactory.h" #include "tests/mocks/MockSettingsProvider.h" #include "tests/mocks/MockDefaultParameters.h" using kImageAnnotator::AnnotationItemFactory; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationArrow; using kImageAnnotator::AnnotationRect; using kImageAnnotator::AnnotationNumber; using kImageAnnotator::AnnotationEllipse; using kImageAnnotator::AnnotationImage; using kImageAnnotator::AnnotationSticker; using kImageAnnotator::AnnotationNumberPointer; using kImageAnnotator::Tools; using kImageAnnotator::Config; using kImageAnnotator::AnnotationPropertiesFactory; class AnnotationItemFactoryTest : public QObject { Q_OBJECT private slots: void TestCreate_Should_CreateItemAtProvidedPosition(); void TestCreate_Should_CreateImageItemAtProvidedPosition(); void TestCreate_Should_ReturnNullPtrForUnknownType(); void TestCreate_Should_ReturnAnnotationLine_When_TypeIsLine(); void TestCreate_Should_ReturnAnnotationArrow_When_TypeIsArrow(); void TestCreate_Should_ReturnAnnotationRect_When_TypeIsRect(); void TestCreate_Should_ReturnAnnotationEllipse_When_TypeIsEllipse(); void TestCreate_Should_ReturnAnnotationNumber_When_TypeIsNumber(); void TestCreate_Should_ReturnAnnotationSticker_When_TypeIsSticker(); void TestCreate_Should_ReturnAnnotationNumberPointer_When_TypeIsNumberPointer(); void TestClone_Should_ReturnNewItemOfSameType(); void TestClone_Should_IncrementZValueForClonedItem(); }; #endif // KIMAGEANNOTATOR_ANNOTATIONITEMFACTORYTEST_H kImageAnnotator-0.6.1/tests/annotations/core/AnnotationPropertiesFactoryTest.cpp000066400000000000000000000171471440330760000303220ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationPropertiesFactoryTest.h" void AnnotationPropertiesFactoryTest::TestCreate_Should_SetPropertiesSizeBasedOnConfiguration() { const int size = 13; auto tool = Tools::Line; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolWidth(size); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); QCOMPARE(properties->width(), size); } void AnnotationPropertiesFactoryTest::TestCreate_Should_SetPropertiesColorBasedOnConfiguration() { const QColor color(Qt::darkMagenta); auto tool = Tools::Line; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); settingsProvider->setToolColor(color); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); QCOMPARE(properties->color(), color); } void AnnotationPropertiesFactoryTest::TestCreate_Should_SetPropertiesTextColorBasedOnConfiguration() { const QColor textColor(Qt::darkMagenta); auto tool = Tools::Number; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); settingsProvider->setTextColor(textColor); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); QCOMPARE(properties->textColor(), textColor); } void AnnotationPropertiesFactoryTest::TestCreate_Should_SetPropertiesFillTypeBasedOnConfiguration() { auto fill = FillModes::BorderAndNoFill; auto tool = Tools::Rect; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); settingsProvider->setFillType(fill); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); QCOMPARE(properties->fillType(), fill); } void AnnotationPropertiesFactoryTest::TestCreate_Should_SetShadowEnabledBasedOnConfiguration() { auto tool = Tools::Pen; MockDefaultParameters parameters; auto enabled = true; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setShadowEnabled(enabled); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); QCOMPARE(properties->shadowEnabled(), enabled); } void AnnotationPropertiesFactoryTest::TestCreate_Should_CreatePathPropertiesWhenItemPen() { auto tool = Tools::Pen; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); auto pathProperties = properties.dynamicCast(); QVERIFY(pathProperties != nullptr); } void AnnotationPropertiesFactoryTest::TestCreate_Should_CreatePathPropertiesWhenItemMarker() { auto tool = Tools::MarkerPen; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); auto pathProperties = properties.dynamicCast(); QVERIFY(pathProperties != nullptr); } void AnnotationPropertiesFactoryTest::TestCreate_Should_CreateTextPropertiesWhenItemNumber() { auto tool = Tools::Number; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); auto textProperties = properties.dynamicCast(); QVERIFY(textProperties != nullptr); } void AnnotationPropertiesFactoryTest::TestCreate_Should_CreateTextPropertiesWhenItemNumberPointer() { auto tool = Tools::NumberPointer; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); auto textProperties = properties.dynamicCast(); QVERIFY(textProperties != nullptr); } void AnnotationPropertiesFactoryTest::TestCreate_Should_CreateTextPropertiesWhenItemText() { auto tool = Tools::Text; MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); auto textProperties = properties.dynamicCast(); QVERIFY(textProperties != nullptr); } void AnnotationPropertiesFactoryTest::TestCreate_Should_SetSmoothPathBasedOnConfiguration() { auto tool = Tools::Pen; MockDefaultParameters parameters; auto smoothPathEnabled = true; auto smoothPathFactor = 99; parameters.config.setSmoothPathEnabled(smoothPathEnabled); parameters.config.setSmoothFactor(smoothPathFactor); auto settingsProvider = new MockSettingsProvider(); settingsProvider->setToolType(tool); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); auto pathProperties = properties.dynamicCast(); QCOMPARE(pathProperties->smoothPathEnabled(), smoothPathEnabled); QCOMPARE(pathProperties->smoothFactor(), smoothPathFactor); } void AnnotationPropertiesFactoryTest::TestCreate_Should_SetToolFontBasedOnSettings() { auto tool = Tools::Number; MockDefaultParameters parameters; auto font = QFont("Helvetica [Cronyx]", 8, QFont::StyleItalic); auto settingsProvider = new MockSettingsProvider(); settingsProvider->setFont(font); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); auto textProperties = properties.dynamicCast(); QCOMPARE(textProperties->font(), font); } void AnnotationPropertiesFactoryTest::TestCreate_Should_StickerPathBasedOnSettings() { auto tool = Tools::Sticker; auto path = QLatin1Literal("/my/path/to/sticker"); MockDefaultParameters parameters; auto settingsProvider = new MockSettingsProvider(); settingsProvider->setSticker(path); AnnotationPropertiesFactory propertiesFactory(¶meters.config, settingsProvider); auto properties = propertiesFactory.create(tool); auto stickerProperties = properties.dynamicCast(); QCOMPARE(stickerProperties->path(), path); } TEST_MAIN(AnnotationPropertiesFactoryTest); kImageAnnotator-0.6.1/tests/annotations/core/AnnotationPropertiesFactoryTest.h000066400000000000000000000045651440330760000277670ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONPROPERTIESFACTORYTEST_H #define KIMAGEANNOTATOR_ANNOTATIONPROPERTIESFACTORYTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/core/AnnotationPropertiesFactory.h" #include "tests/mocks/MockSettingsProvider.h" #include "tests/mocks/MockDefaultParameters.h" using kImageAnnotator::AnnotationPropertiesFactory; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationTextProperties; using kImageAnnotator::AnnotationPathProperties; using kImageAnnotator::AnnotationStickerProperties; using kImageAnnotator::Tools; using kImageAnnotator::FillModes; using kImageAnnotator::Config; class AnnotationPropertiesFactoryTest : public QObject { Q_OBJECT private slots: void TestCreate_Should_SetPropertiesSizeBasedOnConfiguration(); void TestCreate_Should_SetPropertiesColorBasedOnConfiguration(); void TestCreate_Should_SetPropertiesTextColorBasedOnConfiguration(); void TestCreate_Should_SetPropertiesFillTypeBasedOnConfiguration(); void TestCreate_Should_SetShadowEnabledBasedOnConfiguration(); void TestCreate_Should_CreatePathPropertiesWhenItemPen(); void TestCreate_Should_CreatePathPropertiesWhenItemMarker(); void TestCreate_Should_CreateTextPropertiesWhenItemNumber(); void TestCreate_Should_CreateTextPropertiesWhenItemNumberPointer(); void TestCreate_Should_CreateTextPropertiesWhenItemText(); void TestCreate_Should_SetSmoothPathBasedOnConfiguration(); void TestCreate_Should_SetToolFontBasedOnSettings(); void TestCreate_Should_StickerPathBasedOnSettings(); }; #endif // ANNOTATIONPROPERTIESFACTORYTEST_H kImageAnnotator-0.6.1/tests/annotations/items/000077500000000000000000000000001440330760000214165ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/annotations/items/helper/000077500000000000000000000000001440330760000226755ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/annotations/items/helper/KeyInputHelperTest.cpp000066400000000000000000000213211440330760000271500ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "KeyInputHelperTest.h" void KeyInputHelperTest::TestHandleKeyPress_Should_EmitRemoveSignal_When_KeyIsBackspace() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::remove); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Backspace, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::Previous); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitRemoveSignal_When_KeyIsDelete() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::remove); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Delete, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::Next); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitInsertSignalWithNewLine_When_KeyIsReturnAndModifierShift() { KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::insert); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::ShiftModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultText = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultText, QStringLiteral("\n")); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitInsertSignalWithNewLine_When_KeyIsEnterAndModifierShift() { KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::insert); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Enter, Qt::ShiftModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultText = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultText, QStringLiteral("\n")); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitEscape_When_KeyIsReturnAndNoModifier() { KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::escape); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Return, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitEscape_When_KeyIsEnterAndNoModifier() { KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::escape); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Enter, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitEscapeSignal_When_KeyIsEscape() { KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::escape); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Escape, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsHome() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::move); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Home, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::Beginning); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsEnd() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::move); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_End, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::End); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowLeft() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::move); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Left, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::Previous); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowLeftAndModifierCtrl() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::move); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Left, Qt::ControlModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::PreviousWordBeginning); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowRight() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::move); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Right, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::Next); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowRightAndModifierCtrl() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::move); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Right, Qt::ControlModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::NextWordBeginning); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowUp() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::move); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Up, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::Up); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowDown() { qRegisterMetaType("TextPositions"); KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::move); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Down, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultDirection = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultDirection, TextPositions::Down); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitPasteSignal_When_KeyIsPaste() { KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::paste); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Paste, Qt::NoModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitPasteSignal_When_KeySequenceIsPaste() { KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::paste); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_V, Qt::ControlModifier); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); } void KeyInputHelperTest::TestHandleKeyPress_Should_EmitInsertSignal_When_KeyIsCharacter() { KeyInputHelper keyInputHelper; QSignalSpy spy(&keyInputHelper, &KeyInputHelper::insert); QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_J, Qt::NoModifier, QStringLiteral("j")); keyInputHelper.handleKeyPress(&keyEvent); QCOMPARE(spy.count(), 1); auto resultText = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultText, QStringLiteral("j")); } TEST_MAIN(KeyInputHelperTest); kImageAnnotator-0.6.1/tests/annotations/items/helper/KeyInputHelperTest.h000066400000000000000000000047671440330760000266340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_KEYINPUTHELPERTEST_H #define KIMAGEANNOTATOR_KEYINPUTHELPERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/items/text/KeyInputHelper.h" using kImageAnnotator::KeyInputHelper; using kImageAnnotator::TextPositions; class KeyInputHelperTest : public QObject { Q_OBJECT private slots: void TestHandleKeyPress_Should_EmitRemoveSignal_When_KeyIsBackspace(); void TestHandleKeyPress_Should_EmitRemoveSignal_When_KeyIsDelete(); void TestHandleKeyPress_Should_EmitInsertSignalWithNewLine_When_KeyIsReturnAndModifierShift(); void TestHandleKeyPress_Should_EmitInsertSignalWithNewLine_When_KeyIsEnterAndModifierShift(); void TestHandleKeyPress_Should_EmitEscape_When_KeyIsReturnAndNoModifier(); void TestHandleKeyPress_Should_EmitEscape_When_KeyIsEnterAndNoModifier(); void TestHandleKeyPress_Should_EmitEscapeSignal_When_KeyIsEscape(); void TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsHome(); void TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsEnd(); void TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowLeft(); void TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowLeftAndModifierCtrl(); void TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowRight(); void TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowRightAndModifierCtrl(); void TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowUp(); void TestHandleKeyPress_Should_EmitMoveSignal_When_KeyIsArrowDown(); void TestHandleKeyPress_Should_EmitPasteSignal_When_KeyIsPaste(); void TestHandleKeyPress_Should_EmitPasteSignal_When_KeySequenceIsPaste(); void TestHandleKeyPress_Should_EmitInsertSignal_When_KeyIsCharacter(); }; #endif // KIMAGEANNOTATOR_KEYINPUTHELPERTEST_H kImageAnnotator-0.6.1/tests/annotations/items/helper/TextCursorTest.cpp000066400000000000000000000177161440330760000263770ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "TextCursorTest.h" void TextCursorTest::TestMove_Should_MoveCursorToBeginning_When_DirectionBeginning() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(16); textCursor.move(TextPositions::Beginning, text); QCOMPARE(textCursor.position(), 0); } void TextCursorTest::TestMove_Should_MoveCursorToEnd_When_DirectionEnd() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); QCOMPARE(textCursor.position(), 0); textCursor.move(TextPositions::End, text); QCOMPARE(textCursor.position(), 16); } void TextCursorTest::TestMove_Should_MoveCursorByOnePointToRight_When_DirectionNext() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); QCOMPARE(textCursor.position(), 0); textCursor.move(TextPositions::Next, text); QCOMPARE(textCursor.position(), 1); } void TextCursorTest::TestMove_Should_MoveCursorToNextWordBeginning_When_DirectionNextAndModifierCtrl() { TextCursor textCursor; QString text = QLatin1String(" This is a string\n" "spanning multiple lines " " 123 1 "); QCOMPARE(textCursor.position(), 0); QVector nextPositionList{ 1, 6, 10, 12, 18, 19, 28, 37, 44, 48, 51, 51 }; for(int nextPosition : nextPositionList) { textCursor.move(TextPositions::NextWordBeginning, text); QCOMPARE(textCursor.position(), nextPosition); } } void TextCursorTest::TestMove_Should_MoveCursorByOnePointToLeft_When_DirectionPrevious() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.move(TextPositions::Next, text); QCOMPARE(textCursor.position(), 1); textCursor.move(TextPositions::Previous, text); QCOMPARE(textCursor.position(), 0); } void TextCursorTest::TestMove_Should_MoveCursorToPreviousWordBeginning_When_DirectionPreviousAndModifierCtrl() { TextCursor textCursor; QString text = QLatin1String(" This is a string\n" "spanning multiple lines " " 123 1 "); textCursor.setPosition(51); QCOMPARE(textCursor.position(), 51); QVector prevPositionList{ 48, 44, 37, 28, 19, 18, 12, 10, 6, 1, 0, 0 }; for(int prevPosition : prevPositionList) { textCursor.move(TextPositions::PreviousWordBeginning, text); QCOMPARE(textCursor.position(), prevPosition); } } void TextCursorTest::TestMove_Should_MoveCursorToStart_When_DirectionPreviousAndCurrentPositionAtStart() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); QCOMPARE(textCursor.position(), 0); textCursor.move(TextPositions::Previous, text); QCOMPARE(textCursor.position(), 0); } void TextCursorTest::TestMove_Should_MoveCursorToEnd_When_DirectionNextAndCurrentPositionAtEnd() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(text.length()); textCursor.move(TextPositions::Next, text); QCOMPARE(textCursor.position(), text.length()); } void TextCursorTest::TestMove_Should_MoveCursorToNextLineSamePosition_When_DirectionDown() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); QCOMPARE(textCursor.position(), 0); textCursor.move(TextPositions::Down, text); QCOMPARE(textCursor.position(), 5); } void TextCursorTest::TestMove_Should_NotMoveCursor_When_DirectionDownAndInLastLine() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(9); textCursor.move(TextPositions::Down, text); QCOMPARE(textCursor.position(), 9); } void TextCursorTest::TestMove_Should_NotMoveCursor_When_DirectionUpAndInFirstLine() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); QCOMPARE(textCursor.position(), 0); textCursor.move(TextPositions::Up, text); QCOMPARE(textCursor.position(), 0); } void TextCursorTest::TestMove_Should_MoveCursorToPreviousLineSamePosition_When_DirectionUpAndNotInFirstLine() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(9); textCursor.move(TextPositions::Up, text); QCOMPARE(textCursor.position(), 5); } void TextCursorTest::TestMove_Should_MoveCursorToEndOfNextLine_When_DirectionDownAndPositionAtEndOfLineAndLineBelowIsSmaller() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(4); textCursor.move(TextPositions::Down, text); QCOMPARE(textCursor.position(), 8); } void TextCursorTest::TestMove_Should_MoveCursorToEndOfPreviousLine_When_DirectionUpAndPositionAtEndOfLineAndLineAboveIsSmaller() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(16); textCursor.move(TextPositions::Up, text); QCOMPARE(textCursor.position(), 8); } void TextCursorTest::TestMove_Should_MoveCursorToSamePositionOfPreviousLine_When_DirectionUpAndPositionAtEndOfLineAndLineAboveIsLarger() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(8); textCursor.move(TextPositions::Up, text); QCOMPARE(textCursor.position(), 3); } void TextCursorTest::TestMove_Should_MoveCursorToSamePositionOfNextLine_When_DirectionDownAndPositionAtEndOfLineAndLineBelowIsLarger() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(8); textCursor.move(TextPositions::Down, text); QCOMPARE(textCursor.position(), 12); } void TextCursorTest::TestMoveForwardBy_Should_MoveCursorForwardByRequestedSteps() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); QCOMPARE(textCursor.position(), 0); textCursor.moveForwardBy(text, 2); QCOMPARE(textCursor.position(), 2); } void TextCursorTest::TestMoveForwardBy_Should_MoveCursorToEnd_When_RequestedStepsLargerThenTextLength() { TextCursor textCursor; QString text = QLatin1String("Test\n" "123\n" "test123"); textCursor.setPosition(2); textCursor.moveForwardBy(text, 20); QCOMPARE(textCursor.position(), text.length()); } TEST_MAIN(TextCursorTest); kImageAnnotator-0.6.1/tests/annotations/items/helper/TextCursorTest.h000066400000000000000000000053131440330760000260320ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_TEXTCURSORTEST_H #define KIMAGEANNOTATOR_TEXTCURSORTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/items/text/TextCursor.h" using kImageAnnotator::TextCursor; using kImageAnnotator::TextPositions; class TextCursorTest : public QObject { Q_OBJECT private slots: void TestMove_Should_MoveCursorToBeginning_When_DirectionBeginning(); void TestMove_Should_MoveCursorToEnd_When_DirectionEnd(); void TestMove_Should_MoveCursorByOnePointToRight_When_DirectionNext(); void TestMove_Should_MoveCursorToNextWordBeginning_When_DirectionNextAndModifierCtrl(); void TestMove_Should_MoveCursorByOnePointToLeft_When_DirectionPrevious(); void TestMove_Should_MoveCursorToPreviousWordBeginning_When_DirectionPreviousAndModifierCtrl(); void TestMove_Should_MoveCursorToStart_When_DirectionPreviousAndCurrentPositionAtStart(); void TestMove_Should_MoveCursorToEnd_When_DirectionNextAndCurrentPositionAtEnd(); void TestMove_Should_MoveCursorToNextLineSamePosition_When_DirectionDown(); void TestMove_Should_NotMoveCursor_When_DirectionDownAndInLastLine(); void TestMove_Should_NotMoveCursor_When_DirectionUpAndInFirstLine(); void TestMove_Should_MoveCursorToPreviousLineSamePosition_When_DirectionUpAndNotInFirstLine(); void TestMove_Should_MoveCursorToEndOfNextLine_When_DirectionDownAndPositionAtEndOfLineAndLineBelowIsSmaller(); void TestMove_Should_MoveCursorToEndOfPreviousLine_When_DirectionUpAndPositionAtEndOfLineAndLineAboveIsSmaller(); void TestMove_Should_MoveCursorToSamePositionOfPreviousLine_When_DirectionUpAndPositionAtEndOfLineAndLineAboveIsLarger(); void TestMove_Should_MoveCursorToSamePositionOfNextLine_When_DirectionDownAndPositionAtEndOfLineAndLineBelowIsLarger(); void TestMoveForwardBy_Should_MoveCursorForwardByRequestedSteps(); void TestMoveForwardBy_Should_MoveCursorToEnd_When_RequestedStepsLargerThenTextLength(); }; #endif // KIMAGEANNOTATOR_TEXTCURSORTEST_H kImageAnnotator-0.6.1/tests/annotations/misc/000077500000000000000000000000001440330760000212305ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/annotations/misc/AnnotationItemClipboardTest.cpp000066400000000000000000000043301440330760000273450ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemClipboardTest.h" #include "tests/mocks/MockZoomValueProvider.h" void AnnotationItemClipboardTest::TestCopyItems_Should_StoreSelectedItems() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationRect rect(QPointF(0, 0), properties); rect.addPoint(QPointF(50, 50), false); QPointF position(50, 50); QList items; items.append(&rect); MockZoomValueProvider zoomValueProvider; AnnotationItemModifier modifier(&zoomValueProvider); modifier.handleSelectionAt(position, &items, false); AnnotationItemClipboard clipboard(&modifier); clipboard.copyItems(QPointF()); QCOMPARE(clipboard.copiedItemsWithOffset().count(), 1); QCOMPARE(clipboard.copiedItemsWithOffset().keys().first(), &rect); } void AnnotationItemClipboardTest::TestCopyItems_Should_SetCorrectOffset() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationRect rect(QPointF(0, 0), properties); rect.addPoint(QPointF(50, 50), false); QPointF position(50, 50); QList items; items.append(&rect); MockZoomValueProvider zoomValueProvider; AnnotationItemModifier modifier(&zoomValueProvider); modifier.handleSelectionAt(position, &items, false); AnnotationItemClipboard clipboard(&modifier); clipboard.copyItems(QPointF(20, 20)); QCOMPARE(clipboard.copiedItemsWithOffset()[&rect], QPointF(-20, -20)); } TEST_MAIN(AnnotationItemClipboardTest); kImageAnnotator-0.6.1/tests/annotations/misc/AnnotationItemClipboardTest.h000066400000000000000000000027651440330760000270240ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTTIONITEMCLIPBOARDTEST_H #define KIMAGEANNOTATOR_ANNOTTIONITEMCLIPBOARDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/misc/AnnotationItemClipboard.h" using kImageAnnotator::AnnotationItemClipboard; using kImageAnnotator::AnnotationItemModifier; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::AnnotationRect; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::PropertiesPtr; class AnnotationItemClipboardTest : public QObject { Q_OBJECT private slots: void TestCopyItems_Should_StoreSelectedItems(); void TestCopyItems_Should_SetCorrectOffset(); }; #endif // KIMAGEANNOTATOR_ANNOTTIONITEMCLIPBOARDTEST_H kImageAnnotator-0.6.1/tests/annotations/misc/NumberManagerTest.cpp000066400000000000000000000155561440330760000253330ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "NumberManagerTest.h" void NumberManagerTest::TestAddItem_Should_AssignCorrectNumbers_When_UpdateAllNumbersModeSelected() { auto properties1 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties2 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties3 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); AnnotationNumber item1(QPointF(0, 0), properties1); AnnotationNumber item2(QPointF(0, 0), properties2); AnnotationNumber item3(QPointF(0, 0), properties3); NumberManager numberManager; numberManager.setNumberUpdateMode(NumberUpdateMode::UpdateAllNumbers); numberManager.addItem(&item1); numberManager.addItem(&item2); numberManager.addItem(&item3); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); QCOMPARE(item3.number(), 3); } void NumberManagerTest::TestAddItem_Should_AssignCorrectNumbers_When_UpdateOnlyNewNumbers() { auto properties1 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties2 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties3 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); AnnotationNumber item1(QPointF(0, 0), properties1); AnnotationNumber item2(QPointF(0, 0), properties2); AnnotationNumber item3(QPointF(0, 0), properties3); NumberManager numberManager; numberManager.setNumberUpdateMode(NumberUpdateMode::UpdateOnlyNewNumbers); numberManager.addItem(&item1); numberManager.addItem(&item2); numberManager.addItem(&item3); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); QCOMPARE(item3.number(), 3); } void NumberManagerTest::TestUpdateNumbers_Should_BeTriggered_When_ItemIsHiddenAndUpdateAllNumbersModeSelected() { auto properties1 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties2 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties3 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); AnnotationNumber item1(QPointF(0, 0), properties1); AnnotationNumber item2(QPointF(0, 0), properties2); AnnotationNumber item3(QPointF(0, 0), properties3); NumberManager numberManager; numberManager.setNumberUpdateMode(NumberUpdateMode::UpdateAllNumbers); numberManager.addItem(&item1); numberManager.addItem(&item2); numberManager.addItem(&item3); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); QCOMPARE(item3.number(), 3); item2.hide(); QCOMPARE(item1.number(), 1); QCOMPARE(item3.number(), 2); } void NumberManagerTest::TestUpdateNumbers_Should_NotBeTriggered_When_ItemIsHiddenAndUpdateOnlyNewNumbersModeSelected() { auto properties1 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties2 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties3 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); AnnotationNumber item1(QPointF(0, 0), properties1); AnnotationNumber item2(QPointF(0, 0), properties2); AnnotationNumber item3(QPointF(0, 0), properties3); NumberManager numberManager; numberManager.setNumberUpdateMode(NumberUpdateMode::UpdateOnlyNewNumbers); numberManager.addItem(&item1); numberManager.addItem(&item2); numberManager.addItem(&item3); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); QCOMPARE(item3.number(), 3); item2.hide(); QCOMPARE(item1.number(), 1); QCOMPARE(item3.number(), 3); } void NumberManagerTest::TestNumberSeedChanged_Should_TriggerUpdateOfAllNumber_When_UpdateAllNumbersModeSelected() { auto properties1 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties2 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties3 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); AnnotationNumber item1(QPointF(0, 0), properties1); AnnotationNumber item2(QPointF(0, 0), properties2); AnnotationNumber item3(QPointF(0, 0), properties3); NumberManager numberManager; numberManager.setNumberUpdateMode(NumberUpdateMode::UpdateAllNumbers); numberManager.addItem(&item1); numberManager.addItem(&item2); numberManager.addItem(&item3); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); QCOMPARE(item3.number(), 3); numberManager.setNumberSeed(4); QCOMPARE(item1.number(), 4); QCOMPARE(item2.number(), 5); QCOMPARE(item3.number(), 6); } void NumberManagerTest::TestNumberSeedChanged_Should_NotTriggerUpdateOfAllNumber_When_UpdateOnlyNewNumbersModeSelected() { auto properties1 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties2 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties3 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); AnnotationNumber item1(QPointF(0, 0), properties1); AnnotationNumber item2(QPointF(0, 0), properties2); AnnotationNumber item3(QPointF(0, 0), properties3); NumberManager numberManager; numberManager.setNumberUpdateMode(NumberUpdateMode::UpdateOnlyNewNumbers); numberManager.addItem(&item1); numberManager.addItem(&item2); numberManager.addItem(&item3); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); QCOMPARE(item3.number(), 3); numberManager.setNumberSeed(4); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); QCOMPARE(item3.number(), 3); } void NumberManagerTest::TestNumberSeedChanged_Should_AffectOnlyNewItems_When_UpdateOnlyNewNumbersModeSelected() { auto properties1 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties2 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); auto properties3 = TextPropertiesPtr(new AnnotationTextProperties(2, Qt::red)); AnnotationNumber item1(QPointF(0, 0), properties1); AnnotationNumber item2(QPointF(0, 0), properties2); AnnotationNumber item3(QPointF(0, 0), properties3); NumberManager numberManager; numberManager.setNumberUpdateMode(NumberUpdateMode::UpdateOnlyNewNumbers); numberManager.addItem(&item1); numberManager.addItem(&item2); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); numberManager.setNumberSeed(5); numberManager.addItem(&item3); QCOMPARE(item1.number(), 1); QCOMPARE(item2.number(), 2); QCOMPARE(item3.number(), 5); } TEST_MAIN(NumberManagerTest); kImageAnnotator-0.6.1/tests/annotations/misc/NumberManagerTest.h000066400000000000000000000037551440330760000247760ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_NUMBERMANAGERTEST_H #define KIMAGEANNOTATOR_NUMBERMANAGERTEST_H #include #include "tests/utils/TestRunner.h" #include using kImageAnnotator::NumberManager; using kImageAnnotator::AnnotationNumber; using kImageAnnotator::AnnotationTextProperties; using kImageAnnotator::TextPropertiesPtr; using kImageAnnotator::NumberUpdateMode; #include "src/annotations/misc/NumberManager.h" class NumberManagerTest : public QObject { Q_OBJECT private slots: void TestAddItem_Should_AssignCorrectNumbers_When_UpdateAllNumbersModeSelected(); void TestAddItem_Should_AssignCorrectNumbers_When_UpdateOnlyNewNumbers(); void TestUpdateNumbers_Should_BeTriggered_When_ItemIsHiddenAndUpdateAllNumbersModeSelected(); void TestUpdateNumbers_Should_NotBeTriggered_When_ItemIsHiddenAndUpdateOnlyNewNumbersModeSelected(); void TestNumberSeedChanged_Should_TriggerUpdateOfAllNumber_When_UpdateAllNumbersModeSelected(); void TestNumberSeedChanged_Should_NotTriggerUpdateOfAllNumber_When_UpdateOnlyNewNumbersModeSelected(); void TestNumberSeedChanged_Should_AffectOnlyNewItems_When_UpdateOnlyNewNumbersModeSelected(); }; #endif // KIMAGEANNOTATOR_NUMBERMANAGERTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/000077500000000000000000000000001440330760000222565ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemArrangerTest.cpp000066400000000000000000000203711440330760000302400ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemArrangerTest.h" void AnnotationItemArrangerTest::TestBringToFront_Should_BringAllSelectedItemsToFront() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties3 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties4 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationLine item1(QPointF(0, 0), properties1); AnnotationLine item2(QPointF(0, 0), properties2); AnnotationLine item3(QPointF(0, 0), properties3); AnnotationLine item4(QPointF(0, 0), properties4); item1.setZValue(1); item2.setZValue(2); item3.setZValue(3); item4.setZValue(4); QList items; QList selectedItems; items.append(&item4); items.append(&item3); items.append(&item2); items.append(&item1); selectedItems.append(&item2); selectedItems.append(&item1); AnnotationItemArranger arranger(selectedItems, &items); QUndoStack undoStack; connect(&arranger, &AnnotationItemArranger::newCommand, &undoStack, &QUndoStack::push); arranger.bringToFront(); QCOMPARE((int) item1.zValue(), 3); QCOMPARE((int) item2.zValue(), 4); QCOMPARE((int) item3.zValue(), 1); QCOMPARE((int) item4.zValue(), 2); } void AnnotationItemArrangerTest::TestBringForward_Should_MoveAllSelectedItemsOnePositionUp() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties3 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties4 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationLine item1(QPointF(0, 0), properties1); AnnotationLine item2(QPointF(0, 0), properties2); AnnotationLine item3(QPointF(0, 0), properties3); AnnotationLine item4(QPointF(0, 0), properties4); item1.setZValue(1); item2.setZValue(2); item3.setZValue(3); item4.setZValue(4); QList items; QList selectedItems; items.append(&item4); items.append(&item3); items.append(&item2); items.append(&item1); selectedItems.append(&item2); selectedItems.append(&item1); AnnotationItemArranger arranger(selectedItems, &items); QUndoStack undoStack; connect(&arranger, &AnnotationItemArranger::newCommand, &undoStack, &QUndoStack::push); arranger.bringForward(); QCOMPARE((int) item1.zValue(), 2); QCOMPARE((int) item2.zValue(), 3); QCOMPARE((int) item3.zValue(), 1); QCOMPARE((int) item4.zValue(), 4); } void AnnotationItemArrangerTest::TestSendBackward_Should_MoveAllSelectedItemsOnePositionBack() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties3 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties4 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationLine item1(QPointF(0, 0), properties1); AnnotationLine item2(QPointF(0, 0), properties2); AnnotationLine item3(QPointF(0, 0), properties3); AnnotationLine item4(QPointF(0, 0), properties4); item1.setZValue(1); item2.setZValue(2); item3.setZValue(3); item4.setZValue(4); QList items; QList selectedItems; items.append(&item4); items.append(&item3); items.append(&item2); items.append(&item1); selectedItems.append(&item4); selectedItems.append(&item3); AnnotationItemArranger arranger(selectedItems, &items); QUndoStack undoStack; connect(&arranger, &AnnotationItemArranger::newCommand, &undoStack, &QUndoStack::push); arranger.sendBackward(); QCOMPARE((int) item1.zValue(), 1); QCOMPARE((int) item2.zValue(), 4); QCOMPARE((int) item3.zValue(), 2); QCOMPARE((int) item4.zValue(), 3); } void AnnotationItemArrangerTest::TestSendToBack_Should_SendAllSelectedItemToBack() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties3 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties4 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationLine item1(QPointF(0, 0), properties1); AnnotationLine item2(QPointF(0, 0), properties2); AnnotationLine item3(QPointF(0, 0), properties3); AnnotationLine item4(QPointF(0, 0), properties4); item1.setZValue(1); item2.setZValue(2); item3.setZValue(3); item4.setZValue(4); QList items; QList selectedItems; items.append(&item4); items.append(&item3); items.append(&item2); items.append(&item1); selectedItems.append(&item4); selectedItems.append(&item3); AnnotationItemArranger arranger(selectedItems, &items); QUndoStack undoStack; connect(&arranger, &AnnotationItemArranger::newCommand, &undoStack, &QUndoStack::push); arranger.sendToBack(); QCOMPARE((int) item1.zValue(), 3); QCOMPARE((int) item2.zValue(), 4); QCOMPARE((int) item3.zValue(), 1); QCOMPARE((int) item4.zValue(), 2); } void AnnotationItemArrangerTest::TestAnnotationItemArranger_Should_SortAllItemsByZValue_When_PositionHaveBeenSwapped() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties3 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties4 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationLine item1(QPointF(0, 0), properties1); AnnotationLine item2(QPointF(0, 0), properties2); AnnotationLine item3(QPointF(0, 0), properties3); AnnotationLine item4(QPointF(0, 0), properties4); item1.setZValue(1); item2.setZValue(2); item3.setZValue(3); item4.setZValue(4); QList items; QList selectedItems; items.append(&item4); items.append(&item3); items.append(&item2); items.append(&item1); selectedItems.append(&item2); selectedItems.append(&item1); AnnotationItemArranger arranger(selectedItems, &items); QUndoStack undoStack; connect(&arranger, &AnnotationItemArranger::newCommand, &undoStack, &QUndoStack::push); arranger.bringToFront(); QCOMPARE((int) items[0]->zValue(), 4); QCOMPARE((int) items[1]->zValue(), 3); QCOMPARE((int) items[2]->zValue(), 2); QCOMPARE((int) items[3]->zValue(), 1); } void AnnotationItemArrangerTest::TestAnnotationItemArranger_Should_NotSwapAnyPosition_When_NoItemsHaveBeenSelected() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties3 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties4 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationLine item1(QPointF(0, 0), properties1); AnnotationLine item2(QPointF(0, 0), properties2); AnnotationLine item3(QPointF(0, 0), properties3); AnnotationLine item4(QPointF(0, 0), properties4); item1.setZValue(1); item2.setZValue(2); item3.setZValue(3); item4.setZValue(4); QList items; QList selectedItems; items.append(&item4); items.append(&item3); items.append(&item2); items.append(&item1); AnnotationItemArranger arranger(selectedItems, &items); QUndoStack undoStack; connect(&arranger, &AnnotationItemArranger::newCommand, &undoStack, &QUndoStack::push); arranger.bringToFront(); QCOMPARE((int) item1.zValue(), 1); QCOMPARE((int) item2.zValue(), 2); QCOMPARE((int) item3.zValue(), 3); QCOMPARE((int) item4.zValue(), 4); } TEST_MAIN(AnnotationItemArrangerTest); kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemArrangerTest.h000066400000000000000000000035461440330760000277120ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMARRANGERTEST_H #define KIMAGEANNOTATOR_ANNOTATIONITEMARRANGERTEST_H #include #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/AnnotationItemArranger.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::AnnotationItemArranger; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class AnnotationItemArrangerTest : public QObject { Q_OBJECT private slots: void TestBringToFront_Should_BringAllSelectedItemsToFront(); void TestBringForward_Should_MoveAllSelectedItemsOnePositionUp(); void TestSendBackward_Should_MoveAllSelectedItemsOnePositionBack(); void TestSendToBack_Should_SendAllSelectedItemToBack(); void TestAnnotationItemArranger_Should_SortAllItemsByZValue_When_PositionHaveBeenSwapped(); void TestAnnotationItemArranger_Should_NotSwapAnyPosition_When_NoItemsHaveBeenSelected(); }; #endif // KIMAGEANNOTATOR_ANNOTATIONITEMARRANGERTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemModifierTest.cpp000066400000000000000000000135321440330760000302360ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemModifierTest.h" #include "tests/mocks/MockZoomValueProvider.h" void AnnotationItemModifierTest::HandleMousePressMoveRelease_Should_MoveResizerHandle_When_ClickedOnResizerHandle() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(30, 30); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemModifier modifer(&zoomValueProvider); QUndoStack undoStack; connect(&modifer, &AnnotationItemModifier::newCommand, &undoStack, &QUndoStack::push); modifer.handleMousePress(p1, &items, false); modifer.handleMouseRelease(&items); modifer.handleMousePress(p1, &items, false); modifer.handleMouseMove(p3, false); QCOMPARE(line.line().p1(), p3); QCOMPARE(line.line().p2(), p2); } void AnnotationItemModifierTest::HandleMousePressMove_Should_NotMoveResizerHandle_When_NotClickedOnResizerHandle() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(30, 30); QPointF p4(40, 40); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemModifier modifer(&zoomValueProvider); modifer.handleMousePress(p1, &items, false); modifer.handleMouseRelease(&items); modifer.handleMousePress(p3, &items, false); modifer.handleMouseMove(p4, false); QCOMPARE(line.line().p1(), p1); QCOMPARE(line.line().p2(), p2); } void AnnotationItemModifierTest::HandleMousePressMoveRelease_Should_SelectMultipleItems_When_ClickedNotOnItem() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(15, 15); QPointF p4(20, 20); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemModifier modifer(&zoomValueProvider); modifer.handleMousePress(p1 + QPointF(-5, -5), &items, false); modifer.handleMouseMove(p4 + QPointF(5, 5), false); modifer.handleMouseRelease(&items); auto results = modifer.selectedItems(); QCOMPARE(results.count(), 2); QCOMPARE(results.contains(&line1), true); QCOMPARE(results.contains(&line2), true); } void AnnotationItemModifierTest::HandleMousePressMove_Should_MoveClickedItem_When_ClickedOnItemAndMoved() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(20, 20); QPointF clickPos(15, 15); QPointF movePos(30, 30); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemModifier modifer(&zoomValueProvider); QUndoStack undoStack; connect(&modifer, &AnnotationItemModifier::newCommand, &undoStack, &QUndoStack::push); modifer.handleMousePress(clickPos, &items, false); modifer.handleMouseMove(movePos, false); QCOMPARE(line.boundingRect().topLeft(), movePos - (clickPos - p1)); } void AnnotationItemModifierTest::HandleMousePressMove_Should_MoveSelectedItems_When_ClickedOnOfSelectedItemsAndMoved() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(30, 30); QPointF p3(45, 45); QPointF p4(60, 60); QPointF clickPos(20, 20); QPointF movePos(80, 80); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemModifier modifer(&zoomValueProvider); QUndoStack undoStack; connect(&modifer, &AnnotationItemModifier::newCommand, &undoStack, &QUndoStack::push); modifer.handleMousePress(p1 + QPointF(-5, -5), &items, false); modifer.handleMouseMove(p4 + QPointF(5, 5), false); modifer.handleMouseRelease(&items); QCOMPARE(modifer.selectedItems().count(), 2); modifer.handleMousePress(clickPos, &items, false); modifer.handleMouseMove(movePos, false); QCOMPARE(line1.boundingRect().topLeft(), movePos - (clickPos - p1)); QCOMPARE(line2.boundingRect().topLeft(), movePos - (clickPos - p3)); } void AnnotationItemModifierTest::SelectItem_Should_SelectProvidedItem() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); AnnotationLine line(QPointF(10, 10), properties); line.addPoint(QPointF(20, 20), false); MockZoomValueProvider zoomValueProvider; AnnotationItemModifier modifer(&zoomValueProvider); modifer.selectItem(&line); QCOMPARE(modifer.selectedItems().count(), 1); QCOMPARE(modifer.selectedItems().first(), &line); } TEST_MAIN(AnnotationItemModifierTest); kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemModifierTest.h000066400000000000000000000036231440330760000277030ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMMODIFIERTEST_H #define KIMAGEANNOTATOR_ANNOTATIONITEMMODIFIERTEST_H #include #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/AnnotationItemModifier.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::AnnotationItemModifier; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class AnnotationItemModifierTest : public QObject { Q_OBJECT private slots: void HandleMousePressMoveRelease_Should_MoveResizerHandle_When_ClickedOnResizerHandle(); void HandleMousePressMove_Should_NotMoveResizerHandle_When_NotClickedOnResizerHandle(); void HandleMousePressMoveRelease_Should_SelectMultipleItems_When_ClickedNotOnItem(); void HandleMousePressMove_Should_MoveClickedItem_When_ClickedOnItemAndMoved(); void HandleMousePressMove_Should_MoveSelectedItems_When_ClickedOnOfSelectedItemsAndMoved(); void SelectItem_Should_SelectProvidedItem(); }; #endif // KIMAGEANNOTATOR_ANNOTATIONITEMMODIFIERTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemMoverTest.cpp000066400000000000000000000034341440330760000275700ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemMoverTest.h" void AnnotationItemMoverTest::TestMoveItems_Should_MoveItemsToNewPosition() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(15, 15); QPointF p4(20, 20); QPointF clickPos(p1 + QPointF(5, 5)); QPointF newPos(QPointF(50, 50)); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); AnnotationItemMover mover; QUndoStack undoStack; connect(&mover, &AnnotationItemMover::newCommand, &undoStack, &QUndoStack::push); mover.setOffset(clickPos, items); mover.moveItems(newPos); QCOMPARE(line1.boundingRect().topLeft(), newPos - (clickPos - p1)); QCOMPARE(line2.boundingRect().topLeft(), newPos - (clickPos - p3)); } TEST_MAIN(AnnotationItemMoverTest); kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemMoverTest.h000066400000000000000000000027221440330760000272340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMMOVERTEST_H #define KIMAGEANNOTATOR_ANNOTATIONITEMMOVERTEST_H #include #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/AnnotationItemMover.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::AnnotationItemMover; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class AnnotationItemMoverTest : public QObject { Q_OBJECT private slots: void TestMoveItems_Should_MoveItemsToNewPosition(); }; #endif // KIMAGEANNOTATOR_ANNOTATIONITEMMOVERTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemResizerTest.cpp000066400000000000000000000070441440330760000301240ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemResizerTest.h" #include "tests/mocks/MockZoomValueProvider.h" void AnnotationItemResizerTest::TestGrabHandle_Should_GrabHandle_When_ProvidedPointIsAtHandlePosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); MockZoomValueProvider zoomValueProvider; AnnotationItemResizer itemResizer(&lineItem, &zoomValueProvider); itemResizer.grabHandle(p1 + QPointF(2, 2)); auto isResizing = itemResizer.isResizing(); QCOMPARE(isResizing, true); } void AnnotationItemResizerTest::TestGrabHandle_Should_NotGrabHandle_When_ProvidedPointIsNotAtHandlePosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); MockZoomValueProvider zoomValueProvider; AnnotationItemResizer itemResizer(&lineItem, &zoomValueProvider); itemResizer.grabHandle(QPointF(0, 0)); auto isResizing = itemResizer.isResizing(); QCOMPARE(isResizing, false); } void AnnotationItemResizerTest::TestGrabHandle_Should_MoveResizeHandle_When_HandleGrabbed() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); QPointF p3(30, 30); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); MockZoomValueProvider zoomValueProvider; AnnotationItemResizer itemResizer(&lineItem, &zoomValueProvider); QUndoStack undoStack; connect(&itemResizer, &AnnotationItemResizer::newCommand, &undoStack, &QUndoStack::push); itemResizer.grabHandle(p1); itemResizer.moveHandle(p3, false); QCOMPARE(lineItem.line().p1(), p3); } void AnnotationItemResizerTest::TestReleaseHandle_Should_ReleaseHandle() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); MockZoomValueProvider zoomValueProvider; AnnotationItemResizer itemResizer(&lineItem, &zoomValueProvider); itemResizer.grabHandle(p1); QCOMPARE(itemResizer.isResizing(), true); itemResizer.releaseHandle(); QCOMPARE(itemResizer.isResizing(), false); } void AnnotationItemResizerTest::TestIsItemVisible_Should_ReturnFalse_When_ItemIsHidden() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); MockZoomValueProvider zoomValueProvider; AnnotationItemResizer itemResizer(&lineItem, &zoomValueProvider); lineItem.hide(); auto result = itemResizer.isItemVisible(); QCOMPARE(result, false); } TEST_MAIN(AnnotationItemResizerTest); kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemResizerTest.h000066400000000000000000000033221440330760000275640ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMRESIZERTEST_H #define KIMAGEANNOTATOR_ANNOTATIONITEMRESIZERTEST_H #include #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/AnnotationItemResizer.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::AnnotationItemResizer; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationLine; using kImageAnnotator::PropertiesPtr; class AnnotationItemResizerTest : public QObject { Q_OBJECT private slots: void TestGrabHandle_Should_GrabHandle_When_ProvidedPointIsAtHandlePosition(); void TestGrabHandle_Should_NotGrabHandle_When_ProvidedPointIsNotAtHandlePosition(); void TestGrabHandle_Should_MoveResizeHandle_When_HandleGrabbed(); void TestReleaseHandle_Should_ReleaseHandle(); void TestIsItemVisible_Should_ReturnFalse_When_ItemIsHidden(); }; #endif // KIMAGEANNOTATOR_ANNOTATIONITEMRESIZERTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemSelectorTest.cpp000066400000000000000000000351731440330760000302650ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationItemSelectorTest.h" #include "tests/mocks/MockZoomValueProvider.h" void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_SelectItem_When_ItemUnderProvidedPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(0, 5), &items, false); auto results = selector.selectedItems(); QCOMPARE(results.count(), 1); QCOMPARE(results.first(), &line); } void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_NotSelectItem_When_ItemNotUnderProvidedPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(0, -5), &items, false); auto results = selector.selectedItems(); QCOMPARE(results.count(), 0); QCOMPARE(results.contains(&line), false); } void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_UnselectAllItems_When_ProvidedPositionNotOverAnyItem() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(15, 15); QPointF p4(20, 20); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(-5, -5), &items, false); selector.extendSelectionRectWhenShown(p4 + QPointF(5, 5)); selector.finishSelectionRectWhenShown(&items); QCOMPARE(selector.selectedItems().count(), 2); selector.handleSelectionOrShowSelectionRectAt(QPointF(0, 0), &items, false); auto results = selector.selectedItems(); QCOMPARE(results.count(), 0); } void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_NotUnselectAnyItem_When_ProvidedPositionIsOverSelectedItem() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(15, 15); QPointF p4(20, 20); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(-5, -5), &items, false); selector.extendSelectionRectWhenShown(p4 + QPointF(5, 5)); selector.finishSelectionRectWhenShown(&items); QCOMPARE(selector.selectedItems().count(), 2); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(0, 5), &items, false); auto results = selector.selectedItems(); QCOMPARE(results.count(), 2); } void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_UnselectItemsNotUnderPosition_When_ProvidedPositionIsOverNotSelectedItem() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(12, 12); QPointF p3(15, 15); QPointF p4(20, 20); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(-5, -5), &items, false); selector.extendSelectionRectWhenShown(p2 + QPointF(1, 1)); selector.finishSelectionRectWhenShown(&items); QCOMPARE(selector.selectedItems().count(), 1); QCOMPARE(selector.selectedItems().contains(&line1), true); QCOMPARE(selector.selectedItems().contains(&line2), false); selector.handleSelectionOrShowSelectionRectAt(p3 + QPointF(2, 2), &items, false); auto results = selector.selectedItems(); QCOMPARE(results.count(), 1); QCOMPARE(results.contains(&line1), false); QCOMPARE(results.contains(&line2), true); } void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_NotShowRect_When_InitialPositionNotOnItem() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(QPointF(2, 2), &items, false); QCOMPARE(selector.selectedItems().count(), 0); QCOMPARE(selector.isSelecting(), true); } void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_ShowRect_When_InitialPositionOnItem() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(0, 5), &items, false); QCOMPARE(selector.selectedItems().count(), 1); QCOMPARE(selector.isSelecting(), false); } void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_UnselectItem_When_WhenCtrlPressedAndItemUnderProvidedPositionWasSelected() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(10, 20); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1, &items, false); QCOMPARE(selector.selectedItems().first(), &line); selector.handleSelectionOrShowSelectionRectAt(p1, &items, true); auto results = selector.selectedItems(); QCOMPARE(results.count(), 0); } void AnnotationItemSelectorTest::TestHandleSelectionRectAt_Should_SelectItem_When_WhenCtrlPressedAndItemUnderProvidedPositionWasNotSelected() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(10, 20); AnnotationLine line(p1, properties); line.addPoint(p2, false); QList items; items.append(&line); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); QCOMPARE(selector.selectedItems().count(), 0); selector.handleSelectionOrShowSelectionRectAt(p1, &items, true); auto results = selector.selectedItems(); QCOMPARE(results.count(), 1); QCOMPARE(results.first(), &line); } void AnnotationItemSelectorTest::TestFinishSelectionRectWhenShown_Should_SelectItems_When_ItemsWithinSelectionRect() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(15, 15); QPointF p4(20, 20); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(-5, -5), &items, false); selector.extendSelectionRectWhenShown(p4 + QPointF(5, 5)); selector.finishSelectionRectWhenShown(&items); auto results = selector.selectedItems(); QCOMPARE(results.count(), 2); QCOMPARE(results.contains(&line1), true); QCOMPARE(results.contains(&line2), true); } void AnnotationItemSelectorTest::TestFinishSelectionRectWhenShown_Should_SelectOnlyItemWithinSelectionRect() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(25, 25); QPointF p4(30, 30); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(-5, -5), &items, false); selector.extendSelectionRectWhenShown(p2 + QPointF(5, 5)); selector.finishSelectionRectWhenShown(&items); auto results = selector.selectedItems(); QCOMPARE(results.count(), 1); QCOMPARE(results.contains(&line1), true); QCOMPARE(results.contains(&line2), false); } void AnnotationItemSelectorTest::TestClearSelection_Should_UnselectAllSelectedItems() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(15, 15); QPointF p4(20, 20); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(-5, -5), &items, false); selector.extendSelectionRectWhenShown(p4 + QPointF(5, 5)); selector.finishSelectionRectWhenShown(&items); QCOMPARE(selector.selectedItems().count(), 2); QCOMPARE(selector.selectedItems().contains(&line1), true); QCOMPARE(selector.selectedItems().contains(&line2), true); selector.clearSelection(); auto results = selector.selectedItems(); QCOMPARE(results.count(), 0); } void AnnotationItemSelectorTest::TestBoundRect_Should_ReturnRectCoveringSelectedItems_When_ItemsSelected() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(25, 25); QPointF p4(30, 30); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(-5, -5), &items, false); selector.extendSelectionRectWhenShown(p4); selector.finishSelectionRectWhenShown(&items); auto boundingRect = selector.boundingRect(); auto results = selector.selectedItems(); QCOMPARE(results.count(), 2); QCOMPARE(results.contains(&line1), true); QCOMPARE(results.contains(&line2), true); QCOMPARE(boundingRect, line1.boundingRect().united(line2.boundingRect())); } void AnnotationItemSelectorTest::TestRefresh_Should_UpdateBoundingRect_When_CalledAfterItemsHaveBeenMoved() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(25, 25); QPointF p4(30, 30); QPointF p5(50, 50); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(p1 + QPointF(-5, -5), &items, false); selector.extendSelectionRectWhenShown(p4); selector.finishSelectionRectWhenShown(&items); line1.setPosition(p5); QVERIFY(selector.boundingRect() != line1.boundingRect().united(line2.boundingRect())); selector.refresh(); auto boundingRect = selector.boundingRect(); auto results = selector.selectedItems(); QCOMPARE(results.count(), 2); QCOMPARE(results.contains(&line1), true); QCOMPARE(results.contains(&line2), true); QCOMPARE(boundingRect, line1.boundingRect().united(line2.boundingRect())); } void AnnotationItemSelectorTest::TestUpdate_Should_UnselectItemsThatAreNotVisible() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 3)); QPointF p1(10, 10); QPointF p2(10, 20); QPointF p3(25, 25); QPointF p4(30, 30); AnnotationLine line1(p1, properties1); AnnotationLine line2(p3, properties2); line1.addPoint(p2, false); line2.addPoint(p4, false); QList items; items.append(&line1); items.append(&line2); MockZoomValueProvider zoomValueProvider; AnnotationItemSelector selector(&zoomValueProvider); selector.handleSelectionOrShowSelectionRectAt(QPointF(0, 0), &items, false); selector.extendSelectionRectWhenShown(p4); selector.finishSelectionRectWhenShown(&items); QCOMPARE(selector.selectedItems().count(), 2); line2.hide(); selector.update(); auto results = selector.selectedItems(); QCOMPARE(results.count(), 1); QCOMPARE(results.contains(&line1), true); QCOMPARE(results.contains(&line2), false); } TEST_MAIN(AnnotationItemSelectorTest); kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationItemSelectorTest.h000066400000000000000000000053161440330760000277260ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONITEMSELECTORTEST_H #define KIMAGEANNOTATOR_ANNOTATIONITEMSELECTORTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/AnnotationItemSelector.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::AnnotationItemSelector; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class AnnotationItemSelectorTest : public QObject { Q_OBJECT private slots: void TestHandleSelectionRectAt_Should_SelectItem_When_ItemUnderProvidedPosition(); void TestHandleSelectionRectAt_Should_NotSelectItem_When_ItemNotUnderProvidedPosition(); void TestHandleSelectionRectAt_Should_UnselectAllItems_When_ProvidedPositionNotOverAnyItem(); void TestHandleSelectionRectAt_Should_NotUnselectAnyItem_When_ProvidedPositionIsOverSelectedItem(); void TestHandleSelectionRectAt_Should_UnselectItemsNotUnderPosition_When_ProvidedPositionIsOverNotSelectedItem(); void TestHandleSelectionRectAt_Should_NotShowRect_When_InitialPositionNotOnItem(); void TestHandleSelectionRectAt_Should_ShowRect_When_InitialPositionOnItem(); void TestHandleSelectionRectAt_Should_UnselectItem_When_WhenCtrlPressedAndItemUnderProvidedPositionWasSelected(); void TestHandleSelectionRectAt_Should_SelectItem_When_WhenCtrlPressedAndItemUnderProvidedPositionWasNotSelected(); void TestFinishSelectionRectWhenShown_Should_SelectItems_When_ItemsWithinSelectionRect(); void TestFinishSelectionRectWhenShown_Should_SelectOnlyItemWithinSelectionRect(); void TestClearSelection_Should_UnselectAllSelectedItems(); void TestBoundRect_Should_ReturnRectCoveringSelectedItems_When_ItemsSelected(); void TestRefresh_Should_UpdateBoundingRect_When_CalledAfterItemsHaveBeenMoved(); void TestUpdate_Should_UnselectItemsThatAreNotVisible(); }; #endif // KIMAGEANNOTATOR_ANNOTATIONITEMSELECTORTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationMultiItemResizerTest.cpp000066400000000000000000000136021440330760000311340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationMultiItemResizerTest.h" #include "tests/mocks/MockZoomValueProvider.h" void AnnotationMultiItemResizerTest::TestGrabHandle_Should_GrabHandle_When_ProvidedPointIsAtHandlePosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); AnnotationLine item1(line1.p1(), properties); item1.addPoint(line1.p2(), false); QList items = { &item1 }; MockZoomValueProvider zoomValueProvider; AnnotationMultiItemResizer itemResizer(&zoomValueProvider); itemResizer.attachTo(items); itemResizer.grabHandle(line1.p1()); QCOMPARE(itemResizer.isResizing(), true); } void AnnotationMultiItemResizerTest::TestGrabHandle_Should_NotGrabHandle_When_ProvidedPointIsNotAtHandlePosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); AnnotationLine item1(line1.p1(), properties); item1.addPoint(line1.p2(), false); QList items = { &item1 }; MockZoomValueProvider zoomValueProvider; AnnotationMultiItemResizer itemResizer(&zoomValueProvider); itemResizer.attachTo(items); itemResizer.grabHandle(line1.p1() + QPointF(-10, -10)); QCOMPARE(itemResizer.isResizing(), false); } void AnnotationMultiItemResizerTest::TestGrabHandle_Should_MoveResizeHandle_When_HandleGrabbed() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); QPointF newPoint(30, 30); AnnotationLine item1(line1.p1(), properties); item1.addPoint(line1.p2(), false); QList items = { &item1 }; MockZoomValueProvider zoomValueProvider; AnnotationMultiItemResizer itemResizer(&zoomValueProvider); QUndoStack undoStack; connect(&itemResizer, &AnnotationMultiItemResizer::newCommand, &undoStack, &QUndoStack::push); itemResizer.attachTo(items); itemResizer.grabHandle(line1.p1()); itemResizer.moveHandle(newPoint, false); QCOMPARE(item1.line().p1(), newPoint); } void AnnotationMultiItemResizerTest::TestGrabHandle_Should_OnlyMoveOneResizeHandle_When_MultipleItemsInList() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); QPointF newPoint(30, 30); AnnotationLine item1(line1.p1(), properties1); AnnotationLine item2(line1.p1(), properties2); item1.addPoint(line1.p2(), false); item2.addPoint(line1.p2(), false); QList items = { &item1, &item2 }; MockZoomValueProvider zoomValueProvider; AnnotationMultiItemResizer itemResizer(&zoomValueProvider); QUndoStack undoStack; connect(&itemResizer, &AnnotationMultiItemResizer::newCommand, &undoStack, &QUndoStack::push); itemResizer.attachTo(items); itemResizer.grabHandle(line1.p1()); itemResizer.moveHandle(newPoint, false); QCOMPARE(item1.line().p1(), newPoint); QCOMPARE(item1.line().p2(), line1.p2()); QCOMPARE(item2.line().p1(), line1.p1()); QCOMPARE(item2.line().p2(), line1.p2()); } void AnnotationMultiItemResizerTest::TestReleaseHandle_Should_ReleaseHandle() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); AnnotationLine item1(line1.p1(), properties); item1.addPoint(line1.p2(), false); QList items = { &item1 }; MockZoomValueProvider zoomValueProvider; AnnotationMultiItemResizer itemResizer(&zoomValueProvider); itemResizer.attachTo(items); itemResizer.grabHandle(line1.p1()); QCOMPARE(itemResizer.isResizing(), true); itemResizer.releaseHandle(); QCOMPARE(itemResizer.isResizing(), false); } void AnnotationMultiItemResizerTest::TestHasItemsAttached_Should_ReturnFalse_When_NoItemsInList() { QList items; MockZoomValueProvider zoomValueProvider; AnnotationMultiItemResizer itemResizer(&zoomValueProvider); itemResizer.attachTo(items); auto result = itemResizer.hasItemsAttached(); QCOMPARE(result, false); } void AnnotationMultiItemResizerTest::TestHasItemsAttached_Should_ReturnTrue_When_ItemsInList() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); AnnotationLine item1(line1.p1(), properties); item1.addPoint(line1.p2(), false); QList items = { &item1 }; MockZoomValueProvider zoomValueProvider; AnnotationMultiItemResizer itemResizer(&zoomValueProvider); itemResizer.attachTo(items); auto result = itemResizer.hasItemsAttached(); QCOMPARE(result, true); } void AnnotationMultiItemResizerTest::TestUpdate_Should_HideResizers_When_ItemsOfResizersNotVisible() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); AnnotationLine item1(line1.p1(), properties); item1.addPoint(line1.p2(), false); QList items = { &item1 }; MockZoomValueProvider zoomValueProvider; AnnotationMultiItemResizer itemResizer(&zoomValueProvider); itemResizer.attachTo(items); QCOMPARE(itemResizer.hasItemsAttached(), true); item1.hide(); itemResizer.update(); QCOMPARE(itemResizer.hasItemsAttached(), false); } TEST_MAIN(AnnotationMultiItemResizerTest); kImageAnnotator-0.6.1/tests/annotations/modifiers/AnnotationMultiItemResizerTest.h000066400000000000000000000037721440330760000306100ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONMULTIITEMRESIZERTEST_H #define KIMAGEANNOTATOR_ANNOTATIONMULTIITEMRESIZERTEST_H #include #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/AnnotationMultiItemResizer.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::AnnotationMultiItemResizer; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class AnnotationMultiItemResizerTest : public QObject { Q_OBJECT private slots: void TestGrabHandle_Should_GrabHandle_When_ProvidedPointIsAtHandlePosition(); void TestGrabHandle_Should_NotGrabHandle_When_ProvidedPointIsNotAtHandlePosition(); void TestGrabHandle_Should_MoveResizeHandle_When_HandleGrabbed(); void TestGrabHandle_Should_OnlyMoveOneResizeHandle_When_MultipleItemsInList(); void TestReleaseHandle_Should_ReleaseHandle(); void TestHasItemsAttached_Should_ReturnFalse_When_NoItemsInList(); void TestHasItemsAttached_Should_ReturnTrue_When_ItemsInList(); void TestUpdate_Should_HideResizers_When_ItemsOfResizersNotVisible(); }; #endif // KIMAGEANNOTATOR_ANNOTATIONMULTIITEMRESIZERTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/resizeHandles/000077500000000000000000000000001440330760000250565ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/annotations/modifiers/resizeHandles/LineResizeHandlesTest.cpp000066400000000000000000000115471440330760000320020ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "LineResizeHandlesTest.h" void LineResizeHandlesTest::TestInitHandles_Should_PositionTwoHandles() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); LineResizeHandles lineResizeHandles(&lineItem, 1.0); QCOMPARE(lineResizeHandles.handles().count(), 2); QCOMPARE(lineResizeHandles.handles()[0].anchor(), p1); QCOMPARE(lineResizeHandles.handles()[1].anchor(), p2); } void LineResizeHandlesTest::TestIndexOfHandleAt_Should_ReturnIndexOfHandle_When_HandleIsAtProvidedPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); LineResizeHandles lineResizeHandles(&lineItem, 1.0); auto resultP1 = lineResizeHandles.indexOfHandleAt(p1 + QPointF(2, 2)); auto resultP2 = lineResizeHandles.indexOfHandleAt(p2 + QPointF(-2, -2)); QCOMPARE(lineResizeHandles.handles().count(), 2); QCOMPARE(resultP1, 0); QCOMPARE(resultP2, 1); } void LineResizeHandlesTest::TestIndexOfHandleAt_Should_NotReturnAnyIndex_When_HandleIsNotAtProvidedPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); LineResizeHandles lineResizeHandles(&lineItem, 1.0); auto resultP1 = lineResizeHandles.indexOfHandleAt(QPointF(50, 50)); QCOMPARE(lineResizeHandles.handles().count(), 2); QCOMPARE(resultP1, -1); } void LineResizeHandlesTest::TestHandle_Should_ReturnRectAtIndex_When_HandleAtIndexExists() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); LineResizeHandles lineResizeHandles(&lineItem, 1.0); auto result = lineResizeHandles.handle(1); QVERIFY(result != QRectF()); QCOMPARE(result.anchor(), p2); } void LineResizeHandlesTest::TestHandle_Should_NotReturnRect_When_HandleAtIndexDoesntExists() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); LineResizeHandles lineResizeHandles(&lineItem, 1.0); auto result = lineResizeHandles.handle(3); QCOMPARE(result, ResizeHandle()); } void LineResizeHandlesTest::TestGetCursorForHandle_Should_NotReturnDefaultCursor_When_ProvidedPositionOnHandle() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(20, 20); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); LineResizeHandles lineResizeHandles(&lineItem, 1.0); auto result = lineResizeHandles.cursorForPos(p1); QVERIFY(result != CursorHelper::defaultCursor()); } void LineResizeHandlesTest::TestGetCursorForHandle_Should_ReturnDefaultCursor_When_ProvidedPositionNotOnHandle() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(20, 20); QPointF p3(50, 50); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); LineResizeHandles lineResizeHandles(&lineItem, 1.0); auto result = lineResizeHandles.cursorForPos(p3); QCOMPARE(result, CursorHelper::defaultCursor()); } void LineResizeHandlesTest::TestUpdate_Should_SetMoveHandlesToNewPositions() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF p1(10, 10); QPointF p2(20, 20); QPointF p3(50, 50); QPointF p4(60, 60); AnnotationLine lineItem(p1, properties); lineItem.addPoint(p2, false); LineResizeHandles lineResizeHandles(&lineItem, 1.0); QCOMPARE(lineResizeHandles.handles()[0].center(), p1); QCOMPARE(lineResizeHandles.handles()[1].center(), p2); lineItem.setPointAt(p3, 0, false); lineItem.setPointAt(p4, 1, false); lineResizeHandles.update(); QCOMPARE(lineResizeHandles.handles()[0].center(), p3); QCOMPARE(lineResizeHandles.handles()[1].center(), p4); } TEST_MAIN(LineResizeHandlesTest); kImageAnnotator-0.6.1/tests/annotations/modifiers/resizeHandles/LineResizeHandlesTest.h000066400000000000000000000040631440330760000314420ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_LINERESIZEHANDLESTEST_H #define KIMAGEANNOTATOR_LINERESIZEHANDLESTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/resizeHandles/LineResizeHandles.h" #include "src/annotations/items/AnnotationLine.h" #include "src/common/helper/CursorHelper.h" using kImageAnnotator::LineResizeHandles; using kImageAnnotator::CursorHelper; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::ResizeHandle; using kImageAnnotator::PropertiesPtr; class LineResizeHandlesTest : public QObject { Q_OBJECT private slots: void TestInitHandles_Should_PositionTwoHandles(); void TestIndexOfHandleAt_Should_ReturnIndexOfHandle_When_HandleIsAtProvidedPosition(); void TestIndexOfHandleAt_Should_NotReturnAnyIndex_When_HandleIsNotAtProvidedPosition(); void TestHandle_Should_ReturnRectAtIndex_When_HandleAtIndexExists(); void TestHandle_Should_NotReturnRect_When_HandleAtIndexDoesntExists(); void TestGetCursorForHandle_Should_NotReturnDefaultCursor_When_ProvidedPositionOnHandle(); void TestGetCursorForHandle_Should_ReturnDefaultCursor_When_ProvidedPositionNotOnHandle(); void TestUpdate_Should_SetMoveHandlesToNewPositions(); }; #endif // KIMAGEANNOTATOR_LINERESIZEHANDLESTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/resizeHandles/PointerRectResizeHandlesTest.cpp000066400000000000000000000122301440330760000333370ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "PointerRectResizeHandlesTest.h" void PointerRectResizeHandlesTest::TestInitHandles_Should_PositionPointerHandle_When_PointerRectItemProvided() { auto properties = TextPropertiesPtr(new AnnotationTextProperties(Qt::red, 4)); QPointF startPosition(10,10); QPointF pointerPosition(50,50); AnnotationNumberPointer rectItem(startPosition, properties); rectItem.addPoint(pointerPosition, false); PointerRectResizeHandles resizeHandles(&rectItem, 1.0); QCOMPARE(resizeHandles.handles()[8].anchor(), pointerPosition); } void PointerRectResizeHandlesTest::TestIndexOfHandleAt_Should_ReturnIndexOfPointerHandle_When_HandleIsAtProvidedPosition() { auto properties = TextPropertiesPtr(new AnnotationTextProperties(Qt::red, 4)); QPointF startPosition(10,10); QPointF pointerPosition(50,50); AnnotationNumberPointer rectItem(startPosition, properties); rectItem.addPoint(pointerPosition, false); PointerRectResizeHandles resizeHandles(&rectItem, 1.0); auto result = resizeHandles.indexOfHandleAt(pointerPosition + QPointF(2, 2)); QCOMPARE(resizeHandles.handles().count(), 9); QCOMPARE(result, 8); } void PointerRectResizeHandlesTest::TestIndexOfHandleAt_Should_NotReturnAnyIndex_When_HandleIsNotAtProvidedPosition() { auto properties = TextPropertiesPtr(new AnnotationTextProperties(Qt::red, 4)); QPointF startPosition(10,10); QPointF pointerPosition(50,50); AnnotationNumberPointer rectItem(startPosition, properties); rectItem.addPoint(pointerPosition, false); PointerRectResizeHandles resizeHandles(&rectItem, 1.0); auto result = resizeHandles.indexOfHandleAt(QPointF(100, 100)); QCOMPARE(resizeHandles.handles().count(), 9); QCOMPARE(result, -1); } void PointerRectResizeHandlesTest::TestHandle_Should_ReturnPointerRectAtIndex_When_HandleAtIndexExists() { auto properties = TextPropertiesPtr(new AnnotationTextProperties(Qt::red, 4)); QPointF startPosition(10,10); QPointF pointerPosition(50,50); AnnotationNumberPointer rectItem(startPosition, properties); rectItem.addPoint(pointerPosition, false); PointerRectResizeHandles resizeHandles(&rectItem, 1.0); auto result = resizeHandles.handle(8); QVERIFY(result != QRectF()); QCOMPARE(result.anchor(), pointerPosition); } void PointerRectResizeHandlesTest::TestHandle_Should_NotReturnRect_When_HandleAtIndexDoesntExists() { auto properties = TextPropertiesPtr(new AnnotationTextProperties(Qt::red, 4)); QPointF startPosition(10,10); QPointF pointerPosition(50,50); AnnotationNumberPointer rectItem(startPosition, properties); rectItem.addPoint(pointerPosition, false); PointerRectResizeHandles resizeHandles(&rectItem, 1.0); auto result = resizeHandles.handle(10); QCOMPARE(result, ResizeHandle()); } void PointerRectResizeHandlesTest::TestGetCursorForHandle_Should_NotReturnDefaultCursor_When_ProvidedPositionOnHandle() { auto properties = TextPropertiesPtr(new AnnotationTextProperties(Qt::red, 4)); QPointF startPosition(10,10); QPointF pointerPosition(50,50); AnnotationNumberPointer rectItem(startPosition, properties); rectItem.addPoint(pointerPosition, false); PointerRectResizeHandles resizeHandles(&rectItem, 1.0); auto result = resizeHandles.cursorForPos(pointerPosition); QVERIFY(result != CursorHelper::defaultCursor()); } void PointerRectResizeHandlesTest::TestGetCursorForHandle_Should_ReturnDefaultCursor_When_ProvidedPositionNotOnHandle() { auto properties = TextPropertiesPtr(new AnnotationTextProperties(Qt::red, 4)); QPointF startPosition(10,10); QPointF pointerPosition(50,50); AnnotationNumberPointer rectItem(startPosition, properties); rectItem.addPoint(pointerPosition, false); PointerRectResizeHandles resizeHandles(&rectItem, 1.0); auto result = resizeHandles.cursorForPos(QPointF(100,100)); QCOMPARE(result, CursorHelper::defaultCursor()); } void PointerRectResizeHandlesTest::TestUpdate_Should_MovePointerHandlesToNewPosition() { auto properties = TextPropertiesPtr(new AnnotationTextProperties(Qt::red, 4)); QPointF startPosition(10,10); QPointF pointerPosition(50,50); QPointF newPointerPosition(80,80); AnnotationNumberPointer rectItem(startPosition, properties); rectItem.addPoint(pointerPosition, false); PointerRectResizeHandles resizeHandles(&rectItem, 1.0); QCOMPARE(resizeHandles.handles()[8].anchor(), pointerPosition); rectItem.addPoint(newPointerPosition, false); resizeHandles.update(); QCOMPARE(resizeHandles.handles()[8].anchor(), newPointerPosition); } TEST_MAIN(PointerRectResizeHandlesTest) kImageAnnotator-0.6.1/tests/annotations/modifiers/resizeHandles/PointerRectResizeHandlesTest.h000066400000000000000000000043541440330760000330140ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_POINTERRECTRESIZEHANDLESTEST_H #define KIMAGEANNOTATOR_POINTERRECTRESIZEHANDLESTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/resizeHandles/PointerRectResizeHandles.h" #include "src/annotations/items/AnnotationNumberPointer.h" #include "src/common/helper/CursorHelper.h" using kImageAnnotator::PointerRectResizeHandles; using kImageAnnotator::AnnotationNumberPointer; using kImageAnnotator::AnnotationTextProperties; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::CursorHelper; using kImageAnnotator::ShapeHelper; using kImageAnnotator::ResizeHandle; using kImageAnnotator::TextPropertiesPtr; class PointerRectResizeHandlesTest : public QObject { Q_OBJECT private slots: void TestInitHandles_Should_PositionPointerHandle_When_PointerRectItemProvided(); void TestIndexOfHandleAt_Should_ReturnIndexOfPointerHandle_When_HandleIsAtProvidedPosition(); void TestIndexOfHandleAt_Should_NotReturnAnyIndex_When_HandleIsNotAtProvidedPosition(); void TestHandle_Should_ReturnPointerRectAtIndex_When_HandleAtIndexExists(); void TestHandle_Should_NotReturnRect_When_HandleAtIndexDoesntExists(); void TestGetCursorForHandle_Should_NotReturnDefaultCursor_When_ProvidedPositionOnHandle(); void TestGetCursorForHandle_Should_ReturnDefaultCursor_When_ProvidedPositionNotOnHandle(); void TestUpdate_Should_MovePointerHandlesToNewPosition(); }; #endif //KIMAGEANNOTATOR_POINTERRECTRESIZEHANDLESTEST_H kImageAnnotator-0.6.1/tests/annotations/modifiers/resizeHandles/RectResizeHandlesTest.cpp000066400000000000000000000167301440330760000320070ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "RectResizeHandlesTest.h" void RectResizeHandlesTest::TestInitHandles_Should_PositionEightHandles_When_RectItemProvided() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 4)); QRectF rect(QPointF(10, 15), QPointF(20, 25)); AnnotationRect rectItem(rect.topLeft(), properties); rectItem.addPoint(rect.bottomRight(), false); RectResizeHandles rectResizeHandles(&rectItem, 1.0); QCOMPARE(rectResizeHandles.handles().count(), 8); QCOMPARE(rectResizeHandles.handles()[0].anchor(), rect.topLeft()); QCOMPARE(rectResizeHandles.handles()[1].anchor(), QPointF(rect.center().x(), rect.top())); QCOMPARE(rectResizeHandles.handles()[2].anchor(), rect.topRight()); QCOMPARE(rectResizeHandles.handles()[3].anchor(), QPointF(rect.right(), rect.center().y())); QCOMPARE(rectResizeHandles.handles()[4].anchor(), rect.bottomRight()); QCOMPARE(rectResizeHandles.handles()[5].anchor(), QPointF(rect.center().x(), rect.bottom())); QCOMPARE(rectResizeHandles.handles()[6].anchor(), rect.bottomLeft()); QCOMPARE(rectResizeHandles.handles()[7].anchor(), QPointF(rect.left(), rect.center().y())); } void RectResizeHandlesTest::TestIndexOfHandleAt_Should_ReturnIndexOfHandle_When_HandleIsAtProvidedPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QRectF rect(QPointF(10, 15), QPointF(80, 95)); AnnotationRect rectItem(rect.topLeft(), properties); rectItem.addPoint(rect.bottomRight(), false); RectResizeHandles rectResizeHandles(&rectItem, 1.0); auto resultP1 = rectResizeHandles.indexOfHandleAt(rect.topLeft() + QPointF(2, 2)); auto resultP2 = rectResizeHandles.indexOfHandleAt(ShapeHelper::rectTop(rect) + QPointF(-2, -2)); auto resultP3 = rectResizeHandles.indexOfHandleAt(rect.topRight() + QPointF(-2, -2)); auto resultP4 = rectResizeHandles.indexOfHandleAt(ShapeHelper::rectRight(rect) + QPointF(-2, -2)); auto resultP5 = rectResizeHandles.indexOfHandleAt(rect.bottomRight() + QPointF(-2, -2)); auto resultP6 = rectResizeHandles.indexOfHandleAt(ShapeHelper::rectBottom(rect) + QPointF(-2, -2)); auto resultP7 = rectResizeHandles.indexOfHandleAt(rect.bottomLeft() + QPointF(-2, -2)); auto resultP8 = rectResizeHandles.indexOfHandleAt(ShapeHelper::rectLeft(rect) + QPointF(-2, -2)); QCOMPARE(rectResizeHandles.handles().count(), 8); QCOMPARE(resultP1, 0); QCOMPARE(resultP2, 1); QCOMPARE(resultP3, 2); QCOMPARE(resultP4, 3); QCOMPARE(resultP5, 4); QCOMPARE(resultP6, 5); QCOMPARE(resultP7, 6); QCOMPARE(resultP8, 7); } void RectResizeHandlesTest::TestIndexOfHandleAt_Should_NotReturnAnyIndex_When_HandleIsNotAtProvidedPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QRectF rect(QPointF(10, 15), QPointF(20, 25)); AnnotationRect rectItem(rect.topLeft(), properties); rectItem.addPoint(rect.bottomRight(), false); RectResizeHandles rectResizeHandles(&rectItem, 1.0); auto resultP1 = rectResizeHandles.indexOfHandleAt(QPointF(50, 50)); QCOMPARE(rectResizeHandles.handles().count(), 8); QCOMPARE(resultP1, -1); } void RectResizeHandlesTest::TestHandle_Should_ReturnRectAtIndex_When_HandleAtIndexExists() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QRectF rect(QPointF(10, 15), QPointF(20, 25)); AnnotationRect rectItem(rect.topLeft(), properties); rectItem.addPoint(rect.bottomRight(), false); RectResizeHandles rectResizeHandles(&rectItem, 1.0); auto result = rectResizeHandles.handle(2); QVERIFY(result != QRectF()); QCOMPARE(result.anchor(), rect.topRight()); } void RectResizeHandlesTest::TestHandle_Should_NotReturnRect_When_HandleAtIndexDoesntExists() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QRectF rect(QPointF(10, 15), QPointF(20, 25)); AnnotationRect rectItem(rect.topLeft(), properties); rectItem.addPoint(rect.bottomRight(), false); RectResizeHandles rectResizeHandles(&rectItem, 1.0); auto result = rectResizeHandles.handle(10); QCOMPARE(result, ResizeHandle()); } void RectResizeHandlesTest::TestGetCursorForHandle_Should_NotReturnDefaultCursor_When_ProvidedPositionOnHandle() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QRectF rect(QPointF(10, 15), QPointF(20, 25)); AnnotationRect rectItem(rect.topLeft(), properties); rectItem.addPoint(rect.bottomRight(), false); RectResizeHandles rectResizeHandles(&rectItem, 1.0); auto result = rectResizeHandles.cursorForPos(rect.bottomLeft()); QVERIFY(result != CursorHelper::defaultCursor()); } void RectResizeHandlesTest::TestGetCursorForHandle_Should_ReturnDefaultCursor_When_ProvidedPositionNotOnHandle() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QRectF rect(QPointF(10, 15), QPointF(20, 25)); QPointF otherPos(90, 90); AnnotationRect rectItem(rect.topLeft(), properties); rectItem.addPoint(rect.bottomRight(), false); RectResizeHandles rectResizeHandles(&rectItem, 1.0); auto result = rectResizeHandles.cursorForPos(otherPos); QCOMPARE(result, CursorHelper::defaultCursor()); } void RectResizeHandlesTest::TestUpdate_Should_MoveHandlesToNewPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 2)); QRectF rect(QPointF(10, 15), QPointF(80, 95)); QRectF newRect(QPointF(60, 75), QPointF(120, 125)); AnnotationRect rectItem(rect.topLeft(), properties); rectItem.addPoint(rect.bottomRight(), false); RectResizeHandles rectResizeHandles(&rectItem, 1.0); QCOMPARE(rectResizeHandles.handles()[0].anchor(), rect.topLeft()); QCOMPARE(rectResizeHandles.handles()[1].anchor(), ShapeHelper::rectTop(rect)); QCOMPARE(rectResizeHandles.handles()[2].anchor(), rect.topRight()); QCOMPARE(rectResizeHandles.handles()[3].anchor(), ShapeHelper::rectRight(rect)); QCOMPARE(rectResizeHandles.handles()[4].anchor(), rect.bottomRight()); QCOMPARE(rectResizeHandles.handles()[5].anchor(), ShapeHelper::rectBottom(rect)); QCOMPARE(rectResizeHandles.handles()[6].anchor(), rect.bottomLeft()); QCOMPARE(rectResizeHandles.handles()[7].anchor(), ShapeHelper::rectLeft(rect)); rectItem.setPointAt(newRect.topLeft(), 0, false); rectItem.addPoint(newRect.bottomRight(), false); rectResizeHandles.update(); QCOMPARE(rectResizeHandles.handles()[0].anchor(), newRect.topLeft()); QCOMPARE(rectResizeHandles.handles()[1].anchor(), ShapeHelper::rectTop(newRect)); QCOMPARE(rectResizeHandles.handles()[2].anchor(), newRect.topRight()); QCOMPARE(rectResizeHandles.handles()[3].anchor(), ShapeHelper::rectRight(newRect)); QCOMPARE(rectResizeHandles.handles()[4].anchor(), newRect.bottomRight()); QCOMPARE(rectResizeHandles.handles()[5].anchor(), ShapeHelper::rectBottom(newRect)); QCOMPARE(rectResizeHandles.handles()[6].anchor(), newRect.bottomLeft()); QCOMPARE(rectResizeHandles.handles()[7].anchor(), ShapeHelper::rectLeft(newRect)); } TEST_MAIN(RectResizeHandlesTest); kImageAnnotator-0.6.1/tests/annotations/modifiers/resizeHandles/RectResizeHandlesTest.h000066400000000000000000000042311440330760000314450ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_RECTRESIZEHANDLESTEST_H #define KIMAGEANNOTATOR_RECTRESIZEHANDLESTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/modifiers/resizeHandles/RectResizeHandles.h" #include "src/annotations/items/AnnotationRect.h" #include "src/common/helper/CursorHelper.h" using kImageAnnotator::RectResizeHandles; using kImageAnnotator::AnnotationRect; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::CursorHelper; using kImageAnnotator::ShapeHelper; using kImageAnnotator::ResizeHandle; using kImageAnnotator::PropertiesPtr; class RectResizeHandlesTest : public QObject { Q_OBJECT private slots: void TestInitHandles_Should_PositionEightHandles_When_RectItemProvided(); void TestIndexOfHandleAt_Should_ReturnIndexOfHandle_When_HandleIsAtProvidedPosition(); void TestIndexOfHandleAt_Should_NotReturnAnyIndex_When_HandleIsNotAtProvidedPosition(); void TestHandle_Should_ReturnRectAtIndex_When_HandleAtIndexExists(); void TestHandle_Should_NotReturnRect_When_HandleAtIndexDoesntExists(); void TestGetCursorForHandle_Should_NotReturnDefaultCursor_When_ProvidedPositionOnHandle(); void TestGetCursorForHandle_Should_ReturnDefaultCursor_When_ProvidedPositionNotOnHandle(); void TestUpdate_Should_MoveHandlesToNewPosition(); }; #endif // KIMAGEANNOTATOR_RECTRESIZEHANDLESTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/000077500000000000000000000000001440330760000212425ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/annotations/undo/AddCommandTest.cpp000066400000000000000000000042701440330760000246000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AddCommandTest.h" #include "tests/mocks/MockDefaultParameters.h" void AddCommandTest::TestRedo_Should_ApplyOperation() { // arrange MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); AddCommand addCommand(item, &annotationArea); QCOMPARE(annotationArea.items().contains(item), false); // act addCommand.redo(); // arrange QCOMPARE(annotationArea.items().contains(item), true); } void AddCommandTest::TestUndo_Should_UndoOperation() { // arrange MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); AddCommand addCommand(item, &annotationArea); addCommand.redo(); QCOMPARE(annotationArea.items().contains(item), true); // act addCommand.undo(); // assert QCOMPARE(annotationArea.items().contains(item), false); } TEST_MAIN(AddCommandTest); kImageAnnotator-0.6.1/tests/annotations/undo/AddCommandTest.h000066400000000000000000000031061440330760000242420ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ADDCOMMANDTEST_H #define KIMAGEANNOTATOR_ADDCOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/AddCommand.h" #include "src/annotations/core/AnnotationArea.h" #include "src/annotations/items/AnnotationLine.h" #include "tests/mocks/MockSettingsProvider.h" #include "tests/mocks/MockDevicePixelRatioScaler.h" using kImageAnnotator::AddCommand; using kImageAnnotator::AnnotationArea; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::Config; using kImageAnnotator::PropertiesPtr; class AddCommandTest : public QObject { Q_OBJECT private slots: void TestRedo_Should_ApplyOperation(); void TestUndo_Should_UndoOperation(); }; #endif // KIMAGEANNOTATOR_ADDCOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/ArrangeCommandTest.cpp000066400000000000000000000106121440330760000254640ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ArrangeCommandTest.h" void ArrangeCommandTest::TestRedo_Should_SwapItemPosition() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF pos(10, 10); AnnotationLine item1(pos, properties1); AnnotationLine item2(pos, properties2); item1.setZValue(1); item2.setZValue(2); QList> itemToSwap; itemToSwap.append(qMakePair(&item1, &item2)); QList emptyItemList; ArrangeCommand arrangeCommand(itemToSwap, &emptyItemList); QCOMPARE((int) item1.zValue(), 1); QCOMPARE((int) item2.zValue(), 2); arrangeCommand.redo(); QCOMPARE((int) item1.zValue(), 2); QCOMPARE((int) item2.zValue(), 1); } void ArrangeCommandTest::TestRedo_Should_SortItemByZValue() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties3= PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF pos(10, 10); AnnotationLine item1(pos, properties1); AnnotationLine item2(pos, properties2); AnnotationLine item3(pos, properties3); item1.setZValue(1); item2.setZValue(2); item3.setZValue(3); QList> emptySwapList; QList allItems; allItems.append(&item2); allItems.append(&item1); allItems.append(&item3); ArrangeCommand arrangeCommand(emptySwapList, &allItems); QCOMPARE((int) allItems[0]->zValue(), 2); QCOMPARE((int) allItems[1]->zValue(), 1); QCOMPARE((int) allItems[2]->zValue(), 3); arrangeCommand.redo(); QCOMPARE((int) allItems[0]->zValue(), 3); QCOMPARE((int) allItems[1]->zValue(), 2); QCOMPARE((int) allItems[2]->zValue(), 1); } void ArrangeCommandTest::TestUndo_Should_SwapItemPositionBack() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF pos(10, 10); AnnotationLine item1(pos, properties1); AnnotationLine item2(pos, properties2); item1.setZValue(1); item2.setZValue(2); QList> itemToSwap; itemToSwap.append(qMakePair(&item1, &item2)); QList emptyItemList; ArrangeCommand arrangeCommand(itemToSwap, &emptyItemList); arrangeCommand.redo(); QCOMPARE((int) item1.zValue(), 2); QCOMPARE((int) item2.zValue(), 1); arrangeCommand.redo(); QCOMPARE((int) item1.zValue(), 1); QCOMPARE((int) item2.zValue(), 2); } void ArrangeCommandTest::TestUndo_Should_SortItemByZValue() { auto properties1 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties2 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto properties3 = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QPointF pos(10, 10); AnnotationLine item1(pos, properties1); AnnotationLine item2(pos, properties2); AnnotationLine item3(pos, properties3); item1.setZValue(1); item2.setZValue(2); item3.setZValue(3); QList> emptySwapList; QList allItems; allItems.append(&item2); allItems.append(&item1); allItems.append(&item3); ArrangeCommand arrangeCommand(emptySwapList, &allItems); QCOMPARE((int) allItems[0]->zValue(), 2); QCOMPARE((int) allItems[1]->zValue(), 1); QCOMPARE((int) allItems[2]->zValue(), 3); arrangeCommand.undo(); QCOMPARE((int) allItems[0]->zValue(), 3); QCOMPARE((int) allItems[1]->zValue(), 2); QCOMPARE((int) allItems[2]->zValue(), 1); } TEST_MAIN(ArrangeCommandTest); kImageAnnotator-0.6.1/tests/annotations/undo/ArrangeCommandTest.h000066400000000000000000000030231440330760000251270ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGETANNOTATOR_ARRANGECOMMANDTEST_H #define KIMAGETANNOTATOR_ARRANGECOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/ArrangeCommand.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::ArrangeCommand; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class ArrangeCommandTest : public QObject { Q_OBJECT private slots: void TestRedo_Should_SwapItemPosition(); void TestRedo_Should_SortItemByZValue(); void TestUndo_Should_SwapItemPositionBack(); void TestUndo_Should_SortItemByZValue(); }; #endif //KIMAGETANNOTATOR_ARRANGECOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/CropCommandTest.cpp000066400000000000000000000076421440330760000250210ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CropCommandTest.h" void CropCommandTest::TestRedo_Should_CropImageAndScene() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); QPixmap image(400, 400); QGraphicsPixmapItem graphicsPixmapItem(image); QRectF cropRect(100, 100, 200, 200); CropCommand cropCommand(&graphicsPixmapItem, cropRect, &annotationArea); // act cropCommand.redo(); // assert QCOMPARE(annotationArea.sceneRect().size(), cropRect.size()); QCOMPARE(graphicsPixmapItem.boundingRect().size(), cropRect.size()); } void CropCommandTest::TestRedo_Should_MoveItemToNewPosition() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); QPixmap image(400, 400); QGraphicsPixmapItem graphicsPixmapItem(image); QRectF cropRect(100, 100, 200, 200); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QRectF rect(150, 150, 300, 300); auto item = new AnnotationRect(rect.topLeft(), properties); item->addPoint(rect.bottomRight(), false); annotationArea.addAnnotationItem(item); CropCommand cropCommand(&graphicsPixmapItem, cropRect, &annotationArea); // act cropCommand.redo(); // assert QCOMPARE(item->position(), QPointF(50, 50)); QCOMPARE(item->boundingRect().size(), rect.size()); } void CropCommandTest::TestUndo_Should_RestoreOriginalImageAndSceneSize() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); QPixmap image(400, 400); QGraphicsPixmapItem graphicsPixmapItem(image); QRectF cropRect(100, 100, 200, 200); CropCommand cropCommand(&graphicsPixmapItem, cropRect, &annotationArea); cropCommand.redo(); // act cropCommand.undo(); // assert QVERIFY(annotationArea.sceneRect().size() == image.size()); QVERIFY(graphicsPixmapItem.boundingRect().size() == image.size()); } void CropCommandTest::TestUndo_Should_MoveItemBackToPreviousPosition() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); QPixmap image(400, 400); QGraphicsPixmapItem graphicsPixmapItem(image); QRectF cropRect(100, 100, 200, 200); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QRectF rect(150, 150, 300, 300); auto item = new AnnotationRect(rect.topLeft(), properties); item->addPoint(rect.bottomRight(), false); annotationArea.addAnnotationItem(item); CropCommand cropCommand(&graphicsPixmapItem, cropRect, &annotationArea); cropCommand.redo(); // act cropCommand.undo(); // assert QCOMPARE(item->position(), rect.topLeft()); QCOMPARE(item->boundingRect().size(), rect.size()); } TEST_MAIN(CropCommandTest); kImageAnnotator-0.6.1/tests/annotations/undo/CropCommandTest.h000066400000000000000000000033661440330760000244650ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPCOMMANDTEST_H #define KIMAGEANNOTATOR_CROPCOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/AddCommand.h" #include "src/annotations/core/AnnotationArea.h" #include "src/annotations/items/AnnotationLine.h" #include "tests/mocks/MockSettingsProvider.h" #include "tests/mocks/MockDevicePixelRatioScaler.h" #include "tests/mocks/MockDefaultParameters.h" using kImageAnnotator::CropCommand; using kImageAnnotator::AnnotationArea; using kImageAnnotator::AnnotationRect; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::Config; using kImageAnnotator::PropertiesPtr; class CropCommandTest : public QObject { Q_OBJECT private slots: void TestRedo_Should_CropImageAndScene(); void TestRedo_Should_MoveItemToNewPosition(); void TestUndo_Should_RestoreOriginalImageAndSceneSize(); void TestUndo_Should_MoveItemBackToPreviousPosition(); }; #endif // KIMAGEANNOTATOR_CROPCOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/DeleteCommandTest.cpp000066400000000000000000000046021440330760000253110ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "DeleteCommandTest.h" #include "tests/mocks/MockDefaultParameters.h" void DeleteCommandTest::TestRedo_Should_ApplyOperation() { // arrange MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); AnnotationLine item(line.p1(), properties); item.addPoint(line.p2(), false); annotationArea.addAnnotationItem(&item); QCOMPARE(annotationArea.items().contains(&item), true); QList items = { &item }; DeleteCommand deleteCommand(items, &annotationArea); // act deleteCommand.redo(); // assert QCOMPARE(annotationArea.items().contains(&item), false); } void DeleteCommandTest::TestUndo_Should_UndoOperation() { // arrange MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); AnnotationLine item(line.p1(), properties); item.addPoint(line.p2(), false); annotationArea.addAnnotationItem(&item); QList items = { &item }; DeleteCommand deleteCommand(items, &annotationArea); deleteCommand.redo(); QCOMPARE(annotationArea.items().contains(&item), false); // act deleteCommand.undo(); // assert QCOMPARE(annotationArea.items().contains(&item), true); } TEST_MAIN(DeleteCommandTest); kImageAnnotator-0.6.1/tests/annotations/undo/DeleteCommandTest.h000066400000000000000000000032071440330760000247560ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_DELETECOMMANDTEST_H #define KIMAGEANNOTATOR_DELETECOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/DeleteCommand.h" #include "src/annotations/core/AnnotationArea.h" #include "src/annotations/items/AnnotationLine.h" #include "tests/mocks/MockSettingsProvider.h" #include "tests/mocks/MockDevicePixelRatioScaler.h" using kImageAnnotator::DeleteCommand; using kImageAnnotator::AnnotationArea; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::Config; using kImageAnnotator::PropertiesPtr; class DeleteCommandTest : public QObject { Q_OBJECT private slots: void TestRedo_Should_ApplyOperation(); void TestUndo_Should_UndoOperation(); }; #endif // KIMAGEANNOTATOR_DELETECOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/ModifyCanvasCommandTest.cpp000066400000000000000000000105661440330760000265000ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ModifyCanvasCommandTest.h" void ModifyCanvasCommandTest::Redo_Should_ModifyCanvasSizeAndColor_When_SizeAndColorChanged() { MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); QPixmap image(400, 400); annotationArea.loadImage(image); QRectF newCanvasRect(100, 100, 200, 200); QColor newCanvasColor(Qt::red); ModifyCanvasCommand modifyCanvasCommand(newCanvasRect, newCanvasColor, &annotationArea); modifyCanvasCommand.redo(); QCOMPARE(annotationArea.canvasRect(), newCanvasRect); QCOMPARE(annotationArea.canvasColor(), newCanvasColor); QCOMPARE(annotationArea.isCustomCanvasRect(), true); } void ModifyCanvasCommandTest::Redo_Should_OnlyModifyCanvasColor_When_OnlyColorChanged() { MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); QPixmap image(400, 400); annotationArea.loadImage(image); QColor newCanvasColor(Qt::red); auto originalCanvasRect = annotationArea.canvasRect(); ModifyCanvasCommand modifyCanvasCommand(originalCanvasRect, newCanvasColor, &annotationArea); modifyCanvasCommand.redo(); QCOMPARE(annotationArea.canvasRect(), originalCanvasRect); QCOMPARE(annotationArea.canvasColor(), newCanvasColor); QCOMPARE(annotationArea.isCustomCanvasRect(), false); } void ModifyCanvasCommandTest::Undo_Should_RevertCanvasSizeAndColor_When_SizeAndColorChanged() { MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); QPixmap image(400, 400); annotationArea.loadImage(image); auto originalCanvasRect = annotationArea.canvasRect(); auto originalCanvasColor = annotationArea.canvasColor(); QRectF newCanvasRect(100, 100, 200, 200); QColor newCanvasColor(Qt::red); ModifyCanvasCommand modifyCanvasCommand(newCanvasRect, newCanvasColor, &annotationArea); modifyCanvasCommand.redo(); QCOMPARE(annotationArea.canvasRect(), newCanvasRect); QCOMPARE(annotationArea.canvasColor(), newCanvasColor); QCOMPARE(annotationArea.isCustomCanvasRect(), true); modifyCanvasCommand.undo(); QCOMPARE(annotationArea.canvasRect(), originalCanvasRect); QCOMPARE(annotationArea.canvasColor(), originalCanvasColor); QCOMPARE(annotationArea.isCustomCanvasRect(), false); } void ModifyCanvasCommandTest::Undo_Should_RevertOnlyColor_When_OnlyColorChanged() { MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); QPixmap image(400, 400); annotationArea.loadImage(image); QColor newCanvasColor(Qt::red); auto originalCanvasRect = annotationArea.canvasRect(); auto originalCanvasColor = annotationArea.canvasColor(); ModifyCanvasCommand modifyCanvasCommand(originalCanvasRect, newCanvasColor, &annotationArea); modifyCanvasCommand.redo(); QCOMPARE(annotationArea.canvasRect(), originalCanvasRect); QCOMPARE(annotationArea.canvasColor(), newCanvasColor); QCOMPARE(annotationArea.isCustomCanvasRect(), false); modifyCanvasCommand.undo(); QCOMPARE(annotationArea.canvasRect(), originalCanvasRect); QCOMPARE(annotationArea.canvasColor(), originalCanvasColor); QCOMPARE(annotationArea.isCustomCanvasRect(), false); } TEST_MAIN(ModifyCanvasCommandTest); kImageAnnotator-0.6.1/tests/annotations/undo/ModifyCanvasCommandTest.h000066400000000000000000000033511440330760000261370ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MODIFYCANVASCOMMANDTEST_H #define KIMAGEANNOTATOR_MODIFYCANVASCOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/AddCommand.h" #include "src/annotations/core/AnnotationArea.h" #include "src/annotations/items/AnnotationLine.h" #include "tests/mocks/MockSettingsProvider.h" #include "tests/mocks/MockDevicePixelRatioScaler.h" #include "tests/mocks/MockDefaultParameters.h" using kImageAnnotator::ModifyCanvasCommand; using kImageAnnotator::AnnotationArea; using kImageAnnotator::PropertiesPtr; class ModifyCanvasCommandTest : public QObject { Q_OBJECT private slots: void Redo_Should_ModifyCanvasSizeAndColor_When_SizeAndColorChanged(); void Redo_Should_OnlyModifyCanvasColor_When_OnlyColorChanged(); void Undo_Should_RevertCanvasSizeAndColor_When_SizeAndColorChanged(); void Undo_Should_RevertOnlyColor_When_OnlyColorChanged(); }; #endif //KIMAGEANNOTATOR_MODIFYCANVASCOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/MoveCommandTest.cpp000066400000000000000000000112041440330760000250110ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "MoveCommandTest.h" void MoveCommandTest::TestRedo_Should_MoveItemToNewPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); auto oldPosition = item->position(); QPointF newPosition(50, 50); QHash itemToPosition; itemToPosition[item] = newPosition; MoveCommand moveCommand(itemToPosition); QCOMPARE(item->position(), oldPosition); moveCommand.redo(); QCOMPARE(item->position(), newPosition); } void MoveCommandTest::TestUndo_Should_MoveItemToInitialPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); auto oldPosition = item->position(); QPointF newPosition(50, 50); QHash itemToPosition; itemToPosition[item] = newPosition; MoveCommand moveCommand(itemToPosition); moveCommand.redo(); QCOMPARE(item->position(), newPosition); moveCommand.undo(); QCOMPARE(item->position(), oldPosition); } void MoveCommandTest::TestMergeWith_Should_TakeNewPositionFromLastMoveCommand() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); auto oldPosition = item->position(); QPointF firstPosition(50, 50); QPointF secondPosition(70, 70); QHash itemToPositionFirst; QHash itemToPositionSecond; itemToPositionFirst[item] = firstPosition; itemToPositionFirst[item] = secondPosition; MoveCommand moveCommandFirst(itemToPositionFirst); MoveCommand moveCommandSecond(itemToPositionSecond); moveCommandFirst.mergeWith(&moveCommandSecond); QCOMPARE(item->position(), oldPosition); moveCommandFirst.redo(); QCOMPARE(item->position(), secondPosition); } void MoveCommandTest::TestMergeWith_Should_KeepInitialPositionFromFirstMoveCommand() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); auto oldPosition = item->position(); QPointF firstPosition(50, 50); QPointF secondPosition(70, 70); QHash itemToPositionFirst; QHash itemToPositionSecond; itemToPositionFirst[item] = firstPosition; itemToPositionFirst[item] = secondPosition; MoveCommand moveCommandFirst(itemToPositionFirst); MoveCommand moveCommandSecond(itemToPositionSecond); moveCommandFirst.mergeWith(&moveCommandSecond); moveCommandFirst.redo(); QCOMPARE(item->position(), secondPosition); moveCommandFirst.undo(); QCOMPARE(item->position(), oldPosition); } void MoveCommandTest::TestMergeWith_Should_NotMergeMoveCommands_When_ItemsAreNotTheSame() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); QLineF line2(15, 15, 25, 25); auto item1 = new AnnotationLine(line1.p1(), properties); auto item2 = new AnnotationLine(line2.p1(), properties); item1->addPoint(line1.p2(), false); item2->addPoint(line2.p2(), false); QPointF newPosition1(50, 50); QPointF newPosition2(60, 60); QHash item1ToPosition; QHash item2ToPosition; item1ToPosition[item1] = newPosition1; item2ToPosition[item2] = newPosition2; MoveCommand moveCommand1(item1ToPosition); MoveCommand moveCommand2(item2ToPosition); moveCommand1.mergeWith(&moveCommand2); moveCommand1.redo(); moveCommand2.redo(); QCOMPARE(item1->position(), newPosition1); QCOMPARE(item2->position(), newPosition2); } TEST_MAIN(MoveCommandTest); kImageAnnotator-0.6.1/tests/annotations/undo/MoveCommandTest.h000066400000000000000000000032071440330760000244620ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MOVECOMMANDTEST_H #define KIMAGEANNOTATOR_MOVECOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/MoveCommand.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::MoveCommand; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class MoveCommandTest : public QObject { Q_OBJECT private slots: void TestRedo_Should_MoveItemToNewPosition(); void TestUndo_Should_MoveItemToInitialPosition(); void TestMergeWith_Should_TakeNewPositionFromLastMoveCommand(); void TestMergeWith_Should_KeepInitialPositionFromFirstMoveCommand(); void TestMergeWith_Should_NotMergeMoveCommands_When_ItemsAreNotTheSame(); }; #endif // KIMAGEANNOTATOR_MOVECOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/PasteCommandTest.cpp000066400000000000000000000076511440330760000251720ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "PasteCommandTest.h" #include "src/annotations/undo/PasteCommand.h" #include "src/annotations/core/AnnotationArea.h" #include "src/annotations/items/AnnotationLine.h" #include "src/annotations/core/AnnotationPropertiesFactory.h" #include "tests/mocks/MockDefaultParameters.h" using kImageAnnotator::PasteCommand; using kImageAnnotator::AnnotationArea; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::Config; using kImageAnnotator::AnnotationItemFactory; using kImageAnnotator::PropertiesPtr; using kImageAnnotator::AnnotationPropertiesFactory; void PasteCommandTest::TestRedo_Should_AddPastedItemsToAnnotationAreaAtGivenPosition() { // arrange auto offset = QPointF(10, 10); auto position = QPointF(50, 50); MockDefaultParameters mockParameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationPropertiesFactory propertiesFactory(&mockParameters.config, &mockParameters.settingsProvider); AnnotationArea annotationArea(&mockParameters.config, &mockParameters.settingsProvider, scalerMock, &mockParameters.zoomValueProvider, nullptr); AnnotationItemFactory itemFactory(&propertiesFactory, &mockParameters.settingsProvider, &mockParameters.config); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); QHash itemsWithOffset; itemsWithOffset[item] = offset; PasteCommand pasteCommand(itemsWithOffset, position, &itemFactory, &annotationArea); QVERIFY(dynamic_cast(annotationArea.items().last()) == nullptr); // act pasteCommand.redo(); // assert auto lastItem = dynamic_cast(annotationArea.items().last()); QVERIFY(lastItem != nullptr); QCOMPARE(lastItem->position(), position + offset); } void PasteCommandTest::TestUndo_Should_RemovePastedItemsFromAnnotationArea() { // arrange auto offset = QPointF(10, 10); auto position = QPointF(50, 50); MockDefaultParameters mockParameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationPropertiesFactory propertiesFactory(&mockParameters.config, &mockParameters.settingsProvider); AnnotationArea annotationArea(&mockParameters.config, &mockParameters.settingsProvider, scalerMock, &mockParameters.zoomValueProvider, nullptr); AnnotationItemFactory itemFactory(&propertiesFactory, &mockParameters.settingsProvider, &mockParameters.config); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); QHash itemsWithOffset; itemsWithOffset[item] = offset; PasteCommand pasteCommand(itemsWithOffset, position, &itemFactory, &annotationArea); pasteCommand.redo(); QVERIFY(dynamic_cast(annotationArea.items().last()) != nullptr); // act pasteCommand.undo(); // arrange QVERIFY(dynamic_cast(annotationArea.items().last()) == nullptr); } TEST_MAIN(PasteCommandTest); kImageAnnotator-0.6.1/tests/annotations/undo/PasteCommandTest.h000066400000000000000000000022551440330760000246320ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_PASTECOMMANDTEST_H #define KIMAGEANNOTATOR_PASTECOMMANDTEST_H #include #include "tests/utils/TestRunner.h" class PasteCommandTest : public QObject { Q_OBJECT private slots: void TestRedo_Should_AddPastedItemsToAnnotationAreaAtGivenPosition(); void TestUndo_Should_RemovePastedItemsFromAnnotationArea(); }; #endif // KIMAGEANNOTATOR_PASTECOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/ResizeCommandTest.cpp000066400000000000000000000103651440330760000253530ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ResizeCommandTest.h" void ResizeCommandTest::TestRedo_Should_MoveProvidedHandleToNewPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); QPointF newPosition(50, 50); ResizeCommand resize(item, 1, newPosition, false); QCOMPARE(item->line().p2(), line.p2()); resize.redo(); QCOMPARE(item->line().p2(), newPosition); } void ResizeCommandTest::TestUndo_Should_MoveProvidedHandleToInitialPosition() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); QPointF newPosition(50, 50); ResizeCommand resize(item, 1, newPosition, false); resize.redo(); QCOMPARE(item->line().p2(), newPosition); resize.undo(); QCOMPARE(item->line().p2(), line.p2()); } void ResizeCommandTest::TestMergeWith_Should_TakeNewHandlePositionFromLastResizeCommand() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); QPointF newPosition1(50, 50); QPointF newPosition2(60, 60); ResizeCommand resize1(item, 1, newPosition1, false); ResizeCommand resize2(item, 1, newPosition2, false); QCOMPARE(item->line().p2(), line.p2()); resize1.mergeWith(&resize2); resize1.redo(); QCOMPARE(item->line().p2(), newPosition2); } void ResizeCommandTest::TestMergeWith_Should_KeepInitialPositionFromFirstResizeCommand() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line(10, 10, 20, 20); auto item = new AnnotationLine(line.p1(), properties); item->addPoint(line.p2(), false); QPointF newPosition1(50, 50); QPointF newPosition2(60, 60); ResizeCommand resize1(item, 1, newPosition1, false); ResizeCommand resize2(item, 1, newPosition2, false); resize1.mergeWith(&resize2); resize1.redo(); QCOMPARE(item->line().p2(), newPosition2); resize1.undo(); QCOMPARE(item->line().p2(), line.p2()); } void ResizeCommandTest::TestMergeWith_Should_NotMergeResizeCommands_When_ItemsAreNotTheSame() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); QLineF line2(15, 15, 25, 25); auto item1 = new AnnotationLine(line1.p1(), properties); auto item2 = new AnnotationLine(line2.p1(), properties); item1->addPoint(line1.p2(), false); item2->addPoint(line2.p2(), false); QPointF newPosition1(50, 50); QPointF newPosition2(60, 60); ResizeCommand resize1(item1, 1, newPosition1, false); ResizeCommand resize2(item2, 1, newPosition2, false); QCOMPARE(item1->line().p2(), line1.p2()); resize1.mergeWith(&resize2); resize1.redo(); QCOMPARE(item1->line().p2(), newPosition1); } void ResizeCommandTest::TestMergeWith_Should_NotMergeResizeCommands_When_HandlesAreNotTheSame() { auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); QLineF line1(10, 10, 20, 20); auto item1 = new AnnotationLine(line1.p1(), properties); item1->addPoint(line1.p2(), false); QPointF newPosition1(50, 50); QPointF newPosition2(60, 60); ResizeCommand resize1(item1, 1, newPosition1, false); ResizeCommand resize2(item1, 3, newPosition2, false); QCOMPARE(item1->line().p2(), line1.p2()); resize1.mergeWith(&resize2); resize1.redo(); QCOMPARE(item1->line().p2(), newPosition1); } TEST_MAIN(ResizeCommandTest); kImageAnnotator-0.6.1/tests/annotations/undo/ResizeCommandTest.h000066400000000000000000000034021440330760000250120ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_RESIZECOMMANDTEST_H #define KIMAGEANNOTATOR_RESIZECOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/ResizeCommand.h" #include "src/annotations/items/AnnotationLine.h" using kImageAnnotator::ResizeCommand; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class ResizeCommandTest : public QObject { Q_OBJECT private slots: void TestRedo_Should_MoveProvidedHandleToNewPosition(); void TestUndo_Should_MoveProvidedHandleToInitialPosition(); void TestMergeWith_Should_TakeNewHandlePositionFromLastResizeCommand(); void TestMergeWith_Should_KeepInitialPositionFromFirstResizeCommand(); void TestMergeWith_Should_NotMergeResizeCommands_When_ItemsAreNotTheSame(); void TestMergeWith_Should_NotMergeResizeCommands_When_HandlesAreNotTheSame(); }; #endif // KIMAGEANNOTATOR_RESIZECOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/RotateCommandTest.cpp000066400000000000000000000064251440330760000253520ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "RotateCommandTest.h" #include "tests/mocks/MockDefaultParameters.h" void RotateCommandTest::Redo_Should_RotatePixmapByProvidedAngel() { // arrange auto oldSize = QSizeF(100, 50); auto newSize = QSizeF(50, 100); auto angel = 90; QPixmap pixmap(oldSize.toSize()); QGraphicsPixmapItem image(pixmap); MockDefaultParameters defaultParameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&defaultParameters.config, &defaultParameters.settingsProvider, scalerMock, &defaultParameters.zoomValueProvider, nullptr); RotateCommand rotateCommand(&image, angel, &annotationArea); // act rotateCommand.redo(); // assert QCOMPARE(image.boundingRect().size(), newSize); QCOMPARE(annotationArea.sceneRect().size(), newSize); } void RotateCommandTest::Redo_Should_TrimPixmapAndRemoveTransparentPart_WhenRotatedBy45DegreeTwice() { // arrange auto oldSize = QSizeF(100, 50); auto newSize = QSizeF(50, 100) + QSize(3, 3); // Rotating by non 90° multipliers creates fuzzy edges due to antialiasing. auto angel = 45; QPixmap pixmap(oldSize.toSize()); pixmap.fill(Qt::green); QGraphicsPixmapItem image(pixmap); MockDefaultParameters defaultParameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&defaultParameters.config, &defaultParameters.settingsProvider, scalerMock, &defaultParameters.zoomValueProvider, nullptr); RotateCommand rotate1Command(&image, angel, &annotationArea); rotate1Command.redo(); RotateCommand rotate2Command(&image, angel, &annotationArea); // act rotate2Command.redo(); // assert QCOMPARE(image.boundingRect().size(), newSize); QCOMPARE(annotationArea.sceneRect().size(), newSize); } void RotateCommandTest::Undo_Should_RevertBackToInitialImage() { // arrange auto oldSize = QSizeF(100, 50); auto angel = 90; QPixmap pixmap(oldSize.toSize()); QGraphicsPixmapItem image(pixmap); MockDefaultParameters defaultParameters; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&defaultParameters.config, &defaultParameters.settingsProvider, scalerMock, &defaultParameters.zoomValueProvider, nullptr); RotateCommand rotateCommand(&image, angel, &annotationArea); rotateCommand.redo(); QVERIFY(image.pixmap().toImage() != pixmap.toImage()); // act rotateCommand.undo(); // assert QCOMPARE(image.pixmap().toImage(), pixmap.toImage()); QCOMPARE(image.boundingRect().size(), oldSize); QCOMPARE(annotationArea.sceneRect().size(), oldSize); } TEST_MAIN(RotateCommandTest) kImageAnnotator-0.6.1/tests/annotations/undo/RotateCommandTest.h000066400000000000000000000026761440330760000250230ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ROTATECOMMANDTEST_H #define KIMAGEANNOTATOR_ROTATECOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/RotateCommand.h" #include "tests/mocks/MockSettingsProvider.h" #include "tests/mocks/MockDevicePixelRatioScaler.h" using kImageAnnotator::RotateCommand; using kImageAnnotator::AnnotationArea; class RotateCommandTest : public QObject { Q_OBJECT private slots: void Redo_Should_RotatePixmapByProvidedAngel(); void Redo_Should_TrimPixmapAndRemoveTransparentPart_WhenRotatedBy45DegreeTwice(); void Undo_Should_RevertBackToInitialImage(); }; #endif //KIMAGEANNOTATOR_ROTATECOMMANDTEST_H kImageAnnotator-0.6.1/tests/annotations/undo/ScaleCommandTest.cpp000066400000000000000000000073271440330760000251450ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ScaleCommandTest.h" #include "tests/mocks/MockDefaultParameters.h" void ScaleCommandTest::TestRedo_Should_ScaleImageToNewSize() { // arrange auto oldSize = QSize(500, 500); auto newSize = QSize(250, 250); QPixmap pixmap(oldSize); QGraphicsPixmapItem image(pixmap); MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); ScaleCommand scaleCommand(&image, newSize, &annotationArea); // act scaleCommand.redo(); // assert QCOMPARE(image.boundingRect().size().toSize(), newSize); } void ScaleCommandTest::TestUndo_Should_ScaleImageBackToOldSize() { // arrange auto oldSize = QSize(500, 500); auto newSize = QSize(250, 250); QPixmap pixmap(oldSize); QGraphicsPixmapItem image(pixmap); MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); ScaleCommand scaleCommand(&image, newSize, &annotationArea); scaleCommand.redo(); QCOMPARE(image.boundingRect().size().toSize(), newSize); // act scaleCommand.undo(); // assert QCOMPARE(image.boundingRect().size().toSize(), oldSize); } void ScaleCommandTest::TestRedo_Should_ScaleItemsBySameFactorAsImage() { // arrange auto oldSize = QSize(500, 500); auto newSize = QSize(250, 250); QPixmap pixmap(oldSize); QGraphicsPixmapItem image(pixmap); MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto rectItem = new AnnotationRect(QPointF(0, 0), properties); rectItem->addPoint(QPointF(50, 50), false); annotationArea.addAnnotationItem(rectItem); ScaleCommand scaleCommand(&image, newSize, &annotationArea); // act scaleCommand.redo(); // assert QCOMPARE(rectItem->boundingRect().size().toSize(), QSize(25, 25)); } void ScaleCommandTest::TestUndo_Should_ScaleItemsBackToOriginalSize() { // arrange auto oldSize = QSize(500, 500); auto newSize = QSize(250, 250); QPixmap pixmap(oldSize); QGraphicsPixmapItem image(pixmap); MockDefaultParameters p; auto scalerMock = new MockDevicePixelRatioScaler(); AnnotationArea annotationArea(&p.config, &p.settingsProvider, scalerMock, &p.zoomValueProvider, nullptr); auto properties = PropertiesPtr(new AnnotationProperties(Qt::red, 1)); auto rectItem = new AnnotationRect(QPointF(0, 0), properties); rectItem->addPoint(QPointF(50, 50), false); annotationArea.addAnnotationItem(rectItem); ScaleCommand scaleCommand(&image, newSize, &annotationArea); scaleCommand.redo(); QCOMPARE(rectItem->boundingRect().size().toSize(), QSize(25, 25)); // act scaleCommand.undo(); // assert QCOMPARE(rectItem->boundingRect().size().toSize(), QSize(50, 50)); } TEST_MAIN(ScaleCommandTest) kImageAnnotator-0.6.1/tests/annotations/undo/ScaleCommandTest.h000066400000000000000000000031521440330760000246020ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SCALECOMMANDTEST_H #define KIMAGEANNOTATOR_SCALECOMMANDTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/undo/ScaleCommand.h" #include "tests/mocks/MockSettingsProvider.h" #include "tests/mocks/MockDevicePixelRatioScaler.h" using kImageAnnotator::ScaleCommand; using kImageAnnotator::AnnotationArea; using kImageAnnotator::Config; using kImageAnnotator::AnnotationRect; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::PropertiesPtr; class ScaleCommandTest : public QObject { Q_OBJECT private slots: void TestRedo_Should_ScaleImageToNewSize(); void TestUndo_Should_ScaleImageBackToOldSize(); void TestRedo_Should_ScaleItemsBySameFactorAsImage(); void TestUndo_Should_ScaleItemsBackToOriginalSize(); }; #endif // KIMAGEANNOTATOR_SCALECOMMANDTEST_H kImageAnnotator-0.6.1/tests/backend/000077500000000000000000000000001440330760000173275ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/backend/ConfigTest.cpp000066400000000000000000000041151440330760000221010ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ConfigTest.h" void ConfigTest::TestSetSelectedTool_Should_NotSaveSelection_When_SaveToolSelectionDisabled() { // arrange qRegisterMetaType("ToolTypes"); auto defaultTool = Tools::Pen; auto settingsMock = QSharedPointer(new SettingsMock); EXPECT_CALL(*settingsMock, value(testing::_, testing::_)) .WillRepeatedly(testing::Return((int)defaultTool)); EXPECT_CALL(*settingsMock, setValue(testing::_, testing::_)).Times(0); Config config(settingsMock); config.setSaveToolSelection(false); // act & assert config.setSelectedToolType(Tools::Ellipse); } void ConfigTest::TestSetSelectedTool_Should_SaveSelection_When_SaveToolSelectionEnabled() { // arrange qRegisterMetaType("ToolTypes"); auto defaultTool = Tools::Pen; auto selectedTool = Tools::Ellipse; auto settingsMock = QSharedPointer(new SettingsMock); EXPECT_CALL(*settingsMock, value(testing::_, testing::_)) .WillRepeatedly(testing::Return((int)defaultTool)); EXPECT_CALL(*settingsMock, setValue(ConfigNameHelper::toolType(), QVariant((int)selectedTool))).Times(1); EXPECT_CALL(*settingsMock, sync()).Times(testing::AnyNumber()); Config config(settingsMock); config.setSaveToolSelection(true); // act & assert config.setSelectedToolType(selectedTool); } TEST_MAIN(ConfigTest); kImageAnnotator-0.6.1/tests/backend/ConfigTest.h000066400000000000000000000026421440330760000215510ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CONFIGTEST_H #define KIMAGEANNOTATOR_CONFIGTEST_H #include #include #include "tests/utils/TestRunner.h" #include "tests/mocks/backend/SettingsMock.h" #include "src/backend/Config.h" #include "src/common/enum/Tools.h" using kImageAnnotator::Config; using kImageAnnotator::ConfigNameHelper; using kImageAnnotator::Tools; class ConfigTest : public QObject { Q_OBJECT private slots: void TestSetSelectedTool_Should_NotSaveSelection_When_SaveToolSelectionDisabled(); void TestSetSelectedTool_Should_SaveSelection_When_SaveToolSelectionEnabled(); }; #endif // KIMAGEANNOTATOR_CONFIGTEST_H kImageAnnotator-0.6.1/tests/common/000077500000000000000000000000001440330760000172305ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/common/helper/000077500000000000000000000000001440330760000205075ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/common/helper/ItemHelperTest.cpp000066400000000000000000000061211440330760000241110ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ItemHelperTest.h" void ItemHelperTest::TestZValueGreaterThen_Should_ReturnTrue_When_OtherItemHasLowerZValue() { QPointF pos(10, 10); AnnotationLine item1(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); AnnotationLine item2(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); item1.setZValue(100); item2.setZValue(50); auto result = ItemHelper::zValueGreaterThen(&item1, &item2); QCOMPARE(result, true); } void ItemHelperTest::TestZValueGreaterThen_Should_ReturnFalse_When_OtherItemHasHigherZValue() { QPointF pos(10, 10); AnnotationLine item1(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); AnnotationLine item2(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); item1.setZValue(50); item2.setZValue(100); auto result = ItemHelper::zValueGreaterThen(&item1, &item2); QCOMPARE(result, false); } void ItemHelperTest::TestZValueGreaterThen_Should_ReturnFalse_When_OtherItemHasEqualZValue() { QPointF pos(10, 10); AnnotationLine item1(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); AnnotationLine item2(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); item1.setZValue(100); item2.setZValue(100); auto result = ItemHelper::zValueGreaterThen(&item1, &item2); QCOMPARE(result, false); } void ItemHelperTest::TestSortItemsByZValueDesc_Should_SortItemsByZValueInDescendingOrder() { QPointF pos(10, 10); AnnotationLine item1(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); AnnotationLine item2(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); AnnotationLine item3(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); AnnotationLine item4(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); AnnotationLine item5(pos, PropertiesPtr(new AnnotationProperties(Qt::red, 1))); item1.setZValue(100); item2.setZValue(80); item3.setZValue(2); item4.setZValue(60); item5.setZValue(90); QList items; items.append(&item3); items.append(&item1); items.append(&item4); items.append(&item5); items.append(&item2); ItemHelper::sortItemsByZValueDesc(&items); QCOMPARE((int) items[0]->zValue(), 100); QCOMPARE((int) items[1]->zValue(), 90); QCOMPARE((int) items[2]->zValue(), 80); QCOMPARE((int) items[3]->zValue(), 60); QCOMPARE((int) items[4]->zValue(), 2); } TEST_MAIN(ItemHelperTest); kImageAnnotator-0.6.1/tests/common/helper/ItemHelperTest.h000066400000000000000000000032041440330760000235550ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ITEMHELPERTEST_H #define KIMAGEANNOTATOR_ITEMHELPERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/items/AnnotationLine.h" #include "src/common/helper/ItemHelper.h" using kImageAnnotator::ItemHelper; using kImageAnnotator::AnnotationProperties; using kImageAnnotator::AnnotationLine; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::PropertiesPtr; class ItemHelperTest : public QObject { Q_OBJECT private slots: void TestZValueGreaterThen_Should_ReturnTrue_When_OtherItemHasLowerZValue(); void TestZValueGreaterThen_Should_ReturnFalse_When_OtherItemHasHigherZValue(); void TestZValueGreaterThen_Should_ReturnFalse_When_OtherItemHasEqualZValue(); void TestSortItemsByZValueDesc_Should_SortItemsByZValueInDescendingOrder(); }; #endif // KIMAGEANNOTATOR_ITEMHELPERTEST_H kImageAnnotator-0.6.1/tests/common/helper/KeyHelperTest.cpp000066400000000000000000000111661440330760000237500ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "KeyHelperTest.h" void KeyHelperTest::TestKeyPress_Should_EmitUndoSignal_When_ControlAndZKeyArePressed() { QKeyEvent pressCtrlKeyEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier); QKeyEvent pressZKeyEvent(QEvent::KeyPress, Qt::Key_Z, Qt::NoModifier); KeyHelper keyHelper; QSignalSpy spy(&keyHelper, &KeyHelper::undoPressed); keyHelper.keyPress(&pressCtrlKeyEvent); keyHelper.keyPress(&pressZKeyEvent); QCOMPARE(spy.count(), 1); } void KeyHelperTest::TestKeyPress_Should_EmitRedoSignal_When_ControlAndShiftAndZKeyArePressed() { QKeyEvent pressCtrlKeyEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier); QKeyEvent pressShiftKeyEvent(QEvent::KeyPress, Qt::Key_Shift, Qt::NoModifier); QKeyEvent pressZKeyEvent(QEvent::KeyPress, Qt::Key_Z, Qt::NoModifier); KeyHelper keyHelper; QSignalSpy spy(&keyHelper, &KeyHelper::redoPressed); keyHelper.keyPress(&pressCtrlKeyEvent); keyHelper.keyPress(&pressShiftKeyEvent); keyHelper.keyPress(&pressZKeyEvent); QCOMPARE(spy.count(), 1); } void KeyHelperTest::TestKeyRelease_Should_EmitSignal_When_DeleteKeyReleased() { QKeyEvent keyEvent(QEvent::KeyRelease, Qt::Key_Delete, Qt::NoModifier); KeyHelper keyHelper; QSignalSpy spy(&keyHelper, &KeyHelper::deleteReleased); keyHelper.keyRelease(&keyEvent); QCOMPARE(spy.count(), 1); } void KeyHelperTest::TestKeyRelease_Should_EmitSignal_When_EscapeKeyReleased() { QKeyEvent keyEvent(QEvent::KeyRelease, Qt::Key_Escape, Qt::NoModifier); KeyHelper keyHelper; QSignalSpy spy(&keyHelper, &KeyHelper::escapeReleased); keyHelper.keyRelease(&keyEvent); QCOMPARE(spy.count(), 1); } void KeyHelperTest::TestIsControlPressed_ShouldReturnTrue_When_ControlWasPressed() { QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier); KeyHelper keyHelper; QCOMPARE(keyHelper.isControlPressed(), false); keyHelper.keyPress(&keyEvent); QCOMPARE(keyHelper.isControlPressed(), true); } void KeyHelperTest::TestIsControlPressed_ShouldReturnFalse_When_ControlWasReleased() { QKeyEvent keyPressEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier); QKeyEvent keyReleaseEvent(QEvent::KeyRelease, Qt::Key_Control, Qt::NoModifier); KeyHelper keyHelper; keyHelper.keyPress(&keyPressEvent); QCOMPARE(keyHelper.isControlPressed(), true); keyHelper.keyRelease(&keyReleaseEvent); QCOMPARE(keyHelper.isControlPressed(), false); } void KeyHelperTest::TestIsShiftPressed_Should_ReturnTrue_When_ShiftWasPressed() { QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Shift, Qt::NoModifier); KeyHelper keyHelper; QCOMPARE(keyHelper.isShiftPressed(), false); keyHelper.keyPress(&keyEvent); QCOMPARE(keyHelper.isShiftPressed(), true); } void KeyHelperTest::TestIsShiftPressed_Should_ReturnFalse_When_ShiftWasReleased() { QKeyEvent keyPressEvent(QEvent::KeyPress, Qt::Key_Shift, Qt::NoModifier); QKeyEvent keyReleaseEvent(QEvent::KeyRelease, Qt::Key_Shift, Qt::NoModifier); KeyHelper keyHelper; keyHelper.keyPress(&keyPressEvent); QCOMPARE(keyHelper.isShiftPressed(), true); keyHelper.keyRelease(&keyReleaseEvent); QCOMPARE(keyHelper.isShiftPressed(), false); } void KeyHelperTest::TestKeyReleased_Should_EmitReturnReleased_When_ReturnWasReleased() { QKeyEvent keyEvent(QEvent::KeyRelease, Qt::Key_Return, Qt::NoModifier); KeyHelper keyHelper; QSignalSpy spy(&keyHelper, &KeyHelper::returnReleased); keyHelper.keyRelease(&keyEvent); QCOMPARE(spy.count(), 1); } void KeyHelperTest::TestKeyReleased_Should_EmitEnterReleased_When_EnterWasReleased() { QKeyEvent keyEvent(QEvent::KeyRelease, Qt::Key_Enter, Qt::NoModifier); KeyHelper keyHelper; QSignalSpy spy(&keyHelper, &KeyHelper::enterReleased); keyHelper.keyRelease(&keyEvent); QCOMPARE(spy.count(), 1); } TEST_MAIN(KeyHelperTest); kImageAnnotator-0.6.1/tests/common/helper/KeyHelperTest.h000066400000000000000000000035061440330760000234140ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_KEYHELPERTEST_H #define KIMAGEANNOTATOR_KEYHELPERTEST_H #include #include #include "tests/utils/TestRunner.h" #include "src/common/helper/KeyHelper.h" using kImageAnnotator::KeyHelper; class KeyHelperTest : public QObject { Q_OBJECT private slots: void TestKeyPress_Should_EmitUndoSignal_When_ControlAndZKeyArePressed(); void TestKeyPress_Should_EmitRedoSignal_When_ControlAndShiftAndZKeyArePressed(); void TestKeyRelease_Should_EmitSignal_When_DeleteKeyReleased(); void TestKeyRelease_Should_EmitSignal_When_EscapeKeyReleased(); void TestIsControlPressed_ShouldReturnTrue_When_ControlWasPressed(); void TestIsControlPressed_ShouldReturnFalse_When_ControlWasReleased(); void TestIsShiftPressed_Should_ReturnTrue_When_ShiftWasPressed(); void TestIsShiftPressed_Should_ReturnFalse_When_ShiftWasReleased(); void TestKeyReleased_Should_EmitReturnReleased_When_ReturnWasReleased(); void TestKeyReleased_Should_EmitEnterReleased_When_EnterWasReleased(); }; #endif // KIMAGEANNOTATOR_KEYHELPERTEST_H kImageAnnotator-0.6.1/tests/common/helper/MathHelperTest.cpp000066400000000000000000000061521440330760000241100ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "MathHelperTest.h" void MathHelperTest::TestRoundAngleTo_Should_ReturnAngleRoundedUpToIncrement() { QFETCH(qreal, angle); QFETCH(qreal, increment); QFETCH(qreal, result); auto newAngle = MathHelper::roundAngleTo(angle, increment); QCOMPARE(newAngle, result); } void MathHelperTest::TestRoundAngleTo_Should_ReturnAngleRoundedUpToIncrement_data() { QTest::addColumn("angle"); QTest::addColumn("increment"); QTest::addColumn("result"); QTest::newRow("set1") << 50.0 << 45.0 << 45.0; QTest::newRow("set2") << 87.0 << 45.0 << 90.0; QTest::newRow("set3") << 0.0 << 45.0 << 0.0; QTest::newRow("set4") << 355.0 << 45.0 << 360.0; QTest::newRow("set5") << 360.0 << 45.0 << 360.0; QTest::newRow("set6") << -2.0 << 45.0 << 0.0; } void MathHelperTest::TestSmallerValue_Should_AlwaysSmallerOfTwoValues() { QFETCH(qreal, width); QFETCH(qreal, height); QFETCH(qreal, result); auto smallest = MathHelper::smallerValue(width, height); QCOMPARE(smallest, result); } void MathHelperTest::TestSmallerValue_Should_AlwaysSmallerOfTwoValues_data() { QTest::addColumn("width"); QTest::addColumn("height"); QTest::addColumn("result"); QTest::newRow("set1") << 50.0 << 49.0 << 49.0; QTest::newRow("set2") << -87.0 << 1.0 << -1.0; QTest::newRow("set3") << 0.0 << -1.0 << 0.0; QTest::newRow("set4") << 400.0 << -500.0 << 400.0; QTest::newRow("set5") << -3.0 << 2.0 << -2.0; QTest::newRow("set6") << -2.0 << 2.0 << -2.0; } void MathHelperTest::TestDistanceBetweenPoints_Should_ReturnCorrectDistance() { QFETCH(QPointF, point1); QFETCH(QPointF, point2); QFETCH(double, expected); auto result = MathHelper::distanceBetweenPoints(point1, point2); QCOMPARE(result, expected); } void MathHelperTest::TestDistanceBetweenPoints_Should_ReturnCorrectDistance_data() { QTest::addColumn("point1"); QTest::addColumn("point2"); QTest::addColumn("expected"); QTest::newRow("set1") << QPointF(10, 10) << QPointF(20, 10) << 10.0; QTest::newRow("set2") << QPointF(10, 10) << QPointF(10, 20) << 10.0; QTest::newRow("set3") << QPointF(-10, 10) << QPointF(10, 10) << 20.0; QTest::newRow("set4") << QPointF(-4, -3) << QPointF(8, 6) << 15.0; } TEST_MAIN(MathHelperTest); kImageAnnotator-0.6.1/tests/common/helper/MathHelperTest.h000066400000000000000000000030101440330760000235430ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MATHHELPERTEST_H #define KIMAGEANNOTATOR_MATHHELPERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/common/helper/MathHelper.h" using kImageAnnotator::MathHelper; class MathHelperTest : public QObject { Q_OBJECT private slots: void TestRoundAngleTo_Should_ReturnAngleRoundedUpToIncrement(); void TestRoundAngleTo_Should_ReturnAngleRoundedUpToIncrement_data(); void TestSmallerValue_Should_AlwaysSmallerOfTwoValues(); void TestSmallerValue_Should_AlwaysSmallerOfTwoValues_data(); void TestDistanceBetweenPoints_Should_ReturnCorrectDistance(); void TestDistanceBetweenPoints_Should_ReturnCorrectDistance_data(); }; #endif // KIMAGEANNOTATOR_MATHHELPERTEST_H kImageAnnotator-0.6.1/tests/common/helper/PathHelperTest.cpp000066400000000000000000000047371440330760000241220ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "PathHelperTest.h" void PathHelperTest::TestExtractFilename_Should_ReturnOnlyFilename_When_FilenameHasFormat() { auto expected = QStringLiteral("myFile"); auto filename = PathHelper::extractFilename(QStringLiteral("/home/kimageannotator/") + expected + QStringLiteral(".png")); QCOMPARE(filename, expected); } void PathHelperTest::TestExtractFilename_Should_ReturnOnlyFilename_When_FilenameHasNoFormat() { auto expected = QStringLiteral("myFile"); auto filename = PathHelper::extractFilename(QStringLiteral("/home/kimageannotator/") + expected); QCOMPARE(filename, expected); } void PathHelperTest::TestExtractFilename_Should_ReturnOnlyFilename_When_FilenameWithoutPathWasProvided() { auto expected = QStringLiteral("myFile"); auto filename = PathHelper::extractFilename(expected); QCOMPARE(filename, expected); } void PathHelperTest::TestExtractFilenameWithFormat_Should_ReturnOnlyFilename_When_FilenameHasFormat() { auto expected = QStringLiteral("myFile.png"); auto filename = PathHelper::extractFilenameWithFormat(QStringLiteral("/home/kimageannotator/") + expected); QCOMPARE(filename, expected); } void PathHelperTest::TestExtractFilenameWithFormat_Should_ReturnOnlyFilename_When_FilenameWithoutPathWasProvided() { auto expected = QStringLiteral("myFile.png"); auto filename = PathHelper::extractFilenameWithFormat(expected); QCOMPARE(filename, expected); } void PathHelperTest::TestPrettyFilename_Should_ReplaceUnderscoresWithSpacesAndCapitalizeFirstLetters() { auto input = QStringLiteral("my_test_File.png"); auto expected = QStringLiteral("My Test File.png"); auto filename = PathHelper::prettyFilename(input); QCOMPARE(filename, expected); } TEST_MAIN(PathHelperTest); kImageAnnotator-0.6.1/tests/common/helper/PathHelperTest.h000066400000000000000000000031751440330760000235620ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_PATHHELPERTEST_H #define KIMAGEANNOTATOR_PATHHELPERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/common/helper/PathHelper.h" using kImageAnnotator::PathHelper; class PathHelperTest : public QObject { Q_OBJECT private slots: void TestExtractFilename_Should_ReturnOnlyFilename_When_FilenameHasFormat(); void TestExtractFilename_Should_ReturnOnlyFilename_When_FilenameHasNoFormat(); void TestExtractFilename_Should_ReturnOnlyFilename_When_FilenameWithoutPathWasProvided(); void TestExtractFilenameWithFormat_Should_ReturnOnlyFilename_When_FilenameHasFormat(); void TestExtractFilenameWithFormat_Should_ReturnOnlyFilename_When_FilenameWithoutPathWasProvided(); void TestPrettyFilename_Should_ReplaceUnderscoresWithSpacesAndCapitalizeFirstLetters(); }; #endif //KIMAGEANNOTATOR_PATHHELPERTEST_H kImageAnnotator-0.6.1/tests/common/helper/ShapeHelperTest.cpp000066400000000000000000000263121440330760000242570ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ShapeHelperTest.h" void ShapeHelperTest::TestRectTop_Should_ReturnPointAtTopCentered() { QRectF rect(10, 10, 50, 50); auto top = ShapeHelper::rectTop(rect); QCOMPARE(top, QPointF(rect.center().x(), rect.top())); } void ShapeHelperTest::TestRectRight_Should_ReturnPointAtRightCentered() { QRectF rect(10, 10, 50, 50); auto right = ShapeHelper::rectRight(rect); QCOMPARE(right, QPointF(rect.right(), rect.center().y())); } void ShapeHelperTest::TestRectLeft_Should_ReturnPointAtLeftCentered() { QRectF rect(10, 10, 50, 50); auto left = ShapeHelper::rectLeft(rect); QCOMPARE(left, QPointF(rect.left(), rect.center().y())); } void ShapeHelperTest::TestRectBottom_Should_ReturnPointAtBottomCentered() { QRectF rect(10, 10, 50, 50); auto bottom = ShapeHelper::rectBottom(rect); QCOMPARE(bottom, QPointF(rect.center().x(), rect.bottom())); } void ShapeHelperTest::TestRectTopWithOffset_Should_ReturnPointAtTopWithAddedOffset_When_TopSmallerThenBottom() { QRectF rect(10, 10, 50, 50); rect.setTop(rect.bottom() + 20); auto offset = 5; auto top = ShapeHelper::rectTopWithOffset(rect, offset); QCOMPARE(top, QPointF(rect.center().x(), rect.top() + offset)); } void ShapeHelperTest::TestRectTopWithOffset_Should_ReturnPointAtTopWithSubtractedOffset_When_TopLargerThenBottom() { QRectF rect(10, 10, 50, 50); auto offset = 5; auto top = ShapeHelper::rectTopWithOffset(rect, offset); QCOMPARE(top, QPointF(rect.center().x(), rect.top() - offset)); } void ShapeHelperTest::TestRectRightWithOffset_Should_ReturnPointAtRightWithSubtracedOffset_When_RightSmallerThenLeft() { QRectF rect(10, 10, 50, 50); rect.setRight(rect.left() - 20); auto offset = 5; auto right = ShapeHelper::rectRightWithOffset(rect, offset); QCOMPARE(right, QPointF(rect.right() - offset, rect.center().y())); } void ShapeHelperTest::TestRectRightWithOffset_Should_ReturnPointAtRightWithAddedOffset_When_RightLargerThenLeft() { QRectF rect(10, 10, 50, 50); auto offset = 5; auto right = ShapeHelper::rectRightWithOffset(rect, offset); QCOMPARE(right, QPointF(rect.right() + offset, rect.center().y())); } void ShapeHelperTest::TestRectBottomWithOffset_Should_ReturnPointAtBottomWithSubtracedOffset_When_BottomSmallerThenTop() { QRectF rect(10, 10, 50, 50); rect.setBottom(rect.top() - 20); auto offset = 5; auto bottom = ShapeHelper::rectBottomWithOffset(rect, offset); QCOMPARE(bottom, QPointF(rect.center().x(), rect.bottom() - offset)); } void ShapeHelperTest::TestRectBottomWithOffset_Should_ReturnPointAtBottomWithAddedOffset_When_BottomLargerThenTop() { QRectF rect(10, 10, 50, 50); auto offset = 5; auto bottom = ShapeHelper::rectBottomWithOffset(rect, offset); QCOMPARE(bottom, QPointF(rect.center().x(), rect.bottom() + offset)); } void ShapeHelperTest::TestRectLeftWithOffset_Should_ReturnPointAtLeftWithAddedOffset_When_LeftSmallerThenRight() { QRectF rect(10, 10, 50, 50); rect.setLeft(rect.right() + 20); auto offset = 5; auto left = ShapeHelper::rectLeftWithOffset(rect, offset); QCOMPARE(left, QPointF(rect.left() + offset, rect.center().y())); } void ShapeHelperTest::TestRectLeftWithOffset_Should_ReturnPointAtLeftWithSubtracedOffset_When_LeftLargerThenRight() { QRectF rect(10, 10, 50, 50); auto offset = 5; auto left = ShapeHelper::rectLeftWithOffset(rect, offset); QCOMPARE(left, QPointF(rect.left() - offset, rect.center().y())); } void ShapeHelperTest::TestRectTopLeftWithOffset_Should_ReturnPointWithCorrectOffset() { QFETCH(int, addToRight); QFETCH(int, addToBottom); QFETCH(int, expectedOffsetX); QFETCH(int, expectedOffsetY); QRectF rect(10, 10, 50, 50); rect.setRight(rect.left() + addToRight); rect.setBottom(rect.top() + addToBottom); auto offset = 5; auto topLeft = ShapeHelper::rectTopLeftWithOffset(rect, offset); QCOMPARE(topLeft, QPointF(rect.topLeft().x() + expectedOffsetX, rect.topLeft().y() + expectedOffsetY)); } void ShapeHelperTest::TestRectTopLeftWithOffset_Should_ReturnPointWithCorrectOffset_data() { QTest::addColumn("addToRight"); QTest::addColumn("addToBottom"); QTest::addColumn("expectedOffsetX"); QTest::addColumn("expectedOffsetY"); QTest::newRow("set1") << 10 << 10 << -5 << -5; QTest::newRow("set2") << -10 << 10 << 5 << -5; QTest::newRow("set3") << 10 << -10 << -5 << 5; QTest::newRow("set4") << -10 << -10 << 5 << 5; } void ShapeHelperTest::TestRectTopRightWithOffset_Should_ReturnPointWithCorrectOffset() { QFETCH(int, addToRight); QFETCH(int, addToBottom); QFETCH(int, expectedOffsetX); QFETCH(int, expectedOffsetY); QRectF rect(10, 10, 50, 50); rect.setRight(rect.left() + addToRight); rect.setBottom(rect.top() + addToBottom); auto offset = 5; auto topRight = ShapeHelper::rectTopRightWithOffset(rect, offset); QCOMPARE(topRight, QPointF(rect.topRight().x() + expectedOffsetX, rect.topRight().y() + expectedOffsetY)); } void ShapeHelperTest::TestRectTopRightWithOffset_Should_ReturnPointWithCorrectOffset_data() { QTest::addColumn("addToRight"); QTest::addColumn("addToBottom"); QTest::addColumn("expectedOffsetX"); QTest::addColumn("expectedOffsetY"); QTest::newRow("set1") << 10 << 10 << 5 << -5; QTest::newRow("set2") << -10 << 10 << -5 << -5; QTest::newRow("set3") << 10 << -10 << 5 << 5; QTest::newRow("set4") << -10 << -10 << -5 << 5; } void ShapeHelperTest::TestRectBottomLeftWithOffset_Should_ReturnPointWithCorrectOffset() { QFETCH(int, addToRight); QFETCH(int, addToBottom); QFETCH(int, expectedOffsetX); QFETCH(int, expectedOffsetY); QRectF rect(10, 10, 50, 50); rect.setRight(rect.left() + addToRight); rect.setBottom(rect.top() + addToBottom); auto offset = 5; auto bottomLeft = ShapeHelper::rectBottomLeftWithOffset(rect, offset); QCOMPARE(bottomLeft, QPointF(rect.bottomLeft().x() + expectedOffsetX, rect.bottomLeft().y() + expectedOffsetY)); } void ShapeHelperTest::TestRectBottomLeftWithOffset_Should_ReturnPointWithCorrectOffset_data() { QTest::addColumn("addToRight"); QTest::addColumn("addToBottom"); QTest::addColumn("expectedOffsetX"); QTest::addColumn("expectedOffsetY"); QTest::newRow("set1") << 10 << 10 << -5 << 5; QTest::newRow("set2") << -10 << 10 << 5 << 5; QTest::newRow("set3") << 10 << -10 << -5 << -5; QTest::newRow("set4") << -10 << -10 << 5 << -5; } void ShapeHelperTest::TestRectBottomRightWithOffset_Should_ReturnPointWithCorrectOffset() { QFETCH(int, addToRight); QFETCH(int, addToBottom); QFETCH(int, expectedOffsetX); QFETCH(int, expectedOffsetY); QRectF rect(10, 10, 50, 50); rect.setRight(rect.left() + addToRight); rect.setBottom(rect.top() + addToBottom); auto offset = 5; auto bottomRight = ShapeHelper::rectBottomRightWithOffset(rect, offset); QCOMPARE(bottomRight, QPointF(rect.bottomRight().x() + expectedOffsetX, rect.bottomRight().y() + expectedOffsetY)); } void ShapeHelperTest::TestRectBottomRightWithOffset_Should_ReturnPointWithCorrectOffset_data() { QTest::addColumn("addToRight"); QTest::addColumn("addToBottom"); QTest::addColumn("expectedOffsetX"); QTest::addColumn("expectedOffsetY"); QTest::newRow("set1") << 10 << 10 << 5 << 5; QTest::newRow("set2") << -10 << 10 << -5 << 5; QTest::newRow("set3") << 10 << -10 << 5 << -5; QTest::newRow("set4") << -10 << -10 << -5 << -5; } void ShapeHelperTest::TestExtendLine_Should_ReturnNewLineExtendBySizeWithSameAngle() { QLineF line(10, 10, 20, 20); auto extendBy = 12; auto result = ShapeHelper::extendLine(line, extendBy); QLineF lineExtendP1(line.p2(), line.p1()); lineExtendP1.setLength(line.length() + extendBy / 2); lineExtendP1.setLine(lineExtendP1.p2().x(), lineExtendP1.p2().y(), lineExtendP1.p1().x(), lineExtendP1.p1().y()); auto lineExtendP2 = line; lineExtendP2.setLength(line.length() + extendBy / 2); QCOMPARE(result.length(), line.length() + extendBy); QCOMPARE(result.angle(), line.angle()); QCOMPARE(result.p1(), lineExtendP1.p1()); QCOMPARE(result.p2(), lineExtendP2.p2()); } void ShapeHelperTest::TestRectPointAtIndex_Should_ReturnPointAtIndexPosition() { QFETCH(QRectF, rect); QFETCH(int, index); QFETCH(QPointF, expected); auto result = ShapeHelper::rectPointAtIndex(rect, index); QCOMPARE(result, expected); } void ShapeHelperTest::TestRectPointAtIndex_Should_ReturnPointAtIndexPosition_data() { QTest::addColumn("rect"); QTest::addColumn("index"); QTest::addColumn("expected"); QTest::newRow("set1") << QRectF(10, 10, 10, 10) << 0 << QPointF(10, 10); QTest::newRow("set2") << QRectF(10, 10, 10, 10) << 1 << QPointF(15, 10); QTest::newRow("set3") << QRectF(10, 10, 10, 10) << 2 << QPointF(20, 10); QTest::newRow("set4") << QRectF(10, 10, 10, 10) << 3 << QPointF(20, 15); QTest::newRow("set5") << QRectF(10, 10, 10, 10) << 4 << QPointF(20, 20); QTest::newRow("set6") << QRectF(10, 10, 10, 10) << 5 << QPointF(15, 20); QTest::newRow("set7") << QRectF(10, 10, 10, 10) << 6 << QPointF(10, 20); QTest::newRow("set8") << QRectF(10, 10, 10, 10) << 7 << QPointF(10, 15); } void ShapeHelperTest::TestSetRectPointAtIndex_Should_SetRectPointAtIndexToProvidedPoint() { QFETCH(QRectF, rectInitial); QFETCH(int, index); QFETCH(QPointF, point); QFETCH(QRectF, expected); auto result = ShapeHelper::setRectPointAtIndex(rectInitial, index, point); QCOMPARE(result, expected); } void ShapeHelperTest::TestSetRectPointAtIndex_Should_SetRectPointAtIndexToProvidedPoint_data() { QTest::addColumn("rectInitial"); QTest::addColumn("index"); QTest::addColumn("point"); QTest::addColumn("expected"); QTest::newRow("set1") << QRectF(10, 10, 10, 10) << 0 << QPointF(5, 5) << QRectF(5, 5, 15, 15); QTest::newRow("set2") << QRectF(10, 10, 10, 10) << 1 << QPointF(15, 5) << QRectF(10, 5, 10, 15); QTest::newRow("set3") << QRectF(10, 10, 10, 10) << 2 << QPointF(25, 5) << QRectF(10, 5, 15, 15); QTest::newRow("set4") << QRectF(10, 10, 10, 10) << 3 << QPointF(25, 15) << QRectF(10, 10, 15, 10); QTest::newRow("set5") << QRectF(10, 10, 10, 10) << 4 << QPointF(25, 25) << QRectF(10, 10, 15, 15); QTest::newRow("set6") << QRectF(10, 10, 10, 10) << 5 << QPointF(15, 25) << QRectF(10, 10, 10, 15); QTest::newRow("set7") << QRectF(10, 10, 10, 10) << 6 << QPointF(5, 25) << QRectF(5, 10, 15, 15); QTest::newRow("set8") << QRectF(10, 10, 10, 10) << 7 << QPointF(5, 15) << QRectF(5, 10, 15, 10); } void ShapeHelperTest::TestSmoothOut_Should_RetunSamePath_When_PathHasOnlyThreeElement() { QPainterPath path; path.moveTo(10, 10); path.lineTo(20, -10); path.lineTo(30, 10); auto result = ShapeHelper::smoothOut(path, 0); QCOMPARE(result, path); } TEST_MAIN(ShapeHelperTest); kImageAnnotator-0.6.1/tests/common/helper/ShapeHelperTest.h000066400000000000000000000063221440330760000237230ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SHAPEHELPERTEST_H #define KIMAGEANNOTATOR_SHAPEHELPERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/common/helper/ShapeHelper.h" using kImageAnnotator::ShapeHelper; class ShapeHelperTest : public QObject { Q_OBJECT private slots: void TestRectTop_Should_ReturnPointAtTopCentered(); void TestRectRight_Should_ReturnPointAtRightCentered(); void TestRectLeft_Should_ReturnPointAtLeftCentered(); void TestRectBottom_Should_ReturnPointAtBottomCentered(); void TestRectTopWithOffset_Should_ReturnPointAtTopWithAddedOffset_When_TopSmallerThenBottom(); void TestRectTopWithOffset_Should_ReturnPointAtTopWithSubtractedOffset_When_TopLargerThenBottom(); void TestRectRightWithOffset_Should_ReturnPointAtRightWithSubtracedOffset_When_RightSmallerThenLeft(); void TestRectRightWithOffset_Should_ReturnPointAtRightWithAddedOffset_When_RightLargerThenLeft(); void TestRectBottomWithOffset_Should_ReturnPointAtBottomWithSubtracedOffset_When_BottomSmallerThenTop(); void TestRectBottomWithOffset_Should_ReturnPointAtBottomWithAddedOffset_When_BottomLargerThenTop(); void TestRectLeftWithOffset_Should_ReturnPointAtLeftWithAddedOffset_When_LeftSmallerThenRight(); void TestRectLeftWithOffset_Should_ReturnPointAtLeftWithSubtracedOffset_When_LeftLargerThenRight(); void TestRectTopLeftWithOffset_Should_ReturnPointWithCorrectOffset(); void TestRectTopLeftWithOffset_Should_ReturnPointWithCorrectOffset_data(); void TestRectTopRightWithOffset_Should_ReturnPointWithCorrectOffset(); void TestRectTopRightWithOffset_Should_ReturnPointWithCorrectOffset_data(); void TestRectBottomLeftWithOffset_Should_ReturnPointWithCorrectOffset(); void TestRectBottomLeftWithOffset_Should_ReturnPointWithCorrectOffset_data(); void TestRectBottomRightWithOffset_Should_ReturnPointWithCorrectOffset(); void TestRectBottomRightWithOffset_Should_ReturnPointWithCorrectOffset_data(); void TestExtendLine_Should_ReturnNewLineExtendBySizeWithSameAngle(); void TestRectPointAtIndex_Should_ReturnPointAtIndexPosition(); void TestRectPointAtIndex_Should_ReturnPointAtIndexPosition_data(); void TestSetRectPointAtIndex_Should_SetRectPointAtIndexToProvidedPoint(); void TestSetRectPointAtIndex_Should_SetRectPointAtIndexToProvidedPoint_data(); void TestSmoothOut_Should_RetunSamePath_When_PathHasOnlyThreeElement(); }; #endif //KIMAGEANNOTATOR_SHAPEHELPERTEST_H kImageAnnotator-0.6.1/tests/gui/000077500000000000000000000000001440330760000165245ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/gui/annotator/000077500000000000000000000000001440330760000205315ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/gui/annotator/tabs/000077500000000000000000000000001440330760000214625ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/gui/annotator/tabs/AnnotationTabCloserTest.cpp000066400000000000000000000076661440330760000267560ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTabCloserTest.h" void AnnotationTabCloserTest::TestCloseTabTriggered_Should_CallMethodForRequestingTabCloseWithProvidedIndex_When_ProvidedIndexValid() { auto tabWidget = getTabWidgetMock(); QSignalSpy spy(tabWidget.data(), &QTabWidget::tabCloseRequested); AnnotationTabCloser tabCloser(tabWidget.data()); tabCloser.closeTabTriggered(3); QCOMPARE(spy.count(), 1); auto arguments = spy.takeFirst(); QCOMPARE(arguments.at(0).toInt(), 3); } void AnnotationTabCloserTest::TestCloseTabTriggered_Should_CallMethodForRequestingTabCloseWithCurrentIndex_When_ProvidedIndexInvalid() { auto tabWidget = getTabWidgetMock(); QSignalSpy spy(tabWidget.data(), &QTabWidget::tabCloseRequested); AnnotationTabCloser tabCloser(tabWidget.data()); tabCloser.closeTabTriggered(7); QCOMPARE(spy.count(), 1); auto arguments = spy.takeFirst(); QCOMPARE(arguments.at(0).toInt(), 2); } void AnnotationTabCloserTest::TestCloseOtherTabsTriggered_Should_CallMethodForRequestingTabCloseForAllButProvidedIndex() { auto tabWidget = getTabWidgetMock(); QSignalSpy spy(tabWidget.data(), &QTabWidget::tabCloseRequested); AnnotationTabCloser tabCloser(tabWidget.data()); tabCloser.closeOtherTabsTriggered(2); QCOMPARE(spy.count(), 4); QCOMPARE(spy[0].at(0).toInt(), 4); QCOMPARE(spy[1].at(0).toInt(), 3); QCOMPARE(spy[2].at(0).toInt(), 1); QCOMPARE(spy[3].at(0).toInt(), 0); } void AnnotationTabCloserTest::TestCloseAllTabsTriggered_Should_CallMethodForRequestingTabCloseForAllIndex() { auto tabWidget = getTabWidgetMock(); QSignalSpy spy(tabWidget.data(), &QTabWidget::tabCloseRequested); AnnotationTabCloser tabCloser(tabWidget.data()); tabCloser.closeAllTabsTriggered(); QCOMPARE(spy.count(), 5); QCOMPARE(spy[0].at(0).toInt(), 4); QCOMPARE(spy[1].at(0).toInt(), 3); QCOMPARE(spy[2].at(0).toInt(), 2); QCOMPARE(spy[3].at(0).toInt(), 1); QCOMPARE(spy[4].at(0).toInt(), 0); } void AnnotationTabCloserTest::TestCloseAllTabsToLeftTriggered_Should_CallMethodForRequestingTabCloseForAllSmallerIndex() { auto tabWidget = getTabWidgetMock(); QSignalSpy spy(tabWidget.data(), &QTabWidget::tabCloseRequested); AnnotationTabCloser tabCloser(tabWidget.data()); tabCloser.closeAllTabsToLeftTriggered(2); QCOMPARE(spy.count(), 2); QCOMPARE(spy[0].at(0).toInt(), 1); QCOMPARE(spy[1].at(0).toInt(), 0); } void AnnotationTabCloserTest::TestCloseAllTabsToRightTriggered_Should_CallMethodForRequestingTabCloseForAllLargerIndex() { auto tabWidget = getTabWidgetMock(); QSignalSpy spy(tabWidget.data(), &QTabWidget::tabCloseRequested); AnnotationTabCloser tabCloser(tabWidget.data()); tabCloser.closeAllTabsToRightTriggered(2); QCOMPARE(spy.count(), 2); QCOMPARE(spy[0].at(0).toInt(), 4); QCOMPARE(spy[1].at(0).toInt(), 3); } QSharedPointer AnnotationTabCloserTest::getTabWidgetMock() const { auto tabWidget = QSharedPointer(new QTabWidget); tabWidget->addTab(new QWidget(), QString()); tabWidget->addTab(new QWidget(), QString()); tabWidget->addTab(new QWidget(), QString()); tabWidget->addTab(new QWidget(), QString()); tabWidget->addTab(new QWidget(), QString()); tabWidget->setCurrentIndex(2); return tabWidget; } TEST_MAIN(AnnotationTabCloserTest);kImageAnnotator-0.6.1/tests/gui/annotator/tabs/AnnotationTabCloserTest.h000066400000000000000000000035631440330760000264130ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTABCLOSERTEST_H #define KIMAGEANNOTATOR_ANNOTATIONTABCLOSERTEST_H #include #include #include #include "tests/utils/TestRunner.h" #include "src/gui/annotator/tabs/AnnotationTabCloser.h" using kImageAnnotator::AnnotationTabCloser; class AnnotationTabCloserTest : public QObject { Q_OBJECT private slots: void TestCloseTabTriggered_Should_CallMethodForRequestingTabCloseWithProvidedIndex_When_ProvidedIndexValid(); void TestCloseTabTriggered_Should_CallMethodForRequestingTabCloseWithCurrentIndex_When_ProvidedIndexInvalid(); void TestCloseOtherTabsTriggered_Should_CallMethodForRequestingTabCloseForAllButProvidedIndex(); void TestCloseAllTabsTriggered_Should_CallMethodForRequestingTabCloseForAllIndex(); void TestCloseAllTabsToLeftTriggered_Should_CallMethodForRequestingTabCloseForAllSmallerIndex(); void TestCloseAllTabsToRightTriggered_Should_CallMethodForRequestingTabCloseForAllLargerIndex(); private: QSharedPointer getTabWidgetMock() const; }; #endif //KIMAGEANNOTATOR_ANNOTATIONTABCLOSERTEST_H kImageAnnotator-0.6.1/tests/gui/annotator/tabs/AnnotationTabContextMenuTest.cpp000066400000000000000000000051131440330760000277610ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AnnotationTabContextMenuTest.h" void AnnotationTabContextMenuTest::TestCustomActionTriggered_Should_CallInnerActionWithCorrectTabIndexSetInData() { auto tabIndex = 22; QAction customAction; QSignalSpy spy(&customAction, &QAction::triggered); QWidget parent; AnnotationTabContextMenu menu(&parent); menu.addCustomActions(QList{&customAction}); auto outerAction = menu.actions().last(); QTimer::singleShot(300, outerAction, &QAction::trigger); QTimer::singleShot(400, &menu, &QMenu::close); menu.show(tabIndex, {}); QCOMPARE(customAction.data().toInt(), tabIndex); QCOMPARE(spy.count(), 1); } void AnnotationTabContextMenuTest::TestAddCustomActions_Should_SetTextIconAndToolTipInOuterAction() { QAction customAction; customAction.setText(QLatin1Literal("LaLa")); customAction.setToolTip(QLatin1Literal("Hello Hello")); customAction.setIcon(QIcon()); QWidget parent; AnnotationTabContextMenu menu(&parent); menu.addCustomActions(QList{&customAction}); auto outerAction = menu.actions().last(); QCOMPARE(customAction.text(), outerAction->text()); QCOMPARE(customAction.toolTip(), outerAction->toolTip()); QCOMPARE(customAction.icon(), outerAction->icon()); } void AnnotationTabContextMenuTest::TestCustomActionChanged_Should_UpdateEnabledStateOfOuterAction() { QAction customAction; customAction.setEnabled(false); QWidget parent; AnnotationTabContextMenu menu(&parent); menu.addCustomActions(QList{&customAction}); auto outerAction = menu.actions().last(); QCOMPARE(customAction.isEnabled(), outerAction->isEnabled()); customAction.setEnabled(true); QCOMPARE(customAction.isEnabled(), outerAction->isEnabled()); } TEST_MAIN(AnnotationTabContextMenuTest);kImageAnnotator-0.6.1/tests/gui/annotator/tabs/AnnotationTabContextMenuTest.h000066400000000000000000000027101440330760000274260ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ANNOTATIONTABCONTEXTMENUTEST_H #define KIMAGEANNOTATOR_ANNOTATIONTABCONTEXTMENUTEST_H #include #include #include "tests/utils/TestRunner.h" #include "src/gui/annotator/tabs/AnnotationTabContextMenu.h" using kImageAnnotator::AnnotationTabContextMenu; class AnnotationTabContextMenuTest : public QObject { Q_OBJECT private slots: void TestCustomActionTriggered_Should_CallInnerActionWithCorrectTabIndexSetInData(); void TestAddCustomActions_Should_SetTextIconAndToolTipInOuterAction(); void TestCustomActionChanged_Should_UpdateEnabledStateOfOuterAction(); }; #endif //KIMAGEANNOTATOR_ANNOTATIONTABCONTEXTMENUTEST_H kImageAnnotator-0.6.1/tests/gui/canvasModifier/000077500000000000000000000000001440330760000214565ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/gui/canvasModifier/ModifyCanvasSelectionRestrictorTest.cpp000066400000000000000000000077551440330760000313520ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ModifyCanvasSelectionRestrictorTest.h" void ModifyCanvasSelectionRestrictorTest::TestRestrictResize_Should_ChangeResize_When_NewSizeSmallerThenMinRect() { QRectF newRect(50, 50, 400, 400); QRectF currentRect(100, 100, 200, 200); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, minRect); QCOMPARE(resizeRect, minRect); } void ModifyCanvasSelectionRestrictorTest::TestRestrictResize_Should_NotChangeResize_When_NewSizeLargerThenMinRect() { QRectF newRect(0, 0, 600, 600); QRectF currentRect(100, 100, 200, 200); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, minRect); QCOMPARE(resizeRect, newRect); } void ModifyCanvasSelectionRestrictorTest::TestRestrictResize_Should_NotChangeResize_When_NewPositionIsOutsideMinRect() { QRectF newRect(-50, -50, 400, 400); QRectF currentRect(100, 100, 200, 200); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, minRect); QCOMPARE(resizeRect, newRect); } void ModifyCanvasSelectionRestrictorTest::TestRestrictResize_Should_ChangeResize_When_NewPositionIsInsideMinRect() { QRectF newRect(50, 50, 450, 450); QRectF currentRect(-50, -50, 550, 550); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, minRect); QCOMPARE(resizeRect, minRect); } void ModifyCanvasSelectionRestrictorTest::TestRestrictMove_Should_ChangeMove_When_NewPositionAndSizeWithinMinRect() { QRectF newRect(50, 50, 500, 500); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictMove(newRect, minRect); QCOMPARE(resizeRect, minRect); } void ModifyCanvasSelectionRestrictorTest::TestRestrictMove_Should_NotChangeMove_When_NewPositionOutsideMinRect() { QRectF newRect(-50, -50, 200, 200); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictMove(newRect, minRect); QCOMPARE(resizeRect, newRect); } void ModifyCanvasSelectionRestrictorTest::TestRestrictMove_Should_ChangeMove_When_NewPositionInsideMinRect() { QRectF newRect(50, 50, 500, 500); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictMove(newRect, minRect); QCOMPARE(resizeRect, minRect); } void ModifyCanvasSelectionRestrictorTest::TestRestrictMove_Should_NotChangeMove_When_NewSizeOutsideMinRect() { QRectF newRect(300, 300, 300, 300); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictMove(newRect, minRect); QCOMPARE(resizeRect, newRect); } void ModifyCanvasSelectionRestrictorTest::TestRestrictMove_Should_ChangeMove_When_NewSizeInsideMinRect() { QRectF newRect(300, 300, 500, 500); QRectF minRect(0, 0, 500, 500); ModifyCanvasSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictMove(newRect, minRect); QCOMPARE(resizeRect, minRect); } TEST_MAIN(ModifyCanvasSelectionRestrictorTest); kImageAnnotator-0.6.1/tests/gui/canvasModifier/ModifyCanvasSelectionRestrictorTest.h000066400000000000000000000036261440330760000310100ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPSELECTIONRESTRICTORTEST_H #define KIMAGEANNOTATOR_CROPSELECTIONRESTRICTORTEST_H #include #include "tests/utils/TestRunner.h" #include "src/gui/canvasModifier/ModifyCanvasSelectionRestrictor.h" using kImageAnnotator::ModifyCanvasSelectionRestrictor; class ModifyCanvasSelectionRestrictorTest : public QObject { Q_OBJECT private slots: void TestRestrictResize_Should_ChangeResize_When_NewSizeSmallerThenMinRect(); void TestRestrictResize_Should_NotChangeResize_When_NewSizeLargerThenMinRect(); void TestRestrictResize_Should_NotChangeResize_When_NewPositionIsOutsideMinRect(); void TestRestrictResize_Should_ChangeResize_When_NewPositionIsInsideMinRect(); void TestRestrictMove_Should_ChangeMove_When_NewPositionAndSizeWithinMinRect(); void TestRestrictMove_Should_NotChangeMove_When_NewPositionOutsideMinRect(); void TestRestrictMove_Should_ChangeMove_When_NewPositionInsideMinRect(); void TestRestrictMove_Should_NotChangeMove_When_NewSizeOutsideMinRect(); void TestRestrictMove_Should_ChangeMove_When_NewSizeInsideMinRect(); }; #endif // KIMAGEANNOTATOR_CROPSELECTIONRESTRICTORTEST_H kImageAnnotator-0.6.1/tests/gui/cropper/000077500000000000000000000000001440330760000201765ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/gui/cropper/CropSelectionRestrictorTest.cpp000066400000000000000000000073251440330760000264030ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CropSelectionRestrictorTest.h" void CropSelectionRestrictorTest::TestRestrictResize_Should_NotChangeResize_When_NewSizeSmallerThenMaxRect() { QRectF newRect(50, 50, 400, 400); QRectF currentRect(100, 100, 200, 200); QRectF maxRect(0, 0, 500, 500); CropSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, maxRect); QCOMPARE(resizeRect, QRectF(50, 50, 400, 400)); } void CropSelectionRestrictorTest::TestRestrictResize_Should_ChangeResize_When_NewSizeLargerThenMaxRect() { QRectF newRect(0, 0, 600, 600); QRectF currentRect(100, 100, 200, 200); QRectF maxRect(0, 0, 500, 500); CropSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, maxRect); QCOMPARE(resizeRect, QRectF(0, 0, 500, 500)); } void CropSelectionRestrictorTest::TestRestrictResize_Should_ChangeResize_When_NewPositionIsOutsideMaxRect() { QRectF newRect(-50, -50, 400, 400); QRectF currentRect(100, 100, 200, 200); QRectF maxRect(0, 0, 500, 500); CropSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, maxRect); QCOMPARE(resizeRect, QRectF(0, 0, 350, 350)); } void CropSelectionRestrictorTest::TestRestrictResize_Should_ChangeResize_When_NewPositionHasNegativeWidth() { QRectF newRect(50, 50, -400, 400); QRectF currentRect(50, 50, 200, 200); QRectF maxRect(0, 0, 500, 500); CropSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, maxRect); QCOMPARE(resizeRect, QRectF(50, 50, 0, 400)); } void CropSelectionRestrictorTest::TestRestrictResize_Should_ChangeResize_When_NewPositionHasNegativeHeight() { QRectF newRect(50, 50, 400, -400); QRectF currentRect(50, 50, 200, 200); QRectF maxRect(0, 0, 500, 500); CropSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictResize(newRect, currentRect, maxRect); QCOMPARE(resizeRect, QRectF(50, 50, 400, 0)); } void CropSelectionRestrictorTest::TestRestrictMove_Should_NotChangeMove_When_NewPositionAndSizeWithinMaxRect() { QRectF newRect(50, 50, 400, 400); QRectF maxRect(0, 0, 500, 500); CropSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictMove(newRect, maxRect); QCOMPARE(resizeRect, QRectF(50, 50, 400, 400)); } void CropSelectionRestrictorTest::TestRestrictMove_Should_ChangeMove_When_NewPositionOutsideMaxRect() { QRectF newRect(-50, -50, 200, 200); QRectF maxRect(0, 0, 500, 500); CropSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictMove(newRect, maxRect); QCOMPARE(resizeRect, QRectF(0, 0, 200, 200)); } void CropSelectionRestrictorTest::TestRestrictMove_Should_ChangeMove_When_NewSizeOutsideMaxRect() { QRectF newRect(300, 300, 300, 300); QRectF maxRect(0, 0, 500, 500); CropSelectionRestrictor restrictor; auto resizeRect = restrictor.restrictMove(newRect, maxRect); QCOMPARE(resizeRect, QRectF(200, 200, 300, 300)); } TEST_MAIN(CropSelectionRestrictorTest); kImageAnnotator-0.6.1/tests/gui/cropper/CropSelectionRestrictorTest.h000066400000000000000000000034641440330760000260500ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CROPSELECTIONRESTRICTORTEST_H #define KIMAGEANNOTATOR_CROPSELECTIONRESTRICTORTEST_H #include #include "tests/utils/TestRunner.h" #include "src/gui/cropper/CropSelectionRestrictor.h" using kImageAnnotator::CropSelectionRestrictor; class CropSelectionRestrictorTest : public QObject { Q_OBJECT private slots: void TestRestrictResize_Should_NotChangeResize_When_NewSizeSmallerThenMaxRect(); void TestRestrictResize_Should_ChangeResize_When_NewSizeLargerThenMaxRect(); void TestRestrictResize_Should_ChangeResize_When_NewPositionIsOutsideMaxRect(); void TestRestrictResize_Should_ChangeResize_When_NewPositionHasNegativeWidth(); void TestRestrictResize_Should_ChangeResize_When_NewPositionHasNegativeHeight(); void TestRestrictMove_Should_NotChangeMove_When_NewPositionAndSizeWithinMaxRect(); void TestRestrictMove_Should_ChangeMove_When_NewPositionOutsideMaxRect(); void TestRestrictMove_Should_ChangeMove_When_NewSizeOutsideMaxRect(); }; #endif // KIMAGEANNOTATOR_CROPSELECTIONRESTRICTORTEST_H kImageAnnotator-0.6.1/tests/gui/scaler/000077500000000000000000000000001440330760000177755ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/gui/scaler/ScaleSizeHandlerTest.cpp000066400000000000000000000153011440330760000245210ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ScaleSizeHandlerTest.h" void ScaleSizeHandlerTest::TestSetWidthPixel_Should_UpdatePercentCorrectly() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); QSignalSpy spy(&sizeHandler, &ScaleSizeHandler::widthPercentChanged); sizeHandler.setWidthPixel(250); QCOMPARE(spy.count(), 1); auto resultValue = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultValue, 50); } void ScaleSizeHandlerTest::TestSetHeightPixel_Should_UpdatePercentCorrectly() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); QSignalSpy spy(&sizeHandler, &ScaleSizeHandler::heightPercentChanged); sizeHandler.setHeightPixel(250); QCOMPARE(spy.count(), 1); auto resultValue = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultValue, 50); } void ScaleSizeHandlerTest::TestSetWidthPercent_Should_UpdatePixelCorrectly() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); QSignalSpy spy(&sizeHandler, &ScaleSizeHandler::widthPixelChanged); sizeHandler.setWidthPercent(50); QCOMPARE(spy.count(), 1); auto resultValue = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultValue, 250); } void ScaleSizeHandlerTest::TestSetHeightPercent_Should_UpdatePixelCorrectly() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); QSignalSpy spy(&sizeHandler, &ScaleSizeHandler::heightPixelChanged); sizeHandler.setHeightPercent(50); QCOMPARE(spy.count(), 1); auto resultValue = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultValue, 250); } void ScaleSizeHandlerTest::TestSetWidthPixel_Should_NotUpdateHeight_When_KeepAspectRatioNotSet() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); sizeHandler.setAspectRatio(false); QSignalSpy percentSpy(&sizeHandler, &ScaleSizeHandler::heightPercentChanged); QSignalSpy pixelSpy(&sizeHandler, &ScaleSizeHandler::heightPixelChanged); sizeHandler.setWidthPixel(250); QCOMPARE(percentSpy.count(), 0); QCOMPARE(pixelSpy.count(), 0); } void ScaleSizeHandlerTest::TestSetWidthPixel_Should_UpdateHeight_When_KeepAspectRatioIsSet() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); sizeHandler.setAspectRatio(true); QSignalSpy percentSpy(&sizeHandler, &ScaleSizeHandler::heightPercentChanged); QSignalSpy pixelSpy(&sizeHandler, &ScaleSizeHandler::heightPixelChanged); sizeHandler.setWidthPixel(250); QCOMPARE(percentSpy.count(), 1); QCOMPARE(pixelSpy.count(), 1); auto percent = qvariant_cast(percentSpy.at(0).at(0)); auto pixel = qvariant_cast(pixelSpy.at(0).at(0)); QCOMPARE(percent, 50); QCOMPARE(pixel, 250); } void ScaleSizeHandlerTest::TestSetWidthPercent_Should_NotUpdateHeight_When_KeepAspectRatioNotSet() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); sizeHandler.setAspectRatio(false); QSignalSpy percentSpy(&sizeHandler, &ScaleSizeHandler::heightPercentChanged); QSignalSpy pixelSpy(&sizeHandler, &ScaleSizeHandler::heightPixelChanged); sizeHandler.setWidthPercent(50); QCOMPARE(percentSpy.count(), 0); QCOMPARE(pixelSpy.count(), 0); } void ScaleSizeHandlerTest::TestSetWidthPercent_Should_UpdateHeight_When_KeepAspectRatioIsSet() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); sizeHandler.setAspectRatio(true); QSignalSpy percentSpy(&sizeHandler, &ScaleSizeHandler::heightPercentChanged); QSignalSpy pixelSpy(&sizeHandler, &ScaleSizeHandler::heightPixelChanged); sizeHandler.setWidthPercent(50); QCOMPARE(percentSpy.count(), 1); QCOMPARE(pixelSpy.count(), 1); auto percent = qvariant_cast(percentSpy.at(0).at(0)); auto pixel = qvariant_cast(pixelSpy.at(0).at(0)); QCOMPARE(percent, 50); QCOMPARE(pixel, 250); } void ScaleSizeHandlerTest::TestSetHeightPixel_Should_NotUpdateWidth_When_KeepAspectRatioNotSet() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); sizeHandler.setAspectRatio(false); QSignalSpy percentSpy(&sizeHandler, &ScaleSizeHandler::widthPercentChanged); QSignalSpy pixelSpy(&sizeHandler, &ScaleSizeHandler::widthPixelChanged); sizeHandler.setHeightPixel(250); QCOMPARE(percentSpy.count(), 0); QCOMPARE(pixelSpy.count(), 0); } void ScaleSizeHandlerTest::TestSetHeightPixel_Should_UpdateWidth_When_KeepAspectRatioIsSet() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); sizeHandler.setAspectRatio(true); QSignalSpy percentSpy(&sizeHandler, &ScaleSizeHandler::widthPercentChanged); QSignalSpy pixelSpy(&sizeHandler, &ScaleSizeHandler::widthPixelChanged); sizeHandler.setHeightPixel(250); QCOMPARE(percentSpy.count(), 1); QCOMPARE(pixelSpy.count(), 1); auto percent = qvariant_cast(percentSpy.at(0).at(0)); auto pixel = qvariant_cast(pixelSpy.at(0).at(0)); QCOMPARE(percent, 50); QCOMPARE(pixel, 250); } void ScaleSizeHandlerTest::TestSetHeightPercent_Should_NotUpdateWidth_When_KeepAspectRatioNotSet() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); sizeHandler.setAspectRatio(false); QSignalSpy percentSpy(&sizeHandler, &ScaleSizeHandler::widthPercentChanged); QSignalSpy pixelSpy(&sizeHandler, &ScaleSizeHandler::widthPixelChanged); sizeHandler.setHeightPercent(50); QCOMPARE(percentSpy.count(), 0); QCOMPARE(pixelSpy.count(), 0); } void ScaleSizeHandlerTest::TestSetHeightPercent_Should_UpdateWidth_When_KeepAspectRatioIsSet() { QSize size(500, 500); ScaleSizeHandler sizeHandler; sizeHandler.setSize(size); sizeHandler.setAspectRatio(true); QSignalSpy percentSpy(&sizeHandler, &ScaleSizeHandler::widthPercentChanged); QSignalSpy pixelSpy(&sizeHandler, &ScaleSizeHandler::widthPixelChanged); sizeHandler.setHeightPercent(50); QCOMPARE(percentSpy.count(), 1); QCOMPARE(pixelSpy.count(), 1); auto percent = qvariant_cast(percentSpy.at(0).at(0)); auto pixel = qvariant_cast(pixelSpy.at(0).at(0)); QCOMPARE(percent, 50); QCOMPARE(pixel, 250); } TEST_MAIN(ScaleSizeHandlerTest); kImageAnnotator-0.6.1/tests/gui/scaler/ScaleSizeHandlerTest.h000066400000000000000000000037261440330760000241760ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SCALESIZEHANDLERTEST_H #define KIMAGEANNOTATOR_SCALESIZEHANDLERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/gui/scaler/ScaleSizeHandler.h" using kImageAnnotator::ScaleSizeHandler; class ScaleSizeHandlerTest : public QObject { Q_OBJECT private slots: void TestSetWidthPixel_Should_UpdatePercentCorrectly(); void TestSetHeightPixel_Should_UpdatePercentCorrectly(); void TestSetWidthPercent_Should_UpdatePixelCorrectly(); void TestSetHeightPercent_Should_UpdatePixelCorrectly(); void TestSetWidthPixel_Should_NotUpdateHeight_When_KeepAspectRatioNotSet(); void TestSetWidthPixel_Should_UpdateHeight_When_KeepAspectRatioIsSet(); void TestSetWidthPercent_Should_NotUpdateHeight_When_KeepAspectRatioNotSet(); void TestSetWidthPercent_Should_UpdateHeight_When_KeepAspectRatioIsSet(); void TestSetHeightPixel_Should_NotUpdateWidth_When_KeepAspectRatioNotSet(); void TestSetHeightPixel_Should_UpdateWidth_When_KeepAspectRatioIsSet(); void TestSetHeightPercent_Should_NotUpdateWidth_When_KeepAspectRatioNotSet(); void TestSetHeightPercent_Should_UpdateWidth_When_KeepAspectRatioIsSet(); }; #endif // KIMAGEANNOTATOR_SCALESIZEHANDLERTEST_H kImageAnnotator-0.6.1/tests/gui/selection/000077500000000000000000000000001440330760000205115ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/gui/selection/SelectionHandlerTest.cpp000066400000000000000000000246011440330760000253030ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SelectionHandlerTest.h" void SelectionHandlerTest::SetWidth_Should_EmitSelectionChangedSignal() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); QSignalSpy spy(&selectionHandler, &SelectionHandler::selectionChanged); // act selectionHandler.setWidth(30); // assert QCOMPARE(spy.count(), 1); } void SelectionHandlerTest::SetHeight_Should_EmitSelectionChangedSignal() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); QSignalSpy spy(&selectionHandler, &SelectionHandler::selectionChanged); // act selectionHandler.setHeight(30); // assert QCOMPARE(spy.count(), 1); } void SelectionHandlerTest::SetPositionX_Should_EmitSelectionChangedSignal() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); QSignalSpy spy(&selectionHandler, &SelectionHandler::selectionChanged); // act selectionHandler.setPositionY(30); // assert QCOMPARE(spy.count(), 1); } void SelectionHandlerTest::SetPositionY_Should_EmitSelectionChangedSignal() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); QSignalSpy spy(&selectionHandler, &SelectionHandler::selectionChanged); // act selectionHandler.setPositionX(30); // assert QCOMPARE(spy.count(), 1); } void SelectionHandlerTest::ResetSelection_Should_SetSelectionToProvidedRect() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); auto sceneRect = QRectF(0, 0, 500, 500); annotationArea.setSceneRect(sceneRect); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); selectionHandler.setWidth(400); QVERIFY(selectionHandler.selection() != sceneRect); // act selectionHandler.resetSelection(sceneRect, sceneRect); // assert QCOMPARE(selectionHandler.selection(), sceneRect); } void SelectionHandlerTest::IsInMotion_Should_ReturnTrue_WhenClickedOnSelection() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); EXPECT_CALL(*selectionHandles, grabHandle(testing::_, testing::_)).Times(testing::AnyNumber()); EXPECT_CALL(*selectionHandles, isHandleGrabbed()).WillRepeatedly(testing::Return(false)); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); auto sceneRect = QRectF(0, 0, 500, 500); auto position = QPointF(150, 150); annotationArea.setSceneRect(sceneRect); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); selectionHandler.resetSelection(sceneRect, sceneRect); selectionHandler.grab(position); // act auto isInMotion = selectionHandler.isInMotion(); // assert QCOMPARE(isInMotion, true); } void SelectionHandlerTest::IsInMotion_Should_ReturnTrue_WhenClickedOnHandle() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); EXPECT_CALL(*selectionHandles, isHandleGrabbed()).WillRepeatedly(testing::Return(true)); EXPECT_CALL(*selectionHandles, grabHandle(testing::_, testing::_)).Times(testing::AnyNumber()); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); auto sceneRect = QRectF(0, 0, 500, 500); auto position = QPointF(2, 2); annotationArea.setSceneRect(sceneRect); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); selectionHandler.grab(position); // act auto isInMotion = selectionHandler.isInMotion(); // assert QCOMPARE(isInMotion, true); } void SelectionHandlerTest::IsInMotion_Should_ReturnFalse_WhenClickedOutsideSelectionAndHandle() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); EXPECT_CALL(*selectionHandles, grabHandle(testing::_, testing::_)).Times(testing::AnyNumber()); EXPECT_CALL(*selectionHandles, isHandleGrabbed()).WillRepeatedly(testing::Return(false)); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); auto sceneRect = QRectF(0, 0, 500, 500); auto position = QPointF(400, 400); annotationArea.setSceneRect(sceneRect); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); selectionHandler.setWidth(200); selectionHandler.grab(position); // act auto isInMotion = selectionHandler.isInMotion(); // assert QCOMPARE(isInMotion, false); } void SelectionHandlerTest::RestrictResize_Should_KeepCurrentSelection_When_NewSelectionHasNegativeWidthAndRestrictionDisabled() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); selectionHandler.setRestrictionEnabled(false); auto selectionBefore = selectionHandler.selection(); // act selectionHandler.setWidth(-30); // assert auto selectionAfter = selectionHandler.selection(); QCOMPARE(selectionBefore, selectionAfter); QVERIFY(selectionAfter.width() >= 0); } void SelectionHandlerTest::RestrictResize_Should_KeepCurrentSelection_When_NewSelectionHasNegativeHeightAndRestrictionDisabled() { // arrange MockDefaultParameters parameters; auto scalerMock = new MockDevicePixelRatioScaler(); auto selectionRestrictor = new MockSelectionRestrictor(); auto selectionHandles = QSharedPointer(new SelectionHandlesMock()); EXPECT_CALL(*selectionHandles, updateHandles(testing::_)).Times(testing::AnyNumber()); AnnotationArea annotationArea(¶meters.config, ¶meters.settingsProvider, scalerMock, ¶meters.zoomValueProvider, nullptr); SelectionHandler selectionHandler(selectionRestrictor, selectionHandles); selectionHandler.init(&annotationArea); selectionHandler.setRestrictionEnabled(false); auto selectionBefore = selectionHandler.selection(); // act selectionHandler.setHeight(-30); // assert auto selectionAfter = selectionHandler.selection(); QCOMPARE(selectionBefore, selectionAfter); QVERIFY(selectionAfter.height() >= 0.0); } TEST_MAIN(SelectionHandlerTest) kImageAnnotator-0.6.1/tests/gui/selection/SelectionHandlerTest.h000066400000000000000000000040661440330760000247530ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SELECTIONHANDLERTEST_H #define KIMAGEANNOTATOR_SELECTIONHANDLERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/annotations/core/AnnotationArea.h" #include "src/gui/selection/SelectionHandler.h" #include "tests/mocks/MockDefaultParameters.h" #include "tests/mocks/MockSelectionRestrictor.h" #include "tests/mocks/gui/selection/SelectionHandlesMock.h" using kImageAnnotator::AnnotationArea; using kImageAnnotator::SelectionHandler; class SelectionHandlerTest : public QObject { Q_OBJECT private slots: void SetWidth_Should_EmitSelectionChangedSignal(); void SetHeight_Should_EmitSelectionChangedSignal(); void SetPositionX_Should_EmitSelectionChangedSignal(); void SetPositionY_Should_EmitSelectionChangedSignal(); void ResetSelection_Should_SetSelectionToProvidedRect(); void IsInMotion_Should_ReturnTrue_WhenClickedOnSelection(); void IsInMotion_Should_ReturnTrue_WhenClickedOnHandle(); void IsInMotion_Should_ReturnFalse_WhenClickedOutsideSelectionAndHandle(); void RestrictResize_Should_KeepCurrentSelection_When_NewSelectionHasNegativeWidthAndRestrictionDisabled(); void RestrictResize_Should_KeepCurrentSelection_When_NewSelectionHasNegativeHeightAndRestrictionDisabled(); }; #endif // KIMAGEANNOTATOR_SELECTIONHANDLERTEST_H kImageAnnotator-0.6.1/tests/gui/selection/SelectionHandlesAllTest.cpp000066400000000000000000000074031440330760000257360ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SelectionHandlesAllTest.h" void SelectionHandlesAllTest::TestIsHandleGrabbed_Should_ReturnTrue_When_ClickedOnHandle() { QRectF selection(0, 0, 500, 500); auto halfHandle = ResizeHandleSize / 2; QPointF position(halfHandle, halfHandle); SelectionHandlesAll handles; handles.updateHandles(selection); handles.grabHandle(position, selection); auto isHandleGrabbed = handles.isHandleGrabbed(); QCOMPARE(isHandleGrabbed, true); } void SelectionHandlesAllTest::TestIsHandleGrabbed_Should_ReturnFalse_When_ClickedOutsideHandle() { QRectF selection(0, 0, 500, 500); QPointF position(300, 300); SelectionHandlesAll handles; handles.updateHandles(selection); handles.grabHandle(position, selection); auto isHandleGrabbed = handles.isHandleGrabbed(); QCOMPARE(isHandleGrabbed, false); } void SelectionHandlesAllTest::TestGrabbedIndex_Should_ReturnIndexOfHandle_When_ClickedOnHandle() { QRectF selection(0, 0, 500, 500); auto halfHandle = ResizeHandleSize / 2; QPointF position(halfHandle, halfHandle); SelectionHandlesAll handles; handles.updateHandles(selection); handles.grabHandle(position, selection); auto grabbedIndex = handles.grabbedIndex(); QCOMPARE(grabbedIndex, 0); } void SelectionHandlesAllTest::TestGrabbedIndex_Should_ReturnMinusOne_When_ClickedOutsideHandle() { QRectF selection(0, 0, 500, 500); QPointF position(300, 300); SelectionHandlesAll handles; handles.updateHandles(selection); handles.grabHandle(position, selection); auto grabbedIndex = handles.grabbedIndex(); QCOMPARE(grabbedIndex, -1); } void SelectionHandlesAllTest::TestGrabOffset_Should_ReturnClickOffsetForHandle() { QRectF selection(0, 0, 500, 500); auto halfHandle = ResizeHandleSize / 2; QPointF position(halfHandle, halfHandle); SelectionHandlesAll handles; handles.updateHandles(selection); handles.grabHandle(position, selection); auto grabOffset = handles.grabOffset(); QCOMPARE(grabOffset, QPointF(halfHandle, halfHandle)); } void SelectionHandlesAllTest::TestUpdateHandles_Should_PositionHandlesOnCorrectPlaces() { QRectF selection(0, 0, 500, 500); SelectionHandlesAll selectionHandles; selectionHandles.updateHandles(selection); auto handles = selectionHandles.handles(); QCOMPARE(handles[0].topLeft(), QPointF(0, 0)); QCOMPARE(handles[1].topLeft(), QPointF(selection.width() / 2 - ResizeHandleSize / 2, 0)); QCOMPARE(handles[2].topLeft(), QPointF(selection.width() - ResizeHandleSize, 0)); QCOMPARE(handles[3].topLeft(), QPointF(selection.width() - ResizeHandleSize, selection.height() / 2 - ResizeHandleSize / 2)); QCOMPARE(handles[4].topLeft(), QPointF(selection.width() - ResizeHandleSize, selection.height() - ResizeHandleSize)); QCOMPARE(handles[5].topLeft(), QPointF(selection.width() / 2 - ResizeHandleSize / 2, selection.height() - ResizeHandleSize)); QCOMPARE(handles[6].topLeft(), QPointF(0, selection.height() - ResizeHandleSize)); QCOMPARE(handles[7].topLeft(), QPointF(0, selection.height() / 2 - ResizeHandleSize / 2)); } TEST_MAIN(SelectionHandlesAllTest); kImageAnnotator-0.6.1/tests/gui/selection/SelectionHandlesAllTest.h000066400000000000000000000031651440330760000254040ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SELECTIONHANDLESALLTEST_H #define KIMAGEANNOTATOR_SELECTIONHANDLESALLTEST_H #include #include "tests/utils/TestRunner.h" #include "src/gui/selection/SelectionHandlesAll.h" using kImageAnnotator::SelectionHandlesAll; using kImageAnnotator::Constants::ResizeHandleSize; class SelectionHandlesAllTest : public QObject { Q_OBJECT private slots: void TestIsHandleGrabbed_Should_ReturnTrue_When_ClickedOnHandle(); void TestIsHandleGrabbed_Should_ReturnFalse_When_ClickedOutsideHandle(); void TestGrabbedIndex_Should_ReturnIndexOfHandle_When_ClickedOnHandle(); void TestGrabbedIndex_Should_ReturnMinusOne_When_ClickedOutsideHandle(); void TestGrabOffset_Should_ReturnClickOffsetForHandle(); void TestUpdateHandles_Should_PositionHandlesOnCorrectPlaces(); }; #endif // KIMAGEANNOTATOR_SELECTIONHANDLESALLTEST_H kImageAnnotator-0.6.1/tests/gui/selection/SelectionMoveHelperTest.cpp000066400000000000000000000041351440330760000257740ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SelectionMoveHelperTest.h" void SelectionMoveHelperTest::TestGrabSelection_Should_GrabSelection_WhenPositionWithinSelection() { QRectF selection(100, 100, 300, 300); QPointF position(150, 150); SelectionMoveHelper moveHelper; moveHelper.grabSelection(position, selection); QCOMPARE(moveHelper.isSelectionGabbed(), true); } void SelectionMoveHelperTest::TestGrabSelection_Should_NotGrabSelection_WhenPositionOutsideSelection() { QRectF selection(100, 100, 300, 300); QPointF position(50, 50); SelectionMoveHelper moveHelper; moveHelper.grabSelection(position, selection); QCOMPARE(moveHelper.isSelectionGabbed(), false); } void SelectionMoveHelperTest::TestGrabSelection_Should_SetCorrectOffset() { QRectF selection(100, 100, 300, 300); QPointF position(150, 150); SelectionMoveHelper moveHelper; moveHelper.grabSelection(position, selection); QCOMPARE(moveHelper.grabOffset(), QPointF(50, 50)); } void SelectionMoveHelperTest::TestReleaseSelection_Should_ReleaseSelection() { QRectF selection(100, 100, 300, 300); QPointF position(150, 150); SelectionMoveHelper moveHelper; moveHelper.grabSelection(position, selection); QCOMPARE(moveHelper.isSelectionGabbed(), true); moveHelper.releaseSelection(); QCOMPARE(moveHelper.isSelectionGabbed(), false); } TEST_MAIN(SelectionMoveHelperTest); kImageAnnotator-0.6.1/tests/gui/selection/SelectionMoveHelperTest.h000066400000000000000000000026521440330760000254430ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SELECTIONMOVEHELPERTEST_H #define KIMAGEANNOTATOR_SELECTIONMOVEHELPERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/gui/selection/SelectionMoveHelper.h" using kImageAnnotator::SelectionMoveHelper; class SelectionMoveHelperTest : public QObject { Q_OBJECT private slots: void TestGrabSelection_Should_GrabSelection_WhenPositionWithinSelection(); void TestGrabSelection_Should_NotGrabSelection_WhenPositionOutsideSelection(); void TestGrabSelection_Should_SetCorrectOffset(); void TestReleaseSelection_Should_ReleaseSelection(); }; #endif // KIMAGEANNOTATOR_SELECTIONMOVEHELPERTEST_H kImageAnnotator-0.6.1/tests/mocks/000077500000000000000000000000001440330760000170545ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/mocks/MockDefaultParameters.h000066400000000000000000000033161440330760000234520ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MOCKDEFAULTPARAMETERS_H #define KIMAGEANNOTATOR_MOCKDEFAULTPARAMETERS_H #include "MockZoomValueProvider.h" #include "MockSettingsProvider.h" #include "MockDevicePixelRatioScaler.h" #include "tests/mocks/backend/SettingsMock.h" #include "src/backend/Config.h" using kImageAnnotator::Config; struct MockDefaultParameters { MockDefaultParameters() : mSettings(new SettingsMock), config(QSharedPointer(mSettings)) { EXPECT_CALL(*mSettings, value(testing::_, testing::_)).WillRepeatedly(testing::Return(QVariant())); EXPECT_CALL(*mSettings, setValue(testing::_, testing::_)).Times(testing::AnyNumber()); EXPECT_CALL(*mSettings, sync()).Times(testing::AnyNumber()); } private: QSharedPointer mSettings; public: Config config; MockSettingsProvider settingsProvider; MockZoomValueProvider zoomValueProvider; }; #endif // KIMAGEANNOTATOR_MOCKDEFAULTPARAMETERS_H kImageAnnotator-0.6.1/tests/mocks/MockDevicePixelRatioScaler.cpp000066400000000000000000000024041440330760000247240ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "MockDevicePixelRatioScaler.h" MockDevicePixelRatioScaler::MockDevicePixelRatioScaler() : mScaleFactor(1.0) { } QRectF MockDevicePixelRatioScaler::scale(const QRectF &rect) const { return {rect.left() * mScaleFactor, rect.top() * mScaleFactor, rect.width() * mScaleFactor, rect.height() * mScaleFactor}; } qreal MockDevicePixelRatioScaler::scaleFactor() const { return mScaleFactor; } void MockDevicePixelRatioScaler::setScaleFactor(qreal factor) { mScaleFactor = factor; } kImageAnnotator-0.6.1/tests/mocks/MockDevicePixelRatioScaler.h000066400000000000000000000025641440330760000244000ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MOCKDEVICEPIXELRATIOSCALER_H #define KIMAGEANNOTATOR_MOCKDEVICEPIXELRATIOSCALER_H #include #include "src/common/provider/IDevicePixelRatioScaler.h" using kImageAnnotator::IDevicePixelRatioScaler; class MockDevicePixelRatioScaler : public IDevicePixelRatioScaler { public: MockDevicePixelRatioScaler(); ~MockDevicePixelRatioScaler() override = default; QRectF scale(const QRectF &rect) const override; qreal scaleFactor() const override; void setScaleFactor(qreal factor); private: qreal mScaleFactor; }; #endif //KIMAGEANNOTATOR_MOCKDEVICEPIXELRATIOSCALER_H kImageAnnotator-0.6.1/tests/mocks/MockSelectionRestrictor.cpp000066400000000000000000000021201440330760000243730ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "MockSelectionRestrictor.h" QRectF &MockSelectionRestrictor::restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const { return newRect; } QRectF &MockSelectionRestrictor::restrictMove(QRectF &newRect, const QRectF &rectLimit) const { return newRect; } kImageAnnotator-0.6.1/tests/mocks/MockSelectionRestrictor.h000066400000000000000000000026341440330760000240520ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MOCKSELECTIONRESTRICTOR_H #define KIMAGEANNOTATOR_MOCKSELECTIONRESTRICTOR_H #include #include "src/gui/selection/ISelectionRestrictor.h" using kImageAnnotator::ISelectionRestrictor; class MockSelectionRestrictor : public ISelectionRestrictor { public: explicit MockSelectionRestrictor() = default; ~MockSelectionRestrictor() override = default; QRectF &restrictResize(QRectF &newRect, const QRectF ¤tRect, const QRectF &rectLimit) const override; QRectF &restrictMove(QRectF &newRect, const QRectF &rectLimit) const override; }; #endif //KIMAGEANNOTATOR_MOCKSELECTIONRESTRICTOR_H kImageAnnotator-0.6.1/tests/mocks/MockSettingsProvider.cpp000066400000000000000000000053251440330760000237120ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "MockSettingsProvider.h" void MockSettingsProvider::editItem(AbstractAnnotationItem *item) { } void MockSettingsProvider::activateSelectTool() { } Tools MockSettingsProvider::toolType() const { return mToolType; } QColor MockSettingsProvider::toolColor() const { return mToolColor; } QColor MockSettingsProvider::textColor() const { return mTextColor; } int MockSettingsProvider::toolWidth() const { return mToolWidth; } QFont MockSettingsProvider::font() const { return mFont; } FillModes MockSettingsProvider::fillType() const { return mFillType; } int MockSettingsProvider::obfuscationFactor() const { return mBlurRadius; } void MockSettingsProvider::setToolType(Tools tool) { mToolType = tool; } void MockSettingsProvider::setToolColor(const QColor &toolColor) { mToolColor = toolColor; } void MockSettingsProvider::setTextColor(const QColor &textColor) { mTextColor = textColor; } void MockSettingsProvider::setToolWidth(int toolWidth) { mToolWidth = toolWidth; } void MockSettingsProvider::setFont(const QFont &font) { mFont = font; } void MockSettingsProvider::setFillType(FillModes fillMode) { mFillType = fillMode; } void MockSettingsProvider::setBlurRadius(int blurRadius) { mBlurRadius = blurRadius; } QString MockSettingsProvider::sticker() const { return mStickerPath; } ImageEffects MockSettingsProvider::effect() const { return ImageEffects::NoEffect; } qreal MockSettingsProvider::scaling() const { return 1.0; } qreal MockSettingsProvider::opacity() const { return 1.0; } bool MockSettingsProvider::shadowEnabled() const { return mShadowEnabled; } void MockSettingsProvider::setSticker(const QString &stickerPath) { mStickerPath = stickerPath; } void MockSettingsProvider::updateZoomLevel(double value) { mZoomLevel = value; } void MockSettingsProvider::updateNumberToolSeed(int numberToolSeed) { } void MockSettingsProvider::setShadowEnabled(bool enabled) { mShadowEnabled = enabled; } kImageAnnotator-0.6.1/tests/mocks/MockSettingsProvider.h000066400000000000000000000046321440330760000233570ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MOCKSETTINGSPROVIDER_H #define KIMAGEANNOTATOR_MOCKSETTINGSPROVIDER_H #include "src/annotations/core/AbstractSettingsProvider.h" using kImageAnnotator::AbstractSettingsProvider; using kImageAnnotator::AbstractAnnotationItem; using kImageAnnotator::Tools; using kImageAnnotator::FillModes; using kImageAnnotator::ImageEffects; class MockSettingsProvider : public AbstractSettingsProvider { public: void editItem(AbstractAnnotationItem *item) override; void activateSelectTool() override; Tools toolType() const override; void setToolType(Tools tool); QColor toolColor() const override; void setToolColor(const QColor &toolColor); QColor textColor() const override; void setTextColor(const QColor &textColor); int toolWidth() const override; void setToolWidth(int toolWidth); QFont font() const override; void setFont(const QFont &font); FillModes fillType() const override; void setFillType(FillModes fillMode); int obfuscationFactor() const override; void setBlurRadius(int blurRadius); QString sticker() const override; void setSticker(const QString &stickerPath); ImageEffects effect() const override; qreal scaling() const override; qreal opacity() const override; bool shadowEnabled() const override; void setShadowEnabled(bool enabled); void updateNumberToolSeed(int numberToolSeed) override; void updateZoomLevel(double value) override; private: Tools mToolType; QColor mToolColor; QColor mTextColor; int mToolWidth; QFont mFont; FillModes mFillType; int mBlurRadius; QString mStickerPath; double mZoomLevel; bool mShadowEnabled; }; #endif //KIMAGEANNOTATOR_MOCKSETTINGSPROVIDER_H kImageAnnotator-0.6.1/tests/mocks/MockZoomValueProvider.cpp000066400000000000000000000023101440330760000240220ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "MockZoomValueProvider.h" MockZoomValueProvider::MockZoomValueProvider(QObject *parent) : ZoomValueProvider(parent), mZoomValue(1.0) { } double MockZoomValueProvider::zoomValue() const { return mZoomValue; } void MockZoomValueProvider::setZoomValue(double value) { if (value == mZoomValue) return; mZoomValue = value; emit zoomValueChanged(value); } void MockZoomValueProvider::fitImageToView() { } kImageAnnotator-0.6.1/tests/mocks/MockZoomValueProvider.h000066400000000000000000000024621440330760000234770ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_MOCKZOOMVALUEPROVIDER_H #define KIMAGEANNOTATOR_MOCKZOOMVALUEPROVIDER_H #include "src/annotations/core/ZoomValueProvider.h" using kImageAnnotator::ZoomValueProvider; class MockZoomValueProvider : public ZoomValueProvider { Q_OBJECT public: explicit MockZoomValueProvider(QObject *parent = nullptr); double zoomValue() const override; void setZoomValue(double value) override; void fitImageToView() override; private: double mZoomValue; }; #endif // KIMAGEANNOTATOR_MOCKZOOMVALUEPROVIDER_H kImageAnnotator-0.6.1/tests/mocks/backend/000077500000000000000000000000001440330760000204435ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/mocks/backend/SettingsMock.h000066400000000000000000000025111440330760000232250ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SETTINGSMOCK_H #define KIMAGEANNOTATOR_SETTINGSMOCK_H #include "src/backend/ISettings.h" using kImageAnnotator::ISettings; class SettingsMock : public ISettings { public: explicit SettingsMock() = default; ~SettingsMock() override = default; MOCK_METHOD(void, sync, (), (override)); MOCK_METHOD(void, setValue, (const QString &key, const QVariant &value), (override)); MOCK_METHOD(QVariant, value, (const QString &key, const QVariant &defaultValue), (const, override)); }; #endif //KIMAGEANNOTATOR_SETTINGSMOCK_H kImageAnnotator-0.6.1/tests/mocks/gui/000077500000000000000000000000001440330760000176405ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/mocks/gui/selection/000077500000000000000000000000001440330760000216255ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/mocks/gui/selection/SelectionHandlesMock.h000066400000000000000000000033221440330760000260340ustar00rootroot00000000000000/* * Copyright (C) 2022 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_SELECTIONHANDLESMOCK_H #define KIMAGEANNOTATOR_SELECTIONHANDLESMOCK_H #include #include "src/gui/selection/ISelectionHandles.h" using kImageAnnotator::ISelectionHandles; class SelectionHandlesMock : public ISelectionHandles { public: explicit SelectionHandlesMock() = default; ~SelectionHandlesMock() override = default; MOCK_METHOD(QList, handles, (), (const, override)); MOCK_METHOD(void, grabHandle, (const QPointF &position, const QRectF &selection), (override)); MOCK_METHOD(void, releaseHandle, (), (override)); MOCK_METHOD(int, grabbedIndex, (), (const, override)); MOCK_METHOD(void, updateHandles, (const QRectF &selection), (override)); MOCK_METHOD(bool, isHandleGrabbed, (), (const, override)); MOCK_METHOD(QPointF, grabOffset, (), (const, override)); MOCK_METHOD(void, applyZoomValue, (double value), (override)); }; #endif //KIMAGEANNOTATOR_SELECTIONHANDLESMOCK_H kImageAnnotator-0.6.1/tests/utils/000077500000000000000000000000001440330760000171005ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/utils/TestRunner.h000066400000000000000000000066741440330760000213770ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ /* * Example taken from https://rodolfotech.blogspot.com/2017/01/qtest-google-mock.html */ #ifndef KIMAGEANNOTATOR_TESTRUNNER_H #define KIMAGEANNOTATOR_TESTRUNNER_H #include class GoogleTestEventListener : public ::testing::EmptyTestEventListener { void OnTestStart(const ::testing::TestInfo&) override { } void OnTestPartResult(const ::testing::TestPartResult& test_part_result) override { if (test_part_result.failed()) { QFAIL( QString("mock objects failed with '%1' at %2:%3") .arg(QString(test_part_result.summary())) .arg(test_part_result.file_name()) .arg(test_part_result.line_number()) .toLatin1().constData() ); } } void OnTestEnd(const ::testing::TestInfo&) override { } }; #define INIT_GOOGLE_MOCKS(argc, argv) { \ ::testing::InitGoogleTest (&(argc), (argv)); \ ::testing::TestEventListeners& listeners = ::testing::UnitTest::GetInstance()->listeners(); \ delete listeners.Release(listeners.default_result_printer());\ listeners.Append(new GoogleTestEventListener); } /* * Taken from QTEST_MAIN macro and added additional INIT_GOOGLE_MOCKS in the calls. */ #if defined(QT_WIDGETS_LIB) #include #ifdef QT_KEYPAD_NAVIGATION # define QTEST_DISABLE_KEYPAD_NAVIGATION QApplication::setNavigationMode(Qt::NavigationModeNone); #else # define QTEST_DISABLE_KEYPAD_NAVIGATION #endif #define TEST_MAIN(TestObject) \ QT_BEGIN_NAMESPACE \ QTEST_ADD_GPU_BLACKLIST_SUPPORT_DEFS \ QT_END_NAMESPACE \ int main(int argc, char *argv[]) \ { \ INIT_GOOGLE_MOCKS (argc, argv); \ \ QApplication app(argc, argv); \ app.setAttribute(Qt::AA_Use96Dpi, true); \ QTEST_DISABLE_KEYPAD_NAVIGATION \ QTEST_ADD_GPU_BLACKLIST_SUPPORT \ TestObject tc; \ QTEST_SET_MAIN_SOURCE_PATH \ return QTest::qExec(&tc, argc, argv); \ } #elif defined(QT_GUI_LIB) #include #define TEST_MAIN(TestObject) \ QT_BEGIN_NAMESPACE \ QTEST_ADD_GPU_BLACKLIST_SUPPORT_DEFS \ QT_END_NAMESPACE \ int main(int argc, char *argv[]) \ { \ INIT_GOOGLE_MOCKS (argc, argv); \ \ QGuiApplication app(argc, argv); \ app.setAttribute(Qt::AA_Use96Dpi, true); \ QTEST_ADD_GPU_BLACKLIST_SUPPORT \ TestObject tc; \ QTEST_SET_MAIN_SOURCE_PATH \ return QTest::qExec(&tc, argc, argv); \ } #else #define TEST_MAIN(TestObject) \ int main(int argc, char *argv[]) \ { \ INIT_GOOGLE_MOCKS (argc, argv); \ \ QCoreApplication app(argc, argv); \ app.setAttribute(Qt::AA_Use96Dpi, true); \ TestObject tc; \ QTEST_SET_MAIN_SOURCE_PATH \ return QTest::qExec(&tc, argc, argv); \ } #endif // QT_GUI_LIB #endif //KIMAGEANNOTATOR_TESTRUNNER_H kImageAnnotator-0.6.1/tests/widgets/000077500000000000000000000000001440330760000174065ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/widgets/CustomSpinBoxTest.cpp000066400000000000000000000026071440330760000235340ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "CustomSpinBoxTest.h" void CustomSpinBoxTest::TestSetValue_Should_EmitValueChangedSignal() { auto newValue = 23; CustomSpinBox spinBox; QSignalSpy spy(&spinBox, &CustomSpinBox::valueChanged); spinBox.setValue(newValue); QCOMPARE(spy.count(), 1); auto resultValue = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultValue, newValue); } void CustomSpinBoxTest::TestSetValueSilent_Should_NotEmitValueChangedSignal() { CustomSpinBox spinBox; QSignalSpy spy(&spinBox, &CustomSpinBox::valueChanged); spinBox.setValueSilent(23); QCOMPARE(spy.count(), 0); } TEST_MAIN(CustomSpinBoxTest); kImageAnnotator-0.6.1/tests/widgets/CustomSpinBoxTest.h000066400000000000000000000023541440330760000232000ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_CUSTOMSPINBOXTEST_H #define KIMAGEANNOTATOR_CUSTOMSPINBOXTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/CustomSpinBox.h" using kImageAnnotator::CustomSpinBox; class CustomSpinBoxTest : public QObject { Q_OBJECT private slots: void TestSetValue_Should_EmitValueChangedSignal(); void TestSetValueSilent_Should_NotEmitValueChangedSignal(); }; #endif // KIMAGEANNOTATOR_CUSTOMSPINBOXTEST_H kImageAnnotator-0.6.1/tests/widgets/misc/000077500000000000000000000000001440330760000203415ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/widgets/misc/AttachedSeparatorTest.cpp000066400000000000000000000050411440330760000253030ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "AttachedSeparatorTest.h" void AttachedSeparatorTest::Constructor_Should_SetupInitialVisibilityToFalse_When_TargetPickerInitiallyNotVisible() { // arrange BoolPicker picker(nullptr); picker.setVisible(false); // act AttachedSeparator separator(&picker); // assert QCOMPARE(separator.isVisible(), false); } void AttachedSeparatorTest::Constructor_Should_SetupInitialVisibilityToTrue_When_TargetPickerInitiallyVisible() { // arrange BoolPicker picker(nullptr); picker.setVisible(true); // act AttachedSeparator separator(&picker); // assert QCOMPARE(separator.isVisible(), true); } void AttachedSeparatorTest::UpdateVisibility_Should_ChangeVisibility_When_TargetPickerVisibilityChanged() { // arrange BoolPicker picker(nullptr); picker.setVisible(true); AttachedSeparator separator(&picker); QCOMPARE(separator.isVisible(), true); // act picker.setVisible(false); // assert QCOMPARE(separator.isVisible(), false); } void AttachedSeparatorTest::UpdateVisibility_Should_NotChangeVisibility_When_TargetPickerVisibilityChangedButSeparatorIsDisabled() { // arrange BoolPicker picker(nullptr); picker.setVisible(false); AttachedSeparator separator(&picker); QCOMPARE(separator.isVisible(), false); separator.setEnabled(false); // act picker.setVisible(true); // assert QCOMPARE(separator.isVisible(), false); } void AttachedSeparatorTest::SetEnabled_Should_UpdateVisibilityToFalse_When_Disabled() { // arrange BoolPicker picker(nullptr); picker.setVisible(true); AttachedSeparator separator(&picker); QCOMPARE(separator.isVisible(), true); // act separator.setEnabled(false); separator.setEnabled(false); // assert QCOMPARE(separator.isVisible(), false); QCOMPARE(picker.isVisible(), true); } TEST_MAIN(AttachedSeparatorTest) kImageAnnotator-0.6.1/tests/widgets/misc/AttachedSeparatorTest.h000066400000000000000000000032541440330760000247540ustar00rootroot00000000000000/* * Copyright (C) 2021 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ATTACHEDSEPARATORTEST_H #define KIMAGEANNOTATOR_ATTACHEDSEPARATORTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/misc/AttachedSeparator.h" #include "src/widgets/settingsPicker/BoolPicker.h" using kImageAnnotator::AttachedSeparator; using kImageAnnotator::BoolPicker; class AttachedSeparatorTest : public QObject { Q_OBJECT private slots: void Constructor_Should_SetupInitialVisibilityToFalse_When_TargetPickerInitiallyNotVisible(); void Constructor_Should_SetupInitialVisibilityToTrue_When_TargetPickerInitiallyVisible(); void UpdateVisibility_Should_ChangeVisibility_When_TargetPickerVisibilityChanged(); void UpdateVisibility_Should_NotChangeVisibility_When_TargetPickerVisibilityChangedButSeparatorIsDisabled(); void SetEnabled_Should_UpdateVisibilityToFalse_When_Disabled(); }; #endif //KIMAGEANNOTATOR_ATTACHEDSEPARATORTEST_H kImageAnnotator-0.6.1/tests/widgets/settingsPicker/000077500000000000000000000000001440330760000224045ustar00rootroot00000000000000kImageAnnotator-0.6.1/tests/widgets/settingsPicker/ColorPickerTest.cpp000066400000000000000000000023631440330760000261700ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ColorPickerTest.h" void ColorPickerTest::TestSelectColor_Should_EmitSignal_When_ColorChanged() { ColorPicker colorPicker(nullptr); QSignalSpy spy(&colorPicker, &ColorPicker::colorSelected); auto expectedColor = QColor(Qt::blue); colorPicker.setColor(expectedColor); QCOMPARE(spy.count(), 1); auto resultColor = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultColor, expectedColor); } TEST_MAIN(ColorPickerTest); kImageAnnotator-0.6.1/tests/widgets/settingsPicker/ColorPickerTest.h000066400000000000000000000022761440330760000256400ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_COLORPICKERTEST_H #define KIMAGEANNOTATOR_COLORPICKERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/settingsPicker/ColorPicker.h" using kImageAnnotator::ColorPicker; class ColorPickerTest : public QObject { Q_OBJECT private slots: void TestSelectColor_Should_EmitSignal_When_ColorChanged(); }; #endif // KIMAGEANNOTATOR_COLORPICKERTEST_H kImageAnnotator-0.6.1/tests/widgets/settingsPicker/FillModePickerTest.cpp000066400000000000000000000024361440330760000266060ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "FillModePickerTest.h" void FillModePickerTest::TestSelectFill_Should_EmitSignal_When_FillChanged() { qRegisterMetaType("FillModes"); FillModePicker fillPicker(nullptr); QSignalSpy spy(&fillPicker, &FillModePicker::fillSelected); auto expectedFill = FillModes::BorderAndNoFill; fillPicker.setFillType(expectedFill); QCOMPARE(spy.count(), 1); auto resultFill = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultFill, expectedFill); } TEST_MAIN(FillModePickerTest); kImageAnnotator-0.6.1/tests/widgets/settingsPicker/FillModePickerTest.h000066400000000000000000000023411440330760000262460ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_FILLPICKERTEST_H #define KIMAGEANNOTATOR_FILLPICKERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/settingsPicker/FillModePicker.h" using kImageAnnotator::FillModePicker; using kImageAnnotator::FillModes; class FillModePickerTest : public QObject { Q_OBJECT private slots: void TestSelectFill_Should_EmitSignal_When_FillChanged(); }; #endif // KIMAGEANNOTATOR_FILLPICKERTEST_H kImageAnnotator-0.6.1/tests/widgets/settingsPicker/ImageEffectPickerTest.cpp000066400000000000000000000024661440330760000272550ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ImageEffectPickerTest.h" void ImageEffectPickerTest::TestSelectEffect_Should_EmitSignal_When_EffectChanged() { qRegisterMetaType("ImageEffects"); ImageEffectPicker effectPicker(nullptr); QSignalSpy spy(&effectPicker, &ImageEffectPicker::effectSelected); auto expectedEffect = ImageEffects::DropShadow; effectPicker.setEffect(expectedEffect); QCOMPARE(spy.count(), 1); auto resultFill = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultFill, expectedEffect); } TEST_MAIN(ImageEffectPickerTest); kImageAnnotator-0.6.1/tests/widgets/settingsPicker/ImageEffectPickerTest.h000066400000000000000000000023671440330760000267220ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_IMAGEEFFECTPICKERTEST_H #define KIMAGEANNOTATOR_IMAGEEFFECTPICKERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/settingsPicker/ImageEffectPicker.h" using kImageAnnotator::ImageEffectPicker; using kImageAnnotator::ImageEffects; class ImageEffectPickerTest : public QObject { Q_OBJECT private slots: void TestSelectEffect_Should_EmitSignal_When_EffectChanged(); }; #endif //KIMAGEANNOTATOR_IMAGEEFFECTPICKERTEST_H kImageAnnotator-0.6.1/tests/widgets/settingsPicker/NumberPickerTest.cpp000066400000000000000000000023421440330760000263370ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "NumberPickerTest.h" void NumberPickerTest::TestSelectNumber_Should_EmitSignal_When_NumberChanged() { NumberPicker sizePicker(nullptr); QSignalSpy spy(&sizePicker, &NumberPicker::numberSelected); auto expectedSize = 8; sizePicker.setNumber(expectedSize); QCOMPARE(spy.count(), 1); auto resultSize = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultSize, expectedSize); } TEST_MAIN(NumberPickerTest); kImageAnnotator-0.6.1/tests/widgets/settingsPicker/NumberPickerTest.h000066400000000000000000000023031440330760000260010ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_NUMBERPICKERTEST_H #define KIMAGEANNOTATOR_NUMBERPICKERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/settingsPicker/NumberPicker.h" using kImageAnnotator::NumberPicker; class NumberPickerTest : public QObject { Q_OBJECT private slots: void TestSelectNumber_Should_EmitSignal_When_NumberChanged(); }; #endif // KIMAGEANNOTATOR_NUMBERPICKERTEST_H kImageAnnotator-0.6.1/tests/widgets/settingsPicker/StickerPickerTest.cpp000066400000000000000000000024221440330760000265120ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "StickerPickerTest.h" void StickerPickerTest::TestSelectSticker_Should_EmitSignal_When_StickerChanged() { StickerPicker stickerPicker(nullptr); QSignalSpy spy(&stickerPicker, &StickerPicker::stickerSelected); auto expectedStickerPath = QLatin1Literal(":/stickers/nerd_face.svg"); stickerPicker.setSticker(expectedStickerPath); QCOMPARE(spy.count(), 1); auto resultSize = qvariant_cast(spy.at(0).at(0)); QCOMPARE(resultSize, expectedStickerPath); } TEST_MAIN(StickerPickerTest);kImageAnnotator-0.6.1/tests/widgets/settingsPicker/StickerPickerTest.h000066400000000000000000000022741440330760000261640ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_STICKERPICKERTEST_H #define KIMAGEANNOTATOR_STICKERPICKERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/settingsPicker/StickerPicker.h" using kImageAnnotator::StickerPicker; class StickerPickerTest : public QObject { Q_OBJECT private slots: void TestSelectSticker_Should_EmitSignal_When_StickerChanged(); }; #endif //KIMAGEANNOTATOR_STICKERPICKERTEST_H kImageAnnotator-0.6.1/tests/widgets/settingsPicker/ToolPickerTest.cpp000066400000000000000000000026051440330760000260260ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ToolPickerTest.h" void ToolPickerTest::TestSelectTool_Should_EmitSignal_When_ToolChanged() { qRegisterMetaType("Tools"); ToolPicker toolPicker(nullptr); QSignalSpy spy(&toolPicker, &ToolPicker::toolSelected); toolPicker.setTool(Tools::Arrow); QCOMPARE(spy.count(), 1); auto type = qvariant_cast(spy.at(0).at(0)); QCOMPARE(type, Tools::Arrow); } void ToolPickerTest::TestTool_Should_ReturnSelectedTool() { ToolPicker toolPicker(nullptr); toolPicker.setTool(Tools::Arrow); auto result = toolPicker.tool(); QCOMPARE(result, Tools::Arrow); } TEST_MAIN(ToolPickerTest); kImageAnnotator-0.6.1/tests/widgets/settingsPicker/ToolPickerTest.h000066400000000000000000000024201440330760000254660ustar00rootroot00000000000000/* * Copyright (C) 2018 Damir Porobic * * This program 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 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_TOOLPICKERTEST_H #define KIMAGEANNOTATOR_TOOLPICKERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/ToolPicker.h" #include "src/common/enum/Tools.h" using kImageAnnotator::ToolPicker; using kImageAnnotator::Tools; class ToolPickerTest : public QObject { Q_OBJECT private slots: void TestSelectTool_Should_EmitSignal_When_ToolChanged(); void TestTool_Should_ReturnSelectedTool(); }; #endif // KIMAGEANNOTATOR_TOOLPICKERTEST_H kImageAnnotator-0.6.1/tests/widgets/settingsPicker/ZoomPickerTest.cpp000066400000000000000000000021051440330760000260300ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ZoomPickerTest.h" void ZoomPickerTest::SetZoomValue_Should_NotEmitSignalForChangedZoomValue() { ZoomPicker zoomIndicator(nullptr); QSignalSpy spy(&zoomIndicator, &ZoomPicker::zoomValueChanged); zoomIndicator.setZoomValue(7.77); QCOMPARE(spy.count(), 0); } TEST_MAIN(ZoomPickerTest); kImageAnnotator-0.6.1/tests/widgets/settingsPicker/ZoomPickerTest.h000066400000000000000000000022461440330760000255030ustar00rootroot00000000000000/* * Copyright (C) 2020 Damir Porobic * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KIMAGEANNOTATOR_ZOOMPICKERTEST_H #define KIMAGEANNOTATOR_ZOOMPICKERTEST_H #include #include "tests/utils/TestRunner.h" #include "src/widgets/settingsPicker/ZoomPicker.h" using kImageAnnotator::ZoomPicker; class ZoomPickerTest : public QObject { Q_OBJECT private slots: void SetZoomValue_Should_NotEmitSignalForChangedZoomValue(); }; #endif //KIMAGEANNOTATOR_ZOOMPICKERTEST_H kImageAnnotator-0.6.1/translations/000077500000000000000000000000001440330760000173175ustar00rootroot00000000000000kImageAnnotator-0.6.1/translations/CMakeLists.txt000066400000000000000000000023121440330760000220550ustar00rootroot00000000000000find_package(Qt5LinguistTools) set(KIMAGEANNOTATOR_LANG_TS kImageAnnotator_ar.ts kImageAnnotator_bg.ts kImageAnnotator_ca.ts kImageAnnotator_cs.ts kImageAnnotator_da.ts kImageAnnotator_de.ts kImageAnnotator_el.ts kImageAnnotator_es.ts kImageAnnotator_eu.ts kImageAnnotator_fr.ts kImageAnnotator_fr_CA.ts kImageAnnotator_gl.ts kImageAnnotator_hr.ts kImageAnnotator_hu.ts kImageAnnotator_id.ts kImageAnnotator_it.ts kImageAnnotator_ja.ts kImageAnnotator_ko.ts kImageAnnotator_nl.ts kImageAnnotator_no.ts kImageAnnotator_pl.ts kImageAnnotator_pt.ts kImageAnnotator_pt_BR.ts kImageAnnotator_ro.ts kImageAnnotator_ru.ts kImageAnnotator_si.ts kImageAnnotator_sq.ts kImageAnnotator_sv.ts kImageAnnotator_tr.ts kImageAnnotator_uk.ts kImageAnnotator_zh_CN.ts) if (DEFINED UPDATE_TS_FILES) qt5_create_translation(KIMAGEANNOTATOR_LANG_QM ${CMAKE_SOURCE_DIR}/translations ${KIMAGEANNOTATOR_SRCS} ${KIMAGEANNOTATOR_LANG_TS} OPTIONS "-no-obsolete") else () qt5_add_translation(KIMAGEANNOTATOR_LANG_QM ${KIMAGEANNOTATOR_LANG_TS}) endif () add_custom_target(translations ALL DEPENDS ${KIMAGEANNOTATOR_LANG_QM}) install(FILES ${KIMAGEANNOTATOR_LANG_QM} DESTINATION ${KIMAGEANNOTATOR_LANG_INSTALL_DIR}) kImageAnnotator-0.6.1/translations/kImageAnnotator_ar.ts000066400000000000000000000362721440330760000234460ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange رتب Bring to Front أحضر للمقدمة Bring Forward قدّم Send Backward أخّر Send to Back أرسل للخلف Select This اختر هذه Copy انسخ Paste ألصق Edit حرر Delete احذف kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings إعدادات عامة kImageAnnotator::AnnotationImageSettings Image Settings إعدادات الصورة kImageAnnotator::AnnotationItemSettings Color اللون Text Color لون النص Width العرض Number Seed مبدأ الرقم Obfuscation Factor عامل التشويش Item Shadow ظل العنصر Item Settings إعدادات العنصر Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close أغلق Close Other أغلق الأخرى Close All أغلق الكل Close All to the Left أغلق كل ما على اليسار Close All to the Right أغلق كل ما على اليمين kImageAnnotator::AnnotationToolSelection Tool Selection أداة التحديد kImageAnnotator::BoolPicker Enabled ممكن Disabled معطل kImageAnnotator::Controls Undo Redo Crop Scale Rotate دور Modify canvas Cut kImageAnnotator::CropWidget Cancel ألغ X: س: Y: ص: W: ع: H: إ: Apply طبق kImageAnnotator::CutWidget Vertical رأسي Horizontal أفقي Apply طبق Cancel ألغ kImageAnnotator::FillModePicker Border And Fill Visibility الحدود وملء الرؤية Border and Fill حدود و ملء Border and No Fill حدود بدون ملء No Border and No Fill بدون حدود وبدون ملء kImageAnnotator::FontPicker Font Size حجم الخط Bold عريض Italic مائل Underline مسطر kImageAnnotator::ImageEffectPicker Image Effects تأثيرات الصورة No Effect بلا تأثير Drop Shadow ظلال ساقطة Grayscale رمادي Border الحدود Invert Color لون معكوس kImageAnnotator::ModifyCanvasWidget Restricted مقيد When enabled enforces the canvas to include the background image. عندما يمكن يجبر اللوحة على تضمين صورة خلفية. X: س: Y: ص: W: ع: H: إ: Apply طبق Cancel ألغ Color: اللون: Canvas Background Color لون خلفية اللوحة kImageAnnotator::RotateDialog Rotate Image دور الصورة 180° ١٨٠° 90° Clockwise ٩٠° اتجاه عقارب الساعة 90° Counter Clockwise ٩٠° عكس عقارب الساعة Arbitrary عشوائي Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. تدور القيم الموجبة في اتجاه عقارب الساعة، والقيم السالبة عكس اتجاه عقارب الساعة. قد يؤدي التناوب بمضاعفات بغير زاوية ٩٠ درجة إلى فقدان الجودة. Horizontal أفقي Vertical رأسي OK حسنا Cancel ألغ Rotate دور Flip اقلب kImageAnnotator::ScaleDialog Scale Image حجم الصورة Keep Aspect Ratio حافظ على تناسق الأبعاد Width: العرض: Height: الإرتفاع: OK حسنا Cancel ألغ Pixel بكسل Percent نسبة kImageAnnotator::StickerPicker Sticker ملصق kImageAnnotator::ToolPicker Select اختار Pen قلم Number رقم Marker Rectangle معلم المستطيل Marker Ellipse معلم قطع ناقص Marker Pen معلم القلم Text نص Arrow سهم Double Arrow سهم مزدوج Line خط Blur طمس Rectangle مستطيل Ellipse قطع ناقص Number Pointer مؤشر رقمي Sticker ملصق Pixelate تبكسيل Text Pointer مؤشر النص Text Arrow سهم نص Number Arrow سهم رقم Duplicate كرر kImageAnnotator::ZoomPicker Zoom In (%1) كبر (%1) Zoom Out (%1) صغر (%1) Reset Zoom (%1) صفر التكبير (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_bg.ts000066400000000000000000000405661440330760000234350ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Подреждане Bring to Front Преместване на преден план Bring Forward Преместване напред Send Backward Преместване назад Send to Back Преместване на заден план Select This Избиране Copy Копиране Paste Поставяне Edit Промяна Delete Изтриване kImageAnnotator::AnnotationControlsWidget Controls Основни настройки kImageAnnotator::AnnotationGeneralSettings General Settings Основни настройки kImageAnnotator::AnnotationImageSettings Image Settings Настройки на изображение kImageAnnotator::AnnotationItemSettings Color Цвят Text Color Цвят на текст Width Широчина Number Seed Произволна начална стойност Obfuscation Factor Коефициент на обфускация Item Shadow Сянка на елемент Item Settings Настройки на елемент Scale Мащаб Opacity Прозрачност kImageAnnotator::AnnotationTabContextMenu Close Затваряне Close Other Затвори Други Close All Затвори всички Close All to the Left Затваряне на всичко отляво Close All to the Right Затваряне на всичко отдясно kImageAnnotator::AnnotationToolSelection Tool Selection Избор на инструмент kImageAnnotator::BoolPicker Enabled Активирано Disabled Изключено kImageAnnotator::Controls Undo Отмяна Redo Повтаряне Crop Изрязване Scale Мащаб Rotate Завъртане Modify canvas Промяна на платното Cut Изрязване kImageAnnotator::CropWidget Cancel Отказ X: Х: Y: Y: W: W: H: H: Apply Приложи kImageAnnotator::CutWidget Vertical Вертикално Horizontal Хоризонтално Apply Приложи Cancel Отказ kImageAnnotator::FillModePicker Border And Fill Visibility Видимост на граница и пълнеж Border and Fill Граница и пълнеж Border and No Fill Граница без пълнеж No Border and No Fill Без граница и без пълнеж kImageAnnotator::FontPicker Font Size Размер на шрифта Bold Удебелен Italic Курсив Underline Подчертаване kImageAnnotator::ImageEffectPicker Image Effects Ефекти на изображението No Effect Без ефект Drop Shadow Падаща сянка Grayscale Сива скала Border Граница Invert Color Инвертиране на цвета kImageAnnotator::ModifyCanvasWidget Restricted Ограничен When enabled enforces the canvas to include the background image. Когато е активирано, се налага платното да включи фоновото изображение. X: Х: Y: Y: W: W: H: H: Apply Приложи Cancel Отказ Color: Цвят: Canvas Background Color Цвят на фона на платното kImageAnnotator::RotateDialog Rotate Image Завъртане на изображението 180° 180° 90° Clockwise 90° по посока на часовниковата стрелка 90° Counter Clockwise 90° обратно на часовниковата стрелка Arbitrary Произволно Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Положителните стойности се въртят по посока на часовниковата стрелка, отрицателните – обратно на часовниковата стрелка. Завъртането с множители, различни от 90°, може да доведе до загуба на качество. Horizontal Хоризонтално Vertical Вертикално OK OK Cancel Отказ Rotate Завъртане Flip Обръщане kImageAnnotator::ScaleDialog Scale Image Мащабиране на изображението Keep Aspect Ratio Запазване на пропорциите Width: Широчина: Height: Височина: OK OK Cancel Отказ Pixel Пиксел Percent Процент kImageAnnotator::StickerPicker Sticker Стикер kImageAnnotator::ToolPicker Select Избиране Pen Химилка Number Номер Marker Rectangle Маркер правоъгълник Marker Ellipse Маркер елипса Marker Pen Маркер химикалка Text Текст Arrow Стрелка Double Arrow Двойна стрелка Line Линия Blur Размазване Rectangle Правоъгълник Ellipse Елипса Number Pointer Показалец - цифри Sticker Стикер Pixelate Пикселизиране Text Pointer Текстов указател Text Arrow Текстова стрелка Number Arrow Числова стрелка Duplicate Дубликиране kImageAnnotator::ZoomPicker Zoom In (%1) Мащабиране (% 1) Zoom Out (%1) Намаляване (%1) Reset Zoom (%1) Нулиране на мащаба (% 1) Reset Zoom Нулиране на мащаба Fit Image Вместване на изображение Fit image to view (%1) Побиране на изображението за преглед (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_ca.ts000066400000000000000000000354341440330760000234260ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Organitza Bring to Front Porta al davant Bring Forward Porta endavant Send Backward Envia cap enrere Send to Back Envia al darrere Select This Selecciona això Copy Copia Paste Enganxa Edit Edita Delete Suprimeix kImageAnnotator::AnnotationControlsWidget Controls Controls kImageAnnotator::AnnotationGeneralSettings General Settings Configuració general kImageAnnotator::AnnotationImageSettings Image Settings Configuració de la imatge kImageAnnotator::AnnotationItemSettings Color Color Text Color Color del text Width Amplada Number Seed Número de llavor Obfuscation Factor Factor d'ofuscació Item Shadow Ombra d'element Item Settings Configuració d'element Scale Escala Opacity Opacitat kImageAnnotator::AnnotationTabContextMenu Close Tanca Close Other Tanca altres Close All Tanca-ho tot Close All to the Left Tanca tot a l'esquerra Close All to the Right Tanca tot a la dreta kImageAnnotator::AnnotationToolSelection Tool Selection Selecció d'eina kImageAnnotator::BoolPicker Enabled Activat Disabled Desactivat kImageAnnotator::Controls Undo Desfés Redo Refés Crop Escapça Scale Escala Rotate Gira Modify canvas Modifica el llenç Cut Tallar kImageAnnotator::CropWidget Cancel Cancel·la X: X: Y: Y: W: ↔: H: ↕: Apply Aplica kImageAnnotator::CutWidget Vertical Vertical Horizontal Horitzontal Apply Aplica Cancel Cancel·la kImageAnnotator::FillModePicker Border And Fill Visibility Visibilitat de la vora i emplenament Border and Fill Vora i emplenament Border and No Fill Vora i sense emplenament No Border and No Fill Sense vora ni emplenament kImageAnnotator::FontPicker Font Size Mida del tipus de lletra Bold Negreta Italic Cursiva Underline Subratllat kImageAnnotator::ImageEffectPicker Image Effects Efectes d'imatge No Effect Sense efectes Drop Shadow Ombra Grayscale Escala de grisos Border Vora Invert Color Inverteix els colors kImageAnnotator::ModifyCanvasWidget Restricted Restringit When enabled enforces the canvas to include the background image. Quan és actiu, força que el llenç inclogui la imatge de fons. X: X: Y: Y: W: ↔: H: ↕: Apply Aplica Cancel Cancel·la Color: Color: Canvas Background Color Color de fons del llenç kImageAnnotator::RotateDialog Rotate Image Gira la imatge 180° 180° 90° Clockwise 90° en sentit horari 90° Counter Clockwise 90° en sentit antihorari Arbitrary Arbitrari Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Els valors positius giren en sentit horari, els negatius en sentit antihorari. Els girs que no són múltiples de 90° poden presentar pèrdues de qualitat. Horizontal Horitzontal Vertical Vertical OK D'acord Cancel Cancel·la Rotate Gira Flip Inverteix kImageAnnotator::ScaleDialog Scale Image Ajusta la mida de la imatge Keep Aspect Ratio Mantén la relació d'aspecte Width: Amplada: Height: Alçada: OK D'acord Cancel Cancel·la Pixel Píxel Percent Percentatge kImageAnnotator::StickerPicker Sticker Adhesiu kImageAnnotator::ToolPicker Select Selecciona Pen Bolígraf Number Número Marker Rectangle Marcador rectangle Marker Ellipse Marcador el·lipse Marker Pen Marcador bolígraf Text Text Arrow Fletxa Double Arrow Fletxa doble Line Línia Blur Difuminat Rectangle Rectangle Ellipse El·lipse Number Pointer Apuntador numèric Sticker Adhesiu Pixelate Pixela Text Pointer Apuntador de text Text Arrow Text amb fletxa Number Arrow Número amb fletxa Duplicate Duplica kImageAnnotator::ZoomPicker Zoom In (%1) Apropa (%1) Zoom Out (%1) Allunya (%1) Reset Zoom (%1) Reinicia el zoom (%1) Reset Zoom Reinicia el zoom Fit Image Ajusta la imatge Fit image to view (%1) Ajusta la imatge a la vista (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_cs.ts000066400000000000000000000357431440330760000234530ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Rozvržení Bring to Front Přenést do popředí Bring Forward Přenést na pozadí Send Backward Send to Back Select This Vybrat předmět Copy Kopírovat Paste Vložit Edit Upravit Delete Smazat kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Hlavní nastavení kImageAnnotator::AnnotationImageSettings Image Settings Nastavení obrázku kImageAnnotator::AnnotationItemSettings Color Barva Text Color Barva textu Width Šířka Number Seed Obfuscation Factor Faktor obfuskace Item Shadow Stín prvku Item Settings Nastavení prvku Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Zavřít Close Other Zavřít ostatní Close All Zavřít vše Close All to the Left Zavřít všechny vlevo Close All to the Right Zavřít všechny vpravo kImageAnnotator::AnnotationToolSelection Tool Selection Výběr nástroje kImageAnnotator::BoolPicker Enabled Povoleno Disabled Zakázáno kImageAnnotator::Controls Undo Redo Crop Scale Rotate Otočit Modify canvas Cut kImageAnnotator::CropWidget Cancel Zrušit X: X: Y: Y: W: Š: H: V: Apply Aplikovat kImageAnnotator::CutWidget Vertical Vertikální Horizontal Horizontální Apply Aplikovat Cancel Zrušit kImageAnnotator::FillModePicker Border And Fill Visibility Okraje a průhlednost výplně Border and Fill Okraje a výplně Border and No Fill Okraje a bez výplně No Border and No Fill Bez okrajů a bez výplně kImageAnnotator::FontPicker Font Size Velikost písma Bold Tučně Italic Kurzívou Underline Podtrženo kImageAnnotator::ImageEffectPicker Image Effects Efekty obrázku No Effect Bez efektů Drop Shadow Grayscale Stupně šedi Border Okraje Invert Color Invertovat barvy kImageAnnotator::ModifyCanvasWidget Restricted Omezeno When enabled enforces the canvas to include the background image. X: X: Y: Y: W: Š: H: V: Apply Aplikovat Cancel Zrušit Color: Barva: Canvas Background Color Barva pozadí plátna kImageAnnotator::RotateDialog Rotate Image Otáčení obrázku 180° 180° 90° Clockwise 90° ve směru hodinových ručiček 90° Counter Clockwise 90° proti směru hodinových ručiček Arbitrary Libovolné Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Kladné hodnoty se otáčejí ve směru hodinových ručiček, záporné hodnoty proti směru hodinových ručiček. Otáčení jinými násobky než 90°může způsobit ztrátu kvality. Horizontal Horizontální Vertical Vertikální OK OK Cancel Zrušit Rotate Otočit Flip Prohodit kImageAnnotator::ScaleDialog Scale Image Roztažení obrázku Keep Aspect Ratio Zachovat poměr stran Width: Šířka: Height: Výška: OK OK Cancel Zrušit Pixel Pixel Percent Procenta kImageAnnotator::StickerPicker Sticker Nálepka kImageAnnotator::ToolPicker Select Vyberte Pen Pero Number Číslo Marker Rectangle Obdélník zvýrazňovačem Marker Ellipse Elipsa zvýrazňovačem Marker Pen Zvýrazňovač Text Text Arrow Šipka Double Arrow Dvojitá šipka Line Čára Blur Rozmazání Rectangle Obdélník Ellipse Elipsa Number Pointer Číselník Sticker Nálepka Pixelate Pixelizuj Text Pointer Textový ukazatel Text Arrow Number Arrow Duplicate Duplikuj kImageAnnotator::ZoomPicker Zoom In (%1) Přiblížit (%1) Zoom Out (%1) Oddálit (%1) Reset Zoom (%1) Resetovat přiblížení (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_da.ts000066400000000000000000000353071440330760000234260ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Tilpas Bring to Front Flyt Helt Frem Bring Forward Flyt Frem Send Backward FlytTilbage Send to Back Flyt Helt Tilbage Select This Vælg Dette Copy Kopier Paste Indsæt Edit Rediger Delete Slet kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Overordnede Indstillinger kImageAnnotator::AnnotationImageSettings Image Settings Billedindstillinger kImageAnnotator::AnnotationItemSettings Color Farve Text Color Tekstfarve Width Brede Number Seed Tæller Obfuscation Factor Sløringsfaktor Item Shadow Elementets Skygge Item Settings Elementets Indstillinger Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Luk Close Other Luk Andre Close All Luk Alle Close All to the Left Luk Alle Til Venstre Close All to the Right Luk Alle Til Højre kImageAnnotator::AnnotationToolSelection Tool Selection Værktøjsvalg kImageAnnotator::BoolPicker Enabled Aktiveret Disabled Deaktiveret kImageAnnotator::Controls Undo Redo Crop Scale Rotate Roter Modify canvas Cut kImageAnnotator::CropWidget Cancel Fortryd X: X: Y: Y: W: W: H: H: Apply Anvend kImageAnnotator::CutWidget Vertical Lodret Horizontal Vandret Apply Anvend Cancel Fortryd kImageAnnotator::FillModePicker Border And Fill Visibility Kant Og Fylds Synlighed Border and Fill Kant Og Fyld Border and No Fill Kant Uden Fyld No Border and No Fill Hverken Kant Eller Fyld kImageAnnotator::FontPicker Font Size Skriftstørrelse Bold Fed Italic Kursiv Underline Understreget kImageAnnotator::ImageEffectPicker Image Effects Billedeffekter No Effect Ingen Effekt Drop Shadow Faldskygge Grayscale Gråtoneskala Border Kant Invert Color Spejlvend Farven kImageAnnotator::ModifyCanvasWidget Restricted Begrænset When enabled enforces the canvas to include the background image. Når aktiveret bliver baggrundsbilledet til en del af kanvassen. X: X: Y: Y: W: W: H: H: Apply Anvend Cancel Fortryd Color: Farve: Canvas Background Color Kanvassens Bagrundsfarve kImageAnnotator::RotateDialog Rotate Image Roter Billedet 180° 180° 90° Clockwise 90° I Urets Retning 90° Counter Clockwise 90° Mod Urets Retning Arbitrary Vilkårlig Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Positive værdier roterer i urets retning, negative værdier mod urets retning. Rotering af ikke-90° gangefaktorer kan forårsage tab af kvalitet. Horizontal Vandret Vertical Lodret OK OK Cancel Fortryd Rotate Roter Flip Spejlvend kImageAnnotator::ScaleDialog Scale Image Skaler Billedet Keep Aspect Ratio Bevar Størrelsesforhold Width: Brede: Height: Højde: OK OK Cancel Fortryd Pixel Pixel Percent Procent kImageAnnotator::StickerPicker Sticker Klistermærke kImageAnnotator::ToolPicker Select Vælg Pen Blyant Number Nummer Marker Rectangle Markeringsfirkant Marker Ellipse Markeringsellipse Marker Pen Markeringsblyant Text Tekst Arrow Pil Double Arrow Dobbeltpil Line Linje Blur Slør Rectangle Firkant Ellipse Ellipse Number Pointer Nummermarkør Sticker Klistermærke Pixelate Opbryd Text Pointer Tekstmarkøren Text Arrow Tekstpil Number Arrow Nummerpil Duplicate Dupliker kImageAnnotator::ZoomPicker Zoom In (%1) Forstør (%1) Zoom Out (%1) Formindsk (%1) Reset Zoom (%1) Nulstil Zoomen (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_de.ts000066400000000000000000000356501440330760000234330ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Anordnen Bring to Front Ganz nach vorn Bring Forward Nach vorn Send Backward Nach hinten Send to Back Ganz nach hinten Select This Dieses auswählen Copy Kopieren Paste Einfügen Edit Ändern Delete Löschen kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Allgemeine Einstellungen kImageAnnotator::AnnotationImageSettings Image Settings Bild Einstellungen kImageAnnotator::AnnotationItemSettings Color Farbe Text Color Textfarbe Width Breite Number Seed Nummerierung ab Obfuscation Factor Unschärfe Faktor Item Shadow Objekt-Schatten Item Settings Objekt-Einstellungen Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Schließen Close Other Andere schließen Close All Alle schließen Close All to the Left Alle linksseitig schließen Close All to the Right Alle rechtsseitig schließen kImageAnnotator::AnnotationToolSelection Tool Selection Werkzeugauswahl kImageAnnotator::BoolPicker Enabled Aktiviert Disabled Deaktiviert kImageAnnotator::Controls Undo Redo Crop Scale Rotate Drehen Modify canvas Cut kImageAnnotator::CropWidget Cancel Abbrechen X: X: Y: Y: W: B: H: H: Apply Anwenden kImageAnnotator::CutWidget Vertical Vertikal Horizontal Horizontal Apply Anwenden Cancel Abbrechen kImageAnnotator::FillModePicker Border And Fill Visibility Sichtbarkeit von Rahmen und Füllungen Border and Fill Rahmen und Füllung Border and No Fill Rahmen und keine Füllung No Border and No Fill Kein Rahmen und keine Füllung kImageAnnotator::FontPicker Font Size Schriftgröße Bold Fett Italic Kursiv Underline Unterstrichen kImageAnnotator::ImageEffectPicker Image Effects Bild-Effekte No Effect Kein Effekt Drop Shadow Schlagschatten Grayscale Graustufen Border Rand Invert Color Farbe invertieren kImageAnnotator::ModifyCanvasWidget Restricted Gesperrt When enabled enforces the canvas to include the background image. Wenn aktiviert, wird erzwungen, dass die Zeichenfläche das Hintergrundbild beinhaltet. X: X: Y: Y: W: B: H: H: Apply Anwenden Cancel Abbrechen Color: Farbe: Canvas Background Color Hintergrundfarbe der Zeichenfläche kImageAnnotator::RotateDialog Rotate Image Bild drehen 180° 180° 90° Clockwise 90° im Uhrzeigersinn 90° Counter Clockwise 90° gegen den Uhrzeigersinn Arbitrary Beliebig Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Positive Werte rotieren im Uhrzeigersinn, negative Werte gegen den Uhrzeigersinn. Das Drehen um nicht 90°-Multiplikatoren kann zu Qualitätsverlusten führen. Horizontal Horizontal Vertical Vertikal OK OK Cancel Abbrechen Rotate Drehen Flip Umdrehen kImageAnnotator::ScaleDialog Scale Image Bild skalieren Keep Aspect Ratio Seitenverhältnis beibehalten Width: Breite: Height: Höhe: OK OK Cancel Abbrechen Pixel Pixel Percent Prozentzahl kImageAnnotator::StickerPicker Sticker Aufkleber kImageAnnotator::ToolPicker Select Auswählen Pen Stift Number Nummer Marker Rectangle Rechteckige Markierung Marker Ellipse Ellipsen Markierung Marker Pen Stift Markierung Text Text Arrow Pfeil Double Arrow Doppelpfeil Line Strich Blur Verschwommenheit Rectangle Rechteck Ellipse Ellipse Number Pointer Nummer mit Zeiger Sticker Aufkleber Pixelate Verpixelung Text Pointer Sprechblase Text Arrow Text mit Pfeil Number Arrow Nummer mit Pfeil Duplicate Duplizieren kImageAnnotator::ZoomPicker Zoom In (%1) Vergrößern (%1) Zoom Out (%1) Verkleinern (%1) Reset Zoom (%1) Zoom zurücksetzen (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_el.ts000066400000000000000000000407501440330760000234400ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Διάταξη Bring to Front Μετακίνηση στο προσκήνιο Bring Forward Μετακίνηση προς τα εμπρός Send Backward Μετακίνηση προς τα πίσω Send to Back Μετακίνηση στο παρασκήνιο Select This Επιλογή Copy Αντιγραφή Paste Επικόλληση Edit Επεξεργασία Delete Διαγραφή kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Γενικές ρυθμίσεις kImageAnnotator::AnnotationImageSettings Image Settings Ρυθμίσεις εικόνας kImageAnnotator::AnnotationItemSettings Color Χρώμα Text Color Χρώμα κειμένου Width Πλάτος Number Seed Αρχικός αριθμός Obfuscation Factor Συντελεστής θόλωσης Item Shadow Σκιά αντικειμένου Item Settings Ρυθμίσεις αντικειμένου Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Κλείσιμο Close Other Κλείσιμο των άλλων Close All Κλείσιμο όλων Close All to the Left Κλείσιμο όλων στα αριστερά Close All to the Right Κλείσιμο όλων στα δεξιά kImageAnnotator::AnnotationToolSelection Tool Selection Επιλογή εργαλείου kImageAnnotator::BoolPicker Enabled Ενεργοποιημένο Disabled Απενεργοποιημένο kImageAnnotator::Controls Undo Redo Crop Scale Rotate Περιστροφή Modify canvas Cut kImageAnnotator::CropWidget Cancel Άκυρο X: X: Y: Y: W: Π: H: Υ: Apply Εφαρμογή kImageAnnotator::CutWidget Vertical Κατακόρυφα Horizontal Οριζόντια Apply Εφαρμογή Cancel kImageAnnotator::FillModePicker Border And Fill Visibility Ορατότητα περιγράμματος και γέμισης Border and Fill Περίγραμμα και γέμιση Border and No Fill Περίγραμμα χωρίς γέμιση No Border and No Fill Χωρίς περίγραμμα και χωρίς γέμιση kImageAnnotator::FontPicker Font Size Μέγεθος γραμματοσειράς Bold Έντονα Italic Πλάγια Underline Υπογράμμιση kImageAnnotator::ImageEffectPicker Image Effects Τεχνάσματα εικόνας No Effect Κανένα τέχνασμα Drop Shadow Σκίαση Grayscale Διαβαθμίσεις του γκρι Border Περίγραμμα Invert Color Αντιστροφή χρωμάτων kImageAnnotator::ModifyCanvasWidget Restricted Με περιορισμούς When enabled enforces the canvas to include the background image. Όταν είναι ενεργοποιημένο, εξαναγκάζει τον καμβά να συμπεριλάβει την εικόνα παρασκηνίου. X: X: Y: Y: W: Π: H: Υ: Apply Εφαρμογή Cancel Ακύρωση Color: Χρώμα: Canvas Background Color Χρώμα παρασκηνίου του καμβά kImageAnnotator::RotateDialog Rotate Image Περιστροφή εικόνας 180° 180° 90° Clockwise 90° Δεξιόστροφα 90° Counter Clockwise 90° Αριστερόστροφα Arbitrary Αυθαίρετα Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Οι θετικές τιμές περιστρέφουν σύμφωνα με τους δείκτες του ρολογιού, και οι αρνητικές τιμές αντίστροφα. Η περιστροφή με πολλαπλασιαστές διαφορετικούς των 90° μπορεί να προκαλέσει απώλεια στην ποιότητα. Horizontal Οριζόντια Vertical Κατακόρυφα OK Εντάξει Cancel Ακύρωση Rotate Περιστροφή Flip Αναστροφή kImageAnnotator::ScaleDialog Scale Image Κλιμάκωση της εικόνας Keep Aspect Ratio Διατήρηση της αναλογίας διαστάσεων Width: Πλάτος: Height: Ύψος: OK Εντάξει Cancel Άκυρο Pixel Εικονοστοιχείο Percent Ποσοστό kImageAnnotator::StickerPicker Sticker Αυτοκόλλητο kImageAnnotator::ToolPicker Select Επιλογή Pen Γραφίδα Number Αριθμός Marker Rectangle Σημαδευτής ορθογωνίου Marker Ellipse Σημαδευτής έλλειψης Marker Pen Σημαδευτής γραφίδας Text Κείμενο Arrow Βέλος Double Arrow Διπλό βέλος Line Γραμμή Blur Θόλωση Rectangle Ορθογώνιο Ellipse Έλλειψη Number Pointer Δρομέας αριθμού Sticker Αυτοκόλλητο Pixelate Παραμόρφωση εικονοστοιχείων Text Pointer Δρομέας κειμένου Text Arrow Βέλος κειμένου Number Arrow Βέλος αριθμού Duplicate Δημιουργία αντιγράφου kImageAnnotator::ZoomPicker Zoom In (%1) Μεγέθυνση (%1) Zoom Out (%1) Σμίκρυνση (%1) Reset Zoom (%1) Επαναφορά εστίασης (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_es.ts000066400000000000000000000360751440330760000234540ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Organizar Bring to Front Traer al frente Bring Forward Traer adelante Send Backward Enviar atrás Send to Back Enviar al fondo Select This Seleccionar esto Copy Copiar Paste Pegar Edit Editar Delete Eliminar kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings kImageAnnotator::AnnotationImageSettings Image Settings kImageAnnotator::AnnotationItemSettings Color Color Text Color Color de texto Width Anchura Number Seed Obfuscation Factor Item Shadow Item Settings Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Cerrar Close Other Cerrar otros Close All Cerrar todo Close All to the Left Cerrar todos a la izquierda Close All to the Right Cerrar todos a la derecha kImageAnnotator::AnnotationToolSelection Tool Selection kImageAnnotator::BoolPicker Enabled Disabled kImageAnnotator::Controls Undo Redo Crop Scale Rotate Modify canvas Cut kImageAnnotator::CropWidget Cancel Cancelar X: X: Y: Y: W: ↔: H: ↕: Apply kImageAnnotator::CutWidget Vertical Horizontal Apply Cancel Cancelar kImageAnnotator::FillModePicker Border And Fill Visibility Visibilidad de borde y relleno No Border and No Fill Sin borde ni relleno Border and Fill Borde y relleno Border and No Fill Borde sin relleno kImageAnnotator::FontPicker Font Size Tamaño de letra Bold Italic Underline kImageAnnotator::ImageEffectPicker Image Effects No Effect Drop Shadow Grayscale Border Invert Color kImageAnnotator::ModifyCanvasWidget Restricted When enabled enforces the canvas to include the background image. X: X: Y: Y: W: ↔: H: ↕: Apply Cancel Cancelar Color: Canvas Background Color kImageAnnotator::RotateDialog Rotate Image 180° 90° Clockwise 90° Counter Clockwise Arbitrary Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Horizontal Vertical OK Aceptar Cancel Cancelar Rotate Flip kImageAnnotator::ScaleDialog Scale Image Redimensionar imagen Keep Aspect Ratio Mantener relación de aspecto Width: Anchura: Height: Altura: OK Aceptar Cancel Cancelar Pixel Píxel Percent Porcentaje kImageAnnotator::StickerPicker Sticker Adhesivo kImageAnnotator::ToolPicker Select Seleccionar Pen Pluma Number Número Marker Rectangle Marcador, rectángulo Marker Ellipse Marcador, elipse Marker Pen Marcador, pluma Text Texto Arrow Flecha Double Arrow Flecha doble Line Línea Blur Desenfoque Rectangle Rectángulo Ellipse Elipse Number Pointer Apuntador numérico Sticker Adhesivo Pixelate Text Pointer Text Arrow Number Arrow Duplicate kImageAnnotator::ZoomPicker Zoom In (%1) Zoom Out (%1) Reset Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_eu.ts000066400000000000000000000354371440330760000234570ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Antolatu Bring to Front Bring Forward Send Backward Bidali atzera Send to Back Select This Hautatu hau Copy Kopiatu Paste Itsatsi Edit Editatu Delete Ezabatu kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Ezarpen orokorrak kImageAnnotator::AnnotationImageSettings Image Settings Irudi ezarpenak kImageAnnotator::AnnotationItemSettings Color Kolorea Text Color Testu kolorea Width Zabalera Number Seed Zenbaki hazia Obfuscation Factor Ofuskazio-faktorea Item Shadow Item Settings Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Itxi Close Other Itxi besteak Close All Itxi guztiak Close All to the Left Itxi guztiak ezkerrera Close All to the Right Itxi guztiak eskuinera kImageAnnotator::AnnotationToolSelection Tool Selection kImageAnnotator::BoolPicker Enabled Gaituta Disabled Desgaituta kImageAnnotator::Controls Undo Redo Crop Scale Rotate Biratu Modify canvas Cut kImageAnnotator::CropWidget Cancel Utzi X: X: Y: Y: W: W: H: H: Apply Ezarri kImageAnnotator::CutWidget Vertical Bertikala Horizontal Horizontala Apply Ezarri Cancel Utzi kImageAnnotator::FillModePicker Border And Fill Visibility Border and Fill Border and No Fill No Border and No Fill kImageAnnotator::FontPicker Font Size Letra-tamaina Bold Lodia Italic Etzana Underline Azpimarratua kImageAnnotator::ImageEffectPicker Image Effects Irudi efektuak No Effect Efekturik ez Drop Shadow Grayscale Grisen eskala Border Invert Color kImageAnnotator::ModifyCanvasWidget Restricted Mugatuta When enabled enforces the canvas to include the background image. X: X: Y: Y: W: W: H: H: Apply Ezarri Cancel Utzi Color: Kolorea: Canvas Background Color kImageAnnotator::RotateDialog Rotate Image Biratu irudia 180° 180° 90° Clockwise 90° Counter Clockwise Arbitrary Arbitrarioa Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Balio positiboak erlojuaren orratzen noranzkoan biratzen dira, balio negatiboak erlojuaren orratzen noranzkoan. 90° ez diren biderkatzaileen bidez biratzeak kalitate galera ekar dezake. Horizontal Horizontala Vertical Bertikala OK Ados Cancel Utzi Rotate Biratu Flip Irauli kImageAnnotator::ScaleDialog Scale Image Eskalatu irudia Keep Aspect Ratio Mantendu itxura-erlazioa Width: Zabalera: Height: Altuera: OK Ados Cancel Utzi Pixel Pixel Percent Ehunekoa kImageAnnotator::StickerPicker Sticker Pegatina kImageAnnotator::ToolPicker Select Hautatu Pen Number Zenbakia Marker Rectangle Marker Ellipse Marker Pen Text Testua Arrow Gezia Double Arrow Gezi bikoitza Line Lerroa Blur Lausotu Rectangle Laukizuzena Ellipse Elipsea Number Pointer Zenbaki erakuslea Sticker Pegatina Pixelate Pixelatu Text Pointer Testu erakuslea Text Arrow Testu gezia Number Arrow Zenbaki gezia Duplicate Bikoiztu kImageAnnotator::ZoomPicker Zoom In (%1) Handitu (% 1) Zoom Out (%1) Txikiagotu (% 1) Reset Zoom (%1) Berrezarri zooma (% 1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_fr.ts000066400000000000000000000361211440330760000234440ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Disposer Bring to Front Envoyer à l'avant Bring Forward Envoyer vers l'avant Send Backward Envoyer vers l'arrière Send to Back Envoyer à l'arrière Select This Sélectionner ceci Copy Copier Paste Coller Edit Modifier Delete Supprimer kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Préférences générales kImageAnnotator::AnnotationImageSettings Image Settings Préférences image kImageAnnotator::AnnotationItemSettings Color Couleur Text Color Couleur du texte Width Largeur Number Seed Graine aléatoire Obfuscation Factor Facteur d'obfuscation Item Shadow Ombre de l'élément Item Settings Préférences de l'élément Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Fermer Close Other Fermer les autres Close All Tout fermer Close All to the Left Fermer tous ceux de gauche Close All to the Right Fermer tous ceux de droite kImageAnnotator::AnnotationToolSelection Tool Selection Outil de sélection kImageAnnotator::BoolPicker Enabled Actif Disabled Inactif kImageAnnotator::Controls Undo Redo Crop Scale Rotate Pivoter Modify canvas Cut kImageAnnotator::CropWidget Cancel Annuler X: X : Y: Y : W: L : H: H : Apply Appliquer kImageAnnotator::CutWidget Vertical Verticale Horizontal Horizontale Apply Appliquer Cancel Annuler kImageAnnotator::FillModePicker Border And Fill Visibility Visibilité de la bordure et du remplissage Border and Fill Bordure et remplissage Border and No Fill Bordure sans remplissage No Border and No Fill Ni bordure ni remplissage kImageAnnotator::FontPicker Font Size Taille de la police Bold Gras Italic Italique Underline Souligné kImageAnnotator::ImageEffectPicker Image Effects Effets d'image No Effect Aucun effet Drop Shadow Ombre portée Grayscale Niveaux de gris Border Bordure Invert Color Inverser couleur kImageAnnotator::ModifyCanvasWidget Restricted Restreint When enabled enforces the canvas to include the background image. Si activé, applique le canevas pour inclure l’image d'arrière-plan. X: X : Y: Y : W: L : H: H : Apply Appliquer Cancel Annuler Color: Couleur : Canvas Background Color Couleur de fond de la toile kImageAnnotator::RotateDialog Rotate Image Pivoter l'image 180° 180° 90° Clockwise 90° horaire 90° Counter Clockwise 90° anti-horaire Arbitrary Aléatoirement Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Les valeurs positives tournent dans le sens des aiguilles d'une montre, les valeurs négatives dans le sens inverse. La rotation par des multiplicateurs autres que 90° peut entraîner une perte de qualité. Horizontal Horizontale Vertical Verticale OK OK Cancel Annuler Rotate Pivoter Flip Retourner kImageAnnotator::ScaleDialog Scale Image Redimensionner l'image Keep Aspect Ratio Conserver le ratio Width: Largeur : Height: Hauteur : OK OK Cancel Annuler Pixel Pixel Percent Pourcentage kImageAnnotator::StickerPicker Sticker Autocollant kImageAnnotator::ToolPicker Select Sélectionner Pen Crayon Number Numéro Marker Rectangle Marqueur rectangle Marker Ellipse Marqueur ellipse Marker Pen Surligneur Text Texte Arrow Flèche Double Arrow Flèche double Line Ligne Blur Flou Rectangle Rectangle Ellipse Ellipse Number Pointer Pointeur de numéro Sticker Autocollant Pixelate Pixéliser Text Pointer Pointeur de texte Text Arrow Flèche de texte Number Arrow Flèche de nombre Duplicate Dupliquer kImageAnnotator::ZoomPicker Zoom In (%1) Zoom avant (%1) Zoom Out (%1) Zoom arrière (%1) Reset Zoom (%1) Réinitialiser le zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_fr_CA.ts000066400000000000000000000364171440330760000240170ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Bring to Front Bring Forward Send Backward Send to Back Select This Copy Paste Edit Delete kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings kImageAnnotator::AnnotationImageSettings Image Settings kImageAnnotator::AnnotationItemSettings Color Text Color Width Number Seed Obfuscation Factor Item Shadow Item Settings Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Close Other Close All Close All to the Left Close All to the Right kImageAnnotator::AnnotationToolSelection Tool Selection kImageAnnotator::BoolPicker Enabled Disabled kImageAnnotator::Controls Undo Redo Crop Scale Rotate Modify canvas Cut kImageAnnotator::CropWidget Cancel X: Y: W: H: Apply kImageAnnotator::CutWidget Vertical Horizontal Apply Cancel kImageAnnotator::FillModePicker Border And Fill Visibility Border and Fill Border and No Fill No Border and No Fill kImageAnnotator::FontPicker Font Size Bold Italic Underline kImageAnnotator::ImageEffectPicker Image Effects No Effect Drop Shadow Grayscale Border Invert Color kImageAnnotator::ModifyCanvasWidget Restricted When enabled enforces the canvas to include the background image. X: Y: W: H: Apply Cancel Color: Canvas Background Color kImageAnnotator::RotateDialog Rotate Image 180° 90° Clockwise 90° Counter Clockwise Arbitrary Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Horizontal Vertical OK Cancel Rotate Flip kImageAnnotator::ScaleDialog Scale Image Keep Aspect Ratio Width: Height: OK Cancel Pixel Percent kImageAnnotator::StickerPicker Sticker kImageAnnotator::ToolPicker Select Pen Number Marker Rectangle Marker Ellipse Marker Pen Text Arrow Double Arrow Line Blur Rectangle Ellipse Number Pointer Sticker Pixelate Text Pointer Text Arrow Number Arrow Duplicate kImageAnnotator::ZoomPicker Zoom In (%1) Zoom Out (%1) Reset Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_gl.ts000066400000000000000000000364171440330760000234470ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Bring to Front Bring Forward Send Backward Send to Back Select This Copy Paste Edit Delete kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings kImageAnnotator::AnnotationImageSettings Image Settings kImageAnnotator::AnnotationItemSettings Color Text Color Width Number Seed Obfuscation Factor Item Shadow Item Settings Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Close Other Close All Close All to the Left Close All to the Right kImageAnnotator::AnnotationToolSelection Tool Selection kImageAnnotator::BoolPicker Enabled Disabled kImageAnnotator::Controls Undo Redo Crop Scale Rotate Modify canvas Cut kImageAnnotator::CropWidget Cancel X: Y: W: H: Apply kImageAnnotator::CutWidget Vertical Horizontal Apply Cancel kImageAnnotator::FillModePicker Border And Fill Visibility Border and Fill Border and No Fill No Border and No Fill kImageAnnotator::FontPicker Font Size Bold Italic Underline kImageAnnotator::ImageEffectPicker Image Effects No Effect Drop Shadow Grayscale Border Invert Color kImageAnnotator::ModifyCanvasWidget Restricted When enabled enforces the canvas to include the background image. X: Y: W: H: Apply Cancel Color: Canvas Background Color kImageAnnotator::RotateDialog Rotate Image 180° 90° Clockwise 90° Counter Clockwise Arbitrary Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Horizontal Vertical OK Cancel Rotate Flip kImageAnnotator::ScaleDialog Scale Image Keep Aspect Ratio Width: Height: OK Cancel Pixel Percent kImageAnnotator::StickerPicker Sticker kImageAnnotator::ToolPicker Select Pen Number Marker Rectangle Marker Ellipse Marker Pen Text Arrow Double Arrow Line Blur Rectangle Ellipse Number Pointer Sticker Pixelate Text Pointer Text Arrow Number Arrow Duplicate kImageAnnotator::ZoomPicker Zoom In (%1) Zoom Out (%1) Reset Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_hr.ts000066400000000000000000000352261440330760000234530ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Rasporedi Bring to Front Premjesti skroz naprijed Bring Forward Premjesti prema naprijed Send Backward Premjesti prema natrag Send to Back Premjesti skroz natrag Select This Odaberi ovo Copy Kopiraj Paste Umetni Edit Uredi Delete Izbriši kImageAnnotator::AnnotationControlsWidget Controls Kontrole kImageAnnotator::AnnotationGeneralSettings General Settings Opće postavke kImageAnnotator::AnnotationImageSettings Image Settings Postavke slike kImageAnnotator::AnnotationItemSettings Color Boja Text Color Boja teksta Width Širina Number Seed Brojač Obfuscation Factor Faktor zamućenja Item Shadow Sjena elementa Item Settings Postavke elementa Scale Omjer Opacity Neprozirnost kImageAnnotator::AnnotationTabContextMenu Close Zatvori Close Other Zatvori ostale Close All Zatvori sve Close All to the Left Zatvori sve na lijevo Close All to the Right Zatvori sve na desno kImageAnnotator::AnnotationToolSelection Tool Selection Odabir alata kImageAnnotator::BoolPicker Enabled Aktivirano Disabled Deaktivirano kImageAnnotator::Controls Undo Poništi Redo Ponovi Crop Izreži Scale Omjer Rotate Okreni Modify canvas Promijeni platno Cut Izreži kImageAnnotator::CropWidget Cancel Odustani X: X: Y: Y: W: Š: H: V: Apply Primijeni kImageAnnotator::CutWidget Vertical Okomito Horizontal Vodoravno Apply Primijeni Cancel Odustani kImageAnnotator::FillModePicker Border And Fill Visibility Vidljivost ruba i ispune Border and Fill Rub i ispuna Border and No Fill Rub i bez ispune No Border and No Fill Bez ruba i bez ispune kImageAnnotator::FontPicker Font Size Veličina fonta Bold Podebljano Italic Kurziv Underline Podcrtano kImageAnnotator::ImageEffectPicker Image Effects Slikovni efekti No Effect Bez efekta Drop Shadow Odmaknuta sjena Grayscale Crno-bijela Border Rub Invert Color Invertiraj boju kImageAnnotator::ModifyCanvasWidget Restricted Ograničeno When enabled enforces the canvas to include the background image. Kad je aktivirano, područje crtanja uključuje sliku pozadine. X: X: Y: Y: W: Š: H: V: Apply Primijeni Cancel Odustani Color: Boja: Canvas Background Color Boja pozadine patna kImageAnnotator::RotateDialog Rotate Image Okreni sliku 180° 180° 90° Clockwise 90° nadesno 90° Counter Clockwise 90° nalijevo Arbitrary Proizvoljno Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Pozitivne vrijednosti okreću sliku u smjeru kazaljke na satu, negativne u suprotnom smjeru kazaljke na satu. Okretanje množiteljima koji nisu 90° može smanjiti kvalitetu slike. Horizontal Vodoravno Vertical Okomito OK U redu Cancel Odustani Rotate Okreni Flip Preokreni kImageAnnotator::ScaleDialog Scale Image Skaliraj sliku Keep Aspect Ratio Zadrži omjer Width: Širina: Height: Visina: OK U redu Cancel Odustani Pixel Piksel Percent Postotak kImageAnnotator::StickerPicker Sticker Naljepnica kImageAnnotator::ToolPicker Select Odaberi Pen Olovka Number Broj Marker Rectangle Pravokutni odabir Marker Ellipse Ovalni odabir Marker Pen Prostoručni odabir Text Tekst Arrow Strelica Double Arrow Dvostruka strelica Line Crta Blur Mutnoća Rectangle Pravokutnik Ellipse Oval Number Pointer Pokazivač s brojem Sticker Naljepnica Duplicate Dupliciraj Text Pointer Pokazivač s tekstom Text Arrow Strelica s tekstom Number Arrow Strelica s brojem Pixelate Pikseliziraj kImageAnnotator::ZoomPicker Zoom In (%1) Povećaj (%1) Zoom Out (%1) Smanji (%1) Reset Zoom (%1) Poništi zumiranje (%1) Reset Zoom Resetiraj zumiranje Fit Image Prilagodi sliku Fit image to view (%1) Prilagodi sliku za prikaz (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_hu.ts000066400000000000000000000364141440330760000234560ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Bring to Front Bring Forward Send Backward Send to Back Select This Copy Paste Edit Delete kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings kImageAnnotator::AnnotationImageSettings Image Settings kImageAnnotator::AnnotationItemSettings Color Text Color Width Number Seed Obfuscation Factor Item Shadow Item Settings Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Close Other Close All Close All to the Left Close All to the Right kImageAnnotator::AnnotationToolSelection Tool Selection kImageAnnotator::BoolPicker Enabled Disabled kImageAnnotator::Controls Undo Redo Crop Scale Rotate Modify canvas Cut kImageAnnotator::CropWidget Cancel X: Y: W: H: Apply kImageAnnotator::CutWidget Vertical Horizontal Apply Cancel kImageAnnotator::FillModePicker Border And Fill Visibility Border and Fill Border and No Fill No Border and No Fill kImageAnnotator::FontPicker Font Size Bold Italic Underline kImageAnnotator::ImageEffectPicker Image Effects No Effect Drop Shadow Grayscale Border Invert Color kImageAnnotator::ModifyCanvasWidget Restricted When enabled enforces the canvas to include the background image. X: Y: W: H: Apply Cancel Color: Canvas Background Color kImageAnnotator::RotateDialog Rotate Image 180° 90° Clockwise 90° Counter Clockwise Arbitrary Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Horizontal Vertical OK Cancel Rotate Flip kImageAnnotator::ScaleDialog Scale Image Keep Aspect Ratio Width: Height: OK Cancel Pixel Percent kImageAnnotator::StickerPicker Sticker kImageAnnotator::ToolPicker Select Pen Number Marker Rectangle Marker Ellipse Marker Pen Text Arrow Double Arrow Line Blur Rectangle Ellipse Number Pointer Sticker Pixelate Text Pointer Text Arrow Number Arrow Duplicate kImageAnnotator::ZoomPicker Zoom In (%1) Zoom Out (%1) Reset Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_id.ts000066400000000000000000000353021440330760000234310ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Atur Bring to Front Bawa ke Depan Bring Forward Bawa paling depan Send Backward Kirim paling belakang Send to Back Kirim ke belakang Select This Pilih ini Copy Salin Paste Tempel Edit Sunting Delete Hapus kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Pengaturan Umum kImageAnnotator::AnnotationImageSettings Image Settings Pengaturan Gambar kImageAnnotator::AnnotationItemSettings Color Warna Text Color Warna Teks Width Lebar Number Seed Nomor Seed Obfuscation Factor Faktor Obfuscation Item Shadow Bayangan item Item Settings Pengaturan item Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Tutup Close Other Tutup lainnya Close All Tutup semua Close All to the Left Tutup semua ke kiri Close All to the Right Tutup semua ke kanan kImageAnnotator::AnnotationToolSelection Tool Selection Seleksi Alat kImageAnnotator::BoolPicker Enabled Aktifkan Disabled Nonaktifkan kImageAnnotator::Controls Undo Redo Crop Scale Rotate Putar Modify canvas Cut kImageAnnotator::CropWidget Cancel Batal X: X: Y: Y: W: L: H: T: Apply Terapkan kImageAnnotator::CutWidget Vertical Vertikal Horizontal Horisontal Apply Terapkan Cancel Batal kImageAnnotator::FillModePicker Border And Fill Visibility Batas dan visibilitas isian Border and Fill Batas dan Isian Border and No Fill Batas dan Tanpa Isian No Border and No Fill Tanpa Batas dan Tanpa Isian kImageAnnotator::FontPicker Font Size Ukuran font Bold Tebal Italic Miring Underline Garis bawah kImageAnnotator::ImageEffectPicker Image Effects Efek gambar No Effect Tanpa Efek Drop Shadow Bayangan Jatuh Grayscale Skala Abu-abu Border Batas Invert Color Balikkan Warna kImageAnnotator::ModifyCanvasWidget Restricted Dibatasi When enabled enforces the canvas to include the background image. Saat diaktifkan akan membuat kanvas menyertakan gambar latar belakang. X: X: Y: Y: W: L: H: T: Apply Terapkan Cancel Batal Color: Warna: Canvas Background Color Warna Latar Belakang Kanvas kImageAnnotator::RotateDialog Rotate Image Putar gambar 180° 180° 90° Clockwise 90° Serarah jarum jam 90° Counter Clockwise 90° Berlawanan jarum jam Arbitrary Sembarang Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Nilai positif berputar searah jarum jam, nilai negatif berlawanan arah jarum jam. Memutar dengan pengganda non 90° mungkin mengurangi kualitasnya. Horizontal Horisontal Vertical Vertikal OK OK Cancel Batal Rotate Putar Flip Balik kImageAnnotator::ScaleDialog Scale Image Skala gambar Keep Aspect Ratio Jaga Rasio Aspek Width: Lebar: Height: Tinggi: OK Ok Cancel Batal Pixel Piksel Percent Persen kImageAnnotator::StickerPicker Sticker Stiker kImageAnnotator::ToolPicker Select Pilih Pen Pena Number Nomor Marker Rectangle Marker Persegi Panjang Marker Ellipse Penanda Elips Marker Pen Spidol Text Teks Arrow Anak panah Double Arrow Panah Ganda Line Garis Blur Blur Rectangle Persegi Ellipse Elips Number Pointer Penunjuk Angka Sticker Stiker Pixelate Pixelate Text Pointer Penunjuk Teks Text Arrow Panah Teks Number Arrow Panah Angka Duplicate Duplikat kImageAnnotator::ZoomPicker Zoom In (%1) Perbesar (%1) Zoom Out (%1) Perkecil (%1) Reset Zoom (%1) Setel Ulang Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_it.ts000066400000000000000000000353641440330760000234610ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Disponi Bring to Front Porta in primo piano Bring Forward Invia in avanti Send Backward Manda indietro Send to Back Manda in fondo Select This Seleziona questo Copy Copia Paste Incolla Edit Modifica Delete Elimina kImageAnnotator::AnnotationControlsWidget Controls Controlli kImageAnnotator::AnnotationGeneralSettings General Settings Impostazioni generali kImageAnnotator::AnnotationImageSettings Image Settings Impostazioni immagine kImageAnnotator::AnnotationItemSettings Color Colore Text Color Colore del testo Width Larghezza Number Seed Numero seme Obfuscation Factor Fattore di offuscamento Item Shadow Ombreggiatura elemento Item Settings Impostazione elemento Scale Scala Opacity Opacità kImageAnnotator::AnnotationTabContextMenu Close Chiudi Close Other Chiudi altro Close All Chiudi tutto Close All to the Left Chiudi tutto a sinistra Close All to the Right Chiudi tutto a destra kImageAnnotator::AnnotationToolSelection Tool Selection Selezione strumento kImageAnnotator::BoolPicker Enabled Abilitato Disabled Disabilitato kImageAnnotator::Controls Undo Annulla Redo Rifare Crop Ritaglia Scale Scala Rotate Ruota Modify canvas Modifica tela Cut Taglia kImageAnnotator::CropWidget Cancel Annulla X: X: Y: Y: W: L: H: A: Apply Applica kImageAnnotator::CutWidget Vertical Verticale Horizontal Orizzontale Apply Applica Cancel Annulla kImageAnnotator::FillModePicker Border And Fill Visibility Visibilità bordo e riempimento Border and Fill Bordo e riempimento Border and No Fill Bordo e nessun riempimento No Border and No Fill Nessun bordo e nessun riempimento kImageAnnotator::FontPicker Font Size Dimensione caratteri Bold Grassetto Italic Corsivo Underline Sottolineatura kImageAnnotator::ImageEffectPicker Image Effects Effetti immagine No Effect Nessun effetto Drop Shadow Ombra esterna Grayscale Scala di grigi Border Bordo Invert Color Inverti colore kImageAnnotator::ModifyCanvasWidget Restricted Limitato When enabled enforces the canvas to include the background image. Quando abilitato forza la tela ad includere l'immagine di sfondo. X: X: Y: Y: W: L: H: A: Apply Applica Cancel Annulla Color: Colore: Canvas Background Color Colore di sfondo della tela kImageAnnotator::RotateDialog Rotate Image Ruota immagine 180° 180° 90° Clockwise 90° in senso orario 90° Counter Clockwise 90° in senso antiorario Arbitrary Arbitrario Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. I valori positivi ruotano in senso orario, i valori negativi in senso antiorario. La rotazione di moltiplicatori diversi da 90° potrebbe introdurre una perdita di qualità. Horizontal Orizzontale Vertical Verticale OK OK Cancel Annulla Rotate Ruota Flip Capovolgi kImageAnnotator::ScaleDialog Scale Image Scala immagine Keep Aspect Ratio Mantenere proporzioni Width: Larghezza: Height: Altezza: OK OK Cancel Annulla Pixel Pixel Percent Percentuale kImageAnnotator::StickerPicker Sticker Adesivo kImageAnnotator::ToolPicker Select Seleziona Pen Penna Number Numero Marker Rectangle Marcatore rettangolo Marker Ellipse Marcatore ellisse Marker Pen Marcatore penna Text Testo Arrow Freccia Double Arrow Doppia freccia Line Linea Blur Sfocatura Rectangle Rettangolo Ellipse Ellisse Number Pointer Puntatore numerico Sticker Adesivo Pixelate Pixellato Text Pointer Puntatore testo Text Arrow Freccia testo Number Arrow Numero freccia Duplicate Duplica kImageAnnotator::ZoomPicker Zoom In (%1) Ingrandisci (%1) Zoom Out (%1) Rimpicciolisci (%1) Reset Zoom (%1) Reimposta zoom (%1) Reset Zoom Ripristina zoom Fit Image Adatta immagine Fit image to view (%1) Adatta immagine alla visualizzazione (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_ja.ts000066400000000000000000000355421440330760000234350ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange 重なり Bring to Front 最前面へ Bring Forward 前面へ Send Backward 背面へ Send to Back 最背面へ Select This これを選択 Copy コピー Paste 貼り付け Edit 編集 Delete 削除 kImageAnnotator::AnnotationControlsWidget Controls 操作 kImageAnnotator::AnnotationGeneralSettings General Settings 一般設定 kImageAnnotator::AnnotationImageSettings Image Settings 画像の設定 kImageAnnotator::AnnotationItemSettings Color 色 Text Color 文字色 Width 幅 Number Seed シード番号 Obfuscation Factor 不明化係数 Item Shadow アイテムの影 Item Settings アイテムの設定 Scale 拡大率 Opacity 不透明度 kImageAnnotator::AnnotationTabContextMenu Close 閉じる Close Other ほかを閉じる Close All すべて閉じる Close All to the Left 左側のタブをすべて閉じる Close All to the Right 右側のタブをすべて閉じる kImageAnnotator::AnnotationToolSelection Tool Selection ツールの選択 kImageAnnotator::BoolPicker Enabled 有効 Disabled 無効 kImageAnnotator::Controls Undo 元に戻す Redo やり直し Crop 切り取り Scale 拡大縮小 Rotate 回転 Modify canvas キャンバスの修正 Cut 切り抜き削除 kImageAnnotator::CropWidget Cancel キャンセル X: Y: W: 幅: H: 高さ: Apply 適応 kImageAnnotator::CutWidget Vertical 縦 Horizontal 横 Apply 適応 Cancel キャンセル kImageAnnotator::FillModePicker Border And Fill Visibility 枠と塗りつぶし Border and Fill 枠あり/塗りつぶし Border and No Fill 枠のみ No Border and No Fill なし kImageAnnotator::FontPicker Font Size フォントの大きさ Bold 太字 Italic 斜字 Underline 下線 kImageAnnotator::ImageEffectPicker Image Effects 画像エフェクト No Effect エフェクトなし Drop Shadow ドロップシャドー Grayscale グレースケール Border 枠線 Invert Color 色の反転 kImageAnnotator::ModifyCanvasWidget Restricted 制限 When enabled enforces the canvas to include the background image. 有効なら、キャンバスは背景画像を 含めたサイズに制限されます。 X: Y: W: 幅: H: 高さ: Apply 適応 Cancel キャンセル Color: 色: Canvas Background Color キャンバスの背景色 kImageAnnotator::RotateDialog Rotate Image 画像の回転 180° 180° 90° Clockwise 90° 時計回り 90° Counter Clockwise 90° 反時計回り Arbitrary 指定 Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. 正の値で時計回りに回転し、負の値では反時計回りです。 90° 以外の倍数で回転すると、画質が低下することがあります。 Horizontal 横 Vertical 縦 OK OK Cancel キャンセル Rotate 回転 Flip 反転 kImageAnnotator::ScaleDialog Scale Image 画像の拡大縮小 Keep Aspect Ratio アスペクト比を固定 Width: 幅: Height: 高さ: OK OK Cancel キャンセル Pixel ピクセル Percent パーセント kImageAnnotator::StickerPicker Sticker ステッカー kImageAnnotator::ToolPicker Select 選択 Pen ペン Number 番号 Marker Rectangle マーカー四角形 Marker Ellipse マーカー円形 Marker Pen マーカーペン Text 文字 Arrow 矢印 Double Arrow 両矢印 Line 線 Blur ぼやけ Rectangle 四角形 Ellipse 円形 Number Pointer 数字とポイント Sticker ステッカー Pixelate モザイク Text Pointer 文字とポイント Text Arrow 文字と矢印 Number Arrow 番号と矢印 Duplicate 複製 kImageAnnotator::ZoomPicker Zoom In (%1) 拡大 (%1) Zoom Out (%1) 縮小 (%1) Reset Zoom (%1) 拡大を初期化 (%1) Reset Zoom 拡大を初期化 Fit Image 画像に適合 Fit image to view (%1) 表示を画像に適合 (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_ko.ts000066400000000000000000000355551440330760000234600ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange 배열 Bring to Front 맨 앞으로 가져오기 Bring Forward 앞으로 가져오기 Send Backward 뒤로 보내기 Send to Back 맨 뒤로 보내기 Select This 이 항목 선택 Copy 복사 Paste 붙여넣기 Edit 편집 Delete 삭제 kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings 일반 설정 kImageAnnotator::AnnotationImageSettings Image Settings 그림 설정 kImageAnnotator::AnnotationItemSettings Color 색상 Text Color 글자색 Width 너비 Number Seed 숫자 시드 Obfuscation Factor 난독화 계수 Item Shadow 항목 그림자 Item Settings 항목 설정 Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close 닫기 Close Other 다른 모두 닫기 Close All 모두 닫기 Close All to the Left 왼쪽에 있는 모두 닫기 Close All to the Right 오른쪽에 있는 모두 닫기 kImageAnnotator::AnnotationToolSelection Tool Selection 도구 선택 kImageAnnotator::BoolPicker Enabled 사용함 Disabled 사용 안 함 kImageAnnotator::Controls Undo Redo Crop Scale Rotate 회전 Modify canvas Cut kImageAnnotator::CropWidget Cancel 취소 X: X: Y: Y: W: W: H: H: Apply 적용 kImageAnnotator::CutWidget Vertical 수직 Horizontal 수평 Apply 적용 Cancel 취소 kImageAnnotator::FillModePicker Border And Fill Visibility 경계선과 채우기 표시 여부 Border and Fill 경계선과 채우기 Border and No Fill 경계선 있음, 채우기 없음 No Border and No Fill 경계선 없음, 채우기 없음 kImageAnnotator::FontPicker Font Size 글꼴 크기 Bold 굵게 Italic 이탤릭 Underline 밑줄 kImageAnnotator::ImageEffectPicker Image Effects 그림 효과 No Effect 효과 없음 Drop Shadow 외부 그림자 Grayscale 회색조 Border 경계선 Invert Color 색 반전 kImageAnnotator::ModifyCanvasWidget Restricted 제한됨 When enabled enforces the canvas to include the background image. 이 옵션을 사용하면 캔버스에 배경 그림을 포함하도록 강제합니다. X: X: Y: Y: W: W: H: H: Apply 적용 Cancel 취소 Color: 색: Canvas Background Color 캔버스 배경색 kImageAnnotator::RotateDialog Rotate Image 이미지 회전 180° 180° 90° Clockwise 90° 오른쪽 90° Counter Clockwise 90° 왼쪽 Arbitrary 임의 Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. 양수는 오른쪽, 음수는 왼쪽으로 회전합니다. 90°의 배수가 아닌 값으로 회전하면 품질 손실이 있을 수 있습니다. Horizontal 수평 Vertical 수직 OK 확인 Cancel 취소 Rotate 회전 Flip 뒤집기 kImageAnnotator::ScaleDialog Scale Image 그림 크기 조정 Keep Aspect Ratio 가로 세로 비율 유지 Width: 너비: Height: 높이: OK 확인 Cancel 취소 Pixel 픽셀 Percent 백분율 kImageAnnotator::StickerPicker Sticker 스티커 kImageAnnotator::ToolPicker Select 선택 Pen 펜 Number 숫자 Marker Rectangle 마커 직사각형 Marker Ellipse 마커 타원형 Marker Pen 마커 펜 Text 텍스트 Arrow 화살표 Double Arrow 이중 화살표 Line 직선 Blur 흐리게 Rectangle 직사각형 Ellipse 타원형 Number Pointer 숫자 포인터 Sticker 스티커 Pixelate 픽셀화 Text Pointer 텍스트 포인터 Text Arrow 텍스트 화살표 Number Arrow 숫자 화살표 Duplicate 복제 kImageAnnotator::ZoomPicker Zoom In (%1) 확대(%1) Zoom Out (%1) 축소(%1) Reset Zoom (%1) 배율 초기화(%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_nl.ts000066400000000000000000000353731440330760000234560ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Organiseren Bring to Front Op voorgrond plaatsen Bring Forward Op voorgrond plaatsen Send Backward Op achtergrond plaatsen Send to Back Op achtergrond plaatsen Select This Dit selecteren Copy Kopiëren Paste Plakken Edit Bewerken Delete Verwijderen kImageAnnotator::AnnotationControlsWidget Controls Bediening kImageAnnotator::AnnotationGeneralSettings General Settings Algemene instellingen kImageAnnotator::AnnotationImageSettings Image Settings Afbeeldingsinstellingen kImageAnnotator::AnnotationItemSettings Color Kleur Text Color Tekstkleur Width Breedte Number Seed Aantal Obfuscation Factor Maskeerfactor Item Shadow Itemschaduw Item Settings Iteminstellingen Scale Schaal Opacity Doorzichtigheid kImageAnnotator::AnnotationTabContextMenu Close Sluiten Close Other Overige sluiten Close All Alles sluiten Close All to the Left Alles links hiervan sluiten Close All to the Right Alles rechts hiervan sluiten kImageAnnotator::AnnotationToolSelection Tool Selection Gereedschapskeuze kImageAnnotator::BoolPicker Enabled Ingeschakeld Disabled Uitgeschakeld kImageAnnotator::Controls Undo Ongedaan maken Redo Opnieuw uitvoeren Crop Bijsnijden Scale Vergroten/Verkleinen Rotate Draaien Modify canvas Canvas aanpassen Cut Knippen kImageAnnotator::CropWidget Cancel Annuleren X: X: Y: Y: W: B: H: H: Apply Toepassen kImageAnnotator::CutWidget Vertical Verticaal Horizontal Horizontaal Apply Toepassen Cancel Annuleren kImageAnnotator::FillModePicker Border And Fill Visibility Rand- en opvulzichtbaarheid Border and Fill Rand met opvulling Border and No Fill Rand zonder opvulling No Border and No Fill Geen rand, geen opvulling kImageAnnotator::FontPicker Font Size Tekstgrootte Bold Vetgedrukt Italic Cursief Underline Onderstrepen kImageAnnotator::ImageEffectPicker Image Effects Afbeeldingseffecten No Effect Geen effect Drop Shadow Vallende schaduw Grayscale Grijswaarden Border Rand Invert Color Kleuren omkeren kImageAnnotator::ModifyCanvasWidget Restricted Beperkt When enabled enforces the canvas to include the background image. Schakel in om het canvas gedwongen de achtergrondafbeelding te laten tonen. X: X: Y: Y: W: B: H: H: Apply Toepassen Cancel Annuleren Color: Kleur: Canvas Background Color Achtergrondkleur van canvas kImageAnnotator::RotateDialog Rotate Image Afbeelding draaien 180° 180° 90° Clockwise 90° naar rechts 90° Counter Clockwise 90° naar links Arbitrary Willekeurig Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Positieve waarde = naar rechts draaien - Negatieve waarde = naar links draaien. Een waarde die afwijkt van 90° kan kwaliteitsverlies veroorzaken. Horizontal Horizontaal Vertical Verticaal OK Oké Cancel Annuleren Rotate Draaien Flip Spiegelen kImageAnnotator::ScaleDialog Scale Image Afmetingen aanpassen Keep Aspect Ratio Beeldverhouding behouden Width: Breedte: Height: Hoogte: OK Oké Cancel Annuleren Pixel Pixel Percent Procent kImageAnnotator::StickerPicker Sticker Sticker kImageAnnotator::ToolPicker Select Kiezen Pen Pen Number Getal Marker Rectangle Markeerrechthoek Marker Ellipse Markeerellips Marker Pen Markeerstift Text Tekst Arrow Pijl Double Arrow Dubbele pijl Line Lijn Blur Vervaging Rectangle Rechthoek Ellipse Ellips Number Pointer Getalaanwijzer Sticker Sticker Pixelate Pixelvorming Text Pointer Tekstaanwijzer Text Arrow Tekstuele pijl Number Arrow Getalpijl Duplicate Klonen kImageAnnotator::ZoomPicker Zoom In (%1) Inzoomen (%1) Zoom Out (%1) Uitzoomen (%1) Reset Zoom (%1) Standaard zoomniveau (%1) Reset Zoom Oorspronkelijk zoomniveau Fit Image Afbeelding inpassen Fit image to view (%1) Afbeelding aanpassen aan weergave (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_no.ts000066400000000000000000000360341440330760000234540ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Tilpass Bring to Front Ta til forgrunnen Bring Forward Ta forover Send Backward Send bakover Send to Back Send bakerst Select This Velg dette Copy Kopier Paste Lim inn Edit Rediger Delete Slett kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings kImageAnnotator::AnnotationImageSettings Image Settings kImageAnnotator::AnnotationItemSettings Color Farge Text Color Tekstfarge Width Bredde Number Seed Såtall Obfuscation Factor Dekkevnefaktor Item Shadow Item Settings Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Lukk Close Other Lukk andre Close All Lukk alle Close All to the Left Lukk alle til venstre Close All to the Right Lukk alle til høyre kImageAnnotator::AnnotationToolSelection Tool Selection kImageAnnotator::BoolPicker Enabled Disabled kImageAnnotator::Controls Undo Redo Crop Scale Rotate Modify canvas Cut kImageAnnotator::CropWidget Cancel Avbryt X: X: Y: Y: W: B: H: H: Apply Bruk kImageAnnotator::CutWidget Vertical Horizontal Apply Bruk Cancel Avbryt kImageAnnotator::FillModePicker Border And Fill Visibility Kantlinje og utfyllingssynlighet Border and Fill Kantlinje og utfylling Border and No Fill Kantlinje og ingen utfylling No Border and No Fill Ingen kantlinje og ingen utfylling kImageAnnotator::FontPicker Font Size Skriftstørrelse Bold Italic Underline kImageAnnotator::ImageEffectPicker Image Effects Bildeeffekter No Effect Ingen effekt Drop Shadow Kastskygge Grayscale Gråskala Border Kantlinje Invert Color kImageAnnotator::ModifyCanvasWidget Restricted Begrenset When enabled enforces the canvas to include the background image. Påtvinger bruk av bakgrunnsbilde i kanvas når påslått. X: X: Y: Y: W: B: H: H: Apply Bruk Cancel Avbryt Color: Canvas Background Color kImageAnnotator::RotateDialog Rotate Image 180° 90° Clockwise 90° Counter Clockwise Arbitrary Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Horizontal Vertical OK OK Cancel Avbryt Rotate Flip kImageAnnotator::ScaleDialog Scale Image Skaler bilde Keep Aspect Ratio Behold sideforhold Width: Bredde: Height: Høyde: OK OK Cancel Avbryt Pixel Piksel Percent Prosent kImageAnnotator::StickerPicker Sticker Klistremerke kImageAnnotator::ToolPicker Select Velg Pen Penn Number Tall Marker Rectangle Peker-rektangel Marker Ellipse Peker-ellipse Marker Pen Peker-penn Text Tekst Arrow Pil Double Arrow Dobbelpil Line Linje Blur Tilsløring Rectangle Rektangel Ellipse Ellipse Number Pointer Nummerpeker Sticker Klistremerke Pixelate Pikseler Text Pointer Tekstpeker Text Arrow Tekstpil Number Arrow Nummerpil Duplicate Dupliser kImageAnnotator::ZoomPicker Zoom In (%1) Zoom Out (%1) Reset Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_pl.ts000066400000000000000000000357511440330760000234600ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Aranżacja Bring to Front Przesuń na wierzch Bring Forward Przesuń do przodu Send Backward Przesuń do tyłu Send to Back Przesuń na spód Select This Wybierz to Copy Kopiuj Paste Wklej Edit Edycja Delete Usuń kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Ustawienia główne kImageAnnotator::AnnotationImageSettings Image Settings Ustawienia obrazu kImageAnnotator::AnnotationItemSettings Color Kolor Text Color Kolor tekstu Width Szerokość Number Seed Numer ziarna Obfuscation Factor Współczynnik zaciemniania Item Shadow Cień elementu Item Settings Ustawienia elementów Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Zamknij Close Other Zamknij Inne Close All Zamknij wszystko Close All to the Left Zamknij wszystko po lewej stronie Close All to the Right Zamknij wszystkie po prawej stronie kImageAnnotator::AnnotationToolSelection Tool Selection Wybór narzędzia kImageAnnotator::BoolPicker Enabled Włączone Disabled Wyłączone kImageAnnotator::Controls Undo Redo Crop Scale Rotate Obróć Modify canvas Cut kImageAnnotator::CropWidget Cancel Anuluj X: X: Y: Y: W: W: H: H: Apply Zastosuj kImageAnnotator::CutWidget Vertical Pionowo Horizontal Poziomo Apply Zastosuj Cancel Anuluj kImageAnnotator::FillModePicker Border And Fill Visibility Widoczność krawędzi i wypełnienia Border and Fill Obramowanie i wypełnienie Border and No Fill Obramowanie i brak wypełnienia No Border and No Fill Bez obramowania i bez wypełnienia kImageAnnotator::FontPicker Font Size Rozmiar czcionki Bold Pogrubienie Italic Pochylenie Underline Podkreślenie kImageAnnotator::ImageEffectPicker Image Effects Efekty obrazu No Effect Bez efektu Drop Shadow Cień Grayscale Skala szarości Border Obramowanie Invert Color Odwróć kolor kImageAnnotator::ModifyCanvasWidget Restricted Ograniczone When enabled enforces the canvas to include the background image. Po włączeniu wymusza kanwę, aby uwzględnić obraz tła. X: X: Y: Y: W: W: H: H: Apply Zastosuj Cancel Anuluj Color: Kolor: Canvas Background Color Kolor tła płótna kImageAnnotator::RotateDialog Rotate Image Obróć obraz 180° 180° 90° Clockwise 90° zgodnie z ruchem wskazówek zegara 90° Counter Clockwise 90° przeciwnie do ruchu wskazówek zegara Arbitrary Dowolnie Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Wartości dodatnie obracają zgodnie z ruchem wskazówek zegara, wartości ujemne przeciwnie do ruchu wskazówek zegara. Obracanie przez mnożniki inne niż 90° może spowodować utratę jakości. Horizontal Poziomo Vertical Pionowo OK OK Cancel Anuluj Rotate Obróć Flip Przerzut kImageAnnotator::ScaleDialog Scale Image Skaluj obraz Keep Aspect Ratio Zachowaj proporcje Width: Szerokość: Height: Wysokość: OK OK Cancel Anuluj Pixel Pikseli Percent Procent kImageAnnotator::StickerPicker Sticker Naklejka kImageAnnotator::ToolPicker Select Wybierz Pen Pióro Number Numer Marker Rectangle Znacznik prostokątny Marker Ellipse Znacznik eliptyczny Marker Pen Zakreślacz Text Tekst Arrow Strzałka Double Arrow Podwójna strzałka Line Linia Blur Rozmycie Rectangle Prostokąt Ellipse Elipsa Number Pointer Wskaźnik numeryczny Sticker Naklejka Pixelate Pikslowanie Text Pointer Wskaźnik tekstu Text Arrow Strzałka tekstu Number Arrow Strzałka numeryczna Duplicate Zduplikowane kImageAnnotator::ZoomPicker Zoom In (%1) Powiększ (%1) Zoom Out (%1) Pomniejsz (%1) Reset Zoom (%1) Resetuj powiększenie (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_pt.ts000066400000000000000000000357261440330760000234720ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Organizar Bring to Front Trazer para frente Bring Forward Avançar um nível Send Backward Recuar um nível Send to Back Enviar para trás Select This Selecione isto Copy Copiar Paste Colar Edit Editar Delete Apagar kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Configurações Gerais kImageAnnotator::AnnotationImageSettings Image Settings Configurações de imagem kImageAnnotator::AnnotationItemSettings Color Cor Text Color Cor do texto Width Tamanho / Espessura da Ferramenta atual Number Seed Número Obfuscation Factor Fator de Obfuscação Item Shadow Sombra do Item Item Settings Configurações do item Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Fechar aba Close Other Fechar outras abas Close All Fechar todas as abas Close All to the Left Fechar abas à esquerda Close All to the Right Fechar abas à direita kImageAnnotator::AnnotationToolSelection Tool Selection Seleção de ferramentas kImageAnnotator::BoolPicker Enabled Ativado Disabled Desativado kImageAnnotator::Controls Undo Redo Crop Scale Rotate Rotacionar Modify canvas Cut kImageAnnotator::CropWidget Cancel Cancelar X: X: Y: Y: W: Largura: H: Altura: Apply Aplicar kImageAnnotator::CutWidget Vertical Vertical Horizontal Horizontal Apply Aplicar Cancel Cancelar kImageAnnotator::FillModePicker Border And Fill Visibility Exibição de borda e preenchimento Border and Fill Com borda e com preenchimento Border and No Fill Com borda e sem preenchimento No Border and No Fill Sem borda e sem preenchimento kImageAnnotator::FontPicker Font Size Tamanho da fonte Bold Negrito Italic Itálico Underline Sublinhado kImageAnnotator::ImageEffectPicker Image Effects Efeitos da imagem No Effect Sem efeito Drop Shadow Sombreado Grayscale Escala de cinza Border Borda Invert Color Inverter cor kImageAnnotator::ModifyCanvasWidget Restricted RestritO When enabled enforces the canvas to include the background image. Quando ativado, impõe a tela para incluir a imagem de fundo. X: X: Y: Y: W: Largura: H: Altura: Apply Aplicar Cancel Cancelar Color: Cor: Canvas Background Color Cor de fundo da tela kImageAnnotator::RotateDialog Rotate Image Rotacionar Imagem 180° 180º 90° Clockwise 90° no sentido horário 90° Counter Clockwise 90° no sentido anti-horário Arbitrary Arbitrário Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Os valores positivos giram no sentido horário, os valores negativos no sentido anti-horário. Rotacionar por multiplicadores diferentes de 90° pode causar perda de qualidade. Horizontal Horizontal Vertical Vertical OK OK Cancel Cancelar Rotate Rotacionar Flip Girar - Inverter kImageAnnotator::ScaleDialog Scale Image Redimensionar imagem Keep Aspect Ratio Manter proporção Width: Largura: Height: Altura: OK OK Cancel Cancelar Pixel Pixel Percent Percentagem kImageAnnotator::StickerPicker Sticker Adesivo kImageAnnotator::ToolPicker Select Seleção Pen Caneta Number Número Marker Rectangle Marcador Retangular Marker Ellipse Marcador Elíptico Marker Pen Caneta Marcadora Text Texto Arrow Seta Double Arrow Seta Dupla Line Linha Blur Ofuscar Rectangle Retângulo Ellipse Elipse Number Pointer Número com ponteiro Sticker Adesivo Pixelate Pixelar Text Pointer Texto com ponteiro Text Arrow Texto com seta Number Arrow Número com seta Duplicate Duplicar kImageAnnotator::ZoomPicker Zoom In (%1) Zoom + (%1) Zoom Out (%1) Zoom - (%1) Reset Zoom (%1) Redefinir Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_pt_BR.ts000066400000000000000000000355061440330760000240510ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Organizar Bring to Front Trazer para frente Bring Forward Avançar um nível Send Backward Recuar um nível Send to Back Enviar para trás Select This Selecione isto Copy Copiar Paste Colar Edit Editar Delete Excluir kImageAnnotator::AnnotationControlsWidget Controls Controles kImageAnnotator::AnnotationGeneralSettings General Settings Configurações Gerais kImageAnnotator::AnnotationImageSettings Image Settings Configurações de imagem kImageAnnotator::AnnotationItemSettings Color Cor Text Color Cor do texto Width Tamanho / Espessura da Ferramenta atual Number Seed Número Obfuscation Factor Fator de Obfuscação Item Shadow Sombra do Item Item Settings Configurações do item Scale Escala Opacity Opacidade kImageAnnotator::AnnotationTabContextMenu Close Fechar aba Close Other Fechar outras abas Close All Fechar todas as abas Close All to the Left Fechar abas à esquerda Close All to the Right Fechar abas à direita kImageAnnotator::AnnotationToolSelection Tool Selection Ferramenta Seleção kImageAnnotator::BoolPicker Enabled Habilitado Disabled Desabilitado kImageAnnotator::Controls Undo Desfazer Redo Refazer Crop Recortar Scale Escala Rotate Rotacionar Modify canvas Modificar tela Cut Cortar kImageAnnotator::CropWidget Cancel Cancelar X: X: Y: Y: W: Largura: H: Altura: Apply Aplicar kImageAnnotator::CutWidget Vertical Vertical Horizontal Horizontal Apply Aplicar Cancel Cancelar kImageAnnotator::FillModePicker Border And Fill Visibility Modo de desenho da borda e do preenchimento Border and Fill Com borda e com preenchimento Border and No Fill Com borda e sem preenchimento No Border and No Fill Sem borda e sem preenchimento kImageAnnotator::FontPicker Font Size Tamanho da fonte Bold Negrito Italic Itálico Underline Sublinhado kImageAnnotator::ImageEffectPicker Image Effects Efeitos para a imagem No Effect Sem Efeito Drop Shadow Sombreado Grayscale Escala de cinza Border Borda Invert Color Inverter cor kImageAnnotator::ModifyCanvasWidget Restricted RestritO When enabled enforces the canvas to include the background image. Quando ativado, impõe a tela para incluir a imagem de fundo. X: X: Y: Y: W: Largura: H: Altura: Apply Aplicar Cancel Cancelar Color: Cor: Canvas Background Color Cor de fundo da tela kImageAnnotator::RotateDialog Rotate Image Rotacionar Imagem 180° 180º 90° Clockwise 90° no sentido horário 90° Counter Clockwise 90° no sentido anti-horário Arbitrary Arbitrário Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Os valores positivos giram no sentido horário, os valores negativos no sentido anti-horário. Rotacionar por multiplicadores diferentes de 90° pode causar perda de qualidade. Horizontal Horizontal Vertical Vertical OK OK Cancel Cancelar Rotate Rotacionar Flip Girar - Inverter kImageAnnotator::ScaleDialog Scale Image Redimensionar imagem Keep Aspect Ratio Manter proporção Width: Largura: Height: Altura: OK OK Cancel Cancelar Pixel Pixel Percent Porcentagem kImageAnnotator::StickerPicker Sticker Figurinha kImageAnnotator::ToolPicker Select Seleção Pen Caneta Number Número Marker Rectangle Marcador Retangular Marker Ellipse Marcador Elíptico Marker Pen Caneta Marcadora Text Texto Arrow Seta Double Arrow Seta Dupla Line Linha Blur Ofuscar Rectangle Retângulo Ellipse Elipse Number Pointer Número com ponteiro Sticker Figurinha Text Pointer Texto com ponteiro Text Arrow Texto com seta Number Arrow Número com seta Pixelate Pixelizar Duplicate Duplicar kImageAnnotator::ZoomPicker Zoom In (%1) Zoom + (%1) Zoom Out (%1) Zoom - (%1) Reset Zoom (%1) Redefinir Zoom (%1) Reset Zoom Redefinir zoom Fit Image Ajustar a imagem Fit image to view (%1) Ajustar imagem para visualização (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_ro.ts000066400000000000000000000357371440330760000234710ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Aranjează Bring to Front Adu în față Bring Forward Adu mai în față Send Backward Trimite mai în spate Send to Back Trimite în spate Select This Alege acesta Copy Copiază Paste Lipește Edit Modifică Delete Șterge kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings Configurări generale kImageAnnotator::AnnotationImageSettings Image Settings Configurări imagine kImageAnnotator::AnnotationItemSettings Color Culoare Text Color Culoare text Width Lățime Number Seed Sămânță numerică Obfuscation Factor Factor de eclipsare Item Shadow Umbră element Item Settings Configurări element Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Închide Close Other Închide celelalte Close All Închide toate Close All to the Left Închide toate la stânga Close All to the Right Închide toate la dreapta kImageAnnotator::AnnotationToolSelection Tool Selection Alegere unealtă kImageAnnotator::BoolPicker Enabled Activat Disabled Dezactivat kImageAnnotator::Controls Undo Redo Crop Scale Rotate Rotește Modify canvas Cut kImageAnnotator::CropWidget Cancel Renunță X: X: Y: Y: W: L: H: Î: Apply Aplică kImageAnnotator::CutWidget Vertical Vertical Horizontal Orizontal Apply Aplică Cancel Renunță kImageAnnotator::FillModePicker Border And Fill Visibility Vizibilitate contur și umplere Border and Fill Contur și umplere Border and No Fill Contur fără umplere No Border and No Fill Fără contur și fără umplere kImageAnnotator::FontPicker Font Size Dimensiune font Bold Aldin Italic Cursiv Underline Subliniat kImageAnnotator::ImageEffectPicker Image Effects Efecte imagine No Effect Fără efect Drop Shadow Lasă umbră Grayscale Nuanțe de gri Border Contur Invert Color Inversează culoarea kImageAnnotator::ModifyCanvasWidget Restricted Restricționat When enabled enforces the canvas to include the background image. La activare forțează canavaua să includă imaginea de fundal. X: X: Y: Y: W: L: H: Î: Apply Aplică Cancel Renunță Color: Culoare: Canvas Background Color Culoare fundal canava kImageAnnotator::RotateDialog Rotate Image Rotește imaginea 180° 180° 90° Clockwise 90° în sensul acelor de ceasornic 90° Counter Clockwise 90° în sens contrar acelor de ceasornic Arbitrary Arbitrar Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Valorile pozitive rotesc în sensul acelor de ceasornic, cele negative – în sens contrar. Rotirea cu non-multiplu de 90° poate introduce pierderi de calitate. Horizontal Orizontal Vertical Vertical OK Bine Cancel Renunță Rotate Rotește Flip Răstoarnă kImageAnnotator::ScaleDialog Scale Image Scalează imaginea Keep Aspect Ratio Păstrează raportul de aspect Width: Lățime: Height: Înălțime: OK Bine Cancel Renunță Pixel Pixel Percent Procent kImageAnnotator::StickerPicker Sticker Autocolant kImageAnnotator::ToolPicker Select Alege Pen Stilou Number Număr Marker Rectangle Dreptunghi marcator Marker Ellipse Elipsă marcatoare Marker Pen Stilou marcator Text Text Arrow Săgeată Double Arrow Săgeată dublă Line Linie Blur Estompare Rectangle Dreptunghi Ellipse Elipsă Number Pointer Indicator numeric Sticker Autocolant Pixelate Pixelează Text Pointer Indicator textual Text Arrow Săgeată textuală Number Arrow Săgeată numerică Duplicate Duplică kImageAnnotator::ZoomPicker Zoom In (%1) Apropie (%1) Zoom Out (%1) Îndepărtează (%1) Reset Zoom (%1) Reinițializează apropierea (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_ru.ts000066400000000000000000000400241440330760000234600ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Упорядочить Bring to Front На верхний слой Bring Forward На слой выше Send Backward На слой ниже Send to Back На нижний слой Select This Выбрать этот Copy Копировать Paste Вставить Edit Изменить Delete Удалить kImageAnnotator::AnnotationControlsWidget Controls Элементы управления kImageAnnotator::AnnotationGeneralSettings General Settings Общие настройки kImageAnnotator::AnnotationImageSettings Image Settings Настройки изображения kImageAnnotator::AnnotationItemSettings Color Цвет Text Color Цвет текста Width Ширина Number Seed Нумератор Obfuscation Factor Уровень обфускации Item Shadow Тень элемента Item Settings Настройки элемента Scale Масштаб Opacity Прозрачность kImageAnnotator::AnnotationTabContextMenu Close Закрыть Close Other Закрыть остальные Close All Закрыть все Close All to the Left Закрыть все слева Close All to the Right Закрыть все справа kImageAnnotator::AnnotationToolSelection Tool Selection Выбор инструмента kImageAnnotator::BoolPicker Enabled Включено Disabled Отключено kImageAnnotator::Controls Undo Отменить Redo Повторить Crop Обрезать Scale Масштабировать Rotate Повернуть Modify canvas Изменить холст Cut Вырезать kImageAnnotator::CropWidget Cancel Отмена X: X: Y: Y: W: Ш: H: В: Apply Применить kImageAnnotator::CutWidget Vertical Вертикально Horizontal Горизонально Apply Применить Cancel Отменить kImageAnnotator::FillModePicker Border And Fill Visibility Видимость обводки и заливки Border and Fill Обводка и заливка Border and No Fill Обводка без заливки No Border and No Fill Без обводки и заливки kImageAnnotator::FontPicker Font Size Размер шрифта Bold Жирный Italic Курсив Underline Подчёркнутый kImageAnnotator::ImageEffectPicker Image Effects Графические эффекты No Effect Без эффекта Drop Shadow Отбросить тень Grayscale Оттенки серого Border Рамка Invert Color Инвертировать цвет kImageAnnotator::ModifyCanvasWidget Restricted Ограничено When enabled enforces the canvas to include the background image. Включить принудительный захват фонового изображения. X: X: Y: Y: W: Ширина: H: Высота: Apply Применить Cancel Отменить Color: Цвет: Canvas Background Color Цвет фона kImageAnnotator::RotateDialog Rotate Image Повернуть изображение 180° 180° 90° Clockwise 90° по часовой стрелке 90° Counter Clockwise 90° против часовой стрелки Arbitrary Задать угол Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Положительные значения — по часовой стрелке, отрицательные — против. Поворот на некратный 90° угол может привести к потере качества. Horizontal Горизонально Vertical Вертикально OK Применить Cancel Отменить Rotate Повернуть Flip Отразить kImageAnnotator::ScaleDialog Scale Image Масштабировать изображение Keep Aspect Ratio Сохранять пропорции Width: Ширина: Height: Высота: OK Применить Cancel Отмена Pixel Пиксели Percent Проценты kImageAnnotator::StickerPicker Sticker Стикер kImageAnnotator::ToolPicker Select Выбор Pen Карандаш Number Число Marker Rectangle Маркер прямоугольный Marker Ellipse Маркер эллипсом Marker Pen Маркер карандаш Text Текст Arrow Стрелка Double Arrow Двойная стрелка Line Линия Blur Размытие Rectangle Прямоугольник Ellipse Эллипс Number Pointer Числовой указатель Sticker Стикер Pixelate Пикселизовать Text Pointer Текстовый указатель Text Arrow Стрелка с текстом Number Arrow Стрелка с цифрой Duplicate Дублировать kImageAnnotator::ZoomPicker Zoom In (%1) Увеличить (%1) Zoom Out (%1) Уменьшить (%1) Reset Zoom (%1) Исходный масштаб (%1) Reset Zoom Исходный масштаб Fit Image Изображение целиком Fit image to view (%1) Изображение целиком (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_si.ts000066400000000000000000000365201440330760000234530ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Bring to Front Bring Forward Send Backward Send to Back Select This Copy පිටපත් Paste අලවන්න Edit සංස්කරණය Delete kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings kImageAnnotator::AnnotationImageSettings Image Settings kImageAnnotator::AnnotationItemSettings Color වර්ණය Text Color Width පළල Number Seed Obfuscation Factor Item Shadow Item Settings Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close වසන්න Close Other අනෙක්වා වසන්න Close All සියල්ල වසන්න Close All to the Left Close All to the Right kImageAnnotator::AnnotationToolSelection Tool Selection මෙවලම් තේරීම kImageAnnotator::BoolPicker Enabled සබල කර ඇත Disabled අබල කර ඇත kImageAnnotator::Controls Undo Redo Crop Scale Rotate Modify canvas Cut kImageAnnotator::CropWidget Cancel අවලංගු X: Y: W: H: Apply යොදන්න kImageAnnotator::CutWidget Vertical Horizontal Apply යොදන්න Cancel අවලංගු kImageAnnotator::FillModePicker Border And Fill Visibility Border and Fill Border and No Fill No Border and No Fill kImageAnnotator::FontPicker Font Size Bold Italic Underline kImageAnnotator::ImageEffectPicker Image Effects No Effect Drop Shadow Grayscale Border Invert Color kImageAnnotator::ModifyCanvasWidget Restricted When enabled enforces the canvas to include the background image. X: Y: W: H: Apply යොදන්න Cancel අවලංගු Color: වර්ණය: Canvas Background Color kImageAnnotator::RotateDialog Rotate Image 180° 180° 90° Clockwise 90° Counter Clockwise Arbitrary Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Horizontal Vertical OK හරි Cancel අවලංගු Rotate Flip kImageAnnotator::ScaleDialog Scale Image Keep Aspect Ratio Width: පළල: Height: උස: OK හරි Cancel අවලංගු Pixel Percent kImageAnnotator::StickerPicker Sticker kImageAnnotator::ToolPicker Select තෝරන්න Pen Number අංකය Marker Rectangle Marker Ellipse Marker Pen Text Arrow ඊතලය Double Arrow ද්විත්ව ඊතලය Line Blur Rectangle Ellipse Number Pointer Sticker Pixelate Text Pointer Text Arrow Number Arrow අංක ඊතලය Duplicate අනුපිටපත kImageAnnotator::ZoomPicker Zoom In (%1) විශාලනය (% 1) Zoom Out (%1) කුඩාලනය (% 1) Reset Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_sq.ts000066400000000000000000000354271440330760000234700ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Sistemoji Bring to Front Sille Në Ballë Bring Forward Sille Përpara Send Backward Dërgoje Më Pas Send to Back Dërgoje Pas Select This Përzgjidhe Këtë Copy Kopjoje Paste Ngjite Edit Përpunojeni Delete Fshije kImageAnnotator::AnnotationControlsWidget Controls Kontrolle kImageAnnotator::AnnotationGeneralSettings General Settings Rregullime të Përgjithshme kImageAnnotator::AnnotationImageSettings Image Settings Rregullime Figurash kImageAnnotator::AnnotationItemSettings Color Ngjyrë Text Color Ngjyrë Teksti Width Gjerësi Number Seed Number Seed Obfuscation Factor Obfuscation Factor Item Shadow Item Shadow Item Settings Rregullime Objekti Scale Opacity Patejdukshmëri kImageAnnotator::AnnotationTabContextMenu Close Mbylle Close Other Mbyll Tjetrin Close All Mbylli Krejt Close All to the Left Mbylli Krejt ata Majtas Close All to the Right Mbylli Krejt ata Djathtas kImageAnnotator::AnnotationToolSelection Tool Selection Përzgjedhje Mjeti kImageAnnotator::BoolPicker Enabled E aktivizuar Disabled E çaktivizuar kImageAnnotator::Controls Undo Zhbëje Redo Ribëje Crop Qethe Scale Ripërmasojeni Rotate Rrotulloje Modify canvas Ndryshoni kanavacën Cut Prije kImageAnnotator::CropWidget Cancel Anuloje X: X: Y: Y: W: Gj: H: L: Apply Aplikoje kImageAnnotator::CutWidget Vertical Vertika Horizontal Horizontal Apply Aplikoje Cancel Anuloje kImageAnnotator::FillModePicker Border And Fill Visibility Dukshmëri Anësh dhe Mbushjeje Border and Fill Anë dhe Mbushje Border and No Fill Anë dhe Pa Mbushje No Border and No Fill Pa Anë dhe Pa Mbushje kImageAnnotator::FontPicker Font Size Madhësi Shkronjash Bold Të trasha Italic Të pjerrëta Underline Të nënvijëzuara kImageAnnotator::ImageEffectPicker Image Effects Efekte Figurash No Effect Pa Efekte Drop Shadow Drop Shadow Grayscale Shkallë të grisë Border Anë Invert Color Përmbyse Ngjyrën kImageAnnotator::ModifyCanvasWidget Restricted E kufizuar When enabled enforces the canvas to include the background image. Kur aktivizohet, e bën kanavacën të përfshijë figurën sfond. X: X: Y: Y: W: Gj: H: L: Apply Aplikoje Cancel Anuloje Color: Ngjyrë: Canvas Background Color Ngjyrë Sfondi Kanavace kImageAnnotator::RotateDialog Rotate Image Rrotulloje Figurën 180° 180° 90° Clockwise 90° Në kah orar 90° Counter Clockwise 90° Në kah antiorar Arbitrary Arbitrar Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Vlerat pozitive prodhojnë rrotullim në kah orar, vlerat negative në kah antiorar. Rrotullimi me shumëfisha jo të 90° mund të sjellë humbje të cilësisë. Horizontal Horizontal Vertical Vertikal OK OK Cancel Anuloje Rotate Rrotulloje Flip Ktheje më anë tjetër kImageAnnotator::ScaleDialog Scale Image Përshkallëzoje Figurën Keep Aspect Ratio Ruaji Përpjesëtimet Width: Gjerësi: Height: Lartësi: OK OK Cancel Anuloje Pixel Piksel Percent Përqindje kImageAnnotator::StickerPicker Sticker Ngjitës kImageAnnotator::ToolPicker Select Përzgjidhe Pen Penë Number Numër Marker Rectangle Drejtkëndësh Shenjë Marker Ellipse Elips Shenjë Marker Pen Penë Shenjë Text Tekst Arrow Shigjetë Double Arrow Shigjetë Dyshe Line Vijë Blur Turbullim Rectangle Drejtkëndësh Ellipse Elips Number Pointer Tregues Numri Sticker Ngjitës Pixelate Pikselizoje Text Pointer Tregues Teksti Text Arrow Shigjetë Teksti Number Arrow Shigjetë Numrash Duplicate Përsëdytje kImageAnnotator::ZoomPicker Zoom In (%1) Zmadhoje (%1) Zoom Out (%1) Zvogëloje (%1) Reset Zoom (%1) Rikthe Zoom-in te parazgjedhja (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_sv.ts000066400000000000000000000350501440330760000234650ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Ordna Bring to Front Flytta längst fram Bring Forward Flytta framåt Send Backward Flytta bakåt Send to Back Flytta längst bak Select This Markera detta Copy Kopiera Paste Klistra in Edit Redigera Delete Ta bort kImageAnnotator::AnnotationControlsWidget Controls Kontroller kImageAnnotator::AnnotationGeneralSettings General Settings Allmänna Inställningar kImageAnnotator::AnnotationImageSettings Image Settings Bildinställningar kImageAnnotator::AnnotationItemSettings Color Färg Text Color Textfärg Width Bredd Number Seed Räkneverk Obfuscation Factor Fördunklingsfaktor Item Shadow Objektskugga Item Settings Objektinställningar Scale Skala Opacity Opacitet kImageAnnotator::AnnotationTabContextMenu Close Stäng Close Other Stäng andra Close All Stäng alla Close All to the Left Stäng alla till vänster Close All to the Right Stäng alla till höger kImageAnnotator::AnnotationToolSelection Tool Selection Verktygsval kImageAnnotator::BoolPicker Enabled Aktiverat Disabled Inaktiverat kImageAnnotator::Controls Undo Ångra Redo Upprepa Crop Beskär Scale Skala Rotate Rotera Modify canvas Ändra arbetsytan Cut Klipp ut kImageAnnotator::CropWidget Cancel Avbryt X: X: Y: Y: W: B: H: H: Apply Tillämpa kImageAnnotator::CutWidget Vertical Vertikalt Horizontal Horisontell Apply Tillämpa Cancel Avbryt kImageAnnotator::FillModePicker Border And Fill Visibility Kant- och fyllnadssynlighet Border and Fill Kantlinje och fyllning Border and No Fill Kantlinje och ingen fyllning No Border and No Fill Ingen kantlinje och ingen fyllning kImageAnnotator::FontPicker Font Size Teckenstorlek Bold Fet Italic Kursiv Underline Understruken kImageAnnotator::ImageEffectPicker Image Effects Bildeffekter No Effect Ingen effekt Drop Shadow Skugga Grayscale Gråskala Border Kantlinje Invert Color Invertera färg kImageAnnotator::ModifyCanvasWidget Restricted Begränsad When enabled enforces the canvas to include the background image. Vid aktivering tvingas arbetsytan att inkludera bakgrundsbilden. X: X: Y: Y: W: B: H: H: Apply Tillämpa Cancel Avbryt Color: Färg: Canvas Background Color Arbetsytans bakgrundsfärg kImageAnnotator::RotateDialog Rotate Image Rotera bilden 180° 180° 90° Clockwise 90° medurs 90° Counter Clockwise 90° moturs Arbitrary Slumpmässig Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Positiva värden roterar medurs, negativa värden moturs. Rotation med annat än 90°-multiplikator kan leda till kvalitetsförlust. Horizontal Horisontellt Vertical Vertikalt OK OK Cancel Avbryt Rotate Rotera Flip Vänd kImageAnnotator::ScaleDialog Scale Image Skala bild Keep Aspect Ratio Bevara proportioner Width: Bredd: Height: Höjd: OK OK Cancel Avbryt Pixel Pixel Percent Procent kImageAnnotator::StickerPicker Sticker Dekal kImageAnnotator::ToolPicker Select Markera Pen Penna Number Siffra Marker Rectangle Rektangelmarkering Marker Ellipse Ellipsmarkering Marker Pen Överstrykningspenna Text Text Arrow Pil Double Arrow Dubbelpil Line Linje Blur Oskärpa Rectangle Rektangel Ellipse Ellips Number Pointer Nummerpekare Sticker Dekal Pixelate Pixelera Text Pointer Textpekare Text Arrow Textpil Number Arrow Sifferpil Duplicate Duplicera kImageAnnotator::ZoomPicker Zoom In (%1) Zooma in (%1) Zoom Out (%1) Zooma ut (%1) Reset Zoom (%1) Återställ zoom (%1) Reset Zoom Återställ zoom Fit Image Anpassa bild Fit image to view (%1) Anpassa bild till vyn (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_tr.ts000066400000000000000000000363741440330760000234740ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Bring to Front Öne Çıkar Bring Forward Send Backward Send to Back Select This Copy Kopyala Paste Yapıştır Edit Düzenle Delete Sil kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings kImageAnnotator::AnnotationImageSettings Image Settings kImageAnnotator::AnnotationItemSettings Color Renk Text Color Yazı Rengi Width En Number Seed Obfuscation Factor Item Shadow Item Settings Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close Kapat Close Other Close All Hepsini Kapat Close All to the Left Close All to the Right kImageAnnotator::AnnotationToolSelection Tool Selection kImageAnnotator::BoolPicker Enabled Disabled kImageAnnotator::Controls Undo Redo Crop Scale Rotate Modify canvas Cut kImageAnnotator::CropWidget Cancel İptal X: Y: W: H: Apply kImageAnnotator::CutWidget Vertical Horizontal Apply Cancel İptal kImageAnnotator::FillModePicker Border And Fill Visibility Border and Fill Border and No Fill No Border and No Fill kImageAnnotator::FontPicker Font Size Font Büyüklüğü Bold Italic Underline kImageAnnotator::ImageEffectPicker Image Effects No Effect Drop Shadow Grayscale Border Invert Color kImageAnnotator::ModifyCanvasWidget Restricted When enabled enforces the canvas to include the background image. X: Y: W: H: Apply Cancel İptal Color: Canvas Background Color kImageAnnotator::RotateDialog Rotate Image 180° 90° Clockwise 90° Counter Clockwise Arbitrary Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Horizontal Vertical OK Cancel İptal Rotate Flip kImageAnnotator::ScaleDialog Scale Image Keep Aspect Ratio Width: Height: OK Cancel İptal Pixel Percent kImageAnnotator::StickerPicker Sticker kImageAnnotator::ToolPicker Select Pen Number Marker Rectangle Marker Ellipse Marker Pen Text Arrow Double Arrow Line Blur Rectangle Ellipse Number Pointer Sticker Pixelate Text Pointer Text Arrow Number Arrow Duplicate kImageAnnotator::ZoomPicker Zoom In (%1) Zoom Out (%1) Reset Zoom (%1) Reset Zoom Fit Image Fit image to view (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_uk.ts000066400000000000000000000403521440330760000234550ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange Компонування Bring to Front Пересунути на передній план Bring Forward Пересунути вище Send Backward Пересунути нижче Send to Back Перемістити на задній план Select This Вибрати це Copy Копіювати Paste Вставити Edit Змінити Delete Вилучити kImageAnnotator::AnnotationControlsWidget Controls Керування kImageAnnotator::AnnotationGeneralSettings General Settings Загальні параметри kImageAnnotator::AnnotationImageSettings Image Settings Параметри зображень kImageAnnotator::AnnotationItemSettings Color Колір Text Color Колір тексту Width Ширина Number Seed Базове значення Obfuscation Factor Коефіцієнт заплутування Item Shadow Тінь пункту Item Settings Параметри пункту Scale Масштаб Opacity Непрозорість kImageAnnotator::AnnotationTabContextMenu Close Закрити Close Other Закрити інші Close All Закрити всі Close All to the Left Закрити усі ліворуч Close All to the Right Закрити усі праворуч kImageAnnotator::AnnotationToolSelection Tool Selection Вибір інструмента kImageAnnotator::BoolPicker Enabled Увімкнено Disabled Вимкнено kImageAnnotator::Controls Undo Скасувати Redo Повторити Crop Обрізати Scale Масштабувати Rotate Обертати Modify canvas Змінити полотно Cut Вирізати kImageAnnotator::CropWidget Cancel Скасувати X: X: Y: Y: W: Ш: H: В: Apply Застосувати kImageAnnotator::CutWidget Vertical Вертикально Horizontal Горизонтально Apply Застосувати Cancel Скасувати kImageAnnotator::FillModePicker Border And Fill Visibility Видимість рамки і заповнення Border and Fill Рамка і заповнення Border and No Fill Рамка без заповнення No Border and No Fill Без рамки і заповнення kImageAnnotator::FontPicker Font Size Розмір шрифту Bold Жирний Italic Курсив Underline Підкреслення kImageAnnotator::ImageEffectPicker Image Effects Ефекти зображення No Effect Без ефектів Drop Shadow Відкидання тіні Grayscale Відтінки сірого Border Рамка Invert Color Інвертувати кольори kImageAnnotator::ModifyCanvasWidget Restricted Обмеження When enabled enforces the canvas to include the background image. Якщо увімкнено, примусово включати до полотна фонове зображення. X: X: Y: Y: W: Ш: H: В: Apply Застосувати Cancel Скасувати Color: Колір: Canvas Background Color Колір тла полотна kImageAnnotator::RotateDialog Rotate Image Обертати зображення 180° 180° 90° Clockwise 90° за годинниковою стрілкою 90° Counter Clockwise 90° проти годинникової стрілки Arbitrary Довільне Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. Додатні значення призводять до обертання за годинниковою стрілкою, від'ємні — проти годинникової стрілки. Обертання на кути, кратні до 90°, може призвести до втрати якості. Horizontal Горизонтально Vertical Вертикально OK Гаразд Cancel Скасувати Rotate Обертати Flip Перевернути kImageAnnotator::ScaleDialog Scale Image Масштабувати зображення Keep Aspect Ratio Зберігати пропорції Width: Ширина: Height: Висота: OK Гаразд Cancel Скасувати Pixel Піксель Percent Частка kImageAnnotator::StickerPicker Sticker Наліпка kImageAnnotator::ToolPicker Select Вибрати Pen Перо Number Номер Marker Rectangle Прямокутна позначка Marker Ellipse Еліптична позначка Marker Pen Позначка пером Text Текст Arrow Стрілка Double Arrow Подвійна стрілка Line Пряма Blur Розмивання Rectangle Прямокутник Ellipse Еліпс Number Pointer Нумерований вказівник Sticker Наліпка Pixelate Пікселізація Text Pointer Вказівник з текстом Text Arrow Стрілка з текстом Number Arrow Стрілка з номером Duplicate Дублювання kImageAnnotator::ZoomPicker Zoom In (%1) Збільшити (%1) Zoom Out (%1) Зменшити (%1) Reset Zoom (%1) Відновити масштаб (%1) Reset Zoom Відновити масштаб Fit Image За зображенням Fit image to view (%1) Розмір зображення за областю перегляду (%1) kImageAnnotator-0.6.1/translations/kImageAnnotator_zh_CN.ts000066400000000000000000000350251440330760000240400ustar00rootroot00000000000000 kImageAnnotator::AnnotationContextMenu Arrange 排序 Bring to Front 置于顶层 Bring Forward 上移一层 Send Backward 下移一层 Send to Back 置于底层 Select This 选中当前 Copy 复制 Paste 粘贴 Edit 编辑 Delete 删除 kImageAnnotator::AnnotationControlsWidget Controls kImageAnnotator::AnnotationGeneralSettings General Settings 通用设置 kImageAnnotator::AnnotationImageSettings Image Settings 图像设置 kImageAnnotator::AnnotationItemSettings Color 颜色 Text Color 文本颜色 Width 宽度 Number Seed 当前数字 Obfuscation Factor 模糊系数 Item Shadow 元素的阴影 Item Settings 元素设置 Scale Opacity kImageAnnotator::AnnotationTabContextMenu Close 关闭 Close Other 关闭其它 Close All 关闭全部 Close All to the Left 关闭左侧 Close All to the Right 关闭右侧 kImageAnnotator::AnnotationToolSelection Tool Selection 工具选择 kImageAnnotator::BoolPicker Enabled 开启 Disabled 关闭 kImageAnnotator::Controls Undo Redo Crop Scale Rotate 旋转 Modify canvas Cut kImageAnnotator::CropWidget Cancel 取消 X: X: Y: Y: W: 宽度： H: 高度： Apply 应用 kImageAnnotator::CutWidget Vertical 垂直 Horizontal 水平 Apply 应用 Cancel 取消 kImageAnnotator::FillModePicker Border And Fill Visibility 边框和填充可见性 Border and Fill 有边框且有填充 Border and No Fill 有边框且无填充 No Border and No Fill 无边框且无填充 kImageAnnotator::FontPicker Font Size 字体大小 Bold 粗体 Italic 斜体 Underline 下划线 kImageAnnotator::ImageEffectPicker Image Effects 滤镜 No Effect 无滤镜 Drop Shadow 阴影 Grayscale 灰度 Border 描边 Invert Color 反转色 kImageAnnotator::ModifyCanvasWidget Restricted 受限 When enabled enforces the canvas to include the background image. 启用后强制画布 包括背景图像。 X: X: Y: Y: W: 宽度： H: 高度： Apply 应用 Cancel 取消 Color: 颜色： Canvas Background Color 画布背景色 kImageAnnotator::RotateDialog Rotate Image 旋转图片 180° 180° 90° Clockwise 顺时针旋转90° 90° Counter Clockwise 逆时针旋转90° Arbitrary 任意 Positive values rotate clockwise, negative values counter clockwise. Rotating by non 90° multipliers might introduce loss of quality. 正值顺时针旋转，负值逆时针旋转。 用不是90°的整数倍的旋转角度旋转可能会导致图片质量的损失。 Horizontal 水平 Vertical 垂直 OK 确定 Cancel 取消 Rotate 旋转 Flip 反转 kImageAnnotator::ScaleDialog Scale Image 缩放图像 Keep Aspect Ratio 保持长宽比 Width: 宽度： Height: 高度： OK 确定 Cancel 取消 Pixel 像素 Percent 百分比 kImageAnnotator::StickerPicker Sticker 贴纸 kImageAnnotator::ToolPicker Select 选择 Pen 笔 Number 数字 Marker Rectangle 高亮矩形区域 Marker Ellipse 高亮椭圆区域 Marker Pen 高亮笔 Text 文本 Arrow 箭头 Double Arrow 双箭头 Line 线段 Blur 模糊 Rectangle 矩形 Ellipse 椭圆 Number Pointer 数字标注 Sticker 贴纸 Pixelate 像素化 Text Pointer 文字标注 Text Arrow 文字箭头标注 Number Arrow 数字箭头标注 Duplicate 复制 kImageAnnotator::ZoomPicker Zoom In (%1) 放大（%1） Zoom Out (%1) 缩小（%1） Reset Zoom (%1) 重置大小（%1） Reset Zoom Fit Image Fit image to view (%1)